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