From nobody Fri May 3 00:15:38 2024 X-Original-To: dev-commits-src-all@mlmmj.nyi.freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2610:1c1:1:606c::19:1]) by mlmmj.nyi.freebsd.org (Postfix) with ESMTP id 4VVrtL3mZRz5KJyB; Fri, 3 May 2024 00:15:38 +0000 (UTC) (envelope-from git@FreeBSD.org) Received: from mxrelay.nyi.freebsd.org (mxrelay.nyi.freebsd.org [IPv6:2610:1c1:1:606c::19:3]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256 client-signature RSA-PSS (4096 bits) client-digest SHA256) (Client CN "mxrelay.nyi.freebsd.org", Issuer "R3" (verified OK)) by mx1.freebsd.org (Postfix) with ESMTPS id 4VVrtL2t2fz4Q5S; Fri, 3 May 2024 00:15:38 +0000 (UTC) (envelope-from git@FreeBSD.org) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=freebsd.org; s=dkim; t=1714695338; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=RG/cqXXjrx78gCOtnJrjdbJtwQHuiAFCPJWyFlAx/Hw=; b=f1ITegAIlo3LvyA/QH2NiCq3Fl+G0F8zsNaIzJrzPogAWQ/XvHlmEtrKKvV+pOUY5k6Kau BLAMuI/EesMgI78m6bn4G62oa25AvGSx5wmMA7+lnP7RY2mD5OjsgVM1BAKamxORdOjdPW B9eeFRvW67qECEzPobWoMwwD6EIW5fqf9h7865kpV2sHlpnjSfe/3mh423qqxrBq+rR2gR 1937epvtq5aJY4tENLd8aeFiNK3HTWpqIsL0X7eUEMTjsz4ZxvjIlneYWyzmjDH/syC45v sy4WAMq5KBbk9s26zfZBt8XINcGe6a3TXysV6clBOGipoc6TjLBN9zMz6xyMRQ== ARC-Seal: i=1; s=dkim; d=freebsd.org; t=1714695338; a=rsa-sha256; cv=none; b=Svra0tYj5aqm+rDckAmBM4QwYRj0np9dsZ91l2GPeQjzvT9VcLto7HlnbslJ/egL7/HFIH pnAVOpwW89CEOCy4N8xA0dm/Ez6mzlv0SttNkHL7sbWPPA5dg7+0mBM7UI5HIFaiWNTT4+ /TbdIq5L/Of7CmmEYgL87/ZwHLU6F1RKNgy0tP98vivYAeOZCc9b8bFK853bDjJHyVN1Bw wF51NtaY2h/wt1aH+a/UfubWVoVhMsbVmaksQYRkbTMBEV0tcJuE3JVWurSbTk+owEyGir +HU+emMgbGW8GruV8dNmV/5/9uVvMdtI5qowGY7qU4CzfebKHzZsAfuQCZXHcA== ARC-Authentication-Results: i=1; mx1.freebsd.org; none ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=freebsd.org; s=dkim; t=1714695338; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=RG/cqXXjrx78gCOtnJrjdbJtwQHuiAFCPJWyFlAx/Hw=; b=R2/x8F6dNNG6pm4FdaNsaJl6+9dbMhi3ZCdfOpjVf2Dxkg9/dZ20le9ijEB3L/e4Y+6HES AyOCOd4Mrec9k3WS5tnaIy0xzz5YtoD1ryBmlJ7/LReScBAQGk8e7iUZpnFGYNHsGAF6U9 DzmFXX2mMfh0+t4D9g1ykIscHomjqvv252L98uWwKtwFQZi/qJ4vxpaYXcjiXtZWKbIaVt WsiGAGLBbmvVoNWg0DA30rg63SoCZ1qdUoygU7hjUcmoeMa2+3slqz7Skk3MNwfQfvEsWT QH156ijEsmxVblcafZqzM+1FxfPfK8JPsPqBKgTYUe2iabM8+inK5fl1rZg2Qg== Received: from gitrepo.freebsd.org (gitrepo.freebsd.org [IPv6:2610:1c1:1:6068::e6a:5]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (Client did not present a certificate) by mxrelay.nyi.freebsd.org (Postfix) with ESMTPS id 4VVrtL2TNgzNcq; Fri, 3 May 2024 00:15:38 +0000 (UTC) (envelope-from git@FreeBSD.org) Received: from gitrepo.freebsd.org ([127.0.1.44]) by gitrepo.freebsd.org (8.17.1/8.17.1) with ESMTP id 4430Fc37078671; Fri, 3 May 2024 00:15:38 GMT (envelope-from git@gitrepo.freebsd.org) Received: (from git@localhost) by gitrepo.freebsd.org (8.17.1/8.17.1/Submit) id 4430FcrB078668; Fri, 3 May 2024 00:15:38 GMT (envelope-from git) Date: Fri, 3 May 2024 00:15:38 GMT Message-Id: <202405030015.4430FcrB078668@gitrepo.freebsd.org> To: src-committers@FreeBSD.org, dev-commits-src-all@FreeBSD.org, dev-commits-src-main@FreeBSD.org From: John Baldwin Subject: git: 878d102ab9e5 - main - nvmf_proto.h: Update for use in FreeBSD List-Id: Commit messages for all branches of the src repository List-Archive: https://lists.freebsd.org/archives/dev-commits-src-all List-Help: List-Post: List-Subscribe: List-Unsubscribe: X-BeenThere: dev-commits-src-all@freebsd.org Sender: owner-dev-commits-src-all@FreeBSD.org MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit X-Git-Committer: jhb X-Git-Repository: src X-Git-Refname: refs/heads/main X-Git-Reftype: branch X-Git-Commit: 878d102ab9e5cd262fc478ebfdabf31f1c6b84a5 Auto-Submitted: auto-generated The branch main has been updated by jhb: URL: https://cgit.FreeBSD.org/src/commit/?id=878d102ab9e5cd262fc478ebfdabf31f1c6b84a5 commit 878d102ab9e5cd262fc478ebfdabf31f1c6b84a5 Author: John Baldwin AuthorDate: 2024-05-02 23:26:33 +0000 Commit: John Baldwin CommitDate: 2024-05-02 23:26:33 +0000 nvmf_proto.h: Update for use in FreeBSD - Replace SPDK_STATIC_ASSERT with _Static_assert. - Remove SPDK_ and spdk_ prefixes from types and constants. - Switch to using FreeBSD headers, e.g. in place of "spdk/nvme_spec.h". - Add a definition of NVME_NQN_FIELD_SIZE (from SPDK's nvme_spec.h). - Remove constant for the fabrics opcode as this is already present in . - Use types from for NVMe structures including struct nvme_sgl_descriptor, struct nvme_command, and struct nvme_completion. - Use plain uint16_t in place of struct spdk_nvme_status. Reviewed by: imp Sponsored by: Chelsio Communications Differential Revision: https://reviews.freebsd.org/D44704 --- sys/dev/nvmf/nvmf_proto.h | 478 +++++++++++++++++++++++----------------------- 1 file changed, 241 insertions(+), 237 deletions(-) diff --git a/sys/dev/nvmf/nvmf_proto.h b/sys/dev/nvmf/nvmf_proto.h index 75f6db2f8b15..cb94f472c874 100644 --- a/sys/dev/nvmf/nvmf_proto.h +++ b/sys/dev/nvmf/nvmf_proto.h @@ -3,13 +3,19 @@ * All rights reserved. */ -#ifndef SPDK_NVMF_SPEC_H -#define SPDK_NVMF_SPEC_H +/* Derived from include/spdk/nvmf_spec.h from Intel's SPDK. */ -#include "spdk/stdinc.h" +#ifndef __NVMF_PROTO_H__ +#define __NVMF_PROTO_H__ -#include "spdk/assert.h" -#include "spdk/nvme_spec.h" +#include +#include +#ifdef _KERNEL +#include +#else +#include +#endif +#include /** * \file @@ -18,7 +24,9 @@ #pragma pack(push, 1) -struct spdk_nvmf_capsule_cmd { +#define NVME_NQN_FIELD_SIZE 256 + +struct nvmf_capsule_cmd { uint8_t opcode; uint8_t reserved1; uint16_t cid; @@ -26,147 +34,145 @@ struct spdk_nvmf_capsule_cmd { uint8_t reserved2[35]; uint8_t fabric_specific[24]; }; -SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_capsule_cmd) == 64, "Incorrect size"); +_Static_assert(sizeof(struct nvmf_capsule_cmd) == 64, "Incorrect size"); /* Fabric Command Set */ -#define SPDK_NVME_OPC_FABRIC 0x7f - -enum spdk_nvmf_fabric_cmd_types { - SPDK_NVMF_FABRIC_COMMAND_PROPERTY_SET = 0x00, - SPDK_NVMF_FABRIC_COMMAND_CONNECT = 0x01, - SPDK_NVMF_FABRIC_COMMAND_PROPERTY_GET = 0x04, - SPDK_NVMF_FABRIC_COMMAND_AUTHENTICATION_SEND = 0x05, - SPDK_NVMF_FABRIC_COMMAND_AUTHENTICATION_RECV = 0x06, - SPDK_NVMF_FABRIC_COMMAND_START_VENDOR_SPECIFIC = 0xC0, +enum nvmf_fabric_cmd_types { + NVMF_FABRIC_COMMAND_PROPERTY_SET = 0x00, + NVMF_FABRIC_COMMAND_CONNECT = 0x01, + NVMF_FABRIC_COMMAND_PROPERTY_GET = 0x04, + NVMF_FABRIC_COMMAND_AUTHENTICATION_SEND = 0x05, + NVMF_FABRIC_COMMAND_AUTHENTICATION_RECV = 0x06, + NVMF_FABRIC_COMMAND_START_VENDOR_SPECIFIC = 0xC0, }; -enum spdk_nvmf_fabric_cmd_status_code { - SPDK_NVMF_FABRIC_SC_INCOMPATIBLE_FORMAT = 0x80, - SPDK_NVMF_FABRIC_SC_CONTROLLER_BUSY = 0x81, - SPDK_NVMF_FABRIC_SC_INVALID_PARAM = 0x82, - SPDK_NVMF_FABRIC_SC_RESTART_DISCOVERY = 0x83, - SPDK_NVMF_FABRIC_SC_INVALID_HOST = 0x84, - SPDK_NVMF_FABRIC_SC_LOG_RESTART_DISCOVERY = 0x90, - SPDK_NVMF_FABRIC_SC_AUTH_REQUIRED = 0x91, +enum nvmf_fabric_cmd_status_code { + NVMF_FABRIC_SC_INCOMPATIBLE_FORMAT = 0x80, + NVMF_FABRIC_SC_CONTROLLER_BUSY = 0x81, + NVMF_FABRIC_SC_INVALID_PARAM = 0x82, + NVMF_FABRIC_SC_RESTART_DISCOVERY = 0x83, + NVMF_FABRIC_SC_INVALID_HOST = 0x84, + NVMF_FABRIC_SC_LOG_RESTART_DISCOVERY = 0x90, + NVMF_FABRIC_SC_AUTH_REQUIRED = 0x91, }; /** * RDMA Queue Pair service types */ -enum spdk_nvmf_rdma_qptype { +enum nvmf_rdma_qptype { /** Reliable connected */ - SPDK_NVMF_RDMA_QPTYPE_RELIABLE_CONNECTED = 0x1, + NVMF_RDMA_QPTYPE_RELIABLE_CONNECTED = 0x1, /** Reliable datagram */ - SPDK_NVMF_RDMA_QPTYPE_RELIABLE_DATAGRAM = 0x2, + NVMF_RDMA_QPTYPE_RELIABLE_DATAGRAM = 0x2, }; /** * RDMA provider types */ -enum spdk_nvmf_rdma_prtype { +enum nvmf_rdma_prtype { /** No provider specified */ - SPDK_NVMF_RDMA_PRTYPE_NONE = 0x1, + NVMF_RDMA_PRTYPE_NONE = 0x1, /** InfiniBand */ - SPDK_NVMF_RDMA_PRTYPE_IB = 0x2, + NVMF_RDMA_PRTYPE_IB = 0x2, /** RoCE v1 */ - SPDK_NVMF_RDMA_PRTYPE_ROCE = 0x3, + NVMF_RDMA_PRTYPE_ROCE = 0x3, /** RoCE v2 */ - SPDK_NVMF_RDMA_PRTYPE_ROCE2 = 0x4, + NVMF_RDMA_PRTYPE_ROCE2 = 0x4, /** iWARP */ - SPDK_NVMF_RDMA_PRTYPE_IWARP = 0x5, + NVMF_RDMA_PRTYPE_IWARP = 0x5, }; /** * RDMA connection management service types */ -enum spdk_nvmf_rdma_cms { +enum nvmf_rdma_cms { /** Sockets based endpoint addressing */ - SPDK_NVMF_RDMA_CMS_RDMA_CM = 0x1, + NVMF_RDMA_CMS_RDMA_CM = 0x1, }; /** * NVMe over Fabrics transport types */ -enum spdk_nvmf_trtype { +enum nvmf_trtype { /** RDMA */ - SPDK_NVMF_TRTYPE_RDMA = 0x1, + NVMF_TRTYPE_RDMA = 0x1, /** Fibre Channel */ - SPDK_NVMF_TRTYPE_FC = 0x2, + NVMF_TRTYPE_FC = 0x2, /** TCP */ - SPDK_NVMF_TRTYPE_TCP = 0x3, + NVMF_TRTYPE_TCP = 0x3, /** Intra-host transport (loopback) */ - SPDK_NVMF_TRTYPE_INTRA_HOST = 0xfe, + NVMF_TRTYPE_INTRA_HOST = 0xfe, }; /** * Address family types */ -enum spdk_nvmf_adrfam { +enum nvmf_adrfam { /** IPv4 (AF_INET) */ - SPDK_NVMF_ADRFAM_IPV4 = 0x1, + NVMF_ADRFAM_IPV4 = 0x1, /** IPv6 (AF_INET6) */ - SPDK_NVMF_ADRFAM_IPV6 = 0x2, + NVMF_ADRFAM_IPV6 = 0x2, /** InfiniBand (AF_IB) */ - SPDK_NVMF_ADRFAM_IB = 0x3, + NVMF_ADRFAM_IB = 0x3, /** Fibre Channel address family */ - SPDK_NVMF_ADRFAM_FC = 0x4, + NVMF_ADRFAM_FC = 0x4, /** Intra-host transport (loopback) */ - SPDK_NVMF_ADRFAM_INTRA_HOST = 0xfe, + NVMF_ADRFAM_INTRA_HOST = 0xfe, }; /** * NVM subsystem types */ -enum spdk_nvmf_subtype { +enum nvmf_subtype { /** Referral to a discovery service */ - SPDK_NVMF_SUBTYPE_DISCOVERY = 0x1, + NVMF_SUBTYPE_DISCOVERY = 0x1, /** NVM Subsystem */ - SPDK_NVMF_SUBTYPE_NVME = 0x2, + NVMF_SUBTYPE_NVME = 0x2, /** Current Discovery Subsystem */ - SPDK_NVMF_SUBTYPE_DISCOVERY_CURRENT = 0x3 + NVMF_SUBTYPE_DISCOVERY_CURRENT = 0x3 }; /* Discovery Log Entry Flags - Duplicate Returned Information */ -#define SPDK_NVMF_DISCOVERY_LOG_EFLAGS_DUPRETINFO (1u << 0u) +#define NVMF_DISCOVERY_LOG_EFLAGS_DUPRETINFO (1u << 0u) /* Discovery Log Entry Flags - Explicit Persistent Connection Support for Discovery */ -#define SPDK_NVMF_DISCOVERY_LOG_EFLAGS_EPCSD (1u << 1u) +#define NVMF_DISCOVERY_LOG_EFLAGS_EPCSD (1u << 1u) /** * Connections shall be made over a fabric secure channel */ -enum spdk_nvmf_treq_secure_channel { +enum nvmf_treq_secure_channel { /** Not specified */ - SPDK_NVMF_TREQ_SECURE_CHANNEL_NOT_SPECIFIED = 0x0, + NVMF_TREQ_SECURE_CHANNEL_NOT_SPECIFIED = 0x0, /** Required */ - SPDK_NVMF_TREQ_SECURE_CHANNEL_REQUIRED = 0x1, + NVMF_TREQ_SECURE_CHANNEL_REQUIRED = 0x1, /** Not required */ - SPDK_NVMF_TREQ_SECURE_CHANNEL_NOT_REQUIRED = 0x2, + NVMF_TREQ_SECURE_CHANNEL_NOT_REQUIRED = 0x2, }; -struct spdk_nvmf_fabric_auth_recv_cmd { +struct nvmf_fabric_auth_recv_cmd { uint8_t opcode; uint8_t reserved1; uint16_t cid; uint8_t fctype; /* NVMF_FABRIC_COMMAND_AUTHENTICATION_RECV (0x06) */ uint8_t reserved2[19]; - struct spdk_nvme_sgl_descriptor sgl1; + struct nvme_sgl_descriptor sgl1; uint8_t reserved3; uint8_t spsp0; uint8_t spsp1; @@ -174,15 +180,15 @@ struct spdk_nvmf_fabric_auth_recv_cmd { uint32_t al; uint8_t reserved4[16]; }; -SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_fabric_auth_recv_cmd) == 64, "Incorrect size"); +_Static_assert(sizeof(struct nvmf_fabric_auth_recv_cmd) == 64, "Incorrect size"); -struct spdk_nvmf_fabric_auth_send_cmd { +struct nvmf_fabric_auth_send_cmd { uint8_t opcode; uint8_t reserved1; uint16_t cid; uint8_t fctype; /* NVMF_FABRIC_COMMAND_AUTHENTICATION_SEND (0x05) */ uint8_t reserved2[19]; - struct spdk_nvme_sgl_descriptor sgl1; + struct nvme_sgl_descriptor sgl1; uint8_t reserved3; uint8_t spsp0; uint8_t spsp1; @@ -190,25 +196,25 @@ struct spdk_nvmf_fabric_auth_send_cmd { uint32_t tl; uint8_t reserved4[16]; }; -SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_fabric_auth_send_cmd) == 64, "Incorrect size"); +_Static_assert(sizeof(struct nvmf_fabric_auth_send_cmd) == 64, "Incorrect size"); -struct spdk_nvmf_fabric_connect_data { +struct nvmf_fabric_connect_data { uint8_t hostid[16]; uint16_t cntlid; uint8_t reserved5[238]; - uint8_t subnqn[SPDK_NVME_NQN_FIELD_SIZE]; - uint8_t hostnqn[SPDK_NVME_NQN_FIELD_SIZE]; + uint8_t subnqn[NVME_NQN_FIELD_SIZE]; + uint8_t hostnqn[NVME_NQN_FIELD_SIZE]; uint8_t reserved6[256]; }; -SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_fabric_connect_data) == 1024, "Incorrect size"); +_Static_assert(sizeof(struct nvmf_fabric_connect_data) == 1024, "Incorrect size"); -struct spdk_nvmf_fabric_connect_cmd { +struct nvmf_fabric_connect_cmd { uint8_t opcode; uint8_t reserved1; uint16_t cid; uint8_t fctype; uint8_t reserved2[19]; - struct spdk_nvme_sgl_descriptor sgl1; + struct nvme_sgl_descriptor sgl1; uint16_t recfmt; /* Connect Record Format */ uint16_t qid; /* Queue Identifier */ uint16_t sqsize; /* Submission Queue Size */ @@ -217,9 +223,9 @@ struct spdk_nvmf_fabric_connect_cmd { uint32_t kato; /* keep alive timeout */ uint8_t reserved4[12]; }; -SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_fabric_connect_cmd) == 64, "Incorrect size"); +_Static_assert(sizeof(struct nvmf_fabric_connect_cmd) == 64, "Incorrect size"); -struct spdk_nvmf_fabric_connect_rsp { +struct nvmf_fabric_connect_rsp { union { struct { uint16_t cntlid; @@ -239,14 +245,14 @@ struct spdk_nvmf_fabric_connect_rsp { uint16_t sqhd; uint16_t reserved1; uint16_t cid; - struct spdk_nvme_status status; + uint16_t status; }; -SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_fabric_connect_rsp) == 16, "Incorrect size"); +_Static_assert(sizeof(struct nvmf_fabric_connect_rsp) == 16, "Incorrect size"); -#define SPDK_NVMF_PROP_SIZE_4 0 -#define SPDK_NVMF_PROP_SIZE_8 1 +#define NVMF_PROP_SIZE_4 0 +#define NVMF_PROP_SIZE_8 1 -struct spdk_nvmf_fabric_prop_get_cmd { +struct nvmf_fabric_prop_get_cmd { uint8_t opcode; uint8_t reserved1; uint16_t cid; @@ -260,9 +266,9 @@ struct spdk_nvmf_fabric_prop_get_cmd { uint32_t ofst; uint8_t reserved4[16]; }; -SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_fabric_prop_get_cmd) == 64, "Incorrect size"); +_Static_assert(sizeof(struct nvmf_fabric_prop_get_cmd) == 64, "Incorrect size"); -struct spdk_nvmf_fabric_prop_get_rsp { +struct nvmf_fabric_prop_get_rsp { union { uint64_t u64; struct { @@ -274,11 +280,11 @@ struct spdk_nvmf_fabric_prop_get_rsp { uint16_t sqhd; uint16_t reserved0; uint16_t cid; - struct spdk_nvme_status status; + uint16_t status; }; -SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_fabric_prop_get_rsp) == 16, "Incorrect size"); +_Static_assert(sizeof(struct nvmf_fabric_prop_get_rsp) == 16, "Incorrect size"); -struct spdk_nvmf_fabric_prop_set_cmd { +struct nvmf_fabric_prop_set_cmd { uint8_t opcode; uint8_t reserved0; uint16_t cid; @@ -301,30 +307,28 @@ struct spdk_nvmf_fabric_prop_set_cmd { uint8_t reserved4[8]; }; -SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_fabric_prop_set_cmd) == 64, "Incorrect size"); - -#define SPDK_NVMF_NQN_MIN_LEN 11 /* The prefix in the spec is 11 characters */ -#define SPDK_NVMF_NQN_MAX_LEN 223 -#define SPDK_NVMF_NQN_UUID_PRE_LEN 32 -#define SPDK_NVMF_UUID_STRING_LEN 36 -#define SPDK_NVMF_NQN_UUID_PRE "nqn.2014-08.org.nvmexpress:uuid:" -#define SPDK_NVMF_DISCOVERY_NQN "nqn.2014-08.org.nvmexpress.discovery" +_Static_assert(sizeof(struct nvmf_fabric_prop_set_cmd) == 64, "Incorrect size"); -#define SPDK_DOMAIN_LABEL_MAX_LEN 63 /* RFC 1034 max domain label length */ +#define NVMF_NQN_MIN_LEN 11 /* The prefix in the spec is 11 characters */ +#define NVMF_NQN_MAX_LEN 223 +#define NVMF_NQN_UUID_PRE_LEN 32 +#define NVMF_UUID_STRING_LEN 36 +#define NVMF_NQN_UUID_PRE "nqn.2014-08.org.nvmexpress:uuid:" +#define NVMF_DISCOVERY_NQN "nqn.2014-08.org.nvmexpress.discovery" -#define SPDK_NVMF_TRSTRING_MAX_LEN 32 -#define SPDK_NVMF_TRADDR_MAX_LEN 256 -#define SPDK_NVMF_TRSVCID_MAX_LEN 32 +#define NVMF_TRSTRING_MAX_LEN 32 +#define NVMF_TRADDR_MAX_LEN 256 +#define NVMF_TRSVCID_MAX_LEN 32 /** RDMA transport-specific address subtype */ -struct spdk_nvmf_rdma_transport_specific_address_subtype { - /** RDMA QP service type (\ref spdk_nvmf_rdma_qptype) */ +struct nvmf_rdma_transport_specific_address_subtype { + /** RDMA QP service type (\ref nvmf_rdma_qptype) */ uint8_t rdma_qptype; - /** RDMA provider type (\ref spdk_nvmf_rdma_prtype) */ + /** RDMA provider type (\ref nvmf_rdma_prtype) */ uint8_t rdma_prtype; - /** RDMA connection management service (\ref spdk_nvmf_rdma_cms) */ + /** RDMA connection management service (\ref nvmf_rdma_cms) */ uint8_t rdma_cms; uint8_t reserved0[5]; @@ -334,62 +338,62 @@ struct spdk_nvmf_rdma_transport_specific_address_subtype { uint8_t reserved2[246]; }; -SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_rdma_transport_specific_address_subtype) == 256, +_Static_assert(sizeof(struct nvmf_rdma_transport_specific_address_subtype) == 256, "Incorrect size"); /** TCP Secure Socket Type */ -enum spdk_nvme_tcp_secure_socket_type { +enum nvme_tcp_secure_socket_type { /** No security */ - SPDK_NVME_TCP_SECURITY_NONE = 0, + NVME_TCP_SECURITY_NONE = 0, /** TLS (Secure Sockets) version 1.2 */ - SPDK_NVME_TCP_SECURITY_TLS_1_2 = 1, + NVME_TCP_SECURITY_TLS_1_2 = 1, /** TLS (Secure Sockets) version 1.3 */ - SPDK_NVME_TCP_SECURITY_TLS_1_3 = 2, + NVME_TCP_SECURITY_TLS_1_3 = 2, }; /** TCP transport-specific address subtype */ -struct spdk_nvme_tcp_transport_specific_address_subtype { - /** Security type (\ref spdk_nvme_tcp_secure_socket_type) */ +struct nvme_tcp_transport_specific_address_subtype { + /** Security type (\ref nvme_tcp_secure_socket_type) */ uint8_t sectype; uint8_t reserved0[255]; }; -SPDK_STATIC_ASSERT(sizeof(struct spdk_nvme_tcp_transport_specific_address_subtype) == 256, +_Static_assert(sizeof(struct nvme_tcp_transport_specific_address_subtype) == 256, "Incorrect size"); /** Transport-specific address subtype */ -union spdk_nvmf_transport_specific_address_subtype { +union nvmf_transport_specific_address_subtype { uint8_t raw[256]; /** RDMA */ - struct spdk_nvmf_rdma_transport_specific_address_subtype rdma; + struct nvmf_rdma_transport_specific_address_subtype rdma; /** TCP */ - struct spdk_nvme_tcp_transport_specific_address_subtype tcp; + struct nvme_tcp_transport_specific_address_subtype tcp; }; -SPDK_STATIC_ASSERT(sizeof(union spdk_nvmf_transport_specific_address_subtype) == 256, +_Static_assert(sizeof(union nvmf_transport_specific_address_subtype) == 256, "Incorrect size"); -#define SPDK_NVMF_MIN_ADMIN_MAX_SQ_SIZE 32 +#define NVMF_MIN_ADMIN_MAX_SQ_SIZE 32 /** * Discovery Log Page entry */ -struct spdk_nvmf_discovery_log_page_entry { - /** Transport type (\ref spdk_nvmf_trtype) */ +struct nvmf_discovery_log_page_entry { + /** Transport type (\ref nvmf_trtype) */ uint8_t trtype; - /** Address family (\ref spdk_nvmf_adrfam) */ + /** Address family (\ref nvmf_adrfam) */ uint8_t adrfam; - /** Subsystem type (\ref spdk_nvmf_subtype) */ + /** Subsystem type (\ref nvmf_subtype) */ uint8_t subtype; /** Transport requirements */ struct { - /** Secure channel requirements (\ref spdk_nvmf_treq_secure_channel) */ + /** Secure channel requirements (\ref nvmf_treq_secure_channel) */ uint8_t secure_channel : 2; uint8_t reserved : 6; @@ -410,7 +414,7 @@ struct spdk_nvmf_discovery_log_page_entry { uint8_t reserved0[20]; /** Transport service identifier */ - uint8_t trsvcid[SPDK_NVMF_TRSVCID_MAX_LEN]; + uint8_t trsvcid[NVMF_TRSVCID_MAX_LEN]; uint8_t reserved1[192]; @@ -418,27 +422,27 @@ struct spdk_nvmf_discovery_log_page_entry { uint8_t subnqn[256]; /** Transport address */ - uint8_t traddr[SPDK_NVMF_TRADDR_MAX_LEN]; + uint8_t traddr[NVMF_TRADDR_MAX_LEN]; /** Transport-specific address subtype */ - union spdk_nvmf_transport_specific_address_subtype tsas; + union nvmf_transport_specific_address_subtype tsas; }; -SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_discovery_log_page_entry) == 1024, "Incorrect size"); +_Static_assert(sizeof(struct nvmf_discovery_log_page_entry) == 1024, "Incorrect size"); -struct spdk_nvmf_discovery_log_page { +struct nvmf_discovery_log_page { uint64_t genctr; uint64_t numrec; uint16_t recfmt; uint8_t reserved0[1006]; - struct spdk_nvmf_discovery_log_page_entry entries[0]; + struct nvmf_discovery_log_page_entry entries[0]; }; -SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_discovery_log_page) == 1024, "Incorrect size"); +_Static_assert(sizeof(struct nvmf_discovery_log_page) == 1024, "Incorrect size"); /* RDMA Fabric specific definitions below */ -#define SPDK_NVME_SGL_SUBTYPE_INVALIDATE_KEY 0xF +#define NVME_SGL_SUBTYPE_INVALIDATE_KEY 0xF -struct spdk_nvmf_rdma_request_private_data { +struct nvmf_rdma_request_private_data { uint16_t recfmt; /* record format */ uint16_t qid; /* queue id */ uint16_t hrqsize; /* host receive queue size */ @@ -446,74 +450,74 @@ struct spdk_nvmf_rdma_request_private_data { uint16_t cntlid; /* controller id */ uint8_t reserved[22]; }; -SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_rdma_request_private_data) == 32, "Incorrect size"); +_Static_assert(sizeof(struct nvmf_rdma_request_private_data) == 32, "Incorrect size"); -struct spdk_nvmf_rdma_accept_private_data { +struct nvmf_rdma_accept_private_data { uint16_t recfmt; /* record format */ uint16_t crqsize; /* controller receive queue size */ uint8_t reserved[28]; }; -SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_rdma_accept_private_data) == 32, "Incorrect size"); +_Static_assert(sizeof(struct nvmf_rdma_accept_private_data) == 32, "Incorrect size"); -struct spdk_nvmf_rdma_reject_private_data { +struct nvmf_rdma_reject_private_data { uint16_t recfmt; /* record format */ uint16_t sts; /* status */ }; -SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_rdma_reject_private_data) == 4, "Incorrect size"); +_Static_assert(sizeof(struct nvmf_rdma_reject_private_data) == 4, "Incorrect size"); -union spdk_nvmf_rdma_private_data { - struct spdk_nvmf_rdma_request_private_data pd_request; - struct spdk_nvmf_rdma_accept_private_data pd_accept; - struct spdk_nvmf_rdma_reject_private_data pd_reject; +union nvmf_rdma_private_data { + struct nvmf_rdma_request_private_data pd_request; + struct nvmf_rdma_accept_private_data pd_accept; + struct nvmf_rdma_reject_private_data pd_reject; }; -SPDK_STATIC_ASSERT(sizeof(union spdk_nvmf_rdma_private_data) == 32, "Incorrect size"); +_Static_assert(sizeof(union nvmf_rdma_private_data) == 32, "Incorrect size"); -enum spdk_nvmf_rdma_transport_error { - SPDK_NVMF_RDMA_ERROR_INVALID_PRIVATE_DATA_LENGTH = 0x1, - SPDK_NVMF_RDMA_ERROR_INVALID_RECFMT = 0x2, - SPDK_NVMF_RDMA_ERROR_INVALID_QID = 0x3, - SPDK_NVMF_RDMA_ERROR_INVALID_HSQSIZE = 0x4, - SPDK_NVMF_RDMA_ERROR_INVALID_HRQSIZE = 0x5, - SPDK_NVMF_RDMA_ERROR_NO_RESOURCES = 0x6, - SPDK_NVMF_RDMA_ERROR_INVALID_IRD = 0x7, - SPDK_NVMF_RDMA_ERROR_INVALID_ORD = 0x8, +enum nvmf_rdma_transport_error { + NVMF_RDMA_ERROR_INVALID_PRIVATE_DATA_LENGTH = 0x1, + NVMF_RDMA_ERROR_INVALID_RECFMT = 0x2, + NVMF_RDMA_ERROR_INVALID_QID = 0x3, + NVMF_RDMA_ERROR_INVALID_HSQSIZE = 0x4, + NVMF_RDMA_ERROR_INVALID_HRQSIZE = 0x5, + NVMF_RDMA_ERROR_NO_RESOURCES = 0x6, + NVMF_RDMA_ERROR_INVALID_IRD = 0x7, + NVMF_RDMA_ERROR_INVALID_ORD = 0x8, }; /* TCP transport specific definitions below */ /** NVMe/TCP PDU type */ -enum spdk_nvme_tcp_pdu_type { +enum nvme_tcp_pdu_type { /** Initialize Connection Request (ICReq) */ - SPDK_NVME_TCP_PDU_TYPE_IC_REQ = 0x00, + NVME_TCP_PDU_TYPE_IC_REQ = 0x00, /** Initialize Connection Response (ICResp) */ - SPDK_NVME_TCP_PDU_TYPE_IC_RESP = 0x01, + NVME_TCP_PDU_TYPE_IC_RESP = 0x01, /** Terminate Connection Request (TermReq) */ - SPDK_NVME_TCP_PDU_TYPE_H2C_TERM_REQ = 0x02, + NVME_TCP_PDU_TYPE_H2C_TERM_REQ = 0x02, /** Terminate Connection Response (TermResp) */ - SPDK_NVME_TCP_PDU_TYPE_C2H_TERM_REQ = 0x03, + NVME_TCP_PDU_TYPE_C2H_TERM_REQ = 0x03, /** Command Capsule (CapsuleCmd) */ - SPDK_NVME_TCP_PDU_TYPE_CAPSULE_CMD = 0x04, + NVME_TCP_PDU_TYPE_CAPSULE_CMD = 0x04, /** Response Capsule (CapsuleRsp) */ - SPDK_NVME_TCP_PDU_TYPE_CAPSULE_RESP = 0x05, + NVME_TCP_PDU_TYPE_CAPSULE_RESP = 0x05, /** Host To Controller Data (H2CData) */ - SPDK_NVME_TCP_PDU_TYPE_H2C_DATA = 0x06, + NVME_TCP_PDU_TYPE_H2C_DATA = 0x06, /** Controller To Host Data (C2HData) */ - SPDK_NVME_TCP_PDU_TYPE_C2H_DATA = 0x07, + NVME_TCP_PDU_TYPE_C2H_DATA = 0x07, /** Ready to Transfer (R2T) */ - SPDK_NVME_TCP_PDU_TYPE_R2T = 0x09, + NVME_TCP_PDU_TYPE_R2T = 0x09, }; /** Common NVMe/TCP PDU header */ -struct spdk_nvme_tcp_common_pdu_hdr { - /** PDU type (\ref spdk_nvme_tcp_pdu_type) */ +struct nvme_tcp_common_pdu_hdr { + /** PDU type (\ref nvme_tcp_pdu_type) */ uint8_t pdu_type; /** pdu_type-specific flags */ @@ -528,24 +532,24 @@ struct spdk_nvme_tcp_common_pdu_hdr { /** Total number of bytes in PDU, including pdu_hdr */ uint32_t plen; }; -SPDK_STATIC_ASSERT(sizeof(struct spdk_nvme_tcp_common_pdu_hdr) == 8, "Incorrect size"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_common_pdu_hdr, pdu_type) == 0, +_Static_assert(sizeof(struct nvme_tcp_common_pdu_hdr) == 8, "Incorrect size"); +_Static_assert(offsetof(struct nvme_tcp_common_pdu_hdr, pdu_type) == 0, "Incorrect offset"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_common_pdu_hdr, flags) == 1, "Incorrect offset"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_common_pdu_hdr, hlen) == 2, "Incorrect offset"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_common_pdu_hdr, pdo) == 3, "Incorrect offset"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_common_pdu_hdr, plen) == 4, "Incorrect offset"); +_Static_assert(offsetof(struct nvme_tcp_common_pdu_hdr, flags) == 1, "Incorrect offset"); +_Static_assert(offsetof(struct nvme_tcp_common_pdu_hdr, hlen) == 2, "Incorrect offset"); +_Static_assert(offsetof(struct nvme_tcp_common_pdu_hdr, pdo) == 3, "Incorrect offset"); +_Static_assert(offsetof(struct nvme_tcp_common_pdu_hdr, plen) == 4, "Incorrect offset"); -#define SPDK_NVME_TCP_CH_FLAGS_HDGSTF (1u << 0) -#define SPDK_NVME_TCP_CH_FLAGS_DDGSTF (1u << 1) +#define NVME_TCP_CH_FLAGS_HDGSTF (1u << 0) +#define NVME_TCP_CH_FLAGS_DDGSTF (1u << 1) /** * ICReq * - * common.pdu_type == SPDK_NVME_TCP_PDU_TYPE_IC_REQ + * common.pdu_type == NVME_TCP_PDU_TYPE_IC_REQ */ -struct spdk_nvme_tcp_ic_req { - struct spdk_nvme_tcp_common_pdu_hdr common; +struct nvme_tcp_ic_req { + struct nvme_tcp_common_pdu_hdr common; uint16_t pfv; /** Specifies the data alignment for all PDUs transferred from the controller to the host that contain data */ uint8_t hpda; @@ -560,22 +564,22 @@ struct spdk_nvme_tcp_ic_req { uint32_t maxr2t; uint8_t reserved16[112]; }; -SPDK_STATIC_ASSERT(sizeof(struct spdk_nvme_tcp_ic_req) == 128, "Incorrect size"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_ic_req, pfv) == 8, "Incorrect offset"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_ic_req, hpda) == 10, "Incorrect offset"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_ic_req, maxr2t) == 12, "Incorrect offset"); +_Static_assert(sizeof(struct nvme_tcp_ic_req) == 128, "Incorrect size"); +_Static_assert(offsetof(struct nvme_tcp_ic_req, pfv) == 8, "Incorrect offset"); +_Static_assert(offsetof(struct nvme_tcp_ic_req, hpda) == 10, "Incorrect offset"); +_Static_assert(offsetof(struct nvme_tcp_ic_req, maxr2t) == 12, "Incorrect offset"); -#define SPDK_NVME_TCP_HPDA_MAX 31 -#define SPDK_NVME_TCP_CPDA_MAX 31 -#define SPDK_NVME_TCP_PDU_PDO_MAX_OFFSET ((SPDK_NVME_TCP_CPDA_MAX + 1) << 2) +#define NVME_TCP_HPDA_MAX 31 +#define NVME_TCP_CPDA_MAX 31 +#define NVME_TCP_PDU_PDO_MAX_OFFSET ((NVME_TCP_CPDA_MAX + 1) << 2) /** * ICResp * - * common.pdu_type == SPDK_NVME_TCP_PDU_TYPE_IC_RESP + * common.pdu_type == NVME_TCP_PDU_TYPE_IC_RESP */ -struct spdk_nvme_tcp_ic_resp { - struct spdk_nvme_tcp_common_pdu_hdr common; +struct nvme_tcp_ic_resp { + struct nvme_tcp_common_pdu_hdr common; uint16_t pfv; /** Specifies the data alignment for all PDUs transferred from the host to the controller that contain data */ uint8_t cpda; @@ -591,131 +595,131 @@ struct spdk_nvme_tcp_ic_resp { uint32_t maxh2cdata; uint8_t reserved16[112]; }; -SPDK_STATIC_ASSERT(sizeof(struct spdk_nvme_tcp_ic_resp) == 128, "Incorrect size"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_ic_resp, pfv) == 8, "Incorrect offset"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_ic_resp, cpda) == 10, "Incorrect offset"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_ic_resp, maxh2cdata) == 12, "Incorrect offset"); +_Static_assert(sizeof(struct nvme_tcp_ic_resp) == 128, "Incorrect size"); +_Static_assert(offsetof(struct nvme_tcp_ic_resp, pfv) == 8, "Incorrect offset"); +_Static_assert(offsetof(struct nvme_tcp_ic_resp, cpda) == 10, "Incorrect offset"); +_Static_assert(offsetof(struct nvme_tcp_ic_resp, maxh2cdata) == 12, "Incorrect offset"); /** * TermReq * - * common.pdu_type == SPDK_NVME_TCP_PDU_TYPE_TERM_REQ + * common.pdu_type == NVME_TCP_PDU_TYPE_TERM_REQ */ -struct spdk_nvme_tcp_term_req_hdr { - struct spdk_nvme_tcp_common_pdu_hdr common; +struct nvme_tcp_term_req_hdr { + struct nvme_tcp_common_pdu_hdr common; uint16_t fes; uint8_t fei[4]; uint8_t reserved14[10]; }; -SPDK_STATIC_ASSERT(sizeof(struct spdk_nvme_tcp_term_req_hdr) == 24, "Incorrect size"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_term_req_hdr, fes) == 8, "Incorrect offset"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_term_req_hdr, fei) == 10, "Incorrect offset"); +_Static_assert(sizeof(struct nvme_tcp_term_req_hdr) == 24, "Incorrect size"); +_Static_assert(offsetof(struct nvme_tcp_term_req_hdr, fes) == 8, "Incorrect offset"); +_Static_assert(offsetof(struct nvme_tcp_term_req_hdr, fei) == 10, "Incorrect offset"); -enum spdk_nvme_tcp_term_req_fes { - SPDK_NVME_TCP_TERM_REQ_FES_INVALID_HEADER_FIELD = 0x01, - SPDK_NVME_TCP_TERM_REQ_FES_PDU_SEQUENCE_ERROR = 0x02, - SPDK_NVME_TCP_TERM_REQ_FES_HDGST_ERROR = 0x03, - SPDK_NVME_TCP_TERM_REQ_FES_DATA_TRANSFER_OUT_OF_RANGE = 0x04, - SPDK_NVME_TCP_TERM_REQ_FES_DATA_TRANSFER_LIMIT_EXCEEDED = 0x05, - SPDK_NVME_TCP_TERM_REQ_FES_R2T_LIMIT_EXCEEDED = 0x05, - SPDK_NVME_TCP_TERM_REQ_FES_INVALID_DATA_UNSUPPORTED_PARAMETER = 0x06, +enum nvme_tcp_term_req_fes { + NVME_TCP_TERM_REQ_FES_INVALID_HEADER_FIELD = 0x01, + NVME_TCP_TERM_REQ_FES_PDU_SEQUENCE_ERROR = 0x02, + NVME_TCP_TERM_REQ_FES_HDGST_ERROR = 0x03, + NVME_TCP_TERM_REQ_FES_DATA_TRANSFER_OUT_OF_RANGE = 0x04, + NVME_TCP_TERM_REQ_FES_DATA_TRANSFER_LIMIT_EXCEEDED = 0x05, + NVME_TCP_TERM_REQ_FES_R2T_LIMIT_EXCEEDED = 0x05, + NVME_TCP_TERM_REQ_FES_INVALID_DATA_UNSUPPORTED_PARAMETER = 0x06, }; /* Total length of term req PDU (including PDU header and DATA) in bytes shall not exceed a limit of 152 bytes. */ -#define SPDK_NVME_TCP_TERM_REQ_ERROR_DATA_MAX_SIZE 128 -#define SPDK_NVME_TCP_TERM_REQ_PDU_MAX_SIZE (SPDK_NVME_TCP_TERM_REQ_ERROR_DATA_MAX_SIZE + sizeof(struct spdk_nvme_tcp_term_req_hdr)) +#define NVME_TCP_TERM_REQ_ERROR_DATA_MAX_SIZE 128 +#define NVME_TCP_TERM_REQ_PDU_MAX_SIZE (NVME_TCP_TERM_REQ_ERROR_DATA_MAX_SIZE + sizeof(struct nvme_tcp_term_req_hdr)) /** * CapsuleCmd * - * common.pdu_type == SPDK_NVME_TCP_PDU_TYPE_CAPSULE_CMD + * common.pdu_type == NVME_TCP_PDU_TYPE_CAPSULE_CMD */ -struct spdk_nvme_tcp_cmd { - struct spdk_nvme_tcp_common_pdu_hdr common; - struct spdk_nvme_cmd ccsqe; +struct nvme_tcp_cmd { + struct nvme_tcp_common_pdu_hdr common; + struct nvme_command ccsqe; /**< icdoff hdgst padding + in-capsule data + ddgst (if enabled) */ }; -SPDK_STATIC_ASSERT(sizeof(struct spdk_nvme_tcp_cmd) == 72, "Incorrect size"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_cmd, ccsqe) == 8, "Incorrect offset"); +_Static_assert(sizeof(struct nvme_tcp_cmd) == 72, "Incorrect size"); +_Static_assert(offsetof(struct nvme_tcp_cmd, ccsqe) == 8, "Incorrect offset"); /** * CapsuleResp * - * common.pdu_type == SPDK_NVME_TCP_PDU_TYPE_CAPSULE_RESP + * common.pdu_type == NVME_TCP_PDU_TYPE_CAPSULE_RESP */ -struct spdk_nvme_tcp_rsp { - struct spdk_nvme_tcp_common_pdu_hdr common; - struct spdk_nvme_cpl rccqe; +struct nvme_tcp_rsp { + struct nvme_tcp_common_pdu_hdr common; + struct nvme_completion rccqe; }; -SPDK_STATIC_ASSERT(sizeof(struct spdk_nvme_tcp_rsp) == 24, "incorrect size"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_rsp, rccqe) == 8, "Incorrect offset"); +_Static_assert(sizeof(struct nvme_tcp_rsp) == 24, "incorrect size"); +_Static_assert(offsetof(struct nvme_tcp_rsp, rccqe) == 8, "Incorrect offset"); /** * H2CData * - * hdr.pdu_type == SPDK_NVME_TCP_PDU_TYPE_H2C_DATA + * hdr.pdu_type == NVME_TCP_PDU_TYPE_H2C_DATA */ -struct spdk_nvme_tcp_h2c_data_hdr { - struct spdk_nvme_tcp_common_pdu_hdr common; +struct nvme_tcp_h2c_data_hdr { + struct nvme_tcp_common_pdu_hdr common; uint16_t cccid; uint16_t ttag; uint32_t datao; uint32_t datal; uint8_t reserved20[4]; }; -SPDK_STATIC_ASSERT(sizeof(struct spdk_nvme_tcp_h2c_data_hdr) == 24, "Incorrect size"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_h2c_data_hdr, cccid) == 8, "Incorrect offset"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_h2c_data_hdr, ttag) == 10, "Incorrect offset"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_h2c_data_hdr, datao) == 12, "Incorrect offset"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_h2c_data_hdr, datal) == 16, "Incorrect offset"); +_Static_assert(sizeof(struct nvme_tcp_h2c_data_hdr) == 24, "Incorrect size"); +_Static_assert(offsetof(struct nvme_tcp_h2c_data_hdr, cccid) == 8, "Incorrect offset"); +_Static_assert(offsetof(struct nvme_tcp_h2c_data_hdr, ttag) == 10, "Incorrect offset"); +_Static_assert(offsetof(struct nvme_tcp_h2c_data_hdr, datao) == 12, "Incorrect offset"); +_Static_assert(offsetof(struct nvme_tcp_h2c_data_hdr, datal) == 16, "Incorrect offset"); -#define SPDK_NVME_TCP_H2C_DATA_FLAGS_LAST_PDU (1u << 2) -#define SPDK_NVME_TCP_H2C_DATA_FLAGS_SUCCESS (1u << 3) -#define SPDK_NVME_TCP_H2C_DATA_PDO_MULT 8u +#define NVME_TCP_H2C_DATA_FLAGS_LAST_PDU (1u << 2) +#define NVME_TCP_H2C_DATA_FLAGS_SUCCESS (1u << 3) +#define NVME_TCP_H2C_DATA_PDO_MULT 8u /** * C2HData * - * hdr.pdu_type == SPDK_NVME_TCP_PDU_TYPE_C2H_DATA + * hdr.pdu_type == NVME_TCP_PDU_TYPE_C2H_DATA */ -struct spdk_nvme_tcp_c2h_data_hdr { - struct spdk_nvme_tcp_common_pdu_hdr common; +struct nvme_tcp_c2h_data_hdr { + struct nvme_tcp_common_pdu_hdr common; uint16_t cccid; uint8_t reserved10[2]; uint32_t datao; uint32_t datal; uint8_t reserved20[4]; }; -SPDK_STATIC_ASSERT(sizeof(struct spdk_nvme_tcp_c2h_data_hdr) == 24, "Incorrect size"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_c2h_data_hdr, cccid) == 8, "Incorrect offset"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_c2h_data_hdr, datao) == 12, "Incorrect offset"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_c2h_data_hdr, datal) == 16, "Incorrect offset"); +_Static_assert(sizeof(struct nvme_tcp_c2h_data_hdr) == 24, "Incorrect size"); +_Static_assert(offsetof(struct nvme_tcp_c2h_data_hdr, cccid) == 8, "Incorrect offset"); +_Static_assert(offsetof(struct nvme_tcp_c2h_data_hdr, datao) == 12, "Incorrect offset"); +_Static_assert(offsetof(struct nvme_tcp_c2h_data_hdr, datal) == 16, "Incorrect offset"); -#define SPDK_NVME_TCP_C2H_DATA_FLAGS_SUCCESS (1u << 3) -#define SPDK_NVME_TCP_C2H_DATA_FLAGS_LAST_PDU (1u << 2) -#define SPDK_NVME_TCP_C2H_DATA_PDO_MULT 8u +#define NVME_TCP_C2H_DATA_FLAGS_SUCCESS (1u << 3) +#define NVME_TCP_C2H_DATA_FLAGS_LAST_PDU (1u << 2) +#define NVME_TCP_C2H_DATA_PDO_MULT 8u /** * R2T * - * common.pdu_type == SPDK_NVME_TCP_PDU_TYPE_R2T + * common.pdu_type == NVME_TCP_PDU_TYPE_R2T */ -struct spdk_nvme_tcp_r2t_hdr { - struct spdk_nvme_tcp_common_pdu_hdr common; +struct nvme_tcp_r2t_hdr { + struct nvme_tcp_common_pdu_hdr common; uint16_t cccid; uint16_t ttag; uint32_t r2to; uint32_t r2tl; uint8_t reserved20[4]; }; -SPDK_STATIC_ASSERT(sizeof(struct spdk_nvme_tcp_r2t_hdr) == 24, "Incorrect size"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_r2t_hdr, cccid) == 8, "Incorrect offset"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_r2t_hdr, ttag) == 10, "Incorrect offset"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_r2t_hdr, r2to) == 12, "Incorrect offset"); -SPDK_STATIC_ASSERT(offsetof(struct spdk_nvme_tcp_r2t_hdr, r2tl) == 16, "Incorrect offset"); +_Static_assert(sizeof(struct nvme_tcp_r2t_hdr) == 24, "Incorrect size"); +_Static_assert(offsetof(struct nvme_tcp_r2t_hdr, cccid) == 8, "Incorrect offset"); +_Static_assert(offsetof(struct nvme_tcp_r2t_hdr, ttag) == 10, "Incorrect offset"); +_Static_assert(offsetof(struct nvme_tcp_r2t_hdr, r2to) == 12, "Incorrect offset"); +_Static_assert(offsetof(struct nvme_tcp_r2t_hdr, r2tl) == 16, "Incorrect offset"); #pragma pack(pop) -#endif /* __NVMF_SPEC_H__ */ +#endif /* __NVMF_PROTO_H__ */