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