usr.sbin/ctladm/ctladm.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2003, 2004 Silicon Graphics International Corp.
   5  * Copyright (c) 1997-2007 Kenneth D. Merry
   6  * Copyright (c) 2012 The FreeBSD Foundation
   7  * Copyright (c) 2018 Marcelo Araujo <araujo@FreeBSD.org>
   8  * All rights reserved.
   9  *
  10  * Portions of this software were developed by Edward Tomasz Napierala
  11  * under sponsorship from the FreeBSD Foundation.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions, and the following disclaimer,
  18  *    without modification.
  19  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  20  *    substantially similar to the "NO WARRANTY" disclaimer below
  21  *    ("Disclaimer") and any redistribution must be conditioned upon
  22  *    including a substantially similar Disclaimer requirement for further
  23  *    binary redistribution.
  24  *
  25  * NO WARRANTY
  26  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  27  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  28  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  29  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  30  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  34  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  35  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  36  * POSSIBILITY OF SUCH DAMAGES.
  37  *
  38  * $Id: //depot/users/kenm/FreeBSD-test2/usr.sbin/ctladm/ctladm.c#4 $
  39  */
  40 /*
  41  * CAM Target Layer exercise program.
  42  *
  43  * Author: Ken Merry <ken@FreeBSD.org>
  44  */
  45
  46 #include <sys/cdefs.h>
  47 __FBSDID("$FreeBSD$");
  48
  49 #include <sys/param.h>
  50 #include <sys/callout.h>
  51 #include <sys/ioctl.h>
  52 #include <sys/linker.h>
  53 #include <sys/module.h>
  54 #include <sys/queue.h>
  55 #include <sys/sbuf.h>
  56 #include <sys/nv.h>
  57 #include <sys/stat.h>
  58 #include <bsdxml.h>
  59 #include <ctype.h>
  60 #include <err.h>
  61 #include <errno.h>
  62 #include <fcntl.h>
  63 #include <getopt.h>
  64 #include <stdlib.h>
  65 #include <stdint.h>
  66 #include <stdio.h>
  67 #include <string.h>
  68 #include <unistd.h>
  69 #include <cam/scsi/scsi_all.h>
  70 #include <cam/scsi/scsi_message.h>
  71 #include <cam/ctl/ctl.h>
  72 #include <cam/ctl/ctl_io.h>
  73 #include <cam/ctl/ctl_backend.h>
  74 #include <cam/ctl/ctl_ioctl.h>
  75 #include <cam/ctl/ctl_util.h>
  76 #include <cam/ctl/ctl_scsi_all.h>
  77 #include <camlib.h>
  78 #include <libutil.h>
  79 #include "ctladm.h"
  80
  81 #ifdef min
  82 #undef min
  83 #endif
  84 #define min(x,y) (x < y) ? x : y
  85
  86 typedef enum {
  87         CTLADM_CMD_TUR,
  88         CTLADM_CMD_INQUIRY,
  89         CTLADM_CMD_REQ_SENSE,
  90         CTLADM_CMD_ARRAYLIST,
  91         CTLADM_CMD_REPORT_LUNS,
  92         CTLADM_CMD_HELP,
  93         CTLADM_CMD_DEVLIST,
  94         CTLADM_CMD_ADDDEV,
  95         CTLADM_CMD_RM,
  96         CTLADM_CMD_CREATE,
  97         CTLADM_CMD_READ,
  98         CTLADM_CMD_WRITE,
  99         CTLADM_CMD_PORT,
 100         CTLADM_CMD_PORTLIST,
 101         CTLADM_CMD_READCAPACITY,
 102         CTLADM_CMD_MODESENSE,
 103         CTLADM_CMD_DUMPOOA,
 104         CTLADM_CMD_DUMPSTRUCTS,
 105         CTLADM_CMD_START,
 106         CTLADM_CMD_STOP,
 107         CTLADM_CMD_SYNC_CACHE,
 108         CTLADM_CMD_LUNLIST,
 109         CTLADM_CMD_DELAY,
 110         CTLADM_CMD_ERR_INJECT,
 111         CTLADM_CMD_PRES_IN,
 112         CTLADM_CMD_PRES_OUT,
 113         CTLADM_CMD_INQ_VPD_DEVID,
 114         CTLADM_CMD_RTPG,
 115         CTLADM_CMD_MODIFY,
 116         CTLADM_CMD_ISLIST,
 117         CTLADM_CMD_ISLOGOUT,
 118         CTLADM_CMD_ISTERMINATE,
 119         CTLADM_CMD_LUNMAP
 120 } ctladm_cmdfunction;
 121
 122 typedef enum {
 123         CTLADM_ARG_NONE         = 0x0000000,
 124         CTLADM_ARG_AUTOSENSE    = 0x0000001,
 125         CTLADM_ARG_DEVICE       = 0x0000002,
 126         CTLADM_ARG_ARRAYSIZE    = 0x0000004,
 127         CTLADM_ARG_BACKEND      = 0x0000008,
 128         CTLADM_ARG_CDBSIZE      = 0x0000010,
 129         CTLADM_ARG_DATALEN      = 0x0000020,
 130         CTLADM_ARG_FILENAME     = 0x0000040,
 131         CTLADM_ARG_LBA          = 0x0000080,
 132         CTLADM_ARG_PC           = 0x0000100,
 133         CTLADM_ARG_PAGE_CODE    = 0x0000200,
 134         CTLADM_ARG_PAGE_LIST    = 0x0000400,
 135         CTLADM_ARG_SUBPAGE      = 0x0000800,
 136         CTLADM_ARG_PAGELIST     = 0x0001000,
 137         CTLADM_ARG_DBD          = 0x0002000,
 138         CTLADM_ARG_TARG_LUN     = 0x0004000,
 139         CTLADM_ARG_BLOCKSIZE    = 0x0008000,
 140         CTLADM_ARG_IMMED        = 0x0010000,
 141         CTLADM_ARG_RELADR       = 0x0020000,
 142         CTLADM_ARG_RETRIES      = 0x0040000,
 143         CTLADM_ARG_ONOFFLINE    = 0x0080000,
 144         CTLADM_ARG_ONESHOT      = 0x0100000,
 145         CTLADM_ARG_TIMEOUT      = 0x0200000,
 146         CTLADM_ARG_INITIATOR    = 0x0400000,
 147         CTLADM_ARG_NOCOPY       = 0x0800000,
 148         CTLADM_ARG_NEED_TL      = 0x1000000
 149 } ctladm_cmdargs;
 150
 151 struct ctladm_opts {
 152         const char      *optname;
 153         uint32_t        cmdnum;
 154         ctladm_cmdargs  argnum;
 155         const char      *subopt;
 156 };
 157
 158 typedef enum {
 159         CC_OR_NOT_FOUND,
 160         CC_OR_AMBIGUOUS,
 161         CC_OR_FOUND
 162 } ctladm_optret;
 163
 164 static const char rw_opts[] = "Nb:c:d:f:l:";
 165 static const char startstop_opts[] = "i";
 166
 167 static struct ctladm_opts option_table[] = {
 168         {"adddev", CTLADM_CMD_ADDDEV, CTLADM_ARG_NONE, NULL},
 169         {"create", CTLADM_CMD_CREATE, CTLADM_ARG_NONE, "b:B:d:l:o:s:S:t:"},
 170         {"delay", CTLADM_CMD_DELAY, CTLADM_ARG_NEED_TL, "T:l:t:"},
 171         {"devid", CTLADM_CMD_INQ_VPD_DEVID, CTLADM_ARG_NEED_TL, NULL},
 172         {"devlist", CTLADM_CMD_DEVLIST, CTLADM_ARG_NONE, "b:vx"},
 173         {"dumpooa", CTLADM_CMD_DUMPOOA, CTLADM_ARG_NONE, NULL},
 174         {"dumpstructs", CTLADM_CMD_DUMPSTRUCTS, CTLADM_ARG_NONE, NULL},
 175         {"help", CTLADM_CMD_HELP, CTLADM_ARG_NONE, NULL},
 176         {"inject", CTLADM_CMD_ERR_INJECT, CTLADM_ARG_NEED_TL, "cd:i:p:r:s:"},
 177         {"inquiry", CTLADM_CMD_INQUIRY, CTLADM_ARG_NEED_TL, NULL},
 178         {"islist", CTLADM_CMD_ISLIST, CTLADM_ARG_NONE, "vx"},
 179         {"islogout", CTLADM_CMD_ISLOGOUT, CTLADM_ARG_NONE, "ac:i:p:"},
 180         {"isterminate", CTLADM_CMD_ISTERMINATE, CTLADM_ARG_NONE, "ac:i:p:"},
 181         {"lunlist", CTLADM_CMD_LUNLIST, CTLADM_ARG_NONE, NULL},
 182         {"lunmap", CTLADM_CMD_LUNMAP, CTLADM_ARG_NONE, "p:l:L:"},
 183         {"modesense", CTLADM_CMD_MODESENSE, CTLADM_ARG_NEED_TL, "P:S:dlm:c:"},
 184         {"modify", CTLADM_CMD_MODIFY, CTLADM_ARG_NONE, "b:l:o:s:"},
 185         {"port", CTLADM_CMD_PORT, CTLADM_ARG_NONE, "lo:O:d:crp:qt:w:W:x"},
 186         {"portlist", CTLADM_CMD_PORTLIST, CTLADM_ARG_NONE, "f:ilp:qvx"},
 187         {"prin", CTLADM_CMD_PRES_IN, CTLADM_ARG_NEED_TL, "a:"},
 188         {"prout", CTLADM_CMD_PRES_OUT, CTLADM_ARG_NEED_TL, "a:k:r:s:"},
 189         {"read", CTLADM_CMD_READ, CTLADM_ARG_NEED_TL, rw_opts},
 190         {"readcapacity", CTLADM_CMD_READCAPACITY, CTLADM_ARG_NEED_TL, "c:"},
 191         {"remove", CTLADM_CMD_RM, CTLADM_ARG_NONE, "b:l:o:"},
 192         {"reportluns", CTLADM_CMD_REPORT_LUNS, CTLADM_ARG_NEED_TL, NULL},
 193         {"reqsense", CTLADM_CMD_REQ_SENSE, CTLADM_ARG_NEED_TL, NULL},
 194         {"rtpg", CTLADM_CMD_RTPG, CTLADM_ARG_NEED_TL, NULL},
 195         {"start", CTLADM_CMD_START, CTLADM_ARG_NEED_TL, startstop_opts},
 196         {"stop", CTLADM_CMD_STOP, CTLADM_ARG_NEED_TL, startstop_opts},
 197         {"synccache", CTLADM_CMD_SYNC_CACHE, CTLADM_ARG_NEED_TL, "b:c:il:r"},
 198         {"tur", CTLADM_CMD_TUR, CTLADM_ARG_NEED_TL, NULL},
 199         {"write", CTLADM_CMD_WRITE, CTLADM_ARG_NEED_TL, rw_opts},
 200         {"-?", CTLADM_CMD_HELP, CTLADM_ARG_NONE, NULL},
 201         {"-h", CTLADM_CMD_HELP, CTLADM_ARG_NONE, NULL},
 202         {NULL, 0, 0, NULL}
 203 };
 204
 205
 206 ctladm_optret getoption(struct ctladm_opts *table, char *arg, uint32_t *cmdnum,
 207                         ctladm_cmdargs *argnum, const char **subopt);
 208 static int cctl_dump_ooa(int fd, int argc, char **argv);
 209 static int cctl_port(int fd, int argc, char **argv, char *combinedopt);
 210 static int cctl_do_io(int fd, int retries, union ctl_io *io, const char *func);
 211 static int cctl_delay(int fd, int lun, int argc, char **argv,
 212                       char *combinedopt);
 213 static int cctl_lunlist(int fd);
 214 static int cctl_sync_cache(int fd, int lun, int iid, int retries,
 215                            int argc, char **argv, char *combinedopt);
 216 static int cctl_start_stop(int fd, int lun, int iid, int retries,
 217                            int start, int argc, char **argv, char *combinedopt);
 218 static int cctl_mode_sense(int fd, int lun, int iid, int retries,
 219                            int argc, char **argv, char *combinedopt);
 220 static int cctl_read_capacity(int fd, int lun, int iid,
 221                               int retries, int argc, char **argv,
 222                               char *combinedopt);
 223 static int cctl_read_write(int fd, int lun, int iid, int retries,
 224                            int argc, char **argv, char *combinedopt,
 225                            ctladm_cmdfunction command);
 226 static int cctl_get_luns(int fd, int lun, int iid, int retries,
 227                          struct scsi_report_luns_data **lun_data,
 228                          uint32_t *num_luns);
 229 static int cctl_report_luns(int fd, int lun, int iid, int retries);
 230 static int cctl_tur(int fd, int lun, int iid, int retries);
 231 static int cctl_get_inquiry(int fd, int lun, int iid, int retries,
 232                             char *path_str, int path_len,
 233                             struct scsi_inquiry_data *inq_data);
 234 static int cctl_inquiry(int fd, int lun, int iid, int retries);
 235 static int cctl_req_sense(int fd, int lun, int iid, int retries);
 236 static int cctl_persistent_reserve_in(int fd, int lun,
 237                                       int initiator, int argc, char **argv,
 238                                       char *combinedopt, int retry_count);
 239 static int cctl_persistent_reserve_out(int fd, int lun,
 240                                        int initiator, int argc, char **argv,
 241                                        char *combinedopt, int retry_count);
 242 static int cctl_create_lun(int fd, int argc, char **argv, char *combinedopt);
 243 static int cctl_inquiry_vpd_devid(int fd, int lun, int initiator);
 244 static int cctl_report_target_port_group(int fd, int lun, int initiator);
 245 static int cctl_modify_lun(int fd, int argc, char **argv, char *combinedopt);
 246 static int cctl_portlist(int fd, int argc, char **argv, char *combinedopt);
 247
 248 ctladm_optret
 249 getoption(struct ctladm_opts *table, char *arg, uint32_t *cmdnum,
 250           ctladm_cmdargs *argnum, const char **subopt)
 251 {
 252         struct ctladm_opts *opts;
 253         int num_matches = 0;
 254
 255         for (opts = table; (opts != NULL) && (opts->optname != NULL);
 256              opts++) {
 257                 if (strncmp(opts->optname, arg, strlen(arg)) == 0) {
 258                         *cmdnum = opts->cmdnum;
 259                         *argnum = opts->argnum;
 260                         *subopt = opts->subopt;
 261
 262                         if (strcmp(opts->optname, arg) == 0)
 263                                 return (CC_OR_FOUND);
 264
 265                         if (++num_matches > 1)
 266                                 return(CC_OR_AMBIGUOUS);
 267                 }
 268         }
 269
 270         if (num_matches > 0)
 271                 return(CC_OR_FOUND);
 272         else
 273                 return(CC_OR_NOT_FOUND);
 274 }
 275
 276 static int
 277 cctl_dump_ooa(int fd, int argc, char **argv)
 278 {
 279         struct ctl_ooa ooa;
 280         long double cmd_latency;
 281         int num_entries, len, lun = -1, retval = 0;
 282         unsigned int i;
 283
 284         num_entries = 104;
 285
 286         if ((argc > 2) && (isdigit(argv[2][0])))
 287                 lun = strtol(argv[2], NULL, 0);
 288 retry:
 289
 290         len = num_entries * sizeof(struct ctl_ooa_entry);
 291         bzero(&ooa, sizeof(ooa));
 292         ooa.entries = malloc(len);
 293         if (ooa.entries == NULL) {
 294                 warn("%s: error mallocing %d bytes", __func__, len);
 295                 return (1);
 296         }
 297         if (lun >= 0) {
 298                 ooa.lun_num = lun;
 299         } else
 300                 ooa.flags |= CTL_OOA_FLAG_ALL_LUNS;
 301         ooa.alloc_len = len;
 302         ooa.alloc_num = num_entries;
 303         if (ioctl(fd, CTL_GET_OOA, &ooa) == -1) {
 304                 warn("%s: CTL_GET_OOA ioctl failed", __func__);
 305                 retval = 1;
 306                 goto bailout;
 307         }
 308
 309         if (ooa.status == CTL_OOA_NEED_MORE_SPACE) {
 310                 num_entries = num_entries * 2;
 311                 free(ooa.entries);
 312                 ooa.entries = NULL;
 313                 goto retry;
 314         }
 315
 316         if (ooa.status != CTL_OOA_OK) {
 317                 warnx("%s: CTL_GET_OOA ioctl returned error %d", __func__,
 318                       ooa.status);
 319                 retval = 1;
 320                 goto bailout;
 321         }
 322
 323         fprintf(stdout, "Dumping OOA queues\n");
 324         for (i = 0; i < ooa.fill_num; i++) {
 325                 struct ctl_ooa_entry *entry;
 326                 char cdb_str[(SCSI_MAX_CDBLEN * 3) +1];
 327                 struct bintime delta_bt;
 328                 struct timespec ts;
 329
 330                 entry = &ooa.entries[i];
 331
 332                 delta_bt = ooa.cur_bt;
 333                 bintime_sub(&delta_bt, &entry->start_bt);
 334                 bintime2timespec(&delta_bt, &ts);
 335                 cmd_latency = ts.tv_sec * 1000;
 336                 if (ts.tv_nsec > 0)
 337                         cmd_latency += ts.tv_nsec / 1000000;
 338
 339                 fprintf(stdout, "LUN %jd tag 0x%04x%s%s%s%s%s: %s. CDB: %s "
 340                         "(%0.0Lf ms)\n",
 341                         (intmax_t)entry->lun_num, entry->tag_num,
 342                         (entry->cmd_flags & CTL_OOACMD_FLAG_BLOCKED) ?
 343                          " BLOCKED" : "",
 344                         (entry->cmd_flags & CTL_OOACMD_FLAG_DMA) ? " DMA" : "",
 345                         (entry->cmd_flags & CTL_OOACMD_FLAG_DMA_QUEUED) ?
 346                          " DMAQUEUED" : "",
 347                         (entry->cmd_flags & CTL_OOACMD_FLAG_ABORT) ?
 348                          " ABORT" : "",
 349                         (entry->cmd_flags & CTL_OOACMD_FLAG_RTR) ? " RTR" :"",
 350                         scsi_op_desc(entry->cdb[0], NULL),
 351                         scsi_cdb_string(entry->cdb, cdb_str, sizeof(cdb_str)),
 352                         cmd_latency);
 353         }
 354         fprintf(stdout, "OOA queues dump done\n");
 355
 356 bailout:
 357         free(ooa.entries);
 358         return (retval);
 359 }
 360
 361 static int
 362 cctl_dump_structs(int fd, ctladm_cmdargs cmdargs __unused)
 363 {
 364         if (ioctl(fd, CTL_DUMP_STRUCTS) == -1) {
 365                 warn(__func__);
 366                 return (1);
 367         }
 368         return (0);
 369 }
 370
 371 typedef enum {
 372         CCTL_PORT_MODE_NONE,
 373         CCTL_PORT_MODE_LIST,
 374         CCTL_PORT_MODE_SET,
 375         CCTL_PORT_MODE_ON,
 376         CCTL_PORT_MODE_OFF,
 377         CCTL_PORT_MODE_CREATE,
 378         CCTL_PORT_MODE_REMOVE
 379 } cctl_port_mode;
 380
 381 static struct ctladm_opts cctl_fe_table[] = {
 382         {"fc", CTL_PORT_FC, CTLADM_ARG_NONE, NULL},
 383         {"scsi", CTL_PORT_SCSI, CTLADM_ARG_NONE, NULL},
 384         {"internal", CTL_PORT_INTERNAL, CTLADM_ARG_NONE, NULL},
 385         {"iscsi", CTL_PORT_ISCSI, CTLADM_ARG_NONE, NULL},
 386         {"sas", CTL_PORT_SAS, CTLADM_ARG_NONE, NULL},
 387         {"all", CTL_PORT_ALL, CTLADM_ARG_NONE, NULL},
 388         {NULL, 0, 0, NULL}
 389 };
 390
 391 static int
 392 cctl_port(int fd, int argc, char **argv, char *combinedopt)
 393 {
 394         int c;
 395         int32_t targ_port = -1;
 396         int retval = 0;
 397         int wwnn_set = 0, wwpn_set = 0;
 398         uint64_t wwnn = 0, wwpn = 0;
 399         cctl_port_mode port_mode = CCTL_PORT_MODE_NONE;
 400         struct ctl_port_entry entry;
 401         struct ctl_req req;
 402         char *driver = NULL;
 403         nvlist_t *option_list;
 404         ctl_port_type port_type = CTL_PORT_NONE;
 405         int quiet = 0, xml = 0;
 406
 407         option_list = nvlist_create(0);
 408         if (option_list == NULL)
 409                 err(1, "%s: unable to allocate nvlist", __func__);
 410
 411         while ((c = getopt(argc, argv, combinedopt)) != -1) {
 412                 switch (c) {
 413                 case 'l':
 414                         if (port_mode != CCTL_PORT_MODE_NONE)
 415                                 goto bailout_badarg;
 416
 417                         port_mode = CCTL_PORT_MODE_LIST;
 418                         break;
 419                 case 'c':
 420                         port_mode = CCTL_PORT_MODE_CREATE;
 421                         break;
 422                 case 'r':
 423                         port_mode = CCTL_PORT_MODE_REMOVE;
 424                         break;
 425                 case 'o':
 426                         if (port_mode != CCTL_PORT_MODE_NONE)
 427                                 goto bailout_badarg;
 428
 429                         if (strcasecmp(optarg, "on") == 0)
 430                                 port_mode = CCTL_PORT_MODE_ON;
 431                         else if (strcasecmp(optarg, "off") == 0)
 432                                 port_mode = CCTL_PORT_MODE_OFF;
 433                         else {
 434                                 warnx("Invalid -o argument %s, \"on\" or "
 435                                       "\"off\" are the only valid args",
 436                                       optarg);
 437                                 retval = 1;
 438                                 goto bailout;
 439                         }
 440                         break;
 441                 case 'O': {
 442                         char *tmpstr;
 443                         char *name, *value;
 444
 445                         tmpstr = strdup(optarg);
 446                         name = strsep(&tmpstr, "=");
 447                         if (name == NULL) {
 448                                 warnx("%s: option -O takes \"name=value\""
 449                                       "argument", __func__);
 450                                 retval = 1;
 451                                 goto bailout;
 452                         }
 453                         value = strsep(&tmpstr, "=");
 454                         if (value == NULL) {
 455                                 warnx("%s: option -O takes \"name=value\""
 456                                       "argument", __func__);
 457                                 retval = 1;
 458                                 goto bailout;
 459                         }
 460
 461                         free(tmpstr);
 462                         nvlist_add_string(option_list, name, value);
 463                         break;
 464                 }
 465                 case 'd':
 466                         if (driver != NULL) {
 467                                 warnx("%s: option -d cannot be specified twice",
 468                                     __func__);
 469                                 retval = 1;
 470                                 goto bailout;
 471                         }
 472
 473                         driver = strdup(optarg);
 474                         break;
 475                 case 'p':
 476                         targ_port = strtol(optarg, NULL, 0);
 477                         break;
 478                 case 'q':
 479                         quiet = 1;
 480                         break;
 481                 case 't': {
 482                         ctladm_optret optret;
 483                         ctladm_cmdargs argnum;
 484                         const char *subopt;
 485                         ctl_port_type tmp_port_type;
 486
 487                         optret = getoption(cctl_fe_table, optarg, &tmp_port_type,
 488                                            &argnum, &subopt);
 489                         if (optret == CC_OR_AMBIGUOUS) {
 490                                 warnx("%s: ambiguous frontend type %s",
 491                                       __func__, optarg);
 492                                 retval = 1;
 493                                 goto bailout;
 494                         } else if (optret == CC_OR_NOT_FOUND) {
 495                                 warnx("%s: invalid frontend type %s",
 496                                       __func__, optarg);
 497                                 retval = 1;
 498                                 goto bailout;
 499                         }
 500
 501                         port_type |= tmp_port_type;
 502                         break;
 503                 }
 504                 case 'w':
 505                         if ((port_mode != CCTL_PORT_MODE_NONE)
 506                          && (port_mode != CCTL_PORT_MODE_SET))
 507                                 goto bailout_badarg;
 508
 509                         port_mode = CCTL_PORT_MODE_SET;
 510
 511                         wwnn = strtoull(optarg, NULL, 0);
 512                         wwnn_set = 1;
 513                         break;
 514                 case 'W':
 515                         if ((port_mode != CCTL_PORT_MODE_NONE)
 516                          && (port_mode != CCTL_PORT_MODE_SET))
 517                                 goto bailout_badarg;
 518
 519                         port_mode = CCTL_PORT_MODE_SET;
 520
 521                         wwpn = strtoull(optarg, NULL, 0);
 522                         wwpn_set = 1;
 523                         break;
 524                 case 'x':
 525                         xml = 1;
 526                         break;
 527                 }
 528         }
 529
 530         if (driver == NULL)
 531                 driver = strdup("ioctl");
 532
 533         /*
 534          * The user can specify either one or more frontend types (-t), or
 535          * a specific frontend, but not both.
 536          *
 537          * If the user didn't specify a frontend type or number, set it to
 538          * all.  This is primarily needed for the enable/disable ioctls.
 539          * This will be a no-op for the listing code.  For the set ioctl,
 540          * we'll throw an error, since that only works on one port at a time.
 541          */
 542         if ((port_type != CTL_PORT_NONE) && (targ_port != -1)) {
 543                 warnx("%s: can only specify one of -t or -n", __func__);
 544                 retval = 1;
 545                 goto bailout;
 546         } else if ((targ_port == -1) && (port_type == CTL_PORT_NONE))
 547                 port_type = CTL_PORT_ALL;
 548
 549         bzero(&entry, sizeof(entry));
 550
 551         /*
 552          * These are needed for all but list/dump mode.
 553          */
 554         entry.port_type = port_type;
 555         entry.targ_port = targ_port;
 556
 557         switch (port_mode) {
 558         case CCTL_PORT_MODE_LIST: {
 559                 char opts[] = "xq";
 560                 char argx[] = "-x";
 561                 char argq[] = "-q";
 562                 char *argvx[2];
 563                 int argcx = 0;
 564
 565                 optind = 0;
 566                 optreset = 1;
 567                 if (xml)
 568                         argvx[argcx++] = argx;
 569                 if (quiet)
 570                         argvx[argcx++] = argq;
 571                 cctl_portlist(fd, argcx, argvx, opts);
 572                 break;
 573         }
 574         case CCTL_PORT_MODE_REMOVE:
 575                 if (targ_port == -1) {
 576                         warnx("%s: -r require -p", __func__);
 577                         retval = 1;
 578                         goto bailout;
 579                 }
 580         case CCTL_PORT_MODE_CREATE: {
 581                 bzero(&req, sizeof(req));
 582                 strlcpy(req.driver, driver, sizeof(req.driver));
 583
 584                 if (port_mode == CCTL_PORT_MODE_REMOVE) {
 585                         req.reqtype = CTL_REQ_REMOVE;
 586                         nvlist_add_stringf(option_list, "port_id", "%d",
 587                             targ_port);
 588                 } else
 589                         req.reqtype = CTL_REQ_CREATE;
 590
 591                 req.args = nvlist_pack(option_list, &req.args_len);
 592                 if (req.args == NULL) {
 593                         warn("%s: error packing nvlist", __func__);
 594                         retval = 1;
 595                         goto bailout;
 596                 }
 597
 598                 retval = ioctl(fd, CTL_PORT_REQ, &req);
 599                 free(req.args);
 600                 if (retval == -1) {
 601                         warn("%s: CTL_PORT_REQ ioctl failed", __func__);
 602                         retval = 1;
 603                         goto bailout;
 604                 }
 605
 606                 switch (req.status) {
 607                 case CTL_LUN_ERROR:
 608                         warnx("error: %s", req.error_str);
 609                         retval = 1;
 610                         goto bailout;
 611                 case CTL_LUN_WARNING:
 612                         warnx("warning: %s", req.error_str);
 613                         break;
 614                 case CTL_LUN_OK:
 615                         break;
 616                 default:
 617                         warnx("unknown status: %d", req.status);
 618                         retval = 1;
 619                         goto bailout;
 620                 }
 621
 622                 break;
 623         }
 624         case CCTL_PORT_MODE_SET:
 625                 if (targ_port == -1) {
 626                         warnx("%s: -w and -W require -n", __func__);
 627                         retval = 1;
 628                         goto bailout;
 629                 }
 630
 631                 if (wwnn_set) {
 632                         entry.flags |= CTL_PORT_WWNN_VALID;
 633                         entry.wwnn = wwnn;
 634                 }
 635                 if (wwpn_set) {
 636                         entry.flags |= CTL_PORT_WWPN_VALID;
 637                         entry.wwpn = wwpn;
 638                 }
 639
 640                 if (ioctl(fd, CTL_SET_PORT_WWNS, &entry) == -1) {
 641                         warn("%s: CTL_SET_PORT_WWNS ioctl failed", __func__);
 642                         retval = 1;
 643                         goto bailout;
 644                 }
 645                 break;
 646         case CCTL_PORT_MODE_ON:
 647                 if (ioctl(fd, CTL_ENABLE_PORT, &entry) == -1) {
 648                         warn("%s: CTL_ENABLE_PORT ioctl failed", __func__);
 649                         retval = 1;
 650                         goto bailout;
 651                 }
 652                 fprintf(stdout, "Front End Ports enabled\n");
 653                 break;
 654         case CCTL_PORT_MODE_OFF:
 655                 if (ioctl(fd, CTL_DISABLE_PORT, &entry) == -1) {
 656                         warn("%s: CTL_DISABLE_PORT ioctl failed", __func__);
 657                         retval = 1;
 658                         goto bailout;
 659                 }
 660                 fprintf(stdout, "Front End Ports disabled\n");
 661                 break;
 662         default:
 663                 warnx("%s: one of -l, -o or -w/-W must be specified", __func__);
 664                 retval = 1;
 665                 goto bailout;
 666                 break;
 667         }
 668
 669 bailout:
 670         nvlist_destroy(option_list);
 671         free(driver);
 672         return (retval);
 673
 674 bailout_badarg:
 675         warnx("%s: only one of -l, -o or -w/-W may be specified", __func__);
 676         return (1);
 677 }
 678
 679 static int
 680 cctl_do_io(int fd, int retries, union ctl_io *io, const char *func)
 681 {
 682         do {
 683                 if (ioctl(fd, CTL_IO, io) == -1) {
 684                         warn("%s: error sending CTL_IO ioctl", func);
 685                         return (-1);
 686                 }
 687         } while (((io->io_hdr.status & CTL_STATUS_MASK) != CTL_SUCCESS)
 688               && (retries-- > 0));
 689
 690         return (0);
 691 }
 692
 693 static int
 694 cctl_delay(int fd, int lun, int argc, char **argv,
 695            char *combinedopt)
 696 {
 697         struct ctl_io_delay_info delay_info;
 698         char *delayloc = NULL;
 699         char *delaytype = NULL;
 700         int delaytime = -1;
 701         int retval;
 702         int c;
 703
 704         retval = 0;
 705
 706         memset(&delay_info, 0, sizeof(delay_info));
 707
 708         while ((c = getopt(argc, argv, combinedopt)) != -1) {
 709                 switch (c) {
 710                 case 'T':
 711                         delaytype = strdup(optarg);
 712                         break;
 713                 case 'l':
 714                         delayloc = strdup(optarg);
 715                         break;
 716                 case 't':
 717                         delaytime = strtoul(optarg, NULL, 0);
 718                         break;
 719                 }
 720         }
 721
 722         if (delaytime == -1) {
 723                 warnx("%s: you must specify the delaytime with -t", __func__);
 724                 retval = 1;
 725                 goto bailout;
 726         }
 727
 728         if (strcasecmp(delayloc, "datamove") == 0)
 729                 delay_info.delay_loc = CTL_DELAY_LOC_DATAMOVE;
 730         else if (strcasecmp(delayloc, "done") == 0)
 731                 delay_info.delay_loc = CTL_DELAY_LOC_DONE;
 732         else {
 733                 warnx("%s: invalid delay location %s", __func__, delayloc);
 734                 retval = 1;
 735                 goto bailout;
 736         }
 737
 738         if ((delaytype == NULL)
 739          || (strcmp(delaytype, "oneshot") == 0))
 740                 delay_info.delay_type = CTL_DELAY_TYPE_ONESHOT;
 741         else if (strcmp(delaytype, "cont") == 0)
 742                 delay_info.delay_type = CTL_DELAY_TYPE_CONT;
 743         else {
 744                 warnx("%s: invalid delay type %s", __func__, delaytype);
 745                 retval = 1;
 746                 goto bailout;
 747         }
 748
 749         delay_info.lun_id = lun;
 750         delay_info.delay_secs = delaytime;
 751
 752         if (ioctl(fd, CTL_DELAY_IO, &delay_info) == -1) {
 753                 warn("%s: CTL_DELAY_IO ioctl failed", __func__);
 754                 retval = 1;
 755                 goto bailout;
 756         }
 757         switch (delay_info.status) {
 758         case CTL_DELAY_STATUS_NONE:
 759                 warnx("%s: no delay status??", __func__);
 760                 retval = 1;
 761                 break;
 762         case CTL_DELAY_STATUS_OK:
 763                 break;
 764         case CTL_DELAY_STATUS_INVALID_LUN:
 765                 warnx("%s: invalid lun %d", __func__, lun);
 766                 retval = 1;
 767                 break;
 768         case CTL_DELAY_STATUS_INVALID_TYPE:
 769                 warnx("%s: invalid delay type %d", __func__,
 770                       delay_info.delay_type);
 771                 retval = 1;
 772                 break;
 773         case CTL_DELAY_STATUS_INVALID_LOC:
 774                 warnx("%s: delay location %s not implemented?", __func__,
 775                       delayloc);
 776                 retval = 1;
 777                 break;
 778         case CTL_DELAY_STATUS_NOT_IMPLEMENTED:
 779                 warnx("%s: delay not implemented in the kernel", __func__);
 780                 warnx("%s: recompile with the CTL_IO_DELAY flag set", __func__);
 781                 retval = 1;
 782                 break;
 783         default:
 784                 warnx("%s: unknown delay return status %d", __func__,
 785                       delay_info.status);
 786                 retval = 1;
 787                 break;
 788         }
 789
 790 bailout:
 791         free(delayloc);
 792         free(delaytype);
 793         return (retval);
 794 }
 795
 796 static struct ctladm_opts cctl_err_types[] = {
 797         {"aborted", CTL_LUN_INJ_ABORTED, CTLADM_ARG_NONE, NULL},
 798         {"mediumerr", CTL_LUN_INJ_MEDIUM_ERR, CTLADM_ARG_NONE, NULL},
 799         {"ua", CTL_LUN_INJ_UA, CTLADM_ARG_NONE, NULL},
 800         {"custom", CTL_LUN_INJ_CUSTOM, CTLADM_ARG_NONE, NULL},
 801         {NULL, 0, 0, NULL}
 802
 803 };
 804
 805 static struct ctladm_opts cctl_err_patterns[] = {
 806         {"read", CTL_LUN_PAT_READ, CTLADM_ARG_NONE, NULL},
 807         {"write", CTL_LUN_PAT_WRITE, CTLADM_ARG_NONE, NULL},
 808         {"rw", CTL_LUN_PAT_READWRITE, CTLADM_ARG_NONE, NULL},
 809         {"readwrite", CTL_LUN_PAT_READWRITE, CTLADM_ARG_NONE, NULL},
 810         {"readcap", CTL_LUN_PAT_READCAP, CTLADM_ARG_NONE, NULL},
 811         {"tur", CTL_LUN_PAT_TUR, CTLADM_ARG_NONE, NULL},
 812         {"any", CTL_LUN_PAT_ANY, CTLADM_ARG_NONE, NULL},
 813 #if 0
 814         {"cmd", CTL_LUN_PAT_CMD,  CTLADM_ARG_NONE, NULL},
 815 #endif
 816         {NULL, 0, 0, NULL}
 817 };
 818
 819 static int
 820 cctl_error_inject(int fd, uint32_t lun, int argc, char **argv,
 821                   char *combinedopt)
 822 {
 823         int retval = 0;
 824         struct ctl_error_desc err_desc;
 825         uint64_t lba = 0;
 826         uint32_t len = 0;
 827         uint64_t delete_id = 0;
 828         int delete_id_set = 0;
 829         int continuous = 0;
 830         int sense_len = 0;
 831         int fd_sense = 0;
 832         int c;
 833
 834         bzero(&err_desc, sizeof(err_desc));
 835         err_desc.lun_id = lun;
 836
 837         while ((c = getopt(argc, argv, combinedopt)) != -1) {
 838                 switch (c) {
 839                 case 'c':
 840                         continuous = 1;
 841                         break;
 842                 case 'd':
 843                         delete_id = strtoull(optarg, NULL, 0);
 844                         delete_id_set = 1;
 845                         break;
 846                 case 'i':
 847                 case 'p': {
 848                         ctladm_optret optret;
 849                         ctladm_cmdargs argnum;
 850                         const char *subopt;
 851
 852                         if (c == 'i') {
 853                                 ctl_lun_error err_type;
 854
 855                                 if (err_desc.lun_error != CTL_LUN_INJ_NONE) {
 856                                         warnx("%s: can't specify multiple -i "
 857                                               "arguments", __func__);
 858                                         retval = 1;
 859                                         goto bailout;
 860                                 }
 861                                 optret = getoption(cctl_err_types, optarg,
 862                                                    &err_type, &argnum, &subopt);
 863                                 err_desc.lun_error = err_type;
 864                         } else {
 865                                 ctl_lun_error_pattern pattern;
 866
 867                                 optret = getoption(cctl_err_patterns, optarg,
 868                                                    &pattern, &argnum, &subopt);
 869                                 err_desc.error_pattern |= pattern;
 870                         }
 871
 872                         if (optret == CC_OR_AMBIGUOUS) {
 873                                 warnx("%s: ambiguous argument %s", __func__,
 874                                       optarg);
 875                                 retval = 1;
 876                                 goto bailout;
 877                         } else if (optret == CC_OR_NOT_FOUND) {
 878                                 warnx("%s: argument %s not found", __func__,
 879                                       optarg);
 880                                 retval = 1;
 881                                 goto bailout;
 882                         }
 883                         break;
 884                 }
 885                 case 'r': {
 886                         char *tmpstr, *tmpstr2;
 887
 888                         tmpstr = strdup(optarg);
 889                         if (tmpstr == NULL) {
 890                                 warn("%s: error duplicating string %s",
 891                                      __func__, optarg);
 892                                 retval = 1;
 893                                 goto bailout;
 894                         }
 895
 896                         tmpstr2 = strsep(&tmpstr, ",");
 897                         if (tmpstr2 == NULL) {
 898                                 warnx("%s: invalid -r argument %s", __func__,
 899                                       optarg);
 900                                 retval = 1;
 901                                 free(tmpstr);
 902                                 goto bailout;
 903                         }
 904                         lba = strtoull(tmpstr2, NULL, 0);
 905                         tmpstr2 = strsep(&tmpstr, ",");
 906                         if (tmpstr2 == NULL) {
 907                                 warnx("%s: no len argument for -r lba,len, got"
 908                                       " %s", __func__, optarg);
 909                                 retval = 1;
 910                                 free(tmpstr);
 911                                 goto bailout;
 912                         }
 913                         len = strtoul(tmpstr2, NULL, 0);
 914                         free(tmpstr);
 915                         break;
 916                 }
 917                 case 's': {
 918                         struct get_hook hook;
 919                         char *sensestr;
 920
 921                         sense_len = strtol(optarg, NULL, 0);
 922                         if (sense_len <= 0) {
 923                                 warnx("invalid number of sense bytes %d",
 924                                       sense_len);
 925                                 retval = 1;
 926                                 goto bailout;
 927                         }
 928
 929                         sense_len = MIN(sense_len, SSD_FULL_SIZE);
 930
 931                         hook.argc = argc - optind;
 932                         hook.argv = argv + optind;
 933                         hook.got = 0;
 934
 935                         sensestr = cget(&hook, NULL);
 936                         if ((sensestr != NULL)
 937                          && (sensestr[0] == '-')) {
 938                                 fd_sense = 1;
 939                         } else {
 940                                 buff_encode_visit(
 941                                     (uint8_t *)&err_desc.custom_sense,
 942                                     sense_len, sensestr, iget, &hook);
 943                         }
 944                         optind += hook.got;
 945                         break;
 946                 }
 947                 default:
 948                         break;
 949                 }
 950         }
 951
 952         if (delete_id_set != 0) {
 953                 err_desc.serial = delete_id;
 954                 if (ioctl(fd, CTL_ERROR_INJECT_DELETE, &err_desc) == -1) {
 955                         warn("%s: error issuing CTL_ERROR_INJECT_DELETE ioctl",
 956                              __func__);
 957                         retval = 1;
 958                 }
 959                 goto bailout;
 960         }
 961
 962         if (err_desc.lun_error == CTL_LUN_INJ_NONE) {
 963                 warnx("%s: error injection command (-i) needed",
 964                       __func__);
 965                 retval = 1;
 966                 goto bailout;
 967         } else if ((err_desc.lun_error == CTL_LUN_INJ_CUSTOM)
 968                 && (sense_len == 0)) {
 969                 warnx("%s: custom error requires -s", __func__);
 970                 retval = 1;
 971                 goto bailout;
 972         }
 973
 974         if (continuous != 0)
 975                 err_desc.lun_error |= CTL_LUN_INJ_CONTINUOUS;
 976
 977         /*
 978          * If fd_sense is set, we need to read the sense data the user
 979          * wants returned from stdin.
 980          */
 981         if (fd_sense == 1) {
 982                 ssize_t amt_read;
 983                 int amt_to_read = sense_len;
 984                 u_int8_t *buf_ptr = (uint8_t *)&err_desc.custom_sense;
 985
 986                 for (amt_read = 0; amt_to_read > 0;
 987                      amt_read = read(STDIN_FILENO, buf_ptr, amt_to_read)) {
 988                         if (amt_read == -1) {
 989                                 warn("error reading sense data from stdin");
 990                                 retval = 1;
 991                                 goto bailout;
 992                         }
 993                         amt_to_read -= amt_read;
 994                         buf_ptr += amt_read;
 995                 }
 996         }
 997
 998         if (err_desc.error_pattern == CTL_LUN_PAT_NONE) {
 999                 warnx("%s: command pattern (-p) needed", __func__);
1000                 retval = 1;
1001                 goto bailout;
1002         }
1003
1004         if (len != 0) {
1005                 err_desc.error_pattern |= CTL_LUN_PAT_RANGE;
1006                 /*
1007                  * We could check here to see whether it's a read/write
1008                  * command, but that will be pointless once we allow
1009                  * custom patterns.  At that point, the user could specify
1010                  * a READ(6) CDB type, and we wouldn't have an easy way here
1011                  * to verify whether range checking is possible there.  The
1012                  * user will just figure it out when his error never gets
1013                  * executed.
1014                  */
1015 #if 0
1016                 if ((err_desc.pattern & CTL_LUN_PAT_READWRITE) == 0) {
1017                         warnx("%s: need read and/or write pattern if range "
1018                               "is specified", __func__);
1019                         retval = 1;
1020                         goto bailout;
1021                 }
1022 #endif
1023                 err_desc.lba_range.lba = lba;
1024                 err_desc.lba_range.len = len;
1025         }
1026
1027         if (ioctl(fd, CTL_ERROR_INJECT, &err_desc) == -1) {
1028                 warn("%s: error issuing CTL_ERROR_INJECT ioctl", __func__);
1029                 retval = 1;
1030         } else {
1031                 printf("Error injection succeeded, serial number is %ju\n",
1032                        (uintmax_t)err_desc.serial);
1033         }
1034 bailout:
1035
1036         return (retval);
1037 }
1038
1039 static int
1040 cctl_lunlist(int fd)
1041 {
1042         struct scsi_report_luns_data *lun_data;
1043         struct scsi_inquiry_data *inq_data;
1044         uint32_t num_luns;
1045         int initid;
1046         unsigned int i;
1047         int retval;
1048
1049         inq_data = NULL;
1050         initid = 7;
1051
1052         /*
1053          * XXX KDM assuming LUN 0 is fine, but we may need to change this
1054          * if we ever acquire the ability to have multiple targets.
1055          */
1056         if ((retval = cctl_get_luns(fd, /*lun*/ 0, initid,
1057                                     /*retries*/ 2, &lun_data, &num_luns)) != 0)
1058                 goto bailout;
1059
1060         inq_data = malloc(sizeof(*inq_data));
1061         if (inq_data == NULL) {
1062                 warn("%s: couldn't allocate memory for inquiry data\n",
1063                      __func__);
1064                 retval = 1;
1065                 goto bailout;
1066         }
1067         for (i = 0; i < num_luns; i++) {
1068                 char scsi_path[40];
1069                 int lun_val;
1070
1071                 switch (lun_data->luns[i].lundata[0] & RPL_LUNDATA_ATYP_MASK) {
1072                 case RPL_LUNDATA_ATYP_PERIPH:
1073                         lun_val = lun_data->luns[i].lundata[1];
1074                         break;
1075                 case RPL_LUNDATA_ATYP_FLAT:
1076                         lun_val = (lun_data->luns[i].lundata[0] &
1077                                 RPL_LUNDATA_FLAT_LUN_MASK) |
1078                                 (lun_data->luns[i].lundata[1] <<
1079                                 RPL_LUNDATA_FLAT_LUN_BITS);
1080                         break;
1081                 case RPL_LUNDATA_ATYP_LUN:
1082                 case RPL_LUNDATA_ATYP_EXTLUN:
1083                 default:
1084                         fprintf(stdout, "Unsupported LUN format %d\n",
1085                                 lun_data->luns[i].lundata[0] &
1086                                 RPL_LUNDATA_ATYP_MASK);
1087                         lun_val = -1;
1088                         break;
1089                 }
1090                 if (lun_val == -1)
1091                         continue;
1092
1093                 if ((retval = cctl_get_inquiry(fd, lun_val, initid,
1094                                                /*retries*/ 2, scsi_path,
1095                                                sizeof(scsi_path),
1096                                                inq_data)) != 0) {
1097                         goto bailout;
1098                 }
1099                 printf("%s", scsi_path);
1100                 scsi_print_inquiry(inq_data);
1101         }
1102 bailout:
1103
1104         if (lun_data != NULL)
1105                 free(lun_data);
1106
1107         if (inq_data != NULL)
1108                 free(inq_data);
1109
1110         return (retval);
1111 }
1112
1113 static int
1114 cctl_sync_cache(int fd, int lun, int iid, int retries,
1115                 int argc, char **argv, char *combinedopt)
1116 {
1117         union ctl_io *io;
1118         int cdb_size = -1;
1119         int retval;
1120         uint64_t our_lba = 0;
1121         uint32_t our_block_count = 0;
1122         int reladr = 0, immed = 0;
1123         int c;
1124
1125         retval = 0;
1126
1127         io = ctl_scsi_alloc_io(iid);
1128         if (io == NULL) {
1129                 warnx("%s: can't allocate memory", __func__);
1130                 return (1);
1131         }
1132
1133         while ((c = getopt(argc, argv, combinedopt)) != -1) {
1134                 switch (c) {
1135                 case 'b':
1136                         our_block_count = strtoul(optarg, NULL, 0);
1137                         break;
1138                 case 'c':
1139                         cdb_size = strtol(optarg, NULL, 0);
1140                         break;
1141                 case 'i':
1142                         immed = 1;
1143                         break;
1144                 case 'l':
1145                         our_lba = strtoull(optarg, NULL, 0);
1146                         break;
1147                 case 'r':
1148                         reladr = 1;
1149                         break;
1150                 default:
1151                         break;
1152                 }
1153         }
1154
1155         if (cdb_size != -1) {
1156                 switch (cdb_size) {
1157                 case 10:
1158                 case 16:
1159                         break;
1160                 default:
1161                         warnx("%s: invalid cdbsize %d, valid sizes are 10 "
1162                               "and 16", __func__, cdb_size);
1163                         retval = 1;
1164                         goto bailout;
1165                         break; /* NOTREACHED */
1166                 }
1167         } else
1168                 cdb_size = 10;
1169
1170         ctl_scsi_sync_cache(/*io*/ io,
1171                             /*immed*/ immed,
1172                             /*reladr*/ reladr,
1173                             /*minimum_cdb_size*/ cdb_size,
1174                             /*starting_lba*/ our_lba,
1175                             /*block_count*/ our_block_count,
1176                             /*tag_type*/ CTL_TAG_SIMPLE,
1177                             /*control*/ 0);
1178
1179         io->io_hdr.nexus.targ_lun = lun;
1180         io->io_hdr.nexus.initid = iid;
1181
1182         if (cctl_do_io(fd, retries, io, __func__) != 0) {
1183                 retval = 1;
1184                 goto bailout;
1185         }
1186
1187         if ((io->io_hdr.status & CTL_STATUS_MASK) == CTL_SUCCESS) {
1188                 fprintf(stdout, "Cache synchronized successfully\n");
1189         } else
1190                 ctl_io_error_print(io, NULL, stderr);
1191 bailout:
1192         ctl_scsi_free_io(io);
1193
1194         return (retval);
1195 }
1196
1197 static int
1198 cctl_start_stop(int fd, int lun, int iid, int retries, int start,
1199                 int argc, char **argv, char *combinedopt)
1200 {
1201         union ctl_io *io;
1202         char scsi_path[40];
1203         int immed = 0;
1204         int retval, c;
1205
1206         retval = 0;
1207
1208         io = ctl_scsi_alloc_io(iid);
1209         if (io == NULL) {
1210                 warnx("%s: can't allocate memory", __func__);
1211                 return (1);
1212         }
1213
1214         while ((c = getopt(argc, argv, combinedopt)) != -1) {
1215                 switch (c) {
1216                 case 'i':
1217                         immed = 1;
1218                         break;
1219                 default:
1220                         break;
1221                 }
1222         }
1223         /*
1224          * Use an ordered tag for the stop command, to guarantee that any
1225          * pending I/O will finish before the stop command executes.  This
1226          * would normally be the case anyway, since CTL will basically
1227          * treat the start/stop command as an ordered command with respect
1228          * to any other command except an INQUIRY.  (See ctl_ser_table.c.)
1229          */
1230         ctl_scsi_start_stop(/*io*/ io,
1231                             /*start*/ start,
1232                             /*load_eject*/ 0,
1233                             /*immediate*/ immed,
1234                             /*power_conditions*/ SSS_PC_START_VALID,
1235                             /*ctl_tag_type*/ start ? CTL_TAG_SIMPLE :
1236                                                      CTL_TAG_ORDERED,
1237                             /*control*/ 0);
1238
1239         io->io_hdr.nexus.targ_lun = lun;
1240         io->io_hdr.nexus.initid = iid;
1241
1242         if (cctl_do_io(fd, retries, io, __func__) != 0) {
1243                 retval = 1;
1244                 goto bailout;
1245         }
1246
1247         ctl_scsi_path_string(io, scsi_path, sizeof(scsi_path));
1248         if ((io->io_hdr.status & CTL_STATUS_MASK) == CTL_SUCCESS) {
1249                 fprintf(stdout, "%s LUN %s successfully\n", scsi_path,
1250                         (start) ?  "started" : "stopped");
1251         } else
1252                 ctl_io_error_print(io, NULL, stderr);
1253
1254 bailout:
1255         ctl_scsi_free_io(io);
1256
1257         return (retval);
1258 }
1259
1260 static int
1261 cctl_mode_sense(int fd, int lun, int iid, int retries,
1262                 int argc, char **argv, char *combinedopt)
1263 {
1264         union ctl_io *io;
1265         uint32_t datalen;
1266         uint8_t *dataptr;
1267         int pc = -1, cdbsize, retval, dbd = 0, subpage = -1;
1268         int list = 0;
1269         int page_code = -1;
1270         int c;
1271
1272         cdbsize = 0;
1273         retval = 0;
1274         dataptr = NULL;
1275
1276         io = ctl_scsi_alloc_io(iid);
1277         if (io == NULL) {
1278                 warn("%s: can't allocate memory", __func__);
1279                 return (1);
1280         }
1281
1282         while ((c = getopt(argc, argv, combinedopt)) != -1) {
1283                 switch (c) {
1284                 case 'P':
1285                         pc = strtoul(optarg, NULL, 0);
1286                         break;
1287                 case 'S':
1288                         subpage = strtoul(optarg, NULL, 0);
1289                         break;
1290                 case 'd':
1291                         dbd = 1;
1292                         break;
1293                 case 'l':
1294                         list = 1;
1295                         break;
1296                 case 'm':
1297                         page_code = strtoul(optarg, NULL, 0);
1298                         break;
1299                 case 'c':
1300                         cdbsize = strtol(optarg, NULL, 0);
1301                         break;
1302                 default:
1303                         break;
1304                 }
1305         }
1306
1307         if (((list == 0) && (page_code == -1))
1308          || ((list != 0) && (page_code != -1))) {
1309                 warnx("%s: you must specify either a page code (-m) or -l",
1310                       __func__);
1311                 retval = 1;
1312                 goto bailout;
1313         }
1314
1315         if ((page_code != -1)
1316          && ((page_code > SMS_ALL_PAGES_PAGE)
1317           || (page_code < 0))) {
1318                 warnx("%s: page code %d is out of range", __func__,
1319                       page_code);
1320                 retval = 1;
1321                 goto bailout;
1322         }
1323
1324         if (list == 1) {
1325                 page_code = SMS_ALL_PAGES_PAGE;
1326                 if (pc != -1) {
1327                         warnx("%s: arg -P makes no sense with -l",
1328                               __func__);
1329                         retval = 1;
1330                         goto bailout;
1331                 }
1332                 if (subpage != -1) {
1333                         warnx("%s: arg -S makes no sense with -l", __func__);
1334                         retval = 1;
1335                         goto bailout;
1336                 }
1337         }
1338
1339         if (pc == -1)
1340                 pc = SMS_PAGE_CTRL_CURRENT;
1341         else {
1342                 if ((pc > 3)
1343                  || (pc < 0)) {
1344                         warnx("%s: page control value %d is out of range: 0-3",
1345                               __func__, pc);
1346                         retval = 1;
1347                         goto bailout;
1348                 }
1349         }
1350
1351
1352         if ((subpage != -1)
1353          && ((subpage > 255)
1354           || (subpage < 0))) {
1355                 warnx("%s: subpage code %d is out of range: 0-255", __func__,
1356                       subpage);
1357                 retval = 1;
1358                 goto bailout;
1359         }
1360         if (cdbsize != 0) {
1361                 switch (cdbsize) {
1362                 case 6:
1363                 case 10:
1364                         break;
1365                 default:
1366                         warnx("%s: invalid cdbsize %d, valid sizes are 6 "
1367                               "and 10", __func__, cdbsize);
1368                         retval = 1;
1369                         goto bailout;
1370                         break;
1371                 }
1372         } else
1373                 cdbsize = 6;
1374
1375         if (subpage == -1)
1376                 subpage = 0;
1377
1378         if (cdbsize == 6)
1379                 datalen = 255;
1380         else
1381                 datalen = 65535;
1382
1383         dataptr = (uint8_t *)malloc(datalen);
1384         if (dataptr == NULL) {
1385                 warn("%s: can't allocate %d bytes", __func__, datalen);
1386                 retval = 1;
1387                 goto bailout;
1388         }
1389
1390         memset(dataptr, 0, datalen);
1391
1392         ctl_scsi_mode_sense(io,
1393                             /*data_ptr*/ dataptr,
1394                             /*data_len*/ datalen,
1395                             /*dbd*/ dbd,
1396                             /*llbaa*/ 0,
1397                             /*page_code*/ page_code,
1398                             /*pc*/ pc << 6,
1399                             /*subpage*/ subpage,
1400                             /*minimum_cdb_size*/ cdbsize,
1401                             /*tag_type*/ CTL_TAG_SIMPLE,
1402                             /*control*/ 0);
1403
1404         io->io_hdr.nexus.targ_lun = lun;
1405         io->io_hdr.nexus.initid = iid;
1406
1407         if (cctl_do_io(fd, retries, io, __func__) != 0) {
1408                 retval = 1;
1409                 goto bailout;
1410         }
1411
1412         if ((io->io_hdr.status & CTL_STATUS_MASK) == CTL_SUCCESS) {
1413                 int pages_len, used_len;
1414                 uint32_t returned_len;
1415                 uint8_t *ndataptr;
1416
1417                 if (io->scsiio.cdb[0] == MODE_SENSE_6) {
1418                         struct scsi_mode_hdr_6 *hdr6;
1419                         int bdlen;
1420
1421                         hdr6 = (struct scsi_mode_hdr_6 *)dataptr;
1422
1423                         returned_len = hdr6->datalen + 1;
1424                         bdlen = hdr6->block_descr_len;
1425
1426                         ndataptr = (uint8_t *)((uint8_t *)&hdr6[1] + bdlen);
1427                 } else {
1428                         struct scsi_mode_hdr_10 *hdr10;
1429                         int bdlen;
1430
1431                         hdr10 = (struct scsi_mode_hdr_10 *)dataptr;
1432
1433                         returned_len = scsi_2btoul(hdr10->datalen) + 2;
1434                         bdlen = scsi_2btoul(hdr10->block_descr_len);
1435
1436                         ndataptr = (uint8_t *)((uint8_t *)&hdr10[1] + bdlen);
1437                 }
1438                 /* just in case they can give us more than we allocated for */
1439                 returned_len = min(returned_len, datalen);
1440                 pages_len = returned_len - (ndataptr - dataptr);
1441 #if 0
1442                 fprintf(stdout, "returned_len = %d, pages_len = %d\n",
1443                         returned_len, pages_len);
1444 #endif
1445                 if (list == 1) {
1446                         fprintf(stdout, "Supported mode pages:\n");
1447                         for (used_len = 0; used_len < pages_len;) {
1448                                 struct scsi_mode_page_header *header;
1449
1450                                 header = (struct scsi_mode_page_header *)
1451                                         &ndataptr[used_len];
1452                                 fprintf(stdout, "%d\n", header->page_code);
1453                                 used_len += header->page_length + 2;
1454                         }
1455                 } else {
1456                         for (used_len = 0; used_len < pages_len; used_len++) {
1457                                 fprintf(stdout, "0x%x ", ndataptr[used_len]);
1458                                 if (((used_len+1) % 16) == 0)
1459                                         fprintf(stdout, "\n");
1460                         }
1461                         fprintf(stdout, "\n");
1462                 }
1463         } else
1464                 ctl_io_error_print(io, NULL, stderr);
1465 bailout:
1466
1467         ctl_scsi_free_io(io);
1468
1469         if (dataptr != NULL)
1470                 free(dataptr);
1471
1472         return (retval);
1473 }
1474
1475 static int
1476 cctl_read_capacity(int fd, int lun, int iid, int retries,
1477                    int argc, char **argv, char *combinedopt)
1478 {
1479         union ctl_io *io;
1480         struct scsi_read_capacity_data *data;
1481         struct scsi_read_capacity_data_long *longdata;
1482         int cdbsize = -1, retval;
1483         uint8_t *dataptr;
1484         int c;
1485
1486         cdbsize = 10;
1487         dataptr = NULL;
1488         retval = 0;
1489
1490         io = ctl_scsi_alloc_io(iid);
1491         if (io == NULL) {
1492                 warn("%s: can't allocate memory\n", __func__);
1493                 return (1);
1494         }
1495
1496         while ((c = getopt(argc, argv, combinedopt)) != -1) {
1497                 switch (c) {
1498                 case 'c':
1499                         cdbsize = strtol(optarg, NULL, 0);
1500                         break;
1501                 default:
1502                         break;
1503                 }
1504         }
1505         if (cdbsize != -1) {
1506                 switch (cdbsize) {
1507                 case 10:
1508                 case 16:
1509                         break;
1510                 default:
1511                         warnx("%s: invalid cdbsize %d, valid sizes are 10 "
1512                               "and 16", __func__, cdbsize);
1513                         retval = 1;
1514                         goto bailout;
1515                         break; /* NOTREACHED */
1516                 }
1517         } else
1518                 cdbsize = 10;
1519
1520         dataptr = (uint8_t *)malloc(sizeof(*longdata));
1521         if (dataptr == NULL) {
1522                 warn("%s: can't allocate %zd bytes\n", __func__,
1523                      sizeof(*longdata));
1524                 retval = 1;
1525                 goto bailout;
1526         }
1527         memset(dataptr, 0, sizeof(*longdata));
1528
1529 retry:
1530
1531         switch (cdbsize) {
1532         case 10:
1533                 ctl_scsi_read_capacity(io,
1534                                        /*data_ptr*/ dataptr,
1535                                        /*data_len*/ sizeof(*longdata),
1536                                        /*addr*/ 0,
1537                                        /*reladr*/ 0,
1538                                        /*pmi*/ 0,
1539                                        /*tag_type*/ CTL_TAG_SIMPLE,
1540                                        /*control*/ 0);
1541                 break;
1542         case 16:
1543                 ctl_scsi_read_capacity_16(io,
1544                                           /*data_ptr*/ dataptr,
1545                                           /*data_len*/ sizeof(*longdata),
1546                                           /*addr*/ 0,
1547                                           /*reladr*/ 0,
1548                                           /*pmi*/ 0,
1549                                           /*tag_type*/ CTL_TAG_SIMPLE,
1550                                           /*control*/ 0);
1551                 break;
1552         }
1553
1554         io->io_hdr.nexus.initid = iid;
1555         io->io_hdr.nexus.targ_lun = lun;
1556
1557         if (cctl_do_io(fd, retries, io, __func__) != 0) {
1558                 retval = 1;
1559                 goto bailout;
1560         }
1561
1562         if ((io->io_hdr.status & CTL_STATUS_MASK) == CTL_SUCCESS) {
1563                 uint64_t maxlba;
1564                 uint32_t blocksize;
1565
1566                 if (cdbsize == 10) {
1567
1568                         data = (struct scsi_read_capacity_data *)dataptr;
1569
1570                         maxlba = scsi_4btoul(data->addr);
1571                         blocksize = scsi_4btoul(data->length);
1572
1573                         if (maxlba == 0xffffffff) {
1574                                 cdbsize = 16;
1575                                 goto retry;
1576                         }
1577                 } else {
1578                         longdata=(struct scsi_read_capacity_data_long *)dataptr;
1579
1580                         maxlba = scsi_8btou64(longdata->addr);
1581                         blocksize = scsi_4btoul(longdata->length);
1582                 }
1583
1584                 fprintf(stdout, "Disk Capacity: %ju, Blocksize: %d\n",
1585                         (uintmax_t)maxlba, blocksize);
1586         } else {
1587                 ctl_io_error_print(io, NULL, stderr);
1588         }
1589 bailout:
1590         ctl_scsi_free_io(io);
1591
1592         if (dataptr != NULL)
1593                 free(dataptr);
1594
1595         return (retval);
1596 }
1597
1598 static int
1599 cctl_read_write(int fd, int lun, int iid, int retries,
1600                 int argc, char **argv, char *combinedopt,
1601                 ctladm_cmdfunction command)
1602 {
1603         union ctl_io *io;
1604         int file_fd, do_stdio;
1605         int cdbsize = -1, databytes;
1606         uint8_t *dataptr;
1607         char *filename = NULL;
1608         int datalen = -1, blocksize = -1;
1609         uint64_t lba = 0;
1610         int lba_set = 0;
1611         int retval;
1612         int c;
1613
1614         retval = 0;
1615         do_stdio = 0;
1616         dataptr = NULL;
1617         file_fd = -1;
1618
1619         io = ctl_scsi_alloc_io(iid);
1620         if (io == NULL) {
1621                 warn("%s: can't allocate memory\n", __func__);
1622                 return (1);
1623         }
1624
1625         while ((c = getopt(argc, argv, combinedopt)) != -1) {
1626                 switch (c) {
1627                 case 'N':
1628                         io->io_hdr.flags |= CTL_FLAG_NO_DATAMOVE;
1629                         break;
1630                 case 'b':
1631                         blocksize = strtoul(optarg, NULL, 0);
1632                         break;
1633                 case 'c':
1634                         cdbsize = strtoul(optarg, NULL, 0);
1635                         break;
1636                 case 'd':
1637                         datalen = strtoul(optarg, NULL, 0);
1638                         break;
1639                 case 'f':
1640                         filename = strdup(optarg);
1641                         break;
1642                 case 'l':
1643                         lba = strtoull(optarg, NULL, 0);
1644                         lba_set = 1;
1645                         break;
1646                 default:
1647                         break;
1648                 }
1649         }
1650         if (filename == NULL) {
1651                 warnx("%s: you must supply a filename using -f", __func__);
1652                 retval = 1;
1653                 goto bailout;
1654         }
1655
1656         if (datalen == -1) {
1657                 warnx("%s: you must specify the data length with -d", __func__);
1658                 retval = 1;
1659                 goto bailout;
1660         }
1661
1662         if (lba_set == 0) {
1663                 warnx("%s: you must specify the LBA with -l", __func__);
1664                 retval = 1;
1665                 goto bailout;
1666         }
1667
1668         if (blocksize == -1) {
1669                 warnx("%s: you must specify the blocksize with -b", __func__);
1670                 retval = 1;
1671                 goto bailout;
1672         }
1673
1674         if (cdbsize != -1) {
1675                 switch (cdbsize) {
1676                 case 6:
1677                 case 10:
1678                 case 12:
1679                 case 16:
1680                         break;
1681                 default:
1682                         warnx("%s: invalid cdbsize %d, valid sizes are 6, "
1683                               "10, 12 or 16", __func__, cdbsize);
1684                         retval = 1;
1685                         goto bailout;
1686                         break; /* NOTREACHED */
1687                 }
1688         } else
1689                 cdbsize = 6;
1690
1691         databytes = datalen * blocksize;
1692         dataptr = (uint8_t *)malloc(databytes);
1693
1694         if (dataptr == NULL) {
1695                 warn("%s: can't allocate %d bytes\n", __func__, databytes);
1696                 retval = 1;
1697                 goto bailout;
1698         }
1699         if (strcmp(filename, "-") == 0) {
1700                 if (command == CTLADM_CMD_READ)
1701                         file_fd = STDOUT_FILENO;
1702                 else
1703                         file_fd = STDIN_FILENO;
1704                 do_stdio = 1;
1705         } else {
1706                 file_fd = open(filename, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
1707                 if (file_fd == -1) {
1708                         warn("%s: can't open file %s", __func__, filename);
1709                         retval = 1;
1710                         goto bailout;
1711                 }
1712         }
1713
1714         memset(dataptr, 0, databytes);
1715
1716         if (command == CTLADM_CMD_WRITE) {
1717                 int bytes_read;
1718
1719                 bytes_read = read(file_fd, dataptr, databytes);
1720                 if (bytes_read == -1) {
1721                         warn("%s: error reading file %s", __func__, filename);
1722                         retval = 1;
1723                         goto bailout;
1724                 }
1725                 if (bytes_read != databytes) {
1726                         warnx("%s: only read %d bytes from file %s",
1727                               __func__, bytes_read, filename);
1728                         retval = 1;
1729                         goto bailout;
1730                 }
1731         }
1732         ctl_scsi_read_write(io,
1733                             /*data_ptr*/ dataptr,
1734                             /*data_len*/ databytes,
1735                             /*read_op*/ (command == CTLADM_CMD_READ) ? 1 : 0,
1736                             /*byte2*/ 0,
1737                             /*minimum_cdb_size*/ cdbsize,
1738                             /*lba*/ lba,
1739                             /*num_blocks*/ datalen,
1740                             /*tag_type*/ CTL_TAG_SIMPLE,
1741                             /*control*/ 0);
1742
1743         io->io_hdr.nexus.targ_lun = lun;
1744         io->io_hdr.nexus.initid = iid;
1745
1746         if (cctl_do_io(fd, retries, io, __func__) != 0) {
1747                 retval = 1;
1748                 goto bailout;
1749         }
1750
1751         if (((io->io_hdr.status & CTL_STATUS_MASK) == CTL_SUCCESS)
1752          && (command == CTLADM_CMD_READ)) {
1753                 int bytes_written;
1754
1755                 bytes_written = write(file_fd, dataptr, databytes);
1756                 if (bytes_written == -1) {
1757                         warn("%s: can't write to %s", __func__, filename);
1758                         goto bailout;
1759                 }
1760         } else if ((io->io_hdr.status & CTL_STATUS_MASK) != CTL_SUCCESS)
1761                 ctl_io_error_print(io, NULL, stderr);
1762
1763
1764 bailout:
1765
1766         ctl_scsi_free_io(io);
1767
1768         if (dataptr != NULL)
1769                 free(dataptr);
1770
1771         if ((do_stdio == 0)
1772          && (file_fd != -1))
1773                 close(file_fd);
1774
1775         return (retval);
1776 }
1777
1778 static int
1779 cctl_get_luns(int fd, int lun, int iid, int retries, struct
1780               scsi_report_luns_data **lun_data, uint32_t *num_luns)
1781 {
1782         union ctl_io *io;
1783         uint32_t nluns;
1784         int lun_datalen;
1785         int retval;
1786
1787         retval = 0;
1788
1789         io = ctl_scsi_alloc_io(iid);
1790         if (io == NULL) {
1791                 warnx("%s: can't allocate memory", __func__);
1792                 return (1);
1793         }
1794
1795         /*
1796          * lun_data includes space for 1 lun, allocate space for 4 initially.
1797          * If that isn't enough, we'll allocate more.
1798          */
1799         nluns = 4;
1800 retry:
1801         lun_datalen = sizeof(*lun_data) +
1802                 (nluns * sizeof(struct scsi_report_luns_lundata));
1803         *lun_data = malloc(lun_datalen);
1804
1805         if (*lun_data == NULL) {
1806                 warnx("%s: can't allocate memory", __func__);
1807                 ctl_scsi_free_io(io);
1808                 return (1);
1809         }
1810
1811         ctl_scsi_report_luns(io,
1812                              /*data_ptr*/ (uint8_t *)*lun_data,
1813                              /*data_len*/ lun_datalen,
1814                              /*select_report*/ RPL_REPORT_ALL,
1815                              /*tag_type*/ CTL_TAG_SIMPLE,
1816                              /*control*/ 0);
1817
1818         io->io_hdr.nexus.initid = iid;
1819         io->io_hdr.nexus.targ_lun = lun;
1820
1821         if (cctl_do_io(fd, retries, io, __func__) != 0) {
1822                 retval = 1;
1823                 goto bailout;
1824         }
1825
1826         if ((io->io_hdr.status & CTL_STATUS_MASK) == CTL_SUCCESS) {
1827                 uint32_t returned_len, returned_luns;
1828
1829                 returned_len = scsi_4btoul((*lun_data)->length);
1830                 returned_luns = returned_len / 8;
1831                 if (returned_luns > nluns) {
1832                         nluns = returned_luns;
1833                         free(*lun_data);
1834                         goto retry;
1835                 }
1836                 /* These should be the same */
1837                 *num_luns = MIN(returned_luns, nluns);
1838         } else {
1839                 ctl_io_error_print(io, NULL, stderr);
1840                 retval = 1;
1841         }
1842 bailout:
1843         ctl_scsi_free_io(io);
1844
1845         return (retval);
1846 }
1847
1848 static int
1849 cctl_report_luns(int fd, int lun, int iid, int retries)
1850 {
1851         struct scsi_report_luns_data *lun_data;
1852         uint32_t num_luns, i;
1853         int retval;
1854
1855         lun_data = NULL;
1856
1857         if ((retval = cctl_get_luns(fd, lun, iid, retries, &lun_data,
1858                                    &num_luns)) != 0)
1859                 goto bailout;
1860
1861         fprintf(stdout, "%u LUNs returned\n", num_luns);
1862         for (i = 0; i < num_luns; i++) {
1863                 int lun_val;
1864
1865                 /*
1866                  * XXX KDM figure out a way to share this code with
1867                  * cctl_lunlist()?
1868                  */
1869                 switch (lun_data->luns[i].lundata[0] & RPL_LUNDATA_ATYP_MASK) {
1870                 case RPL_LUNDATA_ATYP_PERIPH:
1871                         lun_val = lun_data->luns[i].lundata[1];
1872                         break;
1873                 case RPL_LUNDATA_ATYP_FLAT:
1874                         lun_val = (lun_data->luns[i].lundata[0] &
1875                                 RPL_LUNDATA_FLAT_LUN_MASK) |
1876                                 (lun_data->luns[i].lundata[1] <<
1877                                 RPL_LUNDATA_FLAT_LUN_BITS);
1878                         break;
1879                 case RPL_LUNDATA_ATYP_LUN:
1880                 case RPL_LUNDATA_ATYP_EXTLUN:
1881                 default:
1882                         fprintf(stdout, "Unsupported LUN format %d\n",
1883                                 lun_data->luns[i].lundata[0] &
1884                                 RPL_LUNDATA_ATYP_MASK);
1885                         lun_val = -1;
1886                         break;
1887                 }
1888                 if (lun_val == -1)
1889                         continue;
1890
1891                 fprintf(stdout, "%d\n", lun_val);
1892         }
1893
1894 bailout:
1895         if (lun_data != NULL)
1896                 free(lun_data);
1897
1898         return (retval);
1899 }
1900
1901 static int
1902 cctl_tur(int fd, int lun, int iid, int retries)
1903 {
1904         union ctl_io *io;
1905
1906         io = ctl_scsi_alloc_io(iid);
1907         if (io == NULL) {
1908                 fprintf(stderr, "can't allocate memory\n");
1909                 return (1);
1910         }
1911
1912         ctl_scsi_tur(io,
1913                      /* tag_type */ CTL_TAG_SIMPLE,
1914                      /* control */ 0);
1915
1916         io->io_hdr.nexus.targ_lun = lun;
1917         io->io_hdr.nexus.initid = iid;
1918
1919         if (cctl_do_io(fd, retries, io, __func__) != 0) {
1920                 ctl_scsi_free_io(io);
1921                 return (1);
1922         }
1923
1924         if ((io->io_hdr.status & CTL_STATUS_MASK) == CTL_SUCCESS)
1925                 fprintf(stdout, "Unit is ready\n");
1926         else
1927                 ctl_io_error_print(io, NULL, stderr);
1928
1929         return (0);
1930 }
1931
1932 static int
1933 cctl_get_inquiry(int fd, int lun, int iid, int retries,
1934                  char *path_str, int path_len,
1935                  struct scsi_inquiry_data *inq_data)
1936 {
1937         union ctl_io *io;
1938         int retval;
1939
1940         retval = 0;
1941
1942         io = ctl_scsi_alloc_io(iid);
1943         if (io == NULL) {
1944                 warnx("cctl_inquiry: can't allocate memory\n");
1945                 return (1);
1946         }
1947
1948         ctl_scsi_inquiry(/*io*/ io,
1949                          /*data_ptr*/ (uint8_t *)inq_data,
1950                          /*data_len*/ sizeof(*inq_data),
1951                          /*byte2*/ 0,
1952                          /*page_code*/ 0,
1953                          /*tag_type*/ CTL_TAG_SIMPLE,
1954                          /*control*/ 0);
1955
1956         io->io_hdr.nexus.targ_lun = lun;
1957         io->io_hdr.nexus.initid = iid;
1958
1959         if (cctl_do_io(fd, retries, io, __func__) != 0) {
1960                 retval = 1;
1961                 goto bailout;
1962         }
1963
1964         if ((io->io_hdr.status & CTL_STATUS_MASK) != CTL_SUCCESS) {
1965                 retval = 1;
1966                 ctl_io_error_print(io, NULL, stderr);
1967         } else if (path_str != NULL)
1968                 ctl_scsi_path_string(io, path_str, path_len);
1969
1970 bailout:
1971         ctl_scsi_free_io(io);
1972
1973         return (retval);
1974 }
1975
1976 static int
1977 cctl_inquiry(int fd, int lun, int iid, int retries)
1978 {
1979         struct scsi_inquiry_data *inq_data;
1980         char scsi_path[40];
1981         int retval;
1982
1983         inq_data = malloc(sizeof(*inq_data));
1984         if (inq_data == NULL) {
1985                 warnx("%s: can't allocate inquiry data", __func__);
1986                 retval = 1;
1987                 goto bailout;
1988         }
1989
1990         if ((retval = cctl_get_inquiry(fd, lun, iid, retries, scsi_path,
1991                                        sizeof(scsi_path), inq_data)) != 0)
1992                 goto bailout;
1993
1994         printf("%s", scsi_path);
1995         scsi_print_inquiry(inq_data);
1996
1997 bailout:
1998         if (inq_data != NULL)
1999                 free(inq_data);
2000
2001         return (retval);
2002 }
2003
2004 static int
2005 cctl_req_sense(int fd, int lun, int iid, int retries)
2006 {
2007         union ctl_io *io;
2008         struct scsi_sense_data *sense_data;
2009         int retval;
2010
2011         retval = 0;
2012
2013         io = ctl_scsi_alloc_io(iid);
2014         if (io == NULL) {
2015                 warnx("cctl_req_sense: can't allocate memory\n");
2016                 return (1);
2017         }
2018         sense_data = malloc(sizeof(*sense_data));
2019         memset(sense_data, 0, sizeof(*sense_data));
2020
2021         ctl_scsi_request_sense(/*io*/ io,
2022                                /*data_ptr*/ (uint8_t *)sense_data,
2023                                /*data_len*/ sizeof(*sense_data),
2024                                /*byte2*/ 0,
2025                                /*tag_type*/ CTL_TAG_SIMPLE,
2026                                /*control*/ 0);
2027
2028         io->io_hdr.nexus.targ_lun = lun;
2029         io->io_hdr.nexus.initid = iid;
2030
2031         if (cctl_do_io(fd, retries, io, __func__) != 0) {
2032                 retval = 1;
2033                 goto bailout;
2034         }
2035
2036         if ((io->io_hdr.status & CTL_STATUS_MASK) == CTL_SUCCESS) {
2037                 bcopy(sense_data, &io->scsiio.sense_data, sizeof(*sense_data));
2038                 io->scsiio.sense_len = sizeof(*sense_data);
2039                 ctl_scsi_sense_print(&io->scsiio, NULL, stdout);
2040         } else
2041                 ctl_io_error_print(io, NULL, stderr);
2042
2043 bailout:
2044
2045         ctl_scsi_free_io(io);
2046         free(sense_data);
2047
2048         return (retval);
2049 }
2050
2051 static int
2052 cctl_report_target_port_group(int fd, int lun, int iid)
2053 {
2054         union ctl_io *io;
2055         uint32_t datalen;
2056         uint8_t *dataptr;
2057         int retval;
2058
2059         dataptr = NULL;
2060         retval = 0;
2061
2062         io = ctl_scsi_alloc_io(iid);
2063         if (io == NULL) {
2064                 warn("%s: can't allocate memory", __func__);
2065                 return (1);
2066         }
2067
2068         datalen = 64;
2069         dataptr = (uint8_t *)malloc(datalen);
2070         if (dataptr == NULL) {
2071                 warn("%s: can't allocate %d bytes", __func__, datalen);
2072                 retval = 1;
2073                 goto bailout;
2074         }
2075
2076         memset(dataptr, 0, datalen);
2077
2078         ctl_scsi_maintenance_in(/*io*/ io,
2079                                 /*data_ptr*/ dataptr,
2080                                 /*data_len*/ datalen,
2081                                 /*action*/ SA_RPRT_TRGT_GRP,
2082                                 /*tag_type*/ CTL_TAG_SIMPLE,
2083                                 /*control*/ 0);
2084
2085         io->io_hdr.nexus.targ_lun = lun;
2086         io->io_hdr.nexus.initid = iid;
2087
2088         if (cctl_do_io(fd, 0, io, __func__) != 0) {
2089                 retval = 1;
2090                 goto bailout;
2091         }
2092
2093         if ((io->io_hdr.status & CTL_STATUS_MASK) == CTL_SUCCESS) {
2094                 int returned_len, used_len;
2095
2096                 returned_len = scsi_4btoul(&dataptr[0]) + 4;
2097
2098                 for (used_len = 0; used_len < returned_len; used_len++) {
2099                         fprintf(stdout, "0x%02x ", dataptr[used_len]);
2100                         if (((used_len+1) % 8) == 0)
2101                                 fprintf(stdout, "\n");
2102                 }
2103                 fprintf(stdout, "\n");
2104         } else
2105                 ctl_io_error_print(io, NULL, stderr);
2106
2107 bailout:
2108         ctl_scsi_free_io(io);
2109
2110         if (dataptr != NULL)
2111                 free(dataptr);
2112
2113         return (retval);
2114 }
2115
2116 static int
2117 cctl_inquiry_vpd_devid(int fd, int lun, int iid)
2118 {
2119         union ctl_io *io;
2120         uint32_t datalen;
2121         uint8_t *dataptr;
2122         int retval;
2123
2124         retval = 0;
2125         dataptr = NULL;
2126
2127         io = ctl_scsi_alloc_io(iid);
2128         if (io == NULL) {
2129                 warn("%s: can't allocate memory", __func__);
2130                 return (1);
2131         }
2132
2133         datalen = 256;
2134         dataptr = (uint8_t *)malloc(datalen);
2135         if (dataptr == NULL) {
2136                 warn("%s: can't allocate %d bytes", __func__, datalen);
2137                 retval = 1;
2138                 goto bailout;
2139         }
2140
2141         memset(dataptr, 0, datalen);
2142
2143         ctl_scsi_inquiry(/*io*/        io,
2144                          /*data_ptr*/  dataptr,
2145                          /*data_len*/  datalen,
2146                          /*byte2*/     SI_EVPD,
2147                          /*page_code*/ SVPD_DEVICE_ID,
2148                          /*tag_type*/  CTL_TAG_SIMPLE,
2149                          /*control*/   0);
2150
2151         io->io_hdr.nexus.targ_lun = lun;
2152         io->io_hdr.nexus.initid = iid;
2153
2154         if (cctl_do_io(fd, 0, io, __func__) != 0) {
2155                 retval = 1;
2156                 goto bailout;
2157         }
2158
2159         if ((io->io_hdr.status & CTL_STATUS_MASK) == CTL_SUCCESS) {
2160                 int returned_len, used_len;
2161
2162                 returned_len = scsi_2btoul(&dataptr[2]) + 4;
2163
2164                 for (used_len = 0; used_len < returned_len; used_len++) {
2165                         fprintf(stdout, "0x%02x ", dataptr[used_len]);
2166                         if (((used_len+1) % 8) == 0)
2167                                 fprintf(stdout, "\n");
2168                 }
2169                 fprintf(stdout, "\n");
2170         } else
2171                 ctl_io_error_print(io, NULL, stderr);
2172
2173 bailout:
2174         ctl_scsi_free_io(io);
2175
2176         if (dataptr != NULL)
2177                 free(dataptr);
2178
2179         return (retval);
2180 }
2181
2182 static int
2183 cctl_persistent_reserve_in(int fd, int lun, int iid,
2184                            int argc, char **argv, char *combinedopt,
2185                            int retry_count)
2186 {
2187         union ctl_io *io;
2188         uint32_t datalen;
2189         uint8_t *dataptr;
2190         int action = -1;
2191         int retval;
2192         int c;
2193
2194         retval = 0;
2195         dataptr = NULL;
2196
2197         io = ctl_scsi_alloc_io(iid);
2198         if (io == NULL) {
2199                 warn("%s: can't allocate memory", __func__);
2200                 return (1);
2201         }
2202
2203         while ((c = getopt(argc, argv, combinedopt)) != -1) {
2204                 switch (c) {
2205                 case 'a':
2206                         action = strtol(optarg, NULL, 0);
2207                         break;
2208                 default:
2209                         break;
2210                 }
2211         }
2212
2213         if (action < 0 || action > 2) {
2214                 warn("action must be specified and in the range: 0-2");
2215                 retval = 1;
2216                 goto bailout;
2217         }
2218
2219
2220         datalen = 256;
2221         dataptr = (uint8_t *)malloc(datalen);
2222         if (dataptr == NULL) {
2223                 warn("%s: can't allocate %d bytes", __func__, datalen);
2224                 retval = 1;
2225                 goto bailout;
2226         }
2227
2228         memset(dataptr, 0, datalen);
2229
2230         ctl_scsi_persistent_res_in(io,
2231                                    /*data_ptr*/ dataptr,
2232                                    /*data_len*/ datalen,
2233                                    /*action*/   action,
2234                                    /*tag_type*/ CTL_TAG_SIMPLE,
2235                                    /*control*/  0);
2236
2237         io->io_hdr.nexus.targ_lun = lun;
2238         io->io_hdr.nexus.initid = iid;
2239
2240         if (cctl_do_io(fd, retry_count, io, __func__) != 0) {
2241                 retval = 1;
2242                 goto bailout;
2243         }
2244
2245         if ((io->io_hdr.status & CTL_STATUS_MASK) == CTL_SUCCESS) {
2246                 int returned_len, used_len;
2247
2248                 switch (action) {
2249                 case 0:
2250                         returned_len = scsi_4btoul(&dataptr[4]) + 8;
2251                         returned_len = min(returned_len, 256);
2252                         break;
2253                 case 1:
2254                         returned_len = scsi_4btoul(&dataptr[4]) + 8;
2255                         break;
2256                 case 2:
2257                         returned_len = 8;
2258                         break;
2259                 default:
2260                         warnx("%s: invalid action %d", __func__, action);
2261                         goto bailout;
2262                         break; /* NOTREACHED */
2263                 }
2264
2265                 for (used_len = 0; used_len < returned_len; used_len++) {
2266                         fprintf(stdout, "0x%02x ", dataptr[used_len]);
2267                         if (((used_len+1) % 8) == 0)
2268                                 fprintf(stdout, "\n");
2269                 }
2270                 fprintf(stdout, "\n");
2271         } else
2272                 ctl_io_error_print(io, NULL, stderr);
2273
2274 bailout:
2275         ctl_scsi_free_io(io);
2276
2277         if (dataptr != NULL)
2278                 free(dataptr);
2279
2280         return (retval);
2281 }
2282
2283 static int
2284 cctl_persistent_reserve_out(int fd, int lun, int iid,
2285                             int argc, char **argv, char *combinedopt,
2286                             int retry_count)
2287 {
2288         union ctl_io *io;
2289         uint32_t datalen;
2290         uint64_t key = 0, sa_key = 0;
2291         int action = -1, restype = -1;
2292         uint8_t *dataptr;
2293         int retval;
2294         int c;
2295
2296         retval = 0;
2297         dataptr = NULL;
2298
2299         io = ctl_scsi_alloc_io(iid);
2300         if (io == NULL) {
2301                 warn("%s: can't allocate memory", __func__);
2302                 return (1);
2303         }
2304
2305         while ((c = getopt(argc, argv, combinedopt)) != -1) {
2306                 switch (c) {
2307                 case 'a':
2308                         action = strtol(optarg, NULL, 0);
2309                         break;
2310                 case 'k':
2311                         key = strtoull(optarg, NULL, 0);
2312                         break;
2313                 case 'r':
2314                         restype = strtol(optarg, NULL, 0);
2315                         break;
2316                 case 's':
2317                         sa_key = strtoull(optarg, NULL, 0);
2318                         break;
2319                 default:
2320                         break;
2321                 }
2322         }
2323         if (action < 0 || action > 5) {
2324                 warn("action must be specified and in the range: 0-5");
2325                 retval = 1;
2326                 goto bailout;
2327         }
2328
2329         if (restype < 0 || restype > 5) {
2330                 if (action != 0 && action != 5 && action != 3) {
2331                         warn("'restype' must specified and in the range: 0-5");
2332                         retval = 1;
2333                         goto bailout;
2334                 }
2335         }
2336
2337         datalen = 24;
2338         dataptr = (uint8_t *)malloc(datalen);
2339         if (dataptr == NULL) {
2340                 warn("%s: can't allocate %d bytes", __func__, datalen);
2341                 retval = 1;
2342                 goto bailout;
2343         }
2344
2345         memset(dataptr, 0, datalen);
2346
2347         ctl_scsi_persistent_res_out(io,
2348                                     /*data_ptr*/ dataptr,
2349                                     /*data_len*/ datalen,
2350                                     /*action*/   action,
2351                                     /*type*/     restype,
2352                                     /*key*/      key,
2353                                     /*sa key*/   sa_key,
2354                                     /*tag_type*/ CTL_TAG_SIMPLE,
2355                                     /*control*/  0);
2356
2357         io->io_hdr.nexus.targ_lun = lun;
2358         io->io_hdr.nexus.initid = iid;
2359
2360         if (cctl_do_io(fd, retry_count, io, __func__) != 0) {
2361                 retval = 1;
2362                 goto bailout;
2363         }
2364         if ((io->io_hdr.status & CTL_STATUS_MASK) == CTL_SUCCESS) {
2365                 char scsi_path[40];
2366                 ctl_scsi_path_string(io, scsi_path, sizeof(scsi_path));
2367                 fprintf( stdout, "%sPERSISTENT RESERVE OUT executed "
2368                         "successfully\n", scsi_path);
2369         } else
2370                 ctl_io_error_print(io, NULL, stderr);
2371
2372 bailout:
2373         ctl_scsi_free_io(io);
2374
2375         if (dataptr != NULL)
2376                 free(dataptr);
2377
2378         return (retval);
2379 }
2380
2381 static int
2382 cctl_create_lun(int fd, int argc, char **argv, char *combinedopt)
2383 {
2384         struct ctl_lun_req req;
2385         int device_type = -1;
2386         uint64_t lun_size = 0;
2387         uint32_t blocksize = 0, req_lun_id = 0;
2388         char *serial_num = NULL;
2389         char *device_id = NULL;
2390         int lun_size_set = 0, blocksize_set = 0, lun_id_set = 0;
2391         char *backend_name = NULL;
2392         nvlist_t *option_list;
2393         int retval = 0, c;
2394
2395         option_list = nvlist_create(0);
2396         if (option_list == NULL)
2397                 err(1, "%s: unable to allocate nvlist", __func__);
2398
2399         while ((c = getopt(argc, argv, combinedopt)) != -1) {
2400                 switch (c) {
2401                 case 'b':
2402                         backend_name = strdup(optarg);
2403                         break;
2404                 case 'B':
2405                         blocksize = strtoul(optarg, NULL, 0);
2406                         blocksize_set = 1;
2407                         break;
2408                 case 'd':
2409                         device_id = strdup(optarg);
2410                         break;
2411                 case 'l':
2412                         req_lun_id = strtoul(optarg, NULL, 0);
2413                         lun_id_set = 1;
2414                         break;
2415                 case 'o': {
2416                         char *tmpstr;
2417                         char *name, *value;
2418
2419                         tmpstr = strdup(optarg);
2420                         name = strsep(&tmpstr, "=");
2421                         if (name == NULL) {
2422                                 warnx("%s: option -o takes \"name=value\""
2423                                       "argument", __func__);
2424                                 retval = 1;
2425                                 goto bailout;
2426                         }
2427                         value = strsep(&tmpstr, "=");
2428                         if (value == NULL) {
2429                                 warnx("%s: option -o takes \"name=value\""
2430                                       "argument", __func__);
2431                                 retval = 1;
2432                                 goto bailout;
2433                         }
2434                         free(tmpstr);
2435                         nvlist_add_string(option_list, name, value);
2436                         break;
2437                 }
2438                 case 's':
2439                         if (strcasecmp(optarg, "auto") != 0) {
2440                                 retval = expand_number(optarg, &lun_size);
2441                                 if (retval != 0) {
2442                                         warn("%s: invalid -s argument",
2443                                             __func__);
2444                                         retval = 1;
2445                                         goto bailout;
2446                                 }
2447                         }
2448                         lun_size_set = 1;
2449                         break;
2450                 case 'S':
2451                         serial_num = strdup(optarg);
2452                         break;
2453                 case 't':
2454                         device_type = strtoul(optarg, NULL, 0);
2455                         break;
2456                 default:
2457                         break;
2458                 }
2459         }
2460
2461         if (backend_name == NULL) {
2462                 warnx("%s: backend name (-b) must be specified", __func__);
2463                 retval = 1;
2464                 goto bailout;
2465         }
2466
2467         bzero(&req, sizeof(req));
2468
2469         strlcpy(req.backend, backend_name, sizeof(req.backend));
2470         req.reqtype = CTL_LUNREQ_CREATE;
2471
2472         if (blocksize_set != 0)
2473                 req.reqdata.create.blocksize_bytes = blocksize;
2474
2475         if (lun_size_set != 0)
2476                 req.reqdata.create.lun_size_bytes = lun_size;
2477
2478         if (lun_id_set != 0) {
2479                 req.reqdata.create.flags |= CTL_LUN_FLAG_ID_REQ;
2480                 req.reqdata.create.req_lun_id = req_lun_id;
2481         }
2482
2483         req.reqdata.create.flags |= CTL_LUN_FLAG_DEV_TYPE;
2484
2485         if (device_type != -1)
2486                 req.reqdata.create.device_type = device_type;
2487         else
2488                 req.reqdata.create.device_type = T_DIRECT;
2489
2490         if (serial_num != NULL) {
2491                 strlcpy(req.reqdata.create.serial_num, serial_num,
2492                         sizeof(req.reqdata.create.serial_num));
2493                 req.reqdata.create.flags |= CTL_LUN_FLAG_SERIAL_NUM;
2494         }
2495
2496         if (device_id != NULL) {
2497                 strlcpy(req.reqdata.create.device_id, device_id,
2498                         sizeof(req.reqdata.create.device_id));
2499                 req.reqdata.create.flags |= CTL_LUN_FLAG_DEVID;
2500         }
2501
2502         req.args = nvlist_pack(option_list, &req.args_len);
2503         if (req.args == NULL) {
2504                 warn("%s: error packing nvlist", __func__);
2505                 retval = 1;
2506                 goto bailout;
2507         }
2508
2509         retval = ioctl(fd, CTL_LUN_REQ, &req);
2510         free(req.args);
2511         if (retval == -1) {
2512                 warn("%s: error issuing CTL_LUN_REQ ioctl", __func__);
2513                 retval = 1;
2514                 goto bailout;
2515         }
2516
2517         switch (req.status) {
2518         case CTL_LUN_ERROR:
2519                 warnx("LUN creation error: %s", req.error_str);
2520                 retval = 1;
2521                 goto bailout;
2522         case CTL_LUN_WARNING:
2523                 warnx("LUN creation warning: %s", req.error_str);
2524                 break;
2525         case CTL_LUN_OK:
2526                 break;
2527         default:
2528                 warnx("unknown LUN creation status: %d", req.status);
2529                 retval = 1;
2530                 goto bailout;
2531         }
2532
2533         fprintf(stdout, "LUN created successfully\n");
2534         fprintf(stdout, "backend:       %s\n", req.backend);
2535         fprintf(stdout, "device type:   %d\n",req.reqdata.create.device_type);
2536         fprintf(stdout, "LUN size:      %ju bytes\n",
2537                 (uintmax_t)req.reqdata.create.lun_size_bytes);
2538         fprintf(stdout, "blocksize      %u bytes\n",
2539                 req.reqdata.create.blocksize_bytes);
2540         fprintf(stdout, "LUN ID:        %d\n", req.reqdata.create.req_lun_id);
2541         fprintf(stdout, "Serial Number: %s\n", req.reqdata.create.serial_num);
2542         fprintf(stdout, "Device ID:     %s\n", req.reqdata.create.device_id);
2543
2544 bailout:
2545         nvlist_destroy(option_list);
2546         return (retval);
2547 }
2548
2549 static int
2550 cctl_rm_lun(int fd, int argc, char **argv, char *combinedopt)
2551 {
2552         struct ctl_lun_req req;
2553         uint32_t lun_id = 0;
2554         int lun_id_set = 0;
2555         char *backend_name = NULL;
2556         nvlist_t *option_list;
2557         int retval = 0, c;
2558
2559         option_list = nvlist_create(0);
2560         if (option_list == NULL)
2561                 err(1, "%s: unable to allocate nvlist", __func__);
2562
2563         while ((c = getopt(argc, argv, combinedopt)) != -1) {
2564                 switch (c) {
2565                 case 'b':
2566                         backend_name = strdup(optarg);
2567                         break;
2568                 case 'l':
2569                         lun_id = strtoul(optarg, NULL, 0);
2570                         lun_id_set = 1;
2571                         break;
2572                 case 'o': {
2573                         char *tmpstr;
2574                         char *name, *value;
2575
2576                         tmpstr = strdup(optarg);
2577                         name = strsep(&tmpstr, "=");
2578                         if (name == NULL) {
2579                                 warnx("%s: option -o takes \"name=value\""
2580                                       "argument", __func__);
2581                                 retval = 1;
2582                                 goto bailout;
2583                         }
2584                         value = strsep(&tmpstr, "=");
2585                         if (value == NULL) {
2586                                 warnx("%s: option -o takes \"name=value\""
2587                                       "argument", __func__);
2588                                 retval = 1;
2589                                 goto bailout;
2590                         }
2591                         free(tmpstr);
2592                         nvlist_add_string(option_list, name, value);
2593                         break;
2594                 }
2595                 default:
2596                         break;
2597                 }
2598         }
2599
2600         if (backend_name == NULL)
2601                 errx(1, "%s: backend name (-b) must be specified", __func__);
2602
2603         if (lun_id_set == 0)
2604                 errx(1, "%s: LUN id (-l) must be specified", __func__);
2605
2606         bzero(&req, sizeof(req));
2607
2608         strlcpy(req.backend, backend_name, sizeof(req.backend));
2609         req.reqtype = CTL_LUNREQ_RM;
2610
2611         req.reqdata.rm.lun_id = lun_id;
2612
2613         req.args = nvlist_pack(option_list, &req.args_len);
2614         if (req.args == NULL) {
2615                 warn("%s: error packing nvlist", __func__);
2616                 retval = 1;
2617                 goto bailout;
2618         }
2619
2620         retval = ioctl(fd, CTL_LUN_REQ, &req);
2621         free(req.args);
2622         if (retval == -1) {
2623                 warn("%s: error issuing CTL_LUN_REQ ioctl", __func__);
2624                 retval = 1;
2625                 goto bailout;
2626         }
2627
2628         switch (req.status) {
2629         case CTL_LUN_ERROR:
2630                 warnx("LUN removal error: %s", req.error_str);
2631                 retval = 1;
2632                 goto bailout;
2633         case CTL_LUN_WARNING:
2634                 warnx("LUN removal warning: %s", req.error_str);
2635                 break;
2636         case CTL_LUN_OK:
2637                 break;
2638         default:
2639                 warnx("unknown LUN removal status: %d", req.status);
2640                 retval = 1;
2641                 goto bailout;
2642         }
2643
2644         printf("LUN %d removed successfully\n", lun_id);
2645
2646 bailout:
2647         nvlist_destroy(option_list);
2648         return (retval);
2649 }
2650
2651 static int
2652 cctl_modify_lun(int fd, int argc, char **argv, char *combinedopt)
2653 {
2654         struct ctl_lun_req req;
2655         uint64_t lun_size = 0;
2656         uint32_t lun_id = 0;
2657         int lun_id_set = 0, lun_size_set = 0;
2658         char *backend_name = NULL;
2659         nvlist_t *option_list;
2660         int retval = 0, c;
2661
2662         option_list = nvlist_create(0);
2663         if (option_list == NULL)
2664                 err(1, "%s: unable to allocate nvlist", __func__);
2665
2666         while ((c = getopt(argc, argv, combinedopt)) != -1) {
2667                 switch (c) {
2668                 case 'b':
2669                         backend_name = strdup(optarg);
2670                         break;
2671                 case 'l':
2672                         lun_id = strtoul(optarg, NULL, 0);
2673                         lun_id_set = 1;
2674                         break;
2675                 case 'o': {
2676                         char *tmpstr;
2677                         char *name, *value;
2678
2679                         tmpstr = strdup(optarg);
2680                         name = strsep(&tmpstr, "=");
2681                         if (name == NULL) {
2682                                 warnx("%s: option -o takes \"name=value\""
2683                                       "argument", __func__);
2684                                 retval = 1;
2685                                 goto bailout;
2686                         }
2687                         value = strsep(&tmpstr, "=");
2688                         if (value == NULL) {
2689                                 warnx("%s: option -o takes \"name=value\""
2690                                       "argument", __func__);
2691                                 retval = 1;
2692                                 goto bailout;
2693                         }
2694                         free(tmpstr);
2695                         nvlist_add_string(option_list, name, value);
2696                         break;
2697                 }
2698                 case 's':
2699                         if (strcasecmp(optarg, "auto") != 0) {
2700                                 retval = expand_number(optarg, &lun_size);
2701                                 if (retval != 0) {
2702                                         warn("%s: invalid -s argument",
2703                                             __func__);
2704                                         retval = 1;
2705                                         goto bailout;
2706                                 }
2707                         }
2708                         lun_size_set = 1;
2709                         break;
2710                 default:
2711                         break;
2712                 }
2713         }
2714
2715         if (backend_name == NULL)
2716                 errx(1, "%s: backend name (-b) must be specified", __func__);
2717
2718         if (lun_id_set == 0)
2719                 errx(1, "%s: LUN id (-l) must be specified", __func__);
2720
2721         if (lun_size_set == 0 && nvlist_empty(option_list))
2722                 errx(1, "%s: size (-s) or options (-o) must be specified",
2723                     __func__);
2724
2725         bzero(&req, sizeof(req));
2726
2727         strlcpy(req.backend, backend_name, sizeof(req.backend));
2728         req.reqtype = CTL_LUNREQ_MODIFY;
2729
2730         req.reqdata.modify.lun_id = lun_id;
2731         req.reqdata.modify.lun_size_bytes = lun_size;
2732
2733         req.args = nvlist_pack(option_list, &req.args_len);
2734         if (req.args == NULL) {
2735                 warn("%s: error packing nvlist", __func__);
2736                 retval = 1;
2737                 goto bailout;
2738         }
2739
2740         retval = ioctl(fd, CTL_LUN_REQ, &req);
2741         free(req.args);
2742         if (retval == -1) {
2743                 warn("%s: error issuing CTL_LUN_REQ ioctl", __func__);
2744                 retval = 1;
2745                 goto bailout;
2746         }
2747
2748         switch (req.status) {
2749         case CTL_LUN_ERROR:
2750                 warnx("LUN modification error: %s", req.error_str);
2751                 retval = 1;
2752                 goto bailout;
2753         case CTL_LUN_WARNING:
2754                 warnx("LUN modification warning: %s", req.error_str);
2755                 break;
2756         case CTL_LUN_OK:
2757                 break;
2758         default:
2759                 warnx("unknown LUN modification status: %d", req.status);
2760                 retval = 1;
2761                 goto bailout;
2762         }
2763
2764         printf("LUN %d modified successfully\n", lun_id);
2765
2766 bailout:
2767         nvlist_destroy(option_list);
2768         return (retval);
2769 }
2770
2771 struct cctl_islist_conn {
2772         int connection_id;
2773         char *initiator;
2774         char *initiator_addr;
2775         char *initiator_alias;
2776         char *target;
2777         char *target_alias;
2778         char *header_digest;
2779         char *data_digest;
2780         char *max_recv_data_segment_length;
2781         char *max_send_data_segment_length;
2782         char *max_burst_length;
2783         char *first_burst_length;
2784         char *offload;
2785         int immediate_data;
2786         int iser;
2787         STAILQ_ENTRY(cctl_islist_conn) links;
2788 };
2789
2790 struct cctl_islist_data {
2791         int num_conns;
2792         STAILQ_HEAD(,cctl_islist_conn) conn_list;
2793         struct cctl_islist_conn *cur_conn;
2794         int level;
2795         struct sbuf *cur_sb[32];
2796 };
2797
2798 static void
2799 cctl_islist_start_element(void *user_data, const char *name, const char **attr)
2800 {
2801         int i;
2802         struct cctl_islist_data *islist;
2803         struct cctl_islist_conn *cur_conn;
2804
2805         islist = (struct cctl_islist_data *)user_data;
2806         cur_conn = islist->cur_conn;
2807         islist->level++;
2808         if ((u_int)islist->level >= (sizeof(islist->cur_sb) /
2809             sizeof(islist->cur_sb[0])))
2810                 errx(1, "%s: too many nesting levels, %zd max", __func__,
2811                      sizeof(islist->cur_sb) / sizeof(islist->cur_sb[0]));
2812
2813         islist->cur_sb[islist->level] = sbuf_new_auto();
2814         if (islist->cur_sb[islist->level] == NULL)
2815                 err(1, "%s: Unable to allocate sbuf", __func__);
2816
2817         if (strcmp(name, "connection") == 0) {
2818                 if (cur_conn != NULL)
2819                         errx(1, "%s: improper connection element nesting",
2820                             __func__);
2821
2822                 cur_conn = calloc(1, sizeof(*cur_conn));
2823                 if (cur_conn == NULL)
2824                         err(1, "%s: cannot allocate %zd bytes", __func__,
2825                             sizeof(*cur_conn));
2826
2827                 islist->num_conns++;
2828                 islist->cur_conn = cur_conn;
2829
2830                 STAILQ_INSERT_TAIL(&islist->conn_list, cur_conn, links);
2831
2832                 for (i = 0; attr[i] != NULL; i += 2) {
2833                         if (strcmp(attr[i], "id") == 0) {
2834                                 cur_conn->connection_id =
2835                                     strtoull(attr[i+1], NULL, 0);
2836                         } else {
2837                                 errx(1,
2838                                     "%s: invalid connection attribute %s = %s",
2839                                      __func__, attr[i], attr[i+1]);
2840                         }
2841                 }
2842         }
2843 }
2844
2845 static void
2846 cctl_islist_end_element(void *user_data, const char *name)
2847 {
2848         struct cctl_islist_data *islist;
2849         struct cctl_islist_conn *cur_conn;
2850         char *str;
2851
2852         islist = (struct cctl_islist_data *)user_data;
2853         cur_conn = islist->cur_conn;
2854
2855         if ((cur_conn == NULL)
2856          && (strcmp(name, "ctlislist") != 0))
2857                 errx(1, "%s: cur_conn == NULL! (name = %s)", __func__, name);
2858
2859         if (islist->cur_sb[islist->level] == NULL)
2860                 errx(1, "%s: no valid sbuf at level %d (name %s)", __func__,
2861                      islist->level, name);
2862
2863         sbuf_finish(islist->cur_sb[islist->level]);
2864         str = strdup(sbuf_data(islist->cur_sb[islist->level]));
2865         if (str == NULL)
2866                 err(1, "%s can't allocate %zd bytes for string", __func__,
2867                     sbuf_len(islist->cur_sb[islist->level]));
2868
2869         sbuf_delete(islist->cur_sb[islist->level]);
2870         islist->cur_sb[islist->level] = NULL;
2871         islist->level--;
2872
2873         if (strcmp(name, "initiator") == 0) {
2874                 cur_conn->initiator = str;
2875                 str = NULL;
2876         } else if (strcmp(name, "initiator_addr") == 0) {
2877                 cur_conn->initiator_addr = str;
2878                 str = NULL;
2879         } else if (strcmp(name, "initiator_alias") == 0) {
2880                 cur_conn->initiator_alias = str;
2881                 str = NULL;
2882         } else if (strcmp(name, "target") == 0) {
2883                 cur_conn->target = str;
2884                 str = NULL;
2885         } else if (strcmp(name, "target_alias") == 0) {
2886                 cur_conn->target_alias = str;
2887                 str = NULL;
2888         } else if (strcmp(name, "target_portal_group_tag") == 0) {
2889         } else if (strcmp(name, "header_digest") == 0) {
2890                 cur_conn->header_digest = str;
2891                 str = NULL;
2892         } else if (strcmp(name, "data_digest") == 0) {
2893                 cur_conn->data_digest = str;
2894                 str = NULL;
2895         } else if (strcmp(name, "max_recv_data_segment_length") == 0) {
2896                 cur_conn->max_recv_data_segment_length = str;
2897                 str = NULL;
2898         } else if (strcmp(name, "max_send_data_segment_length") == 0) {
2899                 cur_conn->max_send_data_segment_length = str;
2900                 str = NULL;
2901         } else if (strcmp(name, "max_burst_length") == 0) {
2902                 cur_conn->max_burst_length = str;
2903                 str = NULL;
2904         } else if (strcmp(name, "first_burst_length") == 0) {
2905                 cur_conn->first_burst_length = str;
2906                 str = NULL;
2907         } else if (strcmp(name, "offload") == 0) {
2908                 cur_conn->offload = str;
2909                 str = NULL;
2910         } else if (strcmp(name, "immediate_data") == 0) {
2911                 cur_conn->immediate_data = atoi(str);
2912         } else if (strcmp(name, "iser") == 0) {
2913                 cur_conn->iser = atoi(str);
2914         } else if (strcmp(name, "connection") == 0) {
2915                 islist->cur_conn = NULL;
2916         } else if (strcmp(name, "ctlislist") == 0) {
2917                 /* Nothing. */
2918         } else {
2919                 /*
2920                  * Unknown element; ignore it for forward compatibility.
2921                  */
2922         }
2923
2924         free(str);
2925 }
2926
2927 static void
2928 cctl_islist_char_handler(void *user_data, const XML_Char *str, int len)
2929 {
2930         struct cctl_islist_data *islist;
2931
2932         islist = (struct cctl_islist_data *)user_data;
2933
2934         sbuf_bcat(islist->cur_sb[islist->level], str, len);
2935 }
2936
2937 static int
2938 cctl_islist(int fd, int argc, char **argv, char *combinedopt)
2939 {
2940         struct ctl_iscsi req;
2941         struct cctl_islist_data islist;
2942         struct cctl_islist_conn *conn;
2943         XML_Parser parser;
2944         char *conn_str;
2945         int conn_len;
2946         int dump_xml = 0;
2947         int c, retval, verbose = 0;
2948
2949         retval = 0;
2950         conn_len = 4096;
2951
2952         bzero(&islist, sizeof(islist));
2953         STAILQ_INIT(&islist.conn_list);
2954
2955         while ((c = getopt(argc, argv, combinedopt)) != -1) {
2956                 switch (c) {
2957                 case 'v':
2958                         verbose = 1;
2959                         break;
2960                 case 'x':
2961                         dump_xml = 1;
2962                         break;
2963                 default:
2964                         break;
2965                 }
2966         }
2967
2968 retry:
2969         conn_str = malloc(conn_len);
2970
2971         bzero(&req, sizeof(req));
2972         req.type = CTL_ISCSI_LIST;
2973         req.data.list.alloc_len = conn_len;
2974         req.data.list.conn_xml = conn_str;
2975
2976         if (ioctl(fd, CTL_ISCSI, &req) == -1) {
2977                 warn("%s: error issuing CTL_ISCSI ioctl", __func__);
2978                 retval = 1;
2979                 goto bailout;
2980         }
2981
2982         if (req.status == CTL_ISCSI_ERROR) {
2983                 warnx("%s: error returned from CTL_ISCSI ioctl:\n%s",
2984                       __func__, req.error_str);
2985         } else if (req.status == CTL_ISCSI_LIST_NEED_MORE_SPACE) {
2986                 conn_len = conn_len << 1;
2987                 goto retry;
2988         }
2989
2990         if (dump_xml != 0) {
2991                 printf("%s", conn_str);
2992                 goto bailout;
2993         }
2994
2995         parser = XML_ParserCreate(NULL);
2996         if (parser == NULL) {
2997                 warn("%s: Unable to create XML parser", __func__);
2998                 retval = 1;
2999                 goto bailout;
3000         }
3001
3002         XML_SetUserData(parser, &islist);
3003         XML_SetElementHandler(parser, cctl_islist_start_element,
3004             cctl_islist_end_element);
3005         XML_SetCharacterDataHandler(parser, cctl_islist_char_handler);
3006
3007         retval = XML_Parse(parser, conn_str, strlen(conn_str), 1);
3008         if (retval != 1) {
3009                 warnx("%s: Unable to parse XML: Error %d", __func__,
3010                     XML_GetErrorCode(parser));
3011                 XML_ParserFree(parser);
3012                 retval = 1;
3013                 goto bailout;
3014         }
3015         retval = 0;
3016         XML_ParserFree(parser);
3017
3018         if (verbose != 0) {
3019                 STAILQ_FOREACH(conn, &islist.conn_list, links) {
3020                         printf("%-25s %d\n", "Session ID:", conn->connection_id);
3021                         printf("%-25s %s\n", "Initiator name:", conn->initiator);
3022                         printf("%-25s %s\n", "Initiator portal:", conn->initiator_addr);
3023                         printf("%-25s %s\n", "Initiator alias:", conn->initiator_alias);
3024                         printf("%-25s %s\n", "Target name:", conn->target);
3025                         printf("%-25s %s\n", "Target alias:", conn->target_alias);
3026                         printf("%-25s %s\n", "Header digest:", conn->header_digest);
3027                         printf("%-25s %s\n", "Data digest:", conn->data_digest);
3028                         printf("%-25s %s\n", "MaxRecvDataSegmentLength:", conn->max_recv_data_segment_length);
3029                         printf("%-25s %s\n", "MaxSendDataSegmentLength:", conn->max_send_data_segment_length);
3030                         printf("%-25s %s\n", "MaxBurstLen:", conn->max_burst_length);
3031                         printf("%-25s %s\n", "FirstBurstLen:", conn->first_burst_length);
3032                         printf("%-25s %s\n", "ImmediateData:", conn->immediate_data ? "Yes" : "No");
3033                         printf("%-25s %s\n", "iSER (RDMA):", conn->iser ? "Yes" : "No");
3034                         printf("%-25s %s\n", "Offload driver:", conn->offload);
3035                         printf("\n");
3036                 }
3037         } else {
3038                 printf("%4s %-16s %-36s %-36s\n", "ID", "Portal", "Initiator name",
3039                     "Target name");
3040                 STAILQ_FOREACH(conn, &islist.conn_list, links) {
3041                         printf("%4u %-16s %-36s %-36s\n",
3042                             conn->connection_id, conn->initiator_addr, conn->initiator,
3043                             conn->target);
3044                 }
3045         }
3046 bailout:
3047         free(conn_str);
3048
3049         return (retval);
3050 }
3051
3052 static int
3053 cctl_islogout(int fd, int argc, char **argv, char *combinedopt)
3054 {
3055         struct ctl_iscsi req;
3056         int retval = 0, c;
3057         int all = 0, connection_id = -1, nargs = 0;
3058         char *initiator_name = NULL, *initiator_addr = NULL;
3059
3060         while ((c = getopt(argc, argv, combinedopt)) != -1) {
3061                 switch (c) {
3062                 case 'a':
3063                         all = 1;
3064                         nargs++;
3065                         break;
3066                 case 'c':
3067                         connection_id = strtoul(optarg, NULL, 0);
3068                         nargs++;
3069                         break;
3070                 case 'i':
3071                         initiator_name = strdup(optarg);
3072                         if (initiator_name == NULL)
3073                                 err(1, "%s: strdup", __func__);
3074                         nargs++;
3075                         break;
3076                 case 'p':
3077                         initiator_addr = strdup(optarg);
3078                         if (initiator_addr == NULL)
3079                                 err(1, "%s: strdup", __func__);
3080                         nargs++;
3081                         break;
3082                 default:
3083                         break;
3084                 }
3085         }
3086
3087         if (nargs == 0)
3088                 errx(1, "%s: either -a, -c, -i, or -p must be specified",
3089                     __func__);
3090         if (nargs > 1)
3091                 errx(1, "%s: only one of -a, -c, -i, or -p may be specified",
3092                     __func__);
3093
3094         bzero(&req, sizeof(req));
3095         req.type = CTL_ISCSI_LOGOUT;
3096         req.data.logout.connection_id = connection_id;
3097         if (initiator_addr != NULL)
3098                 strlcpy(req.data.logout.initiator_addr,
3099                     initiator_addr, sizeof(req.data.logout.initiator_addr));
3100         if (initiator_name != NULL)
3101                 strlcpy(req.data.logout.initiator_name,
3102                     initiator_name, sizeof(req.data.logout.initiator_name));
3103         if (all != 0)
3104                 req.data.logout.all = 1;
3105
3106         if (ioctl(fd, CTL_ISCSI, &req) == -1) {
3107                 warn("%s: error issuing CTL_ISCSI ioctl", __func__);
3108                 retval = 1;
3109                 goto bailout;
3110         }
3111
3112         if (req.status != CTL_ISCSI_OK) {
3113                 warnx("%s: error returned from CTL iSCSI logout request:\n%s",
3114                       __func__, req.error_str);
3115                 retval = 1;
3116                 goto bailout;
3117         }
3118
3119         printf("iSCSI logout requests submitted\n");
3120
3121 bailout:
3122         return (retval);
3123 }
3124
3125 static int
3126 cctl_isterminate(int fd, int argc, char **argv, char *combinedopt)
3127 {
3128         struct ctl_iscsi req;
3129         int retval = 0, c;
3130         int all = 0, connection_id = -1, nargs = 0;
3131         char *initiator_name = NULL, *initiator_addr = NULL;
3132
3133         while ((c = getopt(argc, argv, combinedopt)) != -1) {
3134                 switch (c) {
3135                 case 'a':
3136                         all = 1;
3137                         nargs++;
3138                         break;
3139                 case 'c':
3140                         connection_id = strtoul(optarg, NULL, 0);
3141                         nargs++;
3142                         break;
3143                 case 'i':
3144                         initiator_name = strdup(optarg);
3145                         if (initiator_name == NULL)
3146                                 err(1, "%s: strdup", __func__);
3147                         nargs++;
3148                         break;
3149                 case 'p':
3150                         initiator_addr = strdup(optarg);
3151                         if (initiator_addr == NULL)
3152                                 err(1, "%s: strdup", __func__);
3153                         nargs++;
3154                         break;
3155                 default:
3156                         break;
3157                 }
3158         }
3159
3160         if (nargs == 0)
3161                 errx(1, "%s: either -a, -c, -i, or -p must be specified",
3162                     __func__);
3163         if (nargs > 1)
3164                 errx(1, "%s: only one of -a, -c, -i, or -p may be specified",
3165                     __func__);
3166
3167         bzero(&req, sizeof(req));
3168         req.type = CTL_ISCSI_TERMINATE;
3169         req.data.terminate.connection_id = connection_id;
3170         if (initiator_addr != NULL)
3171                 strlcpy(req.data.terminate.initiator_addr,
3172                     initiator_addr, sizeof(req.data.terminate.initiator_addr));
3173         if (initiator_name != NULL)
3174                 strlcpy(req.data.terminate.initiator_name,
3175                     initiator_name, sizeof(req.data.terminate.initiator_name));
3176         if (all != 0)
3177                 req.data.terminate.all = 1;
3178
3179         if (ioctl(fd, CTL_ISCSI, &req) == -1) {
3180                 warn("%s: error issuing CTL_ISCSI ioctl", __func__);
3181                 retval = 1;
3182                 goto bailout;
3183         }
3184
3185         if (req.status != CTL_ISCSI_OK) {
3186                 warnx("%s: error returned from CTL iSCSI connection "
3187                     "termination request:\n%s", __func__, req.error_str);
3188                 retval = 1;
3189                 goto bailout;
3190         }
3191
3192         printf("iSCSI connections terminated\n");
3193
3194 bailout:
3195         return (retval);
3196 }
3197
3198 /*
3199  * Name/value pair used for per-LUN attributes.
3200  */
3201 struct cctl_lun_nv {
3202         char *name;
3203         char *value;
3204         STAILQ_ENTRY(cctl_lun_nv) links;
3205 };
3206
3207 /*
3208  * Backend LUN information.
3209  */
3210 struct cctl_lun {
3211         uint64_t lun_id;
3212         char *backend_type;
3213         uint64_t size_blocks;
3214         uint32_t blocksize;
3215         char *serial_number;
3216         char *device_id;
3217         STAILQ_HEAD(,cctl_lun_nv) attr_list;
3218         STAILQ_ENTRY(cctl_lun) links;
3219 };
3220
3221 struct cctl_devlist_data {
3222         int num_luns;
3223         STAILQ_HEAD(,cctl_lun) lun_list;
3224         struct cctl_lun *cur_lun;
3225         int level;
3226         struct sbuf *cur_sb[32];
3227 };
3228
3229 static void
3230 cctl_start_element(void *user_data, const char *name, const char **attr)
3231 {
3232         int i;
3233         struct cctl_devlist_data *devlist;
3234         struct cctl_lun *cur_lun;
3235
3236         devlist = (struct cctl_devlist_data *)user_data;
3237         cur_lun = devlist->cur_lun;
3238         devlist->level++;
3239         if ((u_int)devlist->level >= (sizeof(devlist->cur_sb) /
3240             sizeof(devlist->cur_sb[0])))
3241                 errx(1, "%s: too many nesting levels, %zd max", __func__,
3242                      sizeof(devlist->cur_sb) / sizeof(devlist->cur_sb[0]));
3243
3244         devlist->cur_sb[devlist->level] = sbuf_new_auto();
3245         if (devlist->cur_sb[devlist->level] == NULL)
3246                 err(1, "%s: Unable to allocate sbuf", __func__);
3247
3248         if (strcmp(name, "lun") == 0) {
3249                 if (cur_lun != NULL)
3250                         errx(1, "%s: improper lun element nesting", __func__);
3251
3252                 cur_lun = calloc(1, sizeof(*cur_lun));
3253                 if (cur_lun == NULL)
3254                         err(1, "%s: cannot allocate %zd bytes", __func__,
3255                             sizeof(*cur_lun));
3256
3257                 devlist->num_luns++;
3258                 devlist->cur_lun = cur_lun;
3259
3260                 STAILQ_INIT(&cur_lun->attr_list);
3261                 STAILQ_INSERT_TAIL(&devlist->lun_list, cur_lun, links);
3262
3263                 for (i = 0; attr[i] != NULL; i += 2) {
3264                         if (strcmp(attr[i], "id") == 0) {
3265                                 cur_lun->lun_id = strtoull(attr[i+1], NULL, 0);
3266                         } else {
3267                                 errx(1, "%s: invalid LUN attribute %s = %s",
3268                                      __func__, attr[i], attr[i+1]);
3269                         }
3270                 }
3271         }
3272 }
3273
3274 static void
3275 cctl_end_element(void *user_data, const char *name)
3276 {
3277         struct cctl_devlist_data *devlist;
3278         struct cctl_lun *cur_lun;
3279         char *str;
3280
3281         devlist = (struct cctl_devlist_data *)user_data;
3282         cur_lun = devlist->cur_lun;
3283
3284         if ((cur_lun == NULL)
3285          && (strcmp(name, "ctllunlist") != 0))
3286                 errx(1, "%s: cur_lun == NULL! (name = %s)", __func__, name);
3287
3288         if (devlist->cur_sb[devlist->level] == NULL)
3289                 errx(1, "%s: no valid sbuf at level %d (name %s)", __func__,
3290                      devlist->level, name);
3291
3292         if (sbuf_finish(devlist->cur_sb[devlist->level]) != 0)
3293                 err(1, "%s: sbuf_finish", __func__);
3294         str = strdup(sbuf_data(devlist->cur_sb[devlist->level]));
3295         if (str == NULL)
3296                 err(1, "%s can't allocate %zd bytes for string", __func__,
3297                     sbuf_len(devlist->cur_sb[devlist->level]));
3298
3299         if (strlen(str) == 0) {
3300                 free(str);
3301                 str = NULL;
3302         }
3303
3304         sbuf_delete(devlist->cur_sb[devlist->level]);
3305         devlist->cur_sb[devlist->level] = NULL;
3306         devlist->level--;
3307
3308         if (strcmp(name, "backend_type") == 0) {
3309                 cur_lun->backend_type = str;
3310                 str = NULL;
3311         } else if (strcmp(name, "size") == 0) {
3312                 cur_lun->size_blocks = strtoull(str, NULL, 0);
3313         } else if (strcmp(name, "blocksize") == 0) {
3314                 cur_lun->blocksize = strtoul(str, NULL, 0);
3315         } else if (strcmp(name, "serial_number") == 0) {
3316                 cur_lun->serial_number = str;
3317                 str = NULL;
3318         } else if (strcmp(name, "device_id") == 0) {
3319                 cur_lun->device_id = str;
3320                 str = NULL;
3321         } else if (strcmp(name, "lun") == 0) {
3322                 devlist->cur_lun = NULL;
3323         } else if (strcmp(name, "ctllunlist") == 0) {
3324                 /* Nothing. */
3325         } else {
3326                 struct cctl_lun_nv *nv;
3327
3328                 nv = calloc(1, sizeof(*nv));
3329                 if (nv == NULL)
3330                         err(1, "%s: can't allocate %zd bytes for nv pair",
3331                             __func__, sizeof(*nv));
3332
3333                 nv->name = strdup(name);
3334                 if (nv->name == NULL)
3335                         err(1, "%s: can't allocated %zd bytes for string",
3336                             __func__, strlen(name));
3337
3338                 nv->value = str;
3339                 str = NULL;
3340                 STAILQ_INSERT_TAIL(&cur_lun->attr_list, nv, links);
3341         }
3342
3343         free(str);
3344 }
3345
3346 static void
3347 cctl_char_handler(void *user_data, const XML_Char *str, int len)
3348 {
3349         struct cctl_devlist_data *devlist;
3350
3351         devlist = (struct cctl_devlist_data *)user_data;
3352
3353         sbuf_bcat(devlist->cur_sb[devlist->level], str, len);
3354 }
3355
3356 static int
3357 cctl_devlist(int fd, int argc, char **argv, char *combinedopt)
3358 {
3359         struct ctl_lun_list list;
3360         struct cctl_devlist_data devlist;
3361         struct cctl_lun *lun;
3362         XML_Parser parser;
3363         char *lun_str;
3364         int lun_len;
3365         int dump_xml = 0;
3366         int retval, c;
3367         char *backend = NULL;
3368         int verbose = 0;
3369
3370         retval = 0;
3371         lun_len = 4096;
3372
3373         bzero(&devlist, sizeof(devlist));
3374         STAILQ_INIT(&devlist.lun_list);
3375
3376         while ((c = getopt(argc, argv, combinedopt)) != -1) {
3377                 switch (c) {
3378                 case 'b':
3379                         backend = strdup(optarg);
3380                         break;
3381                 case 'v':
3382                         verbose++;
3383                         break;
3384                 case 'x':
3385                         dump_xml = 1;
3386                         break;
3387                 default:
3388                         break;
3389                 }
3390         }
3391
3392 retry:
3393         lun_str = malloc(lun_len);
3394
3395         bzero(&list, sizeof(list));
3396         list.alloc_len = lun_len;
3397         list.status = CTL_LUN_LIST_NONE;
3398         list.lun_xml = lun_str;
3399
3400         if (ioctl(fd, CTL_LUN_LIST, &list) == -1) {
3401                 warn("%s: error issuing CTL_LUN_LIST ioctl", __func__);
3402                 retval = 1;
3403                 goto bailout;
3404         }
3405
3406         if (list.status == CTL_LUN_LIST_ERROR) {
3407                 warnx("%s: error returned from CTL_LUN_LIST ioctl:\n%s",
3408                       __func__, list.error_str);
3409         } else if (list.status == CTL_LUN_LIST_NEED_MORE_SPACE) {
3410                 lun_len = lun_len << 1;
3411                 goto retry;
3412         }
3413
3414         if (dump_xml != 0) {
3415                 printf("%s", lun_str);
3416                 goto bailout;
3417         }
3418
3419         parser = XML_ParserCreate(NULL);
3420         if (parser == NULL) {
3421                 warn("%s: Unable to create XML parser", __func__);
3422                 retval = 1;
3423                 goto bailout;
3424         }
3425
3426         XML_SetUserData(parser, &devlist);
3427         XML_SetElementHandler(parser, cctl_start_element, cctl_end_element);
3428         XML_SetCharacterDataHandler(parser, cctl_char_handler);
3429
3430         retval = XML_Parse(parser, lun_str, strlen(lun_str), 1);
3431         if (retval != 1) {
3432                 warnx("%s: Unable to parse XML: Error %d", __func__,
3433                     XML_GetErrorCode(parser));
3434                 XML_ParserFree(parser);
3435                 retval = 1;
3436                 goto bailout;
3437         }
3438         retval = 0;
3439         XML_ParserFree(parser);
3440
3441         printf("LUN Backend  %18s %4s %-16s %-16s\n", "Size (Blocks)", "BS",
3442                "Serial Number", "Device ID");
3443         STAILQ_FOREACH(lun, &devlist.lun_list, links) {
3444                 struct cctl_lun_nv *nv;
3445
3446                 if ((backend != NULL)
3447                  && (strcmp(lun->backend_type, backend) != 0))
3448                         continue;
3449
3450                 printf("%3ju %-8s %18ju %4u %-16s %-16s\n",
3451                        (uintmax_t)lun->lun_id,
3452                        lun->backend_type, (uintmax_t)lun->size_blocks,
3453                        lun->blocksize, lun->serial_number, lun->device_id);
3454
3455                 if (verbose == 0)
3456                         continue;
3457
3458                 STAILQ_FOREACH(nv, &lun->attr_list, links) {
3459                         printf("      %s=%s\n", nv->name, nv->value);
3460                 }
3461         }
3462 bailout:
3463         free(lun_str);
3464
3465         return (retval);
3466 }
3467
3468 /*
3469  * Port information.
3470  */
3471 struct cctl_port {
3472         uint64_t port_id;
3473         char *online;
3474         char *frontend_type;
3475         char *name;
3476         int pp, vp;
3477         char *target, *port, *lun_map;
3478         STAILQ_HEAD(,cctl_lun_nv) init_list;
3479         STAILQ_HEAD(,cctl_lun_nv) lun_list;
3480         STAILQ_HEAD(,cctl_lun_nv) attr_list;
3481         STAILQ_ENTRY(cctl_port) links;
3482 };
3483
3484 struct cctl_portlist_data {
3485         int num_ports;
3486         STAILQ_HEAD(,cctl_port) port_list;
3487         struct cctl_port *cur_port;
3488         int level;
3489         uint64_t cur_id;
3490         struct sbuf *cur_sb[32];
3491 };
3492
3493 static void
3494 cctl_start_pelement(void *user_data, const char *name, const char **attr)
3495 {
3496         int i;
3497         struct cctl_portlist_data *portlist;
3498         struct cctl_port *cur_port;
3499
3500         portlist = (struct cctl_portlist_data *)user_data;
3501         cur_port = portlist->cur_port;
3502         portlist->level++;
3503         if ((u_int)portlist->level >= (sizeof(portlist->cur_sb) /
3504             sizeof(portlist->cur_sb[0])))
3505                 errx(1, "%s: too many nesting levels, %zd max", __func__,
3506                      sizeof(portlist->cur_sb) / sizeof(portlist->cur_sb[0]));
3507
3508         portlist->cur_sb[portlist->level] = sbuf_new_auto();
3509         if (portlist->cur_sb[portlist->level] == NULL)
3510                 err(1, "%s: Unable to allocate sbuf", __func__);
3511
3512         portlist->cur_id = 0;
3513         for (i = 0; attr[i] != NULL; i += 2) {
3514                 if (strcmp(attr[i], "id") == 0) {
3515                         portlist->cur_id = strtoull(attr[i+1], NULL, 0);
3516                         break;
3517                 }
3518         }
3519
3520         if (strcmp(name, "targ_port") == 0) {
3521                 if (cur_port != NULL)
3522                         errx(1, "%s: improper port element nesting", __func__);
3523
3524                 cur_port = calloc(1, sizeof(*cur_port));
3525                 if (cur_port == NULL)
3526                         err(1, "%s: cannot allocate %zd bytes", __func__,
3527                             sizeof(*cur_port));
3528
3529                 portlist->num_ports++;
3530                 portlist->cur_port = cur_port;
3531
3532                 STAILQ_INIT(&cur_port->init_list);
3533                 STAILQ_INIT(&cur_port->lun_list);
3534                 STAILQ_INIT(&cur_port->attr_list);
3535                 cur_port->port_id = portlist->cur_id;
3536                 STAILQ_INSERT_TAIL(&portlist->port_list, cur_port, links);
3537         }
3538 }
3539
3540 static void
3541 cctl_end_pelement(void *user_data, const char *name)
3542 {
3543         struct cctl_portlist_data *portlist;
3544         struct cctl_port *cur_port;
3545         char *str;
3546
3547         portlist = (struct cctl_portlist_data *)user_data;
3548         cur_port = portlist->cur_port;
3549
3550         if ((cur_port == NULL)
3551          && (strcmp(name, "ctlportlist") != 0))
3552                 errx(1, "%s: cur_port == NULL! (name = %s)", __func__, name);
3553
3554         if (portlist->cur_sb[portlist->level] == NULL)
3555                 errx(1, "%s: no valid sbuf at level %d (name %s)", __func__,
3556                      portlist->level, name);
3557
3558         if (sbuf_finish(portlist->cur_sb[portlist->level]) != 0)
3559                 err(1, "%s: sbuf_finish", __func__);
3560         str = strdup(sbuf_data(portlist->cur_sb[portlist->level]));
3561         if (str == NULL)
3562                 err(1, "%s can't allocate %zd bytes for string", __func__,
3563                     sbuf_len(portlist->cur_sb[portlist->level]));
3564
3565         if (strlen(str) == 0) {
3566                 free(str);
3567                 str = NULL;
3568         }
3569
3570         sbuf_delete(portlist->cur_sb[portlist->level]);
3571         portlist->cur_sb[portlist->level] = NULL;
3572         portlist->level--;
3573
3574         if (strcmp(name, "frontend_type") == 0) {
3575                 cur_port->frontend_type = str;
3576                 str = NULL;
3577         } else if (strcmp(name, "port_name") == 0) {
3578                 cur_port->name = str;
3579                 str = NULL;
3580         } else if (strcmp(name, "online") == 0) {
3581                 cur_port->online = str;
3582                 str = NULL;
3583         } else if (strcmp(name, "physical_port") == 0) {
3584                 cur_port->pp = strtoull(str, NULL, 0);
3585         } else if (strcmp(name, "virtual_port") == 0) {
3586                 cur_port->vp = strtoull(str, NULL, 0);
3587         } else if (strcmp(name, "target") == 0) {
3588                 cur_port->target = str;
3589                 str = NULL;
3590         } else if (strcmp(name, "port") == 0) {
3591                 cur_port->port = str;
3592                 str = NULL;
3593         } else if (strcmp(name, "lun_map") == 0) {
3594                 cur_port->lun_map = str;
3595                 str = NULL;
3596         } else if (strcmp(name, "targ_port") == 0) {
3597                 portlist->cur_port = NULL;
3598         } else if (strcmp(name, "ctlportlist") == 0) {
3599                 /* Nothing. */
3600         } else {
3601                 struct cctl_lun_nv *nv;
3602
3603                 nv = calloc(1, sizeof(*nv));
3604                 if (nv == NULL)
3605                         err(1, "%s: can't allocate %zd bytes for nv pair",
3606                             __func__, sizeof(*nv));
3607
3608                 if (strcmp(name, "initiator") == 0 ||
3609                     strcmp(name, "lun") == 0)
3610                         asprintf(&nv->name, "%ju", portlist->cur_id);
3611                 else
3612                         nv->name = strdup(name);
3613                 if (nv->name == NULL)
3614                         err(1, "%s: can't allocated %zd bytes for string",
3615                             __func__, strlen(name));
3616
3617                 nv->value = str;
3618                 str = NULL;
3619                 if (strcmp(name, "initiator") == 0)
3620                         STAILQ_INSERT_TAIL(&cur_port->init_list, nv, links);
3621                 else if (strcmp(name, "lun") == 0)
3622                         STAILQ_INSERT_TAIL(&cur_port->lun_list, nv, links);
3623                 else
3624                         STAILQ_INSERT_TAIL(&cur_port->attr_list, nv, links);
3625         }
3626
3627         free(str);
3628 }
3629
3630 static void
3631 cctl_char_phandler(void *user_data, const XML_Char *str, int len)
3632 {
3633         struct cctl_portlist_data *portlist;
3634
3635         portlist = (struct cctl_portlist_data *)user_data;
3636
3637         sbuf_bcat(portlist->cur_sb[portlist->level], str, len);
3638 }
3639
3640 static int
3641 cctl_portlist(int fd, int argc, char **argv, char *combinedopt)
3642 {
3643         struct ctl_lun_list list;
3644         struct cctl_portlist_data portlist;
3645         struct cctl_port *port;
3646         XML_Parser parser;
3647         char *port_str = NULL;
3648         int port_len;
3649         int dump_xml = 0;
3650         int retval, c;
3651         char *frontend = NULL;
3652         uint64_t portarg = UINT64_MAX;
3653         int verbose = 0, init = 0, lun = 0, quiet = 0;
3654
3655         retval = 0;
3656         port_len = 4096;
3657
3658         bzero(&portlist, sizeof(portlist));
3659         STAILQ_INIT(&portlist.port_list);
3660
3661         while ((c = getopt(argc, argv, combinedopt)) != -1) {
3662                 switch (c) {
3663                 case 'f':
3664                         frontend = strdup(optarg);
3665                         break;
3666                 case 'i':
3667                         init++;
3668                         break;
3669                 case 'l':
3670                         lun++;
3671                         break;
3672                 case 'p':
3673                         portarg = strtoll(optarg, NULL, 0);
3674                         break;
3675                 case 'q':
3676                         quiet++;
3677                         break;
3678                 case 'v':
3679                         verbose++;
3680                         break;
3681                 case 'x':
3682                         dump_xml = 1;
3683                         break;
3684                 default:
3685                         break;
3686                 }
3687         }
3688
3689 retry:
3690         port_str = (char *)realloc(port_str, port_len);
3691
3692         bzero(&list, sizeof(list));
3693         list.alloc_len = port_len;
3694         list.status = CTL_LUN_LIST_NONE;
3695         list.lun_xml = port_str;
3696
3697         if (ioctl(fd, CTL_PORT_LIST, &list) == -1) {
3698                 warn("%s: error issuing CTL_PORT_LIST ioctl", __func__);
3699                 retval = 1;
3700                 goto bailout;
3701         }
3702
3703         if (list.status == CTL_LUN_LIST_ERROR) {
3704                 warnx("%s: error returned from CTL_PORT_LIST ioctl:\n%s",
3705                       __func__, list.error_str);
3706         } else if (list.status == CTL_LUN_LIST_NEED_MORE_SPACE) {
3707                 port_len = port_len << 1;
3708                 goto retry;
3709         }
3710
3711         if (dump_xml != 0) {
3712                 printf("%s", port_str);
3713                 goto bailout;
3714         }
3715
3716         parser = XML_ParserCreate(NULL);
3717         if (parser == NULL) {
3718                 warn("%s: Unable to create XML parser", __func__);
3719                 retval = 1;
3720                 goto bailout;
3721         }
3722
3723         XML_SetUserData(parser, &portlist);
3724         XML_SetElementHandler(parser, cctl_start_pelement, cctl_end_pelement);
3725         XML_SetCharacterDataHandler(parser, cctl_char_phandler);
3726
3727         retval = XML_Parse(parser, port_str, strlen(port_str), 1);
3728         if (retval != 1) {
3729                 warnx("%s: Unable to parse XML: Error %d", __func__,
3730                     XML_GetErrorCode(parser));
3731                 XML_ParserFree(parser);
3732                 retval = 1;
3733                 goto bailout;
3734         }
3735         retval = 0;
3736         XML_ParserFree(parser);
3737
3738         if (quiet == 0)
3739                 printf("Port Online Frontend Name     pp vp\n");
3740         STAILQ_FOREACH(port, &portlist.port_list, links) {
3741                 struct cctl_lun_nv *nv;
3742
3743                 if ((frontend != NULL)
3744                  && (strcmp(port->frontend_type, frontend) != 0))
3745                         continue;
3746
3747                 if ((portarg != UINT64_MAX) && (portarg != port->port_id))
3748                         continue;
3749
3750                 printf("%-4ju %-6s %-8s %-8s %-2d %-2d %s\n",
3751                     (uintmax_t)port->port_id, port->online,
3752                     port->frontend_type, port->name, port->pp, port->vp,
3753                     port->port ? port->port : "");
3754
3755                 if (init || verbose) {
3756                         if (port->target)
3757                                 printf("  Target: %s\n", port->target);
3758                         STAILQ_FOREACH(nv, &port->init_list, links) {
3759                                 printf("  Initiator %s: %s\n",
3760                                     nv->name, nv->value);
3761                         }
3762                 }
3763
3764                 if (lun || verbose) {
3765                         if (port->lun_map) {
3766                                 STAILQ_FOREACH(nv, &port->lun_list, links)
3767                                         printf("  LUN %s: %s\n",
3768                                             nv->name, nv->value);
3769                                 if (STAILQ_EMPTY(&port->lun_list))
3770                                         printf("  No LUNs mapped\n");
3771                         } else
3772                                 printf("  All LUNs mapped\n");
3773                 }
3774
3775                 if (verbose) {
3776                         STAILQ_FOREACH(nv, &port->attr_list, links) {
3777                                 printf("      %s=%s\n", nv->name, nv->value);
3778                         }
3779                 }
3780         }
3781 bailout:
3782         free(port_str);
3783
3784         return (retval);
3785 }
3786
3787 static int
3788 cctl_lunmap(int fd, int argc, char **argv, char *combinedopt)
3789 {
3790         struct ctl_lun_map lm;
3791         int retval = 0, c;
3792
3793         retval = 0;
3794         lm.port = UINT32_MAX;
3795         lm.plun = UINT32_MAX;
3796         lm.lun = UINT32_MAX;
3797
3798         while ((c = getopt(argc, argv, combinedopt)) != -1) {
3799                 switch (c) {
3800                 case 'p':
3801                         lm.port = strtoll(optarg, NULL, 0);
3802                         break;
3803                 case 'l':
3804                         lm.plun = strtoll(optarg, NULL, 0);
3805                         break;
3806                 case 'L':
3807                         lm.lun = strtoll(optarg, NULL, 0);
3808                         break;
3809                 default:
3810                         break;
3811                 }
3812         }
3813
3814         if (ioctl(fd, CTL_LUN_MAP, &lm) == -1) {
3815                 warn("%s: error issuing CTL_LUN_MAP ioctl", __func__);
3816                 retval = 1;
3817         }
3818
3819         return (retval);
3820 }
3821
3822 void
3823 usage(int error)
3824 {
3825         fprintf(error ? stderr : stdout,
3826 "Usage:\n"
3827 "Primary commands:\n"
3828 "         ctladm tur         [dev_id][general options]\n"
3829 "         ctladm inquiry     [dev_id][general options]\n"
3830 "         ctladm devid       [dev_id][general options]\n"
3831 "         ctladm reqsense    [dev_id][general options]\n"
3832 "         ctladm reportluns  [dev_id][general options]\n"
3833 "         ctladm read        [dev_id][general options] <-l lba> <-d len>\n"
3834 "                            <-f file|-> <-b blocksize> [-c cdbsize][-N]\n"
3835 "         ctladm write       [dev_id][general options] <-l lba> <-d len>\n"
3836 "                            <-f file|-> <-b blocksize> [-c cdbsize][-N]\n"
3837 "         ctladm readcap     [dev_id][general options] [-c cdbsize]\n"
3838 "         ctladm modesense   [dev_id][general options] <-m page|-l> [-P pc]\n"
3839 "                            [-d] [-S subpage] [-c cdbsize]\n"
3840 "         ctladm prin        [dev_id][general options] <-a action>\n"
3841 "         ctladm prout       [dev_id][general options] <-a action>\n"
3842 "                            <-r restype] [-k key] [-s sa_key]\n"
3843 "         ctladm rtpg        [dev_id][general options]\n"
3844 "         ctladm start       [dev_id][general options] [-i] [-o]\n"
3845 "         ctladm stop        [dev_id][general options] [-i] [-o]\n"
3846 "         ctladm synccache   [dev_id][general options] [-l lba]\n"
3847 "                            [-b blockcount] [-r] [-i] [-c cdbsize]\n"
3848 "         ctladm create      <-b backend> [-B blocksize] [-d device_id]\n"
3849 "                            [-l lun_id] [-o name=value] [-s size_bytes]\n"
3850 "                            [-S serial_num] [-t dev_type]\n"
3851 "         ctladm remove      <-b backend> <-l lun_id> [-o name=value]\n"
3852 "         ctladm modify      <-b backend> <-l lun_id> <-s size_bytes>\n"
3853 "         ctladm devlist     [-b backend] [-v] [-x]\n"
3854 "         ctladm lunlist\n"
3855 "         ctladm lunmap      -p targ_port [-l pLUN] [-L cLUN]\n"
3856 "         ctladm delay       [dev_id] <-l datamove|done> [-T oneshot|cont]\n"
3857 "                            [-t secs]\n"
3858 "         ctladm inject      [dev_id] <-i action> <-p pattern> [-r lba,len]\n"
3859 "                            [-s len fmt [args]] [-c] [-d delete_id]\n"
3860 "         ctladm port        <-o <on|off> | [-w wwnn][-W wwpn]>\n"
3861 "                            [-p targ_port] [-t port_type]\n"
3862 "                            <-c> [-d driver] [-O name=value]\n"
3863 "                            <-r> <-p targ_port>\n"
3864 "         ctladm portlist    [-f frontend] [-i] [-p targ_port] [-q] [-v] [-x]\n"
3865 "         ctladm islist      [-v | -x]\n"
3866 "         ctladm islogout    <-a | -c connection-id | -i name | -p portal>\n"
3867 "         ctladm isterminate <-a | -c connection-id | -i name | -p portal>\n"
3868 "         ctladm dumpooa\n"
3869 "         ctladm dumpstructs\n"
3870 "         ctladm help\n"
3871 "General Options:\n"
3872 "-I intiator_id           : defaults to 7, used to change the initiator id\n"
3873 "-C retries               : specify the number of times to retry this command\n"
3874 "-D devicename            : specify the device to operate on\n"
3875 "                         : (default is %s)\n"
3876 "read/write options:\n"
3877 "-l lba                   : logical block address\n"
3878 "-d len                   : read/write length, in blocks\n"
3879 "-f file|-                : write/read data to/from file or stdout/stdin\n"
3880 "-b blocksize             : block size, in bytes\n"
3881 "-c cdbsize               : specify minimum cdb size: 6, 10, 12 or 16\n"
3882 "-N                       : do not copy data to/from userland\n"
3883 "readcapacity options:\n"
3884 "-c cdbsize               : specify minimum cdb size: 10 or 16\n"
3885 "modesense options:\n"
3886 "-m page                  : specify the mode page to view\n"
3887 "-l                       : request a list of supported pages\n"
3888 "-P pc                    : specify the page control value: 0-3 (current,\n"
3889 "                           changeable, default, saved, respectively)\n"
3890 "-d                       : disable block descriptors for mode sense\n"
3891 "-S subpage               : specify a subpage\n"
3892 "-c cdbsize               : specify minimum cdb size: 6 or 10\n"
3893 "persistent reserve in options:\n"
3894 "-a action                : specify the action value: 0-2 (read key, read\n"
3895 "                           reservation, read capabilities, respectively)\n"
3896 "persistent reserve out options:\n"
3897 "-a action                : specify the action value: 0-5 (register, reserve,\n"
3898 "                           release, clear, preempt, register and ignore)\n"
3899 "-k key                   : key value\n"
3900 "-s sa_key                : service action value\n"
3901 "-r restype               : specify the reservation type: 0-5(wr ex, ex ac,\n"
3902 "                           wr ex ro, ex ac ro, wr ex ar, ex ac ar)\n"
3903 "start/stop options:\n"
3904 "-i                       : set the immediate bit (CTL does not support this)\n"
3905 "-o                       : set the on/offline bit\n"
3906 "synccache options:\n"
3907 "-l lba                   : set the starting LBA\n"
3908 "-b blockcount            : set the length to sync in blocks\n"
3909 "-r                       : set the relative addressing bit\n"
3910 "-i                       : set the immediate bit\n"
3911 "-c cdbsize               : specify minimum cdb size: 10 or 16\n"
3912 "create options:\n"
3913 "-b backend               : backend name (\"block\", \"ramdisk\", etc.)\n"
3914 "-B blocksize             : LUN blocksize in bytes (some backends)\n"
3915 "-d device_id             : SCSI VPD page 0x83 ID\n"
3916 "-l lun_id                : requested LUN number\n"
3917 "-o name=value            : backend-specific options, multiple allowed\n"
3918 "-s size_bytes            : LUN size in bytes (some backends)\n"
3919 "-S serial_num            : SCSI VPD page 0x80 serial number\n"
3920 "-t dev_type              : SCSI device type (0=disk, 3=processor)\n"
3921 "remove options:\n"
3922 "-b backend               : backend name (\"block\", \"ramdisk\", etc.)\n"
3923 "-l lun_id                : LUN number to delete\n"
3924 "-o name=value            : backend-specific options, multiple allowed\n"
3925 "devlist options:\n"
3926 "-b backend               : list devices from specified backend only\n"
3927 "-v                       : be verbose, show backend attributes\n"
3928 "-x                       : dump raw XML\n"
3929 "delay options:\n"
3930 "-l datamove|done         : delay command at datamove or done phase\n"
3931 "-T oneshot               : delay one command, then resume normal completion\n"
3932 "-T cont                  : delay all commands\n"
3933 "-t secs                  : number of seconds to delay\n"
3934 "inject options:\n"
3935 "-i error_action          : action to perform\n"
3936 "-p pattern               : command pattern to look for\n"
3937 "-r lba,len               : LBA range for pattern\n"
3938 "-s len fmt [args]        : sense data for custom sense action\n"
3939 "-c                       : continuous operation\n"
3940 "-d delete_id             : error id to delete\n"
3941 "port options:\n"
3942 "-c                       : create new ioctl or iscsi frontend port\n"
3943 "-d                       : specify ioctl or iscsi frontend type\n"
3944 "-l                       : list frontend ports\n"
3945 "-o on|off                : turn frontend ports on or off\n"
3946 "-O pp|vp                 : create new frontend port using pp and/or vp\n"
3947 "-w wwnn                  : set WWNN for one frontend\n"
3948 "-W wwpn                  : set WWPN for one frontend\n"
3949 "-t port_type             : specify fc, scsi, ioctl, internal frontend type\n"
3950 "-p targ_port             : specify target port number\n"
3951 "-r                       : remove frontend port\n"
3952 "-q                       : omit header in list output\n"
3953 "-x                       : output port list in XML format\n"
3954 "portlist options:\n"
3955 "-f frontend              : specify frontend type\n"
3956 "-i                       : report target and initiators addresses\n"
3957 "-l                       : report LUN mapping\n"
3958 "-p targ_port             : specify target port number\n"
3959 "-q                       : omit header in list output\n"
3960 "-v                       : verbose output (report all port options)\n"
3961 "-x                       : output port list in XML format\n"
3962 "lunmap options:\n"
3963 "-p targ_port             : specify target port number\n"
3964 "-L pLUN                  : specify port-visible LUN\n"
3965 "-L cLUN                  : specify CTL LUN\n",
3966 CTL_DEFAULT_DEV);
3967 }
3968
3969 int
3970 main(int argc, char **argv)
3971 {
3972         int c;
3973         ctladm_cmdfunction command;
3974         ctladm_cmdargs cmdargs;
3975         ctladm_optret optreturn;
3976         char *device;
3977         const char *mainopt = "C:D:I:";
3978         const char *subopt = NULL;
3979         char combinedopt[256];
3980         int lun;
3981         int optstart = 2;
3982         int retval, fd;
3983         int retries;
3984         int initid;
3985         int saved_errno;
3986
3987         retval = 0;
3988         cmdargs = CTLADM_ARG_NONE;
3989         command = CTLADM_CMD_HELP;
3990         device = NULL;
3991         fd = -1;
3992         retries = 0;
3993         lun = 0;
3994         initid = 7;
3995
3996         if (argc < 2) {
3997                 usage(1);
3998                 retval = 1;
3999                 goto bailout;
4000         }
4001
4002         /*
4003          * Get the base option.
4004          */
4005         optreturn = getoption(option_table,argv[1], &command, &cmdargs,&subopt);
4006
4007         if (optreturn == CC_OR_AMBIGUOUS) {
4008                 warnx("ambiguous option %s", argv[1]);
4009                 usage(0);
4010                 exit(1);
4011         } else if (optreturn == CC_OR_NOT_FOUND) {
4012                 warnx("option %s not found", argv[1]);
4013                 usage(0);
4014                 exit(1);
4015         }
4016
4017         if (cmdargs & CTLADM_ARG_NEED_TL) {
4018                 if ((argc < 3) || (!isdigit(argv[2][0]))) {
4019                         warnx("option %s requires a lun argument",
4020                               argv[1]);
4021                         usage(0);
4022                         exit(1);
4023                 }
4024                 lun = strtol(argv[2], NULL, 0);
4025
4026                 cmdargs |= CTLADM_ARG_TARG_LUN;
4027                 optstart++;
4028         }
4029
4030         /*
4031          * Ahh, getopt(3) is a pain.
4032          *
4033          * This is a gross hack.  There really aren't many other good
4034          * options (excuse the pun) for parsing options in a situation like
4035          * this.  getopt is kinda braindead, so you end up having to run
4036          * through the options twice, and give each invocation of getopt
4037          * the option string for the other invocation.
4038          *
4039          * You would think that you could just have two groups of options.
4040          * The first group would get parsed by the first invocation of
4041          * getopt, and the second group would get parsed by the second
4042          * invocation of getopt.  It doesn't quite work out that way.  When
4043          * the first invocation of getopt finishes, it leaves optind pointing
4044          * to the argument _after_ the first argument in the second group.
4045          * So when the second invocation of getopt comes around, it doesn't
4046          * recognize the first argument it gets and then bails out.
4047          *
4048          * A nice alternative would be to have a flag for getopt that says
4049          * "just keep parsing arguments even when you encounter an unknown
4050          * argument", but there isn't one.  So there's no real clean way to
4051          * easily parse two sets of arguments without having one invocation
4052          * of getopt know about the other.
4053          *
4054          * Without this hack, the first invocation of getopt would work as
4055          * long as the generic arguments are first, but the second invocation
4056          * (in the subfunction) would fail in one of two ways.  In the case
4057          * where you don't set optreset, it would fail because optind may be
4058          * pointing to the argument after the one it should be pointing at.
4059          * In the case where you do set optreset, and reset optind, it would
4060          * fail because getopt would run into the first set of options, which
4061          * it doesn't understand.
4062          *
4063          * All of this would "sort of" work if you could somehow figure out
4064          * whether optind had been incremented one option too far.  The
4065          * mechanics of that, however, are more daunting than just giving
4066          * both invocations all of the expect options for either invocation.
4067          *
4068          * Needless to say, I wouldn't mind if someone invented a better
4069          * (non-GPL!) command line parsing interface than getopt.  I
4070          * wouldn't mind if someone added more knobs to getopt to make it
4071          * work better.  Who knows, I may talk myself into doing it someday,
4072          * if the standards weenies let me.  As it is, it just leads to
4073          * hackery like this and causes people to avoid it in some cases.
4074          *
4075          * KDM, September 8th, 1998
4076          */
4077         if (subopt != NULL)
4078                 sprintf(combinedopt, "%s%s", mainopt, subopt);
4079         else
4080                 sprintf(combinedopt, "%s", mainopt);
4081
4082         /*
4083          * Start getopt processing at argv[2/3], since we've already
4084          * accepted argv[1..2] as the command name, and as a possible
4085          * device name.
4086          */
4087         optind = optstart;
4088
4089         /*
4090          * Now we run through the argument list looking for generic
4091          * options, and ignoring options that possibly belong to
4092          * subfunctions.
4093          */
4094         while ((c = getopt(argc, argv, combinedopt))!= -1){
4095                 switch (c) {
4096                 case 'C':
4097                         cmdargs |= CTLADM_ARG_RETRIES;
4098                         retries = strtol(optarg, NULL, 0);
4099                         break;
4100                 case 'D':
4101                         device = strdup(optarg);
4102                         cmdargs |= CTLADM_ARG_DEVICE;
4103                         break;
4104                 case 'I':
4105                         cmdargs |= CTLADM_ARG_INITIATOR;
4106                         initid = strtol(optarg, NULL, 0);
4107                         break;
4108                 default:
4109                         break;
4110                 }
4111         }
4112
4113         if ((cmdargs & CTLADM_ARG_INITIATOR) == 0)
4114                 initid = 7;
4115
4116         optind = optstart;
4117         optreset = 1;
4118
4119         /*
4120          * Default to opening the CTL device for now.
4121          */
4122         if (((cmdargs & CTLADM_ARG_DEVICE) == 0)
4123          && (command != CTLADM_CMD_HELP)) {
4124                 device = strdup(CTL_DEFAULT_DEV);
4125                 cmdargs |= CTLADM_ARG_DEVICE;
4126         }
4127
4128         if ((cmdargs & CTLADM_ARG_DEVICE)
4129          && (command != CTLADM_CMD_HELP)) {
4130                 fd = open(device, O_RDWR);
4131                 if (fd == -1 && errno == ENOENT) {
4132                         saved_errno = errno;
4133                         retval = kldload("ctl");
4134                         if (retval != -1)
4135                                 fd = open(device, O_RDWR);
4136                         else
4137                                 errno = saved_errno;
4138                 }
4139                 if (fd == -1) {
4140                         fprintf(stderr, "%s: error opening %s: %s\n",
4141                                 argv[0], device, strerror(errno));
4142                         retval = 1;
4143                         goto bailout;
4144                 }
4145 #ifdef  WANT_ISCSI
4146                 else {
4147                         if (modfind("cfiscsi") == -1 &&
4148                             kldload("cfiscsi") == -1)
4149                                 warn("couldn't load cfiscsi");
4150                 }
4151 #endif
4152         } else if ((command != CTLADM_CMD_HELP)
4153                 && ((cmdargs & CTLADM_ARG_DEVICE) == 0)) {
4154                 fprintf(stderr, "%s: you must specify a device with the "
4155                         "--device argument for this command\n", argv[0]);
4156                 command = CTLADM_CMD_HELP;
4157                 retval = 1;
4158         }
4159
4160         switch (command) {
4161         case CTLADM_CMD_TUR:
4162                 retval = cctl_tur(fd, lun, initid, retries);
4163                 break;
4164         case CTLADM_CMD_INQUIRY:
4165                 retval = cctl_inquiry(fd, lun, initid, retries);
4166                 break;
4167         case CTLADM_CMD_REQ_SENSE:
4168                 retval = cctl_req_sense(fd, lun, initid, retries);
4169                 break;
4170         case CTLADM_CMD_REPORT_LUNS:
4171                 retval = cctl_report_luns(fd, lun, initid, retries);
4172                 break;
4173         case CTLADM_CMD_CREATE:
4174                 retval = cctl_create_lun(fd, argc, argv, combinedopt);
4175                 break;
4176         case CTLADM_CMD_RM:
4177                 retval = cctl_rm_lun(fd, argc, argv, combinedopt);
4178                 break;
4179         case CTLADM_CMD_DEVLIST:
4180                 retval = cctl_devlist(fd, argc, argv, combinedopt);
4181                 break;
4182         case CTLADM_CMD_READ:
4183         case CTLADM_CMD_WRITE:
4184                 retval = cctl_read_write(fd, lun, initid, retries,
4185                                          argc, argv, combinedopt, command);
4186                 break;
4187         case CTLADM_CMD_PORT:
4188                 retval = cctl_port(fd, argc, argv, combinedopt);
4189                 break;
4190         case CTLADM_CMD_PORTLIST:
4191                 retval = cctl_portlist(fd, argc, argv, combinedopt);
4192                 break;
4193         case CTLADM_CMD_LUNMAP:
4194                 retval = cctl_lunmap(fd, argc, argv, combinedopt);
4195                 break;
4196         case CTLADM_CMD_READCAPACITY:
4197                 retval = cctl_read_capacity(fd, lun, initid, retries,
4198                                             argc, argv, combinedopt);
4199                 break;
4200         case CTLADM_CMD_MODESENSE:
4201                 retval = cctl_mode_sense(fd, lun, initid, retries,
4202                                          argc, argv, combinedopt);
4203                 break;
4204         case CTLADM_CMD_START:
4205         case CTLADM_CMD_STOP:
4206                 retval = cctl_start_stop(fd, lun, initid, retries,
4207                                          (command == CTLADM_CMD_START) ? 1 : 0,
4208                                          argc, argv, combinedopt);
4209                 break;
4210         case CTLADM_CMD_SYNC_CACHE:
4211                 retval = cctl_sync_cache(fd, lun, initid, retries,
4212                                          argc, argv, combinedopt);
4213                 break;
4214         case CTLADM_CMD_LUNLIST:
4215                 retval = cctl_lunlist(fd);
4216                 break;
4217         case CTLADM_CMD_DELAY:
4218                 retval = cctl_delay(fd, lun, argc, argv, combinedopt);
4219                 break;
4220         case CTLADM_CMD_ERR_INJECT:
4221                 retval = cctl_error_inject(fd, lun, argc, argv,
4222                                            combinedopt);
4223                 break;
4224         case CTLADM_CMD_DUMPOOA:
4225                 retval = cctl_dump_ooa(fd, argc, argv);
4226                 break;
4227         case CTLADM_CMD_DUMPSTRUCTS:
4228                 retval = cctl_dump_structs(fd, cmdargs);
4229                 break;
4230         case CTLADM_CMD_PRES_IN:
4231                 retval = cctl_persistent_reserve_in(fd, lun, initid,
4232                                                     argc, argv, combinedopt,
4233                                                     retries);
4234                 break;
4235         case CTLADM_CMD_PRES_OUT:
4236                 retval = cctl_persistent_reserve_out(fd, lun, initid,
4237                                                      argc, argv, combinedopt,
4238                                                      retries);
4239                 break;
4240         case CTLADM_CMD_INQ_VPD_DEVID:
4241                 retval = cctl_inquiry_vpd_devid(fd, lun, initid);
4242                 break;
4243         case CTLADM_CMD_RTPG:
4244                 retval = cctl_report_target_port_group(fd, lun, initid);
4245                 break;
4246         case CTLADM_CMD_MODIFY:
4247                 retval = cctl_modify_lun(fd, argc, argv, combinedopt);
4248                 break;
4249         case CTLADM_CMD_ISLIST:
4250                 retval = cctl_islist(fd, argc, argv, combinedopt);
4251                 break;
4252         case CTLADM_CMD_ISLOGOUT:
4253                 retval = cctl_islogout(fd, argc, argv, combinedopt);
4254                 break;
4255         case CTLADM_CMD_ISTERMINATE:
4256                 retval = cctl_isterminate(fd, argc, argv, combinedopt);
4257                 break;
4258         case CTLADM_CMD_HELP:
4259         default:
4260                 usage(retval);
4261                 break;
4262         }
4263 bailout:
4264
4265         if (fd != -1)
4266                 close(fd);
4267
4268         exit (retval);
4269 }
4270
4271 /*
4272  * vim: ts=8
4273  */