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