usr.sbin/ctladm/ctladm.c

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