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