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