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