2 * QEMU NVM Express Virtual Namespace
4 * Copyright (c) 2019 CNEX Labs
5 * Copyright (c) 2020 Samsung Electronics
8 * Klaus Jensen <k.jensen@samsung.com>
10 * This work is licensed under the terms of the GNU GPL, version 2. See the
11 * COPYING file in the top-level directory.
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"
25 #define MIN_DISCARD_GRANULARITY (4 * KiB)
26 #define NVME_DEFAULT_ZONE_SIZE (128 * MiB)
28 void nvme_ns_init_format(NvmeNamespace
*ns
)
30 NvmeIdNs
*id_ns
= &ns
->id_ns
;
34 ns
->lbaf
= id_ns
->lbaf
[NVME_ID_NS_FLBAS_INDEX(id_ns
->flbas
)];
35 ns
->lbasz
= 1 << ns
->lbaf
.ds
;
37 nlbas
= ns
->size
/ (ns
->lbasz
+ ns
->lbaf
.ms
);
39 id_ns
->nsze
= cpu_to_le64(nlbas
);
41 /* no thin provisioning */
42 id_ns
->ncap
= id_ns
->nsze
;
43 id_ns
->nuse
= id_ns
->ncap
;
45 ns
->moff
= (int64_t)nlbas
<< ns
->lbaf
.ds
;
47 npdg
= ns
->blkconf
.discard_granularity
/ ns
->lbasz
;
49 ret
= bdrv_get_info(blk_bs(ns
->blkconf
.blk
), &bdi
);
50 if (ret
>= 0 && bdi
.cluster_size
> ns
->blkconf
.discard_granularity
) {
51 npdg
= bdi
.cluster_size
/ ns
->lbasz
;
54 id_ns
->npda
= id_ns
->npdg
= npdg
- 1;
57 static int nvme_ns_init(NvmeNamespace
*ns
, Error
**errp
)
59 NvmeIdNs
*id_ns
= &ns
->id_ns
;
64 ns
->csi
= NVME_CSI_NVM
;
67 ns
->id_ns
.dlfeat
= 0x1;
69 /* support DULBE and I/O optimization fields */
70 id_ns
->nsfeat
|= (0x4 | 0x10);
72 if (ns
->params
.shared
) {
73 id_ns
->nmic
|= NVME_NMIC_NS_SHARED
;
77 id_ns
->mssrl
= cpu_to_le16(ns
->params
.mssrl
);
78 id_ns
->mcl
= cpu_to_le32(ns
->params
.mcl
);
79 id_ns
->msrc
= ns
->params
.msrc
;
81 ds
= 31 - clz32(ns
->blkconf
.logical_block_size
);
87 if (ns
->params
.mset
) {
92 id_ns
->dps
= ((ns
->params
.pil
& 0x1) << 3) | ns
->params
.pi
;
96 [1] = { .ds
= 9, .ms
= 8 },
97 [2] = { .ds
= 9, .ms
= 16 },
98 [3] = { .ds
= 9, .ms
= 64 },
100 [5] = { .ds
= 12, .ms
= 8 },
101 [6] = { .ds
= 12, .ms
= 16 },
102 [7] = { .ds
= 12, .ms
= 64 },
105 memcpy(&id_ns
->lbaf
, &lbaf
, sizeof(lbaf
));
108 NvmeLBAF lbaf
[16] = {
113 memcpy(&id_ns
->lbaf
, &lbaf
, sizeof(lbaf
));
117 for (i
= 0; i
<= id_ns
->nlbaf
; i
++) {
118 NvmeLBAF
*lbaf
= &id_ns
->lbaf
[i
];
119 if (lbaf
->ds
== ds
) {
120 if (lbaf
->ms
== ms
) {
127 /* add non-standard lba format */
129 id_ns
->lbaf
[id_ns
->nlbaf
].ds
= ds
;
130 id_ns
->lbaf
[id_ns
->nlbaf
].ms
= ms
;
131 id_ns
->flbas
|= id_ns
->nlbaf
;
134 nvme_ns_init_format(ns
);
139 static int nvme_ns_init_blk(NvmeNamespace
*ns
, Error
**errp
)
143 if (!blkconf_blocksizes(&ns
->blkconf
, errp
)) {
147 read_only
= !blk_supports_write_perm(ns
->blkconf
.blk
);
148 if (!blkconf_apply_backend_options(&ns
->blkconf
, read_only
, false, errp
)) {
152 if (ns
->blkconf
.discard_granularity
== -1) {
153 ns
->blkconf
.discard_granularity
=
154 MAX(ns
->blkconf
.logical_block_size
, MIN_DISCARD_GRANULARITY
);
157 ns
->size
= blk_getlength(ns
->blkconf
.blk
);
159 error_setg_errno(errp
, -ns
->size
, "could not get blockdev size");
166 static int nvme_ns_zoned_check_calc_geometry(NvmeNamespace
*ns
, Error
**errp
)
168 uint64_t zone_size
, zone_cap
;
170 /* Make sure that the values of ZNS properties are sane */
171 if (ns
->params
.zone_size_bs
) {
172 zone_size
= ns
->params
.zone_size_bs
;
174 zone_size
= NVME_DEFAULT_ZONE_SIZE
;
176 if (ns
->params
.zone_cap_bs
) {
177 zone_cap
= ns
->params
.zone_cap_bs
;
179 zone_cap
= zone_size
;
181 if (zone_cap
> zone_size
) {
182 error_setg(errp
, "zone capacity %"PRIu64
"B exceeds "
183 "zone size %"PRIu64
"B", zone_cap
, zone_size
);
186 if (zone_size
< ns
->lbasz
) {
187 error_setg(errp
, "zone size %"PRIu64
"B too small, "
188 "must be at least %zuB", zone_size
, ns
->lbasz
);
191 if (zone_cap
< ns
->lbasz
) {
192 error_setg(errp
, "zone capacity %"PRIu64
"B too small, "
193 "must be at least %zuB", zone_cap
, ns
->lbasz
);
198 * Save the main zone geometry values to avoid
199 * calculating them later again.
201 ns
->zone_size
= zone_size
/ ns
->lbasz
;
202 ns
->zone_capacity
= zone_cap
/ ns
->lbasz
;
203 ns
->num_zones
= le64_to_cpu(ns
->id_ns
.nsze
) / ns
->zone_size
;
205 /* Do a few more sanity checks of ZNS properties */
206 if (!ns
->num_zones
) {
208 "insufficient drive capacity, must be at least the size "
209 "of one zone (%"PRIu64
"B)", zone_size
);
216 static void nvme_ns_zoned_init_state(NvmeNamespace
*ns
)
218 uint64_t start
= 0, zone_size
= ns
->zone_size
;
219 uint64_t capacity
= ns
->num_zones
* zone_size
;
223 ns
->zone_array
= g_new0(NvmeZone
, ns
->num_zones
);
224 if (ns
->params
.zd_extension_size
) {
225 ns
->zd_extensions
= g_malloc0(ns
->params
.zd_extension_size
*
229 QTAILQ_INIT(&ns
->exp_open_zones
);
230 QTAILQ_INIT(&ns
->imp_open_zones
);
231 QTAILQ_INIT(&ns
->closed_zones
);
232 QTAILQ_INIT(&ns
->full_zones
);
234 zone
= ns
->zone_array
;
235 for (i
= 0; i
< ns
->num_zones
; i
++, zone
++) {
236 if (start
+ zone_size
> capacity
) {
237 zone_size
= capacity
- start
;
239 zone
->d
.zt
= NVME_ZONE_TYPE_SEQ_WRITE
;
240 nvme_set_zone_state(zone
, NVME_ZONE_STATE_EMPTY
);
242 zone
->d
.zcap
= ns
->zone_capacity
;
243 zone
->d
.zslba
= start
;
249 ns
->zone_size_log2
= 0;
250 if (is_power_of_2(ns
->zone_size
)) {
251 ns
->zone_size_log2
= 63 - clz64(ns
->zone_size
);
255 static void nvme_ns_init_zoned(NvmeNamespace
*ns
)
257 NvmeIdNsZoned
*id_ns_z
;
260 nvme_ns_zoned_init_state(ns
);
262 id_ns_z
= g_malloc0(sizeof(NvmeIdNsZoned
));
264 /* MAR/MOR are zeroes-based, FFFFFFFFFh means no limit */
265 id_ns_z
->mar
= cpu_to_le32(ns
->params
.max_active_zones
- 1);
266 id_ns_z
->mor
= cpu_to_le32(ns
->params
.max_open_zones
- 1);
268 id_ns_z
->ozcs
= ns
->params
.cross_zone_read
? 0x01 : 0x00;
270 for (i
= 0; i
<= ns
->id_ns
.nlbaf
; i
++) {
271 id_ns_z
->lbafe
[i
].zsze
= cpu_to_le64(ns
->zone_size
);
272 id_ns_z
->lbafe
[i
].zdes
=
273 ns
->params
.zd_extension_size
>> 6; /* Units of 64B */
276 ns
->csi
= NVME_CSI_ZONED
;
277 ns
->id_ns
.nsze
= cpu_to_le64(ns
->num_zones
* ns
->zone_size
);
278 ns
->id_ns
.ncap
= ns
->id_ns
.nsze
;
279 ns
->id_ns
.nuse
= ns
->id_ns
.ncap
;
282 * The device uses the BDRV_BLOCK_ZERO flag to determine the "deallocated"
283 * status of logical blocks. Since the spec defines that logical blocks
284 * SHALL be deallocated when then zone is in the Empty or Offline states,
285 * we can only support DULBE if the zone size is a multiple of the
288 if (ns
->zone_size
% (ns
->id_ns
.npdg
+ 1)) {
289 warn_report("the zone size (%"PRIu64
" blocks) is not a multiple of "
290 "the calculated deallocation granularity (%d blocks); "
291 "DULBE support disabled",
292 ns
->zone_size
, ns
->id_ns
.npdg
+ 1);
294 ns
->id_ns
.nsfeat
&= ~0x4;
297 ns
->id_ns_zoned
= id_ns_z
;
300 static void nvme_clear_zone(NvmeNamespace
*ns
, NvmeZone
*zone
)
304 zone
->w_ptr
= zone
->d
.wp
;
305 state
= nvme_get_zone_state(zone
);
306 if (zone
->d
.wp
!= zone
->d
.zslba
||
307 (zone
->d
.za
& NVME_ZA_ZD_EXT_VALID
)) {
308 if (state
!= NVME_ZONE_STATE_CLOSED
) {
309 trace_pci_nvme_clear_ns_close(state
, zone
->d
.zslba
);
310 nvme_set_zone_state(zone
, NVME_ZONE_STATE_CLOSED
);
312 nvme_aor_inc_active(ns
);
313 QTAILQ_INSERT_HEAD(&ns
->closed_zones
, zone
, entry
);
315 trace_pci_nvme_clear_ns_reset(state
, zone
->d
.zslba
);
316 nvme_set_zone_state(zone
, NVME_ZONE_STATE_EMPTY
);
321 * Close all the zones that are currently open.
323 static void nvme_zoned_ns_shutdown(NvmeNamespace
*ns
)
325 NvmeZone
*zone
, *next
;
327 QTAILQ_FOREACH_SAFE(zone
, &ns
->closed_zones
, entry
, next
) {
328 QTAILQ_REMOVE(&ns
->closed_zones
, zone
, entry
);
329 nvme_aor_dec_active(ns
);
330 nvme_clear_zone(ns
, zone
);
332 QTAILQ_FOREACH_SAFE(zone
, &ns
->imp_open_zones
, entry
, next
) {
333 QTAILQ_REMOVE(&ns
->imp_open_zones
, zone
, entry
);
334 nvme_aor_dec_open(ns
);
335 nvme_aor_dec_active(ns
);
336 nvme_clear_zone(ns
, zone
);
338 QTAILQ_FOREACH_SAFE(zone
, &ns
->exp_open_zones
, entry
, next
) {
339 QTAILQ_REMOVE(&ns
->exp_open_zones
, zone
, entry
);
340 nvme_aor_dec_open(ns
);
341 nvme_aor_dec_active(ns
);
342 nvme_clear_zone(ns
, zone
);
345 assert(ns
->nr_open_zones
== 0);
348 static int nvme_ns_check_constraints(NvmeCtrl
*n
, NvmeNamespace
*ns
,
351 if (!ns
->blkconf
.blk
) {
352 error_setg(errp
, "block backend not configured");
356 if (ns
->params
.pi
&& ns
->params
.ms
< 8) {
357 error_setg(errp
, "at least 8 bytes of metadata required to enable "
358 "protection information");
362 if (ns
->params
.nsid
> NVME_MAX_NAMESPACES
) {
363 error_setg(errp
, "invalid namespace id (must be between 0 and %d)",
364 NVME_MAX_NAMESPACES
);
369 if (ns
->params
.detached
) {
370 error_setg(errp
, "detached requires that the nvme device is "
371 "linked to an nvme-subsys device");
375 if (ns
->params
.shared
) {
376 error_setg(errp
, "shared requires that the nvme device is "
377 "linked to an nvme-subsys device");
382 if (ns
->params
.zoned
) {
383 if (ns
->params
.max_active_zones
) {
384 if (ns
->params
.max_open_zones
> ns
->params
.max_active_zones
) {
385 error_setg(errp
, "max_open_zones (%u) exceeds "
386 "max_active_zones (%u)", ns
->params
.max_open_zones
,
387 ns
->params
.max_active_zones
);
391 if (!ns
->params
.max_open_zones
) {
392 ns
->params
.max_open_zones
= ns
->params
.max_active_zones
;
396 if (ns
->params
.zd_extension_size
) {
397 if (ns
->params
.zd_extension_size
& 0x3f) {
398 error_setg(errp
, "zone descriptor extension size must be a "
402 if ((ns
->params
.zd_extension_size
>> 6) > 0xff) {
404 "zone descriptor extension size is too large");
413 int nvme_ns_setup(NvmeCtrl
*n
, NvmeNamespace
*ns
, Error
**errp
)
415 if (nvme_ns_check_constraints(n
, ns
, errp
)) {
419 if (nvme_ns_init_blk(ns
, errp
)) {
423 if (nvme_ns_init(ns
, errp
)) {
426 if (ns
->params
.zoned
) {
427 if (nvme_ns_zoned_check_calc_geometry(ns
, errp
) != 0) {
430 nvme_ns_init_zoned(ns
);
436 void nvme_ns_drain(NvmeNamespace
*ns
)
438 blk_drain(ns
->blkconf
.blk
);
441 void nvme_ns_shutdown(NvmeNamespace
*ns
)
443 blk_flush(ns
->blkconf
.blk
);
444 if (ns
->params
.zoned
) {
445 nvme_zoned_ns_shutdown(ns
);
449 void nvme_ns_cleanup(NvmeNamespace
*ns
)
451 if (ns
->params
.zoned
) {
452 g_free(ns
->id_ns_zoned
);
453 g_free(ns
->zone_array
);
454 g_free(ns
->zd_extensions
);
458 static void nvme_ns_realize(DeviceState
*dev
, Error
**errp
)
460 NvmeNamespace
*ns
= NVME_NS(dev
);
461 BusState
*s
= qdev_get_parent_bus(dev
);
462 NvmeCtrl
*n
= NVME(s
->parent
);
463 NvmeSubsystem
*subsys
= n
->subsys
;
464 uint32_t nsid
= ns
->params
.nsid
;
467 if (nvme_ns_setup(n
, ns
, errp
)) {
472 for (i
= 1; i
<= NVME_MAX_NAMESPACES
; i
++) {
473 if (nvme_ns(n
, i
) || nvme_subsys_ns(subsys
, i
)) {
477 nsid
= ns
->params
.nsid
= i
;
482 error_setg(errp
, "no free namespace id");
486 if (nvme_ns(n
, nsid
) || nvme_subsys_ns(subsys
, nsid
)) {
487 error_setg(errp
, "namespace id '%d' already allocated", nsid
);
493 subsys
->namespaces
[nsid
] = ns
;
495 if (ns
->params
.detached
) {
499 if (ns
->params
.shared
) {
500 for (i
= 0; i
< ARRAY_SIZE(subsys
->ctrls
); i
++) {
501 NvmeCtrl
*ctrl
= subsys
->ctrls
[i
];
504 nvme_attach_ns(ctrl
, ns
);
512 nvme_attach_ns(n
, ns
);
515 static Property nvme_ns_props
[] = {
516 DEFINE_BLOCK_PROPERTIES(NvmeNamespace
, blkconf
),
517 DEFINE_PROP_BOOL("detached", NvmeNamespace
, params
.detached
, false),
518 DEFINE_PROP_BOOL("shared", NvmeNamespace
, params
.shared
, false),
519 DEFINE_PROP_UINT32("nsid", NvmeNamespace
, params
.nsid
, 0),
520 DEFINE_PROP_UUID("uuid", NvmeNamespace
, params
.uuid
),
521 DEFINE_PROP_UINT16("ms", NvmeNamespace
, params
.ms
, 0),
522 DEFINE_PROP_UINT8("mset", NvmeNamespace
, params
.mset
, 0),
523 DEFINE_PROP_UINT8("pi", NvmeNamespace
, params
.pi
, 0),
524 DEFINE_PROP_UINT8("pil", NvmeNamespace
, params
.pil
, 0),
525 DEFINE_PROP_UINT16("mssrl", NvmeNamespace
, params
.mssrl
, 128),
526 DEFINE_PROP_UINT32("mcl", NvmeNamespace
, params
.mcl
, 128),
527 DEFINE_PROP_UINT8("msrc", NvmeNamespace
, params
.msrc
, 127),
528 DEFINE_PROP_BOOL("zoned", NvmeNamespace
, params
.zoned
, false),
529 DEFINE_PROP_SIZE("zoned.zone_size", NvmeNamespace
, params
.zone_size_bs
,
530 NVME_DEFAULT_ZONE_SIZE
),
531 DEFINE_PROP_SIZE("zoned.zone_capacity", NvmeNamespace
, params
.zone_cap_bs
,
533 DEFINE_PROP_BOOL("zoned.cross_read", NvmeNamespace
,
534 params
.cross_zone_read
, false),
535 DEFINE_PROP_UINT32("zoned.max_active", NvmeNamespace
,
536 params
.max_active_zones
, 0),
537 DEFINE_PROP_UINT32("zoned.max_open", NvmeNamespace
,
538 params
.max_open_zones
, 0),
539 DEFINE_PROP_UINT32("zoned.descr_ext_size", NvmeNamespace
,
540 params
.zd_extension_size
, 0),
541 DEFINE_PROP_END_OF_LIST(),
544 static void nvme_ns_class_init(ObjectClass
*oc
, void *data
)
546 DeviceClass
*dc
= DEVICE_CLASS(oc
);
548 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
550 dc
->bus_type
= TYPE_NVME_BUS
;
551 dc
->realize
= nvme_ns_realize
;
552 device_class_set_props(dc
, nvme_ns_props
);
553 dc
->desc
= "Virtual NVMe namespace";
556 static void nvme_ns_instance_init(Object
*obj
)
558 NvmeNamespace
*ns
= NVME_NS(obj
);
559 char *bootindex
= g_strdup_printf("/namespace@%d,0", ns
->params
.nsid
);
561 device_add_bootindex_property(obj
, &ns
->bootindex
, "bootindex",
562 bootindex
, DEVICE(obj
));
567 static const TypeInfo nvme_ns_info
= {
568 .name
= TYPE_NVME_NS
,
569 .parent
= TYPE_DEVICE
,
570 .class_init
= nvme_ns_class_init
,
571 .instance_size
= sizeof(NvmeNamespace
),
572 .instance_init
= nvme_ns_instance_init
,
575 static void nvme_ns_register_types(void)
577 type_register_static(&nvme_ns_info
);
580 type_init(nvme_ns_register_types
)