Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rdma/rdma
Pull rdma fixes from Doug Ledford:
"This is probably our last -rc pull request. We don't have anything
else outstanding at the moment anyway, and with the summer months on
us and people taking trips, I expect the next weeks leading up to the
merge window to be pretty calm and sedate.
This has two simple, no brainer fixes for the EFA driver.
Then it has ten not quite so simple fixes for the hfi1 driver. The
problem with them is that they aren't simply one liner typo fixes.
They're still fixes, but they're more complex issues like livelock
under heavy load where the answer was to change work queue usage and
spinlock usage to resolve the problem, or issues with orphaned
requests during certain types of failures like link down which
required some more complex work to fix too. They all look like
legitimate fixes to me, they just aren't small like I wish they were.
Summary:
- 2 minor EFA fixes
- 10 hfi1 fixes related to scaling issues"
* tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rdma/rdma:
RDMA/efa: Handle mmap insertions overflow
RDMA/efa: Fix success return value in case of error
IB/hfi1: Handle port down properly in pio
IB/hfi1: Handle wakeup of orphaned QPs for pio
IB/hfi1: Wakeup QPs orphaned on wait list after flush
IB/hfi1: Use aborts to trigger RC throttling
IB/hfi1: Create inline to get extended headers
IB/hfi1: Silence txreq allocation warnings
IB/hfi1: Avoid hardlockup with flushlist_lock
IB/hfi1: Correct tid qp rcd to match verbs context
IB/hfi1: Close PSM sdma_progress sleep window
IB/hfi1: Validate fault injection opcode user input
+174
-62
+18
-6
drivers/infiniband/hw/efa/efa_com_cmd.c
+18
-6
drivers/infiniband/hw/efa/efa_com_cmd.c
···
139
139
sizeof(qp_cmd),
140
140
(struct efa_admin_acq_entry *)&cmd_completion,
141
141
sizeof(cmd_completion));
142
-
if (err)
142
+
if (err) {
143
143
ibdev_err(edev->efa_dev, "Failed to destroy qp-%u [%d]\n",
144
144
qp_cmd.qp_handle, err);
145
+
return err;
146
+
}
145
147
146
148
return 0;
147
149
}
···
201
199
(struct efa_admin_acq_entry *)&destroy_resp,
202
200
sizeof(destroy_resp));
203
201
204
-
if (err)
202
+
if (err) {
205
203
ibdev_err(edev->efa_dev, "Failed to destroy CQ-%u [%d]\n",
206
204
params->cq_idx, err);
205
+
return err;
206
+
}
207
207
208
208
return 0;
209
209
}
···
277
273
sizeof(mr_cmd),
278
274
(struct efa_admin_acq_entry *)&cmd_completion,
279
275
sizeof(cmd_completion));
280
-
if (err)
276
+
if (err) {
281
277
ibdev_err(edev->efa_dev,
282
278
"Failed to de-register mr(lkey-%u) [%d]\n",
283
279
mr_cmd.l_key, err);
280
+
return err;
281
+
}
284
282
285
283
return 0;
286
284
}
···
333
327
sizeof(ah_cmd),
334
328
(struct efa_admin_acq_entry *)&cmd_completion,
335
329
sizeof(cmd_completion));
336
-
if (err)
330
+
if (err) {
337
331
ibdev_err(edev->efa_dev, "Failed to destroy ah-%d pd-%d [%d]\n",
338
332
ah_cmd.ah, ah_cmd.pd, err);
333
+
return err;
334
+
}
339
335
340
336
return 0;
341
337
}
···
395
387
get_resp,
396
388
sizeof(*get_resp));
397
389
398
-
if (err)
390
+
if (err) {
399
391
ibdev_err(edev->efa_dev,
400
392
"Failed to submit get_feature command %d [%d]\n",
401
393
feature_id, err);
394
+
return err;
395
+
}
402
396
403
397
return 0;
404
398
}
···
544
534
(struct efa_admin_acq_entry *)set_resp,
545
535
sizeof(*set_resp));
546
536
547
-
if (err)
537
+
if (err) {
548
538
ibdev_err(edev->efa_dev,
549
539
"Failed to submit set_feature command %d error: %d\n",
550
540
feature_id, err);
541
+
return err;
542
+
}
551
543
552
544
return 0;
553
545
}
+16
-5
drivers/infiniband/hw/efa/efa_verbs.c
+16
-5
drivers/infiniband/hw/efa/efa_verbs.c
···
204
204
void *obj, u64 address, u64 length, u8 mmap_flag)
205
205
{
206
206
struct efa_mmap_entry *entry;
207
+
u32 next_mmap_page;
207
208
int err;
208
209
209
210
entry = kmalloc(sizeof(*entry), GFP_KERNEL);
···
217
216
entry->mmap_flag = mmap_flag;
218
217
219
218
xa_lock(&ucontext->mmap_xa);
219
+
if (check_add_overflow(ucontext->mmap_xa_page,
220
+
(u32)(length >> PAGE_SHIFT),
221
+
&next_mmap_page))
222
+
goto err_unlock;
223
+
220
224
entry->mmap_page = ucontext->mmap_xa_page;
221
-
ucontext->mmap_xa_page += DIV_ROUND_UP(length, PAGE_SIZE);
225
+
ucontext->mmap_xa_page = next_mmap_page;
222
226
err = __xa_insert(&ucontext->mmap_xa, entry->mmap_page, entry,
223
227
GFP_KERNEL);
228
+
if (err)
229
+
goto err_unlock;
230
+
224
231
xa_unlock(&ucontext->mmap_xa);
225
-
if (err){
226
-
kfree(entry);
227
-
return EFA_MMAP_INVALID;
228
-
}
229
232
230
233
ibdev_dbg(
231
234
&dev->ibdev,
···
237
232
entry->obj, entry->address, entry->length, get_mmap_key(entry));
238
233
239
234
return get_mmap_key(entry);
235
+
236
+
err_unlock:
237
+
xa_unlock(&ucontext->mmap_xa);
238
+
kfree(entry);
239
+
return EFA_MMAP_INVALID;
240
+
240
241
}
241
242
242
243
int efa_query_device(struct ib_device *ibdev,
+13
drivers/infiniband/hw/hfi1/chip.c
+13
drivers/infiniband/hw/hfi1/chip.c
···
14032
14032
}
14033
14033
14034
14034
/**
14035
+
* hfi1_get_qp_map
14036
+
* @dd: device data
14037
+
* @idx: index to read
14038
+
*/
14039
+
u8 hfi1_get_qp_map(struct hfi1_devdata *dd, u8 idx)
14040
+
{
14041
+
u64 reg = read_csr(dd, RCV_QP_MAP_TABLE + (idx / 8) * 8);
14042
+
14043
+
reg >>= (idx % 8) * 8;
14044
+
return reg;
14045
+
}
14046
+
14047
+
/**
14035
14048
* init_qpmap_table
14036
14049
* @dd - device data
14037
14050
* @first_ctxt - first context
+1
drivers/infiniband/hw/hfi1/chip.h
+1
drivers/infiniband/hw/hfi1/chip.h
···
1445
1445
void remap_intr(struct hfi1_devdata *dd, int isrc, int msix_intr);
1446
1446
void remap_sdma_interrupts(struct hfi1_devdata *dd, int engine, int msix_intr);
1447
1447
void reset_interrupts(struct hfi1_devdata *dd);
1448
+
u8 hfi1_get_qp_map(struct hfi1_devdata *dd, u8 idx);
1448
1449
1449
1450
/*
1450
1451
* Interrupt source table.
+5
drivers/infiniband/hw/hfi1/fault.c
+5
drivers/infiniband/hw/hfi1/fault.c
···
153
153
char *dash;
154
154
unsigned long range_start, range_end, i;
155
155
bool remove = false;
156
+
unsigned long bound = 1U << BITS_PER_BYTE;
156
157
157
158
end = strchr(ptr, ',');
158
159
if (end)
···
179
178
BITS_PER_BYTE);
180
179
break;
181
180
}
181
+
/* Check the inputs */
182
+
if (range_start >= bound || range_end >= bound)
183
+
break;
184
+
182
185
for (i = range_start; i <= range_end; i++) {
183
186
if (remove)
184
187
clear_bit(i, fault->opcodes);
+31
drivers/infiniband/hw/hfi1/hfi.h
+31
drivers/infiniband/hw/hfi1/hfi.h
···
539
539
mgmt->src_qpn = cpu_to_be32(src_qp & OPA_16B_MGMT_QPN_MASK);
540
540
}
541
541
542
+
/**
543
+
* hfi1_get_rc_ohdr - get extended header
544
+
* @opah - the opaheader
545
+
*/
546
+
static inline struct ib_other_headers *
547
+
hfi1_get_rc_ohdr(struct hfi1_opa_header *opah)
548
+
{
549
+
struct ib_other_headers *ohdr;
550
+
struct ib_header *hdr = NULL;
551
+
struct hfi1_16b_header *hdr_16b = NULL;
552
+
553
+
/* Find out where the BTH is */
554
+
if (opah->hdr_type == HFI1_PKT_TYPE_9B) {
555
+
hdr = &opah->ibh;
556
+
if (ib_get_lnh(hdr) == HFI1_LRH_BTH)
557
+
ohdr = &hdr->u.oth;
558
+
else
559
+
ohdr = &hdr->u.l.oth;
560
+
} else {
561
+
u8 l4;
562
+
563
+
hdr_16b = &opah->opah;
564
+
l4 = hfi1_16B_get_l4(hdr_16b);
565
+
if (l4 == OPA_16B_L4_IB_LOCAL)
566
+
ohdr = &hdr_16b->u.oth;
567
+
else
568
+
ohdr = &hdr_16b->u.l.oth;
569
+
}
570
+
return ohdr;
571
+
}
572
+
542
573
struct rvt_sge_state;
543
574
544
575
/*
+19
-2
drivers/infiniband/hw/hfi1/pio.c
+19
-2
drivers/infiniband/hw/hfi1/pio.c
···
952
952
}
953
953
}
954
954
spin_unlock(&sc->release_lock);
955
+
956
+
write_seqlock(&sc->waitlock);
957
+
while (!list_empty(&sc->piowait)) {
958
+
struct iowait *wait;
959
+
struct rvt_qp *qp;
960
+
struct hfi1_qp_priv *priv;
961
+
962
+
wait = list_first_entry(&sc->piowait, struct iowait, list);
963
+
qp = iowait_to_qp(wait);
964
+
priv = qp->priv;
965
+
list_del_init(&priv->s_iowait.list);
966
+
priv->s_iowait.lock = NULL;
967
+
hfi1_qp_wakeup(qp, RVT_S_WAIT_PIO | HFI1_S_WAIT_PIO_DRAIN);
968
+
}
969
+
write_sequnlock(&sc->waitlock);
970
+
955
971
spin_unlock_irq(&sc->alloc_lock);
956
972
}
957
973
···
1443
1427
* @cb: optional callback to call when the buffer is finished sending
1444
1428
* @arg: argument for cb
1445
1429
*
1446
-
* Return a pointer to a PIO buffer if successful, NULL if not enough room.
1430
+
* Return a pointer to a PIO buffer, NULL if not enough room, -ECOMM
1431
+
* when link is down.
1447
1432
*/
1448
1433
struct pio_buf *sc_buffer_alloc(struct send_context *sc, u32 dw_len,
1449
1434
pio_release_cb cb, void *arg)
···
1460
1443
spin_lock_irqsave(&sc->alloc_lock, flags);
1461
1444
if (!(sc->flags & SCF_ENABLED)) {
1462
1445
spin_unlock_irqrestore(&sc->alloc_lock, flags);
1463
-
goto done;
1446
+
return ERR_PTR(-ECOMM);
1464
1447
}
1465
1448
1466
1449
retry:
+32
-21
drivers/infiniband/hw/hfi1/rc.c
+32
-21
drivers/infiniband/hw/hfi1/rc.c
···
1432
1432
pbc = create_pbc(ppd, pbc_flags, qp->srate_mbps,
1433
1433
sc_to_vlt(ppd->dd, sc5), plen);
1434
1434
pbuf = sc_buffer_alloc(rcd->sc, plen, NULL, NULL);
1435
-
if (!pbuf) {
1435
+
if (IS_ERR_OR_NULL(pbuf)) {
1436
1436
/*
1437
1437
* We have no room to send at the moment. Pass
1438
1438
* responsibility for sending the ACK to the send engine
···
1701
1701
}
1702
1702
}
1703
1703
1704
+
/**
1705
+
* hfi1_rc_verbs_aborted - handle abort status
1706
+
* @qp: the QP
1707
+
* @opah: the opa header
1708
+
*
1709
+
* This code modifies both ACK bit in BTH[2]
1710
+
* and the s_flags to go into send one mode.
1711
+
*
1712
+
* This serves to throttle the send engine to only
1713
+
* send a single packet in the likely case the
1714
+
* a link has gone down.
1715
+
*/
1716
+
void hfi1_rc_verbs_aborted(struct rvt_qp *qp, struct hfi1_opa_header *opah)
1717
+
{
1718
+
struct ib_other_headers *ohdr = hfi1_get_rc_ohdr(opah);
1719
+
u8 opcode = ib_bth_get_opcode(ohdr);
1720
+
u32 psn;
1721
+
1722
+
/* ignore responses */
1723
+
if ((opcode >= OP(RDMA_READ_RESPONSE_FIRST) &&
1724
+
opcode <= OP(ATOMIC_ACKNOWLEDGE)) ||
1725
+
opcode == TID_OP(READ_RESP) ||
1726
+
opcode == TID_OP(WRITE_RESP))
1727
+
return;
1728
+
1729
+
psn = ib_bth_get_psn(ohdr) | IB_BTH_REQ_ACK;
1730
+
ohdr->bth[2] = cpu_to_be32(psn);
1731
+
qp->s_flags |= RVT_S_SEND_ONE;
1732
+
}
1733
+
1704
1734
/*
1705
1735
* This should be called with the QP s_lock held and interrupts disabled.
1706
1736
*/
···
1739
1709
struct ib_other_headers *ohdr;
1740
1710
struct hfi1_qp_priv *priv = qp->priv;
1741
1711
struct rvt_swqe *wqe;
1742
-
struct ib_header *hdr = NULL;
1743
-
struct hfi1_16b_header *hdr_16b = NULL;
1744
1712
u32 opcode, head, tail;
1745
1713
u32 psn;
1746
1714
struct tid_rdma_request *req;
···
1747
1719
if (!(ib_rvt_state_ops[qp->state] & RVT_SEND_OR_FLUSH_OR_RECV_OK))
1748
1720
return;
1749
1721
1750
-
/* Find out where the BTH is */
1751
-
if (priv->hdr_type == HFI1_PKT_TYPE_9B) {
1752
-
hdr = &opah->ibh;
1753
-
if (ib_get_lnh(hdr) == HFI1_LRH_BTH)
1754
-
ohdr = &hdr->u.oth;
1755
-
else
1756
-
ohdr = &hdr->u.l.oth;
1757
-
} else {
1758
-
u8 l4;
1759
-
1760
-
hdr_16b = &opah->opah;
1761
-
l4 = hfi1_16B_get_l4(hdr_16b);
1762
-
if (l4 == OPA_16B_L4_IB_LOCAL)
1763
-
ohdr = &hdr_16b->u.oth;
1764
-
else
1765
-
ohdr = &hdr_16b->u.l.oth;
1766
-
}
1767
-
1722
+
ohdr = hfi1_get_rc_ohdr(opah);
1768
1723
opcode = ib_bth_get_opcode(ohdr);
1769
1724
if ((opcode >= OP(RDMA_READ_RESPONSE_FIRST) &&
1770
1725
opcode <= OP(ATOMIC_ACKNOWLEDGE)) ||
+20
-6
drivers/infiniband/hw/hfi1/sdma.c
+20
-6
drivers/infiniband/hw/hfi1/sdma.c
···
405
405
struct sdma_txreq *txp, *txp_next;
406
406
LIST_HEAD(flushlist);
407
407
unsigned long flags;
408
+
uint seq;
408
409
409
410
/* flush from head to tail */
410
411
sdma_flush_descq(sde);
411
412
spin_lock_irqsave(&sde->flushlist_lock, flags);
412
413
/* copy flush list */
413
-
list_for_each_entry_safe(txp, txp_next, &sde->flushlist, list) {
414
-
list_del_init(&txp->list);
415
-
list_add_tail(&txp->list, &flushlist);
416
-
}
414
+
list_splice_init(&sde->flushlist, &flushlist);
417
415
spin_unlock_irqrestore(&sde->flushlist_lock, flags);
418
416
/* flush from flush list */
419
417
list_for_each_entry_safe(txp, txp_next, &flushlist, list)
420
418
complete_tx(sde, txp, SDMA_TXREQ_S_ABORTED);
419
+
/* wakeup QPs orphaned on the dmawait list */
420
+
do {
421
+
struct iowait *w, *nw;
422
+
423
+
seq = read_seqbegin(&sde->waitlock);
424
+
if (!list_empty(&sde->dmawait)) {
425
+
write_seqlock(&sde->waitlock);
426
+
list_for_each_entry_safe(w, nw, &sde->dmawait, list) {
427
+
if (w->wakeup) {
428
+
w->wakeup(w, SDMA_AVAIL_REASON);
429
+
list_del_init(&w->list);
430
+
}
431
+
}
432
+
write_sequnlock(&sde->waitlock);
433
+
}
434
+
} while (read_seqretry(&sde->waitlock, seq));
421
435
}
422
436
423
437
/*
···
2427
2413
list_add_tail(&tx->list, &sde->flushlist);
2428
2414
spin_unlock(&sde->flushlist_lock);
2429
2415
iowait_inc_wait_count(wait, tx->num_desc);
2430
-
schedule_work(&sde->flush_worker);
2416
+
queue_work_on(sde->cpu, system_highpri_wq, &sde->flush_worker);
2431
2417
ret = -ECOMM;
2432
2418
goto unlock;
2433
2419
nodesc:
···
2525
2511
iowait_inc_wait_count(wait, tx->num_desc);
2526
2512
}
2527
2513
spin_unlock(&sde->flushlist_lock);
2528
-
schedule_work(&sde->flush_worker);
2514
+
queue_work_on(sde->cpu, system_highpri_wq, &sde->flush_worker);
2529
2515
ret = -ECOMM;
2530
2516
goto update_tail;
2531
2517
nodesc:
+1
-3
drivers/infiniband/hw/hfi1/tid_rdma.c
+1
-3
drivers/infiniband/hw/hfi1/tid_rdma.c
+2
-2
drivers/infiniband/hw/hfi1/ud.c
+2
-2
drivers/infiniband/hw/hfi1/ud.c
···
683
683
pbc = create_pbc(ppd, pbc_flags, qp->srate_mbps, vl, plen);
684
684
if (ctxt) {
685
685
pbuf = sc_buffer_alloc(ctxt, plen, NULL, NULL);
686
-
if (pbuf) {
686
+
if (!IS_ERR_OR_NULL(pbuf)) {
687
687
trace_pio_output_ibhdr(ppd->dd, &hdr, sc5);
688
688
ppd->dd->pio_inline_send(ppd->dd, pbuf, pbc,
689
689
&hdr, hwords);
···
738
738
pbc = create_pbc(ppd, pbc_flags, qp->srate_mbps, vl, plen);
739
739
if (ctxt) {
740
740
pbuf = sc_buffer_alloc(ctxt, plen, NULL, NULL);
741
-
if (pbuf) {
741
+
if (!IS_ERR_OR_NULL(pbuf)) {
742
742
trace_pio_output_ibhdr(ppd->dd, &hdr, sc5);
743
743
ppd->dd->pio_inline_send(ppd->dd, pbuf, pbc,
744
744
&hdr, hwords);
+4
-8
drivers/infiniband/hw/hfi1/user_sdma.c
+4
-8
drivers/infiniband/hw/hfi1/user_sdma.c
···
130
130
{
131
131
struct hfi1_user_sdma_pkt_q *pq =
132
132
container_of(wait->iow, struct hfi1_user_sdma_pkt_q, busy);
133
-
struct user_sdma_txreq *tx =
134
-
container_of(txreq, struct user_sdma_txreq, txreq);
135
133
136
-
if (sdma_progress(sde, seq, txreq)) {
137
-
if (tx->busycount++ < MAX_DEFER_RETRY_COUNT)
138
-
goto eagain;
139
-
}
134
+
write_seqlock(&sde->waitlock);
135
+
if (sdma_progress(sde, seq, txreq))
136
+
goto eagain;
140
137
/*
141
138
* We are assuming that if the list is enqueued somewhere, it
142
139
* is to the dmawait list since that is the only place where
143
140
* it is supposed to be enqueued.
144
141
*/
145
142
xchg(&pq->state, SDMA_PKT_Q_DEFERRED);
146
-
write_seqlock(&sde->waitlock);
147
143
if (list_empty(&pq->busy.list)) {
148
144
iowait_get_priority(&pq->busy);
149
145
iowait_queue(pkts_sent, &pq->busy, &sde->dmawait);
···
147
151
write_sequnlock(&sde->waitlock);
148
152
return -EBUSY;
149
153
eagain:
154
+
write_sequnlock(&sde->waitlock);
150
155
return -EAGAIN;
151
156
}
152
157
···
801
804
802
805
tx->flags = 0;
803
806
tx->req = req;
804
-
tx->busycount = 0;
805
807
INIT_LIST_HEAD(&tx->list);
806
808
807
809
/*
-1
drivers/infiniband/hw/hfi1/user_sdma.h
-1
drivers/infiniband/hw/hfi1/user_sdma.h
+8
-6
drivers/infiniband/hw/hfi1/verbs.c
+8
-6
drivers/infiniband/hw/hfi1/verbs.c
···
638
638
struct hfi1_opa_header *hdr;
639
639
640
640
hdr = &tx->phdr.hdr;
641
+
if (unlikely(status == SDMA_TXREQ_S_ABORTED))
642
+
hfi1_rc_verbs_aborted(qp, hdr);
641
643
hfi1_rc_send_complete(qp, hdr);
642
644
}
643
645
spin_unlock(&qp->s_lock);
···
1039
1037
if (cb)
1040
1038
iowait_pio_inc(&priv->s_iowait);
1041
1039
pbuf = sc_buffer_alloc(sc, plen, cb, qp);
1042
-
if (unlikely(!pbuf)) {
1040
+
if (unlikely(IS_ERR_OR_NULL(pbuf))) {
1043
1041
if (cb)
1044
1042
verbs_pio_complete(qp, 0);
1045
-
if (ppd->host_link_state != HLS_UP_ACTIVE) {
1043
+
if (IS_ERR(pbuf)) {
1046
1044
/*
1047
1045
* If we have filled the PIO buffers to capacity and are
1048
1046
* not in an active state this request is not going to
···
1097
1095
&ps->s_txreq->phdr.hdr, ib_is_sc5(sc5));
1098
1096
1099
1097
pio_bail:
1098
+
spin_lock_irqsave(&qp->s_lock, flags);
1100
1099
if (qp->s_wqe) {
1101
-
spin_lock_irqsave(&qp->s_lock, flags);
1102
1100
rvt_send_complete(qp, qp->s_wqe, wc_status);
1103
-
spin_unlock_irqrestore(&qp->s_lock, flags);
1104
1101
} else if (qp->ibqp.qp_type == IB_QPT_RC) {
1105
-
spin_lock_irqsave(&qp->s_lock, flags);
1102
+
if (unlikely(wc_status == IB_WC_GENERAL_ERR))
1103
+
hfi1_rc_verbs_aborted(qp, &ps->s_txreq->phdr.hdr);
1106
1104
hfi1_rc_send_complete(qp, &ps->s_txreq->phdr.hdr);
1107
-
spin_unlock_irqrestore(&qp->s_lock, flags);
1108
1105
}
1106
+
spin_unlock_irqrestore(&qp->s_lock, flags);
1109
1107
1110
1108
ret = 0;
1111
1109
+1
drivers/infiniband/hw/hfi1/verbs.h
+1
drivers/infiniband/hw/hfi1/verbs.h
···
416
416
417
417
u8 ah_to_sc(struct ib_device *ibdev, struct rdma_ah_attr *ah_attr);
418
418
419
+
void hfi1_rc_verbs_aborted(struct rvt_qp *qp, struct hfi1_opa_header *opah);
419
420
void hfi1_rc_send_complete(struct rvt_qp *qp, struct hfi1_opa_header *opah);
420
421
421
422
void hfi1_ud_rcv(struct hfi1_packet *packet);
+1
-1
drivers/infiniband/hw/hfi1/verbs_txreq.c
+1
-1
drivers/infiniband/hw/hfi1/verbs_txreq.c
···
100
100
if (ib_rvt_state_ops[qp->state] & RVT_PROCESS_RECV_OK) {
101
101
struct hfi1_qp_priv *priv;
102
102
103
-
tx = kmem_cache_alloc(dev->verbs_txreq_cache, GFP_ATOMIC);
103
+
tx = kmem_cache_alloc(dev->verbs_txreq_cache, VERBS_TXREQ_GFP);
104
104
if (tx)
105
105
goto out;
106
106
priv = qp->priv;
+2
-1
drivers/infiniband/hw/hfi1/verbs_txreq.h
+2
-1
drivers/infiniband/hw/hfi1/verbs_txreq.h
···
72
72
struct verbs_txreq *__get_txreq(struct hfi1_ibdev *dev,
73
73
struct rvt_qp *qp);
74
74
75
+
#define VERBS_TXREQ_GFP (GFP_ATOMIC | __GFP_NOWARN)
75
76
static inline struct verbs_txreq *get_txreq(struct hfi1_ibdev *dev,
76
77
struct rvt_qp *qp)
77
78
__must_hold(&qp->slock)
···
80
79
struct verbs_txreq *tx;
81
80
struct hfi1_qp_priv *priv = qp->priv;
82
81
83
-
tx = kmem_cache_alloc(dev->verbs_txreq_cache, GFP_ATOMIC);
82
+
tx = kmem_cache_alloc(dev->verbs_txreq_cache, VERBS_TXREQ_GFP);
84
83
if (unlikely(!tx)) {
85
84
/* call slow path to get the lock */
86
85
tx = __get_txreq(dev, qp);