| 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 "system/system.h" |
| 22 | #include "system/block-backend.h" |
| 23 | #include "migration/vmstate.h" |
| 24 | |
| 25 | #include "nvme.h" |
| 26 | #include "trace.h" |
| 27 | |
| 28 | #define MIN_DISCARD_GRANULARITY (4 * KiB) |
| 29 | #define NVME_DEFAULT_ZONE_SIZE (128 * MiB) |
| 30 | |
| 31 | void nvme_ns_init_format(NvmeNamespace *ns) |
| 32 | { |
| 33 | NvmeIdNs *id_ns = &ns->id_ns; |
| 34 | NvmeIdNsNvm *id_ns_nvm = &ns->id_ns_nvm; |
| 35 | BlockDriverInfo bdi; |
| 36 | int npdg, ret, index; |
| 37 | int64_t nlbas; |
| 38 | |
| 39 | index = NVME_ID_NS_FLBAS_INDEX(id_ns->flbas); |
| 40 | ns->lbaf = id_ns->lbaf[NVME_ID_NS_FLBAS_INDEX(id_ns->flbas)]; |
| 41 | ns->lbasz = 1 << ns->lbaf.ds; |
| 42 | ns->pif = NVME_ID_NS_NVM_ELBAF_PIF(ns->id_ns_nvm.elbaf[index]); |
| 43 | |
| 44 | nlbas = ns->size / (ns->lbasz + ns->lbaf.ms); |
| 45 | |
| 46 | id_ns->nsze = cpu_to_le64(nlbas); |
| 47 | |
| 48 | /* no thin provisioning */ |
| 49 | id_ns->ncap = id_ns->nsze; |
| 50 | id_ns->nuse = id_ns->ncap; |
| 51 | |
| 52 | ns->moff = nlbas << ns->lbaf.ds; |
| 53 | |
| 54 | npdg = ns->blkconf.discard_granularity / ns->lbasz; |
| 55 | |
| 56 | ret = bdrv_get_info(blk_bs(ns->blkconf.blk), &bdi); |
| 57 | if (ret >= 0 && bdi.cluster_size > ns->blkconf.discard_granularity) { |
| 58 | npdg = bdi.cluster_size / ns->lbasz; |
| 59 | } |
| 60 | |
| 61 | id_ns->npda = id_ns->npdg = npdg - 1; |
| 62 | id_ns_nvm->npdal = npdg; |
| 63 | id_ns_nvm->npdgl = npdg; |
| 64 | } |
| 65 | |
| 66 | static int nvme_ns_init(NvmeNamespace *ns, Error **errp) |
| 67 | { |
| 68 | static uint64_t ns_count; |
| 69 | NvmeIdNs *id_ns = &ns->id_ns; |
| 70 | NvmeIdNsNvm *id_ns_nvm = &ns->id_ns_nvm; |
| 71 | NvmeIdNsInd *id_ns_ind = &ns->id_ns_ind; |
| 72 | uint8_t ds; |
| 73 | uint16_t ms; |
| 74 | int i; |
| 75 | |
| 76 | ns->csi = NVME_CSI_NVM; |
| 77 | ns->status = 0x0; |
| 78 | |
| 79 | ns->id_ns.dlfeat = 0x9; |
| 80 | |
| 81 | /* support DULBE and I/O optimization fields */ |
| 82 | id_ns->nsfeat |= (NVME_ID_NS_NSFEAT_DAE | NVME_ID_NS_NSFEAT_OPTPERF_ALL); |
| 83 | |
| 84 | if (ns->params.shared) { |
| 85 | id_ns->nmic |= NVME_ID_NS_IND_NMIC_SHRNS; |
| 86 | id_ns_ind->nmic = NVME_ID_NS_IND_NMIC_SHRNS; |
| 87 | id_ns_ind->nstat = NVME_ID_NS_IND_NSTAT_NRDY; |
| 88 | } |
| 89 | |
| 90 | /* Substitute a missing EUI-64 by an autogenerated one */ |
| 91 | ++ns_count; |
| 92 | if (!ns->params.eui64 && ns->params.eui64_default) { |
| 93 | ns->params.eui64 = ns_count + NVME_EUI64_DEFAULT; |
| 94 | } |
| 95 | |
| 96 | /* simple copy */ |
| 97 | id_ns->mssrl = cpu_to_le16(ns->params.mssrl); |
| 98 | id_ns->mcl = cpu_to_le32(ns->params.mcl); |
| 99 | id_ns->msrc = ns->params.msrc; |
| 100 | id_ns->eui64 = cpu_to_be64(ns->params.eui64); |
| 101 | memcpy(&id_ns->nguid, &ns->params.nguid.data, sizeof(id_ns->nguid)); |
| 102 | |
| 103 | ds = 31 - clz32(ns->blkconf.logical_block_size); |
| 104 | ms = ns->params.ms; |
| 105 | |
| 106 | id_ns->mc = NVME_ID_NS_MC_EXTENDED | NVME_ID_NS_MC_SEPARATE; |
| 107 | |
| 108 | if (ms && ns->params.mset) { |
| 109 | id_ns->flbas |= NVME_ID_NS_FLBAS_EXTENDED; |
| 110 | } |
| 111 | |
| 112 | id_ns->dpc = 0x1f; |
| 113 | id_ns->dps = ns->params.pi; |
| 114 | if (ns->params.pi && ns->params.pil) { |
| 115 | id_ns->dps |= NVME_ID_NS_DPS_FIRST_EIGHT; |
| 116 | } |
| 117 | |
| 118 | static const NvmeLBAF defaults[16] = { |
| 119 | [0] = { .ds = 9 }, |
| 120 | [1] = { .ds = 9, .ms = 8 }, |
| 121 | [2] = { .ds = 9, .ms = 16 }, |
| 122 | [3] = { .ds = 9, .ms = 64 }, |
| 123 | [4] = { .ds = 12 }, |
| 124 | [5] = { .ds = 12, .ms = 8 }, |
| 125 | [6] = { .ds = 12, .ms = 16 }, |
| 126 | [7] = { .ds = 12, .ms = 64 }, |
| 127 | }; |
| 128 | |
| 129 | ns->nlbaf = 8; |
| 130 | |
| 131 | memcpy(&id_ns->lbaf, &defaults, sizeof(defaults)); |
| 132 | |
| 133 | for (i = 0; i < ns->nlbaf; i++) { |
| 134 | if (id_ns->lbaf[i].ms >= 16) { |
| 135 | id_ns_nvm->elbaf[i] = (ns->params.pif & 0x3) << 7; |
| 136 | } |
| 137 | } |
| 138 | |
| 139 | for (i = 0; i < ns->nlbaf; i++) { |
| 140 | NvmeLBAF *lbaf = &id_ns->lbaf[i]; |
| 141 | if (lbaf->ds == ds) { |
| 142 | if (lbaf->ms == ms) { |
| 143 | id_ns->flbas |= i; |
| 144 | goto lbaf_found; |
| 145 | } |
| 146 | } |
| 147 | } |
| 148 | |
| 149 | /* add non-standard lba format */ |
| 150 | id_ns->lbaf[ns->nlbaf].ds = ds; |
| 151 | id_ns->lbaf[ns->nlbaf].ms = ms; |
| 152 | if (ms >= 16) { |
| 153 | id_ns_nvm->elbaf[ns->nlbaf] = (ns->params.pif & 0x3) << 7; |
| 154 | } |
| 155 | ns->nlbaf++; |
| 156 | |
| 157 | id_ns->flbas |= i; |
| 158 | |
| 159 | lbaf_found: |
| 160 | id_ns->nlbaf = ns->nlbaf - 1; |
| 161 | nvme_ns_init_format(ns); |
| 162 | |
| 163 | return 0; |
| 164 | } |
| 165 | |
| 166 | static int nvme_ns_init_blk(NvmeNamespace *ns, Error **errp) |
| 167 | { |
| 168 | bool read_only; |
| 169 | |
| 170 | if (!blkconf_blocksizes(&ns->blkconf, errp)) { |
| 171 | return -1; |
| 172 | } |
| 173 | |
| 174 | read_only = !blk_supports_write_perm(ns->blkconf.blk); |
| 175 | if (!blkconf_apply_backend_options(&ns->blkconf, read_only, false, errp)) { |
| 176 | return -1; |
| 177 | } |
| 178 | |
| 179 | if (ns->blkconf.discard_granularity == -1) { |
| 180 | ns->blkconf.discard_granularity = |
| 181 | MAX(ns->blkconf.logical_block_size, MIN_DISCARD_GRANULARITY); |
| 182 | } |
| 183 | |
| 184 | ns->size = blk_getlength(ns->blkconf.blk); |
| 185 | if (ns->size < 0) { |
| 186 | error_setg_errno(errp, -ns->size, "could not get blockdev size"); |
| 187 | return -1; |
| 188 | } |
| 189 | |
| 190 | return 0; |
| 191 | } |
| 192 | |
| 193 | static int nvme_ns_zoned_check_calc_geometry(NvmeNamespace *ns, Error **errp) |
| 194 | { |
| 195 | uint64_t zone_size, zone_cap; |
| 196 | |
| 197 | /* Make sure that the values of ZNS properties are sane */ |
| 198 | if (ns->params.zone_size_bs) { |
| 199 | zone_size = ns->params.zone_size_bs; |
| 200 | } else { |
| 201 | zone_size = NVME_DEFAULT_ZONE_SIZE; |
| 202 | } |
| 203 | if (ns->params.zone_cap_bs) { |
| 204 | zone_cap = ns->params.zone_cap_bs; |
| 205 | } else { |
| 206 | zone_cap = zone_size; |
| 207 | } |
| 208 | if (zone_cap > zone_size) { |
| 209 | error_setg(errp, "zone capacity %"PRIu64"B exceeds " |
| 210 | "zone size %"PRIu64"B", zone_cap, zone_size); |
| 211 | return -1; |
| 212 | } |
| 213 | if (zone_size < ns->lbasz) { |
| 214 | error_setg(errp, "zone size %"PRIu64"B too small, " |
| 215 | "must be at least %zuB", zone_size, ns->lbasz); |
| 216 | return -1; |
| 217 | } |
| 218 | if (zone_cap < ns->lbasz) { |
| 219 | error_setg(errp, "zone capacity %"PRIu64"B too small, " |
| 220 | "must be at least %zuB", zone_cap, ns->lbasz); |
| 221 | return -1; |
| 222 | } |
| 223 | |
| 224 | /* |
| 225 | * Save the main zone geometry values to avoid |
| 226 | * calculating them later again. |
| 227 | */ |
| 228 | ns->zone_size = zone_size / ns->lbasz; |
| 229 | ns->zone_capacity = zone_cap / ns->lbasz; |
| 230 | ns->num_zones = le64_to_cpu(ns->id_ns.nsze) / ns->zone_size; |
| 231 | |
| 232 | /* Do a few more sanity checks of ZNS properties */ |
| 233 | if (!ns->num_zones) { |
| 234 | error_setg(errp, |
| 235 | "insufficient drive capacity, must be at least the size " |
| 236 | "of one zone (%"PRIu64"B)", zone_size); |
| 237 | return -1; |
| 238 | } |
| 239 | |
| 240 | return 0; |
| 241 | } |
| 242 | |
| 243 | static void nvme_ns_zoned_init_state(NvmeNamespace *ns) |
| 244 | { |
| 245 | uint64_t start = 0, zone_size = ns->zone_size; |
| 246 | uint64_t capacity = ns->num_zones * zone_size; |
| 247 | NvmeZone *zone; |
| 248 | int i; |
| 249 | |
| 250 | ns->zone_array = g_new0(NvmeZone, ns->num_zones); |
| 251 | if (ns->params.zd_extension_size) { |
| 252 | ns->zd_extensions = g_malloc0(ns->params.zd_extension_size * |
| 253 | ns->num_zones); |
| 254 | } |
| 255 | |
| 256 | QTAILQ_INIT(&ns->exp_open_zones); |
| 257 | QTAILQ_INIT(&ns->imp_open_zones); |
| 258 | QTAILQ_INIT(&ns->closed_zones); |
| 259 | QTAILQ_INIT(&ns->full_zones); |
| 260 | |
| 261 | zone = ns->zone_array; |
| 262 | for (i = 0; i < ns->num_zones; i++, zone++) { |
| 263 | if (start + zone_size > capacity) { |
| 264 | zone_size = capacity - start; |
| 265 | } |
| 266 | zone->d.zt = NVME_ZONE_TYPE_SEQ_WRITE; |
| 267 | nvme_set_zone_state(zone, NVME_ZONE_STATE_EMPTY); |
| 268 | zone->d.za = 0; |
| 269 | zone->d.zcap = ns->zone_capacity; |
| 270 | zone->d.zslba = start; |
| 271 | zone->d.wp = start; |
| 272 | zone->w_ptr = start; |
| 273 | start += zone_size; |
| 274 | } |
| 275 | |
| 276 | ns->zone_size_log2 = 0; |
| 277 | if (is_power_of_2(ns->zone_size)) { |
| 278 | ns->zone_size_log2 = 63 - clz64(ns->zone_size); |
| 279 | } |
| 280 | } |
| 281 | |
| 282 | static void nvme_ns_init_zoned(NvmeNamespace *ns) |
| 283 | { |
| 284 | NvmeIdNsZoned *id_ns_z; |
| 285 | int i; |
| 286 | |
| 287 | nvme_ns_zoned_init_state(ns); |
| 288 | |
| 289 | id_ns_z = g_new0(NvmeIdNsZoned, 1); |
| 290 | |
| 291 | /* MAR/MOR are zeroes-based, FFFFFFFFFh means no limit */ |
| 292 | id_ns_z->mar = cpu_to_le32(ns->params.max_active_zones - 1); |
| 293 | id_ns_z->mor = cpu_to_le32(ns->params.max_open_zones - 1); |
| 294 | id_ns_z->zoc = 0; |
| 295 | id_ns_z->ozcs = ns->params.cross_zone_read ? |
| 296 | NVME_ID_NS_ZONED_OZCS_RAZB : 0x00; |
| 297 | |
| 298 | for (i = 0; i <= ns->id_ns.nlbaf; i++) { |
| 299 | id_ns_z->lbafe[i].zsze = cpu_to_le64(ns->zone_size); |
| 300 | id_ns_z->lbafe[i].zdes = |
| 301 | ns->params.zd_extension_size >> 6; /* Units of 64B */ |
| 302 | } |
| 303 | |
| 304 | if (ns->params.zrwas) { |
| 305 | ns->zns.numzrwa = ns->params.numzrwa ? |
| 306 | ns->params.numzrwa : ns->num_zones; |
| 307 | |
| 308 | ns->zns.zrwas = ns->params.zrwas >> ns->lbaf.ds; |
| 309 | ns->zns.zrwafg = ns->params.zrwafg >> ns->lbaf.ds; |
| 310 | |
| 311 | id_ns_z->ozcs |= NVME_ID_NS_ZONED_OZCS_ZRWASUP; |
| 312 | id_ns_z->zrwacap = NVME_ID_NS_ZONED_ZRWACAP_EXPFLUSHSUP; |
| 313 | |
| 314 | id_ns_z->numzrwa = cpu_to_le32(ns->params.numzrwa); |
| 315 | id_ns_z->zrwas = cpu_to_le16(ns->zns.zrwas); |
| 316 | id_ns_z->zrwafg = cpu_to_le16(ns->zns.zrwafg); |
| 317 | } |
| 318 | |
| 319 | id_ns_z->ozcs = cpu_to_le16(id_ns_z->ozcs); |
| 320 | |
| 321 | ns->csi = NVME_CSI_ZONED; |
| 322 | ns->id_ns.nsze = cpu_to_le64(ns->num_zones * ns->zone_size); |
| 323 | ns->id_ns.ncap = ns->id_ns.nsze; |
| 324 | ns->id_ns.nuse = ns->id_ns.ncap; |
| 325 | |
| 326 | /* |
| 327 | * The device uses the BDRV_BLOCK_ZERO flag to determine the "deallocated" |
| 328 | * status of logical blocks. Since the spec defines that logical blocks |
| 329 | * SHALL be deallocated when then zone is in the Empty or Offline states, |
| 330 | * we can only support DULBE if the zone size is a multiple of the |
| 331 | * calculated NPDG. |
| 332 | */ |
| 333 | if (ns->zone_size % (ns->id_ns.npdg + 1)) { |
| 334 | warn_report("the zone size (%"PRIu64" blocks) is not a multiple of " |
| 335 | "the calculated deallocation granularity (%d blocks); " |
| 336 | "DULBE support disabled", |
| 337 | ns->zone_size, ns->id_ns.npdg + 1); |
| 338 | |
| 339 | ns->id_ns.nsfeat &= ~0x4; |
| 340 | } |
| 341 | |
| 342 | ns->id_ns_zoned = id_ns_z; |
| 343 | } |
| 344 | |
| 345 | static void nvme_clear_zone(NvmeNamespace *ns, NvmeZone *zone) |
| 346 | { |
| 347 | uint8_t state; |
| 348 | |
| 349 | zone->w_ptr = zone->d.wp; |
| 350 | state = nvme_get_zone_state(zone); |
| 351 | if (zone->d.wp != zone->d.zslba || |
| 352 | (zone->d.za & NVME_ZA_ZD_EXT_VALID)) { |
| 353 | if (state != NVME_ZONE_STATE_CLOSED) { |
| 354 | trace_pci_nvme_clear_ns_close(state, zone->d.zslba); |
| 355 | nvme_set_zone_state(zone, NVME_ZONE_STATE_CLOSED); |
| 356 | } |
| 357 | nvme_aor_inc_active(ns); |
| 358 | QTAILQ_INSERT_HEAD(&ns->closed_zones, zone, entry); |
| 359 | } else { |
| 360 | trace_pci_nvme_clear_ns_reset(state, zone->d.zslba); |
| 361 | if (zone->d.za & NVME_ZA_ZRWA_VALID) { |
| 362 | zone->d.za &= ~NVME_ZA_ZRWA_VALID; |
| 363 | ns->zns.numzrwa++; |
| 364 | } |
| 365 | nvme_set_zone_state(zone, NVME_ZONE_STATE_EMPTY); |
| 366 | } |
| 367 | } |
| 368 | |
| 369 | /* |
| 370 | * Close all the zones that are currently open. |
| 371 | */ |
| 372 | static void nvme_zoned_ns_shutdown(NvmeNamespace *ns) |
| 373 | { |
| 374 | NvmeZone *zone, *next; |
| 375 | |
| 376 | QTAILQ_FOREACH_SAFE(zone, &ns->closed_zones, entry, next) { |
| 377 | QTAILQ_REMOVE(&ns->closed_zones, zone, entry); |
| 378 | nvme_aor_dec_active(ns); |
| 379 | nvme_clear_zone(ns, zone); |
| 380 | } |
| 381 | QTAILQ_FOREACH_SAFE(zone, &ns->imp_open_zones, entry, next) { |
| 382 | QTAILQ_REMOVE(&ns->imp_open_zones, zone, entry); |
| 383 | nvme_aor_dec_open(ns); |
| 384 | nvme_aor_dec_active(ns); |
| 385 | nvme_clear_zone(ns, zone); |
| 386 | } |
| 387 | QTAILQ_FOREACH_SAFE(zone, &ns->exp_open_zones, entry, next) { |
| 388 | QTAILQ_REMOVE(&ns->exp_open_zones, zone, entry); |
| 389 | nvme_aor_dec_open(ns); |
| 390 | nvme_aor_dec_active(ns); |
| 391 | nvme_clear_zone(ns, zone); |
| 392 | } |
| 393 | |
| 394 | assert(ns->nr_open_zones == 0); |
| 395 | } |
| 396 | |
| 397 | static NvmeRuHandle *nvme_find_ruh_by_attr(NvmeEnduranceGroup *endgrp, |
| 398 | uint8_t ruha, uint16_t *ruhid) |
| 399 | { |
| 400 | for (uint16_t i = 0; i < endgrp->fdp.nruh; i++) { |
| 401 | NvmeRuHandle *ruh = &endgrp->fdp.ruhs[i]; |
| 402 | |
| 403 | if (ruh->ruha == ruha) { |
| 404 | *ruhid = i; |
| 405 | return ruh; |
| 406 | } |
| 407 | } |
| 408 | |
| 409 | return NULL; |
| 410 | } |
| 411 | |
| 412 | static bool nvme_ns_init_fdp(NvmeNamespace *ns, Error **errp) |
| 413 | { |
| 414 | NvmeEnduranceGroup *endgrp = ns->endgrp; |
| 415 | NvmeRuHandle *ruh; |
| 416 | uint8_t lbafi = NVME_ID_NS_FLBAS_INDEX(ns->id_ns.flbas); |
| 417 | g_autofree unsigned int *ruhids = NULL; |
| 418 | unsigned int n, m, *ruhid; |
| 419 | const char *endptr, *token; |
| 420 | char *r, *p; |
| 421 | uint16_t *ph; |
| 422 | |
| 423 | if (!ns->params.fdp.ruhs) { |
| 424 | ns->fdp.nphs = 1; |
| 425 | ph = ns->fdp.phs = g_new(uint16_t, 1); |
| 426 | |
| 427 | ruh = nvme_find_ruh_by_attr(endgrp, NVME_RUHA_CTRL, ph); |
| 428 | if (!ruh) { |
| 429 | ruh = nvme_find_ruh_by_attr(endgrp, NVME_RUHA_UNUSED, ph); |
| 430 | if (!ruh) { |
| 431 | error_setg(errp, "no unused reclaim unit handles left"); |
| 432 | return false; |
| 433 | } |
| 434 | |
| 435 | ruh->ruha = NVME_RUHA_CTRL; |
| 436 | ruh->lbafi = lbafi; |
| 437 | ruh->ruamw = endgrp->fdp.runs >> ns->lbaf.ds; |
| 438 | |
| 439 | for (uint16_t rg = 0; rg < endgrp->fdp.nrg; rg++) { |
| 440 | ruh->rus[rg].ruamw = ruh->ruamw; |
| 441 | } |
| 442 | } else if (ruh->lbafi != lbafi) { |
| 443 | error_setg(errp, "lba format index of controller assigned " |
| 444 | "reclaim unit handle does not match namespace lba " |
| 445 | "format index"); |
| 446 | return false; |
| 447 | } |
| 448 | |
| 449 | return true; |
| 450 | } |
| 451 | |
| 452 | ruhid = ruhids = g_new0(unsigned int, endgrp->fdp.nruh); |
| 453 | r = p = strdup(ns->params.fdp.ruhs); |
| 454 | |
| 455 | /* parse the placement handle identifiers */ |
| 456 | while ((token = qemu_strsep(&p, ";")) != NULL) { |
| 457 | if (qemu_strtoui(token, &endptr, 0, &n) < 0) { |
| 458 | error_setg(errp, "cannot parse reclaim unit handle identifier"); |
| 459 | free(r); |
| 460 | return false; |
| 461 | } |
| 462 | |
| 463 | m = n; |
| 464 | |
| 465 | /* parse range */ |
| 466 | if (*endptr == '-') { |
| 467 | token = endptr + 1; |
| 468 | |
| 469 | if (qemu_strtoui(token, NULL, 0, &m) < 0) { |
| 470 | error_setg(errp, "cannot parse reclaim unit handle identifier"); |
| 471 | free(r); |
| 472 | return false; |
| 473 | } |
| 474 | |
| 475 | if (m < n) { |
| 476 | error_setg(errp, "invalid reclaim unit handle identifier range"); |
| 477 | free(r); |
| 478 | return false; |
| 479 | } |
| 480 | } |
| 481 | |
| 482 | for (; n <= m; n++) { |
| 483 | if (ns->fdp.nphs++ == endgrp->fdp.nruh) { |
| 484 | error_setg(errp, "too many placement handles"); |
| 485 | free(r); |
| 486 | return false; |
| 487 | } |
| 488 | |
| 489 | *ruhid++ = n; |
| 490 | } |
| 491 | } |
| 492 | |
| 493 | free(r); |
| 494 | |
| 495 | /* verify that the ruhids are unique */ |
| 496 | for (unsigned int i = 0; i < ns->fdp.nphs; i++) { |
| 497 | for (unsigned int j = i + 1; j < ns->fdp.nphs; j++) { |
| 498 | if (ruhids[i] == ruhids[j]) { |
| 499 | error_setg(errp, "duplicate reclaim unit handle identifier: %u", |
| 500 | ruhids[i]); |
| 501 | return false; |
| 502 | } |
| 503 | } |
| 504 | } |
| 505 | |
| 506 | ph = ns->fdp.phs = g_new(uint16_t, ns->fdp.nphs); |
| 507 | |
| 508 | ruhid = ruhids; |
| 509 | |
| 510 | /* verify the identifiers */ |
| 511 | for (unsigned int i = 0; i < ns->fdp.nphs; i++, ruhid++, ph++) { |
| 512 | if (*ruhid >= endgrp->fdp.nruh) { |
| 513 | error_setg(errp, "invalid reclaim unit handle identifier"); |
| 514 | return false; |
| 515 | } |
| 516 | |
| 517 | ruh = &endgrp->fdp.ruhs[*ruhid]; |
| 518 | |
| 519 | switch (ruh->ruha) { |
| 520 | case NVME_RUHA_UNUSED: |
| 521 | ruh->ruha = NVME_RUHA_HOST; |
| 522 | ruh->lbafi = lbafi; |
| 523 | ruh->ruamw = endgrp->fdp.runs >> ns->lbaf.ds; |
| 524 | |
| 525 | for (uint16_t rg = 0; rg < endgrp->fdp.nrg; rg++) { |
| 526 | ruh->rus[rg].ruamw = ruh->ruamw; |
| 527 | } |
| 528 | |
| 529 | break; |
| 530 | |
| 531 | case NVME_RUHA_HOST: |
| 532 | if (ruh->lbafi != lbafi) { |
| 533 | error_setg(errp, "lba format index of host assigned" |
| 534 | "reclaim unit handle does not match namespace " |
| 535 | "lba format index"); |
| 536 | return false; |
| 537 | } |
| 538 | |
| 539 | break; |
| 540 | |
| 541 | case NVME_RUHA_CTRL: |
| 542 | error_setg(errp, "reclaim unit handle is controller assigned"); |
| 543 | return false; |
| 544 | |
| 545 | default: |
| 546 | abort(); |
| 547 | } |
| 548 | |
| 549 | *ph = *ruhid; |
| 550 | } |
| 551 | |
| 552 | return true; |
| 553 | } |
| 554 | |
| 555 | static int nvme_ns_check_constraints(NvmeNamespace *ns, Error **errp) |
| 556 | { |
| 557 | unsigned int pi_size; |
| 558 | |
| 559 | if (!ns->blkconf.blk) { |
| 560 | error_setg(errp, "block backend not configured"); |
| 561 | return -1; |
| 562 | } |
| 563 | |
| 564 | if (ns->params.pi) { |
| 565 | if (ns->params.pi > NVME_ID_NS_DPS_TYPE_3) { |
| 566 | error_setg(errp, "invalid 'pi' value"); |
| 567 | return -1; |
| 568 | } |
| 569 | |
| 570 | switch (ns->params.pif) { |
| 571 | case NVME_PI_GUARD_16: |
| 572 | pi_size = 8; |
| 573 | break; |
| 574 | case NVME_PI_GUARD_64: |
| 575 | pi_size = 16; |
| 576 | break; |
| 577 | default: |
| 578 | error_setg(errp, "invalid 'pif'"); |
| 579 | return -1; |
| 580 | } |
| 581 | |
| 582 | if (ns->params.ms < pi_size) { |
| 583 | error_setg(errp, "at least %u bytes of metadata required to " |
| 584 | "enable protection information", pi_size); |
| 585 | return -1; |
| 586 | } |
| 587 | } |
| 588 | |
| 589 | if (ns->params.nsid > NVME_MAX_NAMESPACES) { |
| 590 | error_setg(errp, "invalid namespace id (must be between 0 and %d)", |
| 591 | NVME_MAX_NAMESPACES); |
| 592 | return -1; |
| 593 | } |
| 594 | |
| 595 | if (ns->params.zoned && ns->endgrp && ns->endgrp->fdp.enabled) { |
| 596 | error_setg(errp, "cannot be a zoned- in an FDP configuration"); |
| 597 | return -1; |
| 598 | } |
| 599 | |
| 600 | if (ns->params.zoned) { |
| 601 | if (ns->params.max_active_zones) { |
| 602 | if (ns->params.max_open_zones > ns->params.max_active_zones) { |
| 603 | error_setg(errp, "max_open_zones (%u) exceeds " |
| 604 | "max_active_zones (%u)", ns->params.max_open_zones, |
| 605 | ns->params.max_active_zones); |
| 606 | return -1; |
| 607 | } |
| 608 | |
| 609 | if (!ns->params.max_open_zones) { |
| 610 | ns->params.max_open_zones = ns->params.max_active_zones; |
| 611 | } |
| 612 | } |
| 613 | |
| 614 | if (ns->params.zd_extension_size) { |
| 615 | if (ns->params.zd_extension_size & 0x3f) { |
| 616 | error_setg(errp, "zone descriptor extension size must be a " |
| 617 | "multiple of 64B"); |
| 618 | return -1; |
| 619 | } |
| 620 | if ((ns->params.zd_extension_size >> 6) > 0xff) { |
| 621 | error_setg(errp, |
| 622 | "zone descriptor extension size is too large"); |
| 623 | return -1; |
| 624 | } |
| 625 | } |
| 626 | |
| 627 | if (ns->params.zrwas) { |
| 628 | if (ns->params.zrwas % ns->blkconf.logical_block_size) { |
| 629 | error_setg(errp, "zone random write area size (zoned.zrwas " |
| 630 | "%"PRIu64") must be a multiple of the logical " |
| 631 | "block size (logical_block_size %"PRIu32")", |
| 632 | ns->params.zrwas, ns->blkconf.logical_block_size); |
| 633 | return -1; |
| 634 | } |
| 635 | |
| 636 | if (ns->params.zrwafg == -1) { |
| 637 | ns->params.zrwafg = ns->blkconf.logical_block_size; |
| 638 | } |
| 639 | |
| 640 | if (ns->params.zrwas % ns->params.zrwafg) { |
| 641 | error_setg(errp, "zone random write area size (zoned.zrwas " |
| 642 | "%"PRIu64") must be a multiple of the zone random " |
| 643 | "write area flush granularity (zoned.zrwafg, " |
| 644 | "%"PRIu64")", ns->params.zrwas, ns->params.zrwafg); |
| 645 | return -1; |
| 646 | } |
| 647 | |
| 648 | if (ns->params.max_active_zones) { |
| 649 | if (ns->params.numzrwa > ns->params.max_active_zones) { |
| 650 | error_setg(errp, "number of zone random write area " |
| 651 | "resources (zoned.numzrwa, %d) must be less " |
| 652 | "than or equal to maximum active resources " |
| 653 | "(zoned.max_active_zones, %d)", |
| 654 | ns->params.numzrwa, |
| 655 | ns->params.max_active_zones); |
| 656 | return -1; |
| 657 | } |
| 658 | } |
| 659 | } |
| 660 | } |
| 661 | |
| 662 | return 0; |
| 663 | } |
| 664 | |
| 665 | int nvme_ns_setup(NvmeNamespace *ns, Error **errp) |
| 666 | { |
| 667 | if (nvme_ns_check_constraints(ns, errp)) { |
| 668 | return -1; |
| 669 | } |
| 670 | |
| 671 | if (nvme_ns_init_blk(ns, errp)) { |
| 672 | return -1; |
| 673 | } |
| 674 | |
| 675 | if (nvme_ns_init(ns, errp)) { |
| 676 | return -1; |
| 677 | } |
| 678 | if (ns->params.zoned) { |
| 679 | if (nvme_ns_zoned_check_calc_geometry(ns, errp) != 0) { |
| 680 | return -1; |
| 681 | } |
| 682 | nvme_ns_init_zoned(ns); |
| 683 | } |
| 684 | |
| 685 | if (ns->endgrp && ns->endgrp->fdp.enabled) { |
| 686 | if (!nvme_ns_init_fdp(ns, errp)) { |
| 687 | return -1; |
| 688 | } |
| 689 | } |
| 690 | |
| 691 | return 0; |
| 692 | } |
| 693 | |
| 694 | void nvme_ns_drain(NvmeNamespace *ns) |
| 695 | { |
| 696 | blk_drain(ns->blkconf.blk); |
| 697 | } |
| 698 | |
| 699 | void nvme_ns_shutdown(NvmeNamespace *ns) |
| 700 | { |
| 701 | blk_flush(ns->blkconf.blk); |
| 702 | if (ns->params.zoned) { |
| 703 | nvme_zoned_ns_shutdown(ns); |
| 704 | } |
| 705 | } |
| 706 | |
| 707 | void nvme_ns_cleanup(NvmeNamespace *ns) |
| 708 | { |
| 709 | if (ns->params.zoned) { |
| 710 | g_free(ns->id_ns_zoned); |
| 711 | g_free(ns->zone_array); |
| 712 | g_free(ns->zd_extensions); |
| 713 | } |
| 714 | |
| 715 | if (ns->endgrp && ns->endgrp->fdp.enabled) { |
| 716 | g_free(ns->fdp.phs); |
| 717 | } |
| 718 | } |
| 719 | |
| 720 | static void nvme_ns_unrealize(DeviceState *dev) |
| 721 | { |
| 722 | NvmeNamespace *ns = NVME_NS(dev); |
| 723 | NvmeSubsystem *subsys = ns->subsys; |
| 724 | uint32_t nsid = ns->params.nsid; |
| 725 | |
| 726 | nvme_ns_drain(ns); |
| 727 | nvme_ns_shutdown(ns); |
| 728 | nvme_ns_cleanup(ns); |
| 729 | |
| 730 | /* Symmetric with nvme_ns_realize() which sets subsys->namespaces[nsid]. */ |
| 731 | if (subsys && nsid && subsys->namespaces[nsid] == ns) { |
| 732 | subsys->namespaces[nsid] = NULL; |
| 733 | } |
| 734 | } |
| 735 | |
| 736 | void nvme_ns_atomic_configure_boundary(bool dn, uint16_t nabsn, |
| 737 | uint16_t nabspf, NvmeAtomic *atomic) |
| 738 | { |
| 739 | atomic->atomic_boundary = dn ? nabspf : nabsn; |
| 740 | |
| 741 | if (atomic->atomic_boundary > 0) { |
| 742 | atomic->atomic_boundary += 1; |
| 743 | } |
| 744 | } |
| 745 | |
| 746 | static bool nvme_ns_set_nab(NvmeCtrl *n, NvmeNamespace *ns, Error **errp) |
| 747 | { |
| 748 | NvmeIdNs *id_ns = &ns->id_ns; |
| 749 | NvmeIdCtrl *id_ctrl = &n->id_ctrl; |
| 750 | |
| 751 | uint16_t nabsn = ns->params.atomic.nabsn; |
| 752 | uint16_t nabspf = ns->params.atomic.nabspf; |
| 753 | uint16_t nabo = ns->params.atomic.nabo; |
| 754 | |
| 755 | if (nabsn && nabsn < le16_to_cpu(id_ctrl->awun)) { |
| 756 | error_setg(errp, "nabsn must be greater than or equal to awun"); |
| 757 | return false; |
| 758 | } |
| 759 | |
| 760 | if (nabspf && nabspf < le16_to_cpu(id_ctrl->awupf)) { |
| 761 | error_setg(errp, "nabspf must be greater than or equal to awupf"); |
| 762 | return false; |
| 763 | } |
| 764 | |
| 765 | if (id_ns->nsfeat & NVME_ID_NS_NSFEAT_NSABP) { |
| 766 | if (nabsn && nabsn < le16_to_cpu(id_ns->nawun)) { |
| 767 | error_setg(errp, "nabsn must be greater than or equal to nawun"); |
| 768 | return false; |
| 769 | } |
| 770 | |
| 771 | if (nabspf && nabspf < le16_to_cpu(id_ns->nawupf)) { |
| 772 | error_setg(errp, "nabspf must be great than or equal to nawupf"); |
| 773 | return false; |
| 774 | } |
| 775 | } |
| 776 | |
| 777 | if (nabo && (nabo > nabsn || nabo > nabspf)) { |
| 778 | error_setg(errp, "nabo must be less than or equal to nabsn and nabspf"); |
| 779 | return false; |
| 780 | } |
| 781 | |
| 782 | id_ns->nabsn = cpu_to_le16(nabsn); |
| 783 | id_ns->nabspf = cpu_to_le16(nabspf); |
| 784 | id_ns->nabo = cpu_to_le16(nabo); |
| 785 | |
| 786 | ns->atomic.atomic_nabo = nabo; |
| 787 | |
| 788 | nvme_ns_atomic_configure_boundary(n->dn, nabsn, nabspf, &ns->atomic); |
| 789 | |
| 790 | return true; |
| 791 | } |
| 792 | |
| 793 | static bool nvme_ns_set_nsabp(NvmeCtrl *n, NvmeNamespace *ns, Error **errp) |
| 794 | { |
| 795 | NvmeIdNs *id_ns = &ns->id_ns; |
| 796 | NvmeIdCtrl *id_ctrl = &n->id_ctrl; |
| 797 | |
| 798 | uint16_t awun = le16_to_cpu(id_ctrl->awun); |
| 799 | uint16_t awupf = le16_to_cpu(id_ctrl->awupf); |
| 800 | |
| 801 | uint16_t nawun = ns->params.atomic.nawun; |
| 802 | uint16_t nawupf = ns->params.atomic.nawupf; |
| 803 | |
| 804 | if (nawupf > nawun) { |
| 805 | if (nawun == 0) { |
| 806 | nawun = nawupf; |
| 807 | } else { |
| 808 | error_setg(errp, "nawupf must be less than or equal to nawun"); |
| 809 | return false; |
| 810 | } |
| 811 | } |
| 812 | |
| 813 | /* neither nawun or nawupf is set */ |
| 814 | if (nawun == 0) { |
| 815 | return true; |
| 816 | } |
| 817 | |
| 818 | if (nawun < awun) { |
| 819 | error_setg(errp, "nawun must be greater than or equal to awun"); |
| 820 | return false; |
| 821 | } |
| 822 | |
| 823 | if (nawupf < awupf) { |
| 824 | error_setg(errp, "nawupf must be greater than or equal to awupf"); |
| 825 | return false; |
| 826 | } |
| 827 | |
| 828 | id_ns->nsfeat |= NVME_ID_NS_NSFEAT_NSABP; |
| 829 | |
| 830 | id_ns->nawun = cpu_to_le16(nawun); |
| 831 | id_ns->nawupf = cpu_to_le16(nawupf); |
| 832 | |
| 833 | nvme_atomic_configure_max_write_size(n->dn, nawun, nawupf, &ns->atomic); |
| 834 | |
| 835 | return true; |
| 836 | } |
| 837 | |
| 838 | static void nvme_ns_realize(DeviceState *dev, Error **errp) |
| 839 | { |
| 840 | NvmeNamespace *ns = NVME_NS(dev); |
| 841 | BusState *s = qdev_get_parent_bus(dev); |
| 842 | NvmeCtrl *n = NVME(s->parent); |
| 843 | NvmeSubsystem *subsys = n->subsys; |
| 844 | uint32_t nsid = ns->params.nsid; |
| 845 | int i; |
| 846 | |
| 847 | assert(subsys); |
| 848 | |
| 849 | /* reparent to subsystem bus */ |
| 850 | if (!qdev_set_parent_bus(dev, &subsys->bus.parent_bus, errp)) { |
| 851 | return; |
| 852 | } |
| 853 | ns->subsys = subsys; |
| 854 | ns->endgrp = &subsys->endgrp; |
| 855 | |
| 856 | if (!nvme_ns_set_nsabp(n, ns, errp)) { |
| 857 | return; |
| 858 | } |
| 859 | |
| 860 | if (!nvme_ns_set_nab(n, ns, errp)) { |
| 861 | return; |
| 862 | } |
| 863 | |
| 864 | if (nvme_ns_setup(ns, errp)) { |
| 865 | return; |
| 866 | } |
| 867 | |
| 868 | if (!nsid) { |
| 869 | for (i = 1; i <= NVME_MAX_NAMESPACES; i++) { |
| 870 | if (nvme_subsys_ns(subsys, i)) { |
| 871 | continue; |
| 872 | } |
| 873 | |
| 874 | nsid = ns->params.nsid = i; |
| 875 | break; |
| 876 | } |
| 877 | |
| 878 | if (!nsid) { |
| 879 | error_setg(errp, "no free namespace id"); |
| 880 | return; |
| 881 | } |
| 882 | } else if (nvme_subsys_ns(subsys, nsid)) { |
| 883 | error_setg(errp, "namespace id '%d' already allocated", nsid); |
| 884 | return; |
| 885 | } |
| 886 | |
| 887 | subsys->namespaces[nsid] = ns; |
| 888 | |
| 889 | ns->id_ns.endgid = cpu_to_le16(0x1); |
| 890 | ns->id_ns_ind.endgrpid = cpu_to_le16(0x1); |
| 891 | |
| 892 | if (!ns->params.shared) { |
| 893 | ns->ctrl = n; |
| 894 | } |
| 895 | } |
| 896 | |
| 897 | static const VMStateDescription nvme_vmstate_lbaf = { |
| 898 | .name = "nvme_lbaf", |
| 899 | .version_id = 1, |
| 900 | .minimum_version_id = 1, |
| 901 | .fields = (const VMStateField[]) { |
| 902 | VMSTATE_UINT16(ms, NvmeLBAF), |
| 903 | VMSTATE_UINT8(ds, NvmeLBAF), |
| 904 | VMSTATE_UINT8(rp, NvmeLBAF), |
| 905 | VMSTATE_END_OF_LIST() |
| 906 | } |
| 907 | }; |
| 908 | |
| 909 | static const VMStateDescription nvme_vmstate_id_ns = { |
| 910 | .name = "nvme_id_ns", |
| 911 | .version_id = 1, |
| 912 | .minimum_version_id = 1, |
| 913 | .fields = (const VMStateField[]) { |
| 914 | VMSTATE_UINT64(nsze, NvmeIdNs), |
| 915 | VMSTATE_UINT64(ncap, NvmeIdNs), |
| 916 | VMSTATE_UINT64(nuse, NvmeIdNs), |
| 917 | VMSTATE_UINT8(nsfeat, NvmeIdNs), |
| 918 | VMSTATE_UINT8(nlbaf, NvmeIdNs), |
| 919 | VMSTATE_UINT8(flbas, NvmeIdNs), |
| 920 | VMSTATE_UINT8(mc, NvmeIdNs), |
| 921 | VMSTATE_UINT8(dpc, NvmeIdNs), |
| 922 | VMSTATE_UINT8(dps, NvmeIdNs), |
| 923 | VMSTATE_UINT8(nmic, NvmeIdNs), |
| 924 | VMSTATE_UINT8(rescap, NvmeIdNs), |
| 925 | VMSTATE_UINT8(fpi, NvmeIdNs), |
| 926 | VMSTATE_UINT8(dlfeat, NvmeIdNs), |
| 927 | VMSTATE_UINT16(nawun, NvmeIdNs), |
| 928 | VMSTATE_UINT16(nawupf, NvmeIdNs), |
| 929 | VMSTATE_UINT16(nacwu, NvmeIdNs), |
| 930 | VMSTATE_UINT16(nabsn, NvmeIdNs), |
| 931 | VMSTATE_UINT16(nabo, NvmeIdNs), |
| 932 | VMSTATE_UINT16(nabspf, NvmeIdNs), |
| 933 | VMSTATE_UINT16(noiob, NvmeIdNs), |
| 934 | VMSTATE_UINT8_ARRAY(nvmcap, NvmeIdNs, 16), |
| 935 | VMSTATE_UINT16(npwg, NvmeIdNs), |
| 936 | VMSTATE_UINT16(npwa, NvmeIdNs), |
| 937 | VMSTATE_UINT16(npdg, NvmeIdNs), |
| 938 | VMSTATE_UINT16(npda, NvmeIdNs), |
| 939 | VMSTATE_UINT16(nows, NvmeIdNs), |
| 940 | VMSTATE_UINT16(mssrl, NvmeIdNs), |
| 941 | VMSTATE_UINT32(mcl, NvmeIdNs), |
| 942 | VMSTATE_UINT8(msrc, NvmeIdNs), |
| 943 | VMSTATE_UINT8_ARRAY(rsvd81, NvmeIdNs, 18), |
| 944 | VMSTATE_UINT8(nsattr, NvmeIdNs), |
| 945 | VMSTATE_UINT16(nvmsetid, NvmeIdNs), |
| 946 | VMSTATE_UINT16(endgid, NvmeIdNs), |
| 947 | VMSTATE_UINT8_ARRAY(nguid, NvmeIdNs, 16), |
| 948 | VMSTATE_UINT64(eui64, NvmeIdNs), |
| 949 | VMSTATE_STRUCT_ARRAY(lbaf, NvmeIdNs, NVME_MAX_NLBAF, 1, |
| 950 | nvme_vmstate_lbaf, NvmeLBAF), |
| 951 | VMSTATE_UINT8_ARRAY(vs, NvmeIdNs, 3712), |
| 952 | |
| 953 | VMSTATE_END_OF_LIST() |
| 954 | } |
| 955 | }; |
| 956 | |
| 957 | static const VMStateDescription nvme_vmstate_id_ns_nvm = { |
| 958 | .name = "nvme_id_ns_nvm", |
| 959 | .version_id = 1, |
| 960 | .minimum_version_id = 1, |
| 961 | .fields = (const VMStateField[]) { |
| 962 | VMSTATE_UINT64(lbstm, NvmeIdNsNvm), |
| 963 | VMSTATE_UINT8(pic, NvmeIdNsNvm), |
| 964 | VMSTATE_UINT8_ARRAY(rsvd9, NvmeIdNsNvm, 3), |
| 965 | VMSTATE_UINT32_ARRAY(elbaf, NvmeIdNsNvm, NVME_MAX_NLBAF), |
| 966 | VMSTATE_UINT32(npdgl, NvmeIdNsNvm), |
| 967 | VMSTATE_UINT32(nprg, NvmeIdNsNvm), |
| 968 | VMSTATE_UINT32(npra, NvmeIdNsNvm), |
| 969 | VMSTATE_UINT32(nors, NvmeIdNsNvm), |
| 970 | VMSTATE_UINT32(npdal, NvmeIdNsNvm), |
| 971 | VMSTATE_UINT8_ARRAY(rsvd288, NvmeIdNsNvm, 3808), |
| 972 | VMSTATE_END_OF_LIST() |
| 973 | } |
| 974 | }; |
| 975 | |
| 976 | static const VMStateDescription nvme_vmstate_id_ns_ind = { |
| 977 | .name = "nvme_id_ns_ind", |
| 978 | .version_id = 1, |
| 979 | .minimum_version_id = 1, |
| 980 | .fields = (const VMStateField[]) { |
| 981 | VMSTATE_UINT8(nsfeat, NvmeIdNsInd), |
| 982 | VMSTATE_UINT8(nmic, NvmeIdNsInd), |
| 983 | VMSTATE_UINT8(rescap, NvmeIdNsInd), |
| 984 | VMSTATE_UINT8(fpi, NvmeIdNsInd), |
| 985 | VMSTATE_UINT32(anagrpid, NvmeIdNsInd), |
| 986 | VMSTATE_UINT8(nsattr, NvmeIdNsInd), |
| 987 | VMSTATE_UINT8(rsvd9, NvmeIdNsInd), |
| 988 | VMSTATE_UINT16(nvmsetid, NvmeIdNsInd), |
| 989 | VMSTATE_UINT16(endgrpid, NvmeIdNsInd), |
| 990 | VMSTATE_UINT8(nstat, NvmeIdNsInd), |
| 991 | VMSTATE_UINT8_ARRAY(rsvd15, NvmeIdNsInd, 4081), |
| 992 | VMSTATE_END_OF_LIST() |
| 993 | } |
| 994 | }; |
| 995 | |
| 996 | typedef struct TmpNvmeNamespace { |
| 997 | NvmeNamespace *parent; |
| 998 | bool enable_write_cache; |
| 999 | } TmpNvmeNamespace; |
| 1000 | |
| 1001 | static bool nvme_ns_tmp_pre_save(void *opaque, Error **errp) |
| 1002 | { |
| 1003 | struct TmpNvmeNamespace *tns = opaque; |
| 1004 | |
| 1005 | tns->enable_write_cache = blk_enable_write_cache(tns->parent->blkconf.blk); |
| 1006 | |
| 1007 | return true; |
| 1008 | } |
| 1009 | |
| 1010 | static bool nvme_ns_tmp_post_load(void *opaque, int version_id, Error **errp) |
| 1011 | { |
| 1012 | struct TmpNvmeNamespace *tns = opaque; |
| 1013 | |
| 1014 | blk_set_enable_write_cache(tns->parent->blkconf.blk, |
| 1015 | tns->enable_write_cache); |
| 1016 | |
| 1017 | return true; |
| 1018 | } |
| 1019 | |
| 1020 | static const VMStateDescription nvme_vmstate_ns_tmp = { |
| 1021 | .name = "nvme_ns_tmp", |
| 1022 | .pre_save_errp = nvme_ns_tmp_pre_save, |
| 1023 | .post_load_errp = nvme_ns_tmp_post_load, |
| 1024 | .fields = (const VMStateField[]) { |
| 1025 | VMSTATE_BOOL(enable_write_cache, TmpNvmeNamespace), |
| 1026 | VMSTATE_END_OF_LIST() |
| 1027 | } |
| 1028 | }; |
| 1029 | |
| 1030 | const VMStateDescription nvme_vmstate_ns = { |
| 1031 | .name = "nvme_ns", |
| 1032 | .version_id = 1, |
| 1033 | .minimum_version_id = 1, |
| 1034 | .fields = (const VMStateField[]) { |
| 1035 | VMSTATE_WITH_TMP(NvmeNamespace, TmpNvmeNamespace, nvme_vmstate_ns_tmp), |
| 1036 | |
| 1037 | VMSTATE_STRUCT(id_ns, NvmeNamespace, 0, nvme_vmstate_id_ns, NvmeIdNs), |
| 1038 | VMSTATE_STRUCT(id_ns_nvm, NvmeNamespace, 0, |
| 1039 | nvme_vmstate_id_ns_nvm, NvmeIdNsNvm), |
| 1040 | VMSTATE_STRUCT(id_ns_ind, NvmeNamespace, 0, |
| 1041 | nvme_vmstate_id_ns_ind, NvmeIdNsInd), |
| 1042 | VMSTATE_STRUCT(lbaf, NvmeNamespace, 0, nvme_vmstate_lbaf, NvmeLBAF), |
| 1043 | VMSTATE_UINT32(nlbaf, NvmeNamespace), |
| 1044 | VMSTATE_UINT8(csi, NvmeNamespace), |
| 1045 | VMSTATE_UINT16(status, NvmeNamespace), |
| 1046 | VMSTATE_UINT8(pif, NvmeNamespace), |
| 1047 | |
| 1048 | VMSTATE_UINT16(zns.zrwas, NvmeNamespace), |
| 1049 | VMSTATE_UINT16(zns.zrwafg, NvmeNamespace), |
| 1050 | VMSTATE_UINT32(zns.numzrwa, NvmeNamespace), |
| 1051 | |
| 1052 | VMSTATE_UINT32(features.err_rec, NvmeNamespace), |
| 1053 | VMSTATE_STRUCT(atomic, NvmeNamespace, 0, |
| 1054 | nvme_vmstate_atomic, NvmeAtomic), |
| 1055 | VMSTATE_END_OF_LIST() |
| 1056 | } |
| 1057 | }; |
| 1058 | |
| 1059 | static const Property nvme_ns_props[] = { |
| 1060 | DEFINE_BLOCK_PROPERTIES(NvmeNamespace, blkconf), |
| 1061 | DEFINE_PROP_BOOL("detached", NvmeNamespace, params.detached, false), |
| 1062 | DEFINE_PROP_BOOL("shared", NvmeNamespace, params.shared, true), |
| 1063 | DEFINE_PROP_UINT32("nsid", NvmeNamespace, params.nsid, 0), |
| 1064 | DEFINE_PROP_UUID_NODEFAULT("uuid", NvmeNamespace, params.uuid), |
| 1065 | DEFINE_PROP_NGUID_NODEFAULT("nguid", NvmeNamespace, params.nguid), |
| 1066 | DEFINE_PROP_UINT64("eui64", NvmeNamespace, params.eui64, 0), |
| 1067 | DEFINE_PROP_UINT16("ms", NvmeNamespace, params.ms, 0), |
| 1068 | DEFINE_PROP_UINT8("mset", NvmeNamespace, params.mset, 0), |
| 1069 | DEFINE_PROP_UINT8("pi", NvmeNamespace, params.pi, 0), |
| 1070 | DEFINE_PROP_UINT8("pil", NvmeNamespace, params.pil, 0), |
| 1071 | DEFINE_PROP_UINT8("pif", NvmeNamespace, params.pif, 0), |
| 1072 | DEFINE_PROP_UINT16("mssrl", NvmeNamespace, params.mssrl, 128), |
| 1073 | DEFINE_PROP_UINT32("mcl", NvmeNamespace, params.mcl, 128), |
| 1074 | DEFINE_PROP_UINT8("msrc", NvmeNamespace, params.msrc, 127), |
| 1075 | DEFINE_PROP_BOOL("zoned", NvmeNamespace, params.zoned, false), |
| 1076 | DEFINE_PROP_SIZE("zoned.zone_size", NvmeNamespace, params.zone_size_bs, |
| 1077 | NVME_DEFAULT_ZONE_SIZE), |
| 1078 | DEFINE_PROP_SIZE("zoned.zone_capacity", NvmeNamespace, params.zone_cap_bs, |
| 1079 | 0), |
| 1080 | DEFINE_PROP_BOOL("zoned.cross_read", NvmeNamespace, |
| 1081 | params.cross_zone_read, false), |
| 1082 | DEFINE_PROP_UINT32("zoned.max_active", NvmeNamespace, |
| 1083 | params.max_active_zones, 0), |
| 1084 | DEFINE_PROP_UINT32("zoned.max_open", NvmeNamespace, |
| 1085 | params.max_open_zones, 0), |
| 1086 | DEFINE_PROP_UINT32("zoned.descr_ext_size", NvmeNamespace, |
| 1087 | params.zd_extension_size, 0), |
| 1088 | DEFINE_PROP_UINT32("zoned.numzrwa", NvmeNamespace, params.numzrwa, 0), |
| 1089 | DEFINE_PROP_SIZE("zoned.zrwas", NvmeNamespace, params.zrwas, 0), |
| 1090 | DEFINE_PROP_SIZE("zoned.zrwafg", NvmeNamespace, params.zrwafg, -1), |
| 1091 | DEFINE_PROP_BOOL("eui64-default", NvmeNamespace, params.eui64_default, |
| 1092 | false), |
| 1093 | DEFINE_PROP_STRING("fdp.ruhs", NvmeNamespace, params.fdp.ruhs), |
| 1094 | DEFINE_PROP_UINT16("atomic.nawun", NvmeNamespace, params.atomic.nawun, 0), |
| 1095 | DEFINE_PROP_UINT16("atomic.nawupf", NvmeNamespace, params.atomic.nawupf, 0), |
| 1096 | DEFINE_PROP_UINT16("atomic.nabsn", NvmeNamespace, params.atomic.nabsn, 0), |
| 1097 | DEFINE_PROP_UINT16("atomic.nabspf", NvmeNamespace, params.atomic.nabspf, 0), |
| 1098 | DEFINE_PROP_UINT16("atomic.nabo", NvmeNamespace, params.atomic.nabo, 0), |
| 1099 | }; |
| 1100 | |
| 1101 | static void nvme_ns_class_init(ObjectClass *oc, const void *data) |
| 1102 | { |
| 1103 | DeviceClass *dc = DEVICE_CLASS(oc); |
| 1104 | |
| 1105 | set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); |
| 1106 | |
| 1107 | dc->bus_type = TYPE_NVME_BUS; |
| 1108 | dc->realize = nvme_ns_realize; |
| 1109 | dc->unrealize = nvme_ns_unrealize; |
| 1110 | dc->hotpluggable = true; |
| 1111 | dc->vmsd = &nvme_vmstate_ns; |
| 1112 | device_class_set_props(dc, nvme_ns_props); |
| 1113 | dc->desc = "Virtual NVMe namespace"; |
| 1114 | } |
| 1115 | |
| 1116 | static void nvme_ns_instance_init(Object *obj) |
| 1117 | { |
| 1118 | NvmeNamespace *ns = NVME_NS(obj); |
| 1119 | |
| 1120 | sprintf(ns->bootindex_suffix, "/namespace@%" PRIu32 ",0", ns->params.nsid); |
| 1121 | |
| 1122 | device_add_bootindex_property(obj, &ns->bootindex, "bootindex", |
| 1123 | ns->bootindex_suffix, DEVICE(obj)); |
| 1124 | } |
| 1125 | |
| 1126 | static const TypeInfo nvme_ns_info = { |
| 1127 | .name = TYPE_NVME_NS, |
| 1128 | .parent = TYPE_DEVICE, |
| 1129 | .class_init = nvme_ns_class_init, |
| 1130 | .instance_size = sizeof(NvmeNamespace), |
| 1131 | .instance_init = nvme_ns_instance_init, |
| 1132 | }; |
| 1133 | |
| 1134 | static void nvme_ns_register_types(void) |
| 1135 | { |
| 1136 | type_register_static(&nvme_ns_info); |
| 1137 | } |
| 1138 | |
| 1139 | type_init(nvme_ns_register_types) |