73a701d7d0
It is the same as spdk_nvme_cpl, aside from reserved fields. Change-Id: I62b0718dd58c998b4d26a0d1b44ee16d37eff25d Signed-off-by: Daniel Verkamp <daniel.verkamp@intel.com>
564 lines
16 KiB
C
564 lines
16 KiB
C
/*-
|
|
* BSD LICENSE
|
|
*
|
|
* Copyright (c) Intel Corporation.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in
|
|
* the documentation and/or other materials provided with the
|
|
* distribution.
|
|
* * Neither the name of Intel Corporation nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#ifndef SPDK_NVMF_SPEC_H
|
|
#define SPDK_NVMF_SPEC_H
|
|
|
|
#include <stdint.h>
|
|
|
|
#include "spdk/assert.h"
|
|
#include "spdk/nvme_spec.h"
|
|
|
|
/**
|
|
* \file
|
|
*
|
|
*/
|
|
|
|
#pragma pack(push, 1)
|
|
|
|
struct spdk_nvmf_capsule_cmd {
|
|
uint8_t opcode;
|
|
uint8_t reserved1;
|
|
uint16_t cid;
|
|
uint8_t fctype;
|
|
uint8_t reserved2[35];
|
|
uint8_t fabric_specific[24];
|
|
};
|
|
SPDK_STATIC_ASSERT(sizeof(struct spdk_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 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,
|
|
};
|
|
|
|
/**
|
|
* RDMA Queue Pair service types
|
|
*/
|
|
enum spdk_nvmf_rdma_qp_service_types {
|
|
/** Reliable connected */
|
|
SPDK_NVMF_QP_TYPE_RELIABLE_CONNECTED = 0x1,
|
|
/** Reliable datagram */
|
|
SPDK_NVMF_OQ_TYPE_RELIABLE_DATAGRAM = 0x2,
|
|
};
|
|
|
|
/**
|
|
* RDMA provider types
|
|
*/
|
|
enum spdk_nvmf_rdma_provider_types {
|
|
SPDK_NVMF_RDMA_NO_PROVIDER = 0x1,
|
|
SPDK_NVMF_RDMA_PRTYPE_IB = 0x2,
|
|
SPDK_NVMF_RDMA_PRTYPE_ROCE = 0x3,
|
|
SPDK_NVMF_RDMA_PRTYPE_ROCE2 = 0x4,
|
|
SPDK_NVMF_RDMA_PRTYPE_IWARP = 0x5,
|
|
};
|
|
|
|
/**
|
|
* RDMA connection management service types
|
|
*/
|
|
enum spdk_nvmf_rdma_connection_mgmt_service {
|
|
/** Sockets based endpoint addressing */
|
|
SPDK_NVMF_RDMA_CMS_RDMA_CM = 0x1,
|
|
};
|
|
|
|
/**
|
|
* NVMe over Fabrics transport types
|
|
*/
|
|
enum spdk_nvmf_transport_types {
|
|
SPDK_NVMF_TRANS_RDMA = 0x1,
|
|
SPDK_NVMF_TRANS_FC = 0x2,
|
|
SPDK_NVMF_TRANS_INTRA_HOST = 0xfe,
|
|
};
|
|
|
|
/**
|
|
* Address family types
|
|
*/
|
|
enum spdk_nvmf_address_family_types {
|
|
SPDK_NVMF_ADDR_FAMILY_IPV4 = 0x1,
|
|
SPDK_NVMF_ADDR_FAMILY_IPV6 = 0x2,
|
|
SPDK_NVMF_ADDR_FAMILY_IB = 0x3,
|
|
SPDK_NVMF_ADDR_FAMILY_FC = 0x4,
|
|
SPDK_NVMF_ADDR_FAMILY_INTRA_HOST = 0xfe,
|
|
};
|
|
|
|
/**
|
|
* NVM subsystem types
|
|
*/
|
|
enum spdk_nvmf_subsystem_types {
|
|
/** Discovery type for NVM subsystem */
|
|
SPDK_NVMF_SUB_DISCOVERY = 0x1,
|
|
/** NVMe type for NVM subsystem */
|
|
SPDK_NVMF_SUB_NVME = 0x2,
|
|
};
|
|
|
|
/**
|
|
* Connections shall be made over a fabric secure channel
|
|
*/
|
|
enum spdk_nvmf_transport_requirements {
|
|
SPDK_NVMF_TREQ_NOT_SPECIFIED = 0x0,
|
|
SPDK_NVMF_TREQ_REQUIRED = 0x1,
|
|
SPDK_NVMF_TREQ_NOT_REQUIRED = 0x2,
|
|
};
|
|
|
|
struct spdk_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;
|
|
uint8_t reserved3;
|
|
uint8_t spsp0;
|
|
uint8_t spsp1;
|
|
uint8_t secp;
|
|
uint32_t al;
|
|
uint8_t reserved4[16];
|
|
};
|
|
SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_fabric_auth_recv_cmd) == 64, "Incorrect size");
|
|
|
|
struct spdk_nvmf_fabric_auth_recv_rsp {
|
|
uint8_t reserved0[8];
|
|
uint16_t sqhd;
|
|
uint8_t reserved1[2];
|
|
uint16_t cid;
|
|
struct spdk_nvme_status status;
|
|
};
|
|
SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_fabric_auth_recv_rsp) == 16, "Incorrect size");
|
|
|
|
struct spdk_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;
|
|
uint8_t reserved3;
|
|
uint8_t spsp0;
|
|
uint8_t spsp1;
|
|
uint8_t secp;
|
|
uint32_t tl;
|
|
uint8_t reserved4[16];
|
|
};
|
|
SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_fabric_auth_send_cmd) == 64, "Incorrect size");
|
|
|
|
struct spdk_nvmf_fabric_auth_send_rsp {
|
|
uint8_t reserved0[8];
|
|
uint16_t sqhd;
|
|
uint8_t reserved1[2];
|
|
uint16_t cid;
|
|
struct spdk_nvme_status status;
|
|
};
|
|
SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_fabric_auth_send_rsp) == 16, "Incorrect size");
|
|
|
|
struct spdk_nvmf_fabric_connect_data {
|
|
uint8_t hostid[16];
|
|
uint16_t cntlid;
|
|
uint8_t reserved5[238];
|
|
uint8_t subnqn[256];
|
|
uint8_t hostnqn[256];
|
|
uint8_t reserved6[256];
|
|
};
|
|
SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_fabric_connect_data) == 1024, "Incorrect size");
|
|
|
|
#define SPDK_NVMF_CONNECT_ATTR_PRIORITY_URGENT 0x00
|
|
#define SPDK_NVMF_CONNECT_ATTR_PRIORITY_HIGH 0x01
|
|
#define SPDK_NVMF_CONNECT_ATTR_PRIORITY_MEDIUM 0x02
|
|
#define SPDK_NVMF_CONNECT_ATTR_PRIORITY_LOW 0x03
|
|
#define SPDK_NVMF_CONNECT_ATTR_RESERVED 0xFC
|
|
|
|
struct spdk_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;
|
|
uint16_t recfmt; /* Connect Record Format */
|
|
uint16_t qid; /* Queue Identifier */
|
|
uint16_t sqsize; /* Submission Queue Size */
|
|
uint8_t cattr; /* queue attributes */
|
|
uint8_t reserved3;
|
|
uint32_t kato; /* keep alive timeout */
|
|
uint8_t reserved4[12];
|
|
};
|
|
SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_fabric_connect_cmd) == 64, "Incorrect size");
|
|
|
|
struct spdk_nvmf_fabric_connect_rsp {
|
|
union {
|
|
struct {
|
|
uint16_t cntlid;
|
|
uint16_t authreq;
|
|
} success;
|
|
|
|
struct {
|
|
uint16_t ipo;
|
|
uint8_t iattr;
|
|
uint8_t reserved;
|
|
} invalid;
|
|
|
|
uint32_t raw;
|
|
} status_code_specific;
|
|
|
|
uint32_t reserved0;
|
|
uint16_t sqhd;
|
|
uint16_t reserved1;
|
|
uint16_t cid;
|
|
struct spdk_nvme_status status;
|
|
};
|
|
SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_fabric_connect_rsp) == 16, "Incorrect size");
|
|
|
|
#define SPDK_NVMF_PROP_CAP_OFST 0x0
|
|
#define SPDK_NVMF_PROP_VS_OFST 0x8
|
|
#define SPDK_NVMF_PROP_INTMS_OFST 0xC
|
|
#define SPDK_NVMF_PROP_INTMC_OFST 0x10
|
|
#define SPDK_NVMF_PROP_CC_OFST 0x14
|
|
#define SPDK_NVMF_PROP_CSTS_OFST 0x1C
|
|
#define SPDK_NVMF_PROP_NSSR_OFST 0x20
|
|
#define SPDK_NVMF_PROP_AQA_OFST 0x24
|
|
#define SPDK_NVMF_PROP_ASQ_OFST 0x28
|
|
#define SPDK_NVMF_PROP_ACQ_OFST 0x30
|
|
#define SPDK_NVMF_PROP_CMBLOC_OFST 0x38
|
|
#define SPDK_NVMF_PROP_CMBSZ_OFST 0x3C
|
|
|
|
#define SPDK_NVMF_PROP_CAP_LEN 0x8
|
|
#define SPDK_NVMF_PROP_VS_LEN 0x4
|
|
#define SPDK_NVMF_PROP_INTMS_LEN 0x4
|
|
#define SPDK_NVMF_PROP_INTMC_LEN 0x4
|
|
#define SPDK_NVMF_PROP_CC_LEN 0x4
|
|
#define SPDK_NVMF_PROP_CSTS_LEN 0x4
|
|
#define SPDK_NVMF_PROP_NSSR_LEN 0x4
|
|
#define SPDK_NVMF_PROP_AQA_LEN 0x4
|
|
#define SPDK_NVMF_PROP_ASQ_LEN 0x8
|
|
#define SPDK_NVMF_PROP_ACQ_LEN 0x8
|
|
#define SPDK_NVMF_PROP_CMBLOC_LEN 0x4
|
|
#define SPDK_NVMF_PROP_CMBSZ_LEN 0x4
|
|
|
|
union spdk_nvmf_property_size {
|
|
uint32_t raw;
|
|
struct {
|
|
uint32_t reserved : 16;
|
|
|
|
/** property address space size */
|
|
uint32_t size : 16;
|
|
} bits;
|
|
};
|
|
SPDK_STATIC_ASSERT(sizeof(union spdk_nvmf_property_size) == 4, "Incorrect size");
|
|
|
|
union spdk_nvmf_capsule_attr_lo {
|
|
uint32_t raw;
|
|
struct {
|
|
/** maximum response capsule size */
|
|
uint32_t rspsz : 16;
|
|
|
|
/** maximum command capsule size */
|
|
uint32_t cmdsz : 16;
|
|
} bits;
|
|
};
|
|
SPDK_STATIC_ASSERT(sizeof(union spdk_nvmf_capsule_attr_lo) == 4, "Incorrect size");
|
|
|
|
union spdk_nvmf_capsule_attr_hi {
|
|
uint32_t raw;
|
|
struct {
|
|
/** support capsule alignment in response capsules */
|
|
uint32_t reserved : 26;
|
|
|
|
/** support capsule alignment in response capsules */
|
|
uint32_t cairsp : 1;
|
|
|
|
/** support capsule alignment in command capsules */
|
|
uint32_t caicmd : 1;
|
|
|
|
/** support capsule metadata in response capsules */
|
|
uint32_t cmirsp : 1;
|
|
|
|
/** support capsule metadata in command capsules */
|
|
uint32_t cmicmd : 1;
|
|
|
|
/** support capsule data in response capsules */
|
|
uint32_t cdirsp : 1;
|
|
|
|
/** support capsule data in command capsules */
|
|
uint32_t cdicmd : 1;
|
|
} bits;
|
|
};
|
|
SPDK_STATIC_ASSERT(sizeof(union spdk_nvmf_capsule_attr_hi) == 4, "Incorrect size");
|
|
|
|
struct spdk_nvmf_ctrlr_properties {
|
|
union spdk_nvme_cap_lo_register cap_lo;
|
|
union spdk_nvme_cap_hi_register cap_hi;
|
|
|
|
uint32_t vs;
|
|
uint32_t intms;
|
|
uint32_t intmc;
|
|
|
|
union spdk_nvme_cc_register cc;
|
|
|
|
uint32_t reserved1;
|
|
union spdk_nvme_csts_register csts;
|
|
uint32_t nssr;
|
|
|
|
union spdk_nvme_aqa_register aqa;
|
|
|
|
uint64_t asq;
|
|
uint64_t acq;
|
|
|
|
uint32_t cmbloc;
|
|
uint32_t cmbsz;
|
|
|
|
uint8_t reserved2[0xEC0];
|
|
uint8_t reserved3[0x100];
|
|
union spdk_nvmf_property_size propsz;
|
|
uint32_t reserved4;
|
|
union spdk_nvmf_capsule_attr_lo capattr_lo;
|
|
union spdk_nvmf_capsule_attr_hi capattr_hi;
|
|
uint8_t reserved5[0x2F0];
|
|
};
|
|
SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_ctrlr_properties) == 4864, "Incorrect size");
|
|
SPDK_STATIC_ASSERT(SPDK_NVMF_PROP_CAP_OFST == offsetof(struct spdk_nvmf_ctrlr_properties, cap_lo),
|
|
"Incorrect register offset");
|
|
SPDK_STATIC_ASSERT(SPDK_NVMF_PROP_VS_OFST == offsetof(struct spdk_nvmf_ctrlr_properties, vs),
|
|
"Incorrect register offset");
|
|
SPDK_STATIC_ASSERT(SPDK_NVMF_PROP_INTMS_OFST == offsetof(struct spdk_nvmf_ctrlr_properties, intms),
|
|
"Incorrect register offset");
|
|
SPDK_STATIC_ASSERT(SPDK_NVMF_PROP_INTMC_OFST == offsetof(struct spdk_nvmf_ctrlr_properties, intmc),
|
|
"Incorrect register offset");
|
|
SPDK_STATIC_ASSERT(SPDK_NVMF_PROP_CC_OFST == offsetof(struct spdk_nvmf_ctrlr_properties, cc),
|
|
"Incorrect register offset");
|
|
SPDK_STATIC_ASSERT(SPDK_NVMF_PROP_CSTS_OFST == offsetof(struct spdk_nvmf_ctrlr_properties, csts),
|
|
"Incorrect register offset");
|
|
SPDK_STATIC_ASSERT(SPDK_NVMF_PROP_NSSR_OFST == offsetof(struct spdk_nvmf_ctrlr_properties, nssr),
|
|
"Incorrect register offset");
|
|
SPDK_STATIC_ASSERT(SPDK_NVMF_PROP_AQA_OFST == offsetof(struct spdk_nvmf_ctrlr_properties, aqa),
|
|
"Incorrect register offset");
|
|
SPDK_STATIC_ASSERT(SPDK_NVMF_PROP_ASQ_OFST == offsetof(struct spdk_nvmf_ctrlr_properties, asq),
|
|
"Incorrect register offset");
|
|
SPDK_STATIC_ASSERT(SPDK_NVMF_PROP_ACQ_OFST == offsetof(struct spdk_nvmf_ctrlr_properties, acq),
|
|
"Incorrect register offset");
|
|
SPDK_STATIC_ASSERT(SPDK_NVMF_PROP_CMBLOC_OFST == offsetof(struct spdk_nvmf_ctrlr_properties,
|
|
cmbloc),
|
|
"Incorrect property offset");
|
|
SPDK_STATIC_ASSERT(SPDK_NVMF_PROP_CMBSZ_OFST == offsetof(struct spdk_nvmf_ctrlr_properties, cmbsz),
|
|
"Incorrect property offset");
|
|
|
|
struct spdk_nvmf_fabric_prop_get_cmd {
|
|
uint8_t opcode;
|
|
uint8_t reserved1;
|
|
uint16_t cid;
|
|
uint8_t fctype;
|
|
uint8_t reserved2[35];
|
|
uint8_t attrib;
|
|
uint8_t reserved3[3];
|
|
uint32_t ofst;
|
|
uint8_t reserved4[16];
|
|
};
|
|
SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_fabric_prop_get_cmd) == 64, "Incorrect size");
|
|
|
|
struct spdk_nvmf_fabric_prop_get_rsp {
|
|
union {
|
|
uint64_t u64;
|
|
struct {
|
|
uint32_t low;
|
|
uint32_t high;
|
|
} u32;
|
|
} value;
|
|
|
|
uint16_t sqhd;
|
|
uint16_t reserved0;
|
|
uint16_t cid;
|
|
struct spdk_nvme_status status;
|
|
};
|
|
SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_fabric_prop_get_rsp) == 16, "Incorrect size");
|
|
|
|
struct spdk_nvmf_fabric_prop_set_cmd {
|
|
uint8_t opcode;
|
|
uint8_t reserved0;
|
|
uint16_t cid;
|
|
uint8_t fctype;
|
|
uint8_t reserved1[35];
|
|
uint8_t attrib;
|
|
uint8_t reserved2[3];
|
|
uint32_t ofst;
|
|
|
|
union {
|
|
uint64_t u64;
|
|
struct {
|
|
uint32_t low;
|
|
uint32_t high;
|
|
} u32;
|
|
} value;
|
|
|
|
uint8_t reserved4[8];
|
|
};
|
|
SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_fabric_prop_set_cmd) == 64, "Incorrect size");
|
|
|
|
struct spdk_nvmf_fabric_prop_set_rsp {
|
|
uint8_t reserved0[8];
|
|
uint16_t sqhd;
|
|
uint16_t reserved1;
|
|
uint16_t cid;
|
|
struct spdk_nvme_status status;
|
|
};
|
|
SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_fabric_prop_set_rsp) == 16, "Incorrect size");
|
|
|
|
struct spdk_nvmf_extended_identify_ctrlr_data {
|
|
uint32_t ioccsz;
|
|
uint32_t iorcsz;
|
|
uint16_t icdoff;
|
|
uint8_t ctrattr;
|
|
uint8_t msdbd;
|
|
uint8_t reserved[244];
|
|
};
|
|
SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_extended_identify_ctrlr_data) == 256, "Incorrect size");
|
|
|
|
#define SPDK_NVMF_DISCOVERY_NQN "nqn.2014-08.org.nvmexpress.discovery"
|
|
|
|
struct spdk_nvmf_discovery_identify_data {
|
|
uint8_t reserved0[64];
|
|
uint64_t fr;
|
|
uint8_t reserved1[5];
|
|
uint8_t mdts;
|
|
uint16_t cntlid;
|
|
uint32_t ver;
|
|
uint8_t reserved2[177];
|
|
uint8_t lpa;
|
|
uint8_t elpe;
|
|
uint8_t reserved3[505];
|
|
uint8_t subnqn[256];
|
|
uint8_t discovery[1024];
|
|
uint8_t reserved4[1024];
|
|
uint8_t vs[1024];
|
|
};
|
|
SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_discovery_identify_data) == 4096, "Incorrect size");
|
|
|
|
struct spdk_nvmf_rdma_transport_specific_address {
|
|
uint8_t rdma_qptype; /* see spdk_nvmf_rdma_qp_service_types */
|
|
uint8_t rdma_prtype; /* see spdk_nvmf_rdma_provider_types */
|
|
uint8_t rdma_cms; /* see spdk_nvmf_rdma_connection_mgmt_service */
|
|
uint8_t reserved0[5];
|
|
uint16_t rdma_pkey;
|
|
uint8_t reserved2[246];
|
|
};
|
|
SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_rdma_transport_specific_address) == 256,
|
|
"Incorrect size");
|
|
|
|
struct spdk_nvmf_discovery_log_page_entry {
|
|
uint8_t trtype; /* transport type */
|
|
uint8_t adrfam; /* address family */
|
|
uint8_t subtype;
|
|
uint8_t treq;
|
|
uint16_t portid;
|
|
uint16_t cntlid;
|
|
uint8_t reserved0[24];
|
|
uint8_t trsvcid[32];
|
|
uint8_t reserved1[192];
|
|
uint8_t subnqn[256];
|
|
uint8_t traddr[256];
|
|
union {
|
|
struct spdk_nvmf_rdma_transport_specific_address rdma;
|
|
} tsas;
|
|
};
|
|
SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_discovery_log_page_entry) == 1024, "Incorrect size");
|
|
|
|
struct spdk_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];
|
|
};
|
|
SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_discovery_log_page) == 1024, "Incorrect size");
|
|
|
|
/* RDMA Fabric specific definitions below */
|
|
|
|
#define SPDK_NVME_SGL_SUBTYPE_INVALIDATE_KEY 0xF
|
|
|
|
struct spdk_nvmf_rdma_request_private_data {
|
|
uint16_t recfmt; /* record format */
|
|
uint16_t qid; /* queue id */
|
|
uint16_t hrqsize; /* host receive queue size */
|
|
uint16_t hsqsize; /* host send queue size */
|
|
uint8_t reserved[24];
|
|
};
|
|
SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_rdma_request_private_data) == 32, "Incorrect size");
|
|
|
|
struct spdk_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");
|
|
|
|
struct spdk_nvmf_rdma_reject_private_data {
|
|
uint16_t recfmt; /* record format */
|
|
struct spdk_nvme_status status;
|
|
};
|
|
SPDK_STATIC_ASSERT(sizeof(struct spdk_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;
|
|
};
|
|
SPDK_STATIC_ASSERT(sizeof(union spdk_nvmf_rdma_private_data) == 32, "Incorrect size");
|
|
|
|
enum spdk_nvmf_rdma_transport_errors {
|
|
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,
|
|
};
|
|
|
|
#pragma pack(pop)
|
|
|
|
#endif /* __NVMF_SPEC_H__ */
|