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 "qemu/error-report.h"
  20 #include "hw/block/block.h"
  21 #include "hw/pci/pci.h"
  22 #include "sysemu/sysemu.h"
  23 #include "sysemu/block-backend.h"
  24 #include "qapi/error.h"
  25
  26 #include "hw/qdev-properties.h"
  27 #include "hw/qdev-core.h"
  28
  29 #include "trace.h"
  30 #include "nvme.h"
  31 #include "nvme-ns.h"
  32
  33 #define MIN_DISCARD_GRANULARITY (4 * KiB)
  34
  35 static int nvme_ns_init(NvmeNamespace *ns, Error **errp)
  36 {
  37     BlockDriverInfo bdi;
  38     NvmeIdNs *id_ns = &ns->id_ns;
  39     int lba_index = NVME_ID_NS_FLBAS_INDEX(ns->id_ns.flbas);
  40     int npdg;
  41
  42     ns->id_ns.dlfeat = 0x9;
  43
  44     id_ns->lbaf[lba_index].ds = 31 - clz32(ns->blkconf.logical_block_size);
  45
  46     id_ns->nsze = cpu_to_le64(nvme_ns_nlbas(ns));
  47
  48     ns->csi = NVME_CSI_NVM;
  49
  50     /* no thin provisioning */
  51     id_ns->ncap = id_ns->nsze;
  52     id_ns->nuse = id_ns->ncap;
  53
  54     /* support DULBE and I/O optimization fields */
  55     id_ns->nsfeat |= (0x4 | 0x10);
  56
  57     npdg = ns->blkconf.discard_granularity / ns->blkconf.logical_block_size;
  58
  59     if (bdrv_get_info(blk_bs(ns->blkconf.blk), &bdi) >= 0 &&
  60         bdi.cluster_size > ns->blkconf.discard_granularity) {
  61         npdg = bdi.cluster_size / ns->blkconf.logical_block_size;
  62     }
  63
  64     id_ns->npda = id_ns->npdg = npdg - 1;
  65
  66     if (nvme_ns_shared(ns)) {
  67         id_ns->nmic |= NVME_NMIC_NS_SHARED;
  68     }
  69
  70     /* simple copy */
  71     id_ns->mssrl = cpu_to_le16(ns->params.mssrl);
  72     id_ns->mcl = cpu_to_le32(ns->params.mcl);
  73     id_ns->msrc = ns->params.msrc;
  74
  75     return 0;
  76 }
  77
  78 static int nvme_ns_init_blk(NvmeNamespace *ns, Error **errp)
  79 {
  80     bool read_only;
  81
  82     if (!blkconf_blocksizes(&ns->blkconf, errp)) {
  83         return -1;
  84     }
  85
  86     read_only = !blk_supports_write_perm(ns->blkconf.blk);
  87     if (!blkconf_apply_backend_options(&ns->blkconf, read_only, false, errp)) {
  88         return -1;
  89     }
  90
  91     if (ns->blkconf.discard_granularity == -1) {
  92         ns->blkconf.discard_granularity =
  93             MAX(ns->blkconf.logical_block_size, MIN_DISCARD_GRANULARITY);
  94     }
  95
  96     ns->size = blk_getlength(ns->blkconf.blk);
  97     if (ns->size < 0) {
  98         error_setg_errno(errp, -ns->size, "could not get blockdev size");
  99         return -1;
 100     }
 101
 102     return 0;
 103 }
 104
 105 static int nvme_ns_zoned_check_calc_geometry(NvmeNamespace *ns, Error **errp)
 106 {
 107     uint64_t zone_size, zone_cap;
 108     uint32_t lbasz = ns->blkconf.logical_block_size;
 109
 110     /* Make sure that the values of ZNS properties are sane */
 111     if (ns->params.zone_size_bs) {
 112         zone_size = ns->params.zone_size_bs;
 113     } else {
 114         zone_size = NVME_DEFAULT_ZONE_SIZE;
 115     }
 116     if (ns->params.zone_cap_bs) {
 117         zone_cap = ns->params.zone_cap_bs;
 118     } else {
 119         zone_cap = zone_size;
 120     }
 121     if (zone_cap > zone_size) {
 122         error_setg(errp, "zone capacity %"PRIu64"B exceeds "
 123                    "zone size %"PRIu64"B", zone_cap, zone_size);
 124         return -1;
 125     }
 126     if (zone_size < lbasz) {
 127         error_setg(errp, "zone size %"PRIu64"B too small, "
 128                    "must be at least %"PRIu32"B", zone_size, lbasz);
 129         return -1;
 130     }
 131     if (zone_cap < lbasz) {
 132         error_setg(errp, "zone capacity %"PRIu64"B too small, "
 133                    "must be at least %"PRIu32"B", zone_cap, lbasz);
 134         return -1;
 135     }
 136
 137     /*
 138      * Save the main zone geometry values to avoid
 139      * calculating them later again.
 140      */
 141     ns->zone_size = zone_size / lbasz;
 142     ns->zone_capacity = zone_cap / lbasz;
 143     ns->num_zones = ns->size / lbasz / ns->zone_size;
 144
 145     /* Do a few more sanity checks of ZNS properties */
 146     if (!ns->num_zones) {
 147         error_setg(errp,
 148                    "insufficient drive capacity, must be at least the size "
 149                    "of one zone (%"PRIu64"B)", zone_size);
 150         return -1;
 151     }
 152
 153     if (ns->params.max_open_zones > ns->num_zones) {
 154         error_setg(errp,
 155                    "max_open_zones value %u exceeds the number of zones %u",
 156                    ns->params.max_open_zones, ns->num_zones);
 157         return -1;
 158     }
 159     if (ns->params.max_active_zones > ns->num_zones) {
 160         error_setg(errp,
 161                    "max_active_zones value %u exceeds the number of zones %u",
 162                    ns->params.max_active_zones, ns->num_zones);
 163         return -1;
 164     }
 165
 166     if (ns->params.max_active_zones) {
 167         if (ns->params.max_open_zones > ns->params.max_active_zones) {
 168             error_setg(errp, "max_open_zones (%u) exceeds max_active_zones (%u)",
 169                        ns->params.max_open_zones, ns->params.max_active_zones);
 170             return -1;
 171         }
 172
 173         if (!ns->params.max_open_zones) {
 174             ns->params.max_open_zones = ns->params.max_active_zones;
 175         }
 176     }
 177
 178     if (ns->params.zd_extension_size) {
 179         if (ns->params.zd_extension_size & 0x3f) {
 180             error_setg(errp,
 181                 "zone descriptor extension size must be a multiple of 64B");
 182             return -1;
 183         }
 184         if ((ns->params.zd_extension_size >> 6) > 0xff) {
 185             error_setg(errp, "zone descriptor extension size is too large");
 186             return -1;
 187         }
 188     }
 189
 190     return 0;
 191 }
 192
 193 static void nvme_ns_zoned_init_state(NvmeNamespace *ns)
 194 {
 195     uint64_t start = 0, zone_size = ns->zone_size;
 196     uint64_t capacity = ns->num_zones * zone_size;
 197     NvmeZone *zone;
 198     int i;
 199
 200     ns->zone_array = g_new0(NvmeZone, ns->num_zones);
 201     if (ns->params.zd_extension_size) {
 202         ns->zd_extensions = g_malloc0(ns->params.zd_extension_size *
 203                                       ns->num_zones);
 204     }
 205
 206     QTAILQ_INIT(&ns->exp_open_zones);
 207     QTAILQ_INIT(&ns->imp_open_zones);
 208     QTAILQ_INIT(&ns->closed_zones);
 209     QTAILQ_INIT(&ns->full_zones);
 210
 211     zone = ns->zone_array;
 212     for (i = 0; i < ns->num_zones; i++, zone++) {
 213         if (start + zone_size > capacity) {
 214             zone_size = capacity - start;
 215         }
 216         zone->d.zt = NVME_ZONE_TYPE_SEQ_WRITE;
 217         nvme_set_zone_state(zone, NVME_ZONE_STATE_EMPTY);
 218         zone->d.za = 0;
 219         zone->d.zcap = ns->zone_capacity;
 220         zone->d.zslba = start;
 221         zone->d.wp = start;
 222         zone->w_ptr = start;
 223         start += zone_size;
 224     }
 225
 226     ns->zone_size_log2 = 0;
 227     if (is_power_of_2(ns->zone_size)) {
 228         ns->zone_size_log2 = 63 - clz64(ns->zone_size);
 229     }
 230 }
 231
 232 static void nvme_ns_init_zoned(NvmeNamespace *ns, int lba_index)
 233 {
 234     NvmeIdNsZoned *id_ns_z;
 235
 236     nvme_ns_zoned_init_state(ns);
 237
 238     id_ns_z = g_malloc0(sizeof(NvmeIdNsZoned));
 239
 240     /* MAR/MOR are zeroes-based, 0xffffffff means no limit */
 241     id_ns_z->mar = cpu_to_le32(ns->params.max_active_zones - 1);
 242     id_ns_z->mor = cpu_to_le32(ns->params.max_open_zones - 1);
 243     id_ns_z->zoc = 0;
 244     id_ns_z->ozcs = ns->params.cross_zone_read ? 0x01 : 0x00;
 245
 246     id_ns_z->lbafe[lba_index].zsze = cpu_to_le64(ns->zone_size);
 247     id_ns_z->lbafe[lba_index].zdes =
 248         ns->params.zd_extension_size >> 6; /* Units of 64B */
 249
 250     ns->csi = NVME_CSI_ZONED;
 251     ns->id_ns.nsze = cpu_to_le64(ns->num_zones * ns->zone_size);
 252     ns->id_ns.ncap = ns->id_ns.nsze;
 253     ns->id_ns.nuse = ns->id_ns.ncap;
 254
 255     /*
 256      * The device uses the BDRV_BLOCK_ZERO flag to determine the "deallocated"
 257      * status of logical blocks. Since the spec defines that logical blocks
 258      * SHALL be deallocated when then zone is in the Empty or Offline states,
 259      * we can only support DULBE if the zone size is a multiple of the
 260      * calculated NPDG.
 261      */
 262     if (ns->zone_size % (ns->id_ns.npdg + 1)) {
 263         warn_report("the zone size (%"PRIu64" blocks) is not a multiple of "
 264                     "the calculated deallocation granularity (%d blocks); "
 265                     "DULBE support disabled",
 266                     ns->zone_size, ns->id_ns.npdg + 1);
 267
 268         ns->id_ns.nsfeat &= ~0x4;
 269     }
 270
 271     ns->id_ns_zoned = id_ns_z;
 272 }
 273
 274 static void nvme_clear_zone(NvmeNamespace *ns, NvmeZone *zone)
 275 {
 276     uint8_t state;
 277
 278     zone->w_ptr = zone->d.wp;
 279     state = nvme_get_zone_state(zone);
 280     if (zone->d.wp != zone->d.zslba ||
 281         (zone->d.za & NVME_ZA_ZD_EXT_VALID)) {
 282         if (state != NVME_ZONE_STATE_CLOSED) {
 283             trace_pci_nvme_clear_ns_close(state, zone->d.zslba);
 284             nvme_set_zone_state(zone, NVME_ZONE_STATE_CLOSED);
 285         }
 286         nvme_aor_inc_active(ns);
 287         QTAILQ_INSERT_HEAD(&ns->closed_zones, zone, entry);
 288     } else {
 289         trace_pci_nvme_clear_ns_reset(state, zone->d.zslba);
 290         nvme_set_zone_state(zone, NVME_ZONE_STATE_EMPTY);
 291     }
 292 }
 293
 294 /*
 295  * Close all the zones that are currently open.
 296  */
 297 static void nvme_zoned_ns_shutdown(NvmeNamespace *ns)
 298 {
 299     NvmeZone *zone, *next;
 300
 301     QTAILQ_FOREACH_SAFE(zone, &ns->closed_zones, entry, next) {
 302         QTAILQ_REMOVE(&ns->closed_zones, zone, entry);
 303         nvme_aor_dec_active(ns);
 304         nvme_clear_zone(ns, zone);
 305     }
 306     QTAILQ_FOREACH_SAFE(zone, &ns->imp_open_zones, entry, next) {
 307         QTAILQ_REMOVE(&ns->imp_open_zones, zone, entry);
 308         nvme_aor_dec_open(ns);
 309         nvme_aor_dec_active(ns);
 310         nvme_clear_zone(ns, zone);
 311     }
 312     QTAILQ_FOREACH_SAFE(zone, &ns->exp_open_zones, entry, next) {
 313         QTAILQ_REMOVE(&ns->exp_open_zones, zone, entry);
 314         nvme_aor_dec_open(ns);
 315         nvme_aor_dec_active(ns);
 316         nvme_clear_zone(ns, zone);
 317     }
 318
 319     assert(ns->nr_open_zones == 0);
 320 }
 321
 322 static int nvme_ns_check_constraints(NvmeNamespace *ns, Error **errp)
 323 {
 324     if (!ns->blkconf.blk) {
 325         error_setg(errp, "block backend not configured");
 326         return -1;
 327     }
 328
 329     return 0;
 330 }
 331
 332 int nvme_ns_setup(NvmeNamespace *ns, Error **errp)
 333 {
 334     if (nvme_ns_check_constraints(ns, errp)) {
 335         return -1;
 336     }
 337
 338     if (nvme_ns_init_blk(ns, errp)) {
 339         return -1;
 340     }
 341
 342     if (nvme_ns_init(ns, errp)) {
 343         return -1;
 344     }
 345     if (ns->params.zoned) {
 346         if (nvme_ns_zoned_check_calc_geometry(ns, errp) != 0) {
 347             return -1;
 348         }
 349         nvme_ns_init_zoned(ns, 0);
 350     }
 351
 352     return 0;
 353 }
 354
 355 void nvme_ns_drain(NvmeNamespace *ns)
 356 {
 357     blk_drain(ns->blkconf.blk);
 358 }
 359
 360 void nvme_ns_shutdown(NvmeNamespace *ns)
 361 {
 362     blk_flush(ns->blkconf.blk);
 363     if (ns->params.zoned) {
 364         nvme_zoned_ns_shutdown(ns);
 365     }
 366 }
 367
 368 void nvme_ns_cleanup(NvmeNamespace *ns)
 369 {
 370     if (ns->params.zoned) {
 371         g_free(ns->id_ns_zoned);
 372         g_free(ns->zone_array);
 373         g_free(ns->zd_extensions);
 374     }
 375 }
 376
 377 static void nvme_ns_realize(DeviceState *dev, Error **errp)
 378 {
 379     NvmeNamespace *ns = NVME_NS(dev);
 380     BusState *s = qdev_get_parent_bus(dev);
 381     NvmeCtrl *n = NVME(s->parent);
 382
 383     if (nvme_ns_setup(ns, errp)) {
 384         return;
 385     }
 386
 387     if (ns->subsys) {
 388         if (nvme_subsys_register_ns(ns, errp)) {
 389             return;
 390         }
 391     } else {
 392         if (nvme_register_namespace(n, ns, errp)) {
 393             return;
 394         }
 395     }
 396 }
 397
 398 static Property nvme_ns_props[] = {
 399     DEFINE_BLOCK_PROPERTIES(NvmeNamespace, blkconf),
 400     DEFINE_PROP_LINK("subsys", NvmeNamespace, subsys, TYPE_NVME_SUBSYS,
 401                      NvmeSubsystem *),
 402     DEFINE_PROP_BOOL("detached", NvmeNamespace, params.detached, false),
 403     DEFINE_PROP_UINT32("nsid", NvmeNamespace, params.nsid, 0),
 404     DEFINE_PROP_UUID("uuid", NvmeNamespace, params.uuid),
 405     DEFINE_PROP_UINT16("mssrl", NvmeNamespace, params.mssrl, 128),
 406     DEFINE_PROP_UINT32("mcl", NvmeNamespace, params.mcl, 128),
 407     DEFINE_PROP_UINT8("msrc", NvmeNamespace, params.msrc, 127),
 408     DEFINE_PROP_BOOL("zoned", NvmeNamespace, params.zoned, false),
 409     DEFINE_PROP_SIZE("zoned.zone_size", NvmeNamespace, params.zone_size_bs,
 410                      NVME_DEFAULT_ZONE_SIZE),
 411     DEFINE_PROP_SIZE("zoned.zone_capacity", NvmeNamespace, params.zone_cap_bs,
 412                      0),
 413     DEFINE_PROP_BOOL("zoned.cross_read", NvmeNamespace,
 414                      params.cross_zone_read, false),
 415     DEFINE_PROP_UINT32("zoned.max_active", NvmeNamespace,
 416                        params.max_active_zones, 0),
 417     DEFINE_PROP_UINT32("zoned.max_open", NvmeNamespace,
 418                        params.max_open_zones, 0),
 419     DEFINE_PROP_UINT32("zoned.descr_ext_size", NvmeNamespace,
 420                        params.zd_extension_size, 0),
 421     DEFINE_PROP_END_OF_LIST(),
 422 };
 423
 424 static void nvme_ns_class_init(ObjectClass *oc, void *data)
 425 {
 426     DeviceClass *dc = DEVICE_CLASS(oc);
 427
 428     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
 429
 430     dc->bus_type = TYPE_NVME_BUS;
 431     dc->realize = nvme_ns_realize;
 432     device_class_set_props(dc, nvme_ns_props);
 433     dc->desc = "Virtual NVMe namespace";
 434 }
 435
 436 static void nvme_ns_instance_init(Object *obj)
 437 {
 438     NvmeNamespace *ns = NVME_NS(obj);
 439     char *bootindex = g_strdup_printf("/namespace@%d,0", ns->params.nsid);
 440
 441     device_add_bootindex_property(obj, &ns->bootindex, "bootindex",
 442                                   bootindex, DEVICE(obj));
 443
 444     g_free(bootindex);
 445 }
 446
 447 static const TypeInfo nvme_ns_info = {
 448     .name = TYPE_NVME_NS,
 449     .parent = TYPE_DEVICE,
 450     .class_init = nvme_ns_class_init,
 451     .instance_size = sizeof(NvmeNamespace),
 452     .instance_init = nvme_ns_instance_init,
 453 };
 454
 455 static void nvme_ns_register_types(void)
 456 {
 457     type_register_static(&nvme_ns_info);
 458 }
 459
 460 type_init(nvme_ns_register_types)