Merge branch 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/nab/target-pending

+641 -191

drivers/infiniband/ulp/isert/ib_isert.c

··· 51 51 static int 52 52 isert_reg_rdma(struct iscsi_conn *conn, struct iscsi_cmd *cmd, 53 53 struct isert_rdma_wr *wr); 54 + static int 55 + isert_put_response(struct iscsi_conn *conn, struct iscsi_cmd *cmd); 54 56 55 57 static void 56 58 isert_qp_event_callback(struct ib_event *e, void *context) ··· 89 87 } 90 88 91 89 static int 92 - isert_conn_setup_qp(struct isert_conn *isert_conn, struct rdma_cm_id *cma_id) 90 + isert_conn_setup_qp(struct isert_conn *isert_conn, struct rdma_cm_id *cma_id, 91 + u8 protection) 93 92 { 94 93 struct isert_device *device = isert_conn->conn_device; 95 94 struct ib_qp_init_attr attr; ··· 122 119 attr.cap.max_recv_sge = 1; 123 120 attr.sq_sig_type = IB_SIGNAL_REQ_WR; 124 121 attr.qp_type = IB_QPT_RC; 122 + if (protection) 123 + attr.create_flags |= IB_QP_CREATE_SIGNATURE_EN; 125 124 126 125 pr_debug("isert_conn_setup_qp cma_id->device: %p\n", 127 126 cma_id->device); ··· 231 226 return ret; 232 227 233 228 /* asign function handlers */ 234 - if (dev_attr->device_cap_flags & IB_DEVICE_MEM_MGT_EXTENSIONS) { 229 + if (dev_attr->device_cap_flags & IB_DEVICE_MEM_MGT_EXTENSIONS && 230 + dev_attr->device_cap_flags & IB_DEVICE_SIGNATURE_HANDOVER) { 235 231 device->use_fastreg = 1; 236 232 device->reg_rdma_mem = isert_reg_rdma; 237 233 device->unreg_rdma_mem = isert_unreg_rdma; ··· 242 236 device->unreg_rdma_mem = isert_unmap_cmd; 243 237 } 244 238 239 + /* Check signature cap */ 240 + device->pi_capable = dev_attr->device_cap_flags & 241 + IB_DEVICE_SIGNATURE_HANDOVER ? true : false; 242 + 245 243 device->cqs_used = min_t(int, num_online_cpus(), 246 244 device->ib_device->num_comp_vectors); 247 245 device->cqs_used = min(ISERT_MAX_CQ, device->cqs_used); 248 246 pr_debug("Using %d CQs, device %s supports %d vectors support " 249 - "Fast registration %d\n", 247 + "Fast registration %d pi_capable %d\n", 250 248 device->cqs_used, device->ib_device->name, 251 - device->ib_device->num_comp_vectors, device->use_fastreg); 249 + device->ib_device->num_comp_vectors, device->use_fastreg, 250 + device->pi_capable); 252 251 device->cq_desc = kzalloc(sizeof(struct isert_cq_desc) * 253 252 device->cqs_used, GFP_KERNEL); 254 253 if (!device->cq_desc) { ··· 406 395 list_del(&fr_desc->list); 407 396 ib_free_fast_reg_page_list(fr_desc->data_frpl); 408 397 ib_dereg_mr(fr_desc->data_mr); 398 + if (fr_desc->pi_ctx) { 399 + ib_free_fast_reg_page_list(fr_desc->pi_ctx->prot_frpl); 400 + ib_dereg_mr(fr_desc->pi_ctx->prot_mr); 401 + ib_destroy_mr(fr_desc->pi_ctx->sig_mr); 402 + kfree(fr_desc->pi_ctx); 403 + } 409 404 kfree(fr_desc); 410 405 ++i; 411 406 } ··· 423 406 424 407 static int 425 408 isert_create_fr_desc(struct ib_device *ib_device, struct ib_pd *pd, 426 - struct fast_reg_descriptor *fr_desc) 409 + struct fast_reg_descriptor *fr_desc, u8 protection) 427 410 { 411 + int ret; 412 + 428 413 fr_desc->data_frpl = ib_alloc_fast_reg_page_list(ib_device, 429 414 ISCSI_ISER_SG_TABLESIZE); 430 415 if (IS_ERR(fr_desc->data_frpl)) { ··· 439 420 if (IS_ERR(fr_desc->data_mr)) { 440 421 pr_err("Failed to allocate data frmr err=%ld\n", 441 422 PTR_ERR(fr_desc->data_mr)); 442 - ib_free_fast_reg_page_list(fr_desc->data_frpl); 443 - return PTR_ERR(fr_desc->data_mr); 423 + ret = PTR_ERR(fr_desc->data_mr); 424 + goto err_data_frpl; 444 425 } 445 426 pr_debug("Create fr_desc %p page_list %p\n", 446 427 fr_desc, fr_desc->data_frpl->page_list); 428 + fr_desc->ind |= ISERT_DATA_KEY_VALID; 447 429 448 - fr_desc->valid = true; 430 + if (protection) { 431 + struct ib_mr_init_attr mr_init_attr = {0}; 432 + struct pi_context *pi_ctx; 433 + 434 + fr_desc->pi_ctx = kzalloc(sizeof(*fr_desc->pi_ctx), GFP_KERNEL); 435 + if (!fr_desc->pi_ctx) { 436 + pr_err("Failed to allocate pi context\n"); 437 + ret = -ENOMEM; 438 + goto err_data_mr; 439 + } 440 + pi_ctx = fr_desc->pi_ctx; 441 + 442 + pi_ctx->prot_frpl = ib_alloc_fast_reg_page_list(ib_device, 443 + ISCSI_ISER_SG_TABLESIZE); 444 + if (IS_ERR(pi_ctx->prot_frpl)) { 445 + pr_err("Failed to allocate prot frpl err=%ld\n", 446 + PTR_ERR(pi_ctx->prot_frpl)); 447 + ret = PTR_ERR(pi_ctx->prot_frpl); 448 + goto err_pi_ctx; 449 + } 450 + 451 + pi_ctx->prot_mr = ib_alloc_fast_reg_mr(pd, ISCSI_ISER_SG_TABLESIZE); 452 + if (IS_ERR(pi_ctx->prot_mr)) { 453 + pr_err("Failed to allocate prot frmr err=%ld\n", 454 + PTR_ERR(pi_ctx->prot_mr)); 455 + ret = PTR_ERR(pi_ctx->prot_mr); 456 + goto err_prot_frpl; 457 + } 458 + fr_desc->ind |= ISERT_PROT_KEY_VALID; 459 + 460 + mr_init_attr.max_reg_descriptors = 2; 461 + mr_init_attr.flags |= IB_MR_SIGNATURE_EN; 462 + pi_ctx->sig_mr = ib_create_mr(pd, &mr_init_attr); 463 + if (IS_ERR(pi_ctx->sig_mr)) { 464 + pr_err("Failed to allocate signature enabled mr err=%ld\n", 465 + PTR_ERR(pi_ctx->sig_mr)); 466 + ret = PTR_ERR(pi_ctx->sig_mr); 467 + goto err_prot_mr; 468 + } 469 + fr_desc->ind |= ISERT_SIG_KEY_VALID; 470 + } 471 + fr_desc->ind &= ~ISERT_PROTECTED; 449 472 450 473 return 0; 474 + err_prot_mr: 475 + ib_dereg_mr(fr_desc->pi_ctx->prot_mr); 476 + err_prot_frpl: 477 + ib_free_fast_reg_page_list(fr_desc->pi_ctx->prot_frpl); 478 + err_pi_ctx: 479 + kfree(fr_desc->pi_ctx); 480 + err_data_mr: 481 + ib_dereg_mr(fr_desc->data_mr); 482 + err_data_frpl: 483 + ib_free_fast_reg_page_list(fr_desc->data_frpl); 484 + 485 + return ret; 451 486 } 452 487 453 488 static int 454 - isert_conn_create_fastreg_pool(struct isert_conn *isert_conn) 489 + isert_conn_create_fastreg_pool(struct isert_conn *isert_conn, u8 pi_support) 455 490 { 456 491 struct fast_reg_descriptor *fr_desc; 457 492 struct isert_device *device = isert_conn->conn_device; 458 - int i, ret; 493 + struct se_session *se_sess = isert_conn->conn->sess->se_sess; 494 + struct se_node_acl *se_nacl = se_sess->se_node_acl; 495 + int i, ret, tag_num; 496 + /* 497 + * Setup the number of FRMRs based upon the number of tags 498 + * available to session in iscsi_target_locate_portal(). 499 + */ 500 + tag_num = max_t(u32, ISCSIT_MIN_TAGS, se_nacl->queue_depth); 501 + tag_num = (tag_num * 2) + ISCSIT_EXTRA_TAGS; 459 502 460 - INIT_LIST_HEAD(&isert_conn->conn_fr_pool); 461 503 isert_conn->conn_fr_pool_size = 0; 462 - for (i = 0; i < ISCSI_DEF_XMIT_CMDS_MAX; i++) { 504 + for (i = 0; i < tag_num; i++) { 463 505 fr_desc = kzalloc(sizeof(*fr_desc), GFP_KERNEL); 464 506 if (!fr_desc) { 465 507 pr_err("Failed to allocate fast_reg descriptor\n"); ··· 529 449 } 530 450 531 451 ret = isert_create_fr_desc(device->ib_device, 532 - isert_conn->conn_pd, fr_desc); 452 + isert_conn->conn_pd, fr_desc, 453 + pi_support); 533 454 if (ret) { 534 455 pr_err("Failed to create fastreg descriptor err=%d\n", 535 456 ret); ··· 561 480 struct isert_device *device; 562 481 struct ib_device *ib_dev = cma_id->device; 563 482 int ret = 0; 483 + u8 pi_support = np->tpg_np->tpg->tpg_attrib.t10_pi; 564 484 565 485 pr_debug("Entering isert_connect_request cma_id: %p, context: %p\n", 566 486 cma_id, cma_id->context); ··· 580 498 kref_get(&isert_conn->conn_kref); 581 499 mutex_init(&isert_conn->conn_mutex); 582 500 spin_lock_init(&isert_conn->conn_lock); 501 + INIT_LIST_HEAD(&isert_conn->conn_fr_pool); 583 502 584 503 cma_id->context = isert_conn; 585 504 isert_conn->conn_cm_id = cma_id; ··· 652 569 goto out_mr; 653 570 } 654 571 655 - if (device->use_fastreg) { 656 - ret = isert_conn_create_fastreg_pool(isert_conn); 657 - if (ret) { 658 - pr_err("Conn: %p failed to create fastreg pool\n", 659 - isert_conn); 660 - goto out_fastreg; 661 - } 572 + if (pi_support && !device->pi_capable) { 573 + pr_err("Protection information requested but not supported\n"); 574 + ret = -EINVAL; 575 + goto out_mr; 662 576 } 663 577 664 - ret = isert_conn_setup_qp(isert_conn, cma_id); 578 + ret = isert_conn_setup_qp(isert_conn, cma_id, pi_support); 665 579 if (ret) 666 580 goto out_conn_dev; 667 581 ··· 671 591 return 0; 672 592 673 593 out_conn_dev: 674 - if (device->use_fastreg) 675 - isert_conn_free_fastreg_pool(isert_conn); 676 - out_fastreg: 677 594 ib_dereg_mr(isert_conn->conn_mr); 678 595 out_mr: 679 596 ib_dealloc_pd(isert_conn->conn_pd); ··· 1044 967 } 1045 968 if (!login->login_failed) { 1046 969 if (login->login_complete) { 970 + if (isert_conn->conn_device->use_fastreg) { 971 + u8 pi_support = login->np->tpg_np->tpg->tpg_attrib.t10_pi; 972 + 973 + ret = isert_conn_create_fastreg_pool(isert_conn, 974 + pi_support); 975 + if (ret) { 976 + pr_err("Conn: %p failed to create" 977 + " fastreg pool\n", isert_conn); 978 + return ret; 979 + } 980 + } 981 + 1047 982 ret = isert_alloc_rx_descriptors(isert_conn); 1048 983 if (ret) 1049 984 return ret; ··· 1481 1392 } 1482 1393 } 1483 1394 1395 + static int 1396 + isert_map_data_buf(struct isert_conn *isert_conn, struct isert_cmd *isert_cmd, 1397 + struct scatterlist *sg, u32 nents, u32 length, u32 offset, 1398 + enum iser_ib_op_code op, struct isert_data_buf *data) 1399 + { 1400 + struct ib_device *ib_dev = isert_conn->conn_cm_id->device; 1401 + 1402 + data->dma_dir = op == ISER_IB_RDMA_WRITE ? 1403 + DMA_TO_DEVICE : DMA_FROM_DEVICE; 1404 + 1405 + data->len = length - offset; 1406 + data->offset = offset; 1407 + data->sg_off = data->offset / PAGE_SIZE; 1408 + 1409 + data->sg = &sg[data->sg_off]; 1410 + data->nents = min_t(unsigned int, nents - data->sg_off, 1411 + ISCSI_ISER_SG_TABLESIZE); 1412 + data->len = min_t(unsigned int, data->len, ISCSI_ISER_SG_TABLESIZE * 1413 + PAGE_SIZE); 1414 + 1415 + data->dma_nents = ib_dma_map_sg(ib_dev, data->sg, data->nents, 1416 + data->dma_dir); 1417 + if (unlikely(!data->dma_nents)) { 1418 + pr_err("Cmd: unable to dma map SGs %p\n", sg); 1419 + return -EINVAL; 1420 + } 1421 + 1422 + pr_debug("Mapped cmd: %p count: %u sg: %p sg_nents: %u rdma_len %d\n", 1423 + isert_cmd, data->dma_nents, data->sg, data->nents, data->len); 1424 + 1425 + return 0; 1426 + } 1427 + 1428 + static void 1429 + isert_unmap_data_buf(struct isert_conn *isert_conn, struct isert_data_buf *data) 1430 + { 1431 + struct ib_device *ib_dev = isert_conn->conn_cm_id->device; 1432 + 1433 + ib_dma_unmap_sg(ib_dev, data->sg, data->nents, data->dma_dir); 1434 + memset(data, 0, sizeof(*data)); 1435 + } 1436 + 1437 + 1438 + 1484 1439 static void 1485 1440 isert_unmap_cmd(struct isert_cmd *isert_cmd, struct isert_conn *isert_conn) 1486 1441 { 1487 1442 struct isert_rdma_wr *wr = &isert_cmd->rdma_wr; 1488 - struct ib_device *ib_dev = isert_conn->conn_cm_id->device; 1489 1443 1490 1444 pr_debug("isert_unmap_cmd: %p\n", isert_cmd); 1491 - if (wr->sge) { 1445 + 1446 + if (wr->data.sg) { 1492 1447 pr_debug("isert_unmap_cmd: %p unmap_sg op\n", isert_cmd); 1493 - ib_dma_unmap_sg(ib_dev, wr->sge, wr->num_sge, 1494 - (wr->iser_ib_op == ISER_IB_RDMA_WRITE) ? 1495 - DMA_TO_DEVICE : DMA_FROM_DEVICE); 1496 - wr->sge = NULL; 1448 + isert_unmap_data_buf(isert_conn, &wr->data); 1497 1449 } 1498 1450 1499 1451 if (wr->send_wr) { ··· 1554 1424 isert_unreg_rdma(struct isert_cmd *isert_cmd, struct isert_conn *isert_conn) 1555 1425 { 1556 1426 struct isert_rdma_wr *wr = &isert_cmd->rdma_wr; 1557 - struct ib_device *ib_dev = isert_conn->conn_cm_id->device; 1558 1427 LIST_HEAD(unmap_list); 1559 1428 1560 1429 pr_debug("unreg_fastreg_cmd: %p\n", isert_cmd); ··· 1561 1432 if (wr->fr_desc) { 1562 1433 pr_debug("unreg_fastreg_cmd: %p free fr_desc %p\n", 1563 1434 isert_cmd, wr->fr_desc); 1435 + if (wr->fr_desc->ind & ISERT_PROTECTED) { 1436 + isert_unmap_data_buf(isert_conn, &wr->prot); 1437 + wr->fr_desc->ind &= ~ISERT_PROTECTED; 1438 + } 1564 1439 spin_lock_bh(&isert_conn->conn_lock); 1565 1440 list_add_tail(&wr->fr_desc->list, &isert_conn->conn_fr_pool); 1566 1441 spin_unlock_bh(&isert_conn->conn_lock); 1567 1442 wr->fr_desc = NULL; 1568 1443 } 1569 1444 1570 - if (wr->sge) { 1445 + if (wr->data.sg) { 1571 1446 pr_debug("unreg_fastreg_cmd: %p unmap_sg op\n", isert_cmd); 1572 - ib_dma_unmap_sg(ib_dev, wr->sge, wr->num_sge, 1573 - (wr->iser_ib_op == ISER_IB_RDMA_WRITE) ? 1574 - DMA_TO_DEVICE : DMA_FROM_DEVICE); 1575 - wr->sge = NULL; 1447 + isert_unmap_data_buf(isert_conn, &wr->data); 1576 1448 } 1577 1449 1578 1450 wr->ib_sge = NULL; ··· 1581 1451 } 1582 1452 1583 1453 static void 1584 - isert_put_cmd(struct isert_cmd *isert_cmd) 1454 + isert_put_cmd(struct isert_cmd *isert_cmd, bool comp_err) 1585 1455 { 1586 1456 struct iscsi_cmd *cmd = isert_cmd->iscsi_cmd; 1587 1457 struct isert_conn *isert_conn = isert_cmd->conn; ··· 1597 1467 list_del_init(&cmd->i_conn_node); 1598 1468 spin_unlock_bh(&conn->cmd_lock); 1599 1469 1600 - if (cmd->data_direction == DMA_TO_DEVICE) 1470 + if (cmd->data_direction == DMA_TO_DEVICE) { 1601 1471 iscsit_stop_dataout_timer(cmd); 1472 + /* 1473 + * Check for special case during comp_err where 1474 + * WRITE_PENDING has been handed off from core, 1475 + * but requires an extra target_put_sess_cmd() 1476 + * before transport_generic_free_cmd() below. 1477 + */ 1478 + if (comp_err && 1479 + cmd->se_cmd.t_state == TRANSPORT_WRITE_PENDING) { 1480 + struct se_cmd *se_cmd = &cmd->se_cmd; 1481 + 1482 + target_put_sess_cmd(se_cmd->se_sess, se_cmd); 1483 + } 1484 + } 1602 1485 1603 1486 device->unreg_rdma_mem(isert_cmd, isert_conn); 1604 1487 transport_generic_free_cmd(&cmd->se_cmd, 0); ··· 1666 1523 1667 1524 static void 1668 1525 isert_completion_put(struct iser_tx_desc *tx_desc, struct isert_cmd *isert_cmd, 1669 - struct ib_device *ib_dev) 1526 + struct ib_device *ib_dev, bool comp_err) 1670 1527 { 1671 1528 if (isert_cmd->pdu_buf_dma != 0) { 1672 1529 pr_debug("Calling ib_dma_unmap_single for isert_cmd->pdu_buf_dma\n"); ··· 1676 1533 } 1677 1534 1678 1535 isert_unmap_tx_desc(tx_desc, ib_dev); 1679 - isert_put_cmd(isert_cmd); 1536 + isert_put_cmd(isert_cmd, comp_err); 1537 + } 1538 + 1539 + static int 1540 + isert_check_pi_status(struct se_cmd *se_cmd, struct ib_mr *sig_mr) 1541 + { 1542 + struct ib_mr_status mr_status; 1543 + int ret; 1544 + 1545 + ret = ib_check_mr_status(sig_mr, IB_MR_CHECK_SIG_STATUS, &mr_status); 1546 + if (ret) { 1547 + pr_err("ib_check_mr_status failed, ret %d\n", ret); 1548 + goto fail_mr_status; 1549 + } 1550 + 1551 + if (mr_status.fail_status & IB_MR_CHECK_SIG_STATUS) { 1552 + u64 sec_offset_err; 1553 + u32 block_size = se_cmd->se_dev->dev_attrib.block_size + 8; 1554 + 1555 + switch (mr_status.sig_err.err_type) { 1556 + case IB_SIG_BAD_GUARD: 1557 + se_cmd->pi_err = TCM_LOGICAL_BLOCK_GUARD_CHECK_FAILED; 1558 + break; 1559 + case IB_SIG_BAD_REFTAG: 1560 + se_cmd->pi_err = TCM_LOGICAL_BLOCK_REF_TAG_CHECK_FAILED; 1561 + break; 1562 + case IB_SIG_BAD_APPTAG: 1563 + se_cmd->pi_err = TCM_LOGICAL_BLOCK_APP_TAG_CHECK_FAILED; 1564 + break; 1565 + } 1566 + sec_offset_err = mr_status.sig_err.sig_err_offset; 1567 + do_div(sec_offset_err, block_size); 1568 + se_cmd->bad_sector = sec_offset_err + se_cmd->t_task_lba; 1569 + 1570 + pr_err("isert: PI error found type %d at sector 0x%llx " 1571 + "expected 0x%x vs actual 0x%x\n", 1572 + mr_status.sig_err.err_type, 1573 + (unsigned long long)se_cmd->bad_sector, 1574 + mr_status.sig_err.expected, 1575 + mr_status.sig_err.actual); 1576 + ret = 1; 1577 + } 1578 + 1579 + fail_mr_status: 1580 + return ret; 1581 + } 1582 + 1583 + static void 1584 + isert_completion_rdma_write(struct iser_tx_desc *tx_desc, 1585 + struct isert_cmd *isert_cmd) 1586 + { 1587 + struct isert_rdma_wr *wr = &isert_cmd->rdma_wr; 1588 + struct iscsi_cmd *cmd = isert_cmd->iscsi_cmd; 1589 + struct se_cmd *se_cmd = &cmd->se_cmd; 1590 + struct isert_conn *isert_conn = isert_cmd->conn; 1591 + struct isert_device *device = isert_conn->conn_device; 1592 + int ret = 0; 1593 + 1594 + if (wr->fr_desc && wr->fr_desc->ind & ISERT_PROTECTED) { 1595 + ret = isert_check_pi_status(se_cmd, 1596 + wr->fr_desc->pi_ctx->sig_mr); 1597 + wr->fr_desc->ind &= ~ISERT_PROTECTED; 1598 + } 1599 + 1600 + device->unreg_rdma_mem(isert_cmd, isert_conn); 1601 + wr->send_wr_num = 0; 1602 + if (ret) 1603 + transport_send_check_condition_and_sense(se_cmd, 1604 + se_cmd->pi_err, 0); 1605 + else 1606 + isert_put_response(isert_conn->conn, cmd); 1680 1607 } 1681 1608 1682 1609 static void ··· 1758 1545 struct se_cmd *se_cmd = &cmd->se_cmd; 1759 1546 struct isert_conn *isert_conn = isert_cmd->conn; 1760 1547 struct isert_device *device = isert_conn->conn_device; 1548 + int ret = 0; 1549 + 1550 + if (wr->fr_desc && wr->fr_desc->ind & ISERT_PROTECTED) { 1551 + ret = isert_check_pi_status(se_cmd, 1552 + wr->fr_desc->pi_ctx->sig_mr); 1553 + wr->fr_desc->ind &= ~ISERT_PROTECTED; 1554 + } 1761 1555 1762 1556 iscsit_stop_dataout_timer(cmd); 1763 1557 device->unreg_rdma_mem(isert_cmd, isert_conn); 1764 - cmd->write_data_done = wr->cur_rdma_length; 1558 + cmd->write_data_done = wr->data.len; 1765 1559 wr->send_wr_num = 0; 1766 1560 1767 1561 pr_debug("Cmd: %p RDMA_READ comp calling execute_cmd\n", isert_cmd); ··· 1777 1557 cmd->i_state = ISTATE_RECEIVED_LAST_DATAOUT; 1778 1558 spin_unlock_bh(&cmd->istate_lock); 1779 1559 1780 - target_execute_cmd(se_cmd); 1560 + if (ret) 1561 + transport_send_check_condition_and_sense(se_cmd, 1562 + se_cmd->pi_err, 0); 1563 + else 1564 + target_execute_cmd(se_cmd); 1781 1565 } 1782 1566 1783 1567 static void ··· 1801 1577 iscsit_tmr_post_handler(cmd, cmd->conn); 1802 1578 1803 1579 cmd->i_state = ISTATE_SENT_STATUS; 1804 - isert_completion_put(&isert_cmd->tx_desc, isert_cmd, ib_dev); 1580 + isert_completion_put(&isert_cmd->tx_desc, isert_cmd, ib_dev, false); 1805 1581 break; 1806 1582 case ISTATE_SEND_REJECT: 1807 1583 pr_debug("Got isert_do_control_comp ISTATE_SEND_REJECT: >>>\n"); 1808 1584 atomic_dec(&isert_conn->post_send_buf_count); 1809 1585 1810 1586 cmd->i_state = ISTATE_SENT_STATUS; 1811 - isert_completion_put(&isert_cmd->tx_desc, isert_cmd, ib_dev); 1587 + isert_completion_put(&isert_cmd->tx_desc, isert_cmd, ib_dev, false); 1812 1588 break; 1813 1589 case ISTATE_SEND_LOGOUTRSP: 1814 1590 pr_debug("Calling iscsit_logout_post_handler >>>>>>>>>>>>>>\n"); ··· 1822 1598 case ISTATE_SEND_TEXTRSP: 1823 1599 atomic_dec(&isert_conn->post_send_buf_count); 1824 1600 cmd->i_state = ISTATE_SENT_STATUS; 1825 - isert_completion_put(&isert_cmd->tx_desc, isert_cmd, ib_dev); 1601 + isert_completion_put(&isert_cmd->tx_desc, isert_cmd, ib_dev, false); 1826 1602 break; 1827 1603 default: 1828 1604 pr_err("Unknown do_control_comp i_state %d\n", cmd->i_state); ··· 1850 1626 queue_work(isert_comp_wq, &isert_cmd->comp_work); 1851 1627 return; 1852 1628 } 1853 - atomic_sub(wr->send_wr_num + 1, &isert_conn->post_send_buf_count); 1629 + 1630 + /** 1631 + * If send_wr_num is 0 this means that we got 1632 + * RDMA completion and we cleared it and we should 1633 + * simply decrement the response post. else the 1634 + * response is incorporated in send_wr_num, just 1635 + * sub it. 1636 + **/ 1637 + if (wr->send_wr_num) 1638 + atomic_sub(wr->send_wr_num, &isert_conn->post_send_buf_count); 1639 + else 1640 + atomic_dec(&isert_conn->post_send_buf_count); 1854 1641 1855 1642 cmd->i_state = ISTATE_SENT_STATUS; 1856 - isert_completion_put(tx_desc, isert_cmd, ib_dev); 1643 + isert_completion_put(tx_desc, isert_cmd, ib_dev, false); 1857 1644 } 1858 1645 1859 1646 static void ··· 1893 1658 isert_conn, ib_dev); 1894 1659 break; 1895 1660 case ISER_IB_RDMA_WRITE: 1896 - pr_err("isert_send_completion: Got ISER_IB_RDMA_WRITE\n"); 1897 - dump_stack(); 1661 + pr_debug("isert_send_completion: Got ISER_IB_RDMA_WRITE\n"); 1662 + atomic_sub(wr->send_wr_num, &isert_conn->post_send_buf_count); 1663 + isert_completion_rdma_write(tx_desc, isert_cmd); 1898 1664 break; 1899 1665 case ISER_IB_RDMA_READ: 1900 1666 pr_debug("isert_send_completion: Got ISER_IB_RDMA_READ:\n"); ··· 1945 1709 llnode = llist_next(llnode); 1946 1710 wr = &t->isert_cmd->rdma_wr; 1947 1711 1948 - atomic_sub(wr->send_wr_num + 1, &isert_conn->post_send_buf_count); 1949 - isert_completion_put(t, t->isert_cmd, ib_dev); 1712 + /** 1713 + * If send_wr_num is 0 this means that we got 1714 + * RDMA completion and we cleared it and we should 1715 + * simply decrement the response post. else the 1716 + * response is incorporated in send_wr_num, just 1717 + * sub it. 1718 + **/ 1719 + if (wr->send_wr_num) 1720 + atomic_sub(wr->send_wr_num, 1721 + &isert_conn->post_send_buf_count); 1722 + else 1723 + atomic_dec(&isert_conn->post_send_buf_count); 1724 + 1725 + isert_completion_put(t, t->isert_cmd, ib_dev, true); 1950 1726 } 1951 1727 } 1952 1728 ··· 1976 1728 llnode = llist_next(llnode); 1977 1729 wr = &t->isert_cmd->rdma_wr; 1978 1730 1979 - atomic_sub(wr->send_wr_num + 1, &isert_conn->post_send_buf_count); 1980 - isert_completion_put(t, t->isert_cmd, ib_dev); 1731 + /** 1732 + * If send_wr_num is 0 this means that we got 1733 + * RDMA completion and we cleared it and we should 1734 + * simply decrement the response post. else the 1735 + * response is incorporated in send_wr_num, just 1736 + * sub it. 1737 + **/ 1738 + if (wr->send_wr_num) 1739 + atomic_sub(wr->send_wr_num, 1740 + &isert_conn->post_send_buf_count); 1741 + else 1742 + atomic_dec(&isert_conn->post_send_buf_count); 1743 + 1744 + isert_completion_put(t, t->isert_cmd, ib_dev, true); 1981 1745 } 1982 1746 tx_desc->comp_llnode_batch = NULL; 1983 1747 1984 1748 if (!isert_cmd) 1985 1749 isert_unmap_tx_desc(tx_desc, ib_dev); 1986 1750 else 1987 - isert_completion_put(tx_desc, isert_cmd, ib_dev); 1751 + isert_completion_put(tx_desc, isert_cmd, ib_dev, true); 1988 1752 } 1989 1753 1990 1754 static void ··· 2176 1916 pr_debug("Posting SCSI Response IB_WR_SEND >>>>>>>>>>>>>>>>>>>>>>\n"); 2177 1917 2178 1918 return isert_post_response(isert_conn, isert_cmd); 1919 + } 1920 + 1921 + static void 1922 + isert_aborted_task(struct iscsi_conn *conn, struct iscsi_cmd *cmd) 1923 + { 1924 + struct isert_cmd *isert_cmd = iscsit_priv_cmd(cmd); 1925 + struct isert_conn *isert_conn = (struct isert_conn *)conn->context; 1926 + struct isert_device *device = isert_conn->conn_device; 1927 + 1928 + spin_lock_bh(&conn->cmd_lock); 1929 + if (!list_empty(&cmd->i_conn_node)) 1930 + list_del_init(&cmd->i_conn_node); 1931 + spin_unlock_bh(&conn->cmd_lock); 1932 + 1933 + if (cmd->data_direction == DMA_TO_DEVICE) 1934 + iscsit_stop_dataout_timer(cmd); 1935 + 1936 + device->unreg_rdma_mem(isert_cmd, isert_conn); 1937 + } 1938 + 1939 + static enum target_prot_op 1940 + isert_get_sup_prot_ops(struct iscsi_conn *conn) 1941 + { 1942 + struct isert_conn *isert_conn = (struct isert_conn *)conn->context; 1943 + struct isert_device *device = isert_conn->conn_device; 1944 + 1945 + if (device->pi_capable) 1946 + return TARGET_PROT_ALL; 1947 + 1948 + return TARGET_PROT_NORMAL; 2179 1949 } 2180 1950 2181 1951 static int ··· 2389 2099 struct se_cmd *se_cmd = &cmd->se_cmd; 2390 2100 struct isert_cmd *isert_cmd = iscsit_priv_cmd(cmd); 2391 2101 struct isert_conn *isert_conn = (struct isert_conn *)conn->context; 2392 - struct ib_device *ib_dev = isert_conn->conn_cm_id->device; 2102 + struct isert_data_buf *data = &wr->data; 2393 2103 struct ib_send_wr *send_wr; 2394 2104 struct ib_sge *ib_sge; 2395 - struct scatterlist *sg_start; 2396 - u32 sg_off = 0, sg_nents; 2397 - u32 offset = 0, data_len, data_left, rdma_write_max, va_offset = 0; 2398 - int ret = 0, count, i, ib_sge_cnt; 2105 + u32 offset, data_len, data_left, rdma_write_max, va_offset = 0; 2106 + int ret = 0, i, ib_sge_cnt; 2399 2107 2400 - if (wr->iser_ib_op == ISER_IB_RDMA_WRITE) { 2401 - data_left = se_cmd->data_length; 2402 - } else { 2403 - sg_off = cmd->write_data_done / PAGE_SIZE; 2404 - data_left = se_cmd->data_length - cmd->write_data_done; 2405 - offset = cmd->write_data_done; 2406 - isert_cmd->tx_desc.isert_cmd = isert_cmd; 2407 - } 2108 + isert_cmd->tx_desc.isert_cmd = isert_cmd; 2408 2109 2409 - sg_start = &cmd->se_cmd.t_data_sg[sg_off]; 2410 - sg_nents = se_cmd->t_data_nents - sg_off; 2110 + offset = wr->iser_ib_op == ISER_IB_RDMA_READ ? cmd->write_data_done : 0; 2111 + ret = isert_map_data_buf(isert_conn, isert_cmd, se_cmd->t_data_sg, 2112 + se_cmd->t_data_nents, se_cmd->data_length, 2113 + offset, wr->iser_ib_op, &wr->data); 2114 + if (ret) 2115 + return ret; 2411 2116 2412 - count = ib_dma_map_sg(ib_dev, sg_start, sg_nents, 2413 - (wr->iser_ib_op == ISER_IB_RDMA_WRITE) ? 2414 - DMA_TO_DEVICE : DMA_FROM_DEVICE); 2415 - if (unlikely(!count)) { 2416 - pr_err("Cmd: %p unrable to map SGs\n", isert_cmd); 2417 - return -EINVAL; 2418 - } 2419 - wr->sge = sg_start; 2420 - wr->num_sge = sg_nents; 2421 - wr->cur_rdma_length = data_left; 2422 - pr_debug("Mapped cmd: %p count: %u sg: %p sg_nents: %u rdma_len %d\n", 2423 - isert_cmd, count, sg_start, sg_nents, data_left); 2117 + data_left = data->len; 2118 + offset = data->offset; 2424 2119 2425 - ib_sge = kzalloc(sizeof(struct ib_sge) * sg_nents, GFP_KERNEL); 2120 + ib_sge = kzalloc(sizeof(struct ib_sge) * data->nents, GFP_KERNEL); 2426 2121 if (!ib_sge) { 2427 2122 pr_warn("Unable to allocate ib_sge\n"); 2428 2123 ret = -ENOMEM; 2429 - goto unmap_sg; 2124 + goto unmap_cmd; 2430 2125 } 2431 2126 wr->ib_sge = ib_sge; 2432 2127 2433 - wr->send_wr_num = DIV_ROUND_UP(sg_nents, isert_conn->max_sge); 2128 + wr->send_wr_num = DIV_ROUND_UP(data->nents, isert_conn->max_sge); 2434 2129 wr->send_wr = kzalloc(sizeof(struct ib_send_wr) * wr->send_wr_num, 2435 2130 GFP_KERNEL); 2436 2131 if (!wr->send_wr) { 2437 2132 pr_debug("Unable to allocate wr->send_wr\n"); 2438 2133 ret = -ENOMEM; 2439 - goto unmap_sg; 2134 + goto unmap_cmd; 2440 2135 } 2441 2136 2442 2137 wr->isert_cmd = isert_cmd; ··· 2460 2185 } 2461 2186 2462 2187 return 0; 2463 - unmap_sg: 2464 - ib_dma_unmap_sg(ib_dev, sg_start, sg_nents, 2465 - (wr->iser_ib_op == ISER_IB_RDMA_WRITE) ? 2466 - DMA_TO_DEVICE : DMA_FROM_DEVICE); 2188 + unmap_cmd: 2189 + isert_unmap_data_buf(isert_conn, data); 2190 + 2467 2191 return ret; 2468 2192 } 2469 2193 ··· 2506 2232 } 2507 2233 2508 2234 static int 2509 - isert_fast_reg_mr(struct fast_reg_descriptor *fr_desc, 2510 - struct isert_conn *isert_conn, struct scatterlist *sg_start, 2511 - struct ib_sge *ib_sge, u32 sg_nents, u32 offset, 2512 - unsigned int data_len) 2235 + isert_fast_reg_mr(struct isert_conn *isert_conn, 2236 + struct fast_reg_descriptor *fr_desc, 2237 + struct isert_data_buf *mem, 2238 + enum isert_indicator ind, 2239 + struct ib_sge *sge) 2513 2240 { 2514 2241 struct ib_device *ib_dev = isert_conn->conn_cm_id->device; 2242 + struct ib_mr *mr; 2243 + struct ib_fast_reg_page_list *frpl; 2515 2244 struct ib_send_wr fr_wr, inv_wr; 2516 2245 struct ib_send_wr *bad_wr, *wr = NULL; 2517 2246 int ret, pagelist_len; 2518 2247 u32 page_off; 2519 2248 u8 key; 2520 2249 2521 - sg_nents = min_t(unsigned int, sg_nents, ISCSI_ISER_SG_TABLESIZE); 2522 - page_off = offset % PAGE_SIZE; 2250 + if (mem->dma_nents == 1) { 2251 + sge->lkey = isert_conn->conn_mr->lkey; 2252 + sge->addr = ib_sg_dma_address(ib_dev, &mem->sg[0]); 2253 + sge->length = ib_sg_dma_len(ib_dev, &mem->sg[0]); 2254 + pr_debug("%s:%d sge: addr: 0x%llx length: %u lkey: %x\n", 2255 + __func__, __LINE__, sge->addr, sge->length, 2256 + sge->lkey); 2257 + return 0; 2258 + } 2259 + 2260 + if (ind == ISERT_DATA_KEY_VALID) { 2261 + /* Registering data buffer */ 2262 + mr = fr_desc->data_mr; 2263 + frpl = fr_desc->data_frpl; 2264 + } else { 2265 + /* Registering protection buffer */ 2266 + mr = fr_desc->pi_ctx->prot_mr; 2267 + frpl = fr_desc->pi_ctx->prot_frpl; 2268 + } 2269 + 2270 + page_off = mem->offset % PAGE_SIZE; 2523 2271 2524 2272 pr_debug("Use fr_desc %p sg_nents %d offset %u\n", 2525 - fr_desc, sg_nents, offset); 2273 + fr_desc, mem->nents, mem->offset); 2526 2274 2527 - pagelist_len = isert_map_fr_pagelist(ib_dev, sg_start, sg_nents, 2528 - &fr_desc->data_frpl->page_list[0]); 2275 + pagelist_len = isert_map_fr_pagelist(ib_dev, mem->sg, mem->nents, 2276 + &frpl->page_list[0]); 2529 2277 2530 - if (!fr_desc->valid) { 2278 + if (!(fr_desc->ind & ISERT_DATA_KEY_VALID)) { 2531 2279 memset(&inv_wr, 0, sizeof(inv_wr)); 2532 2280 inv_wr.wr_id = ISER_FASTREG_LI_WRID; 2533 2281 inv_wr.opcode = IB_WR_LOCAL_INV; 2534 - inv_wr.ex.invalidate_rkey = fr_desc->data_mr->rkey; 2282 + inv_wr.ex.invalidate_rkey = mr->rkey; 2535 2283 wr = &inv_wr; 2536 2284 /* Bump the key */ 2537 - key = (u8)(fr_desc->data_mr->rkey & 0x000000FF); 2538 - ib_update_fast_reg_key(fr_desc->data_mr, ++key); 2285 + key = (u8)(mr->rkey & 0x000000FF); 2286 + ib_update_fast_reg_key(mr, ++key); 2539 2287 } 2540 2288 2541 2289 /* Prepare FASTREG WR */ 2542 2290 memset(&fr_wr, 0, sizeof(fr_wr)); 2543 2291 fr_wr.wr_id = ISER_FASTREG_LI_WRID; 2544 2292 fr_wr.opcode = IB_WR_FAST_REG_MR; 2545 - fr_wr.wr.fast_reg.iova_start = 2546 - fr_desc->data_frpl->page_list[0] + page_off; 2547 - fr_wr.wr.fast_reg.page_list = fr_desc->data_frpl; 2293 + fr_wr.wr.fast_reg.iova_start = frpl->page_list[0] + page_off; 2294 + fr_wr.wr.fast_reg.page_list = frpl; 2548 2295 fr_wr.wr.fast_reg.page_list_len = pagelist_len; 2549 2296 fr_wr.wr.fast_reg.page_shift = PAGE_SHIFT; 2550 - fr_wr.wr.fast_reg.length = data_len; 2551 - fr_wr.wr.fast_reg.rkey = fr_desc->data_mr->rkey; 2297 + fr_wr.wr.fast_reg.length = mem->len; 2298 + fr_wr.wr.fast_reg.rkey = mr->rkey; 2552 2299 fr_wr.wr.fast_reg.access_flags = IB_ACCESS_LOCAL_WRITE; 2553 2300 2554 2301 if (!wr) ··· 2582 2287 pr_err("fast registration failed, ret:%d\n", ret); 2583 2288 return ret; 2584 2289 } 2585 - fr_desc->valid = false; 2290 + fr_desc->ind &= ~ind; 2586 2291 2587 - ib_sge->lkey = fr_desc->data_mr->lkey; 2588 - ib_sge->addr = fr_desc->data_frpl->page_list[0] + page_off; 2589 - ib_sge->length = data_len; 2292 + sge->lkey = mr->lkey; 2293 + sge->addr = frpl->page_list[0] + page_off; 2294 + sge->length = mem->len; 2590 2295 2591 - pr_debug("RDMA ib_sge: addr: 0x%16llx length: %u lkey: %08x\n", 2592 - ib_sge->addr, ib_sge->length, ib_sge->lkey); 2296 + pr_debug("%s:%d sge: addr: 0x%llx length: %u lkey: %x\n", 2297 + __func__, __LINE__, sge->addr, sge->length, 2298 + sge->lkey); 2593 2299 2300 + return ret; 2301 + } 2302 + 2303 + static inline enum ib_t10_dif_type 2304 + se2ib_prot_type(enum target_prot_type prot_type) 2305 + { 2306 + switch (prot_type) { 2307 + case TARGET_DIF_TYPE0_PROT: 2308 + return IB_T10DIF_NONE; 2309 + case TARGET_DIF_TYPE1_PROT: 2310 + return IB_T10DIF_TYPE1; 2311 + case TARGET_DIF_TYPE2_PROT: 2312 + return IB_T10DIF_TYPE2; 2313 + case TARGET_DIF_TYPE3_PROT: 2314 + return IB_T10DIF_TYPE3; 2315 + default: 2316 + return IB_T10DIF_NONE; 2317 + } 2318 + } 2319 + 2320 + static int 2321 + isert_set_sig_attrs(struct se_cmd *se_cmd, struct ib_sig_attrs *sig_attrs) 2322 + { 2323 + enum ib_t10_dif_type ib_prot_type = se2ib_prot_type(se_cmd->prot_type); 2324 + 2325 + sig_attrs->mem.sig_type = IB_SIG_TYPE_T10_DIF; 2326 + sig_attrs->wire.sig_type = IB_SIG_TYPE_T10_DIF; 2327 + sig_attrs->mem.sig.dif.pi_interval = 2328 + se_cmd->se_dev->dev_attrib.block_size; 2329 + sig_attrs->wire.sig.dif.pi_interval = 2330 + se_cmd->se_dev->dev_attrib.block_size; 2331 + 2332 + switch (se_cmd->prot_op) { 2333 + case TARGET_PROT_DIN_INSERT: 2334 + case TARGET_PROT_DOUT_STRIP: 2335 + sig_attrs->mem.sig.dif.type = IB_T10DIF_NONE; 2336 + sig_attrs->wire.sig.dif.type = ib_prot_type; 2337 + sig_attrs->wire.sig.dif.bg_type = IB_T10DIF_CRC; 2338 + sig_attrs->wire.sig.dif.ref_tag = se_cmd->reftag_seed; 2339 + break; 2340 + case TARGET_PROT_DOUT_INSERT: 2341 + case TARGET_PROT_DIN_STRIP: 2342 + sig_attrs->mem.sig.dif.type = ib_prot_type; 2343 + sig_attrs->mem.sig.dif.bg_type = IB_T10DIF_CRC; 2344 + sig_attrs->mem.sig.dif.ref_tag = se_cmd->reftag_seed; 2345 + sig_attrs->wire.sig.dif.type = IB_T10DIF_NONE; 2346 + break; 2347 + case TARGET_PROT_DIN_PASS: 2348 + case TARGET_PROT_DOUT_PASS: 2349 + sig_attrs->mem.sig.dif.type = ib_prot_type; 2350 + sig_attrs->mem.sig.dif.bg_type = IB_T10DIF_CRC; 2351 + sig_attrs->mem.sig.dif.ref_tag = se_cmd->reftag_seed; 2352 + sig_attrs->wire.sig.dif.type = ib_prot_type; 2353 + sig_attrs->wire.sig.dif.bg_type = IB_T10DIF_CRC; 2354 + sig_attrs->wire.sig.dif.ref_tag = se_cmd->reftag_seed; 2355 + break; 2356 + default: 2357 + pr_err("Unsupported PI operation %d\n", se_cmd->prot_op); 2358 + return -EINVAL; 2359 + } 2360 + 2361 + return 0; 2362 + } 2363 + 2364 + static inline u8 2365 + isert_set_prot_checks(u8 prot_checks) 2366 + { 2367 + return (prot_checks & TARGET_DIF_CHECK_GUARD ? 0xc0 : 0) | 2368 + (prot_checks & TARGET_DIF_CHECK_REFTAG ? 0x30 : 0) | 2369 + (prot_checks & TARGET_DIF_CHECK_REFTAG ? 0x0f : 0); 2370 + } 2371 + 2372 + static int 2373 + isert_reg_sig_mr(struct isert_conn *isert_conn, struct se_cmd *se_cmd, 2374 + struct fast_reg_descriptor *fr_desc, 2375 + struct ib_sge *data_sge, struct ib_sge *prot_sge, 2376 + struct ib_sge *sig_sge) 2377 + { 2378 + struct ib_send_wr sig_wr, inv_wr; 2379 + struct ib_send_wr *bad_wr, *wr = NULL; 2380 + struct pi_context *pi_ctx = fr_desc->pi_ctx; 2381 + struct ib_sig_attrs sig_attrs; 2382 + int ret; 2383 + u32 key; 2384 + 2385 + memset(&sig_attrs, 0, sizeof(sig_attrs)); 2386 + ret = isert_set_sig_attrs(se_cmd, &sig_attrs); 2387 + if (ret) 2388 + goto err; 2389 + 2390 + sig_attrs.check_mask = isert_set_prot_checks(se_cmd->prot_checks); 2391 + 2392 + if (!(fr_desc->ind & ISERT_SIG_KEY_VALID)) { 2393 + memset(&inv_wr, 0, sizeof(inv_wr)); 2394 + inv_wr.opcode = IB_WR_LOCAL_INV; 2395 + inv_wr.wr_id = ISER_FASTREG_LI_WRID; 2396 + inv_wr.ex.invalidate_rkey = pi_ctx->sig_mr->rkey; 2397 + wr = &inv_wr; 2398 + /* Bump the key */ 2399 + key = (u8)(pi_ctx->sig_mr->rkey & 0x000000FF); 2400 + ib_update_fast_reg_key(pi_ctx->sig_mr, ++key); 2401 + } 2402 + 2403 + memset(&sig_wr, 0, sizeof(sig_wr)); 2404 + sig_wr.opcode = IB_WR_REG_SIG_MR; 2405 + sig_wr.wr_id = ISER_FASTREG_LI_WRID; 2406 + sig_wr.sg_list = data_sge; 2407 + sig_wr.num_sge = 1; 2408 + sig_wr.wr.sig_handover.access_flags = IB_ACCESS_LOCAL_WRITE; 2409 + sig_wr.wr.sig_handover.sig_attrs = &sig_attrs; 2410 + sig_wr.wr.sig_handover.sig_mr = pi_ctx->sig_mr; 2411 + if (se_cmd->t_prot_sg) 2412 + sig_wr.wr.sig_handover.prot = prot_sge; 2413 + 2414 + if (!wr) 2415 + wr = &sig_wr; 2416 + else 2417 + wr->next = &sig_wr; 2418 + 2419 + ret = ib_post_send(isert_conn->conn_qp, wr, &bad_wr); 2420 + if (ret) { 2421 + pr_err("fast registration failed, ret:%d\n", ret); 2422 + goto err; 2423 + } 2424 + fr_desc->ind &= ~ISERT_SIG_KEY_VALID; 2425 + 2426 + sig_sge->lkey = pi_ctx->sig_mr->lkey; 2427 + sig_sge->addr = 0; 2428 + sig_sge->length = se_cmd->data_length; 2429 + if (se_cmd->prot_op != TARGET_PROT_DIN_STRIP && 2430 + se_cmd->prot_op != TARGET_PROT_DOUT_INSERT) 2431 + /* 2432 + * We have protection guards on the wire 2433 + * so we need to set a larget transfer 2434 + */ 2435 + sig_sge->length += se_cmd->prot_length; 2436 + 2437 + pr_debug("sig_sge: addr: 0x%llx length: %u lkey: %x\n", 2438 + sig_sge->addr, sig_sge->length, 2439 + sig_sge->lkey); 2440 + err: 2594 2441 return ret; 2595 2442 } 2596 2443 ··· 2742 2305 { 2743 2306 struct se_cmd *se_cmd = &cmd->se_cmd; 2744 2307 struct isert_cmd *isert_cmd = iscsit_priv_cmd(cmd); 2745 - struct isert_conn *isert_conn = (struct isert_conn *)conn->context; 2746 - struct ib_device *ib_dev = isert_conn->conn_cm_id->device; 2308 + struct isert_conn *isert_conn = conn->context; 2309 + struct ib_sge data_sge; 2747 2310 struct ib_send_wr *send_wr; 2748 - struct ib_sge *ib_sge; 2749 - struct scatterlist *sg_start; 2750 - struct fast_reg_descriptor *fr_desc; 2751 - u32 sg_off = 0, sg_nents; 2752 - u32 offset = 0, data_len, data_left, rdma_write_max; 2753 - int ret = 0, count; 2311 + struct fast_reg_descriptor *fr_desc = NULL; 2312 + u32 offset; 2313 + int ret = 0; 2754 2314 unsigned long flags; 2755 2315 2756 - if (wr->iser_ib_op == ISER_IB_RDMA_WRITE) { 2757 - data_left = se_cmd->data_length; 2758 - } else { 2759 - offset = cmd->write_data_done; 2760 - sg_off = offset / PAGE_SIZE; 2761 - data_left = se_cmd->data_length - cmd->write_data_done; 2762 - isert_cmd->tx_desc.isert_cmd = isert_cmd; 2316 + isert_cmd->tx_desc.isert_cmd = isert_cmd; 2317 + 2318 + offset = wr->iser_ib_op == ISER_IB_RDMA_READ ? cmd->write_data_done : 0; 2319 + ret = isert_map_data_buf(isert_conn, isert_cmd, se_cmd->t_data_sg, 2320 + se_cmd->t_data_nents, se_cmd->data_length, 2321 + offset, wr->iser_ib_op, &wr->data); 2322 + if (ret) 2323 + return ret; 2324 + 2325 + if (wr->data.dma_nents != 1 || 2326 + se_cmd->prot_op != TARGET_PROT_NORMAL) { 2327 + spin_lock_irqsave(&isert_conn->conn_lock, flags); 2328 + fr_desc = list_first_entry(&isert_conn->conn_fr_pool, 2329 + struct fast_reg_descriptor, list); 2330 + list_del(&fr_desc->list); 2331 + spin_unlock_irqrestore(&isert_conn->conn_lock, flags); 2332 + wr->fr_desc = fr_desc; 2763 2333 } 2764 2334 2765 - sg_start = &cmd->se_cmd.t_data_sg[sg_off]; 2766 - sg_nents = se_cmd->t_data_nents - sg_off; 2335 + ret = isert_fast_reg_mr(isert_conn, fr_desc, &wr->data, 2336 + ISERT_DATA_KEY_VALID, &data_sge); 2337 + if (ret) 2338 + goto unmap_cmd; 2767 2339 2768 - count = ib_dma_map_sg(ib_dev, sg_start, sg_nents, 2769 - (wr->iser_ib_op == ISER_IB_RDMA_WRITE) ? 2770 - DMA_TO_DEVICE : DMA_FROM_DEVICE); 2771 - if (unlikely(!count)) { 2772 - pr_err("Cmd: %p unrable to map SGs\n", isert_cmd); 2773 - return -EINVAL; 2774 - } 2775 - wr->sge = sg_start; 2776 - wr->num_sge = sg_nents; 2777 - pr_debug("Mapped cmd: %p count: %u sg: %p sg_nents: %u rdma_len %d\n", 2778 - isert_cmd, count, sg_start, sg_nents, data_left); 2340 + if (se_cmd->prot_op != TARGET_PROT_NORMAL) { 2341 + struct ib_sge prot_sge, sig_sge; 2779 2342 2780 - memset(&wr->s_ib_sge, 0, sizeof(*ib_sge)); 2781 - ib_sge = &wr->s_ib_sge; 2782 - wr->ib_sge = ib_sge; 2343 + if (se_cmd->t_prot_sg) { 2344 + ret = isert_map_data_buf(isert_conn, isert_cmd, 2345 + se_cmd->t_prot_sg, 2346 + se_cmd->t_prot_nents, 2347 + se_cmd->prot_length, 2348 + 0, wr->iser_ib_op, &wr->prot); 2349 + if (ret) 2350 + goto unmap_cmd; 2783 2351 2352 + ret = isert_fast_reg_mr(isert_conn, fr_desc, &wr->prot, 2353 + ISERT_PROT_KEY_VALID, &prot_sge); 2354 + if (ret) 2355 + goto unmap_prot_cmd; 2356 + } 2357 + 2358 + ret = isert_reg_sig_mr(isert_conn, se_cmd, fr_desc, 2359 + &data_sge, &prot_sge, &sig_sge); 2360 + if (ret) 2361 + goto unmap_prot_cmd; 2362 + 2363 + fr_desc->ind |= ISERT_PROTECTED; 2364 + memcpy(&wr->s_ib_sge, &sig_sge, sizeof(sig_sge)); 2365 + } else 2366 + memcpy(&wr->s_ib_sge, &data_sge, sizeof(data_sge)); 2367 + 2368 + wr->ib_sge = &wr->s_ib_sge; 2784 2369 wr->send_wr_num = 1; 2785 2370 memset(&wr->s_send_wr, 0, sizeof(*send_wr)); 2786 2371 wr->send_wr = &wr->s_send_wr; 2787 - 2788 2372 wr->isert_cmd = isert_cmd; 2789 - rdma_write_max = ISCSI_ISER_SG_TABLESIZE * PAGE_SIZE; 2790 2373 2791 2374 send_wr = &isert_cmd->rdma_wr.s_send_wr; 2792 - send_wr->sg_list = ib_sge; 2375 + send_wr->sg_list = &wr->s_ib_sge; 2793 2376 send_wr->num_sge = 1; 2794 2377 send_wr->wr_id = (unsigned long)&isert_cmd->tx_desc; 2795 2378 if (wr->iser_ib_op == ISER_IB_RDMA_WRITE) { 2796 2379 send_wr->opcode = IB_WR_RDMA_WRITE; 2797 2380 send_wr->wr.rdma.remote_addr = isert_cmd->read_va; 2798 2381 send_wr->wr.rdma.rkey = isert_cmd->read_stag; 2799 - send_wr->send_flags = 0; 2800 - send_wr->next = &isert_cmd->tx_desc.send_wr; 2382 + send_wr->send_flags = se_cmd->prot_op == TARGET_PROT_NORMAL ? 2383 + 0 : IB_SEND_SIGNALED; 2801 2384 } else { 2802 2385 send_wr->opcode = IB_WR_RDMA_READ; 2803 2386 send_wr->wr.rdma.remote_addr = isert_cmd->write_va; ··· 2825 2368 send_wr->send_flags = IB_SEND_SIGNALED; 2826 2369 } 2827 2370 2828 - data_len = min(data_left, rdma_write_max); 2829 - wr->cur_rdma_length = data_len; 2830 - 2831 - /* if there is a single dma entry, dma mr is sufficient */ 2832 - if (count == 1) { 2833 - ib_sge->addr = ib_sg_dma_address(ib_dev, &sg_start[0]); 2834 - ib_sge->length = ib_sg_dma_len(ib_dev, &sg_start[0]); 2835 - ib_sge->lkey = isert_conn->conn_mr->lkey; 2836 - wr->fr_desc = NULL; 2837 - } else { 2838 - spin_lock_irqsave(&isert_conn->conn_lock, flags); 2839 - fr_desc = list_first_entry(&isert_conn->conn_fr_pool, 2840 - struct fast_reg_descriptor, list); 2841 - list_del(&fr_desc->list); 2842 - spin_unlock_irqrestore(&isert_conn->conn_lock, flags); 2843 - wr->fr_desc = fr_desc; 2844 - 2845 - ret = isert_fast_reg_mr(fr_desc, isert_conn, sg_start, 2846 - ib_sge, sg_nents, offset, data_len); 2847 - if (ret) { 2848 - list_add_tail(&fr_desc->list, &isert_conn->conn_fr_pool); 2849 - goto unmap_sg; 2850 - } 2851 - } 2852 - 2853 2371 return 0; 2372 + unmap_prot_cmd: 2373 + if (se_cmd->t_prot_sg) 2374 + isert_unmap_data_buf(isert_conn, &wr->prot); 2375 + unmap_cmd: 2376 + if (fr_desc) { 2377 + spin_lock_irqsave(&isert_conn->conn_lock, flags); 2378 + list_add_tail(&fr_desc->list, &isert_conn->conn_fr_pool); 2379 + spin_unlock_irqrestore(&isert_conn->conn_lock, flags); 2380 + } 2381 + isert_unmap_data_buf(isert_conn, &wr->data); 2854 2382 2855 - unmap_sg: 2856 - ib_dma_unmap_sg(ib_dev, sg_start, sg_nents, 2857 - (wr->iser_ib_op == ISER_IB_RDMA_WRITE) ? 2858 - DMA_TO_DEVICE : DMA_FROM_DEVICE); 2859 2383 return ret; 2860 2384 } 2861 2385 ··· 2860 2422 return rc; 2861 2423 } 2862 2424 2863 - /* 2864 - * Build isert_conn->tx_desc for iSCSI response PDU and attach 2865 - */ 2866 - isert_create_send_desc(isert_conn, isert_cmd, &isert_cmd->tx_desc); 2867 - iscsit_build_rsp_pdu(cmd, conn, true, (struct iscsi_scsi_rsp *) 2868 - &isert_cmd->tx_desc.iscsi_header); 2869 - isert_init_tx_hdrs(isert_conn, &isert_cmd->tx_desc); 2870 - isert_init_send_wr(isert_conn, isert_cmd, 2871 - &isert_cmd->tx_desc.send_wr, true); 2425 + if (se_cmd->prot_op == TARGET_PROT_NORMAL) { 2426 + /* 2427 + * Build isert_conn->tx_desc for iSCSI response PDU and attach 2428 + */ 2429 + isert_create_send_desc(isert_conn, isert_cmd, 2430 + &isert_cmd->tx_desc); 2431 + iscsit_build_rsp_pdu(cmd, conn, true, (struct iscsi_scsi_rsp *) 2432 + &isert_cmd->tx_desc.iscsi_header); 2433 + isert_init_tx_hdrs(isert_conn, &isert_cmd->tx_desc); 2434 + isert_init_send_wr(isert_conn, isert_cmd, 2435 + &isert_cmd->tx_desc.send_wr, true); 2436 + isert_cmd->rdma_wr.s_send_wr.next = &isert_cmd->tx_desc.send_wr; 2437 + wr->send_wr_num += 1; 2438 + } 2872 2439 2873 - atomic_add(wr->send_wr_num + 1, &isert_conn->post_send_buf_count); 2440 + atomic_add(wr->send_wr_num, &isert_conn->post_send_buf_count); 2874 2441 2875 2442 rc = ib_post_send(isert_conn->conn_qp, wr->send_wr, &wr_failed); 2876 2443 if (rc) { 2877 2444 pr_warn("ib_post_send() failed for IB_WR_RDMA_WRITE\n"); 2878 - atomic_sub(wr->send_wr_num + 1, &isert_conn->post_send_buf_count); 2445 + atomic_sub(wr->send_wr_num, &isert_conn->post_send_buf_count); 2879 2446 } 2880 - pr_debug("Cmd: %p posted RDMA_WRITE + Response for iSER Data READ\n", 2881 - isert_cmd); 2447 + 2448 + if (se_cmd->prot_op == TARGET_PROT_NORMAL) 2449 + pr_debug("Cmd: %p posted RDMA_WRITE + Response for iSER Data " 2450 + "READ\n", isert_cmd); 2451 + else 2452 + pr_debug("Cmd: %p posted RDMA_WRITE for iSER Data READ\n", 2453 + isert_cmd); 2882 2454 2883 2455 return 1; 2884 2456 } ··· 3263 2815 .iscsit_get_dataout = isert_get_dataout, 3264 2816 .iscsit_queue_data_in = isert_put_datain, 3265 2817 .iscsit_queue_status = isert_put_response, 2818 + .iscsit_aborted_task = isert_aborted_task, 2819 + .iscsit_get_sup_prot_ops = isert_get_sup_prot_ops, 3266 2820 }; 3267 2821 3268 2822 static int __init isert_init(void)

+31 -7

drivers/infiniband/ulp/isert/ib_isert.h

··· 50 50 struct ib_send_wr send_wr; 51 51 } __packed; 52 52 53 + enum isert_indicator { 54 + ISERT_PROTECTED = 1 << 0, 55 + ISERT_DATA_KEY_VALID = 1 << 1, 56 + ISERT_PROT_KEY_VALID = 1 << 2, 57 + ISERT_SIG_KEY_VALID = 1 << 3, 58 + }; 59 + 60 + struct pi_context { 61 + struct ib_mr *prot_mr; 62 + struct ib_fast_reg_page_list *prot_frpl; 63 + struct ib_mr *sig_mr; 64 + }; 65 + 53 66 struct fast_reg_descriptor { 54 - struct list_head list; 55 - struct ib_mr *data_mr; 56 - struct ib_fast_reg_page_list *data_frpl; 57 - bool valid; 67 + struct list_head list; 68 + struct ib_mr *data_mr; 69 + struct ib_fast_reg_page_list *data_frpl; 70 + u8 ind; 71 + struct pi_context *pi_ctx; 72 + }; 73 + 74 + struct isert_data_buf { 75 + struct scatterlist *sg; 76 + int nents; 77 + u32 sg_off; 78 + u32 len; /* cur_rdma_length */ 79 + u32 offset; 80 + unsigned int dma_nents; 81 + enum dma_data_direction dma_dir; 58 82 }; 59 83 60 84 struct isert_rdma_wr { ··· 87 63 enum iser_ib_op_code iser_ib_op; 88 64 struct ib_sge *ib_sge; 89 65 struct ib_sge s_ib_sge; 90 - int num_sge; 91 - struct scatterlist *sge; 92 66 int send_wr_num; 93 67 struct ib_send_wr *send_wr; 94 68 struct ib_send_wr s_send_wr; 95 - u32 cur_rdma_length; 69 + struct isert_data_buf data; 70 + struct isert_data_buf prot; 96 71 struct fast_reg_descriptor *fr_desc; 97 72 }; 98 73 ··· 164 141 165 142 struct isert_device { 166 143 int use_fastreg; 144 + bool pi_capable; 167 145 int cqs_used; 168 146 int refcount; 169 147 int cq_active_qps[ISERT_MAX_CQ];

+20 -7

drivers/infiniband/ulp/srpt/ib_srpt.c

··· 1078 1078 static int srpt_map_sg_to_ib_sge(struct srpt_rdma_ch *ch, 1079 1079 struct srpt_send_ioctx *ioctx) 1080 1080 { 1081 + struct ib_device *dev = ch->sport->sdev->device; 1081 1082 struct se_cmd *cmd; 1082 1083 struct scatterlist *sg, *sg_orig; 1083 1084 int sg_cnt; ··· 1125 1124 1126 1125 db = ioctx->rbufs; 1127 1126 tsize = cmd->data_length; 1128 - dma_len = sg_dma_len(&sg[0]); 1127 + dma_len = ib_sg_dma_len(dev, &sg[0]); 1129 1128 riu = ioctx->rdma_ius; 1130 1129 1131 1130 /* ··· 1156 1155 ++j; 1157 1156 if (j < count) { 1158 1157 sg = sg_next(sg); 1159 - dma_len = sg_dma_len(sg); 1158 + dma_len = ib_sg_dma_len( 1159 + dev, sg); 1160 1160 } 1161 1161 } 1162 1162 } else { ··· 1194 1192 tsize = cmd->data_length; 1195 1193 riu = ioctx->rdma_ius; 1196 1194 sg = sg_orig; 1197 - dma_len = sg_dma_len(&sg[0]); 1198 - dma_addr = sg_dma_address(&sg[0]); 1195 + dma_len = ib_sg_dma_len(dev, &sg[0]); 1196 + dma_addr = ib_sg_dma_address(dev, &sg[0]); 1199 1197 1200 1198 /* this second loop is really mapped sg_addres to rdma_iu->ib_sge */ 1201 1199 for (i = 0, j = 0; ··· 1218 1216 ++j; 1219 1217 if (j < count) { 1220 1218 sg = sg_next(sg); 1221 - dma_len = sg_dma_len(sg); 1222 - dma_addr = sg_dma_address(sg); 1219 + dma_len = ib_sg_dma_len( 1220 + dev, sg); 1221 + dma_addr = ib_sg_dma_address( 1222 + dev, sg); 1223 1223 } 1224 1224 } 1225 1225 } else { ··· 2584 2580 goto destroy_ib; 2585 2581 } 2586 2582 2587 - ch->sess = transport_init_session(); 2583 + ch->sess = transport_init_session(TARGET_PROT_NORMAL); 2588 2584 if (IS_ERR(ch->sess)) { 2589 2585 rej->reason = __constant_cpu_to_be32( 2590 2586 SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES); ··· 3083 3079 static void srpt_queue_tm_rsp(struct se_cmd *cmd) 3084 3080 { 3085 3081 srpt_queue_response(cmd); 3082 + } 3083 + 3084 + static void srpt_aborted_task(struct se_cmd *cmd) 3085 + { 3086 + struct srpt_send_ioctx *ioctx = container_of(cmd, 3087 + struct srpt_send_ioctx, cmd); 3088 + 3089 + srpt_unmap_sg_to_ib_sge(ioctx->ch, ioctx); 3086 3090 } 3087 3091 3088 3092 static int srpt_queue_status(struct se_cmd *cmd) ··· 3940 3928 .queue_data_in = srpt_queue_data_in, 3941 3929 .queue_status = srpt_queue_status, 3942 3930 .queue_tm_rsp = srpt_queue_tm_rsp, 3931 + .aborted_task = srpt_aborted_task, 3943 3932 /* 3944 3933 * Setup function pointers for generic logic in 3945 3934 * target_core_fabric_configfs.c

+17 -1

drivers/scsi/qla2xxx/tcm_qla2xxx.c

··· 684 684 qlt_xmit_tm_rsp(mcmd); 685 685 } 686 686 687 + static void tcm_qla2xxx_aborted_task(struct se_cmd *se_cmd) 688 + { 689 + struct qla_tgt_cmd *cmd = container_of(se_cmd, 690 + struct qla_tgt_cmd, se_cmd); 691 + struct scsi_qla_host *vha = cmd->vha; 692 + struct qla_hw_data *ha = vha->hw; 693 + 694 + if (!cmd->sg_mapped) 695 + return; 696 + 697 + pci_unmap_sg(ha->pdev, cmd->sg, cmd->sg_cnt, cmd->dma_data_direction); 698 + cmd->sg_mapped = 0; 699 + } 700 + 687 701 /* Local pointer to allocated TCM configfs fabric module */ 688 702 struct target_fabric_configfs *tcm_qla2xxx_fabric_configfs; 689 703 struct target_fabric_configfs *tcm_qla2xxx_npiv_fabric_configfs; ··· 1482 1468 } 1483 1469 se_tpg = &tpg->se_tpg; 1484 1470 1485 - se_sess = transport_init_session(); 1471 + se_sess = transport_init_session(TARGET_PROT_NORMAL); 1486 1472 if (IS_ERR(se_sess)) { 1487 1473 pr_err("Unable to initialize struct se_session\n"); 1488 1474 return PTR_ERR(se_sess); ··· 1891 1877 .queue_data_in = tcm_qla2xxx_queue_data_in, 1892 1878 .queue_status = tcm_qla2xxx_queue_status, 1893 1879 .queue_tm_rsp = tcm_qla2xxx_queue_tm_rsp, 1880 + .aborted_task = tcm_qla2xxx_aborted_task, 1894 1881 /* 1895 1882 * Setup function pointers for generic logic in 1896 1883 * target_core_fabric_configfs.c ··· 1941 1926 .queue_data_in = tcm_qla2xxx_queue_data_in, 1942 1927 .queue_status = tcm_qla2xxx_queue_status, 1943 1928 .queue_tm_rsp = tcm_qla2xxx_queue_tm_rsp, 1929 + .aborted_task = tcm_qla2xxx_aborted_task, 1944 1930 /* 1945 1931 * Setup function pointers for generic logic in 1946 1932 * target_core_fabric_configfs.c

+32 -1

drivers/target/iscsi/iscsi_target.c

··· 499 499 return 0; 500 500 } 501 501 502 + static void iscsit_aborted_task(struct iscsi_conn *conn, struct iscsi_cmd *cmd) 503 + { 504 + bool scsi_cmd = (cmd->iscsi_opcode == ISCSI_OP_SCSI_CMD); 505 + 506 + spin_lock_bh(&conn->cmd_lock); 507 + if (!list_empty(&cmd->i_conn_node)) 508 + list_del_init(&cmd->i_conn_node); 509 + spin_unlock_bh(&conn->cmd_lock); 510 + 511 + __iscsit_free_cmd(cmd, scsi_cmd, true); 512 + } 513 + 514 + static enum target_prot_op iscsit_get_sup_prot_ops(struct iscsi_conn *conn) 515 + { 516 + return TARGET_PROT_NORMAL; 517 + } 518 + 502 519 static struct iscsit_transport iscsi_target_transport = { 503 520 .name = "iSCSI/TCP", 504 521 .transport_type = ISCSI_TCP, ··· 530 513 .iscsit_response_queue = iscsit_response_queue, 531 514 .iscsit_queue_data_in = iscsit_queue_rsp, 532 515 .iscsit_queue_status = iscsit_queue_rsp, 516 + .iscsit_aborted_task = iscsit_aborted_task, 517 + .iscsit_get_sup_prot_ops = iscsit_get_sup_prot_ops, 533 518 }; 534 519 535 520 static int __init iscsi_target_init_module(void) ··· 1522 1503 { 1523 1504 u32 payload_length = ntoh24(hdr->dlength); 1524 1505 1506 + if (!(hdr->flags & ISCSI_FLAG_CMD_FINAL)) { 1507 + pr_err("NopOUT Flag's, Left Most Bit not set, protocol error.\n"); 1508 + if (!cmd) 1509 + return iscsit_add_reject(conn, ISCSI_REASON_PROTOCOL_ERROR, 1510 + (unsigned char *)hdr); 1511 + 1512 + return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR, 1513 + (unsigned char *)hdr); 1514 + } 1515 + 1525 1516 if (hdr->itt == RESERVED_ITT && !(hdr->opcode & ISCSI_OP_IMMEDIATE)) { 1526 1517 pr_err("NOPOUT ITT is reserved, but Immediate Bit is" 1527 1518 " not set, protocol error.\n"); ··· 2497 2468 { 2498 2469 struct iscsi_cmd *cmd; 2499 2470 struct iscsi_conn *conn_p; 2471 + bool found = false; 2500 2472 2501 2473 /* 2502 2474 * Only send a Asynchronous Message on connections whos network ··· 2506 2476 list_for_each_entry(conn_p, &conn->sess->sess_conn_list, conn_list) { 2507 2477 if (conn_p->conn_state == TARG_CONN_STATE_LOGGED_IN) { 2508 2478 iscsit_inc_conn_usage_count(conn_p); 2479 + found = true; 2509 2480 break; 2510 2481 } 2511 2482 } 2512 2483 2513 - if (!conn_p) 2484 + if (!found) 2514 2485 return; 2515 2486 2516 2487 cmd = iscsit_allocate_cmd(conn_p, TASK_RUNNING);

+14

drivers/target/iscsi/iscsi_target_configfs.c

··· 1052 1052 */ 1053 1053 DEF_TPG_ATTRIB(default_erl); 1054 1054 TPG_ATTR(default_erl, S_IRUGO | S_IWUSR); 1055 + /* 1056 + * Define iscsi_tpg_attrib_s_t10_pi 1057 + */ 1058 + DEF_TPG_ATTRIB(t10_pi); 1059 + TPG_ATTR(t10_pi, S_IRUGO | S_IWUSR); 1055 1060 1056 1061 static struct configfs_attribute *lio_target_tpg_attrib_attrs[] = { 1057 1062 &iscsi_tpg_attrib_authentication.attr, ··· 1069 1064 &iscsi_tpg_attrib_prod_mode_write_protect.attr, 1070 1065 &iscsi_tpg_attrib_demo_mode_discovery.attr, 1071 1066 &iscsi_tpg_attrib_default_erl.attr, 1067 + &iscsi_tpg_attrib_t10_pi.attr, 1072 1068 NULL, 1073 1069 }; 1074 1070 ··· 1821 1815 iscsit_add_cmd_to_response_queue(cmd, cmd->conn, cmd->i_state); 1822 1816 } 1823 1817 1818 + static void lio_aborted_task(struct se_cmd *se_cmd) 1819 + { 1820 + struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd); 1821 + 1822 + cmd->conn->conn_transport->iscsit_aborted_task(cmd->conn, cmd); 1823 + } 1824 + 1824 1825 static char *lio_tpg_get_endpoint_wwn(struct se_portal_group *se_tpg) 1825 1826 { 1826 1827 struct iscsi_portal_group *tpg = se_tpg->se_tpg_fabric_ptr; ··· 2012 1999 fabric->tf_ops.queue_data_in = &lio_queue_data_in; 2013 2000 fabric->tf_ops.queue_status = &lio_queue_status; 2014 2001 fabric->tf_ops.queue_tm_rsp = &lio_queue_tm_rsp; 2002 + fabric->tf_ops.aborted_task = &lio_aborted_task; 2015 2003 /* 2016 2004 * Setup function pointers for generic logic in target_core_fabric_configfs.c 2017 2005 */

+4 -1

drivers/target/iscsi/iscsi_target_core.h

··· 58 58 #define TA_DEMO_MODE_DISCOVERY 1 59 59 #define TA_DEFAULT_ERL 0 60 60 #define TA_CACHE_CORE_NPS 0 61 - 61 + /* T10 protection information disabled by default */ 62 + #define TA_DEFAULT_T10_PI 0 62 63 63 64 #define ISCSI_IOV_DATA_BUFFER 5 64 65 ··· 766 765 u32 prod_mode_write_protect; 767 766 u32 demo_mode_discovery; 768 767 u32 default_erl; 768 + u8 t10_pi; 769 769 struct iscsi_portal_group *tpg; 770 770 }; 771 771 ··· 789 787 void *np_context; 790 788 struct iscsit_transport *np_transport; 791 789 struct list_head np_list; 790 + struct iscsi_tpg_np *tpg_np; 792 791 } ____cacheline_aligned; 793 792 794 793 struct iscsi_tpg_np {

+3 -1

drivers/target/iscsi/iscsi_target_login.c

··· 259 259 { 260 260 struct iscsi_session *sess = NULL; 261 261 struct iscsi_login_req *pdu = (struct iscsi_login_req *)buf; 262 + enum target_prot_op sup_pro_ops; 262 263 int ret; 263 264 264 265 sess = kzalloc(sizeof(struct iscsi_session), GFP_KERNEL); ··· 321 320 kfree(sess); 322 321 return -ENOMEM; 323 322 } 323 + sup_pro_ops = conn->conn_transport->iscsit_get_sup_prot_ops(conn); 324 324 325 - sess->se_sess = transport_init_session(); 325 + sess->se_sess = transport_init_session(sup_pro_ops); 326 326 if (IS_ERR(sess->se_sess)) { 327 327 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR, 328 328 ISCSI_LOGIN_STATUS_NO_RESOURCES);

+21

drivers/target/iscsi/iscsi_target_tpg.c

··· 225 225 a->prod_mode_write_protect = TA_PROD_MODE_WRITE_PROTECT; 226 226 a->demo_mode_discovery = TA_DEMO_MODE_DISCOVERY; 227 227 a->default_erl = TA_DEFAULT_ERL; 228 + a->t10_pi = TA_DEFAULT_T10_PI; 228 229 } 229 230 230 231 int iscsit_tpg_add_portal_group(struct iscsi_tiqn *tiqn, struct iscsi_portal_group *tpg) ··· 501 500 init_completion(&tpg_np->tpg_np_comp); 502 501 kref_init(&tpg_np->tpg_np_kref); 503 502 tpg_np->tpg_np = np; 503 + np->tpg_np = tpg_np; 504 504 tpg_np->tpg = tpg; 505 505 506 506 spin_lock(&tpg->tpg_np_lock); ··· 857 855 858 856 a->default_erl = default_erl; 859 857 pr_debug("iSCSI_TPG[%hu] - DefaultERL: %u\n", tpg->tpgt, a->default_erl); 858 + 859 + return 0; 860 + } 861 + 862 + int iscsit_ta_t10_pi( 863 + struct iscsi_portal_group *tpg, 864 + u32 flag) 865 + { 866 + struct iscsi_tpg_attrib *a = &tpg->tpg_attrib; 867 + 868 + if ((flag != 0) && (flag != 1)) { 869 + pr_err("Illegal value %d\n", flag); 870 + return -EINVAL; 871 + } 872 + 873 + a->t10_pi = flag; 874 + pr_debug("iSCSI_TPG[%hu] - T10 Protection information bit:" 875 + " %s\n", tpg->tpgt, (a->t10_pi) ? 876 + "ON" : "OFF"); 860 877 861 878 return 0; 862 879 }

+1

drivers/target/iscsi/iscsi_target_tpg.h

··· 39 39 extern int iscsit_ta_prod_mode_write_protect(struct iscsi_portal_group *, u32); 40 40 extern int iscsit_ta_demo_mode_discovery(struct iscsi_portal_group *, u32); 41 41 extern int iscsit_ta_default_erl(struct iscsi_portal_group *, u32); 42 + extern int iscsit_ta_t10_pi(struct iscsi_portal_group *, u32); 42 43 43 44 #endif /* ISCSI_TARGET_TPG_H */

+2 -2

drivers/target/iscsi/iscsi_target_util.c

··· 705 705 } 706 706 EXPORT_SYMBOL(iscsit_release_cmd); 707 707 708 - static void __iscsit_free_cmd(struct iscsi_cmd *cmd, bool scsi_cmd, 709 - bool check_queues) 708 + void __iscsit_free_cmd(struct iscsi_cmd *cmd, bool scsi_cmd, 709 + bool check_queues) 710 710 { 711 711 struct iscsi_conn *conn = cmd->conn; 712 712

+1

drivers/target/iscsi/iscsi_target_util.h

··· 30 30 extern bool iscsit_conn_all_queues_empty(struct iscsi_conn *); 31 31 extern void iscsit_free_queue_reqs_for_conn(struct iscsi_conn *); 32 32 extern void iscsit_release_cmd(struct iscsi_cmd *); 33 + extern void __iscsit_free_cmd(struct iscsi_cmd *, bool, bool); 33 34 extern void iscsit_free_cmd(struct iscsi_cmd *, bool); 34 35 extern int iscsit_check_session_usage_count(struct iscsi_session *); 35 36 extern void iscsit_dec_session_usage_count(struct iscsi_session *);

+11 -1

drivers/target/loopback/tcm_loop.c

··· 212 212 se_cmd->se_cmd_flags |= SCF_BIDI; 213 213 214 214 } 215 + 216 + if (!scsi_prot_sg_count(sc) && scsi_get_prot_op(sc) != SCSI_PROT_NORMAL) 217 + se_cmd->prot_pto = true; 218 + 215 219 rc = target_submit_cmd_map_sgls(se_cmd, tl_nexus->se_sess, sc->cmnd, 216 220 &tl_cmd->tl_sense_buf[0], tl_cmd->sc->device->lun, 217 221 scsi_bufflen(sc), tcm_loop_sam_attr(sc), ··· 919 915 wake_up(&tl_tmr->tl_tmr_wait); 920 916 } 921 917 918 + static void tcm_loop_aborted_task(struct se_cmd *se_cmd) 919 + { 920 + return; 921 + } 922 + 922 923 static char *tcm_loop_dump_proto_id(struct tcm_loop_hba *tl_hba) 923 924 { 924 925 switch (tl_hba->tl_proto_id) { ··· 1018 1009 /* 1019 1010 * Initialize the struct se_session pointer 1020 1011 */ 1021 - tl_nexus->se_sess = transport_init_session(); 1012 + tl_nexus->se_sess = transport_init_session(TARGET_PROT_ALL); 1022 1013 if (IS_ERR(tl_nexus->se_sess)) { 1023 1014 ret = PTR_ERR(tl_nexus->se_sess); 1024 1015 goto out; ··· 1492 1483 fabric->tf_ops.queue_data_in = &tcm_loop_queue_data_in; 1493 1484 fabric->tf_ops.queue_status = &tcm_loop_queue_status; 1494 1485 fabric->tf_ops.queue_tm_rsp = &tcm_loop_queue_tm_rsp; 1486 + fabric->tf_ops.aborted_task = &tcm_loop_aborted_task; 1495 1487 1496 1488 /* 1497 1489 * Setup function pointers for generic logic in target_core_fabric_configfs.c

+7 -1

drivers/target/sbp/sbp_target.c

··· 210 210 return ERR_PTR(-ENOMEM); 211 211 } 212 212 213 - sess->se_sess = transport_init_session(); 213 + sess->se_sess = transport_init_session(TARGET_PROT_NORMAL); 214 214 if (IS_ERR(sess->se_sess)) { 215 215 pr_err("failed to init se_session\n"); 216 216 ··· 1846 1846 { 1847 1847 } 1848 1848 1849 + static void sbp_aborted_task(struct se_cmd *se_cmd) 1850 + { 1851 + return; 1852 + } 1853 + 1849 1854 static int sbp_check_stop_free(struct se_cmd *se_cmd) 1850 1855 { 1851 1856 struct sbp_target_request *req = container_of(se_cmd, ··· 2531 2526 .queue_data_in = sbp_queue_data_in, 2532 2527 .queue_status = sbp_queue_status, 2533 2528 .queue_tm_rsp = sbp_queue_tm_rsp, 2529 + .aborted_task = sbp_aborted_task, 2534 2530 .check_stop_free = sbp_check_stop_free, 2535 2531 2536 2532 .fabric_make_wwn = sbp_make_tport,

+44 -51

drivers/target/target_core_alua.c

··· 455 455 return rc; 456 456 } 457 457 458 - static inline int core_alua_state_nonoptimized( 458 + static inline void set_ascq(struct se_cmd *cmd, u8 alua_ascq) 459 + { 460 + /* 461 + * Set SCSI additional sense code (ASC) to 'LUN Not Accessible'; 462 + * The ALUA additional sense code qualifier (ASCQ) is determined 463 + * by the ALUA primary or secondary access state.. 464 + */ 465 + pr_debug("[%s]: ALUA TG Port not available, " 466 + "SenseKey: NOT_READY, ASC/ASCQ: " 467 + "0x04/0x%02x\n", 468 + cmd->se_tfo->get_fabric_name(), alua_ascq); 469 + 470 + cmd->scsi_asc = 0x04; 471 + cmd->scsi_ascq = alua_ascq; 472 + } 473 + 474 + static inline void core_alua_state_nonoptimized( 459 475 struct se_cmd *cmd, 460 476 unsigned char *cdb, 461 - int nonop_delay_msecs, 462 - u8 *alua_ascq) 477 + int nonop_delay_msecs) 463 478 { 464 479 /* 465 480 * Set SCF_ALUA_NON_OPTIMIZED here, this value will be checked ··· 483 468 */ 484 469 cmd->se_cmd_flags |= SCF_ALUA_NON_OPTIMIZED; 485 470 cmd->alua_nonop_delay = nonop_delay_msecs; 486 - return 0; 487 471 } 488 472 489 473 static inline int core_alua_state_lba_dependent( 490 474 struct se_cmd *cmd, 491 - struct t10_alua_tg_pt_gp *tg_pt_gp, 492 - u8 *alua_ascq) 475 + struct t10_alua_tg_pt_gp *tg_pt_gp) 493 476 { 494 477 struct se_device *dev = cmd->se_dev; 495 478 u64 segment_size, segment_mult, sectors, lba; ··· 533 520 } 534 521 if (!cur_map) { 535 522 spin_unlock(&dev->t10_alua.lba_map_lock); 536 - *alua_ascq = ASCQ_04H_ALUA_TG_PT_UNAVAILABLE; 523 + set_ascq(cmd, ASCQ_04H_ALUA_TG_PT_UNAVAILABLE); 537 524 return 1; 538 525 } 539 526 list_for_each_entry(map_mem, &cur_map->lba_map_mem_list, ··· 544 531 switch(map_mem->lba_map_mem_alua_state) { 545 532 case ALUA_ACCESS_STATE_STANDBY: 546 533 spin_unlock(&dev->t10_alua.lba_map_lock); 547 - *alua_ascq = ASCQ_04H_ALUA_TG_PT_STANDBY; 534 + set_ascq(cmd, ASCQ_04H_ALUA_TG_PT_STANDBY); 548 535 return 1; 549 536 case ALUA_ACCESS_STATE_UNAVAILABLE: 550 537 spin_unlock(&dev->t10_alua.lba_map_lock); 551 - *alua_ascq = ASCQ_04H_ALUA_TG_PT_UNAVAILABLE; 538 + set_ascq(cmd, ASCQ_04H_ALUA_TG_PT_UNAVAILABLE); 552 539 return 1; 553 540 default: 554 541 break; ··· 561 548 562 549 static inline int core_alua_state_standby( 563 550 struct se_cmd *cmd, 564 - unsigned char *cdb, 565 - u8 *alua_ascq) 551 + unsigned char *cdb) 566 552 { 567 553 /* 568 554 * Allowed CDBs for ALUA_ACCESS_STATE_STANDBY as defined by ··· 582 570 case MI_REPORT_TARGET_PGS: 583 571 return 0; 584 572 default: 585 - *alua_ascq = ASCQ_04H_ALUA_TG_PT_STANDBY; 573 + set_ascq(cmd, ASCQ_04H_ALUA_TG_PT_STANDBY); 586 574 return 1; 587 575 } 588 576 case MAINTENANCE_OUT: ··· 590 578 case MO_SET_TARGET_PGS: 591 579 return 0; 592 580 default: 593 - *alua_ascq = ASCQ_04H_ALUA_TG_PT_STANDBY; 581 + set_ascq(cmd, ASCQ_04H_ALUA_TG_PT_STANDBY); 594 582 return 1; 595 583 } 596 584 case REQUEST_SENSE: ··· 600 588 case WRITE_BUFFER: 601 589 return 0; 602 590 default: 603 - *alua_ascq = ASCQ_04H_ALUA_TG_PT_STANDBY; 591 + set_ascq(cmd, ASCQ_04H_ALUA_TG_PT_STANDBY); 604 592 return 1; 605 593 } 606 594 ··· 609 597 610 598 static inline int core_alua_state_unavailable( 611 599 struct se_cmd *cmd, 612 - unsigned char *cdb, 613 - u8 *alua_ascq) 600 + unsigned char *cdb) 614 601 { 615 602 /* 616 603 * Allowed CDBs for ALUA_ACCESS_STATE_UNAVAILABLE as defined by ··· 624 613 case MI_REPORT_TARGET_PGS: 625 614 return 0; 626 615 default: 627 - *alua_ascq = ASCQ_04H_ALUA_TG_PT_UNAVAILABLE; 616 + set_ascq(cmd, ASCQ_04H_ALUA_TG_PT_UNAVAILABLE); 628 617 return 1; 629 618 } 630 619 case MAINTENANCE_OUT: ··· 632 621 case MO_SET_TARGET_PGS: 633 622 return 0; 634 623 default: 635 - *alua_ascq = ASCQ_04H_ALUA_TG_PT_UNAVAILABLE; 624 + set_ascq(cmd, ASCQ_04H_ALUA_TG_PT_UNAVAILABLE); 636 625 return 1; 637 626 } 638 627 case REQUEST_SENSE: ··· 640 629 case WRITE_BUFFER: 641 630 return 0; 642 631 default: 643 - *alua_ascq = ASCQ_04H_ALUA_TG_PT_UNAVAILABLE; 632 + set_ascq(cmd, ASCQ_04H_ALUA_TG_PT_UNAVAILABLE); 644 633 return 1; 645 634 } 646 635 ··· 649 638 650 639 static inline int core_alua_state_transition( 651 640 struct se_cmd *cmd, 652 - unsigned char *cdb, 653 - u8 *alua_ascq) 641 + unsigned char *cdb) 654 642 { 655 643 /* 656 644 * Allowed CDBs for ALUA_ACCESS_STATE_TRANSITION as defined by ··· 664 654 case MI_REPORT_TARGET_PGS: 665 655 return 0; 666 656 default: 667 - *alua_ascq = ASCQ_04H_ALUA_STATE_TRANSITION; 657 + set_ascq(cmd, ASCQ_04H_ALUA_STATE_TRANSITION); 668 658 return 1; 669 659 } 670 660 case REQUEST_SENSE: ··· 672 662 case WRITE_BUFFER: 673 663 return 0; 674 664 default: 675 - *alua_ascq = ASCQ_04H_ALUA_STATE_TRANSITION; 665 + set_ascq(cmd, ASCQ_04H_ALUA_STATE_TRANSITION); 676 666 return 1; 677 667 } 678 668 ··· 694 684 struct t10_alua_tg_pt_gp *tg_pt_gp; 695 685 struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem; 696 686 int out_alua_state, nonop_delay_msecs; 697 - u8 alua_ascq; 698 - int ret; 699 687 700 688 if (dev->se_hba->hba_flags & HBA_FLAGS_INTERNAL_USE) 701 689 return 0; ··· 709 701 if (atomic_read(&port->sep_tg_pt_secondary_offline)) { 710 702 pr_debug("ALUA: Got secondary offline status for local" 711 703 " target port\n"); 712 - alua_ascq = ASCQ_04H_ALUA_OFFLINE; 713 - ret = 1; 714 - goto out; 704 + set_ascq(cmd, ASCQ_04H_ALUA_OFFLINE); 705 + return TCM_CHECK_CONDITION_NOT_READY; 715 706 } 716 707 /* 717 708 * Second, obtain the struct t10_alua_tg_pt_gp_member pointer to the ··· 738 731 739 732 switch (out_alua_state) { 740 733 case ALUA_ACCESS_STATE_ACTIVE_NON_OPTIMIZED: 741 - ret = core_alua_state_nonoptimized(cmd, cdb, 742 - nonop_delay_msecs, &alua_ascq); 734 + core_alua_state_nonoptimized(cmd, cdb, nonop_delay_msecs); 743 735 break; 744 736 case ALUA_ACCESS_STATE_STANDBY: 745 - ret = core_alua_state_standby(cmd, cdb, &alua_ascq); 737 + if (core_alua_state_standby(cmd, cdb)) 738 + return TCM_CHECK_CONDITION_NOT_READY; 746 739 break; 747 740 case ALUA_ACCESS_STATE_UNAVAILABLE: 748 - ret = core_alua_state_unavailable(cmd, cdb, &alua_ascq); 741 + if (core_alua_state_unavailable(cmd, cdb)) 742 + return TCM_CHECK_CONDITION_NOT_READY; 749 743 break; 750 744 case ALUA_ACCESS_STATE_TRANSITION: 751 - ret = core_alua_state_transition(cmd, cdb, &alua_ascq); 745 + if (core_alua_state_transition(cmd, cdb)) 746 + return TCM_CHECK_CONDITION_NOT_READY; 752 747 break; 753 748 case ALUA_ACCESS_STATE_LBA_DEPENDENT: 754 - ret = core_alua_state_lba_dependent(cmd, tg_pt_gp, &alua_ascq); 749 + if (core_alua_state_lba_dependent(cmd, tg_pt_gp)) 750 + return TCM_CHECK_CONDITION_NOT_READY; 755 751 break; 756 752 /* 757 753 * OFFLINE is a secondary ALUA target port group access state, that is ··· 765 755 pr_err("Unknown ALUA access state: 0x%02x\n", 766 756 out_alua_state); 767 757 return TCM_INVALID_CDB_FIELD; 768 - } 769 - 770 - out: 771 - if (ret > 0) { 772 - /* 773 - * Set SCSI additional sense code (ASC) to 'LUN Not Accessible'; 774 - * The ALUA additional sense code qualifier (ASCQ) is determined 775 - * by the ALUA primary or secondary access state.. 776 - */ 777 - pr_debug("[%s]: ALUA TG Port not available, " 778 - "SenseKey: NOT_READY, ASC/ASCQ: " 779 - "0x04/0x%02x\n", 780 - cmd->se_tfo->get_fabric_name(), alua_ascq); 781 - 782 - cmd->scsi_asc = 0x04; 783 - cmd->scsi_ascq = alua_ascq; 784 - return TCM_CHECK_CONDITION_NOT_READY; 785 758 } 786 759 787 760 return 0;

+4

drivers/target/target_core_configfs.c

··· 457 457 pr_err("Missing tfo->queue_tm_rsp()\n"); 458 458 return -EINVAL; 459 459 } 460 + if (!tfo->aborted_task) { 461 + pr_err("Missing tfo->aborted_task()\n"); 462 + return -EINVAL; 463 + } 460 464 /* 461 465 * We at least require tfo->fabric_make_wwn(), tfo->fabric_drop_wwn() 462 466 * tfo->fabric_make_tpg() and tfo->fabric_drop_tpg() in

+1 -39

drivers/target/target_core_file.c

··· 854 854 return 0; 855 855 } 856 856 857 - static void fd_init_format_buf(struct se_device *dev, unsigned char *buf, 858 - u32 unit_size, u32 *ref_tag, u16 app_tag, 859 - bool inc_reftag) 860 - { 861 - unsigned char *p = buf; 862 - int i; 863 - 864 - for (i = 0; i < unit_size; i += dev->prot_length) { 865 - *((u16 *)&p[0]) = 0xffff; 866 - *((__be16 *)&p[2]) = cpu_to_be16(app_tag); 867 - *((__be32 *)&p[4]) = cpu_to_be32(*ref_tag); 868 - 869 - if (inc_reftag) 870 - (*ref_tag)++; 871 - 872 - p += dev->prot_length; 873 - } 874 - } 875 - 876 857 static int fd_format_prot(struct se_device *dev) 877 858 { 878 859 struct fd_dev *fd_dev = FD_DEV(dev); ··· 861 880 sector_t prot_length, prot; 862 881 unsigned char *buf; 863 882 loff_t pos = 0; 864 - u32 ref_tag = 0; 865 883 int unit_size = FDBD_FORMAT_UNIT_SIZE * dev->dev_attrib.block_size; 866 884 int rc, ret = 0, size, len; 867 - bool inc_reftag = false; 868 885 869 886 if (!dev->dev_attrib.pi_prot_type) { 870 887 pr_err("Unable to format_prot while pi_prot_type == 0\n"); ··· 873 894 return -ENODEV; 874 895 } 875 896 876 - switch (dev->dev_attrib.pi_prot_type) { 877 - case TARGET_DIF_TYPE3_PROT: 878 - ref_tag = 0xffffffff; 879 - break; 880 - case TARGET_DIF_TYPE2_PROT: 881 - case TARGET_DIF_TYPE1_PROT: 882 - inc_reftag = true; 883 - break; 884 - default: 885 - break; 886 - } 887 - 888 897 buf = vzalloc(unit_size); 889 898 if (!buf) { 890 899 pr_err("Unable to allocate FILEIO prot buf\n"); 891 900 return -ENOMEM; 892 901 } 893 - 894 902 prot_length = (dev->transport->get_blocks(dev) + 1) * dev->prot_length; 895 903 size = prot_length; 896 904 897 905 pr_debug("Using FILEIO prot_length: %llu\n", 898 906 (unsigned long long)prot_length); 899 907 908 + memset(buf, 0xff, unit_size); 900 909 for (prot = 0; prot < prot_length; prot += unit_size) { 901 - 902 - fd_init_format_buf(dev, buf, unit_size, &ref_tag, 0xffff, 903 - inc_reftag); 904 - 905 910 len = min(unit_size, size); 906 - 907 911 rc = kernel_write(prot_fd, buf, len, pos); 908 912 if (rc != len) { 909 913 pr_err("vfs_write to prot file failed: %d\n", rc);

+2 -3

drivers/target/target_core_iblock.c

··· 203 203 204 204 if (ib_dev->ibd_bd != NULL) 205 205 blkdev_put(ib_dev->ibd_bd, FMODE_WRITE|FMODE_READ|FMODE_EXCL); 206 - if (ib_dev->ibd_bio_set != NULL) { 207 - bioset_integrity_free(ib_dev->ibd_bio_set); 206 + if (ib_dev->ibd_bio_set != NULL) 208 207 bioset_free(ib_dev->ibd_bio_set); 209 - } 208 + 210 209 kfree(ib_dev); 211 210 } 212 211

+10 -4

drivers/target/target_core_rd.c

··· 242 242 rd_dev->sg_prot_count = 0; 243 243 } 244 244 245 - static int rd_build_prot_space(struct rd_dev *rd_dev, int prot_length) 245 + static int rd_build_prot_space(struct rd_dev *rd_dev, int prot_length, int block_size) 246 246 { 247 247 struct rd_dev_sg_table *sg_table; 248 248 u32 total_sg_needed, sg_tables; ··· 252 252 253 253 if (rd_dev->rd_flags & RDF_NULLIO) 254 254 return 0; 255 - 256 - total_sg_needed = rd_dev->rd_page_count / prot_length; 255 + /* 256 + * prot_length=8byte dif data 257 + * tot sg needed = rd_page_count * (PGSZ/block_size) * 258 + * (prot_length/block_size) + pad 259 + * PGSZ canceled each other. 260 + */ 261 + total_sg_needed = (rd_dev->rd_page_count * prot_length / block_size) + 1; 257 262 258 263 sg_tables = (total_sg_needed / max_sg_per_table) + 1; 259 264 ··· 611 606 if (!dev->dev_attrib.pi_prot_type) 612 607 return 0; 613 608 614 - return rd_build_prot_space(rd_dev, dev->prot_length); 609 + return rd_build_prot_space(rd_dev, dev->prot_length, 610 + dev->dev_attrib.block_size); 615 611 } 616 612 617 613 static void rd_free_prot(struct se_device *dev)

+155 -23

drivers/target/target_core_sbc.c

··· 89 89 sbc_emulate_readcapacity_16(struct se_cmd *cmd) 90 90 { 91 91 struct se_device *dev = cmd->se_dev; 92 + struct se_session *sess = cmd->se_sess; 92 93 unsigned char *rbuf; 93 94 unsigned char buf[32]; 94 95 unsigned long long blocks = dev->transport->get_blocks(dev); ··· 110 109 /* 111 110 * Set P_TYPE and PROT_EN bits for DIF support 112 111 */ 113 - if (dev->dev_attrib.pi_prot_type) 114 - buf[12] = (dev->dev_attrib.pi_prot_type - 1) << 1 | 0x1; 112 + if (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) { 113 + if (dev->dev_attrib.pi_prot_type) 114 + buf[12] = (dev->dev_attrib.pi_prot_type - 1) << 1 | 0x1; 115 + } 115 116 116 117 if (dev->transport->get_lbppbe) 117 118 buf[13] = dev->transport->get_lbppbe(dev) & 0x0f; ··· 428 425 goto out; 429 426 } 430 427 431 - write_sg = kzalloc(sizeof(struct scatterlist) * cmd->t_data_nents, 428 + write_sg = kmalloc(sizeof(struct scatterlist) * cmd->t_data_nents, 432 429 GFP_KERNEL); 433 430 if (!write_sg) { 434 431 pr_err("Unable to allocate compare_and_write sg\n"); 435 432 ret = TCM_OUT_OF_RESOURCES; 436 433 goto out; 437 434 } 435 + sg_init_table(write_sg, cmd->t_data_nents); 438 436 /* 439 437 * Setup verify and write data payloads from total NumberLBAs. 440 438 */ ··· 573 569 return TCM_NO_SENSE; 574 570 } 575 571 572 + static int 573 + sbc_set_prot_op_checks(u8 protect, enum target_prot_type prot_type, 574 + bool is_write, struct se_cmd *cmd) 575 + { 576 + if (is_write) { 577 + cmd->prot_op = protect ? TARGET_PROT_DOUT_PASS : 578 + TARGET_PROT_DOUT_INSERT; 579 + switch (protect) { 580 + case 0x0: 581 + case 0x3: 582 + cmd->prot_checks = 0; 583 + break; 584 + case 0x1: 585 + case 0x5: 586 + cmd->prot_checks = TARGET_DIF_CHECK_GUARD; 587 + if (prot_type == TARGET_DIF_TYPE1_PROT) 588 + cmd->prot_checks |= TARGET_DIF_CHECK_REFTAG; 589 + break; 590 + case 0x2: 591 + if (prot_type == TARGET_DIF_TYPE1_PROT) 592 + cmd->prot_checks = TARGET_DIF_CHECK_REFTAG; 593 + break; 594 + case 0x4: 595 + cmd->prot_checks = TARGET_DIF_CHECK_GUARD; 596 + break; 597 + default: 598 + pr_err("Unsupported protect field %d\n", protect); 599 + return -EINVAL; 600 + } 601 + } else { 602 + cmd->prot_op = protect ? TARGET_PROT_DIN_PASS : 603 + TARGET_PROT_DIN_STRIP; 604 + switch (protect) { 605 + case 0x0: 606 + case 0x1: 607 + case 0x5: 608 + cmd->prot_checks = TARGET_DIF_CHECK_GUARD; 609 + if (prot_type == TARGET_DIF_TYPE1_PROT) 610 + cmd->prot_checks |= TARGET_DIF_CHECK_REFTAG; 611 + break; 612 + case 0x2: 613 + if (prot_type == TARGET_DIF_TYPE1_PROT) 614 + cmd->prot_checks = TARGET_DIF_CHECK_REFTAG; 615 + break; 616 + case 0x3: 617 + cmd->prot_checks = 0; 618 + break; 619 + case 0x4: 620 + cmd->prot_checks = TARGET_DIF_CHECK_GUARD; 621 + break; 622 + default: 623 + pr_err("Unsupported protect field %d\n", protect); 624 + return -EINVAL; 625 + } 626 + } 627 + 628 + return 0; 629 + } 630 + 576 631 static bool 577 632 sbc_check_prot(struct se_device *dev, struct se_cmd *cmd, unsigned char *cdb, 578 - u32 sectors) 633 + u32 sectors, bool is_write) 579 634 { 580 - if (!cmd->t_prot_sg || !cmd->t_prot_nents) 635 + u8 protect = cdb[1] >> 5; 636 + 637 + if ((!cmd->t_prot_sg || !cmd->t_prot_nents) && cmd->prot_pto) 581 638 return true; 582 639 583 640 switch (dev->dev_attrib.pi_prot_type) { 584 641 case TARGET_DIF_TYPE3_PROT: 585 - if (!(cdb[1] & 0xe0)) 586 - return true; 587 - 588 642 cmd->reftag_seed = 0xffffffff; 589 643 break; 590 644 case TARGET_DIF_TYPE2_PROT: 591 - if (cdb[1] & 0xe0) 645 + if (protect) 592 646 return false; 593 647 594 648 cmd->reftag_seed = cmd->t_task_lba; 595 649 break; 596 650 case TARGET_DIF_TYPE1_PROT: 597 - if (!(cdb[1] & 0xe0)) 598 - return true; 599 - 600 651 cmd->reftag_seed = cmd->t_task_lba; 601 652 break; 602 653 case TARGET_DIF_TYPE0_PROT: ··· 659 600 return true; 660 601 } 661 602 603 + if (sbc_set_prot_op_checks(protect, dev->dev_attrib.pi_prot_type, 604 + is_write, cmd)) 605 + return false; 606 + 662 607 cmd->prot_type = dev->dev_attrib.pi_prot_type; 663 608 cmd->prot_length = dev->prot_length * sectors; 664 - cmd->prot_handover = PROT_SEPERATED; 609 + pr_debug("%s: prot_type=%d, prot_length=%d prot_op=%d prot_checks=%d\n", 610 + __func__, cmd->prot_type, cmd->prot_length, 611 + cmd->prot_op, cmd->prot_checks); 665 612 666 613 return true; 667 614 } ··· 693 628 sectors = transport_get_sectors_10(cdb); 694 629 cmd->t_task_lba = transport_lba_32(cdb); 695 630 696 - if (!sbc_check_prot(dev, cmd, cdb, sectors)) 631 + if (!sbc_check_prot(dev, cmd, cdb, sectors, false)) 697 632 return TCM_UNSUPPORTED_SCSI_OPCODE; 698 633 699 634 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; ··· 704 639 sectors = transport_get_sectors_12(cdb); 705 640 cmd->t_task_lba = transport_lba_32(cdb); 706 641 707 - if (!sbc_check_prot(dev, cmd, cdb, sectors)) 642 + if (!sbc_check_prot(dev, cmd, cdb, sectors, false)) 708 643 return TCM_UNSUPPORTED_SCSI_OPCODE; 709 644 710 645 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; ··· 715 650 sectors = transport_get_sectors_16(cdb); 716 651 cmd->t_task_lba = transport_lba_64(cdb); 717 652 718 - if (!sbc_check_prot(dev, cmd, cdb, sectors)) 653 + if (!sbc_check_prot(dev, cmd, cdb, sectors, false)) 719 654 return TCM_UNSUPPORTED_SCSI_OPCODE; 720 655 721 656 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; ··· 734 669 sectors = transport_get_sectors_10(cdb); 735 670 cmd->t_task_lba = transport_lba_32(cdb); 736 671 737 - if (!sbc_check_prot(dev, cmd, cdb, sectors)) 672 + if (!sbc_check_prot(dev, cmd, cdb, sectors, true)) 738 673 return TCM_UNSUPPORTED_SCSI_OPCODE; 739 674 740 675 if (cdb[1] & 0x8) ··· 747 682 sectors = transport_get_sectors_12(cdb); 748 683 cmd->t_task_lba = transport_lba_32(cdb); 749 684 750 - if (!sbc_check_prot(dev, cmd, cdb, sectors)) 685 + if (!sbc_check_prot(dev, cmd, cdb, sectors, true)) 751 686 return TCM_UNSUPPORTED_SCSI_OPCODE; 752 687 753 688 if (cdb[1] & 0x8) ··· 760 695 sectors = transport_get_sectors_16(cdb); 761 696 cmd->t_task_lba = transport_lba_64(cdb); 762 697 763 - if (!sbc_check_prot(dev, cmd, cdb, sectors)) 698 + if (!sbc_check_prot(dev, cmd, cdb, sectors, true)) 764 699 return TCM_UNSUPPORTED_SCSI_OPCODE; 765 700 766 701 if (cdb[1] & 0x8) ··· 1096 1031 } 1097 1032 EXPORT_SYMBOL(sbc_execute_unmap); 1098 1033 1034 + void 1035 + sbc_dif_generate(struct se_cmd *cmd) 1036 + { 1037 + struct se_device *dev = cmd->se_dev; 1038 + struct se_dif_v1_tuple *sdt; 1039 + struct scatterlist *dsg, *psg = cmd->t_prot_sg; 1040 + sector_t sector = cmd->t_task_lba; 1041 + void *daddr, *paddr; 1042 + int i, j, offset = 0; 1043 + 1044 + for_each_sg(cmd->t_data_sg, dsg, cmd->t_data_nents, i) { 1045 + daddr = kmap_atomic(sg_page(dsg)) + dsg->offset; 1046 + paddr = kmap_atomic(sg_page(psg)) + psg->offset; 1047 + 1048 + for (j = 0; j < dsg->length; j += dev->dev_attrib.block_size) { 1049 + 1050 + if (offset >= psg->length) { 1051 + kunmap_atomic(paddr); 1052 + psg = sg_next(psg); 1053 + paddr = kmap_atomic(sg_page(psg)) + psg->offset; 1054 + offset = 0; 1055 + } 1056 + 1057 + sdt = paddr + offset; 1058 + sdt->guard_tag = cpu_to_be16(crc_t10dif(daddr + j, 1059 + dev->dev_attrib.block_size)); 1060 + if (dev->dev_attrib.pi_prot_type == TARGET_DIF_TYPE1_PROT) 1061 + sdt->ref_tag = cpu_to_be32(sector & 0xffffffff); 1062 + sdt->app_tag = 0; 1063 + 1064 + pr_debug("DIF WRITE INSERT sector: %llu guard_tag: 0x%04x" 1065 + " app_tag: 0x%04x ref_tag: %u\n", 1066 + (unsigned long long)sector, sdt->guard_tag, 1067 + sdt->app_tag, be32_to_cpu(sdt->ref_tag)); 1068 + 1069 + sector++; 1070 + offset += sizeof(struct se_dif_v1_tuple); 1071 + } 1072 + 1073 + kunmap_atomic(paddr); 1074 + kunmap_atomic(daddr); 1075 + } 1076 + } 1077 + 1099 1078 static sense_reason_t 1100 1079 sbc_dif_v1_verify(struct se_device *dev, struct se_dif_v1_tuple *sdt, 1101 1080 const void *p, sector_t sector, unsigned int ei_lba) ··· 1271 1162 } 1272 1163 EXPORT_SYMBOL(sbc_dif_verify_write); 1273 1164 1274 - sense_reason_t 1275 - sbc_dif_verify_read(struct se_cmd *cmd, sector_t start, unsigned int sectors, 1276 - unsigned int ei_lba, struct scatterlist *sg, int sg_off) 1165 + static sense_reason_t 1166 + __sbc_dif_verify_read(struct se_cmd *cmd, sector_t start, unsigned int sectors, 1167 + unsigned int ei_lba, struct scatterlist *sg, int sg_off) 1277 1168 { 1278 1169 struct se_device *dev = cmd->se_dev; 1279 1170 struct se_dif_v1_tuple *sdt; ··· 1326 1217 kunmap_atomic(paddr); 1327 1218 kunmap_atomic(daddr); 1328 1219 } 1329 - sbc_dif_copy_prot(cmd, sectors, true, sg, sg_off); 1330 1220 1221 + return 0; 1222 + } 1223 + 1224 + sense_reason_t 1225 + sbc_dif_read_strip(struct se_cmd *cmd) 1226 + { 1227 + struct se_device *dev = cmd->se_dev; 1228 + u32 sectors = cmd->prot_length / dev->prot_length; 1229 + 1230 + return __sbc_dif_verify_read(cmd, cmd->t_task_lba, sectors, 0, 1231 + cmd->t_prot_sg, 0); 1232 + } 1233 + 1234 + sense_reason_t 1235 + sbc_dif_verify_read(struct se_cmd *cmd, sector_t start, unsigned int sectors, 1236 + unsigned int ei_lba, struct scatterlist *sg, int sg_off) 1237 + { 1238 + sense_reason_t rc; 1239 + 1240 + rc = __sbc_dif_verify_read(cmd, start, sectors, ei_lba, sg, sg_off); 1241 + if (rc) 1242 + return rc; 1243 + 1244 + sbc_dif_copy_prot(cmd, sectors, true, sg, sg_off); 1331 1245 return 0; 1332 1246 } 1333 1247 EXPORT_SYMBOL(sbc_dif_verify_read);

+31 -18

drivers/target/target_core_spc.c

··· 71 71 { 72 72 struct se_lun *lun = cmd->se_lun; 73 73 struct se_device *dev = cmd->se_dev; 74 + struct se_session *sess = cmd->se_sess; 74 75 75 76 /* Set RMB (removable media) for tape devices */ 76 77 if (dev->transport->get_device_type(dev) == TYPE_TAPE) ··· 102 101 if (dev->dev_attrib.emulate_3pc) 103 102 buf[5] |= 0x8; 104 103 /* 105 - * Set Protection (PROTECT) bit when DIF has been enabled. 104 + * Set Protection (PROTECT) bit when DIF has been enabled on the 105 + * device, and the transport supports VERIFY + PASS. 106 106 */ 107 - if (dev->dev_attrib.pi_prot_type) 108 - buf[5] |= 0x1; 107 + if (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) { 108 + if (dev->dev_attrib.pi_prot_type) 109 + buf[5] |= 0x1; 110 + } 109 111 110 112 buf[7] = 0x2; /* CmdQue=1 */ 111 113 ··· 477 473 spc_emulate_evpd_86(struct se_cmd *cmd, unsigned char *buf) 478 474 { 479 475 struct se_device *dev = cmd->se_dev; 476 + struct se_session *sess = cmd->se_sess; 480 477 481 478 buf[3] = 0x3c; 482 479 /* 483 480 * Set GRD_CHK + REF_CHK for TYPE1 protection, or GRD_CHK 484 481 * only for TYPE3 protection. 485 482 */ 486 - if (dev->dev_attrib.pi_prot_type == TARGET_DIF_TYPE1_PROT) 487 - buf[4] = 0x5; 488 - else if (dev->dev_attrib.pi_prot_type == TARGET_DIF_TYPE3_PROT) 489 - buf[4] = 0x4; 483 + if (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) { 484 + if (dev->dev_attrib.pi_prot_type == TARGET_DIF_TYPE1_PROT) 485 + buf[4] = 0x5; 486 + else if (dev->dev_attrib.pi_prot_type == TARGET_DIF_TYPE3_PROT) 487 + buf[4] = 0x4; 488 + } 490 489 491 490 /* Set HEADSUP, ORDSUP, SIMPSUP */ 492 491 buf[5] = 0x07; ··· 769 762 return ret; 770 763 } 771 764 772 - static int spc_modesense_rwrecovery(struct se_device *dev, u8 pc, u8 *p) 765 + static int spc_modesense_rwrecovery(struct se_cmd *cmd, u8 pc, u8 *p) 773 766 { 774 767 p[0] = 0x01; 775 768 p[1] = 0x0a; ··· 782 775 return 12; 783 776 } 784 777 785 - static int spc_modesense_control(struct se_device *dev, u8 pc, u8 *p) 778 + static int spc_modesense_control(struct se_cmd *cmd, u8 pc, u8 *p) 786 779 { 780 + struct se_device *dev = cmd->se_dev; 781 + struct se_session *sess = cmd->se_sess; 782 + 787 783 p[0] = 0x0a; 788 784 p[1] = 0x0a; 789 785 ··· 878 868 * type, shall not modify the contents of the LOGICAL BLOCK REFERENCE 879 869 * TAG field. 880 870 */ 881 - if (dev->dev_attrib.pi_prot_type) 882 - p[5] |= 0x80; 871 + if (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) { 872 + if (dev->dev_attrib.pi_prot_type) 873 + p[5] |= 0x80; 874 + } 883 875 884 876 p[8] = 0xff; 885 877 p[9] = 0xff; ··· 891 879 return 12; 892 880 } 893 881 894 - static int spc_modesense_caching(struct se_device *dev, u8 pc, u8 *p) 882 + static int spc_modesense_caching(struct se_cmd *cmd, u8 pc, u8 *p) 895 883 { 884 + struct se_device *dev = cmd->se_dev; 885 + 896 886 p[0] = 0x08; 897 887 p[1] = 0x12; 898 888 ··· 910 896 return 20; 911 897 } 912 898 913 - static int spc_modesense_informational_exceptions(struct se_device *dev, u8 pc, unsigned char *p) 899 + static int spc_modesense_informational_exceptions(struct se_cmd *cmd, u8 pc, unsigned char *p) 914 900 { 915 901 p[0] = 0x1c; 916 902 p[1] = 0x0a; ··· 926 912 static struct { 927 913 uint8_t page; 928 914 uint8_t subpage; 929 - int (*emulate)(struct se_device *, u8, unsigned char *); 915 + int (*emulate)(struct se_cmd *, u8, unsigned char *); 930 916 } modesense_handlers[] = { 931 917 { .page = 0x01, .subpage = 0x00, .emulate = spc_modesense_rwrecovery }, 932 918 { .page = 0x08, .subpage = 0x00, .emulate = spc_modesense_caching }, ··· 1064 1050 * the only two possibilities). 1065 1051 */ 1066 1052 if ((modesense_handlers[i].subpage & ~subpage) == 0) { 1067 - ret = modesense_handlers[i].emulate(dev, pc, &buf[length]); 1053 + ret = modesense_handlers[i].emulate(cmd, pc, &buf[length]); 1068 1054 if (!ten && length + ret >= 255) 1069 1055 break; 1070 1056 length += ret; ··· 1077 1063 for (i = 0; i < ARRAY_SIZE(modesense_handlers); ++i) 1078 1064 if (modesense_handlers[i].page == page && 1079 1065 modesense_handlers[i].subpage == subpage) { 1080 - length += modesense_handlers[i].emulate(dev, pc, &buf[length]); 1066 + length += modesense_handlers[i].emulate(cmd, pc, &buf[length]); 1081 1067 goto set_length; 1082 1068 } 1083 1069 ··· 1109 1095 1110 1096 static sense_reason_t spc_emulate_modeselect(struct se_cmd *cmd) 1111 1097 { 1112 - struct se_device *dev = cmd->se_dev; 1113 1098 char *cdb = cmd->t_task_cdb; 1114 1099 bool ten = cdb[0] == MODE_SELECT_10; 1115 1100 int off = ten ? 8 : 4; ··· 1144 1131 if (modesense_handlers[i].page == page && 1145 1132 modesense_handlers[i].subpage == subpage) { 1146 1133 memset(tbuf, 0, SE_MODE_PAGE_BUF); 1147 - length = modesense_handlers[i].emulate(dev, 0, tbuf); 1134 + length = modesense_handlers[i].emulate(cmd, 0, tbuf); 1148 1135 goto check_contents; 1149 1136 } 1150 1137

+11 -12

drivers/target/target_core_tmr.c

··· 87 87 struct se_cmd *cmd, 88 88 int tas) 89 89 { 90 + bool remove = true; 90 91 /* 91 92 * TASK ABORTED status (TAS) bit support 92 93 */ 93 94 if ((tmr_nacl && 94 - (tmr_nacl == cmd->se_sess->se_node_acl)) || tas) 95 + (tmr_nacl != cmd->se_sess->se_node_acl)) && tas) { 96 + remove = false; 95 97 transport_send_task_abort(cmd); 98 + } 96 99 97 - transport_cmd_finish_abort(cmd, 0); 100 + transport_cmd_finish_abort(cmd, remove); 98 101 } 99 102 100 103 static int target_check_cdb_and_preempt(struct list_head *list, ··· 130 127 131 128 if (dev != se_cmd->se_dev) 132 129 continue; 130 + 131 + /* skip se_cmd associated with tmr */ 132 + if (tmr->task_cmd == se_cmd) 133 + continue; 134 + 133 135 ref_tag = se_cmd->se_tfo->get_task_tag(se_cmd); 134 136 if (tmr->ref_task_tag != ref_tag) 135 137 continue; ··· 158 150 159 151 cancel_work_sync(&se_cmd->work); 160 152 transport_wait_for_tasks(se_cmd); 161 - /* 162 - * Now send SAM_STAT_TASK_ABORTED status for the referenced 163 - * se_cmd descriptor.. 164 - */ 165 - transport_send_task_abort(se_cmd); 166 - /* 167 - * Also deal with possible extra acknowledge reference.. 168 - */ 169 - if (se_cmd->se_cmd_flags & SCF_ACK_KREF) 170 - target_put_sess_cmd(se_sess, se_cmd); 171 153 172 154 target_put_sess_cmd(se_sess, se_cmd); 155 + transport_cmd_finish_abort(se_cmd, true); 173 156 174 157 printk("ABORT_TASK: Sending TMR_FUNCTION_COMPLETE for" 175 158 " ref_tag: %d\n", ref_tag);

+81 -11

drivers/target/target_core_transport.c

··· 235 235 sub_api_initialized = 1; 236 236 } 237 237 238 - struct se_session *transport_init_session(void) 238 + struct se_session *transport_init_session(enum target_prot_op sup_prot_ops) 239 239 { 240 240 struct se_session *se_sess; 241 241 ··· 251 251 INIT_LIST_HEAD(&se_sess->sess_wait_list); 252 252 spin_lock_init(&se_sess->sess_cmd_lock); 253 253 kref_init(&se_sess->sess_kref); 254 + se_sess->sup_prot_ops = sup_prot_ops; 254 255 255 256 return se_sess; 256 257 } ··· 289 288 EXPORT_SYMBOL(transport_alloc_session_tags); 290 289 291 290 struct se_session *transport_init_session_tags(unsigned int tag_num, 292 - unsigned int tag_size) 291 + unsigned int tag_size, 292 + enum target_prot_op sup_prot_ops) 293 293 { 294 294 struct se_session *se_sess; 295 295 int rc; 296 296 297 - se_sess = transport_init_session(); 297 + se_sess = transport_init_session(sup_prot_ops); 298 298 if (IS_ERR(se_sess)) 299 299 return se_sess; 300 300 ··· 605 603 606 604 void transport_cmd_finish_abort(struct se_cmd *cmd, int remove) 607 605 { 606 + if (cmd->se_cmd_flags & SCF_SE_LUN_CMD) 607 + transport_lun_remove_cmd(cmd); 608 + /* 609 + * Allow the fabric driver to unmap any resources before 610 + * releasing the descriptor via TFO->release_cmd() 611 + */ 612 + if (remove) 613 + cmd->se_tfo->aborted_task(cmd); 614 + 608 615 if (transport_cmd_check_stop_to_fabric(cmd)) 609 616 return; 610 617 if (remove) ··· 1376 1365 target_put_sess_cmd(se_sess, se_cmd); 1377 1366 return 0; 1378 1367 } 1368 + 1369 + rc = target_setup_cmd_from_cdb(se_cmd, cdb); 1370 + if (rc != 0) { 1371 + transport_generic_request_failure(se_cmd, rc); 1372 + return 0; 1373 + } 1374 + 1379 1375 /* 1380 1376 * Save pointers for SGLs containing protection information, 1381 1377 * if present. ··· 1392 1374 se_cmd->t_prot_nents = sgl_prot_count; 1393 1375 } 1394 1376 1395 - rc = target_setup_cmd_from_cdb(se_cmd, cdb); 1396 - if (rc != 0) { 1397 - transport_generic_request_failure(se_cmd, rc); 1398 - return 0; 1399 - } 1400 1377 /* 1401 1378 * When a non zero sgl_count has been passed perform SGL passthrough 1402 1379 * mapping for pre-allocated fabric memory instead of having target ··· 1767 1754 cmd->t_state = TRANSPORT_PROCESSING; 1768 1755 cmd->transport_state |= CMD_T_ACTIVE|CMD_T_BUSY|CMD_T_SENT; 1769 1756 spin_unlock_irq(&cmd->t_state_lock); 1757 + /* 1758 + * Perform WRITE_INSERT of PI using software emulation when backend 1759 + * device has PI enabled, if the transport has not already generated 1760 + * PI using hardware WRITE_INSERT offload. 1761 + */ 1762 + if (cmd->prot_op == TARGET_PROT_DOUT_INSERT) { 1763 + if (!(cmd->se_sess->sup_prot_ops & TARGET_PROT_DOUT_INSERT)) 1764 + sbc_dif_generate(cmd); 1765 + } 1770 1766 1771 1767 if (target_handle_task_attr(cmd)) { 1772 1768 spin_lock_irq(&cmd->t_state_lock); ··· 1905 1883 schedule_work(&cmd->se_dev->qf_work_queue); 1906 1884 } 1907 1885 1886 + static bool target_check_read_strip(struct se_cmd *cmd) 1887 + { 1888 + sense_reason_t rc; 1889 + 1890 + if (!(cmd->se_sess->sup_prot_ops & TARGET_PROT_DIN_STRIP)) { 1891 + rc = sbc_dif_read_strip(cmd); 1892 + if (rc) { 1893 + cmd->pi_err = rc; 1894 + return true; 1895 + } 1896 + } 1897 + 1898 + return false; 1899 + } 1900 + 1908 1901 static void target_complete_ok_work(struct work_struct *work) 1909 1902 { 1910 1903 struct se_cmd *cmd = container_of(work, struct se_cmd, work); ··· 1984 1947 cmd->data_length; 1985 1948 } 1986 1949 spin_unlock(&cmd->se_lun->lun_sep_lock); 1950 + /* 1951 + * Perform READ_STRIP of PI using software emulation when 1952 + * backend had PI enabled, if the transport will not be 1953 + * performing hardware READ_STRIP offload. 1954 + */ 1955 + if (cmd->prot_op == TARGET_PROT_DIN_STRIP && 1956 + target_check_read_strip(cmd)) { 1957 + ret = transport_send_check_condition_and_sense(cmd, 1958 + cmd->pi_err, 0); 1959 + if (ret == -EAGAIN || ret == -ENOMEM) 1960 + goto queue_full; 1961 + 1962 + transport_lun_remove_cmd(cmd); 1963 + transport_cmd_check_stop_to_fabric(cmd); 1964 + return; 1965 + } 1987 1966 1988 1967 trace_target_cmd_complete(cmd); 1989 1968 ret = cmd->se_tfo->queue_data_in(cmd); ··· 2092 2039 transport_free_sgl(cmd->t_bidi_data_sg, cmd->t_bidi_data_nents); 2093 2040 cmd->t_bidi_data_sg = NULL; 2094 2041 cmd->t_bidi_data_nents = 0; 2042 + 2043 + transport_free_sgl(cmd->t_prot_sg, cmd->t_prot_nents); 2044 + cmd->t_prot_sg = NULL; 2045 + cmd->t_prot_nents = 0; 2095 2046 } 2096 2047 2097 2048 /** ··· 2255 2198 ret = target_alloc_sgl(&cmd->t_bidi_data_sg, 2256 2199 &cmd->t_bidi_data_nents, 2257 2200 bidi_length, zero_flag); 2201 + if (ret < 0) 2202 + return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 2203 + } 2204 + 2205 + if (cmd->prot_op != TARGET_PROT_NORMAL) { 2206 + ret = target_alloc_sgl(&cmd->t_prot_sg, 2207 + &cmd->t_prot_nents, 2208 + cmd->prot_length, true); 2258 2209 if (ret < 0) 2259 2210 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 2260 2211 } ··· 2835 2770 if (!(cmd->transport_state & CMD_T_ABORTED)) 2836 2771 return 0; 2837 2772 2838 - if (!send_status || (cmd->se_cmd_flags & SCF_SENT_DELAYED_TAS)) 2773 + /* 2774 + * If cmd has been aborted but either no status is to be sent or it has 2775 + * already been sent, just return 2776 + */ 2777 + if (!send_status || !(cmd->se_cmd_flags & SCF_SEND_DELAYED_TAS)) 2839 2778 return 1; 2840 2779 2841 2780 pr_debug("Sending delayed SAM_STAT_TASK_ABORTED status for CDB: 0x%02x ITT: 0x%08x\n", 2842 2781 cmd->t_task_cdb[0], cmd->se_tfo->get_task_tag(cmd)); 2843 2782 2844 - cmd->se_cmd_flags |= SCF_SENT_DELAYED_TAS; 2783 + cmd->se_cmd_flags &= ~SCF_SEND_DELAYED_TAS; 2845 2784 cmd->scsi_status = SAM_STAT_TASK_ABORTED; 2846 2785 trace_target_cmd_complete(cmd); 2847 2786 cmd->se_tfo->queue_status(cmd); ··· 2859 2790 unsigned long flags; 2860 2791 2861 2792 spin_lock_irqsave(&cmd->t_state_lock, flags); 2862 - if (cmd->se_cmd_flags & (SCF_SENT_CHECK_CONDITION | SCF_SENT_DELAYED_TAS)) { 2793 + if (cmd->se_cmd_flags & (SCF_SENT_CHECK_CONDITION)) { 2863 2794 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2864 2795 return; 2865 2796 } ··· 2874 2805 if (cmd->data_direction == DMA_TO_DEVICE) { 2875 2806 if (cmd->se_tfo->write_pending_status(cmd) != 0) { 2876 2807 cmd->transport_state |= CMD_T_ABORTED; 2808 + cmd->se_cmd_flags |= SCF_SEND_DELAYED_TAS; 2877 2809 smp_mb__after_atomic_inc(); 2878 2810 return; 2879 2811 }

+6 -7

drivers/target/tcm_fc/tcm_fc.h

··· 94 94 */ 95 95 struct ft_tpg { 96 96 u32 index; 97 - struct ft_lport_acl *lport_acl; 97 + struct ft_lport_wwn *lport_wwn; 98 98 struct ft_tport *tport; /* active tport or NULL */ 99 - struct list_head list; /* linkage in ft_lport_acl tpg_list */ 100 99 struct list_head lun_list; /* head of LUNs */ 101 100 struct se_portal_group se_tpg; 102 101 struct workqueue_struct *workqueue; 103 102 }; 104 103 105 - struct ft_lport_acl { 104 + struct ft_lport_wwn { 106 105 u64 wwpn; 107 106 char name[FT_NAMELEN]; 108 - struct list_head list; 109 - struct list_head tpg_list; 110 - struct se_wwn fc_lport_wwn; 107 + struct list_head ft_wwn_node; 108 + struct ft_tpg *tpg; 109 + struct se_wwn se_wwn; 111 110 }; 112 111 113 112 /* ··· 127 128 u32 sg_cnt; /* No. of item in scatterlist */ 128 129 }; 129 130 130 - extern struct list_head ft_lport_list; 131 131 extern struct mutex ft_lport_lock; 132 132 extern struct fc4_prov ft_prov; 133 133 extern struct target_fabric_configfs *ft_configfs; ··· 161 163 u32 ft_get_task_tag(struct se_cmd *); 162 164 int ft_get_cmd_state(struct se_cmd *); 163 165 void ft_queue_tm_resp(struct se_cmd *); 166 + void ft_aborted_task(struct se_cmd *); 164 167 165 168 /* 166 169 * other internal functions.

+5

drivers/target/tcm_fc/tfc_cmd.c

··· 426 426 ft_send_resp_code(cmd, code); 427 427 } 428 428 429 + void ft_aborted_task(struct se_cmd *se_cmd) 430 + { 431 + return; 432 + } 433 + 429 434 static void ft_send_work(struct work_struct *work); 430 435 431 436 /*

+39 -37

drivers/target/tcm_fc/tfc_conf.c

··· 50 50 51 51 struct target_fabric_configfs *ft_configfs; 52 52 53 - LIST_HEAD(ft_lport_list); 53 + static LIST_HEAD(ft_wwn_list); 54 54 DEFINE_MUTEX(ft_lport_lock); 55 55 56 56 unsigned int ft_debug_logging; ··· 298 298 struct config_group *group, 299 299 const char *name) 300 300 { 301 - struct ft_lport_acl *lacl; 301 + struct ft_lport_wwn *ft_wwn; 302 302 struct ft_tpg *tpg; 303 303 struct workqueue_struct *wq; 304 304 unsigned long index; ··· 318 318 if (index > UINT_MAX) 319 319 return NULL; 320 320 321 - lacl = container_of(wwn, struct ft_lport_acl, fc_lport_wwn); 321 + if ((index != 1)) { 322 + pr_err("Error, a single TPG=1 is used for HW port mappings\n"); 323 + return ERR_PTR(-ENOSYS); 324 + } 325 + 326 + ft_wwn = container_of(wwn, struct ft_lport_wwn, se_wwn); 322 327 tpg = kzalloc(sizeof(*tpg), GFP_KERNEL); 323 328 if (!tpg) 324 329 return NULL; 325 330 tpg->index = index; 326 - tpg->lport_acl = lacl; 331 + tpg->lport_wwn = ft_wwn; 327 332 INIT_LIST_HEAD(&tpg->lun_list); 328 333 329 334 wq = alloc_workqueue("tcm_fc", 0, 1); ··· 347 342 tpg->workqueue = wq; 348 343 349 344 mutex_lock(&ft_lport_lock); 350 - list_add_tail(&tpg->list, &lacl->tpg_list); 345 + ft_wwn->tpg = tpg; 351 346 mutex_unlock(&ft_lport_lock); 352 347 353 348 return &tpg->se_tpg; ··· 356 351 static void ft_del_tpg(struct se_portal_group *se_tpg) 357 352 { 358 353 struct ft_tpg *tpg = container_of(se_tpg, struct ft_tpg, se_tpg); 354 + struct ft_lport_wwn *ft_wwn = tpg->lport_wwn; 359 355 360 356 pr_debug("del tpg %s\n", 361 357 config_item_name(&tpg->se_tpg.tpg_group.cg_item)); ··· 367 361 synchronize_rcu(); 368 362 369 363 mutex_lock(&ft_lport_lock); 370 - list_del(&tpg->list); 364 + ft_wwn->tpg = NULL; 371 365 if (tpg->tport) { 372 366 tpg->tport->tpg = NULL; 373 367 tpg->tport = NULL; ··· 386 380 */ 387 381 struct ft_tpg *ft_lport_find_tpg(struct fc_lport *lport) 388 382 { 389 - struct ft_lport_acl *lacl; 390 - struct ft_tpg *tpg; 383 + struct ft_lport_wwn *ft_wwn; 391 384 392 - list_for_each_entry(lacl, &ft_lport_list, list) { 393 - if (lacl->wwpn == lport->wwpn) { 394 - list_for_each_entry(tpg, &lacl->tpg_list, list) 395 - return tpg; /* XXX for now return first entry */ 396 - return NULL; 397 - } 385 + list_for_each_entry(ft_wwn, &ft_wwn_list, ft_wwn_node) { 386 + if (ft_wwn->wwpn == lport->wwpn) 387 + return ft_wwn->tpg; 398 388 } 399 389 return NULL; 400 390 } ··· 403 401 * Add lport to allowed config. 404 402 * The name is the WWPN in lower-case ASCII, colon-separated bytes. 405 403 */ 406 - static struct se_wwn *ft_add_lport( 404 + static struct se_wwn *ft_add_wwn( 407 405 struct target_fabric_configfs *tf, 408 406 struct config_group *group, 409 407 const char *name) 410 408 { 411 - struct ft_lport_acl *lacl; 412 - struct ft_lport_acl *old_lacl; 409 + struct ft_lport_wwn *ft_wwn; 410 + struct ft_lport_wwn *old_ft_wwn; 413 411 u64 wwpn; 414 412 415 - pr_debug("add lport %s\n", name); 413 + pr_debug("add wwn %s\n", name); 416 414 if (ft_parse_wwn(name, &wwpn, 1) < 0) 417 415 return NULL; 418 - lacl = kzalloc(sizeof(*lacl), GFP_KERNEL); 419 - if (!lacl) 416 + ft_wwn = kzalloc(sizeof(*ft_wwn), GFP_KERNEL); 417 + if (!ft_wwn) 420 418 return NULL; 421 - lacl->wwpn = wwpn; 422 - INIT_LIST_HEAD(&lacl->tpg_list); 419 + ft_wwn->wwpn = wwpn; 423 420 424 421 mutex_lock(&ft_lport_lock); 425 - list_for_each_entry(old_lacl, &ft_lport_list, list) { 426 - if (old_lacl->wwpn == wwpn) { 422 + list_for_each_entry(old_ft_wwn, &ft_wwn_list, ft_wwn_node) { 423 + if (old_ft_wwn->wwpn == wwpn) { 427 424 mutex_unlock(&ft_lport_lock); 428 - kfree(lacl); 425 + kfree(ft_wwn); 429 426 return NULL; 430 427 } 431 428 } 432 - list_add_tail(&lacl->list, &ft_lport_list); 433 - ft_format_wwn(lacl->name, sizeof(lacl->name), wwpn); 429 + list_add_tail(&ft_wwn->ft_wwn_node, &ft_wwn_list); 430 + ft_format_wwn(ft_wwn->name, sizeof(ft_wwn->name), wwpn); 434 431 mutex_unlock(&ft_lport_lock); 435 432 436 - return &lacl->fc_lport_wwn; 433 + return &ft_wwn->se_wwn; 437 434 } 438 435 439 - static void ft_del_lport(struct se_wwn *wwn) 436 + static void ft_del_wwn(struct se_wwn *wwn) 440 437 { 441 - struct ft_lport_acl *lacl = container_of(wwn, 442 - struct ft_lport_acl, fc_lport_wwn); 438 + struct ft_lport_wwn *ft_wwn = container_of(wwn, 439 + struct ft_lport_wwn, se_wwn); 443 440 444 - pr_debug("del lport %s\n", lacl->name); 441 + pr_debug("del wwn %s\n", ft_wwn->name); 445 442 mutex_lock(&ft_lport_lock); 446 - list_del(&lacl->list); 443 + list_del(&ft_wwn->ft_wwn_node); 447 444 mutex_unlock(&ft_lport_lock); 448 445 449 - kfree(lacl); 446 + kfree(ft_wwn); 450 447 } 451 448 452 449 static ssize_t ft_wwn_show_attr_version( ··· 472 471 { 473 472 struct ft_tpg *tpg = se_tpg->se_tpg_fabric_ptr; 474 473 475 - return tpg->lport_acl->name; 474 + return tpg->lport_wwn->name; 476 475 } 477 476 478 477 static u16 ft_get_tag(struct se_portal_group *se_tpg) ··· 537 536 .queue_data_in = ft_queue_data_in, 538 537 .queue_status = ft_queue_status, 539 538 .queue_tm_rsp = ft_queue_tm_resp, 539 + .aborted_task = ft_aborted_task, 540 540 /* 541 541 * Setup function pointers for generic logic in 542 542 * target_core_fabric_configfs.c 543 543 */ 544 - .fabric_make_wwn = &ft_add_lport, 545 - .fabric_drop_wwn = &ft_del_lport, 544 + .fabric_make_wwn = &ft_add_wwn, 545 + .fabric_drop_wwn = &ft_del_wwn, 546 546 .fabric_make_tpg = &ft_add_tpg, 547 547 .fabric_drop_tpg = &ft_del_tpg, 548 548 .fabric_post_link = NULL,

+6 -4

drivers/target/tcm_fc/tfc_sess.c

··· 51 51 * Lookup or allocate target local port. 52 52 * Caller holds ft_lport_lock. 53 53 */ 54 - static struct ft_tport *ft_tport_create(struct fc_lport *lport) 54 + static struct ft_tport *ft_tport_get(struct fc_lport *lport) 55 55 { 56 56 struct ft_tpg *tpg; 57 57 struct ft_tport *tport; ··· 68 68 69 69 if (tport) { 70 70 tport->tpg = tpg; 71 + tpg->tport = tport; 71 72 return tport; 72 73 } 73 74 ··· 115 114 void ft_lport_add(struct fc_lport *lport, void *arg) 116 115 { 117 116 mutex_lock(&ft_lport_lock); 118 - ft_tport_create(lport); 117 + ft_tport_get(lport); 119 118 mutex_unlock(&ft_lport_lock); 120 119 } 121 120 ··· 212 211 return NULL; 213 212 214 213 sess->se_sess = transport_init_session_tags(TCM_FC_DEFAULT_TAGS, 215 - sizeof(struct ft_cmd)); 214 + sizeof(struct ft_cmd), 215 + TARGET_PROT_NORMAL); 216 216 if (IS_ERR(sess->se_sess)) { 217 217 kfree(sess); 218 218 return NULL; ··· 352 350 struct ft_node_acl *acl; 353 351 u32 fcp_parm; 354 352 355 - tport = ft_tport_create(rdata->local_port); 353 + tport = ft_tport_get(rdata->local_port); 356 354 if (!tport) 357 355 goto not_target; /* not a target for this local port */ 358 356

+7 -1

drivers/usb/gadget/tcm_usb_gadget.c

··· 1471 1471 { 1472 1472 } 1473 1473 1474 + static void usbg_aborted_task(struct se_cmd *se_cmd) 1475 + { 1476 + return; 1477 + } 1478 + 1474 1479 static const char *usbg_check_wwn(const char *name) 1475 1480 { 1476 1481 const char *n; ··· 1731 1726 pr_err("Unable to allocate struct tcm_vhost_nexus\n"); 1732 1727 goto err_unlock; 1733 1728 } 1734 - tv_nexus->tvn_se_sess = transport_init_session(); 1729 + tv_nexus->tvn_se_sess = transport_init_session(TARGET_PROT_NORMAL); 1735 1730 if (IS_ERR(tv_nexus->tvn_se_sess)) 1736 1731 goto err_free; 1737 1732 ··· 1902 1897 .queue_data_in = usbg_send_read_response, 1903 1898 .queue_status = usbg_send_status_response, 1904 1899 .queue_tm_rsp = usbg_queue_tm_rsp, 1900 + .aborted_task = usbg_aborted_task, 1905 1901 .check_stop_free = usbg_check_stop_free, 1906 1902 1907 1903 .fabric_make_wwn = usbg_make_tport,

+8 -1

drivers/vhost/scsi.c

··· 539 539 return; 540 540 } 541 541 542 + static void tcm_vhost_aborted_task(struct se_cmd *se_cmd) 543 + { 544 + return; 545 + } 546 + 542 547 static void tcm_vhost_free_evt(struct vhost_scsi *vs, struct tcm_vhost_evt *evt) 543 548 { 544 549 vs->vs_events_nr--; ··· 1745 1740 */ 1746 1741 tv_nexus->tvn_se_sess = transport_init_session_tags( 1747 1742 TCM_VHOST_DEFAULT_TAGS, 1748 - sizeof(struct tcm_vhost_cmd)); 1743 + sizeof(struct tcm_vhost_cmd), 1744 + TARGET_PROT_NORMAL); 1749 1745 if (IS_ERR(tv_nexus->tvn_se_sess)) { 1750 1746 mutex_unlock(&tpg->tv_tpg_mutex); 1751 1747 kfree(tv_nexus); ··· 2137 2131 .queue_data_in = tcm_vhost_queue_data_in, 2138 2132 .queue_status = tcm_vhost_queue_status, 2139 2133 .queue_tm_rsp = tcm_vhost_queue_tm_rsp, 2134 + .aborted_task = tcm_vhost_aborted_task, 2140 2135 /* 2141 2136 * Setup callers for generic logic in target_core_fabric_configfs.c 2142 2137 */

+2

include/target/iscsi/iscsi_transport.h

··· 21 21 int (*iscsit_get_dataout)(struct iscsi_conn *, struct iscsi_cmd *, bool); 22 22 int (*iscsit_queue_data_in)(struct iscsi_conn *, struct iscsi_cmd *); 23 23 int (*iscsit_queue_status)(struct iscsi_conn *, struct iscsi_cmd *); 24 + void (*iscsit_aborted_task)(struct iscsi_conn *, struct iscsi_cmd *); 25 + enum target_prot_op (*iscsit_get_sup_prot_ops)(struct iscsi_conn *); 24 26 }; 25 27 26 28 static inline void *iscsit_priv_cmd(struct iscsi_cmd *cmd)

+2

include/target/target_core_backend.h

··· 73 73 sense_reason_t (*do_unmap_fn)(struct se_cmd *cmd, void *priv, 74 74 sector_t lba, sector_t nolb), 75 75 void *priv); 76 + void sbc_dif_generate(struct se_cmd *); 76 77 sense_reason_t sbc_dif_verify_write(struct se_cmd *, sector_t, unsigned int, 77 78 unsigned int, struct scatterlist *, int); 78 79 sense_reason_t sbc_dif_verify_read(struct se_cmd *, sector_t, unsigned int, 79 80 unsigned int, struct scatterlist *, int); 81 + sense_reason_t sbc_dif_read_strip(struct se_cmd *); 80 82 81 83 void transport_set_vpd_proto_id(struct t10_vpd *, unsigned char *); 82 84 int transport_set_vpd_assoc(struct t10_vpd *, unsigned char *);

+20 -13

include/target/target_core_base.h

··· 162 162 SCF_SENT_CHECK_CONDITION = 0x00000800, 163 163 SCF_OVERFLOW_BIT = 0x00001000, 164 164 SCF_UNDERFLOW_BIT = 0x00002000, 165 - SCF_SENT_DELAYED_TAS = 0x00004000, 165 + SCF_SEND_DELAYED_TAS = 0x00004000, 166 166 SCF_ALUA_NON_OPTIMIZED = 0x00008000, 167 167 SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC = 0x00020000, 168 168 SCF_ACK_KREF = 0x00040000, ··· 442 442 }; 443 443 444 444 enum target_prot_op { 445 - TARGET_PROT_NORMAL = 0, 446 - TARGET_PROT_DIN_INSERT, 447 - TARGET_PROT_DOUT_INSERT, 448 - TARGET_PROT_DIN_STRIP, 449 - TARGET_PROT_DOUT_STRIP, 450 - TARGET_PROT_DIN_PASS, 451 - TARGET_PROT_DOUT_PASS, 445 + TARGET_PROT_NORMAL = 0, 446 + TARGET_PROT_DIN_INSERT = (1 << 0), 447 + TARGET_PROT_DOUT_INSERT = (1 << 1), 448 + TARGET_PROT_DIN_STRIP = (1 << 2), 449 + TARGET_PROT_DOUT_STRIP = (1 << 3), 450 + TARGET_PROT_DIN_PASS = (1 << 4), 451 + TARGET_PROT_DOUT_PASS = (1 << 5), 452 452 }; 453 453 454 - enum target_prot_ho { 455 - PROT_SEPERATED, 456 - PROT_INTERLEAVED, 457 - }; 454 + #define TARGET_PROT_ALL TARGET_PROT_DIN_INSERT | TARGET_PROT_DOUT_INSERT | \ 455 + TARGET_PROT_DIN_STRIP | TARGET_PROT_DOUT_STRIP | \ 456 + TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS 458 457 459 458 enum target_prot_type { 460 459 TARGET_DIF_TYPE0_PROT, 461 460 TARGET_DIF_TYPE1_PROT, 462 461 TARGET_DIF_TYPE2_PROT, 463 462 TARGET_DIF_TYPE3_PROT, 463 + }; 464 + 465 + enum target_core_dif_check { 466 + TARGET_DIF_CHECK_GUARD = 0x1 << 0, 467 + TARGET_DIF_CHECK_APPTAG = 0x1 << 1, 468 + TARGET_DIF_CHECK_REFTAG = 0x1 << 2, 464 469 }; 465 470 466 471 struct se_dif_v1_tuple { ··· 561 556 /* DIF related members */ 562 557 enum target_prot_op prot_op; 563 558 enum target_prot_type prot_type; 559 + u8 prot_checks; 564 560 u32 prot_length; 565 561 u32 reftag_seed; 566 562 struct scatterlist *t_prot_sg; 567 563 unsigned int t_prot_nents; 568 - enum target_prot_ho prot_handover; 569 564 sense_reason_t pi_err; 570 565 sector_t bad_sector; 566 + bool prot_pto; 571 567 }; 572 568 573 569 struct se_ua { ··· 609 603 struct se_session { 610 604 unsigned sess_tearing_down:1; 611 605 u64 sess_bin_isid; 606 + enum target_prot_op sup_prot_ops; 612 607 struct se_node_acl *se_node_acl; 613 608 struct se_portal_group *se_tpg; 614 609 void *fabric_sess_ptr;

+4 -2

include/target/target_core_fabric.h

··· 62 62 int (*queue_data_in)(struct se_cmd *); 63 63 int (*queue_status)(struct se_cmd *); 64 64 void (*queue_tm_rsp)(struct se_cmd *); 65 + void (*aborted_task)(struct se_cmd *); 65 66 /* 66 67 * fabric module calls for target_core_fabric_configfs.c 67 68 */ ··· 84 83 void (*fabric_drop_nodeacl)(struct se_node_acl *); 85 84 }; 86 85 87 - struct se_session *transport_init_session(void); 86 + struct se_session *transport_init_session(enum target_prot_op); 88 87 int transport_alloc_session_tags(struct se_session *, unsigned int, 89 88 unsigned int); 90 - struct se_session *transport_init_session_tags(unsigned int, unsigned int); 89 + struct se_session *transport_init_session_tags(unsigned int, unsigned int, 90 + enum target_prot_op); 91 91 void __transport_register_session(struct se_portal_group *, 92 92 struct se_node_acl *, struct se_session *, void *); 93 93 void transport_register_session(struct se_portal_group *,

Configure Feed

Configure Feed