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/cutils.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"
26 #include "hw/qdev-properties.h"
27 #include "hw/qdev-core.h"
33 #define MIN_DISCARD_GRANULARITY (4 * KiB)
35 void nvme_ns_init_format(NvmeNamespace
*ns
)
37 NvmeIdNs
*id_ns
= &ns
->id_ns
;
41 nlbas
= nvme_ns_nlbas(ns
);
43 id_ns
->nsze
= cpu_to_le64(nlbas
);
45 /* no thin provisioning */
46 id_ns
->ncap
= id_ns
->nsze
;
47 id_ns
->nuse
= id_ns
->ncap
;
49 ns
->mdata_offset
= nvme_l2b(ns
, nlbas
);
51 npdg
= ns
->blkconf
.discard_granularity
/ nvme_lsize(ns
);
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
);
58 id_ns
->npda
= id_ns
->npdg
= npdg
- 1;
61 static int nvme_ns_init(NvmeNamespace
*ns
, Error
**errp
)
63 NvmeIdNs
*id_ns
= &ns
->id_ns
;
68 ns
->csi
= NVME_CSI_NVM
;
71 ns
->id_ns
.dlfeat
= 0x1;
73 /* support DULBE and I/O optimization fields */
74 id_ns
->nsfeat
|= (0x4 | 0x10);
76 if (ns
->params
.shared
) {
77 id_ns
->nmic
|= NVME_NMIC_NS_SHARED
;
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
;
85 ds
= 31 - clz32(ns
->blkconf
.logical_block_size
);
91 if (ns
->params
.mset
) {
96 id_ns
->dps
= ((ns
->params
.pil
& 0x1) << 3) | ns
->params
.pi
;
100 [1] = { .ds
= 9, .ms
= 8 },
101 [2] = { .ds
= 9, .ms
= 16 },
102 [3] = { .ds
= 9, .ms
= 64 },
104 [5] = { .ds
= 12, .ms
= 8 },
105 [6] = { .ds
= 12, .ms
= 16 },
106 [7] = { .ds
= 12, .ms
= 64 },
109 memcpy(&id_ns
->lbaf
, &lbaf
, sizeof(lbaf
));
112 NvmeLBAF lbaf
[16] = {
117 memcpy(&id_ns
->lbaf
, &lbaf
, sizeof(lbaf
));
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
) {
131 /* add non-standard lba format */
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
;
138 nvme_ns_init_format(ns
);
143 static int nvme_ns_init_blk(NvmeNamespace
*ns
, Error
**errp
)
147 if (!blkconf_blocksizes(&ns
->blkconf
, errp
)) {
151 read_only
= !blk_supports_write_perm(ns
->blkconf
.blk
);
152 if (!blkconf_apply_backend_options(&ns
->blkconf
, read_only
, false, errp
)) {
156 if (ns
->blkconf
.discard_granularity
== -1) {
157 ns
->blkconf
.discard_granularity
=
158 MAX(ns
->blkconf
.logical_block_size
, MIN_DISCARD_GRANULARITY
);
161 ns
->size
= blk_getlength(ns
->blkconf
.blk
);
163 error_setg_errno(errp
, -ns
->size
, "could not get blockdev size");
170 static int nvme_ns_zoned_check_calc_geometry(NvmeNamespace
*ns
, Error
**errp
)
172 uint64_t zone_size
, zone_cap
;
173 uint32_t lbasz
= nvme_lsize(ns
);
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
;
179 zone_size
= NVME_DEFAULT_ZONE_SIZE
;
181 if (ns
->params
.zone_cap_bs
) {
182 zone_cap
= ns
->params
.zone_cap_bs
;
184 zone_cap
= zone_size
;
186 if (zone_cap
> zone_size
) {
187 error_setg(errp
, "zone capacity %"PRIu64
"B exceeds "
188 "zone size %"PRIu64
"B", zone_cap
, zone_size
);
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
);
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
);
203 * Save the main zone geometry values to avoid
204 * calculating them later again.
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
;
210 /* Do a few more sanity checks of ZNS properties */
211 if (!ns
->num_zones
) {
213 "insufficient drive capacity, must be at least the size "
214 "of one zone (%"PRIu64
"B)", zone_size
);
218 if (ns
->params
.max_open_zones
> ns
->num_zones
) {
220 "max_open_zones value %u exceeds the number of zones %u",
221 ns
->params
.max_open_zones
, ns
->num_zones
);
224 if (ns
->params
.max_active_zones
> ns
->num_zones
) {
226 "max_active_zones value %u exceeds the number of zones %u",
227 ns
->params
.max_active_zones
, ns
->num_zones
);
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
);
238 if (!ns
->params
.max_open_zones
) {
239 ns
->params
.max_open_zones
= ns
->params
.max_active_zones
;
243 if (ns
->params
.zd_extension_size
) {
244 if (ns
->params
.zd_extension_size
& 0x3f) {
246 "zone descriptor extension size must be a multiple of 64B");
249 if ((ns
->params
.zd_extension_size
>> 6) > 0xff) {
250 error_setg(errp
, "zone descriptor extension size is too large");
258 static void nvme_ns_zoned_init_state(NvmeNamespace
*ns
)
260 uint64_t start
= 0, zone_size
= ns
->zone_size
;
261 uint64_t capacity
= ns
->num_zones
* zone_size
;
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
*
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
);
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
;
281 zone
->d
.zt
= NVME_ZONE_TYPE_SEQ_WRITE
;
282 nvme_set_zone_state(zone
, NVME_ZONE_STATE_EMPTY
);
284 zone
->d
.zcap
= ns
->zone_capacity
;
285 zone
->d
.zslba
= start
;
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
);
297 static void nvme_ns_init_zoned(NvmeNamespace
*ns
)
299 NvmeIdNsZoned
*id_ns_z
;
302 nvme_ns_zoned_init_state(ns
);
304 id_ns_z
= g_malloc0(sizeof(NvmeIdNsZoned
));
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);
310 id_ns_z
->ozcs
= ns
->params
.cross_zone_read
? 0x01 : 0x00;
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 */
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
;
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
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);
336 ns
->id_ns
.nsfeat
&= ~0x4;
339 ns
->id_ns_zoned
= id_ns_z
;
342 static void nvme_clear_zone(NvmeNamespace
*ns
, NvmeZone
*zone
)
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
);
354 nvme_aor_inc_active(ns
);
355 QTAILQ_INSERT_HEAD(&ns
->closed_zones
, zone
, entry
);
357 trace_pci_nvme_clear_ns_reset(state
, zone
->d
.zslba
);
358 nvme_set_zone_state(zone
, NVME_ZONE_STATE_EMPTY
);
363 * Close all the zones that are currently open.
365 static void nvme_zoned_ns_shutdown(NvmeNamespace
*ns
)
367 NvmeZone
*zone
, *next
;
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
);
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
);
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
);
387 assert(ns
->nr_open_zones
== 0);
390 static int nvme_ns_check_constraints(NvmeCtrl
*n
, NvmeNamespace
*ns
,
393 if (!ns
->blkconf
.blk
) {
394 error_setg(errp
, "block backend not configured");
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");
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
);
411 if (ns
->params
.detached
) {
412 error_setg(errp
, "detached requires that the nvme device is "
413 "linked to an nvme-subsys device");
417 if (ns
->params
.shared
) {
418 error_setg(errp
, "shared requires that the nvme device is "
419 "linked to an nvme-subsys device");
427 int nvme_ns_setup(NvmeCtrl
*n
, NvmeNamespace
*ns
, Error
**errp
)
429 if (nvme_ns_check_constraints(n
, ns
, errp
)) {
433 if (nvme_ns_init_blk(ns
, errp
)) {
437 if (nvme_ns_init(ns
, errp
)) {
440 if (ns
->params
.zoned
) {
441 if (nvme_ns_zoned_check_calc_geometry(ns
, errp
) != 0) {
444 nvme_ns_init_zoned(ns
);
450 void nvme_ns_drain(NvmeNamespace
*ns
)
452 blk_drain(ns
->blkconf
.blk
);
455 void nvme_ns_shutdown(NvmeNamespace
*ns
)
457 blk_flush(ns
->blkconf
.blk
);
458 if (ns
->params
.zoned
) {
459 nvme_zoned_ns_shutdown(ns
);
463 void nvme_ns_cleanup(NvmeNamespace
*ns
)
465 if (ns
->params
.zoned
) {
466 g_free(ns
->id_ns_zoned
);
467 g_free(ns
->zone_array
);
468 g_free(ns
->zd_extensions
);
472 static void nvme_ns_realize(DeviceState
*dev
, Error
**errp
)
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
;
481 if (nvme_ns_setup(n
, ns
, errp
)) {
486 for (i
= 1; i
<= NVME_MAX_NAMESPACES
; i
++) {
487 if (nvme_ns(n
, i
) || nvme_subsys_ns(subsys
, i
)) {
491 nsid
= ns
->params
.nsid
= i
;
496 error_setg(errp
, "no free namespace id");
500 if (nvme_ns(n
, nsid
) || nvme_subsys_ns(subsys
, nsid
)) {
501 error_setg(errp
, "namespace id '%d' already allocated", nsid
);
507 subsys
->namespaces
[nsid
] = ns
;
509 if (ns
->params
.detached
) {
513 if (ns
->params
.shared
) {
514 for (i
= 0; i
< ARRAY_SIZE(subsys
->ctrls
); i
++) {
515 NvmeCtrl
*ctrl
= subsys
->ctrls
[i
];
518 nvme_attach_ns(ctrl
, ns
);
526 nvme_attach_ns(n
, ns
);
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
,
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(),
558 static void nvme_ns_class_init(ObjectClass
*oc
, void *data
)
560 DeviceClass
*dc
= DEVICE_CLASS(oc
);
562 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
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";
570 static void nvme_ns_instance_init(Object
*obj
)
572 NvmeNamespace
*ns
= NVME_NS(obj
);
573 char *bootindex
= g_strdup_printf("/namespace@%d,0", ns
->params
.nsid
);
575 device_add_bootindex_property(obj
, &ns
->bootindex
, "bootindex",
576 bootindex
, DEVICE(obj
));
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
,
589 static void nvme_ns_register_types(void)
591 type_register_static(&nvme_ns_info
);
594 type_init(nvme_ns_register_types
)