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