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