Merge tag 'v6.18-rc2-smb-server-fixes' of git://git.samba.org/ksmbd

+42 -25

fs/smb/client/smbdirect.c

··· 172 172 * in order to notice the broken connection. 173 173 */ 174 174 wake_up_all(&sc->status_wait); 175 + wake_up_all(&sc->send_io.lcredits.wait_queue); 175 176 wake_up_all(&sc->send_io.credits.wait_queue); 176 177 wake_up_all(&sc->send_io.pending.dec_wait_queue); 177 178 wake_up_all(&sc->send_io.pending.zero_wait_queue); ··· 496 495 struct smbdirect_send_io *request = 497 496 container_of(wc->wr_cqe, struct smbdirect_send_io, cqe); 498 497 struct smbdirect_socket *sc = request->socket; 498 + int lcredits = 0; 499 499 500 500 log_rdma_send(INFO, "smbdirect_send_io 0x%p completed wc->status=%s\n", 501 501 request, ib_wc_status_msg(wc->status)); ··· 506 504 request->sge[i].addr, 507 505 request->sge[i].length, 508 506 DMA_TO_DEVICE); 507 + mempool_free(request, sc->send_io.mem.pool); 508 + lcredits += 1; 509 509 510 510 if (wc->status != IB_WC_SUCCESS || wc->opcode != IB_WC_SEND) { 511 511 if (wc->status != IB_WC_WR_FLUSH_ERR) 512 512 log_rdma_send(ERR, "wc->status=%s wc->opcode=%d\n", 513 513 ib_wc_status_msg(wc->status), wc->opcode); 514 - mempool_free(request, sc->send_io.mem.pool); 515 514 smbd_disconnect_rdma_connection(sc); 516 515 return; 517 516 } 517 + 518 + atomic_add(lcredits, &sc->send_io.lcredits.count); 519 + wake_up(&sc->send_io.lcredits.wait_queue); 518 520 519 521 if (atomic_dec_and_test(&sc->send_io.pending.count)) 520 522 wake_up(&sc->send_io.pending.zero_wait_queue); 521 523 522 524 wake_up(&sc->send_io.pending.dec_wait_queue); 523 - 524 - mempool_free(request, sc->send_io.mem.pool); 525 525 } 526 526 527 527 static void dump_smbdirect_negotiate_resp(struct smbdirect_negotiate_resp *resp) ··· 571 567 log_rdma_event(ERR, "error: credits_granted==0\n"); 572 568 return false; 573 569 } 570 + atomic_set(&sc->send_io.lcredits.count, sp->send_credit_target); 574 571 atomic_set(&sc->send_io.credits.count, le16_to_cpu(packet->credits_granted)); 575 572 576 573 if (le32_to_cpu(packet->preferred_send_size) > sp->max_recv_size) { ··· 1119 1114 struct smbdirect_data_transfer *packet; 1120 1115 int new_credits = 0; 1121 1116 1117 + wait_lcredit: 1118 + /* Wait for local send credits */ 1119 + rc = wait_event_interruptible(sc->send_io.lcredits.wait_queue, 1120 + atomic_read(&sc->send_io.lcredits.count) > 0 || 1121 + sc->status != SMBDIRECT_SOCKET_CONNECTED); 1122 + if (rc) 1123 + goto err_wait_lcredit; 1124 + 1125 + if (sc->status != SMBDIRECT_SOCKET_CONNECTED) { 1126 + log_outgoing(ERR, "disconnected not sending on wait_credit\n"); 1127 + rc = -EAGAIN; 1128 + goto err_wait_lcredit; 1129 + } 1130 + if (unlikely(atomic_dec_return(&sc->send_io.lcredits.count) < 0)) { 1131 + atomic_inc(&sc->send_io.lcredits.count); 1132 + goto wait_lcredit; 1133 + } 1134 + 1122 1135 wait_credit: 1123 1136 /* Wait for send credits. A SMBD packet needs one credit */ 1124 1137 rc = wait_event_interruptible(sc->send_io.credits.wait_queue, ··· 1153 1130 if (unlikely(atomic_dec_return(&sc->send_io.credits.count) < 0)) { 1154 1131 atomic_inc(&sc->send_io.credits.count); 1155 1132 goto wait_credit; 1156 - } 1157 - 1158 - wait_send_queue: 1159 - wait_event(sc->send_io.pending.dec_wait_queue, 1160 - atomic_read(&sc->send_io.pending.count) < sp->send_credit_target || 1161 - sc->status != SMBDIRECT_SOCKET_CONNECTED); 1162 - 1163 - if (sc->status != SMBDIRECT_SOCKET_CONNECTED) { 1164 - log_outgoing(ERR, "disconnected not sending on wait_send_queue\n"); 1165 - rc = -EAGAIN; 1166 - goto err_wait_send_queue; 1167 - } 1168 - 1169 - if (unlikely(atomic_inc_return(&sc->send_io.pending.count) > 1170 - sp->send_credit_target)) { 1171 - atomic_dec(&sc->send_io.pending.count); 1172 - goto wait_send_queue; 1173 1133 } 1174 1134 1175 1135 request = mempool_alloc(sc->send_io.mem.pool, GFP_KERNEL); ··· 1235 1229 le32_to_cpu(packet->data_length), 1236 1230 le32_to_cpu(packet->remaining_data_length)); 1237 1231 1232 + /* 1233 + * Now that we got a local and a remote credit 1234 + * we add us as pending 1235 + */ 1236 + atomic_inc(&sc->send_io.pending.count); 1237 + 1238 1238 rc = smbd_post_send(sc, request); 1239 1239 if (!rc) 1240 1240 return 0; 1241 + 1242 + if (atomic_dec_and_test(&sc->send_io.pending.count)) 1243 + wake_up(&sc->send_io.pending.zero_wait_queue); 1244 + 1245 + wake_up(&sc->send_io.pending.dec_wait_queue); 1241 1246 1242 1247 err_dma: 1243 1248 for (i = 0; i < request->num_sge; i++) ··· 1263 1246 atomic_sub(new_credits, &sc->recv_io.credits.count); 1264 1247 1265 1248 err_alloc: 1266 - if (atomic_dec_and_test(&sc->send_io.pending.count)) 1267 - wake_up(&sc->send_io.pending.zero_wait_queue); 1268 - 1269 - err_wait_send_queue: 1270 - /* roll back send credits and pending */ 1271 1249 atomic_inc(&sc->send_io.credits.count); 1250 + wake_up(&sc->send_io.credits.wait_queue); 1272 1251 1273 1252 err_wait_credit: 1253 + atomic_inc(&sc->send_io.lcredits.count); 1254 + wake_up(&sc->send_io.lcredits.wait_queue); 1255 + 1256 + err_wait_lcredit: 1274 1257 return rc; 1275 1258 } 1276 1259

+12 -1

fs/smb/common/smbdirect/smbdirect_socket.h

··· 142 142 } mem; 143 143 144 144 /* 145 - * The credit state for the send side 145 + * The local credit state for ib_post_send() 146 + */ 147 + struct { 148 + atomic_t count; 149 + wait_queue_head_t wait_queue; 150 + } lcredits; 151 + 152 + /* 153 + * The remote credit state for the send side 146 154 */ 147 155 struct { 148 156 atomic_t count; ··· 344 336 disable_work_sync(&sc->idle.immediate_work); 345 337 INIT_DELAYED_WORK(&sc->idle.timer_work, __smbdirect_socket_disabled_work); 346 338 disable_delayed_work_sync(&sc->idle.timer_work); 339 + 340 + atomic_set(&sc->send_io.lcredits.count, 0); 341 + init_waitqueue_head(&sc->send_io.lcredits.wait_queue); 347 342 348 343 atomic_set(&sc->send_io.credits.count, 0); 349 344 init_waitqueue_head(&sc->send_io.credits.wait_queue);

+219 -125

fs/smb/server/transport_rdma.c

··· 219 219 * in order to notice the broken connection. 220 220 */ 221 221 wake_up_all(&sc->status_wait); 222 + wake_up_all(&sc->send_io.lcredits.wait_queue); 222 223 wake_up_all(&sc->send_io.credits.wait_queue); 223 224 wake_up_all(&sc->send_io.pending.zero_wait_queue); 224 225 wake_up_all(&sc->recv_io.reassembly.wait_queue); ··· 451 450 struct smbdirect_recv_io *recvmsg; 452 451 453 452 disable_work_sync(&sc->disconnect_work); 454 - if (sc->status < SMBDIRECT_SOCKET_DISCONNECTING) { 453 + if (sc->status < SMBDIRECT_SOCKET_DISCONNECTING) 455 454 smb_direct_disconnect_rdma_work(&sc->disconnect_work); 456 - wait_event_interruptible(sc->status_wait, 457 - sc->status == SMBDIRECT_SOCKET_DISCONNECTED); 458 - } 455 + if (sc->status < SMBDIRECT_SOCKET_DISCONNECTED) 456 + wait_event(sc->status_wait, sc->status == SMBDIRECT_SOCKET_DISCONNECTED); 459 457 460 458 /* 461 459 * Wake up all waiters in all wait queues ··· 471 471 472 472 if (sc->ib.qp) { 473 473 ib_drain_qp(sc->ib.qp); 474 - ib_mr_pool_destroy(sc->ib.qp, &sc->ib.qp->rdma_mrs); 475 474 sc->ib.qp = NULL; 476 475 rdma_destroy_qp(sc->rdma.cm_id); 477 476 } ··· 522 523 struct smbdirect_send_io *msg) 523 524 { 524 525 int i; 526 + 527 + /* 528 + * The list needs to be empty! 529 + * The caller should take care of it. 530 + */ 531 + WARN_ON_ONCE(!list_empty(&msg->sibling_list)); 525 532 526 533 if (msg->num_sge > 0) { 527 534 ib_dma_unmap_single(sc->ib.dev, ··· 914 909 915 910 static void send_done(struct ib_cq *cq, struct ib_wc *wc) 916 911 { 917 - struct smbdirect_send_io *sendmsg, *sibling; 912 + struct smbdirect_send_io *sendmsg, *sibling, *next; 918 913 struct smbdirect_socket *sc; 919 - struct list_head *pos, *prev, *end; 914 + int lcredits = 0; 920 915 921 916 sendmsg = container_of(wc->wr_cqe, struct smbdirect_send_io, cqe); 922 917 sc = sendmsg->socket; ··· 925 920 ib_wc_status_msg(wc->status), wc->status, 926 921 wc->opcode); 927 922 923 + /* 924 + * Free possible siblings and then the main send_io 925 + */ 926 + list_for_each_entry_safe(sibling, next, &sendmsg->sibling_list, sibling_list) { 927 + list_del_init(&sibling->sibling_list); 928 + smb_direct_free_sendmsg(sc, sibling); 929 + lcredits += 1; 930 + } 931 + /* Note this frees wc->wr_cqe, but not wc */ 932 + smb_direct_free_sendmsg(sc, sendmsg); 933 + lcredits += 1; 934 + 928 935 if (wc->status != IB_WC_SUCCESS || wc->opcode != IB_WC_SEND) { 929 936 pr_err("Send error. status='%s (%d)', opcode=%d\n", 930 937 ib_wc_status_msg(wc->status), wc->status, 931 938 wc->opcode); 932 939 smb_direct_disconnect_rdma_connection(sc); 940 + return; 933 941 } 942 + 943 + atomic_add(lcredits, &sc->send_io.lcredits.count); 944 + wake_up(&sc->send_io.lcredits.wait_queue); 934 945 935 946 if (atomic_dec_and_test(&sc->send_io.pending.count)) 936 947 wake_up(&sc->send_io.pending.zero_wait_queue); 937 - 938 - /* iterate and free the list of messages in reverse. the list's head 939 - * is invalid. 940 - */ 941 - for (pos = &sendmsg->sibling_list, prev = pos->prev, end = sendmsg->sibling_list.next; 942 - prev != end; pos = prev, prev = prev->prev) { 943 - sibling = container_of(pos, struct smbdirect_send_io, sibling_list); 944 - smb_direct_free_sendmsg(sc, sibling); 945 - } 946 - 947 - sibling = container_of(pos, struct smbdirect_send_io, sibling_list); 948 - smb_direct_free_sendmsg(sc, sibling); 949 948 } 950 949 951 950 static int manage_credits_prior_sending(struct smbdirect_socket *sc) ··· 997 988 ret = ib_post_send(sc->ib.qp, wr, NULL); 998 989 if (ret) { 999 990 pr_err("failed to post send: %d\n", ret); 1000 - if (atomic_dec_and_test(&sc->send_io.pending.count)) 1001 - wake_up(&sc->send_io.pending.zero_wait_queue); 1002 991 smb_direct_disconnect_rdma_connection(sc); 1003 992 } 1004 993 return ret; ··· 1039 1032 last->wr.send_flags = IB_SEND_SIGNALED; 1040 1033 last->wr.wr_cqe = &last->cqe; 1041 1034 1035 + /* 1036 + * Remove last from send_ctx->msg_list 1037 + * and splice the rest of send_ctx->msg_list 1038 + * to last->sibling_list. 1039 + * 1040 + * send_ctx->msg_list is a valid empty list 1041 + * at the end. 1042 + */ 1043 + list_del_init(&last->sibling_list); 1044 + list_splice_tail_init(&send_ctx->msg_list, &last->sibling_list); 1045 + send_ctx->wr_cnt = 0; 1046 + 1042 1047 ret = smb_direct_post_send(sc, &first->wr); 1043 - if (!ret) { 1044 - smb_direct_send_ctx_init(send_ctx, 1045 - send_ctx->need_invalidate_rkey, 1046 - send_ctx->remote_key); 1047 - } else { 1048 - atomic_add(send_ctx->wr_cnt, &sc->send_io.credits.count); 1049 - wake_up(&sc->send_io.credits.wait_queue); 1050 - list_for_each_entry_safe(first, last, &send_ctx->msg_list, 1051 - sibling_list) { 1052 - smb_direct_free_sendmsg(sc, first); 1048 + if (ret) { 1049 + struct smbdirect_send_io *sibling, *next; 1050 + 1051 + list_for_each_entry_safe(sibling, next, &last->sibling_list, sibling_list) { 1052 + list_del_init(&sibling->sibling_list); 1053 + smb_direct_free_sendmsg(sc, sibling); 1053 1054 } 1055 + smb_direct_free_sendmsg(sc, last); 1054 1056 } 1057 + 1055 1058 return ret; 1056 1059 } 1057 1060 ··· 1085 1068 else if (ret < 0) 1086 1069 return ret; 1087 1070 } while (true); 1071 + } 1072 + 1073 + static int wait_for_send_lcredit(struct smbdirect_socket *sc, 1074 + struct smbdirect_send_batch *send_ctx) 1075 + { 1076 + if (send_ctx && (atomic_read(&sc->send_io.lcredits.count) <= 1)) { 1077 + int ret; 1078 + 1079 + ret = smb_direct_flush_send_list(sc, send_ctx, false); 1080 + if (ret) 1081 + return ret; 1082 + } 1083 + 1084 + return wait_for_credits(sc, 1085 + &sc->send_io.lcredits.wait_queue, 1086 + &sc->send_io.lcredits.count, 1087 + 1); 1088 1088 } 1089 1089 1090 1090 static int wait_for_send_credits(struct smbdirect_socket *sc, ··· 1291 1257 int data_length; 1292 1258 struct scatterlist sg[SMBDIRECT_SEND_IO_MAX_SGE - 1]; 1293 1259 1260 + ret = wait_for_send_lcredit(sc, send_ctx); 1261 + if (ret) 1262 + goto lcredit_failed; 1263 + 1294 1264 ret = wait_for_send_credits(sc, send_ctx); 1295 1265 if (ret) 1296 - return ret; 1266 + goto credit_failed; 1297 1267 1298 1268 data_length = 0; 1299 1269 for (i = 0; i < niov; i++) ··· 1305 1267 1306 1268 ret = smb_direct_create_header(sc, data_length, remaining_data_length, 1307 1269 &msg); 1308 - if (ret) { 1309 - atomic_inc(&sc->send_io.credits.count); 1310 - return ret; 1311 - } 1270 + if (ret) 1271 + goto header_failed; 1312 1272 1313 1273 for (i = 0; i < niov; i++) { 1314 1274 struct ib_sge *sge; ··· 1344 1308 return 0; 1345 1309 err: 1346 1310 smb_direct_free_sendmsg(sc, msg); 1311 + header_failed: 1347 1312 atomic_inc(&sc->send_io.credits.count); 1313 + credit_failed: 1314 + atomic_inc(&sc->send_io.lcredits.count); 1315 + lcredit_failed: 1348 1316 return ret; 1349 1317 } 1350 1318 ··· 1911 1871 return ret; 1912 1872 } 1913 1873 1914 - static unsigned int smb_direct_get_max_fr_pages(struct smbdirect_socket *sc) 1915 - { 1916 - return min_t(unsigned int, 1917 - sc->ib.dev->attrs.max_fast_reg_page_list_len, 1918 - 256); 1919 - } 1920 - 1921 - static int smb_direct_init_params(struct smbdirect_socket *sc, 1922 - struct ib_qp_cap *cap) 1874 + static int smb_direct_init_params(struct smbdirect_socket *sc) 1923 1875 { 1924 1876 struct smbdirect_socket_parameters *sp = &sc->parameters; 1925 - struct ib_device *device = sc->ib.dev; 1926 - int max_send_sges, max_rw_wrs, max_send_wrs; 1927 - unsigned int max_sge_per_wr, wrs_per_credit; 1877 + int max_send_sges; 1878 + unsigned int maxpages; 1928 1879 1929 1880 /* need 3 more sge. because a SMB_DIRECT header, SMB2 header, 1930 1881 * SMB2 response could be mapped. ··· 1926 1895 return -EINVAL; 1927 1896 } 1928 1897 1929 - /* Calculate the number of work requests for RDMA R/W. 1930 - * The maximum number of pages which can be registered 1931 - * with one Memory region can be transferred with one 1932 - * R/W credit. And at least 4 work requests for each credit 1933 - * are needed for MR registration, RDMA R/W, local & remote 1934 - * MR invalidation. 1935 - */ 1936 - sc->rw_io.credits.num_pages = smb_direct_get_max_fr_pages(sc); 1937 - sc->rw_io.credits.max = DIV_ROUND_UP(sp->max_read_write_size, 1938 - (sc->rw_io.credits.num_pages - 1) * 1939 - PAGE_SIZE); 1898 + atomic_set(&sc->send_io.lcredits.count, sp->send_credit_target); 1940 1899 1941 - max_sge_per_wr = min_t(unsigned int, device->attrs.max_send_sge, 1942 - device->attrs.max_sge_rd); 1943 - max_sge_per_wr = max_t(unsigned int, max_sge_per_wr, 1944 - max_send_sges); 1945 - wrs_per_credit = max_t(unsigned int, 4, 1946 - DIV_ROUND_UP(sc->rw_io.credits.num_pages, 1947 - max_sge_per_wr) + 1); 1948 - max_rw_wrs = sc->rw_io.credits.max * wrs_per_credit; 1949 - 1950 - max_send_wrs = sp->send_credit_target + max_rw_wrs; 1951 - if (max_send_wrs > device->attrs.max_cqe || 1952 - max_send_wrs > device->attrs.max_qp_wr) { 1953 - pr_err("consider lowering send_credit_target = %d\n", 1954 - sp->send_credit_target); 1955 - pr_err("Possible CQE overrun, device reporting max_cqe %d max_qp_wr %d\n", 1956 - device->attrs.max_cqe, device->attrs.max_qp_wr); 1957 - return -EINVAL; 1958 - } 1959 - 1960 - if (sp->recv_credit_max > device->attrs.max_cqe || 1961 - sp->recv_credit_max > device->attrs.max_qp_wr) { 1962 - pr_err("consider lowering receive_credit_max = %d\n", 1963 - sp->recv_credit_max); 1964 - pr_err("Possible CQE overrun, device reporting max_cpe %d max_qp_wr %d\n", 1965 - device->attrs.max_cqe, device->attrs.max_qp_wr); 1966 - return -EINVAL; 1967 - } 1968 - 1969 - if (device->attrs.max_send_sge < SMBDIRECT_SEND_IO_MAX_SGE) { 1970 - pr_err("warning: device max_send_sge = %d too small\n", 1971 - device->attrs.max_send_sge); 1972 - return -EINVAL; 1973 - } 1974 - if (device->attrs.max_recv_sge < SMBDIRECT_RECV_IO_MAX_SGE) { 1975 - pr_err("warning: device max_recv_sge = %d too small\n", 1976 - device->attrs.max_recv_sge); 1977 - return -EINVAL; 1978 - } 1900 + maxpages = DIV_ROUND_UP(sp->max_read_write_size, PAGE_SIZE); 1901 + sc->rw_io.credits.max = rdma_rw_mr_factor(sc->ib.dev, 1902 + sc->rdma.cm_id->port_num, 1903 + maxpages); 1904 + sc->rw_io.credits.num_pages = DIV_ROUND_UP(maxpages, sc->rw_io.credits.max); 1905 + /* add one extra in order to handle unaligned pages */ 1906 + sc->rw_io.credits.max += 1; 1979 1907 1980 1908 sc->recv_io.credits.target = 1; 1981 1909 1982 1910 atomic_set(&sc->rw_io.credits.count, sc->rw_io.credits.max); 1983 1911 1984 - cap->max_send_wr = max_send_wrs; 1985 - cap->max_recv_wr = sp->recv_credit_max; 1986 - cap->max_send_sge = SMBDIRECT_SEND_IO_MAX_SGE; 1987 - cap->max_recv_sge = SMBDIRECT_RECV_IO_MAX_SGE; 1988 - cap->max_inline_data = 0; 1989 - cap->max_rdma_ctxs = sc->rw_io.credits.max; 1990 1912 return 0; 1991 1913 } 1992 1914 ··· 2013 2029 return -ENOMEM; 2014 2030 } 2015 2031 2016 - static int smb_direct_create_qpair(struct smbdirect_socket *sc, 2017 - struct ib_qp_cap *cap) 2032 + static u32 smb_direct_rdma_rw_send_wrs(struct ib_device *dev, const struct ib_qp_init_attr *attr) 2033 + { 2034 + /* 2035 + * This could be split out of rdma_rw_init_qp() 2036 + * and be a helper function next to rdma_rw_mr_factor() 2037 + * 2038 + * We can't check unlikely(rdma_rw_force_mr) here, 2039 + * but that is most likely 0 anyway. 2040 + */ 2041 + u32 factor; 2042 + 2043 + WARN_ON_ONCE(attr->port_num == 0); 2044 + 2045 + /* 2046 + * Each context needs at least one RDMA READ or WRITE WR. 2047 + * 2048 + * For some hardware we might need more, eventually we should ask the 2049 + * HCA driver for a multiplier here. 2050 + */ 2051 + factor = 1; 2052 + 2053 + /* 2054 + * If the device needs MRs to perform RDMA READ or WRITE operations, 2055 + * we'll need two additional MRs for the registrations and the 2056 + * invalidation. 2057 + */ 2058 + if (rdma_protocol_iwarp(dev, attr->port_num) || dev->attrs.max_sgl_rd) 2059 + factor += 2; /* inv + reg */ 2060 + 2061 + return factor * attr->cap.max_rdma_ctxs; 2062 + } 2063 + 2064 + static int smb_direct_create_qpair(struct smbdirect_socket *sc) 2018 2065 { 2019 2066 struct smbdirect_socket_parameters *sp = &sc->parameters; 2020 2067 int ret; 2068 + struct ib_qp_cap qp_cap; 2021 2069 struct ib_qp_init_attr qp_attr; 2022 - int pages_per_rw; 2070 + u32 max_send_wr; 2071 + u32 rdma_send_wr; 2072 + 2073 + /* 2074 + * Note that {rdma,ib}_create_qp() will call 2075 + * rdma_rw_init_qp() if cap->max_rdma_ctxs is not 0. 2076 + * It will adjust cap->max_send_wr to the required 2077 + * number of additional WRs for the RDMA RW operations. 2078 + * It will cap cap->max_send_wr to the device limit. 2079 + * 2080 + * +1 for ib_drain_qp 2081 + */ 2082 + qp_cap.max_send_wr = sp->send_credit_target + 1; 2083 + qp_cap.max_recv_wr = sp->recv_credit_max + 1; 2084 + qp_cap.max_send_sge = SMBDIRECT_SEND_IO_MAX_SGE; 2085 + qp_cap.max_recv_sge = SMBDIRECT_RECV_IO_MAX_SGE; 2086 + qp_cap.max_inline_data = 0; 2087 + qp_cap.max_rdma_ctxs = sc->rw_io.credits.max; 2088 + 2089 + /* 2090 + * Find out the number of max_send_wr 2091 + * after rdma_rw_init_qp() adjusted it. 2092 + * 2093 + * We only do it on a temporary variable, 2094 + * as rdma_create_qp() will trigger 2095 + * rdma_rw_init_qp() again. 2096 + */ 2097 + memset(&qp_attr, 0, sizeof(qp_attr)); 2098 + qp_attr.cap = qp_cap; 2099 + qp_attr.port_num = sc->rdma.cm_id->port_num; 2100 + rdma_send_wr = smb_direct_rdma_rw_send_wrs(sc->ib.dev, &qp_attr); 2101 + max_send_wr = qp_cap.max_send_wr + rdma_send_wr; 2102 + 2103 + if (qp_cap.max_send_wr > sc->ib.dev->attrs.max_cqe || 2104 + qp_cap.max_send_wr > sc->ib.dev->attrs.max_qp_wr) { 2105 + pr_err("Possible CQE overrun: max_send_wr %d\n", 2106 + qp_cap.max_send_wr); 2107 + pr_err("device %.*s reporting max_cqe %d max_qp_wr %d\n", 2108 + IB_DEVICE_NAME_MAX, 2109 + sc->ib.dev->name, 2110 + sc->ib.dev->attrs.max_cqe, 2111 + sc->ib.dev->attrs.max_qp_wr); 2112 + pr_err("consider lowering send_credit_target = %d\n", 2113 + sp->send_credit_target); 2114 + return -EINVAL; 2115 + } 2116 + 2117 + if (qp_cap.max_rdma_ctxs && 2118 + (max_send_wr >= sc->ib.dev->attrs.max_cqe || 2119 + max_send_wr >= sc->ib.dev->attrs.max_qp_wr)) { 2120 + pr_err("Possible CQE overrun: rdma_send_wr %d + max_send_wr %d = %d\n", 2121 + rdma_send_wr, qp_cap.max_send_wr, max_send_wr); 2122 + pr_err("device %.*s reporting max_cqe %d max_qp_wr %d\n", 2123 + IB_DEVICE_NAME_MAX, 2124 + sc->ib.dev->name, 2125 + sc->ib.dev->attrs.max_cqe, 2126 + sc->ib.dev->attrs.max_qp_wr); 2127 + pr_err("consider lowering send_credit_target = %d, max_rdma_ctxs = %d\n", 2128 + sp->send_credit_target, qp_cap.max_rdma_ctxs); 2129 + return -EINVAL; 2130 + } 2131 + 2132 + if (qp_cap.max_recv_wr > sc->ib.dev->attrs.max_cqe || 2133 + qp_cap.max_recv_wr > sc->ib.dev->attrs.max_qp_wr) { 2134 + pr_err("Possible CQE overrun: max_recv_wr %d\n", 2135 + qp_cap.max_recv_wr); 2136 + pr_err("device %.*s reporting max_cqe %d max_qp_wr %d\n", 2137 + IB_DEVICE_NAME_MAX, 2138 + sc->ib.dev->name, 2139 + sc->ib.dev->attrs.max_cqe, 2140 + sc->ib.dev->attrs.max_qp_wr); 2141 + pr_err("consider lowering receive_credit_max = %d\n", 2142 + sp->recv_credit_max); 2143 + return -EINVAL; 2144 + } 2145 + 2146 + if (qp_cap.max_send_sge > sc->ib.dev->attrs.max_send_sge || 2147 + qp_cap.max_recv_sge > sc->ib.dev->attrs.max_recv_sge) { 2148 + pr_err("device %.*s max_send_sge/max_recv_sge = %d/%d too small\n", 2149 + IB_DEVICE_NAME_MAX, 2150 + sc->ib.dev->name, 2151 + sc->ib.dev->attrs.max_send_sge, 2152 + sc->ib.dev->attrs.max_recv_sge); 2153 + return -EINVAL; 2154 + } 2023 2155 2024 2156 sc->ib.pd = ib_alloc_pd(sc->ib.dev, 0); 2025 2157 if (IS_ERR(sc->ib.pd)) { ··· 2146 2046 } 2147 2047 2148 2048 sc->ib.send_cq = ib_alloc_cq_any(sc->ib.dev, sc, 2149 - sp->send_credit_target + 2150 - cap->max_rdma_ctxs, 2049 + max_send_wr, 2151 2050 IB_POLL_WORKQUEUE); 2152 2051 if (IS_ERR(sc->ib.send_cq)) { 2153 2052 pr_err("Can't create RDMA send CQ\n"); ··· 2156 2057 } 2157 2058 2158 2059 sc->ib.recv_cq = ib_alloc_cq_any(sc->ib.dev, sc, 2159 - sp->recv_credit_max, 2060 + qp_cap.max_recv_wr, 2160 2061 IB_POLL_WORKQUEUE); 2161 2062 if (IS_ERR(sc->ib.recv_cq)) { 2162 2063 pr_err("Can't create RDMA recv CQ\n"); ··· 2165 2066 goto err; 2166 2067 } 2167 2068 2069 + /* 2070 + * We reset completely here! 2071 + * As the above use was just temporary 2072 + * to calc max_send_wr and rdma_send_wr. 2073 + * 2074 + * rdma_create_qp() will trigger rdma_rw_init_qp() 2075 + * again if max_rdma_ctxs is not 0. 2076 + */ 2168 2077 memset(&qp_attr, 0, sizeof(qp_attr)); 2169 2078 qp_attr.event_handler = smb_direct_qpair_handler; 2170 2079 qp_attr.qp_context = sc; 2171 - qp_attr.cap = *cap; 2080 + qp_attr.cap = qp_cap; 2172 2081 qp_attr.sq_sig_type = IB_SIGNAL_REQ_WR; 2173 2082 qp_attr.qp_type = IB_QPT_RC; 2174 2083 qp_attr.send_cq = sc->ib.send_cq; ··· 2191 2084 2192 2085 sc->ib.qp = sc->rdma.cm_id->qp; 2193 2086 sc->rdma.cm_id->event_handler = smb_direct_cm_handler; 2194 - 2195 - pages_per_rw = DIV_ROUND_UP(sp->max_read_write_size, PAGE_SIZE) + 1; 2196 - if (pages_per_rw > sc->ib.dev->attrs.max_sgl_rd) { 2197 - ret = ib_mr_pool_init(sc->ib.qp, &sc->ib.qp->rdma_mrs, 2198 - sc->rw_io.credits.max, IB_MR_TYPE_MEM_REG, 2199 - sc->rw_io.credits.num_pages, 0); 2200 - if (ret) { 2201 - pr_err("failed to init mr pool count %zu pages %zu\n", 2202 - sc->rw_io.credits.max, sc->rw_io.credits.num_pages); 2203 - goto err; 2204 - } 2205 - } 2206 2087 2207 2088 return 0; 2208 2089 err: ··· 2278 2183 2279 2184 static int smb_direct_connect(struct smbdirect_socket *sc) 2280 2185 { 2281 - struct ib_qp_cap qp_cap; 2282 2186 int ret; 2283 2187 2284 - ret = smb_direct_init_params(sc, &qp_cap); 2188 + ret = smb_direct_init_params(sc); 2285 2189 if (ret) { 2286 2190 pr_err("Can't configure RDMA parameters\n"); 2287 2191 return ret; ··· 2292 2198 return ret; 2293 2199 } 2294 2200 2295 - ret = smb_direct_create_qpair(sc, &qp_cap); 2201 + ret = smb_direct_create_qpair(sc); 2296 2202 if (ret) { 2297 2203 pr_err("Can't accept RDMA client: %d\n", ret); 2298 2204 return ret;

Configure Feed

Configure Feed