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