1
2
3
4
5
6#include <linux/errno.h>
7#include <linux/types.h>
8#include <linux/net.h>
9#include <linux/scatterlist.h>
10#include <linux/highmem.h>
11#include <net/tcp.h>
12
13#include <rdma/iw_cm.h>
14#include <rdma/ib_verbs.h>
15#include <rdma/ib_user_verbs.h>
16
17#include "siw.h"
18#include "siw_verbs.h"
19#include "siw_mem.h"
20
21#define MAX_HDR_INLINE \
22 (((uint32_t)(sizeof(struct siw_rreq_pkt) - \
23 sizeof(struct iwarp_send))) & 0xF8)
24
25static struct page *siw_get_pblpage(struct siw_mem *mem, u64 addr, int *idx)
26{
27 struct siw_pbl *pbl = mem->pbl;
28 u64 offset = addr - mem->va;
29 dma_addr_t paddr = siw_pbl_get_buffer(pbl, offset, NULL, idx);
30
31 if (paddr)
32 return virt_to_page(paddr);
33
34 return NULL;
35}
36
37
38
39
40static int siw_try_1seg(struct siw_iwarp_tx *c_tx, void *paddr)
41{
42 struct siw_wqe *wqe = &c_tx->wqe_active;
43 struct siw_sge *sge = &wqe->sqe.sge[0];
44 u32 bytes = sge->length;
45
46 if (bytes > MAX_HDR_INLINE || wqe->sqe.num_sge != 1)
47 return MAX_HDR_INLINE + 1;
48
49 if (!bytes)
50 return 0;
51
52 if (tx_flags(wqe) & SIW_WQE_INLINE) {
53 memcpy(paddr, &wqe->sqe.sge[1], bytes);
54 } else {
55 struct siw_mem *mem = wqe->mem[0];
56
57 if (!mem->mem_obj) {
58
59 memcpy(paddr,
60 (const void *)(uintptr_t)sge->laddr, bytes);
61 } else if (c_tx->in_syscall) {
62 if (copy_from_user(paddr, u64_to_user_ptr(sge->laddr),
63 bytes))
64 return -EFAULT;
65 } else {
66 unsigned int off = sge->laddr & ~PAGE_MASK;
67 struct page *p;
68 char *buffer;
69 int pbl_idx = 0;
70
71 if (!mem->is_pbl)
72 p = siw_get_upage(mem->umem, sge->laddr);
73 else
74 p = siw_get_pblpage(mem, sge->laddr, &pbl_idx);
75
76 if (unlikely(!p))
77 return -EFAULT;
78
79 buffer = kmap_local_page(p);
80
81 if (likely(PAGE_SIZE - off >= bytes)) {
82 memcpy(paddr, buffer + off, bytes);
83 } else {
84 unsigned long part = bytes - (PAGE_SIZE - off);
85
86 memcpy(paddr, buffer + off, part);
87 kunmap_local(buffer);
88
89 if (!mem->is_pbl)
90 p = siw_get_upage(mem->umem,
91 sge->laddr + part);
92 else
93 p = siw_get_pblpage(mem,
94 sge->laddr + part,
95 &pbl_idx);
96 if (unlikely(!p))
97 return -EFAULT;
98
99 buffer = kmap_local_page(p);
100 memcpy(paddr + part, buffer, bytes - part);
101 }
102 kunmap_local(buffer);
103 }
104 }
105 return (int)bytes;
106}
107
108#define PKT_FRAGMENTED 1
109#define PKT_COMPLETE 0
110
111
112
113
114
115
116
117
118
119static int siw_qp_prepare_tx(struct siw_iwarp_tx *c_tx)
120{
121 struct siw_wqe *wqe = &c_tx->wqe_active;
122 char *crc = NULL;
123 int data = 0;
124
125 switch (tx_type(wqe)) {
126 case SIW_OP_READ:
127 case SIW_OP_READ_LOCAL_INV:
128 memcpy(&c_tx->pkt.ctrl,
129 &iwarp_pktinfo[RDMAP_RDMA_READ_REQ].ctrl,
130 sizeof(struct iwarp_ctrl));
131
132 c_tx->pkt.rreq.rsvd = 0;
133 c_tx->pkt.rreq.ddp_qn = htonl(RDMAP_UNTAGGED_QN_RDMA_READ);
134 c_tx->pkt.rreq.ddp_msn =
135 htonl(++c_tx->ddp_msn[RDMAP_UNTAGGED_QN_RDMA_READ]);
136 c_tx->pkt.rreq.ddp_mo = 0;
137 c_tx->pkt.rreq.sink_stag = htonl(wqe->sqe.sge[0].lkey);
138 c_tx->pkt.rreq.sink_to =
139 cpu_to_be64(wqe->sqe.sge[0].laddr);
140 c_tx->pkt.rreq.source_stag = htonl(wqe->sqe.rkey);
141 c_tx->pkt.rreq.source_to = cpu_to_be64(wqe->sqe.raddr);
142 c_tx->pkt.rreq.read_size = htonl(wqe->sqe.sge[0].length);
143
144 c_tx->ctrl_len = sizeof(struct iwarp_rdma_rreq);
145 crc = (char *)&c_tx->pkt.rreq_pkt.crc;
146 break;
147
148 case SIW_OP_SEND:
149 if (tx_flags(wqe) & SIW_WQE_SOLICITED)
150 memcpy(&c_tx->pkt.ctrl,
151 &iwarp_pktinfo[RDMAP_SEND_SE].ctrl,
152 sizeof(struct iwarp_ctrl));
153 else
154 memcpy(&c_tx->pkt.ctrl, &iwarp_pktinfo[RDMAP_SEND].ctrl,
155 sizeof(struct iwarp_ctrl));
156
157 c_tx->pkt.send.ddp_qn = RDMAP_UNTAGGED_QN_SEND;
158 c_tx->pkt.send.ddp_msn =
159 htonl(++c_tx->ddp_msn[RDMAP_UNTAGGED_QN_SEND]);
160 c_tx->pkt.send.ddp_mo = 0;
161
162 c_tx->pkt.send_inv.inval_stag = 0;
163
164 c_tx->ctrl_len = sizeof(struct iwarp_send);
165
166 crc = (char *)&c_tx->pkt.send_pkt.crc;
167 data = siw_try_1seg(c_tx, crc);
168 break;
169
170 case SIW_OP_SEND_REMOTE_INV:
171 if (tx_flags(wqe) & SIW_WQE_SOLICITED)
172 memcpy(&c_tx->pkt.ctrl,
173 &iwarp_pktinfo[RDMAP_SEND_SE_INVAL].ctrl,
174 sizeof(struct iwarp_ctrl));
175 else
176 memcpy(&c_tx->pkt.ctrl,
177 &iwarp_pktinfo[RDMAP_SEND_INVAL].ctrl,
178 sizeof(struct iwarp_ctrl));
179
180 c_tx->pkt.send.ddp_qn = RDMAP_UNTAGGED_QN_SEND;
181 c_tx->pkt.send.ddp_msn =
182 htonl(++c_tx->ddp_msn[RDMAP_UNTAGGED_QN_SEND]);
183 c_tx->pkt.send.ddp_mo = 0;
184
185 c_tx->pkt.send_inv.inval_stag = cpu_to_be32(wqe->sqe.rkey);
186
187 c_tx->ctrl_len = sizeof(struct iwarp_send_inv);
188
189 crc = (char *)&c_tx->pkt.send_pkt.crc;
190 data = siw_try_1seg(c_tx, crc);
191 break;
192
193 case SIW_OP_WRITE:
194 memcpy(&c_tx->pkt.ctrl, &iwarp_pktinfo[RDMAP_RDMA_WRITE].ctrl,
195 sizeof(struct iwarp_ctrl));
196
197 c_tx->pkt.rwrite.sink_stag = htonl(wqe->sqe.rkey);
198 c_tx->pkt.rwrite.sink_to = cpu_to_be64(wqe->sqe.raddr);
199 c_tx->ctrl_len = sizeof(struct iwarp_rdma_write);
200
201 crc = (char *)&c_tx->pkt.write_pkt.crc;
202 data = siw_try_1seg(c_tx, crc);
203 break;
204
205 case SIW_OP_READ_RESPONSE:
206 memcpy(&c_tx->pkt.ctrl,
207 &iwarp_pktinfo[RDMAP_RDMA_READ_RESP].ctrl,
208 sizeof(struct iwarp_ctrl));
209
210
211 c_tx->pkt.rresp.sink_stag = cpu_to_be32(wqe->sqe.rkey);
212 c_tx->pkt.rresp.sink_to = cpu_to_be64(wqe->sqe.raddr);
213
214 c_tx->ctrl_len = sizeof(struct iwarp_rdma_rresp);
215
216 crc = (char *)&c_tx->pkt.write_pkt.crc;
217 data = siw_try_1seg(c_tx, crc);
218 break;
219
220 default:
221 siw_dbg_qp(tx_qp(c_tx), "stale wqe type %d\n", tx_type(wqe));
222 return -EOPNOTSUPP;
223 }
224 if (unlikely(data < 0))
225 return data;
226
227 c_tx->ctrl_sent = 0;
228
229 if (data <= MAX_HDR_INLINE) {
230 if (data) {
231 wqe->processed = data;
232
233 c_tx->pkt.ctrl.mpa_len =
234 htons(c_tx->ctrl_len + data - MPA_HDR_SIZE);
235
236
237 data += -(int)data & 0x3;
238
239 crc += data;
240 c_tx->ctrl_len += data;
241
242 if (!(c_tx->pkt.ctrl.ddp_rdmap_ctrl & DDP_FLAG_TAGGED))
243 c_tx->pkt.c_untagged.ddp_mo = 0;
244 else
245 c_tx->pkt.c_tagged.ddp_to =
246 cpu_to_be64(wqe->sqe.raddr);
247 }
248
249 *(u32 *)crc = 0;
250
251
252
253 if (c_tx->mpa_crc_hd) {
254 crypto_shash_init(c_tx->mpa_crc_hd);
255 if (crypto_shash_update(c_tx->mpa_crc_hd,
256 (u8 *)&c_tx->pkt,
257 c_tx->ctrl_len))
258 return -EINVAL;
259 crypto_shash_final(c_tx->mpa_crc_hd, (u8 *)crc);
260 }
261 c_tx->ctrl_len += MPA_CRC_SIZE;
262
263 return PKT_COMPLETE;
264 }
265 c_tx->ctrl_len += MPA_CRC_SIZE;
266 c_tx->sge_idx = 0;
267 c_tx->sge_off = 0;
268 c_tx->pbl_idx = 0;
269
270
271
272
273
274
275
276
277
278
279 if (c_tx->zcopy_tx && wqe->bytes >= SENDPAGE_THRESH &&
280 !(tx_flags(wqe) & SIW_WQE_SIGNALLED))
281 c_tx->use_sendpage = 1;
282 else
283 c_tx->use_sendpage = 0;
284
285 return PKT_FRAGMENTED;
286}
287
288
289
290
291
292
293static int siw_tx_ctrl(struct siw_iwarp_tx *c_tx, struct socket *s,
294 int flags)
295{
296 struct msghdr msg = { .msg_flags = flags };
297 struct kvec iov = { .iov_base =
298 (char *)&c_tx->pkt.ctrl + c_tx->ctrl_sent,
299 .iov_len = c_tx->ctrl_len - c_tx->ctrl_sent };
300
301 int rv = kernel_sendmsg(s, &msg, &iov, 1,
302 c_tx->ctrl_len - c_tx->ctrl_sent);
303
304 if (rv >= 0) {
305 c_tx->ctrl_sent += rv;
306
307 if (c_tx->ctrl_sent == c_tx->ctrl_len)
308 rv = 0;
309 else
310 rv = -EAGAIN;
311 }
312 return rv;
313}
314
315
316
317
318
319
320
321
322
323
324static int siw_tcp_sendpages(struct socket *s, struct page **page, int offset,
325 size_t size)
326{
327 struct sock *sk = s->sk;
328 int i = 0, rv = 0, sent = 0,
329 flags = MSG_MORE | MSG_DONTWAIT | MSG_SENDPAGE_NOTLAST;
330
331 while (size) {
332 size_t bytes = min_t(size_t, PAGE_SIZE - offset, size);
333
334 if (size + offset <= PAGE_SIZE)
335 flags = MSG_MORE | MSG_DONTWAIT;
336
337 tcp_rate_check_app_limited(sk);
338try_page_again:
339 lock_sock(sk);
340 rv = do_tcp_sendpages(sk, page[i], offset, bytes, flags);
341 release_sock(sk);
342
343 if (rv > 0) {
344 size -= rv;
345 sent += rv;
346 if (rv != bytes) {
347 offset += rv;
348 bytes -= rv;
349 goto try_page_again;
350 }
351 offset = 0;
352 } else {
353 if (rv == -EAGAIN || rv == 0)
354 break;
355 return rv;
356 }
357 i++;
358 }
359 return sent;
360}
361
362
363
364
365
366
367
368
369static int siw_0copy_tx(struct socket *s, struct page **page,
370 struct siw_sge *sge, unsigned int offset,
371 unsigned int size)
372{
373 int i = 0, sent = 0, rv;
374 int sge_bytes = min(sge->length - offset, size);
375
376 offset = (sge->laddr + offset) & ~PAGE_MASK;
377
378 while (sent != size) {
379 rv = siw_tcp_sendpages(s, &page[i], offset, sge_bytes);
380 if (rv >= 0) {
381 sent += rv;
382 if (size == sent || sge_bytes > rv)
383 break;
384
385 i += PAGE_ALIGN(sge_bytes + offset) >> PAGE_SHIFT;
386 sge++;
387 sge_bytes = min(sge->length, size - sent);
388 offset = sge->laddr & ~PAGE_MASK;
389 } else {
390 sent = rv;
391 break;
392 }
393 }
394 return sent;
395}
396
397#define MAX_TRAILER (MPA_CRC_SIZE + 4)
398
399static void siw_unmap_pages(struct kvec *iov, unsigned long kmap_mask, int len)
400{
401 int i;
402
403
404
405
406
407 for (i = (len-1); i >= 0; i--) {
408 if (kmap_mask & BIT(i)) {
409 unsigned long addr = (unsigned long)iov[i].iov_base;
410
411 kunmap_local((void *)(addr & PAGE_MASK));
412 }
413 }
414}
415
416
417
418
419
420
421
422
423
424
425#define MAX_ARRAY ((0xffff / PAGE_SIZE) + 1 + (2 * (SIW_MAX_SGE - 1) + 2))
426
427
428
429
430
431static int siw_tx_hdt(struct siw_iwarp_tx *c_tx, struct socket *s)
432{
433 struct siw_wqe *wqe = &c_tx->wqe_active;
434 struct siw_sge *sge = &wqe->sqe.sge[c_tx->sge_idx];
435 struct kvec iov[MAX_ARRAY];
436 struct page *page_array[MAX_ARRAY];
437 struct msghdr msg = { .msg_flags = MSG_DONTWAIT | MSG_EOR };
438
439 int seg = 0, do_crc = c_tx->do_crc, is_kva = 0, rv;
440 unsigned int data_len = c_tx->bytes_unsent, hdr_len = 0, trl_len = 0,
441 sge_off = c_tx->sge_off, sge_idx = c_tx->sge_idx,
442 pbl_idx = c_tx->pbl_idx;
443 unsigned long kmap_mask = 0L;
444
445 if (c_tx->state == SIW_SEND_HDR) {
446 if (c_tx->use_sendpage) {
447 rv = siw_tx_ctrl(c_tx, s, MSG_DONTWAIT | MSG_MORE);
448 if (rv)
449 goto done;
450
451 c_tx->state = SIW_SEND_DATA;
452 } else {
453 iov[0].iov_base =
454 (char *)&c_tx->pkt.ctrl + c_tx->ctrl_sent;
455 iov[0].iov_len = hdr_len =
456 c_tx->ctrl_len - c_tx->ctrl_sent;
457 seg = 1;
458 }
459 }
460
461 wqe->processed += data_len;
462
463 while (data_len) {
464 unsigned int sge_len = min(sge->length - sge_off, data_len);
465 unsigned int fp_off = (sge->laddr + sge_off) & ~PAGE_MASK;
466 struct siw_mem *mem;
467
468 if (!(tx_flags(wqe) & SIW_WQE_INLINE)) {
469 mem = wqe->mem[sge_idx];
470 is_kva = mem->mem_obj == NULL ? 1 : 0;
471 } else {
472 is_kva = 1;
473 }
474 if (is_kva && !c_tx->use_sendpage) {
475
476
477
478
479 iov[seg].iov_base =
480 (void *)(uintptr_t)(sge->laddr + sge_off);
481 iov[seg].iov_len = sge_len;
482
483 if (do_crc)
484 crypto_shash_update(c_tx->mpa_crc_hd,
485 iov[seg].iov_base,
486 sge_len);
487 sge_off += sge_len;
488 data_len -= sge_len;
489 seg++;
490 goto sge_done;
491 }
492
493 while (sge_len) {
494 size_t plen = min((int)PAGE_SIZE - fp_off, sge_len);
495 void *kaddr;
496
497 if (!is_kva) {
498 struct page *p;
499
500 if (mem->is_pbl)
501 p = siw_get_pblpage(
502 mem, sge->laddr + sge_off,
503 &pbl_idx);
504 else
505 p = siw_get_upage(mem->umem,
506 sge->laddr + sge_off);
507 if (unlikely(!p)) {
508 siw_unmap_pages(iov, kmap_mask, seg);
509 wqe->processed -= c_tx->bytes_unsent;
510 rv = -EFAULT;
511 goto done_crc;
512 }
513 page_array[seg] = p;
514
515 if (!c_tx->use_sendpage) {
516 void *kaddr = kmap_local_page(p);
517
518
519 kmap_mask |= BIT(seg);
520 iov[seg].iov_base = kaddr + fp_off;
521 iov[seg].iov_len = plen;
522
523 if (do_crc)
524 crypto_shash_update(
525 c_tx->mpa_crc_hd,
526 iov[seg].iov_base,
527 plen);
528 } else if (do_crc) {
529 kaddr = kmap_local_page(p);
530 crypto_shash_update(c_tx->mpa_crc_hd,
531 kaddr + fp_off,
532 plen);
533 kunmap_local(kaddr);
534 }
535 } else {
536 u64 va = sge->laddr + sge_off;
537
538 page_array[seg] = virt_to_page(va & PAGE_MASK);
539 if (do_crc)
540 crypto_shash_update(
541 c_tx->mpa_crc_hd,
542 (void *)(uintptr_t)va,
543 plen);
544 }
545
546 sge_len -= plen;
547 sge_off += plen;
548 data_len -= plen;
549 fp_off = 0;
550
551 if (++seg > (int)MAX_ARRAY) {
552 siw_dbg_qp(tx_qp(c_tx), "to many fragments\n");
553 siw_unmap_pages(iov, kmap_mask, seg-1);
554 wqe->processed -= c_tx->bytes_unsent;
555 rv = -EMSGSIZE;
556 goto done_crc;
557 }
558 }
559sge_done:
560
561 if (sge_off == sge->length &&
562 (data_len != 0 || wqe->processed < wqe->bytes)) {
563 sge_idx++;
564 sge++;
565 sge_off = 0;
566 }
567 }
568
569 if (likely(c_tx->state != SIW_SEND_TRAILER)) {
570 iov[seg].iov_base = &c_tx->trailer.pad[4 - c_tx->pad];
571 iov[seg].iov_len = trl_len = MAX_TRAILER - (4 - c_tx->pad);
572 } else {
573 iov[seg].iov_base = &c_tx->trailer.pad[c_tx->ctrl_sent];
574 iov[seg].iov_len = trl_len = MAX_TRAILER - c_tx->ctrl_sent;
575 }
576
577 if (c_tx->pad) {
578 *(u32 *)c_tx->trailer.pad = 0;
579 if (do_crc)
580 crypto_shash_update(c_tx->mpa_crc_hd,
581 (u8 *)&c_tx->trailer.crc - c_tx->pad,
582 c_tx->pad);
583 }
584 if (!c_tx->mpa_crc_hd)
585 c_tx->trailer.crc = 0;
586 else if (do_crc)
587 crypto_shash_final(c_tx->mpa_crc_hd, (u8 *)&c_tx->trailer.crc);
588
589 data_len = c_tx->bytes_unsent;
590
591 if (c_tx->use_sendpage) {
592 rv = siw_0copy_tx(s, page_array, &wqe->sqe.sge[c_tx->sge_idx],
593 c_tx->sge_off, data_len);
594 if (rv == data_len) {
595 rv = kernel_sendmsg(s, &msg, &iov[seg], 1, trl_len);
596 if (rv > 0)
597 rv += data_len;
598 else
599 rv = data_len;
600 }
601 } else {
602 rv = kernel_sendmsg(s, &msg, iov, seg + 1,
603 hdr_len + data_len + trl_len);
604 siw_unmap_pages(iov, kmap_mask, seg);
605 }
606 if (rv < (int)hdr_len) {
607
608 wqe->processed -= data_len;
609 if (rv >= 0) {
610 c_tx->ctrl_sent += rv;
611 rv = -EAGAIN;
612 }
613 goto done_crc;
614 }
615 rv -= hdr_len;
616
617 if (rv >= (int)data_len) {
618
619 if (data_len > 0 && wqe->processed < wqe->bytes) {
620
621 c_tx->sge_idx = sge_idx;
622 c_tx->sge_off = sge_off;
623 c_tx->pbl_idx = pbl_idx;
624 }
625 rv -= data_len;
626
627 if (rv == trl_len)
628 rv = 0;
629 else {
630 c_tx->state = SIW_SEND_TRAILER;
631 c_tx->ctrl_len = MAX_TRAILER;
632 c_tx->ctrl_sent = rv + 4 - c_tx->pad;
633 c_tx->bytes_unsent = 0;
634 rv = -EAGAIN;
635 }
636
637 } else if (data_len > 0) {
638
639 c_tx->state = SIW_SEND_DATA;
640 wqe->processed -= data_len - rv;
641
642 if (rv) {
643
644
645
646
647 unsigned int sge_unsent;
648
649 c_tx->bytes_unsent -= rv;
650 sge = &wqe->sqe.sge[c_tx->sge_idx];
651 sge_unsent = sge->length - c_tx->sge_off;
652
653 while (sge_unsent <= rv) {
654 rv -= sge_unsent;
655 c_tx->sge_idx++;
656 c_tx->sge_off = 0;
657 sge++;
658 sge_unsent = sge->length;
659 }
660 c_tx->sge_off += rv;
661 }
662 rv = -EAGAIN;
663 }
664done_crc:
665 c_tx->do_crc = 0;
666done:
667 return rv;
668}
669
670static void siw_update_tcpseg(struct siw_iwarp_tx *c_tx,
671 struct socket *s)
672{
673 struct tcp_sock *tp = tcp_sk(s->sk);
674
675 if (tp->gso_segs) {
676 if (c_tx->gso_seg_limit == 0)
677 c_tx->tcp_seglen = tp->mss_cache * tp->gso_segs;
678 else
679 c_tx->tcp_seglen =
680 tp->mss_cache *
681 min_t(u16, c_tx->gso_seg_limit, tp->gso_segs);
682 } else {
683 c_tx->tcp_seglen = tp->mss_cache;
684 }
685
686 c_tx->tcp_seglen &= 0xfffffff8;
687}
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703static void siw_prepare_fpdu(struct siw_qp *qp, struct siw_wqe *wqe)
704{
705 struct siw_iwarp_tx *c_tx = &qp->tx_ctx;
706 int data_len;
707
708 c_tx->ctrl_len =
709 iwarp_pktinfo[__rdmap_get_opcode(&c_tx->pkt.ctrl)].hdr_len;
710 c_tx->ctrl_sent = 0;
711
712
713
714
715 if (!(c_tx->pkt.ctrl.ddp_rdmap_ctrl & DDP_FLAG_TAGGED))
716
717 c_tx->pkt.c_untagged.ddp_mo = cpu_to_be32(wqe->processed);
718 else
719 c_tx->pkt.c_tagged.ddp_to =
720 cpu_to_be64(wqe->sqe.raddr + wqe->processed);
721
722 data_len = wqe->bytes - wqe->processed;
723 if (data_len + c_tx->ctrl_len + MPA_CRC_SIZE > c_tx->tcp_seglen) {
724
725 data_len = c_tx->tcp_seglen - (c_tx->ctrl_len + MPA_CRC_SIZE);
726 c_tx->pkt.ctrl.ddp_rdmap_ctrl &= ~DDP_FLAG_LAST;
727 c_tx->pad = 0;
728 } else {
729 c_tx->pkt.ctrl.ddp_rdmap_ctrl |= DDP_FLAG_LAST;
730 c_tx->pad = -data_len & 0x3;
731 }
732 c_tx->bytes_unsent = data_len;
733
734 c_tx->pkt.ctrl.mpa_len =
735 htons(c_tx->ctrl_len + data_len - MPA_HDR_SIZE);
736
737
738
739
740 if (c_tx->mpa_crc_hd) {
741 crypto_shash_init(c_tx->mpa_crc_hd);
742 crypto_shash_update(c_tx->mpa_crc_hd, (u8 *)&c_tx->pkt,
743 c_tx->ctrl_len);
744 c_tx->do_crc = 1;
745 }
746}
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761static int siw_check_sgl_tx(struct ib_pd *pd, struct siw_wqe *wqe,
762 enum ib_access_flags perms)
763{
764 struct siw_sge *sge = &wqe->sqe.sge[0];
765 int i, len, num_sge = wqe->sqe.num_sge;
766
767 if (unlikely(num_sge > SIW_MAX_SGE))
768 return -EINVAL;
769
770 for (i = 0, len = 0; num_sge; num_sge--, i++, sge++) {
771
772
773
774 if (sge->length) {
775 int rv = siw_check_sge(pd, sge, &wqe->mem[i], perms, 0,
776 sge->length);
777
778 if (unlikely(rv != E_ACCESS_OK))
779 return rv;
780 }
781 len += sge->length;
782 }
783 return len;
784}
785
786
787
788
789
790
791static int siw_qp_sq_proc_tx(struct siw_qp *qp, struct siw_wqe *wqe)
792{
793 struct siw_iwarp_tx *c_tx = &qp->tx_ctx;
794 struct socket *s = qp->attrs.sk;
795 int rv = 0, burst_len = qp->tx_ctx.burst;
796 enum rdmap_ecode ecode = RDMAP_ECODE_CATASTROPHIC_STREAM;
797
798 if (unlikely(wqe->wr_status == SIW_WR_IDLE))
799 return 0;
800
801 if (!burst_len)
802 burst_len = SQ_USER_MAXBURST;
803
804 if (wqe->wr_status == SIW_WR_QUEUED) {
805 if (!(wqe->sqe.flags & SIW_WQE_INLINE)) {
806 if (tx_type(wqe) == SIW_OP_READ_RESPONSE)
807 wqe->sqe.num_sge = 1;
808
809 if (tx_type(wqe) != SIW_OP_READ &&
810 tx_type(wqe) != SIW_OP_READ_LOCAL_INV) {
811
812
813
814
815
816 rv = siw_check_sgl_tx(qp->pd, wqe, 0);
817 if (rv < 0) {
818 if (tx_type(wqe) ==
819 SIW_OP_READ_RESPONSE)
820 ecode = siw_rdmap_error(-rv);
821 rv = -EINVAL;
822 goto tx_error;
823 }
824 wqe->bytes = rv;
825 } else {
826 wqe->bytes = 0;
827 }
828 } else {
829 wqe->bytes = wqe->sqe.sge[0].length;
830 if (!rdma_is_kernel_res(&qp->base_qp.res)) {
831 if (wqe->bytes > SIW_MAX_INLINE) {
832 rv = -EINVAL;
833 goto tx_error;
834 }
835 wqe->sqe.sge[0].laddr =
836 (u64)(uintptr_t)&wqe->sqe.sge[1];
837 }
838 }
839 wqe->wr_status = SIW_WR_INPROGRESS;
840 wqe->processed = 0;
841
842 siw_update_tcpseg(c_tx, s);
843
844 rv = siw_qp_prepare_tx(c_tx);
845 if (rv == PKT_FRAGMENTED) {
846 c_tx->state = SIW_SEND_HDR;
847 siw_prepare_fpdu(qp, wqe);
848 } else if (rv == PKT_COMPLETE) {
849 c_tx->state = SIW_SEND_SHORT_FPDU;
850 } else {
851 goto tx_error;
852 }
853 }
854
855next_segment:
856 siw_dbg_qp(qp, "wr type %d, state %d, data %u, sent %u, id %llx\n",
857 tx_type(wqe), wqe->wr_status, wqe->bytes, wqe->processed,
858 wqe->sqe.id);
859
860 if (--burst_len == 0) {
861 rv = -EINPROGRESS;
862 goto tx_done;
863 }
864 if (c_tx->state == SIW_SEND_SHORT_FPDU) {
865 enum siw_opcode tx_type = tx_type(wqe);
866 unsigned int msg_flags;
867
868 if (siw_sq_empty(qp) || !siw_tcp_nagle || burst_len == 1)
869
870
871
872
873
874 msg_flags = MSG_DONTWAIT;
875 else
876 msg_flags = MSG_DONTWAIT | MSG_MORE;
877
878 rv = siw_tx_ctrl(c_tx, s, msg_flags);
879
880 if (!rv && tx_type != SIW_OP_READ &&
881 tx_type != SIW_OP_READ_LOCAL_INV)
882 wqe->processed = wqe->bytes;
883
884 goto tx_done;
885
886 } else {
887 rv = siw_tx_hdt(c_tx, s);
888 }
889 if (!rv) {
890
891
892
893
894 if (unlikely(c_tx->tx_suspend)) {
895
896
897
898
899
900 rv = -ECONNABORTED;
901 goto tx_done;
902 }
903 if (c_tx->pkt.ctrl.ddp_rdmap_ctrl & DDP_FLAG_LAST) {
904 siw_dbg_qp(qp, "WQE completed\n");
905 goto tx_done;
906 }
907 c_tx->state = SIW_SEND_HDR;
908
909 siw_update_tcpseg(c_tx, s);
910
911 siw_prepare_fpdu(qp, wqe);
912 goto next_segment;
913 }
914tx_done:
915 qp->tx_ctx.burst = burst_len;
916 return rv;
917
918tx_error:
919 if (ecode != RDMAP_ECODE_CATASTROPHIC_STREAM)
920 siw_init_terminate(qp, TERM_ERROR_LAYER_RDMAP,
921 RDMAP_ETYPE_REMOTE_PROTECTION, ecode, 1);
922 else
923 siw_init_terminate(qp, TERM_ERROR_LAYER_RDMAP,
924 RDMAP_ETYPE_CATASTROPHIC,
925 RDMAP_ECODE_UNSPECIFIED, 1);
926 return rv;
927}
928
929static int siw_fastreg_mr(struct ib_pd *pd, struct siw_sqe *sqe)
930{
931 struct ib_mr *base_mr = (struct ib_mr *)(uintptr_t)sqe->base_mr;
932 struct siw_device *sdev = to_siw_dev(pd->device);
933 struct siw_mem *mem;
934 int rv = 0;
935
936 siw_dbg_pd(pd, "STag 0x%08x\n", sqe->rkey);
937
938 if (unlikely(!base_mr)) {
939 pr_warn("siw: fastreg: STag 0x%08x unknown\n", sqe->rkey);
940 return -EINVAL;
941 }
942
943 if (unlikely(base_mr->rkey >> 8 != sqe->rkey >> 8)) {
944 pr_warn("siw: fastreg: STag 0x%08x: bad MR\n", sqe->rkey);
945 return -EINVAL;
946 }
947
948 mem = siw_mem_id2obj(sdev, sqe->rkey >> 8);
949 if (unlikely(!mem)) {
950 pr_warn("siw: fastreg: STag 0x%08x unknown\n", sqe->rkey);
951 return -EINVAL;
952 }
953
954 if (unlikely(mem->pd != pd)) {
955 pr_warn("siw: fastreg: PD mismatch\n");
956 rv = -EINVAL;
957 goto out;
958 }
959 if (unlikely(mem->stag_valid)) {
960 pr_warn("siw: fastreg: STag 0x%08x already valid\n", sqe->rkey);
961 rv = -EINVAL;
962 goto out;
963 }
964
965 mem->stag = sqe->rkey;
966 mem->perms = sqe->access;
967
968 siw_dbg_mem(mem, "STag 0x%08x now valid\n", sqe->rkey);
969 mem->va = base_mr->iova;
970 mem->stag_valid = 1;
971out:
972 siw_mem_put(mem);
973 return rv;
974}
975
976static int siw_qp_sq_proc_local(struct siw_qp *qp, struct siw_wqe *wqe)
977{
978 int rv;
979
980 switch (tx_type(wqe)) {
981 case SIW_OP_REG_MR:
982 rv = siw_fastreg_mr(qp->pd, &wqe->sqe);
983 break;
984
985 case SIW_OP_INVAL_STAG:
986 rv = siw_invalidate_stag(qp->pd, wqe->sqe.rkey);
987 break;
988
989 default:
990 rv = -EINVAL;
991 }
992 return rv;
993}
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022int siw_qp_sq_process(struct siw_qp *qp)
1023{
1024 struct siw_wqe *wqe = tx_wqe(qp);
1025 enum siw_opcode tx_type;
1026 unsigned long flags;
1027 int rv = 0;
1028
1029 siw_dbg_qp(qp, "enter for type %d\n", tx_type(wqe));
1030
1031next_wqe:
1032
1033
1034
1035 if (unlikely(qp->tx_ctx.tx_suspend)) {
1036 siw_dbg_qp(qp, "tx suspended\n");
1037 goto done;
1038 }
1039 tx_type = tx_type(wqe);
1040
1041 if (tx_type <= SIW_OP_READ_RESPONSE)
1042 rv = siw_qp_sq_proc_tx(qp, wqe);
1043 else
1044 rv = siw_qp_sq_proc_local(qp, wqe);
1045
1046 if (!rv) {
1047
1048
1049
1050 switch (tx_type) {
1051 case SIW_OP_SEND:
1052 case SIW_OP_SEND_REMOTE_INV:
1053 case SIW_OP_WRITE:
1054 siw_wqe_put_mem(wqe, tx_type);
1055 fallthrough;
1056
1057 case SIW_OP_INVAL_STAG:
1058 case SIW_OP_REG_MR:
1059 if (tx_flags(wqe) & SIW_WQE_SIGNALLED)
1060 siw_sqe_complete(qp, &wqe->sqe, wqe->bytes,
1061 SIW_WC_SUCCESS);
1062 break;
1063
1064 case SIW_OP_READ:
1065 case SIW_OP_READ_LOCAL_INV:
1066
1067
1068
1069 break;
1070
1071 case SIW_OP_READ_RESPONSE:
1072 siw_wqe_put_mem(wqe, tx_type);
1073 break;
1074
1075 default:
1076 WARN(1, "undefined WQE type %d\n", tx_type);
1077 rv = -EINVAL;
1078 goto done;
1079 }
1080
1081 spin_lock_irqsave(&qp->sq_lock, flags);
1082 wqe->wr_status = SIW_WR_IDLE;
1083 rv = siw_activate_tx(qp);
1084 spin_unlock_irqrestore(&qp->sq_lock, flags);
1085
1086 if (rv <= 0)
1087 goto done;
1088
1089 goto next_wqe;
1090
1091 } else if (rv == -EAGAIN) {
1092 siw_dbg_qp(qp, "sq paused: hd/tr %d of %d, data %d\n",
1093 qp->tx_ctx.ctrl_sent, qp->tx_ctx.ctrl_len,
1094 qp->tx_ctx.bytes_unsent);
1095 rv = 0;
1096 goto done;
1097 } else if (rv == -EINPROGRESS) {
1098 rv = siw_sq_start(qp);
1099 goto done;
1100 } else {
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113 siw_dbg_qp(qp, "wqe type %d processing failed: %d\n",
1114 tx_type(wqe), rv);
1115
1116 spin_lock_irqsave(&qp->sq_lock, flags);
1117
1118
1119
1120 if ((tx_type == SIW_OP_READ ||
1121 tx_type == SIW_OP_READ_LOCAL_INV) && qp->attrs.orq_size) {
1122
1123 qp->orq_put--;
1124 qp->orq[qp->orq_put % qp->attrs.orq_size].flags = 0;
1125 }
1126 spin_unlock_irqrestore(&qp->sq_lock, flags);
1127
1128
1129
1130 if (!qp->tx_ctx.tx_suspend)
1131 siw_qp_cm_drop(qp, 0);
1132
1133 switch (tx_type) {
1134 case SIW_OP_SEND:
1135 case SIW_OP_SEND_REMOTE_INV:
1136 case SIW_OP_SEND_WITH_IMM:
1137 case SIW_OP_WRITE:
1138 case SIW_OP_READ:
1139 case SIW_OP_READ_LOCAL_INV:
1140 siw_wqe_put_mem(wqe, tx_type);
1141 fallthrough;
1142
1143 case SIW_OP_INVAL_STAG:
1144 case SIW_OP_REG_MR:
1145 siw_sqe_complete(qp, &wqe->sqe, wqe->bytes,
1146 SIW_WC_LOC_QP_OP_ERR);
1147
1148 siw_qp_event(qp, IB_EVENT_QP_FATAL);
1149
1150 break;
1151
1152 case SIW_OP_READ_RESPONSE:
1153 siw_dbg_qp(qp, "proc. read.response failed: %d\n", rv);
1154
1155 siw_qp_event(qp, IB_EVENT_QP_REQ_ERR);
1156
1157 siw_wqe_put_mem(wqe, SIW_OP_READ_RESPONSE);
1158
1159 break;
1160
1161 default:
1162 WARN(1, "undefined WQE type %d\n", tx_type);
1163 rv = -EINVAL;
1164 }
1165 wqe->wr_status = SIW_WR_IDLE;
1166 }
1167done:
1168 return rv;
1169}
1170
1171static void siw_sq_resume(struct siw_qp *qp)
1172{
1173 if (down_read_trylock(&qp->state_lock)) {
1174 if (likely(qp->attrs.state == SIW_QP_STATE_RTS &&
1175 !qp->tx_ctx.tx_suspend)) {
1176 int rv = siw_qp_sq_process(qp);
1177
1178 up_read(&qp->state_lock);
1179
1180 if (unlikely(rv < 0)) {
1181 siw_dbg_qp(qp, "SQ task failed: err %d\n", rv);
1182
1183 if (!qp->tx_ctx.tx_suspend)
1184 siw_qp_cm_drop(qp, 0);
1185 }
1186 } else {
1187 up_read(&qp->state_lock);
1188 }
1189 } else {
1190 siw_dbg_qp(qp, "Resume SQ while QP locked\n");
1191 }
1192 siw_qp_put(qp);
1193}
1194
1195struct tx_task_t {
1196 struct llist_head active;
1197 wait_queue_head_t waiting;
1198};
1199
1200static DEFINE_PER_CPU(struct tx_task_t, siw_tx_task_g);
1201
1202void siw_stop_tx_thread(int nr_cpu)
1203{
1204 kthread_stop(siw_tx_thread[nr_cpu]);
1205 wake_up(&per_cpu(siw_tx_task_g, nr_cpu).waiting);
1206}
1207
1208int siw_run_sq(void *data)
1209{
1210 const int nr_cpu = (unsigned int)(long)data;
1211 struct llist_node *active;
1212 struct siw_qp *qp;
1213 struct tx_task_t *tx_task = &per_cpu(siw_tx_task_g, nr_cpu);
1214
1215 init_llist_head(&tx_task->active);
1216 init_waitqueue_head(&tx_task->waiting);
1217
1218 while (1) {
1219 struct llist_node *fifo_list = NULL;
1220
1221 wait_event_interruptible(tx_task->waiting,
1222 !llist_empty(&tx_task->active) ||
1223 kthread_should_stop());
1224
1225 if (kthread_should_stop())
1226 break;
1227
1228 active = llist_del_all(&tx_task->active);
1229
1230
1231
1232
1233 while (active) {
1234 struct llist_node *tmp = active;
1235
1236 active = llist_next(active);
1237 tmp->next = fifo_list;
1238 fifo_list = tmp;
1239 }
1240 while (fifo_list) {
1241 qp = container_of(fifo_list, struct siw_qp, tx_list);
1242 fifo_list = llist_next(fifo_list);
1243 qp->tx_list.next = NULL;
1244
1245 siw_sq_resume(qp);
1246 }
1247 }
1248 active = llist_del_all(&tx_task->active);
1249 if (active) {
1250 llist_for_each_entry(qp, active, tx_list) {
1251 qp->tx_list.next = NULL;
1252 siw_sq_resume(qp);
1253 }
1254 }
1255 return 0;
1256}
1257
1258int siw_sq_start(struct siw_qp *qp)
1259{
1260 if (tx_wqe(qp)->wr_status == SIW_WR_IDLE)
1261 return 0;
1262
1263 if (unlikely(!cpu_online(qp->tx_cpu))) {
1264 siw_put_tx_cpu(qp->tx_cpu);
1265 qp->tx_cpu = siw_get_tx_cpu(qp->sdev);
1266 if (qp->tx_cpu < 0) {
1267 pr_warn("siw: no tx cpu available\n");
1268
1269 return -EIO;
1270 }
1271 }
1272 siw_qp_get(qp);
1273
1274 llist_add(&qp->tx_list, &per_cpu(siw_tx_task_g, qp->tx_cpu).active);
1275
1276 wake_up(&per_cpu(siw_tx_task_g, qp->tx_cpu).waiting);
1277
1278 return 0;
1279}
1280