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