Add reservation acquire, reservation register,
reservation release and reservation report commands
in the nvme device layer.
By introducing these commands, this enables the nvme
device to perform reservation-related tasks, including
querying keys, querying reservation status, registering
reservation keys, initiating and releasing reservations,
as well as clearing and preempting reservations held by
other keys.
These commands are crucial for management and control of
shared storage resources in a persistent manner.
Signed-off-by: Changqi Lu <luchangqi.123@bytedance.com>
Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
Acked-by: Klaus Jensen <k.jensen@samsung.com>
---
hw/nvme/ctrl.c | 359 +++++++++++++++++++++++++++++++++++++++++++
hw/nvme/ns.c | 6 +
hw/nvme/nvme.h | 10 ++
include/block/nvme.h | 44 ++++++
4 files changed, 419 insertions(+)
diff --git a/hw/nvme/ctrl.c b/hw/nvme/ctrl.c
index ad212de723..ffb876a99f 100644
--- a/hw/nvme/ctrl.c
+++ b/hw/nvme/ctrl.c
@@ -294,6 +294,10 @@ static const uint32_t nvme_cse_iocs_nvm[256] = {
[NVME_CMD_COMPARE] = NVME_CMD_EFF_CSUPP,
[NVME_CMD_IO_MGMT_RECV] = NVME_CMD_EFF_CSUPP,
[NVME_CMD_IO_MGMT_SEND] = NVME_CMD_EFF_CSUPP | NVME_CMD_EFF_LBCC,
+ [NVME_CMD_RESV_REGISTER] = NVME_CMD_EFF_CSUPP,
+ [NVME_CMD_RESV_REPORT] = NVME_CMD_EFF_CSUPP,
+ [NVME_CMD_RESV_ACQUIRE] = NVME_CMD_EFF_CSUPP,
+ [NVME_CMD_RESV_RELEASE] = NVME_CMD_EFF_CSUPP,
};
static const uint32_t nvme_cse_iocs_zoned[256] = {
@@ -308,6 +312,10 @@ static const uint32_t nvme_cse_iocs_zoned[256] = {
[NVME_CMD_ZONE_APPEND] = NVME_CMD_EFF_CSUPP | NVME_CMD_EFF_LBCC,
[NVME_CMD_ZONE_MGMT_SEND] = NVME_CMD_EFF_CSUPP | NVME_CMD_EFF_LBCC,
[NVME_CMD_ZONE_MGMT_RECV] = NVME_CMD_EFF_CSUPP,
+ [NVME_CMD_RESV_REGISTER] = NVME_CMD_EFF_CSUPP,
+ [NVME_CMD_RESV_REPORT] = NVME_CMD_EFF_CSUPP,
+ [NVME_CMD_RESV_ACQUIRE] = NVME_CMD_EFF_CSUPP,
+ [NVME_CMD_RESV_RELEASE] = NVME_CMD_EFF_CSUPP,
};
static void nvme_process_sq(void *opaque);
@@ -1747,6 +1755,13 @@ static void nvme_aio_err(NvmeRequest *req, int ret)
case NVME_CMD_READ:
status = NVME_UNRECOVERED_READ;
break;
+ case NVME_CMD_RESV_REPORT:
+ if (ret == -ENOTSUP) {
+ status = NVME_INVALID_OPCODE;
+ } else {
+ status = NVME_UNRECOVERED_READ;
+ }
+ break;
case NVME_CMD_FLUSH:
case NVME_CMD_WRITE:
case NVME_CMD_WRITE_ZEROES:
@@ -1754,6 +1769,15 @@ static void nvme_aio_err(NvmeRequest *req, int ret)
case NVME_CMD_COPY:
status = NVME_WRITE_FAULT;
break;
+ case NVME_CMD_RESV_REGISTER:
+ case NVME_CMD_RESV_ACQUIRE:
+ case NVME_CMD_RESV_RELEASE:
+ if (ret == -ENOTSUP) {
+ status = NVME_INVALID_OPCODE;
+ } else {
+ status = NVME_WRITE_FAULT;
+ }
+ break;
default:
status = NVME_INTERNAL_DEV_ERROR;
break;
@@ -2692,6 +2716,333 @@ static uint16_t nvme_verify(NvmeCtrl *n, NvmeRequest *req)
return NVME_NO_COMPLETE;
}
+typedef struct NvmeKeyInfo {
+ uint64_t cr_key;
+ uint64_t nr_key;
+} NvmeKeyInfo;
+
+static uint16_t nvme_resv_register(NvmeCtrl *n, NvmeRequest *req)
+{
+ int ret;
+ NvmeKeyInfo key_info;
+ NvmeNamespace *ns = req->ns;
+ uint32_t cdw10 = le32_to_cpu(req->cmd.cdw10);
+ bool ignore_key = cdw10 >> 3 & 0x1;
+ uint8_t action = cdw10 & 0x7;
+ uint8_t ptpl = cdw10 >> 30 & 0x3;
+ bool aptpl;
+
+ if (!nvme_support_pr(ns)) {
+ return NVME_INVALID_OPCODE;
+ }
+
+ switch (ptpl) {
+ case NVME_RESV_PTPL_NO_CHANGE:
+ aptpl = (ns->id_ns.rescap & NVME_PR_CAP_PTPL) ? true : false;
+ break;
+ case NVME_RESV_PTPL_DISABLE:
+ aptpl = false;
+ break;
+ case NVME_RESV_PTPL_ENABLE:
+ aptpl = true;
+ break;
+ default:
+ return NVME_INVALID_FIELD;
+ }
+
+ ret = nvme_h2c(n, (uint8_t *)&key_info, sizeof(NvmeKeyInfo), req);
+ if (ret) {
+ return ret;
+ }
+
+ key_info.cr_key = le64_to_cpu(key_info.cr_key);
+ key_info.nr_key = le64_to_cpu(key_info.nr_key);
+
+ switch (action) {
+ case NVME_RESV_REGISTER_ACTION_REGISTER:
+ req->aiocb = blk_aio_pr_register(ns->blkconf.blk, 0,
+ key_info.nr_key, 0, aptpl,
+ ignore_key, nvme_misc_cb,
+ req);
+ break;
+ case NVME_RESV_REGISTER_ACTION_UNREGISTER:
+ req->aiocb = blk_aio_pr_register(ns->blkconf.blk, key_info.cr_key, 0,
+ 0, aptpl, ignore_key,
+ nvme_misc_cb, req);
+ break;
+ case NVME_RESV_REGISTER_ACTION_REPLACE:
+ req->aiocb = blk_aio_pr_register(ns->blkconf.blk, key_info.cr_key,
+ key_info.nr_key, 0, aptpl, ignore_key,
+ nvme_misc_cb, req);
+ break;
+ default:
+ return NVME_INVALID_FIELD;
+ }
+
+ return NVME_NO_COMPLETE;
+}
+
+static uint16_t nvme_resv_release(NvmeCtrl *n, NvmeRequest *req)
+{
+ int ret;
+ uint64_t cr_key;
+ NvmeNamespace *ns = req->ns;
+ uint32_t cdw10 = le32_to_cpu(req->cmd.cdw10);
+ uint8_t action = cdw10 & 0x7;
+ NvmeResvType type = cdw10 >> 8 & 0xff;
+
+ if (!nvme_support_pr(ns)) {
+ return NVME_INVALID_OPCODE;
+ }
+
+ ret = nvme_h2c(n, (uint8_t *)&cr_key, sizeof(cr_key), req);
+ if (ret) {
+ return ret;
+ }
+
+ cr_key = le64_to_cpu(cr_key);
+
+ switch (action) {
+ case NVME_RESV_RELEASE_ACTION_RELEASE:
+ req->aiocb = blk_aio_pr_release(ns->blkconf.blk, cr_key,
+ nvme_pr_type_to_block(type),
+ nvme_misc_cb, req);
+ break;
+ case NVME_RESV_RELEASE_ACTION_CLEAR:
+ req->aiocb = blk_aio_pr_clear(ns->blkconf.blk, cr_key,
+ nvme_misc_cb, req);
+ break;
+ default:
+ return NVME_INVALID_FIELD;
+ }
+
+ return NVME_NO_COMPLETE;
+}
+
+static uint16_t nvme_resv_acquire(NvmeCtrl *n, NvmeRequest *req)
+{
+ int ret;
+ NvmeKeyInfo key_info;
+ NvmeNamespace *ns = req->ns;
+ uint32_t cdw10 = le32_to_cpu(req->cmd.cdw10);
+ uint8_t action = cdw10 & 0x7;
+ NvmeResvType type = cdw10 >> 8 & 0xff;
+
+ if (!nvme_support_pr(ns)) {
+ return NVME_INVALID_OPCODE;
+ }
+
+ ret = nvme_h2c(n, (uint8_t *)&key_info, sizeof(NvmeKeyInfo), req);
+ if (ret) {
+ return ret;
+ }
+
+ key_info.cr_key = le64_to_cpu(key_info.cr_key);
+ key_info.nr_key = le64_to_cpu(key_info.nr_key);
+
+ switch (action) {
+ case NVME_RESV_ACQUIRE_ACTION_ACQUIRE:
+ req->aiocb = blk_aio_pr_reserve(ns->blkconf.blk, key_info.cr_key,
+ nvme_pr_type_to_block(type),
+ nvme_misc_cb, req);
+ break;
+ case NVME_RESV_ACQUIRE_ACTION_PREEMPT:
+ req->aiocb = blk_aio_pr_preempt(ns->blkconf.blk,
+ key_info.cr_key, key_info.nr_key,
+ nvme_pr_type_to_block(type),
+ false, nvme_misc_cb, req);
+ break;
+ case NVME_RESV_ACQUIRE_ACTION_PREEMPT_AND_ABORT:
+ req->aiocb = blk_aio_pr_preempt(ns->blkconf.blk, key_info.cr_key,
+ key_info.nr_key, type, true,
+ nvme_misc_cb, req);
+ break;
+ default:
+ return NVME_INVALID_FIELD;
+ }
+
+ return NVME_NO_COMPLETE;
+}
+
+typedef struct NvmeResvKeys {
+ uint32_t generation;
+ uint32_t num_keys;
+ uint64_t *keys;
+ NvmeRequest *req;
+} NvmeResvKeys;
+
+typedef struct NvmeReadReservation {
+ uint32_t generation;
+ uint64_t key;
+ BlockPrType type;
+ NvmeRequest *req;
+ NvmeResvKeys *keys_info;
+} NvmeReadReservation;
+
+static int nvme_read_reservation_cb(NvmeReadReservation *reservation)
+{
+ int rc;
+ NvmeReservationStatus *nvme_status;
+ NvmeRequest *req = reservation->req;
+ NvmeCtrl *n = req->sq->ctrl;
+ NvmeResvKeys *keys_info = reservation->keys_info;
+ int len = sizeof(NvmeReservationStatusHeader) +
+ sizeof(NvmeRegisteredCtrl) * keys_info->num_keys;
+
+ nvme_status = g_malloc(len);
+ nvme_status->header.gen = cpu_to_be32(reservation->generation);
+ nvme_status->header.rtype = block_pr_type_to_nvme(reservation->type);
+ nvme_status->header.regctl = cpu_to_be16(keys_info->num_keys);
+ for (int i = 0; i < keys_info->num_keys; i++) {
+ uint16_t ctnlid = nvme_ctrl(req)->cntlid;
+ nvme_status->regctl_ds[i].cntlid = cpu_to_be16(ctnlid);
+ nvme_status->regctl_ds[i].rkey = cpu_to_be64(keys_info->keys[i]);
+ nvme_status->regctl_ds[i].rcsts = keys_info->keys[i] ==
+ reservation->key ? 1 : 0;
+ /* hostid is not supported currently */
+ memset(&nvme_status->regctl_ds[i].hostid, 0, 8);
+ }
+
+ rc = nvme_c2h(n, (uint8_t *)nvme_status, len, req);
+ g_free(nvme_status);
+ return rc;
+}
+
+static int nvme_read_reservation_ext_cb(NvmeReadReservation *reservation)
+{
+ int rc;
+ NvmeReservationStatusExt *nvme_status_ext;
+ NvmeRequest *req = reservation->req;
+ NvmeCtrl *n = req->sq->ctrl;
+ NvmeResvKeys *keys_info = reservation->keys_info;
+ int len = sizeof(NvmeReservationStatusHeader) +
+ sizeof(uint8_t) * 40 +
+ sizeof(NvmeRegisteredCtrlExt) * keys_info->num_keys;
+
+ nvme_status_ext = g_malloc(len);
+ nvme_status_ext->header.gen = cpu_to_be32(reservation->generation);
+ nvme_status_ext->header.rtype = block_pr_type_to_nvme(reservation->type);
+ nvme_status_ext->header.regctl = cpu_to_be16(keys_info->num_keys);
+
+ for (int i = 0; i < keys_info->num_keys; i++) {
+ uint16_t ctnlid = nvme_ctrl(req)->cntlid;
+ nvme_status_ext->regctl_eds[i].cntlid = cpu_to_be16(ctnlid);
+ nvme_status_ext->regctl_eds[i].rkey = cpu_to_be64(keys_info->keys[i]);
+ nvme_status_ext->regctl_eds[i].rcsts = keys_info->keys[i] ==
+ reservation->key ? 1 : 0;
+ /* hostid is not supported currently */
+ memset(&nvme_status_ext->regctl_eds[i].hostid, 0, 16);
+ }
+
+ rc = nvme_c2h(n, (uint8_t *)nvme_status_ext, len, req);
+ g_free(nvme_status_ext);
+ return rc;
+}
+
+static void nvme_resv_read_reservation_cb(void *opaque, int ret)
+{
+ NvmeReadReservation *reservation = opaque;
+ NvmeRequest *req = reservation->req;
+ bool eds = le32_to_cpu(req->cmd.cdw11) & 0x1;
+ NvmeResvKeys *keys_info = reservation->keys_info;
+
+ if (ret < 0) {
+ goto out;
+ }
+
+ if (eds) {
+ ret = nvme_read_reservation_ext_cb(reservation);
+ } else {
+ ret = nvme_read_reservation_cb(reservation);
+ }
+
+out:
+ g_free(keys_info->keys);
+ g_free(keys_info);
+ g_free(reservation);
+ nvme_misc_cb(req, ret);
+}
+
+static void nvme_resv_read_keys_cb(void *opaque, int ret)
+{
+ NvmeResvKeys *keys_info = opaque;
+ NvmeRequest *req = keys_info->req;
+ NvmeNamespace *ns = req->ns;
+ NvmeReadReservation *reservation;
+
+ if (ret < 0) {
+ goto out;
+ }
+
+ keys_info->num_keys = MIN(ret, keys_info->num_keys);
+ reservation = g_new0(NvmeReadReservation, 1);
+ memset(reservation, 0, sizeof(*reservation));
+ reservation->req = req;
+ reservation->keys_info = keys_info;
+
+ req->aiocb = blk_aio_pr_read_reservation(ns->blkconf.blk,
+ &reservation->generation, &reservation->key,
+ &reservation->type, nvme_resv_read_reservation_cb,
+ reservation);
+ return;
+
+out:
+ g_free(keys_info->keys);
+ g_free(keys_info);
+ nvme_misc_cb(req, ret);
+}
+
+
+static uint16_t nvme_resv_report(NvmeCtrl *n, NvmeRequest *req)
+{
+ int num_keys;
+ uint32_t cdw10 = le32_to_cpu(req->cmd.cdw10);
+ uint32_t cdw11 = le32_to_cpu(req->cmd.cdw11);
+ size_t buflen = (cdw10 + 1) * sizeof(uint32_t);
+ bool eds = cdw11 & 0x1;
+ NvmeNamespace *ns = req->ns;
+ NvmeResvKeys *keys_info;
+
+ if (!nvme_support_pr(ns)) {
+ return NVME_INVALID_OPCODE;
+ }
+
+ if (eds) {
+ if (buflen < sizeof(NvmeReservationStatusHeader) +
+ sizeof(uint8_t) * 40) {
+ return NVME_INVALID_FIELD;
+ }
+
+ num_keys = (buflen - sizeof(NvmeReservationStatusHeader) -
+ sizeof(uint8_t) * 40) /
+ sizeof(struct NvmeRegisteredCtrlExt);
+ } else {
+ if (buflen < sizeof(NvmeReservationStatusHeader)) {
+ return NVME_INVALID_FIELD;
+ }
+
+ num_keys = (buflen - sizeof(NvmeReservationStatusHeader)) /
+ sizeof(struct NvmeRegisteredCtrl);
+ }
+
+ /*
+ * The maximum number of keys that can be transmitted is 128.
+ */
+ num_keys = MIN(num_keys, NVME_MAX_RESERVATION_KEYS);
+ keys_info = g_new0(NvmeResvKeys, 1);
+ keys_info->generation = 0;
+ /* num_keys is the maximum number of keys that can be transmitted */
+ keys_info->num_keys = num_keys;
+ keys_info->keys = g_malloc(sizeof(uint64_t) * num_keys);
+ keys_info->req = req;
+
+ req->aiocb = blk_aio_pr_read_keys(ns->blkconf.blk, &keys_info->generation,
+ keys_info->num_keys, keys_info->keys,
+ nvme_resv_read_keys_cb, keys_info);
+
+ return NVME_NO_COMPLETE;
+}
+
typedef struct NvmeCopyAIOCB {
BlockAIOCB common;
BlockAIOCB *aiocb;
@@ -4469,6 +4820,14 @@ static uint16_t nvme_io_cmd(NvmeCtrl *n, NvmeRequest *req)
return nvme_dsm(n, req);
case NVME_CMD_VERIFY:
return nvme_verify(n, req);
+ case NVME_CMD_RESV_REGISTER:
+ return nvme_resv_register(n, req);
+ case NVME_CMD_RESV_REPORT:
+ return nvme_resv_report(n, req);
+ case NVME_CMD_RESV_ACQUIRE:
+ return nvme_resv_acquire(n, req);
+ case NVME_CMD_RESV_RELEASE:
+ return nvme_resv_release(n, req);
case NVME_CMD_COPY:
return nvme_copy(n, req);
case NVME_CMD_ZONE_MGMT_SEND:
diff --git a/hw/nvme/ns.c b/hw/nvme/ns.c
index a5c903d727..833bcbae08 100644
--- a/hw/nvme/ns.c
+++ b/hw/nvme/ns.c
@@ -60,6 +60,12 @@ void nvme_ns_init_format(NvmeNamespace *ns)
blk_pr_cap = blk_bs(ns->blkconf.blk)->bl.pr_cap;
id_ns->rescap = block_pr_cap_to_nvme(blk_pr_cap);
+ if (id_ns->rescap != NVME_PR_CAP_ALL &&
+ id_ns->rescap != NVME_PR_CAP_RW) {
+
+ /* Rescap either supports all or none of them */
+ id_ns->rescap = 0;
+ }
}
static int nvme_ns_init(NvmeNamespace *ns, Error **errp)
diff --git a/hw/nvme/nvme.h b/hw/nvme/nvme.h
index 6d0e456348..b87e1fa3b0 100644
--- a/hw/nvme/nvme.h
+++ b/hw/nvme/nvme.h
@@ -29,6 +29,7 @@
#define NVME_EUI64_DEFAULT ((uint64_t)0x5254000000000000)
#define NVME_FDP_MAX_EVENTS 63
#define NVME_FDP_MAXPIDS 128
+#define NVME_MAX_RESERVATION_KEYS 128
/*
* The controller only supports Submission and Completion Queue Entry Sizes of
@@ -470,6 +471,10 @@ static inline const char *nvme_io_opc_str(uint8_t opc)
case NVME_CMD_ZONE_MGMT_SEND: return "NVME_ZONED_CMD_MGMT_SEND";
case NVME_CMD_ZONE_MGMT_RECV: return "NVME_ZONED_CMD_MGMT_RECV";
case NVME_CMD_ZONE_APPEND: return "NVME_ZONED_CMD_ZONE_APPEND";
+ case NVME_CMD_RESV_REGISTER: return "NVME_CMD_RESV_REGISTER";
+ case NVME_CMD_RESV_REPORT: return "NVME_CMD_RESV_REPORT";
+ case NVME_CMD_RESV_ACQUIRE: return "NVME_CMD_RESV_ACQUIRE";
+ case NVME_CMD_RESV_RELEASE: return "NVME_CMD_RESV_RELEASE";
default: return "NVME_NVM_CMD_UNKNOWN";
}
}
@@ -558,6 +563,11 @@ static inline uint8_t block_pr_cap_to_nvme(uint8_t block_pr_cap)
return res;
}
+static inline bool nvme_support_pr(NvmeNamespace *ns)
+{
+ return (ns->id_ns.rescap & NVME_PR_CAP_RW) == NVME_PR_CAP_RW;
+}
+
typedef struct NvmeSQueue {
struct NvmeCtrl *ctrl;
uint16_t sqid;
diff --git a/include/block/nvme.h b/include/block/nvme.h
index 9b9eaeb3a7..2eec339028 100644
--- a/include/block/nvme.h
+++ b/include/block/nvme.h
@@ -692,6 +692,13 @@ typedef enum NVMEPrCap {
NVME_PR_CAP_WR_EX_AR = 1 << 5,
/* Exclusive Access All Registrants reservation type */
NVME_PR_CAP_EX_AC_AR = 1 << 6,
+ /* Write and Read reservation type */
+ NVME_PR_CAP_RW = (NVME_PR_CAP_WR_EX |
+ NVME_PR_CAP_EX_AC |
+ NVME_PR_CAP_WR_EX_RO |
+ NVME_PR_CAP_EX_AC_RO |
+ NVME_PR_CAP_WR_EX_AR |
+ NVME_PR_CAP_EX_AC_AR),
NVME_PR_CAP_ALL = (NVME_PR_CAP_PTPL |
NVME_PR_CAP_WR_EX |
@@ -702,6 +709,43 @@ typedef enum NVMEPrCap {
NVME_PR_CAP_EX_AC_AR),
} NvmePrCap;
+typedef struct QEMU_PACKED NvmeRegisteredCtrl {
+ uint16_t cntlid;
+ uint8_t rcsts;
+ uint8_t rsvd3[5];
+ uint8_t hostid[8];
+ uint64_t rkey;
+} NvmeRegisteredCtrl;
+
+typedef struct QEMU_PACKED NvmeRegisteredCtrlExt {
+ uint16_t cntlid;
+ uint8_t rcsts;
+ uint8_t rsvd3[5];
+ uint64_t rkey;
+ uint8_t hostid[16];
+ uint8_t rsvd32[32];
+} NvmeRegisteredCtrlExt;
+
+typedef struct QEMU_PACKED NvmeReservationStatusHeader {
+ uint32_t gen;
+ uint8_t rtype;
+ uint16_t regctl;
+ uint16_t resv5;
+ uint8_t ptpls;
+ uint8_t resv10[14];
+} NvmeReservationStatusHeader;
+
+typedef struct QEMU_PACKED NvmeReservationStatus {
+ struct NvmeReservationStatusHeader header;
+ struct NvmeRegisteredCtrl regctl_ds[];
+} NvmeReservationStatus;
+
+typedef struct QEMU_PACKED NvmeReservationStatusExt {
+ struct NvmeReservationStatusHeader header;
+ uint8_t rsvd24[40];
+ struct NvmeRegisteredCtrlExt regctl_eds[];
+} NvmeReservationStatusExt;
+
typedef struct QEMU_PACKED NvmeDeleteQ {
uint8_t opcode;
uint8_t flags;
--
2.20.1On Sep 26 15:45, Changqi Lu wrote:
> Add reservation acquire, reservation register,
> reservation release and reservation report commands
> in the nvme device layer.
>
> By introducing these commands, this enables the nvme
> device to perform reservation-related tasks, including
> querying keys, querying reservation status, registering
> reservation keys, initiating and releasing reservations,
> as well as clearing and preempting reservations held by
> other keys.
>
> These commands are crucial for management and control of
> shared storage resources in a persistent manner.
> Signed-off-by: Changqi Lu <luchangqi.123@bytedance.com>
> Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
> Acked-by: Klaus Jensen <k.jensen@samsung.com>
> ---
> hw/nvme/ctrl.c | 359 +++++++++++++++++++++++++++++++++++++++++++
> hw/nvme/ns.c | 6 +
> hw/nvme/nvme.h | 10 ++
> include/block/nvme.h | 44 ++++++
> 4 files changed, 419 insertions(+)
>
> diff --git a/hw/nvme/ctrl.c b/hw/nvme/ctrl.c
> index ad212de723..ffb876a99f 100644
> --- a/hw/nvme/ctrl.c
> +++ b/hw/nvme/ctrl.c
> @@ -294,6 +294,10 @@ static const uint32_t nvme_cse_iocs_nvm[256] = {
> [NVME_CMD_COMPARE] = NVME_CMD_EFF_CSUPP,
> [NVME_CMD_IO_MGMT_RECV] = NVME_CMD_EFF_CSUPP,
> [NVME_CMD_IO_MGMT_SEND] = NVME_CMD_EFF_CSUPP | NVME_CMD_EFF_LBCC,
> + [NVME_CMD_RESV_REGISTER] = NVME_CMD_EFF_CSUPP,
> + [NVME_CMD_RESV_REPORT] = NVME_CMD_EFF_CSUPP,
> + [NVME_CMD_RESV_ACQUIRE] = NVME_CMD_EFF_CSUPP,
> + [NVME_CMD_RESV_RELEASE] = NVME_CMD_EFF_CSUPP,
> };
>
> static const uint32_t nvme_cse_iocs_zoned[256] = {
> @@ -308,6 +312,10 @@ static const uint32_t nvme_cse_iocs_zoned[256] = {
> [NVME_CMD_ZONE_APPEND] = NVME_CMD_EFF_CSUPP | NVME_CMD_EFF_LBCC,
> [NVME_CMD_ZONE_MGMT_SEND] = NVME_CMD_EFF_CSUPP | NVME_CMD_EFF_LBCC,
> [NVME_CMD_ZONE_MGMT_RECV] = NVME_CMD_EFF_CSUPP,
> + [NVME_CMD_RESV_REGISTER] = NVME_CMD_EFF_CSUPP,
> + [NVME_CMD_RESV_REPORT] = NVME_CMD_EFF_CSUPP,
> + [NVME_CMD_RESV_ACQUIRE] = NVME_CMD_EFF_CSUPP,
> + [NVME_CMD_RESV_RELEASE] = NVME_CMD_EFF_CSUPP,
> };
>
> static void nvme_process_sq(void *opaque);
> @@ -1747,6 +1755,13 @@ static void nvme_aio_err(NvmeRequest *req, int ret)
> case NVME_CMD_READ:
> status = NVME_UNRECOVERED_READ;
> break;
> + case NVME_CMD_RESV_REPORT:
> + if (ret == -ENOTSUP) {
> + status = NVME_INVALID_OPCODE;
> + } else {
> + status = NVME_UNRECOVERED_READ;
> + }
> + break;
> case NVME_CMD_FLUSH:
> case NVME_CMD_WRITE:
> case NVME_CMD_WRITE_ZEROES:
> @@ -1754,6 +1769,15 @@ static void nvme_aio_err(NvmeRequest *req, int ret)
> case NVME_CMD_COPY:
> status = NVME_WRITE_FAULT;
> break;
> + case NVME_CMD_RESV_REGISTER:
> + case NVME_CMD_RESV_ACQUIRE:
> + case NVME_CMD_RESV_RELEASE:
> + if (ret == -ENOTSUP) {
> + status = NVME_INVALID_OPCODE;
> + } else {
> + status = NVME_WRITE_FAULT;
> + }
> + break;
Can the -ENOTSUP actually happen if the block layer has indicated
support for reservations? Or is this a left over from the way you
handled missing support earlier?
> default:
> status = NVME_INTERNAL_DEV_ERROR;
> break;
> @@ -2692,6 +2716,333 @@ static uint16_t nvme_verify(NvmeCtrl *n, NvmeRequest *req)
> return NVME_NO_COMPLETE;
> }
>
> +typedef struct NvmeKeyInfo {
> + uint64_t cr_key;
> + uint64_t nr_key;
> +} NvmeKeyInfo;
This is an spec data structure, should be in include/block/nvme.h (and
maybe use a union to alias NRKEY and PRKEY).
> +
> +static uint16_t nvme_resv_register(NvmeCtrl *n, NvmeRequest *req)
> +{
> + int ret;
> + NvmeKeyInfo key_info;
> + NvmeNamespace *ns = req->ns;
> + uint32_t cdw10 = le32_to_cpu(req->cmd.cdw10);
> + bool ignore_key = cdw10 >> 3 & 0x1;
Prefer parantheses around the shift arguments.
> + uint8_t action = cdw10 & 0x7;
> + uint8_t ptpl = cdw10 >> 30 & 0x3;
Parantheses. Name is technically CPTPL.
> + bool aptpl;
> +
> + if (!nvme_support_pr(ns)) {
> + return NVME_INVALID_OPCODE;
> + }
> +
> + switch (ptpl) {
> + case NVME_RESV_PTPL_NO_CHANGE:
> + aptpl = (ns->id_ns.rescap & NVME_PR_CAP_PTPL) ? true : false;
> + break;
> + case NVME_RESV_PTPL_DISABLE:
> + aptpl = false;
> + break;
> + case NVME_RESV_PTPL_ENABLE:
> + aptpl = true;
> + break;
> + default:
> + return NVME_INVALID_FIELD;
> + }
> +
> + ret = nvme_h2c(n, (uint8_t *)&key_info, sizeof(NvmeKeyInfo), req);
> + if (ret) {
> + return ret;
> + }
> +
> + key_info.cr_key = le64_to_cpu(key_info.cr_key);
> + key_info.nr_key = le64_to_cpu(key_info.nr_key);
> +
> + switch (action) {
> + case NVME_RESV_REGISTER_ACTION_REGISTER:
> + req->aiocb = blk_aio_pr_register(ns->blkconf.blk, 0,
> + key_info.nr_key, 0, aptpl,
> + ignore_key, nvme_misc_cb,
> + req);
> + break;
> + case NVME_RESV_REGISTER_ACTION_UNREGISTER:
> + req->aiocb = blk_aio_pr_register(ns->blkconf.blk, key_info.cr_key, 0,
> + 0, aptpl, ignore_key,
> + nvme_misc_cb, req);
> + break;
> + case NVME_RESV_REGISTER_ACTION_REPLACE:
> + req->aiocb = blk_aio_pr_register(ns->blkconf.blk, key_info.cr_key,
> + key_info.nr_key, 0, aptpl, ignore_key,
> + nvme_misc_cb, req);
> + break;
> + default:
> + return NVME_INVALID_FIELD;
> + }
> +
> + return NVME_NO_COMPLETE;
> +}
> +
> +static uint16_t nvme_resv_release(NvmeCtrl *n, NvmeRequest *req)
> +{
> + int ret;
> + uint64_t cr_key;
> + NvmeNamespace *ns = req->ns;
> + uint32_t cdw10 = le32_to_cpu(req->cmd.cdw10);
I don't understand the reason for this requirement (due to an ECN?), but
if IEKEY (bit 3 in DWORD 10) is set, the controller SHALL return an
error of Invalid Field in Command.
> + uint8_t action = cdw10 & 0x7;
> + NvmeResvType type = cdw10 >> 8 & 0xff;
Parantheses.
> +
> + if (!nvme_support_pr(ns)) {
> + return NVME_INVALID_OPCODE;
> + }
> +
> + ret = nvme_h2c(n, (uint8_t *)&cr_key, sizeof(cr_key), req);
> + if (ret) {
> + return ret;
> + }
> +
> + cr_key = le64_to_cpu(cr_key);
> +
> + switch (action) {
> + case NVME_RESV_RELEASE_ACTION_RELEASE:
> + req->aiocb = blk_aio_pr_release(ns->blkconf.blk, cr_key,
> + nvme_pr_type_to_block(type),
> + nvme_misc_cb, req);
> + break;
> + case NVME_RESV_RELEASE_ACTION_CLEAR:
> + req->aiocb = blk_aio_pr_clear(ns->blkconf.blk, cr_key,
> + nvme_misc_cb, req);
> + break;
> + default:
> + return NVME_INVALID_FIELD;
> + }
> +
> + return NVME_NO_COMPLETE;
> +}
> +
> +static uint16_t nvme_resv_acquire(NvmeCtrl *n, NvmeRequest *req)
> +{
> + int ret;
> + NvmeKeyInfo key_info;
> + NvmeNamespace *ns = req->ns;
> + uint32_t cdw10 = le32_to_cpu(req->cmd.cdw10);
Same weird IEKEY requirement.
> + uint8_t action = cdw10 & 0x7;
> + NvmeResvType type = cdw10 >> 8 & 0xff;
Parantheses.
> +
> + if (!nvme_support_pr(ns)) {
> + return NVME_INVALID_OPCODE;
> + }
> +
> + ret = nvme_h2c(n, (uint8_t *)&key_info, sizeof(NvmeKeyInfo), req);
> + if (ret) {
> + return ret;
> + }
> +
> + key_info.cr_key = le64_to_cpu(key_info.cr_key);
> + key_info.nr_key = le64_to_cpu(key_info.nr_key);
> +
> + switch (action) {
> + case NVME_RESV_ACQUIRE_ACTION_ACQUIRE:
> + req->aiocb = blk_aio_pr_reserve(ns->blkconf.blk, key_info.cr_key,
> + nvme_pr_type_to_block(type),
> + nvme_misc_cb, req);
> + break;
> + case NVME_RESV_ACQUIRE_ACTION_PREEMPT:
> + req->aiocb = blk_aio_pr_preempt(ns->blkconf.blk,
> + key_info.cr_key, key_info.nr_key,
> + nvme_pr_type_to_block(type),
> + false, nvme_misc_cb, req);
> + break;
> + case NVME_RESV_ACQUIRE_ACTION_PREEMPT_AND_ABORT:
> + req->aiocb = blk_aio_pr_preempt(ns->blkconf.blk, key_info.cr_key,
> + key_info.nr_key, type, true,
> + nvme_misc_cb, req);
> + break;
> + default:
> + return NVME_INVALID_FIELD;
> + }
> +
> + return NVME_NO_COMPLETE;
> +}
> +
> +typedef struct NvmeResvKeys {
> + uint32_t generation;
> + uint32_t num_keys;
> + uint64_t *keys;
> + NvmeRequest *req;
> +} NvmeResvKeys;
> +
> +typedef struct NvmeReadReservation {
> + uint32_t generation;
> + uint64_t key;
> + BlockPrType type;
> + NvmeRequest *req;
> + NvmeResvKeys *keys_info;
> +} NvmeReadReservation;
> +
> +static int nvme_read_reservation_cb(NvmeReadReservation *reservation)
> +{
> + int rc;
> + NvmeReservationStatus *nvme_status;
> + NvmeRequest *req = reservation->req;
> + NvmeCtrl *n = req->sq->ctrl;
> + NvmeResvKeys *keys_info = reservation->keys_info;
> + int len = sizeof(NvmeReservationStatusHeader) +
> + sizeof(NvmeRegisteredCtrl) * keys_info->num_keys;
> +
> + nvme_status = g_malloc(len);
This leaks contents of the heap in the uninitialized reserved fields.
Use g_malloc0.
> + nvme_status->header.gen = cpu_to_be32(reservation->generation);
> + nvme_status->header.rtype = block_pr_type_to_nvme(reservation->type);
> + nvme_status->header.regctl = cpu_to_be16(keys_info->num_keys);
> + for (int i = 0; i < keys_info->num_keys; i++) {
> + uint16_t ctnlid = nvme_ctrl(req)->cntlid;
> + nvme_status->regctl_ds[i].cntlid = cpu_to_be16(ctnlid);
> + nvme_status->regctl_ds[i].rkey = cpu_to_be64(keys_info->keys[i]);
> + nvme_status->regctl_ds[i].rcsts = keys_info->keys[i] ==
> + reservation->key ? 1 : 0;
> + /* hostid is not supported currently */
> + memset(&nvme_status->regctl_ds[i].hostid, 0, 8);
With g_malloc0, no need to memset this.
> + }
The endian conversions here should all be cpu to little-endian, no? I
don't see anything in the spec defining these to be big-endian.
> +
> + rc = nvme_c2h(n, (uint8_t *)nvme_status, len, req);
> + g_free(nvme_status);
> + return rc;
> +}
> +
> +static int nvme_read_reservation_ext_cb(NvmeReadReservation *reservation)
> +{
> + int rc;
> + NvmeReservationStatusExt *nvme_status_ext;
> + NvmeRequest *req = reservation->req;
> + NvmeCtrl *n = req->sq->ctrl;
> + NvmeResvKeys *keys_info = reservation->keys_info;
> + int len = sizeof(NvmeReservationStatusHeader) +
> + sizeof(uint8_t) * 40 +
sizeof(NvmeReservationStatusExt)?
> + sizeof(NvmeRegisteredCtrlExt) * keys_info->num_keys;
> +
> + nvme_status_ext = g_malloc(len);
This leaks contents of the heap in the uninitialized reserved fields.
Use g_malloc0.
> + nvme_status_ext->header.gen = cpu_to_be32(reservation->generation);
> + nvme_status_ext->header.rtype = block_pr_type_to_nvme(reservation->type);
> + nvme_status_ext->header.regctl = cpu_to_be16(keys_info->num_keys);
> +
> + for (int i = 0; i < keys_info->num_keys; i++) {
> + uint16_t ctnlid = nvme_ctrl(req)->cntlid;
> + nvme_status_ext->regctl_eds[i].cntlid = cpu_to_be16(ctnlid);
> + nvme_status_ext->regctl_eds[i].rkey = cpu_to_be64(keys_info->keys[i]);
> + nvme_status_ext->regctl_eds[i].rcsts = keys_info->keys[i] ==
> + reservation->key ? 1 : 0;
> + /* hostid is not supported currently */
> + memset(&nvme_status_ext->regctl_eds[i].hostid, 0, 16);
With g_malloc0, no need to memset this.
> + }
Same here, should be little-endian I believe.
> +
> + rc = nvme_c2h(n, (uint8_t *)nvme_status_ext, len, req);
> + g_free(nvme_status_ext);
> + return rc;
> +}
> +
> +static void nvme_resv_read_reservation_cb(void *opaque, int ret)
> +{
> + NvmeReadReservation *reservation = opaque;
> + NvmeRequest *req = reservation->req;
> + bool eds = le32_to_cpu(req->cmd.cdw11) & 0x1;
> + NvmeResvKeys *keys_info = reservation->keys_info;
> +
> + if (ret < 0) {
> + goto out;
> + }
> +
> + if (eds) {
> + ret = nvme_read_reservation_ext_cb(reservation);
> + } else {
> + ret = nvme_read_reservation_cb(reservation);
> + }
> +
> +out:
> + g_free(keys_info->keys);
> + g_free(keys_info);
> + g_free(reservation);
> + nvme_misc_cb(req, ret);
> +}
> +
> +static void nvme_resv_read_keys_cb(void *opaque, int ret)
> +{
> + NvmeResvKeys *keys_info = opaque;
> + NvmeRequest *req = keys_info->req;
> + NvmeNamespace *ns = req->ns;
> + NvmeReadReservation *reservation;
> +
> + if (ret < 0) {
> + goto out;
> + }
> +
> + keys_info->num_keys = MIN(ret, keys_info->num_keys);
> + reservation = g_new0(NvmeReadReservation, 1);
> + memset(reservation, 0, sizeof(*reservation));
g_new0 zeroes the memory.
> + reservation->req = req;
> + reservation->keys_info = keys_info;
> +
> + req->aiocb = blk_aio_pr_read_reservation(ns->blkconf.blk,
> + &reservation->generation, &reservation->key,
> + &reservation->type, nvme_resv_read_reservation_cb,
> + reservation);
> + return;
> +
> +out:
> + g_free(keys_info->keys);
> + g_free(keys_info);
> + nvme_misc_cb(req, ret);
> +}
> +
> +
> +static uint16_t nvme_resv_report(NvmeCtrl *n, NvmeRequest *req)
> +{
> + int num_keys;
> + uint32_t cdw10 = le32_to_cpu(req->cmd.cdw10);
> + uint32_t cdw11 = le32_to_cpu(req->cmd.cdw11);
> + size_t buflen = (cdw10 + 1) * sizeof(uint32_t);
> + bool eds = cdw11 & 0x1;
> + NvmeNamespace *ns = req->ns;
> + NvmeResvKeys *keys_info;
> +
> + if (!nvme_support_pr(ns)) {
> + return NVME_INVALID_OPCODE;
> + }
> +
> + if (eds) {
> + if (buflen < sizeof(NvmeReservationStatusHeader) +
> + sizeof(uint8_t) * 40) {
> + return NVME_INVALID_FIELD;
> + }
No point in the sizeof(uint8_t) and would be more clear to just use
sizeof(NvmeReservationStatusExt), no?
In these cases I try to go for the strategy of just building the data
structure in its entirety and then when we get to nvme_c2h above, only
transfer the part of the data structure that the host requested.
Maybe, you could get rid of the NVME_MAX_RESERVATION_KEYS band-aid
(that, as far as I can tell, is non-spec compliant?), by DMA'ing to the
host in "chunks" in the callback (i.e., read 128 keys, c2h, repeat), but
I guess that would require the blk_aio_pr API to have an "offset" so you
didn't have to read all keys in one go?
What are the implications of putting a hard limit of
NVME_MAX_RESERVATION_KEYS here? There is no way to convey that limit to
the host, is there?
> +
> + num_keys = (buflen - sizeof(NvmeReservationStatusHeader) -
> + sizeof(uint8_t) * 40) /
> + sizeof(struct NvmeRegisteredCtrlExt);
> + } else {
> + if (buflen < sizeof(NvmeReservationStatusHeader)) {
> + return NVME_INVALID_FIELD;
> + }
> +
> + num_keys = (buflen - sizeof(NvmeReservationStatusHeader)) /
> + sizeof(struct NvmeRegisteredCtrl);
> + }
> +
> + /*
> + * The maximum number of keys that can be transmitted is 128.
> + */
> + num_keys = MIN(num_keys, NVME_MAX_RESERVATION_KEYS);
> + keys_info = g_new0(NvmeResvKeys, 1);
> + keys_info->generation = 0;
> + /* num_keys is the maximum number of keys that can be transmitted */
> + keys_info->num_keys = num_keys;
> + keys_info->keys = g_malloc(sizeof(uint64_t) * num_keys);
> + keys_info->req = req;
> +
> + req->aiocb = blk_aio_pr_read_keys(ns->blkconf.blk, &keys_info->generation,
> + keys_info->num_keys, keys_info->keys,
> + nvme_resv_read_keys_cb, keys_info);
> +
> + return NVME_NO_COMPLETE;
> +}
> +
> typedef struct NvmeCopyAIOCB {
> BlockAIOCB common;
> BlockAIOCB *aiocb;
> @@ -4469,6 +4820,14 @@ static uint16_t nvme_io_cmd(NvmeCtrl *n, NvmeRequest *req)
> return nvme_dsm(n, req);
> case NVME_CMD_VERIFY:
> return nvme_verify(n, req);
> + case NVME_CMD_RESV_REGISTER:
> + return nvme_resv_register(n, req);
> + case NVME_CMD_RESV_REPORT:
> + return nvme_resv_report(n, req);
> + case NVME_CMD_RESV_ACQUIRE:
> + return nvme_resv_acquire(n, req);
> + case NVME_CMD_RESV_RELEASE:
> + return nvme_resv_release(n, req);
> case NVME_CMD_COPY:
> return nvme_copy(n, req);
> case NVME_CMD_ZONE_MGMT_SEND:
> diff --git a/hw/nvme/ns.c b/hw/nvme/ns.c
> index a5c903d727..833bcbae08 100644
> --- a/hw/nvme/ns.c
> +++ b/hw/nvme/ns.c
> @@ -60,6 +60,12 @@ void nvme_ns_init_format(NvmeNamespace *ns)
>
> blk_pr_cap = blk_bs(ns->blkconf.blk)->bl.pr_cap;
> id_ns->rescap = block_pr_cap_to_nvme(blk_pr_cap);
> + if (id_ns->rescap != NVME_PR_CAP_ALL &&
> + id_ns->rescap != NVME_PR_CAP_RW) {
> +
> + /* Rescap either supports all or none of them */
> + id_ns->rescap = 0;
> + }
> }
>
> static int nvme_ns_init(NvmeNamespace *ns, Error **errp)
> diff --git a/hw/nvme/nvme.h b/hw/nvme/nvme.h
> index 6d0e456348..b87e1fa3b0 100644
> --- a/hw/nvme/nvme.h
> +++ b/hw/nvme/nvme.h
> @@ -29,6 +29,7 @@
> #define NVME_EUI64_DEFAULT ((uint64_t)0x5254000000000000)
> #define NVME_FDP_MAX_EVENTS 63
> #define NVME_FDP_MAXPIDS 128
> +#define NVME_MAX_RESERVATION_KEYS 128
>
> /*
> * The controller only supports Submission and Completion Queue Entry Sizes of
> @@ -470,6 +471,10 @@ static inline const char *nvme_io_opc_str(uint8_t opc)
> case NVME_CMD_ZONE_MGMT_SEND: return "NVME_ZONED_CMD_MGMT_SEND";
> case NVME_CMD_ZONE_MGMT_RECV: return "NVME_ZONED_CMD_MGMT_RECV";
> case NVME_CMD_ZONE_APPEND: return "NVME_ZONED_CMD_ZONE_APPEND";
> + case NVME_CMD_RESV_REGISTER: return "NVME_CMD_RESV_REGISTER";
> + case NVME_CMD_RESV_REPORT: return "NVME_CMD_RESV_REPORT";
> + case NVME_CMD_RESV_ACQUIRE: return "NVME_CMD_RESV_ACQUIRE";
> + case NVME_CMD_RESV_RELEASE: return "NVME_CMD_RESV_RELEASE";
> default: return "NVME_NVM_CMD_UNKNOWN";
> }
> }
> @@ -558,6 +563,11 @@ static inline uint8_t block_pr_cap_to_nvme(uint8_t block_pr_cap)
> return res;
> }
>
> +static inline bool nvme_support_pr(NvmeNamespace *ns)
> +{
> + return (ns->id_ns.rescap & NVME_PR_CAP_RW) == NVME_PR_CAP_RW;
> +}
> +
> typedef struct NvmeSQueue {
> struct NvmeCtrl *ctrl;
> uint16_t sqid;
> diff --git a/include/block/nvme.h b/include/block/nvme.h
> index 9b9eaeb3a7..2eec339028 100644
> --- a/include/block/nvme.h
> +++ b/include/block/nvme.h
> @@ -692,6 +692,13 @@ typedef enum NVMEPrCap {
> NVME_PR_CAP_WR_EX_AR = 1 << 5,
> /* Exclusive Access All Registrants reservation type */
> NVME_PR_CAP_EX_AC_AR = 1 << 6,
> + /* Write and Read reservation type */
> + NVME_PR_CAP_RW = (NVME_PR_CAP_WR_EX |
> + NVME_PR_CAP_EX_AC |
> + NVME_PR_CAP_WR_EX_RO |
> + NVME_PR_CAP_EX_AC_RO |
> + NVME_PR_CAP_WR_EX_AR |
> + NVME_PR_CAP_EX_AC_AR),
>
> NVME_PR_CAP_ALL = (NVME_PR_CAP_PTPL |
> NVME_PR_CAP_WR_EX |
> @@ -702,6 +709,43 @@ typedef enum NVMEPrCap {
> NVME_PR_CAP_EX_AC_AR),
> } NvmePrCap;
>
> +typedef struct QEMU_PACKED NvmeRegisteredCtrl {
> + uint16_t cntlid;
> + uint8_t rcsts;
> + uint8_t rsvd3[5];
> + uint8_t hostid[8];
> + uint64_t rkey;
> +} NvmeRegisteredCtrl;
> +
> +typedef struct QEMU_PACKED NvmeRegisteredCtrlExt {
> + uint16_t cntlid;
> + uint8_t rcsts;
> + uint8_t rsvd3[5];
> + uint64_t rkey;
> + uint8_t hostid[16];
> + uint8_t rsvd32[32];
> +} NvmeRegisteredCtrlExt;
> +
> +typedef struct QEMU_PACKED NvmeReservationStatusHeader {
> + uint32_t gen;
> + uint8_t rtype;
> + uint16_t regctl;
Not a biggie, but this field is named REGSTRNT now.
> + uint16_t resv5;
> + uint8_t ptpls;
> + uint8_t resv10[14];
> +} NvmeReservationStatusHeader;
> +
> +typedef struct QEMU_PACKED NvmeReservationStatus {
> + struct NvmeReservationStatusHeader header;
> + struct NvmeRegisteredCtrl regctl_ds[];
We generally do not use 'struct' if we do not have to, and here it is
not required I believe.
> +} NvmeReservationStatus;
> +
> +typedef struct QEMU_PACKED NvmeReservationStatusExt {
> + struct NvmeReservationStatusHeader header;
> + uint8_t rsvd24[40];
Align or drop the spaces here.
> + struct NvmeRegisteredCtrlExt regctl_eds[];
Same here.
> +} NvmeReservationStatusExt;
> +
Please add QEMU_BUILD_BUG_ON(sizeof(...) != ...) checks in
_nvme_check_size for these structs.
They all add up as far as I can tell, but it's a good safe-guard
generally.
> typedef struct QEMU_PACKED NvmeDeleteQ {
> uint8_t opcode;
> uint8_t flags;
> --
> 2.20.1
>
>
© 2016 - 2024 Red Hat, Inc.