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