Merge tag 'nvme-6.19-2025-12-04' of git://git.infradead.org/nvme into block-6.19

+1 -1

drivers/nvme/host/auth.c

··· 1122 1122 if (ctrl->dhchap_ctxs) { 1123 1123 for (i = 0; i < ctrl_max_dhchaps(ctrl); i++) 1124 1124 nvme_auth_free_dhchap(&ctrl->dhchap_ctxs[i]); 1125 - kfree(ctrl->dhchap_ctxs); 1125 + kvfree(ctrl->dhchap_ctxs); 1126 1126 } 1127 1127 if (ctrl->host_key) { 1128 1128 nvme_auth_free_key(ctrl->host_key);

+1 -1

drivers/nvme/host/fabrics.c

··· 592 592 if (status > 0 && (status & NVME_STATUS_DNR)) 593 593 return false; 594 594 595 - if (status == -EKEYREJECTED) 595 + if (status == -EKEYREJECTED || status == -ENOKEY) 596 596 return false; 597 597 598 598 if (ctrl->opts->max_reconnects == -1 ||

+6 -2

drivers/nvme/host/fc.c

··· 520 520 521 521 WARN_ON(rport->remoteport.port_state != FC_OBJSTATE_DELETED); 522 522 WARN_ON(!list_empty(&rport->ctrl_list)); 523 + WARN_ON(!list_empty(&rport->ls_req_list)); 524 + WARN_ON(!list_empty(&rport->ls_rcv_list)); 523 525 524 526 /* remove from lport list */ 525 527 spin_lock_irqsave(&nvme_fc_lock, flags); ··· 1470 1468 { 1471 1469 struct fcnvme_ls_disconnect_assoc_rqst *rqst = 1472 1470 &lsop->rqstbuf->rq_dis_assoc; 1473 - struct nvme_fc_ctrl *ctrl, *ret = NULL; 1471 + struct nvme_fc_ctrl *ctrl, *tmp, *ret = NULL; 1474 1472 struct nvmefc_ls_rcv_op *oldls = NULL; 1475 1473 u64 association_id = be64_to_cpu(rqst->associd.association_id); 1476 1474 unsigned long flags; 1477 1475 1478 1476 spin_lock_irqsave(&rport->lock, flags); 1479 1477 1480 - list_for_each_entry(ctrl, &rport->ctrl_list, ctrl_list) { 1478 + list_for_each_entry_safe(ctrl, tmp, &rport->ctrl_list, ctrl_list) { 1481 1479 if (!nvme_fc_ctrl_get(ctrl)) 1482 1480 continue; 1483 1481 spin_lock(&ctrl->lock); ··· 1490 1488 if (ret) 1491 1489 /* leave the ctrl get reference */ 1492 1490 break; 1491 + spin_unlock_irqrestore(&rport->lock, flags); 1493 1492 nvme_fc_ctrl_put(ctrl); 1493 + spin_lock_irqsave(&rport->lock, flags); 1494 1494 } 1495 1495 1496 1496 spin_unlock_irqrestore(&rport->lock, flags);

+2

drivers/nvme/host/pci.c

··· 2984 2984 pci_set_master(pdev); 2985 2985 2986 2986 if (readl(dev->bar + NVME_REG_CSTS) == -1) { 2987 + dev_dbg(dev->ctrl.device, "reading CSTS register failed\n"); 2987 2988 result = -ENODEV; 2988 2989 goto disable; 2989 2990 } ··· 3610 3609 nvme_uninit_ctrl(&dev->ctrl); 3611 3610 out_put_ctrl: 3612 3611 nvme_put_ctrl(&dev->ctrl); 3612 + dev_err_probe(&pdev->dev, result, "probe failed\n"); 3613 3613 return result; 3614 3614 } 3615 3615

+1 -1

drivers/nvme/target/admin-cmd.c

··· 708 708 709 709 /* 710 710 * We don't really have a practical limit on the number of abort 711 - * comands. But we don't do anything useful for abort either, so 711 + * commands. But we don't do anything useful for abort either, so 712 712 * no point in allowing more abort commands than the spec requires. 713 713 */ 714 714 id->acl = 3;

+10 -8

drivers/nvme/target/auth.c

··· 381 381 ret = crypto_shash_update(shash, buf, 1); 382 382 if (ret) 383 383 goto out; 384 - ret = crypto_shash_update(shash, ctrl->subsysnqn, 385 - strlen(ctrl->subsysnqn)); 384 + ret = crypto_shash_update(shash, ctrl->subsys->subsysnqn, 385 + strlen(ctrl->subsys->subsysnqn)); 386 386 if (ret) 387 387 goto out; 388 388 ret = crypto_shash_final(shash, response); ··· 429 429 } 430 430 431 431 transformed_key = nvme_auth_transform_key(ctrl->ctrl_key, 432 - ctrl->subsysnqn); 432 + ctrl->subsys->subsysnqn); 433 433 if (IS_ERR(transformed_key)) { 434 434 ret = PTR_ERR(transformed_key); 435 435 goto out_free_tfm; ··· 484 484 ret = crypto_shash_update(shash, "Controller", 10); 485 485 if (ret) 486 486 goto out; 487 - ret = crypto_shash_update(shash, ctrl->subsysnqn, 488 - strlen(ctrl->subsysnqn)); 487 + ret = crypto_shash_update(shash, ctrl->subsys->subsysnqn, 488 + strlen(ctrl->subsys->subsysnqn)); 489 489 if (ret) 490 490 goto out; 491 491 ret = crypto_shash_update(shash, buf, 1); ··· 575 575 return; 576 576 } 577 577 ret = nvme_auth_generate_digest(sq->ctrl->shash_id, psk, psk_len, 578 - sq->ctrl->subsysnqn, 578 + sq->ctrl->subsys->subsysnqn, 579 579 sq->ctrl->hostnqn, &digest); 580 580 if (ret) { 581 581 pr_warn("%s: ctrl %d qid %d failed to generate digest, error %d\n", ··· 590 590 goto out_free_digest; 591 591 } 592 592 #ifdef CONFIG_NVME_TARGET_TCP_TLS 593 - tls_key = nvme_tls_psk_refresh(NULL, sq->ctrl->hostnqn, sq->ctrl->subsysnqn, 594 - sq->ctrl->shash_id, tls_psk, psk_len, digest); 593 + tls_key = nvme_tls_psk_refresh(NULL, sq->ctrl->hostnqn, 594 + sq->ctrl->subsys->subsysnqn, 595 + sq->ctrl->shash_id, tls_psk, psk_len, 596 + digest); 595 597 if (IS_ERR(tls_key)) { 596 598 pr_warn("%s: ctrl %d qid %d failed to refresh key, error %ld\n", 597 599 __func__, sq->ctrl->cntlid, sq->qid, PTR_ERR(tls_key));

+3 -2

drivers/nvme/target/core.c

··· 40 40 * - the nvmet_transports array 41 41 * 42 42 * When updating any of those lists/structures write lock should be obtained, 43 - * while when reading (popolating discovery log page or checking host-subsystem 43 + * while when reading (populating discovery log page or checking host-subsystem 44 44 * link) read lock is obtained to allow concurrent reads. 45 45 */ 46 46 DECLARE_RWSEM(nvmet_config_sem); ··· 1628 1628 INIT_WORK(&ctrl->fatal_err_work, nvmet_fatal_error_handler); 1629 1629 INIT_DELAYED_WORK(&ctrl->ka_work, nvmet_keep_alive_timer); 1630 1630 1631 - memcpy(ctrl->subsysnqn, args->subsysnqn, NVMF_NQN_SIZE); 1632 1631 memcpy(ctrl->hostnqn, args->hostnqn, NVMF_NQN_SIZE); 1633 1632 1634 1633 kref_init(&ctrl->ref); ··· 1902 1903 struct nvmet_subsys *subsys = 1903 1904 container_of(ref, struct nvmet_subsys, ref); 1904 1905 1906 + WARN_ON_ONCE(!list_empty(&subsys->ctrls)); 1907 + WARN_ON_ONCE(!list_empty(&subsys->hosts)); 1905 1908 WARN_ON_ONCE(!xa_empty(&subsys->namespaces)); 1906 1909 1907 1910 nvmet_debugfs_subsys_free(subsys);

+21 -27

drivers/nvme/target/fc.c

··· 490 490 sizeof(*discon_rqst) + sizeof(*discon_acc) + 491 491 tgtport->ops->lsrqst_priv_sz), GFP_KERNEL); 492 492 if (!lsop) { 493 - dev_info(tgtport->dev, 494 - "{%d:%d} send Disconnect Association failed: ENOMEM\n", 493 + pr_info("{%d:%d}: send Disconnect Association failed: ENOMEM\n", 495 494 tgtport->fc_target_port.port_num, assoc->a_id); 496 495 return; 497 496 } ··· 512 513 ret = nvmet_fc_send_ls_req_async(tgtport, lsop, 513 514 nvmet_fc_disconnect_assoc_done); 514 515 if (ret) { 515 - dev_info(tgtport->dev, 516 - "{%d:%d} XMT Disconnect Association failed: %d\n", 516 + pr_info("{%d:%d}: XMT Disconnect Association failed: %d\n", 517 517 tgtport->fc_target_port.port_num, assoc->a_id, ret); 518 518 kfree(lsop); 519 519 } ··· 1185 1187 if (oldls) 1186 1188 nvmet_fc_xmt_ls_rsp(tgtport, oldls); 1187 1189 ida_free(&tgtport->assoc_cnt, assoc->a_id); 1188 - dev_info(tgtport->dev, 1189 - "{%d:%d} Association freed\n", 1190 + pr_info("{%d:%d}: Association freed\n", 1190 1191 tgtport->fc_target_port.port_num, assoc->a_id); 1191 1192 kfree(assoc); 1192 1193 } ··· 1221 1224 flush_workqueue(assoc->queues[i]->work_q); 1222 1225 } 1223 1226 1224 - dev_info(tgtport->dev, 1225 - "{%d:%d} Association deleted\n", 1227 + pr_info("{%d:%d}: Association deleted\n", 1226 1228 tgtport->fc_target_port.port_num, assoc->a_id); 1227 1229 1228 1230 nvmet_fc_tgtport_put(tgtport); ··· 1712 1716 } 1713 1717 1714 1718 if (ret) { 1715 - dev_err(tgtport->dev, 1716 - "Create Association LS failed: %s\n", 1717 - validation_errors[ret]); 1719 + pr_err("{%d}: Create Association LS failed: %s\n", 1720 + tgtport->fc_target_port.port_num, 1721 + validation_errors[ret]); 1718 1722 iod->lsrsp->rsplen = nvme_fc_format_rjt(acc, 1719 1723 sizeof(*acc), rqst->w0.ls_cmd, 1720 1724 FCNVME_RJT_RC_LOGIC, ··· 1726 1730 atomic_set(&queue->connected, 1); 1727 1731 queue->sqhd = 0; /* best place to init value */ 1728 1732 1729 - dev_info(tgtport->dev, 1730 - "{%d:%d} Association created\n", 1733 + pr_info("{%d:%d}: Association created\n", 1731 1734 tgtport->fc_target_port.port_num, iod->assoc->a_id); 1732 1735 1733 1736 /* format a response */ ··· 1804 1809 } 1805 1810 1806 1811 if (ret) { 1807 - dev_err(tgtport->dev, 1808 - "Create Connection LS failed: %s\n", 1809 - validation_errors[ret]); 1812 + pr_err("{%d}: Create Connection LS failed: %s\n", 1813 + tgtport->fc_target_port.port_num, 1814 + validation_errors[ret]); 1810 1815 iod->lsrsp->rsplen = nvme_fc_format_rjt(acc, 1811 1816 sizeof(*acc), rqst->w0.ls_cmd, 1812 1817 (ret == VERR_NO_ASSOC) ? ··· 1866 1871 } 1867 1872 1868 1873 if (ret || !assoc) { 1869 - dev_err(tgtport->dev, 1870 - "Disconnect LS failed: %s\n", 1871 - validation_errors[ret]); 1874 + pr_err("{%d}: Disconnect LS failed: %s\n", 1875 + tgtport->fc_target_port.port_num, 1876 + validation_errors[ret]); 1872 1877 iod->lsrsp->rsplen = nvme_fc_format_rjt(acc, 1873 1878 sizeof(*acc), rqst->w0.ls_cmd, 1874 1879 (ret == VERR_NO_ASSOC) ? ··· 1902 1907 spin_unlock_irqrestore(&tgtport->lock, flags); 1903 1908 1904 1909 if (oldls) { 1905 - dev_info(tgtport->dev, 1906 - "{%d:%d} Multiple Disconnect Association LS's " 1910 + pr_info("{%d:%d}: Multiple Disconnect Association LS's " 1907 1911 "received\n", 1908 1912 tgtport->fc_target_port.port_num, assoc->a_id); 1909 1913 /* overwrite good response with bogus failure */ ··· 2045 2051 struct fcnvme_ls_rqst_w0 *w0 = (struct fcnvme_ls_rqst_w0 *)lsreqbuf; 2046 2052 2047 2053 if (lsreqbuf_len > sizeof(union nvmefc_ls_requests)) { 2048 - dev_info(tgtport->dev, 2049 - "RCV %s LS failed: payload too large (%d)\n", 2054 + pr_info("{%d}: RCV %s LS failed: payload too large (%d)\n", 2055 + tgtport->fc_target_port.port_num, 2050 2056 (w0->ls_cmd <= NVME_FC_LAST_LS_CMD_VALUE) ? 2051 2057 nvmefc_ls_names[w0->ls_cmd] : "", 2052 2058 lsreqbuf_len); ··· 2054 2060 } 2055 2061 2056 2062 if (!nvmet_fc_tgtport_get(tgtport)) { 2057 - dev_info(tgtport->dev, 2058 - "RCV %s LS failed: target deleting\n", 2063 + pr_info("{%d}: RCV %s LS failed: target deleting\n", 2064 + tgtport->fc_target_port.port_num, 2059 2065 (w0->ls_cmd <= NVME_FC_LAST_LS_CMD_VALUE) ? 2060 2066 nvmefc_ls_names[w0->ls_cmd] : ""); 2061 2067 return -ESHUTDOWN; ··· 2063 2069 2064 2070 iod = nvmet_fc_alloc_ls_iod(tgtport); 2065 2071 if (!iod) { 2066 - dev_info(tgtport->dev, 2067 - "RCV %s LS failed: context allocation failed\n", 2072 + pr_info("{%d}: RCV %s LS failed: context allocation failed\n", 2073 + tgtport->fc_target_port.port_num, 2068 2074 (w0->ls_cmd <= NVME_FC_LAST_LS_CMD_VALUE) ? 2069 2075 nvmefc_ls_names[w0->ls_cmd] : ""); 2070 2076 nvmet_fc_tgtport_put(tgtport);

+6 -3

drivers/nvme/target/fcloop.c

··· 254 254 struct fcloop_lsreq { 255 255 struct nvmefc_ls_req *lsreq; 256 256 struct nvmefc_ls_rsp ls_rsp; 257 - int lsdir; /* H2T or T2H */ 258 257 int status; 259 258 struct list_head ls_list; /* fcloop_rport->ls_list */ 260 259 }; ··· 1110 1111 rport->nport->rport = NULL; 1111 1112 spin_unlock_irqrestore(&fcloop_lock, flags); 1112 1113 1113 - if (put_port) 1114 + if (put_port) { 1115 + WARN_ON(!list_empty(&rport->ls_list)); 1114 1116 fcloop_nport_put(rport->nport); 1117 + } 1115 1118 } 1116 1119 1117 1120 static void ··· 1131 1130 tport->nport->tport = NULL; 1132 1131 spin_unlock_irqrestore(&fcloop_lock, flags); 1133 1132 1134 - if (put_port) 1133 + if (put_port) { 1134 + WARN_ON(!list_empty(&tport->ls_list)); 1135 1135 fcloop_nport_put(tport->nport); 1136 + } 1136 1137 } 1137 1138 1138 1139 #define FCLOOP_HW_QUEUES 4

-1

drivers/nvme/target/nvmet.h

··· 285 285 __le32 *changed_ns_list; 286 286 u32 nr_changed_ns; 287 287 288 - char subsysnqn[NVMF_NQN_FIELD_LEN]; 289 288 char hostnqn[NVMF_NQN_FIELD_LEN]; 290 289 291 290 struct device *p2p_client;

+1 -1

drivers/nvme/target/passthru.c

··· 150 150 * code path with duplicate ctrl subsysnqn. In order to prevent that we 151 151 * mask the passthru-ctrl subsysnqn with the target ctrl subsysnqn. 152 152 */ 153 - memcpy(id->subnqn, ctrl->subsysnqn, sizeof(id->subnqn)); 153 + memcpy(id->subnqn, ctrl->subsys->subsysnqn, sizeof(id->subnqn)); 154 154 155 155 /* use fabric id-ctrl values */ 156 156 id->ioccsz = cpu_to_le32((sizeof(struct nvme_command) +

+8 -6

drivers/nvme/target/pci-epf.c

··· 320 320 nvme_epf->dma_enabled = true; 321 321 322 322 dev_dbg(dev, "Using DMA RX channel %s, maximum segment size %u B\n", 323 - dma_chan_name(chan), 324 - dma_get_max_seg_size(dmaengine_get_dma_device(chan))); 323 + dma_chan_name(nvme_epf->dma_rx_chan), 324 + dma_get_max_seg_size(dmaengine_get_dma_device(nvme_epf-> 325 + dma_rx_chan))); 325 326 326 327 dev_dbg(dev, "Using DMA TX channel %s, maximum segment size %u B\n", 327 - dma_chan_name(chan), 328 - dma_get_max_seg_size(dmaengine_get_dma_device(chan))); 328 + dma_chan_name(nvme_epf->dma_tx_chan), 329 + dma_get_max_seg_size(dmaengine_get_dma_device(nvme_epf-> 330 + dma_tx_chan))); 329 331 330 332 return; 331 333 ··· 2327 2325 return ret; 2328 2326 } 2329 2327 2328 + nvmet_pci_epf_init_dma(nvme_epf); 2329 + 2330 2330 /* Set device ID, class, etc. */ 2331 2331 epf->header->vendorid = ctrl->tctrl->subsys->vendor_id; 2332 2332 epf->header->subsys_vendor_id = ctrl->tctrl->subsys->subsys_vendor_id; ··· 2425 2421 ret = nvmet_pci_epf_configure_bar(nvme_epf); 2426 2422 if (ret) 2427 2423 return ret; 2428 - 2429 - nvmet_pci_epf_init_dma(nvme_epf); 2430 2424 2431 2425 return 0; 2432 2426 }

+6 -6

drivers/nvme/target/rdma.c

··· 367 367 struct nvmet_rdma_cmd *cmds; 368 368 int ret = -EINVAL, i; 369 369 370 - cmds = kcalloc(nr_cmds, sizeof(struct nvmet_rdma_cmd), GFP_KERNEL); 370 + cmds = kvcalloc(nr_cmds, sizeof(struct nvmet_rdma_cmd), GFP_KERNEL); 371 371 if (!cmds) 372 372 goto out; 373 373 ··· 382 382 out_free: 383 383 while (--i >= 0) 384 384 nvmet_rdma_free_cmd(ndev, cmds + i, admin); 385 - kfree(cmds); 385 + kvfree(cmds); 386 386 out: 387 387 return ERR_PTR(ret); 388 388 } ··· 394 394 395 395 for (i = 0; i < nr_cmds; i++) 396 396 nvmet_rdma_free_cmd(ndev, cmds + i, admin); 397 - kfree(cmds); 397 + kvfree(cmds); 398 398 } 399 399 400 400 static int nvmet_rdma_alloc_rsp(struct nvmet_rdma_device *ndev, ··· 455 455 NUMA_NO_NODE, false, true)) 456 456 goto out; 457 457 458 - queue->rsps = kcalloc(nr_rsps, sizeof(struct nvmet_rdma_rsp), 458 + queue->rsps = kvcalloc(nr_rsps, sizeof(struct nvmet_rdma_rsp), 459 459 GFP_KERNEL); 460 460 if (!queue->rsps) 461 461 goto out_free_sbitmap; ··· 473 473 out_free: 474 474 while (--i >= 0) 475 475 nvmet_rdma_free_rsp(ndev, &queue->rsps[i]); 476 - kfree(queue->rsps); 476 + kvfree(queue->rsps); 477 477 out_free_sbitmap: 478 478 sbitmap_free(&queue->rsp_tags); 479 479 out: ··· 487 487 488 488 for (i = 0; i < nr_rsps; i++) 489 489 nvmet_rdma_free_rsp(ndev, &queue->rsps[i]); 490 - kfree(queue->rsps); 490 + kvfree(queue->rsps); 491 491 sbitmap_free(&queue->rsp_tags); 492 492 } 493 493

+3 -3

drivers/nvme/target/tcp.c

··· 1484 1484 struct nvmet_tcp_cmd *cmds; 1485 1485 int i, ret = -EINVAL, nr_cmds = queue->nr_cmds; 1486 1486 1487 - cmds = kcalloc(nr_cmds, sizeof(struct nvmet_tcp_cmd), GFP_KERNEL); 1487 + cmds = kvcalloc(nr_cmds, sizeof(struct nvmet_tcp_cmd), GFP_KERNEL); 1488 1488 if (!cmds) 1489 1489 goto out; 1490 1490 ··· 1500 1500 out_free: 1501 1501 while (--i >= 0) 1502 1502 nvmet_tcp_free_cmd(cmds + i); 1503 - kfree(cmds); 1503 + kvfree(cmds); 1504 1504 out: 1505 1505 return ret; 1506 1506 } ··· 1514 1514 nvmet_tcp_free_cmd(cmds + i); 1515 1515 1516 1516 nvmet_tcp_free_cmd(&queue->connect); 1517 - kfree(cmds); 1517 + kvfree(cmds); 1518 1518 } 1519 1519 1520 1520 static void nvmet_tcp_restore_socket_callbacks(struct nvmet_tcp_queue *queue)

Configure Feed

Configure Feed