hw/block/nvme-ns.h

   1 /*
   2  * QEMU NVM Express Virtual Namespace
   3  *
   4  * Copyright (c) 2019 CNEX Labs
   5  * Copyright (c) 2020 Samsung Electronics
   6  *
   7  * Authors:
   8  *  Klaus Jensen      <k.jensen@samsung.com>
   9  *
  10  * This work is licensed under the terms of the GNU GPL, version 2. See the
  11  * COPYING file in the top-level directory.
  12  *
  13  */
  14
  15 #ifndef NVME_NS_H
  16 #define NVME_NS_H
  17
  18 #define TYPE_NVME_NS "nvme-ns"
  19 #define NVME_NS(obj) \
  20     OBJECT_CHECK(NvmeNamespace, (obj), TYPE_NVME_NS)
  21
  22 typedef struct NvmeZone {
  23     NvmeZoneDescr   d;
  24     uint64_t        w_ptr;
  25     QTAILQ_ENTRY(NvmeZone) entry;
  26 } NvmeZone;
  27
  28 typedef struct NvmeNamespaceParams {
  29     uint32_t nsid;
  30     QemuUUID uuid;
  31
  32     bool     zoned;
  33     bool     cross_zone_read;
  34     uint64_t zone_size_bs;
  35     uint64_t zone_cap_bs;
  36     uint32_t max_active_zones;
  37     uint32_t max_open_zones;
  38     uint32_t zd_extension_size;
  39 } NvmeNamespaceParams;
  40
  41 typedef struct NvmeNamespace {
  42     DeviceState  parent_obj;
  43     BlockConf    blkconf;
  44     int32_t      bootindex;
  45     int64_t      size;
  46     NvmeIdNs     id_ns;
  47     const uint32_t *iocs;
  48     uint8_t      csi;
  49
  50     NvmeIdNsZoned   *id_ns_zoned;
  51     NvmeZone        *zone_array;
  52     QTAILQ_HEAD(, NvmeZone) exp_open_zones;
  53     QTAILQ_HEAD(, NvmeZone) imp_open_zones;
  54     QTAILQ_HEAD(, NvmeZone) closed_zones;
  55     QTAILQ_HEAD(, NvmeZone) full_zones;
  56     uint32_t        num_zones;
  57     uint64_t        zone_size;
  58     uint64_t        zone_capacity;
  59     uint32_t        zone_size_log2;
  60     uint8_t         *zd_extensions;
  61     int32_t         nr_open_zones;
  62     int32_t         nr_active_zones;
  63
  64     NvmeNamespaceParams params;
  65
  66     struct {
  67         uint32_t err_rec;
  68     } features;
  69 } NvmeNamespace;
  70
  71 static inline uint32_t nvme_nsid(NvmeNamespace *ns)
  72 {
  73     if (ns) {
  74         return ns->params.nsid;
  75     }
  76
  77     return -1;
  78 }
  79
  80 static inline NvmeLBAF *nvme_ns_lbaf(NvmeNamespace *ns)
  81 {
  82     NvmeIdNs *id_ns = &ns->id_ns;
  83     return &id_ns->lbaf[NVME_ID_NS_FLBAS_INDEX(id_ns->flbas)];
  84 }
  85
  86 static inline uint8_t nvme_ns_lbads(NvmeNamespace *ns)
  87 {
  88     return nvme_ns_lbaf(ns)->ds;
  89 }
  90
  91 /* calculate the number of LBAs that the namespace can accomodate */
  92 static inline uint64_t nvme_ns_nlbas(NvmeNamespace *ns)
  93 {
  94     return ns->size >> nvme_ns_lbads(ns);
  95 }
  96
  97 /* convert an LBA to the equivalent in bytes */
  98 static inline size_t nvme_l2b(NvmeNamespace *ns, uint64_t lba)
  99 {
 100     return lba << nvme_ns_lbads(ns);
 101 }
 102
 103 typedef struct NvmeCtrl NvmeCtrl;
 104
 105 static inline NvmeZoneState nvme_get_zone_state(NvmeZone *zone)
 106 {
 107     return zone->d.zs >> 4;
 108 }
 109
 110 static inline void nvme_set_zone_state(NvmeZone *zone, NvmeZoneState state)
 111 {
 112     zone->d.zs = state << 4;
 113 }
 114
 115 static inline uint64_t nvme_zone_rd_boundary(NvmeNamespace *ns, NvmeZone *zone)
 116 {
 117     return zone->d.zslba + ns->zone_size;
 118 }
 119
 120 static inline uint64_t nvme_zone_wr_boundary(NvmeZone *zone)
 121 {
 122     return zone->d.zslba + zone->d.zcap;
 123 }
 124
 125 static inline bool nvme_wp_is_valid(NvmeZone *zone)
 126 {
 127     uint8_t st = nvme_get_zone_state(zone);
 128
 129     return st != NVME_ZONE_STATE_FULL &&
 130            st != NVME_ZONE_STATE_READ_ONLY &&
 131            st != NVME_ZONE_STATE_OFFLINE;
 132 }
 133
 134 static inline uint8_t *nvme_get_zd_extension(NvmeNamespace *ns,
 135                                              uint32_t zone_idx)
 136 {
 137     return &ns->zd_extensions[zone_idx * ns->params.zd_extension_size];
 138 }
 139
 140 static inline void nvme_aor_inc_open(NvmeNamespace *ns)
 141 {
 142     assert(ns->nr_open_zones >= 0);
 143     if (ns->params.max_open_zones) {
 144         ns->nr_open_zones++;
 145         assert(ns->nr_open_zones <= ns->params.max_open_zones);
 146     }
 147 }
 148
 149 static inline void nvme_aor_dec_open(NvmeNamespace *ns)
 150 {
 151     if (ns->params.max_open_zones) {
 152         assert(ns->nr_open_zones > 0);
 153         ns->nr_open_zones--;
 154     }
 155     assert(ns->nr_open_zones >= 0);
 156 }
 157
 158 static inline void nvme_aor_inc_active(NvmeNamespace *ns)
 159 {
 160     assert(ns->nr_active_zones >= 0);
 161     if (ns->params.max_active_zones) {
 162         ns->nr_active_zones++;
 163         assert(ns->nr_active_zones <= ns->params.max_active_zones);
 164     }
 165 }
 166
 167 static inline void nvme_aor_dec_active(NvmeNamespace *ns)
 168 {
 169     if (ns->params.max_active_zones) {
 170         assert(ns->nr_active_zones > 0);
 171         ns->nr_active_zones--;
 172         assert(ns->nr_active_zones >= ns->nr_open_zones);
 173     }
 174     assert(ns->nr_active_zones >= 0);
 175 }
 176
 177 int nvme_ns_setup(NvmeNamespace *ns, Error **errp);
 178 void nvme_ns_drain(NvmeNamespace *ns);
 179 void nvme_ns_shutdown(NvmeNamespace *ns);
 180 void nvme_ns_cleanup(NvmeNamespace *ns);
 181
 182 #endif /* NVME_NS_H */