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