1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2017 Netflix, Inc. 5 * Copyright (C) 2018-2019 Alexander Motin <mav@FreeBSD.org> 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer, 12 * without modification, immediately at the beginning of the file. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __FBSDID("$FreeBSD$"); 31 32 #include <sys/param.h> 33 #include <sys/ioccom.h> 34 35 #include <err.h> 36 #include <fcntl.h> 37 #include <stdbool.h> 38 #include <stddef.h> 39 #include <stdio.h> 40 #include <stdlib.h> 41 #include <string.h> 42 #include <sysexits.h> 43 #include <unistd.h> 44 45 #include "nvmecontrol.h" 46 47 /* Tables for command line parsing */ 48 49 static cmd_fn_t ns; 50 static cmd_fn_t nsactive; 51 static cmd_fn_t nsallocated; 52 static cmd_fn_t nscontrollers; 53 static cmd_fn_t nscreate; 54 static cmd_fn_t nsdelete; 55 static cmd_fn_t nsattach; 56 static cmd_fn_t nsdetach; 57 static cmd_fn_t nsattached; 58 static cmd_fn_t nsidentify; 59 60 #define NONE 0xffffffffu 61 #define NONE64 0xffffffffffffffffull 62 #define OPT(l, s, t, opt, addr, desc) { l, s, t, &opt.addr, desc } 63 #define OPT_END { NULL, 0, arg_none, NULL, NULL } 64 65 static struct cmd ns_cmd = { 66 .name = "ns", 67 .fn = ns, 68 .descr = "Namespace management commands", 69 .ctx_size = 0, 70 .opts = NULL, 71 .args = NULL, 72 }; 73 74 CMD_COMMAND(ns_cmd); 75 76 static struct active_options { 77 const char *dev; 78 } active_opt = { 79 .dev = NULL, 80 }; 81 82 static const struct args active_args[] = { 83 { arg_string, &active_opt.dev, "controller-id|namespace-id" }, 84 { arg_none, NULL, NULL }, 85 }; 86 87 static struct cmd active_cmd = { 88 .name = "active", 89 .fn = nsactive, 90 .descr = "List active (attached) namespaces", 91 .ctx_size = sizeof(active_opt), 92 .opts = NULL, 93 .args = active_args, 94 }; 95 96 CMD_SUBCOMMAND(ns_cmd, active_cmd); 97 98 static struct cmd allocated_cmd = { 99 .name = "allocated", 100 .fn = nsallocated, 101 .descr = "List allocated (created) namespaces", 102 .ctx_size = sizeof(active_opt), 103 .opts = NULL, 104 .args = active_args, 105 }; 106 107 CMD_SUBCOMMAND(ns_cmd, allocated_cmd); 108 109 static struct controllers_options { 110 const char *dev; 111 } controllers_opt = { 112 .dev = NULL, 113 }; 114 115 static const struct args controllers_args[] = { 116 { arg_string, &controllers_opt.dev, "controller-id|namespace-id" }, 117 { arg_none, NULL, NULL }, 118 }; 119 120 static struct cmd controllers_cmd = { 121 .name = "controllers", 122 .fn = nscontrollers, 123 .descr = "List all controllers in NVM subsystem", 124 .ctx_size = sizeof(controllers_opt), 125 .opts = NULL, 126 .args = controllers_args, 127 }; 128 129 CMD_SUBCOMMAND(ns_cmd, controllers_cmd); 130 131 static struct create_options { 132 uint64_t nsze; 133 uint64_t cap; 134 uint32_t lbaf; 135 uint32_t mset; 136 uint32_t nmic; 137 uint32_t pi; 138 uint32_t pil; 139 uint32_t flbas; 140 uint32_t dps; 141 // uint32_t block_size; 142 const char *dev; 143 } create_opt = { 144 .nsze = NONE64, 145 .cap = NONE64, 146 .lbaf = NONE, 147 .mset = NONE, 148 .nmic = NONE, 149 .pi = NONE, 150 .pil = NONE, 151 .flbas = NONE, 152 .dps = NONE, 153 .dev = NULL, 154 // .block_size = NONE, 155 }; 156 157 static const struct opts create_opts[] = { 158 OPT("nsze", 's', arg_uint64, create_opt, nsze, 159 "The namespace size"), 160 OPT("ncap", 'c', arg_uint64, create_opt, cap, 161 "The capacity of the namespace (<= ns size)"), 162 OPT("lbaf", 'f', arg_uint32, create_opt, lbaf, 163 "The FMT field of the FLBAS"), 164 OPT("mset", 'm', arg_uint32, create_opt, mset, 165 "The MSET field of the FLBAS"), 166 OPT("nmic", 'n', arg_uint32, create_opt, nmic, 167 "Namespace multipath and sharing capabilities"), 168 OPT("pi", 'p', arg_uint32, create_opt, pi, 169 "PI field of FLBAS"), 170 OPT("pil", 'l', arg_uint32, create_opt, pil, 171 "PIL field of FLBAS"), 172 OPT("flbas", 'L', arg_uint32, create_opt, flbas, 173 "Namespace formatted logical block size setting"), 174 OPT("dps", 'd', arg_uint32, create_opt, dps, 175 "Data protection settings"), 176 // OPT("block-size", 'b', arg_uint32, create_opt, block_size, 177 // "Blocksize of the namespace"), 178 OPT_END 179 }; 180 181 static const struct args create_args[] = { 182 { arg_string, &create_opt.dev, "controller-id|namespace-id" }, 183 { arg_none, NULL, NULL }, 184 }; 185 186 static struct cmd create_cmd = { 187 .name = "create", 188 .fn = nscreate, 189 .descr = "Create a namespace", 190 .ctx_size = sizeof(create_opt), 191 .opts = create_opts, 192 .args = create_args, 193 }; 194 195 CMD_SUBCOMMAND(ns_cmd, create_cmd); 196 197 static struct delete_options { 198 uint32_t nsid; 199 const char *dev; 200 } delete_opt = { 201 .nsid = NONE - 1, 202 .dev = NULL, 203 }; 204 205 static const struct opts delete_opts[] = { 206 OPT("namespace-id", 'n', arg_uint32, delete_opt, nsid, 207 "The namespace ID to delete"), 208 OPT_END 209 }; 210 211 static const struct args delete_args[] = { 212 { arg_string, &delete_opt.dev, "controller-id|namespace-id" }, 213 { arg_none, NULL, NULL }, 214 }; 215 216 static struct cmd delete_cmd = { 217 .name = "delete", 218 .fn = nsdelete, 219 .descr = "Delete a namespace", 220 .ctx_size = sizeof(delete_opt), 221 .opts = delete_opts, 222 .args = delete_args, 223 }; 224 225 CMD_SUBCOMMAND(ns_cmd, delete_cmd); 226 227 static struct attach_options { 228 uint32_t nsid; 229 uint32_t ctrlrid; 230 const char *dev; 231 } attach_opt = { 232 .nsid = NONE, 233 .ctrlrid = NONE - 1, 234 .dev = NULL, 235 }; 236 237 static const struct opts attach_opts[] = { 238 OPT("namespace-id", 'n', arg_uint32, attach_opt, nsid, 239 "The namespace ID to attach"), 240 OPT("controller", 'c', arg_uint32, attach_opt, ctrlrid, 241 "The controller ID to attach"), 242 OPT_END 243 }; 244 245 static const struct args attach_args[] = { 246 { arg_string, &attach_opt.dev, "controller-id|namespace-id" }, 247 { arg_none, NULL, NULL }, 248 }; 249 250 static struct cmd attach_cmd = { 251 .name = "attach", 252 .fn = nsattach, 253 .descr = "Attach a controller to a namespace", 254 .ctx_size = sizeof(attach_opt), 255 .opts = attach_opts, 256 .args = attach_args, 257 }; 258 259 CMD_SUBCOMMAND(ns_cmd, attach_cmd); 260 261 static struct attached_options { 262 uint32_t nsid; 263 const char *dev; 264 } attached_opt = { 265 .nsid = NONE, 266 .dev = NULL, 267 }; 268 269 static const struct opts attached_opts[] = { 270 OPT("namespace-id", 'n', arg_uint32, attached_opt, nsid, 271 "The namespace ID to request attached controllers"), 272 OPT_END 273 }; 274 275 static const struct args attached_args[] = { 276 { arg_string, &attached_opt.dev, "controller-id|namespace-id" }, 277 { arg_none, NULL, NULL }, 278 }; 279 280 static struct cmd attached_cmd = { 281 .name = "attached", 282 .fn = nsattached, 283 .descr = "List controllers attached to a namespace", 284 .ctx_size = sizeof(attached_opt), 285 .opts = attached_opts, 286 .args = attached_args, 287 }; 288 289 CMD_SUBCOMMAND(ns_cmd, attached_cmd); 290 291 static struct detach_options { 292 uint32_t nsid; 293 uint32_t ctrlrid; 294 const char *dev; 295 } detach_opt = { 296 .nsid = NONE, 297 .ctrlrid = NONE - 1, 298 .dev = NULL, 299 }; 300 301 static const struct opts detach_opts[] = { 302 OPT("namespace-id", 'n', arg_uint32, detach_opt, nsid, 303 "The namespace ID to detach"), 304 OPT("controller", 'c', arg_uint32, detach_opt, ctrlrid, 305 "The controller ID to detach"), 306 OPT_END 307 }; 308 309 static const struct args detach_args[] = { 310 { arg_string, &detach_opt.dev, "controller-id|namespace-id" }, 311 { arg_none, NULL, NULL }, 312 }; 313 314 static struct cmd detach_cmd = { 315 .name = "detach", 316 .fn = nsdetach, 317 .descr = "Detach a controller from a namespace", 318 .ctx_size = sizeof(detach_opt), 319 .opts = detach_opts, 320 .args = detach_args, 321 }; 322 323 CMD_SUBCOMMAND(ns_cmd, detach_cmd); 324 325 static struct identify_options { 326 bool hex; 327 bool verbose; 328 const char *dev; 329 uint32_t nsid; 330 } identify_opt = { 331 .hex = false, 332 .verbose = false, 333 .dev = NULL, 334 .nsid = NONE, 335 }; 336 337 static const struct opts identify_opts[] = { 338 OPT("hex", 'x', arg_none, identify_opt, hex, 339 "Print identiy information in hex"), 340 OPT("verbose", 'v', arg_none, identify_opt, verbose, 341 "More verbosity: print entire identify table"), 342 OPT("nsid", 'n', arg_uint32, identify_opt, nsid, 343 "The namespace ID to print IDENTIFY for"), 344 { NULL, 0, arg_none, NULL, NULL } 345 }; 346 347 static const struct args identify_args[] = { 348 { arg_string, &identify_opt.dev, "controller-id|namespace-id" }, 349 { arg_none, NULL, NULL }, 350 }; 351 352 static struct cmd identify_cmd = { 353 .name = "identify", 354 .fn = nsidentify, 355 .descr = "Print IDENTIFY for allocated namespace", 356 .ctx_size = sizeof(identify_opt), 357 .opts = identify_opts, 358 .args = identify_args, 359 }; 360 361 CMD_SUBCOMMAND(ns_cmd, identify_cmd); 362 363 /* handles NVME_OPC_NAMESPACE_MANAGEMENT and ATTACHMENT admin cmds */ 364 365 struct ns_result_str { 366 uint16_t res; 367 const char * str; 368 }; 369 370 static struct ns_result_str ns_result[] = { 371 { 0x2, "Invalid Field"}, 372 { 0xa, "Invalid Format"}, 373 { 0xb, "Invalid Namespace or format"}, 374 { 0x15, "Namespace insufficent capacity"}, 375 { 0x16, "Namespace ID unavaliable"}, 376 { 0x18, "Namespace already attached"}, 377 { 0x19, "Namespace is private"}, 378 { 0x1a, "Namespace is not attached"}, 379 { 0x1b, "Thin provisioning not supported"}, 380 { 0x1c, "Controller list invalid"}, 381 { 0x24, "ANA Group Identifier Invalid"}, 382 { 0x25, "ANA Attach Failed"}, 383 { 0xFFFF, "Unknown"} 384 }; 385 386 static const char * 387 get_res_str(uint16_t res) 388 { 389 struct ns_result_str *t = ns_result; 390 391 while (t->res != 0xFFFF) { 392 if (t->res == res) 393 return (t->str); 394 t++; 395 } 396 return t->str; 397 } 398 399 static void 400 nsactive(const struct cmd *f, int argc, char *argv[]) 401 { 402 struct nvme_pt_command pt; 403 struct nvme_controller_data cd; 404 int fd, i; 405 char *path; 406 uint32_t nsid; 407 uint32_t list[1024]; 408 409 if (arg_parse(argc, argv, f)) 410 return; 411 open_dev(active_opt.dev, &fd, 0, 1); 412 get_nsid(fd, &path, &nsid); 413 if (nsid != 0) { 414 close(fd); 415 open_dev(path, &fd, 0, 1); 416 } 417 free(path); 418 if (read_controller_data(fd, &cd)) 419 errx(EX_IOERR, "Identify request failed"); 420 421 /* Check that controller can execute this command. */ 422 if (((cd.oacs >> NVME_CTRLR_DATA_OACS_NSMGMT_SHIFT) & 423 NVME_CTRLR_DATA_OACS_NSMGMT_MASK) == 0) 424 errx(EX_UNAVAILABLE, "controller does not support namespace management"); 425 426 memset(&pt, 0, sizeof(pt)); 427 pt.cmd.opc = NVME_OPC_IDENTIFY; 428 pt.cmd.nsid = htole32(0); 429 pt.cmd.cdw10 = htole32(0x02); 430 pt.buf = list; 431 pt.len = sizeof(list); 432 pt.is_read = 1; 433 if (ioctl(fd, NVME_PASSTHROUGH_CMD, &pt) < 0) 434 err(EX_IOERR, "identify request failed"); 435 if (nvme_completion_is_error(&pt.cpl)) 436 errx(EX_IOERR, "identify request returned error"); 437 438 printf("Active namespaces:\n"); 439 for (i = 0; list[i] != 0; i++) 440 printf("%10d\n", le32toh(list[i])); 441 442 exit(0); 443 } 444 445 static void 446 nsallocated(const struct cmd *f, int argc, char *argv[]) 447 { 448 struct nvme_pt_command pt; 449 struct nvme_controller_data cd; 450 int fd, i; 451 char *path; 452 uint32_t nsid; 453 uint32_t list[1024]; 454 455 if (arg_parse(argc, argv, f)) 456 return; 457 open_dev(active_opt.dev, &fd, 0, 1); 458 get_nsid(fd, &path, &nsid); 459 if (nsid != 0) { 460 close(fd); 461 open_dev(path, &fd, 0, 1); 462 } 463 free(path); 464 if (read_controller_data(fd, &cd)) 465 errx(EX_IOERR, "Identify request failed"); 466 467 /* Check that controller can execute this command. */ 468 if (((cd.oacs >> NVME_CTRLR_DATA_OACS_NSMGMT_SHIFT) & 469 NVME_CTRLR_DATA_OACS_NSMGMT_MASK) == 0) 470 errx(EX_UNAVAILABLE, "controller does not support namespace management"); 471 472 memset(&pt, 0, sizeof(pt)); 473 pt.cmd.opc = NVME_OPC_IDENTIFY; 474 pt.cmd.nsid = htole32(0); 475 pt.cmd.cdw10 = htole32(0x10); 476 pt.buf = list; 477 pt.len = sizeof(list); 478 pt.is_read = 1; 479 if (ioctl(fd, NVME_PASSTHROUGH_CMD, &pt) < 0) 480 err(EX_IOERR, "identify request failed"); 481 if (nvme_completion_is_error(&pt.cpl)) 482 errx(EX_IOERR, "identify request returned error"); 483 484 printf("Allocated namespaces:\n"); 485 for (i = 0; list[i] != 0; i++) 486 printf("%10d\n", le32toh(list[i])); 487 488 exit(0); 489 } 490 491 static void 492 nscontrollers(const struct cmd *f, int argc, char *argv[]) 493 { 494 struct nvme_pt_command pt; 495 struct nvme_controller_data cd; 496 int fd, i, n; 497 char *path; 498 uint32_t nsid; 499 uint16_t clist[2048]; 500 501 if (arg_parse(argc, argv, f)) 502 return; 503 open_dev(controllers_opt.dev, &fd, 0, 1); 504 get_nsid(fd, &path, &nsid); 505 if (nsid != 0) { 506 close(fd); 507 open_dev(path, &fd, 0, 1); 508 } 509 free(path); 510 if (read_controller_data(fd, &cd)) 511 errx(EX_IOERR, "Identify request failed"); 512 513 /* Check that controller can execute this command. */ 514 if (((cd.oacs >> NVME_CTRLR_DATA_OACS_NSMGMT_SHIFT) & 515 NVME_CTRLR_DATA_OACS_NSMGMT_MASK) == 0) 516 errx(EX_UNAVAILABLE, "controller does not support namespace management"); 517 518 memset(&pt, 0, sizeof(pt)); 519 pt.cmd.opc = NVME_OPC_IDENTIFY; 520 pt.cmd.cdw10 = htole32(0x13); 521 pt.buf = clist; 522 pt.len = sizeof(clist); 523 pt.is_read = 1; 524 if (ioctl(fd, NVME_PASSTHROUGH_CMD, &pt) < 0) 525 err(EX_IOERR, "identify request failed"); 526 if (nvme_completion_is_error(&pt.cpl)) 527 errx(EX_IOERR, "identify request returned error"); 528 529 n = le16toh(clist[0]); 530 printf("NVM subsystem includes %d controller(s):\n", n); 531 for (i = 0; i < n; i++) 532 printf(" 0x%04x\n", le16toh(clist[i + 1])); 533 534 exit(0); 535 } 536 537 /* 538 * NS MGMT Command specific status values: 539 * 0xa = Invalid Format 540 * 0x15 = Namespace Insuffience capacity 541 * 0x16 = Namespace ID unavailable (number namespaces exceeded) 542 * 0xb = Thin Provisioning Not supported 543 */ 544 static void 545 nscreate(const struct cmd *f, int argc, char *argv[]) 546 { 547 struct nvme_pt_command pt; 548 struct nvme_controller_data cd; 549 struct nvme_namespace_data nsdata; 550 int fd, result; 551 char *path; 552 uint32_t nsid; 553 554 if (arg_parse(argc, argv, f)) 555 return; 556 557 if (create_opt.cap == NONE64) 558 create_opt.cap = create_opt.nsze; 559 if (create_opt.nsze == NONE64) { 560 fprintf(stderr, 561 "Size not specified\n"); 562 arg_help(argc, argv, f); 563 } 564 565 open_dev(create_opt.dev, &fd, 1, 1); 566 get_nsid(fd, &path, &nsid); 567 if (nsid != 0) { 568 close(fd); 569 open_dev(path, &fd, 1, 1); 570 } 571 free(path); 572 if (read_controller_data(fd, &cd)) 573 errx(EX_IOERR, "Identify request failed"); 574 575 /* Check that controller can execute this command. */ 576 if (((cd.oacs >> NVME_CTRLR_DATA_OACS_NSMGMT_SHIFT) & 577 NVME_CTRLR_DATA_OACS_NSMGMT_MASK) == 0) 578 errx(EX_UNAVAILABLE, "controller does not support namespace management"); 579 580 /* Allow namespaces sharing if Multi-Path I/O is supported. */ 581 if (create_opt.nmic == NONE) { 582 create_opt.nmic = cd.mic ? (NVME_NS_DATA_NMIC_MAY_BE_SHARED_MASK << 583 NVME_NS_DATA_NMIC_MAY_BE_SHARED_SHIFT) : 0; 584 } 585 586 memset(&nsdata, 0, sizeof(nsdata)); 587 nsdata.nsze = create_opt.nsze; 588 nsdata.ncap = create_opt.cap; 589 if (create_opt.flbas == NONE) 590 nsdata.flbas = ((create_opt.lbaf & NVME_NS_DATA_FLBAS_FORMAT_MASK) 591 << NVME_NS_DATA_FLBAS_FORMAT_SHIFT) | 592 ((create_opt.mset & NVME_NS_DATA_FLBAS_EXTENDED_MASK) 593 << NVME_NS_DATA_FLBAS_EXTENDED_SHIFT); 594 else 595 nsdata.flbas = create_opt.flbas; 596 if (create_opt.dps == NONE) 597 nsdata.dps = ((create_opt.pi & NVME_NS_DATA_DPS_MD_START_MASK) 598 << NVME_NS_DATA_DPS_MD_START_SHIFT) | 599 ((create_opt.pil & NVME_NS_DATA_DPS_PIT_MASK) 600 << NVME_NS_DATA_DPS_PIT_SHIFT); 601 else 602 nsdata.dps = create_opt.dps; 603 nsdata.nmic = create_opt.nmic; 604 nvme_namespace_data_swapbytes(&nsdata); 605 606 memset(&pt, 0, sizeof(pt)); 607 pt.cmd.opc = NVME_OPC_NAMESPACE_MANAGEMENT; 608 pt.cmd.cdw10 = htole32(0); /* create */ 609 pt.buf = &nsdata; 610 pt.len = sizeof(struct nvme_namespace_data); 611 pt.is_read = 0; /* passthrough writes data to ctrlr */ 612 if ((result = ioctl(fd, NVME_PASSTHROUGH_CMD, &pt)) < 0) 613 errx(EX_IOERR, "ioctl request to %s failed: %d", create_opt.dev, result); 614 615 if (nvme_completion_is_error(&pt.cpl)) { 616 errx(EX_IOERR, "namespace creation failed: %s", 617 get_res_str((pt.cpl.status >> NVME_STATUS_SC_SHIFT) & 618 NVME_STATUS_SC_MASK)); 619 } 620 printf("namespace %d created\n", pt.cpl.cdw0); 621 exit(0); 622 } 623 624 static void 625 nsdelete(const struct cmd *f, int argc, char *argv[]) 626 { 627 struct nvme_pt_command pt; 628 struct nvme_controller_data cd; 629 int fd, result; 630 char *path; 631 uint32_t nsid; 632 char buf[2]; 633 634 if (arg_parse(argc, argv, f)) 635 return; 636 637 open_dev(delete_opt.dev, &fd, 1, 1); 638 get_nsid(fd, &path, &nsid); 639 if (nsid != 0) { 640 close(fd); 641 open_dev(path, &fd, 1, 1); 642 } else if (delete_opt.nsid == NONE - 1) { 643 close(fd); 644 fprintf(stderr, "No NSID specified"); 645 arg_help(argc, argv, f); 646 } 647 if (delete_opt.nsid != NONE - 1) 648 nsid = delete_opt.nsid; 649 free(path); 650 if (read_controller_data(fd, &cd)) 651 errx(EX_IOERR, "Identify request failed"); 652 653 /* Check that controller can execute this command. */ 654 if (((cd.oacs >> NVME_CTRLR_DATA_OACS_NSMGMT_SHIFT) & 655 NVME_CTRLR_DATA_OACS_NSMGMT_MASK) == 0) 656 errx(EX_UNAVAILABLE, "controller does not support namespace management"); 657 658 memset(&pt, 0, sizeof(pt)); 659 pt.cmd.opc = NVME_OPC_NAMESPACE_MANAGEMENT; 660 pt.cmd.cdw10 = htole32(1); /* delete */ 661 pt.buf = buf; 662 pt.len = sizeof(buf); 663 pt.is_read = 1; 664 pt.cmd.nsid = nsid; 665 666 if ((result = ioctl(fd, NVME_PASSTHROUGH_CMD, &pt)) < 0) 667 errx(EX_IOERR, "ioctl request to %s failed: %d", delete_opt.dev, result); 668 669 if (nvme_completion_is_error(&pt.cpl)) { 670 errx(EX_IOERR, "namespace deletion failed: %s", 671 get_res_str((pt.cpl.status >> NVME_STATUS_SC_SHIFT) & 672 NVME_STATUS_SC_MASK)); 673 } 674 printf("namespace %d deleted\n", nsid); 675 exit(0); 676 } 677 678 /* 679 * Attach and Detach use Dword 10, and a controller list (section 4.9) 680 * This struct is 4096 bytes in size. 681 * 0h = attach 682 * 1h = detach 683 * 684 * Result values for both attach/detach: 685 * 686 * Completion 18h = Already attached 687 * 19h = NS is private and already attached to a controller 688 * 1Ah = Not attached, request could not be completed 689 * 1Ch = Controller list invalid. 690 * 691 * 0x2 Invalid Field can occur if ctrlrid d.n.e in system. 692 */ 693 static void 694 nsattach(const struct cmd *f, int argc, char *argv[]) 695 { 696 struct nvme_pt_command pt; 697 struct nvme_controller_data cd; 698 int fd, result; 699 char *path; 700 uint32_t nsid; 701 uint16_t clist[2048]; 702 703 if (arg_parse(argc, argv, f)) 704 return; 705 open_dev(attach_opt.dev, &fd, 1, 1); 706 get_nsid(fd, &path, &nsid); 707 if (nsid != 0) { 708 close(fd); 709 open_dev(path, &fd, 1, 1); 710 } else if (attach_opt.nsid == NONE) { 711 close(fd); 712 fprintf(stderr, "No NSID specified"); 713 arg_help(argc, argv, f); 714 } 715 if (attach_opt.nsid != NONE) 716 nsid = attach_opt.nsid; 717 if (read_controller_data(fd, &cd)) 718 errx(EX_IOERR, "Identify request failed"); 719 720 /* Check that controller can execute this command. */ 721 if (((cd.oacs >> NVME_CTRLR_DATA_OACS_NSMGMT_SHIFT) & 722 NVME_CTRLR_DATA_OACS_NSMGMT_MASK) == 0) 723 errx(EX_UNAVAILABLE, "controller does not support namespace management"); 724 725 if (attach_opt.ctrlrid == NONE) { 726 /* Get full list of controllers to attach to. */ 727 memset(&pt, 0, sizeof(pt)); 728 pt.cmd.opc = NVME_OPC_IDENTIFY; 729 pt.cmd.cdw10 = htole32(0x13); 730 pt.buf = clist; 731 pt.len = sizeof(clist); 732 pt.is_read = 1; 733 if (ioctl(fd, NVME_PASSTHROUGH_CMD, &pt) < 0) 734 err(EX_IOERR, "identify request failed"); 735 if (nvme_completion_is_error(&pt.cpl)) 736 errx(EX_IOERR, "identify request returned error"); 737 } else { 738 /* By default attach to this controller. */ 739 if (attach_opt.ctrlrid == NONE - 1) 740 attach_opt.ctrlrid = cd.ctrlr_id; 741 memset(&clist, 0, sizeof(clist)); 742 clist[0] = htole16(1); 743 clist[1] = htole16(attach_opt.ctrlrid); 744 } 745 746 memset(&pt, 0, sizeof(pt)); 747 pt.cmd.opc = NVME_OPC_NAMESPACE_ATTACHMENT; 748 pt.cmd.cdw10 = htole32(0); /* attach */ 749 pt.cmd.nsid = nsid; 750 pt.buf = &clist; 751 pt.len = sizeof(clist); 752 753 if ((result = ioctl(fd, NVME_PASSTHROUGH_CMD, &pt)) < 0) 754 errx(EX_IOERR, "ioctl request to %s failed: %d", attach_opt.dev, result); 755 756 if (nvme_completion_is_error(&pt.cpl)) { 757 errx(EX_IOERR, "namespace attach failed: %s", 758 get_res_str((pt.cpl.status >> NVME_STATUS_SC_SHIFT) & 759 NVME_STATUS_SC_MASK)); 760 } 761 printf("namespace %d attached\n", nsid); 762 exit(0); 763 } 764 765 static void 766 nsdetach(const struct cmd *f, int argc, char *argv[]) 767 { 768 struct nvme_pt_command pt; 769 struct nvme_controller_data cd; 770 int fd, result; 771 char *path; 772 uint32_t nsid; 773 uint16_t clist[2048]; 774 775 if (arg_parse(argc, argv, f)) 776 return; 777 open_dev(detach_opt.dev, &fd, 1, 1); 778 get_nsid(fd, &path, &nsid); 779 if (nsid != 0) { 780 close(fd); 781 open_dev(path, &fd, 1, 1); 782 } else if (detach_opt.nsid == NONE) { 783 close(fd); 784 fprintf(stderr, "No NSID specified"); 785 arg_help(argc, argv, f); 786 } 787 if (detach_opt.nsid != NONE) 788 nsid = detach_opt.nsid; 789 if (read_controller_data(fd, &cd)) 790 errx(EX_IOERR, "Identify request failed"); 791 792 /* Check that controller can execute this command. */ 793 if (((cd.oacs >> NVME_CTRLR_DATA_OACS_NSMGMT_SHIFT) & 794 NVME_CTRLR_DATA_OACS_NSMGMT_MASK) == 0) 795 errx(EX_UNAVAILABLE, "controller does not support namespace management"); 796 797 if (detach_opt.ctrlrid == NONE) { 798 /* Get list of controllers this namespace attached to. */ 799 memset(&pt, 0, sizeof(pt)); 800 pt.cmd.opc = NVME_OPC_IDENTIFY; 801 pt.cmd.nsid = htole32(nsid); 802 pt.cmd.cdw10 = htole32(0x12); 803 pt.buf = clist; 804 pt.len = sizeof(clist); 805 pt.is_read = 1; 806 if (ioctl(fd, NVME_PASSTHROUGH_CMD, &pt) < 0) 807 err(EX_IOERR, "identify request failed"); 808 if (nvme_completion_is_error(&pt.cpl)) 809 errx(EX_IOERR, "identify request returned error"); 810 if (clist[0] == 0) { 811 detach_opt.ctrlrid = cd.ctrlr_id; 812 memset(&clist, 0, sizeof(clist)); 813 clist[0] = htole16(1); 814 clist[1] = htole16(detach_opt.ctrlrid); 815 } 816 } else { 817 /* By default detach from this controller. */ 818 if (detach_opt.ctrlrid == NONE - 1) 819 detach_opt.ctrlrid = cd.ctrlr_id; 820 memset(&clist, 0, sizeof(clist)); 821 clist[0] = htole16(1); 822 clist[1] = htole16(detach_opt.ctrlrid); 823 } 824 825 memset(&pt, 0, sizeof(pt)); 826 pt.cmd.opc = NVME_OPC_NAMESPACE_ATTACHMENT; 827 pt.cmd.cdw10 = htole32(1); /* detach */ 828 pt.cmd.nsid = nsid; 829 pt.buf = &clist; 830 pt.len = sizeof(clist); 831 832 if ((result = ioctl(fd, NVME_PASSTHROUGH_CMD, &pt)) < 0) 833 errx(EX_IOERR, "ioctl request to %s failed: %d", detach_opt.dev, result); 834 835 if (nvme_completion_is_error(&pt.cpl)) { 836 errx(EX_IOERR, "namespace detach failed: %s", 837 get_res_str((pt.cpl.status >> NVME_STATUS_SC_SHIFT) & 838 NVME_STATUS_SC_MASK)); 839 } 840 printf("namespace %d detached\n", nsid); 841 exit(0); 842 } 843 844 static void 845 nsattached(const struct cmd *f, int argc, char *argv[]) 846 { 847 struct nvme_pt_command pt; 848 struct nvme_controller_data cd; 849 int fd, i, n; 850 char *path; 851 uint32_t nsid; 852 uint16_t clist[2048]; 853 854 if (arg_parse(argc, argv, f)) 855 return; 856 open_dev(attached_opt.dev, &fd, 0, 1); 857 get_nsid(fd, &path, &nsid); 858 if (nsid != 0) { 859 close(fd); 860 open_dev(path, &fd, 1, 1); 861 } else if (attached_opt.nsid == NONE) { 862 close(fd); 863 fprintf(stderr, "No NSID specified"); 864 arg_help(argc, argv, f); 865 } 866 if (attached_opt.nsid != NONE) 867 nsid = attached_opt.nsid; 868 if (read_controller_data(fd, &cd)) 869 errx(EX_IOERR, "Identify request failed"); 870 871 /* Check that controller can execute this command. */ 872 if (((cd.oacs >> NVME_CTRLR_DATA_OACS_NSMGMT_SHIFT) & 873 NVME_CTRLR_DATA_OACS_NSMGMT_MASK) == 0) 874 errx(EX_UNAVAILABLE, "controller does not support namespace management"); 875 876 memset(&pt, 0, sizeof(pt)); 877 pt.cmd.opc = NVME_OPC_IDENTIFY; 878 pt.cmd.nsid = htole32(nsid); 879 pt.cmd.cdw10 = htole32(0x12); 880 pt.buf = clist; 881 pt.len = sizeof(clist); 882 pt.is_read = 1; 883 if (ioctl(fd, NVME_PASSTHROUGH_CMD, &pt) < 0) 884 err(EX_IOERR, "identify request failed"); 885 if (nvme_completion_is_error(&pt.cpl)) 886 errx(EX_IOERR, "identify request returned error"); 887 888 n = le16toh(clist[0]); 889 printf("Attached %d controller(s):\n", n); 890 for (i = 0; i < n; i++) 891 printf(" 0x%04x\n", le16toh(clist[i + 1])); 892 893 exit(0); 894 } 895 896 static void 897 nsidentify(const struct cmd *f, int argc, char *argv[]) 898 { 899 struct nvme_pt_command pt; 900 struct nvme_controller_data cd; 901 struct nvme_namespace_data nsdata; 902 uint8_t *data; 903 int fd; 904 char *path; 905 uint32_t nsid; 906 u_int i; 907 908 if (arg_parse(argc, argv, f)) 909 return; 910 open_dev(identify_opt.dev, &fd, 0, 1); 911 get_nsid(fd, &path, &nsid); 912 if (nsid != 0) { 913 close(fd); 914 open_dev(path, &fd, 1, 1); 915 } else if (identify_opt.nsid == NONE) { 916 close(fd); 917 fprintf(stderr, "No NSID specified"); 918 arg_help(argc, argv, f); 919 } 920 if (identify_opt.nsid != NONE) 921 nsid = identify_opt.nsid; 922 if (read_controller_data(fd, &cd)) 923 errx(EX_IOERR, "Identify request failed"); 924 925 /* Check that controller can execute this command. */ 926 if (((cd.oacs >> NVME_CTRLR_DATA_OACS_NSMGMT_SHIFT) & 927 NVME_CTRLR_DATA_OACS_NSMGMT_MASK) == 0) 928 errx(EX_UNAVAILABLE, "controller does not support namespace management"); 929 930 memset(&pt, 0, sizeof(pt)); 931 pt.cmd.opc = NVME_OPC_IDENTIFY; 932 pt.cmd.nsid = htole32(nsid); 933 pt.cmd.cdw10 = htole32(0x11); 934 pt.buf = &nsdata; 935 pt.len = sizeof(nsdata); 936 pt.is_read = 1; 937 938 if (ioctl(fd, NVME_PASSTHROUGH_CMD, &pt) < 0) 939 err(EX_IOERR, "identify request failed"); 940 941 if (nvme_completion_is_error(&pt.cpl)) 942 errx(EX_IOERR, "identify request returned error"); 943 944 close(fd); 945 946 data = (uint8_t *)&nsdata; 947 for (i = 0; i < sizeof(nsdata); i++) { 948 if (data[i] != 0) 949 break; 950 } 951 if (i == sizeof(nsdata)) 952 errx(EX_UNAVAILABLE, "namespace %d is not allocated", nsid); 953 954 /* Convert data to host endian */ 955 nvme_namespace_data_swapbytes(&nsdata); 956 957 if (identify_opt.hex) { 958 i = sizeof(struct nvme_namespace_data); 959 if (!identify_opt.verbose) { 960 for (; i > 384; i--) { 961 if (data[i - 1] != 0) 962 break; 963 } 964 } 965 print_hex(&nsdata, i); 966 exit(0); 967 } 968 969 print_namespace(&nsdata); 970 exit(0); 971 } 972 973 static void 974 ns(const struct cmd *nf __unused, int argc, char *argv[]) 975 { 976 977 cmd_dispatch(argc, argv, &ns_cmd); 978 } 979