sbin/camcontrol/camcontrol.c

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