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 void nvme_ns_init_format(NvmeNamespace *ns)
  36 {
  37     NvmeIdNs *id_ns = &ns->id_ns;
  38     BlockDriverInfo bdi;
  39     int npdg, nlbas, ret;
  40
  41     nlbas = nvme_ns_nlbas(ns);
  42
  43     id_ns->nsze = cpu_to_le64(nlbas);
  44
  45     /* no thin provisioning */
  46     id_ns->ncap = id_ns->nsze;
  47     id_ns->nuse = id_ns->ncap;
  48
  49     ns->mdata_offset = nvme_l2b(ns, nlbas);
  50
  51     npdg = ns->blkconf.discard_granularity / nvme_lsize(ns);
  52
  53     ret = bdrv_get_info(blk_bs(ns->blkconf.blk), &bdi);
  54     if (ret >= 0 && bdi.cluster_size > ns->blkconf.discard_granularity) {
  55         npdg = bdi.cluster_size / nvme_lsize(ns);
  56     }
  57
  58     id_ns->npda = id_ns->npdg = npdg - 1;
  59 }
  60
  61 static int nvme_ns_init(NvmeNamespace *ns, Error **errp)
  62 {
  63     NvmeIdNs *id_ns = &ns->id_ns;
  64     uint8_t ds;
  65     uint16_t ms;
  66     int i;
  67
  68     ns->csi = NVME_CSI_NVM;
  69     ns->status = 0x0;
  70
  71     ns->id_ns.dlfeat = 0x1;
  72
  73     /* support DULBE and I/O optimization fields */
  74     id_ns->nsfeat |= (0x4 | 0x10);
  75
  76     if (ns->params.shared) {
  77         id_ns->nmic |= NVME_NMIC_NS_SHARED;
  78     }
  79
  80     /* simple copy */
  81     id_ns->mssrl = cpu_to_le16(ns->params.mssrl);
  82     id_ns->mcl = cpu_to_le32(ns->params.mcl);
  83     id_ns->msrc = ns->params.msrc;
  84
  85     ds = 31 - clz32(ns->blkconf.logical_block_size);
  86     ms = ns->params.ms;
  87
  88     if (ns->params.ms) {
  89         id_ns->mc = 0x3;
  90
  91         if (ns->params.mset) {
  92             id_ns->flbas |= 0x10;
  93         }
  94
  95         id_ns->dpc = 0x1f;
  96         id_ns->dps = ((ns->params.pil & 0x1) << 3) | ns->params.pi;
  97
  98         NvmeLBAF lbaf[16] = {
  99             [0] = { .ds =  9           },
 100             [1] = { .ds =  9, .ms =  8 },
 101             [2] = { .ds =  9, .ms = 16 },
 102             [3] = { .ds =  9, .ms = 64 },
 103             [4] = { .ds = 12           },
 104             [5] = { .ds = 12, .ms =  8 },
 105             [6] = { .ds = 12, .ms = 16 },
 106             [7] = { .ds = 12, .ms = 64 },
 107         };
 108
 109         memcpy(&id_ns->lbaf, &lbaf, sizeof(lbaf));
 110         id_ns->nlbaf = 7;
 111     } else {
 112         NvmeLBAF lbaf[16] = {
 113             [0] = { .ds =  9 },
 114             [1] = { .ds = 12 },
 115         };
 116
 117         memcpy(&id_ns->lbaf, &lbaf, sizeof(lbaf));
 118         id_ns->nlbaf = 1;
 119     }
 120
 121     for (i = 0; i <= id_ns->nlbaf; i++) {
 122         NvmeLBAF *lbaf = &id_ns->lbaf[i];
 123         if (lbaf->ds == ds) {
 124             if (lbaf->ms == ms) {
 125                 id_ns->flbas |= i;
 126                 goto lbaf_found;
 127             }
 128         }
 129     }
 130
 131     /* add non-standard lba format */
 132     id_ns->nlbaf++;
 133     id_ns->lbaf[id_ns->nlbaf].ds = ds;
 134     id_ns->lbaf[id_ns->nlbaf].ms = ms;
 135     id_ns->flbas |= id_ns->nlbaf;
 136
 137 lbaf_found:
 138     nvme_ns_init_format(ns);
 139
 140     return 0;
 141 }
 142
 143 static int nvme_ns_init_blk(NvmeNamespace *ns, Error **errp)
 144 {
 145     bool read_only;
 146
 147     if (!blkconf_blocksizes(&ns->blkconf, errp)) {
 148         return -1;
 149     }
 150
 151     read_only = !blk_supports_write_perm(ns->blkconf.blk);
 152     if (!blkconf_apply_backend_options(&ns->blkconf, read_only, false, errp)) {
 153         return -1;
 154     }
 155
 156     if (ns->blkconf.discard_granularity == -1) {
 157         ns->blkconf.discard_granularity =
 158             MAX(ns->blkconf.logical_block_size, MIN_DISCARD_GRANULARITY);
 159     }
 160
 161     ns->size = blk_getlength(ns->blkconf.blk);
 162     if (ns->size < 0) {
 163         error_setg_errno(errp, -ns->size, "could not get blockdev size");
 164         return -1;
 165     }
 166
 167     return 0;
 168 }
 169
 170 static int nvme_ns_zoned_check_calc_geometry(NvmeNamespace *ns, Error **errp)
 171 {
 172     uint64_t zone_size, zone_cap;
 173     uint32_t lbasz = nvme_lsize(ns);
 174
 175     /* Make sure that the values of ZNS properties are sane */
 176     if (ns->params.zone_size_bs) {
 177         zone_size = ns->params.zone_size_bs;
 178     } else {
 179         zone_size = NVME_DEFAULT_ZONE_SIZE;
 180     }
 181     if (ns->params.zone_cap_bs) {
 182         zone_cap = ns->params.zone_cap_bs;
 183     } else {
 184         zone_cap = zone_size;
 185     }
 186     if (zone_cap > zone_size) {
 187         error_setg(errp, "zone capacity %"PRIu64"B exceeds "
 188                    "zone size %"PRIu64"B", zone_cap, zone_size);
 189         return -1;
 190     }
 191     if (zone_size < lbasz) {
 192         error_setg(errp, "zone size %"PRIu64"B too small, "
 193                    "must be at least %"PRIu32"B", zone_size, lbasz);
 194         return -1;
 195     }
 196     if (zone_cap < lbasz) {
 197         error_setg(errp, "zone capacity %"PRIu64"B too small, "
 198                    "must be at least %"PRIu32"B", zone_cap, lbasz);
 199         return -1;
 200     }
 201
 202     /*
 203      * Save the main zone geometry values to avoid
 204      * calculating them later again.
 205      */
 206     ns->zone_size = zone_size / lbasz;
 207     ns->zone_capacity = zone_cap / lbasz;
 208     ns->num_zones = nvme_ns_nlbas(ns) / ns->zone_size;
 209
 210     /* Do a few more sanity checks of ZNS properties */
 211     if (!ns->num_zones) {
 212         error_setg(errp,
 213                    "insufficient drive capacity, must be at least the size "
 214                    "of one zone (%"PRIu64"B)", zone_size);
 215         return -1;
 216     }
 217
 218     if (ns->params.max_open_zones > ns->num_zones) {
 219         error_setg(errp,
 220                    "max_open_zones value %u exceeds the number of zones %u",
 221                    ns->params.max_open_zones, ns->num_zones);
 222         return -1;
 223     }
 224     if (ns->params.max_active_zones > ns->num_zones) {
 225         error_setg(errp,
 226                    "max_active_zones value %u exceeds the number of zones %u",
 227                    ns->params.max_active_zones, ns->num_zones);
 228         return -1;
 229     }
 230
 231     if (ns->params.max_active_zones) {
 232         if (ns->params.max_open_zones > ns->params.max_active_zones) {
 233             error_setg(errp, "max_open_zones (%u) exceeds max_active_zones (%u)",
 234                        ns->params.max_open_zones, ns->params.max_active_zones);
 235             return -1;
 236         }
 237
 238         if (!ns->params.max_open_zones) {
 239             ns->params.max_open_zones = ns->params.max_active_zones;
 240         }
 241     }
 242
 243     if (ns->params.zd_extension_size) {
 244         if (ns->params.zd_extension_size & 0x3f) {
 245             error_setg(errp,
 246                 "zone descriptor extension size must be a multiple of 64B");
 247             return -1;
 248         }
 249         if ((ns->params.zd_extension_size >> 6) > 0xff) {
 250             error_setg(errp, "zone descriptor extension size is too large");
 251             return -1;
 252         }
 253     }
 254
 255     return 0;
 256 }
 257
 258 static void nvme_ns_zoned_init_state(NvmeNamespace *ns)
 259 {
 260     uint64_t start = 0, zone_size = ns->zone_size;
 261     uint64_t capacity = ns->num_zones * zone_size;
 262     NvmeZone *zone;
 263     int i;
 264
 265     ns->zone_array = g_new0(NvmeZone, ns->num_zones);
 266     if (ns->params.zd_extension_size) {
 267         ns->zd_extensions = g_malloc0(ns->params.zd_extension_size *
 268                                       ns->num_zones);
 269     }
 270
 271     QTAILQ_INIT(&ns->exp_open_zones);
 272     QTAILQ_INIT(&ns->imp_open_zones);
 273     QTAILQ_INIT(&ns->closed_zones);
 274     QTAILQ_INIT(&ns->full_zones);
 275
 276     zone = ns->zone_array;
 277     for (i = 0; i < ns->num_zones; i++, zone++) {
 278         if (start + zone_size > capacity) {
 279             zone_size = capacity - start;
 280         }
 281         zone->d.zt = NVME_ZONE_TYPE_SEQ_WRITE;
 282         nvme_set_zone_state(zone, NVME_ZONE_STATE_EMPTY);
 283         zone->d.za = 0;
 284         zone->d.zcap = ns->zone_capacity;
 285         zone->d.zslba = start;
 286         zone->d.wp = start;
 287         zone->w_ptr = start;
 288         start += zone_size;
 289     }
 290
 291     ns->zone_size_log2 = 0;
 292     if (is_power_of_2(ns->zone_size)) {
 293         ns->zone_size_log2 = 63 - clz64(ns->zone_size);
 294     }
 295 }
 296
 297 static void nvme_ns_init_zoned(NvmeNamespace *ns)
 298 {
 299     NvmeIdNsZoned *id_ns_z;
 300     int i;
 301
 302     nvme_ns_zoned_init_state(ns);
 303
 304     id_ns_z = g_malloc0(sizeof(NvmeIdNsZoned));
 305
 306     /* MAR/MOR are zeroes-based, 0xffffffff means no limit */
 307     id_ns_z->mar = cpu_to_le32(ns->params.max_active_zones - 1);
 308     id_ns_z->mor = cpu_to_le32(ns->params.max_open_zones - 1);
 309     id_ns_z->zoc = 0;
 310     id_ns_z->ozcs = ns->params.cross_zone_read ? 0x01 : 0x00;
 311
 312     for (i = 0; i <= ns->id_ns.nlbaf; i++) {
 313         id_ns_z->lbafe[i].zsze = cpu_to_le64(ns->zone_size);
 314         id_ns_z->lbafe[i].zdes =
 315             ns->params.zd_extension_size >> 6; /* Units of 64B */
 316     }
 317
 318     ns->csi = NVME_CSI_ZONED;
 319     ns->id_ns.nsze = cpu_to_le64(ns->num_zones * ns->zone_size);
 320     ns->id_ns.ncap = ns->id_ns.nsze;
 321     ns->id_ns.nuse = ns->id_ns.ncap;
 322
 323     /*
 324      * The device uses the BDRV_BLOCK_ZERO flag to determine the "deallocated"
 325      * status of logical blocks. Since the spec defines that logical blocks
 326      * SHALL be deallocated when then zone is in the Empty or Offline states,
 327      * we can only support DULBE if the zone size is a multiple of the
 328      * calculated NPDG.
 329      */
 330     if (ns->zone_size % (ns->id_ns.npdg + 1)) {
 331         warn_report("the zone size (%"PRIu64" blocks) is not a multiple of "
 332                     "the calculated deallocation granularity (%d blocks); "
 333                     "DULBE support disabled",
 334                     ns->zone_size, ns->id_ns.npdg + 1);
 335
 336         ns->id_ns.nsfeat &= ~0x4;
 337     }
 338
 339     ns->id_ns_zoned = id_ns_z;
 340 }
 341
 342 static void nvme_clear_zone(NvmeNamespace *ns, NvmeZone *zone)
 343 {
 344     uint8_t state;
 345
 346     zone->w_ptr = zone->d.wp;
 347     state = nvme_get_zone_state(zone);
 348     if (zone->d.wp != zone->d.zslba ||
 349         (zone->d.za & NVME_ZA_ZD_EXT_VALID)) {
 350         if (state != NVME_ZONE_STATE_CLOSED) {
 351             trace_pci_nvme_clear_ns_close(state, zone->d.zslba);
 352             nvme_set_zone_state(zone, NVME_ZONE_STATE_CLOSED);
 353         }
 354         nvme_aor_inc_active(ns);
 355         QTAILQ_INSERT_HEAD(&ns->closed_zones, zone, entry);
 356     } else {
 357         trace_pci_nvme_clear_ns_reset(state, zone->d.zslba);
 358         nvme_set_zone_state(zone, NVME_ZONE_STATE_EMPTY);
 359     }
 360 }
 361
 362 /*
 363  * Close all the zones that are currently open.
 364  */
 365 static void nvme_zoned_ns_shutdown(NvmeNamespace *ns)
 366 {
 367     NvmeZone *zone, *next;
 368
 369     QTAILQ_FOREACH_SAFE(zone, &ns->closed_zones, entry, next) {
 370         QTAILQ_REMOVE(&ns->closed_zones, zone, entry);
 371         nvme_aor_dec_active(ns);
 372         nvme_clear_zone(ns, zone);
 373     }
 374     QTAILQ_FOREACH_SAFE(zone, &ns->imp_open_zones, entry, next) {
 375         QTAILQ_REMOVE(&ns->imp_open_zones, zone, entry);
 376         nvme_aor_dec_open(ns);
 377         nvme_aor_dec_active(ns);
 378         nvme_clear_zone(ns, zone);
 379     }
 380     QTAILQ_FOREACH_SAFE(zone, &ns->exp_open_zones, entry, next) {
 381         QTAILQ_REMOVE(&ns->exp_open_zones, zone, entry);
 382         nvme_aor_dec_open(ns);
 383         nvme_aor_dec_active(ns);
 384         nvme_clear_zone(ns, zone);
 385     }
 386
 387     assert(ns->nr_open_zones == 0);
 388 }
 389
 390 static int nvme_ns_check_constraints(NvmeCtrl *n, NvmeNamespace *ns,
 391                                      Error **errp)
 392 {
 393     if (!ns->blkconf.blk) {
 394         error_setg(errp, "block backend not configured");
 395         return -1;
 396     }
 397
 398     if (ns->params.pi && ns->params.ms < 8) {
 399         error_setg(errp, "at least 8 bytes of metadata required to enable "
 400                    "protection information");
 401         return -1;
 402     }
 403
 404     if (ns->params.nsid > NVME_MAX_NAMESPACES) {
 405         error_setg(errp, "invalid namespace id (must be between 0 and %d)",
 406                    NVME_MAX_NAMESPACES);
 407         return -1;
 408     }
 409
 410     if (!n->subsys) {
 411         if (ns->params.detached) {
 412             error_setg(errp, "detached requires that the nvme device is "
 413                        "linked to an nvme-subsys device");
 414             return -1;
 415         }
 416
 417         if (ns->params.shared) {
 418             error_setg(errp, "shared requires that the nvme device is "
 419                        "linked to an nvme-subsys device");
 420             return -1;
 421         }
 422     }
 423
 424     return 0;
 425 }
 426
 427 int nvme_ns_setup(NvmeCtrl *n, NvmeNamespace *ns, Error **errp)
 428 {
 429     if (nvme_ns_check_constraints(n, ns, errp)) {
 430         return -1;
 431     }
 432
 433     if (nvme_ns_init_blk(ns, errp)) {
 434         return -1;
 435     }
 436
 437     if (nvme_ns_init(ns, errp)) {
 438         return -1;
 439     }
 440     if (ns->params.zoned) {
 441         if (nvme_ns_zoned_check_calc_geometry(ns, errp) != 0) {
 442             return -1;
 443         }
 444         nvme_ns_init_zoned(ns);
 445     }
 446
 447     return 0;
 448 }
 449
 450 void nvme_ns_drain(NvmeNamespace *ns)
 451 {
 452     blk_drain(ns->blkconf.blk);
 453 }
 454
 455 void nvme_ns_shutdown(NvmeNamespace *ns)
 456 {
 457     blk_flush(ns->blkconf.blk);
 458     if (ns->params.zoned) {
 459         nvme_zoned_ns_shutdown(ns);
 460     }
 461 }
 462
 463 void nvme_ns_cleanup(NvmeNamespace *ns)
 464 {
 465     if (ns->params.zoned) {
 466         g_free(ns->id_ns_zoned);
 467         g_free(ns->zone_array);
 468         g_free(ns->zd_extensions);
 469     }
 470 }
 471
 472 static void nvme_ns_realize(DeviceState *dev, Error **errp)
 473 {
 474     NvmeNamespace *ns = NVME_NS(dev);
 475     BusState *s = qdev_get_parent_bus(dev);
 476     NvmeCtrl *n = NVME(s->parent);
 477     NvmeSubsystem *subsys = n->subsys;
 478     uint32_t nsid = ns->params.nsid;
 479     int i;
 480
 481     if (nvme_ns_setup(n, ns, errp)) {
 482         return;
 483     }
 484
 485     if (!nsid) {
 486         for (i = 1; i <= NVME_MAX_NAMESPACES; i++) {
 487             if (nvme_ns(n, i) || nvme_subsys_ns(subsys, i)) {
 488                 continue;
 489             }
 490
 491             nsid = ns->params.nsid = i;
 492             break;
 493         }
 494
 495         if (!nsid) {
 496             error_setg(errp, "no free namespace id");
 497             return;
 498         }
 499     } else {
 500         if (nvme_ns(n, nsid) || nvme_subsys_ns(subsys, nsid)) {
 501             error_setg(errp, "namespace id '%d' already allocated", nsid);
 502             return;
 503         }
 504     }
 505
 506     if (subsys) {
 507         subsys->namespaces[nsid] = ns;
 508
 509         if (ns->params.detached) {
 510             return;
 511         }
 512
 513         if (ns->params.shared) {
 514             for (i = 0; i < ARRAY_SIZE(subsys->ctrls); i++) {
 515                 NvmeCtrl *ctrl = subsys->ctrls[i];
 516
 517                 if (ctrl) {
 518                     nvme_attach_ns(ctrl, ns);
 519                 }
 520             }
 521
 522             return;
 523         }
 524     }
 525
 526     nvme_attach_ns(n, ns);
 527 }
 528
 529 static Property nvme_ns_props[] = {
 530     DEFINE_BLOCK_PROPERTIES(NvmeNamespace, blkconf),
 531     DEFINE_PROP_BOOL("detached", NvmeNamespace, params.detached, false),
 532     DEFINE_PROP_BOOL("shared", NvmeNamespace, params.shared, false),
 533     DEFINE_PROP_UINT32("nsid", NvmeNamespace, params.nsid, 0),
 534     DEFINE_PROP_UUID("uuid", NvmeNamespace, params.uuid),
 535     DEFINE_PROP_UINT16("ms", NvmeNamespace, params.ms, 0),
 536     DEFINE_PROP_UINT8("mset", NvmeNamespace, params.mset, 0),
 537     DEFINE_PROP_UINT8("pi", NvmeNamespace, params.pi, 0),
 538     DEFINE_PROP_UINT8("pil", NvmeNamespace, params.pil, 0),
 539     DEFINE_PROP_UINT16("mssrl", NvmeNamespace, params.mssrl, 128),
 540     DEFINE_PROP_UINT32("mcl", NvmeNamespace, params.mcl, 128),
 541     DEFINE_PROP_UINT8("msrc", NvmeNamespace, params.msrc, 127),
 542     DEFINE_PROP_BOOL("zoned", NvmeNamespace, params.zoned, false),
 543     DEFINE_PROP_SIZE("zoned.zone_size", NvmeNamespace, params.zone_size_bs,
 544                      NVME_DEFAULT_ZONE_SIZE),
 545     DEFINE_PROP_SIZE("zoned.zone_capacity", NvmeNamespace, params.zone_cap_bs,
 546                      0),
 547     DEFINE_PROP_BOOL("zoned.cross_read", NvmeNamespace,
 548                      params.cross_zone_read, false),
 549     DEFINE_PROP_UINT32("zoned.max_active", NvmeNamespace,
 550                        params.max_active_zones, 0),
 551     DEFINE_PROP_UINT32("zoned.max_open", NvmeNamespace,
 552                        params.max_open_zones, 0),
 553     DEFINE_PROP_UINT32("zoned.descr_ext_size", NvmeNamespace,
 554                        params.zd_extension_size, 0),
 555     DEFINE_PROP_END_OF_LIST(),
 556 };
 557
 558 static void nvme_ns_class_init(ObjectClass *oc, void *data)
 559 {
 560     DeviceClass *dc = DEVICE_CLASS(oc);
 561
 562     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
 563
 564     dc->bus_type = TYPE_NVME_BUS;
 565     dc->realize = nvme_ns_realize;
 566     device_class_set_props(dc, nvme_ns_props);
 567     dc->desc = "Virtual NVMe namespace";
 568 }
 569
 570 static void nvme_ns_instance_init(Object *obj)
 571 {
 572     NvmeNamespace *ns = NVME_NS(obj);
 573     char *bootindex = g_strdup_printf("/namespace@%d,0", ns->params.nsid);
 574
 575     device_add_bootindex_property(obj, &ns->bootindex, "bootindex",
 576                                   bootindex, DEVICE(obj));
 577
 578     g_free(bootindex);
 579 }
 580
 581 static const TypeInfo nvme_ns_info = {
 582     .name = TYPE_NVME_NS,
 583     .parent = TYPE_DEVICE,
 584     .class_init = nvme_ns_class_init,
 585     .instance_size = sizeof(NvmeNamespace),
 586     .instance_init = nvme_ns_instance_init,
 587 };
 588
 589 static void nvme_ns_register_types(void)
 590 {
 591     type_register_static(&nvme_ns_info);
 592 }
 593
 594 type_init(nvme_ns_register_types)