From nobody Thu Apr 2 22:28:59 2026 Received: from mail-dl1-f48.google.com (mail-dl1-f48.google.com [74.125.82.48]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id BEBEE17A31C for ; Sat, 14 Feb 2026 04:28:22 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.48 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043304; cv=none; b=qKEjGNLZFFZyDAs/MBGZVOQHcn77MivdDFqPQScUeDJX2Jlv5SH07QWkx2hcW2eVO2rWC5DmIOTQFSL7Zyr79ebh24PE22cEUrpUn/AaG/sAUKTWY+vyRUc0ZuS+mJKb0gWka78tTSZOZp1NZ64YEDgQUcWujZu6ums0crYoaQY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043304; c=relaxed/simple; bh=y7L9tNtdwqa4S4X4xFl4mjh0detKB1D0E0gERIKPd18=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=BxUHtcNHP476xScoS30QoQARpmmziS03sl2qtylGsW//STiMsIzxyR1PkdUlZl4Q0Atgf4rFibyMpmmhzyoHbmvPjYBTygWeyDA6OrUbBK6aPh5xEqYfeFinDEBL6BTO0r4WXrQYlbQyJHVP1clQtq1IXLeHWht8OYRa1DZqQ7E= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com; spf=fail smtp.mailfrom=purestorage.com; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b=NVbX9qb7; arc=none smtp.client-ip=74.125.82.48 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=purestorage.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b="NVbX9qb7" Received: by mail-dl1-f48.google.com with SMTP id a92af1059eb24-1270adc5121so2321964c88.0 for ; Fri, 13 Feb 2026 20:28:22 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=purestorage.com; s=google2022; t=1771043302; x=1771648102; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=DWiAfLikzaFr4GnyqsyXng2vgSJVn4kiF95ZAV+60zk=; b=NVbX9qb7Ql7oZAAYGLSXNzz0YhVODu0BYy8Pe1WjxKEuATbGxvGF4mi8WjPNH7Fqmd a1ZgAoAeLdWbbIQAEo5HNOoaDxNBojEZJLHSZHUg8EjCsI7rlvBV4sQdaCeCSvMQzQGG QYIp4hlb8/SAm6FEYsz0WGhOZ+2Up3OSNJlfU7GIb6IDUjVpm9b0tblhdGqQoQLMrxnf FQvxu1v7R3GwFXmxGiRque+YMWr4MX+ImiUyPUNZO9UTdN/7Xn75dpEEOncOToWtQIkU MP64jRWJ5OXUOpwrjy/XIhCj4JXxxNy05YNdX+qpJo2TlTb48+s07B2yNM2ANG7wRq78 1k0A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1771043302; x=1771648102; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=DWiAfLikzaFr4GnyqsyXng2vgSJVn4kiF95ZAV+60zk=; b=q7oFAN9zgTK85RPjeG0gIfssPtqXpyRbPXvRDjNYqd1mv9fBt06gm/ZQ3Qyq+4v/Rb 2H+8h02ZUQMU/sz3/WLSfHMr1indaMFGUHy7aEMlu9Rgh0hyy+1glyywWPMMDB/904EA NduJZ3k7XQdidCqJUkx0lA3BA+xpwlYYGPSxgzlFGPMRzgX05GqETnyXOqBpfqJ22kUw Wvvfn6wmnXJGP4g7StS4iMEQ/Q6ofRFFtfwX1EdD7pfV6BDw+0ZZCQgSuVBYZIdVjJoD bJt0GSarUGtCGXeSRUqcMJ1t6RopxxGsA1NieMzvJqbDN8hnxPwRcKXiOyzbnP/8LNhR N4Ig== X-Forwarded-Encrypted: i=1; AJvYcCXZ8+tIv0aWE6cuBMKVO9+ySUM0zjByKN/vuaKGN+pJTSgkomRH4k3hfjWNNsYgeYCl9CGqUdGgZqkkOV4=@vger.kernel.org X-Gm-Message-State: AOJu0YwJ6fYJWfQqBPatX8akZs3/EGJV9SvLfKwwOTgr05URMS60TUme CjH0JQreKVPSW7N7OsgFGVVzWRcaWgWWKEPYZgIsEUh53jN3Mi0UmwloiM/+wEqXsyI= X-Gm-Gg: AZuq6aLGJw36ktMXHIygVGMqbY0Kqy/XBcxkM5poweK+u7jUdkDiBJKY/krj05Q7h/M Eox5vy9pPH/5NnTJ7cW6Hs7AKwUn3Z5CW8QFX0R6J1vl9sv+KP/CtPtGJhWOsQRB3CukNVN3lqY zoOnT6l01rWSn1u/2aGYR2QClx8YsmfoLWrbZe5nmEgcR4Ur4ROqlLIzWj75kXW1D3/cNGp/93V 7KeGFMK8Dz9AABSZHkPq9tOyGIoW3YNjfWWM19R/VfH/oP76SkektKp0LrjtYPzWr7r059OYmmi nzQtJI1I9Z8Ojf0x/fs1jJtk6UF2aHsZAqhAIJDaTt1IZ3ANoNSB2zT4Ar680hL4xjMg0AfaAF0 UzYu1YjlceNXg/+4P/3qaBuWgVy6lPWSQ/+e2OMXPo+tLiL2mOz93U/ppHTQcXs7+9fWvsrgeNB A0GbWdJnqDa3oYGcpfxf5B8gQwXQPJBGr3QE+hBPVl2k32Wg== X-Received: by 2002:a05:7022:2394:b0:127:33c5:536b with SMTP id a92af1059eb24-1273adf06e3mr1330405c88.1.1771043301717; Fri, 13 Feb 2026 20:28:21 -0800 (PST) Received: from apollo.purestorage.com ([208.88.152.253]) by smtp.googlemail.com with ESMTPSA id a92af1059eb24-12742cbc900sm1021042c88.14.2026.02.13.20.28.21 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Feb 2026 20:28:21 -0800 (PST) From: Mohamed Khalfella To: Justin Tee , Naresh Gottumukkala , Paul Ely , Chaitanya Kulkarni , Christoph Hellwig , Jens Axboe , Keith Busch , Sagi Grimberg , James Smart , Hannes Reinecke Cc: Aaron Dailey , Randy Jennings , Dhaval Giani , linux-nvme@lists.infradead.org, linux-kernel@vger.kernel.org, Mohamed Khalfella Subject: [PATCH v3 01/21] nvmet: Rapid Path Failure Recovery set controller identify fields Date: Fri, 13 Feb 2026 20:25:02 -0800 Message-ID: <20260214042753.4073668-2-mkhalfella@purestorage.com> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260214042753.4073668-1-mkhalfella@purestorage.com> References: <20260214042753.4073668-1-mkhalfella@purestorage.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" TP8028 Rapid Path Failure Recovery defined new fields in controller identify response. The newly defined fields are: - CIU (Controller Instance UNIQUIFIER): is an 8bit non-zero value that is assigned a random value when controller first created. The value is expected to be incremented when RDY bit in CSTS register is asserted - CIRN (Controller Instance Random Number): is 64bit random value that gets generated when controller is crated. CIRN is regenerated everytime RDY bit is CSTS register is asserted. - CCRL (Cross-Controller Reset Limit) is an 8bit value that defines the maximum number of in-progress controller reset operations. CCRL is hardcoded to 4 as recommended by TP8028. Signed-off-by: Mohamed Khalfella --- drivers/nvme/target/admin-cmd.c | 5 +++++ drivers/nvme/target/core.c | 9 +++++++++ drivers/nvme/target/nvmet.h | 2 ++ include/linux/nvme.h | 10 ++++++++-- 4 files changed, 24 insertions(+), 2 deletions(-) diff --git a/drivers/nvme/target/admin-cmd.c b/drivers/nvme/target/admin-cm= d.c index 5e366502fb75..368e36362ac5 100644 --- a/drivers/nvme/target/admin-cmd.c +++ b/drivers/nvme/target/admin-cmd.c @@ -696,6 +696,11 @@ static void nvmet_execute_identify_ctrl(struct nvmet_r= eq *req) =20 id->cntlid =3D cpu_to_le16(ctrl->cntlid); id->ver =3D cpu_to_le32(ctrl->subsys->ver); + if (!nvmet_is_disc_subsys(ctrl->subsys)) { + id->ciu =3D ctrl->ciu; + id->cirn =3D cpu_to_le64(ctrl->cirn); + id->ccrl =3D NVMF_CCR_LIMIT; + } =20 /* XXX: figure out what to do about RTD3R/RTD3 */ id->oaes =3D cpu_to_le32(NVMET_AEN_CFG_OPTIONAL); diff --git a/drivers/nvme/target/core.c b/drivers/nvme/target/core.c index eab3e4fc0f74..e5f413405604 100644 --- a/drivers/nvme/target/core.c +++ b/drivers/nvme/target/core.c @@ -1394,6 +1394,10 @@ static void nvmet_start_ctrl(struct nvmet_ctrl *ctrl) return; } =20 + if (!nvmet_is_disc_subsys(ctrl->subsys)) { + ctrl->ciu =3D ((u8)(ctrl->ciu + 1)) ? : 1; + ctrl->cirn =3D get_random_u64(); + } ctrl->csts =3D NVME_CSTS_RDY; =20 /* @@ -1662,6 +1666,11 @@ struct nvmet_ctrl *nvmet_alloc_ctrl(struct nvmet_all= oc_ctrl_args *args) } ctrl->cntlid =3D ret; =20 + if (!nvmet_is_disc_subsys(ctrl->subsys)) { + ctrl->ciu =3D get_random_u8() ? : 1; + ctrl->cirn =3D get_random_u64(); + } + /* * Discovery controllers may use some arbitrary high value * in order to cleanup stale discovery sessions diff --git a/drivers/nvme/target/nvmet.h b/drivers/nvme/target/nvmet.h index b664b584fdc8..a36daa5d3a57 100644 --- a/drivers/nvme/target/nvmet.h +++ b/drivers/nvme/target/nvmet.h @@ -264,7 +264,9 @@ struct nvmet_ctrl { =20 uuid_t hostid; u16 cntlid; + u8 ciu; u32 kato; + u64 cirn; =20 struct nvmet_port *port; =20 diff --git a/include/linux/nvme.h b/include/linux/nvme.h index 655d194f8e72..7746b6d30349 100644 --- a/include/linux/nvme.h +++ b/include/linux/nvme.h @@ -21,6 +21,8 @@ #define NVMF_TRADDR_SIZE 256 #define NVMF_TSAS_SIZE 256 =20 +#define NVMF_CCR_LIMIT 4 + #define NVME_DISC_SUBSYS_NAME "nqn.2014-08.org.nvmexpress.discovery" =20 #define NVME_NSID_ALL 0xffffffff @@ -328,7 +330,10 @@ struct nvme_id_ctrl { __le16 crdt1; __le16 crdt2; __le16 crdt3; - __u8 rsvd134[122]; + __u8 rsvd134[1]; + __u8 ciu; + __le64 cirn; + __u8 rsvd144[112]; __le16 oacs; __u8 acl; __u8 aerl; @@ -389,7 +394,8 @@ struct nvme_id_ctrl { __u8 msdbd; __u8 rsvd1804[2]; __u8 dctype; - __u8 rsvd1807[241]; + __u8 ccrl; + __u8 rsvd1808[240]; struct nvme_id_power_state psd[32]; __u8 vs[1024]; }; --=20 2.52.0 From nobody Thu Apr 2 22:28:59 2026 Received: from mail-dl1-f67.google.com (mail-dl1-f67.google.com [74.125.82.67]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 9B16B221F26 for ; Sat, 14 Feb 2026 04:28:23 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.67 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043304; cv=none; b=eL1tAwWPeVUuAOuTP2rVx25EmuGtCEIMHlIqgUMnKE2Snag2PJD9KCSzBiRNTKdF9aE5RzRutzCdw8hygLZ8oHMWjg+bLocIDKz2M5sL65ryQcR2ZFjJcwmsU/ecMv+fbVipX+uY0HMJzMmzY4/RmJ1xIynoUupXxEK64bAj0Go= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043304; c=relaxed/simple; bh=VY7znN3rP/XuecIcYOIeWnzhVhdmypuwu3Lu5HvoHig=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=KBp5AAFX+VaVajwXnxOf5rlTmLDCRxqXXaaWNd0883S3a90hJOskDaSd4FMAClyktycUME3PUd09WHe1Z5hwzqjYzMFZB/Cdl0dSiVTHo/HXdUG+QWiIwYMUY8gvE2Ls6Qd2V47dQxk85OL23pv4sAKSBkopw4msMTGlTUhMgQI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com; spf=fail smtp.mailfrom=purestorage.com; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b=IQiT8/70; arc=none smtp.client-ip=74.125.82.67 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=purestorage.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b="IQiT8/70" Received: by mail-dl1-f67.google.com with SMTP id a92af1059eb24-1271195d2a7so1945328c88.0 for ; Fri, 13 Feb 2026 20:28:23 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=purestorage.com; s=google2022; t=1771043303; x=1771648103; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=+voUH76g/Pq9YBKjG67uJM4aaUaY9JLa+bj+ayVk72U=; b=IQiT8/700rVuH0QEBqvNAHWhE5YIFzc2wxN++9XpkSyPxSjPmYuejfABno1jd0s1LH WWaJx5pHOfjRqCxKbzxo+5TAxZh8Y2+57qvcRErwddMeK6q8KHqPNqjSsiC6fN+vMm4F GDyjWIL4kZLo/dUsV472ft/oKtrpmlrQ/AgnSQGn2AC8BKpbW6Jq5ZR8ykH/LYs4vp3G ThiIT0ORIpOQBGI9Te065BGwot/IJbFbDWiEcO5Wn5pzmAHIicBPoE9Ekz0k/ixOhHMb OMIxJUTWWb7Trew5PpEv27Q7YwdpgLYOeUIpqne4VwFpA70A2vhopdTRGP6W7AxbIph8 aspQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1771043303; x=1771648103; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=+voUH76g/Pq9YBKjG67uJM4aaUaY9JLa+bj+ayVk72U=; b=P0K3JKFQn2G/DcxLVROatOO164bsKBP2bmCsFVtFDK/UvSx6VD+JspuZJpVvI1WhCn XPw9EVKlQPdP7A6MDjQTRePi55fgGOIX6SVtUJLs3tUP3DTBHfjvB5OybdccJi9uIP3O 08LHQ2UXiZvXK06kWm6sR1OLq8x7lyxc1lnkYoQYJ3V64MAyWr6EKjmTNWtORcX76h9K 7+DG5ya8xvXCAPfc0ZYo3WGMX9mgqGvuEU0qhpE/P3EoP9Nulg/SegjgFSao4hpZGyfW Xin7JmgAmMq1om+rISt/pH4oIp7eFk9O+jY0mLKIjzUebRxV6jsw4g7BoJ/7dPwVPosg rHyw== X-Forwarded-Encrypted: i=1; AJvYcCWJrNG9jN72C6uJVaXMekIjjWV7YpgxjOhvpZ66Wl+xfpxn7f9X54Kh/GAIj4+43v8XdsG3o+5cQMXZHtc=@vger.kernel.org X-Gm-Message-State: AOJu0YxJ6byMcHT6UYvopMD4fxPF+qMlgoQVZR9c1zGweKRJrPujCiEM R6Pie5hOhB5Krd4aqpe2lKkduWDQS9ASifsH8slcaEQbDddpMV8gQcq5lbVBfchsqbQ= X-Gm-Gg: AZuq6aL1OZrR3a1jdKDY/iviZWURaeSLZlc6uecuC4y8d0VFbMR2xMbUmg9aydCBCF+ 9CurMCSvRK+1A5OueTOaHHmA6Gk1JMf2x9s74BFpCIdJ6dv7jqpa9K1dTdxKNK3pdcvbScmc9VT 9HMro4+u1rmZAFw744yI3gXRbJdenBDqy6FiFr1nI64Tr0a8IzU/wTxJ82TiMFdEGPYv+mRX7FD +wdD2o6VuvcmDQN+50oSAAnDNiBmjQU+l5xZB37uc5H8iIBBMxW/wj8nMEaSDgDG/YfxF9s02KJ FLlD6hjYZI1QcaHR1D/GyHq8nXzlYpImltwjyIrGLTll/YQ9R6iVajeiVUUqbOSC20SRYjGzlkp RWa9SR0tgGXJuiNmZMqN8As2YOijKrykuW2a8g/EiSOAfLMXUgn/oQieSXeyKMUl5uIj2KAx0e2 VmDadRMHjLjOM/HYzGRd/JtoLAe4iXPtsc8txdVHavRMnc5g== X-Received: by 2002:a05:7022:439b:b0:11b:9386:a3c3 with SMTP id a92af1059eb24-12741bea9e8mr875209c88.46.1771043302619; Fri, 13 Feb 2026 20:28:22 -0800 (PST) Received: from apollo.purestorage.com ([208.88.152.253]) by smtp.googlemail.com with ESMTPSA id a92af1059eb24-12742cbc900sm1021042c88.14.2026.02.13.20.28.21 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Feb 2026 20:28:22 -0800 (PST) From: Mohamed Khalfella To: Justin Tee , Naresh Gottumukkala , Paul Ely , Chaitanya Kulkarni , Christoph Hellwig , Jens Axboe , Keith Busch , Sagi Grimberg , James Smart , Hannes Reinecke Cc: Aaron Dailey , Randy Jennings , Dhaval Giani , linux-nvme@lists.infradead.org, linux-kernel@vger.kernel.org, Mohamed Khalfella Subject: [PATCH v3 02/21] nvmet/debugfs: Export controller CIU and CIRN via debugfs Date: Fri, 13 Feb 2026 20:25:03 -0800 Message-ID: <20260214042753.4073668-3-mkhalfella@purestorage.com> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260214042753.4073668-1-mkhalfella@purestorage.com> References: <20260214042753.4073668-1-mkhalfella@purestorage.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Export ctrl->ciu and ctrl->cirn as debugfs files under controller debugfs directory. Signed-off-by: Mohamed Khalfella Reviewed-by: Hannes Reinecke Reviewed-by: Sagi Grimberg --- drivers/nvme/target/debugfs.c | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/drivers/nvme/target/debugfs.c b/drivers/nvme/target/debugfs.c index 5dcbd5aa86e1..1300adf6c1fb 100644 --- a/drivers/nvme/target/debugfs.c +++ b/drivers/nvme/target/debugfs.c @@ -152,6 +152,23 @@ static int nvmet_ctrl_tls_concat_show(struct seq_file = *m, void *p) } NVMET_DEBUGFS_ATTR(nvmet_ctrl_tls_concat); #endif +static int nvmet_ctrl_instance_ciu_show(struct seq_file *m, void *p) +{ + struct nvmet_ctrl *ctrl =3D m->private; + + seq_printf(m, "%02x\n", ctrl->ciu); + return 0; +} +NVMET_DEBUGFS_ATTR(nvmet_ctrl_instance_ciu); + +static int nvmet_ctrl_instance_cirn_show(struct seq_file *m, void *p) +{ + struct nvmet_ctrl *ctrl =3D m->private; + + seq_printf(m, "%016llx\n", ctrl->cirn); + return 0; +} +NVMET_DEBUGFS_ATTR(nvmet_ctrl_instance_cirn); =20 int nvmet_debugfs_ctrl_setup(struct nvmet_ctrl *ctrl) { @@ -184,6 +201,10 @@ int nvmet_debugfs_ctrl_setup(struct nvmet_ctrl *ctrl) debugfs_create_file("tls_key", S_IRUSR, ctrl->debugfs_dir, ctrl, &nvmet_ctrl_tls_key_fops); #endif + debugfs_create_file("ciu", S_IRUSR, ctrl->debugfs_dir, ctrl, + &nvmet_ctrl_instance_ciu_fops); + debugfs_create_file("cirn", S_IRUSR, ctrl->debugfs_dir, ctrl, + &nvmet_ctrl_instance_cirn_fops); return 0; } =20 --=20 2.52.0 From nobody Thu Apr 2 22:28:59 2026 Received: from mail-dl1-f52.google.com (mail-dl1-f52.google.com [74.125.82.52]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id C144D298CBE for ; Sat, 14 Feb 2026 04:28:24 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.52 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043306; cv=none; b=A1v+wHOBeyfti0B3WvegfsD60CWeXN5Bxrz6o337eIP6+TvVhPKSP28FJOFgv7Jzj7o6jaw0wDRY+Do4XrL6DVtoZfdfaQqm7ji1BzjwPUREDg7L7hrsIcTvuy/9XZRQVTG1/YMoqraApiLYMLwmtUtLBtL6fqrod0iBWGhUi1A= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043306; c=relaxed/simple; bh=CqKWmFYRpeblxnoLJEdPi4K5j/dG+SP7dfFDqSQv1Lw=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=mFFodt8l9PetzeOAVsgKIoPIsCHelwD0nOvtfx0OlQ+vtR6oUEa4dqbyh6b9/Jco7ut2cGkCtu8+bXLSBjj1OzSzfscW2b5yZ6RcjwxBUA0l/8HdmOi9na5D8ubirzCefYPc8wlOtCDZSMsyUuK702/rSSqJszRgFHBlnJwZWo4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com; spf=fail smtp.mailfrom=purestorage.com; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b=EFKS71xI; arc=none smtp.client-ip=74.125.82.52 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=purestorage.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b="EFKS71xI" Received: by mail-dl1-f52.google.com with SMTP id a92af1059eb24-127380532eeso4212771c88.1 for ; Fri, 13 Feb 2026 20:28:24 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=purestorage.com; s=google2022; t=1771043304; x=1771648104; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=ujn7W+4lPH9KY9lfQwvZKjDUpNnsTIoIT7dQKW4fPmw=; b=EFKS71xIrLaBab8A22ddEpfYhEM613lqMTNW9urdWMBXRpeZ27UbhXADOT8PBMdP9A 4s23SIiF1SeR+9gWBo14Z4Lnt93KLlxtXG3INcUKZF4lwR9TNKCqR2vrsXw2Srwv1XY0 Lu/o75iSUM2/+z2qP6OdyBiDaLXrUyH9XuiJDtXWNNVsh4yTNhAVY1gwZHP6ngCnn9X1 VxgTtBSJ02OwsPjryrtYgvipZz1WL4rlW9yjax5I0zaNxg4zsQx+AmIv1iIYjeiA/WPM VC/k51ob5utxazcyvH7zBtecu3JjJFFC5fhz2KmIXSd1OUMfgMFOPWUtDN813V7nz6c0 DCgg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1771043304; x=1771648104; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=ujn7W+4lPH9KY9lfQwvZKjDUpNnsTIoIT7dQKW4fPmw=; b=WD0lMqs65+O45e26/T1XESGQYezunbH2k4lncNbMh1Ib56FIrSgXK5PIGvd+dyoJ1m jS2pLdAr4b2fAQEy3iPWx1Eto6+24Oiat98W5PT2QNHplnWxzjaXdYHuhRvPkJBMlTEd LM7Av6rnBp1iooq53Dwj0l51gvwmxTG+3sz6gWUSE0lMYlin/My+7P/0e48WzBZSMVpj ktI6wTy4QT2tE6BCvNH0D04XxvbQ/BiKCi+arXkcJm5zyQHSwEhNkk4HBCtJjuL/RcZO wSIbclA2qMSNdRwgvPX1VYzo9yVSRGTLqaUzzjoIlwD0ugFrKDfwhhAqK/vm9yOa0vI1 ENMw== X-Forwarded-Encrypted: i=1; AJvYcCU/JP4G9GL9kCJgYZM9bRXyLLs5Shp+KGxx6s0MyCwnv5w3+wMuTpjdYFJK7BE6UJ4/6/um1vjPwKqiXes=@vger.kernel.org X-Gm-Message-State: AOJu0YzBz3SixgG3BWpIdFz1zT59dHY5NPogQpnTbcPxri9o2Qg6LMNi gpJE4fMBgQmHPY23UY6Vp1KgkTe3H8axGo9Na8cS0GhOZ5TBcIeVEGTj2X2GrK1tDaE= X-Gm-Gg: AZuq6aL02v74iA5pkRC6L1J35NxmB1Dri3B1T5h10RvvXmwP9xjWUNrEXFkwd6pA1Od blEL2b3EyT8zf2ofQwgpZVdSycEdIfpXGhbWbhWacSkVc67WK1uUf9aJCgQOryTJdPUb5urYfaS +jViKO62YDyXR6LP5XQ2vVUkVKN90Za8v3oaTNw+SnZabyR7b+kV/hm3kyb8TU5e3PzABaF6CHG RYzrKetbj4EAXKfjv+BcZVYi3h/ZlvapVIG5srUlaUbeSqBOfWl1kdXeUPaGOAzB0NkVtnGW4Af LXQizzGrCTVjrffQZcSbfphYdNlQB7u3MkUWeYOWLEffoMquIaI2r2kQdRU2YmhzUotgsyBxh+E 4LAK7bE1hL7msNdpwyQjioMHRnS2T7H0Pr73CNNP6540kbklIBd97S11ksjNcDHdkmU25FQ1M45 Jz2tEG6/L2R/myS6AoG1wupkaio6L7U9T7aS1AyU+wt95xaA== X-Received: by 2002:a05:7022:4384:b0:119:e56b:c752 with SMTP id a92af1059eb24-1273ae6989cmr1603645c88.23.1771043303588; Fri, 13 Feb 2026 20:28:23 -0800 (PST) Received: from apollo.purestorage.com ([208.88.152.253]) by smtp.googlemail.com with ESMTPSA id a92af1059eb24-12742cbc900sm1021042c88.14.2026.02.13.20.28.22 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Feb 2026 20:28:23 -0800 (PST) From: Mohamed Khalfella To: Justin Tee , Naresh Gottumukkala , Paul Ely , Chaitanya Kulkarni , Christoph Hellwig , Jens Axboe , Keith Busch , Sagi Grimberg , James Smart , Hannes Reinecke Cc: Aaron Dailey , Randy Jennings , Dhaval Giani , linux-nvme@lists.infradead.org, linux-kernel@vger.kernel.org, Mohamed Khalfella Subject: [PATCH v3 03/21] nvmet: Implement CCR nvme command Date: Fri, 13 Feb 2026 20:25:04 -0800 Message-ID: <20260214042753.4073668-4-mkhalfella@purestorage.com> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260214042753.4073668-1-mkhalfella@purestorage.com> References: <20260214042753.4073668-1-mkhalfella@purestorage.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Defined by TP8028 Rapid Path Failure Recovery, CCR (Cross-Controller Reset) command is an nvme command issued to source controller by initiator to reset impacted controller. Implement CCR command for linux nvme target. Signed-off-by: Mohamed Khalfella --- drivers/nvme/target/admin-cmd.c | 74 ++++++++++++++++++++++++++++++++ drivers/nvme/target/core.c | 76 +++++++++++++++++++++++++++++++++ drivers/nvme/target/nvmet.h | 13 ++++++ include/linux/nvme.h | 23 ++++++++++ 4 files changed, 186 insertions(+) diff --git a/drivers/nvme/target/admin-cmd.c b/drivers/nvme/target/admin-cm= d.c index 368e36362ac5..65ed772babb8 100644 --- a/drivers/nvme/target/admin-cmd.c +++ b/drivers/nvme/target/admin-cmd.c @@ -376,7 +376,9 @@ static void nvmet_get_cmd_effects_admin(struct nvmet_ct= rl *ctrl, log->acs[nvme_admin_get_features] =3D log->acs[nvme_admin_async_event] =3D log->acs[nvme_admin_keep_alive] =3D + log->acs[nvme_admin_cross_ctrl_reset] =3D cpu_to_le32(NVME_CMD_EFFECTS_CSUPP); + } =20 static void nvmet_get_cmd_effects_nvm(struct nvme_effects_log *log) @@ -1614,6 +1616,75 @@ void nvmet_execute_keep_alive(struct nvmet_req *req) nvmet_req_complete(req, status); } =20 +void nvmet_execute_cross_ctrl_reset(struct nvmet_req *req) +{ + struct nvmet_ctrl *ictrl, *sctrl =3D req->sq->ctrl; + struct nvme_command *cmd =3D req->cmd; + struct nvmet_ccr *ccr, *new_ccr; + int ccr_active, ccr_total; + u16 cntlid, status =3D NVME_SC_SUCCESS; + + cntlid =3D le16_to_cpu(cmd->ccr.icid); + if (sctrl->cntlid =3D=3D cntlid) { + req->error_loc =3D + offsetof(struct nvme_cross_ctrl_reset_cmd, icid); + status =3D NVME_SC_INVALID_FIELD | NVME_STATUS_DNR; + goto out; + } + + /* Find and get impacted controller */ + ictrl =3D nvmet_ctrl_find_get_ccr(sctrl->subsys, sctrl->hostnqn, + cmd->ccr.ciu, cntlid, + le64_to_cpu(cmd->ccr.cirn)); + if (!ictrl) { + /* Immediate Reset Successful */ + nvmet_set_result(req, 1); + status =3D NVME_SC_SUCCESS; + goto out; + } + + ccr_total =3D ccr_active =3D 0; + mutex_lock(&sctrl->lock); + list_for_each_entry(ccr, &sctrl->ccr_list, entry) { + if (ccr->ctrl =3D=3D ictrl) { + status =3D NVME_SC_CCR_IN_PROGRESS | NVME_STATUS_DNR; + goto out_unlock; + } + + ccr_total++; + if (ccr->ctrl) + ccr_active++; + } + + if (ccr_active >=3D NVMF_CCR_LIMIT) { + status =3D NVME_SC_CCR_LIMIT_EXCEEDED; + goto out_unlock; + } + if (ccr_total >=3D NVMF_CCR_PER_PAGE) { + status =3D NVME_SC_CCR_LOGPAGE_FULL; + goto out_unlock; + } + + new_ccr =3D kmalloc(sizeof(*new_ccr), GFP_KERNEL); + if (!new_ccr) { + status =3D NVME_SC_INTERNAL; + goto out_unlock; + } + + new_ccr->ciu =3D cmd->ccr.ciu; + new_ccr->icid =3D cntlid; + new_ccr->ctrl =3D ictrl; + list_add_tail(&new_ccr->entry, &sctrl->ccr_list); + +out_unlock: + mutex_unlock(&sctrl->lock); + if (status =3D=3D NVME_SC_SUCCESS) + nvmet_ctrl_fatal_error(ictrl); + nvmet_ctrl_put(ictrl); +out: + nvmet_req_complete(req, status); +} + u32 nvmet_admin_cmd_data_len(struct nvmet_req *req) { struct nvme_command *cmd =3D req->cmd; @@ -1691,6 +1762,9 @@ u16 nvmet_parse_admin_cmd(struct nvmet_req *req) case nvme_admin_keep_alive: req->execute =3D nvmet_execute_keep_alive; return 0; + case nvme_admin_cross_ctrl_reset: + req->execute =3D nvmet_execute_cross_ctrl_reset; + return 0; default: return nvmet_report_invalid_opcode(req); } diff --git a/drivers/nvme/target/core.c b/drivers/nvme/target/core.c index e5f413405604..38f71e1a1b8e 100644 --- a/drivers/nvme/target/core.c +++ b/drivers/nvme/target/core.c @@ -115,6 +115,20 @@ u16 nvmet_zero_sgl(struct nvmet_req *req, off_t off, s= ize_t len) return 0; } =20 +void nvmet_ctrl_cleanup_ccrs(struct nvmet_ctrl *ctrl, bool all) +{ + struct nvmet_ccr *ccr, *tmp; + + lockdep_assert_held(&ctrl->lock); + + list_for_each_entry_safe(ccr, tmp, &ctrl->ccr_list, entry) { + if (all || ccr->ctrl =3D=3D NULL) { + list_del(&ccr->entry); + kfree(ccr); + } + } +} + static u32 nvmet_max_nsid(struct nvmet_subsys *subsys) { struct nvmet_ns *cur; @@ -1397,6 +1411,7 @@ static void nvmet_start_ctrl(struct nvmet_ctrl *ctrl) if (!nvmet_is_disc_subsys(ctrl->subsys)) { ctrl->ciu =3D ((u8)(ctrl->ciu + 1)) ? : 1; ctrl->cirn =3D get_random_u64(); + nvmet_ctrl_cleanup_ccrs(ctrl, false); } ctrl->csts =3D NVME_CSTS_RDY; =20 @@ -1502,6 +1517,35 @@ struct nvmet_ctrl *nvmet_ctrl_find_get(const char *s= ubsysnqn, return ctrl; } =20 +struct nvmet_ctrl *nvmet_ctrl_find_get_ccr(struct nvmet_subsys *subsys, + const char *hostnqn, u8 ciu, + u16 cntlid, u64 cirn) +{ + struct nvmet_ctrl *ctrl, *ictrl =3D NULL; + bool found =3D false; + + mutex_lock(&subsys->lock); + list_for_each_entry(ctrl, &subsys->ctrls, subsys_entry) { + if (ctrl->cntlid !=3D cntlid) + continue; + + /* Avoid racing with a controller that is becoming ready */ + mutex_lock(&ctrl->lock); + if (ctrl->ciu =3D=3D ciu && ctrl->cirn =3D=3D cirn) + found =3D true; + mutex_unlock(&ctrl->lock); + + if (found) { + if (kref_get_unless_zero(&ctrl->ref)) + ictrl =3D ctrl; + break; + } + }; + mutex_unlock(&subsys->lock); + + return ictrl; +} + u16 nvmet_check_ctrl_status(struct nvmet_req *req) { if (unlikely(!(req->sq->ctrl->cc & NVME_CC_ENABLE))) { @@ -1627,6 +1671,7 @@ struct nvmet_ctrl *nvmet_alloc_ctrl(struct nvmet_allo= c_ctrl_args *args) subsys->clear_ids =3D 1; #endif =20 + INIT_LIST_HEAD(&ctrl->ccr_list); INIT_WORK(&ctrl->async_event_work, nvmet_async_event_work); INIT_LIST_HEAD(&ctrl->async_events); INIT_RADIX_TREE(&ctrl->p2p_ns_map, GFP_KERNEL); @@ -1740,12 +1785,43 @@ struct nvmet_ctrl *nvmet_alloc_ctrl(struct nvmet_al= loc_ctrl_args *args) } EXPORT_SYMBOL_GPL(nvmet_alloc_ctrl); =20 +static void nvmet_ctrl_complete_pending_ccr(struct nvmet_ctrl *ctrl) +{ + struct nvmet_subsys *subsys =3D ctrl->subsys; + struct nvmet_ctrl *sctrl; + struct nvmet_ccr *ccr; + + lockdep_assert_held(&subsys->lock); + + /* Cleanup all CCRs issued by ctrl as source controller */ + mutex_lock(&ctrl->lock); + nvmet_ctrl_cleanup_ccrs(ctrl, true); + mutex_unlock(&ctrl->lock); + + /* + * Find all CCRs targeting ctrl as impacted controller and + * set ccr->ctrl to NULL. This tells the source controller + * that CCR completed successfully. + */ + list_for_each_entry(sctrl, &subsys->ctrls, subsys_entry) { + mutex_lock(&sctrl->lock); + list_for_each_entry(ccr, &sctrl->ccr_list, entry) { + if (ccr->ctrl =3D=3D ctrl) { + ccr->ctrl =3D NULL; + break; + } + } + mutex_unlock(&sctrl->lock); + } +} + static void nvmet_ctrl_free(struct kref *ref) { struct nvmet_ctrl *ctrl =3D container_of(ref, struct nvmet_ctrl, ref); struct nvmet_subsys *subsys =3D ctrl->subsys; =20 mutex_lock(&subsys->lock); + nvmet_ctrl_complete_pending_ccr(ctrl); nvmet_ctrl_destroy_pr(ctrl); nvmet_release_p2p_ns_map(ctrl); list_del(&ctrl->subsys_entry); diff --git a/drivers/nvme/target/nvmet.h b/drivers/nvme/target/nvmet.h index a36daa5d3a57..b06d905c08c8 100644 --- a/drivers/nvme/target/nvmet.h +++ b/drivers/nvme/target/nvmet.h @@ -268,6 +268,7 @@ struct nvmet_ctrl { u32 kato; u64 cirn; =20 + struct list_head ccr_list; struct nvmet_port *port; =20 u32 aen_enabled; @@ -314,6 +315,13 @@ struct nvmet_ctrl { struct nvmet_pr_log_mgr pr_log_mgr; }; =20 +struct nvmet_ccr { + struct nvmet_ctrl *ctrl; + struct list_head entry; + u16 icid; + u8 ciu; +}; + struct nvmet_subsys { enum nvme_subsys_type type; =20 @@ -576,6 +584,7 @@ void nvmet_req_free_sgls(struct nvmet_req *req); void nvmet_execute_set_features(struct nvmet_req *req); void nvmet_execute_get_features(struct nvmet_req *req); void nvmet_execute_keep_alive(struct nvmet_req *req); +void nvmet_execute_cross_ctrl_reset(struct nvmet_req *req); =20 u16 nvmet_check_cqid(struct nvmet_ctrl *ctrl, u16 cqid, bool create); u16 nvmet_check_io_cqid(struct nvmet_ctrl *ctrl, u16 cqid, bool create); @@ -618,6 +627,10 @@ struct nvmet_ctrl *nvmet_alloc_ctrl(struct nvmet_alloc= _ctrl_args *args); struct nvmet_ctrl *nvmet_ctrl_find_get(const char *subsysnqn, const char *hostnqn, u16 cntlid, struct nvmet_req *req); +struct nvmet_ctrl *nvmet_ctrl_find_get_ccr(struct nvmet_subsys *subsys, + const char *hostnqn, u8 ciu, + u16 cntlid, u64 cirn); +void nvmet_ctrl_cleanup_ccrs(struct nvmet_ctrl *ctrl, bool all); void nvmet_ctrl_put(struct nvmet_ctrl *ctrl); u16 nvmet_check_ctrl_status(struct nvmet_req *req); ssize_t nvmet_ctrl_host_traddr(struct nvmet_ctrl *ctrl, diff --git a/include/linux/nvme.h b/include/linux/nvme.h index 7746b6d30349..d9b421dc1ef3 100644 --- a/include/linux/nvme.h +++ b/include/linux/nvme.h @@ -22,6 +22,7 @@ #define NVMF_TSAS_SIZE 256 =20 #define NVMF_CCR_LIMIT 4 +#define NVMF_CCR_PER_PAGE 511 =20 #define NVME_DISC_SUBSYS_NAME "nqn.2014-08.org.nvmexpress.discovery" =20 @@ -1222,6 +1223,22 @@ struct nvme_zone_mgmt_recv_cmd { __le32 cdw14[2]; }; =20 +struct nvme_cross_ctrl_reset_cmd { + __u8 opcode; + __u8 flags; + __u16 command_id; + __le32 nsid; + __le64 rsvd2[2]; + union nvme_data_ptr dptr; + __u8 rsvd10; + __u8 ciu; + __le16 icid; + __le32 cdw11; + __le64 cirn; + __le32 cdw14; + __le32 cdw15; +}; + struct nvme_io_mgmt_recv_cmd { __u8 opcode; __u8 flags; @@ -1320,6 +1337,7 @@ enum nvme_admin_opcode { nvme_admin_virtual_mgmt =3D 0x1c, nvme_admin_nvme_mi_send =3D 0x1d, nvme_admin_nvme_mi_recv =3D 0x1e, + nvme_admin_cross_ctrl_reset =3D 0x38, nvme_admin_dbbuf =3D 0x7C, nvme_admin_format_nvm =3D 0x80, nvme_admin_security_send =3D 0x81, @@ -1353,6 +1371,7 @@ enum nvme_admin_opcode { nvme_admin_opcode_name(nvme_admin_virtual_mgmt), \ nvme_admin_opcode_name(nvme_admin_nvme_mi_send), \ nvme_admin_opcode_name(nvme_admin_nvme_mi_recv), \ + nvme_admin_opcode_name(nvme_admin_cross_ctrl_reset), \ nvme_admin_opcode_name(nvme_admin_dbbuf), \ nvme_admin_opcode_name(nvme_admin_format_nvm), \ nvme_admin_opcode_name(nvme_admin_security_send), \ @@ -2006,6 +2025,7 @@ struct nvme_command { struct nvme_dbbuf dbbuf; struct nvme_directive_cmd directive; struct nvme_io_mgmt_recv_cmd imr; + struct nvme_cross_ctrl_reset_cmd ccr; }; }; =20 @@ -2170,6 +2190,9 @@ enum { NVME_SC_PMR_SAN_PROHIBITED =3D 0x123, NVME_SC_ANA_GROUP_ID_INVALID =3D 0x124, NVME_SC_ANA_ATTACH_FAILED =3D 0x125, + NVME_SC_CCR_IN_PROGRESS =3D 0x13f, + NVME_SC_CCR_LOGPAGE_FULL =3D 0x140, + NVME_SC_CCR_LIMIT_EXCEEDED =3D 0x141, =20 /* * I/O Command Set Specific - NVM commands: --=20 2.52.0 From nobody Thu Apr 2 22:28:59 2026 Received: from mail-dl1-f45.google.com (mail-dl1-f45.google.com [74.125.82.45]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 8F56E2BE03B for ; Sat, 14 Feb 2026 04:28:25 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.45 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043306; cv=none; b=Oe6K3aKH1ZlMdznBuovHrNnVhjoebu2CqE8HD28FopiVoqR+gswPzVrYi6LMjIz+COvUQZrpwzu6/3ZbpP4nX8zcf3Sf5MCWFGemaDErjwbT8zSDb8b4sbyVN8OaLk2yo4v1uJU9ERcnyg7zGsSw3jL6MSD895sfvhTONI8yD9k= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043306; c=relaxed/simple; bh=Qj+5yNQaODMwMypBYxmbGsn05bpI9Wn8ngebcpEKNmg=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=pwxOlQdJLgdHpnv2aVpsuXQCF/L3JTA/x9K+3hi90ODXFoypFHrYWRY5H+GA1ALkQg3/7Kxh/Q8PVW4chBPUHSYyr9Pq/D9iR+bN/LzOFpZHjWrVfJL16HCdbiYpSVwQHrPiLS99cwB20/Hkjn73uL9PVkowNJtOcq55bqR3qPw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com; spf=fail smtp.mailfrom=purestorage.com; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b=P38rMBNg; arc=none smtp.client-ip=74.125.82.45 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=purestorage.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b="P38rMBNg" Received: by mail-dl1-f45.google.com with SMTP id a92af1059eb24-126ea4b77adso2033435c88.1 for ; Fri, 13 Feb 2026 20:28:25 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=purestorage.com; s=google2022; t=1771043305; x=1771648105; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=CZrFuOxPh30GDseArs+7imxFHdxAweEbIg0R0txG24E=; b=P38rMBNg2rZhXcogQGJ9+R8tF4LHzRfUBLIcyRngzoipm01vDmqxDNgvwtYrtkImr3 dnP2/wCgSmPb0T1vly7kTz9vhOx+w0oNpTKYlnNYTm/TYbjnDRBYMs5IeqbfBR+i6mc4 lCJgws9zxEctDE74pMbEQNwT53SN0DD025tZ/KOiLidjMSvofR8VQjHg/HW6Hs6IZENm GbusmRAmf4tVJIU8KH/P552HHdKA1rs7kOv/lk6cFpni15F4xg6HU9bglemd41SKx/Ws oBFxDkB4dhzeW8lAOYH4/+3xW/pAZu9IS69Dj+SMbVf828qsvPxsT7Qxz8EQqya8vdj/ bbOQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1771043305; x=1771648105; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=CZrFuOxPh30GDseArs+7imxFHdxAweEbIg0R0txG24E=; b=Fqo2cR5C5AMAxAblfVjDpgQ/jJtgn18w32ac7ymkdVPumzkmb0PRp0WxE2clUeJRna 1fT9bGPJaTFe8RwGjYG3rLwXs1FsfJFwpBRFlKcqhfcQR25d4jjpqAdRh9NTrcaPPrwG 1sXqRqzzw9s8+t2O2Woh8KN0fty4PGze0pHyId+jHzoDpHahIu/ce6LCNnNS210hgSGp S0LreADwWAP5tSlebw7LtkQr+Zzxv7Qn7WrzzbGTFc+N37bLo+8jp9IUlYVi6th9vHmA 4sGZQM3mbmQPFE4rvOmiclFJ3rMrh7AfksFriP8SXIEuWKJnVhpkBNtyLEX9zFznrn6G WaPQ== X-Forwarded-Encrypted: i=1; AJvYcCWEuqtQP1PYva1pyzMCCYArdx2j75s1HTldMV8vjPmul4GaEzIUflpTtBk5qkfSncOFL2qGikX2Dsl5jtI=@vger.kernel.org X-Gm-Message-State: AOJu0YwSg7S0/FCYccGyrtIjcKT+IsbCM099PynjwRbBarQbFWrKPk/K O4uoZCDFTVNtmMszqD6akHRZv88GmvZqf58eMCBRzweZFMgtZZCQC3tRCHwTkGfu77c= X-Gm-Gg: AZuq6aLtua65ss/OliNCakcMXNKv1LZNw7LbHHa2ZUlvQtOIsf3d7oU6Yw0gbQ32F9T h/hU3LECPIrsuF/zblLNiouM4mxy/cK4AvvOJ++EvQ0oIO06A27hjS79ZR4/wDt6UmD5RaKA0D7 WPg78BhQ5jysgiIiBcESG/DdelAVzWvpNiH8+gDhejIFDo/9hAjC+duPPKHlzqyQqmiFNcc0VEb A6+QXNGEOWOEKWjEL8uJgdbPqocXLm8kU3onxy7eoXC89XNwVmEnnH28vDk9UyFvWc+RUlLSQQ+ ori+7UOuxMzD6earDMZ0XOtn036inXsFVevLYkdbFggQnbL59N3oA4QWvsKKdHhUuZahIGM5Vcj 6xMC8AFI9rPIbeV0x8wEKvdrOpbhEXjJzzSO3v2ULyY/XiVaSjOCTILRftGdOcXFe/U+4c0kDAW UhRFn/HoLxnkJqoBSzsbeL+IGsZcn+Cxfw5FAfxWfEdAW+gg== X-Received: by 2002:a05:7022:929:b0:11d:f44d:1863 with SMTP id a92af1059eb24-127397a2455mr2164149c88.11.1771043304472; Fri, 13 Feb 2026 20:28:24 -0800 (PST) Received: from apollo.purestorage.com ([208.88.152.253]) by smtp.googlemail.com with ESMTPSA id a92af1059eb24-12742cbc900sm1021042c88.14.2026.02.13.20.28.23 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Feb 2026 20:28:24 -0800 (PST) From: Mohamed Khalfella To: Justin Tee , Naresh Gottumukkala , Paul Ely , Chaitanya Kulkarni , Christoph Hellwig , Jens Axboe , Keith Busch , Sagi Grimberg , James Smart , Hannes Reinecke Cc: Aaron Dailey , Randy Jennings , Dhaval Giani , linux-nvme@lists.infradead.org, linux-kernel@vger.kernel.org, Mohamed Khalfella Subject: [PATCH v3 04/21] nvmet: Implement CCR logpage Date: Fri, 13 Feb 2026 20:25:05 -0800 Message-ID: <20260214042753.4073668-5-mkhalfella@purestorage.com> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260214042753.4073668-1-mkhalfella@purestorage.com> References: <20260214042753.4073668-1-mkhalfella@purestorage.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Defined by TP8028 Rapid Path Failure Recovery, CCR (Cross-Controller Reset) log page contains an entry for each CCR request submitted to source controller. Implement CCR logpage for nvme linux target. Signed-off-by: Mohamed Khalfella Reviewed-by: Hannes Reinecke Reviewed-by: Sagi Grimberg --- drivers/nvme/target/admin-cmd.c | 44 +++++++++++++++++++++++++++++++++ include/linux/nvme.h | 29 ++++++++++++++++++++++ 2 files changed, 73 insertions(+) diff --git a/drivers/nvme/target/admin-cmd.c b/drivers/nvme/target/admin-cm= d.c index 65ed772babb8..925a81979278 100644 --- a/drivers/nvme/target/admin-cmd.c +++ b/drivers/nvme/target/admin-cmd.c @@ -220,6 +220,7 @@ static void nvmet_execute_get_supported_log_pages(struc= t nvmet_req *req) logs->lids[NVME_LOG_FEATURES] =3D cpu_to_le32(NVME_LIDS_LSUPP); logs->lids[NVME_LOG_RMI] =3D cpu_to_le32(NVME_LIDS_LSUPP); logs->lids[NVME_LOG_RESERVATION] =3D cpu_to_le32(NVME_LIDS_LSUPP); + logs->lids[NVME_LOG_CCR] =3D cpu_to_le32(NVME_LIDS_LSUPP); =20 status =3D nvmet_copy_to_sgl(req, 0, logs, sizeof(*logs)); kfree(logs); @@ -608,6 +609,47 @@ static void nvmet_execute_get_log_page_features(struct= nvmet_req *req) nvmet_req_complete(req, status); } =20 +static void nvmet_execute_get_log_page_ccr(struct nvmet_req *req) +{ + struct nvmet_ctrl *ctrl =3D req->sq->ctrl; + struct nvmet_ccr *ccr; + struct nvme_ccr_log *log; + int index =3D 0; + u16 status; + + log =3D kzalloc(sizeof(*log), GFP_KERNEL); + if (!log) { + status =3D NVME_SC_INTERNAL; + goto out; + } + + mutex_lock(&ctrl->lock); + list_for_each_entry(ccr, &ctrl->ccr_list, entry) { + u8 flags =3D NVME_CCR_FLAGS_VALIDATED | NVME_CCR_FLAGS_INITIATED; + u8 status =3D ccr->ctrl ? NVME_CCR_STATUS_IN_PROGRESS : + NVME_CCR_STATUS_SUCCESS; + + log->entries[index].icid =3D cpu_to_le16(ccr->icid); + log->entries[index].ciu =3D ccr->ciu; + log->entries[index].acid =3D cpu_to_le16(0xffff); + log->entries[index].ccrs =3D status; + log->entries[index].ccrf =3D flags; + index++; + } + + /* Cleanup completed CCRs if requested */ + if (req->cmd->get_log_page.lsp & 0x1) + nvmet_ctrl_cleanup_ccrs(ctrl, false); + mutex_unlock(&ctrl->lock); + + log->ne =3D cpu_to_le16(index); + nvmet_clear_aen_bit(req, NVME_AEN_BIT_CCR_COMPLETE); + status =3D nvmet_copy_to_sgl(req, 0, log, sizeof(*log)); + kfree(log); +out: + nvmet_req_complete(req, status); +} + static void nvmet_execute_get_log_page(struct nvmet_req *req) { if (!nvmet_check_transfer_len(req, nvmet_get_log_page_len(req->cmd))) @@ -641,6 +683,8 @@ static void nvmet_execute_get_log_page(struct nvmet_req= *req) return nvmet_execute_get_log_page_rmi(req); case NVME_LOG_RESERVATION: return nvmet_execute_get_log_page_resv(req); + case NVME_LOG_CCR: + return nvmet_execute_get_log_page_ccr(req); } pr_debug("unhandled lid %d on qid %d\n", req->cmd->get_log_page.lid, req->sq->qid); diff --git a/include/linux/nvme.h b/include/linux/nvme.h index d9b421dc1ef3..9b6d93270c59 100644 --- a/include/linux/nvme.h +++ b/include/linux/nvme.h @@ -1432,6 +1432,7 @@ enum { NVME_LOG_FDP_CONFIGS =3D 0x20, NVME_LOG_DISC =3D 0x70, NVME_LOG_RESERVATION =3D 0x80, + NVME_LOG_CCR =3D 0x1E, NVME_FWACT_REPL =3D (0 << 3), NVME_FWACT_REPL_ACTV =3D (1 << 3), NVME_FWACT_ACTV =3D (2 << 3), @@ -1455,6 +1456,34 @@ enum { NVME_FIS_CSCPE =3D 1 << 21, }; =20 +/* NVMe Cross-Controller Reset Status */ +enum { + NVME_CCR_STATUS_IN_PROGRESS, + NVME_CCR_STATUS_SUCCESS, + NVME_CCR_STATUS_FAILED, +}; + +/* NVMe Cross-Controller Reset Flags */ +enum { + NVME_CCR_FLAGS_VALIDATED =3D 0x01, + NVME_CCR_FLAGS_INITIATED =3D 0x02, +}; + +struct nvme_ccr_log_entry { + __le16 icid; + __u8 ciu; + __u8 rsvd3; + __le16 acid; + __u8 ccrs; + __u8 ccrf; +}; + +struct nvme_ccr_log { + __le16 ne; + __u8 rsvd2[6]; + struct nvme_ccr_log_entry entries[NVMF_CCR_PER_PAGE]; +}; + /* NVMe Namespace Write Protect State */ enum { NVME_NS_NO_WRITE_PROTECT =3D 0, --=20 2.52.0 From nobody Thu Apr 2 22:28:59 2026 Received: from mail-dl1-f44.google.com (mail-dl1-f44.google.com [74.125.82.44]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 6EC442BEC4E for ; Sat, 14 Feb 2026 04:28:26 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.44 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043308; cv=none; b=nc7kgyYb7yZmYDL0e3tGSkvFv91LaSMVc6owhNRYaTLegsiALbko5jsY4j6RJcc2nEfjVhBofY3j4tTXOyeeWFVRKu9GGXjlfRglrRg3pchb9TQCI5SV8n+S+ci6sxCSP5HxsMXmm7gys0JkyU3GAZlFaGvcKOrZo0uZR2Aw2Ss= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043308; c=relaxed/simple; bh=3qwkRFUlIv7SMQ+hbI7qAkH9qXXcpPjMaV1P9bpYGjw=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=mStnxRn6pgKIVt60gBQIg5yn+ZQK/Y8vrDrGUnaz8zILSve7DEfxawlnggxQfcD7sO8asc2jOwGumi0PLmGFQPN3l1k+v+MwtXwYLVrnkQ1a302R7/lNY7LsP6rGh0kB6PjhQqCoxmM6qHXiFBDlk0p9vgmB71fS9xTAjzJGsbo= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com; spf=fail smtp.mailfrom=purestorage.com; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b=b4R/x/1/; arc=none smtp.client-ip=74.125.82.44 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=purestorage.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b="b4R/x/1/" Received: by mail-dl1-f44.google.com with SMTP id a92af1059eb24-124afd03fd1so2559664c88.0 for ; Fri, 13 Feb 2026 20:28:26 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=purestorage.com; s=google2022; t=1771043305; x=1771648105; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=aUvJMxt7knmUTeOZs2dmIkt23G0xfZRWuCisOpX3yO8=; b=b4R/x/1/A7WZnrf1WULBBa0wXuQAFQEFuHWVUVHpysoP15y0zJBq4VT7BWNFyXrFLz nkA+dw19KcQVwQD5bf6oNAkzwlfx4KAKnnnkEriab8P8F/FJwPp3HLcCftSjg6kCLmKw VL4lJO5yDn/ijDES/U1+swXGgOjWPZ9rvZkgXaEa+ADLpsySlhfv68tvjT01RzJ7ddkl jyLUto5hgV2lXbjqcNHhTC6/cvKKA2JQdENV0ZR99G7pKB86ZOrSkDRYNMhstb5ren5e Cyz6t4hEPaiJun7L81nmzdCDqtzo6Rj6JcVTUeWyzOsip4BB/MwP8DdXOU+9jdRQh5bb OP2A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1771043305; x=1771648105; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=aUvJMxt7knmUTeOZs2dmIkt23G0xfZRWuCisOpX3yO8=; b=KJO/0ME7/U6t3rhtqJeuz74uwHzcjDDlkz+iU/7ip4mKwGF8fuc50/TgrBOEZ5e7yQ 3FPEJZ+jA22C2InHv4difEc5T1TKKil6DzQi5haY9rvYH3TMpFA2lUuZt7typt4czyMZ M4ifRAFCabft1DsefcVTjsJPOJU6EaWyv9JgSGrsl85efFW54iwQ/nhRbpLEgUrDOHUs U1dCeO7KpyUU/nq0BrHTbWOyTuuTVJDi1+i4nno+pax9/AeqvBF6t++L1rzhpyjShAv7 126duJUp4dj+l06U7AiB6OezQvWsQtukUIy3h6nR6A04B8iGpENfXOcA9ZG6LkQoLNu2 sIJg== X-Forwarded-Encrypted: i=1; AJvYcCWQwoSorg0GEUeoyjH1sK7/Y9zjhmOs7tt9r6TaVx+AjjFYJyOEYLpjW/oeNjETS0pUCcHAC2TpC3bk1tw=@vger.kernel.org X-Gm-Message-State: AOJu0YzERG618EdYPRl4BKF4wa44kHb7j5UwPd5yRUg3Vgqapfxo7VZP 7ugBi7ZdW5zl3dk0Mprx6CeRLZ+6XswAHi/TJ79VlwQTr1G1u95tZ6AP3WCq9N34uJw= X-Gm-Gg: AZuq6aIJV0InVBO957JgoPvF8PPgEqAjmg0vXPDkaCa0rMSrQ8GMQY8UHb6dnuX0sKL eCv0c9spQ17k86wOcreDlq9c0m265MkEmahpC6sy7o7TLAcC0o94C6InhJPWaRLWBD2slhp+K11 bU/e2X2EdBP12o1Xlx3lie9fx5SdPlR6a32Qpz25qA/7jTT4WIbrJUQ0q+cYTpdoFUpMD+oXWqa OdTY/5mRoeT/eP49xjeUYOuLkndPaaAFM3WvlhbVTFPXxfD1yN0z7BV0ht13fQWcCxvnjnefcyB ReKimMUBJM7tiFdeeCvsD5ZFCJCSTcBZtdS/mdRke7ZkUi6a/bgACPWfVtGEpYb5z4jFGciU90G 06DKfxGgvATVayS3PFd6JD8SR0blmyC6JUZeIuo77As2e/7l4rRFe95//ySzQhc8N6YcMrpRRV1 eAgeuFXp/qqXTCOgxNe5AgCptvQg7b6c1VlOEwMt2kyz0Fqw== X-Received: by 2002:a05:7022:6897:b0:123:35a4:e8be with SMTP id a92af1059eb24-12741b6dae9mr681320c88.13.1771043305340; Fri, 13 Feb 2026 20:28:25 -0800 (PST) Received: from apollo.purestorage.com ([208.88.152.253]) by smtp.googlemail.com with ESMTPSA id a92af1059eb24-12742cbc900sm1021042c88.14.2026.02.13.20.28.24 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Feb 2026 20:28:25 -0800 (PST) From: Mohamed Khalfella To: Justin Tee , Naresh Gottumukkala , Paul Ely , Chaitanya Kulkarni , Christoph Hellwig , Jens Axboe , Keith Busch , Sagi Grimberg , James Smart , Hannes Reinecke Cc: Aaron Dailey , Randy Jennings , Dhaval Giani , linux-nvme@lists.infradead.org, linux-kernel@vger.kernel.org, Mohamed Khalfella Subject: [PATCH v3 05/21] nvmet: Send an AEN on CCR completion Date: Fri, 13 Feb 2026 20:25:06 -0800 Message-ID: <20260214042753.4073668-6-mkhalfella@purestorage.com> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260214042753.4073668-1-mkhalfella@purestorage.com> References: <20260214042753.4073668-1-mkhalfella@purestorage.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Send an AEN to initiator when impacted controller exists. The notification points to CCR log page that initiator can read to check which CCR operation completed. Signed-off-by: Mohamed Khalfella Reviewed-by: Hannes Reinecke Reviewed-by: Sagi Grimberg --- drivers/nvme/target/core.c | 25 ++++++++++++++++++++++--- drivers/nvme/target/nvmet.h | 3 ++- include/linux/nvme.h | 3 +++ 3 files changed, 27 insertions(+), 4 deletions(-) diff --git a/drivers/nvme/target/core.c b/drivers/nvme/target/core.c index 38f71e1a1b8e..a9f8a2242703 100644 --- a/drivers/nvme/target/core.c +++ b/drivers/nvme/target/core.c @@ -203,7 +203,7 @@ static void nvmet_async_event_work(struct work_struct *= work) nvmet_async_events_process(ctrl); } =20 -void nvmet_add_async_event(struct nvmet_ctrl *ctrl, u8 event_type, +static void nvmet_add_async_event_locked(struct nvmet_ctrl *ctrl, u8 event= _type, u8 event_info, u8 log_page) { struct nvmet_async_event *aen; @@ -216,13 +216,19 @@ void nvmet_add_async_event(struct nvmet_ctrl *ctrl, u= 8 event_type, aen->event_info =3D event_info; aen->log_page =3D log_page; =20 - mutex_lock(&ctrl->lock); list_add_tail(&aen->entry, &ctrl->async_events); - mutex_unlock(&ctrl->lock); =20 queue_work(nvmet_wq, &ctrl->async_event_work); } =20 +void nvmet_add_async_event(struct nvmet_ctrl *ctrl, u8 event_type, + u8 event_info, u8 log_page) +{ + mutex_lock(&ctrl->lock); + nvmet_add_async_event_locked(ctrl, event_type, event_info, log_page); + mutex_unlock(&ctrl->lock); +} + static void nvmet_add_to_changed_ns_log(struct nvmet_ctrl *ctrl, __le32 ns= id) { u32 i; @@ -1785,6 +1791,18 @@ struct nvmet_ctrl *nvmet_alloc_ctrl(struct nvmet_all= oc_ctrl_args *args) } EXPORT_SYMBOL_GPL(nvmet_alloc_ctrl); =20 +static void nvmet_ctrl_notify_ccr(struct nvmet_ctrl *ctrl) +{ + lockdep_assert_held(&ctrl->lock); + + if (nvmet_aen_bit_disabled(ctrl, NVME_AEN_BIT_CCR_COMPLETE)) + return; + + nvmet_add_async_event_locked(ctrl, NVME_AER_NOTICE, + NVME_AER_NOTICE_CCR_COMPLETED, + NVME_LOG_CCR); +} + static void nvmet_ctrl_complete_pending_ccr(struct nvmet_ctrl *ctrl) { struct nvmet_subsys *subsys =3D ctrl->subsys; @@ -1808,6 +1826,7 @@ static void nvmet_ctrl_complete_pending_ccr(struct nv= met_ctrl *ctrl) list_for_each_entry(ccr, &sctrl->ccr_list, entry) { if (ccr->ctrl =3D=3D ctrl) { ccr->ctrl =3D NULL; + nvmet_ctrl_notify_ccr(sctrl); break; } } diff --git a/drivers/nvme/target/nvmet.h b/drivers/nvme/target/nvmet.h index b06d905c08c8..0ed41a3d0562 100644 --- a/drivers/nvme/target/nvmet.h +++ b/drivers/nvme/target/nvmet.h @@ -44,7 +44,8 @@ * Supported optional AENs: */ #define NVMET_AEN_CFG_OPTIONAL \ - (NVME_AEN_CFG_NS_ATTR | NVME_AEN_CFG_ANA_CHANGE) + (NVME_AEN_CFG_NS_ATTR | NVME_AEN_CFG_ANA_CHANGE | \ + NVME_AEN_CFG_CCR_COMPLETE) #define NVMET_DISC_AEN_CFG_OPTIONAL \ (NVME_AEN_CFG_DISC_CHANGE) =20 diff --git a/include/linux/nvme.h b/include/linux/nvme.h index 9b6d93270c59..fc33ae48d149 100644 --- a/include/linux/nvme.h +++ b/include/linux/nvme.h @@ -860,12 +860,14 @@ enum { NVME_AER_NOTICE_FW_ACT_STARTING =3D 0x01, NVME_AER_NOTICE_ANA =3D 0x03, NVME_AER_NOTICE_DISC_CHANGED =3D 0xf0, + NVME_AER_NOTICE_CCR_COMPLETED =3D 0xf4, }; =20 enum { NVME_AEN_BIT_NS_ATTR =3D 8, NVME_AEN_BIT_FW_ACT =3D 9, NVME_AEN_BIT_ANA_CHANGE =3D 11, + NVME_AEN_BIT_CCR_COMPLETE =3D 20, NVME_AEN_BIT_DISC_CHANGE =3D 31, }; =20 @@ -873,6 +875,7 @@ enum { NVME_AEN_CFG_NS_ATTR =3D 1 << NVME_AEN_BIT_NS_ATTR, NVME_AEN_CFG_FW_ACT =3D 1 << NVME_AEN_BIT_FW_ACT, NVME_AEN_CFG_ANA_CHANGE =3D 1 << NVME_AEN_BIT_ANA_CHANGE, + NVME_AEN_CFG_CCR_COMPLETE =3D 1 << NVME_AEN_BIT_CCR_COMPLETE, NVME_AEN_CFG_DISC_CHANGE =3D 1 << NVME_AEN_BIT_DISC_CHANGE, }; =20 --=20 2.52.0 From nobody Thu Apr 2 22:28:59 2026 Received: from mail-dl1-f48.google.com (mail-dl1-f48.google.com [74.125.82.48]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 2709D2C0F90 for ; Sat, 14 Feb 2026 04:28:27 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.48 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043308; cv=none; b=WwxemmKEcpbEoIjmwq13VnKQf9r1rk1iz+Yuip+8eEdkhRCxKu5pA4C2I+OldeiZJDenZGXL3qGXIKR7j9J2DNch+TqUOIGeZ9QqJC6hWxvHvfhlRCWfCNyymOU/qiAS1OnFnPhqRarrg+miaMBsJLRn2koCjJXOfoeZYI4xt9Q= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043308; c=relaxed/simple; bh=ryAJ1ZfPON5N0IrpW2ypYxaKArmIUB3NhbS8yQxKbhQ=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=g99YraIs+8nXAA6UYJfrLxUqcxV5S7wPxjqfrG9LG/kMzHop0uZqlTUU3PnknBXHb9ve4476INYVClK/R5yXu5uvTZyFhec7uKcZnPh9BGlMmxP4nl+G9NBXWGyKIjjWfEjB3YcCDrfhC0BETVxru0yKZDE4jwqhXUf8Sf9sSoQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com; spf=fail smtp.mailfrom=purestorage.com; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b=TYsE99Mi; arc=none smtp.client-ip=74.125.82.48 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=purestorage.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b="TYsE99Mi" Received: by mail-dl1-f48.google.com with SMTP id a92af1059eb24-12732165d1eso1959170c88.1 for ; Fri, 13 Feb 2026 20:28:27 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=purestorage.com; s=google2022; t=1771043306; x=1771648106; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=Pvgw2VSXgLVN+GlRTxvdu7bkd3BlZLv7u6upmku6CGw=; b=TYsE99MiO66qy1F321EmRh2pAxgbkX5go7RvxW5V+KfK7ggF1w1OuH08ZdIobZVy3o LgFdknOsUCp39f43FCJDdDYlPXvyDhMWh3G7yeYopRj0bNEtqQMP4NxK4S4TZDIqqG6i PUzwjuy2bagihIWmsa7Ul0cjd1m7qeJGUltva9zLmZh4LFRl74pHEzQSZYQeTOdo/NtB qyw1rXGSkZwgbyGizLhP3zky+N6bgQMF6Vbz0exZniooKLfVtrfnWI/Zc1b/LjRcB1/9 BYqmC/8QIlHIBKuAMnOU9/dtyuYOW9BcBpdjlHYnIMCXfixmNInMDRALJi97ud6o00/1 w1+g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1771043306; x=1771648106; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=Pvgw2VSXgLVN+GlRTxvdu7bkd3BlZLv7u6upmku6CGw=; b=CcdHECx3Xgecwvj/8SXcSkIzAQORc1GC9GkklIgSB2qau4iWv+4QjvEJo++RBOJLNO IXedDnOSVqmXbeB/1FH3OWU0sLfGttHxWEkW3HFHVEHExhYp50pXeN9GQuBO6yjDS9Ra rFvxFOsb8Yha8mye79HEP4FEUXekJV13tg3YrVpoGg1cs1Z42KmyRFN1ZZyASi8U/RHF f0Lab0ebE31xN9tnOa8qRqqRY+M1PSprwvGF4zcWTcvVvm2f9etY8c27U07rd6YY05v+ AvmpmHpSyE4h8xFx3nj8jTYQL7Z7k++CpQASdoYFn09PEhC8bGardeFEsB5Zh1oRlRnw o2Gg== X-Forwarded-Encrypted: i=1; AJvYcCXlkOcqP3zG74eZ84cS1gCQD5oMtn6ZAUClFwDe8iCj9qE3SvkH1GSeE09PRA+kDdZGf4Xq4zuvWsOxDAI=@vger.kernel.org X-Gm-Message-State: AOJu0YzFVq3ybCQTEw7n7pAsLwIXXogOlEnH2QaNiiiieDjWEpVB+YO8 A83O42+Kx6MgLxPGMgEvYKzEw+YvxR33ur2W9xPjxIeVR1wR/r83PtY+0IoO3/tlx8k= X-Gm-Gg: AZuq6aKY9xNjLJHmmZHDkyyGs1sEeh6nxsnXq2y5TC5liR7Q/u/KJVsnL3XPsdOLNmQ X0rsSSiisJNgUWBwiDsUPfC/c8Gn45uu4KMydmq9bPAgb6BQKEgkTioxWyMESNw6gCxJtvNug1T IJusWP++wMopXJjF718dbCB58sA1AsNw+0ObAm4I0Rsw4F5FfDWlbq8ueCXsyIpBKR5k2wYEYyC ngLSbqCWNL63NyZ5w7Hq399kM7nCxaJz9ZvG91jXnMeapkPGiT4DX6XFlDFvRvYVUbcxxwVHfKf 4q3cow2MKmIq2eNzO0UulIOx2x4WbSdWLmp9DzaT0t+NVjcFWujLqce87JrlEggOazkuAW9hcX6 2cWIkNPohuh6FC5o7dFQNGpeD5h1qobAoGwu3kNHq3qg2xqS9mA3s+UY0S3UMVTWWfCCYQA/G60 iZkJNI4IlU4PV1Ol6WRFIySsoPj08W79cEBnl6vQ7ghN/LiA== X-Received: by 2002:a05:7022:fa2:b0:119:e56b:98a0 with SMTP id a92af1059eb24-1273adf0427mr1591730c88.7.1771043306128; Fri, 13 Feb 2026 20:28:26 -0800 (PST) Received: from apollo.purestorage.com ([208.88.152.253]) by smtp.googlemail.com with ESMTPSA id a92af1059eb24-12742cbc900sm1021042c88.14.2026.02.13.20.28.25 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Feb 2026 20:28:25 -0800 (PST) From: Mohamed Khalfella To: Justin Tee , Naresh Gottumukkala , Paul Ely , Chaitanya Kulkarni , Christoph Hellwig , Jens Axboe , Keith Busch , Sagi Grimberg , James Smart , Hannes Reinecke Cc: Aaron Dailey , Randy Jennings , Dhaval Giani , linux-nvme@lists.infradead.org, linux-kernel@vger.kernel.org, Mohamed Khalfella Subject: [PATCH v3 06/21] nvme: Rapid Path Failure Recovery read controller identify fields Date: Fri, 13 Feb 2026 20:25:07 -0800 Message-ID: <20260214042753.4073668-7-mkhalfella@purestorage.com> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260214042753.4073668-1-mkhalfella@purestorage.com> References: <20260214042753.4073668-1-mkhalfella@purestorage.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" TP8028 Rapid path failure added new fileds to controller identify response. Read CIU (Controller Instance Uniquifier), CIRN (Controller Instance Random Number), and CCRL (Cross-Controller Reset Limit) from controller identify response. Expose CIU and CIRN as sysfs attributes so the values can be used directrly by user if needed. Signed-off-by: Mohamed Khalfella Reviewed-by: Hannes Reinecke --- drivers/nvme/host/core.c | 4 ++++ drivers/nvme/host/nvme.h | 10 ++++++++++ drivers/nvme/host/sysfs.c | 23 +++++++++++++++++++++++ 3 files changed, 37 insertions(+) diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c index 19b67cf5d550..8d26e27992fc 100644 --- a/drivers/nvme/host/core.c +++ b/drivers/nvme/host/core.c @@ -3572,6 +3572,10 @@ static int nvme_init_identify(struct nvme_ctrl *ctrl) ctrl->crdt[1] =3D le16_to_cpu(id->crdt2); ctrl->crdt[2] =3D le16_to_cpu(id->crdt3); =20 + ctrl->ciu =3D id->ciu; + ctrl->cirn =3D le64_to_cpu(id->cirn); + atomic_set(&ctrl->ccr_limit, id->ccrl); + ctrl->oacs =3D le16_to_cpu(id->oacs); ctrl->oncs =3D le16_to_cpu(id->oncs); ctrl->mtfa =3D le16_to_cpu(id->mtfa); diff --git a/drivers/nvme/host/nvme.h b/drivers/nvme/host/nvme.h index 9a5f28c5103c..6984950b9aa8 100644 --- a/drivers/nvme/host/nvme.h +++ b/drivers/nvme/host/nvme.h @@ -328,11 +328,14 @@ struct nvme_ctrl { u16 crdt[3]; u16 oncs; u8 dmrl; + u8 ciu; u32 dmrsl; + u64 cirn; u16 oacs; u16 sqsize; u32 max_namespaces; atomic_t abort_limit; + atomic_t ccr_limit; u8 vwc; u32 vs; u32 sgls; @@ -1225,4 +1228,11 @@ static inline bool nvme_multi_css(struct nvme_ctrl *= ctrl) return (ctrl->ctrl_config & NVME_CC_CSS_MASK) =3D=3D NVME_CC_CSS_CSI; } =20 +static inline unsigned long nvme_fence_timeout_ms(struct nvme_ctrl *ctrl) +{ + if (ctrl->ctratt & NVME_CTRL_ATTR_TBKAS) + return 3 * ctrl->kato * 1000; + return 2 * ctrl->kato * 1000; +} + #endif /* _NVME_H */ diff --git a/drivers/nvme/host/sysfs.c b/drivers/nvme/host/sysfs.c index 29430949ce2f..cd835dd2377f 100644 --- a/drivers/nvme/host/sysfs.c +++ b/drivers/nvme/host/sysfs.c @@ -388,6 +388,27 @@ nvme_show_int_function(queue_count); nvme_show_int_function(sqsize); nvme_show_int_function(kato); =20 +static ssize_t nvme_sysfs_ciu_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct nvme_ctrl *ctrl =3D dev_get_drvdata(dev); + + return sysfs_emit(buf, "%02x\n", ctrl->ciu); +} +static DEVICE_ATTR(ciu, S_IRUSR, nvme_sysfs_ciu_show, NULL); + +static ssize_t nvme_sysfs_cirn_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct nvme_ctrl *ctrl =3D dev_get_drvdata(dev); + + return sysfs_emit(buf, "%016llx\n", ctrl->cirn); +} +static DEVICE_ATTR(cirn, S_IRUSR, nvme_sysfs_cirn_show, NULL); + + static ssize_t nvme_sysfs_delete(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) @@ -734,6 +755,8 @@ static struct attribute *nvme_dev_attrs[] =3D { &dev_attr_numa_node.attr, &dev_attr_queue_count.attr, &dev_attr_sqsize.attr, + &dev_attr_ciu.attr, + &dev_attr_cirn.attr, &dev_attr_hostnqn.attr, &dev_attr_hostid.attr, &dev_attr_ctrl_loss_tmo.attr, --=20 2.52.0 From nobody Thu Apr 2 22:28:59 2026 Received: from mail-dl1-f52.google.com (mail-dl1-f52.google.com [74.125.82.52]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 0A1672BDC2F for ; Sat, 14 Feb 2026 04:28:27 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.52 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043311; cv=none; b=heNncDSC4XKObZcO0ImrhTJVq6oqbPNuzJAz93C2ysRR7gosY/lzPmYyM3ccdZUSXhdOFuKxIdlh2eHhzOKR5eGkfmdgCP6yhunTdvE8JIxkEUzs9LSaz+8pTHnPAcr6Sk6nJUHiBeHVnLJlSUfaUQD4e0kfKqb5A2Ha2qkFqmI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043311; c=relaxed/simple; bh=rY8VtL20RrRuTrGx+BCj5qNQJT9lFX1N+Lnq70gdVZk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=hJa9yCGPbqrajNlGETSwUPs4KVMg+QHPdJsck5AT4WWZQbeJkc6f5lZRnTOxTHcBfjshQNoTm46MMY2I86o8U7iY+53oMtRwz8YKqHjccAjkHUes2BT0Bc4CFHQ5yUOvoCUucMXWBbPCtDGZwHMd3Uhx8qUoO+4eTX7i+aKxJts= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com; spf=fail smtp.mailfrom=purestorage.com; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b=cwBcEu3x; arc=none smtp.client-ip=74.125.82.52 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=purestorage.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b="cwBcEu3x" Received: by mail-dl1-f52.google.com with SMTP id a92af1059eb24-1248d27f2b9so2229472c88.0 for ; Fri, 13 Feb 2026 20:28:27 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=purestorage.com; s=google2022; t=1771043307; x=1771648107; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=+YYScjSesE0x8k06HUvqt/BkKPH2VBLshBgb+fspSKA=; b=cwBcEu3xPSPRbClzQOqckpDgNrbqQfhutjCtQ/zcBSJ7oZ94iEpSwnDs8QCUS+HU9I go5AqugEzeK5Twa4VUolWRnJba00Q/1LTG4PDaLoQwrMRXqpSKQasyNL4qTZOVu/0Kg/ dHOvaTmkTy3SoXOZweVU8uSxFbamIhp1nA9jyNt/OEQfz02nqnASkCCAGZ1SvMzlXeT5 UaUkYELxGXPNvlaUUw9XFAGVdtahdjI/okVmvYediCdxrkU0G1w3Xeqr/SEqltyQqEd4 Ko5IQaAsMGnst3GRfJNHUlzL7Bz88WLsA1numEj82qH7YvZ8ZYWzzX1SEri37nb2AL9n 6P+w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1771043307; x=1771648107; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=+YYScjSesE0x8k06HUvqt/BkKPH2VBLshBgb+fspSKA=; b=JMISXdBj0X/vtwQpXvTjtmoWT/XNBKY7EX+azicz5LVNwC9NQGbw6YgLVXpAaYMpvo awlpKfY5tTQ+/s+J9mG/lQzAq+Sp2qVgeHOUEJgeJEVrD8ck31lkO4zM60u3anmYKJa5 A7gRYSGtQ36o+of9QSfYkUGVK1jaU4E4uyREQ5Oefeva7zAj+Od98jtlQ13hBt9r7bg0 KViA/9GAnscJ7KPbYSi3LA1fd1jcaEMH2f1dE2e+198rafWxI4XyYJwehhRVBXkh6LzL CZkn2h+8HrE5mpGrWDRPmzP2stHIpLL3Ekkwtq2t82QiCTNbrvwfzvxLzJPIyD80BJMz fSAg== X-Forwarded-Encrypted: i=1; AJvYcCUsEF/yq4+ScKpgUMiN8Jzxv0qMoEzl/VfZsnOkZ9pNUlt5fb1XifMIUTYD2vx6Y/rIYc0alJdopl+FXns=@vger.kernel.org X-Gm-Message-State: AOJu0YxcFMpoOlqMmzEoBMGPsiB2v1l70x9GKRxIY6qRLtzPk7kt5fTY R5Y0sxpfsxYAMSoSXsDWkHG63bXOihX7zwjOYeiF/wZxlbW8Hi5NwViBb/0bZs8Vpn4= X-Gm-Gg: AZuq6aKf1zezHpIQNq545ubaShmGkKB2T2f2clKf/F7wKSBn/7Ak1z/i4xZ0qjcxSZt mhDYHUOPI1sqMJVFH8MGmXtPioVLAM7HZ4ae/b+mpjuTFW50uHrVlF06GBDKLEpbUPNTJtm7xNm T4rLONdULqVUkZ0WM4s1eJ+MwG7+fVHSWDXNUFf63QT5jily9Nd2YvGZ/gmTd2WWiC8QRuVlaHV xnmRpTIU3hJgzdUY5afGSuPLqwElhZ5J4UJbvDg+zzYEDjgYRQmVtbnAzkOblzCt1Fl0ldNnLUG m5AFPPhjLECh2ZWSSf0PJ835BNQm39WdttzYPM+fCYCV2dXNN2vgufntRAklAKHhrdgBMX6Jfzv UN6dqKucLmKg50EjlEP8uRNqMniursdx/flZF3BIQA6yDTZf7mH+hGeiA7J5Jyit+Da3BkMHaB2 XQLeL/DVsn5m2xbJNcP8cLGpeMC4hYEzpD//ImYUefLmHN1g== X-Received: by 2002:a05:7022:4596:b0:124:65f7:2c2e with SMTP id a92af1059eb24-127398443b8mr1428287c88.43.1771043306958; Fri, 13 Feb 2026 20:28:26 -0800 (PST) Received: from apollo.purestorage.com ([208.88.152.253]) by smtp.googlemail.com with ESMTPSA id a92af1059eb24-12742cbc900sm1021042c88.14.2026.02.13.20.28.26 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Feb 2026 20:28:26 -0800 (PST) From: Mohamed Khalfella To: Justin Tee , Naresh Gottumukkala , Paul Ely , Chaitanya Kulkarni , Christoph Hellwig , Jens Axboe , Keith Busch , Sagi Grimberg , James Smart , Hannes Reinecke Cc: Aaron Dailey , Randy Jennings , Dhaval Giani , linux-nvme@lists.infradead.org, linux-kernel@vger.kernel.org, Mohamed Khalfella Subject: [PATCH v3 07/21] nvme: Introduce FENCING and FENCED controller states Date: Fri, 13 Feb 2026 20:25:08 -0800 Message-ID: <20260214042753.4073668-8-mkhalfella@purestorage.com> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260214042753.4073668-1-mkhalfella@purestorage.com> References: <20260214042753.4073668-1-mkhalfella@purestorage.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" FENCING is a new controller state that a LIVE controller enter when an error is encountered. While in FENCING state,inflight IOs that timeout are not canceled because they should be held until either CCR succeeds or time-based recovery completes. While the queues remain alive requests are not allowed to be sent in this state and the controller cannot be reset or deleted. This is intentional because resetting or deleting the controller results in canceling inflight IOs. FENCED is a short-term state the controller enters before it is reset. It exists only to prevent manual resets from happening while controller is in FENCING state. Signed-off-by: Mohamed Khalfella Reviewed-by: Hannes Reinecke --- drivers/nvme/host/core.c | 27 +++++++++++++++++++++++++-- drivers/nvme/host/nvme.h | 4 ++++ drivers/nvme/host/sysfs.c | 2 ++ 3 files changed, 31 insertions(+), 2 deletions(-) diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c index 8d26e27992fc..231d402e9bfb 100644 --- a/drivers/nvme/host/core.c +++ b/drivers/nvme/host/core.c @@ -574,10 +574,29 @@ bool nvme_change_ctrl_state(struct nvme_ctrl *ctrl, break; } break; + case NVME_CTRL_FENCING: + switch (old_state) { + case NVME_CTRL_LIVE: + changed =3D true; + fallthrough; + default: + break; + } + break; + case NVME_CTRL_FENCED: + switch (old_state) { + case NVME_CTRL_FENCING: + changed =3D true; + fallthrough; + default: + break; + } + break; case NVME_CTRL_RESETTING: switch (old_state) { case NVME_CTRL_NEW: case NVME_CTRL_LIVE: + case NVME_CTRL_FENCED: changed =3D true; fallthrough; default: @@ -760,6 +779,8 @@ blk_status_t nvme_fail_nonready_command(struct nvme_ctr= l *ctrl, =20 if (state !=3D NVME_CTRL_DELETING_NOIO && state !=3D NVME_CTRL_DELETING && + state !=3D NVME_CTRL_FENCING && + state !=3D NVME_CTRL_FENCED && state !=3D NVME_CTRL_DEAD && !test_bit(NVME_CTRL_FAILFAST_EXPIRED, &ctrl->flags) && !blk_noretry_request(rq) && !(rq->cmd_flags & REQ_NVME_MPATH)) @@ -802,10 +823,12 @@ bool __nvme_check_ready(struct nvme_ctrl *ctrl, struc= t request *rq, req->cmd->fabrics.fctype =3D=3D nvme_fabrics_type_auth_receive)) return true; break; - default: - break; + case NVME_CTRL_FENCING: + case NVME_CTRL_FENCED: case NVME_CTRL_DEAD: return false; + default: + break; } } =20 diff --git a/drivers/nvme/host/nvme.h b/drivers/nvme/host/nvme.h index 6984950b9aa8..b1c37eb3379e 100644 --- a/drivers/nvme/host/nvme.h +++ b/drivers/nvme/host/nvme.h @@ -251,6 +251,8 @@ static inline u16 nvme_req_qid(struct request *req) enum nvme_ctrl_state { NVME_CTRL_NEW, NVME_CTRL_LIVE, + NVME_CTRL_FENCING, + NVME_CTRL_FENCED, NVME_CTRL_RESETTING, NVME_CTRL_CONNECTING, NVME_CTRL_DELETING, @@ -776,6 +778,8 @@ static inline bool nvme_state_terminal(struct nvme_ctrl= *ctrl) switch (nvme_ctrl_state(ctrl)) { case NVME_CTRL_NEW: case NVME_CTRL_LIVE: + case NVME_CTRL_FENCING: + case NVME_CTRL_FENCED: case NVME_CTRL_RESETTING: case NVME_CTRL_CONNECTING: return false; diff --git a/drivers/nvme/host/sysfs.c b/drivers/nvme/host/sysfs.c index cd835dd2377f..1e4261144933 100644 --- a/drivers/nvme/host/sysfs.c +++ b/drivers/nvme/host/sysfs.c @@ -443,6 +443,8 @@ static ssize_t nvme_sysfs_show_state(struct device *dev, static const char *const state_name[] =3D { [NVME_CTRL_NEW] =3D "new", [NVME_CTRL_LIVE] =3D "live", + [NVME_CTRL_FENCING] =3D "fencing", + [NVME_CTRL_FENCED] =3D "fenced", [NVME_CTRL_RESETTING] =3D "resetting", [NVME_CTRL_CONNECTING] =3D "connecting", [NVME_CTRL_DELETING] =3D "deleting", --=20 2.52.0 From nobody Thu Apr 2 22:28:59 2026 Received: from mail-dl1-f44.google.com (mail-dl1-f44.google.com [74.125.82.44]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id CF32E2C2349 for ; Sat, 14 Feb 2026 04:28:28 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.44 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043315; cv=none; b=UZBCUW3KP1VByc5br8VQsnaOhhHpIPlaq+5svGI/JyLrMb7O/CK/JlHU9m+BhiCv+yDjMG/aINpfaC19Y40V05wZEt9ug6K6wlMpaQmrPl4XHadT4k5D8mXW/+d/qb8t01YY7okW+JatM1ldfmTpXHuwK6tyiR+LXjLa0QPmfJw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043315; c=relaxed/simple; bh=gvbdYeCJZGAGcP7vbCYXSkR0RaKRHDdbTKKsQjbEvuA=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=j2INS6n3fJkx0x6J46JmI7bs67hYo+3sB44b681B/JRIfVzRjEFtfVr+H4n/PbzrlyT7GbqSQgOEAAUFMqUukRlgKUXCSvHm1YbvnxdjbKsJWKQCuNfIG3yGa7GhES1HUF/F3Sk9PUPLlcUnpsamyj0Uj2mm4fRZDndEC0vZiX8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com; spf=fail smtp.mailfrom=purestorage.com; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b=LciNHkVQ; arc=none smtp.client-ip=74.125.82.44 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=purestorage.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b="LciNHkVQ" Received: by mail-dl1-f44.google.com with SMTP id a92af1059eb24-1273349c56bso2148201c88.0 for ; Fri, 13 Feb 2026 20:28:28 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=purestorage.com; s=google2022; t=1771043308; x=1771648108; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=zCK7MkIJ9W8S4oRts15YT/FeKYBXhBdPnkffI4uC3PQ=; b=LciNHkVQY2golepIOWccsjaSy2CFun6Nntnr9x6WCszhJBRlKh3yaEKnUodYfxAZ14 +X1SQhWGoKPXp9/OJjqmJ2YuON7t3SoHGlJTbC8SbCMuY8pHEsHslVt9uj4N4TWUTnRY GC0bM23M9/8MmAMReZB/cq3swaIIu4U2puvlJ8k9iX7zgJ0Ms7Nsvw6TZ4/e+bhcCPCT vd9+xIs8AaDIOVmwS14ToeBuBKNBp9PQUEzPull7FuryW7tZHnOt2mdqsue61uL8r4IS +8hbG4Pus3ZQY4rmNguxgY5sQ28QgOz5XfnbiPWlOVUJWmGEwUb7hxUTGGiEnLlsFGOp Yhrw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1771043308; x=1771648108; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=zCK7MkIJ9W8S4oRts15YT/FeKYBXhBdPnkffI4uC3PQ=; b=KAwMvyW/VLgSgrm+npTnN3ivARRkN5loyUnr9+6tgmtzQHMch37nGQwiOQRumRGL3w RB8RQnvrIBRBRRdgeTKC5NSU/55wSK8F+zaO/8gy9lqS1Fd/XGUZturV7tTjB//2jN5i 9Ee+rIjE/dS6WlGCXay7ZOAa/mpeA0sF1DKyeTU1ZzRQK3WGPt2kTOlRqJVykpXhQiX1 oQgRBUA0K6nbjZ8ymfoM9LE4nl7TfmQ5zQo0mIscLXsXhVixLu4Mruul+NsQL8tvvpnQ KFhxTeCnpGv7lDzkczCurwxH86EPMz/hPutB2Lw1kSoSSi6/VYpfgxATx5gUrVTAMWP6 hZcA== X-Forwarded-Encrypted: i=1; AJvYcCWzvXnNlHQ3aylM2YtGx1OfJdHIWTtrZ15GDkr0k4uJfXQdvDw3Nb+dfWvrQMLkwtbU6JqZS+jZjhu2Syg=@vger.kernel.org X-Gm-Message-State: AOJu0Ywz4HToBHNuW84zVbf07YR8Y0PBavx5cI9ZXGthi8pVlhwaDKFf FsUlp0AtkVzcX6PCPrVto+HP53OcziX32LChyb5Y5HVKn/EJYaKSBKZMngC/Su59IY0= X-Gm-Gg: AZuq6aKJZ/DSz2HqRlVEiAigi86nubocQyBJ7m9dKXG/B1OpzqWDDStpta7BmOeX3Xa iC0V1L09y6MDu7p8sbrVNQIq35IJKuP036I42KDSMeO/K59RW7gBBL7r4UMmwvNyUd/6G554SD5 ei+GEQ27Q01T17VWcAZj0YScrhugAWBI7g0N+EYGIYIcwQv8felHg+H522g1WaDJ3Cay4RrwdVB z+We47Qo7tQOOiK+xjSkzXQBn92BG1PGD/2600YKDKgEvUUDce7cPqFwRaAx8zheMF5pDYltlyg wClPRrHBwWwEp9ApjPfqnIbZntXTs/NYhv+SJ4sp2Ekh4yU1Ne1ReuaFSZzzzAReKFp8sv+hWTL Mbqf4DGNK3pFR1Lu2Sau7ucqDqxXhf+mwY8yFzot/UcoEInb6hggxPJpVM6hoML7osSVItu8MJu hZLkirZC0oW6PiYY2v74sXRqM8WX3uTWUaF5CRXVA3Fs6ltsnDGQNLbiOM X-Received: by 2002:a05:7022:6ba9:b0:127:3863:6440 with SMTP id a92af1059eb24-12741c02ba9mr605463c88.47.1771043307739; Fri, 13 Feb 2026 20:28:27 -0800 (PST) Received: from apollo.purestorage.com ([208.88.152.253]) by smtp.googlemail.com with ESMTPSA id a92af1059eb24-12742cbc900sm1021042c88.14.2026.02.13.20.28.27 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Feb 2026 20:28:27 -0800 (PST) From: Mohamed Khalfella To: Justin Tee , Naresh Gottumukkala , Paul Ely , Chaitanya Kulkarni , Christoph Hellwig , Jens Axboe , Keith Busch , Sagi Grimberg , James Smart , Hannes Reinecke Cc: Aaron Dailey , Randy Jennings , Dhaval Giani , linux-nvme@lists.infradead.org, linux-kernel@vger.kernel.org, Mohamed Khalfella Subject: [PATCH v3 08/21] nvme: Implement cross-controller reset recovery Date: Fri, 13 Feb 2026 20:25:09 -0800 Message-ID: <20260214042753.4073668-9-mkhalfella@purestorage.com> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260214042753.4073668-1-mkhalfella@purestorage.com> References: <20260214042753.4073668-1-mkhalfella@purestorage.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" A host that has more than one path connecting to an nvme subsystem typically has an nvme controller associated with every path. This is mostly applicable to nvmeof. If one path goes down, inflight IOs on that path should not be retried immediately on another path because this could lead to data corruption as described in TP4129. TP8028 defines cross-controller reset mechanism that can be used by host to terminate IOs on the failed path using one of the remaining healthy paths. Only after IOs are terminated, or long enough time passes as defined by TP4129, inflight IOs should be retried on another path. Implement core cross-controller reset shared logic to be used by the transports. Signed-off-by: Mohamed Khalfella --- drivers/nvme/host/constants.c | 1 + drivers/nvme/host/core.c | 141 ++++++++++++++++++++++++++++++++++ drivers/nvme/host/nvme.h | 9 +++ 3 files changed, 151 insertions(+) diff --git a/drivers/nvme/host/constants.c b/drivers/nvme/host/constants.c index dc90df9e13a2..f679efd5110e 100644 --- a/drivers/nvme/host/constants.c +++ b/drivers/nvme/host/constants.c @@ -46,6 +46,7 @@ static const char * const nvme_admin_ops[] =3D { [nvme_admin_virtual_mgmt] =3D "Virtual Management", [nvme_admin_nvme_mi_send] =3D "NVMe Send MI", [nvme_admin_nvme_mi_recv] =3D "NVMe Receive MI", + [nvme_admin_cross_ctrl_reset] =3D "Cross Controller Reset", [nvme_admin_dbbuf] =3D "Doorbell Buffer Config", [nvme_admin_format_nvm] =3D "Format NVM", [nvme_admin_security_send] =3D "Security Send", diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c index 231d402e9bfb..765b1524b3ed 100644 --- a/drivers/nvme/host/core.c +++ b/drivers/nvme/host/core.c @@ -554,6 +554,146 @@ void nvme_cancel_admin_tagset(struct nvme_ctrl *ctrl) } EXPORT_SYMBOL_GPL(nvme_cancel_admin_tagset); =20 +static struct nvme_ctrl *nvme_find_ctrl_ccr(struct nvme_ctrl *ictrl, + u32 min_cntlid) +{ + struct nvme_subsystem *subsys =3D ictrl->subsys; + struct nvme_ctrl *ctrl, *sctrl =3D NULL; + unsigned long flags; + + mutex_lock(&nvme_subsystems_lock); + list_for_each_entry(ctrl, &subsys->ctrls, subsys_entry) { + if (ctrl->cntlid < min_cntlid) + continue; + + if (atomic_dec_if_positive(&ctrl->ccr_limit) < 0) + continue; + + spin_lock_irqsave(&ctrl->lock, flags); + if (ctrl->state !=3D NVME_CTRL_LIVE) { + spin_unlock_irqrestore(&ctrl->lock, flags); + atomic_inc(&ctrl->ccr_limit); + continue; + } + + /* + * We got a good candidate source controller that is locked and + * LIVE. However, no guarantee ctrl will not be deleted after + * ctrl->lock is released. Get a ref of both ctrl and admin_q + * so they do not disappear until we are done with them. + */ + WARN_ON_ONCE(!blk_get_queue(ctrl->admin_q)); + nvme_get_ctrl(ctrl); + spin_unlock_irqrestore(&ctrl->lock, flags); + sctrl =3D ctrl; + break; + } + mutex_unlock(&nvme_subsystems_lock); + return sctrl; +} + +static void nvme_put_ctrl_ccr(struct nvme_ctrl *sctrl) +{ + atomic_inc(&sctrl->ccr_limit); + blk_put_queue(sctrl->admin_q); + nvme_put_ctrl(sctrl); +} + +static int nvme_issue_wait_ccr(struct nvme_ctrl *sctrl, struct nvme_ctrl *= ictrl) +{ + struct nvme_ccr_entry ccr =3D { }; + union nvme_result res =3D { 0 }; + struct nvme_command c =3D { }; + unsigned long flags, tmo; + bool completed =3D false; + int ret =3D 0; + u32 result; + + init_completion(&ccr.complete); + ccr.ictrl =3D ictrl; + + spin_lock_irqsave(&sctrl->lock, flags); + list_add_tail(&ccr.list, &sctrl->ccr_list); + spin_unlock_irqrestore(&sctrl->lock, flags); + + c.ccr.opcode =3D nvme_admin_cross_ctrl_reset; + c.ccr.ciu =3D ictrl->ciu; + c.ccr.icid =3D cpu_to_le16(ictrl->cntlid); + c.ccr.cirn =3D cpu_to_le64(ictrl->cirn); + ret =3D __nvme_submit_sync_cmd(sctrl->admin_q, &c, &res, + NULL, 0, NVME_QID_ANY, 0); + if (ret) { + ret =3D -EIO; + goto out; + } + + result =3D le32_to_cpu(res.u32); + if (result & 0x01) /* Immediate Reset Successful */ + goto out; + + tmo =3D secs_to_jiffies(ictrl->kato); + if (!wait_for_completion_timeout(&ccr.complete, tmo)) { + ret =3D -ETIMEDOUT; + goto out; + } + + completed =3D true; + +out: + spin_lock_irqsave(&sctrl->lock, flags); + list_del(&ccr.list); + spin_unlock_irqrestore(&sctrl->lock, flags); + if (completed) { + if (ccr.ccrs =3D=3D NVME_CCR_STATUS_SUCCESS) + return 0; + return -EREMOTEIO; + } + return ret; +} + +unsigned long nvme_fence_ctrl(struct nvme_ctrl *ictrl) +{ + unsigned long deadline, now, timeout; + struct nvme_ctrl *sctrl; + u32 min_cntlid =3D 0; + int ret; + + timeout =3D nvme_fence_timeout_ms(ictrl); + dev_info(ictrl->device, "attempting CCR, timeout %lums\n", timeout); + + now =3D jiffies; + deadline =3D now + msecs_to_jiffies(timeout); + while (time_before(now, deadline)) { + sctrl =3D nvme_find_ctrl_ccr(ictrl, min_cntlid); + if (!sctrl) { + /* CCR failed, switch to time-based recovery */ + return deadline - now; + } + + ret =3D nvme_issue_wait_ccr(sctrl, ictrl); + if (!ret) { + dev_info(ictrl->device, "CCR succeeded using %s\n", + dev_name(sctrl->device)); + nvme_put_ctrl_ccr(sctrl); + return 0; + } + + min_cntlid =3D sctrl->cntlid + 1; + nvme_put_ctrl_ccr(sctrl); + now =3D jiffies; + + if (ret =3D=3D -EIO) /* CCR command failed */ + continue; + + /* CCR operation failed or timed out */ + return time_before(now, deadline) ? deadline - now : 0; + } + + dev_info(ictrl->device, "CCR reached timeout, call it done\n"); + return 0; +} +EXPORT_SYMBOL_GPL(nvme_fence_ctrl); + bool nvme_change_ctrl_state(struct nvme_ctrl *ctrl, enum nvme_ctrl_state new_state) { @@ -5121,6 +5261,7 @@ int nvme_init_ctrl(struct nvme_ctrl *ctrl, struct dev= ice *dev, =20 mutex_init(&ctrl->scan_lock); INIT_LIST_HEAD(&ctrl->namespaces); + INIT_LIST_HEAD(&ctrl->ccr_list); xa_init(&ctrl->cels); ctrl->dev =3D dev; ctrl->ops =3D ops; diff --git a/drivers/nvme/host/nvme.h b/drivers/nvme/host/nvme.h index b1c37eb3379e..f3ab9411cac5 100644 --- a/drivers/nvme/host/nvme.h +++ b/drivers/nvme/host/nvme.h @@ -279,6 +279,13 @@ enum nvme_ctrl_flags { NVME_CTRL_FROZEN =3D 6, }; =20 +struct nvme_ccr_entry { + struct list_head list; + struct completion complete; + struct nvme_ctrl *ictrl; + u8 ccrs; +}; + struct nvme_ctrl { bool comp_seen; bool identified; @@ -296,6 +303,7 @@ struct nvme_ctrl { struct blk_mq_tag_set *tagset; struct blk_mq_tag_set *admin_tagset; struct list_head namespaces; + struct list_head ccr_list; struct mutex namespaces_lock; struct srcu_struct srcu; struct device ctrl_device; @@ -813,6 +821,7 @@ blk_status_t nvme_host_path_error(struct request *req); bool nvme_cancel_request(struct request *req, void *data); void nvme_cancel_tagset(struct nvme_ctrl *ctrl); void nvme_cancel_admin_tagset(struct nvme_ctrl *ctrl); +unsigned long nvme_fence_ctrl(struct nvme_ctrl *ctrl); bool nvme_change_ctrl_state(struct nvme_ctrl *ctrl, enum nvme_ctrl_state new_state); int nvme_disable_ctrl(struct nvme_ctrl *ctrl, bool shutdown); --=20 2.52.0 From nobody Thu Apr 2 22:28:59 2026 Received: from mail-dl1-f45.google.com (mail-dl1-f45.google.com [74.125.82.45]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 994542D2486 for ; Sat, 14 Feb 2026 04:28:29 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.45 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043314; cv=none; b=tneYEZl5jKMOBM/12ppV6jppFXcrjpisbwkyrIiRIBwt6eODRpRd+bKO/EiJ7MF6jksnSOIbLWI0Fe+RvsDd65FYtE9TG5nXN9a4P0aLHv0ZVoPkYh8rTZaO6GTw9UWdNIHz6K0KjQ2QpYBjj/FQeufuBpWOtOTkJ6uG7DhSbnc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043314; c=relaxed/simple; bh=hOIRy5DghCbHb3N7TV2jNNldDPImTiDgSxqhK5YSxUk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Eyai0lYU1kn71nQKC7mNN6766jdWOtv0f08Mm68Bj1vffPz+ayb9PF46NxgV8of6TVi0HJ0K9r2gLvDVH7KyDTiuaLaaPD+xozWF3jeGJAG7gSLjGgVP2SGEtCHIIOvGDi68uXYSxvi33Hg+TN5o+OuKSmTsTqhLskgFpd6XfkA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com; spf=fail smtp.mailfrom=purestorage.com; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b=GiCcB3xX; arc=none smtp.client-ip=74.125.82.45 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=purestorage.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b="GiCcB3xX" Received: by mail-dl1-f45.google.com with SMTP id a92af1059eb24-1273349c56bso2148204c88.0 for ; Fri, 13 Feb 2026 20:28:29 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=purestorage.com; s=google2022; t=1771043309; x=1771648109; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=edwDbFdh37sKWpDzCd1wbhpALgQ620l1aL8E/Iy7bHY=; b=GiCcB3xXpKgjavoLedh6rmzLjEFwxO7Q1p8oFv7uTZw9yM5HKlUgljafivCM6wz3pj mSqrHQK7LYvRNEk9LCgk9cjl7BJCzx5Zgca8qRuX4F8sYHSXEFoMVnIJhODGomXWo16z uQ1W+EdIgbH9jg7IyYUqaEGnxuj9/RPQ7PTIpC9RnT8jriwcsZzKCa5ve31Ubgq3iudz 2Dl0SCgs6U4/Ht90W0A7JrY4JaJ8aQUhW6MAYBTmjaImw5YZ3lJEf4xJ95FX9OeFZZ8K ynaSfJIK4c/rweiy8eCdtP2Jdf22j/LK1mcI22VbMzksaIwcuZQoB0l/dBDLe4cmqwyt TjUg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1771043309; x=1771648109; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=edwDbFdh37sKWpDzCd1wbhpALgQ620l1aL8E/Iy7bHY=; b=pdkzUqGa/BV5J4hQJRZn5JsGxpbrKLsYXJZGJeGgk16PzDSiQ8DZO954kJZ8nVJQPL S0Qo+p9GVhabfZ6MJA25neWBITjEif+EC55DksCfyapprT7NMZhRPA8VUKkvQWADAvKF NVMf9E2QWWNlr7ivLC7dCEktkOE81uyRSZd7dfmt/ZIUvblXZV29Zn1UUVj1uw5hH9Xm zfXQIOqKpbcxN0Nr2LjKzgGrFXGaUOdV7bvvs4uHincU86DH6hew8ysH9GUQiymlEAG7 qz+AxDZbcMBHZLKuEBHbG97gWqfNzvQHB0PWxcLJv6VvhBQB8dYBAnqwF9LsNAFmkGuC HUow== X-Forwarded-Encrypted: i=1; AJvYcCWf077gDnngsXrrnX5UVRtte+s0Tc1TVT2i5VVgmDITAepKgNUpWDgDJU11cQDhdDfmm0lu7uE1d1VcutM=@vger.kernel.org X-Gm-Message-State: AOJu0YyvZhjffudUsE1t5mNQ3rY31zOsjChc5h1I5qjWYJRaDchy3UEZ 6CS4YTjM9BKdZ2gB9izNJIPJiTRIdvB39SmfkEBUCZuvSzpjw/APCgKmsLEp8onWdYo= X-Gm-Gg: AZuq6aLFKI7fteMKOLxx0nd4haIUcumBLpfzeYYEDIcHqK5dSzvERatggDkQNhkouHi vI3zPmWtMR7Pep8tINSD462VkhIS0qBYn2s8k7twccoJxhQqHimaHu1Dr+TcxTEq6tp5KF6Reub tGqtMxTWGNKYxz6tF895a1D4iqpd5hfa8g0mSdWmeiYPuDMWnz725Bi1VPO5dnqhUZIwsPxhUdG HFhTgptQQRlsF5Xjny/kgb5Yp6JqKorF4HMP4eYyzPNjl1gSAswmz46znC0651yJR/SH5wAQ2Sf yvZZwOucBORV2khsU4MkCZKMeheFSzC0g692hbTUuUAl5YCGqVjW12o+l7B4NcRe6uFHQR6V1rH qq0xSo+Qd7soNtk3iH0q6DtjfM53Rih3JchIzN+1Q9Oz83CrZTeekbD+WJLbazAiJASAKL1V31R h+u4N76SLFezVhxbj7QnHy92/70LQFytrUFodlQpkGuRBqgA== X-Received: by 2002:a05:7022:249d:b0:123:2d38:928e with SMTP id a92af1059eb24-12741bd5d74mr633497c88.35.1771043308556; Fri, 13 Feb 2026 20:28:28 -0800 (PST) Received: from apollo.purestorage.com ([208.88.152.253]) by smtp.googlemail.com with ESMTPSA id a92af1059eb24-12742cbc900sm1021042c88.14.2026.02.13.20.28.27 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Feb 2026 20:28:28 -0800 (PST) From: Mohamed Khalfella To: Justin Tee , Naresh Gottumukkala , Paul Ely , Chaitanya Kulkarni , Christoph Hellwig , Jens Axboe , Keith Busch , Sagi Grimberg , James Smart , Hannes Reinecke Cc: Aaron Dailey , Randy Jennings , Dhaval Giani , linux-nvme@lists.infradead.org, linux-kernel@vger.kernel.org, Mohamed Khalfella Subject: [PATCH v3 09/21] nvme: Implement cross-controller reset completion Date: Fri, 13 Feb 2026 20:25:10 -0800 Message-ID: <20260214042753.4073668-10-mkhalfella@purestorage.com> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260214042753.4073668-1-mkhalfella@purestorage.com> References: <20260214042753.4073668-1-mkhalfella@purestorage.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" An nvme source controller that issues CCR command expects to receive an NVME_AER_NOTICE_CCR_COMPLETED when pending CCR succeeds or fails. Add sctrl->ccr_work to read NVME_LOG_CCR logpage and wakeup any thread waiting on CCR completion. Signed-off-by: Mohamed Khalfella --- drivers/nvme/host/core.c | 49 +++++++++++++++++++++++++++++++++++++++- drivers/nvme/host/nvme.h | 1 + 2 files changed, 49 insertions(+), 1 deletion(-) diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c index 765b1524b3ed..a9fcde1b411b 100644 --- a/drivers/nvme/host/core.c +++ b/drivers/nvme/host/core.c @@ -1916,7 +1916,8 @@ EXPORT_SYMBOL_GPL(nvme_set_queue_count); =20 #define NVME_AEN_SUPPORTED \ (NVME_AEN_CFG_NS_ATTR | NVME_AEN_CFG_FW_ACT | \ - NVME_AEN_CFG_ANA_CHANGE | NVME_AEN_CFG_DISC_CHANGE) + NVME_AEN_CFG_ANA_CHANGE | NVME_AEN_CFG_CCR_COMPLETE | \ + NVME_AEN_CFG_DISC_CHANGE) =20 static void nvme_enable_aen(struct nvme_ctrl *ctrl) { @@ -4880,6 +4881,47 @@ static void nvme_get_fw_slot_info(struct nvme_ctrl *= ctrl) kfree(log); } =20 +static void nvme_ccr_work(struct work_struct *work) +{ + struct nvme_ctrl *ctrl =3D container_of(work, struct nvme_ctrl, ccr_work); + struct nvme_ccr_entry *ccr; + struct nvme_ccr_log_entry *entry; + struct nvme_ccr_log *log; + unsigned long flags; + int ret, i; + + log =3D kmalloc(sizeof(*log), GFP_KERNEL); + if (!log) + return; + + ret =3D nvme_get_log(ctrl, 0, NVME_LOG_CCR, 0x01, + 0x00, log, sizeof(*log), 0); + if (ret) + goto out; + + spin_lock_irqsave(&ctrl->lock, flags); + for (i =3D 0; i < le16_to_cpu(log->ne); i++) { + entry =3D &log->entries[i]; + if (entry->ccrs =3D=3D NVME_CCR_STATUS_IN_PROGRESS) + continue; + + list_for_each_entry(ccr, &ctrl->ccr_list, list) { + struct nvme_ctrl *ictrl =3D ccr->ictrl; + + if (ictrl->cntlid !=3D le16_to_cpu(entry->icid) || + ictrl->ciu !=3D entry->ciu) + continue; + + /* Complete matching entry */ + ccr->ccrs =3D entry->ccrs; + complete(&ccr->complete); + } + } + spin_unlock_irqrestore(&ctrl->lock, flags); +out: + kfree(log); +} + static void nvme_fw_act_work(struct work_struct *work) { struct nvme_ctrl *ctrl =3D container_of(work, @@ -4956,6 +4998,9 @@ static bool nvme_handle_aen_notice(struct nvme_ctrl *= ctrl, u32 result) case NVME_AER_NOTICE_DISC_CHANGED: ctrl->aen_result =3D result; break; + case NVME_AER_NOTICE_CCR_COMPLETED: + queue_work(nvme_wq, &ctrl->ccr_work); + break; default: dev_warn(ctrl->device, "async event result %08x\n", result); } @@ -5145,6 +5190,7 @@ void nvme_stop_ctrl(struct nvme_ctrl *ctrl) nvme_stop_failfast_work(ctrl); flush_work(&ctrl->async_event_work); cancel_work_sync(&ctrl->fw_act_work); + cancel_work_sync(&ctrl->ccr_work); if (ctrl->ops->stop_ctrl) ctrl->ops->stop_ctrl(ctrl); } @@ -5268,6 +5314,7 @@ int nvme_init_ctrl(struct nvme_ctrl *ctrl, struct dev= ice *dev, ctrl->quirks =3D quirks; ctrl->numa_node =3D NUMA_NO_NODE; INIT_WORK(&ctrl->scan_work, nvme_scan_work); + INIT_WORK(&ctrl->ccr_work, nvme_ccr_work); INIT_WORK(&ctrl->async_event_work, nvme_async_event_work); INIT_WORK(&ctrl->fw_act_work, nvme_fw_act_work); INIT_WORK(&ctrl->delete_work, nvme_delete_ctrl_work); diff --git a/drivers/nvme/host/nvme.h b/drivers/nvme/host/nvme.h index f3ab9411cac5..af6a4e83053e 100644 --- a/drivers/nvme/host/nvme.h +++ b/drivers/nvme/host/nvme.h @@ -365,6 +365,7 @@ struct nvme_ctrl { struct nvme_effects_log *effects; struct xarray cels; struct work_struct scan_work; + struct work_struct ccr_work; struct work_struct async_event_work; struct delayed_work ka_work; struct delayed_work failfast_work; --=20 2.52.0 From nobody Thu Apr 2 22:28:59 2026 Received: from mail-dl1-f46.google.com (mail-dl1-f46.google.com [74.125.82.46]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 7A8972BFC73 for ; Sat, 14 Feb 2026 04:28:30 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.46 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043315; cv=none; b=I80sl3atSGSPbq5J7UpSd19i8V9G6fX27XwJ7PDNhmT6s/n3NuuuF4r8tU9HfLGVCQeshJrNxDJnc2vwWOnToFRaCihMbmW9PLzqQGec0xrWZoKn1l0AxbNMuiPEf0DKCvE5s9tgaMLqrAd79GzKGPsnZLWC5XYlfj4J2nIqQxA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043315; c=relaxed/simple; bh=+pxtO/kUc1gXKagayS4/JiFTpp7PQT9pDtufAFD04og=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=piVLNdc7k6ZTYJqM19+kvLAXTwSAH+u1dVjLWg1qjC6yhF9hpV0SgeA1SBsiUEF8zb3gMIfY1Mj+GGybxJBbphBw6rJaS50iUxqMwVkVNG377CCBEeNkxrm9gNdDzz67SSHyhunvYc4QOh74ZLGsBFTBu1Oyy8j1dak5QPVc8JM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com; spf=fail smtp.mailfrom=purestorage.com; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b=QrBE7Rek; arc=none smtp.client-ip=74.125.82.46 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=purestorage.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b="QrBE7Rek" Received: by mail-dl1-f46.google.com with SMTP id a92af1059eb24-12732165d1eso1959191c88.1 for ; Fri, 13 Feb 2026 20:28:30 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=purestorage.com; s=google2022; t=1771043310; x=1771648110; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=V6Jiwb+wqf39+Dhp+Oi0BJKLILh8l4FLgFLnd5UIyDU=; b=QrBE7Rekrqj4ukHY7kfFUwDk41M+bAIa8cvVFQjmx89lqIwl32b1LvpyGr9pHiW/cT TJC55pFBx7OIvnEsBrEYv+O2JPQMA5WUgqhcccvXS4awBP20jXQQh5jLUoe0WLLIEznG U+3FWmcYgrX6xvIxA3za1eG8Cmqw3cFb1Fp6zGwWweGlfRppgHXWzCKmp1hp9FaZIYQP qI+v3AAyP2OckGQq9kkzM3iuB2u93FuwPz9ZM2THxX+Q32cbpx3qIVkQFJvUIMwmYkp2 S5TeqS7YKjr5GYGvyGXyFnMK01TdJdPiiNW9wT1AbULRPw/ks54P7OlI09yu1tS5EorJ 2++g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1771043310; x=1771648110; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=V6Jiwb+wqf39+Dhp+Oi0BJKLILh8l4FLgFLnd5UIyDU=; b=RHeHhZrLQCxtxLEz/IFk7bEmq/uzwFSaF7LH3Em77XPKj7Mx3UtZzf+M/bVBLHH52+ YVknMuz2I23V71tHMTIY7HPq9tguK352eEF4B22FR+sQGjAStf8WVAm7BKIcej0m500+ bzWh1SP5Ym6qjlBJ6NhwMFRzYSqIs42aKWsTsB8ad7BV1m5HQe48WWedmXzow8qpIZv/ ML/Q9CnwEZPZ6u7V38hKQOPB4yJ78q6j3OQKiDLadu4K8TFWH4umkElnvtBn10cddloN 4ScCryOtYEFrbkhIrQ9X2W3lOCHM19ZZPBXv0AmicQGwiMiybbjtJUigFuBMp+C1+SBj 9VwA== X-Forwarded-Encrypted: i=1; AJvYcCUq8NaVGM9T4NajIHzh4+nJC6bVlDHjJ2EU2pWo06AowofCfylsCZZl7mNk85S9tU3tnVFQhelpcLYwdjo=@vger.kernel.org X-Gm-Message-State: AOJu0Ywi2rafqpkZi3p5H9hudLN5gHpYnapBb51bo4Z9JWIBU+DugiL1 fwqx7HRBTVlI5jPdxXS8PECFV1Qy7VKocDNYO0nt2Qu7mo7gYpOIvrSrWX1+ZDsGotI= X-Gm-Gg: AZuq6aIVKWlqFIHM4YgUzx1HMtVeG8tKUmaeVcjgeXiqfi1gx205S96J/D/d8QAy9xA c7FVYhYAUy+Tykc+D/JGLLPF5a5osCfXRm+YVBYAMbY3aaqmTz9nIMYIoQ9qe7I5VnoxeQ39Nva B3fg8dvKXNLjgPQuj+zIJfMQCC/zGtsACJEUJ5Sa1oHpey/g+aIusIBQcNqnq7GPDyq+hBoz/qT 8Tv1RcPJucPfXZktnkWtkTIQnTWmTlDd+Tr1pYsmCnxH3WOghFnHIbnsenGS4BtyDzG7o4OUUqE crAxBorqAVRVkQSVoizMtKowgIqEXRjxEgDhemGMesBCi1bd1dNu7wF+YQ9HmatP62BFcvKH2Yu Kbi0BWy1XkyBAdcGnvu/VKg98jsvNcPH3rAjebYseXbW+Dvw0xs9Th6BRyF7RDNMQy0/xF6lbzy DK3x0lNL5BUCTa0YSInT24UlcHsQwgt8n/x+si4PRhjQZqNg== X-Received: by 2002:a05:7022:6191:b0:123:2ee9:d1cc with SMTP id a92af1059eb24-1273aecf0e4mr1790771c88.48.1771043309383; Fri, 13 Feb 2026 20:28:29 -0800 (PST) Received: from apollo.purestorage.com ([208.88.152.253]) by smtp.googlemail.com with ESMTPSA id a92af1059eb24-12742cbc900sm1021042c88.14.2026.02.13.20.28.28 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Feb 2026 20:28:29 -0800 (PST) From: Mohamed Khalfella To: Justin Tee , Naresh Gottumukkala , Paul Ely , Chaitanya Kulkarni , Christoph Hellwig , Jens Axboe , Keith Busch , Sagi Grimberg , James Smart , Hannes Reinecke Cc: Aaron Dailey , Randy Jennings , Dhaval Giani , linux-nvme@lists.infradead.org, linux-kernel@vger.kernel.org, Mohamed Khalfella Subject: [PATCH v3 10/21] nvme-tcp: Use CCR to recover controller that hits an error Date: Fri, 13 Feb 2026 20:25:11 -0800 Message-ID: <20260214042753.4073668-11-mkhalfella@purestorage.com> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260214042753.4073668-1-mkhalfella@purestorage.com> References: <20260214042753.4073668-1-mkhalfella@purestorage.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" An alive nvme controller that hits an error now will move to FENCING state instead of RESETTING state. ctrl->fencing_work attempts CCR to terminate inflight IOs. Regardless of the success or failure of CCR operation the controller is transitioned to RESETTING state to continue error recovery process. Signed-off-by: Mohamed Khalfella Reviewed-by: Hannes Reinecke --- drivers/nvme/host/tcp.c | 32 +++++++++++++++++++++++++++++++- 1 file changed, 31 insertions(+), 1 deletion(-) diff --git a/drivers/nvme/host/tcp.c b/drivers/nvme/host/tcp.c index 69cb04406b47..229cfdffd848 100644 --- a/drivers/nvme/host/tcp.c +++ b/drivers/nvme/host/tcp.c @@ -193,6 +193,7 @@ struct nvme_tcp_ctrl { struct sockaddr_storage src_addr; struct nvme_ctrl ctrl; =20 + struct work_struct fencing_work; struct work_struct err_work; struct delayed_work connect_work; struct nvme_tcp_request async_req; @@ -611,6 +612,12 @@ static void nvme_tcp_init_recv_ctx(struct nvme_tcp_que= ue *queue) =20 static void nvme_tcp_error_recovery(struct nvme_ctrl *ctrl) { + if (nvme_change_ctrl_state(ctrl, NVME_CTRL_FENCING)) { + dev_warn(ctrl->device, "starting controller fencing\n"); + queue_work(nvme_wq, &to_tcp_ctrl(ctrl)->fencing_work); + return; + } + if (!nvme_change_ctrl_state(ctrl, NVME_CTRL_RESETTING)) return; =20 @@ -2470,12 +2477,31 @@ static void nvme_tcp_reconnect_ctrl_work(struct wor= k_struct *work) nvme_tcp_reconnect_or_remove(ctrl, ret); } =20 +static void nvme_tcp_fencing_work(struct work_struct *work) +{ + struct nvme_tcp_ctrl *tcp_ctrl =3D container_of(work, + struct nvme_tcp_ctrl, fencing_work); + struct nvme_ctrl *ctrl =3D &tcp_ctrl->ctrl; + unsigned long rem; + + rem =3D nvme_fence_ctrl(ctrl); + if (rem) { + dev_info(ctrl->device, + "CCR failed, skipping time-based recovery\n"); + } + + nvme_change_ctrl_state(ctrl, NVME_CTRL_FENCED); + if (nvme_change_ctrl_state(ctrl, NVME_CTRL_RESETTING)) + queue_work(nvme_reset_wq, &tcp_ctrl->err_work); +} + static void nvme_tcp_error_recovery_work(struct work_struct *work) { struct nvme_tcp_ctrl *tcp_ctrl =3D container_of(work, struct nvme_tcp_ctrl, err_work); struct nvme_ctrl *ctrl =3D &tcp_ctrl->ctrl; =20 + flush_work(&to_tcp_ctrl(ctrl)->fencing_work); if (nvme_tcp_key_revoke_needed(ctrl)) nvme_auth_revoke_tls_key(ctrl); nvme_stop_keep_alive(ctrl); @@ -2518,6 +2544,7 @@ static void nvme_reset_ctrl_work(struct work_struct *= work) container_of(work, struct nvme_ctrl, reset_work); int ret; =20 + flush_work(&to_tcp_ctrl(ctrl)->fencing_work); if (nvme_tcp_key_revoke_needed(ctrl)) nvme_auth_revoke_tls_key(ctrl); nvme_stop_ctrl(ctrl); @@ -2643,13 +2670,15 @@ static enum blk_eh_timer_return nvme_tcp_timeout(st= ruct request *rq) struct nvme_tcp_cmd_pdu *pdu =3D nvme_tcp_req_cmd_pdu(req); struct nvme_command *cmd =3D &pdu->cmd; int qid =3D nvme_tcp_queue_id(req->queue); + enum nvme_ctrl_state state; =20 dev_warn(ctrl->device, "I/O tag %d (%04x) type %d opcode %#x (%s) QID %d timeout\n", rq->tag, nvme_cid(rq), pdu->hdr.type, cmd->common.opcode, nvme_fabrics_opcode_str(qid, cmd), qid); =20 - if (nvme_ctrl_state(ctrl) !=3D NVME_CTRL_LIVE) { + state =3D nvme_ctrl_state(ctrl); + if (state !=3D NVME_CTRL_LIVE && state !=3D NVME_CTRL_FENCING) { /* * If we are resetting, connecting or deleting we should * complete immediately because we may block controller @@ -2904,6 +2933,7 @@ static struct nvme_tcp_ctrl *nvme_tcp_alloc_ctrl(stru= ct device *dev, =20 INIT_DELAYED_WORK(&ctrl->connect_work, nvme_tcp_reconnect_ctrl_work); + INIT_WORK(&ctrl->fencing_work, nvme_tcp_fencing_work); INIT_WORK(&ctrl->err_work, nvme_tcp_error_recovery_work); INIT_WORK(&ctrl->ctrl.reset_work, nvme_reset_ctrl_work); =20 --=20 2.52.0 From nobody Thu Apr 2 22:28:59 2026 Received: from mail-dl1-f45.google.com (mail-dl1-f45.google.com [74.125.82.45]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 4157B23F26A for ; Sat, 14 Feb 2026 04:28:31 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.45 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043319; cv=none; b=ukyQ7zytkM5k3GrzTUhR2Ggq+9iNV3SI9TtSt6IB5TRqw40UrAYIlZ6ZNYPnoWyl1a4QhnLw3TJjucv+weM3PaPh42aqg8P28DB5wzpXt51qjaLX16XOv6o0xQvaV8GiwjQ5FwGMuVDhcdUkHtNAWPzAiZkWV5nB5Fu3nKj1TiQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043319; c=relaxed/simple; bh=+81Jh/gtkA5pFA50hWxQakUUjWRYlu80DgxczS1fSOQ=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=ggIds26KegakNDyqWkHZ2iildtcmFFrxfbOKORabr+X/pJjjEjjdaFHWcbb5+AVYtEkFwKNx4/xhq5lsyvBXsXS485OTAN9diuQ9mxmC6R+dCs4oHT7YVVMiRW4lzvBMJqz/ipO5Fo4pxNUpUTiPsIQxCvquuVWgkXlNOxkMslU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com; spf=fail smtp.mailfrom=purestorage.com; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b=UquK9oMS; arc=none smtp.client-ip=74.125.82.45 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=purestorage.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b="UquK9oMS" Received: by mail-dl1-f45.google.com with SMTP id a92af1059eb24-1271195d2a7so1945492c88.0 for ; Fri, 13 Feb 2026 20:28:31 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=purestorage.com; s=google2022; t=1771043310; x=1771648110; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=B78xagprpyBVY7dOisWT+DL2wEB4yi6Dl89xT/FMHaI=; b=UquK9oMS6if/BAznjwH3JZ32ou2Yr5T0jX/bsWs6CpUyoMVN+Cc4/U1tqOgUfrqjjH kFcoqODLxeSwRJaz7SZhmOaQ/6KR36MY44cy15sgFcyLu7YQB8Bh8vmgJtZfsRAMOfrj +hIu3WM7SXeu7Y/x7fuqPNr+xfu9Ig3rFsN4alS8uTP6Vm++EQvwK8BfXxiLUjFIYrgC lJg0fwMzKGVCOMA/HDSmxIiUSlUY4r+jl3qv6jLY4anOj1msE3Yt7i8ukp5lXEivQjVf AKLu46OJtlcKLYjw3j7oAplRGOkJ+kyyV5RjFcwgoEuk3F+kALasfd+BvKrTBwfhPTk1 bkkQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1771043310; x=1771648110; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=B78xagprpyBVY7dOisWT+DL2wEB4yi6Dl89xT/FMHaI=; b=QY1aya3gi/sUXSjbNmTlaZctD5UpjqsU/rLSi16vkPWFTuIrhFkWWlNS87G9zUnSSI WEWnsDPeOl1BRj6r4yFF3ubuqy5FOs8LYi6n61q9vKsgqdM7R0dUxeCR73C56Ka25GP7 MVp93jqRObDjHAN3pG/nsC0BQ7ZfExyFJocwbh02BJ2KmYsK1VyfcAhQ7RtS0tQqAXeA r1sMkz4/jexryWtckox8CHqNYDxNq57gOiQWBdR8dtt2vb24GxDF1RgTxbJvPoKX6fLz Q/YlMKDl1A0ChJQmWcHldEGOChQgbsVRROaRgwmdIlJzSL5g81EzHFxzcriv2dNb0h43 Fp7w== X-Forwarded-Encrypted: i=1; AJvYcCWmJ1YXPK18xs885gkM94RH/E2TmJ3QJG9ytAZ2uf3AX4d+COsQSk8eV+zsGJh6V2YrINbWzpJMC/Wo+3I=@vger.kernel.org X-Gm-Message-State: AOJu0YyaVDKP0/kopLcJMH50G+ZztKGyLYd9GgOQPQmx7GEdGCg6oM1L +9xjZdIKARtBsZda0QyI4XhswCqM+w6F/+Nf+c4HDRKtxf8SPPlcN3/V7JfqP6l1WG4= X-Gm-Gg: AZuq6aLrNxAZPvJXRHUr/23dy6tRMBoHfAJxRga41Ei7zEQ+MtRFTFvlZzoWKCOUT8J 590zNv6/iop8v11Qt4upGsNsz9CaibtT1pNR8Qjrb8jWVX20ZcH+NK97tgtHgtnYo0AmjBva4Du 9qaVWzgiC7MDhngsfh7kvcQYWGkDmDWLPMm4IJPRCuZbXeR9ADPXDYcQD8Ogd9Sw4APDNNgPmIp rK0l2RE+w0e1DJLtdPHlMHxpP8FhHsl12ijPq7wlviL9pTGGnX8ZJ7KsSWoXcfNDvZ1AfRLgIXT 8TZy/46ZnjDgmQLaWReo87wVSKgMdqDgqYCumuuYpAv9xhv3swMqffd2cspefRwFISvuqEbIsd7 3hwdQW7oFENI6fa1yH0xZ5zWvLn89FSRptGHl9NClNGB8KqhpX+UmLwWNBTe8ZiWJ16YLnSqRLT zPeEKE2Jj9qlZBUbnDsP6COmmh88f5YsXRZ1ZAaZyfFAAZPw== X-Received: by 2002:a05:7022:6183:b0:123:3bba:fc4c with SMTP id a92af1059eb24-12741bd1a97mr687392c88.38.1771043310143; Fri, 13 Feb 2026 20:28:30 -0800 (PST) Received: from apollo.purestorage.com ([208.88.152.253]) by smtp.googlemail.com with ESMTPSA id a92af1059eb24-12742cbc900sm1021042c88.14.2026.02.13.20.28.29 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Feb 2026 20:28:29 -0800 (PST) From: Mohamed Khalfella To: Justin Tee , Naresh Gottumukkala , Paul Ely , Chaitanya Kulkarni , Christoph Hellwig , Jens Axboe , Keith Busch , Sagi Grimberg , James Smart , Hannes Reinecke Cc: Aaron Dailey , Randy Jennings , Dhaval Giani , linux-nvme@lists.infradead.org, linux-kernel@vger.kernel.org, Mohamed Khalfella Subject: [PATCH v3 11/21] nvme-rdma: Use CCR to recover controller that hits an error Date: Fri, 13 Feb 2026 20:25:12 -0800 Message-ID: <20260214042753.4073668-12-mkhalfella@purestorage.com> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260214042753.4073668-1-mkhalfella@purestorage.com> References: <20260214042753.4073668-1-mkhalfella@purestorage.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" An alive nvme controller that hits an error now will move to FENCING state instead of RESETTING state. ctrl->fencing_work attempts CCR to terminate inflight IOs. Regardless of the success or failure of CCR operation the controller is transitioned to RESETTING state to continue error recovery process. Signed-off-by: Mohamed Khalfella Reviewed-by: Hannes Reinecke --- drivers/nvme/host/rdma.c | 32 +++++++++++++++++++++++++++++++- 1 file changed, 31 insertions(+), 1 deletion(-) diff --git a/drivers/nvme/host/rdma.c b/drivers/nvme/host/rdma.c index 35c0822edb2d..2fb47f41215f 100644 --- a/drivers/nvme/host/rdma.c +++ b/drivers/nvme/host/rdma.c @@ -106,6 +106,7 @@ struct nvme_rdma_ctrl { =20 /* other member variables */ struct blk_mq_tag_set tag_set; + struct work_struct fencing_work; struct work_struct err_work; =20 struct nvme_rdma_qe async_event_sqe; @@ -1120,11 +1121,30 @@ static void nvme_rdma_reconnect_ctrl_work(struct wo= rk_struct *work) nvme_rdma_reconnect_or_remove(ctrl, ret); } =20 +static void nvme_rdma_fencing_work(struct work_struct *work) +{ + struct nvme_rdma_ctrl *rdma_ctrl =3D container_of(work, + struct nvme_rdma_ctrl, fencing_work); + struct nvme_ctrl *ctrl =3D &rdma_ctrl->ctrl; + unsigned long rem; + + rem =3D nvme_fence_ctrl(ctrl); + if (rem) { + dev_info(ctrl->device, + "CCR failed, skipping time-based recovery\n"); + } + + nvme_change_ctrl_state(ctrl, NVME_CTRL_FENCED); + if (nvme_change_ctrl_state(ctrl, NVME_CTRL_RESETTING)) + queue_work(nvme_reset_wq, &rdma_ctrl->err_work); +} + static void nvme_rdma_error_recovery_work(struct work_struct *work) { struct nvme_rdma_ctrl *ctrl =3D container_of(work, struct nvme_rdma_ctrl, err_work); =20 + flush_work(&ctrl->fencing_work); nvme_stop_keep_alive(&ctrl->ctrl); flush_work(&ctrl->ctrl.async_event_work); nvme_rdma_teardown_io_queues(ctrl, false); @@ -1147,6 +1167,12 @@ static void nvme_rdma_error_recovery_work(struct wor= k_struct *work) =20 static void nvme_rdma_error_recovery(struct nvme_rdma_ctrl *ctrl) { + if (nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_FENCING)) { + dev_warn(ctrl->ctrl.device, "starting controller fencing\n"); + queue_work(nvme_wq, &ctrl->fencing_work); + return; + } + if (!nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_RESETTING)) return; =20 @@ -1957,13 +1983,15 @@ static enum blk_eh_timer_return nvme_rdma_timeout(s= truct request *rq) struct nvme_rdma_ctrl *ctrl =3D queue->ctrl; struct nvme_command *cmd =3D req->req.cmd; int qid =3D nvme_rdma_queue_idx(queue); + enum nvme_ctrl_state state; =20 dev_warn(ctrl->ctrl.device, "I/O tag %d (%04x) opcode %#x (%s) QID %d timeout\n", rq->tag, nvme_cid(rq), cmd->common.opcode, nvme_fabrics_opcode_str(qid, cmd), qid); =20 - if (nvme_ctrl_state(&ctrl->ctrl) !=3D NVME_CTRL_LIVE) { + state =3D nvme_ctrl_state(&ctrl->ctrl); + if (state !=3D NVME_CTRL_LIVE && state !=3D NVME_CTRL_FENCING) { /* * If we are resetting, connecting or deleting we should * complete immediately because we may block controller @@ -2169,6 +2197,7 @@ static void nvme_rdma_reset_ctrl_work(struct work_str= uct *work) container_of(work, struct nvme_rdma_ctrl, ctrl.reset_work); int ret; =20 + flush_work(&ctrl->fencing_work); nvme_stop_ctrl(&ctrl->ctrl); nvme_rdma_shutdown_ctrl(ctrl, false); =20 @@ -2281,6 +2310,7 @@ static struct nvme_rdma_ctrl *nvme_rdma_alloc_ctrl(st= ruct device *dev, =20 INIT_DELAYED_WORK(&ctrl->reconnect_work, nvme_rdma_reconnect_ctrl_work); + INIT_WORK(&ctrl->fencing_work, nvme_rdma_fencing_work); INIT_WORK(&ctrl->err_work, nvme_rdma_error_recovery_work); INIT_WORK(&ctrl->ctrl.reset_work, nvme_rdma_reset_ctrl_work); =20 --=20 2.52.0 From nobody Thu Apr 2 22:28:59 2026 Received: from mail-dl1-f53.google.com (mail-dl1-f53.google.com [74.125.82.53]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 17BA024A07C for ; Sat, 14 Feb 2026 04:28:31 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.53 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043319; cv=none; b=sAmBtmxUf1bjyj6NrYXZnb4uEVO/AuC3724XkYIyBo/OL1Or6XqxO+sC5PqQ1sPhcbg3KgDVqjYcdHIL0ENgkXvLb2ycpqDza1D0d4BfKuMxkUwoqKCp6VLIfWtOjpMJ/WdMDa92rEoeFAyydQBwuUQfUOikv9U05+aNBL9CbvQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043319; c=relaxed/simple; bh=2Lob27LXacmU41JJLUPDIryQknZBfYBRwlb0ekDMVq8=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=W/dzfl3E7haFKUnSp6TMNV+M8VRsEwzW/sUVFTl6FS2PTa9qZTW1anzF6+tPvAEXh030EWif+eu5ezWntYORYLfW10OE4/yvk7PxtpgIkp8ARJ23NP0erKbb6WfERJe2jAGfSZUk+Iv9dSjWFOqiquzaAaZTFkPZhmyIASPAB8k= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com; spf=fail smtp.mailfrom=purestorage.com; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b=gZr/fsa5; arc=none smtp.client-ip=74.125.82.53 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=purestorage.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b="gZr/fsa5" Received: by mail-dl1-f53.google.com with SMTP id a92af1059eb24-1270be4d125so3698307c88.1 for ; Fri, 13 Feb 2026 20:28:31 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=purestorage.com; s=google2022; t=1771043311; x=1771648111; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=Imu19h/MshhAGpnKdw7Is91vPSU7w8nWppIzdQ0Ksj0=; b=gZr/fsa5PsYMuQLK3TBlKF6aP8RrFlhFOfQwMIOCiijS9CzPHdOvk5mJhi1JQPpSmm +3ZHZtbjdOqZ9eaPL6KOA3faXMskIoaiRGECZku5hhq6ME8Pu9HMNxytfVg/LHk10tIM 7FGxC1GM3sMusO+c3qvtfWbhnfXLvBjIKzPY8pj/2+4gRADp9v2/t1OHfJqHjgf5Y6sQ aMleGN9RH0uzvKsS+aTdmyd+Ad2pGXK75sObTJEbZ4rF8bWAjO0OeufDL7SrOrlc8Bs2 wnB/cPYXN98XUy6aGHWtdnTtbltzyGPsD7NampM64cEMBU+xjd8PCcKAcXpCKgHL1hlF HpRg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1771043311; x=1771648111; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=Imu19h/MshhAGpnKdw7Is91vPSU7w8nWppIzdQ0Ksj0=; b=WNCX0P4B5f6C/R6ckrUrLePGElt5VssTtBHzD5dRJMZlyx25Ge0WQ7GTIO0OSMZ4h0 iMSJTlFJYpIzJPWGHIfNrqw5ctVbUp+UNtInM3JccAdaCWGrpGCMreh5LLGLXkhmjT/i KU1IySOHpRxgOWB//zSNfSy7QocqHGoZPCeWWfwxe21l+rDRzmTAMfDPceCNSzbHrpfr nhX0ESyQe+mhDtS5oNnZxV/kl7rESJKWUApsuHmuEkYV1VRuYowf871Rat4Hogk6FPx6 IW/CUycf/AYPQ3MMorCL2EcI3doAdrtyKiKKCrSr/oYIk6w7Vgy/rlQSTNmyrCe7yDdJ Eucw== X-Forwarded-Encrypted: i=1; AJvYcCVgwzj/p+X0MxJQX3nqn4pXHPLeV2BdZFmMCUzE1aVj5Xq6qd4XiHDJx7nMyzdHn2fTqaWMUXf6z5UIh/U=@vger.kernel.org X-Gm-Message-State: AOJu0YzX5EVEHCRSPoXbzyC91vwN9npqP7GvX21GxPYHSj1qyBGJXIEl HnnG+RVmAz5lS5SXuhrl6F7JdOcFFdlu8OAn5zS7Tv6TVJbzEEcn5s38tpp9KVUJf+w= X-Gm-Gg: AZuq6aJIyucL6R07HF2ZXmKglZC3A78xhRWT3TaxHlteJmAoqYJHGur7IG5K/4rTO3T kRLgjM7CA99r/mGz6YnPmM2RuB9pevPF+M5AvsqmaDA2qxRf/zQdBzFDALRY4S2/VFzWR68s1lb Ehv3rlb4L8WnInIKgDIbyFTGU+hilOSiGlvVmOXVPfWfuxYjagDAnrVCyzTDctr6mm/18+acocr QSLks9Rfk6P2zZtaCiOOAuKb5DHRc/hfYuEKW9xwUoWWLeyBNgxnenBNorLUt36rD5PRimLD5pE EyVmHto/AR0+5YKKsaJF28AFKp1Y73WFsEiZMJEupFq82IEqSvIIdmvf5v/exu/MxKU+WO87op7 OoJW2jopZT4/jhdjGHXZ9q5clldxMF7kkYzZ352+bnQGNqvfPJW5S5YZz3UcLTxvS2SYkvngd13 uK03o96w946SjIPqL767wjulgYktVfbC01Ogvah9dLOytg+g== X-Received: by 2002:a05:7022:6897:b0:127:337e:3301 with SMTP id a92af1059eb24-12741b6fd42mr661529c88.12.1771043310981; Fri, 13 Feb 2026 20:28:30 -0800 (PST) Received: from apollo.purestorage.com ([208.88.152.253]) by smtp.googlemail.com with ESMTPSA id a92af1059eb24-12742cbc900sm1021042c88.14.2026.02.13.20.28.30 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Feb 2026 20:28:30 -0800 (PST) From: Mohamed Khalfella To: Justin Tee , Naresh Gottumukkala , Paul Ely , Chaitanya Kulkarni , Christoph Hellwig , Jens Axboe , Keith Busch , Sagi Grimberg , James Smart , Hannes Reinecke Cc: Aaron Dailey , Randy Jennings , Dhaval Giani , linux-nvme@lists.infradead.org, linux-kernel@vger.kernel.org, Mohamed Khalfella Subject: [PATCH v3 12/21] nvme-fc: Decouple error recovery from controller reset Date: Fri, 13 Feb 2026 20:25:13 -0800 Message-ID: <20260214042753.4073668-13-mkhalfella@purestorage.com> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260214042753.4073668-1-mkhalfella@purestorage.com> References: <20260214042753.4073668-1-mkhalfella@purestorage.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" nvme_fc_error_recovery() called from nvme_fc_timeout() while controller in CONNECTING state results in deadlock reported in link below. Update nvme_fc_timeout() to schedule error recovery to avoid the deadlock. Previous to this change if controller was LIVE error recovery resets the controller and this does not match nvme-tcp and nvme-rdma. Decouple error recovery from controller reset to match other fabric transports. Link: https://lore.kernel.org/all/20250529214928.2112990-1-mkhalfella@pures= torage.com/ Signed-off-by: Mohamed Khalfella --- drivers/nvme/host/fc.c | 120 +++++++++++++++++++++++------------------ 1 file changed, 67 insertions(+), 53 deletions(-) diff --git a/drivers/nvme/host/fc.c b/drivers/nvme/host/fc.c index 6948de3f438a..e6ffaa19aba4 100644 --- a/drivers/nvme/host/fc.c +++ b/drivers/nvme/host/fc.c @@ -227,6 +227,10 @@ static DEFINE_IDA(nvme_fc_ctrl_cnt); static struct device *fc_udev_device; =20 static void nvme_fc_complete_rq(struct request *rq); +static void nvme_fc_start_ioerr_recovery(struct nvme_fc_ctrl *ctrl, + char *errmsg); +static void __nvme_fc_abort_outstanding_ios(struct nvme_fc_ctrl *ctrl, + bool start_queues); =20 /* *********************** FC-NVME Port Management ***********************= * */ =20 @@ -788,7 +792,7 @@ nvme_fc_ctrl_connectivity_loss(struct nvme_fc_ctrl *ctr= l) "Reconnect", ctrl->cnum); =20 set_bit(ASSOC_FAILED, &ctrl->flags); - nvme_reset_ctrl(&ctrl->ctrl); + nvme_fc_start_ioerr_recovery(ctrl, "Connectivity Loss"); } =20 /** @@ -985,7 +989,7 @@ fc_dma_unmap_sg(struct device *dev, struct scatterlist = *sg, int nents, static void nvme_fc_ctrl_put(struct nvme_fc_ctrl *); static int nvme_fc_ctrl_get(struct nvme_fc_ctrl *); =20 -static void nvme_fc_error_recovery(struct nvme_fc_ctrl *ctrl, char *errmsg= ); +static void nvme_fc_error_recovery(struct nvme_fc_ctrl *ctrl); =20 static void __nvme_fc_finish_ls_req(struct nvmefc_ls_req_op *lsop) @@ -1567,9 +1571,8 @@ nvme_fc_ls_disconnect_assoc(struct nvmefc_ls_rcv_op *= lsop) * for the association have been ABTS'd by * nvme_fc_delete_association(). */ - - /* fail the association */ - nvme_fc_error_recovery(ctrl, "Disconnect Association LS received"); + nvme_fc_start_ioerr_recovery(ctrl, + "Disconnect Association LS received"); =20 /* release the reference taken by nvme_fc_match_disconn_ls() */ nvme_fc_ctrl_put(ctrl); @@ -1871,7 +1874,22 @@ nvme_fc_ctrl_ioerr_work(struct work_struct *work) struct nvme_fc_ctrl *ctrl =3D container_of(work, struct nvme_fc_ctrl, ioerr_work); =20 - nvme_fc_error_recovery(ctrl, "transport detected io error"); + /* + * if an error (io timeout, etc) while (re)connecting, the remote + * port requested terminating of the association (disconnect_ls) + * or an error (timeout or abort) occurred on an io while creating + * the controller. Abort any ios on the association and let the + * create_association error path resolve things. + */ + if (nvme_ctrl_state(&ctrl->ctrl) =3D=3D NVME_CTRL_CONNECTING) { + __nvme_fc_abort_outstanding_ios(ctrl, true); + dev_warn(ctrl->ctrl.device, + "NVME-FC{%d}: transport error during (re)connect\n", + ctrl->cnum); + return; + } + + nvme_fc_error_recovery(ctrl); } =20 /* @@ -1892,6 +1910,25 @@ char *nvme_fc_io_getuuid(struct nvmefc_fcp_req *req) } EXPORT_SYMBOL_GPL(nvme_fc_io_getuuid); =20 +static void nvme_fc_start_ioerr_recovery(struct nvme_fc_ctrl *ctrl, + char *errmsg) +{ + enum nvme_ctrl_state state; + + if (nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_RESETTING)) { + dev_warn(ctrl->ctrl.device, "NVME-FC{%d}: starting error recovery %s\n", + ctrl->cnum, errmsg); + queue_work(nvme_reset_wq, &ctrl->ioerr_work); + return; + } + + state =3D nvme_ctrl_state(&ctrl->ctrl); + if (state =3D=3D NVME_CTRL_CONNECTING || state =3D=3D NVME_CTRL_DELETING = || + state =3D=3D NVME_CTRL_DELETING_NOIO) { + queue_work(nvme_reset_wq, &ctrl->ioerr_work); + } +} + static void nvme_fc_fcpio_done(struct nvmefc_fcp_req *req) { @@ -2049,9 +2086,8 @@ nvme_fc_fcpio_done(struct nvmefc_fcp_req *req) nvme_fc_complete_rq(rq); =20 check_error: - if (terminate_assoc && - nvme_ctrl_state(&ctrl->ctrl) !=3D NVME_CTRL_RESETTING) - queue_work(nvme_reset_wq, &ctrl->ioerr_work); + if (terminate_assoc) + nvme_fc_start_ioerr_recovery(ctrl, "io error"); } =20 static int @@ -2495,39 +2531,6 @@ __nvme_fc_abort_outstanding_ios(struct nvme_fc_ctrl = *ctrl, bool start_queues) nvme_unquiesce_admin_queue(&ctrl->ctrl); } =20 -static void -nvme_fc_error_recovery(struct nvme_fc_ctrl *ctrl, char *errmsg) -{ - enum nvme_ctrl_state state =3D nvme_ctrl_state(&ctrl->ctrl); - - /* - * if an error (io timeout, etc) while (re)connecting, the remote - * port requested terminating of the association (disconnect_ls) - * or an error (timeout or abort) occurred on an io while creating - * the controller. Abort any ios on the association and let the - * create_association error path resolve things. - */ - if (state =3D=3D NVME_CTRL_CONNECTING) { - __nvme_fc_abort_outstanding_ios(ctrl, true); - dev_warn(ctrl->ctrl.device, - "NVME-FC{%d}: transport error during (re)connect\n", - ctrl->cnum); - return; - } - - /* Otherwise, only proceed if in LIVE state - e.g. on first error */ - if (state !=3D NVME_CTRL_LIVE) - return; - - dev_warn(ctrl->ctrl.device, - "NVME-FC{%d}: transport association event: %s\n", - ctrl->cnum, errmsg); - dev_warn(ctrl->ctrl.device, - "NVME-FC{%d}: resetting controller\n", ctrl->cnum); - - nvme_reset_ctrl(&ctrl->ctrl); -} - static enum blk_eh_timer_return nvme_fc_timeout(struct request *rq) { struct nvme_fc_fcp_op *op =3D blk_mq_rq_to_pdu(rq); @@ -2536,24 +2539,14 @@ static enum blk_eh_timer_return nvme_fc_timeout(str= uct request *rq) struct nvme_fc_cmd_iu *cmdiu =3D &op->cmd_iu; struct nvme_command *sqe =3D &cmdiu->sqe; =20 - /* - * Attempt to abort the offending command. Command completion - * will detect the aborted io and will fail the connection. - */ dev_info(ctrl->ctrl.device, "NVME-FC{%d.%d}: io timeout: opcode %d fctype %d (%s) w10/11: " "x%08x/x%08x\n", ctrl->cnum, qnum, sqe->common.opcode, sqe->fabrics.fctype, nvme_fabrics_opcode_str(qnum, sqe), sqe->common.cdw10, sqe->common.cdw11); - if (__nvme_fc_abort_op(ctrl, op)) - nvme_fc_error_recovery(ctrl, "io timeout abort failed"); =20 - /* - * the io abort has been initiated. Have the reset timer - * restarted and the abort completion will complete the io - * shortly. Avoids a synchronous wait while the abort finishes. - */ + nvme_fc_start_ioerr_recovery(ctrl, "io timeout"); return BLK_EH_RESET_TIMER; } =20 @@ -3352,6 +3345,27 @@ nvme_fc_reset_ctrl_work(struct work_struct *work) } } =20 +static void +nvme_fc_error_recovery(struct nvme_fc_ctrl *ctrl) +{ + nvme_stop_keep_alive(&ctrl->ctrl); + nvme_stop_ctrl(&ctrl->ctrl); + flush_work(&ctrl->ctrl.async_event_work); + + /* will block while waiting for io to terminate */ + nvme_fc_delete_association(ctrl); + + /* Do not reconnect if controller is being deleted */ + if (!nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_CONNECTING)) + return; + + if (ctrl->rport->remoteport.port_state =3D=3D FC_OBJSTATE_ONLINE) { + queue_delayed_work(nvme_wq, &ctrl->connect_work, 0); + return; + } + + nvme_fc_reconnect_or_delete(ctrl, -ENOTCONN); +} =20 static const struct nvme_ctrl_ops nvme_fc_ctrl_ops =3D { .name =3D "fc", --=20 2.52.0 From nobody Thu Apr 2 22:28:59 2026 Received: from mail-dl1-f44.google.com (mail-dl1-f44.google.com [74.125.82.44]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 39BE929D28F for ; Sat, 14 Feb 2026 04:28:34 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.44 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043319; cv=none; b=RZhXQNuR+UEUI+71z9Fe8zWy2WpGupMFYSJa6wRekpX9EaSKt06RGVSVxc4t8SjR0cLgn2Y+AzSaMxvTKSrkcuD5FK5bLytgsxY6XHiYruK9WS04CixDF0B+OCanZ90xn8tH9ilH89klAI5HImitGBbnKoJbtORed8LkcNbjpNk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043319; c=relaxed/simple; bh=/B74rC7en6yjYP0MzdpgJ++YVbG7lR6S5MtCVCFWekk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=W1GY/oremLQe6tHPOxy1POlWOOTKdIrklgokSfTc68kc/5iDjCNPeNwHv20vx8vEZGltA1ijOLpPjVjU6aRgixHxihqwIfd2TPOpD9zowV1bTF5FX1uPbNEY+XcWu9+tK0wrgUVe/GOF7N9QDnX/P8IMx3QnzW4HD1qqjpiQQys= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com; spf=fail smtp.mailfrom=purestorage.com; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b=YLzBP9e7; arc=none smtp.client-ip=74.125.82.44 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=purestorage.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b="YLzBP9e7" Received: by mail-dl1-f44.google.com with SMTP id a92af1059eb24-12732e6a123so2654805c88.1 for ; Fri, 13 Feb 2026 20:28:34 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=purestorage.com; s=google2022; t=1771043312; x=1771648112; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=XwNieIMOOEiX5lV5XWEf+KtzHT/dG6SPDzSjOWp5JHE=; b=YLzBP9e7OWVkX6OBxlQrnQLkZTIAp+5BOt+4DEwAgkpJvCVqc6DtRn3obMB9dirS+m v0EpSVc+qr2Y9zLOj8wibPLlnXkBpwbdcQ5LvcBUOeL/Hdpxo6oH+CwPQV3U4hn6BEIX VWEUzyIv00ZINFox4BXhaIARi85j8D9aRJL8zbYjiaQPL79reYOd+INwpbgvenrnhrUk 9T2zjoB8CnBpA9EBaHSFuckKiCbesNn5b/+PVjmyTiSSkvi0033R43bMUJ+gdY10kUNH SnNlYPoDmyCpxFxm05vcaISRtkVaihpkkfdncNSd+iEE4F4PRKPhqZhkURu68K9iGOr0 qtjA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1771043312; x=1771648112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=XwNieIMOOEiX5lV5XWEf+KtzHT/dG6SPDzSjOWp5JHE=; b=HHEVd7tLUNWEAQywOy6uYsvXc6zOYvrBT9DXCfh3U64z9BO0RW9GuagWF2Hoplek+p OCao9p5q9r3qbVv3b88OFd+3gaEPLeRaC34sveTicMaR9DMUoEBG7VkASEiadWDn/6FN iReCT+w2KN0KqbM27uX6v54DdSFFrihX/HZOv+G8FVUUzMij5bLh9eeHC0t6plad2PYy d18/NsYumH5OoLz4KOs6whNFTw9Zck7GSsKorNETMzWNQHLE7Whkia3MK8Py6/SQMOQY GmtrfePq8Pzjjhbb5Nuk5aE+jTEYkHKeVxPO/M17touCZSNF4zOWnTDoEv8fUfiZhfB0 xkQg== X-Forwarded-Encrypted: i=1; AJvYcCV2bVcbpslP0V0YrfvsZMnh8EkHp8/vpg0fGCe1EXfbVGonUjoaN+mUinfPGR5zQVJ6Tbg+MwBNacRCbQY=@vger.kernel.org X-Gm-Message-State: AOJu0Yx88KKAocxXD0hW/cMu61zBLxIYCLvL1ScVAmrzJ2l2aIgJDrv5 Z9jFYlcTACwFRRZbuC8rIbVgV2AFAn3Sy4PgzANJP949PW7h1ZOafickl+VF7hG8MwQ= X-Gm-Gg: AZuq6aL365KwLFsKPJglsfZeV89sLVO8BJbLVYC3FHRTlGcNnckXqWhK52juSrBN+7f y7YMb2DLXQq2YpVznAJDPbUvdQAU6x8KFeA/m2tRrKJEhlIodijOaetQH48YUWu7bpA2+mRiLWo Vf8WbO7fWwJEHU4X97s81sR21yiqPY5riFJXrmZb83aw5CSrMnNWoHYQ8sTWvOryKpDIHG5+B1K y2g3ED1O7Nzl1TcMEOKDOOvW6ECled/SfHLbz5apqADIOjo1Bc5XUvf9W5ePZp/l0CVn3FPWiAd 0Bgq0X7d4Zaog9FHMzQav4IzzCF1+87nEDAV4LK74D2uMriyeNY2rpix0reacV50yET1S5zZBG4 oTxodnzdzrOkV/qrZbDjOfnyF8hBnya0nFb9loUqy8s+j+vXIBtmegkLR6ShdGqo5mOVcXA8Lzm vCGIMjEfO491EeNtsyIlTvQuebpiHkB++1PV/oLmXHplqtjw== X-Received: by 2002:a05:7022:6706:b0:119:e569:fb9a with SMTP id a92af1059eb24-1273adba5d6mr1562540c88.9.1771043311738; Fri, 13 Feb 2026 20:28:31 -0800 (PST) Received: from apollo.purestorage.com ([208.88.152.253]) by smtp.googlemail.com with ESMTPSA id a92af1059eb24-12742cbc900sm1021042c88.14.2026.02.13.20.28.31 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Feb 2026 20:28:31 -0800 (PST) From: Mohamed Khalfella To: Justin Tee , Naresh Gottumukkala , Paul Ely , Chaitanya Kulkarni , Christoph Hellwig , Jens Axboe , Keith Busch , Sagi Grimberg , James Smart , Hannes Reinecke Cc: Aaron Dailey , Randy Jennings , Dhaval Giani , linux-nvme@lists.infradead.org, linux-kernel@vger.kernel.org, Mohamed Khalfella Subject: [PATCH v3 13/21] nvme-fc: Use CCR to recover controller that hits an error Date: Fri, 13 Feb 2026 20:25:14 -0800 Message-ID: <20260214042753.4073668-14-mkhalfella@purestorage.com> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260214042753.4073668-1-mkhalfella@purestorage.com> References: <20260214042753.4073668-1-mkhalfella@purestorage.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" An alive nvme controller that hits an error now will move to FENCING state instead of RESETTING state. ctrl->fencing_work attempts CCR to terminate inflight IOs. Regardless of the success or failure of CCR operation the controller is transitioned to RESETTING state to continue error recovery process. Signed-off-by: Mohamed Khalfella --- drivers/nvme/host/fc.c | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/drivers/nvme/host/fc.c b/drivers/nvme/host/fc.c index e6ffaa19aba4..6ebabfb7e76d 100644 --- a/drivers/nvme/host/fc.c +++ b/drivers/nvme/host/fc.c @@ -166,6 +166,7 @@ struct nvme_fc_ctrl { struct blk_mq_tag_set admin_tag_set; struct blk_mq_tag_set tag_set; =20 + struct work_struct fencing_work; struct work_struct ioerr_work; struct delayed_work connect_work; =20 @@ -1868,6 +1869,24 @@ __nvme_fc_fcpop_chk_teardowns(struct nvme_fc_ctrl *c= trl, } } =20 +static void nvme_fc_fencing_work(struct work_struct *work) +{ + struct nvme_fc_ctrl *fc_ctrl =3D + container_of(work, struct nvme_fc_ctrl, fencing_work); + struct nvme_ctrl *ctrl =3D &fc_ctrl->ctrl; + unsigned long rem; + + rem =3D nvme_fence_ctrl(ctrl); + if (rem) { + dev_info(ctrl->device, + "CCR failed, skipping time-based recovery\n"); + } + + nvme_change_ctrl_state(ctrl, NVME_CTRL_FENCED); + if (nvme_change_ctrl_state(ctrl, NVME_CTRL_RESETTING)) + queue_work(nvme_reset_wq, &fc_ctrl->ioerr_work); +} + static void nvme_fc_ctrl_ioerr_work(struct work_struct *work) { @@ -1889,6 +1908,7 @@ nvme_fc_ctrl_ioerr_work(struct work_struct *work) return; } =20 + flush_work(&ctrl->fencing_work); nvme_fc_error_recovery(ctrl); } =20 @@ -1915,6 +1935,14 @@ static void nvme_fc_start_ioerr_recovery(struct nvme= _fc_ctrl *ctrl, { enum nvme_ctrl_state state; =20 + if (nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_FENCING)) { + dev_warn(ctrl->ctrl.device, + "NVME-FC{%d}: starting controller fencing %s\n", + ctrl->cnum, errmsg); + queue_work(nvme_wq, &ctrl->fencing_work); + return; + } + if (nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_RESETTING)) { dev_warn(ctrl->ctrl.device, "NVME-FC{%d}: starting error recovery %s\n", ctrl->cnum, errmsg); @@ -3322,6 +3350,7 @@ nvme_fc_reset_ctrl_work(struct work_struct *work) struct nvme_fc_ctrl *ctrl =3D container_of(work, struct nvme_fc_ctrl, ctrl.reset_work); =20 + flush_work(&ctrl->fencing_work); nvme_stop_ctrl(&ctrl->ctrl); =20 /* will block will waiting for io to terminate */ @@ -3497,6 +3526,7 @@ nvme_fc_alloc_ctrl(struct device *dev, struct nvmf_ct= rl_options *opts, =20 INIT_WORK(&ctrl->ctrl.reset_work, nvme_fc_reset_ctrl_work); INIT_DELAYED_WORK(&ctrl->connect_work, nvme_fc_connect_ctrl_work); + INIT_WORK(&ctrl->fencing_work, nvme_fc_fencing_work); INIT_WORK(&ctrl->ioerr_work, nvme_fc_ctrl_ioerr_work); spin_lock_init(&ctrl->lock); =20 --=20 2.52.0 From nobody Thu Apr 2 22:28:59 2026 Received: from mail-dl1-f43.google.com (mail-dl1-f43.google.com [74.125.82.43]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 380C42BEC30 for ; Sat, 14 Feb 2026 04:28:33 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.43 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043320; cv=none; b=J3MI1v5GRAhgDPcC7SXrHOD3zQotCHcnFpE18xB8+v7ZTjxrXc1oLMBivrg2IQN5qs3gtyjXpD7MPOyWqXoMWxWzgR8ehlRQZNm+Blbja2k/c/8rCqhksalzNBMG8GDx70kSGbv8dTAPL453p4ueJl10QDHkeRl0tegT/ALcm2A= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043320; c=relaxed/simple; bh=ESD4NgMJyYwcLca5Bppkico1E2KSIPGqq/sBl6nuGlE=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=BtfSw964F4aq5nHgntd3bK4ORWaWH5HLpO3qCbYBzVdPRDtnipIewkTLjthET/AdefI9HKRICMZ9fFlnHBvzEZ2yKbd9gqmZ96ZRW2NqonDLRGP9bhxlrQo2F0PsmksKLLcwFRYN0bycVOTG82rR3iU3gXqc45s2npKTNlvNlJ4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com; spf=fail smtp.mailfrom=purestorage.com; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b=Y9jUKH2Y; arc=none smtp.client-ip=74.125.82.43 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=purestorage.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b="Y9jUKH2Y" Received: by mail-dl1-f43.google.com with SMTP id a92af1059eb24-124a635476fso2000845c88.0 for ; Fri, 13 Feb 2026 20:28:33 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=purestorage.com; s=google2022; t=1771043313; x=1771648113; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=fq5iuFqiPF/Ft8LgP12Pou/FFdH+onXHL70j0HtoixQ=; b=Y9jUKH2YPz147uBV2ouqTAdj4gCF7SFktBN7pqFmKKMYX7ascWEy7/r1V60EgqbyJA 7c1LgdxZzQm8YSYajyefJTwdZhnHZjGLIhhnp9HXpxsFsa5UXM5HE/pXl2aZ7QnKhV06 IFvHS9n1bOh1JcAzB5vvC/KY2zf5ryTkIxicXOEHlrzeVmUdZ/T8iqKqr5ON4VT1GPYI n8P4U0J4SU+rge8YNFeD5H5xGgQq+dan0/e2LOJVLDybkQyUdikL9u/+4SzDFvxacqNG e30Rw1LO18lt9IShibBTdq4X5crM1g5xa5RvdaQtnpz2RXwowbSCDeNF/l4We+sF6RTk 5HGw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1771043313; x=1771648113; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=fq5iuFqiPF/Ft8LgP12Pou/FFdH+onXHL70j0HtoixQ=; b=bDEvACjbvdT2Ox4VMDv2Qqw7Gs2xyCIFsUqOQAdOrGKUuC4akxxu2XpQAC1DUuDNhM ny25Tg8bdrpayfpBEMjwk0nJARQYNt80WMWFm/BU26KYYgyWswnwhFthYfvXN11Mhi+N BGlJ7Vhux62CyWNs8T4ffwpImxZhxygN+kcPpElZ2nuQ2fQevyrznswKOzBOC5hgg0fh Q3nN1oDgHebRpHLhgL408TFXl0+ZMAL9J6chaYx8vvqt/qWGjWA6Xv1l6SAbbe+oW7Te rPZwyAmc8lA6xby1Rwa5WavvooZex/grSEy+YaBpgbrjChN4GViOEzWkyxIjo6x04pQY k/1g== X-Forwarded-Encrypted: i=1; AJvYcCXjg8epIZ3eor81l0oAJEyY5s4sM+b1Guz5tvenedYQ2W81I9NflOea/zycubYacxbv5oPqjmoiGe3ylnM=@vger.kernel.org X-Gm-Message-State: AOJu0YzUWyV49fJNNg8PVMHeKqNR8Y62T/UMWJGYJU/FbuEDDo7ZaCem 6j9SLBfIX+h3NXU66Tn24ULtChFgB/s5QhvY7ZTtTiOor6aYvPgJuQqmov1LZY6KoKw= X-Gm-Gg: AZuq6aJKmhCEN4CQMsXlcb/5UbdpH4MFqJvW3Gg9/QHibzq6M+Y0V9J1lKHVn/oFb+x sna+focWX5O1S7cUNdTg35MBzB/YGMtygACoZ02KwIIcuXUG/gPtBays9sPn5lnHLSvQJQwnuKm Ktxa8NLbyaB1RaG0TQqz5GQ5FU108Fzmh20HfemtJ/MpoxfXHOcONtfFQ/pOvKGRakdwU/yln4S v+4WVytSL1TkzKVQJJeFcwtsuKLoI3nwIpAn+sbI2NBgrS9/EYnWuBvly7zoyHEBlQM5BlMZPV7 A5ghmL8DavliYLTvk9IuFQ2QQ9QXPC72pFzJa+Q9i8UlgeYod2unVOwOjjXtkrS8nJK8eQrq58o b1bS2Pr7Jw1ZxzHCxWYVeMKmBRZd8pzACjk8MMagaLIpQV7IpcDp0MvG877pnkGRITLekI36jDS 03NSvmLPqVtYNvIeTZONZJm2E3n6/6aPuNT3T+6l07pMukzQ== X-Received: by 2002:a05:7022:f102:b0:11d:f0d3:c5da with SMTP id a92af1059eb24-1273ae66557mr1331974c88.43.1771043312566; Fri, 13 Feb 2026 20:28:32 -0800 (PST) Received: from apollo.purestorage.com ([208.88.152.253]) by smtp.googlemail.com with ESMTPSA id a92af1059eb24-12742cbc900sm1021042c88.14.2026.02.13.20.28.31 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Feb 2026 20:28:32 -0800 (PST) From: Mohamed Khalfella To: Justin Tee , Naresh Gottumukkala , Paul Ely , Chaitanya Kulkarni , Christoph Hellwig , Jens Axboe , Keith Busch , Sagi Grimberg , James Smart , Hannes Reinecke Cc: Aaron Dailey , Randy Jennings , Dhaval Giani , linux-nvme@lists.infradead.org, linux-kernel@vger.kernel.org, Mohamed Khalfella Subject: [PATCH v3 14/21] nvme-fc: Hold inflight requests while in FENCING state Date: Fri, 13 Feb 2026 20:25:15 -0800 Message-ID: <20260214042753.4073668-15-mkhalfella@purestorage.com> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260214042753.4073668-1-mkhalfella@purestorage.com> References: <20260214042753.4073668-1-mkhalfella@purestorage.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" While in FENCING state, aborted inflight IOs should be held until fencing is done. Update nvme_fc_fcpio_done() to not complete aborted requests or requests with transport errors. These held requests will be canceled in nvme_fc_delete_association() after fencing is done. nvme_fc_fcpio_done() avoids racing with canceling aborted requests by making sure we complete successful requests before waking up the waiting thread. Signed-off-by: Mohamed Khalfella --- drivers/nvme/host/fc.c | 61 +++++++++++++++++++++++++++++++++++------- 1 file changed, 51 insertions(+), 10 deletions(-) diff --git a/drivers/nvme/host/fc.c b/drivers/nvme/host/fc.c index 6ebabfb7e76d..e605dd3f4a40 100644 --- a/drivers/nvme/host/fc.c +++ b/drivers/nvme/host/fc.c @@ -172,7 +172,7 @@ struct nvme_fc_ctrl { =20 struct kref ref; unsigned long flags; - u32 iocnt; + atomic_t iocnt; wait_queue_head_t ioabort_wait; =20 struct nvme_fc_fcp_op aen_ops[NVME_NR_AEN_COMMANDS]; @@ -1823,7 +1823,7 @@ __nvme_fc_abort_op(struct nvme_fc_ctrl *ctrl, struct = nvme_fc_fcp_op *op) atomic_set(&op->state, opstate); else if (test_bit(FCCTRL_TERMIO, &ctrl->flags)) { op->flags |=3D FCOP_FLAGS_TERMIO; - ctrl->iocnt++; + atomic_inc(&ctrl->iocnt); } spin_unlock_irqrestore(&ctrl->lock, flags); =20 @@ -1853,20 +1853,29 @@ nvme_fc_abort_aen_ops(struct nvme_fc_ctrl *ctrl) } =20 static inline void +__nvme_fc_fcpop_count_one_down(struct nvme_fc_ctrl *ctrl) +{ + if (atomic_dec_return(&ctrl->iocnt) =3D=3D 0) + wake_up(&ctrl->ioabort_wait); +} + +static inline bool __nvme_fc_fcpop_chk_teardowns(struct nvme_fc_ctrl *ctrl, struct nvme_fc_fcp_op *op, int opstate) { unsigned long flags; + bool ret =3D false; =20 if (opstate =3D=3D FCPOP_STATE_ABORTED) { spin_lock_irqsave(&ctrl->lock, flags); if (test_bit(FCCTRL_TERMIO, &ctrl->flags) && op->flags & FCOP_FLAGS_TERMIO) { - if (!--ctrl->iocnt) - wake_up(&ctrl->ioabort_wait); + ret =3D true; } spin_unlock_irqrestore(&ctrl->lock, flags); } + + return ret; } =20 static void nvme_fc_fencing_work(struct work_struct *work) @@ -1969,7 +1978,8 @@ nvme_fc_fcpio_done(struct nvmefc_fcp_req *req) struct nvme_command *sqe =3D &op->cmd_iu.sqe; __le16 status =3D cpu_to_le16(NVME_SC_SUCCESS << 1); union nvme_result result; - bool terminate_assoc =3D true; + bool op_term, terminate_assoc =3D true; + enum nvme_ctrl_state state; int opstate; =20 /* @@ -2102,16 +2112,38 @@ nvme_fc_fcpio_done(struct nvmefc_fcp_req *req) done: if (op->flags & FCOP_FLAGS_AEN) { nvme_complete_async_event(&queue->ctrl->ctrl, status, &result); - __nvme_fc_fcpop_chk_teardowns(ctrl, op, opstate); + if (__nvme_fc_fcpop_chk_teardowns(ctrl, op, opstate)) + __nvme_fc_fcpop_count_one_down(ctrl); atomic_set(&op->state, FCPOP_STATE_IDLE); op->flags =3D FCOP_FLAGS_AEN; /* clear other flags */ nvme_fc_ctrl_put(ctrl); goto check_error; } =20 - __nvme_fc_fcpop_chk_teardowns(ctrl, op, opstate); + /* + * We can not access op after the request is completed because it can + * be reused immediately. At the same time we want to wakeup the thread + * waiting for ongoing IOs _after_ requests are completed. This is + * necessary because that thread will start canceling inflight IOs + * and we want to avoid request completion racing with cancellation. + */ + op_term =3D __nvme_fc_fcpop_chk_teardowns(ctrl, op, opstate); + + /* + * If we are going to terminate associations and the controller is + * LIVE or FENCING, then do not complete this request now. Let error + * recovery cancel this request when it is safe to do so. + */ + state =3D nvme_ctrl_state(&ctrl->ctrl); + if (terminate_assoc && + (state =3D=3D NVME_CTRL_LIVE || state =3D=3D NVME_CTRL_FENCING)) + goto check_op_term; + if (!nvme_try_complete_req(rq, status, result)) nvme_fc_complete_rq(rq); +check_op_term: + if (op_term) + __nvme_fc_fcpop_count_one_down(ctrl); =20 check_error: if (terminate_assoc) @@ -2750,7 +2782,8 @@ nvme_fc_start_fcp_op(struct nvme_fc_ctrl *ctrl, struc= t nvme_fc_queue *queue, * cmd with the csn was supposed to arrive. */ opstate =3D atomic_xchg(&op->state, FCPOP_STATE_COMPLETE); - __nvme_fc_fcpop_chk_teardowns(ctrl, op, opstate); + if (__nvme_fc_fcpop_chk_teardowns(ctrl, op, opstate)) + __nvme_fc_fcpop_count_one_down(ctrl); =20 if (!(op->flags & FCOP_FLAGS_AEN)) { nvme_fc_unmap_data(ctrl, op->rq, op); @@ -3219,7 +3252,7 @@ nvme_fc_delete_association(struct nvme_fc_ctrl *ctrl) =20 spin_lock_irqsave(&ctrl->lock, flags); set_bit(FCCTRL_TERMIO, &ctrl->flags); - ctrl->iocnt =3D 0; + atomic_set(&ctrl->iocnt, 0); spin_unlock_irqrestore(&ctrl->lock, flags); =20 __nvme_fc_abort_outstanding_ios(ctrl, false); @@ -3228,11 +3261,19 @@ nvme_fc_delete_association(struct nvme_fc_ctrl *ctr= l) nvme_fc_abort_aen_ops(ctrl); =20 /* wait for all io that had to be aborted */ + wait_event(ctrl->ioabort_wait, atomic_read(&ctrl->iocnt) =3D=3D 0); spin_lock_irq(&ctrl->lock); - wait_event_lock_irq(ctrl->ioabort_wait, ctrl->iocnt =3D=3D 0, ctrl->lock); clear_bit(FCCTRL_TERMIO, &ctrl->flags); spin_unlock_irq(&ctrl->lock); =20 + /* + * At this point all inflight requests have been successfully + * aborted. Now it is safe to cancel all requests we decided + * not to complete in nvme_fc_fcpio_done(). + */ + nvme_cancel_tagset(&ctrl->ctrl); + nvme_cancel_admin_tagset(&ctrl->ctrl); + nvme_fc_term_aen_ops(ctrl); =20 /* --=20 2.52.0 From nobody Thu Apr 2 22:28:59 2026 Received: from mail-dl1-f45.google.com (mail-dl1-f45.google.com [74.125.82.45]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 7D882221F26 for ; Sat, 14 Feb 2026 04:28:36 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.45 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043320; cv=none; b=JlB9stOXXe5vvmX8HBvRmRDqj3ACqyoN16nsykQ63fD7ItPcGaDibMZ2LLGPHVQDKDoUHBED7nPNgW0RmZ1K58my+igfPM+DajN45wjre+auVjAG4HZ5+B+sZIltcIDVoIq2r/eyjgc3kLnjTTw4O02evuQAmpK8nsVNSEp6Plk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043320; c=relaxed/simple; bh=0udHID5KL61Xx3Y6ZYYZn5XQ2+6n6XT/3Rp742TCj2w=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=p/ww32mJ6OI8M6zUoeLCVJjIKy5j1NKSvcAfyeCiKr9wpE1rE5Hr03/SZLbohztSzlxOMMMfU88ocqBFNacxdq2R3h8tvl9KW8WY7Lfcaf+0nDM0bktEkkcL+DcGa03pa7qXH7xKSTHgNWdkpcK5yULwB7IJMx5AQBT0Vd7fs+g= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com; spf=fail smtp.mailfrom=purestorage.com; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b=QGS4NuGY; arc=none smtp.client-ip=74.125.82.45 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=purestorage.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b="QGS4NuGY" Received: by mail-dl1-f45.google.com with SMTP id a92af1059eb24-1248d27f293so3710907c88.0 for ; Fri, 13 Feb 2026 20:28:36 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=purestorage.com; s=google2022; t=1771043314; x=1771648114; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=ekotz5RVjYf6MGMkCCi7bJt1PcW5y5lDCPYdfqHxyyw=; b=QGS4NuGYnxjIdCdjDu/nIQT6h7fddWIXK3QUMYdiMRWlawTYF+NckyxFg1M+/2tuFY DdYLCVA31C+SCTA9cXgMTpgfEVHwjxETRr3U9BlLCNNC9aVq/+8xLBFU5tbpQ6w5JF5C iX//lWkpxADIo4JsV7OiSJqEjcdYP+xJnmkkqIVBt6I/9kc4O7eR/mxkjTSQldLzw6Iv LT4d16X8q95XhmdooY38jHoCzk5VhSDphYlu2dNRxsdtpb2wW/Umvw4Sw8MICCEOnoQD me0qzlPxsuepeTzYfTnzF1cy+MLU5hL4V1bwWgDI6OaOrf+Dtk9jwRwRRCMQflM684Kk 5Stw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1771043314; x=1771648114; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=ekotz5RVjYf6MGMkCCi7bJt1PcW5y5lDCPYdfqHxyyw=; b=E4ZuQDFg2xUtexfCusRagb9REVwVV73m6iVFbpn7WgsZnjKV5HmzgOAzPMvZzEkwVv hrHGzMdxQ0d3AZUggRYQC6Tt3jN0Oqoo2CviylJmulGAV29gbc1OzpfbCcEiAKHBRoAO mzObjFQxJZ/s7wWLoivcbs4FgWy0F05NRlGNx+b4l3mDSFiP0o3cyVEJEnkK/snewo+s egPH48TlzJUZgFAFgOUJf0QvikvVV7wWLtq2cbBF4kJMaoMumQUEffIdbKRpiJYKIFrO y578YeKeqKvidKfOJVLXln32ZKg8hScoZahzzlrvTeRBAhhjMYx96KsnfZX014ph0TNm FE9w== X-Forwarded-Encrypted: i=1; AJvYcCWhfVXHOxl2uqKLuuzNta6vWYdO+6fweR09tpEpZ80EEaW73Oq7cbHLKDDcNov/U28IOssYtKXbe0XPafM=@vger.kernel.org X-Gm-Message-State: AOJu0YwYZtHdC64nT6EdeBZn1CicDYg/BDVm1PnYubb3Iy/MFgnuMc0q xpdG6MAiUVdQMYFqbhjUlHoEH7rKyBp95oI1SGALMfD5RYcGiZR6UiOSkz6CkvlkyKo= X-Gm-Gg: AZuq6aJpDV/+lOU+n6Wu3UnNM7vmz5/95HLDFEdnxM2G8L2A2CdrRcN3z427n2LjT3C 1YdA2zpvr5AK2cbv9t8aTEf3GwJDv0xTh3T37CSllQryS+cqj/1q0L7AqRjHGsGD6CueATNg5p/ rgw6mS09UkS6CNZ+T+4Dn9sKkB1KWYvtrHkSyPV98j5nv1066DkVgsnHyED6oHWCWgO6IBbvWuR SZihYy17SY+WVCS8eG6T5datKWL1pk5qOpnpA2GqT/4k7gwWTaPBxwLujbXBILb6jv41x96rueP WKtP38bVS+F6bSF3laPnz1R4UEcjiaHKbWlkOGAu67p4AJAtm8XYmRusaQJdSfbBJ7F6leiyhvl m5btALabWc+HS+BvIsD6wUiClE1eQeh5arqPUUN0c31vqAZFSHyxYfdtfEBPHqjciQrJ9lGXp+k Ag8c2ySmci1624MnB3bpae93G29OVGPH0sEw2JRLJhFVWS2A== X-Received: by 2002:a05:7022:e1e:b0:11b:9386:7ed3 with SMTP id a92af1059eb24-1273aed4989mr2119761c88.48.1771043313356; Fri, 13 Feb 2026 20:28:33 -0800 (PST) Received: from apollo.purestorage.com ([208.88.152.253]) by smtp.googlemail.com with ESMTPSA id a92af1059eb24-12742cbc900sm1021042c88.14.2026.02.13.20.28.32 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Feb 2026 20:28:33 -0800 (PST) From: Mohamed Khalfella To: Justin Tee , Naresh Gottumukkala , Paul Ely , Chaitanya Kulkarni , Christoph Hellwig , Jens Axboe , Keith Busch , Sagi Grimberg , James Smart , Hannes Reinecke Cc: Aaron Dailey , Randy Jennings , Dhaval Giani , linux-nvme@lists.infradead.org, linux-kernel@vger.kernel.org, Mohamed Khalfella Subject: [PATCH v3 15/21] nvme-fc: Do not cancel requests in io taget before it is initialized Date: Fri, 13 Feb 2026 20:25:16 -0800 Message-ID: <20260214042753.4073668-16-mkhalfella@purestorage.com> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260214042753.4073668-1-mkhalfella@purestorage.com> References: <20260214042753.4073668-1-mkhalfella@purestorage.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" A new nvme-fc controller in CONNECTING state sees admin request timeout schedules ctrl->ioerr_work to abort inflight requests. This ends up calling __nvme_fc_abort_outstanding_ios() which aborts requests in both admin and io tagsets. In case fc_ctrl->tag_set was not initialized we see the warning below. This is because ctrl.queue_count is initialized early in nvme_fc_alloc_ctrl(). nvme nvme0: NVME-FC{0}: starting error recovery Connectivity Loss INFO: trying to register non-static key. The code is fine but needs lockdep annotation, or maybe lpfc 0000:ab:00.0: queue 0 connect admin queue failed (-6). you didn't initialize this object before use? turning off the locking correctness validator. Workqueue: nvme-reset-wq nvme_fc_ctrl_ioerr_work [nvme_fc] Call Trace: dump_stack_lvl+0x57/0x80 register_lock_class+0x567/0x580 __lock_acquire+0x330/0xb90 lock_acquire.part.0+0xad/0x210 blk_mq_tagset_busy_iter+0xf9/0xc00 __nvme_fc_abort_outstanding_ios+0x23f/0x320 [nvme_fc] nvme_fc_ctrl_ioerr_work+0x172/0x210 [nvme_fc] process_one_work+0x82c/0x1450 worker_thread+0x5ee/0xfd0 kthread+0x3a0/0x750 ret_from_fork+0x439/0x670 ret_from_fork_asm+0x1a/0x30 Update the check in __nvme_fc_abort_outstanding_ios() confirm that io tagset was created before iterating over busy requests. Also make sure to cancel ctrl->ioerr_work before removing io tagset. Signed-off-by: Mohamed Khalfella --- drivers/nvme/host/fc.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/drivers/nvme/host/fc.c b/drivers/nvme/host/fc.c index e605dd3f4a40..eac3a7ccaa5c 100644 --- a/drivers/nvme/host/fc.c +++ b/drivers/nvme/host/fc.c @@ -2557,7 +2557,7 @@ __nvme_fc_abort_outstanding_ios(struct nvme_fc_ctrl *= ctrl, bool start_queues) * io requests back to the block layer as part of normal completions * (but with error status). */ - if (ctrl->ctrl.queue_count > 1) { + if (ctrl->ctrl.queue_count > 1 && ctrl->ctrl.tagset) { nvme_quiesce_io_queues(&ctrl->ctrl); nvme_sync_io_queues(&ctrl->ctrl); blk_mq_tagset_busy_iter(&ctrl->tag_set, @@ -2954,6 +2954,11 @@ nvme_fc_create_io_queues(struct nvme_fc_ctrl *ctrl) out_delete_hw_queues: nvme_fc_delete_hw_io_queues(ctrl); out_cleanup_tagset: + /* + * In CONNECTING state ctrl->ioerr_work will abort both admin + * and io tagsets. Cancel it first before removing io tagset. + */ + cancel_work_sync(&ctrl->ioerr_work); nvme_remove_io_tag_set(&ctrl->ctrl); nvme_fc_free_io_queues(ctrl); =20 --=20 2.52.0 From nobody Thu Apr 2 22:28:59 2026 Received: from mail-dl1-f44.google.com (mail-dl1-f44.google.com [74.125.82.44]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 4019B2877FC for ; Sat, 14 Feb 2026 04:28:35 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.44 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043327; cv=none; b=RyHnXs5vyCCx/zcoQFNdHPSVbFVvv8FlCry9U28e1Jfk1+yHb9q+CX0xOj+wlogueLtGzg8cnArLcW11CiYJyNJK+GlGmcRzMOQFfpu5beVHYNiAlohr5rmIiIIVFgWpaDFkbJkAW6/WEE2FwKW1O3eJJH3vvPn57PxMmhNBuUw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043327; c=relaxed/simple; bh=HJYmALZM51O5F13S+sWSXtruVH1L8A6zHC17zV2Yl+w=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=iLPk5ApkkFT/4iDtR1mz0l/sQnay2wLEUrlyr1bFdaCQ+DkFvUZ2DJf3OgOo2a6+nZPH6vkKdHgprMsvYFYM6vMic1ygTxQJhPRFw9PjS3HG2j6NaKFQnJ4zJGntAYyTXoo32iCI0gUSVBNmnPwp1+dMwa5lUY6R1oeBMxP6JWQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com; spf=fail smtp.mailfrom=purestorage.com; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b=Tewz4tfw; arc=none smtp.client-ip=74.125.82.44 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=purestorage.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b="Tewz4tfw" Received: by mail-dl1-f44.google.com with SMTP id a92af1059eb24-1270be4d125so3698366c88.1 for ; Fri, 13 Feb 2026 20:28:35 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=purestorage.com; s=google2022; t=1771043314; x=1771648114; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=60jyQ1ZIQG8Pf4xFK6xEZaP994isrxae0+XCbgekpxA=; b=Tewz4tfwHu/3OXDCnFm+++uj1PW7fmp8DdvDzwd/PDAH3glbsJG1SGoaI8OA7+1oze qlhvofAzkAasWkMl1aVLAyhs1dVxn83fc3vDqVqggKBeYhIPk4FBz3gnAjLbuceLEN+X 1a2gITp5bxZF0r3BGBKBZw51si1s3Q6bOKeJLSAr+k2E87d6fJszSpz2ZFs/Wn5XqBDq VUUmLItowQxuX8wBabGcRvD4e8IeiYgWnTIHloZ9mXMjkkoPGXh9OwCOop8SCKSSQnwe 70qUaRdNcZ2/ziSp69BzciS1JpBnNZ3kbX5aaF5SVVvJGepESD/vFlBibGDf5IAsrkHM cQEQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1771043314; x=1771648114; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=60jyQ1ZIQG8Pf4xFK6xEZaP994isrxae0+XCbgekpxA=; b=VbhY4zTSh8WaB8GJafdvQxMsx1EW6zVi2JLUP4VrAPsZSdTPI7srQuUim1td5xhnZq IEeyRK4gHKxfbPeM7wtvHWMjO6O8nxHRTWtPj+ioVdkNHcDaT3VbWss9cOSmF2be2S6/ 2zafR0/EGOWTaRb9sW9fklXbpTZamgcHxB08W3oQsf3SCck+olvNZfjsAIEXV4T0O5su TrVhEx1lngevGM7RACVyEDkBgL03kLXQcgioHzezWwBkHjlTs3LHEQShfujB3t+q1zjd bhszuPVuOVESAnM/UOdSiidmXmOMnGXy17oR6ccQQKyggCa0txIKXrLB7q6HcUl6x/Xd oEDg== X-Forwarded-Encrypted: i=1; AJvYcCWC24TQoxo8yWncMdo1krVnMr73Tt2MNaZXc0KAic9MKcbHlLjJNh4jNilRnKafIM6IRbv6MhKiL8ozcRc=@vger.kernel.org X-Gm-Message-State: AOJu0Yyuf24WuCcmx0f9Ub80k/vDmhLgWPSVNY+kgMb9IUcWm2T765F8 uVIkQMoDFIRp5uguYuu4rvazM5mVIH7TjUFQVP3tNtFcdQUZD6rUasdOrUafueImfsM= X-Gm-Gg: AZuq6aI/D4anlF4vDWgZjkeLV3Ly1XanOVF99xETVdzi+mXjWyD1K7ZoVqx6/YeYFXH NTz+CMTMWFCY0v7IvT3RdIYmQ5gP0Z7SS2whcidhN35kfWO1VdmMWN+TTI6wbapWG1MMHkAYtYN yyIoacZP1rt/a6rSSZqfBUJdvbO27rUbcxTnWLVsGCygn6XkSJ0MOlNdbzS2LG/PstjrytyOzq+ aeK9x0XjbqOyc4BU2GU+/qDve3GupDBL0ETaZOkj3TpB6CThmKxl57KONjRZElwsdH9KnG9Le/A nQCh/Bi2J6ozRsJCtcFucTODY9N+IDKq2D7UpQaI4pwVUQdnPjvMKgiJNh3c1Nj5OBG6kndEqn5 6Xr/haJuyoQbZ3F9jj4btRuFS19zMMqA+0aG1/UD2SI8Flv6hnyiI6zxEdAsKbEaBCaUxitHwaU nRKU6buNZo0Gw+pVah04AF/uchC2BEgqI+LKuIaS150Topvg== X-Received: by 2002:a05:7022:793:b0:124:9acd:32d1 with SMTP id a92af1059eb24-12741b6348bmr821445c88.9.1771043314205; Fri, 13 Feb 2026 20:28:34 -0800 (PST) Received: from apollo.purestorage.com ([208.88.152.253]) by smtp.googlemail.com with ESMTPSA id a92af1059eb24-12742cbc900sm1021042c88.14.2026.02.13.20.28.33 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Feb 2026 20:28:33 -0800 (PST) From: Mohamed Khalfella To: Justin Tee , Naresh Gottumukkala , Paul Ely , Chaitanya Kulkarni , Christoph Hellwig , Jens Axboe , Keith Busch , Sagi Grimberg , James Smart , Hannes Reinecke Cc: Aaron Dailey , Randy Jennings , Dhaval Giani , linux-nvme@lists.infradead.org, linux-kernel@vger.kernel.org, Mohamed Khalfella Subject: [PATCH v3 16/21] nvmet: Add support for CQT to nvme target Date: Fri, 13 Feb 2026 20:25:17 -0800 Message-ID: <20260214042753.4073668-17-mkhalfella@purestorage.com> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260214042753.4073668-1-mkhalfella@purestorage.com> References: <20260214042753.4073668-1-mkhalfella@purestorage.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" TP4129 KATO Corrections and Clarifications defined CQT (Command Quiesce Time) which is used along with KATO (Keep Alive Timeout) to set an upper time limit for attempting Cross-Controller Recovery. CQT is added as a subsystem attribute that defaults to 0 to maintain the current behavior. Signed-off-by: Mohamed Khalfella --- drivers/nvme/target/admin-cmd.c | 1 + drivers/nvme/target/configfs.c | 31 +++++++++++++++++++++++++++++++ drivers/nvme/target/core.c | 3 +++ drivers/nvme/target/nvmet.h | 2 ++ include/linux/nvme.h | 5 ++++- 5 files changed, 41 insertions(+), 1 deletion(-) diff --git a/drivers/nvme/target/admin-cmd.c b/drivers/nvme/target/admin-cm= d.c index 925a81979278..5077a9ddba44 100644 --- a/drivers/nvme/target/admin-cmd.c +++ b/drivers/nvme/target/admin-cmd.c @@ -743,6 +743,7 @@ static void nvmet_execute_identify_ctrl(struct nvmet_re= q *req) id->cntlid =3D cpu_to_le16(ctrl->cntlid); id->ver =3D cpu_to_le32(ctrl->subsys->ver); if (!nvmet_is_disc_subsys(ctrl->subsys)) { + id->cqt =3D cpu_to_le16(ctrl->cqt); id->ciu =3D ctrl->ciu; id->cirn =3D cpu_to_le64(ctrl->cirn); id->ccrl =3D NVMF_CCR_LIMIT; diff --git a/drivers/nvme/target/configfs.c b/drivers/nvme/target/configfs.c index 127dae51fec1..c9b7a2eeeee5 100644 --- a/drivers/nvme/target/configfs.c +++ b/drivers/nvme/target/configfs.c @@ -1637,6 +1637,36 @@ static ssize_t nvmet_subsys_attr_pi_enable_store(str= uct config_item *item, CONFIGFS_ATTR(nvmet_subsys_, attr_pi_enable); #endif =20 +static ssize_t nvmet_subsys_attr_cqt_show(struct config_item *item, + char *page) +{ + return snprintf(page, PAGE_SIZE, "%u\n", to_subsys(item)->cqt); +} + +static ssize_t nvmet_subsys_attr_cqt_store(struct config_item *item, + const char *page, size_t cnt) +{ + struct nvmet_subsys *subsys =3D to_subsys(item); + struct nvmet_ctrl *ctrl; + u16 cqt; + + if (sscanf(page, "%hu\n", &cqt) !=3D 1) + return -EINVAL; + + down_write(&nvmet_config_sem); + if (subsys->cqt =3D=3D cqt) + goto out; + + subsys->cqt =3D cqt; + /* Force reconnect */ + list_for_each_entry(ctrl, &subsys->ctrls, subsys_entry) + ctrl->ops->delete_ctrl(ctrl); +out: + up_write(&nvmet_config_sem); + return cnt; +} +CONFIGFS_ATTR(nvmet_subsys_, attr_cqt); + static ssize_t nvmet_subsys_attr_qid_max_show(struct config_item *item, char *page) { @@ -1677,6 +1707,7 @@ static struct configfs_attribute *nvmet_subsys_attrs[= ] =3D { &nvmet_subsys_attr_attr_vendor_id, &nvmet_subsys_attr_attr_subsys_vendor_id, &nvmet_subsys_attr_attr_model, + &nvmet_subsys_attr_attr_cqt, &nvmet_subsys_attr_attr_qid_max, &nvmet_subsys_attr_attr_ieee_oui, &nvmet_subsys_attr_attr_firmware, diff --git a/drivers/nvme/target/core.c b/drivers/nvme/target/core.c index a9f8a2242703..886083bb7a83 100644 --- a/drivers/nvme/target/core.c +++ b/drivers/nvme/target/core.c @@ -1718,6 +1718,7 @@ struct nvmet_ctrl *nvmet_alloc_ctrl(struct nvmet_allo= c_ctrl_args *args) ctrl->cntlid =3D ret; =20 if (!nvmet_is_disc_subsys(ctrl->subsys)) { + ctrl->cqt =3D subsys->cqt; ctrl->ciu =3D get_random_u8() ? : 1; ctrl->cirn =3D get_random_u64(); } @@ -1958,10 +1959,12 @@ struct nvmet_subsys *nvmet_subsys_alloc(const char = *subsysnqn, =20 switch (type) { case NVME_NQN_NVME: + subsys->cqt =3D NVMF_CQT_MS; subsys->max_qid =3D NVMET_NR_QUEUES; break; case NVME_NQN_DISC: case NVME_NQN_CURR: + subsys->cqt =3D 0; subsys->max_qid =3D 0; break; default: diff --git a/drivers/nvme/target/nvmet.h b/drivers/nvme/target/nvmet.h index 0ed41a3d0562..00528feeb3cd 100644 --- a/drivers/nvme/target/nvmet.h +++ b/drivers/nvme/target/nvmet.h @@ -265,6 +265,7 @@ struct nvmet_ctrl { =20 uuid_t hostid; u16 cntlid; + u16 cqt; u8 ciu; u32 kato; u64 cirn; @@ -342,6 +343,7 @@ struct nvmet_subsys { #ifdef CONFIG_NVME_TARGET_DEBUGFS struct dentry *debugfs_dir; #endif + u16 cqt; u16 max_qid; =20 u64 ver; diff --git a/include/linux/nvme.h b/include/linux/nvme.h index fc33ae48d149..f6d66dadc5b1 100644 --- a/include/linux/nvme.h +++ b/include/linux/nvme.h @@ -21,6 +21,7 @@ #define NVMF_TRADDR_SIZE 256 #define NVMF_TSAS_SIZE 256 =20 +#define NVMF_CQT_MS 0 #define NVMF_CCR_LIMIT 4 #define NVMF_CCR_PER_PAGE 511 =20 @@ -368,7 +369,9 @@ struct nvme_id_ctrl { __u8 anacap; __le32 anagrpmax; __le32 nanagrpid; - __u8 rsvd352[160]; + __u8 rsvd352[34]; + __le16 cqt; + __u8 rsvd388[124]; __u8 sqes; __u8 cqes; __le16 maxcmd; --=20 2.52.0 From nobody Thu Apr 2 22:28:59 2026 Received: from mail-dy1-f182.google.com (mail-dy1-f182.google.com [74.125.82.182]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 15BA37404E for ; Sat, 14 Feb 2026 04:28:35 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.182 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043320; cv=none; b=oRruJMfln9R6PvKrIIdtt6LyLs2ytyndFf1Acg2pFqMfPGc6Ll1hEyXm0DJ3VynkfYI7ZjLwC/x6YuFJUmrPCgtzfGo1oqSkxy38KxmwDVwcuaehses631eFI/fBQefKRad0K48soAyME0zmHETqrKVqfOI8CS+OxNOImLymP6w= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043320; c=relaxed/simple; bh=HtHr6JewgH5QgRGWBcJc8AhgYfwYel9RsTrenRXrXeM=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=LONbSb2qa81C+zQT8iNON4DmxpM/HzZsa7/CeASVrGbFpIy/a3jvmdiu4kG9P+2TDcNmJppKs4GgV3g5gggFPOOBw7aWRwys7VU1e2mWO2PuhTVcGbbLlBJtZKPUDLWcP4NYL/CSJvFFLduLclXha0JholR5L6sIGkitlpafKBY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com; spf=fail smtp.mailfrom=purestorage.com; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b=BSj3/2jv; arc=none smtp.client-ip=74.125.82.182 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=purestorage.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b="BSj3/2jv" Received: by mail-dy1-f182.google.com with SMTP id 5a478bee46e88-2b82c605dbdso3189512eec.0 for ; Fri, 13 Feb 2026 20:28:35 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=purestorage.com; s=google2022; t=1771043315; x=1771648115; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=oVheserzpS3TkYHKpvBl78HcBp8VYTBPF64haSBCcyY=; b=BSj3/2jvBQgg7iSrjuUe+JQAi1VK3Gc5hfaFcKvYZT+jWBSLePDzo+ITXiYRUa7IRZ d/Rl4PgzxfAym4imG3jMXkYlpTzlMFqh67XfrMTrp7fd6O1l4BWdBS20AQDgTfW9YjZc UzMsqTXHDIa0dp6Mz0OM7nhUkMtfVQWezUluOc2TXcaLAnHPxbIQcMzSr0ez1BxP1XFk HgO5/jyBPyfgNFdCpKewT+3EC9ae8zDAMX3guV0D8q2GjhCPTSzSxUIbIgP5V2Ign/bT SjBZcgsdkxIUXZucEgfXshVR92LBbh/vuZeHOaCvn4BrAYAASKfFdYBfKvsKknI/vHq2 vIqA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1771043315; x=1771648115; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=oVheserzpS3TkYHKpvBl78HcBp8VYTBPF64haSBCcyY=; b=BNspQzWJMsKLevd4qKEuS/O14bymBt3m2frFbggTmKLDd4N4L0/jt6k1yvd9q/nRMS k++ZIfXWy3swoBzSLrqAZcsq5Le2W+lIqyoh9j+zE/W7rOQ/q63HsxMvHQ9qOr4YNTsm lbP3aVhtgVh35bd/qkq3SyyfRSWE/r9dK3aVsXpSW1WZHwXl+bm8qjMP40i/lILX+yoK lY56sGik2nVPxr2PIF+D3jZHDjdXHOtCRhdvBg8r31MH99dkApLwJt/iFcGwKgPx3XU3 4mS4u+meXyqAVEBnv7VmMOqPnu4DJKct4QTgkaqp0phRMqLXDtABuO5CKtkYJZdI9HG+ +sGw== X-Forwarded-Encrypted: i=1; AJvYcCUWkDaVrWp0PCvDPUuGe6XXGfpZNq9ja1umD2EM/thxGY3z3qVeM6dw6apLGuH9JX4giqL0XRn/enA7I+8=@vger.kernel.org X-Gm-Message-State: AOJu0Yw3mzUyFgWHnRVLqxnNcbuMz+3BHSD7TmKZQlWB61UvjMO1xIuF ZfNNSyv0S62NSzwrxOOsskG44d/fZsay6GwDdd6KqRLTqNd2NpBCCg5gU9cTzoL1fnI= X-Gm-Gg: AZuq6aLWj9sVl++ybAAdOAPS7Vn/xRQvM2mSRn4rvImUh0j52AlpUUHUIZ9xpkcMTEb tu3/5FeA12deXkLjRopQ/Js715hiNSYU25Vq6LKKYIUA/3DQZk058uH2mZXT7Db3S5J5/47uKgC B58Z8rP0J8d6bgv9xWlKoh8Pk5yuKIwIB6Z/meJuOVh/gm0njnfnWSf2hnBr8AI7rQpGCETLXkH Da9K6L8WPButc9OwLqHefzAunX8AOmMbzNv3NujuD+1K+PTlq7c9nxnia/59sC8CahrTY1CWSok btX/3XpVoZc7LBQe3vYcdqkUswRH7Ts3MBBp8tja5hcsV7DKHRHPbvVpkhkICjb5OLM/IWJz0Gl EKGnini853k4NmSeeYbvfl/JyKeSizOtI+WsH020NF/v09yb44SluElzltSqM9v+DmZXxxrribI pb2eezXqro4LYq7/0fMOL4ijsfUt9Q9oRiIiWq4Xzv79eu5g== X-Received: by 2002:a05:7022:b93:b0:11d:f682:e475 with SMTP id a92af1059eb24-1273aea73d4mr1856668c88.40.1771043314988; Fri, 13 Feb 2026 20:28:34 -0800 (PST) Received: from apollo.purestorage.com ([208.88.152.253]) by smtp.googlemail.com with ESMTPSA id a92af1059eb24-12742cbc900sm1021042c88.14.2026.02.13.20.28.34 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Feb 2026 20:28:34 -0800 (PST) From: Mohamed Khalfella To: Justin Tee , Naresh Gottumukkala , Paul Ely , Chaitanya Kulkarni , Christoph Hellwig , Jens Axboe , Keith Busch , Sagi Grimberg , James Smart , Hannes Reinecke Cc: Aaron Dailey , Randy Jennings , Dhaval Giani , linux-nvme@lists.infradead.org, linux-kernel@vger.kernel.org, Mohamed Khalfella Subject: [PATCH v3 17/21] nvme: Add support for CQT to nvme host Date: Fri, 13 Feb 2026 20:25:18 -0800 Message-ID: <20260214042753.4073668-18-mkhalfella@purestorage.com> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260214042753.4073668-1-mkhalfella@purestorage.com> References: <20260214042753.4073668-1-mkhalfella@purestorage.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" TP4129 KATO Corrections and Clarifications defined CQT (Command Quiesce Time) which is used along with KATO (Keep Alive Timeout) to set an upper limit for attempting Cross-Controller Recovery. Add ctrl->cqt and read its value from controller identify response. Update fence timeout to consider ctrl->cqt. Signed-off-by: Mohamed Khalfella --- drivers/nvme/host/core.c | 1 + drivers/nvme/host/nvme.h | 5 +++-- drivers/nvme/host/sysfs.c | 2 ++ 3 files changed, 6 insertions(+), 2 deletions(-) diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c index a9fcde1b411b..0680d05900c1 100644 --- a/drivers/nvme/host/core.c +++ b/drivers/nvme/host/core.c @@ -3739,6 +3739,7 @@ static int nvme_init_identify(struct nvme_ctrl *ctrl) ctrl->ciu =3D id->ciu; ctrl->cirn =3D le64_to_cpu(id->cirn); atomic_set(&ctrl->ccr_limit, id->ccrl); + ctrl->cqt =3D le16_to_cpu(id->cqt); =20 ctrl->oacs =3D le16_to_cpu(id->oacs); ctrl->oncs =3D le16_to_cpu(id->oncs); diff --git a/drivers/nvme/host/nvme.h b/drivers/nvme/host/nvme.h index af6a4e83053e..a7f382e35821 100644 --- a/drivers/nvme/host/nvme.h +++ b/drivers/nvme/host/nvme.h @@ -336,6 +336,7 @@ struct nvme_ctrl { u32 max_zone_append; #endif u16 crdt[3]; + u16 cqt; u16 oncs; u8 dmrl; u8 ciu; @@ -1245,8 +1246,8 @@ static inline bool nvme_multi_css(struct nvme_ctrl *c= trl) static inline unsigned long nvme_fence_timeout_ms(struct nvme_ctrl *ctrl) { if (ctrl->ctratt & NVME_CTRL_ATTR_TBKAS) - return 3 * ctrl->kato * 1000; - return 2 * ctrl->kato * 1000; + return 3 * ctrl->kato * 1000 + ctrl->cqt; + return 2 * ctrl->kato * 1000 + ctrl->cqt; } =20 #endif /* _NVME_H */ diff --git a/drivers/nvme/host/sysfs.c b/drivers/nvme/host/sysfs.c index 1e4261144933..0234e11730bb 100644 --- a/drivers/nvme/host/sysfs.c +++ b/drivers/nvme/host/sysfs.c @@ -387,6 +387,7 @@ nvme_show_int_function(numa_node); nvme_show_int_function(queue_count); nvme_show_int_function(sqsize); nvme_show_int_function(kato); +nvme_show_int_function(cqt); =20 static ssize_t nvme_sysfs_ciu_show(struct device *dev, struct device_attribute *attr, @@ -759,6 +760,7 @@ static struct attribute *nvme_dev_attrs[] =3D { &dev_attr_sqsize.attr, &dev_attr_ciu.attr, &dev_attr_cirn.attr, + &dev_attr_cqt.attr, &dev_attr_hostnqn.attr, &dev_attr_hostid.attr, &dev_attr_ctrl_loss_tmo.attr, --=20 2.52.0 From nobody Thu Apr 2 22:28:59 2026 Received: from mail-dl1-f54.google.com (mail-dl1-f54.google.com [74.125.82.54]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 7C9252BF006 for ; Sat, 14 Feb 2026 04:28:38 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.54 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043327; cv=none; b=UT/xoZ6KmNs0CazInA5PhDM/9Y741e1aqEtFoPka6m4I+lu9KOw8ZLPS+3H70u0Hsu1Z9TvfdMWjqw7qxqPWZyDn2NxBKQwHnYry2LbJBbeo/zEV8ZdnYF2x5YyrL+PTXwK3rIM1JimbkrjtTum9fNS7+gQl+jMPCtiY6/a+3pM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043327; c=relaxed/simple; bh=EOwrQrtPcAy4jDPFHyG9KNm/GPE7Fp++z4SJI2Vx0j4=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=iFKvwRpdOCe6dVJUFvpoApQxb9N8Ph7s+gl2qD5DN35Vk6hgvaStDaqQLo8XT3q6U9wjJQYiiQdP5i5JoAze+kMCV3jyurX6qXzXGa7n6AzbIfwWGGSYDlJB5/RMnwNJzI0YgUYQN1YAAjPR+2dkNPR7pyePLvfj7Ei1cfuaDTQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com; spf=fail smtp.mailfrom=purestorage.com; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b=Q1Iu+/4O; arc=none smtp.client-ip=74.125.82.54 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=purestorage.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b="Q1Iu+/4O" Received: by mail-dl1-f54.google.com with SMTP id a92af1059eb24-12721cd256bso2118884c88.1 for ; Fri, 13 Feb 2026 20:28:38 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=purestorage.com; s=google2022; t=1771043316; x=1771648116; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=G5ZA7/tV4zDqNdP5WkUsqXWJkCvvpgg6msvp7dtPWuI=; b=Q1Iu+/4OYVyoCZnXk1WIwRaKUwsmeRnyk6+brb3Q7yFKGfqpcdr/Xxe3GauytfghbF yqwJYRyFPcRqoxkBRb8aY7ouiYheFcg4/hoOjLruKHKF96LiuGNkRbyCm+susjMKZI8X 6FwJ4x0SP+yu8HXX4EO0fq/z6UTXYbCw3aYGBgxIit1iUE2K1fGT1s1Vvlqyyb58saFO 0DU8B2wLbsen7x7/VgKOuzhOk98RrJ6XKO5tKNRGKL4v+qWzEVdqnW5SOswfoq9mjmM8 9oddz38UD12oqyT94upbluwMhi1dSHQepENKxjTSieWMsbjNGhr0ZX4W/GGXwkSAtPnY NWIw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1771043316; x=1771648116; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=G5ZA7/tV4zDqNdP5WkUsqXWJkCvvpgg6msvp7dtPWuI=; b=Gbs5bS0p19CGoMf3BLfIpBtS2O4dEGYzd1I7XLxlW6FQ0ZCIndDM8uq0mkf0JTrteu V9GD9hjHoRcm7iW5TPh7Ra8QT/hwPMW2vqQgtcUFxw0WoMEHw/YXK4Jwe/QFOe6kWGMB 0E1tDRtW2AboNgxtvMasmTwHR8lKCoCXNFV4HWY8mbHUIt/qE5+MSo6wsUkH9zsZHF7w krN9ns2d5SV6sE2veJda4jmkQJ7S79SebhGzVG1fEHF4UVmF4zrwgCkY/OHdNLABHNNe LIVxfRFjwFqAoNONvtRoLknoLLgOQsuo66/2I10ms3holZp1d1WrWxFJL5QqYgs+obqi 5TAg== X-Forwarded-Encrypted: i=1; AJvYcCVHiU/n8dxxNbHDjZ2SnctwGVHi5cpdmt77llduHjMZq85A5Oc2IpP73qOwoiXx/Tf0WpHZaR1A8QxMUBw=@vger.kernel.org X-Gm-Message-State: AOJu0YwLmF2Eb/0biFYUJ+8ZtEn2G2NYJLWemk7s/VpQWAeEUDTXRNW2 vpIp5zbtnQrMl+WYojYw3FO7QzFsOiNuqQkoTQ/FVJW1q8WXwjUVywpvClMz1ASjZBU= X-Gm-Gg: AZuq6aIYEuCTQ1h+aGLelWUeEklVh4gQLYhFZMesf8g0eSLk/ij13Stk+HE1wnpc4U9 BA/VY0yM53kcsrcqV7r8rDAIWGqyeIXkPpdP0A0R1CpFQRPhvx7sZzf5yfRUudpfACqmzDOdpav DXB3dPQb3N9vrDiRgI2cSBL8DwLWIRZfh47pruhMj7x6e6JsaGDoDoI6S7oeD9YCJ1uQykArnR2 o9luDlyeHx8Gc2Vq23Xcr+2DrhY1XGJ0lEzOCeMfn6vIH739uvo1yqHsVUdXJC6CA0ORbyA7GZK Y3qluI1wFM8JY87YZZM+Gbq6SJSHs+lwe/aBITCBGkjsRLub0OWFyif3wlze4wEyGlEEk/1Mrmr nt3V8kEvxZuBSUb4c7To+DnOr28InG6EzuKT5aB7iCEvgm3D3tmlDQCGyLhFQ2Xru7b6YUOMifG 3O8qkJa+IQMcNYTxMfPiOC1XXM5sPmbQ+FkO5hnsPBoKAPoA== X-Received: by 2002:a05:7022:662c:b0:11a:4ffb:9849 with SMTP id a92af1059eb24-12741b925d5mr742340c88.21.1771043315759; Fri, 13 Feb 2026 20:28:35 -0800 (PST) Received: from apollo.purestorage.com ([208.88.152.253]) by smtp.googlemail.com with ESMTPSA id a92af1059eb24-12742cbc900sm1021042c88.14.2026.02.13.20.28.35 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Feb 2026 20:28:35 -0800 (PST) From: Mohamed Khalfella To: Justin Tee , Naresh Gottumukkala , Paul Ely , Chaitanya Kulkarni , Christoph Hellwig , Jens Axboe , Keith Busch , Sagi Grimberg , James Smart , Hannes Reinecke Cc: Aaron Dailey , Randy Jennings , Dhaval Giani , linux-nvme@lists.infradead.org, linux-kernel@vger.kernel.org, Mohamed Khalfella Subject: [PATCH v3 18/21] nvme: Update CCR completion wait timeout to consider CQT Date: Fri, 13 Feb 2026 20:25:19 -0800 Message-ID: <20260214042753.4073668-19-mkhalfella@purestorage.com> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260214042753.4073668-1-mkhalfella@purestorage.com> References: <20260214042753.4073668-1-mkhalfella@purestorage.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" TP8028 Rapid Path Failure Recovery does not define how much time the host should wait for CCR operation to complete. It is reasonable to assume that CCR operation can take up to ctrl->cqt. Update wait time for CCR operation to be max(ctrl->cqt, ctrl->kato). Signed-off-by: Mohamed Khalfella --- drivers/nvme/host/core.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c index 0680d05900c1..ff479c0263ab 100644 --- a/drivers/nvme/host/core.c +++ b/drivers/nvme/host/core.c @@ -631,7 +631,7 @@ static int nvme_issue_wait_ccr(struct nvme_ctrl *sctrl,= struct nvme_ctrl *ictrl) if (result & 0x01) /* Immediate Reset Successful */ goto out; =20 - tmo =3D secs_to_jiffies(ictrl->kato); + tmo =3D msecs_to_jiffies(max(ictrl->cqt, ictrl->kato * 1000)); if (!wait_for_completion_timeout(&ccr.complete, tmo)) { ret =3D -ETIMEDOUT; goto out; --=20 2.52.0 From nobody Thu Apr 2 22:28:59 2026 Received: from mail-dl1-f45.google.com (mail-dl1-f45.google.com [74.125.82.45]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 8BD402DF134 for ; Sat, 14 Feb 2026 04:28:39 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.45 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043327; cv=none; b=utkW/YPRdEpFjT0CiXKloQCXpMLQgNV00u07yw+EgKLKOLkTX2zXcZ8zCSvvbtJXx4vu3eOGinWK0zvJ5LGZZyxiKq+S7u5oIc6vs8XMB//3n9CuzDsOoK/QOftG3mmH4fQ9Qmd8ivmrvuZm7UQ90ZNkMxmI2SbCk6pj4Z/y0zs= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043327; c=relaxed/simple; bh=I4AHBz96V+/FJikfTVqG2RFrtWnWfdWD2EWoX0HE45U=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=qIzRxc3AqeTzxEQZ32Ct/TCLXt6heoGYMrAf0e0CpVElUnUvAblLUKIzRfcNK2RbfUz2zY9oAHeiGiiReL2AOwJmcC65jUfy9vH3lhZ6tmCiCFZQzO/KWwwLsYYRfBm9144k8PobGiHdLC6N1zPX7G1FD21x01EAsq9CSfoPPqc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com; spf=fail smtp.mailfrom=purestorage.com; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b=COPBffal; arc=none smtp.client-ip=74.125.82.45 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=purestorage.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b="COPBffal" Received: by mail-dl1-f45.google.com with SMTP id a92af1059eb24-127380532eeso4212991c88.1 for ; Fri, 13 Feb 2026 20:28:39 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=purestorage.com; s=google2022; t=1771043317; x=1771648117; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=vmQB6UPDuJJWXHBdsmsQAxC67O4gJkvSY/l87y/lKo8=; b=COPBffalkdHYiOKxQ7QAbcSngURXYrcYPDDHPcZGPIQaR9Rw2RUs0ZlwtQ6xe95JxS 9mJjZqnSfpgSAOYsREl48hzFVgy+DHk21vnwwMhv0b8axriu74cpD1ApSTXlNCWlECwz H5DmREcBQLPRwoByY8C35QSbwHC/QlsvPeanQMWqwHWYByfUdVIZWUHnsNarQ41FWrZf /950uwM2hLEV/LWTS2SaSOK71/jCGjPegpNnqu8c7PHcwkYrweSiEpS7Cq22zFxXEHY4 6c9zNvskG0887Q8p1oy+HCIQ9dP1LXc4xggwheWlG41BWlwxcNeU1P3cuPheRaKC00cF ecsQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1771043317; x=1771648117; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=vmQB6UPDuJJWXHBdsmsQAxC67O4gJkvSY/l87y/lKo8=; b=obC1zbNcY/t4w439PzK8jTHnsWy+KWe3aClWOON+vFmPd4RXVdieYichmuwY72Mlai J475QGzeXwVExTV/mxh0Lx8aFAdl3Z4QTTrRAk8iccG+Rk78rkoTUupyjXZiQV74yn2r vd3qIc9WY/axwvInZjdhduWO0zlkDKQYJ6jdYEV22Q8pYRYXTfHobCQI+ncF7AkeZPyE BUwEVi/UAroQgqRr5DBlDOipu4fqcSTT9DEdxJJZOlGHhSld+jUYCBG8WeIT1sAWcDzH GS/XKrBgg+O2A8zoZpu/uq4IDw04fXd2ZVj9XG7ZRW3futc6ip8kJr0DdByEfw35tYx8 uuhA== X-Forwarded-Encrypted: i=1; AJvYcCVt9Y76LCQFpFNTaiBV9rn5gLdBQjw7ykNor5lW7doYgEb6u5q9F8xMLL242gnhQgdTvL8Bm8CgsNCKwgQ=@vger.kernel.org X-Gm-Message-State: AOJu0YzkmAmvqT7C575Wttv7+ByJC963u/5o0STulP92wL/k9Gg+4D1g aOdA7iKrHsN/QpjujRCjterdFJBprVYg+OO9yZX9/ndiIzCB5Z6Pzxrv1UgyLeBkzcY= X-Gm-Gg: AZuq6aIzko3s1rlYPXZoWC/mCp+ROaZpLrFGjyIrJGFhfuROqGy1P8vz63POUZ9rjyx 86cIeDintAbYGU8E28JhALvk4tKP7Gf8eZCvjCJqxFZATLRuLdl/W8B/tcEKVDj5M7vsH1rhFIT lI/vqexkp4TxIaSU+DWb8X5u2LKz0KKUHC5tSK11xmxiWVIJ+qvOtacu7SFV8fmJ2dWrvnlI9j/ 9ITV38EU2rLLG8+uJylLBKFHa0fZwTQitV0trP+Zt0vX+80dJ2710Tz/GBqRDx3KYip3kNTN+JG MFz87csGREqSKSFDqDwmHL65xPyEtAnKGSEMtbtgqngCPDtboCaw3eVxGnrf9yExXtadaaYqSji SslViz9b+v5VuqFVB4Blq/Q37gnG7aE4SygpeZjlfrmpaYPtbxkpZDjs6quA2cOIgj4z+xo09ds aHN9ZVVPsXlY/dibEcMXOU2n8aYekaOU+WNlwPjhucp7rKHg== X-Received: by 2002:a05:7022:2506:b0:11b:bf3f:5240 with SMTP id a92af1059eb24-1273adf2adcmr1795450c88.9.1771043316554; Fri, 13 Feb 2026 20:28:36 -0800 (PST) Received: from apollo.purestorage.com ([208.88.152.253]) by smtp.googlemail.com with ESMTPSA id a92af1059eb24-12742cbc900sm1021042c88.14.2026.02.13.20.28.35 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Feb 2026 20:28:36 -0800 (PST) From: Mohamed Khalfella To: Justin Tee , Naresh Gottumukkala , Paul Ely , Chaitanya Kulkarni , Christoph Hellwig , Jens Axboe , Keith Busch , Sagi Grimberg , James Smart , Hannes Reinecke Cc: Aaron Dailey , Randy Jennings , Dhaval Giani , linux-nvme@lists.infradead.org, linux-kernel@vger.kernel.org, Mohamed Khalfella Subject: [PATCH v3 19/21] nvme-tcp: Extend FENCING state per TP4129 on CCR failure Date: Fri, 13 Feb 2026 20:25:20 -0800 Message-ID: <20260214042753.4073668-20-mkhalfella@purestorage.com> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260214042753.4073668-1-mkhalfella@purestorage.com> References: <20260214042753.4073668-1-mkhalfella@purestorage.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" If CCR operations fail and CQT is supported, we must defer the retry of inflight requests per TP4129. Update ctrl->fencing_work to schedule ctrl->fenced_work, effectively extending the FENCING state. This delay ensures that inflight requests are held until it is safe for them to be retired. Signed-off-by: Mohamed Khalfella --- drivers/nvme/host/tcp.c | 39 +++++++++++++++++++++++++++++++++++---- 1 file changed, 35 insertions(+), 4 deletions(-) diff --git a/drivers/nvme/host/tcp.c b/drivers/nvme/host/tcp.c index 229cfdffd848..054e8a350d75 100644 --- a/drivers/nvme/host/tcp.c +++ b/drivers/nvme/host/tcp.c @@ -194,6 +194,7 @@ struct nvme_tcp_ctrl { struct nvme_ctrl ctrl; =20 struct work_struct fencing_work; + struct delayed_work fenced_work; struct work_struct err_work; struct delayed_work connect_work; struct nvme_tcp_request async_req; @@ -2477,6 +2478,18 @@ static void nvme_tcp_reconnect_ctrl_work(struct work= _struct *work) nvme_tcp_reconnect_or_remove(ctrl, ret); } =20 +static void nvme_tcp_fenced_work(struct work_struct *work) +{ + struct nvme_tcp_ctrl *tcp_ctrl =3D container_of(to_delayed_work(work), + struct nvme_tcp_ctrl, fenced_work); + struct nvme_ctrl *ctrl =3D &tcp_ctrl->ctrl; + + dev_info(ctrl->device, "Time-based recovery finished\n"); + nvme_change_ctrl_state(ctrl, NVME_CTRL_FENCED); + if (nvme_change_ctrl_state(ctrl, NVME_CTRL_RESETTING)) + queue_work(nvme_reset_wq, &tcp_ctrl->err_work); +} + static void nvme_tcp_fencing_work(struct work_struct *work) { struct nvme_tcp_ctrl *tcp_ctrl =3D container_of(work, @@ -2485,23 +2498,40 @@ static void nvme_tcp_fencing_work(struct work_struc= t *work) unsigned long rem; =20 rem =3D nvme_fence_ctrl(ctrl); - if (rem) { + if (!rem) + goto done; + + if (!ctrl->cqt) { dev_info(ctrl->device, - "CCR failed, skipping time-based recovery\n"); + "CCR failed, CQT not supported, skip time-based recovery\n"); + goto done; } =20 + dev_info(ctrl->device, + "CCR failed, switch to time-based recovery, timeout =3D %ums\n", + jiffies_to_msecs(rem)); + queue_delayed_work(nvme_wq, &tcp_ctrl->fenced_work, rem); + return; + +done: nvme_change_ctrl_state(ctrl, NVME_CTRL_FENCED); if (nvme_change_ctrl_state(ctrl, NVME_CTRL_RESETTING)) queue_work(nvme_reset_wq, &tcp_ctrl->err_work); } =20 +static void nvme_tcp_flush_fencing_works(struct nvme_ctrl *ctrl) +{ + flush_work(&to_tcp_ctrl(ctrl)->fencing_work); + flush_delayed_work(&to_tcp_ctrl(ctrl)->fenced_work); +} + static void nvme_tcp_error_recovery_work(struct work_struct *work) { struct nvme_tcp_ctrl *tcp_ctrl =3D container_of(work, struct nvme_tcp_ctrl, err_work); struct nvme_ctrl *ctrl =3D &tcp_ctrl->ctrl; =20 - flush_work(&to_tcp_ctrl(ctrl)->fencing_work); + nvme_tcp_flush_fencing_works(ctrl); if (nvme_tcp_key_revoke_needed(ctrl)) nvme_auth_revoke_tls_key(ctrl); nvme_stop_keep_alive(ctrl); @@ -2544,7 +2574,7 @@ static void nvme_reset_ctrl_work(struct work_struct *= work) container_of(work, struct nvme_ctrl, reset_work); int ret; =20 - flush_work(&to_tcp_ctrl(ctrl)->fencing_work); + nvme_tcp_flush_fencing_works(ctrl); if (nvme_tcp_key_revoke_needed(ctrl)) nvme_auth_revoke_tls_key(ctrl); nvme_stop_ctrl(ctrl); @@ -2934,6 +2964,7 @@ static struct nvme_tcp_ctrl *nvme_tcp_alloc_ctrl(stru= ct device *dev, INIT_DELAYED_WORK(&ctrl->connect_work, nvme_tcp_reconnect_ctrl_work); INIT_WORK(&ctrl->fencing_work, nvme_tcp_fencing_work); + INIT_DELAYED_WORK(&ctrl->fenced_work, nvme_tcp_fenced_work); INIT_WORK(&ctrl->err_work, nvme_tcp_error_recovery_work); INIT_WORK(&ctrl->ctrl.reset_work, nvme_reset_ctrl_work); =20 --=20 2.52.0 From nobody Thu Apr 2 22:28:59 2026 Received: from mail-dl1-f47.google.com (mail-dl1-f47.google.com [74.125.82.47]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 7171F2E719C for ; Sat, 14 Feb 2026 04:28:38 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.47 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043327; cv=none; b=CaeuaFyLfM8W5n+lKuN6/dWh8GHzjGCYUEuNqSx85hILIy4YGptsLPxtv8xWkXeqyTDCqgnu4RvKOKqCMXajKCWCLT0/8yK9LGLPAcSnzHiRNU8oecjuL+dOxJOeMamgBhSCecuU1aM/9YRVsmWTiITIRbBR8PSPR2V5Vyx1phI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043327; c=relaxed/simple; bh=KMYzIlB9TeyHaa/kPYwm2oQAzVvcnTKFz1aAtoHyI+Y=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Z644hhjCdqxhDG01kWjp3QaWXuubOuYxJUQjFOFcvT4dPqYhb5D5H+99T02vF8WSlCedqb3k0z8ksbL8OzBYPhhub1H5eigrhYPk8Rb991C5lBqU6FKw7s69NSQRMzIreyFsadcRMDGk/fH11H2L2DHb1KDagKeqRWu9u3R5c+Y= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com; spf=fail smtp.mailfrom=purestorage.com; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b=WFG3w7kT; arc=none smtp.client-ip=74.125.82.47 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=purestorage.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b="WFG3w7kT" Received: by mail-dl1-f47.google.com with SMTP id a92af1059eb24-1270be4d125so3698429c88.1 for ; Fri, 13 Feb 2026 20:28:38 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=purestorage.com; s=google2022; t=1771043318; x=1771648118; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=AyBlaNKrUhJxF0JOHaXwDus/gth9nfmpIZXXREVAOz0=; b=WFG3w7kTCXvwtLWgavCJHXvtRqlIixHY1yqKU75ihVy3AyEJ6iojBaGZC3l0hVxqxZ VljZYYRkr7kkKtK92m88bamT6vloEBlFfWqHzcJZ3WnYYFA+WKsyWO12+POxci44D1BN b83PI0YkG1OSFRKwix+QYa0JammKI66WyVhSr8BCbE2VWmf9yEKuGeDoiXJYk+85NWwG BuLH443mbTk6wvI3axkxfi2Py6DEtpY3b5rGf9HEDrsQFwR2f5ghXzHZ7ny4yTgdvhrB Zg7MyhwBfzT5m2vUkSoyJFMMSSKuivLDX1bx576hZicnWubv2ENLCnB7hkhTGRY5Sj4Y LtYg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1771043318; x=1771648118; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=AyBlaNKrUhJxF0JOHaXwDus/gth9nfmpIZXXREVAOz0=; b=Vm/UOqK3qxzMbozOFu5B9rNHoacXnfSGJCaYNUN2TfKGHejqCy/oSUAmy2uIaDDZQR c7BoVycS3a2g+haUCy4FNUlPsG+0fs2rUbRYQlFpwi+/RcKDRpZhy6W0qXlOMmI9LBhZ Wko+XBKPLRZkKVwEO3aSARmFJugqY2q0Ow1pgh2Cy0znwYDPngiTrrvInqPFyah8b2JP 8y54ImTmrEbP/+0qd08isEw3h2s31/DgrHTNf/kI2aKRnyqZCGYM90a3kT6cUlXIb1BH BGyu+PHncF7QcT0PJ2b3ct9po1LYY5NScEgZBoWzSBK6IyV4KgzRHcoVKocbOs7S38fS bcCA== X-Forwarded-Encrypted: i=1; AJvYcCWm24qSQrwuEgu4lZqY6TSeY6ZkINSUjiDf36MwyKyzqIlEeEbuIr6ZfWUgO3kBDpvfJ0K7+cyk45zSEvg=@vger.kernel.org X-Gm-Message-State: AOJu0Yw2A26IGQbYugnfZwzu8yZFqtx59zQAtQ1ZfmK2YsmNtuH4qhVo eOKathJ8l2VFedey8B07caFU6BScJCvGIyg38XLbPr8q8iul3UGYlrA43RwY4/wQmG4= X-Gm-Gg: AZuq6aKbBBtBOPXWpTDO8LCZZ+pmvQnG9MuxbdnMfvKvGkZfZ9nw8gp/KL02Q7CI9MY B6f1Y+1+5hhYKcDGKVlWmCJDd/1JXNGE7W+DgOTEW1x/2yJTTedjbMMcoTofFv7owJTxFqkvEiC NyUZTO3uBsOetsiqe5suNxZdhE3VDQPHC7dJuwxWimAES70VwTWY7Ge+wYQJEU+b/l046mYZVUF 7kLflJG8oWKZuRGHWc/RJB008aKglQS3V0IdxPNvfkTjFEPzUjbnp822fGeFpZ+c4lsY6XWAVnu 8R0JrO1m+T9EQWDpBgDIOThVxunKOCt03BgsOwRt8AqDln2u2HMWJf1oJL0XPVpU9H+h8sqT9QG tleOhdDNcQRAJhWpgRpFeSJocJRb5PG3Px1evee7qSITpMAmH1jT6H3WWc/j1jU0O19newc7hea C8irwA1dKvtShaMPeWS5v2JDxY8qT5n7u+lGhAzXcbXh9DRA== X-Received: by 2002:a05:7022:45a8:b0:11d:c91e:3b58 with SMTP id a92af1059eb24-12741bd2c33mr759110c88.39.1771043317436; Fri, 13 Feb 2026 20:28:37 -0800 (PST) Received: from apollo.purestorage.com ([208.88.152.253]) by smtp.googlemail.com with ESMTPSA id a92af1059eb24-12742cbc900sm1021042c88.14.2026.02.13.20.28.36 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Feb 2026 20:28:37 -0800 (PST) From: Mohamed Khalfella To: Justin Tee , Naresh Gottumukkala , Paul Ely , Chaitanya Kulkarni , Christoph Hellwig , Jens Axboe , Keith Busch , Sagi Grimberg , James Smart , Hannes Reinecke Cc: Aaron Dailey , Randy Jennings , Dhaval Giani , linux-nvme@lists.infradead.org, linux-kernel@vger.kernel.org, Mohamed Khalfella Subject: [PATCH v3 20/21] nvme-rdma: Extend FENCING state per TP4129 on CCR failure Date: Fri, 13 Feb 2026 20:25:21 -0800 Message-ID: <20260214042753.4073668-21-mkhalfella@purestorage.com> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260214042753.4073668-1-mkhalfella@purestorage.com> References: <20260214042753.4073668-1-mkhalfella@purestorage.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" If CCR operations fail and CQT is supported, we must defer the retry of inflight requests per TP4129. Update ctrl->fencing_work to schedule ctrl->fenced_work, effectively extending the FENCING state. This delay ensures that inflight requests are held until it is safe for them to be retired. Signed-off-by: Mohamed Khalfella --- drivers/nvme/host/rdma.c | 39 +++++++++++++++++++++++++++++++++++---- 1 file changed, 35 insertions(+), 4 deletions(-) diff --git a/drivers/nvme/host/rdma.c b/drivers/nvme/host/rdma.c index 2fb47f41215f..4f48780c3b19 100644 --- a/drivers/nvme/host/rdma.c +++ b/drivers/nvme/host/rdma.c @@ -107,6 +107,7 @@ struct nvme_rdma_ctrl { /* other member variables */ struct blk_mq_tag_set tag_set; struct work_struct fencing_work; + struct delayed_work fenced_work; struct work_struct err_work; =20 struct nvme_rdma_qe async_event_sqe; @@ -1121,6 +1122,18 @@ static void nvme_rdma_reconnect_ctrl_work(struct wor= k_struct *work) nvme_rdma_reconnect_or_remove(ctrl, ret); } =20 +static void nvme_rdma_fenced_work(struct work_struct *work) +{ + struct nvme_rdma_ctrl *rdma_ctrl =3D container_of(to_delayed_work(work), + struct nvme_rdma_ctrl, fenced_work); + struct nvme_ctrl *ctrl =3D &rdma_ctrl->ctrl; + + dev_info(ctrl->device, "Time-based recovery finished\n"); + nvme_change_ctrl_state(ctrl, NVME_CTRL_FENCED); + if (nvme_change_ctrl_state(ctrl, NVME_CTRL_RESETTING)) + queue_work(nvme_reset_wq, &rdma_ctrl->err_work); +} + static void nvme_rdma_fencing_work(struct work_struct *work) { struct nvme_rdma_ctrl *rdma_ctrl =3D container_of(work, @@ -1129,22 +1142,39 @@ static void nvme_rdma_fencing_work(struct work_stru= ct *work) unsigned long rem; =20 rem =3D nvme_fence_ctrl(ctrl); - if (rem) { + if (!rem) + goto done; + + if (!ctrl->cqt) { dev_info(ctrl->device, - "CCR failed, skipping time-based recovery\n"); + "CCR failed, CQT not supported, skip time-based recovery\n"); + goto done; } =20 + dev_info(ctrl->device, + "CCR failed, switch to time-based recovery, timeout =3D %ums\n", + jiffies_to_msecs(rem)); + queue_delayed_work(nvme_wq, &rdma_ctrl->fenced_work, rem); + return; + +done: nvme_change_ctrl_state(ctrl, NVME_CTRL_FENCED); if (nvme_change_ctrl_state(ctrl, NVME_CTRL_RESETTING)) queue_work(nvme_reset_wq, &rdma_ctrl->err_work); } =20 +static void nvme_rdma_flush_fencing_works(struct nvme_rdma_ctrl *ctrl) +{ + flush_work(&ctrl->fencing_work); + flush_delayed_work(&ctrl->fenced_work); +} + static void nvme_rdma_error_recovery_work(struct work_struct *work) { struct nvme_rdma_ctrl *ctrl =3D container_of(work, struct nvme_rdma_ctrl, err_work); =20 - flush_work(&ctrl->fencing_work); + nvme_rdma_flush_fencing_works(ctrl); nvme_stop_keep_alive(&ctrl->ctrl); flush_work(&ctrl->ctrl.async_event_work); nvme_rdma_teardown_io_queues(ctrl, false); @@ -2197,7 +2227,7 @@ static void nvme_rdma_reset_ctrl_work(struct work_str= uct *work) container_of(work, struct nvme_rdma_ctrl, ctrl.reset_work); int ret; =20 - flush_work(&ctrl->fencing_work); + nvme_rdma_flush_fencing_works(ctrl); nvme_stop_ctrl(&ctrl->ctrl); nvme_rdma_shutdown_ctrl(ctrl, false); =20 @@ -2311,6 +2341,7 @@ static struct nvme_rdma_ctrl *nvme_rdma_alloc_ctrl(st= ruct device *dev, INIT_DELAYED_WORK(&ctrl->reconnect_work, nvme_rdma_reconnect_ctrl_work); INIT_WORK(&ctrl->fencing_work, nvme_rdma_fencing_work); + INIT_DELAYED_WORK(&ctrl->fenced_work, nvme_rdma_fenced_work); INIT_WORK(&ctrl->err_work, nvme_rdma_error_recovery_work); INIT_WORK(&ctrl->ctrl.reset_work, nvme_rdma_reset_ctrl_work); =20 --=20 2.52.0 From nobody Thu Apr 2 22:28:59 2026 Received: from mail-dl1-f53.google.com (mail-dl1-f53.google.com [74.125.82.53]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 73D782BEFF6 for ; Sat, 14 Feb 2026 04:28:39 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.53 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043327; cv=none; b=szZOmEIVhFVjvNqL/6f+seYCQAkuUN3zVuVY7Ptklb6+JS1bEDOxrSV8CUtIEbz8g580SfhN+C7GLFK31VunhZRA8JQwpV7ntpX0Ttj9Iz/v7ix6bSgwjzOepjZ7ToSsfrKUfLudm8OUaA6k65vc4drATzYBuDQWw97PwKbeWIk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771043327; c=relaxed/simple; bh=FSiED3HyNT8AthJzBZqLtfYzOa/KWw3tAdsNyvPTlew=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=o0DsXLzuewvs6hDL4ZiS1lvl2YQVuDQjfcoAZzXSzCc4MM/ks9wF879baVNeQ3qDJSAYF5Qgl9OHML27T+rmeiBudNvJb+fIpp4eE8CG1quDdgfvFTxvMoPBbjrBFMvge8l0XohJmM3941MfxV6HAsBXFkq/CN3OEgtbnKJziZI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com; spf=fail smtp.mailfrom=purestorage.com; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b=H2B6k+eI; arc=none smtp.client-ip=74.125.82.53 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=purestorage.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b="H2B6k+eI" Received: by mail-dl1-f53.google.com with SMTP id a92af1059eb24-124899ee9d3so1154893c88.0 for ; Fri, 13 Feb 2026 20:28:39 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=purestorage.com; s=google2022; t=1771043318; x=1771648118; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=/3PZZpvojr3QJ+1nB0s8EMVY3OCbXeX5sFwA3G15rFM=; b=H2B6k+eIre2qSRDwEQ/Lr11Gevgo08fioPkIiDuUsOjsoSQ6b5LfsoZGR2wlIC6RKd TucPATPmotu8EaEfU4uTuczH6YAa+yIOp7Ysx74iQuGu3j5hRRdYaIRKs3FhA/Jcd8i6 4y2FqYbMIuwzKeTRhBStMKRAqsltH/iagWrhmLMSMjGTZXUwRWrjnLZnjW2bTDOcotHP R9SWBDeJ/D1rjSMuK9z9e2lk+mMdbDXq2QhjlzO/lXcpBL9L++teaX++7LRRu81tMAXU qqsiuAMdcpIYGAUoE+6a5BK/pORkgbh3BcF861Rr4nf2xhLpaWqejMDb/ioennPcqoVf WMsA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1771043318; x=1771648118; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=/3PZZpvojr3QJ+1nB0s8EMVY3OCbXeX5sFwA3G15rFM=; b=iUHnJm5SxS2ARroXfn9d3nC/a8Hi6THCOx5+SJ8EcU8y8Gnfd8lZueWuDoETB/rrV1 5741fGy9fr+UAwEPTuqkUjD1Mph7UJzWhfutlxe37y6zhWFAkk9o0kfRvxg6LaHRIhJe UIVlAkn4hZlXJCH1iCEDTwBwj/8AJBDm+Bnr8kRuh9hfDVdPSqJUzT/8sKDjQpxp9GFX ZD1IhSGEtOFn+oivDXQKKSAB3sLUZEd75PtbRZXWtuGynPfhaS3CLsVMhWbFSkpi1JWn piZsmBhZeamFY71wHFmdCaCnd8AQcY6z6a1fbN51BRsK1T3PZmPadIMsefOgLN2sIGNR rDsw== X-Forwarded-Encrypted: i=1; AJvYcCUuwdlm3I3g00kIBS7Tjqve990m/yQJCel4ZFDLrx72CgHwRq98WfA/i/cpoMttSG6m2R5Cz6OEJvTfAaQ=@vger.kernel.org X-Gm-Message-State: AOJu0Yz3bn5zZhKwH730AE9RELQRZt2+/nCD0ga16HexCeS4nTZ87bsX GJpl4RpTBFvV//ovJv767NWV/zGufem6sYGXumRFEwTadze4hoIpzTuR0ohVZj26PTc= X-Gm-Gg: AZuq6aJQ3g+SzYunKT6MfFGE2mf8Ydp1JQVbd5wKiJ02TzGbUl4sCxosPhIckTdE2fg etGDMpkEOXZBPhTJUi6vJvafTC4q97jJGA7NNO1rf+7x5vmkhWMXx3oDkbHpIQeAu20IYz8isEx G0BoK6hxm7UHlyl6EzNwbRIB/2zhd06mRU09xRSJLxwMd0Sx1NaNPlIzMUBWDYxDn3nc7NipdFE 2NQIzJp8CVmdA+7PtGYa8UkG9ZoxE8WoOXaQYI2Ga+DOf2G7bf8wdkpczYM5SzPANFGW2gEqyox 2HRVNY92/xvlIOBkE9qAqdMCGwWw4nFeRs+Wrzvk5Wiralg+tvLF7P+aAOeW7YuWU82qmpWl3ew 1Lgylpx7Uji+KQoZSMrlq+llAZDIwIce2Yezd0cXyRWCRDs+uD8rKRPepHYFHctY+MUqFtmeqqJ k2hdNc9mqOagzcQDxxo6YwB2TwGZCYFDOboRDwtJgsrXZIQA== X-Received: by 2002:a05:7022:628e:b0:119:e569:f86d with SMTP id a92af1059eb24-12740fdcd97mr1003218c88.10.1771043318277; Fri, 13 Feb 2026 20:28:38 -0800 (PST) Received: from apollo.purestorage.com ([208.88.152.253]) by smtp.googlemail.com with ESMTPSA id a92af1059eb24-12742cbc900sm1021042c88.14.2026.02.13.20.28.37 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Feb 2026 20:28:37 -0800 (PST) From: Mohamed Khalfella To: Justin Tee , Naresh Gottumukkala , Paul Ely , Chaitanya Kulkarni , Christoph Hellwig , Jens Axboe , Keith Busch , Sagi Grimberg , James Smart , Hannes Reinecke Cc: Aaron Dailey , Randy Jennings , Dhaval Giani , linux-nvme@lists.infradead.org, linux-kernel@vger.kernel.org, Mohamed Khalfella Subject: [PATCH v3 21/21] nvme-fc: Extend FENCING state per TP4129 on CCR failure Date: Fri, 13 Feb 2026 20:25:22 -0800 Message-ID: <20260214042753.4073668-22-mkhalfella@purestorage.com> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260214042753.4073668-1-mkhalfella@purestorage.com> References: <20260214042753.4073668-1-mkhalfella@purestorage.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" If CCR operations fail and CQT is supported, we must defer the retry of inflight requests per TP4129. Update ctrl->fencing_work to schedule ctrl->fenced_work, effectively extending the FENCING state. This delay ensures that inflight requests are held until it is safe for them to be retired. Signed-off-by: Mohamed Khalfella --- drivers/nvme/host/fc.c | 39 +++++++++++++++++++++++++++++++++++---- 1 file changed, 35 insertions(+), 4 deletions(-) diff --git a/drivers/nvme/host/fc.c b/drivers/nvme/host/fc.c index eac3a7ccaa5c..81088a4ce298 100644 --- a/drivers/nvme/host/fc.c +++ b/drivers/nvme/host/fc.c @@ -167,6 +167,7 @@ struct nvme_fc_ctrl { struct blk_mq_tag_set tag_set; =20 struct work_struct fencing_work; + struct delayed_work fenced_work; struct work_struct ioerr_work; struct delayed_work connect_work; =20 @@ -1878,6 +1879,18 @@ __nvme_fc_fcpop_chk_teardowns(struct nvme_fc_ctrl *c= trl, return ret; } =20 +static void nvme_fc_fenced_work(struct work_struct *work) +{ + struct nvme_fc_ctrl *fc_ctrl =3D container_of(to_delayed_work(work), + struct nvme_fc_ctrl, fenced_work); + struct nvme_ctrl *ctrl =3D &fc_ctrl->ctrl; + + dev_info(ctrl->device, "Time-based recovery finished\n"); + nvme_change_ctrl_state(ctrl, NVME_CTRL_FENCED); + if (nvme_change_ctrl_state(ctrl, NVME_CTRL_RESETTING)) + queue_work(nvme_reset_wq, &fc_ctrl->ioerr_work); +} + static void nvme_fc_fencing_work(struct work_struct *work) { struct nvme_fc_ctrl *fc_ctrl =3D @@ -1886,16 +1899,33 @@ static void nvme_fc_fencing_work(struct work_struct= *work) unsigned long rem; =20 rem =3D nvme_fence_ctrl(ctrl); - if (rem) { + if (!rem) + goto done; + + if (!ctrl->cqt) { dev_info(ctrl->device, - "CCR failed, skipping time-based recovery\n"); + "CCR failed, CQT not supported, skip time-based recovery\n"); + goto done; } =20 + dev_info(ctrl->device, + "CCR failed, switch to time-based recovery, timeout =3D %ums\n", + jiffies_to_msecs(rem)); + queue_delayed_work(nvme_wq, &fc_ctrl->fenced_work, rem); + return; + +done: nvme_change_ctrl_state(ctrl, NVME_CTRL_FENCED); if (nvme_change_ctrl_state(ctrl, NVME_CTRL_RESETTING)) queue_work(nvme_reset_wq, &fc_ctrl->ioerr_work); } =20 +static void nvme_fc_flush_fencing_works(struct nvme_fc_ctrl *ctrl) +{ + flush_work(&ctrl->fencing_work); + flush_delayed_work(&ctrl->fenced_work); +} + static void nvme_fc_ctrl_ioerr_work(struct work_struct *work) { @@ -1917,7 +1947,7 @@ nvme_fc_ctrl_ioerr_work(struct work_struct *work) return; } =20 - flush_work(&ctrl->fencing_work); + nvme_fc_flush_fencing_works(ctrl); nvme_fc_error_recovery(ctrl); } =20 @@ -3396,7 +3426,7 @@ nvme_fc_reset_ctrl_work(struct work_struct *work) struct nvme_fc_ctrl *ctrl =3D container_of(work, struct nvme_fc_ctrl, ctrl.reset_work); =20 - flush_work(&ctrl->fencing_work); + nvme_fc_flush_fencing_works(ctrl); nvme_stop_ctrl(&ctrl->ctrl); =20 /* will block will waiting for io to terminate */ @@ -3573,6 +3603,7 @@ nvme_fc_alloc_ctrl(struct device *dev, struct nvmf_ct= rl_options *opts, INIT_WORK(&ctrl->ctrl.reset_work, nvme_fc_reset_ctrl_work); INIT_DELAYED_WORK(&ctrl->connect_work, nvme_fc_connect_ctrl_work); INIT_WORK(&ctrl->fencing_work, nvme_fc_fencing_work); + INIT_DELAYED_WORK(&ctrl->fenced_work, nvme_fc_fenced_work); INIT_WORK(&ctrl->ioerr_work, nvme_fc_ctrl_ioerr_work); spin_lock_init(&ctrl->lock); =20 --=20 2.52.0