2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 * Copyright (c) 2017 Netflix, Inc.
5 * Copyright (C) 2018-2019 Alexander Motin <mav@FreeBSD.org>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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.
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.
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
32 #include <sys/param.h>
33 #include <sys/ioccom.h>
45 #include "nvmecontrol.h"
47 /* Tables for command line parsing */
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;
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 }
65 static struct cmd ns_cmd = {
68 .descr = "Namespace management commands",
76 static struct active_options {
82 static const struct args active_args[] = {
83 { arg_string, &active_opt.dev, "controller-id|namespace-id" },
84 { arg_none, NULL, NULL },
87 static struct cmd active_cmd = {
90 .descr = "List active (attached) namespaces",
91 .ctx_size = sizeof(active_opt),
96 CMD_SUBCOMMAND(ns_cmd, active_cmd);
98 static struct cmd allocated_cmd = {
101 .descr = "List allocated (created) namespaces",
102 .ctx_size = sizeof(active_opt),
107 CMD_SUBCOMMAND(ns_cmd, allocated_cmd);
109 static struct controllers_options {
111 } controllers_opt = {
115 static const struct args controllers_args[] = {
116 { arg_string, &controllers_opt.dev, "controller-id|namespace-id" },
117 { arg_none, NULL, NULL },
120 static struct cmd controllers_cmd = {
121 .name = "controllers",
123 .descr = "List all controllers in NVM subsystem",
124 .ctx_size = sizeof(controllers_opt),
126 .args = controllers_args,
129 CMD_SUBCOMMAND(ns_cmd, controllers_cmd);
131 static struct create_options {
141 // uint32_t block_size;
154 // .block_size = NONE,
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"),
181 static const struct args create_args[] = {
182 { arg_string, &create_opt.dev, "controller-id|namespace-id" },
183 { arg_none, NULL, NULL },
186 static struct cmd create_cmd = {
189 .descr = "Create a namespace",
190 .ctx_size = sizeof(create_opt),
195 CMD_SUBCOMMAND(ns_cmd, create_cmd);
197 static struct delete_options {
205 static const struct opts delete_opts[] = {
206 OPT("namespace-id", 'n', arg_uint32, delete_opt, nsid,
207 "The namespace ID to delete"),
211 static const struct args delete_args[] = {
212 { arg_string, &delete_opt.dev, "controller-id|namespace-id" },
213 { arg_none, NULL, NULL },
216 static struct cmd delete_cmd = {
219 .descr = "Delete a namespace",
220 .ctx_size = sizeof(delete_opt),
225 CMD_SUBCOMMAND(ns_cmd, delete_cmd);
227 static struct attach_options {
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"),
245 static const struct args attach_args[] = {
246 { arg_string, &attach_opt.dev, "controller-id|namespace-id" },
247 { arg_none, NULL, NULL },
250 static struct cmd attach_cmd = {
253 .descr = "Attach a controller to a namespace",
254 .ctx_size = sizeof(attach_opt),
259 CMD_SUBCOMMAND(ns_cmd, attach_cmd);
261 static struct attached_options {
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"),
275 static const struct args attached_args[] = {
276 { arg_string, &attached_opt.dev, "controller-id|namespace-id" },
277 { arg_none, NULL, NULL },
280 static struct cmd attached_cmd = {
283 .descr = "List controllers attached to a namespace",
284 .ctx_size = sizeof(attached_opt),
285 .opts = attached_opts,
286 .args = attached_args,
289 CMD_SUBCOMMAND(ns_cmd, attached_cmd);
291 static struct detach_options {
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"),
309 static const struct args detach_args[] = {
310 { arg_string, &detach_opt.dev, "controller-id|namespace-id" },
311 { arg_none, NULL, NULL },
314 static struct cmd detach_cmd = {
317 .descr = "Detach a controller from a namespace",
318 .ctx_size = sizeof(detach_opt),
323 CMD_SUBCOMMAND(ns_cmd, detach_cmd);
325 static struct identify_options {
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 }
347 static const struct args identify_args[] = {
348 { arg_string, &identify_opt.dev, "controller-id|namespace-id" },
349 { arg_none, NULL, NULL },
352 static struct cmd identify_cmd = {
355 .descr = "Print IDENTIFY for allocated namespace",
356 .ctx_size = sizeof(identify_opt),
357 .opts = identify_opts,
358 .args = identify_args,
361 CMD_SUBCOMMAND(ns_cmd, identify_cmd);
363 /* handles NVME_OPC_NAMESPACE_MANAGEMENT and ATTACHMENT admin cmds */
365 struct ns_result_str {
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"},
387 get_res_str(uint16_t res)
389 struct ns_result_str *t = ns_result;
391 while (t->res != 0xFFFF) {
400 nsactive(const struct cmd *f, int argc, char *argv[])
402 struct nvme_pt_command pt;
403 struct nvme_controller_data cd;
409 if (arg_parse(argc, argv, f))
411 open_dev(active_opt.dev, &fd, 0, 1);
412 get_nsid(fd, &path, &nsid);
415 open_dev(path, &fd, 0, 1);
418 if (read_controller_data(fd, &cd))
419 errx(EX_IOERR, "Identify request failed");
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");
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);
431 pt.len = sizeof(list);
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");
438 printf("Active namespaces:\n");
439 for (i = 0; list[i] != 0; i++)
440 printf("%10d\n", le32toh(list[i]));
446 nsallocated(const struct cmd *f, int argc, char *argv[])
448 struct nvme_pt_command pt;
449 struct nvme_controller_data cd;
455 if (arg_parse(argc, argv, f))
457 open_dev(active_opt.dev, &fd, 0, 1);
458 get_nsid(fd, &path, &nsid);
461 open_dev(path, &fd, 0, 1);
464 if (read_controller_data(fd, &cd))
465 errx(EX_IOERR, "Identify request failed");
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");
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);
477 pt.len = sizeof(list);
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");
484 printf("Allocated namespaces:\n");
485 for (i = 0; list[i] != 0; i++)
486 printf("%10d\n", le32toh(list[i]));
492 nscontrollers(const struct cmd *f, int argc, char *argv[])
494 struct nvme_pt_command pt;
495 struct nvme_controller_data cd;
499 uint16_t clist[2048];
501 if (arg_parse(argc, argv, f))
503 open_dev(controllers_opt.dev, &fd, 0, 1);
504 get_nsid(fd, &path, &nsid);
507 open_dev(path, &fd, 0, 1);
510 if (read_controller_data(fd, &cd))
511 errx(EX_IOERR, "Identify request failed");
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");
518 memset(&pt, 0, sizeof(pt));
519 pt.cmd.opc = NVME_OPC_IDENTIFY;
520 pt.cmd.cdw10 = htole32(0x13);
522 pt.len = sizeof(clist);
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");
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]));
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
545 nscreate(const struct cmd *f, int argc, char *argv[])
547 struct nvme_pt_command pt;
548 struct nvme_controller_data cd;
549 struct nvme_namespace_data nsdata;
554 if (arg_parse(argc, argv, f))
557 if (create_opt.cap == NONE64)
558 create_opt.cap = create_opt.nsze;
559 if (create_opt.nsze == NONE64) {
561 "Size not specified\n");
562 arg_help(argc, argv, f);
565 open_dev(create_opt.dev, &fd, 1, 1);
566 get_nsid(fd, &path, &nsid);
569 open_dev(path, &fd, 1, 1);
572 if (read_controller_data(fd, &cd))
573 errx(EX_IOERR, "Identify request failed");
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");
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;
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);
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);
602 nsdata.dps = create_opt.dps;
603 nsdata.nmic = create_opt.nmic;
604 nvme_namespace_data_swapbytes(&nsdata);
606 memset(&pt, 0, sizeof(pt));
607 pt.cmd.opc = NVME_OPC_NAMESPACE_MANAGEMENT;
608 pt.cmd.cdw10 = htole32(0); /* create */
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);
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));
620 printf("namespace %d created\n", pt.cpl.cdw0);
625 nsdelete(const struct cmd *f, int argc, char *argv[])
627 struct nvme_pt_command pt;
628 struct nvme_controller_data cd;
634 if (arg_parse(argc, argv, f))
637 open_dev(delete_opt.dev, &fd, 1, 1);
638 get_nsid(fd, &path, &nsid);
641 open_dev(path, &fd, 1, 1);
642 } else if (delete_opt.nsid == NONE) {
644 fprintf(stderr, "No NSID specified");
645 arg_help(argc, argv, f);
647 if (delete_opt.nsid != NONE)
648 nsid = delete_opt.nsid;
650 if (read_controller_data(fd, &cd))
651 errx(EX_IOERR, "Identify request failed");
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");
658 memset(&pt, 0, sizeof(pt));
659 pt.cmd.opc = NVME_OPC_NAMESPACE_MANAGEMENT;
660 pt.cmd.cdw10 = htole32(1); /* delete */
662 pt.len = sizeof(buf);
666 if ((result = ioctl(fd, NVME_PASSTHROUGH_CMD, &pt)) < 0)
667 errx(EX_IOERR, "ioctl request to %s failed: %d", delete_opt.dev, result);
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));
674 printf("namespace %d deleted\n", nsid);
679 * Attach and Detach use Dword 10, and a controller list (section 4.9)
680 * This struct is 4096 bytes in size.
684 * Result values for both attach/detach:
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.
691 * 0x2 Invalid Field can occur if ctrlrid d.n.e in system.
694 nsattach(const struct cmd *f, int argc, char *argv[])
696 struct nvme_pt_command pt;
697 struct nvme_controller_data cd;
701 uint16_t clist[2048];
703 if (arg_parse(argc, argv, f))
705 open_dev(attach_opt.dev, &fd, 1, 1);
706 get_nsid(fd, &path, &nsid);
709 open_dev(path, &fd, 1, 1);
710 } else if (attach_opt.nsid == NONE) {
712 fprintf(stderr, "No NSID specified");
713 arg_help(argc, argv, f);
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");
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");
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);
731 pt.len = sizeof(clist);
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");
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);
746 memset(&pt, 0, sizeof(pt));
747 pt.cmd.opc = NVME_OPC_NAMESPACE_ATTACHMENT;
748 pt.cmd.cdw10 = htole32(0); /* attach */
751 pt.len = sizeof(clist);
753 if ((result = ioctl(fd, NVME_PASSTHROUGH_CMD, &pt)) < 0)
754 errx(EX_IOERR, "ioctl request to %s failed: %d", attach_opt.dev, result);
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));
761 printf("namespace %d attached\n", nsid);
766 nsdetach(const struct cmd *f, int argc, char *argv[])
768 struct nvme_pt_command pt;
769 struct nvme_controller_data cd;
773 uint16_t clist[2048];
775 if (arg_parse(argc, argv, f))
777 open_dev(detach_opt.dev, &fd, 1, 1);
778 get_nsid(fd, &path, &nsid);
781 open_dev(path, &fd, 1, 1);
782 } else if (detach_opt.nsid == NONE) {
784 fprintf(stderr, "No NSID specified");
785 arg_help(argc, argv, f);
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");
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");
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);
804 pt.len = sizeof(clist);
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");
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);
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);
825 memset(&pt, 0, sizeof(pt));
826 pt.cmd.opc = NVME_OPC_NAMESPACE_ATTACHMENT;
827 pt.cmd.cdw10 = htole32(1); /* detach */
830 pt.len = sizeof(clist);
832 if ((result = ioctl(fd, NVME_PASSTHROUGH_CMD, &pt)) < 0)
833 errx(EX_IOERR, "ioctl request to %s failed: %d", detach_opt.dev, result);
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));
840 printf("namespace %d detached\n", nsid);
845 nsattached(const struct cmd *f, int argc, char *argv[])
847 struct nvme_pt_command pt;
848 struct nvme_controller_data cd;
852 uint16_t clist[2048];
854 if (arg_parse(argc, argv, f))
856 open_dev(attached_opt.dev, &fd, 0, 1);
857 get_nsid(fd, &path, &nsid);
860 open_dev(path, &fd, 1, 1);
861 } else if (attached_opt.nsid == NONE) {
863 fprintf(stderr, "No NSID specified");
864 arg_help(argc, argv, f);
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");
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");
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);
881 pt.len = sizeof(clist);
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");
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]));
897 nsidentify(const struct cmd *f, int argc, char *argv[])
899 struct nvme_pt_command pt;
900 struct nvme_controller_data cd;
901 struct nvme_namespace_data nsdata;
908 if (arg_parse(argc, argv, f))
910 open_dev(identify_opt.dev, &fd, 0, 1);
911 get_nsid(fd, &path, &nsid);
914 open_dev(path, &fd, 1, 1);
915 } else if (identify_opt.nsid == NONE) {
917 fprintf(stderr, "No NSID specified");
918 arg_help(argc, argv, f);
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");
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");
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);
935 pt.len = sizeof(nsdata);
938 if (ioctl(fd, NVME_PASSTHROUGH_CMD, &pt) < 0)
939 err(EX_IOERR, "identify request failed");
941 if (nvme_completion_is_error(&pt.cpl))
942 errx(EX_IOERR, "identify request returned error");
946 data = (uint8_t *)&nsdata;
947 for (i = 0; i < sizeof(nsdata); i++) {
951 if (i == sizeof(nsdata))
952 errx(EX_UNAVAILABLE, "namespace %d is not allocated", nsid);
954 /* Convert data to host endian */
955 nvme_namespace_data_swapbytes(&nsdata);
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)
965 print_hex(&nsdata, i);
969 print_namespace(&nsdata);
974 ns(const struct cmd *nf __unused, int argc, char *argv[])
977 cmd_dispatch(argc, argv, &ns_cmd);