hw/block/nvme-ns.c

   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 #include "qemu/osdep.h"
  16 #include "qemu/units.h"
  17 #include "qemu/cutils.h"
  18 #include "qemu/log.h"
  19 #include "hw/block/block.h"
  20 #include "hw/pci/pci.h"
  21 #include "sysemu/sysemu.h"
  22 #include "sysemu/block-backend.h"
  23 #include "qapi/error.h"
  24
  25 #include "hw/qdev-properties.h"
  26 #include "hw/qdev-core.h"
  27
  28 #include "nvme.h"
  29 #include "nvme-ns.h"
  30
  31 #define MIN_DISCARD_GRANULARITY (4 * KiB)
  32
  33 static int nvme_ns_init(NvmeNamespace *ns, Error **errp)
  34 {
  35     BlockDriverInfo bdi;
  36     NvmeIdNs *id_ns = &ns->id_ns;
  37     int lba_index = NVME_ID_NS_FLBAS_INDEX(ns->id_ns.flbas);
  38     int npdg;
  39
  40     ns->id_ns.dlfeat = 0x9;
  41
  42     id_ns->lbaf[lba_index].ds = 31 - clz32(ns->blkconf.logical_block_size);
  43
  44     id_ns->nsze = cpu_to_le64(nvme_ns_nlbas(ns));
  45
  46     /* no thin provisioning */
  47     id_ns->ncap = id_ns->nsze;
  48     id_ns->nuse = id_ns->ncap;
  49
  50     /* support DULBE and I/O optimization fields */
  51     id_ns->nsfeat |= (0x4 | 0x10);
  52
  53     npdg = ns->blkconf.discard_granularity / ns->blkconf.logical_block_size;
  54
  55     if (bdrv_get_info(blk_bs(ns->blkconf.blk), &bdi) >= 0 &&
  56         bdi.cluster_size > ns->blkconf.discard_granularity) {
  57         npdg = bdi.cluster_size / ns->blkconf.logical_block_size;
  58     }
  59
  60     id_ns->npda = id_ns->npdg = npdg - 1;
  61
  62     return 0;
  63 }
  64
  65 static int nvme_ns_init_blk(NvmeCtrl *n, NvmeNamespace *ns, Error **errp)
  66 {
  67     bool read_only;
  68
  69     if (!blkconf_blocksizes(&ns->blkconf, errp)) {
  70         return -1;
  71     }
  72
  73     read_only = !blk_supports_write_perm(ns->blkconf.blk);
  74     if (!blkconf_apply_backend_options(&ns->blkconf, read_only, false, errp)) {
  75         return -1;
  76     }
  77
  78     if (ns->blkconf.discard_granularity == -1) {
  79         ns->blkconf.discard_granularity =
  80             MAX(ns->blkconf.logical_block_size, MIN_DISCARD_GRANULARITY);
  81     }
  82
  83     ns->size = blk_getlength(ns->blkconf.blk);
  84     if (ns->size < 0) {
  85         error_setg_errno(errp, -ns->size, "could not get blockdev size");
  86         return -1;
  87     }
  88
  89     if (blk_enable_write_cache(ns->blkconf.blk)) {
  90         n->features.vwc = 0x1;
  91     }
  92
  93     return 0;
  94 }
  95
  96 static int nvme_ns_check_constraints(NvmeNamespace *ns, Error **errp)
  97 {
  98     if (!ns->blkconf.blk) {
  99         error_setg(errp, "block backend not configured");
 100         return -1;
 101     }
 102
 103     return 0;
 104 }
 105
 106 int nvme_ns_setup(NvmeCtrl *n, NvmeNamespace *ns, Error **errp)
 107 {
 108     if (nvme_ns_check_constraints(ns, errp)) {
 109         return -1;
 110     }
 111
 112     if (nvme_ns_init_blk(n, ns, errp)) {
 113         return -1;
 114     }
 115
 116     if (nvme_ns_init(ns, errp)) {
 117         return -1;
 118     }
 119
 120     if (nvme_register_namespace(n, ns, errp)) {
 121         return -1;
 122     }
 123
 124     return 0;
 125 }
 126
 127 void nvme_ns_drain(NvmeNamespace *ns)
 128 {
 129     blk_drain(ns->blkconf.blk);
 130 }
 131
 132 void nvme_ns_shutdown(NvmeNamespace *ns)
 133 {
 134     blk_flush(ns->blkconf.blk);
 135 }
 136
 137 static void nvme_ns_realize(DeviceState *dev, Error **errp)
 138 {
 139     NvmeNamespace *ns = NVME_NS(dev);
 140     BusState *s = qdev_get_parent_bus(dev);
 141     NvmeCtrl *n = NVME(s->parent);
 142     Error *local_err = NULL;
 143
 144     if (nvme_ns_setup(n, ns, &local_err)) {
 145         error_propagate_prepend(errp, local_err,
 146                                 "could not setup namespace: ");
 147         return;
 148     }
 149 }
 150
 151 static Property nvme_ns_props[] = {
 152     DEFINE_BLOCK_PROPERTIES(NvmeNamespace, blkconf),
 153     DEFINE_PROP_UINT32("nsid", NvmeNamespace, params.nsid, 0),
 154     DEFINE_PROP_UUID("uuid", NvmeNamespace, params.uuid),
 155     DEFINE_PROP_END_OF_LIST(),
 156 };
 157
 158 static void nvme_ns_class_init(ObjectClass *oc, void *data)
 159 {
 160     DeviceClass *dc = DEVICE_CLASS(oc);
 161
 162     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
 163
 164     dc->bus_type = TYPE_NVME_BUS;
 165     dc->realize = nvme_ns_realize;
 166     device_class_set_props(dc, nvme_ns_props);
 167     dc->desc = "Virtual NVMe namespace";
 168 }
 169
 170 static void nvme_ns_instance_init(Object *obj)
 171 {
 172     NvmeNamespace *ns = NVME_NS(obj);
 173     char *bootindex = g_strdup_printf("/namespace@%d,0", ns->params.nsid);
 174
 175     device_add_bootindex_property(obj, &ns->bootindex, "bootindex",
 176                                   bootindex, DEVICE(obj));
 177
 178     g_free(bootindex);
 179 }
 180
 181 static const TypeInfo nvme_ns_info = {
 182     .name = TYPE_NVME_NS,
 183     .parent = TYPE_DEVICE,
 184     .class_init = nvme_ns_class_init,
 185     .instance_size = sizeof(NvmeNamespace),
 186     .instance_init = nvme_ns_instance_init,
 187 };
 188
 189 static void nvme_ns_register_types(void)
 190 {
 191     type_register_static(&nvme_ns_info);
 192 }
 193
 194 type_init(nvme_ns_register_types)