1 /* 2 * This file and its contents are supplied under the terms of the 3 * Common Development and Distribution License ("CDDL"), version 1.0. 4 * You may only use this file in accordance with the terms of version 5 * 1.0 of the CDDL. 6 * 7 * A full copy of the text of the CDDL should have accompanied this 8 * source. A copy of the CDDL is also available via the Internet at 9 * http://www.illumos.org/license/CDDL. 10 */ 11 12 /* 13 * Copyright 2026 Oxide Computer Company 14 */ 15 16 /* 17 * libnvme error manipulation and translation. This maintains the error objects 18 * that we have on handles and provides translations between the kernel's errors 19 * and those that we might generate ourselves. Information errors are instead 20 * contained in the corresponding files that own controller and namespace 21 * information libnvme_ctrl_info.c and libnvme_ns_info.c respectively. 22 */ 23 24 #include <string.h> 25 #include <stdarg.h> 26 #include <sys/debug.h> 27 #include <sys/sysmacros.h> 28 #include <upanic.h> 29 30 #include "libnvme_impl.h" 31 32 /* 33 * The following sets of functions provide translations of error types. Note, 34 * the kernel headers need to be updated for newer NVMe specs at which point 35 * these should be updated. 36 */ 37 const char * 38 nvme_scttostr(nvme_ctrl_t *ctrl __unused, uint32_t sc) 39 { 40 switch (sc) { 41 case NVME_CQE_SCT_GENERIC: 42 return ("generic command status"); 43 case NVME_CQE_SCT_SPECIFIC: 44 return ("command specific status"); 45 case NVME_CQE_SCT_INTEGRITY: 46 return ("media and data integrity errors"); 47 case NVME_CQE_SCT_PATH: 48 return ("path related status"); 49 case NVME_CQE_SCT_VENDOR: 50 return ("vendor specific"); 51 default: 52 return ("unknown status type"); 53 } 54 } 55 56 static const char * 57 nvme_sctostr_gen_gen(uint32_t sct) 58 { 59 switch (sct) { 60 case NVME_CQE_SC_GEN_SUCCESS: 61 return ("successful completion"); 62 case NVME_CQE_SC_GEN_INV_OPC: 63 return ("invalid command opcode"); 64 case NVME_CQE_SC_GEN_INV_FLD: 65 return ("invalid field in command"); 66 case NVME_CQE_SC_GEN_ID_CNFL: 67 return ("command id conflict"); 68 case NVME_CQE_SC_GEN_DATA_XFR_ERR: 69 return ("data transfer error"); 70 case NVME_CQE_SC_GEN_ABORT_PWRLOSS: 71 return ("commands aborted due to power loss notification"); 72 case NVME_CQE_SC_GEN_INTERNAL_ERR: 73 return ("internal error"); 74 case NVME_CQE_SC_GEN_ABORT_REQUEST: 75 return ("command abort requested"); 76 case NVME_CQE_SC_GEN_ABORT_SQ_DEL: 77 return ("command aborted due to sq deletion"); 78 case NVME_CQE_SC_GEN_ABORT_FUSE_FAIL: 79 return ("command aborted due to failed fused command"); 80 case NVME_CQE_SC_GEN_ABORT_FUSE_MISS: 81 return ("command aborted due to missing fused command"); 82 case NVME_CQE_SC_GEN_INV_NS: 83 return ("invalid namespace or format"); 84 case NVME_CQE_SC_GEN_CMD_SEQ_ERR: 85 return ("command sequence error"); 86 case NVME_CQE_SC_GEN_INV_SGL_LAST: 87 return ("invalid sgl last segment descriptor"); 88 case NVME_CQE_SC_GEN_INV_SGL_NUM: 89 return ("invalid number of sgl descriptors"); 90 case NVME_CQE_SC_GEN_INV_DSGL_LEN: 91 return ("data sgl length invalid"); 92 case NVME_CQE_SC_GEN_INV_MSGL_LEN: 93 return ("metadata sgl length invalid"); 94 case NVME_CQE_SC_GEN_INV_SGL_DESC: 95 return ("sgl descriptor type invalid"); 96 case NVME_CQE_SC_GEN_INV_USE_CMB: 97 return ("invalid use of controller memory buffer"); 98 case NVME_CQE_SC_GEN_INV_PRP_OFF: 99 return ("prp offset invalid"); 100 case NVME_CQE_SC_GEN_AWU_EXCEEDED: 101 return ("atomic write unit exceeded"); 102 case NVME_CQE_SC_GEN_OP_DENIED: 103 return ("operation denied"); 104 case NVME_CQE_SC_GEN_INV_SGL_OFF: 105 return ("sgl offset invalid"); 106 case NVME_CQE_SC_GEN_INV_SGL_ST: 107 return ("sgl sub type invalid"); 108 case NVME_CQE_SC_GEN_INCON_HOSTID: 109 return ("host identifier inconsistent format"); 110 case NVME_CQE_SC_GEN_KA_EXP: 111 return ("keep alive timer expired"); 112 case NVME_CQE_SC_GEN_INV_KA_TO: 113 return ("keep alive timeout invalid"); 114 case NVME_CQE_SC_GEN_ABORT_PREEMPT: 115 return ("command aborted due to preempt and abort"); 116 case NVME_CQE_SC_GEN_SANITIZE_FAIL: 117 return ("sanitize failed"); 118 case NVME_CQE_SC_GEN_SANITIZING: 119 return ("sanitize in progress"); 120 case NVME_CQE_SC_GEN_INV_SGL_GRAN: 121 return ("sgl data block granularity invalid"); 122 case NVME_CQE_SC_GEN_NO_CMD_Q_CMD: 123 return ("command not supported for queue in cmb"); 124 case NVME_CQE_SC_GEN_NS_RDONLY: 125 return ("namespace is write protected"); 126 case NVME_CQE_SC_GEN_CMD_INTR: 127 return ("command interrupted"); 128 case NVME_CQE_SC_GEN_TRANSIENT: 129 return ("transient transport error"); 130 case NVME_CQE_SC_GEN_CMD_LOCK: 131 return ("command prohibited by command and feature lockdown"); 132 case NVME_CQE_SC_GEN_ADM_MEDIA_NR: 133 return ("admin command media not ready"); 134 case NVME_CQE_SC_GEN_INV_KEY: 135 return ("invalid key tag"); 136 case NVME_CQE_SC_GEN_HOST_DISPNS_DIS: 137 return ("host dispersed namespace support not enabled"); 138 case NVME_CQE_SC_GEN_HOSTID_UNINIT: 139 return ("host identifier not initialized"); 140 case NVME_CQE_SC_GEN_WRONG_KEY: 141 return ("incorrect key"); 142 case NVME_CQE_SC_GEN_FDP_DIS: 143 return ("FDP disabled"); 144 case NVME_CQE_SC_GEN_INV_PHL: 145 return ("invalid placement handle list"); 146 case NVME_CQE_SC_GEN_SAN_NS_FAIL: 147 return ("sanitize namespace failed"); 148 case NVME_CQE_SC_GEN_SAN_NS_PROG: 149 return ("sanitize namespace in progress"); 150 default: 151 return ("unknown status code"); 152 } 153 } 154 155 static const char * 156 nvme_sctostr_gen_csi(nvme_csi_t csi, uint32_t sct) 157 { 158 /* 159 * These errors are allowed for all command sets. 160 */ 161 switch (sct) { 162 case NVME_CQE_SC_GEN_NVM_CAP_EXC: 163 return ("capacity exceeded"); 164 case NVME_CQE_SC_GEN_NVM_NS_NOTRDY: 165 return ("namespace not ready"); 166 case NVME_CQE_SC_GEN_NVM_RSV_CNFLCT: 167 return ("reservation conflict"); 168 default: 169 break; 170 } 171 172 switch (csi) { 173 case NVME_CSI_NVM: 174 case NVME_CSI_ZNS: 175 switch (sct) { 176 case NVME_CQE_SC_GEN_NVM_LBA_RANGE: 177 return ("lba out of range"); 178 case NVME_CQE_SC_GEN_NVM_FORMATTING: 179 return ("format in progress"); 180 default: 181 break; 182 } 183 break; 184 case NVME_CSI_KV: 185 switch (sct) { 186 case NVME_CQE_SC_GEN_KEY_INV_VAL: 187 return ("invalid value size"); 188 case NVME_CQE_SC_GEN_KEY_INV_KEY: 189 return ("invalid key size"); 190 case NVME_CQE_SC_GEN_KEY_ENOENT: 191 return ("kv key does not exist"); 192 case NVME_CQE_SC_GEN_KEY_UNRECOV: 193 return ("unrecovered error"); 194 case NVME_CQE_SC_GEN_KEY_EXISTS: 195 return ("key exists"); 196 default: 197 break; 198 } 199 break; 200 default: 201 break; 202 } 203 204 return ("unknown command set specific general status code"); 205 } 206 207 static const char * 208 nvme_sctostr_cmd_gen(uint32_t sct) 209 { 210 switch (sct) { 211 case NVME_CQE_SC_SPC_INV_CQ: 212 return ("completion queue invalid"); 213 case NVME_CQE_SC_SPC_INV_QID: 214 return ("invalid queue identifier"); 215 case NVME_CQE_SC_SPC_MAX_QSZ_EXC: 216 return ("max queue size exceeded"); 217 case NVME_CQE_SC_SPC_ABRT_CMD_EXC: 218 return ("abort command limit exceeded"); 219 case NVME_CQE_SC_SPC_ASYNC_EVREQ_EXC: 220 return ("asynchronous event request limit"); 221 case NVME_CQE_SC_SPC_INV_FW_SLOT: 222 return ("invalid firmware slot"); 223 case NVME_CQE_SC_SPC_INV_FW_IMG: 224 return ("invalid firmware image"); 225 case NVME_CQE_SC_SPC_INV_INT_VECT: 226 return ("invalid interrupt vector"); 227 case NVME_CQE_SC_SPC_INV_LOG_PAGE: 228 return ("invalid log page"); 229 case NVME_CQE_SC_SPC_INV_FORMAT: 230 return ("invalid format"); 231 case NVME_CQE_SC_SPC_FW_RESET: 232 return ("firmware activation requires conventional reset"); 233 case NVME_CQE_SC_SPC_INV_Q_DEL: 234 return ("invalid queue deletion"); 235 case NVME_CQE_SC_SPC_FEAT_SAVE: 236 return ("feature identifier not saveable"); 237 case NVME_CQE_SC_SPC_FEAT_CHG: 238 return ("feature not changeable"); 239 case NVME_CQE_SC_SPC_FEAT_NS_SPEC: 240 return ("feature not namespace spec"); 241 case NVME_CQE_SC_SPC_FW_NSSR: 242 return ("firmware activation requires nvm subsystem reset"); 243 case NVME_CQE_SC_SPC_FW_NEXT_RESET: 244 return ("firmware activation requires controller level reset"); 245 case NVME_CQE_SC_SPC_FW_MTFA: 246 return ("firmware activation requires maximum time violation"); 247 case NVME_CQE_SC_SPC_FW_PROHIBITED: 248 return ("firmware activation prohibited"); 249 case NVME_CQE_SC_SPC_FW_OVERLAP: 250 return ("overlapping range"); 251 case NVME_CQE_SC_SPC_NS_INSUF_CAP: 252 return ("namespace insufficient capacity"); 253 case NVME_CQE_SC_SPC_NS_NO_ID: 254 return ("namespace identifier unavailable"); 255 case NVME_CQE_SC_SPC_NS_ATTACHED: 256 return ("namespace already attached"); 257 case NVME_CQE_SC_SPC_NS_PRIV: 258 return ("namespace is private"); 259 case NVME_CQE_SC_SPC_NS_NOT_ATTACH: 260 return ("namespace is not attached"); 261 case NVME_CQE_SC_SPC_THIN_ENOTSUP: 262 return ("thin provisioning not supported"); 263 case NVME_CQE_SC_SPC_INV_CTRL_LIST: 264 return ("controller list invalid"); 265 case NVME_CQE_SC_SPC_SELF_TESTING: 266 return ("device self-test in progress"); 267 case NVME_CQE_SC_SPC_NO_BP_WRITE: 268 return ("boot partition write protected"); 269 case NVME_CQE_SC_SPC_INV_CTRL_ID: 270 return ("invalid controller identifier"); 271 case NVME_CQE_SC_SPC_INV_SEC_CTRL: 272 return ("invalid secondary controller state"); 273 case NVME_CQE_SC_SPC_INV_CTRL_NRSRC: 274 return ("invalid number of controller resources"); 275 case NVME_CQE_SC_SPC_INV_RSRC_ID: 276 return ("Invalid resource identifier"); 277 case NVME_CQE_SC_SPC_NO_SAN_PMR: 278 return ("sanitize prohibited while persistent memory region " 279 "is enabled"); 280 case NVME_CQE_SC_SPC_INV_ANA_GID: 281 return ("ana group identifier invalid"); 282 case NVME_CQE_SC_SPC_ANA_ATTACH: 283 return ("ana attach failed"); 284 case NVME_CQE_SC_SPC_INSUF_CAP: 285 return ("insufficient capacity"); 286 case NVME_CQE_SC_SPC_NS_ATTACH_LIM: 287 return ("namespace attachment limit exceeded"); 288 case NVME_CQE_SC_SPC_LOCKDOWN_UNSUP: 289 return ("prohibition of command execution not supported"); 290 case NVME_CQE_SC_SPC_UNSUP_IO_CMD: 291 return ("I/O command set not supported"); 292 case NVME_CQE_SC_SPC_DIS_IO_CMD: 293 return ("I/O command set not enabled"); 294 case NVME_CQE_SC_SPC_INV_CMD_COMBO: 295 return ("I/O command set combination rejected"); 296 case NVME_CQE_SC_SPC_INV_IO_CMD: 297 return ("Invalid I/O command set"); 298 case NVME_CQE_SC_SPC_UNAVAIL_ID: 299 return ("identifier unavailable"); 300 case NVME_CQE_SC_SPC_DISPERSE_NS: 301 return ("namespace is dispersed"); 302 case NVME_CQE_SC_SPC_INV_DISC: 303 return ("invalid discovery information"); 304 case NVME_CQE_SC_SPC_ZONE_LOCKED: 305 return ("zoning data structure locked"); 306 case NVME_CQE_SC_SPC_ZONE_ENOENT: 307 return ("zoning data structure not found"); 308 case NVME_CQE_SC_SPC_DISC_RSRCS: 309 return ("insufficient discovery resources"); 310 case NVME_CQE_SC_SPC_FUNC_DIS: 311 return ("requested function disabled"); 312 case NVME_CQE_SC_SPC_INV_ZGRP_ORIG: 313 return ("zonegroup originator invalid"); 314 case NVME_CQE_SC_SPC_INV_HOST: 315 return ("invalid host"); 316 case NVME_CQE_SC_SPC_INV_NVM_SYS: 317 return ("invalid nvm subsystem"); 318 case NVME_CQE_SC_SPC_INV_CTL_DQ: 319 return ("invalid controller data queue"); 320 case NVME_CQE_SC_SPC_ERSRC: 321 return ("not enough resources"); 322 case NVME_CQE_SC_SPC_CTL_SUSPEND: 323 return ("controller suspended"); 324 case NVME_CQE_SC_SPC_CTL_NOT_SUSPEND: 325 return ("controller not suspended"); 326 case NVME_CQE_SC_SPC_CTL_DQ_FULL: 327 return ("controller data queue full"); 328 case NVME_CQE_SC_SPC_MAX_NS_SAN: 329 return ("request exceeds maximum namespace sanitize operations " 330 "in progress"); 331 case NVME_CQE_SC_SPC_REQ_DEF_PERS: 332 return ("manufacturing default personality required"); 333 case NVME_CQE_SC_SPC_INV_PLIMIT: 334 return ("invalid power limit"); 335 case NVME_CQE_SC_SPC_XCTL_RST_PROG: 336 return ("cross-controller reset in progress"); 337 case NVME_CQE_SC_SPC_XCTL_RST_LPF: 338 return ("cross-controller reset log page full"); 339 case NVME_CQE_SC_SPC_XCTL_RST_LIM: 340 return ("cross-controller reset limit exceeded"); 341 default: 342 return ("unknown generic command status code"); 343 } 344 } 345 346 /* 347 * The NVMe 2.0c spec that introduces many of the zoned related errors has 348 * footnotes to suggest some of these are command set specific, but does not 349 * mark any of them. For the moment we basically assume that they're valid 350 * everywhere due to the fact that they don't overlap. 351 */ 352 static const char * 353 nvme_sctostr_cmd_csi(nvme_csi_t csi, uint32_t sct) 354 { 355 switch (sct) { 356 case NVME_CQE_SC_SPC_NVM_CNFL_ATTR: 357 return ("conflicting attributes"); 358 case NVME_CQE_SC_SPC_NVM_INV_PROT: 359 return ("invalid protection"); 360 case NVME_CQE_SC_SPC_NVM_READONLY: 361 return ("write to read only range"); 362 case NVME_CQE_SC_SPC_INV_CID: 363 return ("invalid command id"); 364 case NVME_CQE_SC_SPC_INCOMPAT_NS: 365 return ("incompatible namespace or format"); 366 case NVME_CQE_SC_SPC_NO_FAST_COPY: 367 return ("fast copy not possible"); 368 case NVME_CQE_SC_SPC_OVLP_IO: 369 return ("overlapping i/o range"); 370 case NVME_CQE_SC_SPC_NS_UNREACH: 371 return ("namespace not reachable"); 372 case NVME_CQE_SC_SPC_INSUF_RSRC: 373 return ("insufficient resources"); 374 case NVME_CQE_SC_SPC_INSUF_PROG: 375 return ("insufficient program resources"); 376 case NVME_CQE_SC_SPC_INV_MEM_NS: 377 return ("invalid memory namespace"); 378 case NVME_CQE_SC_SPC_INV_MEM_RANGE: 379 return ("invalid memory range set"); 380 case NVME_CQE_SC_SPC_INV_MEM_SETID: 381 return ("invalid memory range set identifier"); 382 case NVME_CQE_SC_SPC_INV_PROG_DATA: 383 return ("invalid program data"); 384 case NVME_CQE_SC_SPC_INV_PROG_IDX: 385 return ("invalid program index"); 386 case NVME_CQE_SC_SPC_INV_PROG_TYPE: 387 return ("invalid program type"); 388 case NVME_CQE_SC_SPC_MAX_MEM_RANGE: 389 return ("maximum memory ranges exceeded"); 390 case NVME_CQE_SC_SPC_MAX_MEM_SETIDS: 391 return ("maximum memory range sets exceeded"); 392 case NVME_CQE_SC_SPC_MAX_PROG_ACT: 393 return ("maximum programs activated"); 394 case NVME_CQE_SC_SPC_MAX_PROG_BYTES: 395 return ("maximum program bytes exceeded"); 396 case NVME_CQE_SC_SPC_MEM_SET_IN_USE: 397 return ("memory range set in use"); 398 case NVME_CQE_SC_SPC_NO_PROG: 399 return ("no program"); 400 case NVME_CQE_SC_SPC_OVLP_MEM_RANGE: 401 return ("overlapping memory ranges"); 402 case NVME_CQE_SC_SPC_PROG_NOT_ACT: 403 return ("program not activated"); 404 case NVME_CQE_SC_SPC_PROG_IN_USE: 405 return ("program in use"); 406 case NVME_CQE_SC_SPC_PROG_IDX_NO_DL: 407 return ("program index not downloadable"); 408 case NVME_CQE_SC_SPC_PROG_2BIG: 409 return ("program too big"); 410 case NVME_CQE_SC_SPC_MEDIA_VERIF: 411 return ("successful media verification read"); 412 case NVME_CQE_SC_SPC_ZONE_BDRY_ERR: 413 return ("zoned boundary error"); 414 case NVME_CQE_SC_SPC_ZONE_FULL: 415 return ("zone is full"); 416 case NVME_CQE_SC_SPC_ZONE_RDONLY: 417 return ("zone is read only"); 418 case NVME_CQE_SC_SPC_ZONE_OFFLINE: 419 return ("zone is offline"); 420 case NVME_CQE_SC_SPC_ZONE_INV_WRITE: 421 return ("zone invalid write"); 422 case NVME_CQE_SC_SPC_ZONE_ACT: 423 return ("too many active zones"); 424 case NVME_CQE_SC_SPC_ZONE_OPEN: 425 return ("too many open zones"); 426 case NVME_CQE_SC_SPC_INV_ZONE_TRANS: 427 return ("invalid zone state transition"); 428 default: 429 return ("unknown command specific, I/O command set specific " 430 "status code"); 431 } 432 } 433 434 static const char * 435 nvme_sctostr_media(nvme_csi_t csi, uint32_t sct) 436 { 437 if (sct >= NVME_CQE_SC_VEND_MIN) { 438 return ("vendor specific media and data integrity status code"); 439 } 440 441 /* 442 * Unlike NVMe 1.x, NVMe 2.x declares the following command set 443 * independent. 444 */ 445 switch (sct) { 446 case NVME_CQE_SC_INT_NVM_WRITE: 447 return ("write fault"); 448 case NVME_CQE_SC_INT_NVM_READ: 449 return ("unrecovered read error"); 450 case NVME_CQE_SC_INT_NVM_GUARD: 451 return ("guard check error"); 452 case NVME_CQE_SC_INT_NVM_APPL_TAG: 453 return ("application tag check err"); 454 case NVME_CQE_SC_INT_NVM_REF_TAG: 455 return ("reference tag check err"); 456 case NVME_CQE_SC_INT_NVM_ACCESS: 457 return ("access denied"); 458 case NVME_CQE_SC_INT_NVM_TAG: 459 return ("end-to-end storage tag check error"); 460 default: 461 break; 462 } 463 464 /* 465 * The only command-set specific values are currently defined for the 466 * NVM command set. 467 */ 468 if (csi != NVME_CSI_NVM) { 469 return ("unknown media and data integrity status code"); 470 } 471 472 switch (sct) { 473 case NVME_CQE_SC_INT_NVM_COMPARE: 474 return ("compare failure"); 475 case NVME_CQE_SC_INT_NVM_DEALLOC: 476 return ("deallocated or unwritten logical block"); 477 default: 478 return ("unknown media and data integrity status code"); 479 } 480 } 481 482 static const char * 483 nvme_sctostr_path(uint32_t sct) 484 { 485 switch (sct) { 486 case NVME_CQE_SC_PATH_INT_ERR: 487 return ("internal path error"); 488 case NVME_CQE_SC_PATH_AA_PLOSS: 489 return ("asymmetric access persistent loss"); 490 case NVME_CQE_SC_PATH_AA_INACC: 491 return ("asymmetric access inaccessible"); 492 case NVME_CQE_SC_PATH_AA_TRANS: 493 return ("asymmetric access transition"); 494 case NVME_CQE_SC_PATH_CTRL_ERR: 495 return ("controller pathing error"); 496 case NVME_CQE_SC_PATH_HOST_ERR: 497 return ("host pathing error"); 498 case NVME_CQE_SC_PATH_HOST_ABRT: 499 return ("command aborted by host"); 500 default: 501 return ("unknown path related status code"); 502 } 503 } 504 505 const char * 506 nvme_sctostr(nvme_ctrl_t *ctrl __unused, nvme_csi_t csi, uint32_t sct, 507 uint32_t sc) 508 { 509 switch (sct) { 510 case NVME_CQE_SCT_GENERIC: 511 if (sc <= NVME_CQE_SC_GEN_MAX) { 512 return (nvme_sctostr_gen_gen(sc)); 513 } else if (sc <= NVME_CQE_SC_CSI_MAX) { 514 return (nvme_sctostr_gen_csi(csi, sc)); 515 } else { 516 return ("generic vendor specific status code"); 517 } 518 case NVME_CQE_SCT_SPECIFIC: 519 if (sc <= NVME_CQE_SC_GEN_MAX) { 520 return (nvme_sctostr_cmd_gen(sc)); 521 } else if (sc <= NVME_CQE_SC_CSI_MAX) { 522 return (nvme_sctostr_cmd_csi(csi, sc)); 523 } else { 524 return ("command specific vendor specific status code"); 525 } 526 case NVME_CQE_SCT_INTEGRITY: 527 return (nvme_sctostr_media(csi, sc)); 528 case NVME_CQE_SCT_PATH: 529 return (nvme_sctostr_path(sc)); 530 case NVME_CQE_SCT_VENDOR: 531 return ("vendor specific"); 532 default: 533 return ("unknown status code"); 534 } 535 } 536 537 nvme_err_t 538 nvme_err(nvme_t *nvme) 539 { 540 return (nvme->nh_err.ne_err); 541 } 542 543 int32_t 544 nvme_syserr(nvme_t *nvme) 545 { 546 return (nvme->nh_err.ne_syserr); 547 } 548 549 const char * 550 nvme_errmsg(nvme_t *nvme) 551 { 552 return (nvme->nh_err.ne_errmsg); 553 } 554 555 size_t 556 nvme_errlen(nvme_t *nvme) 557 { 558 return (nvme->nh_err.ne_errlen); 559 } 560 561 const char * 562 nvme_errtostr(nvme_t *nvme, nvme_err_t err) 563 { 564 switch (err) { 565 case NVME_ERR_OK: 566 return ("NVME_ERR_OK"); 567 case NVME_ERR_CONTROLLER: 568 return ("NVME_ERR_CONTROLLER"); 569 case NVME_ERR_NO_MEM: 570 return ("NVME_ERR_NO_MEM"); 571 case NVME_ERR_NO_DMA_MEM: 572 return ("NVME_ERR_NO_DMA_MEM"); 573 case NVME_ERR_LIBDEVINFO: 574 return ("NVME_ERR_LIBDEVINFO"); 575 case NVME_ERR_INTERNAL: 576 return ("NVME_ERR_INTERNAL"); 577 case NVME_ERR_BAD_PTR: 578 return ("NVME_ERR_BAD_PTR"); 579 case NVME_ERR_BAD_FLAG: 580 return ("NVME_ERR_BAD_FLAG"); 581 case NVME_ERR_BAD_DEVI: 582 return ("NVME_ERR_BAD_DEVI"); 583 case NVME_ERR_BAD_DEVI_PROP: 584 return ("NVME_ERR_BAD_DEVI_PROP"); 585 case NVME_ERR_ILLEGAL_INSTANCE: 586 return ("NVME_ERR_ILLEGAL_INSTANCE"); 587 case NVME_ERR_BAD_CONTROLLER: 588 return ("NVME_ERR_BAD_CONTROLLER"); 589 case NVME_ERR_PRIVS: 590 return ("NVME_ERR_PRIVS"); 591 case NVME_ERR_OPEN_DEV: 592 return ("NVME_ERR_OPEN_DEV"); 593 case NVME_ERR_BAD_RESTORE: 594 return ("NVME_ERR_BAD_RESTORE"); 595 case NVME_ERR_NS_RANGE: 596 return ("NVME_ERR_NS_RANGE"); 597 case NVME_ERR_NS_UNUSE: 598 return ("NVME_ERR_NS_UNUSE"); 599 case NVME_ERR_LOG_CSI_RANGE: 600 return ("NVME_ERR_LOG_CSI_RANGE"); 601 case NVME_ERR_LOG_LID_RANGE: 602 return ("NVME_ERR_LOG_LID_RANGE"); 603 case NVME_ERR_LOG_LSP_RANGE: 604 return ("NVME_ERR_LOG_LSP_RANGE"); 605 case NVME_ERR_LOG_LSI_RANGE: 606 return ("NVME_ERR_LOG_LSI_RANGE"); 607 case NVME_ERR_LOG_RAE_RANGE: 608 return ("NVME_ERR_LOG_RAE_RANGE"); 609 case NVME_ERR_LOG_SIZE_RANGE: 610 return ("NVME_ERR_LOG_SIZE_RANGE"); 611 case NVME_ERR_LOG_OFFSET_RANGE: 612 return ("NVME_ERR_LOG_OFFSET_RANGE"); 613 case NVME_ERR_LOG_CSI_UNSUP: 614 return ("NVME_ERR_LOG_CSI_UNSUP"); 615 case NVME_ERR_LOG_LSP_UNSUP: 616 return ("NVME_ERR_LOG_LSP_UNSUP"); 617 case NVME_ERR_LOG_LSI_UNSUP: 618 return ("NVME_ERR_LOG_LSI_UNSUP"); 619 case NVME_ERR_LOG_RAE_UNSUP: 620 return ("NVME_ERR_LOG_RAE_UNSUP"); 621 case NVME_ERR_LOG_OFFSET_UNSUP: 622 return ("NVME_ERR_LOG_OFFSET_UNSUP"); 623 case NVME_ERR_LOG_LSP_UNUSE: 624 return ("NVME_ERR_LOG_LSP_UNUSE"); 625 case NVME_ERR_LOG_LSI_UNUSE: 626 return ("NVME_ERR_LOG_LSI_UNUSE"); 627 case NVME_ERR_LOG_RAE_UNUSE: 628 return ("NVME_ERR_LOG_RAE_UNUSE"); 629 case NVME_ERR_LOG_SCOPE_MISMATCH: 630 return ("NVME_ERR_LOG_SCOPE_MISMATCH"); 631 case NVME_ERR_LOG_REQ_MISSING_FIELDS: 632 return ("NVME_ERR_LOG_REQ_MISSING_FIELDS"); 633 case NVME_ERR_LOG_NAME_UNKNOWN: 634 return ("NVME_ERR_LOG_NAME_UNKNOWN"); 635 case NVME_ERR_LOG_UNSUP_BY_DEV: 636 return ("NVME_ERR_LOG_UNSUP_BY_DEV"); 637 case NVME_ERR_IDENTIFY_UNKNOWN: 638 return ("NVME_ERR_IDENTIFY_UNKNOWN"); 639 case NVME_ERR_IDENTIFY_UNSUP_BY_DEV: 640 return ("NVME_ERR_IDENTIFY_UNSUP_BY_DEV"); 641 case NVME_ERR_IDENTIFY_CTRLID_RANGE: 642 return ("NVME_ERR_IDENTIFY_CTRLID_RANGE"); 643 case NVME_ERR_IDENTIFY_OUTPUT_RANGE: 644 return ("NVME_ERR_IDENTIFY_OUTPUT_RANGE"); 645 case NVME_ERR_IDENTIFY_CTRLID_UNSUP: 646 return ("NVME_ERR_IDENTIFY_CTRLID_UNSUP"); 647 case NVME_ERR_IDENTIFY_CTRLID_UNUSE: 648 return ("NVME_ERR_IDENTIFY_CTRLID_UNUSE"); 649 case NVME_ERR_IDENTIFY_REQ_MISSING_FIELDS: 650 return ("NVME_ERR_IDENTIFY_REQ_MISSING_FIELDS"); 651 case NVME_ERR_VUC_UNSUP_BY_DEV: 652 return ("NVME_ERR_VUC_UNSUP_BY_DEV"); 653 case NVME_ERR_VUC_TIMEOUT_RANGE: 654 return ("NVME_ERR_VUC_TIMEOUT_RANGE"); 655 case NVME_ERR_VUC_OPCODE_RANGE: 656 return ("NVME_ERR_VUC_OPCODE_RANGE"); 657 case NVME_ERR_VUC_IMPACT_RANGE: 658 return ("NVME_ERR_VUC_IMPACT_RANGE"); 659 case NVME_ERR_VUC_NDT_RANGE: 660 return ("NVME_ERR_VUC_NDT_RANGE"); 661 case NVME_ERR_VUC_CANNOT_RW: 662 return ("NVME_ERR_VUC_CANNOT_RW"); 663 case NVME_ERR_VUC_NO_RESULTS: 664 return ("NVME_ERR_VUC_NO_RESULTS"); 665 case NVME_ERR_VUC_UNKNOWN: 666 return ("NVME_ERR_VUC_UNKNOWN"); 667 case NVME_ERR_VUC_REQ_MISSING_FIELDS: 668 return ("NVME_ERR_VUC_REQ_MISSING_FIELDS"); 669 case NVME_ERR_VU_FUNC_UNSUP_BY_DEV: 670 return ("NVME_ERR_VU_FUNC_UNSUP_BY_DEV"); 671 case NVME_ERR_WDC_E6_OFFSET_RANGE: 672 return ("NVME_ERR_WDC_E6_OFFSET_RANGE"); 673 case NVME_ERR_FW_UNSUP_BY_DEV: 674 return ("NVME_ERR_FW_UNSUP_BY_DEV"); 675 case NVME_ERR_KERN_FW_IMPOS: 676 return ("NVME_ERR_KERN_FW_IMPOS"); 677 case NVME_ERR_FW_LOAD_LEN_RANGE: 678 return ("NVME_ERR_FW_LOAD_LEN_RANGE"); 679 case NVME_ERR_FW_LOAD_OFFSET_RANGE: 680 return ("NVME_ERR_FW_LOAD_OFFSET_RANGE"); 681 case NVME_ERR_FW_COMMIT_SLOT_RANGE: 682 return ("NVME_ERR_FW_COMMIT_SLOT_RANGE"); 683 case NVME_ERR_FW_COMMIT_ACTION_RANGE: 684 return ("NVME_ERR_FW_COMMIT_ACTION_RANGE"); 685 case NVME_ERR_FW_COMMIT_REQ_MISSING_FIELDS: 686 return ("NVME_ERR_FW_COMMIT_REQ_MISSING_FIELDS"); 687 case NVME_ERR_FW_SLOT_RO: 688 return ("NVME_ERR_FW_SLOT_RO"); 689 case NVME_ERR_FORMAT_UNSUP_BY_DEV: 690 return ("NVME_ERR_FORMAT_UNSUP_BY_DEV"); 691 case NVME_ERR_CRYPTO_SE_UNSUP_BY_DEV: 692 return ("NVME_ERR_CRYPTO_SE_UNSUP_BY_DEV"); 693 case NVME_ERR_NS_FORMAT_UNSUP_BY_DEV: 694 return ("NVME_ERR_NS_FORMAT_UNSUP_BY_DEV"); 695 case NVME_ERR_KERN_FORMAT_UNSUP: 696 return ("NVME_ERR_KERN_FORMAT_UNSUP"); 697 case NVME_ERR_FORMAT_LBAF_RANGE: 698 return ("NVME_ERR_FORMAT_LBAF_RANGE"); 699 case NVME_ERR_FORMAT_SES_RANGE: 700 return ("NVME_ERR_FORMAT_SES_RANGE"); 701 case NVME_ERR_FORMAT_PARAM_UNSUP: 702 return ("NVME_ERR_FORMAT_PARAM_UNSUP"); 703 case NVME_ERR_FORMAT_REQ_MISSING_FIELDS: 704 return ("NVME_ERR_FORMAT_REQ_MISSING_FIELDS"); 705 case NVME_ERR_WDC_E6_REQ_MISSING_FIELDS: 706 return ("NVME_ERR_WDC_E6_REQ_MISSING_FIELDS"); 707 case NVME_ERR_FEAT_NAME_UNKNOWN: 708 return ("NVME_ERR_FEAT_NAME_UNKNOWN"); 709 case NVME_ERR_FEAT_UNSUP_BY_DEV: 710 return ("NVME_ERR_FEAT_UNSUP_BY_DEV"); 711 case NVME_ERR_FEAT_FID_RANGE: 712 return ("NVME_ERR_FEAT_FID_RANGE"); 713 case NVME_ERR_FEAT_SEL_RANGE: 714 return ("NVME_ERR_FEAT_SEL_RANGE"); 715 case NVME_ERR_FEAT_CDW11_RANGE: 716 return ("NVME_ERR_FEAT_CDW11_RANGE"); 717 case NVME_ERR_FEAT_DATA_RANGE: 718 return ("NVME_ERR_FEAT_DATA_RANGE"); 719 case NVME_ERR_FEAT_SEL_UNSUP: 720 return ("NVME_ERR_FEAT_SEL_UNSUP"); 721 case NVME_ERR_FEAT_CDW11_UNUSE: 722 return ("NVME_ERR_FEAT_CDW11_UNUSE"); 723 case NVME_ERR_FEAT_DATA_UNUSE: 724 return ("NVME_ERR_FEAT_DATA_UNUSE"); 725 case NVME_ERR_FEAT_NO_RESULTS: 726 return ("NVME_ERR_FEAT_NO_RESULTS"); 727 case NVME_ERR_GET_FEAT_REQ_MISSING_FIELDS: 728 return ("NVME_ERR_GET_FEAT_REQ_MISSING_FIELDS"); 729 case NVME_ERR_NEED_CTRL_WRLOCK: 730 return ("NVME_ERR_NEED_CTRL_WRLOCK"); 731 case NVME_ERR_NEED_NS_WRLOCK: 732 return ("NVME_ERR_NEED_NS_WRLOCK"); 733 case NVME_ERR_CTRL_LOCKED: 734 return ("NVME_ERR_CTRL_LOCKED"); 735 case NVME_ERR_NS_LOCKED: 736 return ("NVME_ERR_NS_LOCKED"); 737 case NVME_ERR_LOCK_PROG: 738 return ("NVME_ERR_LOCK_PROG"); 739 case NVME_ERR_LOCK_ORDER: 740 return ("NVME_ERR_LOCK_ORDER"); 741 case NVME_ERR_LOCK_WAIT_INTR: 742 return ("NVME_ERR_LOCK_WAIT_INTR"); 743 case NVME_ERR_LOCK_WOULD_BLOCK: 744 return ("NVME_ERR_LOCK_WOULD_BLOCK"); 745 case NVME_ERR_DETACH_KERN: 746 return ("NVME_ERR_DETACH_KERN"); 747 case NVME_ERR_ATTACH_KERN: 748 return ("NVME_ERR_ATTACH_KERN"); 749 case NVME_ERR_ATTACH_UNSUP_KERN: 750 return ("NVME_ERR_ATTACH_UNSUP_KERN"); 751 case NVME_ERR_NS_BLKDEV_ATTACH: 752 return ("NVME_ERR_NS_BLKDEV_ATTACH"); 753 case NVME_ERR_NO_KERN_MEM: 754 return ("NVME_ERR_NO_KERN_MEM"); 755 case NVME_ERR_CTRL_DEAD: 756 return ("NVME_ERR_CTRL_DEAD"); 757 case NVME_ERR_CTRL_GONE: 758 return ("NVME_ERR_CTRL_GONE"); 759 case NVME_ERR_NS_MGMT_UNSUP_BY_DEV: 760 return ("NVME_ERR_NS_MGMT_UNSUP_BY_DEV"); 761 case NVME_ERR_THIN_PROV_UNSUP_BY_DEV: 762 return ("NVME_ERR_THIN_PROV_UNSUP_BY_DEV"); 763 case NVME_ERR_NS_ATTACH_REQ_MISSING_FIELDS: 764 return ("NVME_ERR_NS_ATTACH_REQ_MISSING_FIELDS"); 765 case NVME_ERR_NS_CREATE_REQ_MISSING_FIELDS: 766 return ("NVME_ERR_NS_CREATE_REQ_MISSING_FIELDS"); 767 case NVME_ERR_NS_DELETE_REQ_MISSING_FIELDS: 768 return ("NVME_ERR_NS_DELETE_REQ_MISSING_FIELDS"); 769 case NVME_ERR_NS_CREATE_BAD_CSI: 770 return ("NVME_ERR_NS_CREATE_BAD_CSI"); 771 case NVME_ERR_NS_ATTACH_BAD_SEL: 772 return ("NVME_ERR_NS_ATTACH_BAD_SEL"); 773 case NVME_ERR_NS_CREATE_NO_RESULTS: 774 return ("NVME_ERR_NS_CREATE_NO_RESULTS"); 775 case NVME_ERR_NS_CREATE_NCAP_RANGE: 776 return ("NVME_ERR_NS_CREATE_NCAP_RANGE"); 777 case NVME_ERR_NS_CREATE_NSZE_RANGE: 778 return ("NVME_ERR_NS_CREATE_NSZE_RANGE"); 779 case NVME_ERR_NS_CREATE_NMIC_RANGE: 780 return ("NVME_ERR_NS_CREATE_NMIC_RANGE"); 781 case NVME_ERR_NS_CREATE_FLBAS_RANGE: 782 return ("NVME_ERR_NS_CREATE_FLBAS_RANGE"); 783 case NVME_ERR_NS_CTRL_ATTACHED: 784 return ("NVME_ERR_NS_CTRL_ATTACHED"); 785 case NVME_ERR_NS_CTRL_NOT_ATTACHED: 786 return ("NVME_ERR_NS_CTRL_NOT_ATTACHED"); 787 case NVME_ERR_NS_UNALLOC: 788 return ("NVME_ERR_NS_UNALLOC"); 789 case NVME_ERR_PCIE_LANE_RANGE: 790 return ("NVME_ERR_PCIE_LANE_RANGE"); 791 case NVME_ERR_PCIE_EYE_BUF_RANGE: 792 return ("NVME_ERR_PCIE_EYE_BUF_RANGE"); 793 case NVME_ERR_SET_FEAT_USER_UNSUP: 794 return ("NVME_ERR_SET_FEAT_USER_UNSUP"); 795 case NVME_ERR_FEAT_SAVE_RANGE: 796 return ("NVME_ERR_FEAT_SAVE_RANGE"); 797 case NVME_ERR_FEAT_CDW12_RANGE: 798 return ("NVME_ERR_FEAT_CDW12_RANGE"); 799 case NVME_ERR_FEAT_CDW13_RANGE: 800 return ("NVME_ERR_FEAT_CDW13_RANGE"); 801 case NVME_ERR_FEAT_CDW15_RANGE: 802 return ("NVME_ERR_FEAT_CDW15_RANGE"); 803 case NVME_ERR_FEAT_IMPACT_RANGE: 804 return ("NVME_ERR_FEAT_IMPACT_RANGE"); 805 case NVME_ERR_FEAT_SAVE_UNSUP: 806 return ("NVME_ERR_FEAT_SAVE_UNSUP"); 807 case NVME_ERR_FEAT_CDW12_UNSUP: 808 return ("NVME_ERR_FEAT_CDW12_UNSUP"); 809 case NVME_ERR_FEAT_CDW13_UNSUP: 810 return ("NVME_ERR_FEAT_CDW13_UNSUP"); 811 case NVME_ERR_FEAT_CDW15_UNSUP: 812 return ("NVME_ERR_FEAT_CDW15_UNSUP"); 813 case NVME_ERR_FEAT_CDW12_UNUSE: 814 return ("NVME_ERR_FEAT_CDW12_UNUSE"); 815 case NVME_ERR_FEAT_CDW13_UNUSE: 816 return ("NVME_ERR_FEAT_CDW13_UNUSE"); 817 case NVME_ERR_FEAT_CDW15_UNUSE: 818 return ("NVME_ERR_FEAT_CDW15_UNUSE"); 819 case NVME_ERR_SET_FEAT_REQ_MISSING_FIELDS: 820 return ("NVME_ERR_SET_FEAT_REQ_MISSING_FIELDS"); 821 case NVME_ERR_VU_FEAT_UNSUP_BY_DEV: 822 return ("NVME_ERR_VU_FEAT_UNSUP_BY_DEV"); 823 case NVME_ERR_OCP_ERRINJ_TYPE_RANGE: 824 return ("NVME_ERR_OCP_ERRINJ_TYPE_RANGE"); 825 case NVME_ERR_OCP_ERRINJ_NRTDE_RANGE: 826 return ("NVME_ERR_OCP_ERRINJ_NRTDE_RANGE"); 827 case NVME_ERR_OCP_ERRINJ_LD_RANGE: 828 return ("NVME_ERR_OCP_ERRINJ_LD_RANGE"); 829 case NVME_ERR_OCP_ERRINJ_LD_UNSUP: 830 return ("NVME_ERR_OCP_ERRINJ_LD_UNSUP"); 831 case NVME_ERR_OCP_ERRINJ_LD_UNUSE: 832 return ("NVME_ERR_OCP_ERRINJ_LD_UNUSE"); 833 case NVME_ERR_OCP_ERRINJ_REQ_MISSING_FIELDS: 834 return ("NVME_ERR_OCP_ERRINJ_REQ_MISSING_FIELDS"); 835 default: 836 return ("unknown error"); 837 } 838 } 839 840 nvme_err_t 841 nvme_ctrl_err(nvme_ctrl_t *ctrl) 842 { 843 return (ctrl->nc_err.ne_err); 844 } 845 846 int32_t 847 nvme_ctrl_syserr(nvme_ctrl_t *ctrl) 848 { 849 return (ctrl->nc_err.ne_syserr); 850 } 851 852 const char * 853 nvme_ctrl_errmsg(nvme_ctrl_t *ctrl) 854 { 855 return (ctrl->nc_err.ne_errmsg); 856 } 857 858 size_t 859 nvme_ctrl_errlen(nvme_ctrl_t *ctrl) 860 { 861 return (ctrl->nc_err.ne_errlen); 862 } 863 864 void 865 nvme_ctrl_deverr(nvme_ctrl_t *ctrl, uint32_t *sct, uint32_t *sc) 866 { 867 if (sct != NULL) { 868 *sct = ctrl->nc_err.ne_ctrl_sct; 869 } 870 871 if (sc != NULL) { 872 *sc = ctrl->nc_err.ne_ctrl_sc; 873 } 874 } 875 876 const char * 877 nvme_ctrl_errtostr(nvme_ctrl_t *ctrl, nvme_err_t err) 878 { 879 return (nvme_errtostr(ctrl->nc_nvme, err)); 880 } 881 882 static void 883 nvme_error_common(nvme_err_data_t *ep, nvme_err_t err, int32_t sys, 884 const char *fmt, va_list ap) 885 { 886 int ret; 887 888 ep->ne_err = err; 889 ep->ne_syserr = sys; 890 ep->ne_ctrl_sct = 0; 891 ep->ne_ctrl_sc = 0; 892 ret = vsnprintf(ep->ne_errmsg, 893 sizeof (ep->ne_errmsg), fmt, ap); 894 if (ret >= sizeof (ep->ne_errmsg)) { 895 ep->ne_errlen = sizeof (ep->ne_errmsg) - 1; 896 } else if (ret <= 0) { 897 ep->ne_errlen = 0; 898 ep->ne_errmsg[0] = '\0'; 899 } else { 900 ep->ne_errlen = (size_t)ret; 901 } 902 } 903 904 bool 905 nvme_error(nvme_t *nvme, nvme_err_t err, int32_t sys, const char *fmt, ...) 906 { 907 va_list ap; 908 909 va_start(ap, fmt); 910 nvme_error_common(&nvme->nh_err, err, sys, fmt, ap); 911 va_end(ap); 912 913 return (false); 914 } 915 916 bool 917 nvme_ctrl_error(nvme_ctrl_t *ctrl, nvme_err_t err, int32_t sys, 918 const char *fmt, ...) 919 { 920 va_list ap; 921 922 va_start(ap, fmt); 923 nvme_error_common(&ctrl->nc_err, err, sys, fmt, ap); 924 va_end(ap); 925 926 return (false); 927 } 928 929 static bool 930 nvme_success_common(nvme_err_data_t *err) 931 { 932 err->ne_err = NVME_ERR_OK; 933 err->ne_syserr = 0; 934 err->ne_ctrl_sct = 0; 935 err->ne_ctrl_sc = 0; 936 err->ne_errmsg[0] = '\0'; 937 err->ne_errlen = 0; 938 939 return (true); 940 } 941 942 bool 943 nvme_success(nvme_t *nvme) 944 { 945 return (nvme_success_common(&nvme->nh_err)); 946 } 947 948 bool 949 nvme_ctrl_success(nvme_ctrl_t *ctrl) 950 { 951 return (nvme_success_common(&ctrl->nc_err)); 952 } 953 954 void 955 nvme_err_save(const nvme_t *nvme, nvme_err_data_t *out) 956 { 957 *out = nvme->nh_err; 958 } 959 960 void 961 nvme_err_set(nvme_t *nvme, const nvme_err_data_t *err) 962 { 963 nvme->nh_err = *err; 964 } 965 966 void 967 nvme_ctrl_err_save(const nvme_ctrl_t *ctrl, nvme_err_data_t *out) 968 { 969 *out = ctrl->nc_err; 970 } 971 972 void 973 nvme_ctrl_err_set(nvme_ctrl_t *ctrl, const nvme_err_data_t *err) 974 { 975 ctrl->nc_err = *err; 976 } 977 978 /* 979 * This table deals with mapping a kernel error to a library error and provides 980 * a short description of what it is. Note, we do not expect all kernel errors 981 * to occur and we may want to revisit which of these end up indicating a 982 * programmer error that we caused somehow. 983 */ 984 typedef struct { 985 nvme_ioctl_errno_t kl_kern; 986 nvme_err_t kl_lib; 987 const char *kl_desc; 988 } nvme_ktolmap_t; 989 990 /* 991 * Please keep this table ordered based on the nvme_ioctl_error_t enumeration 992 * order. This is not required for correctness, but helps when scanning for 993 * missing entries. Please document why certain entries are skipped. 994 */ 995 static const nvme_ktolmap_t nvme_ktolmap[] = { 996 /* 997 * NVME_IOCTL_E_OK and NVME_IOCTL_E_CTRL_ERROR should already have been 998 * dealt with and shouldn't be included here. 999 */ 1000 { NVME_IOCTL_E_CTRL_DEAD, NVME_ERR_CTRL_DEAD, "the controller is no " 1001 "longer usable by the system" }, 1002 { NVME_IOCTL_E_CTRL_GONE, NVME_ERR_CTRL_GONE, "the controller has been " 1003 "physically removed from the system" }, 1004 { NVME_IOCTL_E_NS_RANGE, NVME_ERR_NS_RANGE, "invalid namespace " 1005 "requested" }, 1006 { NVME_IOCTL_E_NS_UNUSE, NVME_ERR_NS_UNUSE, "a namespace ID may not be " 1007 "specified in this context" }, 1008 /* 1009 * We have purposefully skipped NVME_IOCTL_E_MINOR_WRONG_NS and 1010 * NVME_IOCTL_E_NOT_CTRL as the library should not ever use the 1011 * namespace minor. 1012 */ 1013 { NVME_IOCTL_E_NO_BCAST_NS, NVME_ERR_NS_RANGE, "the broadcast " 1014 "namespace may not be used in this context" }, 1015 { NVME_IOCTL_E_NEED_CTRL_WRLOCK, NVME_ERR_NEED_CTRL_WRLOCK, "operation " 1016 "requires a controller write lock, but it is not owned" }, 1017 { NVME_IOCTL_E_NEED_NS_WRLOCK, NVME_ERR_NEED_NS_WRLOCK, "operation " 1018 "requires a namespace write lock, but it is not owned" }, 1019 { NVME_IOCTL_E_CTRL_LOCKED, NVME_ERR_CTRL_LOCKED, "controller locked" }, 1020 { NVME_IOCTL_E_NS_LOCKED, NVME_ERR_NS_LOCKED, "namespace locked" }, 1021 /* 1022 * We have purposefully skipped NVME_IOCTL_E_UNKNOWN_LOG_PAGE as in 1023 * theory the library and kernel should be in sync with the set of known 1024 * log pages. If it is out of sync due to someone distributing the two 1025 * weirdly or a bad build, we'd rather that end up as an internal error 1026 * rather than a first class error for users. 1027 */ 1028 { NVME_IOCTL_E_UNSUP_LOG_PAGE, NVME_ERR_LOG_UNSUP_BY_DEV, "controller " 1029 "does not support the specified log page" }, 1030 { NVME_IOCTL_E_BAD_LOG_SCOPE, NVME_ERR_LOG_SCOPE_MISMATCH, "log page " 1031 "does not work with the requested scope" }, 1032 { NVME_IOCTL_E_LOG_CSI_RANGE, NVME_ERR_LOG_CSI_RANGE, "invalid command " 1033 "set interface value" }, 1034 { NVME_IOCTL_E_LOG_LID_RANGE, NVME_ERR_LOG_LID_RANGE, "invalid log " 1035 "identifier value" }, 1036 { NVME_IOCTL_E_LOG_LSP_RANGE, NVME_ERR_LOG_LSP_RANGE, "invalid log " 1037 "specific parameter value" }, 1038 { NVME_IOCTL_E_LOG_LSI_RANGE, NVME_ERR_LOG_LSI_RANGE, "invalid log " 1039 "specific identifier value" }, 1040 { NVME_IOCTL_E_LOG_RAE_RANGE, NVME_ERR_LOG_SIZE_RANGE, "invalid retain " 1041 "asynchronous event value" }, 1042 { NVME_IOCTL_E_LOG_SIZE_RANGE, NVME_ERR_LOG_SIZE_RANGE, "invalid log " 1043 "length value" }, 1044 { NVME_IOCTL_E_LOG_OFFSET_RANGE, NVME_ERR_LOG_OFFSET_RANGE, "invalid " 1045 "log offset value" }, 1046 { NVME_IOCTL_E_LOG_CSI_UNSUP, NVME_ERR_LOG_CSI_UNSUP, 1047 "the controller does not support specifying the csi" }, 1048 { NVME_IOCTL_E_LOG_LSP_UNSUP, NVME_ERR_LOG_LSP_UNSUP, 1049 "the controller does not support specifying the lsp" }, 1050 { NVME_IOCTL_E_LOG_LSI_UNSUP, NVME_ERR_LOG_LSI_UNSUP, 1051 "the controller does not support specifying the lsi" }, 1052 { NVME_IOCTL_E_LOG_RAE_UNSUP, NVME_ERR_LOG_RAE_UNSUP, 1053 "the controller does not support retaining an asynchronous event" }, 1054 { NVME_IOCTL_E_LOG_OFFSET_UNSUP, NVME_ERR_LOG_OFFSET_UNSUP, 1055 "the controller do not support specifying a a read offset" }, 1056 { NVME_IOCTL_E_LOG_LSP_UNUSE, NVME_ERR_LOG_LSP_UNUSE, "the log page " 1057 "does not allow the lsp to be used" }, 1058 { NVME_IOCTL_E_LOG_LSI_UNUSE, NVME_ERR_LOG_LSI_UNUSE, "the log page " 1059 "does not allow the lsi to be used" }, 1060 { NVME_IOCTL_E_LOG_RAE_UNUSE, NVME_ERR_LOG_RAE_UNUSE, "the log page " 1061 "does not allow rae to be set" }, 1062 { NVME_IOCTL_E_NO_DMA_MEM, NVME_ERR_NO_DMA_MEM, "the kernel failed to " 1063 "allocate sufficient DMA resources" }, 1064 { NVME_IOCTL_E_NO_KERN_MEM, NVME_ERR_NO_KERN_MEM, "the kernel failed " 1065 "to allocate sufficient memory for this operation" }, 1066 { NVME_IOCTL_E_BAD_PRP, NVME_ERR_INTERNAL, "a driver error occurred " 1067 "while filling out the command's DMA resources" }, 1068 { NVME_IOCTL_E_BAD_USER_DATA, NVME_ERR_BAD_PTR, "the kernel " 1069 "detected an invalid user buffer while trying to read/write the " 1070 "passed in data buffer" }, 1071 { NVME_IOCTL_E_UNKNOWN_IDENTIFY, NVME_ERR_IDENTIFY_UNKNOWN, "unknown " 1072 "identify command requested" }, 1073 { NVME_IOCTL_E_UNSUP_IDENTIFY, NVME_ERR_IDENTIFY_UNSUP_BY_DEV, 1074 "controller does not support the requested identify command" }, 1075 { NVME_IOCTL_E_IDENTIFY_CTRLID_RANGE, NVME_ERR_IDENTIFY_CTRLID_RANGE, 1076 "invalid controller id value" }, 1077 { NVME_IOCTL_E_IDENTIFY_CTRLID_UNSUP, NVME_ERR_IDENTIFY_CTRLID_UNSUP, 1078 "the controller does not support specifying the controller ID" }, 1079 { NVME_IOCTL_E_IDENTIFY_CTRLID_UNUSE, NVME_ERR_IDENTIFY_CTRLID_UNUSE, 1080 "this specific identify request does not allow setting the " 1081 "controller id" }, 1082 { NVME_IOCTL_E_CTRL_VUC_UNSUP, NVME_ERR_VUC_UNSUP_BY_DEV, 1083 "the controller does not support standard NVMe vendor unique " 1084 "commands" }, 1085 /* 1086 * The following indicate bad values for given NVMe vendor unique 1087 * command fields. Note, we do not include an entry for 1088 * NVME_IOCTL_E_VUC_FLAGS_RANGE because these flags are entirely owned 1089 * by the library. 1090 */ 1091 { NVME_IOCTL_E_VUC_TIMEOUT_RANGE, NVME_ERR_VUC_TIMEOUT_RANGE, "invalid " 1092 "command timeout value" }, 1093 { NVME_IOCTL_E_VUC_OPCODE_RANGE, NVME_ERR_VUC_OPCODE_RANGE, "invalid " 1094 "vendor unique opcode specified" }, 1095 { NVME_IOCTL_E_VUC_IMPACT_RANGE, NVME_ERR_VUC_IMPACT_RANGE, "invalid " 1096 "vendor unique impact specified" }, 1097 { NVME_IOCTL_E_VUC_NDT_RANGE, NVME_ERR_VUC_NDT_RANGE, "invalid " 1098 "data transfer size specified" }, 1099 /* 1100 * We skip NVME_IOCTL_E_INCONSIST_VUC_FLAGS_NDT and 1101 * NVME_IOCTL_E_INCONSIST_VUC_BUF_NDT because these are solely under the 1102 * library control and would indicate a programming error at our end. 1103 * The user shouldn't be able to cause this. 1104 */ 1105 { NVME_IOCTL_E_BLKDEV_DETACH, NVME_ERR_DETACH_KERN, "the kernel failed " 1106 "to detach the requested namespace" }, 1107 { NVME_IOCTL_E_BLKDEV_ATTACH, NVME_ERR_ATTACH_KERN, "the kernel failed " 1108 "to attach the requested namespace" }, 1109 { NVME_IOCTL_E_UNSUP_ATTACH_NS, NVME_ERR_ATTACH_UNSUP_KERN, 1110 "the namespace is not supported by the kernel" }, 1111 { NVME_IOCTL_E_CTRL_FORMAT_UNSUP, NVME_ERR_FORMAT_UNSUP_BY_DEV, "the " 1112 "controller does not support formatting namespaces" }, 1113 { NVME_IOCTL_E_CTRL_CRYPTO_SE_UNSUP, NVME_ERR_CRYPTO_SE_UNSUP_BY_DEV, 1114 "the controller does not support cryptographic secure erase" }, 1115 { NVME_IOCTL_E_CTRL_NS_FORMAT_UNSUP, NVME_ERR_NS_FORMAT_UNSUP_BY_DEV, 1116 "the controller cannot format a single namespace" }, 1117 { NVME_IOCTL_E_CTRL_NS_SE_UNSUP, NVME_ERR_NS_FORMAT_UNSUP_BY_DEV, 1118 "the controller cannot secure erase a single namespace" }, 1119 { NVME_IOCTL_E_FORMAT_LBAF_RANGE, NVME_ERR_FORMAT_LBAF_RANGE, 1120 "invalid LBA format value" }, 1121 { NVME_IOCTL_E_FORMAT_SES_RANGE, NVME_ERR_FORMAT_SES_RANGE, 1122 "invalid secure erase settings value" }, 1123 { NVME_IOCTL_E_UNSUP_LBAF_META, NVME_ERR_KERN_FORMAT_UNSUP, "cannot " 1124 "format due to the use of unsupported metadata sectors" }, 1125 { NVME_IOCTL_E_CTRL_FW_UNSUP, NVME_ERR_FW_UNSUP_BY_DEV, "the " 1126 "controller does not support firmware commands" }, 1127 { NVME_IOCTL_E_FW_LOAD_IMPOS_GRAN, NVME_ERR_KERN_FW_IMPOS, "controller " 1128 "reported firmware upgrade granularity does not work with the " 1129 "calculated maximum DMA transfer size" }, 1130 { NVME_IOCTL_E_FW_LOAD_LEN_RANGE, NVME_ERR_FW_LOAD_LEN_RANGE, 1131 "invalid firmware load length value" }, 1132 { NVME_IOCTL_E_FW_LOAD_OFFSET_RANGE, NVME_ERR_FW_LOAD_OFFSET_RANGE, 1133 "invalid firmware load offset value" }, 1134 { NVME_IOCTL_E_FW_COMMIT_SLOT_RANGE, NVME_ERR_FW_COMMIT_SLOT_RANGE, 1135 "invalid firmware commit slot value" }, 1136 { NVME_IOCTL_E_FW_COMMIT_ACTION_RANGE, NVME_ERR_FW_COMMIT_ACTION_RANGE, 1137 "invalid firmware commit action value" }, 1138 { NVME_IOCTL_E_RO_FW_SLOT, NVME_ERR_FW_SLOT_RO, "cannot write to read-" 1139 "only slot" }, 1140 /* 1141 * We have purposefully skipped NVME_IOCTL_E_UNKNOWN_FEATURE for the 1142 * same reasons we did with NVME_IOCTL_E_UNKNOWN_LOG above. 1143 */ 1144 { NVME_IOCTL_E_UNSUP_FEATURE, NVME_ERR_FEAT_UNSUP_BY_DEV, "the " 1145 "controller does not supported the requested feature" }, 1146 { NVME_IOCTL_E_GET_FEAT_SEL_RANGE, NVME_ERR_FEAT_SEL_RANGE, "invalid " 1147 "feature selector value" }, 1148 { NVME_IOCTL_E_GET_FEAT_CDW11_RANGE, NVME_ERR_FEAT_CDW11_RANGE, 1149 "invalid feature-specific cdw11 value" }, 1150 { NVME_IOCTL_E_GET_FEAT_DATA_RANGE, NVME_ERR_FEAT_DATA_RANGE, "invalid " 1151 "feature data, likely a size mismatch" }, 1152 { NVME_IOCTL_E_GET_FEAT_SEL_UNSUP, NVME_ERR_FEAT_SEL_UNSUP, "the " 1153 "controller does not support specifying a feature selector" }, 1154 { NVME_IOCTL_E_GET_FEAT_CDW11_UNUSE, NVME_ERR_FEAT_CDW11_UNUSE, 1155 "the feature does not support specifying a cdw11 argument" }, 1156 { NVME_IOCTL_E_GET_FEAT_DATA_UNUSE, NVME_ERR_FEAT_DATA_UNUSE, 1157 "the feature does not support specifying a data buffer" }, 1158 /* 1159 * We skip the NVME_IOCTL_E_BAD_LOCK_ENTITY, 1160 * NVME_IOCTL_E_BAD_LOCK_LEVEL, and NVME_IOCTL_E_BAD_LOCK_FLAGS 1161 * arguments as these are all generally passed by the library and not 1162 * really under direct user control. Therefore if there is a problem, 1163 * that should be an internal error. 1164 * 1165 * Similarly we skip NVME_IOCTL_E_NS_CANNOT_LOCK_CTRL and 1166 * NVME_IOCTL_E_NS_CANNOT_UNLOCK_CTRL because the library does not 1167 * utilize namespace minors and these can only apply to those. 1168 */ 1169 { NVME_IOCTL_E_LOCK_ALREADY_HELD, NVME_ERR_LOCK_PROG, "fatal " 1170 "programmer error: recursive lock attempt" }, 1171 { NVME_IOCTL_E_LOCK_NO_CTRL_WITH_NS, NVME_ERR_LOCK_ORDER, 1172 "control locks cannot be acquired while holding a namespace lock" }, 1173 { NVME_IOCTL_LOCK_NO_NS_WITH_CTRL_WRLOCK, NVME_ERR_LOCK_ORDER, 1174 "no namespace locks may be acquired while holding a controller " 1175 "write lock" }, 1176 { NVME_IOCTL_E_LOCK_NO_2ND_NS, NVME_ERR_LOCK_ORDER, "only a single " 1177 "namespace lock can be held at any time" }, 1178 { NVME_IOCTL_E_LOCK_WAIT_SIGNAL, NVME_ERR_LOCK_WAIT_INTR, "signal " 1179 "received while blocking" }, 1180 { NVME_IOCTL_E_LOCK_WOULD_BLOCK, NVME_ERR_LOCK_WOULD_BLOCK, "lock not " 1181 "available and no blocking allowed" }, 1182 { NVME_IOCTL_E_LOCK_PENDING, NVME_ERR_LOCK_ORDER, "a handle may only " 1183 "block on one lock at a time" }, 1184 { NVME_IOCTL_E_LOCK_NOT_HELD, NVME_ERR_LOCK_PROG, "fatal " 1185 "programmer error: asked to unlock lock that was not held" }, 1186 /* 1187 * This error is almost a can't happen due to the library construction 1188 * and should result in the above error, but if this does happen, we 1189 * treat this as a fatal lock error regardless. 1190 */ 1191 { NVME_IOCTL_E_LOCK_WRONG_NS, NVME_ERR_LOCK_PROG, "fatal " 1192 "programmer error: asked to unlock namespace lock that was not " 1193 "held" }, 1194 { NVME_IOCTL_E_NS_BLKDEV_ATTACH, NVME_ERR_NS_BLKDEV_ATTACH, "cannot " 1195 "execute request while blkdev is attached to the namespace" }, 1196 /* 1197 * We purposefully skip NVME_IOCTL_E_BD_ADDR_OVER right now because 1198 * there is nothing that a user can do about this. This is a 1199 * libnvme/kernel interface issue. 1200 */ 1201 { NVME_IOCTL_E_CTRL_NS_MGMT_UNSUP, NVME_ERR_NS_MGMT_UNSUP_BY_DEV, 1202 "controller does not support namespace management" }, 1203 { NVME_IOCTL_E_NS_CTRL_ATTACHED, NVME_ERR_NS_CTRL_ATTACHED, 1204 "cannot execute request against an attached namespace" }, 1205 { NVME_IOCTL_E_NS_CTRL_NOT_ATTACHED, NVME_ERR_NS_CTRL_NOT_ATTACHED, 1206 "cannot execute request against an unattached namespace" }, 1207 { NVME_IOCTL_E_NS_NO_NS, NVME_ERR_NS_UNALLOC, "cannot execute request " 1208 "against an unallocated namespace" }, 1209 { NVME_IOCTL_E_NS_CREATE_NSZE_RANGE, NVME_ERR_NS_CREATE_NSZE_RANGE, 1210 "invalid namespace create size specified" }, 1211 { NVME_IOCTL_E_NS_CREATE_NCAP_RANGE, NVME_ERR_NS_CREATE_NCAP_RANGE, 1212 "invalid namespace create capacity specified" }, 1213 /* 1214 * Right now the library only has a single error for an invalid CSI on 1215 * namespace create regardless of the reason. 1216 */ 1217 { NVME_IOCTL_E_NS_CREATE_CSI_RANGE, NVME_ERR_NS_CREATE_BAD_CSI, 1218 "invalid namespace create command set identifier specified" }, 1219 { NVME_IOCTL_E_NS_CREATE_FLBAS_RANGE, NVME_ERR_NS_CREATE_FLBAS_RANGE, 1220 "invalid namespace create LBA format specified" }, 1221 { NVME_IOCTL_E_NS_CREATE_NMIC_RANGE, NVME_ERR_NS_CREATE_NMIC_RANGE, 1222 "invalid namespace multi-path and sharing capability specified" }, 1223 { NVME_IOCTL_E_NS_CREATE_CSI_UNSUP, NVME_ERR_NS_CREATE_BAD_CSI, "the " 1224 "controller does not support specifying a CSI when creating " 1225 "namespaces" }, 1226 { NVME_IOCTL_E_DRV_CSI_UNSUP, NVME_ERR_NS_CREATE_BAD_CSI, "the nvme " 1227 "driver does not supporting CSIs with that value" }, 1228 { NVME_IOCTL_E_CTRL_THIN_PROV_UNSUP, NVME_ERR_THIN_PROV_UNSUP_BY_DEV, 1229 "controller does not support thin provisioning of namespaces" }, 1230 { NVME_IOCTL_E_SET_FEAT_USER_UNSUP, NVME_ERR_SET_FEAT_USER_UNSUP, 1231 "feature is not settable from userland" }, 1232 { NVME_IOCTL_E_SET_FEAT_SAVE_RANGE, NVME_ERR_FEAT_SAVE_RANGE, 1233 "invalid set feature save value" }, 1234 { NVME_IOCTL_E_SET_FEAT_CDW11_RANGE, NVME_ERR_FEAT_CDW11_RANGE, 1235 "invalid feature-specific cdw11 value" }, 1236 { NVME_IOCTL_E_SET_FEAT_CDW12_RANGE, NVME_ERR_FEAT_CDW12_RANGE, 1237 "invalid feature-specific cdw12 value" }, 1238 { NVME_IOCTL_E_SET_FEAT_CDW13_RANGE, NVME_ERR_FEAT_CDW13_RANGE, 1239 "invalid feature-specific cdw13 value" }, 1240 { NVME_IOCTL_E_SET_FEAT_CDW15_RANGE, NVME_ERR_FEAT_CDW15_RANGE, 1241 "invalid feature-specific cdw15 value" }, 1242 { NVME_IOCTL_E_SET_FEAT_DATA_RANGE, NVME_ERR_FEAT_DATA_RANGE, 1243 "invalid set feature data and buffer request" }, 1244 { NVME_IOCTL_E_SET_FEAT_IMPACT_RANGE, NVME_ERR_FEAT_IMPACT_RANGE, 1245 "invalid set feature impact value" }, 1246 { NVME_IOCTL_E_SET_FEAT_SAVE_UNSUP, NVME_ERR_FEAT_SAVE_UNSUP, 1247 "the controller does not support setting the save field" }, 1248 { NVME_IOCTL_E_SET_FEAT_CDW12_UNSUP, NVME_ERR_FEAT_CDW12_UNSUP, 1249 "the controller does not support setting cdw12" }, 1250 { NVME_IOCTL_E_SET_FEAT_CDW13_UNSUP, NVME_ERR_FEAT_CDW13_UNSUP, 1251 "the controller does not support setting cdw13" }, 1252 { NVME_IOCTL_E_SET_FEAT_CDW15_UNSUP, NVME_ERR_FEAT_CDW15_UNSUP, 1253 "the controller does not support setting cdw15" }, 1254 { NVME_IOCTL_E_SET_FEAT_CDW11_UNUSE, NVME_ERR_FEAT_CDW11_UNUSE, 1255 "the set feature does not allow cdw11 to be used" }, 1256 { NVME_IOCTL_E_SET_FEAT_CDW12_UNUSE, NVME_ERR_FEAT_CDW12_UNUSE, 1257 "the set feature does not allow cdw12 to be used" }, 1258 { NVME_IOCTL_E_SET_FEAT_CDW13_UNUSE, NVME_ERR_FEAT_CDW13_UNUSE, 1259 "the set feature does not allow cdw13 to be used" }, 1260 { NVME_IOCTL_E_SET_FEAT_CDW15_UNUSE, NVME_ERR_FEAT_CDW15_UNUSE, 1261 "the set feature does not allow cdw15 to be used" }, 1262 { NVME_IOCTL_E_SET_FEAT_DATA_UNUSE, NVME_ERR_FEAT_DATA_UNUSE, 1263 "the set feature does not allow data to be used" }, 1264 1265 }; 1266 1267 /* 1268 * Translate a kernel ioctl error into the library's error. We handle the 1269 * controller error separately. Otherwise, everything else is done based upon 1270 * our translation table. 1271 */ 1272 bool 1273 nvme_ioctl_error(nvme_ctrl_t *ctrl, const nvme_ioctl_common_t *ioc, 1274 const char *desc) 1275 { 1276 int ret; 1277 nvme_err_data_t *err = &ctrl->nc_err; 1278 VERIFY3U(ioc->nioc_drv_err, !=, NVME_IOCTL_E_OK); 1279 1280 err->ne_syserr = 0; 1281 err->ne_ctrl_sct = 0; 1282 err->ne_ctrl_sc = 0; 1283 1284 if (ioc->nioc_drv_err == NVME_IOCTL_E_CTRL_ERROR) { 1285 const char *sct, *sc; 1286 err->ne_err = NVME_ERR_CONTROLLER; 1287 err->ne_ctrl_sct = ioc->nioc_ctrl_sct; 1288 err->ne_ctrl_sc = ioc->nioc_ctrl_sc; 1289 sct = nvme_scttostr(ctrl, ioc->nioc_ctrl_sct); 1290 sc = nvme_sctostr(ctrl, NVME_CSI_NVM, ioc->nioc_ctrl_sct, 1291 ioc->nioc_ctrl_sc); 1292 ret = snprintf(err->ne_errmsg, sizeof (err->ne_errmsg), 1293 "failed to execute %s command: received controller error " 1294 "sct/sc %s/%s (0x%x/0x%x)", desc, sct, sc, 1295 ioc->nioc_ctrl_sct, ioc->nioc_ctrl_sc); 1296 } else { 1297 const nvme_ktolmap_t *map = NULL; 1298 for (size_t i = 0; i < ARRAY_SIZE(nvme_ktolmap); i++) { 1299 if (nvme_ktolmap[i].kl_kern == ioc->nioc_drv_err) { 1300 map = &nvme_ktolmap[i]; 1301 break; 1302 } 1303 } 1304 1305 if (map != NULL) { 1306 err->ne_err = map->kl_lib; 1307 ret = snprintf(err->ne_errmsg, sizeof (err->ne_errmsg), 1308 "failed to execute %s command: %s", desc, 1309 map->kl_desc); 1310 } else { 1311 err->ne_err = NVME_ERR_INTERNAL; 1312 ret = snprintf(err->ne_errmsg, sizeof (err->ne_errmsg), 1313 "failed to execute %s command: failed to map " 1314 "kernel error 0x%x to a known cause", desc, 1315 ioc->nioc_drv_err); 1316 } 1317 } 1318 1319 if (ret >= sizeof (err->ne_errmsg)) { 1320 err->ne_errlen = sizeof (err->ne_errmsg) - 1; 1321 } else if (ret <= 0) { 1322 err->ne_errlen = 0; 1323 err->ne_errmsg[0] = '\0'; 1324 } else { 1325 err->ne_errlen = (size_t)ret; 1326 } 1327 1328 return (false); 1329 } 1330 1331 /* 1332 * Evaluate the set of ioctl errors that we see and translate and/or abort a few 1333 * of the expected values. Most things will end up being translated into a 1334 * generic internal error as we expect a rather tight error set at this point. 1335 * 1336 * We choose to panic on EFAULT because we are responsible for all such EFAULT 1337 * errors. These are structure that are coming from the library. This is not 1338 * something that the user could have passed us (their buffers will trigger 1339 * an explicit nvme_ioctl_errno_t). Therefore, something has gone very wrong 1340 * with our stack or we just corrupted some memory. 1341 * 1342 * The same is true with EBADF. In this case, that'd happen either because our 1343 * controller fd was bandit'd away by someone or somehow we lost FREAD or FWRITE 1344 * on the fd. That should not be possible assuming everyone is acting in good 1345 * faith, so we treat this as a sign that something quite bad has happened and 1346 * we shouldn't continue. 1347 */ 1348 bool 1349 nvme_ioctl_syserror(nvme_ctrl_t *ctrl, int err, const char *desc) 1350 { 1351 switch (err) { 1352 case EFAULT: 1353 case EBADF: { 1354 const char *base = "fatal libnvme internal programming error: " 1355 "failed to issue ioctl"; 1356 char msg[1024]; 1357 int ret; 1358 const char *up; 1359 size_t ulen; 1360 1361 ret = snprintf(msg, sizeof (msg), "%s %s: %s (controller %p)", 1362 base, desc, strerror(err), ctrl); 1363 if (ret >= sizeof (msg)) { 1364 ulen = sizeof (msg); 1365 up = msg; 1366 } else if (ret <= 0) { 1367 up = base; 1368 ulen = strlen(base) + 1; 1369 } else { 1370 ulen = (size_t)ret; 1371 up = msg; 1372 } 1373 1374 upanic(up, ulen); 1375 } 1376 case EPERM: 1377 return (nvme_ctrl_error(ctrl, NVME_ERR_PRIVS, err, 1378 "failed to issue %s ioctl due to missing privileges", 1379 desc)); 1380 default: 1381 return (nvme_ctrl_error(ctrl, NVME_ERR_INTERNAL, err, 1382 "failed to issue %s ioctl due to unexpected system " 1383 "error: %s", desc, strerror(err))); 1384 } 1385 } 1386 1387 /* 1388 * Generate the standard warning about which fields are unused. 1389 */ 1390 bool 1391 nvme_field_miss_err(nvme_ctrl_t *ctrl, const nvme_field_info_t *fields, 1392 size_t nfields, nvme_err_t err, const char *desc, uint32_t val) 1393 { 1394 char buf[512]; 1395 bool comma = false; 1396 1397 VERIFY3U(val, !=, 0); 1398 buf[0] = '\0'; 1399 for (size_t i = 0; i < nfields; i++) { 1400 if ((val & (1 << i)) == 0) { 1401 continue; 1402 } 1403 1404 if (comma) { 1405 (void) strlcat(buf, ",", sizeof (buf)); 1406 } 1407 (void) strlcat(buf, fields[i].nlfi_spec, sizeof (buf)); 1408 comma = true; 1409 } 1410 1411 return (nvme_ctrl_error(ctrl, err, 0, "cannot execute %s request due " 1412 "to missing fields: %s", desc, buf)); 1413 } 1414 1415 bool 1416 nvme_field_check_one(nvme_ctrl_t *ctrl, uint64_t val, const char *req, 1417 const nvme_field_check_t *check, uint32_t allow) 1418 { 1419 const nvme_field_info_t *field = &check->chk_fields[check->chk_index]; 1420 nvme_valid_ctrl_data_t data; 1421 nvme_field_error_t err; 1422 char msg[256]; 1423 1424 if (allow != 0 && (allow & (1 << check->chk_index)) == 0) { 1425 VERIFY3U(check->chk_field_unuse, !=, 0); 1426 return (nvme_ctrl_error(ctrl, check->chk_field_unuse, 0, 1427 "field %s (%s) cannot be set in this %s request", 1428 field->nlfi_human, field->nlfi_spec, req)); 1429 } 1430 1431 data.vcd_vers = &ctrl->nc_vers; 1432 data.vcd_id = &ctrl->nc_info; 1433 1434 err = nvme_field_validate(field, &data, val, msg, sizeof (msg)); 1435 switch (err) { 1436 case NVME_FIELD_ERR_OK: 1437 break; 1438 case NVME_FIELD_ERR_UNSUP_VERSION: 1439 case NVME_FIELD_ERR_UNSUP_FIELD: 1440 VERIFY3U(check->chk_field_unsup, !=, 0); 1441 return (nvme_ctrl_error(ctrl, check->chk_field_unsup, 0, "%s", 1442 msg)); 1443 case NVME_FIELD_ERR_BAD_VALUE: 1444 VERIFY3U(check->chk_field_range, !=, 0); 1445 return (nvme_ctrl_error(ctrl, check->chk_field_range, 0, "%s", 1446 msg)); 1447 } 1448 1449 return (true); 1450 } 1451 1452 bool 1453 nvme_field_valid_impact(nvme_ctrl_t *ctrl, nvme_disc_impact_t impact, 1454 nvme_err_t err) 1455 { 1456 const nvme_disc_impact_t all_impact = NVME_DISC_IMPACT_DATA | 1457 NVME_DISC_IMPACT_NS; 1458 1459 if ((impact & ~all_impact) != 0) { 1460 return (nvme_ctrl_error(ctrl, err, 0, "encountered unknown " 1461 "impact flags: 0x%x", impact & ~all_impact)); 1462 } 1463 1464 return (true); 1465 } 1466