git: 878d102ab9e5 - main - nvmf_proto.h: Update for use in FreeBSD
- Go to: [ bottom of page ] [ top of archives ] [ this month ]
Date: Fri, 03 May 2024 00:15:38 UTC
The branch main has been updated by jhb: URL: https://cgit.FreeBSD.org/src/commit/?id=878d102ab9e5cd262fc478ebfdabf31f1c6b84a5 commit 878d102ab9e5cd262fc478ebfdabf31f1c6b84a5 Author: John Baldwin <jhb@FreeBSD.org> AuthorDate: 2024-05-02 23:26:33 +0000 Commit: John Baldwin <jhb@FreeBSD.org> 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. <dev/nvme/nvme.h> 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 <dev/nvme/nvme.h>. - Use types from <dev/nvme/nvme.h> 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 <sys/types.h> +#include <sys/cdefs.h> +#ifdef _KERNEL +#include <sys/stddef.h> +#else +#include <stddef.h> +#endif +#include <dev/nvme/nvme.h> /** * \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__ */