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