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