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