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