sbin/nvmecontrol/ns.c

   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,
 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) {
 643                 close(fd);
 644                 fprintf(stderr, "No NSID specified");
 645                 arg_help(argc, argv, f);
 646         }
 647         if (delete_opt.nsid != NONE)
 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 }