?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Install dma(8) config files with mode 640 as root:mail to prevent ``normal''
[dragonfly.git] / sbin / camcontrol / camcontrol.c
blobca9d51c2bd0fd69e9f5657ab72e020d415594554
1 /*
2 * Copyright (c) 1997, 1998, 1999, 2000, 2001, 2002, 2005, 2006 Kenneth D. Merry
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 *
28 * $FreeBSD: src/sbin/camcontrol/camcontrol.c,v 1.21.2.13 2003/01/08 17:55:02 njl Exp $
29 * $DragonFly: src/sbin/camcontrol/camcontrol.c,v 1.9 2007/12/02 04:44:03 pavalos Exp $
30 */
31
32 #include <sys/ioctl.h>
33 #include <sys/types.h>
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include <unistd.h>
38 #include <fcntl.h>
39 #include <ctype.h>
40 #include <err.h>
41
42 #include <cam/cam.h>
43 #include <cam/cam_debug.h>
44 #include <cam/cam_ccb.h>
45 #include <cam/scsi/scsi_all.h>
46 #include <cam/scsi/scsi_da.h>
47 #include <cam/scsi/scsi_pass.h>
48 #include <cam/scsi/scsi_message.h>
49 #include <camlib.h>
50 #include "camcontrol.h"
51
52 typedef enum {
53 CAM_CMD_NONE = 0x00000000,
54 CAM_CMD_DEVLIST = 0x00000001,
55 CAM_CMD_TUR = 0x00000002,
56 CAM_CMD_INQUIRY = 0x00000003,
57 CAM_CMD_STARTSTOP = 0x00000004,
58 CAM_CMD_RESCAN = 0x00000005,
59 CAM_CMD_READ_DEFECTS = 0x00000006,
60 CAM_CMD_MODE_PAGE = 0x00000007,
61 CAM_CMD_SCSI_CMD = 0x00000008,
62 CAM_CMD_DEVTREE = 0x00000009,
63 CAM_CMD_USAGE = 0x0000000a,
64 CAM_CMD_DEBUG = 0x0000000b,
65 CAM_CMD_RESET = 0x0000000c,
66 CAM_CMD_FORMAT = 0x0000000d,
67 CAM_CMD_TAG = 0x0000000e,
68 CAM_CMD_RATE = 0x0000000f,
69 CAM_CMD_DETACH = 0x00000010,
70 CAM_CMD_REPORTLUNS = 0x00000011
71 } cam_cmdmask;
72
73 typedef enum {
74 CAM_ARG_NONE = 0x00000000,
75 CAM_ARG_VERBOSE = 0x00000001,
76 CAM_ARG_DEVICE = 0x00000002,
77 CAM_ARG_BUS = 0x00000004,
78 CAM_ARG_TARGET = 0x00000008,
79 CAM_ARG_LUN = 0x00000010,
80 CAM_ARG_EJECT = 0x00000020,
81 CAM_ARG_UNIT = 0x00000040,
82 CAM_ARG_FORMAT_BLOCK = 0x00000080,
83 CAM_ARG_FORMAT_BFI = 0x00000100,
84 CAM_ARG_FORMAT_PHYS = 0x00000200,
85 CAM_ARG_PLIST = 0x00000400,
86 CAM_ARG_GLIST = 0x00000800,
87 CAM_ARG_GET_SERIAL = 0x00001000,
88 CAM_ARG_GET_STDINQ = 0x00002000,
89 CAM_ARG_GET_XFERRATE = 0x00004000,
90 CAM_ARG_INQ_MASK = 0x00007000,
91 CAM_ARG_MODE_EDIT = 0x00008000,
92 CAM_ARG_PAGE_CNTL = 0x00010000,
93 CAM_ARG_TIMEOUT = 0x00020000,
94 CAM_ARG_CMD_IN = 0x00040000,
95 CAM_ARG_CMD_OUT = 0x00080000,
96 CAM_ARG_DBD = 0x00100000,
97 CAM_ARG_ERR_RECOVER = 0x00200000,
98 CAM_ARG_RETRIES = 0x00400000,
99 CAM_ARG_START_UNIT = 0x00800000,
100 CAM_ARG_DEBUG_INFO = 0x01000000,
101 CAM_ARG_DEBUG_TRACE = 0x02000000,
102 CAM_ARG_DEBUG_SUBTRACE = 0x04000000,
103 CAM_ARG_DEBUG_CDB = 0x08000000,
104 CAM_ARG_DEBUG_XPT = 0x10000000,
105 CAM_ARG_DEBUG_PERIPH = 0x20000000,
106 } cam_argmask;
107
108 struct camcontrol_opts {
109 const char *optname;
110 cam_cmdmask cmdnum;
111 cam_argmask argnum;
112 const char *subopt;
113 };
114
115 #ifndef MINIMALISTIC
116 static const char scsicmd_opts[] = "c:i:o:";
117 static const char readdefect_opts[] = "f:GP";
118 static const char negotiate_opts[] = "acD:O:qR:T:UW:";
119 #endif
120
121 struct camcontrol_opts option_table[] = {
122 #ifndef MINIMALISTIC
123 {"tur", CAM_CMD_TUR, CAM_ARG_NONE, NULL},
124 {"inquiry", CAM_CMD_INQUIRY, CAM_ARG_NONE, "DSR"},
125 {"start", CAM_CMD_STARTSTOP, CAM_ARG_START_UNIT, NULL},
126 {"stop", CAM_CMD_STARTSTOP, CAM_ARG_NONE, NULL},
127 {"load", CAM_CMD_STARTSTOP, CAM_ARG_START_UNIT | CAM_ARG_EJECT, NULL},
128 {"eject", CAM_CMD_STARTSTOP, CAM_ARG_EJECT, NULL},
129 {"reportluns", CAM_CMD_REPORTLUNS, CAM_ARG_NONE, "clr:"},
130 #endif /* MINIMALISTIC */
131 {"rescan", CAM_CMD_RESCAN, CAM_ARG_NONE, NULL},
132 {"reset", CAM_CMD_RESET, CAM_ARG_NONE, NULL},
133 #ifndef MINIMALISTIC
134 {"cmd", CAM_CMD_SCSI_CMD, CAM_ARG_NONE, scsicmd_opts},
135 {"command", CAM_CMD_SCSI_CMD, CAM_ARG_NONE, scsicmd_opts},
136 {"defects", CAM_CMD_READ_DEFECTS, CAM_ARG_NONE, readdefect_opts},
137 {"defectlist", CAM_CMD_READ_DEFECTS, CAM_ARG_NONE, readdefect_opts},
138 #endif /* MINIMALISTIC */
139 {"devlist", CAM_CMD_DEVTREE, CAM_ARG_NONE, NULL},
140 #ifndef MINIMALISTIC
141 {"periphlist", CAM_CMD_DEVLIST, CAM_ARG_NONE, NULL},
142 {"modepage", CAM_CMD_MODE_PAGE, CAM_ARG_NONE, "bdelm:P:"},
143 {"tags", CAM_CMD_TAG, CAM_ARG_NONE, "N:q"},
144 {"negotiate", CAM_CMD_RATE, CAM_ARG_NONE, negotiate_opts},
145 {"rate", CAM_CMD_RATE, CAM_ARG_NONE, negotiate_opts},
146 {"debug", CAM_CMD_DEBUG, CAM_ARG_NONE, "IPTSXc"},
147 {"format", CAM_CMD_FORMAT, CAM_ARG_NONE, "qrwy"},
148 #endif /* MINIMALISTIC */
149 {"help", CAM_CMD_USAGE, CAM_ARG_NONE, NULL},
150 {"-?", CAM_CMD_USAGE, CAM_ARG_NONE, NULL},
151 {"-h", CAM_CMD_USAGE, CAM_ARG_NONE, NULL},
152 {NULL, 0, 0, NULL}
153 };
154
155 typedef enum {
156 CC_OR_NOT_FOUND,
157 CC_OR_AMBIGUOUS,
158 CC_OR_FOUND
159 } camcontrol_optret;
160
161 cam_cmdmask cmdlist;
162 cam_argmask arglist;
163 int bus, target, lun;
164
165
166 camcontrol_optret getoption(char *, cam_cmdmask *, cam_argmask *,
167 const char **);
168 #ifndef MINIMALISTIC
169 static int getdevlist(struct cam_device *);
170 static int getdevtree(void);
171 static int testunitready(struct cam_device *, int, int, int);
172 static int scsistart(struct cam_device *, int, int, int, int);
173 static int scsidoinquiry(struct cam_device *, int, char **, char *, int,
174 int);
175 static int scsiinquiry(struct cam_device *, int, int);
176 static int scsiserial(struct cam_device *, int, int);
177 static int scsixferrate(struct cam_device *);
178 #endif /* MINIMALISTIC */
179 static int parse_btl(char *, int *, int *, int *, cam_argmask *);
180 static int dorescan_or_reset(int, char **, int);
181 static int rescan_or_reset_bus(int, int);
182 static int scanlun_or_reset_dev(int, int, int, int);
183 #ifndef MINIMALISTIC
184 static int readdefects(struct cam_device *, int, char **, char *, int,
185 int);
186 static void modepage(struct cam_device *, int, char **, char *, int, int);
187 static int scsicmd(struct cam_device *, int, char **, char *, int, int);
188 static int tagcontrol(struct cam_device *, int, char **, char *);
189 static void cts_print(struct cam_device *device,
190 struct ccb_trans_settings *);
191 static void cpi_print(struct ccb_pathinq *);
192 static int get_cpi(struct cam_device *, struct ccb_pathinq *);
193 static int get_print_cts(struct cam_device *, int, int,
194 struct ccb_trans_settings *);
195 static int ratecontrol(struct cam_device *, int, int, int, char **,
196 char *);
197 static int scsiformat(struct cam_device *, int, char **, char *, int, int);
198 static int scsireportluns(struct cam_device *device, int argc, char **argv,
199 char *combinedopt, int retry_count, int timeout);
200 #endif /* MINIMALISTIC */
201
202
203 camcontrol_optret
204 getoption(char *arg, cam_cmdmask *cmdnum, cam_argmask *argnum,
205 const char **subopt)
206 {
207 struct camcontrol_opts *opts;
208 int num_matches = 0;
209
210 for (opts = option_table; (opts != NULL) && (opts->optname != NULL);
211 opts++) {
212 if (strncmp(opts->optname, arg, strlen(arg)) == 0) {
213 *cmdnum = opts->cmdnum;
214 *argnum = opts->argnum;
215 *subopt = opts->subopt;
216 if (++num_matches > 1)
217 return(CC_OR_AMBIGUOUS);
218 }
219 }
220
221 if (num_matches > 0)
222 return(CC_OR_FOUND);
223 else
224 return(CC_OR_NOT_FOUND);
225 }
226
227 #ifndef MINIMALISTIC
228 static int
229 getdevlist(struct cam_device *device)
230 {
231 union ccb *ccb;
232 char status[32];
233 int error = 0;
234
235 ccb = cam_getccb(device);
236
237 ccb->ccb_h.func_code = XPT_GDEVLIST;
238 ccb->ccb_h.flags = CAM_DIR_NONE;
239 ccb->ccb_h.retry_count = 1;
240 ccb->cgdl.index = 0;
241 ccb->cgdl.status = CAM_GDEVLIST_MORE_DEVS;
242 while (ccb->cgdl.status == CAM_GDEVLIST_MORE_DEVS) {
243 if (cam_send_ccb(device, ccb) < 0) {
244 perror("error getting device list");
245 cam_freeccb(ccb);
246 return(1);
247 }
248
249 status[0] = '\0';
250
251 switch (ccb->cgdl.status) {
252 case CAM_GDEVLIST_MORE_DEVS:
253 strcpy(status, "MORE");
254 break;
255 case CAM_GDEVLIST_LAST_DEVICE:
256 strcpy(status, "LAST");
257 break;
258 case CAM_GDEVLIST_LIST_CHANGED:
259 strcpy(status, "CHANGED");
260 break;
261 case CAM_GDEVLIST_ERROR:
262 strcpy(status, "ERROR");
263 error = 1;
264 break;
265 }
266
267 fprintf(stdout, "%s%d: generation: %d index: %d status: %s\n",
268 ccb->cgdl.periph_name,
269 ccb->cgdl.unit_number,
270 ccb->cgdl.generation,
271 ccb->cgdl.index,
272 status);
273
274 /*
275 * If the list has changed, we need to start over from the
276 * beginning.
277 */
278 if (ccb->cgdl.status == CAM_GDEVLIST_LIST_CHANGED)
279 ccb->cgdl.index = 0;
280 }
281
282 cam_freeccb(ccb);
283
284 return(error);
285 }
286 #endif /* MINIMALISTIC */
287
288 static int
289 getdevtree(void)
290 {
291 union ccb ccb;
292 int bufsize, fd;
293 unsigned int i;
294 int need_close = 0;
295 int error = 0;
296 int skip_device = 0;
297
298 if ((fd = open(XPT_DEVICE, O_RDWR)) == -1) {
299 warn("couldn't open %s", XPT_DEVICE);
300 return(1);
301 }
302
303 bzero(&ccb, sizeof(union ccb));
304
305 ccb.ccb_h.path_id = CAM_XPT_PATH_ID;
306 ccb.ccb_h.target_id = CAM_TARGET_WILDCARD;
307 ccb.ccb_h.target_lun = CAM_LUN_WILDCARD;
308
309 ccb.ccb_h.func_code = XPT_DEV_MATCH;
310 bufsize = sizeof(struct dev_match_result) * 100;
311 ccb.cdm.match_buf_len = bufsize;
312 ccb.cdm.matches = (struct dev_match_result *)malloc(bufsize);
313 if (ccb.cdm.matches == NULL) {
314 warnx("can't malloc memory for matches");
315 close(fd);
316 return(1);
317 }
318 ccb.cdm.num_matches = 0;
319
320 /*
321 * We fetch all nodes, since we display most of them in the default
322 * case, and all in the verbose case.
323 */
324 ccb.cdm.num_patterns = 0;
325 ccb.cdm.pattern_buf_len = 0;
326
327 /*
328 * We do the ioctl multiple times if necessary, in case there are
329 * more than 100 nodes in the EDT.
330 */
331 do {
332 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
333 warn("error sending CAMIOCOMMAND ioctl");
334 error = 1;
335 break;
336 }
337
338 if ((ccb.ccb_h.status != CAM_REQ_CMP)
339 || ((ccb.cdm.status != CAM_DEV_MATCH_LAST)
340 && (ccb.cdm.status != CAM_DEV_MATCH_MORE))) {
341 warnx("got CAM error %#x, CDM error %d\n",
342 ccb.ccb_h.status, ccb.cdm.status);
343 error = 1;
344 break;
345 }
346
347 for (i = 0; i < ccb.cdm.num_matches; i++) {
348 switch (ccb.cdm.matches[i].type) {
349 case DEV_MATCH_BUS: {
350 struct bus_match_result *bus_result;
351
352 /*
353 * Only print the bus information if the
354 * user turns on the verbose flag.
355 */
356 if ((arglist & CAM_ARG_VERBOSE) == 0)
357 break;
358
359 bus_result =
360 &ccb.cdm.matches[i].result.bus_result;
361
362 if (need_close) {
363 fprintf(stdout, ")\n");
364 need_close = 0;
365 }
366
367 fprintf(stdout, "scbus%d on %s%d bus %d:\n",
368 bus_result->path_id,
369 bus_result->dev_name,
370 bus_result->unit_number,
371 bus_result->bus_id);
372 break;
373 }
374 case DEV_MATCH_DEVICE: {
375 struct device_match_result *dev_result;
376 char vendor[16], product[48], revision[16];
377 char tmpstr[256];
378
379 dev_result =
380 &ccb.cdm.matches[i].result.device_result;
381
382 if ((dev_result->flags
383 & DEV_RESULT_UNCONFIGURED)
384 && ((arglist & CAM_ARG_VERBOSE) == 0)) {
385 skip_device = 1;
386 break;
387 } else
388 skip_device = 0;
389
390 cam_strvis(vendor, dev_result->inq_data.vendor,
391 sizeof(dev_result->inq_data.vendor),
392 sizeof(vendor));
393 cam_strvis(product,
394 dev_result->inq_data.product,
395 sizeof(dev_result->inq_data.product),
396 sizeof(product));
397 cam_strvis(revision,
398 dev_result->inq_data.revision,
399 sizeof(dev_result->inq_data.revision),
400 sizeof(revision));
401 sprintf(tmpstr, "<%s %s %s>", vendor, product,
402 revision);
403 if (need_close) {
404 fprintf(stdout, ")\n");
405 need_close = 0;
406 }
407
408 fprintf(stdout, "%-33s at scbus%d "
409 "target %d lun %d (",
410 tmpstr,
411 dev_result->path_id,
412 dev_result->target_id,
413 dev_result->target_lun);
414
415 need_close = 1;
416
417 break;
418 }
419 case DEV_MATCH_PERIPH: {
420 struct periph_match_result *periph_result;
421
422 periph_result =
423 &ccb.cdm.matches[i].result.periph_result;
424
425 if (skip_device != 0)
426 break;
427
428 if (need_close > 1)
429 fprintf(stdout, ",");
430
431 fprintf(stdout, "%s%d",
432 periph_result->periph_name,
433 periph_result->unit_number);
434
435 need_close++;
436 break;
437 }
438 default:
439 fprintf(stdout, "unknown match type\n");
440 break;
441 }
442 }
443
444 } while ((ccb.ccb_h.status == CAM_REQ_CMP)
445 && (ccb.cdm.status == CAM_DEV_MATCH_MORE));
446
447 if (need_close)
448 fprintf(stdout, ")\n");
449
450 close(fd);
451
452 return(error);
453 }
454
455 #ifndef MINIMALISTIC
456 static int
457 testunitready(struct cam_device *device, int retry_count, int timeout,
458 int quiet)
459 {
460 int error = 0;
461 union ccb *ccb;
462
463 ccb = cam_getccb(device);
464
465 scsi_test_unit_ready(&ccb->csio,
466 /* retries */ retry_count,
467 /* cbfcnp */ NULL,
468 /* tag_action */ MSG_SIMPLE_Q_TAG,
469 /* sense_len */ SSD_FULL_SIZE,
470 /* timeout */ timeout ? timeout : 5000);
471
472 /* Disable freezing the device queue */
473 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
474
475 if (arglist & CAM_ARG_ERR_RECOVER)
476 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
477
478 if (cam_send_ccb(device, ccb) < 0) {
479 if (quiet == 0)
480 perror("error sending test unit ready");
481
482 if (arglist & CAM_ARG_VERBOSE) {
483 cam_error_print(device, ccb, CAM_ESF_ALL,
484 CAM_EPF_ALL, stderr);
485 }
486
487 cam_freeccb(ccb);
488 return(1);
489 }
490
491 if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
492 if (quiet == 0)
493 fprintf(stdout, "Unit is ready\n");
494 } else {
495 if (quiet == 0)
496 fprintf(stdout, "Unit is not ready\n");
497 error = 1;
498
499 if (arglist & CAM_ARG_VERBOSE) {
500 cam_error_print(device, ccb, CAM_ESF_ALL,
501 CAM_EPF_ALL, stderr);
502 }
503 }
504
505 cam_freeccb(ccb);
506
507 return(error);
508 }
509
510 static int
511 scsistart(struct cam_device *device, int startstop, int loadeject,
512 int retry_count, int timeout)
513 {
514 union ccb *ccb;
515 int error = 0;
516
517 ccb = cam_getccb(device);
518
519 /*
520 * If we're stopping, send an ordered tag so the drive in question
521 * will finish any previously queued writes before stopping. If
522 * the device isn't capable of tagged queueing, or if tagged
523 * queueing is turned off, the tag action is a no-op.
524 */
525 scsi_start_stop(&ccb->csio,
526 /* retries */ retry_count,
527 /* cbfcnp */ NULL,
528 /* tag_action */ startstop ? MSG_SIMPLE_Q_TAG :
529 MSG_ORDERED_Q_TAG,
530 /* start/stop */ startstop,
531 /* load_eject */ loadeject,
532 /* immediate */ 0,
533 /* sense_len */ SSD_FULL_SIZE,
534 /* timeout */ timeout ? timeout : 120000);
535
536 /* Disable freezing the device queue */
537 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
538
539 if (arglist & CAM_ARG_ERR_RECOVER)
540 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
541
542 if (cam_send_ccb(device, ccb) < 0) {
543 perror("error sending start unit");
544
545 if (arglist & CAM_ARG_VERBOSE) {
546 cam_error_print(device, ccb, CAM_ESF_ALL,
547 CAM_EPF_ALL, stderr);
548 }
549
550 cam_freeccb(ccb);
551 return(1);
552 }
553
554 if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP)
555 if (startstop) {
556 fprintf(stdout, "Unit started successfully");
557 if (loadeject)
558 fprintf(stdout,", Media loaded\n");
559 else
560 fprintf(stdout,"\n");
561 } else {
562 fprintf(stdout, "Unit stopped successfully");
563 if (loadeject)
564 fprintf(stdout, ", Media ejected\n");
565 else
566 fprintf(stdout, "\n");
567 }
568 else {
569 error = 1;
570 if (startstop)
571 fprintf(stdout,
572 "Error received from start unit command\n");
573 else
574 fprintf(stdout,
575 "Error received from stop unit command\n");
576
577 if (arglist & CAM_ARG_VERBOSE) {
578 cam_error_print(device, ccb, CAM_ESF_ALL,
579 CAM_EPF_ALL, stderr);
580 }
581 }
582
583 cam_freeccb(ccb);
584
585 return(error);
586 }
587
588 static int
589 scsidoinquiry(struct cam_device *device, int argc, char **argv,
590 char *combinedopt, int retry_count, int timeout)
591 {
592 int c;
593 int error = 0;
594
595 while ((c = getopt(argc, argv, combinedopt)) != -1) {
596 switch(c) {
597 case 'D':
598 arglist |= CAM_ARG_GET_STDINQ;
599 break;
600 case 'R':
601 arglist |= CAM_ARG_GET_XFERRATE;
602 break;
603 case 'S':
604 arglist |= CAM_ARG_GET_SERIAL;
605 break;
606 default:
607 break;
608 }
609 }
610
611 /*
612 * If the user didn't specify any inquiry options, he wants all of
613 * them.
614 */
615 if ((arglist & CAM_ARG_INQ_MASK) == 0)
616 arglist |= CAM_ARG_INQ_MASK;
617
618 if (arglist & CAM_ARG_GET_STDINQ)
619 error = scsiinquiry(device, retry_count, timeout);
620
621 if (error != 0)
622 return(error);
623
624 if (arglist & CAM_ARG_GET_SERIAL)
625 scsiserial(device, retry_count, timeout);
626
627 if (error != 0)
628 return(error);
629
630 if (arglist & CAM_ARG_GET_XFERRATE)
631 error = scsixferrate(device);
632
633 return(error);
634 }
635
636 static int
637 scsiinquiry(struct cam_device *device, int retry_count, int timeout)
638 {
639 union ccb *ccb;
640 struct scsi_inquiry_data *inq_buf;
641 int error = 0;
642
643 ccb = cam_getccb(device);
644
645 if (ccb == NULL) {
646 warnx("couldn't allocate CCB");
647 return(1);
648 }
649
650 /* cam_getccb cleans up the header, caller has to zero the payload */
651 bzero(&(&ccb->ccb_h)[1],
652 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
653
654 inq_buf = (struct scsi_inquiry_data *)malloc(
655 sizeof(struct scsi_inquiry_data));
656
657 if (inq_buf == NULL) {
658 cam_freeccb(ccb);
659 warnx("can't malloc memory for inquiry\n");
660 return(1);
661 }
662 bzero(inq_buf, sizeof(*inq_buf));
663
664 /*
665 * Note that although the size of the inquiry buffer is the full
666 * 256 bytes specified in the SCSI spec, we only tell the device
667 * that we have allocated SHORT_INQUIRY_LENGTH bytes. There are
668 * two reasons for this:
669 *
670 * - The SCSI spec says that when a length field is only 1 byte,
671 * a value of 0 will be interpreted as 256. Therefore
672 * scsi_inquiry() will convert an inq_len (which is passed in as
673 * a u_int32_t, but the field in the CDB is only 1 byte) of 256
674 * to 0. Evidently, very few devices meet the spec in that
675 * regard. Some devices, like many Seagate disks, take the 0 as
676 * 0, and don't return any data. One Pioneer DVD-R drive
677 * returns more data than the command asked for.
678 *
679 * So, since there are numerous devices that just don't work
680 * right with the full inquiry size, we don't send the full size.
681 *
682 * - The second reason not to use the full inquiry data length is
683 * that we don't need it here. The only reason we issue a
684 * standard inquiry is to get the vendor name, device name,
685 * and revision so scsi_print_inquiry() can print them.
686 *
687 * If, at some point in the future, more inquiry data is needed for
688 * some reason, this code should use a procedure similar to the
689 * probe code. i.e., issue a short inquiry, and determine from
690 * the additional length passed back from the device how much
691 * inquiry data the device supports. Once the amount the device
692 * supports is determined, issue an inquiry for that amount and no
693 * more.
694 *
695 * KDM, 2/18/2000
696 */
697 scsi_inquiry(&ccb->csio,
698 /* retries */ retry_count,
699 /* cbfcnp */ NULL,
700 /* tag_action */ MSG_SIMPLE_Q_TAG,
701 /* inq_buf */ (u_int8_t *)inq_buf,
702 /* inq_len */ SHORT_INQUIRY_LENGTH,
703 /* evpd */ 0,
704 /* page_code */ 0,
705 /* sense_len */ SSD_FULL_SIZE,
706 /* timeout */ timeout ? timeout : 5000);
707
708 /* Disable freezing the device queue */
709 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
710
711 if (arglist & CAM_ARG_ERR_RECOVER)
712 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
713
714 if (cam_send_ccb(device, ccb) < 0) {
715 perror("error sending SCSI inquiry");
716
717 if (arglist & CAM_ARG_VERBOSE) {
718 cam_error_print(device, ccb, CAM_ESF_ALL,
719 CAM_EPF_ALL, stderr);
720 }
721
722 cam_freeccb(ccb);
723 return(1);
724 }
725
726 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
727 error = 1;
728
729 if (arglist & CAM_ARG_VERBOSE) {
730 cam_error_print(device, ccb, CAM_ESF_ALL,
731 CAM_EPF_ALL, stderr);
732 }
733 }
734
735 cam_freeccb(ccb);
736
737 if (error != 0) {
738 free(inq_buf);
739 return(error);
740 }
741
742 fprintf(stdout, "%s%d: ", device->device_name,
743 device->dev_unit_num);
744 scsi_print_inquiry(inq_buf);
745
746 free(inq_buf);
747
748 return(0);
749 }
750
751 static int
752 scsiserial(struct cam_device *device, int retry_count, int timeout)
753 {
754 union ccb *ccb;
755 struct scsi_vpd_unit_serial_number *serial_buf;
756 char serial_num[SVPD_SERIAL_NUM_SIZE + 1];
757 int error = 0;
758
759 ccb = cam_getccb(device);
760
761 if (ccb == NULL) {
762 warnx("couldn't allocate CCB");
763 return(1);
764 }
765
766 /* cam_getccb cleans up the header, caller has to zero the payload */
767 bzero(&(&ccb->ccb_h)[1],
768 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
769
770 serial_buf = (struct scsi_vpd_unit_serial_number *)
771 malloc(sizeof(*serial_buf));
772
773 if (serial_buf == NULL) {
774 cam_freeccb(ccb);
775 warnx("can't malloc memory for serial number");
776 return(1);
777 }
778
779 scsi_inquiry(&ccb->csio,
780 /*retries*/ retry_count,
781 /*cbfcnp*/ NULL,
782 /* tag_action */ MSG_SIMPLE_Q_TAG,
783 /* inq_buf */ (u_int8_t *)serial_buf,
784 /* inq_len */ sizeof(*serial_buf),
785 /* evpd */ 1,
786 /* page_code */ SVPD_UNIT_SERIAL_NUMBER,
787 /* sense_len */ SSD_FULL_SIZE,
788 /* timeout */ timeout ? timeout : 5000);
789
790 /* Disable freezing the device queue */
791 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
792
793 if (arglist & CAM_ARG_ERR_RECOVER)
794 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
795
796 if (cam_send_ccb(device, ccb) < 0) {
797 warn("error getting serial number");
798
799 if (arglist & CAM_ARG_VERBOSE) {
800 cam_error_print(device, ccb, CAM_ESF_ALL,
801 CAM_EPF_ALL, stderr);
802 }
803
804 cam_freeccb(ccb);
805 free(serial_buf);
806 return(1);
807 }
808
809 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
810 error = 1;
811
812 if (arglist & CAM_ARG_VERBOSE) {
813 cam_error_print(device, ccb, CAM_ESF_ALL,
814 CAM_EPF_ALL, stderr);
815 }
816 }
817
818 cam_freeccb(ccb);
819
820 if (error != 0) {
821 free(serial_buf);
822 return(error);
823 }
824
825 bcopy(serial_buf->serial_num, serial_num, serial_buf->length);
826 serial_num[serial_buf->length] = '\0';
827
828 if ((arglist & CAM_ARG_GET_STDINQ)
829 || (arglist & CAM_ARG_GET_XFERRATE))
830 fprintf(stdout, "%s%d: Serial Number ",
831 device->device_name, device->dev_unit_num);
832
833 fprintf(stdout, "%.60s\n", serial_num);
834
835 free(serial_buf);
836
837 return(0);
838 }
839
840 static int
841 scsixferrate(struct cam_device *device)
842 {
843 u_int32_t freq;
844 u_int32_t speed;
845 union ccb *ccb;
846 u_int mb;
847 int retval = 0;
848
849 ccb = cam_getccb(device);
850
851 if (ccb == NULL) {
852 warnx("couldn't allocate CCB");
853 return(1);
854 }
855
856 bzero(&(&ccb->ccb_h)[1],
857 sizeof(struct ccb_trans_settings) - sizeof(struct ccb_hdr));
858
859 ccb->ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
860 ccb->cts.flags = CCB_TRANS_CURRENT_SETTINGS;
861
862 if (((retval = cam_send_ccb(device, ccb)) < 0)
863 || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
864 const char error_string[] = "error getting transfer settings";
865
866 if (retval < 0)
867 warn(error_string);
868 else
869 warnx(error_string);
870
871 if (arglist & CAM_ARG_VERBOSE)
872 cam_error_print(device, ccb, CAM_ESF_ALL,
873 CAM_EPF_ALL, stderr);
874
875 retval = 1;
876
877 goto xferrate_bailout;
878
879 }
880
881 if (((ccb->cts.valid & CCB_TRANS_SYNC_OFFSET_VALID) != 0)
882 && (ccb->cts.sync_offset != 0)) {
883 freq = scsi_calc_syncsrate(ccb->cts.sync_period);
884 speed = freq;
885 } else {
886 struct ccb_pathinq cpi;
887
888 retval = get_cpi(device, &cpi);
889
890 if (retval != 0)
891 goto xferrate_bailout;
892
893 speed = cpi.base_transfer_speed;
894 freq = 0;
895 }
896
897 fprintf(stdout, "%s%d: ", device->device_name,
898 device->dev_unit_num);
899
900 if ((ccb->cts.valid & CCB_TRANS_BUS_WIDTH_VALID) != 0)
901 speed *= (0x01 << device->bus_width);
902
903 mb = speed / 1000;
904
905 if (mb > 0)
906 fprintf(stdout, "%d.%03dMB/s transfers ",
907 mb, speed % 1000);
908 else
909 fprintf(stdout, "%dKB/s transfers ",
910 speed);
911
912 if (((ccb->cts.valid & CCB_TRANS_SYNC_OFFSET_VALID) != 0)
913 && (ccb->cts.sync_offset != 0))
914 fprintf(stdout, "(%d.%03dMHz, offset %d", freq / 1000,
915 freq % 1000, ccb->cts.sync_offset);
916
917 if (((ccb->cts.valid & CCB_TRANS_BUS_WIDTH_VALID) != 0)
918 && (ccb->cts.bus_width > 0)) {
919 if (((ccb->cts.valid & CCB_TRANS_SYNC_OFFSET_VALID) != 0)
920 && (ccb->cts.sync_offset != 0)) {
921 fprintf(stdout, ", ");
922 } else {
923 fprintf(stdout, " (");
924 }
925 fprintf(stdout, "%dbit)", 8 * (0x01 << ccb->cts.bus_width));
926 } else if (((ccb->cts.valid & CCB_TRANS_SYNC_OFFSET_VALID) != 0)
927 && (ccb->cts.sync_offset != 0)) {
928 fprintf(stdout, ")");
929 }
930
931 if (((ccb->cts.valid & CCB_TRANS_TQ_VALID) != 0)
932 && (ccb->cts.flags & CCB_TRANS_TAG_ENB))
933 fprintf(stdout, ", Tagged Queueing Enabled");
934
935 fprintf(stdout, "\n");
936
937 xferrate_bailout:
938
939 cam_freeccb(ccb);
940
941 return(retval);
942 }
943 #endif /* MINIMALISTIC */
944
945 /*
946 * Parse out a bus, or a bus, target and lun in the following
947 * format:
948 * bus
949 * bus:target
950 * bus:target:lun
951 *
952 * Returns the number of parsed components, or 0.
953 */
954 static int
955 parse_btl(char *tstr, int *mybus, int *mytarget, int *mylun,
956 cam_argmask *myarglist)
957 {
958 char *tmpstr;
959 int convs = 0;
960
961 while (isspace(*tstr) && (*tstr != '\0'))
962 tstr++;
963
964 tmpstr = (char *)strtok(tstr, ":");
965 if ((tmpstr != NULL) && (*tmpstr != '\0')) {
966 *mybus = strtol(tmpstr, NULL, 0);
967 *myarglist |= CAM_ARG_BUS;
968 convs++;
969 tmpstr = (char *)strtok(NULL, ":");
970 if ((tmpstr != NULL) && (*tmpstr != '\0')) {
971 *mytarget = strtol(tmpstr, NULL, 0);
972 *myarglist |= CAM_ARG_TARGET;
973 convs++;
974 tmpstr = (char *)strtok(NULL, ":");
975 if ((tmpstr != NULL) && (*tmpstr != '\0')) {
976 *mylun = strtol(tmpstr, NULL, 0);
977 *myarglist |= CAM_ARG_LUN;
978 convs++;
979 }
980 }
981 }
982
983 return convs;
984 }
985
986 static int
987 dorescan_or_reset(int argc, char **argv, int rescan)
988 {
989 static const char must[] =
990 "you must specify \"all\", a bus, or a bus:target:lun to %s";
991 int rv, error = 0;
992 int mybus = -1, mytarget = -1, mylun = -1;
993 char *tstr;
994
995 if (argc < 3) {
996 warnx(must, rescan? "rescan" : "reset");
997 return(1);
998 }
999
1000 tstr = argv[optind];
1001 while (isspace(*tstr) && (*tstr != '\0'))
1002 tstr++;
1003 if (strncasecmp(tstr, "all", strlen("all")) == 0)
1004 arglist |= CAM_ARG_BUS;
1005 else {
1006 rv = parse_btl(argv[optind], &mybus, &mytarget, &mylun,
1007 &arglist);
1008 if (rv != 1 && rv != 3) {
1009 warnx(must, rescan? "rescan" : "reset");
1010 return(1);
1011 }
1012 }
1013
1014 if ((arglist & CAM_ARG_BUS)
1015 && (arglist & CAM_ARG_TARGET)
1016 && (arglist & CAM_ARG_LUN))
1017 error = scanlun_or_reset_dev(mybus, mytarget, mylun, rescan);
1018 else
1019 error = rescan_or_reset_bus(mybus, rescan);
1020
1021 return(error);
1022 }
1023
1024 static int
1025 rescan_or_reset_bus(int mybus, int rescan)
1026 {
1027 union ccb ccb, matchccb;
1028 int fd, retval;
1029 int bufsize;
1030
1031 retval = 0;
1032
1033 if ((fd = open(XPT_DEVICE, O_RDWR)) < 0) {
1034 warnx("error opening transport layer device %s", XPT_DEVICE);
1035 warn("%s", XPT_DEVICE);
1036 return(1);
1037 }
1038
1039 if (mybus != -1) {
1040 ccb.ccb_h.func_code = rescan ? XPT_SCAN_BUS : XPT_RESET_BUS;
1041 ccb.ccb_h.path_id = mybus;
1042 ccb.ccb_h.target_id = CAM_TARGET_WILDCARD;
1043 ccb.ccb_h.target_lun = CAM_LUN_WILDCARD;
1044 ccb.crcn.flags = CAM_FLAG_NONE;
1045
1046 /* run this at a low priority */
1047 ccb.ccb_h.pinfo.priority = 5;
1048
1049 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
1050 warn("CAMIOCOMMAND ioctl failed");
1051 close(fd);
1052 return(1);
1053 }
1054
1055 if ((ccb.ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
1056 fprintf(stdout, "%s of bus %d was successful\n",
1057 rescan ? "Re-scan" : "Reset", mybus);
1058 } else {
1059 fprintf(stdout, "%s of bus %d returned error %#x\n",
1060 rescan ? "Re-scan" : "Reset", mybus,
1061 ccb.ccb_h.status & CAM_STATUS_MASK);
1062 retval = 1;
1063 }
1064
1065 close(fd);
1066 return(retval);
1067
1068 }
1069
1070
1071 /*
1072 * The right way to handle this is to modify the xpt so that it can
1073 * handle a wildcarded bus in a rescan or reset CCB. At the moment
1074 * that isn't implemented, so instead we enumerate the busses and
1075 * send the rescan or reset to those busses in the case where the
1076 * given bus is -1 (wildcard). We don't send a rescan or reset
1077 * to the xpt bus; sending a rescan to the xpt bus is effectively a
1078 * no-op, sending a rescan to the xpt bus would result in a status of
1079 * CAM_REQ_INVALID.
1080 */
1081 bzero(&(&matchccb.ccb_h)[1],
1082 sizeof(struct ccb_dev_match) - sizeof(struct ccb_hdr));
1083 matchccb.ccb_h.func_code = XPT_DEV_MATCH;
1084 bufsize = sizeof(struct dev_match_result) * 20;
1085 matchccb.cdm.match_buf_len = bufsize;
1086 matchccb.cdm.matches=(struct dev_match_result *)malloc(bufsize);
1087 if (matchccb.cdm.matches == NULL) {
1088 warnx("can't malloc memory for matches");
1089 retval = 1;
1090 goto bailout;
1091 }
1092 matchccb.cdm.num_matches = 0;
1093
1094 matchccb.cdm.num_patterns = 1;
1095 matchccb.cdm.pattern_buf_len = sizeof(struct dev_match_pattern);
1096
1097 matchccb.cdm.patterns = (struct dev_match_pattern *)malloc(
1098 matchccb.cdm.pattern_buf_len);
1099 if (matchccb.cdm.patterns == NULL) {
1100 warnx("can't malloc memory for patterns");
1101 retval = 1;
1102 goto bailout;
1103 }
1104 matchccb.cdm.patterns[0].type = DEV_MATCH_BUS;
1105 matchccb.cdm.patterns[0].pattern.bus_pattern.flags = BUS_MATCH_ANY;
1106
1107 do {
1108 unsigned int i;
1109
1110 if (ioctl(fd, CAMIOCOMMAND, &matchccb) == -1) {
1111 warn("CAMIOCOMMAND ioctl failed");
1112 retval = 1;
1113 goto bailout;
1114 }
1115
1116 if ((matchccb.ccb_h.status != CAM_REQ_CMP)
1117 || ((matchccb.cdm.status != CAM_DEV_MATCH_LAST)
1118 && (matchccb.cdm.status != CAM_DEV_MATCH_MORE))) {
1119 warnx("got CAM error %#x, CDM error %d\n",
1120 matchccb.ccb_h.status, matchccb.cdm.status);
1121 retval = 1;
1122 goto bailout;
1123 }
1124
1125 for (i = 0; i < matchccb.cdm.num_matches; i++) {
1126 struct bus_match_result *bus_result;
1127
1128 /* This shouldn't happen. */
1129 if (matchccb.cdm.matches[i].type != DEV_MATCH_BUS)
1130 continue;
1131
1132 bus_result = &matchccb.cdm.matches[i].result.bus_result;
1133
1134 /*
1135 * We don't want to rescan or reset the xpt bus.
1136 * See above.
1137 */
1138 if ((int)bus_result->path_id == -1)
1139 continue;
1140
1141 ccb.ccb_h.func_code = rescan ? XPT_SCAN_BUS :
1142 XPT_RESET_BUS;
1143 ccb.ccb_h.path_id = bus_result->path_id;
1144 ccb.ccb_h.target_id = CAM_TARGET_WILDCARD;
1145 ccb.ccb_h.target_lun = CAM_LUN_WILDCARD;
1146 ccb.crcn.flags = CAM_FLAG_NONE;
1147
1148 /* run this at a low priority */
1149 ccb.ccb_h.pinfo.priority = 5;
1150
1151 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
1152 warn("CAMIOCOMMAND ioctl failed");
1153 retval = 1;
1154 goto bailout;
1155 }
1156
1157 if ((ccb.ccb_h.status & CAM_STATUS_MASK) ==CAM_REQ_CMP){
1158 fprintf(stdout, "%s of bus %d was successful\n",
1159 rescan? "Re-scan" : "Reset",
1160 bus_result->path_id);
1161 } else {
1162 /*
1163 * Don't bail out just yet, maybe the other
1164 * rescan or reset commands will complete
1165 * successfully.
1166 */
1167 fprintf(stderr, "%s of bus %d returned error "
1168 "%#x\n", rescan? "Re-scan" : "Reset",
1169 bus_result->path_id,
1170 ccb.ccb_h.status & CAM_STATUS_MASK);
1171 retval = 1;
1172 }
1173 }
1174 } while ((matchccb.ccb_h.status == CAM_REQ_CMP)
1175 && (matchccb.cdm.status == CAM_DEV_MATCH_MORE));
1176
1177 bailout:
1178
1179 if (fd != -1)
1180 close(fd);
1181
1182 if (matchccb.cdm.patterns != NULL)
1183 free(matchccb.cdm.patterns);
1184 if (matchccb.cdm.matches != NULL)
1185 free(matchccb.cdm.matches);
1186
1187 return(retval);
1188 }
1189
1190 static int
1191 scanlun_or_reset_dev(int mybus, int mytarget, int mylun, int scan)
1192 {
1193 union ccb ccb;
1194 struct cam_device *device;
1195 int fd;
1196
1197 device = NULL;
1198
1199 if (mybus < 0) {
1200 warnx("invalid bus number %d", mybus);
1201 return(1);
1202 }
1203
1204 if (mytarget < 0) {
1205 warnx("invalid target number %d", mytarget);
1206 return(1);
1207 }
1208
1209 if (mylun < 0) {
1210 warnx("invalid lun number %d", mylun);
1211 return(1);
1212 }
1213
1214 fd = -1;
1215
1216 bzero(&ccb, sizeof(union ccb));
1217
1218 if (scan) {
1219 if ((fd = open(XPT_DEVICE, O_RDWR)) < 0) {
1220 warnx("error opening transport layer device %s\n",
1221 XPT_DEVICE);
1222 warn("%s", XPT_DEVICE);
1223 return(1);
1224 }
1225 } else {
1226 device = cam_open_btl(mybus, mytarget, mylun, O_RDWR, NULL);
1227 if (device == NULL) {
1228 warnx("%s", cam_errbuf);
1229 return(1);
1230 }
1231 }
1232
1233 ccb.ccb_h.func_code = (scan)? XPT_SCAN_LUN : XPT_RESET_DEV;
1234 ccb.ccb_h.path_id = mybus;
1235 ccb.ccb_h.target_id = mytarget;
1236 ccb.ccb_h.target_lun = mylun;
1237 ccb.ccb_h.timeout = 5000;
1238 ccb.crcn.flags = CAM_FLAG_NONE;
1239
1240 /* run this at a low priority */
1241 ccb.ccb_h.pinfo.priority = 5;
1242
1243 if (scan) {
1244 if (ioctl(fd, CAMIOCOMMAND, &ccb) < 0) {
1245 warn("CAMIOCOMMAND ioctl failed");
1246 close(fd);
1247 return(1);
1248 }
1249 } else {
1250 if (cam_send_ccb(device, &ccb) < 0) {
1251 warn("error sending XPT_RESET_DEV CCB");
1252 cam_close_device(device);
1253 return(1);
1254 }
1255 }
1256
1257 if (scan)
1258 close(fd);
1259 else
1260 cam_close_device(device);
1261
1262 /*
1263 * An error code of CAM_BDR_SENT is normal for a BDR request.
1264 */
1265 if (((ccb.ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP)
1266 || ((!scan)
1267 && ((ccb.ccb_h.status & CAM_STATUS_MASK) == CAM_BDR_SENT))) {
1268 fprintf(stdout, "%s of %d:%d:%d was successful\n",
1269 scan? "Re-scan" : "Reset", mybus, mytarget, mylun);
1270 return(0);
1271 } else {
1272 fprintf(stdout, "%s of %d:%d:%d returned error %#x\n",
1273 scan? "Re-scan" : "Reset", mybus, mytarget, mylun,
1274 ccb.ccb_h.status & CAM_STATUS_MASK);
1275 return(1);
1276 }
1277 }
1278
1279 #ifndef MINIMALISTIC
1280 static int
1281 readdefects(struct cam_device *device, int argc, char **argv,
1282 char *combinedopt, int retry_count, int timeout)
1283 {
1284 union ccb *ccb = NULL;
1285 struct scsi_read_defect_data_10 *rdd_cdb;
1286 u_int8_t *defect_list = NULL;
1287 u_int32_t dlist_length = 65000;
1288 u_int32_t returned_length = 0;
1289 u_int32_t num_returned = 0;
1290 u_int8_t returned_format;
1291 unsigned int i;
1292 int c, error = 0;
1293 int lists_specified = 0;
1294
1295 while ((c = getopt(argc, argv, combinedopt)) != -1) {
1296 switch(c){
1297 case 'f':
1298 {
1299 char *tstr;
1300 tstr = optarg;
1301 while (isspace(*tstr) && (*tstr != '\0'))
1302 tstr++;
1303 if (strcmp(tstr, "block") == 0)
1304 arglist |= CAM_ARG_FORMAT_BLOCK;
1305 else if (strcmp(tstr, "bfi") == 0)
1306 arglist |= CAM_ARG_FORMAT_BFI;
1307 else if (strcmp(tstr, "phys") == 0)
1308 arglist |= CAM_ARG_FORMAT_PHYS;
1309 else {
1310 error = 1;
1311 warnx("invalid defect format %s", tstr);
1312 goto defect_bailout;
1313 }
1314 break;
1315 }
1316 case 'G':
1317 arglist |= CAM_ARG_GLIST;
1318 break;
1319 case 'P':
1320 arglist |= CAM_ARG_PLIST;
1321 break;
1322 default:
1323 break;
1324 }
1325 }
1326
1327 ccb = cam_getccb(device);
1328
1329 /*
1330 * Hopefully 65000 bytes is enough to hold the defect list. If it
1331 * isn't, the disk is probably dead already. We'd have to go with
1332 * 12 byte command (i.e. alloc_length is 32 bits instead of 16)
1333 * to hold them all.
1334 */
1335 defect_list = malloc(dlist_length);
1336 if (defect_list == NULL) {
1337 warnx("can't malloc memory for defect list");
1338 error = 1;
1339 goto defect_bailout;
1340 }
1341
1342 rdd_cdb =(struct scsi_read_defect_data_10 *)&ccb->csio.cdb_io.cdb_bytes;
1343
1344 /*
1345 * cam_getccb() zeros the CCB header only. So we need to zero the
1346 * payload portion of the ccb.
1347 */
1348 bzero(&(&ccb->ccb_h)[1],
1349 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
1350
1351 cam_fill_csio(&ccb->csio,
1352 /*retries*/ retry_count,
1353 /*cbfcnp*/ NULL,
1354 /*flags*/ CAM_DIR_IN | ((arglist & CAM_ARG_ERR_RECOVER) ?
1355 CAM_PASS_ERR_RECOVER : 0),
1356 /*tag_action*/ MSG_SIMPLE_Q_TAG,
1357 /*data_ptr*/ defect_list,
1358 /*dxfer_len*/ dlist_length,
1359 /*sense_len*/ SSD_FULL_SIZE,
1360 /*cdb_len*/ sizeof(struct scsi_read_defect_data_10),
1361 /*timeout*/ timeout ? timeout : 5000);
1362
1363 rdd_cdb->opcode = READ_DEFECT_DATA_10;
1364 if (arglist & CAM_ARG_FORMAT_BLOCK)
1365 rdd_cdb->format = SRDD10_BLOCK_FORMAT;
1366 else if (arglist & CAM_ARG_FORMAT_BFI)
1367 rdd_cdb->format = SRDD10_BYTES_FROM_INDEX_FORMAT;
1368 else if (arglist & CAM_ARG_FORMAT_PHYS)
1369 rdd_cdb->format = SRDD10_PHYSICAL_SECTOR_FORMAT;
1370 else {
1371 error = 1;
1372 warnx("no defect list format specified");
1373 goto defect_bailout;
1374 }
1375 if (arglist & CAM_ARG_PLIST) {
1376 rdd_cdb->format |= SRDD10_PLIST;
1377 lists_specified++;
1378 }
1379
1380 if (arglist & CAM_ARG_GLIST) {
1381 rdd_cdb->format |= SRDD10_GLIST;
1382 lists_specified++;
1383 }
1384
1385 scsi_ulto2b(dlist_length, rdd_cdb->alloc_length);
1386
1387 /* Disable freezing the device queue */
1388 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
1389
1390 if (cam_send_ccb(device, ccb) < 0) {
1391 perror("error reading defect list");
1392
1393 if (arglist & CAM_ARG_VERBOSE) {
1394 cam_error_print(device, ccb, CAM_ESF_ALL,
1395 CAM_EPF_ALL, stderr);
1396 }
1397
1398 error = 1;
1399 goto defect_bailout;
1400 }
1401
1402 returned_length = scsi_2btoul(((struct
1403 scsi_read_defect_data_hdr_10 *)defect_list)->length);
1404
1405 returned_format = ((struct scsi_read_defect_data_hdr_10 *)
1406 defect_list)->format;
1407
1408 if (((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_SCSI_STATUS_ERROR)
1409 && (ccb->csio.scsi_status == SCSI_STATUS_CHECK_COND)
1410 && ((ccb->ccb_h.status & CAM_AUTOSNS_VALID) != 0)) {
1411 struct scsi_sense_data *sense;
1412 int error_code, sense_key, asc, ascq;
1413
1414 sense = &ccb->csio.sense_data;
1415 scsi_extract_sense(sense, &error_code, &sense_key, &asc, &ascq);
1416
1417 /*
1418 * According to the SCSI spec, if the disk doesn't support
1419 * the requested format, it will generally return a sense
1420 * key of RECOVERED ERROR, and an additional sense code
1421 * of "DEFECT LIST NOT FOUND". So, we check for that, and
1422 * also check to make sure that the returned length is
1423 * greater than 0, and then print out whatever format the
1424 * disk gave us.
1425 */
1426 if ((sense_key == SSD_KEY_RECOVERED_ERROR)
1427 && (asc == 0x1c) && (ascq == 0x00)
1428 && (returned_length > 0)) {
1429 warnx("requested defect format not available");
1430 switch(returned_format & SRDDH10_DLIST_FORMAT_MASK) {
1431 case SRDD10_BLOCK_FORMAT:
1432 warnx("Device returned block format");
1433 break;
1434 case SRDD10_BYTES_FROM_INDEX_FORMAT:
1435 warnx("Device returned bytes from index"
1436 " format");
1437 break;
1438 case SRDD10_PHYSICAL_SECTOR_FORMAT:
1439 warnx("Device returned physical sector format");
1440 break;
1441 default:
1442 error = 1;
1443 warnx("Device returned unknown defect"
1444 " data format %#x", returned_format);
1445 goto defect_bailout;
1446 break; /* NOTREACHED */
1447 }
1448 } else {
1449 error = 1;
1450 warnx("Error returned from read defect data command");
1451 if (arglist & CAM_ARG_VERBOSE)
1452 cam_error_print(device, ccb, CAM_ESF_ALL,
1453 CAM_EPF_ALL, stderr);
1454 goto defect_bailout;
1455 }
1456 } else if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
1457 error = 1;
1458 warnx("Error returned from read defect data command");
1459 if (arglist & CAM_ARG_VERBOSE)
1460 cam_error_print(device, ccb, CAM_ESF_ALL,
1461 CAM_EPF_ALL, stderr);
1462 goto defect_bailout;
1463 }
1464
1465 /*
1466 * XXX KDM I should probably clean up the printout format for the
1467 * disk defects.
1468 */
1469 switch (returned_format & SRDDH10_DLIST_FORMAT_MASK){
1470 case SRDDH10_PHYSICAL_SECTOR_FORMAT:
1471 {
1472 struct scsi_defect_desc_phys_sector *dlist;
1473
1474 dlist = (struct scsi_defect_desc_phys_sector *)
1475 (defect_list +
1476 sizeof(struct scsi_read_defect_data_hdr_10));
1477
1478 num_returned = returned_length /
1479 sizeof(struct scsi_defect_desc_phys_sector);
1480
1481 fprintf(stderr, "Got %d defect", num_returned);
1482
1483 if ((lists_specified == 0) || (num_returned == 0)) {
1484 fprintf(stderr, "s.\n");
1485 break;
1486 } else if (num_returned == 1)
1487 fprintf(stderr, ":\n");
1488 else
1489 fprintf(stderr, "s:\n");
1490
1491 for (i = 0; i < num_returned; i++) {
1492 fprintf(stdout, "%d:%d:%d\n",
1493 scsi_3btoul(dlist[i].cylinder),
1494 dlist[i].head,
1495 scsi_4btoul(dlist[i].sector));
1496 }
1497 break;
1498 }
1499 case SRDDH10_BYTES_FROM_INDEX_FORMAT:
1500 {
1501 struct scsi_defect_desc_bytes_from_index *dlist;
1502
1503 dlist = (struct scsi_defect_desc_bytes_from_index *)
1504 (defect_list +
1505 sizeof(struct scsi_read_defect_data_hdr_10));
1506
1507 num_returned = returned_length /
1508 sizeof(struct scsi_defect_desc_bytes_from_index);
1509
1510 fprintf(stderr, "Got %d defect", num_returned);
1511
1512 if ((lists_specified == 0) || (num_returned == 0)) {
1513 fprintf(stderr, "s.\n");
1514 break;
1515 } else if (num_returned == 1)
1516 fprintf(stderr, ":\n");
1517 else
1518 fprintf(stderr, "s:\n");
1519
1520 for (i = 0; i < num_returned; i++) {
1521 fprintf(stdout, "%d:%d:%d\n",
1522 scsi_3btoul(dlist[i].cylinder),
1523 dlist[i].head,
1524 scsi_4btoul(dlist[i].bytes_from_index));
1525 }
1526 break;
1527 }
1528 case SRDDH10_BLOCK_FORMAT:
1529 {
1530 struct scsi_defect_desc_block *dlist;
1531
1532 dlist = (struct scsi_defect_desc_block *)(defect_list +
1533 sizeof(struct scsi_read_defect_data_hdr_10));
1534
1535 num_returned = returned_length /
1536 sizeof(struct scsi_defect_desc_block);
1537
1538 fprintf(stderr, "Got %d defect", num_returned);
1539
1540 if ((lists_specified == 0) || (num_returned == 0)) {
1541 fprintf(stderr, "s.\n");
1542 break;
1543 } else if (num_returned == 1)
1544 fprintf(stderr, ":\n");
1545 else
1546 fprintf(stderr, "s:\n");
1547
1548 for (i = 0; i < num_returned; i++)
1549 fprintf(stdout, "%u\n",
1550 scsi_4btoul(dlist[i].address));
1551 break;
1552 }
1553 default:
1554 fprintf(stderr, "Unknown defect format %d\n",
1555 returned_format & SRDDH10_DLIST_FORMAT_MASK);
1556 error = 1;
1557 break;
1558 }
1559 defect_bailout:
1560
1561 if (defect_list != NULL)
1562 free(defect_list);
1563
1564 if (ccb != NULL)
1565 cam_freeccb(ccb);
1566
1567 return(error);
1568 }
1569 #endif /* MINIMALISTIC */
1570
1571 #if 0
1572 void
1573 reassignblocks(struct cam_device *device, u_int32_t *blocks, int num_blocks)
1574 {
1575 union ccb *ccb;
1576
1577 ccb = cam_getccb(device);
1578
1579 cam_freeccb(ccb);
1580 }
1581 #endif
1582
1583 #ifndef MINIMALISTIC
1584 void
1585 mode_sense(struct cam_device *device, int mode_page, int page_control,
1586 int dbd, int retry_count, int timeout, u_int8_t *data, int datalen)
1587 {
1588 union ccb *ccb;
1589 int retval;
1590
1591 ccb = cam_getccb(device);
1592
1593 if (ccb == NULL)
1594 errx(1, "mode_sense: couldn't allocate CCB");
1595
1596 bzero(&(&ccb->ccb_h)[1],
1597 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
1598
1599 scsi_mode_sense(&ccb->csio,
1600 /* retries */ retry_count,
1601 /* cbfcnp */ NULL,
1602 /* tag_action */ MSG_SIMPLE_Q_TAG,
1603 /* dbd */ dbd,
1604 /* page_code */ page_control << 6,
1605 /* page */ mode_page,
1606 /* param_buf */ data,
1607 /* param_len */ datalen,
1608 /* sense_len */ SSD_FULL_SIZE,
1609 /* timeout */ timeout ? timeout : 5000);
1610
1611 if (arglist & CAM_ARG_ERR_RECOVER)
1612 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
1613
1614 /* Disable freezing the device queue */
1615 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
1616
1617 if (((retval = cam_send_ccb(device, ccb)) < 0)
1618 || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
1619 if (arglist & CAM_ARG_VERBOSE) {
1620 cam_error_print(device, ccb, CAM_ESF_ALL,
1621 CAM_EPF_ALL, stderr);
1622 }
1623 cam_freeccb(ccb);
1624 cam_close_device(device);
1625 if (retval < 0)
1626 err(1, "error sending mode sense command");
1627 else
1628 errx(1, "error sending mode sense command");
1629 }
1630
1631 cam_freeccb(ccb);
1632 }
1633
1634 void
1635 mode_select(struct cam_device *device, int save_pages, int retry_count,
1636 int timeout, u_int8_t *data, int datalen)
1637 {
1638 union ccb *ccb;
1639 int retval;
1640
1641 ccb = cam_getccb(device);
1642
1643 if (ccb == NULL)
1644 errx(1, "mode_select: couldn't allocate CCB");
1645
1646 bzero(&(&ccb->ccb_h)[1],
1647 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
1648
1649 scsi_mode_select(&ccb->csio,
1650 /* retries */ retry_count,
1651 /* cbfcnp */ NULL,
1652 /* tag_action */ MSG_SIMPLE_Q_TAG,
1653 /* scsi_page_fmt */ 1,
1654 /* save_pages */ save_pages,
1655 /* param_buf */ data,
1656 /* param_len */ datalen,
1657 /* sense_len */ SSD_FULL_SIZE,
1658 /* timeout */ timeout ? timeout : 5000);
1659
1660 if (arglist & CAM_ARG_ERR_RECOVER)
1661 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
1662
1663 /* Disable freezing the device queue */
1664 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
1665
1666 if (((retval = cam_send_ccb(device, ccb)) < 0)
1667 || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
1668 if (arglist & CAM_ARG_VERBOSE) {
1669 cam_error_print(device, ccb, CAM_ESF_ALL,
1670 CAM_EPF_ALL, stderr);
1671 }
1672 cam_freeccb(ccb);
1673 cam_close_device(device);
1674
1675 if (retval < 0)
1676 err(1, "error sending mode select command");
1677 else
1678 errx(1, "error sending mode select command");
1679
1680 }
1681
1682 cam_freeccb(ccb);
1683 }
1684
1685 void
1686 modepage(struct cam_device *device, int argc, char **argv, char *combinedopt,
1687 int retry_count, int timeout)
1688 {
1689 int c, mode_page = -1, page_control = 0;
1690 int binary = 0, list = 0;
1691
1692 while ((c = getopt(argc, argv, combinedopt)) != -1) {
1693 switch(c) {
1694 case 'b':
1695 binary = 1;
1696 break;
1697 case 'd':
1698 arglist |= CAM_ARG_DBD;
1699 break;
1700 case 'e':
1701 arglist |= CAM_ARG_MODE_EDIT;
1702 break;
1703 case 'l':
1704 list = 1;
1705 break;
1706 case 'm':
1707 mode_page = strtol(optarg, NULL, 0);
1708 if (mode_page < 0)
1709 errx(1, "invalid mode page %d", mode_page);
1710 break;
1711 case 'P':
1712 page_control = strtol(optarg, NULL, 0);
1713 if ((page_control < 0) || (page_control > 3))
1714 errx(1, "invalid page control field %d",
1715 page_control);
1716 arglist |= CAM_ARG_PAGE_CNTL;
1717 break;
1718 default:
1719 break;
1720 }
1721 }
1722
1723 if (mode_page == -1 && list == 0)
1724 errx(1, "you must specify a mode page!");
1725
1726 if (list) {
1727 mode_list(device, page_control, arglist & CAM_ARG_DBD,
1728 retry_count, timeout);
1729 } else {
1730 mode_edit(device, mode_page, page_control,
1731 arglist & CAM_ARG_DBD, arglist & CAM_ARG_MODE_EDIT, binary,
1732 retry_count, timeout);
1733 }
1734 }
1735
1736 static int
1737 scsicmd(struct cam_device *device, int argc, char **argv, char *combinedopt,
1738 int retry_count, int timeout)
1739 {
1740 union ccb *ccb;
1741 u_int32_t flags = CAM_DIR_NONE;
1742 u_int8_t *data_ptr = NULL;
1743 u_int8_t cdb[20];
1744 struct get_hook hook;
1745 int c, data_bytes = 0;
1746 int cdb_len = 0;
1747 char *datastr = NULL, *tstr;
1748 int error = 0;
1749 int fd_data = 0;
1750 int retval;
1751
1752 ccb = cam_getccb(device);
1753
1754 if (ccb == NULL) {
1755 warnx("scsicmd: error allocating ccb");
1756 return(1);
1757 }
1758
1759 bzero(&(&ccb->ccb_h)[1],
1760 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
1761
1762 while ((c = getopt(argc, argv, combinedopt)) != -1) {
1763 switch(c) {
1764 case 'c':
1765 tstr = optarg;
1766 while (isspace(*tstr) && (*tstr != '\0'))
1767 tstr++;
1768 hook.argc = argc - optind;
1769 hook.argv = argv + optind;
1770 hook.got = 0;
1771 cdb_len = buff_encode_visit(cdb, sizeof(cdb), tstr,
1772 iget, &hook);
1773 /*
1774 * Increment optind by the number of arguments the
1775 * encoding routine processed. After each call to
1776 * getopt(3), optind points to the argument that
1777 * getopt should process _next_. In this case,
1778 * that means it points to the first command string
1779 * argument, if there is one. Once we increment
1780 * this, it should point to either the next command
1781 * line argument, or it should be past the end of
1782 * the list.
1783 */
1784 optind += hook.got;
1785 break;
1786 case 'i':
1787 if (arglist & CAM_ARG_CMD_OUT) {
1788 warnx("command must either be "
1789 "read or write, not both");
1790 error = 1;
1791 goto scsicmd_bailout;
1792 }
1793 arglist |= CAM_ARG_CMD_IN;
1794 flags = CAM_DIR_IN;
1795 data_bytes = strtol(optarg, NULL, 0);
1796 if (data_bytes <= 0) {
1797 warnx("invalid number of input bytes %d",
1798 data_bytes);
1799 error = 1;
1800 goto scsicmd_bailout;
1801 }
1802 hook.argc = argc - optind;
1803 hook.argv = argv + optind;
1804 hook.got = 0;
1805 optind++;
1806 datastr = cget(&hook, NULL);
1807 /*
1808 * If the user supplied "-" instead of a format, he
1809 * wants the data to be written to stdout.
1810 */
1811 if ((datastr != NULL)
1812 && (datastr[0] == '-'))
1813 fd_data = 1;
1814
1815 data_ptr = (u_int8_t *)malloc(data_bytes);
1816 if (data_ptr == NULL) {
1817 warnx("can't malloc memory for data_ptr");
1818 error = 1;
1819 goto scsicmd_bailout;
1820 }
1821 break;
1822 case 'o':
1823 if (arglist & CAM_ARG_CMD_IN) {
1824 warnx("command must either be "
1825 "read or write, not both");
1826 error = 1;
1827 goto scsicmd_bailout;
1828 }
1829 arglist |= CAM_ARG_CMD_OUT;
1830 flags = CAM_DIR_OUT;
1831 data_bytes = strtol(optarg, NULL, 0);
1832 if (data_bytes <= 0) {
1833 warnx("invalid number of output bytes %d",
1834 data_bytes);
1835 error = 1;
1836 goto scsicmd_bailout;
1837 }
1838 hook.argc = argc - optind;
1839 hook.argv = argv + optind;
1840 hook.got = 0;
1841 datastr = cget(&hook, NULL);
1842 data_ptr = (u_int8_t *)malloc(data_bytes);
1843 if (data_ptr == NULL) {
1844 warnx("can't malloc memory for data_ptr");
1845 error = 1;
1846 goto scsicmd_bailout;
1847 }
1848 /*
1849 * If the user supplied "-" instead of a format, he
1850 * wants the data to be read from stdin.
1851 */
1852 if ((datastr != NULL)
1853 && (datastr[0] == '-'))
1854 fd_data = 1;
1855 else
1856 buff_encode_visit(data_ptr, data_bytes, datastr,
1857 iget, &hook);
1858 optind += hook.got;
1859 break;
1860 default:
1861 break;
1862 }
1863 }
1864
1865 /*
1866 * If fd_data is set, and we're writing to the device, we need to
1867 * read the data the user wants written from stdin.
1868 */
1869 if ((fd_data == 1) && (arglist & CAM_ARG_CMD_OUT)) {
1870 ssize_t amt_read;
1871 int amt_to_read = data_bytes;
1872 u_int8_t *buf_ptr = data_ptr;
1873
1874 for (amt_read = 0; amt_to_read > 0;
1875 amt_read = read(STDIN_FILENO, buf_ptr, amt_to_read)) {
1876 if (amt_read == -1) {
1877 warn("error reading data from stdin");
1878 error = 1;
1879 goto scsicmd_bailout;
1880 }
1881 amt_to_read -= amt_read;
1882 buf_ptr += amt_read;
1883 }
1884 }
1885
1886 if (arglist & CAM_ARG_ERR_RECOVER)
1887 flags |= CAM_PASS_ERR_RECOVER;
1888
1889 /* Disable freezing the device queue */
1890 flags |= CAM_DEV_QFRZDIS;
1891
1892 /*
1893 * This is taken from the SCSI-3 draft spec.
1894 * (T10/1157D revision 0.3)
1895 * The top 3 bits of an opcode are the group code. The next 5 bits
1896 * are the command code.
1897 * Group 0: six byte commands
1898 * Group 1: ten byte commands
1899 * Group 2: ten byte commands
1900 * Group 3: reserved
1901 * Group 4: sixteen byte commands
1902 * Group 5: twelve byte commands
1903 * Group 6: vendor specific
1904 * Group 7: vendor specific
1905 */
1906 switch((cdb[0] >> 5) & 0x7) {
1907 case 0:
1908 cdb_len = 6;
1909 break;
1910 case 1:
1911 case 2:
1912 cdb_len = 10;
1913 break;
1914 case 3:
1915 case 6:
1916 case 7:
1917 /* computed by buff_encode_visit */
1918 break;
1919 case 4:
1920 cdb_len = 16;
1921 break;
1922 case 5:
1923 cdb_len = 12;
1924 break;
1925 }
1926
1927 /*
1928 * We should probably use csio_build_visit or something like that
1929 * here, but it's easier to encode arguments as you go. The
1930 * alternative would be skipping the CDB argument and then encoding
1931 * it here, since we've got the data buffer argument by now.
1932 */
1933 bcopy(cdb, &ccb->csio.cdb_io.cdb_bytes, cdb_len);
1934
1935 cam_fill_csio(&ccb->csio,
1936 /*retries*/ retry_count,
1937 /*cbfcnp*/ NULL,
1938 /*flags*/ flags,
1939 /*tag_action*/ MSG_SIMPLE_Q_TAG,
1940 /*data_ptr*/ data_ptr,
1941 /*dxfer_len*/ data_bytes,
1942 /*sense_len*/ SSD_FULL_SIZE,
1943 /*cdb_len*/ cdb_len,
1944 /*timeout*/ timeout ? timeout : 5000);
1945
1946 if (((retval = cam_send_ccb(device, ccb)) < 0)
1947 || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
1948 if (retval < 0)
1949 warn("error sending command");
1950 else
1951 warnx("error sending command");
1952
1953 if (arglist & CAM_ARG_VERBOSE) {
1954 cam_error_print(device, ccb, CAM_ESF_ALL,
1955 CAM_EPF_ALL, stderr);
1956 }
1957
1958 error = 1;
1959 goto scsicmd_bailout;
1960 }
1961
1962
1963 if (((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP)
1964 && (arglist & CAM_ARG_CMD_IN)
1965 && (data_bytes > 0)) {
1966 if (fd_data == 0) {
1967 buff_decode_visit(data_ptr, data_bytes, datastr,
1968 arg_put, NULL);
1969 fprintf(stdout, "\n");
1970 } else {
1971 ssize_t amt_written;
1972 int amt_to_write = data_bytes;
1973 u_int8_t *buf_ptr = data_ptr;
1974
1975 for (amt_written = 0; (amt_to_write > 0) &&
1976 (amt_written =write(1, buf_ptr,amt_to_write))> 0;){
1977 amt_to_write -= amt_written;
1978 buf_ptr += amt_written;
1979 }
1980 if (amt_written == -1) {
1981 warn("error writing data to stdout");
1982 error = 1;
1983 goto scsicmd_bailout;
1984 } else if ((amt_written == 0)
1985 && (amt_to_write > 0)) {
1986 warnx("only wrote %u bytes out of %u",
1987 data_bytes - amt_to_write, data_bytes);
1988 }
1989 }
1990 }
1991
1992 scsicmd_bailout:
1993
1994 if ((data_bytes > 0) && (data_ptr != NULL))
1995 free(data_ptr);
1996
1997 cam_freeccb(ccb);
1998
1999 return(error);
2000 }
2001
2002 static int
2003 camdebug(int argc, char **argv, char *combinedopt)
2004 {
2005 int c, fd;
2006 int mybus = -1, mytarget = -1, mylun = -1;
2007 char *tstr, *tmpstr = NULL;
2008 union ccb ccb;
2009 int error = 0;
2010
2011 bzero(&ccb, sizeof(union ccb));
2012
2013 while ((c = getopt(argc, argv, combinedopt)) != -1) {
2014 switch(c) {
2015 case 'I':
2016 arglist |= CAM_ARG_DEBUG_INFO;
2017 ccb.cdbg.flags |= CAM_DEBUG_INFO;
2018 break;
2019 case 'P':
2020 arglist |= CAM_ARG_DEBUG_PERIPH;
2021 ccb.cdbg.flags |= CAM_DEBUG_PERIPH;
2022 break;
2023 case 'S':
2024 arglist |= CAM_ARG_DEBUG_SUBTRACE;
2025 ccb.cdbg.flags |= CAM_DEBUG_SUBTRACE;
2026 break;
2027 case 'T':
2028 arglist |= CAM_ARG_DEBUG_TRACE;
2029 ccb.cdbg.flags |= CAM_DEBUG_TRACE;
2030 break;
2031 case 'X':
2032 arglist |= CAM_ARG_DEBUG_XPT;
2033 ccb.cdbg.flags |= CAM_DEBUG_XPT;
2034 break;
2035 case 'c':
2036 arglist |= CAM_ARG_DEBUG_CDB;
2037 ccb.cdbg.flags |= CAM_DEBUG_CDB;
2038 break;
2039 default:
2040 break;
2041 }
2042 }
2043
2044 if ((fd = open(XPT_DEVICE, O_RDWR)) < 0) {
2045 warnx("error opening transport layer device %s", XPT_DEVICE);
2046 warn("%s", XPT_DEVICE);
2047 return(1);
2048 }
2049 argc -= optind;
2050 argv += optind;
2051
2052 if (argc <= 0) {
2053 warnx("you must specify \"off\", \"all\" or a bus,");
2054 warnx("bus:target, or bus:target:lun");
2055 close(fd);
2056 return(1);
2057 }
2058
2059 tstr = *argv;
2060
2061 while (isspace(*tstr) && (*tstr != '\0'))
2062 tstr++;
2063
2064 if (strncmp(tstr, "off", 3) == 0) {
2065 ccb.cdbg.flags = CAM_DEBUG_NONE;
2066 arglist &= ~(CAM_ARG_DEBUG_INFO|CAM_ARG_DEBUG_PERIPH|
2067 CAM_ARG_DEBUG_TRACE|CAM_ARG_DEBUG_SUBTRACE|
2068 CAM_ARG_DEBUG_XPT);
2069 } else if (strncmp(tstr, "all", 3) != 0) {
2070 tmpstr = (char *)strtok(tstr, ":");
2071 if ((tmpstr != NULL) && (*tmpstr != '\0')){
2072 mybus = strtol(tmpstr, NULL, 0);
2073 arglist |= CAM_ARG_BUS;
2074 tmpstr = (char *)strtok(NULL, ":");
2075 if ((tmpstr != NULL) && (*tmpstr != '\0')){
2076 mytarget = strtol(tmpstr, NULL, 0);
2077 arglist |= CAM_ARG_TARGET;
2078 tmpstr = (char *)strtok(NULL, ":");
2079 if ((tmpstr != NULL) && (*tmpstr != '\0')){
2080 mylun = strtol(tmpstr, NULL, 0);
2081 arglist |= CAM_ARG_LUN;
2082 }
2083 }
2084 } else {
2085 error = 1;
2086 warnx("you must specify \"all\", \"off\", or a bus,");
2087 warnx("bus:target, or bus:target:lun to debug");
2088 }
2089 }
2090
2091 if (error == 0) {
2092
2093 ccb.ccb_h.func_code = XPT_DEBUG;
2094 ccb.ccb_h.path_id = mybus;
2095 ccb.ccb_h.target_id = mytarget;
2096 ccb.ccb_h.target_lun = mylun;
2097
2098 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
2099 warn("CAMIOCOMMAND ioctl failed");
2100 error = 1;
2101 }
2102
2103 if (error == 0) {
2104 if ((ccb.ccb_h.status & CAM_STATUS_MASK) ==
2105 CAM_FUNC_NOTAVAIL) {
2106 warnx("CAM debugging not available");
2107 warnx("you need to put options CAMDEBUG in"
2108 " your kernel config file!");
2109 error = 1;
2110 } else if ((ccb.ccb_h.status & CAM_STATUS_MASK) !=
2111 CAM_REQ_CMP) {
2112 warnx("XPT_DEBUG CCB failed with status %#x",
2113 ccb.ccb_h.status);
2114 error = 1;
2115 } else {
2116 if (ccb.cdbg.flags == CAM_DEBUG_NONE) {
2117 fprintf(stderr,
2118 "Debugging turned off\n");
2119 } else {
2120 fprintf(stderr,
2121 "Debugging enabled for "
2122 "%d:%d:%d\n",
2123 mybus, mytarget, mylun);
2124 }
2125 }
2126 }
2127 close(fd);
2128 }
2129
2130 return(error);
2131 }
2132
2133 static int
2134 tagcontrol(struct cam_device *device, int argc, char **argv,
2135 char *combinedopt)
2136 {
2137 int c;
2138 union ccb *ccb;
2139 int numtags = -1;
2140 int retval = 0;
2141 int quiet = 0;
2142 char pathstr[1024];
2143
2144 ccb = cam_getccb(device);
2145
2146 if (ccb == NULL) {
2147 warnx("tagcontrol: error allocating ccb");
2148 return(1);
2149 }
2150
2151 while ((c = getopt(argc, argv, combinedopt)) != -1) {
2152 switch(c) {
2153 case 'N':
2154 numtags = strtol(optarg, NULL, 0);
2155 if (numtags < 0) {
2156 warnx("tag count %d is < 0", numtags);
2157 retval = 1;
2158 goto tagcontrol_bailout;
2159 }
2160 break;
2161 case 'q':
2162 quiet++;
2163 break;
2164 default:
2165 break;
2166 }
2167 }
2168
2169 cam_path_string(device, pathstr, sizeof(pathstr));
2170
2171 if (numtags >= 0) {
2172 bzero(&(&ccb->ccb_h)[1],
2173 sizeof(struct ccb_relsim) - sizeof(struct ccb_hdr));
2174 ccb->ccb_h.func_code = XPT_REL_SIMQ;
2175 ccb->crs.release_flags = RELSIM_ADJUST_OPENINGS;
2176 ccb->crs.openings = numtags;
2177
2178
2179 if (cam_send_ccb(device, ccb) < 0) {
2180 perror("error sending XPT_REL_SIMQ CCB");
2181 retval = 1;
2182 goto tagcontrol_bailout;
2183 }
2184
2185 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
2186 warnx("XPT_REL_SIMQ CCB failed");
2187 cam_error_print(device, ccb, CAM_ESF_ALL,
2188 CAM_EPF_ALL, stderr);
2189 retval = 1;
2190 goto tagcontrol_bailout;
2191 }
2192
2193
2194 if (quiet == 0)
2195 fprintf(stdout, "%stagged openings now %d\n",
2196 pathstr, ccb->crs.openings);
2197 }
2198
2199 bzero(&(&ccb->ccb_h)[1],
2200 sizeof(struct ccb_getdevstats) - sizeof(struct ccb_hdr));
2201
2202 ccb->ccb_h.func_code = XPT_GDEV_STATS;
2203
2204 if (cam_send_ccb(device, ccb) < 0) {
2205 perror("error sending XPT_GDEV_STATS CCB");
2206 retval = 1;
2207 goto tagcontrol_bailout;
2208 }
2209
2210 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
2211 warnx("XPT_GDEV_STATS CCB failed");
2212 cam_error_print(device, ccb, CAM_ESF_ALL,
2213 CAM_EPF_ALL, stderr);
2214 retval = 1;
2215 goto tagcontrol_bailout;
2216 }
2217
2218 if (arglist & CAM_ARG_VERBOSE) {
2219 fprintf(stdout, "%s", pathstr);
2220 fprintf(stdout, "dev_openings %d\n", ccb->cgds.dev_openings);
2221 fprintf(stdout, "%s", pathstr);
2222 fprintf(stdout, "dev_active %d\n", ccb->cgds.dev_active);
2223 fprintf(stdout, "%s", pathstr);
2224 fprintf(stdout, "devq_openings %d\n", ccb->cgds.devq_openings);
2225 fprintf(stdout, "%s", pathstr);
2226 fprintf(stdout, "devq_queued %d\n", ccb->cgds.devq_queued);
2227 fprintf(stdout, "%s", pathstr);
2228 fprintf(stdout, "held %d\n", ccb->cgds.held);
2229 fprintf(stdout, "%s", pathstr);
2230 fprintf(stdout, "mintags %d\n", ccb->cgds.mintags);
2231 fprintf(stdout, "%s", pathstr);
2232 fprintf(stdout, "maxtags %d\n", ccb->cgds.maxtags);
2233 } else {
2234 if (quiet == 0) {
2235 fprintf(stdout, "%s", pathstr);
2236 fprintf(stdout, "device openings: ");
2237 }
2238 fprintf(stdout, "%d\n", ccb->cgds.dev_openings +
2239 ccb->cgds.dev_active);
2240 }
2241
2242 tagcontrol_bailout:
2243
2244 cam_freeccb(ccb);
2245 return(retval);
2246 }
2247
2248 static void
2249 cts_print(struct cam_device *device, struct ccb_trans_settings *cts)
2250 {
2251 char pathstr[1024];
2252
2253 cam_path_string(device, pathstr, sizeof(pathstr));
2254
2255 if ((cts->valid & CCB_TRANS_SYNC_RATE_VALID) != 0) {
2256
2257 fprintf(stdout, "%ssync parameter: %d\n", pathstr,
2258 cts->sync_period);
2259
2260 if (cts->sync_offset != 0) {
2261 u_int freq;
2262
2263 freq = scsi_calc_syncsrate(cts->sync_period);
2264 fprintf(stdout, "%sfrequency: %d.%03dMHz\n", pathstr,
2265 freq / 1000, freq % 1000);
2266 }
2267 }
2268
2269 if (cts->valid & CCB_TRANS_SYNC_OFFSET_VALID)
2270 fprintf(stdout, "%soffset: %d\n", pathstr, cts->sync_offset);
2271
2272 if (cts->valid & CCB_TRANS_BUS_WIDTH_VALID)
2273 fprintf(stdout, "%sbus width: %d bits\n", pathstr,
2274 (0x01 << cts->bus_width) * 8);
2275
2276 if (cts->valid & CCB_TRANS_DISC_VALID)
2277 fprintf(stdout, "%sdisconnection is %s\n", pathstr,
2278 (cts->flags & CCB_TRANS_DISC_ENB) ? "enabled" :
2279 "disabled");
2280
2281 if (cts->valid & CCB_TRANS_TQ_VALID)
2282 fprintf(stdout, "%stagged queueing is %s\n", pathstr,
2283 (cts->flags & CCB_TRANS_TAG_ENB) ? "enabled" :
2284 "disabled");
2285
2286 }
2287
2288 /*
2289 * Get a path inquiry CCB for the specified device.
2290 */
2291 static int
2292 get_cpi(struct cam_device *device, struct ccb_pathinq *cpi)
2293 {
2294 union ccb *ccb;
2295 int retval = 0;
2296
2297 ccb = cam_getccb(device);
2298
2299 if (ccb == NULL) {
2300 warnx("get_cpi: couldn't allocate CCB");
2301 return(1);
2302 }
2303
2304 bzero(&(&ccb->ccb_h)[1],
2305 sizeof(struct ccb_pathinq) - sizeof(struct ccb_hdr));
2306
2307 ccb->ccb_h.func_code = XPT_PATH_INQ;
2308
2309 if (cam_send_ccb(device, ccb) < 0) {
2310 warn("get_cpi: error sending Path Inquiry CCB");
2311
2312 if (arglist & CAM_ARG_VERBOSE)
2313 cam_error_print(device, ccb, CAM_ESF_ALL,
2314 CAM_EPF_ALL, stderr);
2315
2316 retval = 1;
2317
2318 goto get_cpi_bailout;
2319 }
2320
2321 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
2322
2323 if (arglist & CAM_ARG_VERBOSE)
2324 cam_error_print(device, ccb, CAM_ESF_ALL,
2325 CAM_EPF_ALL, stderr);
2326
2327 retval = 1;
2328
2329 goto get_cpi_bailout;
2330 }
2331
2332 bcopy(&ccb->cpi, cpi, sizeof(struct ccb_pathinq));
2333
2334 get_cpi_bailout:
2335
2336 cam_freeccb(ccb);
2337
2338 return(retval);
2339 }
2340
2341 static void
2342 cpi_print(struct ccb_pathinq *cpi)
2343 {
2344 char adapter_str[1024];
2345 int i;
2346
2347 snprintf(adapter_str, sizeof(adapter_str),
2348 "%s%d:", cpi->dev_name, cpi->unit_number);
2349
2350 fprintf(stdout, "%s SIM/HBA version: %d\n", adapter_str,
2351 cpi->version_num);
2352
2353 for (i = 1; i < 0xff; i = i << 1) {
2354 const char *str;
2355
2356 if ((i & cpi->hba_inquiry) == 0)
2357 continue;
2358
2359 fprintf(stdout, "%s supports ", adapter_str);
2360
2361 switch(i) {
2362 case PI_MDP_ABLE:
2363 str = "MDP message";
2364 break;
2365 case PI_WIDE_32:
2366 str = "32 bit wide SCSI";
2367 break;
2368 case PI_WIDE_16:
2369 str = "16 bit wide SCSI";
2370 break;
2371 case PI_SDTR_ABLE:
2372 str = "SDTR message";
2373 break;
2374 case PI_LINKED_CDB:
2375 str = "linked CDBs";
2376 break;
2377 case PI_TAG_ABLE:
2378 str = "tag queue messages";
2379 break;
2380 case PI_SOFT_RST:
2381 str = "soft reset alternative";
2382 break;
2383 default:
2384 str = "unknown PI bit set";
2385 break;
2386 }
2387 fprintf(stdout, "%s\n", str);
2388 }
2389
2390 for (i = 1; i < 0xff; i = i << 1) {
2391 const char *str;
2392
2393 if ((i & cpi->hba_misc) == 0)
2394 continue;
2395
2396 fprintf(stdout, "%s ", adapter_str);
2397
2398 switch(i) {
2399 case PIM_SCANHILO:
2400 str = "bus scans from high ID to low ID";
2401 break;
2402 case PIM_NOREMOVE:
2403 str = "removable devices not included in scan";
2404 break;
2405 case PIM_NOINITIATOR:
2406 str = "initiator role not supported";
2407 break;
2408 case PIM_NOBUSRESET:
2409 str = "user has disabled initial BUS RESET or"
2410 " controller is in target/mixed mode";
2411 break;
2412 default:
2413 str = "unknown PIM bit set";
2414 break;
2415 }
2416 fprintf(stdout, "%s\n", str);
2417 }
2418
2419 for (i = 1; i < 0xff; i = i << 1) {
2420 const char *str;
2421
2422 if ((i & cpi->target_sprt) == 0)
2423 continue;
2424
2425 fprintf(stdout, "%s supports ", adapter_str);
2426 switch(i) {
2427 case PIT_PROCESSOR:
2428 str = "target mode processor mode";
2429 break;
2430 case PIT_PHASE:
2431 str = "target mode phase cog. mode";
2432 break;
2433 case PIT_DISCONNECT:
2434 str = "disconnects in target mode";
2435 break;
2436 case PIT_TERM_IO:
2437 str = "terminate I/O message in target mode";
2438 break;
2439 case PIT_GRP_6:
2440 str = "group 6 commands in target mode";
2441 break;
2442 case PIT_GRP_7:
2443 str = "group 7 commands in target mode";
2444 break;
2445 default:
2446 str = "unknown PIT bit set";
2447 break;
2448 }
2449
2450 fprintf(stdout, "%s\n", str);
2451 }
2452 fprintf(stdout, "%s HBA engine count: %d\n", adapter_str,
2453 cpi->hba_eng_cnt);
2454 fprintf(stdout, "%s maximum target: %d\n", adapter_str,
2455 cpi->max_target);
2456 fprintf(stdout, "%s maximum LUN: %d\n", adapter_str,
2457 cpi->max_lun);
2458 fprintf(stdout, "%s highest path ID in subsystem: %d\n",
2459 adapter_str, cpi->hpath_id);
2460 fprintf(stdout, "%s initiator ID: %d\n", adapter_str,
2461 cpi->initiator_id);
2462 fprintf(stdout, "%s SIM vendor: %s\n", adapter_str, cpi->sim_vid);
2463 fprintf(stdout, "%s HBA vendor: %s\n", adapter_str, cpi->hba_vid);
2464 fprintf(stdout, "%s bus ID: %d\n", adapter_str, cpi->bus_id);
2465 fprintf(stdout, "%s base transfer speed: ", adapter_str);
2466 if (cpi->base_transfer_speed > 1000)
2467 fprintf(stdout, "%d.%03dMB/sec\n",
2468 cpi->base_transfer_speed / 1000,
2469 cpi->base_transfer_speed % 1000);
2470 else
2471 fprintf(stdout, "%dKB/sec\n",
2472 (cpi->base_transfer_speed % 1000) * 1000);
2473 }
2474
2475 static int
2476 get_print_cts(struct cam_device *device, int user_settings, int quiet,
2477 struct ccb_trans_settings *cts)
2478 {
2479 int retval;
2480 union ccb *ccb;
2481
2482 retval = 0;
2483 ccb = cam_getccb(device);
2484
2485 if (ccb == NULL) {
2486 warnx("get_print_cts: error allocating ccb");
2487 return(1);
2488 }
2489
2490 bzero(&(&ccb->ccb_h)[1],
2491 sizeof(struct ccb_trans_settings) - sizeof(struct ccb_hdr));
2492
2493 ccb->ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
2494
2495 if (user_settings == 0)
2496 ccb->cts.flags = CCB_TRANS_CURRENT_SETTINGS;
2497 else
2498 ccb->cts.flags = CCB_TRANS_USER_SETTINGS;
2499
2500 if (cam_send_ccb(device, ccb) < 0) {
2501 perror("error sending XPT_GET_TRAN_SETTINGS CCB");
2502 if (arglist & CAM_ARG_VERBOSE)
2503 cam_error_print(device, ccb, CAM_ESF_ALL,
2504 CAM_EPF_ALL, stderr);
2505 retval = 1;
2506 goto get_print_cts_bailout;
2507 }
2508
2509 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
2510 warnx("XPT_GET_TRANS_SETTINGS CCB failed");
2511 if (arglist & CAM_ARG_VERBOSE)
2512 cam_error_print(device, ccb, CAM_ESF_ALL,
2513 CAM_EPF_ALL, stderr);
2514 retval = 1;
2515 goto get_print_cts_bailout;
2516 }
2517
2518 if (quiet == 0)
2519 cts_print(device, &ccb->cts);
2520
2521 if (cts != NULL)
2522 bcopy(&ccb->cts, cts, sizeof(struct ccb_trans_settings));
2523
2524 get_print_cts_bailout:
2525
2526 cam_freeccb(ccb);
2527
2528 return(retval);
2529 }
2530
2531 static int
2532 ratecontrol(struct cam_device *device, int retry_count, int timeout,
2533 int argc, char **argv, char *combinedopt)
2534 {
2535 int c;
2536 union ccb *ccb;
2537 int user_settings = 0;
2538 int retval = 0;
2539 int disc_enable = -1, tag_enable = -1;
2540 int offset = -1;
2541 double syncrate = -1;
2542 int bus_width = -1;
2543 int quiet = 0;
2544 int change_settings = 0, send_tur = 0;
2545 struct ccb_pathinq cpi;
2546
2547 ccb = cam_getccb(device);
2548
2549 if (ccb == NULL) {
2550 warnx("ratecontrol: error allocating ccb");
2551 return(1);
2552 }
2553
2554 while ((c = getopt(argc, argv, combinedopt)) != -1) {
2555 switch(c){
2556 case 'a':
2557 send_tur = 1;
2558 break;
2559 case 'c':
2560 user_settings = 0;
2561 break;
2562 case 'D':
2563 if (strncasecmp(optarg, "enable", 6) == 0)
2564 disc_enable = 1;
2565 else if (strncasecmp(optarg, "disable", 7) == 0)
2566 disc_enable = 0;
2567 else {
2568 warnx("-D argument \"%s\" is unknown", optarg);
2569 retval = 1;
2570 goto ratecontrol_bailout;
2571 }
2572 change_settings = 1;
2573 break;
2574 case 'O':
2575 offset = strtol(optarg, NULL, 0);
2576 if (offset < 0) {
2577 warnx("offset value %d is < 0", offset);
2578 retval = 1;
2579 goto ratecontrol_bailout;
2580 }
2581 change_settings = 1;
2582 break;
2583 case 'q':
2584 quiet++;
2585 break;
2586 case 'R':
2587 syncrate = atof(optarg);
2588
2589 if (syncrate < 0) {
2590 warnx("sync rate %f is < 0", syncrate);
2591 retval = 1;
2592 goto ratecontrol_bailout;
2593 }
2594 change_settings = 1;
2595 break;
2596 case 'T':
2597 if (strncasecmp(optarg, "enable", 6) == 0)
2598 tag_enable = 1;
2599 else if (strncasecmp(optarg, "disable", 7) == 0)
2600 tag_enable = 0;
2601 else {
2602 warnx("-T argument \"%s\" is unknown", optarg);
2603 retval = 1;
2604 goto ratecontrol_bailout;
2605 }
2606 change_settings = 1;
2607 break;
2608 case 'U':
2609 user_settings = 1;
2610 break;
2611 case 'W':
2612 bus_width = strtol(optarg, NULL, 0);
2613 if (bus_width < 0) {
2614 warnx("bus width %d is < 0", bus_width);
2615 retval = 1;
2616 goto ratecontrol_bailout;
2617 }
2618 change_settings = 1;
2619 break;
2620 default:
2621 break;
2622 }
2623 }
2624
2625 bzero(&(&ccb->ccb_h)[1],
2626 sizeof(struct ccb_pathinq) - sizeof(struct ccb_hdr));
2627
2628 /*
2629 * Grab path inquiry information, so we can determine whether
2630 * or not the initiator is capable of the things that the user
2631 * requests.
2632 */
2633 ccb->ccb_h.func_code = XPT_PATH_INQ;
2634
2635 if (cam_send_ccb(device, ccb) < 0) {
2636 perror("error sending XPT_PATH_INQ CCB");
2637 if (arglist & CAM_ARG_VERBOSE) {
2638 cam_error_print(device, ccb, CAM_ESF_ALL,
2639 CAM_EPF_ALL, stderr);
2640 }
2641 retval = 1;
2642 goto ratecontrol_bailout;
2643 }
2644
2645 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
2646 warnx("XPT_PATH_INQ CCB failed");
2647 if (arglist & CAM_ARG_VERBOSE) {
2648 cam_error_print(device, ccb, CAM_ESF_ALL,
2649 CAM_EPF_ALL, stderr);
2650 }
2651 retval = 1;
2652 goto ratecontrol_bailout;
2653 }
2654
2655 bcopy(&ccb->cpi, &cpi, sizeof(struct ccb_pathinq));
2656
2657 bzero(&(&ccb->ccb_h)[1],
2658 sizeof(struct ccb_trans_settings) - sizeof(struct ccb_hdr));
2659
2660 if (quiet == 0)
2661 fprintf(stdout, "Current Parameters:\n");
2662
2663 retval = get_print_cts(device, user_settings, quiet, &ccb->cts);
2664
2665 if (retval != 0)
2666 goto ratecontrol_bailout;
2667
2668 if (arglist & CAM_ARG_VERBOSE)
2669 cpi_print(&cpi);
2670
2671 if (change_settings) {
2672 if (disc_enable != -1) {
2673 ccb->cts.valid |= CCB_TRANS_DISC_VALID;
2674 if (disc_enable == 0)
2675 ccb->cts.flags &= ~CCB_TRANS_DISC_ENB;
2676 else
2677 ccb->cts.flags |= CCB_TRANS_DISC_ENB;
2678 } else
2679 ccb->cts.valid &= ~CCB_TRANS_DISC_VALID;
2680
2681 if (tag_enable != -1) {
2682 if ((cpi.hba_inquiry & PI_TAG_ABLE) == 0) {
2683 warnx("HBA does not support tagged queueing, "
2684 "so you cannot modify tag settings");
2685 retval = 1;
2686 goto ratecontrol_bailout;
2687 }
2688
2689 ccb->cts.valid |= CCB_TRANS_TQ_VALID;
2690
2691 if (tag_enable == 0)
2692 ccb->cts.flags &= ~CCB_TRANS_TAG_ENB;
2693 else
2694 ccb->cts.flags |= CCB_TRANS_TAG_ENB;
2695 } else
2696 ccb->cts.valid &= ~CCB_TRANS_TQ_VALID;
2697
2698 if (offset != -1) {
2699 if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) {
2700 warnx("HBA at %s%d is not cable of changing "
2701 "offset", cpi.dev_name,
2702 cpi.unit_number);
2703 retval = 1;
2704 goto ratecontrol_bailout;
2705 }
2706 ccb->cts.valid |= CCB_TRANS_SYNC_OFFSET_VALID;
2707 ccb->cts.sync_offset = offset;
2708 } else
2709 ccb->cts.valid &= ~CCB_TRANS_SYNC_OFFSET_VALID;
2710
2711 if (syncrate != -1) {
2712 int prelim_sync_period;
2713 u_int freq;
2714
2715 if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) {
2716 warnx("HBA at %s%d is not cable of changing "
2717 "transfer rates", cpi.dev_name,
2718 cpi.unit_number);
2719 retval = 1;
2720 goto ratecontrol_bailout;
2721 }
2722
2723 ccb->cts.valid |= CCB_TRANS_SYNC_RATE_VALID;
2724
2725 /*
2726 * The sync rate the user gives us is in MHz.
2727 * We need to translate it into KHz for this
2728 * calculation.
2729 */
2730 syncrate *= 1000;
2731
2732 /*
2733 * Next, we calculate a "preliminary" sync period
2734 * in tenths of a nanosecond.
2735 */
2736 if (syncrate == 0)
2737 prelim_sync_period = 0;
2738 else
2739 prelim_sync_period = 10000000 / syncrate;
2740
2741 ccb->cts.sync_period =
2742 scsi_calc_syncparam(prelim_sync_period);
2743
2744 freq = scsi_calc_syncsrate(ccb->cts.sync_period);
2745 } else
2746 ccb->cts.valid &= ~CCB_TRANS_SYNC_RATE_VALID;
2747
2748 /*
2749 * The bus_width argument goes like this:
2750 * 0 == 8 bit
2751 * 1 == 16 bit
2752 * 2 == 32 bit
2753 * Therefore, if you shift the number of bits given on the
2754 * command line right by 4, you should get the correct
2755 * number.
2756 */
2757 if (bus_width != -1) {
2758
2759 /*
2760 * We might as well validate things here with a
2761 * decipherable error message, rather than what
2762 * will probably be an indecipherable error message
2763 * by the time it gets back to us.
2764 */
2765 if ((bus_width == 16)
2766 && ((cpi.hba_inquiry & PI_WIDE_16) == 0)) {
2767 warnx("HBA does not support 16 bit bus width");
2768 retval = 1;
2769 goto ratecontrol_bailout;
2770 } else if ((bus_width == 32)
2771 && ((cpi.hba_inquiry & PI_WIDE_32) == 0)) {
2772 warnx("HBA does not support 32 bit bus width");
2773 retval = 1;
2774 goto ratecontrol_bailout;
2775 } else if ((bus_width != 8)
2776 && (bus_width != 16)
2777 && (bus_width != 32)) {
2778 warnx("Invalid bus width %d", bus_width);
2779 retval = 1;
2780 goto ratecontrol_bailout;
2781 }
2782
2783 ccb->cts.valid |= CCB_TRANS_BUS_WIDTH_VALID;
2784 ccb->cts.bus_width = bus_width >> 4;
2785 } else
2786 ccb->cts.valid &= ~CCB_TRANS_BUS_WIDTH_VALID;
2787
2788 ccb->ccb_h.func_code = XPT_SET_TRAN_SETTINGS;
2789
2790 if (cam_send_ccb(device, ccb) < 0) {
2791 perror("error sending XPT_SET_TRAN_SETTINGS CCB");
2792 if (arglist & CAM_ARG_VERBOSE) {
2793 cam_error_print(device, ccb, CAM_ESF_ALL,
2794 CAM_EPF_ALL, stderr);
2795 }
2796 retval = 1;
2797 goto ratecontrol_bailout;
2798 }
2799
2800 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
2801 warnx("XPT_SET_TRANS_SETTINGS CCB failed");
2802 if (arglist & CAM_ARG_VERBOSE) {
2803 cam_error_print(device, ccb, CAM_ESF_ALL,
2804 CAM_EPF_ALL, stderr);
2805 }
2806 retval = 1;
2807 goto ratecontrol_bailout;
2808 }
2809 }
2810
2811 if (send_tur) {
2812 retval = testunitready(device, retry_count, timeout,
2813 (arglist & CAM_ARG_VERBOSE) ? 0 : 1);
2814
2815 /*
2816 * If the TUR didn't succeed, just bail.
2817 */
2818 if (retval != 0) {
2819 if (quiet == 0)
2820 fprintf(stderr, "Test Unit Ready failed\n");
2821 goto ratecontrol_bailout;
2822 }
2823
2824 /*
2825 * If the user wants things quiet, there's no sense in
2826 * getting the transfer settings, if we're not going
2827 * to print them.
2828 */
2829 if (quiet != 0)
2830 goto ratecontrol_bailout;
2831
2832 fprintf(stdout, "New Parameters:\n");
2833 retval = get_print_cts(device, user_settings, 0, NULL);
2834 }
2835
2836 ratecontrol_bailout:
2837
2838 cam_freeccb(ccb);
2839 return(retval);
2840 }
2841
2842 static int
2843 scsiformat(struct cam_device *device, int argc, char **argv,
2844 char *combinedopt, int retry_count, int timeout)
2845 {
2846 union ccb *ccb;
2847 int c;
2848 int ycount = 0, quiet = 0;
2849 int error = 0, response = 0, retval = 0;
2850 int use_timeout = 10800 * 1000;
2851 int immediate = 1;
2852 struct format_defect_list_header fh;
2853 u_int8_t *data_ptr = NULL;
2854 u_int32_t dxfer_len = 0;
2855 u_int8_t byte2 = 0;
2856 int num_warnings = 0;
2857 int reportonly = 0;
2858
2859 ccb = cam_getccb(device);
2860
2861 if (ccb == NULL) {
2862 warnx("scsiformat: error allocating ccb");
2863 return(1);
2864 }
2865
2866 bzero(&(&ccb->ccb_h)[1],
2867 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
2868
2869 while ((c = getopt(argc, argv, combinedopt)) != -1) {
2870 switch(c) {
2871 case 'q':
2872 quiet++;
2873 break;
2874 case 'r':
2875 reportonly = 1;
2876 break;
2877 case 'w':
2878 immediate = 0;
2879 break;
2880 case 'y':
2881 ycount++;
2882 break;
2883 }
2884 }
2885
2886 if (reportonly)
2887 goto doreport;
2888
2889 if (quiet == 0) {
2890 fprintf(stdout, "You are about to REMOVE ALL DATA from the "
2891 "following device:\n");
2892
2893 error = scsidoinquiry(device, argc, argv, combinedopt,
2894 retry_count, timeout);
2895
2896 if (error != 0) {
2897 warnx("scsiformat: error sending inquiry");
2898 goto scsiformat_bailout;
2899 }
2900 }
2901
2902 if (ycount == 0) {
2903
2904 do {
2905 char str[1024];
2906
2907 fprintf(stdout, "Are you SURE you want to do "
2908 "this? (yes/no) ");
2909
2910 if (fgets(str, sizeof(str), stdin) != NULL) {
2911
2912 if (strncasecmp(str, "yes", 3) == 0)
2913 response = 1;
2914 else if (strncasecmp(str, "no", 2) == 0)
2915 response = -1;
2916 else {
2917 fprintf(stdout, "Please answer"
2918 " \"yes\" or \"no\"\n");
2919 }
2920 }
2921 } while (response == 0);
2922
2923 if (response == -1) {
2924 error = 1;
2925 goto scsiformat_bailout;
2926 }
2927 }
2928
2929 if (timeout != 0)
2930 use_timeout = timeout;
2931
2932 if (quiet == 0) {
2933 fprintf(stdout, "Current format timeout is %d seconds\n",
2934 use_timeout / 1000);
2935 }
2936
2937 /*
2938 * If the user hasn't disabled questions and didn't specify a
2939 * timeout on the command line, ask them if they want the current
2940 * timeout.
2941 */
2942 if ((ycount == 0)
2943 && (timeout == 0)) {
2944 char str[1024];
2945 int new_timeout = 0;
2946
2947 fprintf(stdout, "Enter new timeout in seconds or press\n"
2948 "return to keep the current timeout [%d] ",
2949 use_timeout / 1000);
2950
2951 if (fgets(str, sizeof(str), stdin) != NULL) {
2952 if (str[0] != '\0')
2953 new_timeout = atoi(str);
2954 }
2955
2956 if (new_timeout != 0) {
2957 use_timeout = new_timeout * 1000;
2958 fprintf(stdout, "Using new timeout value %d\n",
2959 use_timeout / 1000);
2960 }
2961 }
2962
2963 /*
2964 * Keep this outside the if block below to silence any unused
2965 * variable warnings.
2966 */
2967 bzero(&fh, sizeof(fh));
2968
2969 /*
2970 * If we're in immediate mode, we've got to include the format
2971 * header
2972 */
2973 if (immediate != 0) {
2974 fh.byte2 = FU_DLH_IMMED;
2975 data_ptr = (u_int8_t *)&fh;
2976 dxfer_len = sizeof(fh);
2977 byte2 = FU_FMT_DATA;
2978 } else if (quiet == 0) {
2979 fprintf(stdout, "Formatting...");
2980 fflush(stdout);
2981 }
2982
2983 scsi_format_unit(&ccb->csio,
2984 /* retries */ retry_count,
2985 /* cbfcnp */ NULL,
2986 /* tag_action */ MSG_SIMPLE_Q_TAG,
2987 /* byte2 */ byte2,
2988 /* ileave */ 0,
2989 /* data_ptr */ data_ptr,
2990 /* dxfer_len */ dxfer_len,
2991 /* sense_len */ SSD_FULL_SIZE,
2992 /* timeout */ use_timeout);
2993
2994 /* Disable freezing the device queue */
2995 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
2996
2997 if (arglist & CAM_ARG_ERR_RECOVER)
2998 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
2999
3000 if (((retval = cam_send_ccb(device, ccb)) < 0)
3001 || ((immediate == 0)
3002 && ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP))) {
3003 const char errstr[] = "error sending format command";
3004
3005 if (retval < 0)
3006 warn(errstr);
3007 else
3008 warnx(errstr);
3009
3010 if (arglist & CAM_ARG_VERBOSE) {
3011 cam_error_print(device, ccb, CAM_ESF_ALL,
3012 CAM_EPF_ALL, stderr);
3013 }
3014 error = 1;
3015 goto scsiformat_bailout;
3016 }
3017
3018 /*
3019 * If we ran in non-immediate mode, we already checked for errors
3020 * above and printed out any necessary information. If we're in
3021 * immediate mode, we need to loop through and get status
3022 * information periodically.
3023 */
3024 if (immediate == 0) {
3025 if (quiet == 0) {
3026 fprintf(stdout, "Format Complete\n");
3027 }
3028 goto scsiformat_bailout;
3029 }
3030
3031 doreport:
3032 do {
3033 cam_status status;
3034
3035 bzero(&(&ccb->ccb_h)[1],
3036 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
3037
3038 /*
3039 * There's really no need to do error recovery or
3040 * retries here, since we're just going to sit in a
3041 * loop and wait for the device to finish formatting.
3042 */
3043 scsi_test_unit_ready(&ccb->csio,
3044 /* retries */ 0,
3045 /* cbfcnp */ NULL,
3046 /* tag_action */ MSG_SIMPLE_Q_TAG,
3047 /* sense_len */ SSD_FULL_SIZE,
3048 /* timeout */ 5000);
3049
3050 /* Disable freezing the device queue */
3051 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
3052
3053 retval = cam_send_ccb(device, ccb);
3054
3055 /*
3056 * If we get an error from the ioctl, bail out. SCSI
3057 * errors are expected.
3058 */
3059 if (retval < 0) {
3060 warn("error sending CAMIOCOMMAND ioctl");
3061 if (arglist & CAM_ARG_VERBOSE) {
3062 cam_error_print(device, ccb, CAM_ESF_ALL,
3063 CAM_EPF_ALL, stderr);
3064 }
3065 error = 1;
3066 goto scsiformat_bailout;
3067 }
3068
3069 status = ccb->ccb_h.status & CAM_STATUS_MASK;
3070
3071 if ((status != CAM_REQ_CMP)
3072 && (status == CAM_SCSI_STATUS_ERROR)
3073 && ((ccb->ccb_h.status & CAM_AUTOSNS_VALID) != 0)) {
3074 struct scsi_sense_data *sense;
3075 int error_code, sense_key, asc, ascq;
3076
3077 sense = &ccb->csio.sense_data;
3078 scsi_extract_sense(sense, &error_code, &sense_key,
3079 &asc, &ascq);
3080
3081 /*
3082 * According to the SCSI-2 and SCSI-3 specs, a
3083 * drive that is in the middle of a format should
3084 * return NOT READY with an ASC of "logical unit
3085 * not ready, format in progress". The sense key
3086 * specific bytes will then be a progress indicator.
3087 */
3088 if ((sense_key == SSD_KEY_NOT_READY)
3089 && (asc == 0x04) && (ascq == 0x04)) {
3090 if ((sense->extra_len >= 10)
3091 && ((sense->sense_key_spec[0] &
3092 SSD_SCS_VALID) != 0)
3093 && (quiet == 0)) {
3094 int val;
3095 u_int64_t percentage;
3096
3097 val = scsi_2btoul(
3098 &sense->sense_key_spec[1]);
3099 percentage = 10000 * val;
3100
3101 fprintf(stdout,
3102 "\rFormatting: %qd.%02qd %% "
3103 "(%d/%d) done",
3104 percentage / (0x10000 * 100),
3105 (percentage / 0x10000) % 100,
3106 val, 0x10000);
3107 fflush(stdout);
3108 } else if ((quiet == 0)
3109 && (++num_warnings <= 1)) {
3110 warnx("Unexpected SCSI Sense Key "
3111 "Specific value returned "
3112 "during format:");
3113 scsi_sense_print(device, &ccb->csio,
3114 stderr);
3115 warnx("Unable to print status "
3116 "information, but format will "
3117 "proceed.");
3118 warnx("will exit when format is "
3119 "complete");
3120 }
3121 sleep(1);
3122 } else {
3123 warnx("Unexpected SCSI error during format");
3124 cam_error_print(device, ccb, CAM_ESF_ALL,
3125 CAM_EPF_ALL, stderr);
3126 error = 1;
3127 goto scsiformat_bailout;
3128 }
3129
3130 } else if (status != CAM_REQ_CMP) {
3131 warnx("Unexpected CAM status %#x", status);
3132 if (arglist & CAM_ARG_VERBOSE)
3133 cam_error_print(device, ccb, CAM_ESF_ALL,
3134 CAM_EPF_ALL, stderr);
3135 error = 1;
3136 goto scsiformat_bailout;
3137 }
3138
3139 } while((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP);
3140
3141 if (quiet == 0)
3142 fprintf(stdout, "\nFormat Complete\n");
3143
3144 scsiformat_bailout:
3145
3146 cam_freeccb(ccb);
3147
3148 return(error);
3149 }
3150
3151 static int
3152 scsireportluns(struct cam_device *device, int argc, char **argv,
3153 char *combinedopt, int retry_count, int timeout)
3154 {
3155 union ccb *ccb;
3156 int c, countonly, lunsonly;
3157 struct scsi_report_luns_data *lundata;
3158 int alloc_len;
3159 uint8_t report_type;
3160 uint32_t list_len, i, j;
3161 int retval;
3162
3163 retval = 0;
3164 lundata = NULL;
3165 report_type = RPL_REPORT_DEFAULT;
3166 ccb = cam_getccb(device);
3167
3168 if (ccb == NULL) {
3169 warnx("%s: error allocating ccb", __func__);
3170 return (1);
3171 }
3172
3173 bzero(&(&ccb->ccb_h)[1],
3174 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr));
3175
3176 countonly = 0;
3177 lunsonly = 0;
3178
3179 while ((c = getopt(argc, argv, combinedopt)) != -1) {
3180 switch (c) {
3181 case 'c':
3182 countonly++;
3183 break;
3184 case 'l':
3185 lunsonly++;
3186 break;
3187 case 'r':
3188 if (strcasecmp(optarg, "default") == 0)
3189 report_type = RPL_REPORT_DEFAULT;
3190 else if (strcasecmp(optarg, "wellknown") == 0)
3191 report_type = RPL_REPORT_WELLKNOWN;
3192 else if (strcasecmp(optarg, "all") == 0)
3193 report_type = RPL_REPORT_ALL;
3194 else {
3195 warnx("%s: invalid report type \"%s\"",
3196 __func__, optarg);
3197 retval = 1;
3198 goto bailout;
3199 }
3200 break;
3201 default:
3202 break;
3203 }
3204 }
3205
3206 if ((countonly != 0)
3207 && (lunsonly != 0)) {
3208 warnx("%s: you can only specify one of -c or -l", __func__);
3209 retval = 1;
3210 goto bailout;
3211 }
3212 /*
3213 * According to SPC-4, the allocation length must be at least 16
3214 * bytes -- enough for the header and one LUN.
3215 */
3216 alloc_len = sizeof(*lundata) + 8;
3217
3218 retry:
3219
3220 lundata = malloc(alloc_len);
3221
3222 if (lundata == NULL) {
3223 warn("%s: error mallocing %d bytes", __func__, alloc_len);
3224 retval = 1;
3225 goto bailout;
3226 }
3227
3228 scsi_report_luns(&ccb->csio,
3229 /*retries*/ retry_count,
3230 /*cbfcnp*/ NULL,
3231 /*tag_action*/ MSG_SIMPLE_Q_TAG,
3232 /*select_report*/ report_type,
3233 /*rpl_buf*/ lundata,
3234 /*alloc_len*/ alloc_len,
3235 /*sense_len*/ SSD_FULL_SIZE,
3236 /*timeout*/ timeout ? timeout : 5000);
3237
3238 /* Disable freezing the device queue */
3239 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
3240
3241 if (arglist & CAM_ARG_ERR_RECOVER)
3242 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
3243
3244 if (cam_send_ccb(device, ccb) < 0) {
3245 warn("error sending REPORT LUNS command");
3246
3247 if (arglist & CAM_ARG_VERBOSE)
3248 cam_error_print(device, ccb, CAM_ESF_ALL,
3249 CAM_EPF_ALL, stderr);
3250
3251 retval = 1;
3252 goto bailout;
3253 }
3254
3255 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
3256 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr);
3257 retval = 1;
3258 goto bailout;
3259 }
3260
3261
3262 list_len = scsi_4btoul(lundata->length);
3263
3264 /*
3265 * If we need to list the LUNs, and our allocation
3266 * length was too short, reallocate and retry.
3267 */
3268 if ((countonly == 0)
3269 && (list_len > (alloc_len - sizeof(*lundata)))) {
3270 alloc_len = list_len + sizeof(*lundata);
3271 free(lundata);
3272 goto retry;
3273 }
3274
3275 if (lunsonly == 0)
3276 fprintf(stdout, "%u LUN%s found\n", list_len / 8,
3277 ((list_len / 8) > 1) ? "s" : "");
3278
3279 if (countonly != 0)
3280 goto bailout;
3281
3282 for (i = 0; i < (list_len / 8); i++) {
3283 int no_more;
3284
3285 no_more = 0;
3286 for (j = 0; j < sizeof(lundata->luns[i].lundata); j += 2) {
3287 if (j != 0)
3288 fprintf(stdout, ",");
3289 switch (lundata->luns[i].lundata[j] &
3290 RPL_LUNDATA_ATYP_MASK) {
3291 case RPL_LUNDATA_ATYP_PERIPH:
3292 if ((lundata->luns[i].lundata[j] &
3293 RPL_LUNDATA_PERIPH_BUS_MASK) != 0)
3294 fprintf(stdout, "%d:",
3295 lundata->luns[i].lundata[j] &
3296 RPL_LUNDATA_PERIPH_BUS_MASK);
3297 else if ((j == 0)
3298 && ((lundata->luns[i].lundata[j+2] &
3299 RPL_LUNDATA_PERIPH_BUS_MASK) == 0))
3300 no_more = 1;
3301
3302 fprintf(stdout, "%d",
3303 lundata->luns[i].lundata[j+1]);
3304 break;
3305 case RPL_LUNDATA_ATYP_FLAT: {
3306 uint8_t tmplun[2];
3307 tmplun[0] = lundata->luns[i].lundata[j] &
3308 RPL_LUNDATA_FLAT_LUN_MASK;
3309 tmplun[1] = lundata->luns[i].lundata[j+1];
3310
3311 fprintf(stdout, "%d", scsi_2btoul(tmplun));
3312 no_more = 1;
3313 break;
3314 }
3315 case RPL_LUNDATA_ATYP_LUN:
3316 fprintf(stdout, "%d:%d:%d",
3317 (lundata->luns[i].lundata[j+1] &
3318 RPL_LUNDATA_LUN_BUS_MASK) >> 5,
3319 lundata->luns[i].lundata[j] &
3320 RPL_LUNDATA_LUN_TARG_MASK,
3321 lundata->luns[i].lundata[j+1] &
3322 RPL_LUNDATA_LUN_LUN_MASK);
3323 break;
3324 case RPL_LUNDATA_ATYP_EXTLUN: {
3325 int field_len, field_len_code, eam_code;
3326
3327 eam_code = lundata->luns[i].lundata[j] &
3328 RPL_LUNDATA_EXT_EAM_MASK;
3329 field_len_code = (lundata->luns[i].lundata[j] &
3330 RPL_LUNDATA_EXT_LEN_MASK) >> 4;
3331 field_len = field_len_code * 2;
3332
3333 if ((eam_code == RPL_LUNDATA_EXT_EAM_WK)
3334 && (field_len_code == 0x00)) {
3335 fprintf(stdout, "%d",
3336 lundata->luns[i].lundata[j+1]);
3337 } else if ((eam_code ==
3338 RPL_LUNDATA_EXT_EAM_NOT_SPEC)
3339 && (field_len_code == 0x03)) {
3340 uint8_t tmp_lun[8];
3341
3342 /*
3343 * This format takes up all 8 bytes.
3344 * If we aren't starting at offset 0,
3345 * that's a bug.
3346 */
3347 if (j != 0) {
3348 fprintf(stdout, "Invalid "
3349 "offset %d for "
3350 "Extended LUN not "
3351 "specified format", j);
3352 no_more = 1;
3353 break;
3354 }
3355 bzero(tmp_lun, sizeof(tmp_lun));
3356 bcopy(&lundata->luns[i].lundata[j+1],
3357 &tmp_lun[1], sizeof(tmp_lun) - 1);
3358 fprintf(stdout, "%#jx",
3359 (intmax_t)scsi_8btou64(tmp_lun));
3360 no_more = 1;
3361 } else {
3362 fprintf(stderr, "Unknown Extended LUN"
3363 "Address method %#x, length "
3364 "code %#x", eam_code,
3365 field_len_code);
3366 no_more = 1;
3367 }
3368 break;
3369 }
3370 default:
3371 fprintf(stderr, "Unknown LUN address method "
3372 "%#x\n", lundata->luns[i].lundata[0] &
3373 RPL_LUNDATA_ATYP_MASK);
3374 break;
3375 }
3376 /*
3377 * For the flat addressing method, there are no
3378 * other levels after it.
3379 */
3380 if (no_more != 0)
3381 break;
3382 }
3383 fprintf(stdout, "\n");
3384 }
3385
3386 bailout:
3387
3388 cam_freeccb(ccb);
3389
3390 free(lundata);
3391
3392 return (retval);
3393 }
3394
3395 #endif /* MINIMALISTIC */
3396
3397 void
3398 usage(int verbose)
3399 {
3400 fprintf(verbose ? stdout : stderr,
3401 "usage: camcontrol <command> [device id][generic args][command args]\n"
3402 " camcontrol devlist [-v]\n"
3403 #ifndef MINIMALISTIC
3404 " camcontrol periphlist [dev_id][-n dev_name] [-u unit]\n"
3405 " camcontrol tur [dev_id][generic args]\n"
3406 " camcontrol inquiry [dev_id][generic args] [-D] [-S] [-R]\n"
3407 " camcontrol reportluns [dev_id][generic args] [-c] [-l] [-r report]\n"
3408 " camcontrol start [dev_id][generic args]\n"
3409 " camcontrol stop [dev_id][generic args]\n"
3410 " camcontrol load [dev_id][generic args]\n"
3411 " camcontrol eject [dev_id][generic args]\n"
3412 #endif /* MINIMALISTIC */
3413 " camcontrol rescan <all | bus[:target:lun]>\n"
3414 " camcontrol reset <all | bus[:target:lun]>\n"
3415 #ifndef MINIMALISTIC
3416 " camcontrol defects [dev_id][generic args] <-f format> [-P][-G]\n"
3417 " camcontrol modepage [dev_id][generic args] <-m page | -l>\n"
3418 " [-P pagectl][-e | -b][-d]\n"
3419 " camcontrol cmd [dev_id][generic args] <-c cmd [args]>\n"
3420 " [-i len fmt|-o len fmt [args]]\n"
3421 " camcontrol debug [-I][-P][-T][-S][-X][-c]\n"
3422 " <all|bus[:target[:lun]]|off>\n"
3423 " camcontrol tags [dev_id][generic args] [-N tags] [-q] [-v]\n"
3424 " camcontrol negotiate [dev_id][generic args] [-a][-c]\n"
3425 " [-D <enable|disable>][-O offset][-q]\n"
3426 " [-R syncrate][-v][-T <enable|disable>]\n"
3427 " [-U][-W bus_width]\n"
3428 " camcontrol format [dev_id][generic args][-q][-r][-w][-y]\n"
3429 #endif /* MINIMALISTIC */
3430 " camcontrol help\n");
3431 if (!verbose)
3432 return;
3433 #ifndef MINIMALISTIC
3434 fprintf(stdout,
3435 "Specify one of the following options:\n"
3436 "devlist list all CAM devices\n"
3437 "periphlist list all CAM peripheral drivers attached to a device\n"
3438 "tur send a test unit ready to the named device\n"
3439 "inquiry send a SCSI inquiry command to the named device\n"
3440 "reportluns send a SCSI report luns command to the device\n"
3441 "start send a Start Unit command to the device\n"
3442 "stop send a Stop Unit command to the device\n"
3443 "load send a Start Unit command to the device with the load bit set\n"
3444 "eject send a Stop Unit command to the device with the eject bit set\n"
3445 "rescan rescan all busses, the given bus, or bus:target:lun\n"
3446 "reset reset all busses, the given bus, or bus:target:lun\n"
3447 "defects read the defect list of the specified device\n"
3448 "modepage display or edit (-e) the given mode page\n"
3449 "cmd send the given scsi command, may need -i or -o as well\n"
3450 "debug turn debugging on/off for a bus, target, or lun, or all devices\n"
3451 "tags report or set the number of transaction slots for a device\n"
3452 "negotiate report or set device negotiation parameters\n"
3453 "format send the SCSI FORMAT UNIT command to the named device\n"
3454 "help this message\n"
3455 "Device Identifiers:\n"
3456 "bus:target specify the bus and target, lun defaults to 0\n"
3457 "bus:target:lun specify the bus, target and lun\n"
3458 "deviceUNIT specify the device name, like \"da4\" or \"cd2\"\n"
3459 "Generic arguments:\n"
3460 "-v be verbose, print out sense information\n"
3461 "-t timeout command timeout in seconds, overrides default timeout\n"
3462 "-n dev_name specify device name, e.g. \"da\", \"cd\"\n"
3463 "-u unit specify unit number, e.g. \"0\", \"5\"\n"
3464 "-E have the kernel attempt to perform SCSI error recovery\n"
3465 "-C count specify the SCSI command retry count (needs -E to work)\n"
3466 "modepage arguments:\n"
3467 "-l list all available mode pages\n"
3468 "-m page specify the mode page to view or edit\n"
3469 "-e edit the specified mode page\n"
3470 "-b force view to binary mode\n"
3471 "-d disable block descriptors for mode sense\n"
3472 "-P pgctl page control field 0-3\n"
3473 "defects arguments:\n"
3474 "-f format specify defect list format (block, bfi or phys)\n"
3475 "-G get the grown defect list\n"
3476 "-P get the permanant defect list\n"
3477 "inquiry arguments:\n"
3478 "-D get the standard inquiry data\n"
3479 "-S get the serial number\n"
3480 "-R get the transfer rate, etc.\n"
3481 "reportluns arguments:\n"
3482 "-c only report a count of available LUNs\n"
3483 "-l only print out luns, and not a count\n"
3484 "-r <reporttype> specify \"default\", \"wellknown\" or \"all\"\n"
3485 "cmd arguments:\n"
3486 "-c cdb [args] specify the SCSI CDB\n"
3487 "-i len fmt specify input data and input data format\n"
3488 "-o len fmt [args] specify output data and output data fmt\n"
3489 "debug arguments:\n"
3490 "-I CAM_DEBUG_INFO -- scsi commands, errors, data\n"
3491 "-T CAM_DEBUG_TRACE -- routine flow tracking\n"
3492 "-S CAM_DEBUG_SUBTRACE -- internal routine command flow\n"
3493 "-c CAM_DEBUG_CDB -- print out SCSI CDBs only\n"
3494 "tags arguments:\n"
3495 "-N tags specify the number of tags to use for this device\n"
3496 "-q be quiet, don't report the number of tags\n"
3497 "-v report a number of tag-related parameters\n"
3498 "negotiate arguments:\n"
3499 "-a send a test unit ready after negotiation\n"
3500 "-c report/set current negotiation settings\n"
3501 "-D <arg> \"enable\" or \"disable\" disconnection\n"
3502 "-O offset set command delay offset\n"
3503 "-q be quiet, don't report anything\n"
3504 "-R syncrate synchronization rate in MHz\n"
3505 "-T <arg> \"enable\" or \"disable\" tagged queueing\n"
3506 "-U report/set user negotiation settings\n"
3507 "-W bus_width set the bus width in bits (8, 16 or 32)\n"
3508 "-v also print a Path Inquiry CCB for the controller\n"
3509 "format arguments:\n"
3510 "-q be quiet, don't print status messages\n"
3511 "-r run in report only mode\n"
3512 "-w don't send immediate format command\n"
3513 "-y don't ask any questions\n");
3514 #endif /* MINIMALISTIC */
3515 }
3516
3517 int
3518 main(int argc, char **argv)
3519 {
3520 int c;
3521 char *device = NULL;
3522 int unit = 0;
3523 struct cam_device *cam_dev = NULL;
3524 int timeout = 0, retry_count = 1;
3525 camcontrol_optret optreturn;
3526 char *tstr;
3527 const char *mainopt = "C:En:t:u:v";
3528 const char *subopt = NULL;
3529 char combinedopt[256];
3530 int error = 0, optstart = 2;
3531 int devopen = 1;
3532
3533 cmdlist = CAM_CMD_NONE;
3534 arglist = CAM_ARG_NONE;
3535
3536 if (argc < 2) {
3537 usage(0);
3538 exit(1);
3539 }
3540
3541 /*
3542 * Get the base option.
3543 */
3544 optreturn = getoption(argv[1], &cmdlist, &arglist, &subopt);
3545
3546 if (optreturn == CC_OR_AMBIGUOUS) {
3547 warnx("ambiguous option %s", argv[1]);
3548 usage(0);
3549 exit(1);
3550 } else if (optreturn == CC_OR_NOT_FOUND) {
3551 warnx("option %s not found", argv[1]);
3552 usage(0);
3553 exit(1);
3554 }
3555
3556 /*
3557 * Ahh, getopt(3) is a pain.
3558 *
3559 * This is a gross hack. There really aren't many other good
3560 * options (excuse the pun) for parsing options in a situation like
3561 * this. getopt is kinda braindead, so you end up having to run
3562 * through the options twice, and give each invocation of getopt
3563 * the option string for the other invocation.
3564 *
3565 * You would think that you could just have two groups of options.
3566 * The first group would get parsed by the first invocation of
3567 * getopt, and the second group would get parsed by the second
3568 * invocation of getopt. It doesn't quite work out that way. When
3569 * the first invocation of getopt finishes, it leaves optind pointing
3570 * to the argument _after_ the first argument in the second group.
3571 * So when the second invocation of getopt comes around, it doesn't
3572 * recognize the first argument it gets and then bails out.
3573 *
3574 * A nice alternative would be to have a flag for getopt that says
3575 * "just keep parsing arguments even when you encounter an unknown
3576 * argument", but there isn't one. So there's no real clean way to
3577 * easily parse two sets of arguments without having one invocation
3578 * of getopt know about the other.
3579 *
3580 * Without this hack, the first invocation of getopt would work as
3581 * long as the generic arguments are first, but the second invocation
3582 * (in the subfunction) would fail in one of two ways. In the case
3583 * where you don't set optreset, it would fail because optind may be
3584 * pointing to the argument after the one it should be pointing at.
3585 * In the case where you do set optreset, and reset optind, it would
3586 * fail because getopt would run into the first set of options, which
3587 * it doesn't understand.
3588 *
3589 * All of this would "sort of" work if you could somehow figure out
3590 * whether optind had been incremented one option too far. The
3591 * mechanics of that, however, are more daunting than just giving
3592 * both invocations all of the expect options for either invocation.
3593 *
3594 * Needless to say, I wouldn't mind if someone invented a better
3595 * (non-GPL!) command line parsing interface than getopt. I
3596 * wouldn't mind if someone added more knobs to getopt to make it
3597 * work better. Who knows, I may talk myself into doing it someday,
3598 * if the standards weenies let me. As it is, it just leads to
3599 * hackery like this and causes people to avoid it in some cases.
3600 *
3601 * KDM, September 8th, 1998
3602 */
3603 if (subopt != NULL)
3604 sprintf(combinedopt, "%s%s", mainopt, subopt);
3605 else
3606 sprintf(combinedopt, "%s", mainopt);
3607
3608 /*
3609 * For these options we do not parse optional device arguments and
3610 * we do not open a passthrough device.
3611 */
3612 if ((cmdlist == CAM_CMD_RESCAN)
3613 || (cmdlist == CAM_CMD_RESET)
3614 || (cmdlist == CAM_CMD_DEVTREE)
3615 || (cmdlist == CAM_CMD_USAGE)
3616 || (cmdlist == CAM_CMD_DEBUG))
3617 devopen = 0;
3618
3619 #ifndef MINIMALISTIC
3620 if ((devopen == 1)
3621 && (argc > 2 && argv[2][0] != '-')) {
3622 char name[30];
3623 int rv;
3624
3625 /*
3626 * First catch people who try to do things like:
3627 * camcontrol tur /dev/da0
3628 * camcontrol doesn't take device nodes as arguments.
3629 */
3630 if (argv[2][0] == '/') {
3631 warnx("%s is not a valid device identifier", argv[2]);
3632 errx(1, "please read the camcontrol(8) man page");
3633 } else if (isdigit(argv[2][0])) {
3634 /* device specified as bus:target[:lun] */
3635 rv = parse_btl(argv[2], &bus, &target, &lun, &arglist);
3636 if (rv < 2)
3637 errx(1, "numeric device specification must "
3638 "be either bus:target, or "
3639 "bus:target:lun");
3640 /* default to 0 if lun was not specified */
3641 if ((arglist & CAM_ARG_LUN) == 0) {
3642 lun = 0;
3643 arglist |= CAM_ARG_LUN;
3644 }
3645 optstart++;
3646 } else {
3647 if (cam_get_device(argv[2], name, sizeof name, &unit)
3648 == -1)
3649 errx(1, "%s", cam_errbuf);
3650 device = strdup(name);
3651 arglist |= CAM_ARG_DEVICE | CAM_ARG_UNIT;
3652 optstart++;
3653 }
3654 }
3655 #endif /* MINIMALISTIC */
3656 /*
3657 * Start getopt processing at argv[2/3], since we've already
3658 * accepted argv[1..2] as the command name, and as a possible
3659 * device name.
3660 */
3661 optind = optstart;
3662
3663 /*
3664 * Now we run through the argument list looking for generic
3665 * options, and ignoring options that possibly belong to
3666 * subfunctions.
3667 */
3668 while ((c = getopt(argc, argv, combinedopt))!= -1){
3669 switch(c) {
3670 case 'C':
3671 retry_count = strtol(optarg, NULL, 0);
3672 if (retry_count < 0)
3673 errx(1, "retry count %d is < 0",
3674 retry_count);
3675 arglist |= CAM_ARG_RETRIES;
3676 break;
3677 case 'E':
3678 arglist |= CAM_ARG_ERR_RECOVER;
3679 break;
3680 case 'n':
3681 arglist |= CAM_ARG_DEVICE;
3682 tstr = optarg;
3683 while (isspace(*tstr) && (*tstr != '\0'))
3684 tstr++;
3685 device = (char *)strdup(tstr);
3686 break;
3687 case 't':
3688 timeout = strtol(optarg, NULL, 0);
3689 if (timeout < 0)
3690 errx(1, "invalid timeout %d", timeout);
3691 /* Convert the timeout from seconds to ms */
3692 timeout *= 1000;
3693 arglist |= CAM_ARG_TIMEOUT;
3694 break;
3695 case 'u':
3696 arglist |= CAM_ARG_UNIT;
3697 unit = strtol(optarg, NULL, 0);
3698 break;
3699 case 'v':
3700 arglist |= CAM_ARG_VERBOSE;
3701 break;
3702 default:
3703 break;
3704 }
3705 }
3706
3707 #ifndef MINIMALISTIC
3708 /*
3709 * For most commands we'll want to open the passthrough device
3710 * associated with the specified device. In the case of the rescan
3711 * commands, we don't use a passthrough device at all, just the
3712 * transport layer device.
3713 */
3714 if (devopen == 1) {
3715 if (((arglist & (CAM_ARG_BUS|CAM_ARG_TARGET)) == 0)
3716 && (((arglist & CAM_ARG_DEVICE) == 0)
3717 || ((arglist & CAM_ARG_UNIT) == 0))) {
3718 errx(1, "subcommand \"%s\" requires a valid device "
3719 "identifier", argv[1]);
3720 }
3721
3722 if ((cam_dev = ((arglist & (CAM_ARG_BUS | CAM_ARG_TARGET))?
3723 cam_open_btl(bus, target, lun, O_RDWR, NULL) :
3724 cam_open_spec_device(device,unit,O_RDWR,NULL)))
3725 == NULL)
3726 errx(1,"%s", cam_errbuf);
3727 }
3728 #endif /* MINIMALISTIC */
3729
3730 /*
3731 * Reset optind to 2, and reset getopt, so these routines can parse
3732 * the arguments again.
3733 */
3734 optind = optstart;
3735 optreset = 1;
3736
3737 switch(cmdlist) {
3738 #ifndef MINIMALISTIC
3739 case CAM_CMD_DEVLIST:
3740 error = getdevlist(cam_dev);
3741 break;
3742 #endif /* MINIMALISTIC */
3743 case CAM_CMD_DEVTREE:
3744 error = getdevtree();
3745 break;
3746 #ifndef MINIMALISTIC
3747 case CAM_CMD_TUR:
3748 error = testunitready(cam_dev, retry_count, timeout, 0);
3749 break;
3750 case CAM_CMD_INQUIRY:
3751 error = scsidoinquiry(cam_dev, argc, argv, combinedopt,
3752 retry_count, timeout);
3753 break;
3754 case CAM_CMD_STARTSTOP:
3755 error = scsistart(cam_dev, arglist & CAM_ARG_START_UNIT,
3756 arglist & CAM_ARG_EJECT, retry_count,
3757 timeout);
3758 break;
3759 #endif /* MINIMALISTIC */
3760 case CAM_CMD_RESCAN:
3761 error = dorescan_or_reset(argc, argv, 1);
3762 break;
3763 case CAM_CMD_RESET:
3764 error = dorescan_or_reset(argc, argv, 0);
3765 break;
3766 #ifndef MINIMALISTIC
3767 case CAM_CMD_READ_DEFECTS:
3768 error = readdefects(cam_dev, argc, argv, combinedopt,
3769 retry_count, timeout);
3770 break;
3771 case CAM_CMD_MODE_PAGE:
3772 modepage(cam_dev, argc, argv, combinedopt,
3773 retry_count, timeout);
3774 break;
3775 case CAM_CMD_SCSI_CMD:
3776 error = scsicmd(cam_dev, argc, argv, combinedopt,
3777 retry_count, timeout);
3778 break;
3779 case CAM_CMD_DEBUG:
3780 error = camdebug(argc, argv, combinedopt);
3781 break;
3782 case CAM_CMD_TAG:
3783 error = tagcontrol(cam_dev, argc, argv, combinedopt);
3784 break;
3785 case CAM_CMD_RATE:
3786 error = ratecontrol(cam_dev, retry_count, timeout,
3787 argc, argv, combinedopt);
3788 break;
3789 case CAM_CMD_FORMAT:
3790 error = scsiformat(cam_dev, argc, argv,
3791 combinedopt, retry_count, timeout);
3792 break;
3793 case CAM_CMD_REPORTLUNS:
3794 error = scsireportluns(cam_dev, argc, argv,
3795 combinedopt, retry_count,
3796 timeout);
3797 break;
3798 #endif /* MINIMALISTIC */
3799 case CAM_CMD_USAGE:
3800 usage(1);
3801 break;
3802 default:
3803 usage(0);
3804 error = 1;
3805 break;
3806 }
3807
3808 if (cam_dev != NULL)
3809 cam_close_device(cam_dev);
3810
3811 exit(error);
3812 }
DragonFly BSD