Merge git://git.kernel.org/pub/scm/linux/kernel/git/nab/target-pending

+186 -107

drivers/infiniband/ulp/isert/ib_isert.c

··· 238 238 rx_sg->lkey = device->pd->local_dma_lkey; 239 239 } 240 240 241 - isert_conn->rx_desc_head = 0; 242 - 243 241 return 0; 244 242 245 243 dma_map_fail: ··· 632 634 isert_init_conn(struct isert_conn *isert_conn) 633 635 { 634 636 isert_conn->state = ISER_CONN_INIT; 635 - INIT_LIST_HEAD(&isert_conn->accept_node); 637 + INIT_LIST_HEAD(&isert_conn->node); 636 638 init_completion(&isert_conn->login_comp); 637 639 init_completion(&isert_conn->login_req_comp); 638 640 init_completion(&isert_conn->wait); ··· 760 762 ret = isert_rdma_post_recvl(isert_conn); 761 763 if (ret) 762 764 goto out_conn_dev; 763 - /* 764 - * Obtain the second reference now before isert_rdma_accept() to 765 - * ensure that any initiator generated REJECT CM event that occurs 766 - * asynchronously won't drop the last reference until the error path 767 - * in iscsi_target_login_sess_out() does it's ->iscsit_free_conn() -> 768 - * isert_free_conn() -> isert_put_conn() -> kref_put(). 769 - */ 770 - if (!kref_get_unless_zero(&isert_conn->kref)) { 771 - isert_warn("conn %p connect_release is running\n", isert_conn); 772 - goto out_conn_dev; 773 - } 774 765 775 766 ret = isert_rdma_accept(isert_conn); 776 767 if (ret) 777 768 goto out_conn_dev; 778 769 779 - mutex_lock(&isert_np->np_accept_mutex); 780 - list_add_tail(&isert_conn->accept_node, &isert_np->np_accept_list); 781 - mutex_unlock(&isert_np->np_accept_mutex); 770 + mutex_lock(&isert_np->mutex); 771 + list_add_tail(&isert_conn->node, &isert_np->accepted); 772 + mutex_unlock(&isert_np->mutex); 782 773 783 - isert_info("np %p: Allow accept_np to continue\n", np); 784 - up(&isert_np->np_sem); 785 774 return 0; 786 775 787 776 out_conn_dev: ··· 816 831 isert_connected_handler(struct rdma_cm_id *cma_id) 817 832 { 818 833 struct isert_conn *isert_conn = cma_id->qp->qp_context; 834 + struct isert_np *isert_np = cma_id->context; 819 835 820 836 isert_info("conn %p\n", isert_conn); 821 837 822 838 mutex_lock(&isert_conn->mutex); 823 - if (isert_conn->state != ISER_CONN_FULL_FEATURE) 824 - isert_conn->state = ISER_CONN_UP; 839 + isert_conn->state = ISER_CONN_UP; 840 + kref_get(&isert_conn->kref); 825 841 mutex_unlock(&isert_conn->mutex); 842 + 843 + mutex_lock(&isert_np->mutex); 844 + list_move_tail(&isert_conn->node, &isert_np->pending); 845 + mutex_unlock(&isert_np->mutex); 846 + 847 + isert_info("np %p: Allow accept_np to continue\n", isert_np); 848 + up(&isert_np->sem); 826 849 } 827 850 828 851 static void ··· 896 903 897 904 switch (event) { 898 905 case RDMA_CM_EVENT_DEVICE_REMOVAL: 899 - isert_np->np_cm_id = NULL; 906 + isert_np->cm_id = NULL; 900 907 break; 901 908 case RDMA_CM_EVENT_ADDR_CHANGE: 902 - isert_np->np_cm_id = isert_setup_id(isert_np); 903 - if (IS_ERR(isert_np->np_cm_id)) { 909 + isert_np->cm_id = isert_setup_id(isert_np); 910 + if (IS_ERR(isert_np->cm_id)) { 904 911 isert_err("isert np %p setup id failed: %ld\n", 905 - isert_np, PTR_ERR(isert_np->np_cm_id)); 906 - isert_np->np_cm_id = NULL; 912 + isert_np, PTR_ERR(isert_np->cm_id)); 913 + isert_np->cm_id = NULL; 907 914 } 908 915 break; 909 916 default: ··· 922 929 struct isert_conn *isert_conn; 923 930 bool terminating = false; 924 931 925 - if (isert_np->np_cm_id == cma_id) 932 + if (isert_np->cm_id == cma_id) 926 933 return isert_np_cma_handler(cma_id->context, event); 927 934 928 935 isert_conn = cma_id->qp->qp_context; ··· 938 945 if (terminating) 939 946 goto out; 940 947 941 - mutex_lock(&isert_np->np_accept_mutex); 942 - if (!list_empty(&isert_conn->accept_node)) { 943 - list_del_init(&isert_conn->accept_node); 948 + mutex_lock(&isert_np->mutex); 949 + if (!list_empty(&isert_conn->node)) { 950 + list_del_init(&isert_conn->node); 944 951 isert_put_conn(isert_conn); 945 952 queue_work(isert_release_wq, &isert_conn->release_work); 946 953 } 947 - mutex_unlock(&isert_np->np_accept_mutex); 954 + mutex_unlock(&isert_np->mutex); 948 955 949 956 out: 950 957 return 0; ··· 955 962 { 956 963 struct isert_conn *isert_conn = cma_id->qp->qp_context; 957 964 965 + list_del_init(&isert_conn->node); 958 966 isert_conn->cm_id = NULL; 959 967 isert_put_conn(isert_conn); 960 968 ··· 1000 1006 } 1001 1007 1002 1008 static int 1003 - isert_post_recv(struct isert_conn *isert_conn, u32 count) 1009 + isert_post_recvm(struct isert_conn *isert_conn, u32 count) 1004 1010 { 1005 1011 struct ib_recv_wr *rx_wr, *rx_wr_failed; 1006 1012 int i, ret; 1007 - unsigned int rx_head = isert_conn->rx_desc_head; 1008 1013 struct iser_rx_desc *rx_desc; 1009 1014 1010 1015 for (rx_wr = isert_conn->rx_wr, i = 0; i < count; i++, rx_wr++) { 1011 - rx_desc = &isert_conn->rx_descs[rx_head]; 1012 - rx_wr->wr_id = (uintptr_t)rx_desc; 1013 - rx_wr->sg_list = &rx_desc->rx_sg; 1014 - rx_wr->num_sge = 1; 1015 - rx_wr->next = rx_wr + 1; 1016 - rx_head = (rx_head + 1) & (ISERT_QP_MAX_RECV_DTOS - 1); 1016 + rx_desc = &isert_conn->rx_descs[i]; 1017 + rx_wr->wr_id = (uintptr_t)rx_desc; 1018 + rx_wr->sg_list = &rx_desc->rx_sg; 1019 + rx_wr->num_sge = 1; 1020 + rx_wr->next = rx_wr + 1; 1017 1021 } 1018 - 1019 1022 rx_wr--; 1020 1023 rx_wr->next = NULL; /* mark end of work requests list */ 1021 1024 1022 1025 isert_conn->post_recv_buf_count += count; 1023 1026 ret = ib_post_recv(isert_conn->qp, isert_conn->rx_wr, 1024 - &rx_wr_failed); 1027 + &rx_wr_failed); 1025 1028 if (ret) { 1026 1029 isert_err("ib_post_recv() failed with ret: %d\n", ret); 1027 1030 isert_conn->post_recv_buf_count -= count; 1028 - } else { 1029 - isert_dbg("Posted %d RX buffers\n", count); 1030 - isert_conn->rx_desc_head = rx_head; 1031 1031 } 1032 + 1033 + return ret; 1034 + } 1035 + 1036 + static int 1037 + isert_post_recv(struct isert_conn *isert_conn, struct iser_rx_desc *rx_desc) 1038 + { 1039 + struct ib_recv_wr *rx_wr_failed, rx_wr; 1040 + int ret; 1041 + 1042 + rx_wr.wr_id = (uintptr_t)rx_desc; 1043 + rx_wr.sg_list = &rx_desc->rx_sg; 1044 + rx_wr.num_sge = 1; 1045 + rx_wr.next = NULL; 1046 + 1047 + isert_conn->post_recv_buf_count++; 1048 + ret = ib_post_recv(isert_conn->qp, &rx_wr, &rx_wr_failed); 1049 + if (ret) { 1050 + isert_err("ib_post_recv() failed with ret: %d\n", ret); 1051 + isert_conn->post_recv_buf_count--; 1052 + } 1053 + 1032 1054 return ret; 1033 1055 } 1034 1056 ··· 1215 1205 if (ret) 1216 1206 return ret; 1217 1207 1218 - ret = isert_post_recv(isert_conn, ISERT_MIN_POSTED_RX); 1208 + ret = isert_post_recvm(isert_conn, 1209 + ISERT_QP_MAX_RECV_DTOS); 1219 1210 if (ret) 1220 1211 return ret; 1221 1212 ··· 1289 1278 } 1290 1279 1291 1280 static struct iscsi_cmd 1292 - *isert_allocate_cmd(struct iscsi_conn *conn) 1281 + *isert_allocate_cmd(struct iscsi_conn *conn, struct iser_rx_desc *rx_desc) 1293 1282 { 1294 1283 struct isert_conn *isert_conn = conn->context; 1295 1284 struct isert_cmd *isert_cmd; ··· 1303 1292 isert_cmd = iscsit_priv_cmd(cmd); 1304 1293 isert_cmd->conn = isert_conn; 1305 1294 isert_cmd->iscsi_cmd = cmd; 1295 + isert_cmd->rx_desc = rx_desc; 1306 1296 1307 1297 return cmd; 1308 1298 } ··· 1315 1303 { 1316 1304 struct iscsi_conn *conn = isert_conn->conn; 1317 1305 struct iscsi_scsi_req *hdr = (struct iscsi_scsi_req *)buf; 1318 - struct scatterlist *sg; 1319 1306 int imm_data, imm_data_len, unsol_data, sg_nents, rc; 1320 1307 bool dump_payload = false; 1308 + unsigned int data_len; 1321 1309 1322 1310 rc = iscsit_setup_scsi_cmd(conn, cmd, buf); 1323 1311 if (rc < 0) ··· 1326 1314 imm_data = cmd->immediate_data; 1327 1315 imm_data_len = cmd->first_burst_len; 1328 1316 unsol_data = cmd->unsolicited_data; 1317 + data_len = cmd->se_cmd.data_length; 1329 1318 1319 + if (imm_data && imm_data_len == data_len) 1320 + cmd->se_cmd.se_cmd_flags |= SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC; 1330 1321 rc = iscsit_process_scsi_cmd(conn, cmd, hdr); 1331 1322 if (rc < 0) { 1332 1323 return 0; ··· 1341 1326 if (!imm_data) 1342 1327 return 0; 1343 1328 1344 - sg = &cmd->se_cmd.t_data_sg[0]; 1345 - sg_nents = max(1UL, DIV_ROUND_UP(imm_data_len, PAGE_SIZE)); 1346 - 1347 - isert_dbg("Copying Immediate SG: %p sg_nents: %u from %p imm_data_len: %d\n", 1348 - sg, sg_nents, &rx_desc->data[0], imm_data_len); 1349 - 1350 - sg_copy_from_buffer(sg, sg_nents, &rx_desc->data[0], imm_data_len); 1329 + if (imm_data_len != data_len) { 1330 + sg_nents = max(1UL, DIV_ROUND_UP(imm_data_len, PAGE_SIZE)); 1331 + sg_copy_from_buffer(cmd->se_cmd.t_data_sg, sg_nents, 1332 + &rx_desc->data[0], imm_data_len); 1333 + isert_dbg("Copy Immediate sg_nents: %u imm_data_len: %d\n", 1334 + sg_nents, imm_data_len); 1335 + } else { 1336 + sg_init_table(&isert_cmd->sg, 1); 1337 + cmd->se_cmd.t_data_sg = &isert_cmd->sg; 1338 + cmd->se_cmd.t_data_nents = 1; 1339 + sg_set_buf(&isert_cmd->sg, &rx_desc->data[0], imm_data_len); 1340 + isert_dbg("Transfer Immediate imm_data_len: %d\n", 1341 + imm_data_len); 1342 + } 1351 1343 1352 1344 cmd->write_data_done += imm_data_len; 1353 1345 ··· 1429 1407 if (rc < 0) 1430 1408 return rc; 1431 1409 1410 + /* 1411 + * multiple data-outs on the same command can arrive - 1412 + * so post the buffer before hand 1413 + */ 1414 + rc = isert_post_recv(isert_conn, rx_desc); 1415 + if (rc) { 1416 + isert_err("ib_post_recv failed with %d\n", rc); 1417 + return rc; 1418 + } 1432 1419 return 0; 1433 1420 } 1434 1421 ··· 1510 1479 1511 1480 switch (opcode) { 1512 1481 case ISCSI_OP_SCSI_CMD: 1513 - cmd = isert_allocate_cmd(conn); 1482 + cmd = isert_allocate_cmd(conn, rx_desc); 1514 1483 if (!cmd) 1515 1484 break; 1516 1485 ··· 1524 1493 rx_desc, (unsigned char *)hdr); 1525 1494 break; 1526 1495 case ISCSI_OP_NOOP_OUT: 1527 - cmd = isert_allocate_cmd(conn); 1496 + cmd = isert_allocate_cmd(conn, rx_desc); 1528 1497 if (!cmd) 1529 1498 break; 1530 1499 ··· 1537 1506 (unsigned char *)hdr); 1538 1507 break; 1539 1508 case ISCSI_OP_SCSI_TMFUNC: 1540 - cmd = isert_allocate_cmd(conn); 1509 + cmd = isert_allocate_cmd(conn, rx_desc); 1541 1510 if (!cmd) 1542 1511 break; 1543 1512 ··· 1545 1514 (unsigned char *)hdr); 1546 1515 break; 1547 1516 case ISCSI_OP_LOGOUT: 1548 - cmd = isert_allocate_cmd(conn); 1517 + cmd = isert_allocate_cmd(conn, rx_desc); 1549 1518 if (!cmd) 1550 1519 break; 1551 1520 1552 1521 ret = iscsit_handle_logout_cmd(conn, cmd, (unsigned char *)hdr); 1553 1522 break; 1554 1523 case ISCSI_OP_TEXT: 1555 - if (be32_to_cpu(hdr->ttt) != 0xFFFFFFFF) { 1524 + if (be32_to_cpu(hdr->ttt) != 0xFFFFFFFF) 1556 1525 cmd = iscsit_find_cmd_from_itt(conn, hdr->itt); 1557 - if (!cmd) 1558 - break; 1559 - } else { 1560 - cmd = isert_allocate_cmd(conn); 1561 - if (!cmd) 1562 - break; 1563 - } 1526 + else 1527 + cmd = isert_allocate_cmd(conn, rx_desc); 1528 + 1529 + if (!cmd) 1530 + break; 1564 1531 1565 1532 isert_cmd = iscsit_priv_cmd(cmd); 1566 1533 ret = isert_handle_text_cmd(isert_conn, isert_cmd, cmd, ··· 1618 1589 struct ib_device *ib_dev = isert_conn->cm_id->device; 1619 1590 struct iscsi_hdr *hdr; 1620 1591 u64 rx_dma; 1621 - int rx_buflen, outstanding; 1592 + int rx_buflen; 1622 1593 1623 1594 if ((char *)desc == isert_conn->login_req_buf) { 1624 1595 rx_dma = isert_conn->login_req_dma; ··· 1658 1629 DMA_FROM_DEVICE); 1659 1630 1660 1631 isert_conn->post_recv_buf_count--; 1661 - isert_dbg("Decremented post_recv_buf_count: %d\n", 1662 - isert_conn->post_recv_buf_count); 1663 - 1664 - if ((char *)desc == isert_conn->login_req_buf) 1665 - return; 1666 - 1667 - outstanding = isert_conn->post_recv_buf_count; 1668 - if (outstanding + ISERT_MIN_POSTED_RX <= ISERT_QP_MAX_RECV_DTOS) { 1669 - int err, count = min(ISERT_QP_MAX_RECV_DTOS - outstanding, 1670 - ISERT_MIN_POSTED_RX); 1671 - err = isert_post_recv(isert_conn, count); 1672 - if (err) { 1673 - isert_err("isert_post_recv() count: %d failed, %d\n", 1674 - count, err); 1675 - } 1676 - } 1677 1632 } 1678 1633 1679 1634 static int ··· 2168 2155 { 2169 2156 struct ib_send_wr *wr_failed; 2170 2157 int ret; 2158 + 2159 + ret = isert_post_recv(isert_conn, isert_cmd->rx_desc); 2160 + if (ret) { 2161 + isert_err("ib_post_recv failed with %d\n", ret); 2162 + return ret; 2163 + } 2171 2164 2172 2165 ret = ib_post_send(isert_conn->qp, &isert_cmd->tx_desc.send_wr, 2173 2166 &wr_failed); ··· 2969 2950 &isert_cmd->tx_desc.send_wr); 2970 2951 isert_cmd->rdma_wr.s_send_wr.next = &isert_cmd->tx_desc.send_wr; 2971 2952 wr->send_wr_num += 1; 2953 + 2954 + rc = isert_post_recv(isert_conn, isert_cmd->rx_desc); 2955 + if (rc) { 2956 + isert_err("ib_post_recv failed with %d\n", rc); 2957 + return rc; 2958 + } 2972 2959 } 2973 2960 2974 2961 rc = ib_post_send(isert_conn->qp, wr->send_wr, &wr_failed); ··· 3024 2999 static int 3025 3000 isert_immediate_queue(struct iscsi_conn *conn, struct iscsi_cmd *cmd, int state) 3026 3001 { 3027 - int ret; 3002 + struct isert_cmd *isert_cmd = iscsit_priv_cmd(cmd); 3003 + int ret = 0; 3028 3004 3029 3005 switch (state) { 3006 + case ISTATE_REMOVE: 3007 + spin_lock_bh(&conn->cmd_lock); 3008 + list_del_init(&cmd->i_conn_node); 3009 + spin_unlock_bh(&conn->cmd_lock); 3010 + isert_put_cmd(isert_cmd, true); 3011 + break; 3030 3012 case ISTATE_SEND_NOPIN_WANT_RESPONSE: 3031 3013 ret = isert_put_nopin(cmd, conn, false); 3032 3014 break; ··· 3138 3106 isert_err("Unable to allocate struct isert_np\n"); 3139 3107 return -ENOMEM; 3140 3108 } 3141 - sema_init(&isert_np->np_sem, 0); 3142 - mutex_init(&isert_np->np_accept_mutex); 3143 - INIT_LIST_HEAD(&isert_np->np_accept_list); 3144 - init_completion(&isert_np->np_login_comp); 3109 + sema_init(&isert_np->sem, 0); 3110 + mutex_init(&isert_np->mutex); 3111 + INIT_LIST_HEAD(&isert_np->accepted); 3112 + INIT_LIST_HEAD(&isert_np->pending); 3145 3113 isert_np->np = np; 3146 3114 3147 3115 /* ··· 3157 3125 goto out; 3158 3126 } 3159 3127 3160 - isert_np->np_cm_id = isert_lid; 3128 + isert_np->cm_id = isert_lid; 3161 3129 np->np_context = isert_np; 3162 3130 3163 3131 return 0; ··· 3246 3214 int ret; 3247 3215 3248 3216 accept_wait: 3249 - ret = down_interruptible(&isert_np->np_sem); 3217 + ret = down_interruptible(&isert_np->sem); 3250 3218 if (ret) 3251 3219 return -ENODEV; 3252 3220 ··· 3263 3231 } 3264 3232 spin_unlock_bh(&np->np_thread_lock); 3265 3233 3266 - mutex_lock(&isert_np->np_accept_mutex); 3267 - if (list_empty(&isert_np->np_accept_list)) { 3268 - mutex_unlock(&isert_np->np_accept_mutex); 3234 + mutex_lock(&isert_np->mutex); 3235 + if (list_empty(&isert_np->pending)) { 3236 + mutex_unlock(&isert_np->mutex); 3269 3237 goto accept_wait; 3270 3238 } 3271 - isert_conn = list_first_entry(&isert_np->np_accept_list, 3272 - struct isert_conn, accept_node); 3273 - list_del_init(&isert_conn->accept_node); 3274 - mutex_unlock(&isert_np->np_accept_mutex); 3239 + isert_conn = list_first_entry(&isert_np->pending, 3240 + struct isert_conn, node); 3241 + list_del_init(&isert_conn->node); 3242 + mutex_unlock(&isert_np->mutex); 3275 3243 3276 3244 conn->context = isert_conn; 3277 3245 isert_conn->conn = conn; ··· 3289 3257 struct isert_np *isert_np = np->np_context; 3290 3258 struct isert_conn *isert_conn, *n; 3291 3259 3292 - if (isert_np->np_cm_id) 3293 - rdma_destroy_id(isert_np->np_cm_id); 3260 + if (isert_np->cm_id) 3261 + rdma_destroy_id(isert_np->cm_id); 3294 3262 3295 3263 /* 3296 3264 * FIXME: At this point we don't have a good way to insure 3297 3265 * that at this point we don't have hanging connections that 3298 3266 * completed RDMA establishment but didn't start iscsi login 3299 3267 * process. So work-around this by cleaning up what ever piled 3300 - * up in np_accept_list. 3268 + * up in accepted and pending lists. 3301 3269 */ 3302 - mutex_lock(&isert_np->np_accept_mutex); 3303 - if (!list_empty(&isert_np->np_accept_list)) { 3304 - isert_info("Still have isert connections, cleaning up...\n"); 3270 + mutex_lock(&isert_np->mutex); 3271 + if (!list_empty(&isert_np->pending)) { 3272 + isert_info("Still have isert pending connections\n"); 3305 3273 list_for_each_entry_safe(isert_conn, n, 3306 - &isert_np->np_accept_list, 3307 - accept_node) { 3274 + &isert_np->pending, 3275 + node) { 3308 3276 isert_info("cleaning isert_conn %p state (%d)\n", 3309 3277 isert_conn, isert_conn->state); 3310 3278 isert_connect_release(isert_conn); 3311 3279 } 3312 3280 } 3313 - mutex_unlock(&isert_np->np_accept_mutex); 3281 + 3282 + if (!list_empty(&isert_np->accepted)) { 3283 + isert_info("Still have isert accepted connections\n"); 3284 + list_for_each_entry_safe(isert_conn, n, 3285 + &isert_np->accepted, 3286 + node) { 3287 + isert_info("cleaning isert_conn %p state (%d)\n", 3288 + isert_conn, isert_conn->state); 3289 + isert_connect_release(isert_conn); 3290 + } 3291 + } 3292 + mutex_unlock(&isert_np->mutex); 3314 3293 3315 3294 np->np_context = NULL; 3316 3295 kfree(isert_np); ··· 3388 3345 wait_for_completion(&isert_conn->wait_comp_err); 3389 3346 } 3390 3347 3348 + /** 3349 + * isert_put_unsol_pending_cmds() - Drop commands waiting for 3350 + * unsolicitate dataout 3351 + * @conn: iscsi connection 3352 + * 3353 + * We might still have commands that are waiting for unsolicited 3354 + * dataouts messages. We must put the extra reference on those 3355 + * before blocking on the target_wait_for_session_cmds 3356 + */ 3357 + static void 3358 + isert_put_unsol_pending_cmds(struct iscsi_conn *conn) 3359 + { 3360 + struct iscsi_cmd *cmd, *tmp; 3361 + static LIST_HEAD(drop_cmd_list); 3362 + 3363 + spin_lock_bh(&conn->cmd_lock); 3364 + list_for_each_entry_safe(cmd, tmp, &conn->conn_cmd_list, i_conn_node) { 3365 + if ((cmd->cmd_flags & ICF_NON_IMMEDIATE_UNSOLICITED_DATA) && 3366 + (cmd->write_data_done < conn->sess->sess_ops->FirstBurstLength) && 3367 + (cmd->write_data_done < cmd->se_cmd.data_length)) 3368 + list_move_tail(&cmd->i_conn_node, &drop_cmd_list); 3369 + } 3370 + spin_unlock_bh(&conn->cmd_lock); 3371 + 3372 + list_for_each_entry_safe(cmd, tmp, &drop_cmd_list, i_conn_node) { 3373 + list_del_init(&cmd->i_conn_node); 3374 + if (cmd->i_state != ISTATE_REMOVE) { 3375 + struct isert_cmd *isert_cmd = iscsit_priv_cmd(cmd); 3376 + 3377 + isert_info("conn %p dropping cmd %p\n", conn, cmd); 3378 + isert_put_cmd(isert_cmd, true); 3379 + } 3380 + } 3381 + } 3382 + 3391 3383 static void isert_wait_conn(struct iscsi_conn *conn) 3392 3384 { 3393 3385 struct isert_conn *isert_conn = conn->context; ··· 3441 3363 isert_conn_terminate(isert_conn); 3442 3364 mutex_unlock(&isert_conn->mutex); 3443 3365 3444 - isert_wait4cmds(conn); 3445 3366 isert_wait4flush(isert_conn); 3367 + isert_put_unsol_pending_cmds(conn); 3368 + isert_wait4cmds(conn); 3446 3369 isert_wait4logout(isert_conn); 3447 3370 3448 3371 queue_work(isert_release_wq, &isert_conn->release_work);

+9 -12

drivers/infiniband/ulp/isert/ib_isert.h

··· 113 113 }; 114 114 115 115 struct isert_rdma_wr { 116 - struct list_head wr_list; 117 116 struct isert_cmd *isert_cmd; 118 117 enum iser_ib_op_code iser_ib_op; 119 118 struct ib_sge *ib_sge; ··· 133 134 uint64_t write_va; 134 135 u64 pdu_buf_dma; 135 136 u32 pdu_buf_len; 136 - u32 read_va_off; 137 - u32 write_va_off; 138 - u32 rdma_wr_num; 139 137 struct isert_conn *conn; 140 138 struct iscsi_cmd *iscsi_cmd; 141 139 struct iser_tx_desc tx_desc; 140 + struct iser_rx_desc *rx_desc; 142 141 struct isert_rdma_wr rdma_wr; 143 142 struct work_struct comp_work; 143 + struct scatterlist sg; 144 144 }; 145 145 146 146 struct isert_device; ··· 157 159 u64 login_req_dma; 158 160 int login_req_len; 159 161 u64 login_rsp_dma; 160 - unsigned int rx_desc_head; 161 162 struct iser_rx_desc *rx_descs; 162 - struct ib_recv_wr rx_wr[ISERT_MIN_POSTED_RX]; 163 + struct ib_recv_wr rx_wr[ISERT_QP_MAX_RECV_DTOS]; 163 164 struct iscsi_conn *conn; 164 - struct list_head accept_node; 165 + struct list_head node; 165 166 struct completion login_comp; 166 167 struct completion login_req_comp; 167 168 struct iser_tx_desc login_tx_desc; ··· 219 222 220 223 struct isert_np { 221 224 struct iscsi_np *np; 222 - struct semaphore np_sem; 223 - struct rdma_cm_id *np_cm_id; 224 - struct mutex np_accept_mutex; 225 - struct list_head np_accept_list; 226 - struct completion np_login_comp; 225 + struct semaphore sem; 226 + struct rdma_cm_id *cm_id; 227 + struct mutex mutex; 228 + struct list_head accepted; 229 + struct list_head pending; 227 230 };

+3 -2

drivers/target/iscsi/iscsi_target_parameters.c

··· 407 407 TYPERANGE_UTF8, USE_INITIAL_ONLY); 408 408 if (!param) 409 409 goto out; 410 + 410 411 /* 411 412 * Extra parameters for ISER from RFC-5046 412 413 */ ··· 497 496 } else if (!strcmp(param->name, SESSIONTYPE)) { 498 497 SET_PSTATE_NEGOTIATE(param); 499 498 } else if (!strcmp(param->name, IFMARKER)) { 500 - SET_PSTATE_NEGOTIATE(param); 499 + SET_PSTATE_REJECT(param); 501 500 } else if (!strcmp(param->name, OFMARKER)) { 502 - SET_PSTATE_NEGOTIATE(param); 501 + SET_PSTATE_REJECT(param); 503 502 } else if (!strcmp(param->name, IFMARKINT)) { 504 503 SET_PSTATE_REJECT(param); 505 504 } else if (!strcmp(param->name, OFMARKINT)) {

+26 -19

drivers/target/target_core_device.c

··· 62 62 struct se_session *se_sess = se_cmd->se_sess; 63 63 struct se_node_acl *nacl = se_sess->se_node_acl; 64 64 struct se_dev_entry *deve; 65 + sense_reason_t ret = TCM_NO_SENSE; 65 66 66 67 rcu_read_lock(); 67 68 deve = target_nacl_find_deve(nacl, unpacked_lun); 68 69 if (deve) { 69 70 atomic_long_inc(&deve->total_cmds); 70 - 71 - if ((se_cmd->data_direction == DMA_TO_DEVICE) && 72 - (deve->lun_flags & TRANSPORT_LUNFLAGS_READ_ONLY)) { 73 - pr_err("TARGET_CORE[%s]: Detected WRITE_PROTECTED LUN" 74 - " Access for 0x%08llx\n", 75 - se_cmd->se_tfo->get_fabric_name(), 76 - unpacked_lun); 77 - rcu_read_unlock(); 78 - return TCM_WRITE_PROTECTED; 79 - } 80 71 81 72 if (se_cmd->data_direction == DMA_TO_DEVICE) 82 73 atomic_long_add(se_cmd->data_length, ··· 84 93 85 94 percpu_ref_get(&se_lun->lun_ref); 86 95 se_cmd->lun_ref_active = true; 96 + 97 + if ((se_cmd->data_direction == DMA_TO_DEVICE) && 98 + (deve->lun_flags & TRANSPORT_LUNFLAGS_READ_ONLY)) { 99 + pr_err("TARGET_CORE[%s]: Detected WRITE_PROTECTED LUN" 100 + " Access for 0x%08llx\n", 101 + se_cmd->se_tfo->get_fabric_name(), 102 + unpacked_lun); 103 + rcu_read_unlock(); 104 + ret = TCM_WRITE_PROTECTED; 105 + goto ref_dev; 106 + } 87 107 } 88 108 rcu_read_unlock(); 89 109 ··· 111 109 unpacked_lun); 112 110 return TCM_NON_EXISTENT_LUN; 113 111 } 114 - /* 115 - * Force WRITE PROTECT for virtual LUN 0 116 - */ 117 - if ((se_cmd->data_direction != DMA_FROM_DEVICE) && 118 - (se_cmd->data_direction != DMA_NONE)) 119 - return TCM_WRITE_PROTECTED; 120 112 121 113 se_lun = se_sess->se_tpg->tpg_virt_lun0; 122 114 se_cmd->se_lun = se_sess->se_tpg->tpg_virt_lun0; ··· 119 123 120 124 percpu_ref_get(&se_lun->lun_ref); 121 125 se_cmd->lun_ref_active = true; 126 + 127 + /* 128 + * Force WRITE PROTECT for virtual LUN 0 129 + */ 130 + if ((se_cmd->data_direction != DMA_FROM_DEVICE) && 131 + (se_cmd->data_direction != DMA_NONE)) { 132 + ret = TCM_WRITE_PROTECTED; 133 + goto ref_dev; 134 + } 122 135 } 123 136 /* 124 137 * RCU reference protected by percpu se_lun->lun_ref taken above that ··· 135 130 * pointer can be kfree_rcu() by the final se_lun->lun_group put via 136 131 * target_core_fabric_configfs.c:target_fabric_port_release 137 132 */ 133 + ref_dev: 138 134 se_cmd->se_dev = rcu_dereference_raw(se_lun->lun_se_dev); 139 135 atomic_long_inc(&se_cmd->se_dev->num_cmds); 140 136 ··· 146 140 atomic_long_add(se_cmd->data_length, 147 141 &se_cmd->se_dev->read_bytes); 148 142 149 - return 0; 143 + return ret; 150 144 } 151 145 EXPORT_SYMBOL(transport_lookup_cmd_lun); 152 146 ··· 433 427 434 428 hlist_del_rcu(&orig->link); 435 429 clear_bit(DEF_PR_REG_ACTIVE, &orig->deve_flags); 436 - rcu_assign_pointer(orig->se_lun, NULL); 437 - rcu_assign_pointer(orig->se_lun_acl, NULL); 438 430 orig->lun_flags = 0; 439 431 orig->creation_time = 0; 440 432 orig->attach_count--; ··· 442 438 */ 443 439 kref_put(&orig->pr_kref, target_pr_kref_release); 444 440 wait_for_completion(&orig->pr_comp); 441 + 442 + rcu_assign_pointer(orig->se_lun, NULL); 443 + rcu_assign_pointer(orig->se_lun_acl, NULL); 445 444 446 445 kfree_rcu(orig, rcu_head); 447 446

+1 -1

drivers/target/target_core_hba.c

··· 187 187 188 188 bool target_sense_desc_format(struct se_device *dev) 189 189 { 190 - return dev->transport->get_blocks(dev) > U32_MAX; 190 + return (dev) ? dev->transport->get_blocks(dev) > U32_MAX : false; 191 191 }

+2

drivers/target/target_core_iblock.c

··· 105 105 mode = FMODE_READ|FMODE_EXCL; 106 106 if (!ib_dev->ibd_readonly) 107 107 mode |= FMODE_WRITE; 108 + else 109 + dev->dev_flags |= DF_READ_ONLY; 108 110 109 111 bd = blkdev_get_by_path(ib_dev->ibd_udev_path, mode, ib_dev); 110 112 if (IS_ERR(bd)) {

+67 -24

drivers/target/target_core_pr.c

··· 618 618 struct se_device *dev, 619 619 struct se_node_acl *nacl, 620 620 struct se_lun *lun, 621 - struct se_dev_entry *deve, 621 + struct se_dev_entry *dest_deve, 622 622 u64 mapped_lun, 623 623 unsigned char *isid, 624 624 u64 sa_res_key, ··· 640 640 INIT_LIST_HEAD(&pr_reg->pr_reg_atp_mem_list); 641 641 atomic_set(&pr_reg->pr_res_holders, 0); 642 642 pr_reg->pr_reg_nacl = nacl; 643 - pr_reg->pr_reg_deve = deve; 643 + /* 644 + * For destination registrations for ALL_TG_PT=1 and SPEC_I_PT=1, 645 + * the se_dev_entry->pr_ref will have been already obtained by 646 + * core_get_se_deve_from_rtpi() or __core_scsi3_alloc_registration(). 647 + * 648 + * Otherwise, locate se_dev_entry now and obtain a reference until 649 + * registration completes in __core_scsi3_add_registration(). 650 + */ 651 + if (dest_deve) { 652 + pr_reg->pr_reg_deve = dest_deve; 653 + } else { 654 + rcu_read_lock(); 655 + pr_reg->pr_reg_deve = target_nacl_find_deve(nacl, mapped_lun); 656 + if (!pr_reg->pr_reg_deve) { 657 + rcu_read_unlock(); 658 + pr_err("Unable to locate PR deve %s mapped_lun: %llu\n", 659 + nacl->initiatorname, mapped_lun); 660 + kmem_cache_free(t10_pr_reg_cache, pr_reg); 661 + return NULL; 662 + } 663 + kref_get(&pr_reg->pr_reg_deve->pr_kref); 664 + rcu_read_unlock(); 665 + } 644 666 pr_reg->pr_res_mapped_lun = mapped_lun; 645 667 pr_reg->pr_aptpl_target_lun = lun->unpacked_lun; 646 668 pr_reg->tg_pt_sep_rtpi = lun->lun_rtpi; ··· 958 936 !(strcmp(pr_reg->pr_tport, t_port)) && 959 937 (pr_reg->pr_reg_tpgt == tpgt) && 960 938 (pr_reg->pr_aptpl_target_lun == target_lun)) { 939 + /* 940 + * Obtain the ->pr_reg_deve pointer + reference, that 941 + * is released by __core_scsi3_add_registration() below. 942 + */ 943 + rcu_read_lock(); 944 + pr_reg->pr_reg_deve = target_nacl_find_deve(nacl, mapped_lun); 945 + if (!pr_reg->pr_reg_deve) { 946 + pr_err("Unable to locate PR APTPL %s mapped_lun:" 947 + " %llu\n", nacl->initiatorname, mapped_lun); 948 + rcu_read_unlock(); 949 + continue; 950 + } 951 + kref_get(&pr_reg->pr_reg_deve->pr_kref); 952 + rcu_read_unlock(); 961 953 962 954 pr_reg->pr_reg_nacl = nacl; 963 955 pr_reg->tg_pt_sep_rtpi = lun->lun_rtpi; 964 - 965 956 list_del(&pr_reg->pr_reg_aptpl_list); 966 957 spin_unlock(&pr_tmpl->aptpl_reg_lock); 967 958 /* 968 959 * At this point all of the pointers in *pr_reg will 969 960 * be setup, so go ahead and add the registration. 970 961 */ 971 - 972 962 __core_scsi3_add_registration(dev, nacl, pr_reg, 0, 0); 973 963 /* 974 964 * If this registration is the reservation holder, ··· 1078 1044 1079 1045 __core_scsi3_dump_registration(tfo, dev, nacl, pr_reg, register_type); 1080 1046 spin_unlock(&pr_tmpl->registration_lock); 1081 - 1082 - rcu_read_lock(); 1083 - deve = pr_reg->pr_reg_deve; 1084 - if (deve) 1085 - set_bit(DEF_PR_REG_ACTIVE, &deve->deve_flags); 1086 - rcu_read_unlock(); 1087 - 1088 1047 /* 1089 1048 * Skip extra processing for ALL_TG_PT=0 or REGISTER_AND_MOVE. 1090 1049 */ 1091 1050 if (!pr_reg->pr_reg_all_tg_pt || register_move) 1092 - return; 1051 + goto out; 1093 1052 /* 1094 1053 * Walk pr_reg->pr_reg_atp_list and add registrations for ALL_TG_PT=1 1095 1054 * allocated in __core_scsi3_alloc_registration() ··· 1102 1075 __core_scsi3_dump_registration(tfo, dev, nacl_tmp, pr_reg_tmp, 1103 1076 register_type); 1104 1077 spin_unlock(&pr_tmpl->registration_lock); 1105 - 1078 + /* 1079 + * Drop configfs group dependency reference and deve->pr_kref 1080 + * obtained from __core_scsi3_alloc_registration() code. 1081 + */ 1106 1082 rcu_read_lock(); 1107 1083 deve = pr_reg_tmp->pr_reg_deve; 1108 - if (deve) 1084 + if (deve) { 1109 1085 set_bit(DEF_PR_REG_ACTIVE, &deve->deve_flags); 1086 + core_scsi3_lunacl_undepend_item(deve); 1087 + pr_reg_tmp->pr_reg_deve = NULL; 1088 + } 1110 1089 rcu_read_unlock(); 1111 - 1112 - /* 1113 - * Drop configfs group dependency reference from 1114 - * __core_scsi3_alloc_registration() 1115 - */ 1116 - core_scsi3_lunacl_undepend_item(pr_reg_tmp->pr_reg_deve); 1117 1090 } 1091 + out: 1092 + /* 1093 + * Drop deve->pr_kref obtained in __core_scsi3_do_alloc_registration() 1094 + */ 1095 + rcu_read_lock(); 1096 + deve = pr_reg->pr_reg_deve; 1097 + if (deve) { 1098 + set_bit(DEF_PR_REG_ACTIVE, &deve->deve_flags); 1099 + kref_put(&deve->pr_kref, target_pr_kref_release); 1100 + pr_reg->pr_reg_deve = NULL; 1101 + } 1102 + rcu_read_unlock(); 1118 1103 } 1119 1104 1120 1105 static int core_scsi3_alloc_registration( ··· 1824 1785 dest_node_acl->initiatorname, i_buf, (dest_se_deve) ? 1825 1786 dest_se_deve->mapped_lun : 0); 1826 1787 1827 - if (!dest_se_deve) 1788 + if (!dest_se_deve) { 1789 + kref_put(&local_pr_reg->pr_reg_deve->pr_kref, 1790 + target_pr_kref_release); 1828 1791 continue; 1829 - 1792 + } 1830 1793 core_scsi3_lunacl_undepend_item(dest_se_deve); 1831 1794 core_scsi3_nodeacl_undepend_item(dest_node_acl); 1832 1795 core_scsi3_tpg_undepend_item(dest_tpg); ··· 1864 1823 1865 1824 kmem_cache_free(t10_pr_reg_cache, dest_pr_reg); 1866 1825 1867 - if (!dest_se_deve) 1826 + if (!dest_se_deve) { 1827 + kref_put(&local_pr_reg->pr_reg_deve->pr_kref, 1828 + target_pr_kref_release); 1868 1829 continue; 1869 - 1830 + } 1870 1831 core_scsi3_lunacl_undepend_item(dest_se_deve); 1871 1832 core_scsi3_nodeacl_undepend_item(dest_node_acl); 1872 1833 core_scsi3_tpg_undepend_item(dest_tpg);

+4 -1

drivers/target/target_core_tpg.c

··· 668 668 list_add_tail(&lun->lun_dev_link, &dev->dev_sep_list); 669 669 spin_unlock(&dev->se_port_lock); 670 670 671 - lun->lun_access = lun_access; 671 + if (dev->dev_flags & DF_READ_ONLY) 672 + lun->lun_access = TRANSPORT_LUNFLAGS_READ_ONLY; 673 + else 674 + lun->lun_access = lun_access; 672 675 if (!(dev->se_hba->hba_flags & HBA_FLAGS_INTERNAL_USE)) 673 676 hlist_add_head_rcu(&lun->link, &tpg->tpg_lun_hlist); 674 677 mutex_unlock(&tpg->tpg_lun_mutex);

+1

include/target/target_core_base.h

··· 730 730 #define DF_EMULATED_VPD_UNIT_SERIAL 0x00000004 731 731 #define DF_USING_UDEV_PATH 0x00000008 732 732 #define DF_USING_ALIAS 0x00000010 733 + #define DF_READ_ONLY 0x00000020 733 734 /* Physical device queue depth */ 734 735 u32 queue_depth; 735 736 /* Used for SPC-2 reservations enforce of ISIDs */

Configure Feed

Configure Feed