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/stat.h>
  36 #include <sys/endian.h>
  37 #include <sys/sbuf.h>
  38
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #include <unistd.h>
  43 #include <inttypes.h>
  44 #include <limits.h>
  45 #include <fcntl.h>
  46 #include <ctype.h>
  47 #include <err.h>
  48 #include <libutil.h>
  49 #ifndef MINIMALISTIC
  50 #include <limits.h>
  51 #include <inttypes.h>
  52 #endif
  53
  54 #include <cam/cam.h>
  55 #include <cam/cam_debug.h>
  56 #include <cam/cam_ccb.h>
  57 #include <cam/scsi/scsi_all.h>
  58 #include <cam/scsi/scsi_da.h>
  59 #include <cam/scsi/scsi_pass.h>
  60 #include <cam/scsi/scsi_message.h>
  61 #include <cam/scsi/smp_all.h>
  62 #include <cam/ata/ata_all.h>
  63 #include <camlib.h>
  64 #include "camcontrol.h"
  65
  66 typedef enum {
  67         CAM_CMD_NONE            = 0x00000000,
  68         CAM_CMD_DEVLIST         = 0x00000001,
  69         CAM_CMD_TUR             = 0x00000002,
  70         CAM_CMD_INQUIRY         = 0x00000003,
  71         CAM_CMD_STARTSTOP       = 0x00000004,
  72         CAM_CMD_RESCAN          = 0x00000005,
  73         CAM_CMD_READ_DEFECTS    = 0x00000006,
  74         CAM_CMD_MODE_PAGE       = 0x00000007,
  75         CAM_CMD_SCSI_CMD        = 0x00000008,
  76         CAM_CMD_DEVTREE         = 0x00000009,
  77         CAM_CMD_USAGE           = 0x0000000a,
  78         CAM_CMD_DEBUG           = 0x0000000b,
  79         CAM_CMD_RESET           = 0x0000000c,
  80         CAM_CMD_FORMAT          = 0x0000000d,
  81         CAM_CMD_TAG             = 0x0000000e,
  82         CAM_CMD_RATE            = 0x0000000f,
  83         CAM_CMD_DETACH          = 0x00000010,
  84         CAM_CMD_REPORTLUNS      = 0x00000011,
  85         CAM_CMD_READCAP         = 0x00000012,
  86         CAM_CMD_IDENTIFY        = 0x00000013,
  87         CAM_CMD_IDLE            = 0x00000014,
  88         CAM_CMD_STANDBY         = 0x00000015,
  89         CAM_CMD_SLEEP           = 0x00000016,
  90         CAM_CMD_SMP_CMD         = 0x00000017,
  91         CAM_CMD_SMP_RG          = 0x00000018,
  92         CAM_CMD_SMP_PC          = 0x00000019,
  93         CAM_CMD_SMP_PHYLIST     = 0x0000001a,
  94         CAM_CMD_SMP_MANINFO     = 0x0000001b,
  95         CAM_CMD_DOWNLOAD_FW     = 0x0000001c,
  96         CAM_CMD_SECURITY        = 0x0000001d,
  97         CAM_CMD_HPA             = 0x0000001e,
  98         CAM_CMD_SANITIZE        = 0x0000001f,
  99         CAM_CMD_PERSIST         = 0x00000020,
 100         CAM_CMD_APM             = 0x00000021,
 101         CAM_CMD_AAM             = 0x00000022,
 102         CAM_CMD_ATTRIB          = 0x00000023,
 103         CAM_CMD_OPCODES         = 0x00000024,
 104         CAM_CMD_REPROBE         = 0x00000025,
 105         CAM_CMD_ZONE            = 0x00000026,
 106         CAM_CMD_EPC             = 0x00000027,
 107         CAM_CMD_TIMESTAMP       = 0x00000028
 108 } cam_cmdmask;
 109
 110 typedef enum {
 111         CAM_ARG_NONE            = 0x00000000,
 112         CAM_ARG_VERBOSE         = 0x00000001,
 113         CAM_ARG_DEVICE          = 0x00000002,
 114         CAM_ARG_BUS             = 0x00000004,
 115         CAM_ARG_TARGET          = 0x00000008,
 116         CAM_ARG_LUN             = 0x00000010,
 117         CAM_ARG_EJECT           = 0x00000020,
 118         CAM_ARG_UNIT            = 0x00000040,
 119         CAM_ARG_FORMAT_BLOCK    = 0x00000080,
 120         CAM_ARG_FORMAT_BFI      = 0x00000100,
 121         CAM_ARG_FORMAT_PHYS     = 0x00000200,
 122         CAM_ARG_PLIST           = 0x00000400,
 123         CAM_ARG_GLIST           = 0x00000800,
 124         CAM_ARG_GET_SERIAL      = 0x00001000,
 125         CAM_ARG_GET_STDINQ      = 0x00002000,
 126         CAM_ARG_GET_XFERRATE    = 0x00004000,
 127         CAM_ARG_INQ_MASK        = 0x00007000,
 128         CAM_ARG_TIMEOUT         = 0x00020000,
 129         CAM_ARG_CMD_IN          = 0x00040000,
 130         CAM_ARG_CMD_OUT         = 0x00080000,
 131         CAM_ARG_ERR_RECOVER     = 0x00200000,
 132         CAM_ARG_RETRIES         = 0x00400000,
 133         CAM_ARG_START_UNIT      = 0x00800000,
 134         CAM_ARG_DEBUG_INFO      = 0x01000000,
 135         CAM_ARG_DEBUG_TRACE     = 0x02000000,
 136         CAM_ARG_DEBUG_SUBTRACE  = 0x04000000,
 137         CAM_ARG_DEBUG_CDB       = 0x08000000,
 138         CAM_ARG_DEBUG_XPT       = 0x10000000,
 139         CAM_ARG_DEBUG_PERIPH    = 0x20000000,
 140         CAM_ARG_DEBUG_PROBE     = 0x40000000,
 141 } cam_argmask;
 142
 143 struct camcontrol_opts {
 144         const char      *optname;
 145         uint32_t        cmdnum;
 146         cam_argmask     argnum;
 147         const char      *subopt;
 148 };
 149
 150 #ifndef MINIMALISTIC
 151 struct ata_res_pass16 {
 152         u_int16_t reserved[5];
 153         u_int8_t flags;
 154         u_int8_t error;
 155         u_int8_t sector_count_exp;
 156         u_int8_t sector_count;
 157         u_int8_t lba_low_exp;
 158         u_int8_t lba_low;
 159         u_int8_t lba_mid_exp;
 160         u_int8_t lba_mid;
 161         u_int8_t lba_high_exp;
 162         u_int8_t lba_high;
 163         u_int8_t device;
 164         u_int8_t status;
 165 };
 166
 167 struct ata_set_max_pwd
 168 {
 169         u_int16_t reserved1;
 170         u_int8_t password[32];
 171         u_int16_t reserved2[239];
 172 };
 173
 174 static struct scsi_nv task_attrs[] = {
 175         { "simple", MSG_SIMPLE_Q_TAG },
 176         { "head", MSG_HEAD_OF_Q_TAG },
 177         { "ordered", MSG_ORDERED_Q_TAG },
 178         { "iwr", MSG_IGN_WIDE_RESIDUE },
 179         { "aca", MSG_ACA_TASK }
 180 };
 181
 182 static const char scsicmd_opts[] = "a:c:dfi:o:r";
 183 static const char readdefect_opts[] = "f:GPqsS:X";
 184 static const char negotiate_opts[] = "acD:M:O:qR:T:UW:";
 185 static const char smprg_opts[] = "l";
 186 static const char smppc_opts[] = "a:A:d:lm:M:o:p:s:S:T:";
 187 static const char smpphylist_opts[] = "lq";
 188 static char pwd_opt;
 189 #endif
 190
 191 static struct camcontrol_opts option_table[] = {
 192 #ifndef MINIMALISTIC
 193         {"tur", CAM_CMD_TUR, CAM_ARG_NONE, NULL},
 194         {"inquiry", CAM_CMD_INQUIRY, CAM_ARG_NONE, "DSR"},
 195         {"identify", CAM_CMD_IDENTIFY, CAM_ARG_NONE, NULL},
 196         {"start", CAM_CMD_STARTSTOP, CAM_ARG_START_UNIT, NULL},
 197         {"stop", CAM_CMD_STARTSTOP, CAM_ARG_NONE, NULL},
 198         {"load", CAM_CMD_STARTSTOP, CAM_ARG_START_UNIT | CAM_ARG_EJECT, NULL},
 199         {"eject", CAM_CMD_STARTSTOP, CAM_ARG_EJECT, NULL},
 200         {"reportluns", CAM_CMD_REPORTLUNS, CAM_ARG_NONE, "clr:"},
 201         {"readcapacity", CAM_CMD_READCAP, CAM_ARG_NONE, "bhHNqs"},
 202         {"reprobe", CAM_CMD_REPROBE, CAM_ARG_NONE, NULL},
 203 #endif /* MINIMALISTIC */
 204         {"rescan", CAM_CMD_RESCAN, CAM_ARG_NONE, NULL},
 205         {"reset", CAM_CMD_RESET, CAM_ARG_NONE, NULL},
 206 #ifndef MINIMALISTIC
 207         {"cmd", CAM_CMD_SCSI_CMD, CAM_ARG_NONE, scsicmd_opts},
 208         {"command", CAM_CMD_SCSI_CMD, CAM_ARG_NONE, scsicmd_opts},
 209         {"smpcmd", CAM_CMD_SMP_CMD, CAM_ARG_NONE, "r:R:"},
 210         {"smprg", CAM_CMD_SMP_RG, CAM_ARG_NONE, smprg_opts},
 211         {"smpreportgeneral", CAM_CMD_SMP_RG, CAM_ARG_NONE, smprg_opts},
 212         {"smppc", CAM_CMD_SMP_PC, CAM_ARG_NONE, smppc_opts},
 213         {"smpphycontrol", CAM_CMD_SMP_PC, CAM_ARG_NONE, smppc_opts},
 214         {"smpplist", CAM_CMD_SMP_PHYLIST, CAM_ARG_NONE, smpphylist_opts},
 215         {"smpphylist", CAM_CMD_SMP_PHYLIST, CAM_ARG_NONE, smpphylist_opts},
 216         {"smpmaninfo", CAM_CMD_SMP_MANINFO, CAM_ARG_NONE, "l"},
 217         {"defects", CAM_CMD_READ_DEFECTS, CAM_ARG_NONE, readdefect_opts},
 218         {"defectlist", CAM_CMD_READ_DEFECTS, CAM_ARG_NONE, readdefect_opts},
 219 #endif /* MINIMALISTIC */
 220         {"devlist", CAM_CMD_DEVTREE, CAM_ARG_NONE, "-b"},
 221 #ifndef MINIMALISTIC
 222         {"periphlist", CAM_CMD_DEVLIST, CAM_ARG_NONE, NULL},
 223         {"modepage", CAM_CMD_MODE_PAGE, CAM_ARG_NONE, "bdelm:P:"},
 224         {"tags", CAM_CMD_TAG, CAM_ARG_NONE, "N:q"},
 225         {"negotiate", CAM_CMD_RATE, CAM_ARG_NONE, negotiate_opts},
 226         {"rate", CAM_CMD_RATE, CAM_ARG_NONE, negotiate_opts},
 227         {"debug", CAM_CMD_DEBUG, CAM_ARG_NONE, "IPTSXcp"},
 228         {"format", CAM_CMD_FORMAT, CAM_ARG_NONE, "qrwy"},
 229         {"sanitize", CAM_CMD_SANITIZE, CAM_ARG_NONE, "a:c:IP:qrUwy"},
 230         {"idle", CAM_CMD_IDLE, CAM_ARG_NONE, "t:"},
 231         {"standby", CAM_CMD_STANDBY, CAM_ARG_NONE, "t:"},
 232         {"sleep", CAM_CMD_SLEEP, CAM_ARG_NONE, ""},
 233         {"apm", CAM_CMD_APM, CAM_ARG_NONE, "l:"},
 234         {"aam", CAM_CMD_AAM, CAM_ARG_NONE, "l:"},
 235         {"fwdownload", CAM_CMD_DOWNLOAD_FW, CAM_ARG_NONE, "f:qsy"},
 236         {"security", CAM_CMD_SECURITY, CAM_ARG_NONE, "d:e:fh:k:l:qs:T:U:y"},
 237         {"hpa", CAM_CMD_HPA, CAM_ARG_NONE, "Pflp:qs:U:y"},
 238         {"persist", CAM_CMD_PERSIST, CAM_ARG_NONE, "ai:I:k:K:o:ps:ST:U"},
 239         {"attrib", CAM_CMD_ATTRIB, CAM_ARG_NONE, "a:ce:F:p:r:s:T:w:V:"},
 240         {"opcodes", CAM_CMD_OPCODES, CAM_ARG_NONE, "No:s:T"},
 241         {"zone", CAM_CMD_ZONE, CAM_ARG_NONE, "ac:l:No:P:"},
 242         {"epc", CAM_CMD_EPC, CAM_ARG_NONE, "c:dDeHp:Pr:sS:T:"},
 243         {"timestamp", CAM_CMD_TIMESTAMP, CAM_ARG_NONE, "f:mrsUT:"},
 244 #endif /* MINIMALISTIC */
 245         {"help", CAM_CMD_USAGE, CAM_ARG_NONE, NULL},
 246         {"-?", CAM_CMD_USAGE, CAM_ARG_NONE, NULL},
 247         {"-h", CAM_CMD_USAGE, CAM_ARG_NONE, NULL},
 248         {NULL, 0, 0, NULL}
 249 };
 250
 251 struct cam_devitem {
 252         struct device_match_result dev_match;
 253         int num_periphs;
 254         struct periph_match_result *periph_matches;
 255         struct scsi_vpd_device_id *device_id;
 256         int device_id_len;
 257         STAILQ_ENTRY(cam_devitem) links;
 258 };
 259
 260 struct cam_devlist {
 261         STAILQ_HEAD(, cam_devitem) dev_queue;
 262         path_id_t path_id;
 263 };
 264
 265 static cam_cmdmask cmdlist;
 266 static cam_argmask arglist;
 267
 268 camcontrol_optret getoption(struct camcontrol_opts *table, char *arg,
 269                             uint32_t *cmdnum, cam_argmask *argnum,
 270                             const char **subopt);
 271 #ifndef MINIMALISTIC
 272 static int getdevlist(struct cam_device *device);
 273 #endif /* MINIMALISTIC */
 274 static int getdevtree(int argc, char **argv, char *combinedopt);
 275 #ifndef MINIMALISTIC
 276 static int testunitready(struct cam_device *device, int task_attr,
 277                          int retry_count, int timeout, int quiet);
 278 static int scsistart(struct cam_device *device, int startstop, int loadeject,
 279                      int task_attr, int retry_count, int timeout);
 280 static int scsiinquiry(struct cam_device *device, int task_attr,
 281                        int retry_count, int timeout);
 282 static int scsiserial(struct cam_device *device, int task_attr,
 283                       int retry_count, int timeout);
 284 #endif /* MINIMALISTIC */
 285 static int parse_btl(char *tstr, path_id_t *bus, target_id_t *target,
 286                      lun_id_t *lun, cam_argmask *arglst);
 287 static int dorescan_or_reset(int argc, char **argv, int rescan);
 288 static int rescan_or_reset_bus(path_id_t bus, int rescan);
 289 static int scanlun_or_reset_dev(path_id_t bus, target_id_t target,
 290     lun_id_t lun, int scan);
 291 #ifndef MINIMALISTIC
 292 static int readdefects(struct cam_device *device, int argc, char **argv,
 293                        char *combinedopt, int task_attr, int retry_count,
 294                        int timeout);
 295 static void modepage(struct cam_device *device, int argc, char **argv,
 296                      char *combinedopt, int task_attr, int retry_count,
 297                      int timeout);
 298 static int scsicmd(struct cam_device *device, int argc, char **argv,
 299                    char *combinedopt, int task_attr, int retry_count,
 300                    int timeout);
 301 static int smpcmd(struct cam_device *device, int argc, char **argv,
 302                   char *combinedopt, int retry_count, int timeout);
 303 static int smpreportgeneral(struct cam_device *device, int argc, char **argv,
 304                             char *combinedopt, int retry_count, int timeout);
 305 static int smpphycontrol(struct cam_device *device, int argc, char **argv,
 306                          char *combinedopt, int retry_count, int timeout);
 307 static int smpmaninfo(struct cam_device *device, int argc, char **argv,
 308                       char *combinedopt, int retry_count, int timeout);
 309 static int getdevid(struct cam_devitem *item);
 310 static int buildbusdevlist(struct cam_devlist *devlist);
 311 static void freebusdevlist(struct cam_devlist *devlist);
 312 static struct cam_devitem *findsasdevice(struct cam_devlist *devlist,
 313                                          uint64_t sasaddr);
 314 static int smpphylist(struct cam_device *device, int argc, char **argv,
 315                       char *combinedopt, int retry_count, int timeout);
 316 static int tagcontrol(struct cam_device *device, int argc, char **argv,
 317                       char *combinedopt);
 318 static void cts_print(struct cam_device *device,
 319                       struct ccb_trans_settings *cts);
 320 static void cpi_print(struct ccb_pathinq *cpi);
 321 static int get_cpi(struct cam_device *device, struct ccb_pathinq *cpi);
 322 static int get_cgd(struct cam_device *device, struct ccb_getdev *cgd);
 323 static int get_print_cts(struct cam_device *device, int user_settings,
 324                          int quiet, struct ccb_trans_settings *cts);
 325 static int ratecontrol(struct cam_device *device, int task_attr,
 326                        int retry_count, int timeout, int argc, char **argv,
 327                        char *combinedopt);
 328 static int scsiformat(struct cam_device *device, int argc, char **argv,
 329                       char *combinedopt, int task_attr, int retry_count,
 330                       int timeout);
 331 static int scsisanitize(struct cam_device *device, int argc, char **argv,
 332                         char *combinedopt, int task_attr, int retry_count,
 333                         int timeout);
 334 static int scsireportluns(struct cam_device *device, int argc, char **argv,
 335                           char *combinedopt, int task_attr, int retry_count,
 336                           int timeout);
 337 static int scsireadcapacity(struct cam_device *device, int argc, char **argv,
 338                             char *combinedopt, int task_attr, int retry_count,
 339                             int timeout);
 340 static int atapm(struct cam_device *device, int argc, char **argv,
 341                  char *combinedopt, int retry_count, int timeout);
 342 static int atasecurity(struct cam_device *device, int retry_count, int timeout,
 343                        int argc, char **argv, char *combinedopt);
 344 static int atahpa(struct cam_device *device, int retry_count, int timeout,
 345                   int argc, char **argv, char *combinedopt);
 346 static int scsiprintoneopcode(struct cam_device *device, int req_opcode,
 347                               int sa_set, int req_sa, uint8_t *buf,
 348                               uint32_t valid_len);
 349 static int scsiprintopcodes(struct cam_device *device, int td_req, uint8_t *buf,
 350                             uint32_t valid_len);
 351 static int scsiopcodes(struct cam_device *device, int argc, char **argv,
 352                        char *combinedopt, int task_attr, int retry_count,
 353                        int timeout, int verbose);
 354 static int scsireprobe(struct cam_device *device);
 355
 356 #endif /* MINIMALISTIC */
 357 #ifndef min
 358 #define min(a,b) (((a)<(b))?(a):(b))
 359 #endif
 360 #ifndef max
 361 #define max(a,b) (((a)>(b))?(a):(b))
 362 #endif
 363
 364 camcontrol_optret
 365 getoption(struct camcontrol_opts *table, char *arg, uint32_t *cmdnum,
 366           cam_argmask *argnum, const char **subopt)
 367 {
 368         struct camcontrol_opts *opts;
 369         int num_matches = 0;
 370
 371         for (opts = table; (opts != NULL) && (opts->optname != NULL);
 372              opts++) {
 373                 if (strncmp(opts->optname, arg, strlen(arg)) == 0) {
 374                         *cmdnum = opts->cmdnum;
 375                         *argnum = opts->argnum;
 376                         *subopt = opts->subopt;
 377                         if (++num_matches > 1)
 378                                 return(CC_OR_AMBIGUOUS);
 379                 }
 380         }
 381
 382         if (num_matches > 0)
 383                 return(CC_OR_FOUND);
 384         else
 385                 return(CC_OR_NOT_FOUND);
 386 }
 387
 388 #ifndef MINIMALISTIC
 389 static int
 390 getdevlist(struct cam_device *device)
 391 {
 392         union ccb *ccb;
 393         char status[32];
 394         int error = 0;
 395
 396         ccb = cam_getccb(device);
 397
 398         ccb->ccb_h.func_code = XPT_GDEVLIST;
 399         ccb->ccb_h.flags = CAM_DIR_NONE;
 400         ccb->ccb_h.retry_count = 1;
 401         ccb->cgdl.index = 0;
 402         ccb->cgdl.status = CAM_GDEVLIST_MORE_DEVS;
 403         while (ccb->cgdl.status == CAM_GDEVLIST_MORE_DEVS) {
 404                 if (cam_send_ccb(device, ccb) < 0) {
 405                         perror("error getting device list");
 406                         cam_freeccb(ccb);
 407                         return(1);
 408                 }
 409
 410                 status[0] = '\0';
 411
 412                 switch (ccb->cgdl.status) {
 413                         case CAM_GDEVLIST_MORE_DEVS:
 414                                 strcpy(status, "MORE");
 415                                 break;
 416                         case CAM_GDEVLIST_LAST_DEVICE:
 417                                 strcpy(status, "LAST");
 418                                 break;
 419                         case CAM_GDEVLIST_LIST_CHANGED:
 420                                 strcpy(status, "CHANGED");
 421                                 break;
 422                         case CAM_GDEVLIST_ERROR:
 423                                 strcpy(status, "ERROR");
 424                                 error = 1;
 425                                 break;
 426                 }
 427
 428                 fprintf(stdout, "%s%d:  generation: %d index: %d status: %s\n",
 429                         ccb->cgdl.periph_name,
 430                         ccb->cgdl.unit_number,
 431                         ccb->cgdl.generation,
 432                         ccb->cgdl.index,
 433                         status);
 434
 435                 /*
 436                  * If the list has changed, we need to start over from the
 437                  * beginning.
 438                  */
 439                 if (ccb->cgdl.status == CAM_GDEVLIST_LIST_CHANGED)
 440                         ccb->cgdl.index = 0;
 441         }
 442
 443         cam_freeccb(ccb);
 444
 445         return(error);
 446 }
 447 #endif /* MINIMALISTIC */
 448
 449 static int
 450 getdevtree(int argc, char **argv, char *combinedopt)
 451 {
 452         union ccb ccb;
 453         int bufsize, fd;
 454         unsigned int i;
 455         int need_close = 0;
 456         int error = 0;
 457         int skip_device = 0;
 458         int busonly = 0;
 459         int c;
 460
 461         while ((c = getopt(argc, argv, combinedopt)) != -1) {
 462                 switch(c) {
 463                 case 'b':
 464                         if ((arglist & CAM_ARG_VERBOSE) == 0)
 465                                 busonly = 1;
 466                         break;
 467                 default:
 468                         break;
 469                 }
 470         }
 471
 472         if ((fd = open(XPT_DEVICE, O_RDWR)) == -1) {
 473                 warn("couldn't open %s", XPT_DEVICE);
 474                 return(1);
 475         }
 476
 477         bzero(&ccb, sizeof(union ccb));
 478
 479         ccb.ccb_h.path_id = CAM_XPT_PATH_ID;
 480         ccb.ccb_h.target_id = CAM_TARGET_WILDCARD;
 481         ccb.ccb_h.target_lun = CAM_LUN_WILDCARD;
 482
 483         ccb.ccb_h.func_code = XPT_DEV_MATCH;
 484         bufsize = sizeof(struct dev_match_result) * 100;
 485         ccb.cdm.match_buf_len = bufsize;
 486         ccb.cdm.matches = (struct dev_match_result *)malloc(bufsize);
 487         if (ccb.cdm.matches == NULL) {
 488                 warnx("can't malloc memory for matches");
 489                 close(fd);
 490                 return(1);
 491         }
 492         ccb.cdm.num_matches = 0;
 493
 494         /*
 495          * We fetch all nodes, since we display most of them in the default
 496          * case, and all in the verbose case.
 497          */
 498         ccb.cdm.num_patterns = 0;
 499         ccb.cdm.pattern_buf_len = 0;
 500
 501         /*
 502          * We do the ioctl multiple times if necessary, in case there are
 503          * more than 100 nodes in the EDT.
 504          */
 505         do {
 506                 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
 507                         warn("error sending CAMIOCOMMAND ioctl");
 508                         error = 1;
 509                         break;
 510                 }
 511
 512                 if ((ccb.ccb_h.status != CAM_REQ_CMP)
 513                  || ((ccb.cdm.status != CAM_DEV_MATCH_LAST)
 514                     && (ccb.cdm.status != CAM_DEV_MATCH_MORE))) {
 515                         warnx("got CAM error %#x, CDM error %d\n",
 516                               ccb.ccb_h.status, ccb.cdm.status);
 517                         error = 1;
 518                         break;
 519                 }
 520
 521                 for (i = 0; i < ccb.cdm.num_matches; i++) {
 522                         switch (ccb.cdm.matches[i].type) {
 523                         case DEV_MATCH_BUS: {
 524                                 struct bus_match_result *bus_result;
 525
 526                                 /*
 527                                  * Only print the bus information if the
 528                                  * user turns on the verbose flag.
 529                                  */
 530                                 if ((busonly == 0) &&
 531                                     (arglist & CAM_ARG_VERBOSE) == 0)
 532                                         break;
 533
 534                                 bus_result =
 535                                         &ccb.cdm.matches[i].result.bus_result;
 536
 537                                 if (need_close) {
 538                                         fprintf(stdout, ")\n");
 539                                         need_close = 0;
 540                                 }
 541
 542                                 fprintf(stdout, "scbus%d on %s%d bus %d%s\n",
 543                                         bus_result->path_id,
 544                                         bus_result->dev_name,
 545                                         bus_result->unit_number,
 546                                         bus_result->bus_id,
 547                                         (busonly ? "" : ":"));
 548                                 break;
 549                         }
 550                         case DEV_MATCH_DEVICE: {
 551                                 struct device_match_result *dev_result;
 552                                 char vendor[16], product[48], revision[16];
 553                                 char fw[5], tmpstr[256];
 554
 555                                 if (busonly == 1)
 556                                         break;
 557
 558                                 dev_result =
 559                                      &ccb.cdm.matches[i].result.device_result;
 560
 561                                 if ((dev_result->flags
 562                                      & DEV_RESULT_UNCONFIGURED)
 563                                  && ((arglist & CAM_ARG_VERBOSE) == 0)) {
 564                                         skip_device = 1;
 565                                         break;
 566                                 } else
 567                                         skip_device = 0;
 568
 569                                 if (dev_result->protocol == PROTO_SCSI) {
 570                                     cam_strvis(vendor, dev_result->inq_data.vendor,
 571                                            sizeof(dev_result->inq_data.vendor),
 572                                            sizeof(vendor));
 573                                     cam_strvis(product,
 574                                            dev_result->inq_data.product,
 575                                            sizeof(dev_result->inq_data.product),
 576                                            sizeof(product));
 577                                     cam_strvis(revision,
 578                                            dev_result->inq_data.revision,
 579                                           sizeof(dev_result->inq_data.revision),
 580                                            sizeof(revision));
 581                                     sprintf(tmpstr, "<%s %s %s>", vendor, product,
 582                                         revision);
 583                                 } else if (dev_result->protocol == PROTO_ATA ||
 584                                     dev_result->protocol == PROTO_SATAPM) {
 585                                     cam_strvis(product,
 586                                            dev_result->ident_data.model,
 587                                            sizeof(dev_result->ident_data.model),
 588                                            sizeof(product));
 589                                     cam_strvis(revision,
 590                                            dev_result->ident_data.revision,
 591                                           sizeof(dev_result->ident_data.revision),
 592                                            sizeof(revision));
 593                                     sprintf(tmpstr, "<%s %s>", product,
 594                                         revision);
 595                                 } else if (dev_result->protocol == PROTO_SEMB) {
 596                                         struct sep_identify_data *sid;
 597
 598                                         sid = (struct sep_identify_data *)
 599                                             &dev_result->ident_data;
 600                                         cam_strvis(vendor, sid->vendor_id,
 601                                             sizeof(sid->vendor_id),
 602                                             sizeof(vendor));
 603                                         cam_strvis(product, sid->product_id,
 604                                             sizeof(sid->product_id),
 605                                             sizeof(product));
 606                                         cam_strvis(revision, sid->product_rev,
 607                                             sizeof(sid->product_rev),
 608                                             sizeof(revision));
 609                                         cam_strvis(fw, sid->firmware_rev,
 610                                             sizeof(sid->firmware_rev),
 611                                             sizeof(fw));
 612                                         sprintf(tmpstr, "<%s %s %s %s>",
 613                                             vendor, product, revision, fw);
 614                                 } else {
 615                                     sprintf(tmpstr, "<>");
 616                                 }
 617                                 if (need_close) {
 618                                         fprintf(stdout, ")\n");
 619                                         need_close = 0;
 620                                 }
 621
 622                                 fprintf(stdout, "%-33s  at scbus%d "
 623                                         "target %d lun %jx (",
 624                                         tmpstr,
 625                                         dev_result->path_id,
 626                                         dev_result->target_id,
 627                                         (uintmax_t)dev_result->target_lun);
 628
 629                                 need_close = 1;
 630
 631                                 break;
 632                         }
 633                         case DEV_MATCH_PERIPH: {
 634                                 struct periph_match_result *periph_result;
 635
 636                                 periph_result =
 637                                       &ccb.cdm.matches[i].result.periph_result;
 638
 639                                 if (busonly || skip_device != 0)
 640                                         break;
 641
 642                                 if (need_close > 1)
 643                                         fprintf(stdout, ",");
 644
 645                                 fprintf(stdout, "%s%d",
 646                                         periph_result->periph_name,
 647                                         periph_result->unit_number);
 648
 649                                 need_close++;
 650                                 break;
 651                         }
 652                         default:
 653                                 fprintf(stdout, "unknown match type\n");
 654                                 break;
 655                         }
 656                 }
 657
 658         } while ((ccb.ccb_h.status == CAM_REQ_CMP)
 659                 && (ccb.cdm.status == CAM_DEV_MATCH_MORE));
 660
 661         if (need_close)
 662                 fprintf(stdout, ")\n");
 663
 664         close(fd);
 665
 666         return(error);
 667 }
 668
 669 #ifndef MINIMALISTIC
 670 static int
 671 testunitready(struct cam_device *device, int task_attr, int retry_count,
 672               int timeout, int quiet)
 673 {
 674         int error = 0;
 675         union ccb *ccb;
 676
 677         ccb = cam_getccb(device);
 678
 679         scsi_test_unit_ready(&ccb->csio,
 680                              /* retries */ retry_count,
 681                              /* cbfcnp */ NULL,
 682                              /* tag_action */ task_attr,
 683                              /* sense_len */ SSD_FULL_SIZE,
 684                              /* timeout */ timeout ? timeout : 5000);
 685
 686         /* Disable freezing the device queue */
 687         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
 688
 689         if (arglist & CAM_ARG_ERR_RECOVER)
 690                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
 691
 692         if (cam_send_ccb(device, ccb) < 0) {
 693                 if (quiet == 0)
 694                         perror("error sending test unit ready");
 695
 696                 if (arglist & CAM_ARG_VERBOSE) {
 697                         cam_error_print(device, ccb, CAM_ESF_ALL,
 698                                         CAM_EPF_ALL, stderr);
 699                 }
 700
 701                 cam_freeccb(ccb);
 702                 return(1);
 703         }
 704
 705         if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
 706                 if (quiet == 0)
 707                         fprintf(stdout, "Unit is ready\n");
 708         } else {
 709                 if (quiet == 0)
 710                         fprintf(stdout, "Unit is not ready\n");
 711                 error = 1;
 712
 713                 if (arglist & CAM_ARG_VERBOSE) {
 714                         cam_error_print(device, ccb, CAM_ESF_ALL,
 715                                         CAM_EPF_ALL, stderr);
 716                 }
 717         }
 718
 719         cam_freeccb(ccb);
 720
 721         return(error);
 722 }
 723
 724 static int
 725 scsistart(struct cam_device *device, int startstop, int loadeject,
 726           int task_attr, int retry_count, int timeout)
 727 {
 728         union ccb *ccb;
 729         int error = 0;
 730
 731         ccb = cam_getccb(device);
 732
 733         /*
 734          * If we're stopping, send an ordered tag so the drive in question
 735          * will finish any previously queued writes before stopping.  If
 736          * the device isn't capable of tagged queueing, or if tagged
 737          * queueing is turned off, the tag action is a no-op.  We override
 738          * the default simple tag, although this also has the effect of
 739          * overriding the user's wishes if he wanted to specify a simple
 740          * tag.
 741          */
 742         if ((startstop == 0)
 743          && (task_attr == MSG_SIMPLE_Q_TAG))
 744                 task_attr = MSG_ORDERED_Q_TAG;
 745
 746         scsi_start_stop(&ccb->csio,
 747                         /* retries */ retry_count,
 748                         /* cbfcnp */ NULL,
 749                         /* tag_action */ task_attr,
 750                         /* start/stop */ startstop,
 751                         /* load_eject */ loadeject,
 752                         /* immediate */ 0,
 753                         /* sense_len */ SSD_FULL_SIZE,
 754                         /* timeout */ timeout ? timeout : 120000);
 755
 756         /* Disable freezing the device queue */
 757         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
 758
 759         if (arglist & CAM_ARG_ERR_RECOVER)
 760                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
 761
 762         if (cam_send_ccb(device, ccb) < 0) {
 763                 perror("error sending start unit");
 764
 765                 if (arglist & CAM_ARG_VERBOSE) {
 766                         cam_error_print(device, ccb, CAM_ESF_ALL,
 767                                         CAM_EPF_ALL, stderr);
 768                 }
 769
 770                 cam_freeccb(ccb);
 771                 return(1);
 772         }
 773
 774         if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP)
 775                 if (startstop) {
 776                         fprintf(stdout, "Unit started successfully");
 777                         if (loadeject)
 778                                 fprintf(stdout,", Media loaded\n");
 779                         else
 780                                 fprintf(stdout,"\n");
 781                 } else {
 782                         fprintf(stdout, "Unit stopped successfully");
 783                         if (loadeject)
 784                                 fprintf(stdout, ", Media ejected\n");
 785                         else
 786                                 fprintf(stdout, "\n");
 787                 }
 788         else {
 789                 error = 1;
 790                 if (startstop)
 791                         fprintf(stdout,
 792                                 "Error received from start unit command\n");
 793                 else
 794                         fprintf(stdout,
 795                                 "Error received from stop unit command\n");
 796
 797                 if (arglist & CAM_ARG_VERBOSE) {
 798                         cam_error_print(device, ccb, CAM_ESF_ALL,
 799                                         CAM_EPF_ALL, stderr);
 800                 }
 801         }
 802
 803         cam_freeccb(ccb);
 804
 805         return(error);
 806 }
 807
 808 int
 809 scsidoinquiry(struct cam_device *device, int argc, char **argv,
 810               char *combinedopt, int task_attr, int retry_count, int timeout)
 811 {
 812         int c;
 813         int error = 0;
 814
 815         while ((c = getopt(argc, argv, combinedopt)) != -1) {
 816                 switch(c) {
 817                 case 'D':
 818                         arglist |= CAM_ARG_GET_STDINQ;
 819                         break;
 820                 case 'R':
 821                         arglist |= CAM_ARG_GET_XFERRATE;
 822                         break;
 823                 case 'S':
 824                         arglist |= CAM_ARG_GET_SERIAL;
 825                         break;
 826                 default:
 827                         break;
 828                 }
 829         }
 830
 831         /*
 832          * If the user didn't specify any inquiry options, he wants all of
 833          * them.
 834          */
 835         if ((arglist & CAM_ARG_INQ_MASK) == 0)
 836                 arglist |= CAM_ARG_INQ_MASK;
 837
 838         if (arglist & CAM_ARG_GET_STDINQ)
 839                 error = scsiinquiry(device, task_attr, retry_count, timeout);
 840
 841         if (error != 0)
 842                 return(error);
 843
 844         if (arglist & CAM_ARG_GET_SERIAL)
 845                 scsiserial(device, task_attr, retry_count, timeout);
 846
 847         if (arglist & CAM_ARG_GET_XFERRATE)
 848                 error = camxferrate(device);
 849
 850         return(error);
 851 }
 852
 853 static int
 854 scsiinquiry(struct cam_device *device, int task_attr, int retry_count,
 855             int timeout)
 856 {
 857         union ccb *ccb;
 858         struct scsi_inquiry_data *inq_buf;
 859         int error = 0;
 860
 861         ccb = cam_getccb(device);
 862
 863         if (ccb == NULL) {
 864                 warnx("couldn't allocate CCB");
 865                 return(1);
 866         }
 867
 868         /* cam_getccb cleans up the header, caller has to zero the payload */
 869         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
 870
 871         inq_buf = (struct scsi_inquiry_data *)malloc(
 872                 sizeof(struct scsi_inquiry_data));
 873
 874         if (inq_buf == NULL) {
 875                 cam_freeccb(ccb);
 876                 warnx("can't malloc memory for inquiry\n");
 877                 return(1);
 878         }
 879         bzero(inq_buf, sizeof(*inq_buf));
 880
 881         /*
 882          * Note that although the size of the inquiry buffer is the full
 883          * 256 bytes specified in the SCSI spec, we only tell the device
 884          * that we have allocated SHORT_INQUIRY_LENGTH bytes.  There are
 885          * two reasons for this:
 886          *
 887          *  - The SCSI spec says that when a length field is only 1 byte,
 888          *    a value of 0 will be interpreted as 256.  Therefore
 889          *    scsi_inquiry() will convert an inq_len (which is passed in as
 890          *    a u_int32_t, but the field in the CDB is only 1 byte) of 256
 891          *    to 0.  Evidently, very few devices meet the spec in that
 892          *    regard.  Some devices, like many Seagate disks, take the 0 as
 893          *    0, and don't return any data.  One Pioneer DVD-R drive
 894          *    returns more data than the command asked for.
 895          *
 896          *    So, since there are numerous devices that just don't work
 897          *    right with the full inquiry size, we don't send the full size.
 898          *
 899          *  - The second reason not to use the full inquiry data length is
 900          *    that we don't need it here.  The only reason we issue a
 901          *    standard inquiry is to get the vendor name, device name,
 902          *    and revision so scsi_print_inquiry() can print them.
 903          *
 904          * If, at some point in the future, more inquiry data is needed for
 905          * some reason, this code should use a procedure similar to the
 906          * probe code.  i.e., issue a short inquiry, and determine from
 907          * the additional length passed back from the device how much
 908          * inquiry data the device supports.  Once the amount the device
 909          * supports is determined, issue an inquiry for that amount and no
 910          * more.
 911          *
 912          * KDM, 2/18/2000
 913          */
 914         scsi_inquiry(&ccb->csio,
 915                      /* retries */ retry_count,
 916                      /* cbfcnp */ NULL,
 917                      /* tag_action */ task_attr,
 918                      /* inq_buf */ (u_int8_t *)inq_buf,
 919                      /* inq_len */ SHORT_INQUIRY_LENGTH,
 920                      /* evpd */ 0,
 921                      /* page_code */ 0,
 922                      /* sense_len */ SSD_FULL_SIZE,
 923                      /* timeout */ timeout ? timeout : 5000);
 924
 925         /* Disable freezing the device queue */
 926         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
 927
 928         if (arglist & CAM_ARG_ERR_RECOVER)
 929                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
 930
 931         if (cam_send_ccb(device, ccb) < 0) {
 932                 perror("error sending SCSI inquiry");
 933
 934                 if (arglist & CAM_ARG_VERBOSE) {
 935                         cam_error_print(device, ccb, CAM_ESF_ALL,
 936                                         CAM_EPF_ALL, stderr);
 937                 }
 938
 939                 cam_freeccb(ccb);
 940                 return(1);
 941         }
 942
 943         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
 944                 error = 1;
 945
 946                 if (arglist & CAM_ARG_VERBOSE) {
 947                         cam_error_print(device, ccb, CAM_ESF_ALL,
 948                                         CAM_EPF_ALL, stderr);
 949                 }
 950         }
 951
 952         cam_freeccb(ccb);
 953
 954         if (error != 0) {
 955                 free(inq_buf);
 956                 return(error);
 957         }
 958
 959         fprintf(stdout, "%s%d: ", device->device_name,
 960                 device->dev_unit_num);
 961         scsi_print_inquiry(inq_buf);
 962
 963         free(inq_buf);
 964
 965         return(0);
 966 }
 967
 968 static int
 969 scsiserial(struct cam_device *device, int task_attr, int retry_count,
 970            int timeout)
 971 {
 972         union ccb *ccb;
 973         struct scsi_vpd_unit_serial_number *serial_buf;
 974         char serial_num[SVPD_SERIAL_NUM_SIZE + 1];
 975         int error = 0;
 976
 977         ccb = cam_getccb(device);
 978
 979         if (ccb == NULL) {
 980                 warnx("couldn't allocate CCB");
 981                 return(1);
 982         }
 983
 984         /* cam_getccb cleans up the header, caller has to zero the payload */
 985         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
 986
 987         serial_buf = (struct scsi_vpd_unit_serial_number *)
 988                 malloc(sizeof(*serial_buf));
 989
 990         if (serial_buf == NULL) {
 991                 cam_freeccb(ccb);
 992                 warnx("can't malloc memory for serial number");
 993                 return(1);
 994         }
 995
 996         scsi_inquiry(&ccb->csio,
 997                      /*retries*/ retry_count,
 998                      /*cbfcnp*/ NULL,
 999                      /* tag_action */ task_attr,
1000                      /* inq_buf */ (u_int8_t *)serial_buf,
1001                      /* inq_len */ sizeof(*serial_buf),
1002                      /* evpd */ 1,
1003                      /* page_code */ SVPD_UNIT_SERIAL_NUMBER,
1004                      /* sense_len */ SSD_FULL_SIZE,
1005                      /* timeout */ timeout ? timeout : 5000);
1006
1007         /* Disable freezing the device queue */
1008         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
1009
1010         if (arglist & CAM_ARG_ERR_RECOVER)
1011                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
1012
1013         if (cam_send_ccb(device, ccb) < 0) {
1014                 warn("error getting serial number");
1015
1016                 if (arglist & CAM_ARG_VERBOSE) {
1017                         cam_error_print(device, ccb, CAM_ESF_ALL,
1018                                         CAM_EPF_ALL, stderr);
1019                 }
1020
1021                 cam_freeccb(ccb);
1022                 free(serial_buf);
1023                 return(1);
1024         }
1025
1026         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
1027                 error = 1;
1028
1029                 if (arglist & CAM_ARG_VERBOSE) {
1030                         cam_error_print(device, ccb, CAM_ESF_ALL,
1031                                         CAM_EPF_ALL, stderr);
1032                 }
1033         }
1034
1035         cam_freeccb(ccb);
1036
1037         if (error != 0) {
1038                 free(serial_buf);
1039                 return(error);
1040         }
1041
1042         bcopy(serial_buf->serial_num, serial_num, serial_buf->length);
1043         serial_num[serial_buf->length] = '\0';
1044
1045         if ((arglist & CAM_ARG_GET_STDINQ)
1046          || (arglist & CAM_ARG_GET_XFERRATE))
1047                 fprintf(stdout, "%s%d: Serial Number ",
1048                         device->device_name, device->dev_unit_num);
1049
1050         fprintf(stdout, "%.60s\n", serial_num);
1051
1052         free(serial_buf);
1053
1054         return(0);
1055 }
1056
1057 int
1058 camxferrate(struct cam_device *device)
1059 {
1060         struct ccb_pathinq cpi;
1061         u_int32_t freq = 0;
1062         u_int32_t speed = 0;
1063         union ccb *ccb;
1064         u_int mb;
1065         int retval = 0;
1066
1067         if ((retval = get_cpi(device, &cpi)) != 0)
1068                 return (1);
1069
1070         ccb = cam_getccb(device);
1071
1072         if (ccb == NULL) {
1073                 warnx("couldn't allocate CCB");
1074                 return(1);
1075         }
1076
1077         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->cts);
1078
1079         ccb->ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
1080         ccb->cts.type = CTS_TYPE_CURRENT_SETTINGS;
1081
1082         if (((retval = cam_send_ccb(device, ccb)) < 0)
1083          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
1084                 const char error_string[] = "error getting transfer settings";
1085
1086                 if (retval < 0)
1087                         warn(error_string);
1088                 else
1089                         warnx(error_string);
1090
1091                 if (arglist & CAM_ARG_VERBOSE)
1092                         cam_error_print(device, ccb, CAM_ESF_ALL,
1093                                         CAM_EPF_ALL, stderr);
1094
1095                 retval = 1;
1096
1097                 goto xferrate_bailout;
1098
1099         }
1100
1101         speed = cpi.base_transfer_speed;
1102         freq = 0;
1103         if (ccb->cts.transport == XPORT_SPI) {
1104                 struct ccb_trans_settings_spi *spi =
1105                     &ccb->cts.xport_specific.spi;
1106
1107                 if ((spi->valid & CTS_SPI_VALID_SYNC_RATE) != 0) {
1108                         freq = scsi_calc_syncsrate(spi->sync_period);
1109                         speed = freq;
1110                 }
1111                 if ((spi->valid & CTS_SPI_VALID_BUS_WIDTH) != 0) {
1112                         speed *= (0x01 << spi->bus_width);
1113                 }
1114         } else if (ccb->cts.transport == XPORT_FC) {
1115                 struct ccb_trans_settings_fc *fc =
1116                     &ccb->cts.xport_specific.fc;
1117
1118                 if (fc->valid & CTS_FC_VALID_SPEED)
1119                         speed = fc->bitrate;
1120         } else if (ccb->cts.transport == XPORT_SAS) {
1121                 struct ccb_trans_settings_sas *sas =
1122                     &ccb->cts.xport_specific.sas;
1123
1124                 if (sas->valid & CTS_SAS_VALID_SPEED)
1125                         speed = sas->bitrate;
1126         } else if (ccb->cts.transport == XPORT_ATA) {
1127                 struct ccb_trans_settings_pata *pata =
1128                     &ccb->cts.xport_specific.ata;
1129
1130                 if (pata->valid & CTS_ATA_VALID_MODE)
1131                         speed = ata_mode2speed(pata->mode);
1132         } else if (ccb->cts.transport == XPORT_SATA) {
1133                 struct  ccb_trans_settings_sata *sata =
1134                     &ccb->cts.xport_specific.sata;
1135
1136                 if (sata->valid & CTS_SATA_VALID_REVISION)
1137                         speed = ata_revision2speed(sata->revision);
1138         }
1139
1140         mb = speed / 1000;
1141         if (mb > 0) {
1142                 fprintf(stdout, "%s%d: %d.%03dMB/s transfers",
1143                         device->device_name, device->dev_unit_num,
1144                         mb, speed % 1000);
1145         } else {
1146                 fprintf(stdout, "%s%d: %dKB/s transfers",
1147                         device->device_name, device->dev_unit_num,
1148                         speed);
1149         }
1150
1151         if (ccb->cts.transport == XPORT_SPI) {
1152                 struct ccb_trans_settings_spi *spi =
1153                     &ccb->cts.xport_specific.spi;
1154
1155                 if (((spi->valid & CTS_SPI_VALID_SYNC_OFFSET) != 0)
1156                  && (spi->sync_offset != 0))
1157                         fprintf(stdout, " (%d.%03dMHz, offset %d", freq / 1000,
1158                                 freq % 1000, spi->sync_offset);
1159
1160                 if (((spi->valid & CTS_SPI_VALID_BUS_WIDTH) != 0)
1161                  && (spi->bus_width > 0)) {
1162                         if (((spi->valid & CTS_SPI_VALID_SYNC_OFFSET) != 0)
1163                          && (spi->sync_offset != 0)) {
1164                                 fprintf(stdout, ", ");
1165                         } else {
1166                                 fprintf(stdout, " (");
1167                         }
1168                         fprintf(stdout, "%dbit)", 8 * (0x01 << spi->bus_width));
1169                 } else if (((spi->valid & CTS_SPI_VALID_SYNC_OFFSET) != 0)
1170                  && (spi->sync_offset != 0)) {
1171                         fprintf(stdout, ")");
1172                 }
1173         } else if (ccb->cts.transport == XPORT_ATA) {
1174                 struct ccb_trans_settings_pata *pata =
1175                     &ccb->cts.xport_specific.ata;
1176
1177                 printf(" (");
1178                 if (pata->valid & CTS_ATA_VALID_MODE)
1179                         printf("%s, ", ata_mode2string(pata->mode));
1180                 if ((pata->valid & CTS_ATA_VALID_ATAPI) && pata->atapi != 0)
1181                         printf("ATAPI %dbytes, ", pata->atapi);
1182                 if (pata->valid & CTS_ATA_VALID_BYTECOUNT)
1183                         printf("PIO %dbytes", pata->bytecount);
1184                 printf(")");
1185         } else if (ccb->cts.transport == XPORT_SATA) {
1186                 struct ccb_trans_settings_sata *sata =
1187                     &ccb->cts.xport_specific.sata;
1188
1189                 printf(" (");
1190                 if (sata->valid & CTS_SATA_VALID_REVISION)
1191                         printf("SATA %d.x, ", sata->revision);
1192                 else
1193                         printf("SATA, ");
1194                 if (sata->valid & CTS_SATA_VALID_MODE)
1195                         printf("%s, ", ata_mode2string(sata->mode));
1196                 if ((sata->valid & CTS_SATA_VALID_ATAPI) && sata->atapi != 0)
1197                         printf("ATAPI %dbytes, ", sata->atapi);
1198                 if (sata->valid & CTS_SATA_VALID_BYTECOUNT)
1199                         printf("PIO %dbytes", sata->bytecount);
1200                 printf(")");
1201         }
1202
1203         if (ccb->cts.protocol == PROTO_SCSI) {
1204                 struct ccb_trans_settings_scsi *scsi =
1205                     &ccb->cts.proto_specific.scsi;
1206                 if (scsi->valid & CTS_SCSI_VALID_TQ) {
1207                         if (scsi->flags & CTS_SCSI_FLAGS_TAG_ENB) {
1208                                 fprintf(stdout, ", Command Queueing Enabled");
1209                         }
1210                 }
1211         }
1212
1213         fprintf(stdout, "\n");
1214
1215 xferrate_bailout:
1216
1217         cam_freeccb(ccb);
1218
1219         return(retval);
1220 }
1221
1222 static void
1223 atahpa_print(struct ata_params *parm, u_int64_t hpasize, int header)
1224 {
1225         u_int32_t lbasize = (u_int32_t)parm->lba_size_1 |
1226                                 ((u_int32_t)parm->lba_size_2 << 16);
1227
1228         u_int64_t lbasize48 = ((u_int64_t)parm->lba_size48_1) |
1229                                 ((u_int64_t)parm->lba_size48_2 << 16) |
1230                                 ((u_int64_t)parm->lba_size48_3 << 32) |
1231                                 ((u_int64_t)parm->lba_size48_4 << 48);
1232
1233         if (header) {
1234                 printf("\nFeature                      "
1235                        "Support  Enabled   Value\n");
1236         }
1237
1238         printf("Host Protected Area (HPA)      ");
1239         if (parm->support.command1 & ATA_SUPPORT_PROTECTED) {
1240                 u_int64_t lba = lbasize48 ? lbasize48 : lbasize;
1241                 printf("yes      %s     %ju/%ju\n", (hpasize > lba) ? "yes" : "no ",
1242                         lba, hpasize);
1243
1244                 printf("HPA - Security                 ");
1245                 if (parm->support.command1 & ATA_SUPPORT_MAXSECURITY)
1246                         printf("yes\n");
1247                 else
1248                         printf("no\n");
1249         } else {
1250                 printf("no\n");
1251         }
1252 }
1253
1254 static int
1255 atasata(struct ata_params *parm)
1256 {
1257
1258
1259         if (parm->satacapabilities != 0xffff &&
1260             parm->satacapabilities != 0x0000)
1261                 return 1;
1262
1263         return 0;
1264 }
1265
1266 static void
1267 atacapprint(struct ata_params *parm)
1268 {
1269         u_int32_t lbasize = (u_int32_t)parm->lba_size_1 |
1270                                 ((u_int32_t)parm->lba_size_2 << 16);
1271
1272         u_int64_t lbasize48 = ((u_int64_t)parm->lba_size48_1) |
1273                                 ((u_int64_t)parm->lba_size48_2 << 16) |
1274                                 ((u_int64_t)parm->lba_size48_3 << 32) |
1275                                 ((u_int64_t)parm->lba_size48_4 << 48);
1276
1277         printf("\n");
1278         printf("protocol              ");
1279         printf("ATA/ATAPI-%d", ata_version(parm->version_major));
1280         if (parm->satacapabilities && parm->satacapabilities != 0xffff) {
1281                 if (parm->satacapabilities & ATA_SATA_GEN3)
1282                         printf(" SATA 3.x\n");
1283                 else if (parm->satacapabilities & ATA_SATA_GEN2)
1284                         printf(" SATA 2.x\n");
1285                 else if (parm->satacapabilities & ATA_SATA_GEN1)
1286                         printf(" SATA 1.x\n");
1287                 else
1288                         printf(" SATA\n");
1289         }
1290         else
1291                 printf("\n");
1292         printf("device model          %.40s\n", parm->model);
1293         printf("firmware revision     %.8s\n", parm->revision);
1294         printf("serial number         %.20s\n", parm->serial);
1295         if (parm->enabled.extension & ATA_SUPPORT_64BITWWN) {
1296                 printf("WWN                   %04x%04x%04x%04x\n",
1297                     parm->wwn[0], parm->wwn[1], parm->wwn[2], parm->wwn[3]);
1298         }
1299         if (parm->enabled.extension & ATA_SUPPORT_MEDIASN) {
1300                 printf("media serial number   %.30s\n",
1301                     parm->media_serial);
1302         }
1303
1304         printf("cylinders             %d\n", parm->cylinders);
1305         printf("heads                 %d\n", parm->heads);
1306         printf("sectors/track         %d\n", parm->sectors);
1307         printf("sector size           logical %u, physical %lu, offset %lu\n",
1308             ata_logical_sector_size(parm),
1309             (unsigned long)ata_physical_sector_size(parm),
1310             (unsigned long)ata_logical_sector_offset(parm));
1311
1312         if (parm->config == ATA_PROTO_CFA ||
1313             (parm->support.command2 & ATA_SUPPORT_CFA))
1314                 printf("CFA supported\n");
1315
1316         printf("LBA%ssupported         ",
1317                 parm->capabilities1 & ATA_SUPPORT_LBA ? " " : " not ");
1318         if (lbasize)
1319                 printf("%d sectors\n", lbasize);
1320         else
1321                 printf("\n");
1322
1323         printf("LBA48%ssupported       ",
1324                 parm->support.command2 & ATA_SUPPORT_ADDRESS48 ? " " : " not ");
1325         if (lbasize48)
1326                 printf("%ju sectors\n", (uintmax_t)lbasize48);
1327         else
1328                 printf("\n");
1329
1330         printf("PIO supported         PIO");
1331         switch (ata_max_pmode(parm)) {
1332         case ATA_PIO4:
1333                 printf("4");
1334                 break;
1335         case ATA_PIO3:
1336                 printf("3");
1337                 break;
1338         case ATA_PIO2:
1339                 printf("2");
1340                 break;
1341         case ATA_PIO1:
1342                 printf("1");
1343                 break;
1344         default:
1345                 printf("0");
1346         }
1347         if ((parm->capabilities1 & ATA_SUPPORT_IORDY) == 0)
1348                 printf(" w/o IORDY");
1349         printf("\n");
1350
1351         printf("DMA%ssupported         ",
1352                 parm->capabilities1 & ATA_SUPPORT_DMA ? " " : " not ");
1353         if (parm->capabilities1 & ATA_SUPPORT_DMA) {
1354                 if (parm->mwdmamodes & 0xff) {
1355                         printf("WDMA");
1356                         if (parm->mwdmamodes & 0x04)
1357                                 printf("2");
1358                         else if (parm->mwdmamodes & 0x02)
1359                                 printf("1");
1360                         else if (parm->mwdmamodes & 0x01)
1361                                 printf("0");
1362                         printf(" ");
1363                 }
1364                 if ((parm->atavalid & ATA_FLAG_88) &&
1365                     (parm->udmamodes & 0xff)) {
1366                         printf("UDMA");
1367                         if (parm->udmamodes & 0x40)
1368                                 printf("6");
1369                         else if (parm->udmamodes & 0x20)
1370                                 printf("5");
1371                         else if (parm->udmamodes & 0x10)
1372                                 printf("4");
1373                         else if (parm->udmamodes & 0x08)
1374                                 printf("3");
1375                         else if (parm->udmamodes & 0x04)
1376                                 printf("2");
1377                         else if (parm->udmamodes & 0x02)
1378                                 printf("1");
1379                         else if (parm->udmamodes & 0x01)
1380                                 printf("0");
1381                         printf(" ");
1382                 }
1383         }
1384         printf("\n");
1385
1386         if (parm->media_rotation_rate == 1) {
1387                 printf("media RPM             non-rotating\n");
1388         } else if (parm->media_rotation_rate >= 0x0401 &&
1389             parm->media_rotation_rate <= 0xFFFE) {
1390                 printf("media RPM             %d\n",
1391                         parm->media_rotation_rate);
1392         }
1393
1394         printf("\nFeature                      "
1395                 "Support  Enabled   Value           Vendor\n");
1396         printf("read ahead                     %s       %s\n",
1397                 parm->support.command1 & ATA_SUPPORT_LOOKAHEAD ? "yes" : "no",
1398                 parm->enabled.command1 & ATA_SUPPORT_LOOKAHEAD ? "yes" : "no");
1399         printf("write cache                    %s       %s\n",
1400                 parm->support.command1 & ATA_SUPPORT_WRITECACHE ? "yes" : "no",
1401                 parm->enabled.command1 & ATA_SUPPORT_WRITECACHE ? "yes" : "no");
1402         printf("flush cache                    %s       %s\n",
1403                 parm->support.command2 & ATA_SUPPORT_FLUSHCACHE ? "yes" : "no",
1404                 parm->enabled.command2 & ATA_SUPPORT_FLUSHCACHE ? "yes" : "no");
1405         printf("overlap                        %s\n",
1406                 parm->capabilities1 & ATA_SUPPORT_OVERLAP ? "yes" : "no");
1407         printf("Tagged Command Queuing (TCQ)   %s       %s",
1408                 parm->support.command2 & ATA_SUPPORT_QUEUED ? "yes" : "no",
1409                 parm->enabled.command2 & ATA_SUPPORT_QUEUED ? "yes" : "no");
1410                 if (parm->support.command2 & ATA_SUPPORT_QUEUED) {
1411                         printf("        %d tags\n",
1412                             ATA_QUEUE_LEN(parm->queue) + 1);
1413                 } else
1414                         printf("\n");
1415         printf("Native Command Queuing (NCQ)   ");
1416         if (parm->satacapabilities != 0xffff &&
1417             (parm->satacapabilities & ATA_SUPPORT_NCQ)) {
1418                 printf("yes             %d tags\n",
1419                     ATA_QUEUE_LEN(parm->queue) + 1);
1420         } else
1421                 printf("no\n");
1422
1423         printf("NCQ Queue Management           %s\n", atasata(parm) &&
1424                 parm->satacapabilities2 & ATA_SUPPORT_NCQ_QMANAGEMENT ?
1425                 "yes" : "no");
1426         printf("NCQ Streaming                  %s\n", atasata(parm) &&
1427                 parm->satacapabilities2 & ATA_SUPPORT_NCQ_STREAM ?
1428                 "yes" : "no");
1429         printf("Receive & Send FPDMA Queued    %s\n", atasata(parm) &&
1430                 parm->satacapabilities2 & ATA_SUPPORT_RCVSND_FPDMA_QUEUED ?
1431                 "yes" : "no");
1432
1433         printf("SMART                          %s       %s\n",
1434                 parm->support.command1 & ATA_SUPPORT_SMART ? "yes" : "no",
1435                 parm->enabled.command1 & ATA_SUPPORT_SMART ? "yes" : "no");
1436         printf("microcode download             %s       %s\n",
1437                 parm->support.command2 & ATA_SUPPORT_MICROCODE ? "yes" : "no",
1438                 parm->enabled.command2 & ATA_SUPPORT_MICROCODE ? "yes" : "no");
1439         printf("security                       %s       %s\n",
1440                 parm->support.command1 & ATA_SUPPORT_SECURITY ? "yes" : "no",
1441                 parm->enabled.command1 & ATA_SUPPORT_SECURITY ? "yes" : "no");
1442         printf("power management               %s       %s\n",
1443                 parm->support.command1 & ATA_SUPPORT_POWERMGT ? "yes" : "no",
1444                 parm->enabled.command1 & ATA_SUPPORT_POWERMGT ? "yes" : "no");
1445         printf("advanced power management      %s       %s",
1446                 parm->support.command2 & ATA_SUPPORT_APM ? "yes" : "no",
1447                 parm->enabled.command2 & ATA_SUPPORT_APM ? "yes" : "no");
1448                 if (parm->support.command2 & ATA_SUPPORT_APM) {
1449                         printf("        %d/0x%02X\n",
1450                             parm->apm_value & 0xff, parm->apm_value & 0xff);
1451                 } else
1452                         printf("\n");
1453         printf("automatic acoustic management  %s       %s",
1454                 parm->support.command2 & ATA_SUPPORT_AUTOACOUSTIC ? "yes" :"no",
1455                 parm->enabled.command2 & ATA_SUPPORT_AUTOACOUSTIC ? "yes" :"no");
1456                 if (parm->support.command2 & ATA_SUPPORT_AUTOACOUSTIC) {
1457                         printf("        %d/0x%02X       %d/0x%02X\n",
1458                             ATA_ACOUSTIC_CURRENT(parm->acoustic),
1459                             ATA_ACOUSTIC_CURRENT(parm->acoustic),
1460                             ATA_ACOUSTIC_VENDOR(parm->acoustic),
1461                             ATA_ACOUSTIC_VENDOR(parm->acoustic));
1462                 } else
1463                         printf("\n");
1464         printf("media status notification      %s       %s\n",
1465                 parm->support.command2 & ATA_SUPPORT_NOTIFY ? "yes" : "no",
1466                 parm->enabled.command2 & ATA_SUPPORT_NOTIFY ? "yes" : "no");
1467         printf("power-up in Standby            %s       %s\n",
1468                 parm->support.command2 & ATA_SUPPORT_STANDBY ? "yes" : "no",
1469                 parm->enabled.command2 & ATA_SUPPORT_STANDBY ? "yes" : "no");
1470         printf("write-read-verify              %s       %s",
1471                 parm->support2 & ATA_SUPPORT_WRITEREADVERIFY ? "yes" : "no",
1472                 parm->enabled2 & ATA_SUPPORT_WRITEREADVERIFY ? "yes" : "no");
1473                 if (parm->support2 & ATA_SUPPORT_WRITEREADVERIFY) {
1474                         printf("        %d/0x%x\n",
1475                             parm->wrv_mode, parm->wrv_mode);
1476                 } else
1477                         printf("\n");
1478         printf("unload                         %s       %s\n",
1479                 parm->support.extension & ATA_SUPPORT_UNLOAD ? "yes" : "no",
1480                 parm->enabled.extension & ATA_SUPPORT_UNLOAD ? "yes" : "no");
1481         printf("general purpose logging        %s       %s\n",
1482                 parm->support.extension & ATA_SUPPORT_GENLOG ? "yes" : "no",
1483                 parm->enabled.extension & ATA_SUPPORT_GENLOG ? "yes" : "no");
1484         printf("free-fall                      %s       %s\n",
1485                 parm->support2 & ATA_SUPPORT_FREEFALL ? "yes" : "no",
1486                 parm->enabled2 & ATA_SUPPORT_FREEFALL ? "yes" : "no");
1487         printf("Data Set Management (DSM/TRIM) ");
1488         if (parm->support_dsm & ATA_SUPPORT_DSM_TRIM) {
1489                 printf("yes\n");
1490                 printf("DSM - max 512byte blocks       ");
1491                 if (parm->max_dsm_blocks == 0x00)
1492                         printf("yes              not specified\n");
1493                 else
1494                         printf("yes              %d\n",
1495                                 parm->max_dsm_blocks);
1496
1497                 printf("DSM - deterministic read       ");
1498                 if (parm->support3 & ATA_SUPPORT_DRAT) {
1499                         if (parm->support3 & ATA_SUPPORT_RZAT)
1500                                 printf("yes              zeroed\n");
1501                         else
1502                                 printf("yes              any value\n");
1503                 } else {
1504                         printf("no\n");
1505                 }
1506         } else {
1507                 printf("no\n");
1508         }
1509 }
1510
1511 static int
1512 scsi_cam_pass_16_send(struct cam_device *device, union ccb *ccb, int quiet)
1513 {
1514         struct ata_pass_16 *ata_pass_16;
1515         struct ata_cmd ata_cmd;
1516
1517         ata_pass_16 = (struct ata_pass_16 *)ccb->csio.cdb_io.cdb_bytes;
1518         ata_cmd.command = ata_pass_16->command;
1519         ata_cmd.control = ata_pass_16->control;
1520         ata_cmd.features = ata_pass_16->features;
1521
1522         if (arglist & CAM_ARG_VERBOSE) {
1523                 warnx("sending ATA %s via pass_16 with timeout of %u msecs",
1524                       ata_op_string(&ata_cmd),
1525                       ccb->csio.ccb_h.timeout);
1526         }
1527
1528         /* Disable freezing the device queue */
1529         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
1530
1531         if (arglist & CAM_ARG_ERR_RECOVER)
1532                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
1533
1534         if (cam_send_ccb(device, ccb) < 0) {
1535                 if (quiet != 1 || arglist & CAM_ARG_VERBOSE) {
1536                         warn("error sending ATA %s via pass_16",
1537                              ata_op_string(&ata_cmd));
1538                 }
1539
1540                 if (arglist & CAM_ARG_VERBOSE) {
1541                         cam_error_print(device, ccb, CAM_ESF_ALL,
1542                                         CAM_EPF_ALL, stderr);
1543                 }
1544
1545                 return (1);
1546         }
1547
1548         if (!(ata_pass_16->flags & AP_FLAG_CHK_COND) &&
1549             (ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
1550                 if (quiet != 1 || arglist & CAM_ARG_VERBOSE) {
1551                         warnx("ATA %s via pass_16 failed",
1552                               ata_op_string(&ata_cmd));
1553                 }
1554                 if (arglist & CAM_ARG_VERBOSE) {
1555                         cam_error_print(device, ccb, CAM_ESF_ALL,
1556                                         CAM_EPF_ALL, stderr);
1557                 }
1558
1559                 return (1);
1560         }
1561
1562         return (0);
1563 }
1564
1565
1566 static int
1567 ata_cam_send(struct cam_device *device, union ccb *ccb, int quiet)
1568 {
1569         if (arglist & CAM_ARG_VERBOSE) {
1570                 warnx("sending ATA %s with timeout of %u msecs",
1571                       ata_op_string(&(ccb->ataio.cmd)),
1572                       ccb->ataio.ccb_h.timeout);
1573         }
1574
1575         /* Disable freezing the device queue */
1576         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
1577
1578         if (arglist & CAM_ARG_ERR_RECOVER)
1579                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
1580
1581         if (cam_send_ccb(device, ccb) < 0) {
1582                 if (quiet != 1 || arglist & CAM_ARG_VERBOSE) {
1583                         warn("error sending ATA %s",
1584                              ata_op_string(&(ccb->ataio.cmd)));
1585                 }
1586
1587                 if (arglist & CAM_ARG_VERBOSE) {
1588                         cam_error_print(device, ccb, CAM_ESF_ALL,
1589                                         CAM_EPF_ALL, stderr);
1590                 }
1591
1592                 return (1);
1593         }
1594
1595         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
1596                 if (quiet != 1 || arglist & CAM_ARG_VERBOSE) {
1597                         warnx("ATA %s failed: %d",
1598                               ata_op_string(&(ccb->ataio.cmd)), quiet);
1599                 }
1600
1601                 if (arglist & CAM_ARG_VERBOSE) {
1602                         cam_error_print(device, ccb, CAM_ESF_ALL,
1603                                         CAM_EPF_ALL, stderr);
1604                 }
1605
1606                 return (1);
1607         }
1608
1609         return (0);
1610 }
1611
1612 static int
1613 ata_do_pass_16(struct cam_device *device, union ccb *ccb, int retries,
1614                u_int32_t flags, u_int8_t protocol, u_int8_t ata_flags,
1615                u_int8_t tag_action, u_int8_t command, u_int8_t features,
1616                u_int64_t lba, u_int8_t sector_count, u_int8_t *data_ptr,
1617                u_int16_t dxfer_len, int timeout, int quiet)
1618 {
1619         if (data_ptr != NULL) {
1620                 ata_flags |= AP_FLAG_BYT_BLOK_BYTES |
1621                             AP_FLAG_TLEN_SECT_CNT;
1622                 if (flags & CAM_DIR_OUT)
1623                         ata_flags |= AP_FLAG_TDIR_TO_DEV;
1624                 else
1625                         ata_flags |= AP_FLAG_TDIR_FROM_DEV;
1626         } else {
1627                 ata_flags |= AP_FLAG_TLEN_NO_DATA;
1628         }
1629
1630         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
1631
1632         scsi_ata_pass_16(&ccb->csio,
1633                          retries,
1634                          NULL,
1635                          flags,
1636                          tag_action,
1637                          protocol,
1638                          ata_flags,
1639                          features,
1640                          sector_count,
1641                          lba,
1642                          command,
1643                          /*control*/0,
1644                          data_ptr,
1645                          dxfer_len,
1646                          /*sense_len*/SSD_FULL_SIZE,
1647                          timeout);
1648
1649         return scsi_cam_pass_16_send(device, ccb, quiet);
1650 }
1651
1652 static int
1653 ata_try_pass_16(struct cam_device *device)
1654 {
1655         struct ccb_pathinq cpi;
1656
1657         if (get_cpi(device, &cpi) != 0) {
1658                 warnx("couldn't get CPI");
1659                 return (-1);
1660         }
1661
1662         if (cpi.protocol == PROTO_SCSI) {
1663                 /* possibly compatible with pass_16 */
1664                 return (1);
1665         }
1666
1667         /* likely not compatible with pass_16 */
1668         return (0);
1669 }
1670
1671 static int
1672 ata_do_28bit_cmd(struct cam_device *device, union ccb *ccb, int retries,
1673                  u_int32_t flags, u_int8_t protocol, u_int8_t tag_action,
1674                  u_int8_t command, u_int8_t features, u_int32_t lba,
1675                  u_int8_t sector_count, u_int8_t *data_ptr, u_int16_t dxfer_len,
1676                  int timeout, int quiet)
1677 {
1678
1679
1680         switch (ata_try_pass_16(device)) {
1681         case -1:
1682                 return (1);
1683         case 1:
1684                 /* Try using SCSI Passthrough */
1685                 return ata_do_pass_16(device, ccb, retries, flags, protocol,
1686                                       0, tag_action, command, features, lba,
1687                                       sector_count, data_ptr, dxfer_len,
1688                                       timeout, quiet);
1689         }
1690
1691         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->ataio);
1692         cam_fill_ataio(&ccb->ataio,
1693                        retries,
1694                        NULL,
1695                        flags,
1696                        tag_action,
1697                        data_ptr,
1698                        dxfer_len,
1699                        timeout);
1700
1701         ata_28bit_cmd(&ccb->ataio, command, features, lba, sector_count);
1702         return ata_cam_send(device, ccb, quiet);
1703 }
1704
1705 static int
1706 ata_do_cmd(struct cam_device *device, union ccb *ccb, int retries,
1707            u_int32_t flags, u_int8_t protocol, u_int8_t ata_flags,
1708            u_int8_t tag_action, u_int8_t command, u_int8_t features,
1709            u_int64_t lba, u_int8_t sector_count, u_int8_t *data_ptr,
1710            u_int16_t dxfer_len, int timeout, int force48bit)
1711 {
1712         int retval;
1713
1714         retval = ata_try_pass_16(device);
1715         if (retval == -1)
1716                 return (1);
1717
1718         if (retval == 1) {
1719                 int error;
1720
1721                 /* Try using SCSI Passthrough */
1722                 error = ata_do_pass_16(device, ccb, retries, flags, protocol,
1723                                       ata_flags, tag_action, command, features,
1724                                       lba, sector_count, data_ptr, dxfer_len,
1725                                       timeout, 0);
1726
1727                 if (ata_flags & AP_FLAG_CHK_COND) {
1728                         /* Decode ata_res from sense data */
1729                         struct ata_res_pass16 *res_pass16;
1730                         struct ata_res *res;
1731                         u_int i;
1732                         u_int16_t *ptr;
1733
1734                         /* sense_data is 4 byte aligned */
1735                         ptr = (uint16_t*)(uintptr_t)&ccb->csio.sense_data;
1736                         for (i = 0; i < sizeof(*res_pass16) / 2; i++)
1737                                 ptr[i] = le16toh(ptr[i]);
1738
1739                         /* sense_data is 4 byte aligned */
1740                         res_pass16 = (struct ata_res_pass16 *)(uintptr_t)
1741                             &ccb->csio.sense_data;
1742                         res = &ccb->ataio.res;
1743                         res->flags = res_pass16->flags;
1744                         res->status = res_pass16->status;
1745                         res->error = res_pass16->error;
1746                         res->lba_low = res_pass16->lba_low;
1747                         res->lba_mid = res_pass16->lba_mid;
1748                         res->lba_high = res_pass16->lba_high;
1749                         res->device = res_pass16->device;
1750                         res->lba_low_exp = res_pass16->lba_low_exp;
1751                         res->lba_mid_exp = res_pass16->lba_mid_exp;
1752                         res->lba_high_exp = res_pass16->lba_high_exp;
1753                         res->sector_count = res_pass16->sector_count;
1754                         res->sector_count_exp = res_pass16->sector_count_exp;
1755                 }
1756
1757                 return (error);
1758         }
1759
1760         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->ataio);
1761         cam_fill_ataio(&ccb->ataio,
1762                        retries,
1763                        NULL,
1764                        flags,
1765                        tag_action,
1766                        data_ptr,
1767                        dxfer_len,
1768                        timeout);
1769
1770         if (force48bit || lba > ATA_MAX_28BIT_LBA)
1771                 ata_48bit_cmd(&ccb->ataio, command, features, lba, sector_count);
1772         else
1773                 ata_28bit_cmd(&ccb->ataio, command, features, lba, sector_count);
1774
1775         if (ata_flags & AP_FLAG_CHK_COND)
1776                 ccb->ataio.cmd.flags |= CAM_ATAIO_NEEDRESULT;
1777
1778         return ata_cam_send(device, ccb, 0);
1779 }
1780
1781 static void
1782 dump_data(uint16_t *ptr, uint32_t len)
1783 {
1784         u_int i;
1785
1786         for (i = 0; i < len / 2; i++) {
1787                 if ((i % 8) == 0)
1788                         printf(" %3d: ", i);
1789                 printf("%04hx ", ptr[i]);
1790                 if ((i % 8) == 7)
1791                         printf("\n");
1792         }
1793         if ((i % 8) != 7)
1794                 printf("\n");
1795 }
1796
1797 static int
1798 atahpa_proc_resp(struct cam_device *device, union ccb *ccb,
1799                  int is48bit, u_int64_t *hpasize)
1800 {
1801         struct ata_res *res;
1802
1803         res = &ccb->ataio.res;
1804         if (res->status & ATA_STATUS_ERROR) {
1805                 if (arglist & CAM_ARG_VERBOSE) {
1806                         cam_error_print(device, ccb, CAM_ESF_ALL,
1807                                         CAM_EPF_ALL, stderr);
1808                         printf("error = 0x%02x, sector_count = 0x%04x, "
1809                                "device = 0x%02x, status = 0x%02x\n",
1810                                res->error, res->sector_count,
1811                                res->device, res->status);
1812                 }
1813
1814                 if (res->error & ATA_ERROR_ID_NOT_FOUND) {
1815                         warnx("Max address has already been set since "
1816                               "last power-on or hardware reset");
1817                 }
1818
1819                 return (1);
1820         }
1821
1822         if (arglist & CAM_ARG_VERBOSE) {
1823                 fprintf(stdout, "%s%d: Raw native max data:\n",
1824                         device->device_name, device->dev_unit_num);
1825                 /* res is 4 byte aligned */
1826                 dump_data((uint16_t*)(uintptr_t)res, sizeof(struct ata_res));
1827
1828                 printf("error = 0x%02x, sector_count = 0x%04x, device = 0x%02x, "
1829                        "status = 0x%02x\n", res->error, res->sector_count,
1830                        res->device, res->status);
1831         }
1832
1833         if (hpasize != NULL) {
1834                 if (is48bit) {
1835                         *hpasize = (((u_int64_t)((res->lba_high_exp << 16) |
1836                             (res->lba_mid_exp << 8) | res->lba_low_exp) << 24) |
1837                             ((res->lba_high << 16) | (res->lba_mid << 8) |
1838                             res->lba_low)) + 1;
1839                 } else {
1840                         *hpasize = (((res->device & 0x0f) << 24) |
1841                             (res->lba_high << 16) | (res->lba_mid << 8) |
1842                             res->lba_low) + 1;
1843                 }
1844         }
1845
1846         return (0);
1847 }
1848
1849 static int
1850 ata_read_native_max(struct cam_device *device, int retry_count,
1851                       u_int32_t timeout, union ccb *ccb,
1852                       struct ata_params *parm, u_int64_t *hpasize)
1853 {
1854         int error;
1855         u_int cmd, is48bit;
1856         u_int8_t protocol;
1857
1858         is48bit = parm->support.command2 & ATA_SUPPORT_ADDRESS48;
1859         protocol = AP_PROTO_NON_DATA;
1860
1861         if (is48bit) {
1862                 cmd = ATA_READ_NATIVE_MAX_ADDRESS48;
1863                 protocol |= AP_EXTEND;
1864         } else {
1865                 cmd = ATA_READ_NATIVE_MAX_ADDRESS;
1866         }
1867
1868         error = ata_do_cmd(device,
1869                            ccb,
1870                            retry_count,
1871                            /*flags*/CAM_DIR_NONE,
1872                            /*protocol*/protocol,
1873                            /*ata_flags*/AP_FLAG_CHK_COND,
1874                            /*tag_action*/MSG_SIMPLE_Q_TAG,
1875                            /*command*/cmd,
1876                            /*features*/0,
1877                            /*lba*/0,
1878                            /*sector_count*/0,
1879                            /*data_ptr*/NULL,
1880                            /*dxfer_len*/0,
1881                            timeout ? timeout : 1000,
1882                            is48bit);
1883
1884         if (error)
1885                 return (error);
1886
1887         return atahpa_proc_resp(device, ccb, is48bit, hpasize);
1888 }
1889
1890 static int
1891 atahpa_set_max(struct cam_device *device, int retry_count,
1892               u_int32_t timeout, union ccb *ccb,
1893               int is48bit, u_int64_t maxsize, int persist)
1894 {
1895         int error;
1896         u_int cmd;
1897         u_int8_t protocol;
1898
1899         protocol = AP_PROTO_NON_DATA;
1900
1901         if (is48bit) {
1902                 cmd = ATA_SET_MAX_ADDRESS48;
1903                 protocol |= AP_EXTEND;
1904         } else {
1905                 cmd = ATA_SET_MAX_ADDRESS;
1906         }
1907
1908         /* lba's are zero indexed so the max lba is requested max - 1 */
1909         if (maxsize)
1910                 maxsize--;
1911
1912         error = ata_do_cmd(device,
1913                            ccb,
1914                            retry_count,
1915                            /*flags*/CAM_DIR_NONE,
1916                            /*protocol*/protocol,
1917                            /*ata_flags*/AP_FLAG_CHK_COND,
1918                            /*tag_action*/MSG_SIMPLE_Q_TAG,
1919                            /*command*/cmd,
1920                            /*features*/ATA_HPA_FEAT_MAX_ADDR,
1921                            /*lba*/maxsize,
1922                            /*sector_count*/persist,
1923                            /*data_ptr*/NULL,
1924                            /*dxfer_len*/0,
1925                            timeout ? timeout : 1000,
1926                            is48bit);
1927
1928         if (error)
1929                 return (error);
1930
1931         return atahpa_proc_resp(device, ccb, is48bit, NULL);
1932 }
1933
1934 static int
1935 atahpa_password(struct cam_device *device, int retry_count,
1936                 u_int32_t timeout, union ccb *ccb,
1937                 int is48bit, struct ata_set_max_pwd *pwd)
1938 {
1939         int error;
1940         u_int cmd;
1941         u_int8_t protocol;
1942
1943         protocol = AP_PROTO_PIO_OUT;
1944         cmd = (is48bit) ? ATA_SET_MAX_ADDRESS48 : ATA_SET_MAX_ADDRESS;
1945
1946         error = ata_do_cmd(device,
1947                            ccb,
1948                            retry_count,
1949                            /*flags*/CAM_DIR_OUT,
1950                            /*protocol*/protocol,
1951                            /*ata_flags*/AP_FLAG_CHK_COND,
1952                            /*tag_action*/MSG_SIMPLE_Q_TAG,
1953                            /*command*/cmd,
1954                            /*features*/ATA_HPA_FEAT_SET_PWD,
1955                            /*lba*/0,
1956                            /*sector_count*/0,
1957                            /*data_ptr*/(u_int8_t*)pwd,
1958                            /*dxfer_len*/sizeof(struct ata_set_max_pwd),
1959                            timeout ? timeout : 1000,
1960                            is48bit);
1961
1962         if (error)
1963                 return (error);
1964
1965         return atahpa_proc_resp(device, ccb, is48bit, NULL);
1966 }
1967
1968 static int
1969 atahpa_lock(struct cam_device *device, int retry_count,
1970             u_int32_t timeout, union ccb *ccb, int is48bit)
1971 {
1972         int error;
1973         u_int cmd;
1974         u_int8_t protocol;
1975
1976         protocol = AP_PROTO_NON_DATA;
1977         cmd = (is48bit) ? ATA_SET_MAX_ADDRESS48 : ATA_SET_MAX_ADDRESS;
1978
1979         error = ata_do_cmd(device,
1980                            ccb,
1981                            retry_count,
1982                            /*flags*/CAM_DIR_NONE,
1983                            /*protocol*/protocol,
1984                            /*ata_flags*/AP_FLAG_CHK_COND,
1985                            /*tag_action*/MSG_SIMPLE_Q_TAG,
1986                            /*command*/cmd,
1987                            /*features*/ATA_HPA_FEAT_LOCK,
1988                            /*lba*/0,
1989                            /*sector_count*/0,
1990                            /*data_ptr*/NULL,
1991                            /*dxfer_len*/0,
1992                            timeout ? timeout : 1000,
1993                            is48bit);
1994
1995         if (error)
1996                 return (error);
1997
1998         return atahpa_proc_resp(device, ccb, is48bit, NULL);
1999 }
2000
2001 static int
2002 atahpa_unlock(struct cam_device *device, int retry_count,
2003               u_int32_t timeout, union ccb *ccb,
2004               int is48bit, struct ata_set_max_pwd *pwd)
2005 {
2006         int error;
2007         u_int cmd;
2008         u_int8_t protocol;
2009
2010         protocol = AP_PROTO_PIO_OUT;
2011         cmd = (is48bit) ? ATA_SET_MAX_ADDRESS48 : ATA_SET_MAX_ADDRESS;
2012
2013         error = ata_do_cmd(device,
2014                            ccb,
2015                            retry_count,
2016                            /*flags*/CAM_DIR_OUT,
2017                            /*protocol*/protocol,
2018                            /*ata_flags*/AP_FLAG_CHK_COND,
2019                            /*tag_action*/MSG_SIMPLE_Q_TAG,
2020                            /*command*/cmd,
2021                            /*features*/ATA_HPA_FEAT_UNLOCK,
2022                            /*lba*/0,
2023                            /*sector_count*/0,
2024                            /*data_ptr*/(u_int8_t*)pwd,
2025                            /*dxfer_len*/sizeof(struct ata_set_max_pwd),
2026                            timeout ? timeout : 1000,
2027                            is48bit);
2028
2029         if (error)
2030                 return (error);
2031
2032         return atahpa_proc_resp(device, ccb, is48bit, NULL);
2033 }
2034
2035 static int
2036 atahpa_freeze_lock(struct cam_device *device, int retry_count,
2037                    u_int32_t timeout, union ccb *ccb, int is48bit)
2038 {
2039         int error;
2040         u_int cmd;
2041         u_int8_t protocol;
2042
2043         protocol = AP_PROTO_NON_DATA;
2044         cmd = (is48bit) ? ATA_SET_MAX_ADDRESS48 : ATA_SET_MAX_ADDRESS;
2045
2046         error = ata_do_cmd(device,
2047                            ccb,
2048                            retry_count,
2049                            /*flags*/CAM_DIR_NONE,
2050                            /*protocol*/protocol,
2051                            /*ata_flags*/AP_FLAG_CHK_COND,
2052                            /*tag_action*/MSG_SIMPLE_Q_TAG,
2053                            /*command*/cmd,
2054                            /*features*/ATA_HPA_FEAT_FREEZE,
2055                            /*lba*/0,
2056                            /*sector_count*/0,
2057                            /*data_ptr*/NULL,
2058                            /*dxfer_len*/0,
2059                            timeout ? timeout : 1000,
2060                            is48bit);
2061
2062         if (error)
2063                 return (error);
2064
2065         return atahpa_proc_resp(device, ccb, is48bit, NULL);
2066 }
2067
2068
2069 int
2070 ata_do_identify(struct cam_device *device, int retry_count, int timeout,
2071                 union ccb *ccb, struct ata_params** ident_bufp)
2072 {
2073         struct ata_params *ident_buf;
2074         struct ccb_pathinq cpi;
2075         struct ccb_getdev cgd;
2076         u_int i, error;
2077         int16_t *ptr;
2078         u_int8_t command, retry_command;
2079
2080         if (get_cpi(device, &cpi) != 0) {
2081                 warnx("couldn't get CPI");
2082                 return (-1);
2083         }
2084
2085         /* Neither PROTO_ATAPI or PROTO_SATAPM are used in cpi.protocol */
2086         if (cpi.protocol == PROTO_ATA) {
2087                 if (get_cgd(device, &cgd) != 0) {
2088                         warnx("couldn't get CGD");
2089                         return (-1);
2090                 }
2091
2092                 command = (cgd.protocol == PROTO_ATA) ?
2093                     ATA_ATA_IDENTIFY : ATA_ATAPI_IDENTIFY;
2094                 retry_command = 0;
2095         } else {
2096                 /* We don't know which for sure so try both */
2097                 command = ATA_ATA_IDENTIFY;
2098                 retry_command = ATA_ATAPI_IDENTIFY;
2099         }
2100
2101         ptr = (uint16_t *)calloc(1, sizeof(struct ata_params));
2102         if (ptr == NULL) {
2103                 warnx("can't calloc memory for identify\n");
2104                 return (1);
2105         }
2106
2107         error = ata_do_28bit_cmd(device,
2108                                  ccb,
2109                                  /*retries*/retry_count,
2110                                  /*flags*/CAM_DIR_IN,
2111                                  /*protocol*/AP_PROTO_PIO_IN,
2112                                  /*tag_action*/MSG_SIMPLE_Q_TAG,
2113                                  /*command*/command,
2114                                  /*features*/0,
2115                                  /*lba*/0,
2116                                  /*sector_count*/(u_int8_t)sizeof(struct ata_params),
2117                                  /*data_ptr*/(u_int8_t *)ptr,
2118                                  /*dxfer_len*/sizeof(struct ata_params),
2119                                  /*timeout*/timeout ? timeout : 30 * 1000,
2120                                  /*quiet*/1);
2121
2122         if (error != 0) {
2123                 if (retry_command == 0) {
2124                         free(ptr);
2125                         return (1);
2126                 }
2127                 error = ata_do_28bit_cmd(device,
2128                                          ccb,
2129                                          /*retries*/retry_count,
2130                                          /*flags*/CAM_DIR_IN,
2131                                          /*protocol*/AP_PROTO_PIO_IN,
2132                                          /*tag_action*/MSG_SIMPLE_Q_TAG,
2133                                          /*command*/retry_command,
2134                                          /*features*/0,
2135                                          /*lba*/0,
2136                                          /*sector_count*/(u_int8_t)
2137                                              sizeof(struct ata_params),
2138                                          /*data_ptr*/(u_int8_t *)ptr,
2139                                          /*dxfer_len*/sizeof(struct ata_params),
2140                                          /*timeout*/timeout ? timeout : 30 * 1000,
2141                                          /*quiet*/0);
2142
2143                 if (error != 0) {
2144                         free(ptr);
2145                         return (1);
2146                 }
2147         }
2148
2149         error = 1;
2150         for (i = 0; i < sizeof(struct ata_params) / 2; i++) {
2151                 ptr[i] = le16toh(ptr[i]);
2152                 if (ptr[i] != 0)
2153                         error = 0;
2154         }
2155
2156         if (arglist & CAM_ARG_VERBOSE) {
2157                 fprintf(stdout, "%s%d: Raw identify data:\n",
2158                     device->device_name, device->dev_unit_num);
2159                 dump_data(ptr, sizeof(struct ata_params));
2160         }
2161
2162         /* check for invalid (all zero) response */
2163         if (error != 0) {
2164                 warnx("Invalid identify response detected");
2165                 free(ptr);
2166                 return (error);
2167         }
2168
2169         ident_buf = (struct ata_params *)ptr;
2170         if (strncmp(ident_buf->model, "FX", 2) &&
2171             strncmp(ident_buf->model, "NEC", 3) &&
2172             strncmp(ident_buf->model, "Pioneer", 7) &&
2173             strncmp(ident_buf->model, "SHARP", 5)) {
2174                 ata_bswap(ident_buf->model, sizeof(ident_buf->model));
2175                 ata_bswap(ident_buf->revision, sizeof(ident_buf->revision));
2176                 ata_bswap(ident_buf->serial, sizeof(ident_buf->serial));
2177                 ata_bswap(ident_buf->media_serial, sizeof(ident_buf->media_serial));
2178         }
2179         ata_btrim(ident_buf->model, sizeof(ident_buf->model));
2180         ata_bpack(ident_buf->model, ident_buf->model, sizeof(ident_buf->model));
2181         ata_btrim(ident_buf->revision, sizeof(ident_buf->revision));
2182         ata_bpack(ident_buf->revision, ident_buf->revision, sizeof(ident_buf->revision));
2183         ata_btrim(ident_buf->serial, sizeof(ident_buf->serial));
2184         ata_bpack(ident_buf->serial, ident_buf->serial, sizeof(ident_buf->serial));
2185         ata_btrim(ident_buf->media_serial, sizeof(ident_buf->media_serial));
2186         ata_bpack(ident_buf->media_serial, ident_buf->media_serial,
2187             sizeof(ident_buf->media_serial));
2188
2189         *ident_bufp = ident_buf;
2190
2191         return (0);
2192 }
2193
2194
2195 static int
2196 ataidentify(struct cam_device *device, int retry_count, int timeout)
2197 {
2198         union ccb *ccb;
2199         struct ata_params *ident_buf;
2200         u_int64_t hpasize;
2201
2202         if ((ccb = cam_getccb(device)) == NULL) {
2203                 warnx("couldn't allocate CCB");
2204                 return (1);
2205         }
2206
2207         if (ata_do_identify(device, retry_count, timeout, ccb, &ident_buf) != 0) {
2208                 cam_freeccb(ccb);
2209                 return (1);
2210         }
2211
2212         if (ident_buf->support.command1 & ATA_SUPPORT_PROTECTED) {
2213                 if (ata_read_native_max(device, retry_count, timeout, ccb,
2214                                         ident_buf, &hpasize) != 0) {
2215                         cam_freeccb(ccb);
2216                         return (1);
2217                 }
2218         } else {
2219                 hpasize = 0;
2220         }
2221
2222         printf("%s%d: ", device->device_name, device->dev_unit_num);
2223         ata_print_ident(ident_buf);
2224         camxferrate(device);
2225         atacapprint(ident_buf);
2226         atahpa_print(ident_buf, hpasize, 0);
2227
2228         free(ident_buf);
2229         cam_freeccb(ccb);
2230
2231         return (0);
2232 }
2233 #endif /* MINIMALISTIC */
2234
2235
2236 #ifndef MINIMALISTIC
2237 enum {
2238         ATA_SECURITY_ACTION_PRINT,
2239         ATA_SECURITY_ACTION_FREEZE,
2240         ATA_SECURITY_ACTION_UNLOCK,
2241         ATA_SECURITY_ACTION_DISABLE,
2242         ATA_SECURITY_ACTION_ERASE,
2243         ATA_SECURITY_ACTION_ERASE_ENHANCED,
2244         ATA_SECURITY_ACTION_SET_PASSWORD
2245 };
2246
2247 static void
2248 atasecurity_print_time(u_int16_t tw)
2249 {
2250
2251         if (tw == 0)
2252                 printf("unspecified");
2253         else if (tw >= 255)
2254                 printf("> 508 min");
2255         else
2256                 printf("%i min", 2 * tw);
2257 }
2258
2259 static u_int32_t
2260 atasecurity_erase_timeout_msecs(u_int16_t timeout)
2261 {
2262
2263         if (timeout == 0)
2264                 return 2 * 3600 * 1000; /* default: two hours */
2265         else if (timeout > 255)
2266                 return (508 + 60) * 60 * 1000; /* spec says > 508 minutes */
2267
2268         return ((2 * timeout) + 5) * 60 * 1000; /* add a 5min margin */
2269 }
2270
2271
2272 static void
2273 atasecurity_notify(u_int8_t command, struct ata_security_password *pwd)
2274 {
2275         struct ata_cmd cmd;
2276
2277         bzero(&cmd, sizeof(cmd));
2278         cmd.command = command;
2279         printf("Issuing %s", ata_op_string(&cmd));
2280
2281         if (pwd != NULL) {
2282                 char pass[sizeof(pwd->password)+1];
2283
2284                 /* pwd->password may not be null terminated */
2285                 pass[sizeof(pwd->password)] = '\0';
2286                 strncpy(pass, pwd->password, sizeof(pwd->password));
2287                 printf(" password='%s', user='%s'",
2288                         pass,
2289                         (pwd->ctrl & ATA_SECURITY_PASSWORD_MASTER) ?
2290                         "master" : "user");
2291
2292                 if (command == ATA_SECURITY_SET_PASSWORD) {
2293                         printf(", mode='%s'",
2294                                (pwd->ctrl & ATA_SECURITY_LEVEL_MAXIMUM) ?
2295                                "maximum" : "high");
2296                 }
2297         }
2298
2299         printf("\n");
2300 }
2301
2302 static int
2303 atasecurity_freeze(struct cam_device *device, union ccb *ccb,
2304                    int retry_count, u_int32_t timeout, int quiet)
2305 {
2306
2307         if (quiet == 0)
2308                 atasecurity_notify(ATA_SECURITY_FREEZE_LOCK, NULL);
2309
2310         return ata_do_28bit_cmd(device,
2311                                 ccb,
2312                                 retry_count,
2313                                 /*flags*/CAM_DIR_NONE,
2314                                 /*protocol*/AP_PROTO_NON_DATA,
2315                                 /*tag_action*/MSG_SIMPLE_Q_TAG,
2316                                 /*command*/ATA_SECURITY_FREEZE_LOCK,
2317                                 /*features*/0,
2318                                 /*lba*/0,
2319                                 /*sector_count*/0,
2320                                 /*data_ptr*/NULL,
2321                                 /*dxfer_len*/0,
2322                                 /*timeout*/timeout,
2323                                 /*quiet*/0);
2324 }
2325
2326 static int
2327 atasecurity_unlock(struct cam_device *device, union ccb *ccb,
2328                    int retry_count, u_int32_t timeout,
2329                    struct ata_security_password *pwd, int quiet)
2330 {
2331
2332         if (quiet == 0)
2333                 atasecurity_notify(ATA_SECURITY_UNLOCK, pwd);
2334
2335         return ata_do_28bit_cmd(device,
2336                                 ccb,
2337                                 retry_count,
2338                                 /*flags*/CAM_DIR_OUT,
2339                                 /*protocol*/AP_PROTO_PIO_OUT,
2340                                 /*tag_action*/MSG_SIMPLE_Q_TAG,
2341                                 /*command*/ATA_SECURITY_UNLOCK,
2342                                 /*features*/0,
2343                                 /*lba*/0,
2344                                 /*sector_count*/0,
2345                                 /*data_ptr*/(u_int8_t *)pwd,
2346                                 /*dxfer_len*/sizeof(*pwd),
2347                                 /*timeout*/timeout,
2348                                 /*quiet*/0);
2349 }
2350
2351 static int
2352 atasecurity_disable(struct cam_device *device, union ccb *ccb,
2353                     int retry_count, u_int32_t timeout,
2354                     struct ata_security_password *pwd, int quiet)
2355 {
2356
2357         if (quiet == 0)
2358                 atasecurity_notify(ATA_SECURITY_DISABLE_PASSWORD, pwd);
2359         return ata_do_28bit_cmd(device,
2360                                 ccb,
2361                                 retry_count,
2362                                 /*flags*/CAM_DIR_OUT,
2363                                 /*protocol*/AP_PROTO_PIO_OUT,
2364                                 /*tag_action*/MSG_SIMPLE_Q_TAG,
2365                                 /*command*/ATA_SECURITY_DISABLE_PASSWORD,
2366                                 /*features*/0,
2367                                 /*lba*/0,
2368                                 /*sector_count*/0,
2369                                 /*data_ptr*/(u_int8_t *)pwd,
2370                                 /*dxfer_len*/sizeof(*pwd),
2371                                 /*timeout*/timeout,
2372                                 /*quiet*/0);
2373 }
2374
2375
2376 static int
2377 atasecurity_erase_confirm(struct cam_device *device,
2378                           struct ata_params* ident_buf)
2379 {
2380
2381         printf("\nYou are about to ERASE ALL DATA from the following"
2382                " device:\n%s%d,%s%d: ", device->device_name,
2383                device->dev_unit_num, device->given_dev_name,
2384                device->given_unit_number);
2385         ata_print_ident(ident_buf);
2386
2387         for(;;) {
2388                 char str[50];
2389                 printf("\nAre you SURE you want to ERASE ALL DATA? (yes/no) ");
2390
2391                 if (fgets(str, sizeof(str), stdin) != NULL) {
2392                         if (strncasecmp(str, "yes", 3) == 0) {
2393                                 return (1);
2394                         } else if (strncasecmp(str, "no", 2) == 0) {
2395                                 return (0);
2396                         } else {
2397                                 printf("Please answer \"yes\" or "
2398                                        "\"no\"\n");
2399                         }
2400                 }
2401         }
2402
2403         /* NOTREACHED */
2404         return (0);
2405 }
2406
2407 static int
2408 atasecurity_erase(struct cam_device *device, union ccb *ccb,
2409                   int retry_count, u_int32_t timeout,
2410                   u_int32_t erase_timeout,
2411                   struct ata_security_password *pwd, int quiet)
2412 {
2413         int error;
2414
2415         if (quiet == 0)
2416                 atasecurity_notify(ATA_SECURITY_ERASE_PREPARE, NULL);
2417
2418         error = ata_do_28bit_cmd(device,
2419                                  ccb,
2420                                  retry_count,
2421                                  /*flags*/CAM_DIR_NONE,
2422                                  /*protocol*/AP_PROTO_NON_DATA,
2423                                  /*tag_action*/MSG_SIMPLE_Q_TAG,
2424                                  /*command*/ATA_SECURITY_ERASE_PREPARE,
2425                                  /*features*/0,
2426                                  /*lba*/0,
2427                                  /*sector_count*/0,
2428                                  /*data_ptr*/NULL,
2429                                  /*dxfer_len*/0,
2430                                  /*timeout*/timeout,
2431                                  /*quiet*/0);
2432
2433         if (error != 0)
2434                 return error;
2435
2436         if (quiet == 0)
2437                 atasecurity_notify(ATA_SECURITY_ERASE_UNIT, pwd);
2438
2439         error = ata_do_28bit_cmd(device,
2440                                  ccb,
2441                                  retry_count,
2442                                  /*flags*/CAM_DIR_OUT,
2443                                  /*protocol*/AP_PROTO_PIO_OUT,
2444                                  /*tag_action*/MSG_SIMPLE_Q_TAG,
2445                                  /*command*/ATA_SECURITY_ERASE_UNIT,
2446                                  /*features*/0,
2447                                  /*lba*/0,
2448                                  /*sector_count*/0,
2449                                  /*data_ptr*/(u_int8_t *)pwd,
2450                                  /*dxfer_len*/sizeof(*pwd),
2451                                  /*timeout*/erase_timeout,
2452                                  /*quiet*/0);
2453
2454         if (error == 0 && quiet == 0)
2455                 printf("\nErase Complete\n");
2456
2457         return error;
2458 }
2459
2460 static int
2461 atasecurity_set_password(struct cam_device *device, union ccb *ccb,
2462                          int retry_count, u_int32_t timeout,
2463                          struct ata_security_password *pwd, int quiet)
2464 {
2465
2466         if (quiet == 0)
2467                 atasecurity_notify(ATA_SECURITY_SET_PASSWORD, pwd);
2468
2469         return ata_do_28bit_cmd(device,
2470                                  ccb,
2471                                  retry_count,
2472                                  /*flags*/CAM_DIR_OUT,
2473                                  /*protocol*/AP_PROTO_PIO_OUT,
2474                                  /*tag_action*/MSG_SIMPLE_Q_TAG,
2475                                  /*command*/ATA_SECURITY_SET_PASSWORD,
2476                                  /*features*/0,
2477                                  /*lba*/0,
2478                                  /*sector_count*/0,
2479                                  /*data_ptr*/(u_int8_t *)pwd,
2480                                  /*dxfer_len*/sizeof(*pwd),
2481                                  /*timeout*/timeout,
2482                                  /*quiet*/0);
2483 }
2484
2485 static void
2486 atasecurity_print(struct ata_params *parm)
2487 {
2488
2489         printf("\nSecurity Option           Value\n");
2490         if (arglist & CAM_ARG_VERBOSE) {
2491                 printf("status                    %04x\n",
2492                        parm->security_status);
2493         }
2494         printf("supported                 %s\n",
2495                 parm->security_status & ATA_SECURITY_SUPPORTED ? "yes" : "no");
2496         if (!(parm->security_status & ATA_SECURITY_SUPPORTED))
2497                 return;
2498         printf("enabled                   %s\n",
2499                 parm->security_status & ATA_SECURITY_ENABLED ? "yes" : "no");
2500         printf("drive locked              %s\n",
2501                 parm->security_status & ATA_SECURITY_LOCKED ? "yes" : "no");
2502         printf("security config frozen    %s\n",
2503                 parm->security_status & ATA_SECURITY_FROZEN ? "yes" : "no");
2504         printf("count expired             %s\n",
2505                 parm->security_status & ATA_SECURITY_COUNT_EXP ? "yes" : "no");
2506         printf("security level            %s\n",
2507                 parm->security_status & ATA_SECURITY_LEVEL ? "maximum" : "high");
2508         printf("enhanced erase supported  %s\n",
2509                 parm->security_status & ATA_SECURITY_ENH_SUPP ? "yes" : "no");
2510         printf("erase time                ");
2511         atasecurity_print_time(parm->erase_time);
2512         printf("\n");
2513         printf("enhanced erase time       ");
2514         atasecurity_print_time(parm->enhanced_erase_time);
2515         printf("\n");
2516         printf("master password rev       %04x%s\n",
2517                 parm->master_passwd_revision,
2518                 parm->master_passwd_revision == 0x0000 ||
2519                 parm->master_passwd_revision == 0xFFFF ?  " (unsupported)" : "");
2520 }
2521
2522 /*
2523  * Validates and copies the password in optarg to the passed buffer.
2524  * If the password in optarg is the same length as the buffer then
2525  * the data will still be copied but no null termination will occur.
2526  */
2527 static int
2528 ata_getpwd(u_int8_t *passwd, int max, char opt)
2529 {
2530         int len;
2531
2532         len = strlen(optarg);
2533         if (len > max) {
2534                 warnx("-%c password is too long", opt);
2535                 return (1);
2536         } else if (len == 0) {
2537                 warnx("-%c password is missing", opt);
2538                 return (1);
2539         } else if (optarg[0] == '-'){
2540                 warnx("-%c password starts with '-' (generic arg?)", opt);
2541                 return (1);
2542         } else if (strlen(passwd) != 0 && strcmp(passwd, optarg) != 0) {
2543                 warnx("-%c password conflicts with existing password from -%c",
2544                       opt, pwd_opt);
2545                 return (1);
2546         }
2547
2548         /* Callers pass in a buffer which does NOT need to be terminated */
2549         strncpy(passwd, optarg, max);
2550         pwd_opt = opt;
2551
2552         return (0);
2553 }
2554
2555 enum {
2556         ATA_HPA_ACTION_PRINT,
2557         ATA_HPA_ACTION_SET_MAX,
2558         ATA_HPA_ACTION_SET_PWD,
2559         ATA_HPA_ACTION_LOCK,
2560         ATA_HPA_ACTION_UNLOCK,
2561         ATA_HPA_ACTION_FREEZE_LOCK
2562 };
2563
2564 static int
2565 atahpa_set_confirm(struct cam_device *device, struct ata_params* ident_buf,
2566                    u_int64_t maxsize, int persist)
2567 {
2568         printf("\nYou are about to configure HPA to limit the user accessible\n"
2569                "sectors to %ju %s on the device:\n%s%d,%s%d: ", maxsize,
2570                persist ? "persistently" : "temporarily",
2571                device->device_name, device->dev_unit_num,
2572                device->given_dev_name, device->given_unit_number);
2573         ata_print_ident(ident_buf);
2574
2575         for(;;) {
2576                 char str[50];
2577                 printf("\nAre you SURE you want to configure HPA? (yes/no) ");
2578
2579                 if (NULL != fgets(str, sizeof(str), stdin)) {
2580                         if (0 == strncasecmp(str, "yes", 3)) {
2581                                 return (1);
2582                         } else if (0 == strncasecmp(str, "no", 2)) {
2583                                 return (0);
2584                         } else {
2585                                 printf("Please answer \"yes\" or "
2586                                        "\"no\"\n");
2587                         }
2588                 }
2589         }
2590
2591         /* NOTREACHED */
2592         return (0);
2593 }
2594
2595 static int
2596 atahpa(struct cam_device *device, int retry_count, int timeout,
2597        int argc, char **argv, char *combinedopt)
2598 {
2599         union ccb *ccb;
2600         struct ata_params *ident_buf;
2601         struct ccb_getdev cgd;
2602         struct ata_set_max_pwd pwd;
2603         int error, confirm, quiet, c, action, actions, persist;
2604         int security, is48bit, pwdsize;
2605         u_int64_t hpasize, maxsize;
2606
2607         actions = 0;
2608         confirm = 0;
2609         quiet = 0;
2610         maxsize = 0;
2611         persist = 0;
2612         security = 0;
2613
2614         memset(&pwd, 0, sizeof(pwd));
2615
2616         /* default action is to print hpa information */
2617         action = ATA_HPA_ACTION_PRINT;
2618         pwdsize = sizeof(pwd.password);
2619
2620         while ((c = getopt(argc, argv, combinedopt)) != -1) {
2621                 switch(c){
2622                 case 's':
2623                         action = ATA_HPA_ACTION_SET_MAX;
2624                         maxsize = strtoumax(optarg, NULL, 0);
2625                         actions++;
2626                         break;
2627
2628                 case 'p':
2629                         if (ata_getpwd(pwd.password, pwdsize, c) != 0)
2630                                 return (1);
2631                         action = ATA_HPA_ACTION_SET_PWD;
2632                         security = 1;
2633                         actions++;
2634                         break;
2635
2636                 case 'l':
2637                         action = ATA_HPA_ACTION_LOCK;
2638                         security = 1;
2639                         actions++;
2640                         break;
2641
2642                 case 'U':
2643                         if (ata_getpwd(pwd.password, pwdsize, c) != 0)
2644                                 return (1);
2645                         action = ATA_HPA_ACTION_UNLOCK;
2646                         security = 1;
2647                         actions++;
2648                         break;
2649
2650                 case 'f':
2651                         action = ATA_HPA_ACTION_FREEZE_LOCK;
2652                         security = 1;
2653                         actions++;
2654                         break;
2655
2656                 case 'P':
2657                         persist = 1;
2658                         break;
2659
2660                 case 'y':
2661                         confirm++;
2662                         break;
2663
2664                 case 'q':
2665                         quiet++;
2666                         break;
2667                 }
2668         }
2669
2670         if (actions > 1) {
2671                 warnx("too many hpa actions specified");
2672                 return (1);
2673         }
2674
2675         if (get_cgd(device, &cgd) != 0) {
2676                 warnx("couldn't get CGD");
2677                 return (1);
2678         }
2679
2680         ccb = cam_getccb(device);
2681         if (ccb == NULL) {
2682                 warnx("couldn't allocate CCB");
2683                 return (1);
2684         }
2685
2686         error = ata_do_identify(device, retry_count, timeout, ccb, &ident_buf);
2687         if (error != 0) {
2688                 cam_freeccb(ccb);
2689                 return (1);
2690         }
2691
2692         if (quiet == 0) {
2693                 printf("%s%d: ", device->device_name, device->dev_unit_num);
2694                 ata_print_ident(ident_buf);
2695                 camxferrate(device);
2696         }
2697
2698         if (action == ATA_HPA_ACTION_PRINT) {
2699                 error = ata_read_native_max(device, retry_count, timeout, ccb,
2700                                             ident_buf, &hpasize);
2701                 if (error == 0)
2702                         atahpa_print(ident_buf, hpasize, 1);
2703
2704                 cam_freeccb(ccb);
2705                 free(ident_buf);
2706                 return (error);
2707         }
2708
2709         if (!(ident_buf->support.command1 & ATA_SUPPORT_PROTECTED)) {
2710                 warnx("HPA is not supported by this device");
2711                 cam_freeccb(ccb);
2712                 free(ident_buf);
2713                 return (1);
2714         }
2715
2716         if (security && !(ident_buf->support.command1 & ATA_SUPPORT_MAXSECURITY)) {
2717                 warnx("HPA Security is not supported by this device");
2718                 cam_freeccb(ccb);
2719                 free(ident_buf);
2720                 return (1);
2721         }
2722
2723         is48bit = ident_buf->support.command2 & ATA_SUPPORT_ADDRESS48;
2724
2725         /*
2726          * The ATA spec requires:
2727          * 1. Read native max addr is called directly before set max addr
2728          * 2. Read native max addr is NOT called before any other set max call
2729          */
2730         switch(action) {
2731         case ATA_HPA_ACTION_SET_MAX:
2732                 if (confirm == 0 &&
2733                     atahpa_set_confirm(device, ident_buf, maxsize,
2734                     persist) == 0) {
2735                         cam_freeccb(ccb);
2736                         free(ident_buf);
2737                         return (1);
2738                 }
2739
2740                 error = ata_read_native_max(device, retry_count, timeout,
2741                                             ccb, ident_buf, &hpasize);
2742                 if (error == 0) {
2743                         error = atahpa_set_max(device, retry_count, timeout,
2744                                                ccb, is48bit, maxsize, persist);
2745                         if (error == 0) {
2746                                 /* redo identify to get new lba values */
2747                                 error = ata_do_identify(device, retry_count,
2748                                                         timeout, ccb,
2749                                                         &ident_buf);
2750                                 atahpa_print(ident_buf, hpasize, 1);
2751                         }
2752                 }
2753                 break;
2754
2755         case ATA_HPA_ACTION_SET_PWD:
2756                 error = atahpa_password(device, retry_count, timeout,
2757                                         ccb, is48bit, &pwd);
2758                 if (error == 0)
2759                         printf("HPA password has been set\n");
2760                 break;
2761
2762         case ATA_HPA_ACTION_LOCK:
2763                 error = atahpa_lock(device, retry_count, timeout,
2764                                     ccb, is48bit);
2765                 if (error == 0)
2766                         printf("HPA has been locked\n");
2767                 break;
2768
2769         case ATA_HPA_ACTION_UNLOCK:
2770                 error = atahpa_unlock(device, retry_count, timeout,
2771                                       ccb, is48bit, &pwd);
2772                 if (error == 0)
2773                         printf("HPA has been unlocked\n");
2774                 break;
2775
2776         case ATA_HPA_ACTION_FREEZE_LOCK:
2777                 error = atahpa_freeze_lock(device, retry_count, timeout,
2778                                            ccb, is48bit);
2779                 if (error == 0)
2780                         printf("HPA has been frozen\n");
2781                 break;
2782
2783         default:
2784                 errx(1, "Option currently not supported");
2785         }
2786
2787         cam_freeccb(ccb);
2788         free(ident_buf);
2789
2790         return (error);
2791 }
2792
2793 static int
2794 atasecurity(struct cam_device *device, int retry_count, int timeout,
2795             int argc, char **argv, char *combinedopt)
2796 {
2797         union ccb *ccb;
2798         struct ata_params *ident_buf;
2799         int error, confirm, quiet, c, action, actions, setpwd;
2800         int security_enabled, erase_timeout, pwdsize;
2801         struct ata_security_password pwd;
2802
2803         actions = 0;
2804         setpwd = 0;
2805         erase_timeout = 0;
2806         confirm = 0;
2807         quiet = 0;
2808
2809         memset(&pwd, 0, sizeof(pwd));
2810
2811         /* default action is to print security information */
2812         action = ATA_SECURITY_ACTION_PRINT;
2813
2814         /* user is master by default as its safer that way */
2815         pwd.ctrl |= ATA_SECURITY_PASSWORD_MASTER;
2816         pwdsize = sizeof(pwd.password);
2817
2818         while ((c = getopt(argc, argv, combinedopt)) != -1) {
2819                 switch(c){
2820                 case 'f':
2821                         action = ATA_SECURITY_ACTION_FREEZE;
2822                         actions++;
2823                         break;
2824
2825                 case 'U':
2826                         if (strcasecmp(optarg, "user") == 0) {
2827                                 pwd.ctrl |= ATA_SECURITY_PASSWORD_USER;
2828                                 pwd.ctrl &= ~ATA_SECURITY_PASSWORD_MASTER;
2829                         } else if (strcasecmp(optarg, "master") == 0) {
2830                                 pwd.ctrl |= ATA_SECURITY_PASSWORD_MASTER;
2831                                 pwd.ctrl &= ~ATA_SECURITY_PASSWORD_USER;
2832                         } else {
2833                                 warnx("-U argument '%s' is invalid (must be "
2834                                       "'user' or 'master')", optarg);
2835                                 return (1);
2836                         }
2837                         break;
2838
2839                 case 'l':
2840                         if (strcasecmp(optarg, "high") == 0) {
2841                                 pwd.ctrl |= ATA_SECURITY_LEVEL_HIGH;
2842                                 pwd.ctrl &= ~ATA_SECURITY_LEVEL_MAXIMUM;
2843                         } else if (strcasecmp(optarg, "maximum") == 0) {
2844                                 pwd.ctrl |= ATA_SECURITY_LEVEL_MAXIMUM;
2845                                 pwd.ctrl &= ~ATA_SECURITY_LEVEL_HIGH;
2846                         } else {
2847                                 warnx("-l argument '%s' is unknown (must be "
2848                                       "'high' or 'maximum')", optarg);
2849                                 return (1);
2850                         }
2851                         break;
2852
2853                 case 'k':
2854                         if (ata_getpwd(pwd.password, pwdsize, c) != 0)
2855                                 return (1);
2856                         action = ATA_SECURITY_ACTION_UNLOCK;
2857                         actions++;
2858                         break;
2859
2860                 case 'd':
2861                         if (ata_getpwd(pwd.password, pwdsize, c) != 0)
2862                                 return (1);
2863                         action = ATA_SECURITY_ACTION_DISABLE;
2864                         actions++;
2865                         break;
2866
2867                 case 'e':
2868                         if (ata_getpwd(pwd.password, pwdsize, c) != 0)
2869                                 return (1);
2870                         action = ATA_SECURITY_ACTION_ERASE;
2871                         actions++;
2872                         break;
2873
2874                 case 'h':
2875                         if (ata_getpwd(pwd.password, pwdsize, c) != 0)
2876                                 return (1);
2877                         pwd.ctrl |= ATA_SECURITY_ERASE_ENHANCED;
2878                         action = ATA_SECURITY_ACTION_ERASE_ENHANCED;
2879                         actions++;
2880                         break;
2881
2882                 case 's':
2883                         if (ata_getpwd(pwd.password, pwdsize, c) != 0)
2884                                 return (1);
2885                         setpwd = 1;
2886                         if (action == ATA_SECURITY_ACTION_PRINT)
2887                                 action = ATA_SECURITY_ACTION_SET_PASSWORD;
2888                         /*
2889                          * Don't increment action as this can be combined
2890                          * with other actions.
2891                          */
2892                         break;
2893
2894                 case 'y':
2895                         confirm++;
2896                         break;
2897
2898                 case 'q':
2899                         quiet++;
2900                         break;
2901
2902                 case 'T':
2903                         erase_timeout = atoi(optarg) * 1000;
2904                         break;
2905                 }
2906         }
2907
2908         if (actions > 1) {
2909                 warnx("too many security actions specified");
2910                 return (1);
2911         }
2912
2913         if ((ccb = cam_getccb(device)) == NULL) {
2914                 warnx("couldn't allocate CCB");
2915                 return (1);
2916         }
2917
2918         error = ata_do_identify(device, retry_count, timeout, ccb, &ident_buf);
2919         if (error != 0) {
2920                 cam_freeccb(ccb);
2921                 return (1);
2922         }
2923
2924         if (quiet == 0) {
2925                 printf("%s%d: ", device->device_name, device->dev_unit_num);
2926                 ata_print_ident(ident_buf);
2927                 camxferrate(device);
2928         }
2929
2930         if (action == ATA_SECURITY_ACTION_PRINT) {
2931                 atasecurity_print(ident_buf);
2932                 free(ident_buf);
2933                 cam_freeccb(ccb);
2934                 return (0);
2935         }
2936
2937         if ((ident_buf->support.command1 & ATA_SUPPORT_SECURITY) == 0) {
2938                 warnx("Security not supported");
2939                 free(ident_buf);
2940                 cam_freeccb(ccb);
2941                 return (1);
2942         }
2943
2944         /* default timeout 15 seconds the same as linux hdparm */
2945         timeout = timeout ? timeout : 15 * 1000;
2946
2947         security_enabled = ident_buf->security_status & ATA_SECURITY_ENABLED;
2948
2949         /* first set the password if requested */
2950         if (setpwd == 1) {
2951                 /* confirm we can erase before setting the password if erasing */
2952                 if (confirm == 0 &&
2953                     (action == ATA_SECURITY_ACTION_ERASE_ENHANCED ||
2954                     action == ATA_SECURITY_ACTION_ERASE) &&
2955                     atasecurity_erase_confirm(device, ident_buf) == 0) {
2956                         cam_freeccb(ccb);
2957                         free(ident_buf);
2958                         return (error);
2959                 }
2960
2961                 if (pwd.ctrl & ATA_SECURITY_PASSWORD_MASTER) {
2962                         pwd.revision = ident_buf->master_passwd_revision;
2963                         if (pwd.revision != 0 && pwd.revision != 0xfff &&
2964                             --pwd.revision == 0) {
2965                                 pwd.revision = 0xfffe;
2966                         }
2967                 }
2968                 error = atasecurity_set_password(device, ccb, retry_count,
2969                                                  timeout, &pwd, quiet);
2970                 if (error != 0) {
2971                         cam_freeccb(ccb);
2972                         free(ident_buf);
2973                         return (error);
2974                 }
2975                 security_enabled = 1;
2976         }
2977
2978         switch(action) {
2979         case ATA_SECURITY_ACTION_FREEZE:
2980                 error = atasecurity_freeze(device, ccb, retry_count,
2981                                            timeout, quiet);
2982                 break;
2983
2984         case ATA_SECURITY_ACTION_UNLOCK:
2985                 if (security_enabled) {
2986                         if (ident_buf->security_status & ATA_SECURITY_LOCKED) {
2987                                 error = atasecurity_unlock(device, ccb,
2988                                         retry_count, timeout, &pwd, quiet);
2989                         } else {
2990                                 warnx("Can't unlock, drive is not locked");
2991                                 error = 1;
2992                         }
2993                 } else {
2994                         warnx("Can't unlock, security is disabled");
2995                         error = 1;
2996                 }
2997                 break;
2998
2999         case ATA_SECURITY_ACTION_DISABLE:
3000                 if (security_enabled) {
3001                         /* First unlock the drive if its locked */
3002                         if (ident_buf->security_status & ATA_SECURITY_LOCKED) {
3003                                 error = atasecurity_unlock(device, ccb,
3004                                                            retry_count,
3005                                                            timeout,
3006                                                            &pwd,
3007                                                            quiet);
3008                         }
3009
3010                         if (error == 0) {
3011                                 error = atasecurity_disable(device,
3012                                                             ccb,
3013                                                             retry_count,
3014                                                             timeout,
3015                                                             &pwd,
3016                                                             quiet);
3017                         }
3018                 } else {
3019                         warnx("Can't disable security (already disabled)");
3020                         error = 1;
3021                 }
3022                 break;
3023
3024         case ATA_SECURITY_ACTION_ERASE:
3025                 if (security_enabled) {
3026                         if (erase_timeout == 0) {
3027                                 erase_timeout = atasecurity_erase_timeout_msecs(
3028                                     ident_buf->erase_time);
3029                         }
3030
3031                         error = atasecurity_erase(device, ccb, retry_count,
3032                                                   timeout, erase_timeout, &pwd,
3033                                                   quiet);
3034                 } else {
3035                         warnx("Can't secure erase (security is disabled)");
3036                         error = 1;
3037                 }
3038                 break;
3039
3040         case ATA_SECURITY_ACTION_ERASE_ENHANCED:
3041                 if (security_enabled) {
3042                         if (ident_buf->security_status & ATA_SECURITY_ENH_SUPP) {
3043                                 if (erase_timeout == 0) {
3044                                         erase_timeout =
3045                                             atasecurity_erase_timeout_msecs(
3046                                                 ident_buf->enhanced_erase_time);
3047                                 }
3048
3049                                 error = atasecurity_erase(device, ccb,
3050                                                           retry_count, timeout,
3051                                                           erase_timeout, &pwd,
3052                                                           quiet);
3053                         } else {
3054                                 warnx("Enhanced erase is not supported");
3055                                 error = 1;
3056                         }
3057                 } else {
3058                         warnx("Can't secure erase (enhanced), "
3059                               "(security is disabled)");
3060                         error = 1;
3061                 }
3062                 break;
3063         }
3064
3065         cam_freeccb(ccb);
3066         free(ident_buf);
3067
3068         return (error);
3069 }
3070 #endif /* MINIMALISTIC */
3071
3072 /*
3073  * Parse out a bus, or a bus, target and lun in the following
3074  * format:
3075  * bus
3076  * bus:target
3077  * bus:target:lun
3078  *
3079  * Returns the number of parsed components, or 0.
3080  */
3081 static int
3082 parse_btl(char *tstr, path_id_t *bus, target_id_t *target, lun_id_t *lun,
3083     cam_argmask *arglst)
3084 {
3085         char *tmpstr;
3086         int convs = 0;
3087
3088         while (isspace(*tstr) && (*tstr != '\0'))
3089                 tstr++;
3090
3091         tmpstr = (char *)strtok(tstr, ":");
3092         if ((tmpstr != NULL) && (*tmpstr != '\0')) {
3093                 *bus = strtol(tmpstr, NULL, 0);
3094                 *arglst |= CAM_ARG_BUS;
3095                 convs++;
3096                 tmpstr = (char *)strtok(NULL, ":");
3097                 if ((tmpstr != NULL) && (*tmpstr != '\0')) {
3098                         *target = strtol(tmpstr, NULL, 0);
3099                         *arglst |= CAM_ARG_TARGET;
3100                         convs++;
3101                         tmpstr = (char *)strtok(NULL, ":");
3102                         if ((tmpstr != NULL) && (*tmpstr != '\0')) {
3103                                 *lun = strtol(tmpstr, NULL, 0);
3104                                 *arglst |= CAM_ARG_LUN;
3105                                 convs++;
3106                         }
3107                 }
3108         }
3109
3110         return convs;
3111 }
3112
3113 static int
3114 dorescan_or_reset(int argc, char **argv, int rescan)
3115 {
3116         static const char must[] =
3117                 "you must specify \"all\", a bus, or a bus:target:lun to %s";
3118         int rv, error = 0;
3119         path_id_t bus = CAM_BUS_WILDCARD;
3120         target_id_t target = CAM_TARGET_WILDCARD;
3121         lun_id_t lun = CAM_LUN_WILDCARD;
3122         char *tstr;
3123
3124         if (argc < 3) {
3125                 warnx(must, rescan? "rescan" : "reset");
3126                 return(1);
3127         }
3128
3129         tstr = argv[optind];
3130         while (isspace(*tstr) && (*tstr != '\0'))
3131                 tstr++;
3132         if (strncasecmp(tstr, "all", strlen("all")) == 0)
3133                 arglist |= CAM_ARG_BUS;
3134         else if (isdigit(*tstr)) {
3135                 rv = parse_btl(argv[optind], &bus, &target, &lun, &arglist);
3136                 if (rv != 1 && rv != 3) {
3137                         warnx(must, rescan? "rescan" : "reset");
3138                         return(1);
3139                 }
3140         } else {
3141                 char name[30];
3142                 int unit;
3143                 int fd = -1;
3144                 union ccb ccb;
3145
3146                 /*
3147                  * Note that resetting or rescanning a device used to
3148                  * require a bus or bus:target:lun.  This is because the
3149                  * device in question may not exist and you're trying to
3150                  * get the controller to rescan to find it.  It may also be
3151                  * because the device is hung / unresponsive, and opening
3152                  * an unresponsive device is not desireable.
3153                  *
3154                  * It can be more convenient to reference a device by
3155                  * peripheral name and unit number, though, and it is
3156                  * possible to get the bus:target:lun for devices that
3157                  * currently exist in the EDT.  So this can work for
3158                  * devices that we want to reset, or devices that exist
3159                  * that we want to rescan, but not devices that do not
3160                  * exist yet.
3161                  *
3162                  * So, we are careful here to look up the bus/target/lun
3163                  * for the device the user wants to operate on, specified
3164                  * by peripheral instance (e.g. da0, pass32) without
3165                  * actually opening that device.  The process is similar to
3166                  * what cam_lookup_pass() does, except that we don't
3167                  * actually open the passthrough driver instance in the end.
3168                  */
3169
3170                 if (cam_get_device(tstr, name, sizeof(name), &unit) == -1) {
3171                         warnx("%s", cam_errbuf);
3172                         error = 1;
3173                         goto bailout;
3174                 }
3175
3176                 if ((fd = open(XPT_DEVICE, O_RDWR)) == -1) {
3177                         warn("Unable to open %s", XPT_DEVICE);
3178                         error = 1;
3179                         goto bailout;
3180                 }
3181
3182                 bzero(&ccb, sizeof(ccb));
3183
3184                 /*
3185                  * The function code isn't strictly necessary for the
3186                  * GETPASSTHRU ioctl.
3187                  */
3188                 ccb.ccb_h.func_code = XPT_GDEVLIST;
3189
3190                 /*
3191                  * These two are necessary for the GETPASSTHRU ioctl to
3192                  * work.
3193                  */
3194                 strlcpy(ccb.cgdl.periph_name, name,
3195                         sizeof(ccb.cgdl.periph_name));
3196                 ccb.cgdl.unit_number = unit;
3197
3198                 /*
3199                  * Attempt to get the passthrough device.  This ioctl will
3200                  * fail if the device name is null, if the device doesn't
3201                  * exist, or if the passthrough driver isn't in the kernel.
3202                  */
3203                 if (ioctl(fd, CAMGETPASSTHRU, &ccb) == -1) {
3204                         warn("Unable to find bus:target:lun for device %s%d",
3205                             name, unit);
3206                         error = 1;
3207                         close(fd);
3208                         goto bailout;
3209                 }
3210                 if ((ccb.ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
3211                         const struct cam_status_entry *entry;
3212
3213                         entry = cam_fetch_status_entry(ccb.ccb_h.status);
3214                         warnx("Unable to find bus:target_lun for device %s%d, "
3215                             "CAM status: %s (%#x)", name, unit,
3216                             entry ? entry->status_text : "Unknown",
3217                             ccb.ccb_h.status);
3218                         error = 1;
3219                         close(fd);
3220                         goto bailout;
3221                 }
3222
3223                 /*
3224                  * The kernel fills in the bus/target/lun.  We don't
3225                  * need the passthrough device name and unit number since
3226                  * we aren't going to open it.
3227                  */
3228                 bus = ccb.ccb_h.path_id;
3229                 target = ccb.ccb_h.target_id;
3230                 lun = ccb.ccb_h.target_lun;
3231
3232                 arglist |= CAM_ARG_BUS | CAM_ARG_TARGET | CAM_ARG_LUN;
3233
3234                 close(fd);
3235         }
3236
3237         if ((arglist & CAM_ARG_BUS)
3238             && (arglist & CAM_ARG_TARGET)
3239             && (arglist & CAM_ARG_LUN))
3240                 error = scanlun_or_reset_dev(bus, target, lun, rescan);
3241         else
3242                 error = rescan_or_reset_bus(bus, rescan);
3243
3244 bailout:
3245
3246         return(error);
3247 }
3248
3249 static int
3250 rescan_or_reset_bus(path_id_t bus, int rescan)
3251 {
3252         union ccb *ccb = NULL, *matchccb = NULL;
3253         int fd = -1, retval;
3254         int bufsize;
3255
3256         retval = 0;
3257
3258         if ((fd = open(XPT_DEVICE, O_RDWR)) < 0) {
3259                 warnx("error opening transport layer device %s", XPT_DEVICE);
3260                 warn("%s", XPT_DEVICE);
3261                 return(1);
3262         }
3263
3264         ccb = malloc(sizeof(*ccb));
3265         if (ccb == NULL) {
3266                 warn("failed to allocate CCB");
3267                 retval = 1;
3268                 goto bailout;
3269         }
3270         bzero(ccb, sizeof(*ccb));
3271
3272         if (bus != CAM_BUS_WILDCARD) {
3273                 ccb->ccb_h.func_code = rescan ? XPT_SCAN_BUS : XPT_RESET_BUS;
3274                 ccb->ccb_h.path_id = bus;
3275                 ccb->ccb_h.target_id = CAM_TARGET_WILDCARD;
3276                 ccb->ccb_h.target_lun = CAM_LUN_WILDCARD;
3277                 ccb->crcn.flags = CAM_FLAG_NONE;
3278
3279                 /* run this at a low priority */
3280                 ccb->ccb_h.pinfo.priority = 5;
3281
3282                 if (ioctl(fd, CAMIOCOMMAND, ccb) == -1) {
3283                         warn("CAMIOCOMMAND ioctl failed");
3284                         retval = 1;
3285                         goto bailout;
3286                 }
3287
3288                 if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
3289                         fprintf(stdout, "%s of bus %d was successful\n",
3290                             rescan ? "Re-scan" : "Reset", bus);
3291                 } else {
3292                         fprintf(stdout, "%s of bus %d returned error %#x\n",
3293                                 rescan ? "Re-scan" : "Reset", bus,
3294                                 ccb->ccb_h.status & CAM_STATUS_MASK);
3295                         retval = 1;
3296                 }
3297
3298                 goto bailout;
3299         }
3300
3301
3302         /*
3303          * The right way to handle this is to modify the xpt so that it can
3304          * handle a wildcarded bus in a rescan or reset CCB.  At the moment
3305          * that isn't implemented, so instead we enumerate the busses and
3306          * send the rescan or reset to those busses in the case where the
3307          * given bus is -1 (wildcard).  We don't send a rescan or reset
3308          * to the xpt bus; sending a rescan to the xpt bus is effectively a
3309          * no-op, sending a rescan to the xpt bus would result in a status of
3310          * CAM_REQ_INVALID.
3311          */
3312         matchccb = malloc(sizeof(*matchccb));
3313         if (matchccb == NULL) {
3314                 warn("failed to allocate CCB");
3315                 retval = 1;
3316                 goto bailout;
3317         }
3318         bzero(matchccb, sizeof(*matchccb));
3319         matchccb->ccb_h.func_code = XPT_DEV_MATCH;
3320         matchccb->ccb_h.path_id = CAM_BUS_WILDCARD;
3321         bufsize = sizeof(struct dev_match_result) * 20;
3322         matchccb->cdm.match_buf_len = bufsize;
3323         matchccb->cdm.matches=(struct dev_match_result *)malloc(bufsize);
3324         if (matchccb->cdm.matches == NULL) {
3325                 warnx("can't malloc memory for matches");
3326                 retval = 1;
3327                 goto bailout;
3328         }
3329         matchccb->cdm.num_matches = 0;
3330
3331         matchccb->cdm.num_patterns = 1;
3332         matchccb->cdm.pattern_buf_len = sizeof(struct dev_match_pattern);
3333
3334         matchccb->cdm.patterns = (struct dev_match_pattern *)malloc(
3335                 matchccb->cdm.pattern_buf_len);
3336         if (matchccb->cdm.patterns == NULL) {
3337                 warnx("can't malloc memory for patterns");
3338                 retval = 1;
3339                 goto bailout;
3340         }
3341         matchccb->cdm.patterns[0].type = DEV_MATCH_BUS;
3342         matchccb->cdm.patterns[0].pattern.bus_pattern.flags = BUS_MATCH_ANY;
3343
3344         do {
3345                 unsigned int i;
3346
3347                 if (ioctl(fd, CAMIOCOMMAND, matchccb) == -1) {
3348                         warn("CAMIOCOMMAND ioctl failed");
3349                         retval = 1;
3350                         goto bailout;
3351                 }
3352
3353                 if ((matchccb->ccb_h.status != CAM_REQ_CMP)
3354                  || ((matchccb->cdm.status != CAM_DEV_MATCH_LAST)
3355                    && (matchccb->cdm.status != CAM_DEV_MATCH_MORE))) {
3356                         warnx("got CAM error %#x, CDM error %d\n",
3357                               matchccb->ccb_h.status, matchccb->cdm.status);
3358                         retval = 1;
3359                         goto bailout;
3360                 }
3361
3362                 for (i = 0; i < matchccb->cdm.num_matches; i++) {
3363                         struct bus_match_result *bus_result;
3364
3365                         /* This shouldn't happen. */
3366                         if (matchccb->cdm.matches[i].type != DEV_MATCH_BUS)
3367                                 continue;
3368
3369                         bus_result =&matchccb->cdm.matches[i].result.bus_result;
3370
3371                         /*
3372                          * We don't want to rescan or reset the xpt bus.
3373                          * See above.
3374                          */
3375                         if (bus_result->path_id == CAM_XPT_PATH_ID)
3376                                 continue;
3377
3378                         ccb->ccb_h.func_code = rescan ? XPT_SCAN_BUS :
3379                                                        XPT_RESET_BUS;
3380                         ccb->ccb_h.path_id = bus_result->path_id;
3381                         ccb->ccb_h.target_id = CAM_TARGET_WILDCARD;
3382                         ccb->ccb_h.target_lun = CAM_LUN_WILDCARD;
3383                         ccb->crcn.flags = CAM_FLAG_NONE;
3384
3385                         /* run this at a low priority */
3386                         ccb->ccb_h.pinfo.priority = 5;
3387
3388                         if (ioctl(fd, CAMIOCOMMAND, ccb) == -1) {
3389                                 warn("CAMIOCOMMAND ioctl failed");
3390                                 retval = 1;
3391                                 goto bailout;
3392                         }
3393
3394                         if ((ccb->ccb_h.status & CAM_STATUS_MASK)==CAM_REQ_CMP){
3395                                 fprintf(stdout, "%s of bus %d was successful\n",
3396                                         rescan? "Re-scan" : "Reset",
3397                                         bus_result->path_id);
3398                         } else {
3399                                 /*
3400                                  * Don't bail out just yet, maybe the other
3401                                  * rescan or reset commands will complete
3402                                  * successfully.
3403                                  */
3404                                 fprintf(stderr, "%s of bus %d returned error "
3405                                         "%#x\n", rescan? "Re-scan" : "Reset",
3406                                         bus_result->path_id,
3407                                         ccb->ccb_h.status & CAM_STATUS_MASK);
3408                                 retval = 1;
3409                         }
3410                 }
3411         } while ((matchccb->ccb_h.status == CAM_REQ_CMP)
3412                  && (matchccb->cdm.status == CAM_DEV_MATCH_MORE));
3413
3414 bailout:
3415
3416         if (fd != -1)
3417                 close(fd);
3418
3419         if (matchccb != NULL) {
3420                 free(matchccb->cdm.patterns);
3421                 free(matchccb->cdm.matches);
3422                 free(matchccb);
3423         }
3424         free(ccb);
3425
3426         return(retval);
3427 }
3428
3429 static int
3430 scanlun_or_reset_dev(path_id_t bus, target_id_t target, lun_id_t lun, int scan)
3431 {
3432         union ccb ccb;
3433         struct cam_device *device;
3434         int fd;
3435
3436         device = NULL;
3437
3438         if (bus == CAM_BUS_WILDCARD) {
3439                 warnx("invalid bus number %d", bus);
3440                 return(1);
3441         }
3442
3443         if (target == CAM_TARGET_WILDCARD) {
3444                 warnx("invalid target number %d", target);
3445                 return(1);
3446         }
3447
3448         if (lun == CAM_LUN_WILDCARD) {
3449                 warnx("invalid lun number %jx", (uintmax_t)lun);
3450                 return(1);
3451         }
3452
3453         fd = -1;
3454
3455         bzero(&ccb, sizeof(union ccb));
3456
3457         if (scan) {
3458                 if ((fd = open(XPT_DEVICE, O_RDWR)) < 0) {
3459                         warnx("error opening transport layer device %s\n",
3460                             XPT_DEVICE);
3461                         warn("%s", XPT_DEVICE);
3462                         return(1);
3463                 }
3464         } else {
3465                 device = cam_open_btl(bus, target, lun, O_RDWR, NULL);
3466                 if (device == NULL) {
3467                         warnx("%s", cam_errbuf);
3468                         return(1);
3469                 }
3470         }
3471
3472         ccb.ccb_h.func_code = (scan)? XPT_SCAN_LUN : XPT_RESET_DEV;
3473         ccb.ccb_h.path_id = bus;
3474         ccb.ccb_h.target_id = target;
3475         ccb.ccb_h.target_lun = lun;
3476         ccb.ccb_h.timeout = 5000;
3477         ccb.crcn.flags = CAM_FLAG_NONE;
3478
3479         /* run this at a low priority */
3480         ccb.ccb_h.pinfo.priority = 5;
3481
3482         if (scan) {
3483                 if (ioctl(fd, CAMIOCOMMAND, &ccb) < 0) {
3484                         warn("CAMIOCOMMAND ioctl failed");
3485                         close(fd);
3486                         return(1);
3487                 }
3488         } else {
3489                 if (cam_send_ccb(device, &ccb) < 0) {
3490                         warn("error sending XPT_RESET_DEV CCB");
3491                         cam_close_device(device);
3492                         return(1);
3493                 }
3494         }
3495
3496         if (scan)
3497                 close(fd);
3498         else
3499                 cam_close_device(device);
3500
3501         /*
3502          * An error code of CAM_BDR_SENT is normal for a BDR request.
3503          */
3504         if (((ccb.ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP)
3505          || ((!scan)
3506           && ((ccb.ccb_h.status & CAM_STATUS_MASK) == CAM_BDR_SENT))) {
3507                 fprintf(stdout, "%s of %d:%d:%jx was successful\n",
3508                     scan? "Re-scan" : "Reset", bus, target, (uintmax_t)lun);
3509                 return(0);
3510         } else {
3511                 fprintf(stdout, "%s of %d:%d:%jx returned error %#x\n",
3512                     scan? "Re-scan" : "Reset", bus, target, (uintmax_t)lun,
3513                     ccb.ccb_h.status & CAM_STATUS_MASK);
3514                 return(1);
3515         }
3516 }
3517
3518 #ifndef MINIMALISTIC
3519
3520 static struct scsi_nv defect_list_type_map[] = {
3521         { "block", SRDD10_BLOCK_FORMAT },
3522         { "extbfi", SRDD10_EXT_BFI_FORMAT },
3523         { "extphys", SRDD10_EXT_PHYS_FORMAT },
3524         { "longblock", SRDD10_LONG_BLOCK_FORMAT },
3525         { "bfi", SRDD10_BYTES_FROM_INDEX_FORMAT },
3526         { "phys", SRDD10_PHYSICAL_SECTOR_FORMAT }
3527 };
3528
3529 static int
3530 readdefects(struct cam_device *device, int argc, char **argv,
3531             char *combinedopt, int task_attr, int retry_count, int timeout)
3532 {
3533         union ccb *ccb = NULL;
3534         struct scsi_read_defect_data_hdr_10 *hdr10 = NULL;
3535         struct scsi_read_defect_data_hdr_12 *hdr12 = NULL;
3536         size_t hdr_size = 0, entry_size = 0;
3537         int use_12byte = 0;
3538         int hex_format = 0;
3539         u_int8_t *defect_list = NULL;
3540         u_int8_t list_format = 0;
3541         int list_type_set = 0;
3542         u_int32_t dlist_length = 0;
3543         u_int32_t returned_length = 0, valid_len = 0;
3544         u_int32_t num_returned = 0, num_valid = 0;
3545         u_int32_t max_possible_size = 0, hdr_max = 0;
3546         u_int32_t starting_offset = 0;
3547         u_int8_t returned_format, returned_type;
3548         unsigned int i;
3549         int summary = 0, quiet = 0;
3550         int c, error = 0;
3551         int lists_specified = 0;
3552         int get_length = 1, first_pass = 1;
3553         int mads = 0;
3554
3555         while ((c = getopt(argc, argv, combinedopt)) != -1) {
3556                 switch(c){
3557                 case 'f':
3558                 {
3559                         scsi_nv_status status;
3560                         int entry_num = 0;
3561
3562                         status = scsi_get_nv(defect_list_type_map,
3563                             sizeof(defect_list_type_map) /
3564                             sizeof(defect_list_type_map[0]), optarg,
3565                             &entry_num, SCSI_NV_FLAG_IG_CASE);
3566
3567                         if (status == SCSI_NV_FOUND) {
3568                                 list_format = defect_list_type_map[
3569                                     entry_num].value;
3570                                 list_type_set = 1;
3571                         } else {
3572                                 warnx("%s: %s %s option %s", __func__,
3573                                     (status == SCSI_NV_AMBIGUOUS) ?
3574                                     "ambiguous" : "invalid", "defect list type",
3575                                     optarg);
3576                                 error = 1;
3577                                 goto defect_bailout;
3578                         }
3579                         break;
3580                 }
3581                 case 'G':
3582                         arglist |= CAM_ARG_GLIST;
3583                         break;
3584                 case 'P':
3585                         arglist |= CAM_ARG_PLIST;
3586                         break;
3587                 case 'q':
3588                         quiet = 1;
3589                         break;
3590                 case 's':
3591                         summary = 1;
3592                         break;
3593                 case 'S': {
3594                         char *endptr;
3595
3596                         starting_offset = strtoul(optarg, &endptr, 0);
3597                         if (*endptr != '\0') {
3598                                 error = 1;
3599                                 warnx("invalid starting offset %s", optarg);
3600                                 goto defect_bailout;
3601                         }
3602                         break;
3603                 }
3604                 case 'X':
3605                         hex_format = 1;
3606                         break;
3607                 default:
3608                         break;
3609                 }
3610         }
3611
3612         if (list_type_set == 0) {
3613                 error = 1;
3614                 warnx("no defect list format specified");
3615                 goto defect_bailout;
3616         }
3617
3618         if (arglist & CAM_ARG_PLIST) {
3619                 list_format |= SRDD10_PLIST;
3620                 lists_specified++;
3621         }
3622
3623         if (arglist & CAM_ARG_GLIST) {
3624                 list_format |= SRDD10_GLIST;
3625                 lists_specified++;
3626         }
3627
3628         /*
3629          * This implies a summary, and was the previous behavior.
3630          */
3631         if (lists_specified == 0)
3632                 summary = 1;
3633
3634         ccb = cam_getccb(device);
3635
3636 retry_12byte:
3637
3638         /*
3639          * We start off asking for just the header to determine how much
3640          * defect data is available.  Some Hitachi drives return an error
3641          * if you ask for more data than the drive has.  Once we know the
3642          * length, we retry the command with the returned length.
3643          */
3644         if (use_12byte == 0)
3645                 dlist_length = sizeof(*hdr10);
3646         else
3647                 dlist_length = sizeof(*hdr12);
3648
3649 retry:
3650         if (defect_list != NULL) {
3651                 free(defect_list);
3652                 defect_list = NULL;
3653         }
3654         defect_list = malloc(dlist_length);
3655         if (defect_list == NULL) {
3656                 warnx("can't malloc memory for defect list");
3657                 error = 1;
3658                 goto defect_bailout;
3659         }
3660
3661 next_batch:
3662         bzero(defect_list, dlist_length);
3663
3664         /*
3665          * cam_getccb() zeros the CCB header only.  So we need to zero the
3666          * payload portion of the ccb.
3667          */
3668         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
3669
3670         scsi_read_defects(&ccb->csio,
3671                           /*retries*/ retry_count,
3672                           /*cbfcnp*/ NULL,
3673                           /*tag_action*/ task_attr,
3674                           /*list_format*/ list_format,
3675                           /*addr_desc_index*/ starting_offset,
3676                           /*data_ptr*/ defect_list,
3677                           /*dxfer_len*/ dlist_length,
3678                           /*minimum_cmd_size*/ use_12byte ? 12 : 0,
3679                           /*sense_len*/ SSD_FULL_SIZE,
3680                           /*timeout*/ timeout ? timeout : 5000);
3681
3682         /* Disable freezing the device queue */
3683         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
3684
3685         if (cam_send_ccb(device, ccb) < 0) {
3686                 perror("error reading defect list");
3687
3688                 if (arglist & CAM_ARG_VERBOSE) {
3689                         cam_error_print(device, ccb, CAM_ESF_ALL,
3690                                         CAM_EPF_ALL, stderr);
3691                 }
3692
3693                 error = 1;
3694                 goto defect_bailout;
3695         }
3696
3697         valid_len = ccb->csio.dxfer_len - ccb->csio.resid;
3698
3699         if (use_12byte == 0) {
3700                 hdr10 = (struct scsi_read_defect_data_hdr_10 *)defect_list;
3701                 hdr_size = sizeof(*hdr10);
3702                 hdr_max = SRDDH10_MAX_LENGTH;
3703
3704                 if (valid_len >= hdr_size) {
3705                         returned_length = scsi_2btoul(hdr10->length);
3706                         returned_format = hdr10->format;
3707                 } else {
3708                         returned_length = 0;
3709                         returned_format = 0;
3710                 }
3711         } else {
3712                 hdr12 = (struct scsi_read_defect_data_hdr_12 *)defect_list;
3713                 hdr_size = sizeof(*hdr12);
3714                 hdr_max = SRDDH12_MAX_LENGTH;
3715
3716                 if (valid_len >= hdr_size) {
3717                         returned_length = scsi_4btoul(hdr12->length);
3718                         returned_format = hdr12->format;
3719                 } else {
3720                         returned_length = 0;
3721                         returned_format = 0;
3722                 }
3723         }
3724
3725         returned_type = returned_format & SRDDH10_DLIST_FORMAT_MASK;
3726         switch (returned_type) {
3727         case SRDD10_BLOCK_FORMAT:
3728                 entry_size = sizeof(struct scsi_defect_desc_block);
3729                 break;
3730         case SRDD10_LONG_BLOCK_FORMAT:
3731                 entry_size = sizeof(struct scsi_defect_desc_long_block);
3732                 break;
3733         case SRDD10_EXT_PHYS_FORMAT:
3734         case SRDD10_PHYSICAL_SECTOR_FORMAT:
3735                 entry_size = sizeof(struct scsi_defect_desc_phys_sector);
3736                 break;
3737         case SRDD10_EXT_BFI_FORMAT:
3738         case SRDD10_BYTES_FROM_INDEX_FORMAT:
3739                 entry_size = sizeof(struct scsi_defect_desc_bytes_from_index);
3740                 break;
3741         default:
3742                 warnx("Unknown defect format 0x%x\n", returned_type);
3743                 error = 1;
3744                 goto defect_bailout;
3745                 break;
3746         }
3747
3748         max_possible_size = (hdr_max / entry_size) * entry_size;
3749         num_returned = returned_length / entry_size;
3750         num_valid = min(returned_length, valid_len - hdr_size);
3751         num_valid /= entry_size;
3752
3753         if (get_length != 0) {
3754                 get_length = 0;
3755
3756                 if ((ccb->ccb_h.status & CAM_STATUS_MASK) ==
3757                      CAM_SCSI_STATUS_ERROR) {
3758                         struct scsi_sense_data *sense;
3759                         int error_code, sense_key, asc, ascq;
3760
3761                         sense = &ccb->csio.sense_data;
3762                         scsi_extract_sense_len(sense, ccb->csio.sense_len -
3763                             ccb->csio.sense_resid, &error_code, &sense_key,
3764                             &asc, &ascq, /*show_errors*/ 1);
3765
3766                         /*
3767                          * If the drive is reporting that it just doesn't
3768                          * support the defect list format, go ahead and use
3769                          * the length it reported.  Otherwise, the length
3770                          * may not be valid, so use the maximum.
3771                          */
3772                         if ((sense_key == SSD_KEY_RECOVERED_ERROR)
3773                          && (asc == 0x1c) && (ascq == 0x00)
3774                          && (returned_length > 0)) {
3775                                 if ((use_12byte == 0)
3776                                  && (returned_length >= max_possible_size)) {
3777                                         get_length = 1;
3778                                         use_12byte = 1;
3779                                         goto retry_12byte;
3780                                 }
3781                                 dlist_length = returned_length + hdr_size;
3782                         } else if ((sense_key == SSD_KEY_RECOVERED_ERROR)
3783                                 && (asc == 0x1f) && (ascq == 0x00)
3784                                 && (returned_length > 0)) {
3785                                 /* Partial defect list transfer */
3786                                 /*
3787                                  * Hitachi drives return this error
3788                                  * along with a partial defect list if they
3789                                  * have more defects than the 10 byte
3790                                  * command can support.  Retry with the 12
3791                                  * byte command.
3792                                  */
3793                                 if (use_12byte == 0) {
3794                                         get_length = 1;
3795                                         use_12byte = 1;
3796                                         goto retry_12byte;
3797                                 }
3798                                 dlist_length = returned_length + hdr_size;
3799                         } else if ((sense_key == SSD_KEY_ILLEGAL_REQUEST)
3800                                 && (asc == 0x24) && (ascq == 0x00)) {
3801                                 /* Invalid field in CDB */
3802                                 /*
3803                                  * SBC-3 says that if the drive has more
3804                                  * defects than can be reported with the
3805                                  * 10 byte command, it should return this
3806                                  * error and no data.  Retry with the 12
3807                                  * byte command.
3808                                  */
3809                                 if (use_12byte == 0) {
3810                                         get_length = 1;
3811                                         use_12byte = 1;
3812                                         goto retry_12byte;
3813                                 }
3814                                 dlist_length = returned_length + hdr_size;
3815                         } else {
3816                                 /*
3817                                  * If we got a SCSI error and no valid length,
3818                                  * just use the 10 byte maximum.  The 12
3819                                  * byte maximum is too large.
3820                                  */
3821                                 if (returned_length == 0)
3822                                         dlist_length = SRDD10_MAX_LENGTH;
3823                                 else {
3824                                         if ((use_12byte == 0)
3825                                          && (returned_length >=
3826                                              max_possible_size)) {
3827                                                 get_length = 1;
3828                                                 use_12byte = 1;
3829                                                 goto retry_12byte;
3830                                         }
3831                                         dlist_length = returned_length +
3832                                             hdr_size;
3833                                 }
3834                         }
3835                 } else if ((ccb->ccb_h.status & CAM_STATUS_MASK) !=
3836                             CAM_REQ_CMP){
3837                         error = 1;
3838                         warnx("Error reading defect header");
3839                         if (arglist & CAM_ARG_VERBOSE)
3840                                 cam_error_print(device, ccb, CAM_ESF_ALL,
3841                                                 CAM_EPF_ALL, stderr);
3842                         goto defect_bailout;
3843                 } else {
3844                         if ((use_12byte == 0)
3845                          && (returned_length >= max_possible_size)) {
3846                                 get_length = 1;
3847                                 use_12byte = 1;
3848                                 goto retry_12byte;
3849                         }
3850                         dlist_length = returned_length + hdr_size;
3851                 }
3852                 if (summary != 0) {
3853                         fprintf(stdout, "%u", num_returned);
3854                         if (quiet == 0) {
3855                                 fprintf(stdout, " defect%s",
3856                                         (num_returned != 1) ? "s" : "");
3857                         }
3858                         fprintf(stdout, "\n");
3859
3860                         goto defect_bailout;
3861                 }
3862
3863                 /*
3864                  * We always limit the list length to the 10-byte maximum
3865                  * length (0xffff).  The reason is that some controllers
3866                  * can't handle larger I/Os, and we can transfer the entire
3867                  * 10 byte list in one shot.  For drives that support the 12
3868                  * byte read defects command, we'll step through the list
3869                  * by specifying a starting offset.  For drives that don't
3870                  * support the 12 byte command's starting offset, we'll
3871                  * just display the first 64K.
3872                  */
3873                 dlist_length = min(dlist_length, SRDD10_MAX_LENGTH);
3874
3875                 goto retry;
3876         }
3877
3878
3879         if (((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_SCSI_STATUS_ERROR)
3880          && (ccb->csio.scsi_status == SCSI_STATUS_CHECK_COND)
3881          && ((ccb->ccb_h.status & CAM_AUTOSNS_VALID) != 0)) {
3882                 struct scsi_sense_data *sense;
3883                 int error_code, sense_key, asc, ascq;
3884
3885                 sense = &ccb->csio.sense_data;
3886                 scsi_extract_sense_len(sense, ccb->csio.sense_len -
3887                     ccb->csio.sense_resid, &error_code, &sense_key, &asc,
3888                     &ascq, /*show_errors*/ 1);
3889
3890                 /*
3891                  * According to the SCSI spec, if the disk doesn't support
3892                  * the requested format, it will generally return a sense
3893                  * key of RECOVERED ERROR, and an additional sense code
3894                  * of "DEFECT LIST NOT FOUND".  HGST drives also return
3895                  * Primary/Grown defect list not found errors.  So just
3896                  * check for an ASC of 0x1c.
3897                  */
3898                 if ((sense_key == SSD_KEY_RECOVERED_ERROR)
3899                  && (asc == 0x1c)) {
3900                         const char *format_str;
3901
3902                         format_str = scsi_nv_to_str(defect_list_type_map,
3903                             sizeof(defect_list_type_map) /
3904                             sizeof(defect_list_type_map[0]),
3905                             list_format & SRDD10_DLIST_FORMAT_MASK);
3906                         warnx("requested defect format %s not available",
3907                             format_str ? format_str : "unknown");
3908
3909                         format_str = scsi_nv_to_str(defect_list_type_map,
3910                             sizeof(defect_list_type_map) /
3911                             sizeof(defect_list_type_map[0]), returned_type);
3912                         if (format_str != NULL) {
3913                                 warnx("Device returned %s format",
3914                                     format_str);
3915                         } else {
3916                                 error = 1;
3917                                 warnx("Device returned unknown defect"
3918                                      " data format %#x", returned_type);
3919                                 goto defect_bailout;
3920                         }
3921                 } else {
3922                         error = 1;
3923                         warnx("Error returned from read defect data command");
3924                         if (arglist & CAM_ARG_VERBOSE)
3925                                 cam_error_print(device, ccb, CAM_ESF_ALL,
3926                                                 CAM_EPF_ALL, stderr);
3927                         goto defect_bailout;
3928                 }
3929         } else if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
3930                 error = 1;
3931                 warnx("Error returned from read defect data command");
3932                 if (arglist & CAM_ARG_VERBOSE)
3933                         cam_error_print(device, ccb, CAM_ESF_ALL,
3934                                         CAM_EPF_ALL, stderr);
3935                 goto defect_bailout;
3936         }
3937
3938         if (first_pass != 0) {
3939                 fprintf(stderr, "Got %d defect", num_returned);
3940
3941                 if ((lists_specified == 0) || (num_returned == 0)) {
3942                         fprintf(stderr, "s.\n");
3943                         goto defect_bailout;
3944                 } else if (num_returned == 1)
3945                         fprintf(stderr, ":\n");
3946                 else
3947                         fprintf(stderr, "s:\n");
3948
3949                 first_pass = 0;
3950         }
3951
3952         /*
3953          * XXX KDM  I should probably clean up the printout format for the
3954          * disk defects.
3955          */
3956         switch (returned_type) {
3957         case SRDD10_PHYSICAL_SECTOR_FORMAT:
3958         case SRDD10_EXT_PHYS_FORMAT:
3959         {
3960                 struct scsi_defect_desc_phys_sector *dlist;
3961
3962                 dlist = (struct scsi_defect_desc_phys_sector *)
3963                         (defect_list + hdr_size);
3964
3965                 for (i = 0; i < num_valid; i++) {
3966                         uint32_t sector;
3967
3968                         sector = scsi_4btoul(dlist[i].sector);
3969                         if (returned_type == SRDD10_EXT_PHYS_FORMAT) {
3970                                 mads = (sector & SDD_EXT_PHYS_MADS) ?
3971                                        0 : 1;
3972                                 sector &= ~SDD_EXT_PHYS_FLAG_MASK;
3973                         }
3974                         if (hex_format == 0)
3975                                 fprintf(stdout, "%d:%d:%d%s",
3976                                         scsi_3btoul(dlist[i].cylinder),
3977                                         dlist[i].head,
3978                                         scsi_4btoul(dlist[i].sector),
3979                                         mads ? " - " : "\n");
3980                         else
3981                                 fprintf(stdout, "0x%x:0x%x:0x%x%s",
3982                                         scsi_3btoul(dlist[i].cylinder),
3983                                         dlist[i].head,
3984                                         scsi_4btoul(dlist[i].sector),
3985                                         mads ? " - " : "\n");
3986                         mads = 0;
3987                 }
3988                 if (num_valid < num_returned) {
3989                         starting_offset += num_valid;
3990                         goto next_batch;
3991                 }
3992                 break;
3993         }
3994         case SRDD10_BYTES_FROM_INDEX_FORMAT:
3995         case SRDD10_EXT_BFI_FORMAT:
3996         {
3997                 struct scsi_defect_desc_bytes_from_index *dlist;
3998
3999                 dlist = (struct scsi_defect_desc_bytes_from_index *)
4000                         (defect_list + hdr_size);
4001
4002                 for (i = 0; i < num_valid; i++) {
4003                         uint32_t bfi;
4004
4005                         bfi = scsi_4btoul(dlist[i].bytes_from_index);
4006                         if (returned_type == SRDD10_EXT_BFI_FORMAT) {
4007                                 mads = (bfi & SDD_EXT_BFI_MADS) ? 1 : 0;
4008                                 bfi &= ~SDD_EXT_BFI_FLAG_MASK;
4009                         }
4010                         if (hex_format == 0)
4011                                 fprintf(stdout, "%d:%d:%d%s",
4012                                         scsi_3btoul(dlist[i].cylinder),
4013                                         dlist[i].head,
4014                                         scsi_4btoul(dlist[i].bytes_from_index),
4015                                         mads ? " - " : "\n");
4016                         else
4017                                 fprintf(stdout, "0x%x:0x%x:0x%x%s",
4018                                         scsi_3btoul(dlist[i].cylinder),
4019                                         dlist[i].head,
4020                                         scsi_4btoul(dlist[i].bytes_from_index),
4021                                         mads ? " - " : "\n");
4022
4023                         mads = 0;
4024                 }
4025                 if (num_valid < num_returned) {
4026                         starting_offset += num_valid;
4027                         goto next_batch;
4028                 }
4029                 break;
4030         }
4031         case SRDDH10_BLOCK_FORMAT:
4032         {
4033                 struct scsi_defect_desc_block *dlist;
4034
4035                 dlist = (struct scsi_defect_desc_block *)
4036                         (defect_list + hdr_size);
4037
4038                 for (i = 0; i < num_valid; i++) {
4039                         if (hex_format == 0)
4040                                 fprintf(stdout, "%u\n",
4041                                         scsi_4btoul(dlist[i].address));
4042                         else
4043                                 fprintf(stdout, "0x%x\n",
4044                                         scsi_4btoul(dlist[i].address));
4045                 }
4046
4047                 if (num_valid < num_returned) {
4048                         starting_offset += num_valid;
4049                         goto next_batch;
4050                 }
4051
4052                 break;
4053         }
4054         case SRDD10_LONG_BLOCK_FORMAT:
4055         {
4056                 struct scsi_defect_desc_long_block *dlist;
4057
4058                 dlist = (struct scsi_defect_desc_long_block *)
4059                         (defect_list + hdr_size);
4060
4061                 for (i = 0; i < num_valid; i++) {
4062                         if (hex_format == 0)
4063                                 fprintf(stdout, "%ju\n",
4064                                         (uintmax_t)scsi_8btou64(
4065                                         dlist[i].address));
4066                         else
4067                                 fprintf(stdout, "0x%jx\n",
4068                                         (uintmax_t)scsi_8btou64(
4069                                         dlist[i].address));
4070                 }
4071
4072                 if (num_valid < num_returned) {
4073                         starting_offset += num_valid;
4074                         goto next_batch;
4075                 }
4076                 break;
4077         }
4078         default:
4079                 fprintf(stderr, "Unknown defect format 0x%x\n",
4080                         returned_type);
4081                 error = 1;
4082                 break;
4083         }
4084 defect_bailout:
4085
4086         if (defect_list != NULL)
4087                 free(defect_list);
4088
4089         if (ccb != NULL)
4090                 cam_freeccb(ccb);
4091
4092         return(error);
4093 }
4094 #endif /* MINIMALISTIC */
4095
4096 #if 0
4097 void
4098 reassignblocks(struct cam_device *device, u_int32_t *blocks, int num_blocks)
4099 {
4100         union ccb *ccb;
4101
4102         ccb = cam_getccb(device);
4103
4104         cam_freeccb(ccb);
4105 }
4106 #endif
4107
4108 #ifndef MINIMALISTIC
4109 void
4110 mode_sense(struct cam_device *device, int dbd, int pc, int page, int subpage,
4111            int task_attr, int retry_count, int timeout, u_int8_t *data,
4112            int datalen)
4113 {
4114         union ccb *ccb;
4115         int retval;
4116
4117         ccb = cam_getccb(device);
4118
4119         if (ccb == NULL)
4120                 errx(1, "mode_sense: couldn't allocate CCB");
4121
4122         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
4123
4124         scsi_mode_sense_subpage(&ccb->csio,
4125                         /* retries */ retry_count,
4126                         /* cbfcnp */ NULL,
4127                         /* tag_action */ task_attr,
4128                         /* dbd */ dbd,
4129                         /* pc */ pc << 6,
4130                         /* page */ page,
4131                         /* subpage */ subpage,
4132                         /* param_buf */ data,
4133                         /* param_len */ datalen,
4134                         /* minimum_cmd_size */ 0,
4135                         /* sense_len */ SSD_FULL_SIZE,
4136                         /* timeout */ timeout ? timeout : 5000);
4137
4138         if (arglist & CAM_ARG_ERR_RECOVER)
4139                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
4140
4141         /* Disable freezing the device queue */
4142         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
4143
4144         if (((retval = cam_send_ccb(device, ccb)) < 0)
4145          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
4146                 if (arglist & CAM_ARG_VERBOSE) {
4147                         cam_error_print(device, ccb, CAM_ESF_ALL,
4148                                         CAM_EPF_ALL, stderr);
4149                 }
4150                 cam_freeccb(ccb);
4151                 cam_close_device(device);
4152                 if (retval < 0)
4153                         err(1, "error sending mode sense command");
4154                 else
4155                         errx(1, "error sending mode sense command");
4156         }
4157
4158         cam_freeccb(ccb);
4159 }
4160
4161 void
4162 mode_select(struct cam_device *device, int save_pages, int task_attr,
4163             int retry_count, int timeout, u_int8_t *data, int datalen)
4164 {
4165         union ccb *ccb;
4166         int retval;
4167
4168         ccb = cam_getccb(device);
4169
4170         if (ccb == NULL)
4171                 errx(1, "mode_select: couldn't allocate CCB");
4172
4173         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
4174
4175         scsi_mode_select(&ccb->csio,
4176                          /* retries */ retry_count,
4177                          /* cbfcnp */ NULL,
4178                          /* tag_action */ task_attr,
4179                          /* scsi_page_fmt */ 1,
4180                          /* save_pages */ save_pages,
4181                          /* param_buf */ data,
4182                          /* param_len */ datalen,
4183                          /* sense_len */ SSD_FULL_SIZE,
4184                          /* timeout */ timeout ? timeout : 5000);
4185
4186         if (arglist & CAM_ARG_ERR_RECOVER)
4187                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
4188
4189         /* Disable freezing the device queue */
4190         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
4191
4192         if (((retval = cam_send_ccb(device, ccb)) < 0)
4193          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
4194                 if (arglist & CAM_ARG_VERBOSE) {
4195                         cam_error_print(device, ccb, CAM_ESF_ALL,
4196                                         CAM_EPF_ALL, stderr);
4197                 }
4198                 cam_freeccb(ccb);
4199                 cam_close_device(device);
4200
4201                 if (retval < 0)
4202                         err(1, "error sending mode select command");
4203                 else
4204                         errx(1, "error sending mode select command");
4205
4206         }
4207
4208         cam_freeccb(ccb);
4209 }
4210
4211 void
4212 modepage(struct cam_device *device, int argc, char **argv, char *combinedopt,
4213          int task_attr, int retry_count, int timeout)
4214 {
4215         char *str_subpage;
4216         int c, page = -1, subpage = -1, pc = 0;
4217         int binary = 0, dbd = 0, edit = 0, list = 0;
4218
4219         while ((c = getopt(argc, argv, combinedopt)) != -1) {
4220                 switch(c) {
4221                 case 'b':
4222                         binary = 1;
4223                         break;
4224                 case 'd':
4225                         dbd = 1;
4226                         break;
4227                 case 'e':
4228                         edit = 1;
4229                         break;
4230                 case 'l':
4231                         list++;
4232                         break;
4233                 case 'm':
4234                         str_subpage = optarg;
4235                         strsep(&str_subpage, ",");
4236                         page = strtol(optarg, NULL, 0);
4237                         if (str_subpage)
4238                             subpage = strtol(str_subpage, NULL, 0);
4239                         else
4240                             subpage = 0;
4241                         if (page < 0)
4242                                 errx(1, "invalid mode page %d", page);
4243                         if (subpage < 0)
4244                                 errx(1, "invalid mode subpage %d", subpage);
4245                         break;
4246                 case 'P':
4247                         pc = strtol(optarg, NULL, 0);
4248                         if ((pc < 0) || (pc > 3))
4249                                 errx(1, "invalid page control field %d", pc);
4250                         break;
4251                 default:
4252                         break;
4253                 }
4254         }
4255
4256         if (page == -1 && list == 0)
4257                 errx(1, "you must specify a mode page!");
4258
4259         if (list != 0) {
4260                 mode_list(device, dbd, pc, list > 1, task_attr, retry_count,
4261                           timeout);
4262         } else {
4263                 mode_edit(device, dbd, pc, page, subpage, edit, binary,
4264                     task_attr, retry_count, timeout);
4265         }
4266 }
4267
4268 static int
4269 scsicmd(struct cam_device *device, int argc, char **argv, char *combinedopt,
4270         int task_attr, int retry_count, int timeout)
4271 {
4272         union ccb *ccb;
4273         u_int32_t flags = CAM_DIR_NONE;
4274         u_int8_t *data_ptr = NULL;
4275         u_int8_t cdb[20];
4276         u_int8_t atacmd[12];
4277         struct get_hook hook;
4278         int c, data_bytes = 0, valid_bytes;
4279         int cdb_len = 0;
4280         int atacmd_len = 0;
4281         int dmacmd = 0;
4282         int fpdmacmd = 0;
4283         int need_res = 0;
4284         char *datastr = NULL, *tstr, *resstr = NULL;
4285         int error = 0;
4286         int fd_data = 0, fd_res = 0;
4287         int retval;
4288
4289         ccb = cam_getccb(device);
4290
4291         if (ccb == NULL) {
4292                 warnx("scsicmd: error allocating ccb");
4293                 return(1);
4294         }
4295
4296         CCB_CLEAR_ALL_EXCEPT_HDR(ccb);
4297
4298         while ((c = getopt(argc, argv, combinedopt)) != -1) {
4299                 switch(c) {
4300                 case 'a':
4301                         tstr = optarg;
4302                         while (isspace(*tstr) && (*tstr != '\0'))
4303                                 tstr++;
4304                         hook.argc = argc - optind;
4305                         hook.argv = argv + optind;
4306                         hook.got = 0;
4307                         atacmd_len = buff_encode_visit(atacmd, sizeof(atacmd), tstr,
4308                                                     iget, &hook);
4309                         /*
4310                          * Increment optind by the number of arguments the
4311                          * encoding routine processed.  After each call to
4312                          * getopt(3), optind points to the argument that
4313                          * getopt should process _next_.  In this case,
4314                          * that means it points to the first command string
4315                          * argument, if there is one.  Once we increment
4316                          * this, it should point to either the next command
4317                          * line argument, or it should be past the end of
4318                          * the list.
4319                          */
4320                         optind += hook.got;
4321                         break;
4322                 case 'c':
4323                         tstr = optarg;
4324                         while (isspace(*tstr) && (*tstr != '\0'))
4325                                 tstr++;
4326                         hook.argc = argc - optind;
4327                         hook.argv = argv + optind;
4328                         hook.got = 0;
4329                         cdb_len = buff_encode_visit(cdb, sizeof(cdb), tstr,
4330                                                     iget, &hook);
4331                         /*
4332                          * Increment optind by the number of arguments the
4333                          * encoding routine processed.  After each call to
4334                          * getopt(3), optind points to the argument that
4335                          * getopt should process _next_.  In this case,
4336                          * that means it points to the first command string
4337                          * argument, if there is one.  Once we increment
4338                          * this, it should point to either the next command
4339                          * line argument, or it should be past the end of
4340                          * the list.
4341                          */
4342                         optind += hook.got;
4343                         break;
4344                 case 'd':
4345                         dmacmd = 1;
4346                         break;
4347                 case 'f':
4348                         fpdmacmd = 1;
4349                         break;
4350                 case 'i':
4351                         if (arglist & CAM_ARG_CMD_OUT) {
4352                                 warnx("command must either be "
4353                                       "read or write, not both");
4354                                 error = 1;
4355                                 goto scsicmd_bailout;
4356                         }
4357                         arglist |= CAM_ARG_CMD_IN;
4358                         flags = CAM_DIR_IN;
4359                         data_bytes = strtol(optarg, NULL, 0);
4360                         if (data_bytes <= 0) {
4361                                 warnx("invalid number of input bytes %d",
4362                                       data_bytes);
4363                                 error = 1;
4364                                 goto scsicmd_bailout;
4365                         }
4366                         hook.argc = argc - optind;
4367                         hook.argv = argv + optind;
4368                         hook.got = 0;
4369                         optind++;
4370                         datastr = cget(&hook, NULL);
4371                         /*
4372                          * If the user supplied "-" instead of a format, he
4373                          * wants the data to be written to stdout.
4374                          */
4375                         if ((datastr != NULL)
4376                          && (datastr[0] == '-'))
4377                                 fd_data = 1;
4378
4379                         data_ptr = (u_int8_t *)malloc(data_bytes);
4380                         if (data_ptr == NULL) {
4381                                 warnx("can't malloc memory for data_ptr");
4382                                 error = 1;
4383                                 goto scsicmd_bailout;
4384                         }
4385                         break;
4386                 case 'o':
4387                         if (arglist & CAM_ARG_CMD_IN) {
4388                                 warnx("command must either be "
4389                                       "read or write, not both");
4390                                 error = 1;
4391                                 goto scsicmd_bailout;
4392                         }
4393                         arglist |= CAM_ARG_CMD_OUT;
4394                         flags = CAM_DIR_OUT;
4395                         data_bytes = strtol(optarg, NULL, 0);
4396                         if (data_bytes <= 0) {
4397                                 warnx("invalid number of output bytes %d",
4398                                       data_bytes);
4399                                 error = 1;
4400                                 goto scsicmd_bailout;
4401                         }
4402                         hook.argc = argc - optind;
4403                         hook.argv = argv + optind;
4404                         hook.got = 0;
4405                         datastr = cget(&hook, NULL);
4406                         data_ptr = (u_int8_t *)malloc(data_bytes);
4407                         if (data_ptr == NULL) {
4408                                 warnx("can't malloc memory for data_ptr");
4409                                 error = 1;
4410                                 goto scsicmd_bailout;
4411                         }
4412                         bzero(data_ptr, data_bytes);
4413                         /*
4414                          * If the user supplied "-" instead of a format, he
4415                          * wants the data to be read from stdin.
4416                          */
4417                         if ((datastr != NULL)
4418                          && (datastr[0] == '-'))
4419                                 fd_data = 1;
4420                         else
4421                                 buff_encode_visit(data_ptr, data_bytes, datastr,
4422                                                   iget, &hook);
4423                         optind += hook.got;
4424                         break;
4425                 case 'r':
4426                         need_res = 1;
4427                         hook.argc = argc - optind;
4428                         hook.argv = argv + optind;
4429                         hook.got = 0;
4430                         resstr = cget(&hook, NULL);
4431                         if ((resstr != NULL) && (resstr[0] == '-'))
4432                                 fd_res = 1;
4433                         optind += hook.got;
4434                         break;
4435                 default:
4436                         break;
4437                 }
4438         }
4439
4440         /*
4441          * If fd_data is set, and we're writing to the device, we need to
4442          * read the data the user wants written from stdin.
4443          */
4444         if ((fd_data == 1) && (arglist & CAM_ARG_CMD_OUT)) {
4445                 ssize_t amt_read;
4446                 int amt_to_read = data_bytes;
4447                 u_int8_t *buf_ptr = data_ptr;
4448
4449                 for (amt_read = 0; amt_to_read > 0;
4450                      amt_read = read(STDIN_FILENO, buf_ptr, amt_to_read)) {
4451                         if (amt_read == -1) {
4452                                 warn("error reading data from stdin");
4453                                 error = 1;
4454                                 goto scsicmd_bailout;
4455                         }
4456                         amt_to_read -= amt_read;
4457                         buf_ptr += amt_read;
4458                 }
4459         }
4460
4461         if (arglist & CAM_ARG_ERR_RECOVER)
4462                 flags |= CAM_PASS_ERR_RECOVER;
4463
4464         /* Disable freezing the device queue */
4465         flags |= CAM_DEV_QFRZDIS;
4466
4467         if (cdb_len) {
4468                 /*
4469                  * This is taken from the SCSI-3 draft spec.
4470                  * (T10/1157D revision 0.3)
4471                  * The top 3 bits of an opcode are the group code.
4472                  * The next 5 bits are the command code.
4473                  * Group 0:  six byte commands
4474                  * Group 1:  ten byte commands
4475                  * Group 2:  ten byte commands
4476                  * Group 3:  reserved
4477                  * Group 4:  sixteen byte commands
4478                  * Group 5:  twelve byte commands
4479                  * Group 6:  vendor specific
4480                  * Group 7:  vendor specific
4481                  */
4482                 switch((cdb[0] >> 5) & 0x7) {
4483                         case 0:
4484                                 cdb_len = 6;
4485                                 break;
4486                         case 1:
4487                         case 2:
4488                                 cdb_len = 10;
4489                                 break;
4490                         case 3:
4491                         case 6:
4492                         case 7:
4493                                 /* computed by buff_encode_visit */
4494                                 break;
4495                         case 4:
4496                                 cdb_len = 16;
4497                                 break;
4498                         case 5:
4499                                 cdb_len = 12;
4500                                 break;
4501                 }
4502
4503                 /*
4504                  * We should probably use csio_build_visit or something like that
4505                  * here, but it's easier to encode arguments as you go.  The
4506                  * alternative would be skipping the CDB argument and then encoding
4507                  * it here, since we've got the data buffer argument by now.
4508                  */
4509                 bcopy(cdb, &ccb->csio.cdb_io.cdb_bytes, cdb_len);
4510
4511                 cam_fill_csio(&ccb->csio,
4512                       /*retries*/ retry_count,
4513                       /*cbfcnp*/ NULL,
4514                       /*flags*/ flags,
4515                       /*tag_action*/ task_attr,
4516                       /*data_ptr*/ data_ptr,
4517                       /*dxfer_len*/ data_bytes,
4518                       /*sense_len*/ SSD_FULL_SIZE,
4519                       /*cdb_len*/ cdb_len,
4520                       /*timeout*/ timeout ? timeout : 5000);
4521         } else {
4522                 atacmd_len = 12;
4523                 bcopy(atacmd, &ccb->ataio.cmd.command, atacmd_len);
4524                 if (need_res)
4525                         ccb->ataio.cmd.flags |= CAM_ATAIO_NEEDRESULT;
4526                 if (dmacmd)
4527                         ccb->ataio.cmd.flags |= CAM_ATAIO_DMA;
4528                 if (fpdmacmd)
4529                         ccb->ataio.cmd.flags |= CAM_ATAIO_FPDMA;
4530
4531                 cam_fill_ataio(&ccb->ataio,
4532                       /*retries*/ retry_count,
4533                       /*cbfcnp*/ NULL,
4534                       /*flags*/ flags,
4535                       /*tag_action*/ 0,
4536                       /*data_ptr*/ data_ptr,
4537                       /*dxfer_len*/ data_bytes,
4538                       /*timeout*/ timeout ? timeout : 5000);
4539         }
4540
4541         if (((retval = cam_send_ccb(device, ccb)) < 0)
4542          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
4543                 const char warnstr[] = "error sending command";
4544
4545                 if (retval < 0)
4546                         warn(warnstr);
4547                 else
4548                         warnx(warnstr);
4549
4550                 if (arglist & CAM_ARG_VERBOSE) {
4551                         cam_error_print(device, ccb, CAM_ESF_ALL,
4552                                         CAM_EPF_ALL, stderr);
4553                 }
4554
4555                 error = 1;
4556                 goto scsicmd_bailout;
4557         }
4558
4559         if (atacmd_len && need_res) {
4560                 if (fd_res == 0) {
4561                         buff_decode_visit(&ccb->ataio.res.status, 11, resstr,
4562                                           arg_put, NULL);
4563                         fprintf(stdout, "\n");
4564                 } else {
4565                         fprintf(stdout,
4566                             "%02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n",
4567                             ccb->ataio.res.status,
4568                             ccb->ataio.res.error,
4569                             ccb->ataio.res.lba_low,
4570                             ccb->ataio.res.lba_mid,
4571                             ccb->ataio.res.lba_high,
4572                             ccb->ataio.res.device,
4573                             ccb->ataio.res.lba_low_exp,
4574                             ccb->ataio.res.lba_mid_exp,
4575                             ccb->ataio.res.lba_high_exp,
4576                             ccb->ataio.res.sector_count,
4577                             ccb->ataio.res.sector_count_exp);
4578                         fflush(stdout);
4579                 }
4580         }
4581
4582         if (cdb_len)
4583                 valid_bytes = ccb->csio.dxfer_len - ccb->csio.resid;
4584         else
4585                 valid_bytes = ccb->ataio.dxfer_len - ccb->ataio.resid;
4586         if (((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP)
4587          && (arglist & CAM_ARG_CMD_IN)
4588          && (valid_bytes > 0)) {
4589                 if (fd_data == 0) {
4590                         buff_decode_visit(data_ptr, valid_bytes, datastr,
4591                                           arg_put, NULL);
4592                         fprintf(stdout, "\n");
4593                 } else {
4594                         ssize_t amt_written;
4595                         int amt_to_write = valid_bytes;
4596                         u_int8_t *buf_ptr = data_ptr;
4597
4598                         for (amt_written = 0; (amt_to_write > 0) &&
4599                              (amt_written =write(1, buf_ptr,amt_to_write))> 0;){
4600                                 amt_to_write -= amt_written;
4601                                 buf_ptr += amt_written;
4602                         }
4603                         if (amt_written == -1) {
4604                                 warn("error writing data to stdout");
4605                                 error = 1;
4606                                 goto scsicmd_bailout;
4607                         } else if ((amt_written == 0)
4608                                 && (amt_to_write > 0)) {
4609                                 warnx("only wrote %u bytes out of %u",
4610                                       valid_bytes - amt_to_write, valid_bytes);
4611                         }
4612                 }
4613         }
4614
4615 scsicmd_bailout:
4616
4617         if ((data_bytes > 0) && (data_ptr != NULL))
4618                 free(data_ptr);
4619
4620         cam_freeccb(ccb);
4621
4622         return(error);
4623 }
4624
4625 static int
4626 camdebug(int argc, char **argv, char *combinedopt)
4627 {
4628         int c, fd;
4629         path_id_t bus = CAM_BUS_WILDCARD;
4630         target_id_t target = CAM_TARGET_WILDCARD;
4631         lun_id_t lun = CAM_LUN_WILDCARD;
4632         char *tstr, *tmpstr = NULL;
4633         union ccb ccb;
4634         int error = 0;
4635
4636         bzero(&ccb, sizeof(union ccb));
4637
4638         while ((c = getopt(argc, argv, combinedopt)) != -1) {
4639                 switch(c) {
4640                 case 'I':
4641                         arglist |= CAM_ARG_DEBUG_INFO;
4642                         ccb.cdbg.flags |= CAM_DEBUG_INFO;
4643                         break;
4644                 case 'P':
4645                         arglist |= CAM_ARG_DEBUG_PERIPH;
4646                         ccb.cdbg.flags |= CAM_DEBUG_PERIPH;
4647                         break;
4648                 case 'S':
4649                         arglist |= CAM_ARG_DEBUG_SUBTRACE;
4650                         ccb.cdbg.flags |= CAM_DEBUG_SUBTRACE;
4651                         break;
4652                 case 'T':
4653                         arglist |= CAM_ARG_DEBUG_TRACE;
4654                         ccb.cdbg.flags |= CAM_DEBUG_TRACE;
4655                         break;
4656                 case 'X':
4657                         arglist |= CAM_ARG_DEBUG_XPT;
4658                         ccb.cdbg.flags |= CAM_DEBUG_XPT;
4659                         break;
4660                 case 'c':
4661                         arglist |= CAM_ARG_DEBUG_CDB;
4662                         ccb.cdbg.flags |= CAM_DEBUG_CDB;
4663                         break;
4664                 case 'p':
4665                         arglist |= CAM_ARG_DEBUG_PROBE;
4666                         ccb.cdbg.flags |= CAM_DEBUG_PROBE;
4667                         break;
4668                 default:
4669                         break;
4670                 }
4671         }
4672
4673         if ((fd = open(XPT_DEVICE, O_RDWR)) < 0) {
4674                 warnx("error opening transport layer device %s", XPT_DEVICE);
4675                 warn("%s", XPT_DEVICE);
4676                 return(1);
4677         }
4678         argc -= optind;
4679         argv += optind;
4680
4681         if (argc <= 0) {
4682                 warnx("you must specify \"off\", \"all\" or a bus,");
4683                 warnx("bus:target, or bus:target:lun");
4684                 close(fd);
4685                 return(1);
4686         }
4687
4688         tstr = *argv;
4689
4690         while (isspace(*tstr) && (*tstr != '\0'))
4691                 tstr++;
4692
4693         if (strncmp(tstr, "off", 3) == 0) {
4694                 ccb.cdbg.flags = CAM_DEBUG_NONE;
4695                 arglist &= ~(CAM_ARG_DEBUG_INFO|CAM_ARG_DEBUG_PERIPH|
4696                              CAM_ARG_DEBUG_TRACE|CAM_ARG_DEBUG_SUBTRACE|
4697                              CAM_ARG_DEBUG_XPT|CAM_ARG_DEBUG_PROBE);
4698         } else if (strncmp(tstr, "all", 3) != 0) {
4699                 tmpstr = (char *)strtok(tstr, ":");
4700                 if ((tmpstr != NULL) && (*tmpstr != '\0')){
4701                         bus = strtol(tmpstr, NULL, 0);
4702                         arglist |= CAM_ARG_BUS;
4703                         tmpstr = (char *)strtok(NULL, ":");
4704                         if ((tmpstr != NULL) && (*tmpstr != '\0')){
4705                                 target = strtol(tmpstr, NULL, 0);
4706                                 arglist |= CAM_ARG_TARGET;
4707                                 tmpstr = (char *)strtok(NULL, ":");
4708                                 if ((tmpstr != NULL) && (*tmpstr != '\0')){
4709                                         lun = strtol(tmpstr, NULL, 0);
4710                                         arglist |= CAM_ARG_LUN;
4711                                 }
4712                         }
4713                 } else {
4714                         error = 1;
4715                         warnx("you must specify \"all\", \"off\", or a bus,");
4716                         warnx("bus:target, or bus:target:lun to debug");
4717                 }
4718         }
4719
4720         if (error == 0) {
4721
4722                 ccb.ccb_h.func_code = XPT_DEBUG;
4723                 ccb.ccb_h.path_id = bus;
4724                 ccb.ccb_h.target_id = target;
4725                 ccb.ccb_h.target_lun = lun;
4726
4727                 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
4728                         warn("CAMIOCOMMAND ioctl failed");
4729                         error = 1;
4730                 }
4731
4732                 if (error == 0) {
4733                         if ((ccb.ccb_h.status & CAM_STATUS_MASK) ==
4734                              CAM_FUNC_NOTAVAIL) {
4735                                 warnx("CAM debugging not available");
4736                                 warnx("you need to put options CAMDEBUG in"
4737                                       " your kernel config file!");
4738                                 error = 1;
4739                         } else if ((ccb.ccb_h.status & CAM_STATUS_MASK) !=
4740                                     CAM_REQ_CMP) {
4741                                 warnx("XPT_DEBUG CCB failed with status %#x",
4742                                       ccb.ccb_h.status);
4743                                 error = 1;
4744                         } else {
4745                                 if (ccb.cdbg.flags == CAM_DEBUG_NONE) {
4746                                         fprintf(stderr,
4747                                                 "Debugging turned off\n");
4748                                 } else {
4749                                         fprintf(stderr,
4750                                                 "Debugging enabled for "
4751                                                 "%d:%d:%jx\n",
4752                                                 bus, target, (uintmax_t)lun);
4753                                 }
4754                         }
4755                 }
4756                 close(fd);
4757         }
4758
4759         return(error);
4760 }
4761
4762 static int
4763 tagcontrol(struct cam_device *device, int argc, char **argv,
4764            char *combinedopt)
4765 {
4766         int c;
4767         union ccb *ccb;
4768         int numtags = -1;
4769         int retval = 0;
4770         int quiet = 0;
4771         char pathstr[1024];
4772
4773         ccb = cam_getccb(device);
4774
4775         if (ccb == NULL) {
4776                 warnx("tagcontrol: error allocating ccb");
4777                 return(1);
4778         }
4779
4780         while ((c = getopt(argc, argv, combinedopt)) != -1) {
4781                 switch(c) {
4782                 case 'N':
4783                         numtags = strtol(optarg, NULL, 0);
4784                         if (numtags < 0) {
4785                                 warnx("tag count %d is < 0", numtags);
4786                                 retval = 1;
4787                                 goto tagcontrol_bailout;
4788                         }
4789                         break;
4790                 case 'q':
4791                         quiet++;
4792                         break;
4793                 default:
4794                         break;
4795                 }
4796         }
4797
4798         cam_path_string(device, pathstr, sizeof(pathstr));
4799
4800         if (numtags >= 0) {
4801                 CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->crs);
4802                 ccb->ccb_h.func_code = XPT_REL_SIMQ;
4803                 ccb->ccb_h.flags = CAM_DEV_QFREEZE;
4804                 ccb->crs.release_flags = RELSIM_ADJUST_OPENINGS;
4805                 ccb->crs.openings = numtags;
4806
4807
4808                 if (cam_send_ccb(device, ccb) < 0) {
4809                         perror("error sending XPT_REL_SIMQ CCB");
4810                         retval = 1;
4811                         goto tagcontrol_bailout;
4812                 }
4813
4814                 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
4815                         warnx("XPT_REL_SIMQ CCB failed");
4816                         cam_error_print(device, ccb, CAM_ESF_ALL,
4817                                         CAM_EPF_ALL, stderr);
4818                         retval = 1;
4819                         goto tagcontrol_bailout;
4820                 }
4821
4822
4823                 if (quiet == 0)
4824                         fprintf(stdout, "%stagged openings now %d\n",
4825                                 pathstr, ccb->crs.openings);
4826         }
4827
4828         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->cgds);
4829
4830         ccb->ccb_h.func_code = XPT_GDEV_STATS;
4831
4832         if (cam_send_ccb(device, ccb) < 0) {
4833                 perror("error sending XPT_GDEV_STATS CCB");
4834                 retval = 1;
4835                 goto tagcontrol_bailout;
4836         }
4837
4838         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
4839                 warnx("XPT_GDEV_STATS CCB failed");
4840                 cam_error_print(device, ccb, CAM_ESF_ALL,
4841                                 CAM_EPF_ALL, stderr);
4842                 retval = 1;
4843                 goto tagcontrol_bailout;
4844         }
4845
4846         if (arglist & CAM_ARG_VERBOSE) {
4847                 fprintf(stdout, "%s", pathstr);
4848                 fprintf(stdout, "dev_openings  %d\n", ccb->cgds.dev_openings);
4849                 fprintf(stdout, "%s", pathstr);
4850                 fprintf(stdout, "dev_active    %d\n", ccb->cgds.dev_active);
4851                 fprintf(stdout, "%s", pathstr);
4852                 fprintf(stdout, "allocated     %d\n", ccb->cgds.allocated);
4853                 fprintf(stdout, "%s", pathstr);
4854                 fprintf(stdout, "queued        %d\n", ccb->cgds.queued);
4855                 fprintf(stdout, "%s", pathstr);
4856                 fprintf(stdout, "held          %d\n", ccb->cgds.held);
4857                 fprintf(stdout, "%s", pathstr);
4858                 fprintf(stdout, "mintags       %d\n", ccb->cgds.mintags);
4859                 fprintf(stdout, "%s", pathstr);
4860                 fprintf(stdout, "maxtags       %d\n", ccb->cgds.maxtags);
4861         } else {
4862                 if (quiet == 0) {
4863                         fprintf(stdout, "%s", pathstr);
4864                         fprintf(stdout, "device openings: ");
4865                 }
4866                 fprintf(stdout, "%d\n", ccb->cgds.dev_openings +
4867                         ccb->cgds.dev_active);
4868         }
4869
4870 tagcontrol_bailout:
4871
4872         cam_freeccb(ccb);
4873         return(retval);
4874 }
4875
4876 static void
4877 cts_print(struct cam_device *device, struct ccb_trans_settings *cts)
4878 {
4879         char pathstr[1024];
4880
4881         cam_path_string(device, pathstr, sizeof(pathstr));
4882
4883         if (cts->transport == XPORT_SPI) {
4884                 struct ccb_trans_settings_spi *spi =
4885                     &cts->xport_specific.spi;
4886
4887                 if ((spi->valid & CTS_SPI_VALID_SYNC_RATE) != 0) {
4888
4889                         fprintf(stdout, "%ssync parameter: %d\n", pathstr,
4890                                 spi->sync_period);
4891
4892                         if (spi->sync_offset != 0) {
4893                                 u_int freq;
4894
4895                                 freq = scsi_calc_syncsrate(spi->sync_period);
4896                                 fprintf(stdout, "%sfrequency: %d.%03dMHz\n",
4897                                         pathstr, freq / 1000, freq % 1000);
4898                         }
4899                 }
4900
4901                 if (spi->valid & CTS_SPI_VALID_SYNC_OFFSET) {
4902                         fprintf(stdout, "%soffset: %d\n", pathstr,
4903                             spi->sync_offset);
4904                 }
4905
4906                 if (spi->valid & CTS_SPI_VALID_BUS_WIDTH) {
4907                         fprintf(stdout, "%sbus width: %d bits\n", pathstr,
4908                                 (0x01 << spi->bus_width) * 8);
4909                 }
4910
4911                 if (spi->valid & CTS_SPI_VALID_DISC) {
4912                         fprintf(stdout, "%sdisconnection is %s\n", pathstr,
4913                                 (spi->flags & CTS_SPI_FLAGS_DISC_ENB) ?
4914                                 "enabled" : "disabled");
4915                 }
4916         }
4917         if (cts->transport == XPORT_FC) {
4918                 struct ccb_trans_settings_fc *fc =
4919                     &cts->xport_specific.fc;
4920
4921                 if (fc->valid & CTS_FC_VALID_WWNN)
4922                         fprintf(stdout, "%sWWNN: 0x%llx\n", pathstr,
4923                             (long long) fc->wwnn);
4924                 if (fc->valid & CTS_FC_VALID_WWPN)
4925                         fprintf(stdout, "%sWWPN: 0x%llx\n", pathstr,
4926                             (long long) fc->wwpn);
4927                 if (fc->valid & CTS_FC_VALID_PORT)
4928                         fprintf(stdout, "%sPortID: 0x%x\n", pathstr, fc->port);
4929                 if (fc->valid & CTS_FC_VALID_SPEED)
4930                         fprintf(stdout, "%stransfer speed: %d.%03dMB/s\n",
4931                             pathstr, fc->bitrate / 1000, fc->bitrate % 1000);
4932         }
4933         if (cts->transport == XPORT_SAS) {
4934                 struct ccb_trans_settings_sas *sas =
4935                     &cts->xport_specific.sas;
4936
4937                 if (sas->valid & CTS_SAS_VALID_SPEED)
4938                         fprintf(stdout, "%stransfer speed: %d.%03dMB/s\n",
4939                             pathstr, sas->bitrate / 1000, sas->bitrate % 1000);
4940         }
4941         if (cts->transport == XPORT_ATA) {
4942                 struct ccb_trans_settings_pata *pata =
4943                     &cts->xport_specific.ata;
4944
4945                 if ((pata->valid & CTS_ATA_VALID_MODE) != 0) {
4946                         fprintf(stdout, "%sATA mode: %s\n", pathstr,
4947                                 ata_mode2string(pata->mode));
4948                 }
4949                 if ((pata->valid & CTS_ATA_VALID_ATAPI) != 0) {
4950                         fprintf(stdout, "%sATAPI packet length: %d\n", pathstr,
4951                                 pata->atapi);
4952                 }
4953                 if ((pata->valid & CTS_ATA_VALID_BYTECOUNT) != 0) {
4954                         fprintf(stdout, "%sPIO transaction length: %d\n",
4955                                 pathstr, pata->bytecount);
4956                 }
4957         }
4958         if (cts->transport == XPORT_SATA) {
4959                 struct ccb_trans_settings_sata *sata =
4960                     &cts->xport_specific.sata;
4961
4962                 if ((sata->valid & CTS_SATA_VALID_REVISION) != 0) {
4963                         fprintf(stdout, "%sSATA revision: %d.x\n", pathstr,
4964                                 sata->revision);
4965                 }
4966                 if ((sata->valid & CTS_SATA_VALID_MODE) != 0) {
4967                         fprintf(stdout, "%sATA mode: %s\n", pathstr,
4968                                 ata_mode2string(sata->mode));
4969                 }
4970                 if ((sata->valid & CTS_SATA_VALID_ATAPI) != 0) {
4971                         fprintf(stdout, "%sATAPI packet length: %d\n", pathstr,
4972                                 sata->atapi);
4973                 }
4974                 if ((sata->valid & CTS_SATA_VALID_BYTECOUNT) != 0) {
4975                         fprintf(stdout, "%sPIO transaction length: %d\n",
4976                                 pathstr, sata->bytecount);
4977                 }
4978                 if ((sata->valid & CTS_SATA_VALID_PM) != 0) {
4979                         fprintf(stdout, "%sPMP presence: %d\n", pathstr,
4980                                 sata->pm_present);
4981                 }
4982                 if ((sata->valid & CTS_SATA_VALID_TAGS) != 0) {
4983                         fprintf(stdout, "%sNumber of tags: %d\n", pathstr,
4984                                 sata->tags);
4985                 }
4986                 if ((sata->valid & CTS_SATA_VALID_CAPS) != 0) {
4987                         fprintf(stdout, "%sSATA capabilities: %08x\n", pathstr,
4988                                 sata->caps);
4989                 }
4990         }
4991         if (cts->protocol == PROTO_ATA) {
4992                 struct ccb_trans_settings_ata *ata=
4993                     &cts->proto_specific.ata;
4994
4995                 if (ata->valid & CTS_ATA_VALID_TQ) {
4996                         fprintf(stdout, "%stagged queueing: %s\n", pathstr,
4997                                 (ata->flags & CTS_ATA_FLAGS_TAG_ENB) ?
4998                                 "enabled" : "disabled");
4999                 }
5000         }
5001         if (cts->protocol == PROTO_SCSI) {
5002                 struct ccb_trans_settings_scsi *scsi=
5003                     &cts->proto_specific.scsi;
5004
5005                 if (scsi->valid & CTS_SCSI_VALID_TQ) {
5006                         fprintf(stdout, "%stagged queueing: %s\n", pathstr,
5007                                 (scsi->flags & CTS_SCSI_FLAGS_TAG_ENB) ?
5008                                 "enabled" : "disabled");
5009                 }
5010         }
5011
5012 }
5013
5014 /*
5015  * Get a path inquiry CCB for the specified device.
5016  */
5017 static int
5018 get_cpi(struct cam_device *device, struct ccb_pathinq *cpi)
5019 {
5020         union ccb *ccb;
5021         int retval = 0;
5022
5023         ccb = cam_getccb(device);
5024         if (ccb == NULL) {
5025                 warnx("get_cpi: couldn't allocate CCB");
5026                 return(1);
5027         }
5028         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->cpi);
5029         ccb->ccb_h.func_code = XPT_PATH_INQ;
5030         if (cam_send_ccb(device, ccb) < 0) {
5031                 warn("get_cpi: error sending Path Inquiry CCB");
5032                 if (arglist & CAM_ARG_VERBOSE)
5033                         cam_error_print(device, ccb, CAM_ESF_ALL,
5034                                         CAM_EPF_ALL, stderr);
5035                 retval = 1;
5036                 goto get_cpi_bailout;
5037         }
5038         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
5039                 if (arglist & CAM_ARG_VERBOSE)
5040                         cam_error_print(device, ccb, CAM_ESF_ALL,
5041                                         CAM_EPF_ALL, stderr);
5042                 retval = 1;
5043                 goto get_cpi_bailout;
5044         }
5045         bcopy(&ccb->cpi, cpi, sizeof(struct ccb_pathinq));
5046
5047 get_cpi_bailout:
5048         cam_freeccb(ccb);
5049         return(retval);
5050 }
5051
5052 /*
5053  * Get a get device CCB for the specified device.
5054  */
5055 static int
5056 get_cgd(struct cam_device *device, struct ccb_getdev *cgd)
5057 {
5058         union ccb *ccb;
5059         int retval = 0;
5060
5061         ccb = cam_getccb(device);
5062         if (ccb == NULL) {
5063                 warnx("get_cgd: couldn't allocate CCB");
5064                 return(1);
5065         }
5066         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->cgd);
5067         ccb->ccb_h.func_code = XPT_GDEV_TYPE;
5068         if (cam_send_ccb(device, ccb) < 0) {
5069                 warn("get_cgd: error sending Path Inquiry CCB");
5070                 if (arglist & CAM_ARG_VERBOSE)
5071                         cam_error_print(device, ccb, CAM_ESF_ALL,
5072                                         CAM_EPF_ALL, stderr);
5073                 retval = 1;
5074                 goto get_cgd_bailout;
5075         }
5076         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
5077                 if (arglist & CAM_ARG_VERBOSE)
5078                         cam_error_print(device, ccb, CAM_ESF_ALL,
5079                                         CAM_EPF_ALL, stderr);
5080                 retval = 1;
5081                 goto get_cgd_bailout;
5082         }
5083         bcopy(&ccb->cgd, cgd, sizeof(struct ccb_getdev));
5084
5085 get_cgd_bailout:
5086         cam_freeccb(ccb);
5087         return(retval);
5088 }
5089
5090 /*
5091  * Returns 1 if the device has the VPD page, 0 if it does not, and -1 on an
5092  * error.
5093  */
5094 int
5095 dev_has_vpd_page(struct cam_device *dev, uint8_t page_id, int retry_count,
5096                  int timeout, int verbosemode)
5097 {
5098         union ccb *ccb = NULL;
5099         struct scsi_vpd_supported_page_list sup_pages;
5100         int i;
5101         int retval = 0;
5102
5103         ccb = cam_getccb(dev);
5104         if (ccb == NULL) {
5105                 warn("Unable to allocate CCB");
5106                 retval = -1;
5107                 goto bailout;
5108         }
5109
5110         /* cam_getccb cleans up the header, caller has to zero the payload */
5111         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
5112
5113         bzero(&sup_pages, sizeof(sup_pages));
5114
5115         scsi_inquiry(&ccb->csio,
5116                      /*retries*/ retry_count,
5117                      /*cbfcnp*/ NULL,
5118                      /* tag_action */ MSG_SIMPLE_Q_TAG,
5119                      /* inq_buf */ (u_int8_t *)&sup_pages,
5120                      /* inq_len */ sizeof(sup_pages),
5121                      /* evpd */ 1,
5122                      /* page_code */ SVPD_SUPPORTED_PAGE_LIST,
5123                      /* sense_len */ SSD_FULL_SIZE,
5124                      /* timeout */ timeout ? timeout : 5000);
5125
5126         /* Disable freezing the device queue */
5127         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
5128
5129         if (retry_count != 0)
5130                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
5131
5132         if (cam_send_ccb(dev, ccb) < 0) {
5133                 cam_freeccb(ccb);
5134                 ccb = NULL;
5135                 retval = -1;
5136                 goto bailout;
5137         }
5138
5139         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
5140                 if (verbosemode != 0)
5141                         cam_error_print(dev, ccb, CAM_ESF_ALL,
5142                                         CAM_EPF_ALL, stderr);
5143                 retval = -1;
5144                 goto bailout;
5145         }
5146
5147         for (i = 0; i < sup_pages.length; i++) {
5148                 if (sup_pages.list[i] == page_id) {
5149                         retval = 1;
5150                         goto bailout;
5151                 }
5152         }
5153 bailout:
5154         if (ccb != NULL)
5155                 cam_freeccb(ccb);
5156
5157         return (retval);
5158 }
5159
5160 /*
5161  * devtype is filled in with the type of device.
5162  * Returns 0 for success, non-zero for failure.
5163  */
5164 int
5165 get_device_type(struct cam_device *dev, int retry_count, int timeout,
5166                     int verbosemode, camcontrol_devtype *devtype)
5167 {
5168         struct ccb_getdev cgd;
5169         int retval = 0;
5170
5171         retval = get_cgd(dev, &cgd);
5172         if (retval != 0)
5173                 goto bailout;
5174
5175         switch (cgd.protocol) {
5176         case PROTO_SCSI:
5177                 break;
5178         case PROTO_ATA:
5179         case PROTO_ATAPI:
5180         case PROTO_SATAPM:
5181                 *devtype = CC_DT_ATA;
5182                 goto bailout;
5183                 break; /*NOTREACHED*/
5184         default:
5185                 *devtype = CC_DT_UNKNOWN;
5186                 goto bailout;
5187                 break; /*NOTREACHED*/
5188         }
5189
5190         /*
5191          * Check for the ATA Information VPD page (0x89).  If this is an
5192          * ATA device behind a SCSI to ATA translation layer, this VPD page
5193          * should be present.
5194          *
5195          * If that VPD page isn't present, or we get an error back from the
5196          * INQUIRY command, we'll just treat it as a normal SCSI device.
5197          */
5198         retval = dev_has_vpd_page(dev, SVPD_ATA_INFORMATION, retry_count,
5199                                   timeout, verbosemode);
5200         if (retval == 1)
5201                 *devtype = CC_DT_ATA_BEHIND_SCSI;
5202         else
5203                 *devtype = CC_DT_SCSI;
5204
5205         retval = 0;
5206
5207 bailout:
5208         return (retval);
5209 }
5210
5211 int
5212 build_ata_cmd(union ccb *ccb, uint32_t retry_count, uint32_t flags,
5213     uint8_t tag_action, uint8_t protocol, uint8_t ata_flags, uint16_t features,
5214     uint16_t sector_count, uint64_t lba, uint8_t command, uint32_t auxiliary,
5215     uint8_t *data_ptr, uint32_t dxfer_len, uint8_t *cdb_storage,
5216     size_t cdb_storage_len, uint8_t sense_len, uint32_t timeout,
5217     int is48bit, camcontrol_devtype devtype)
5218 {
5219         int retval = 0;
5220
5221         if (devtype == CC_DT_ATA) {
5222                 cam_fill_ataio(&ccb->ataio,
5223                     /*retries*/ retry_count,
5224                     /*cbfcnp*/ NULL,
5225                     /*flags*/ flags,
5226                     /*tag_action*/ tag_action,
5227                     /*data_ptr*/ data_ptr,
5228                     /*dxfer_len*/ dxfer_len,
5229                     /*timeout*/ timeout);
5230                 if (is48bit || lba > ATA_MAX_28BIT_LBA)
5231                         ata_48bit_cmd(&ccb->ataio, command, features, lba,
5232                             sector_count);
5233                 else
5234                         ata_28bit_cmd(&ccb->ataio, command, features, lba,
5235                             sector_count);
5236
5237                 if (auxiliary != 0) {
5238                         ccb->ataio.ata_flags |= ATA_FLAG_AUX;
5239                         ccb->ataio.aux = auxiliary;
5240                 }
5241
5242                 if (ata_flags & AP_FLAG_CHK_COND)
5243                         ccb->ataio.cmd.flags |= CAM_ATAIO_NEEDRESULT;
5244
5245                 if ((protocol & AP_PROTO_MASK) == AP_PROTO_DMA)
5246                         ccb->ataio.cmd.flags |= CAM_ATAIO_DMA;
5247                 else if ((protocol & AP_PROTO_MASK) == AP_PROTO_FPDMA)
5248                         ccb->ataio.cmd.flags |= CAM_ATAIO_FPDMA;
5249         } else {
5250                 if (is48bit || lba > ATA_MAX_28BIT_LBA)
5251                         protocol |= AP_EXTEND;
5252
5253                 retval = scsi_ata_pass(&ccb->csio,
5254                     /*retries*/ retry_count,
5255                     /*cbfcnp*/ NULL,
5256                     /*flags*/ flags,
5257                     /*tag_action*/ tag_action,
5258                     /*protocol*/ protocol,
5259                     /*ata_flags*/ ata_flags,
5260                     /*features*/ features,
5261                     /*sector_count*/ sector_count,
5262                     /*lba*/ lba,
5263                     /*command*/ command,
5264                     /*device*/ 0,
5265                     /*icc*/ 0,
5266                     /*auxiliary*/ auxiliary,
5267                     /*control*/ 0,
5268                     /*data_ptr*/ data_ptr,
5269                     /*dxfer_len*/ dxfer_len,
5270                     /*cdb_storage*/ cdb_storage,
5271                     /*cdb_storage_len*/ cdb_storage_len,
5272                     /*minimum_cmd_size*/ 0,
5273                     /*sense_len*/ sense_len,
5274                     /*timeout*/ timeout);
5275         }
5276
5277         return (retval);
5278 }
5279
5280 int
5281 get_ata_status(struct cam_device *dev, union ccb *ccb, uint8_t *error,
5282                uint16_t *count, uint64_t *lba, uint8_t *device, uint8_t *status)
5283 {
5284         int retval = 0;
5285
5286         switch (ccb->ccb_h.func_code) {
5287         case XPT_SCSI_IO: {
5288                 uint8_t opcode;
5289                 int error_code = 0, sense_key = 0, asc = 0, ascq = 0;
5290
5291                 /*
5292                  * In this case, we have SCSI ATA PASS-THROUGH command, 12
5293                  * or 16 byte, and need to see what
5294                  */
5295                 if (ccb->ccb_h.flags & CAM_CDB_POINTER)
5296                         opcode = ccb->csio.cdb_io.cdb_ptr[0];
5297                 else
5298                         opcode = ccb->csio.cdb_io.cdb_bytes[0];
5299                 if ((opcode != ATA_PASS_12)
5300                  && (opcode != ATA_PASS_16)) {
5301                         retval = 1;
5302                         warnx("%s: unsupported opcode %02x", __func__, opcode);
5303                         goto bailout;
5304                 }
5305
5306                 retval = scsi_extract_sense_ccb(ccb, &error_code, &sense_key,
5307                                                 &asc, &ascq);
5308                 /* Note: the _ccb() variant returns 0 for an error */
5309                 if (retval == 0) {
5310                         retval = 1;
5311                         goto bailout;
5312                 } else
5313                         retval = 0;
5314
5315                 switch (error_code) {
5316                 case SSD_DESC_CURRENT_ERROR:
5317                 case SSD_DESC_DEFERRED_ERROR: {
5318                         struct scsi_sense_data_desc *sense;
5319                         struct scsi_sense_ata_ret_desc *desc;
5320                         uint8_t *desc_ptr;
5321
5322                         sense = (struct scsi_sense_data_desc *)
5323                             &ccb->csio.sense_data;
5324
5325                         desc_ptr = scsi_find_desc(sense, ccb->csio.sense_len -
5326                             ccb->csio.sense_resid, SSD_DESC_ATA);
5327                         if (desc_ptr == NULL) {
5328                                 cam_error_print(dev, ccb, CAM_ESF_ALL,
5329                                     CAM_EPF_ALL, stderr);
5330                                 retval = 1;
5331                                 goto bailout;
5332                         }
5333                         desc = (struct scsi_sense_ata_ret_desc *)desc_ptr;
5334
5335                         *error = desc->error;
5336                         *count = (desc->count_15_8 << 8) |
5337                                   desc->count_7_0;
5338                         *lba = ((uint64_t)desc->lba_47_40 << 40) |
5339                                ((uint64_t)desc->lba_39_32 << 32) |
5340                                ((uint64_t)desc->lba_31_24 << 24) |
5341                                (desc->lba_23_16 << 16) |
5342                                (desc->lba_15_8  <<  8) |
5343                                 desc->lba_7_0;
5344                         *device = desc->device;
5345                         *status = desc->status;
5346
5347                         /*
5348                          * If the extend bit isn't set, the result is for a
5349                          * 12-byte ATA PASS-THROUGH command or a 16 or 32 byte
5350                          * command without the extend bit set.  This means
5351                          * that the device is supposed to return 28-bit
5352                          * status.  The count field is only 8 bits, and the
5353                          * LBA field is only 8 bits.
5354                          */
5355                         if ((desc->flags & SSD_DESC_ATA_FLAG_EXTEND) == 0){
5356                                 *count &= 0xff;
5357                                 *lba &= 0x0fffffff;
5358                         }
5359                         break;
5360                 }
5361                 case SSD_CURRENT_ERROR:
5362                 case SSD_DEFERRED_ERROR: {
5363 #if 0
5364                         struct scsi_sense_data_fixed *sense;
5365 #endif
5366                         /*
5367                          * XXX KDM need to support fixed sense data.
5368                          */
5369                         warnx("%s: Fixed sense data not supported yet",
5370                             __func__);
5371                         retval = 1;
5372                         goto bailout;
5373                         break; /*NOTREACHED*/
5374                 }
5375                 default:
5376                         retval = 1;
5377                         goto bailout;
5378                         break;
5379                 }
5380
5381                 break;
5382         }
5383         case XPT_ATA_IO: {
5384                 struct ata_res *res;
5385
5386                 /*
5387                  * In this case, we have an ATA command, and we need to
5388                  * fill in the requested values from the result register
5389                  * set.
5390                  */
5391                 res = &ccb->ataio.res;
5392                 *error = res->error;
5393                 *status = res->status;
5394                 *device = res->device;
5395                 *count = res->sector_count;
5396                 *lba = (res->lba_high << 16) |
5397                        (res->lba_mid << 8) |
5398                        (res->lba_low);
5399                 if (res->flags & CAM_ATAIO_48BIT) {
5400                         *count |= (res->sector_count_exp << 8);
5401                         *lba |= ((uint64_t)res->lba_low_exp << 24) |
5402                                 ((uint64_t)res->lba_mid_exp << 32) |
5403                                 ((uint64_t)res->lba_high_exp << 40);
5404                 } else {
5405                         *lba |= (res->device & 0xf) << 24;
5406                 }
5407                 break;
5408         }
5409         default:
5410                 retval = 1;
5411                 break;
5412         }
5413 bailout:
5414         return (retval);
5415 }
5416
5417 static void
5418 cpi_print(struct ccb_pathinq *cpi)
5419 {
5420         char adapter_str[1024];
5421         uint64_t i;
5422
5423         snprintf(adapter_str, sizeof(adapter_str),
5424                  "%s%d:", cpi->dev_name, cpi->unit_number);
5425
5426         fprintf(stdout, "%s SIM/HBA version: %d\n", adapter_str,
5427                 cpi->version_num);
5428
5429         for (i = 1; i < UINT8_MAX; i = i << 1) {
5430                 const char *str;
5431
5432                 if ((i & cpi->hba_inquiry) == 0)
5433                         continue;
5434
5435                 fprintf(stdout, "%s supports ", adapter_str);
5436
5437                 switch(i) {
5438                 case PI_MDP_ABLE:
5439                         str = "MDP message";
5440                         break;
5441                 case PI_WIDE_32:
5442                         str = "32 bit wide SCSI";
5443                         break;
5444                 case PI_WIDE_16:
5445                         str = "16 bit wide SCSI";
5446                         break;
5447                 case PI_SDTR_ABLE:
5448                         str = "SDTR message";
5449                         break;
5450                 case PI_LINKED_CDB:
5451                         str = "linked CDBs";
5452                         break;
5453                 case PI_TAG_ABLE:
5454                         str = "tag queue messages";
5455                         break;
5456                 case PI_SOFT_RST:
5457                         str = "soft reset alternative";
5458                         break;
5459                 case PI_SATAPM:
5460                         str = "SATA Port Multiplier";
5461                         break;
5462                 default:
5463                         str = "unknown PI bit set";
5464                         break;
5465                 }
5466                 fprintf(stdout, "%s\n", str);
5467         }
5468
5469         for (i = 1; i < UINT32_MAX; i = i << 1) {
5470                 const char *str;
5471
5472                 if ((i & cpi->hba_misc) == 0)
5473                         continue;
5474
5475                 fprintf(stdout, "%s ", adapter_str);
5476
5477                 switch(i) {
5478                 case PIM_ATA_EXT:
5479                         str = "can understand ata_ext requests";
5480                         break;
5481                 case PIM_EXTLUNS:
5482                         str = "64bit extended LUNs supported";
5483                         break;
5484                 case PIM_SCANHILO:
5485                         str = "bus scans from high ID to low ID";
5486                         break;
5487                 case PIM_NOREMOVE:
5488                         str = "removable devices not included in scan";
5489                         break;
5490                 case PIM_NOINITIATOR:
5491                         str = "initiator role not supported";
5492                         break;
5493                 case PIM_NOBUSRESET:
5494                         str = "user has disabled initial BUS RESET or"
5495                               " controller is in target/mixed mode";
5496                         break;
5497                 case PIM_NO_6_BYTE:
5498                         str = "do not send 6-byte commands";
5499                         break;
5500                 case PIM_SEQSCAN:
5501                         str = "scan bus sequentially";
5502                         break;
5503                 case PIM_UNMAPPED:
5504                         str = "unmapped I/O supported";
5505                         break;
5506                 case PIM_NOSCAN:
5507                         str = "does its own scanning";
5508                         break;
5509                 default:
5510                         str = "unknown PIM bit set";
5511                         break;
5512                 }
5513                 fprintf(stdout, "%s\n", str);
5514         }
5515
5516         for (i = 1; i < UINT16_MAX; i = i << 1) {
5517                 const char *str;
5518
5519                 if ((i & cpi->target_sprt) == 0)
5520                         continue;
5521
5522                 fprintf(stdout, "%s supports ", adapter_str);
5523                 switch(i) {
5524                 case PIT_PROCESSOR:
5525                         str = "target mode processor mode";
5526                         break;
5527                 case PIT_PHASE:
5528                         str = "target mode phase cog. mode";
5529                         break;
5530                 case PIT_DISCONNECT:
5531                         str = "disconnects in target mode";
5532                         break;
5533                 case PIT_TERM_IO:
5534                         str = "terminate I/O message in target mode";
5535                         break;
5536                 case PIT_GRP_6:
5537                         str = "group 6 commands in target mode";
5538                         break;
5539                 case PIT_GRP_7:
5540                         str = "group 7 commands in target mode";
5541                         break;
5542                 default:
5543                         str = "unknown PIT bit set";
5544                         break;
5545                 }
5546
5547                 fprintf(stdout, "%s\n", str);
5548         }
5549         fprintf(stdout, "%s HBA engine count: %d\n", adapter_str,
5550                 cpi->hba_eng_cnt);
5551         fprintf(stdout, "%s maximum target: %d\n", adapter_str,
5552                 cpi->max_target);
5553         fprintf(stdout, "%s maximum LUN: %d\n", adapter_str,
5554                 cpi->max_lun);
5555         fprintf(stdout, "%s highest path ID in subsystem: %d\n",
5556                 adapter_str, cpi->hpath_id);
5557         fprintf(stdout, "%s initiator ID: %d\n", adapter_str,
5558                 cpi->initiator_id);
5559         fprintf(stdout, "%s SIM vendor: %s\n", adapter_str, cpi->sim_vid);
5560         fprintf(stdout, "%s HBA vendor: %s\n", adapter_str, cpi->hba_vid);
5561         fprintf(stdout, "%s HBA vendor ID: 0x%04x\n",
5562             adapter_str, cpi->hba_vendor);
5563         fprintf(stdout, "%s HBA device ID: 0x%04x\n",
5564             adapter_str, cpi->hba_device);
5565         fprintf(stdout, "%s HBA subvendor ID: 0x%04x\n",
5566             adapter_str, cpi->hba_subvendor);
5567         fprintf(stdout, "%s HBA subdevice ID: 0x%04x\n",
5568             adapter_str, cpi->hba_subdevice);
5569         fprintf(stdout, "%s bus ID: %d\n", adapter_str, cpi->bus_id);
5570         fprintf(stdout, "%s base transfer speed: ", adapter_str);
5571         if (cpi->base_transfer_speed > 1000)
5572                 fprintf(stdout, "%d.%03dMB/sec\n",
5573                         cpi->base_transfer_speed / 1000,
5574                         cpi->base_transfer_speed % 1000);
5575         else
5576                 fprintf(stdout, "%dKB/sec\n",
5577                         (cpi->base_transfer_speed % 1000) * 1000);
5578         fprintf(stdout, "%s maximum transfer size: %u bytes\n",
5579             adapter_str, cpi->maxio);
5580 }
5581
5582 static int
5583 get_print_cts(struct cam_device *device, int user_settings, int quiet,
5584               struct ccb_trans_settings *cts)
5585 {
5586         int retval;
5587         union ccb *ccb;
5588
5589         retval = 0;
5590         ccb = cam_getccb(device);
5591
5592         if (ccb == NULL) {
5593                 warnx("get_print_cts: error allocating ccb");
5594                 return(1);
5595         }
5596
5597         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->cts);
5598
5599         ccb->ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
5600
5601         if (user_settings == 0)
5602                 ccb->cts.type = CTS_TYPE_CURRENT_SETTINGS;
5603         else
5604                 ccb->cts.type = CTS_TYPE_USER_SETTINGS;
5605
5606         if (cam_send_ccb(device, ccb) < 0) {
5607                 perror("error sending XPT_GET_TRAN_SETTINGS CCB");
5608                 if (arglist & CAM_ARG_VERBOSE)
5609                         cam_error_print(device, ccb, CAM_ESF_ALL,
5610                                         CAM_EPF_ALL, stderr);
5611                 retval = 1;
5612                 goto get_print_cts_bailout;
5613         }
5614
5615         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
5616                 warnx("XPT_GET_TRANS_SETTINGS CCB failed");
5617                 if (arglist & CAM_ARG_VERBOSE)
5618                         cam_error_print(device, ccb, CAM_ESF_ALL,
5619                                         CAM_EPF_ALL, stderr);
5620                 retval = 1;
5621                 goto get_print_cts_bailout;
5622         }
5623
5624         if (quiet == 0)
5625                 cts_print(device, &ccb->cts);
5626
5627         if (cts != NULL)
5628                 bcopy(&ccb->cts, cts, sizeof(struct ccb_trans_settings));
5629
5630 get_print_cts_bailout:
5631
5632         cam_freeccb(ccb);
5633
5634         return(retval);
5635 }
5636
5637 static int
5638 ratecontrol(struct cam_device *device, int task_attr, int retry_count,
5639             int timeout, int argc, char **argv, char *combinedopt)
5640 {
5641         int c;
5642         union ccb *ccb;
5643         int user_settings = 0;
5644         int retval = 0;
5645         int disc_enable = -1, tag_enable = -1;
5646         int mode = -1;
5647         int offset = -1;
5648         double syncrate = -1;
5649         int bus_width = -1;
5650         int quiet = 0;
5651         int change_settings = 0, send_tur = 0;
5652         struct ccb_pathinq cpi;
5653
5654         ccb = cam_getccb(device);
5655         if (ccb == NULL) {
5656                 warnx("ratecontrol: error allocating ccb");
5657                 return(1);
5658         }
5659         while ((c = getopt(argc, argv, combinedopt)) != -1) {
5660                 switch(c){
5661                 case 'a':
5662                         send_tur = 1;
5663                         break;
5664                 case 'c':
5665                         user_settings = 0;
5666                         break;
5667                 case 'D':
5668                         if (strncasecmp(optarg, "enable", 6) == 0)
5669                                 disc_enable = 1;
5670                         else if (strncasecmp(optarg, "disable", 7) == 0)
5671                                 disc_enable = 0;
5672                         else {
5673                                 warnx("-D argument \"%s\" is unknown", optarg);
5674                                 retval = 1;
5675                                 goto ratecontrol_bailout;
5676                         }
5677                         change_settings = 1;
5678                         break;
5679                 case 'M':
5680                         mode = ata_string2mode(optarg);
5681                         if (mode < 0) {
5682                                 warnx("unknown mode '%s'", optarg);
5683                                 retval = 1;
5684                                 goto ratecontrol_bailout;
5685                         }
5686                         change_settings = 1;
5687                         break;
5688                 case 'O':
5689                         offset = strtol(optarg, NULL, 0);
5690                         if (offset < 0) {
5691                                 warnx("offset value %d is < 0", offset);
5692                                 retval = 1;
5693                                 goto ratecontrol_bailout;
5694                         }
5695                         change_settings = 1;
5696                         break;
5697                 case 'q':
5698                         quiet++;
5699                         break;
5700                 case 'R':
5701                         syncrate = atof(optarg);
5702                         if (syncrate < 0) {
5703                                 warnx("sync rate %f is < 0", syncrate);
5704                                 retval = 1;
5705                                 goto ratecontrol_bailout;
5706                         }
5707                         change_settings = 1;
5708                         break;
5709                 case 'T':
5710                         if (strncasecmp(optarg, "enable", 6) == 0)
5711                                 tag_enable = 1;
5712                         else if (strncasecmp(optarg, "disable", 7) == 0)
5713                                 tag_enable = 0;
5714                         else {
5715                                 warnx("-T argument \"%s\" is unknown", optarg);
5716                                 retval = 1;
5717                                 goto ratecontrol_bailout;
5718                         }
5719                         change_settings = 1;
5720                         break;
5721                 case 'U':
5722                         user_settings = 1;
5723                         break;
5724                 case 'W':
5725                         bus_width = strtol(optarg, NULL, 0);
5726                         if (bus_width < 0) {
5727                                 warnx("bus width %d is < 0", bus_width);
5728                                 retval = 1;
5729                                 goto ratecontrol_bailout;
5730                         }
5731                         change_settings = 1;
5732                         break;
5733                 default:
5734                         break;
5735                 }
5736         }
5737         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->cpi);
5738         /*
5739          * Grab path inquiry information, so we can determine whether
5740          * or not the initiator is capable of the things that the user
5741          * requests.
5742          */
5743         ccb->ccb_h.func_code = XPT_PATH_INQ;
5744         if (cam_send_ccb(device, ccb) < 0) {
5745                 perror("error sending XPT_PATH_INQ CCB");
5746                 if (arglist & CAM_ARG_VERBOSE) {
5747                         cam_error_print(device, ccb, CAM_ESF_ALL,
5748                                         CAM_EPF_ALL, stderr);
5749                 }
5750                 retval = 1;
5751                 goto ratecontrol_bailout;
5752         }
5753         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
5754                 warnx("XPT_PATH_INQ CCB failed");
5755                 if (arglist & CAM_ARG_VERBOSE) {
5756                         cam_error_print(device, ccb, CAM_ESF_ALL,
5757                                         CAM_EPF_ALL, stderr);
5758                 }
5759                 retval = 1;
5760                 goto ratecontrol_bailout;
5761         }
5762         bcopy(&ccb->cpi, &cpi, sizeof(struct ccb_pathinq));
5763         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->cts);
5764         if (quiet == 0) {
5765                 fprintf(stdout, "%s parameters:\n",
5766                     user_settings ? "User" : "Current");
5767         }
5768         retval = get_print_cts(device, user_settings, quiet, &ccb->cts);
5769         if (retval != 0)
5770                 goto ratecontrol_bailout;
5771
5772         if (arglist & CAM_ARG_VERBOSE)
5773                 cpi_print(&cpi);
5774
5775         if (change_settings) {
5776                 int didsettings = 0;
5777                 struct ccb_trans_settings_spi *spi = NULL;
5778                 struct ccb_trans_settings_pata *pata = NULL;
5779                 struct ccb_trans_settings_sata *sata = NULL;
5780                 struct ccb_trans_settings_ata *ata = NULL;
5781                 struct ccb_trans_settings_scsi *scsi = NULL;
5782
5783                 if (ccb->cts.transport == XPORT_SPI)
5784                         spi = &ccb->cts.xport_specific.spi;
5785                 if (ccb->cts.transport == XPORT_ATA)
5786                         pata = &ccb->cts.xport_specific.ata;
5787                 if (ccb->cts.transport == XPORT_SATA)
5788                         sata = &ccb->cts.xport_specific.sata;
5789                 if (ccb->cts.protocol == PROTO_ATA)
5790                         ata = &ccb->cts.proto_specific.ata;
5791                 if (ccb->cts.protocol == PROTO_SCSI)
5792                         scsi = &ccb->cts.proto_specific.scsi;
5793                 ccb->cts.xport_specific.valid = 0;
5794                 ccb->cts.proto_specific.valid = 0;
5795                 if (spi && disc_enable != -1) {
5796                         spi->valid |= CTS_SPI_VALID_DISC;
5797                         if (disc_enable == 0)
5798                                 spi->flags &= ~CTS_SPI_FLAGS_DISC_ENB;
5799                         else
5800                                 spi->flags |= CTS_SPI_FLAGS_DISC_ENB;
5801                         didsettings++;
5802                 }
5803                 if (tag_enable != -1) {
5804                         if ((cpi.hba_inquiry & PI_TAG_ABLE) == 0) {
5805                                 warnx("HBA does not support tagged queueing, "
5806                                       "so you cannot modify tag settings");
5807                                 retval = 1;
5808                                 goto ratecontrol_bailout;
5809                         }
5810                         if (ata) {
5811                                 ata->valid |= CTS_SCSI_VALID_TQ;
5812                                 if (tag_enable == 0)
5813                                         ata->flags &= ~CTS_ATA_FLAGS_TAG_ENB;
5814                                 else
5815                                         ata->flags |= CTS_ATA_FLAGS_TAG_ENB;
5816                                 didsettings++;
5817                         } else if (scsi) {
5818                                 scsi->valid |= CTS_SCSI_VALID_TQ;
5819                                 if (tag_enable == 0)
5820                                         scsi->flags &= ~CTS_SCSI_FLAGS_TAG_ENB;
5821                                 else
5822                                         scsi->flags |= CTS_SCSI_FLAGS_TAG_ENB;
5823                                 didsettings++;
5824                         }
5825                 }
5826                 if (spi && offset != -1) {
5827                         if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) {
5828                                 warnx("HBA is not capable of changing offset");
5829                                 retval = 1;
5830                                 goto ratecontrol_bailout;
5831                         }
5832                         spi->valid |= CTS_SPI_VALID_SYNC_OFFSET;
5833                         spi->sync_offset = offset;
5834                         didsettings++;
5835                 }
5836                 if (spi && syncrate != -1) {
5837                         int prelim_sync_period;
5838
5839                         if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) {
5840                                 warnx("HBA is not capable of changing "
5841                                       "transfer rates");
5842                                 retval = 1;
5843                                 goto ratecontrol_bailout;
5844                         }
5845                         spi->valid |= CTS_SPI_VALID_SYNC_RATE;
5846                         /*
5847                          * The sync rate the user gives us is in MHz.
5848                          * We need to translate it into KHz for this
5849                          * calculation.
5850                          */
5851                         syncrate *= 1000;
5852                         /*
5853                          * Next, we calculate a "preliminary" sync period
5854                          * in tenths of a nanosecond.
5855                          */
5856                         if (syncrate == 0)
5857                                 prelim_sync_period = 0;
5858                         else
5859                                 prelim_sync_period = 10000000 / syncrate;
5860                         spi->sync_period =
5861                                 scsi_calc_syncparam(prelim_sync_period);
5862                         didsettings++;
5863                 }
5864                 if (sata && syncrate != -1) {
5865                         if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) {
5866                                 warnx("HBA is not capable of changing "
5867                                       "transfer rates");
5868                                 retval = 1;
5869                                 goto ratecontrol_bailout;
5870                         }
5871                         if  (!user_settings) {
5872                                 warnx("You can modify only user rate "
5873                                     "settings for SATA");
5874                                 retval = 1;
5875                                 goto ratecontrol_bailout;
5876                         }
5877                         sata->revision = ata_speed2revision(syncrate * 100);
5878                         if (sata->revision < 0) {
5879                                 warnx("Invalid rate %f", syncrate);
5880                                 retval = 1;
5881                                 goto ratecontrol_bailout;
5882                         }
5883                         sata->valid |= CTS_SATA_VALID_REVISION;
5884                         didsettings++;
5885                 }
5886                 if ((pata || sata) && mode != -1) {
5887                         if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) {
5888                                 warnx("HBA is not capable of changing "
5889                                       "transfer rates");
5890                                 retval = 1;
5891                                 goto ratecontrol_bailout;
5892                         }
5893                         if  (!user_settings) {
5894                                 warnx("You can modify only user mode "
5895                                     "settings for ATA/SATA");
5896                                 retval = 1;
5897                                 goto ratecontrol_bailout;
5898                         }
5899                         if (pata) {
5900                                 pata->mode = mode;
5901                                 pata->valid |= CTS_ATA_VALID_MODE;
5902                         } else {
5903                                 sata->mode = mode;
5904                                 sata->valid |= CTS_SATA_VALID_MODE;
5905                         }
5906                         didsettings++;
5907                 }
5908                 /*
5909                  * The bus_width argument goes like this:
5910                  * 0 == 8 bit
5911                  * 1 == 16 bit
5912                  * 2 == 32 bit
5913                  * Therefore, if you shift the number of bits given on the
5914                  * command line right by 4, you should get the correct
5915                  * number.
5916                  */
5917                 if (spi && bus_width != -1) {
5918                         /*
5919                          * We might as well validate things here with a
5920                          * decipherable error message, rather than what
5921                          * will probably be an indecipherable error message
5922                          * by the time it gets back to us.
5923                          */
5924                         if ((bus_width == 16)
5925                          && ((cpi.hba_inquiry & PI_WIDE_16) == 0)) {
5926                                 warnx("HBA does not support 16 bit bus width");
5927                                 retval = 1;
5928                                 goto ratecontrol_bailout;
5929                         } else if ((bus_width == 32)
5930                                 && ((cpi.hba_inquiry & PI_WIDE_32) == 0)) {
5931                                 warnx("HBA does not support 32 bit bus width");
5932                                 retval = 1;
5933                                 goto ratecontrol_bailout;
5934                         } else if ((bus_width != 8)
5935                                 && (bus_width != 16)
5936                                 && (bus_width != 32)) {
5937                                 warnx("Invalid bus width %d", bus_width);
5938                                 retval = 1;
5939                                 goto ratecontrol_bailout;
5940                         }
5941                         spi->valid |= CTS_SPI_VALID_BUS_WIDTH;
5942                         spi->bus_width = bus_width >> 4;
5943                         didsettings++;
5944                 }
5945                 if  (didsettings == 0) {
5946                         goto ratecontrol_bailout;
5947                 }
5948                 ccb->ccb_h.func_code = XPT_SET_TRAN_SETTINGS;
5949                 if (cam_send_ccb(device, ccb) < 0) {
5950                         perror("error sending XPT_SET_TRAN_SETTINGS CCB");
5951                         if (arglist & CAM_ARG_VERBOSE) {
5952                                 cam_error_print(device, ccb, CAM_ESF_ALL,
5953                                                 CAM_EPF_ALL, stderr);
5954                         }
5955                         retval = 1;
5956                         goto ratecontrol_bailout;
5957                 }
5958                 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
5959                         warnx("XPT_SET_TRANS_SETTINGS CCB failed");
5960                         if (arglist & CAM_ARG_VERBOSE) {
5961                                 cam_error_print(device, ccb, CAM_ESF_ALL,
5962                                                 CAM_EPF_ALL, stderr);
5963                         }
5964                         retval = 1;
5965                         goto ratecontrol_bailout;
5966                 }
5967         }
5968         if (send_tur) {
5969                 retval = testunitready(device, task_attr, retry_count, timeout,
5970                                        (arglist & CAM_ARG_VERBOSE) ? 0 : 1);
5971                 /*
5972                  * If the TUR didn't succeed, just bail.
5973                  */
5974                 if (retval != 0) {
5975                         if (quiet == 0)
5976                                 fprintf(stderr, "Test Unit Ready failed\n");
5977                         goto ratecontrol_bailout;
5978                 }
5979         }
5980         if ((change_settings || send_tur) && !quiet &&
5981             (ccb->cts.transport == XPORT_ATA ||
5982              ccb->cts.transport == XPORT_SATA || send_tur)) {
5983                 fprintf(stdout, "New parameters:\n");
5984                 retval = get_print_cts(device, user_settings, 0, NULL);
5985         }
5986
5987 ratecontrol_bailout:
5988         cam_freeccb(ccb);
5989         return(retval);
5990 }
5991
5992 static int
5993 scsiformat(struct cam_device *device, int argc, char **argv,
5994            char *combinedopt, int task_attr, int retry_count, int timeout)
5995 {
5996         union ccb *ccb;
5997         int c;
5998         int ycount = 0, quiet = 0;
5999         int error = 0, retval = 0;
6000         int use_timeout = 10800 * 1000;
6001         int immediate = 1;
6002         struct format_defect_list_header fh;
6003         u_int8_t *data_ptr = NULL;
6004         u_int32_t dxfer_len = 0;
6005         u_int8_t byte2 = 0;
6006         int num_warnings = 0;
6007         int reportonly = 0;
6008
6009         ccb = cam_getccb(device);
6010
6011         if (ccb == NULL) {
6012                 warnx("scsiformat: error allocating ccb");
6013                 return(1);
6014         }
6015
6016         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
6017
6018         while ((c = getopt(argc, argv, combinedopt)) != -1) {
6019                 switch(c) {
6020                 case 'q':
6021                         quiet++;
6022                         break;
6023                 case 'r':
6024                         reportonly = 1;
6025                         break;
6026                 case 'w':
6027                         immediate = 0;
6028                         break;
6029                 case 'y':
6030                         ycount++;
6031                         break;
6032                 }
6033         }
6034
6035         if (reportonly)
6036                 goto doreport;
6037
6038         if (quiet == 0) {
6039                 fprintf(stdout, "You are about to REMOVE ALL DATA from the "
6040                         "following device:\n");
6041
6042                 error = scsidoinquiry(device, argc, argv, combinedopt,
6043                                       task_attr, retry_count, timeout);
6044
6045                 if (error != 0) {
6046                         warnx("scsiformat: error sending inquiry");
6047                         goto scsiformat_bailout;
6048                 }
6049         }
6050
6051         if (ycount == 0) {
6052                 if (!get_confirmation()) {
6053                         error = 1;
6054                         goto scsiformat_bailout;
6055                 }
6056         }
6057
6058         if (timeout != 0)
6059                 use_timeout = timeout;
6060
6061         if (quiet == 0) {
6062                 fprintf(stdout, "Current format timeout is %d seconds\n",
6063                         use_timeout / 1000);
6064         }
6065
6066         /*
6067          * If the user hasn't disabled questions and didn't specify a
6068          * timeout on the command line, ask them if they want the current
6069          * timeout.
6070          */
6071         if ((ycount == 0)
6072          && (timeout == 0)) {
6073                 char str[1024];
6074                 int new_timeout = 0;
6075
6076                 fprintf(stdout, "Enter new timeout in seconds or press\n"
6077                         "return to keep the current timeout [%d] ",
6078                         use_timeout / 1000);
6079
6080                 if (fgets(str, sizeof(str), stdin) != NULL) {
6081                         if (str[0] != '\0')
6082                                 new_timeout = atoi(str);
6083                 }
6084
6085                 if (new_timeout != 0) {
6086                         use_timeout = new_timeout * 1000;
6087                         fprintf(stdout, "Using new timeout value %d\n",
6088                                 use_timeout / 1000);
6089                 }
6090         }
6091
6092         /*
6093          * Keep this outside the if block below to silence any unused
6094          * variable warnings.
6095          */
6096         bzero(&fh, sizeof(fh));
6097
6098         /*
6099          * If we're in immediate mode, we've got to include the format
6100          * header
6101          */
6102         if (immediate != 0) {
6103                 fh.byte2 = FU_DLH_IMMED;
6104                 data_ptr = (u_int8_t *)&fh;
6105                 dxfer_len = sizeof(fh);
6106                 byte2 = FU_FMT_DATA;
6107         } else if (quiet == 0) {
6108                 fprintf(stdout, "Formatting...");
6109                 fflush(stdout);
6110         }
6111
6112         scsi_format_unit(&ccb->csio,
6113                          /* retries */ retry_count,
6114                          /* cbfcnp */ NULL,
6115                          /* tag_action */ task_attr,
6116                          /* byte2 */ byte2,
6117                          /* ileave */ 0,
6118                          /* data_ptr */ data_ptr,
6119                          /* dxfer_len */ dxfer_len,
6120                          /* sense_len */ SSD_FULL_SIZE,
6121                          /* timeout */ use_timeout);
6122
6123         /* Disable freezing the device queue */
6124         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
6125
6126         if (arglist & CAM_ARG_ERR_RECOVER)
6127                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
6128
6129         if (((retval = cam_send_ccb(device, ccb)) < 0)
6130          || ((immediate == 0)
6131            && ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP))) {
6132                 const char errstr[] = "error sending format command";
6133
6134                 if (retval < 0)
6135                         warn(errstr);
6136                 else
6137                         warnx(errstr);
6138
6139                 if (arglist & CAM_ARG_VERBOSE) {
6140                         cam_error_print(device, ccb, CAM_ESF_ALL,
6141                                         CAM_EPF_ALL, stderr);
6142                 }
6143                 error = 1;
6144                 goto scsiformat_bailout;
6145         }
6146
6147         /*
6148          * If we ran in non-immediate mode, we already checked for errors
6149          * above and printed out any necessary information.  If we're in
6150          * immediate mode, we need to loop through and get status
6151          * information periodically.
6152          */
6153         if (immediate == 0) {
6154                 if (quiet == 0) {
6155                         fprintf(stdout, "Format Complete\n");
6156                 }
6157                 goto scsiformat_bailout;
6158         }
6159
6160 doreport:
6161         do {
6162                 cam_status status;
6163
6164                 CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
6165
6166                 /*
6167                  * There's really no need to do error recovery or
6168                  * retries here, since we're just going to sit in a
6169                  * loop and wait for the device to finish formatting.
6170                  */
6171                 scsi_test_unit_ready(&ccb->csio,
6172                                      /* retries */ 0,
6173                                      /* cbfcnp */ NULL,
6174                                      /* tag_action */ task_attr,
6175                                      /* sense_len */ SSD_FULL_SIZE,
6176                                      /* timeout */ 5000);
6177
6178                 /* Disable freezing the device queue */
6179                 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
6180
6181                 retval = cam_send_ccb(device, ccb);
6182
6183                 /*
6184                  * If we get an error from the ioctl, bail out.  SCSI
6185                  * errors are expected.
6186                  */
6187                 if (retval < 0) {
6188                         warn("error sending CAMIOCOMMAND ioctl");
6189                         if (arglist & CAM_ARG_VERBOSE) {
6190                                 cam_error_print(device, ccb, CAM_ESF_ALL,
6191                                                 CAM_EPF_ALL, stderr);
6192                         }
6193                         error = 1;
6194                         goto scsiformat_bailout;
6195                 }
6196
6197                 status = ccb->ccb_h.status & CAM_STATUS_MASK;
6198
6199                 if ((status != CAM_REQ_CMP)
6200                  && (status == CAM_SCSI_STATUS_ERROR)
6201                  && ((ccb->ccb_h.status & CAM_AUTOSNS_VALID) != 0)) {
6202                         struct scsi_sense_data *sense;
6203                         int error_code, sense_key, asc, ascq;
6204
6205                         sense = &ccb->csio.sense_data;
6206                         scsi_extract_sense_len(sense, ccb->csio.sense_len -
6207                             ccb->csio.sense_resid, &error_code, &sense_key,
6208                             &asc, &ascq, /*show_errors*/ 1);
6209
6210                         /*
6211                          * According to the SCSI-2 and SCSI-3 specs, a
6212                          * drive that is in the middle of a format should
6213                          * return NOT READY with an ASC of "logical unit
6214                          * not ready, format in progress".  The sense key
6215                          * specific bytes will then be a progress indicator.
6216                          */
6217                         if ((sense_key == SSD_KEY_NOT_READY)
6218                          && (asc == 0x04) && (ascq == 0x04)) {
6219                                 uint8_t sks[3];
6220
6221                                 if ((scsi_get_sks(sense, ccb->csio.sense_len -
6222                                      ccb->csio.sense_resid, sks) == 0)
6223                                  && (quiet == 0)) {
6224                                         int val;
6225                                         u_int64_t percentage;
6226
6227                                         val = scsi_2btoul(&sks[1]);
6228                                         percentage = 10000 * val;
6229
6230                                         fprintf(stdout,
6231                                                 "\rFormatting:  %ju.%02u %% "
6232                                                 "(%d/%d) done",
6233                                                 (uintmax_t)(percentage /
6234                                                 (0x10000 * 100)),
6235                                                 (unsigned)((percentage /
6236                                                 0x10000) % 100),
6237                                                 val, 0x10000);
6238                                         fflush(stdout);
6239                                 } else if ((quiet == 0)
6240                                         && (++num_warnings <= 1)) {
6241                                         warnx("Unexpected SCSI Sense Key "
6242                                               "Specific value returned "
6243                                               "during format:");
6244                                         scsi_sense_print(device, &ccb->csio,
6245                                                          stderr);
6246                                         warnx("Unable to print status "
6247                                               "information, but format will "
6248                                               "proceed.");
6249                                         warnx("will exit when format is "
6250                                               "complete");
6251                                 }
6252                                 sleep(1);
6253                         } else {
6254                                 warnx("Unexpected SCSI error during format");
6255                                 cam_error_print(device, ccb, CAM_ESF_ALL,
6256                                                 CAM_EPF_ALL, stderr);
6257                                 error = 1;
6258                                 goto scsiformat_bailout;
6259                         }
6260
6261                 } else if (status != CAM_REQ_CMP) {
6262                         warnx("Unexpected CAM status %#x", status);
6263                         if (arglist & CAM_ARG_VERBOSE)
6264                                 cam_error_print(device, ccb, CAM_ESF_ALL,
6265                                                 CAM_EPF_ALL, stderr);
6266                         error = 1;
6267                         goto scsiformat_bailout;
6268                 }
6269
6270         } while((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP);
6271
6272         if (quiet == 0)
6273                 fprintf(stdout, "\nFormat Complete\n");
6274
6275 scsiformat_bailout:
6276
6277         cam_freeccb(ccb);
6278
6279         return(error);
6280 }
6281
6282 static int
6283 scsisanitize(struct cam_device *device, int argc, char **argv,
6284              char *combinedopt, int task_attr, int retry_count, int timeout)
6285 {
6286         union ccb *ccb;
6287         u_int8_t action = 0;
6288         int c;
6289         int ycount = 0, quiet = 0;
6290         int error = 0, retval = 0;
6291         int use_timeout = 10800 * 1000;
6292         int immediate = 1;
6293         int invert = 0;
6294         int passes = 0;
6295         int ause = 0;
6296         int fd = -1;
6297         const char *pattern = NULL;
6298         u_int8_t *data_ptr = NULL;
6299         u_int32_t dxfer_len = 0;
6300         u_int8_t byte2 = 0;
6301         int num_warnings = 0;
6302         int reportonly = 0;
6303
6304         ccb = cam_getccb(device);
6305
6306         if (ccb == NULL) {
6307                 warnx("scsisanitize: error allocating ccb");
6308                 return(1);
6309         }
6310
6311         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
6312
6313         while ((c = getopt(argc, argv, combinedopt)) != -1) {
6314                 switch(c) {
6315                 case 'a':
6316                         if (strcasecmp(optarg, "overwrite") == 0)
6317                                 action = SSZ_SERVICE_ACTION_OVERWRITE;
6318                         else if (strcasecmp(optarg, "block") == 0)
6319                                 action = SSZ_SERVICE_ACTION_BLOCK_ERASE;
6320                         else if (strcasecmp(optarg, "crypto") == 0)
6321                                 action = SSZ_SERVICE_ACTION_CRYPTO_ERASE;
6322                         else if (strcasecmp(optarg, "exitfailure") == 0)
6323                                 action = SSZ_SERVICE_ACTION_EXIT_MODE_FAILURE;
6324                         else {
6325                                 warnx("invalid service operation \"%s\"",
6326                                       optarg);
6327                                 error = 1;
6328                                 goto scsisanitize_bailout;
6329                         }
6330                         break;
6331                 case 'c':
6332                         passes = strtol(optarg, NULL, 0);
6333                         if (passes < 1 || passes > 31) {
6334                                 warnx("invalid passes value %d", passes);
6335                                 error = 1;
6336                                 goto scsisanitize_bailout;
6337                         }
6338                         break;
6339                 case 'I':
6340                         invert = 1;
6341                         break;
6342                 case 'P':
6343                         pattern = optarg;
6344                         break;
6345                 case 'q':
6346                         quiet++;
6347                         break;
6348                 case 'U':
6349                         ause = 1;
6350                         break;
6351                 case 'r':
6352                         reportonly = 1;
6353                         break;
6354                 case 'w':
6355                         immediate = 0;
6356                         break;
6357                 case 'y':
6358                         ycount++;
6359                         break;
6360                 }
6361         }
6362
6363         if (reportonly)
6364                 goto doreport;
6365
6366         if (action == 0) {
6367                 warnx("an action is required");
6368                 error = 1;
6369                 goto scsisanitize_bailout;
6370         } else if (action == SSZ_SERVICE_ACTION_OVERWRITE) {
6371                 struct scsi_sanitize_parameter_list *pl;
6372                 struct stat sb;
6373                 ssize_t sz, amt;
6374
6375                 if (pattern == NULL) {
6376                         warnx("overwrite action requires -P argument");
6377                         error = 1;
6378                         goto scsisanitize_bailout;
6379                 }
6380                 fd = open(pattern, O_RDONLY);
6381                 if (fd < 0) {
6382                         warn("cannot open pattern file %s", pattern);
6383                         error = 1;
6384                         goto scsisanitize_bailout;
6385                 }
6386                 if (fstat(fd, &sb) < 0) {
6387                         warn("cannot stat pattern file %s", pattern);
6388                         error = 1;
6389                         goto scsisanitize_bailout;
6390                 }
6391                 sz = sb.st_size;
6392                 if (sz > SSZPL_MAX_PATTERN_LENGTH) {
6393                         warnx("pattern file size exceeds maximum value %d",
6394                               SSZPL_MAX_PATTERN_LENGTH);
6395                         error = 1;
6396                         goto scsisanitize_bailout;
6397                 }
6398                 dxfer_len = sizeof(*pl) + sz;
6399                 data_ptr = calloc(1, dxfer_len);
6400                 if (data_ptr == NULL) {
6401                         warnx("cannot allocate parameter list buffer");
6402                         error = 1;
6403                         goto scsisanitize_bailout;
6404                 }
6405
6406                 amt = read(fd, data_ptr + sizeof(*pl), sz);
6407                 if (amt < 0) {
6408                         warn("cannot read pattern file");
6409                         error = 1;
6410                         goto scsisanitize_bailout;
6411                 } else if (amt != sz) {
6412                         warnx("short pattern file read");
6413                         error = 1;
6414                         goto scsisanitize_bailout;
6415                 }
6416
6417                 pl = (struct scsi_sanitize_parameter_list *)data_ptr;
6418                 if (passes == 0)
6419                         pl->byte1 = 1;
6420                 else
6421                         pl->byte1 = passes;
6422                 if (invert != 0)
6423                         pl->byte1 |= SSZPL_INVERT;
6424                 scsi_ulto2b(sz, pl->length);
6425         } else {
6426                 const char *arg;
6427
6428                 if (passes != 0)
6429                         arg = "-c";
6430                 else if (invert != 0)
6431                         arg = "-I";
6432                 else if (pattern != NULL)
6433                         arg = "-P";
6434                 else
6435                         arg = NULL;
6436                 if (arg != NULL) {
6437                         warnx("%s argument only valid with overwrite "
6438                               "operation", arg);
6439                         error = 1;
6440                         goto scsisanitize_bailout;
6441                 }
6442         }
6443
6444         if (quiet == 0) {
6445                 fprintf(stdout, "You are about to REMOVE ALL DATA from the "
6446                         "following device:\n");
6447
6448                 error = scsidoinquiry(device, argc, argv, combinedopt,
6449                                       task_attr, retry_count, timeout);
6450
6451                 if (error != 0) {
6452                         warnx("scsisanitize: error sending inquiry");
6453                         goto scsisanitize_bailout;
6454                 }
6455         }
6456
6457         if (ycount == 0) {
6458                 if (!get_confirmation()) {
6459                         error = 1;
6460                         goto scsisanitize_bailout;
6461                 }
6462         }
6463
6464         if (timeout != 0)
6465                 use_timeout = timeout;
6466
6467         if (quiet == 0) {
6468                 fprintf(stdout, "Current sanitize timeout is %d seconds\n",
6469                         use_timeout / 1000);
6470         }
6471
6472         /*
6473          * If the user hasn't disabled questions and didn't specify a
6474          * timeout on the command line, ask them if they want the current
6475          * timeout.
6476          */
6477         if ((ycount == 0)
6478          && (timeout == 0)) {
6479                 char str[1024];
6480                 int new_timeout = 0;
6481
6482                 fprintf(stdout, "Enter new timeout in seconds or press\n"
6483                         "return to keep the current timeout [%d] ",
6484                         use_timeout / 1000);
6485
6486                 if (fgets(str, sizeof(str), stdin) != NULL) {
6487                         if (str[0] != '\0')
6488                                 new_timeout = atoi(str);
6489                 }
6490
6491                 if (new_timeout != 0) {
6492                         use_timeout = new_timeout * 1000;
6493                         fprintf(stdout, "Using new timeout value %d\n",
6494                                 use_timeout / 1000);
6495                 }
6496         }
6497
6498         byte2 = action;
6499         if (ause != 0)
6500                 byte2 |= SSZ_UNRESTRICTED_EXIT;
6501         if (immediate != 0)
6502                 byte2 |= SSZ_IMMED;
6503
6504         scsi_sanitize(&ccb->csio,
6505                       /* retries */ retry_count,
6506                       /* cbfcnp */ NULL,
6507                       /* tag_action */ task_attr,
6508                       /* byte2 */ byte2,
6509                       /* control */ 0,
6510                       /* data_ptr */ data_ptr,
6511                       /* dxfer_len */ dxfer_len,
6512                       /* sense_len */ SSD_FULL_SIZE,
6513                       /* timeout */ use_timeout);
6514
6515         /* Disable freezing the device queue */
6516         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
6517
6518         if (arglist & CAM_ARG_ERR_RECOVER)
6519                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
6520
6521         if (cam_send_ccb(device, ccb) < 0) {
6522                 warn("error sending sanitize command");
6523                 error = 1;
6524                 goto scsisanitize_bailout;
6525         }
6526
6527         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
6528                 struct scsi_sense_data *sense;
6529                 int error_code, sense_key, asc, ascq;
6530
6531                 if ((ccb->ccb_h.status & CAM_STATUS_MASK) ==
6532                     CAM_SCSI_STATUS_ERROR) {
6533                         sense = &ccb->csio.sense_data;
6534                         scsi_extract_sense_len(sense, ccb->csio.sense_len -
6535                             ccb->csio.sense_resid, &error_code, &sense_key,
6536                             &asc, &ascq, /*show_errors*/ 1);
6537
6538                         if (sense_key == SSD_KEY_ILLEGAL_REQUEST &&
6539                             asc == 0x20 && ascq == 0x00)
6540                                 warnx("sanitize is not supported by "
6541                                       "this device");
6542                         else
6543                                 warnx("error sanitizing this device");
6544                 } else
6545                         warnx("error sanitizing this device");
6546
6547                 if (arglist & CAM_ARG_VERBOSE) {
6548                         cam_error_print(device, ccb, CAM_ESF_ALL,
6549                                         CAM_EPF_ALL, stderr);
6550                 }
6551                 error = 1;
6552                 goto scsisanitize_bailout;
6553         }
6554
6555         /*
6556          * If we ran in non-immediate mode, we already checked for errors
6557          * above and printed out any necessary information.  If we're in
6558          * immediate mode, we need to loop through and get status
6559          * information periodically.
6560          */
6561         if (immediate == 0) {
6562                 if (quiet == 0) {
6563                         fprintf(stdout, "Sanitize Complete\n");
6564                 }
6565                 goto scsisanitize_bailout;
6566         }
6567
6568 doreport:
6569         do {
6570                 cam_status status;
6571
6572                 CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
6573
6574                 /*
6575                  * There's really no need to do error recovery or
6576                  * retries here, since we're just going to sit in a
6577                  * loop and wait for the device to finish sanitizing.
6578                  */
6579                 scsi_test_unit_ready(&ccb->csio,
6580                                      /* retries */ 0,
6581                                      /* cbfcnp */ NULL,
6582                                      /* tag_action */ task_attr,
6583                                      /* sense_len */ SSD_FULL_SIZE,
6584                                      /* timeout */ 5000);
6585
6586                 /* Disable freezing the device queue */
6587                 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
6588
6589                 retval = cam_send_ccb(device, ccb);
6590
6591                 /*
6592                  * If we get an error from the ioctl, bail out.  SCSI
6593                  * errors are expected.
6594                  */
6595                 if (retval < 0) {
6596                         warn("error sending CAMIOCOMMAND ioctl");
6597                         if (arglist & CAM_ARG_VERBOSE) {
6598                                 cam_error_print(device, ccb, CAM_ESF_ALL,
6599                                                 CAM_EPF_ALL, stderr);
6600                         }
6601                         error = 1;
6602                         goto scsisanitize_bailout;
6603                 }
6604
6605                 status = ccb->ccb_h.status & CAM_STATUS_MASK;
6606
6607                 if ((status != CAM_REQ_CMP)
6608                  && (status == CAM_SCSI_STATUS_ERROR)
6609                  && ((ccb->ccb_h.status & CAM_AUTOSNS_VALID) != 0)) {
6610                         struct scsi_sense_data *sense;
6611                         int error_code, sense_key, asc, ascq;
6612
6613                         sense = &ccb->csio.sense_data;
6614                         scsi_extract_sense_len(sense, ccb->csio.sense_len -
6615                             ccb->csio.sense_resid, &error_code, &sense_key,
6616                             &asc, &ascq, /*show_errors*/ 1);
6617
6618                         /*
6619                          * According to the SCSI-3 spec, a drive that is in the
6620                          * middle of a sanitize should return NOT READY with an
6621                          * ASC of "logical unit not ready, sanitize in
6622                          * progress". The sense key specific bytes will then
6623                          * be a progress indicator.
6624                          */
6625                         if ((sense_key == SSD_KEY_NOT_READY)
6626                          && (asc == 0x04) && (ascq == 0x1b)) {
6627                                 uint8_t sks[3];
6628
6629                                 if ((scsi_get_sks(sense, ccb->csio.sense_len -
6630                                      ccb->csio.sense_resid, sks) == 0)
6631                                  && (quiet == 0)) {
6632                                         int val;
6633                                         u_int64_t percentage;
6634
6635                                         val = scsi_2btoul(&sks[1]);
6636                                         percentage = 10000 * val;
6637
6638                                         fprintf(stdout,
6639                                                 "\rSanitizing:  %ju.%02u %% "
6640                                                 "(%d/%d) done",
6641                                                 (uintmax_t)(percentage /
6642                                                 (0x10000 * 100)),
6643                                                 (unsigned)((percentage /
6644                                                 0x10000) % 100),
6645                                                 val, 0x10000);
6646                                         fflush(stdout);
6647                                 } else if ((quiet == 0)
6648                                         && (++num_warnings <= 1)) {
6649                                         warnx("Unexpected SCSI Sense Key "
6650                                               "Specific value returned "
6651                                               "during sanitize:");
6652                                         scsi_sense_print(device, &ccb->csio,
6653                                                          stderr);
6654                                         warnx("Unable to print status "
6655                                               "information, but sanitze will "
6656                                               "proceed.");
6657                                         warnx("will exit when sanitize is "
6658                                               "complete");
6659                                 }
6660                                 sleep(1);
6661                         } else {
6662                                 warnx("Unexpected SCSI error during sanitize");
6663                                 cam_error_print(device, ccb, CAM_ESF_ALL,
6664                                                 CAM_EPF_ALL, stderr);
6665                                 error = 1;
6666                                 goto scsisanitize_bailout;
6667                         }
6668
6669                 } else if (status != CAM_REQ_CMP) {
6670                         warnx("Unexpected CAM status %#x", status);
6671                         if (arglist & CAM_ARG_VERBOSE)
6672                                 cam_error_print(device, ccb, CAM_ESF_ALL,
6673                                                 CAM_EPF_ALL, stderr);
6674                         error = 1;
6675                         goto scsisanitize_bailout;
6676                 }
6677         } while((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP);
6678
6679         if (quiet == 0)
6680                 fprintf(stdout, "\nSanitize Complete\n");
6681
6682 scsisanitize_bailout:
6683         if (fd >= 0)
6684                 close(fd);
6685         if (data_ptr != NULL)
6686                 free(data_ptr);
6687         cam_freeccb(ccb);
6688
6689         return(error);
6690 }
6691
6692 static int
6693 scsireportluns(struct cam_device *device, int argc, char **argv,
6694                char *combinedopt, int task_attr, int retry_count, int timeout)
6695 {
6696         union ccb *ccb;
6697         int c, countonly, lunsonly;
6698         struct scsi_report_luns_data *lundata;
6699         int alloc_len;
6700         uint8_t report_type;
6701         uint32_t list_len, i, j;
6702         int retval;
6703
6704         retval = 0;
6705         lundata = NULL;
6706         report_type = RPL_REPORT_DEFAULT;
6707         ccb = cam_getccb(device);
6708
6709         if (ccb == NULL) {
6710                 warnx("%s: error allocating ccb", __func__);
6711                 return (1);
6712         }
6713
6714         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
6715
6716         countonly = 0;
6717         lunsonly = 0;
6718
6719         while ((c = getopt(argc, argv, combinedopt)) != -1) {
6720                 switch (c) {
6721                 case 'c':
6722                         countonly++;
6723                         break;
6724                 case 'l':
6725                         lunsonly++;
6726                         break;
6727                 case 'r':
6728                         if (strcasecmp(optarg, "default") == 0)
6729                                 report_type = RPL_REPORT_DEFAULT;
6730                         else if (strcasecmp(optarg, "wellknown") == 0)
6731                                 report_type = RPL_REPORT_WELLKNOWN;
6732                         else if (strcasecmp(optarg, "all") == 0)
6733                                 report_type = RPL_REPORT_ALL;
6734                         else {
6735                                 warnx("%s: invalid report type \"%s\"",
6736                                       __func__, optarg);
6737                                 retval = 1;
6738                                 goto bailout;
6739                         }
6740                         break;
6741                 default:
6742                         break;
6743                 }
6744         }
6745
6746         if ((countonly != 0)
6747          && (lunsonly != 0)) {
6748                 warnx("%s: you can only specify one of -c or -l", __func__);
6749                 retval = 1;
6750                 goto bailout;
6751         }
6752         /*
6753          * According to SPC-4, the allocation length must be at least 16
6754          * bytes -- enough for the header and one LUN.
6755          */
6756         alloc_len = sizeof(*lundata) + 8;
6757
6758 retry:
6759
6760         lundata = malloc(alloc_len);
6761
6762         if (lundata == NULL) {
6763                 warn("%s: error mallocing %d bytes", __func__, alloc_len);
6764                 retval = 1;
6765                 goto bailout;
6766         }
6767
6768         scsi_report_luns(&ccb->csio,
6769                          /*retries*/ retry_count,
6770                          /*cbfcnp*/ NULL,
6771                          /*tag_action*/ task_attr,
6772                          /*select_report*/ report_type,
6773                          /*rpl_buf*/ lundata,
6774                          /*alloc_len*/ alloc_len,
6775                          /*sense_len*/ SSD_FULL_SIZE,
6776                          /*timeout*/ timeout ? timeout : 5000);
6777
6778         /* Disable freezing the device queue */
6779         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
6780
6781         if (arglist & CAM_ARG_ERR_RECOVER)
6782                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
6783
6784         if (cam_send_ccb(device, ccb) < 0) {
6785                 warn("error sending REPORT LUNS command");
6786
6787                 if (arglist & CAM_ARG_VERBOSE)
6788                         cam_error_print(device, ccb, CAM_ESF_ALL,
6789                                         CAM_EPF_ALL, stderr);
6790
6791                 retval = 1;
6792                 goto bailout;
6793         }
6794
6795         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
6796                 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr);
6797                 retval = 1;
6798                 goto bailout;
6799         }
6800
6801
6802         list_len = scsi_4btoul(lundata->length);
6803
6804         /*
6805          * If we need to list the LUNs, and our allocation
6806          * length was too short, reallocate and retry.
6807          */
6808         if ((countonly == 0)
6809          && (list_len > (alloc_len - sizeof(*lundata)))) {
6810                 alloc_len = list_len + sizeof(*lundata);
6811                 free(lundata);
6812                 goto retry;
6813         }
6814
6815         if (lunsonly == 0)
6816                 fprintf(stdout, "%u LUN%s found\n", list_len / 8,
6817                         ((list_len / 8) > 1) ? "s" : "");
6818
6819         if (countonly != 0)
6820                 goto bailout;
6821
6822         for (i = 0; i < (list_len / 8); i++) {
6823                 int no_more;
6824
6825                 no_more = 0;
6826                 for (j = 0; j < sizeof(lundata->luns[i].lundata); j += 2) {
6827                         if (j != 0)
6828                                 fprintf(stdout, ",");
6829                         switch (lundata->luns[i].lundata[j] &
6830                                 RPL_LUNDATA_ATYP_MASK) {
6831                         case RPL_LUNDATA_ATYP_PERIPH:
6832                                 if ((lundata->luns[i].lundata[j] &
6833                                     RPL_LUNDATA_PERIPH_BUS_MASK) != 0)
6834                                         fprintf(stdout, "%d:",
6835                                                 lundata->luns[i].lundata[j] &
6836                                                 RPL_LUNDATA_PERIPH_BUS_MASK);
6837                                 else if ((j == 0)
6838                                       && ((lundata->luns[i].lundata[j+2] &
6839                                           RPL_LUNDATA_PERIPH_BUS_MASK) == 0))
6840                                         no_more = 1;
6841
6842                                 fprintf(stdout, "%d",
6843                                         lundata->luns[i].lundata[j+1]);
6844                                 break;
6845                         case RPL_LUNDATA_ATYP_FLAT: {
6846                                 uint8_t tmplun[2];
6847                                 tmplun[0] = lundata->luns[i].lundata[j] &
6848                                         RPL_LUNDATA_FLAT_LUN_MASK;
6849                                 tmplun[1] = lundata->luns[i].lundata[j+1];
6850
6851                                 fprintf(stdout, "%d", scsi_2btoul(tmplun));
6852                                 no_more = 1;
6853                                 break;
6854                         }
6855                         case RPL_LUNDATA_ATYP_LUN:
6856                                 fprintf(stdout, "%d:%d:%d",
6857                                         (lundata->luns[i].lundata[j+1] &
6858                                         RPL_LUNDATA_LUN_BUS_MASK) >> 5,
6859                                         lundata->luns[i].lundata[j] &
6860                                         RPL_LUNDATA_LUN_TARG_MASK,
6861                                         lundata->luns[i].lundata[j+1] &
6862                                         RPL_LUNDATA_LUN_LUN_MASK);
6863                                 break;
6864                         case RPL_LUNDATA_ATYP_EXTLUN: {
6865                                 int field_len_code, eam_code;
6866
6867                                 eam_code = lundata->luns[i].lundata[j] &
6868                                         RPL_LUNDATA_EXT_EAM_MASK;
6869                                 field_len_code = (lundata->luns[i].lundata[j] &
6870                                         RPL_LUNDATA_EXT_LEN_MASK) >> 4;
6871
6872                                 if ((eam_code == RPL_LUNDATA_EXT_EAM_WK)
6873                                  && (field_len_code == 0x00)) {
6874                                         fprintf(stdout, "%d",
6875                                                 lundata->luns[i].lundata[j+1]);
6876                                 } else if ((eam_code ==
6877                                             RPL_LUNDATA_EXT_EAM_NOT_SPEC)
6878                                         && (field_len_code == 0x03)) {
6879                                         uint8_t tmp_lun[8];
6880
6881                                         /*
6882                                          * This format takes up all 8 bytes.
6883                                          * If we aren't starting at offset 0,
6884                                          * that's a bug.
6885                                          */
6886                                         if (j != 0) {
6887                                                 fprintf(stdout, "Invalid "
6888                                                         "offset %d for "
6889                                                         "Extended LUN not "
6890                                                         "specified format", j);
6891                                                 no_more = 1;
6892                                                 break;
6893                                         }
6894                                         bzero(tmp_lun, sizeof(tmp_lun));
6895                                         bcopy(&lundata->luns[i].lundata[j+1],
6896                                               &tmp_lun[1], sizeof(tmp_lun) - 1);
6897                                         fprintf(stdout, "%#jx",
6898                                                (intmax_t)scsi_8btou64(tmp_lun));
6899                                         no_more = 1;
6900                                 } else {
6901                                         fprintf(stderr, "Unknown Extended LUN"
6902                                                 "Address method %#x, length "
6903                                                 "code %#x", eam_code,
6904                                                 field_len_code);
6905                                         no_more = 1;
6906                                 }
6907                                 break;
6908                         }
6909                         default:
6910                                 fprintf(stderr, "Unknown LUN address method "
6911                                         "%#x\n", lundata->luns[i].lundata[0] &
6912                                         RPL_LUNDATA_ATYP_MASK);
6913                                 break;
6914                         }
6915                         /*
6916                          * For the flat addressing method, there are no
6917                          * other levels after it.
6918                          */
6919                         if (no_more != 0)
6920                                 break;
6921                 }
6922                 fprintf(stdout, "\n");
6923         }
6924
6925 bailout:
6926
6927         cam_freeccb(ccb);
6928
6929         free(lundata);
6930
6931         return (retval);
6932 }
6933
6934 static int
6935 scsireadcapacity(struct cam_device *device, int argc, char **argv,
6936                  char *combinedopt, int task_attr, int retry_count, int timeout)
6937 {
6938         union ccb *ccb;
6939         int blocksizeonly, humanize, numblocks, quiet, sizeonly, baseten;
6940         struct scsi_read_capacity_data rcap;
6941         struct scsi_read_capacity_data_long rcaplong;
6942         uint64_t maxsector;
6943         uint32_t block_len;
6944         int retval;
6945         int c;
6946
6947         blocksizeonly = 0;
6948         humanize = 0;
6949         numblocks = 0;
6950         quiet = 0;
6951         sizeonly = 0;
6952         baseten = 0;
6953         retval = 0;
6954
6955         ccb = cam_getccb(device);
6956
6957         if (ccb == NULL) {
6958                 warnx("%s: error allocating ccb", __func__);
6959                 return (1);
6960         }
6961
6962         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
6963
6964         while ((c = getopt(argc, argv, combinedopt)) != -1) {
6965                 switch (c) {
6966                 case 'b':
6967                         blocksizeonly++;
6968                         break;
6969                 case 'h':
6970                         humanize++;
6971                         baseten = 0;
6972                         break;
6973                 case 'H':
6974                         humanize++;
6975                         baseten++;
6976                         break;
6977                 case 'N':
6978                         numblocks++;
6979                         break;
6980                 case 'q':
6981                         quiet++;
6982                         break;
6983                 case 's':
6984                         sizeonly++;
6985                         break;
6986                 default:
6987                         break;
6988                 }
6989         }
6990
6991         if ((blocksizeonly != 0)
6992          && (numblocks != 0)) {
6993                 warnx("%s: you can only specify one of -b or -N", __func__);
6994                 retval = 1;
6995                 goto bailout;
6996         }
6997
6998         if ((blocksizeonly != 0)
6999          && (sizeonly != 0)) {
7000                 warnx("%s: you can only specify one of -b or -s", __func__);
7001                 retval = 1;
7002                 goto bailout;
7003         }
7004
7005         if ((humanize != 0)
7006          && (quiet != 0)) {
7007                 warnx("%s: you can only specify one of -h/-H or -q", __func__);
7008                 retval = 1;
7009                 goto bailout;
7010         }
7011
7012         if ((humanize != 0)
7013          && (blocksizeonly != 0)) {
7014                 warnx("%s: you can only specify one of -h/-H or -b", __func__);
7015                 retval = 1;
7016                 goto bailout;
7017         }
7018
7019         scsi_read_capacity(&ccb->csio,
7020                            /*retries*/ retry_count,
7021                            /*cbfcnp*/ NULL,
7022                            /*tag_action*/ task_attr,
7023                            &rcap,
7024                            SSD_FULL_SIZE,
7025                            /*timeout*/ timeout ? timeout : 5000);
7026
7027         /* Disable freezing the device queue */
7028         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
7029
7030         if (arglist & CAM_ARG_ERR_RECOVER)
7031                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
7032
7033         if (cam_send_ccb(device, ccb) < 0) {
7034                 warn("error sending READ CAPACITY command");
7035
7036                 if (arglist & CAM_ARG_VERBOSE)
7037                         cam_error_print(device, ccb, CAM_ESF_ALL,
7038                                         CAM_EPF_ALL, stderr);
7039
7040                 retval = 1;
7041                 goto bailout;
7042         }
7043
7044         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
7045                 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr);
7046                 retval = 1;
7047                 goto bailout;
7048         }
7049
7050         maxsector = scsi_4btoul(rcap.addr);
7051         block_len = scsi_4btoul(rcap.length);
7052
7053         /*
7054          * A last block of 2^32-1 means that the true capacity is over 2TB,
7055          * and we need to issue the long READ CAPACITY to get the real
7056          * capacity.  Otherwise, we're all set.
7057          */
7058         if (maxsector != 0xffffffff)
7059                 goto do_print;
7060
7061         scsi_read_capacity_16(&ccb->csio,
7062                               /*retries*/ retry_count,
7063                               /*cbfcnp*/ NULL,
7064                               /*tag_action*/ task_attr,
7065                               /*lba*/ 0,
7066                               /*reladdr*/ 0,
7067                               /*pmi*/ 0,
7068                               /*rcap_buf*/ (uint8_t *)&rcaplong,
7069                               /*rcap_buf_len*/ sizeof(rcaplong),
7070                               /*sense_len*/ SSD_FULL_SIZE,
7071                               /*timeout*/ timeout ? timeout : 5000);
7072
7073         /* Disable freezing the device queue */
7074         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
7075
7076         if (arglist & CAM_ARG_ERR_RECOVER)
7077                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
7078
7079         if (cam_send_ccb(device, ccb) < 0) {
7080                 warn("error sending READ CAPACITY (16) command");
7081
7082                 if (arglist & CAM_ARG_VERBOSE)
7083                         cam_error_print(device, ccb, CAM_ESF_ALL,
7084                                         CAM_EPF_ALL, stderr);
7085
7086                 retval = 1;
7087                 goto bailout;
7088         }
7089
7090         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
7091                 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr);
7092                 retval = 1;
7093                 goto bailout;
7094         }
7095
7096         maxsector = scsi_8btou64(rcaplong.addr);
7097         block_len = scsi_4btoul(rcaplong.length);
7098
7099 do_print:
7100         if (blocksizeonly == 0) {
7101                 /*
7102                  * Humanize implies !quiet, and also implies numblocks.
7103                  */
7104                 if (humanize != 0) {
7105                         char tmpstr[6];
7106                         int64_t tmpbytes;
7107                         int ret;
7108
7109                         tmpbytes = (maxsector + 1) * block_len;
7110                         ret = humanize_number(tmpstr, sizeof(tmpstr),
7111                                               tmpbytes, "", HN_AUTOSCALE,
7112                                               HN_B | HN_DECIMAL |
7113                                               ((baseten != 0) ?
7114                                               HN_DIVISOR_1000 : 0));
7115                         if (ret == -1) {
7116                                 warnx("%s: humanize_number failed!", __func__);
7117                                 retval = 1;
7118                                 goto bailout;
7119                         }
7120                         fprintf(stdout, "Device Size: %s%s", tmpstr,
7121                                 (sizeonly == 0) ?  ", " : "\n");
7122                 } else if (numblocks != 0) {
7123                         fprintf(stdout, "%s%ju%s", (quiet == 0) ?
7124                                 "Blocks: " : "", (uintmax_t)maxsector + 1,
7125                                 (sizeonly == 0) ? ", " : "\n");
7126                 } else {
7127                         fprintf(stdout, "%s%ju%s", (quiet == 0) ?
7128                                 "Last Block: " : "", (uintmax_t)maxsector,
7129                                 (sizeonly == 0) ? ", " : "\n");
7130                 }
7131         }
7132         if (sizeonly == 0)
7133                 fprintf(stdout, "%s%u%s\n", (quiet == 0) ?
7134                         "Block Length: " : "", block_len, (quiet == 0) ?
7135                         " bytes" : "");
7136 bailout:
7137         cam_freeccb(ccb);
7138
7139         return (retval);
7140 }
7141
7142 static int
7143 smpcmd(struct cam_device *device, int argc, char **argv, char *combinedopt,
7144        int retry_count, int timeout)
7145 {
7146         int c, error = 0;
7147         union ccb *ccb;
7148         uint8_t *smp_request = NULL, *smp_response = NULL;
7149         int request_size = 0, response_size = 0;
7150         int fd_request = 0, fd_response = 0;
7151         char *datastr = NULL;
7152         struct get_hook hook;
7153         int retval;
7154         int flags = 0;
7155
7156         /*
7157          * Note that at the moment we don't support sending SMP CCBs to
7158          * devices that aren't probed by CAM.
7159          */
7160         ccb = cam_getccb(device);
7161         if (ccb == NULL) {
7162                 warnx("%s: error allocating CCB", __func__);
7163                 return (1);
7164         }
7165
7166         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->smpio);
7167
7168         while ((c = getopt(argc, argv, combinedopt)) != -1) {
7169                 switch (c) {
7170                 case 'R':
7171                         arglist |= CAM_ARG_CMD_IN;
7172                         response_size = strtol(optarg, NULL, 0);
7173                         if (response_size <= 0) {
7174                                 warnx("invalid number of response bytes %d",
7175                                       response_size);
7176                                 error = 1;
7177                                 goto smpcmd_bailout;
7178                         }
7179                         hook.argc = argc - optind;
7180                         hook.argv = argv + optind;
7181                         hook.got = 0;
7182                         optind++;
7183                         datastr = cget(&hook, NULL);
7184                         /*
7185                          * If the user supplied "-" instead of a format, he
7186                          * wants the data to be written to stdout.
7187                          */
7188                         if ((datastr != NULL)
7189                          && (datastr[0] == '-'))
7190                                 fd_response = 1;
7191
7192                         smp_response = (u_int8_t *)malloc(response_size);
7193                         if (smp_response == NULL) {
7194                                 warn("can't malloc memory for SMP response");
7195                                 error = 1;
7196                                 goto smpcmd_bailout;
7197                         }
7198                         break;
7199                 case 'r':
7200                         arglist |= CAM_ARG_CMD_OUT;
7201                         request_size = strtol(optarg, NULL, 0);
7202                         if (request_size <= 0) {
7203                                 warnx("invalid number of request bytes %d",
7204                                       request_size);
7205                                 error = 1;
7206                                 goto smpcmd_bailout;
7207                         }
7208                         hook.argc = argc - optind;
7209                         hook.argv = argv + optind;
7210                         hook.got = 0;
7211                         datastr = cget(&hook, NULL);
7212                         smp_request = (u_int8_t *)malloc(request_size);
7213                         if (smp_request == NULL) {
7214                                 warn("can't malloc memory for SMP request");
7215                                 error = 1;
7216                                 goto smpcmd_bailout;
7217                         }
7218                         bzero(smp_request, request_size);
7219                         /*
7220                          * If the user supplied "-" instead of a format, he
7221                          * wants the data to be read from stdin.
7222                          */
7223                         if ((datastr != NULL)
7224                          && (datastr[0] == '-'))
7225                                 fd_request = 1;
7226                         else
7227                                 buff_encode_visit(smp_request, request_size,
7228                                                   datastr,
7229                                                   iget, &hook);
7230                         optind += hook.got;
7231                         break;
7232                 default:
7233                         break;
7234                 }
7235         }
7236
7237         /*
7238          * If fd_data is set, and we're writing to the device, we need to
7239          * read the data the user wants written from stdin.
7240          */
7241         if ((fd_request == 1) && (arglist & CAM_ARG_CMD_OUT)) {
7242                 ssize_t amt_read;
7243                 int amt_to_read = request_size;
7244                 u_int8_t *buf_ptr = smp_request;
7245
7246                 for (amt_read = 0; amt_to_read > 0;
7247                      amt_read = read(STDIN_FILENO, buf_ptr, amt_to_read)) {
7248                         if (amt_read == -1) {
7249                                 warn("error reading data from stdin");
7250                                 error = 1;
7251                                 goto smpcmd_bailout;
7252                         }
7253                         amt_to_read -= amt_read;
7254                         buf_ptr += amt_read;
7255                 }
7256         }
7257
7258         if (((arglist & CAM_ARG_CMD_IN) == 0)
7259          || ((arglist & CAM_ARG_CMD_OUT) == 0)) {
7260                 warnx("%s: need both the request (-r) and response (-R) "
7261                       "arguments", __func__);
7262                 error = 1;
7263                 goto smpcmd_bailout;
7264         }
7265
7266         flags |= CAM_DEV_QFRZDIS;
7267
7268         cam_fill_smpio(&ccb->smpio,
7269                        /*retries*/ retry_count,
7270                        /*cbfcnp*/ NULL,
7271                        /*flags*/ flags,
7272                        /*smp_request*/ smp_request,
7273                        /*smp_request_len*/ request_size,
7274                        /*smp_response*/ smp_response,
7275                        /*smp_response_len*/ response_size,
7276                        /*timeout*/ timeout ? timeout : 5000);
7277
7278         ccb->smpio.flags = SMP_FLAG_NONE;
7279
7280         if (((retval = cam_send_ccb(device, ccb)) < 0)
7281          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
7282                 const char warnstr[] = "error sending command";
7283
7284                 if (retval < 0)
7285                         warn(warnstr);
7286                 else
7287                         warnx(warnstr);
7288
7289                 if (arglist & CAM_ARG_VERBOSE) {
7290                         cam_error_print(device, ccb, CAM_ESF_ALL,
7291                                         CAM_EPF_ALL, stderr);
7292                 }
7293         }
7294
7295         if (((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP)
7296          && (response_size > 0)) {
7297                 if (fd_response == 0) {
7298                         buff_decode_visit(smp_response, response_size,
7299                                           datastr, arg_put, NULL);
7300                         fprintf(stdout, "\n");
7301                 } else {
7302                         ssize_t amt_written;
7303                         int amt_to_write = response_size;
7304                         u_int8_t *buf_ptr = smp_response;
7305
7306                         for (amt_written = 0; (amt_to_write > 0) &&
7307                              (amt_written = write(STDOUT_FILENO, buf_ptr,
7308                                                   amt_to_write)) > 0;){
7309                                 amt_to_write -= amt_written;
7310                                 buf_ptr += amt_written;
7311                         }
7312                         if (amt_written == -1) {
7313                                 warn("error writing data to stdout");
7314                                 error = 1;
7315                                 goto smpcmd_bailout;
7316                         } else if ((amt_written == 0)
7317                                 && (amt_to_write > 0)) {
7318                                 warnx("only wrote %u bytes out of %u",
7319                                       response_size - amt_to_write,
7320                                       response_size);
7321                         }
7322                 }
7323         }
7324 smpcmd_bailout:
7325         if (ccb != NULL)
7326                 cam_freeccb(ccb);
7327
7328         if (smp_request != NULL)
7329                 free(smp_request);
7330
7331         if (smp_response != NULL)
7332                 free(smp_response);
7333
7334         return (error);
7335 }
7336
7337 static int
7338 smpreportgeneral(struct cam_device *device, int argc, char **argv,
7339                  char *combinedopt, int retry_count, int timeout)
7340 {
7341         union ccb *ccb;
7342         struct smp_report_general_request *request = NULL;
7343         struct smp_report_general_response *response = NULL;
7344         struct sbuf *sb = NULL;
7345         int error = 0;
7346         int c, long_response = 0;
7347         int retval;
7348
7349         /*
7350          * Note that at the moment we don't support sending SMP CCBs to
7351          * devices that aren't probed by CAM.
7352          */
7353         ccb = cam_getccb(device);
7354         if (ccb == NULL) {
7355                 warnx("%s: error allocating CCB", __func__);
7356                 return (1);
7357         }
7358
7359         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->smpio);
7360
7361         while ((c = getopt(argc, argv, combinedopt)) != -1) {
7362                 switch (c) {
7363                 case 'l':
7364                         long_response = 1;
7365                         break;
7366                 default:
7367                         break;
7368                 }
7369         }
7370         request = malloc(sizeof(*request));
7371         if (request == NULL) {
7372                 warn("%s: unable to allocate %zd bytes", __func__,
7373                      sizeof(*request));
7374                 error = 1;
7375                 goto bailout;
7376         }
7377
7378         response = malloc(sizeof(*response));
7379         if (response == NULL) {
7380                 warn("%s: unable to allocate %zd bytes", __func__,
7381                      sizeof(*response));
7382                 error = 1;
7383                 goto bailout;
7384         }
7385
7386 try_long:
7387         smp_report_general(&ccb->smpio,
7388                            retry_count,
7389                            /*cbfcnp*/ NULL,
7390                            request,
7391                            /*request_len*/ sizeof(*request),
7392                            (uint8_t *)response,
7393                            /*response_len*/ sizeof(*response),
7394                            /*long_response*/ long_response,
7395                            timeout);
7396
7397         if (((retval = cam_send_ccb(device, ccb)) < 0)
7398          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
7399                 const char warnstr[] = "error sending command";
7400
7401                 if (retval < 0)
7402                         warn(warnstr);
7403                 else
7404                         warnx(warnstr);
7405
7406                 if (arglist & CAM_ARG_VERBOSE) {
7407                         cam_error_print(device, ccb, CAM_ESF_ALL,
7408                                         CAM_EPF_ALL, stderr);
7409                 }
7410                 error = 1;
7411                 goto bailout;
7412         }
7413
7414         /*
7415          * If the device supports the long response bit, try again and see
7416          * if we can get all of the data.
7417          */
7418         if ((response->long_response & SMP_RG_LONG_RESPONSE)
7419          && (long_response == 0)) {
7420                 ccb->ccb_h.status = CAM_REQ_INPROG;
7421                 CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->smpio);
7422                 long_response = 1;
7423                 goto try_long;
7424         }
7425
7426         /*
7427          * XXX KDM detect and decode SMP errors here.
7428          */
7429         sb = sbuf_new_auto();
7430         if (sb == NULL) {
7431                 warnx("%s: error allocating sbuf", __func__);
7432                 goto bailout;
7433         }
7434
7435         smp_report_general_sbuf(response, sizeof(*response), sb);
7436
7437         if (sbuf_finish(sb) != 0) {
7438                 warnx("%s: sbuf_finish", __func__);
7439                 goto bailout;
7440         }
7441
7442         printf("%s", sbuf_data(sb));
7443
7444 bailout:
7445         if (ccb != NULL)
7446                 cam_freeccb(ccb);
7447
7448         if (request != NULL)
7449                 free(request);
7450
7451         if (response != NULL)
7452                 free(response);
7453
7454         if (sb != NULL)
7455                 sbuf_delete(sb);
7456
7457         return (error);
7458 }
7459
7460 static struct camcontrol_opts phy_ops[] = {
7461         {"nop", SMP_PC_PHY_OP_NOP, CAM_ARG_NONE, NULL},
7462         {"linkreset", SMP_PC_PHY_OP_LINK_RESET, CAM_ARG_NONE, NULL},
7463         {"hardreset", SMP_PC_PHY_OP_HARD_RESET, CAM_ARG_NONE, NULL},
7464         {"disable", SMP_PC_PHY_OP_DISABLE, CAM_ARG_NONE, NULL},
7465         {"clearerrlog", SMP_PC_PHY_OP_CLEAR_ERR_LOG, CAM_ARG_NONE, NULL},
7466         {"clearaffiliation", SMP_PC_PHY_OP_CLEAR_AFFILIATON, CAM_ARG_NONE,NULL},
7467         {"sataportsel", SMP_PC_PHY_OP_TRANS_SATA_PSS, CAM_ARG_NONE, NULL},
7468         {"clearitnl", SMP_PC_PHY_OP_CLEAR_STP_ITN_LS, CAM_ARG_NONE, NULL},
7469         {"setdevname", SMP_PC_PHY_OP_SET_ATT_DEV_NAME, CAM_ARG_NONE, NULL},
7470         {NULL, 0, 0, NULL}
7471 };
7472
7473 static int
7474 smpphycontrol(struct cam_device *device, int argc, char **argv,
7475               char *combinedopt, int retry_count, int timeout)
7476 {
7477         union ccb *ccb;
7478         struct smp_phy_control_request *request = NULL;
7479         struct smp_phy_control_response *response = NULL;
7480         int long_response = 0;
7481         int retval = 0;
7482         int phy = -1;
7483         uint32_t phy_operation = SMP_PC_PHY_OP_NOP;
7484         int phy_op_set = 0;
7485         uint64_t attached_dev_name = 0;
7486         int dev_name_set = 0;
7487         uint32_t min_plr = 0, max_plr = 0;
7488         uint32_t pp_timeout_val = 0;
7489         int slumber_partial = 0;
7490         int set_pp_timeout_val = 0;
7491         int c;
7492
7493         /*
7494          * Note that at the moment we don't support sending SMP CCBs to
7495          * devices that aren't probed by CAM.
7496          */
7497         ccb = cam_getccb(device);
7498         if (ccb == NULL) {
7499                 warnx("%s: error allocating CCB", __func__);
7500                 return (1);
7501         }
7502
7503         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->smpio);
7504
7505         while ((c = getopt(argc, argv, combinedopt)) != -1) {
7506                 switch (c) {
7507                 case 'a':
7508                 case 'A':
7509                 case 's':
7510                 case 'S': {
7511                         int enable = -1;
7512
7513                         if (strcasecmp(optarg, "enable") == 0)
7514                                 enable = 1;
7515                         else if (strcasecmp(optarg, "disable") == 0)
7516                                 enable = 2;
7517                         else {
7518                                 warnx("%s: Invalid argument %s", __func__,
7519                                       optarg);
7520                                 retval = 1;
7521                                 goto bailout;
7522                         }
7523                         switch (c) {
7524                         case 's':
7525                                 slumber_partial |= enable <<
7526                                                    SMP_PC_SAS_SLUMBER_SHIFT;
7527                                 break;
7528                         case 'S':
7529                                 slumber_partial |= enable <<
7530                                                    SMP_PC_SAS_PARTIAL_SHIFT;
7531                                 break;
7532                         case 'a':
7533                                 slumber_partial |= enable <<
7534                                                    SMP_PC_SATA_SLUMBER_SHIFT;
7535                                 break;
7536                         case 'A':
7537                                 slumber_partial |= enable <<
7538                                                    SMP_PC_SATA_PARTIAL_SHIFT;
7539                                 break;
7540                         default:
7541                                 warnx("%s: programmer error", __func__);
7542                                 retval = 1;
7543                                 goto bailout;
7544                                 break; /*NOTREACHED*/
7545                         }
7546                         break;
7547                 }
7548                 case 'd':
7549                         attached_dev_name = (uintmax_t)strtoumax(optarg,
7550                                                                  NULL,0);
7551                         dev_name_set = 1;
7552                         break;
7553                 case 'l':
7554                         long_response = 1;
7555                         break;
7556                 case 'm':
7557                         /*
7558                          * We don't do extensive checking here, so this
7559                          * will continue to work when new speeds come out.
7560                          */
7561                         min_plr = strtoul(optarg, NULL, 0);
7562                         if ((min_plr == 0)
7563                          || (min_plr > 0xf)) {
7564                                 warnx("%s: invalid link rate %x",
7565                                       __func__, min_plr);
7566                                 retval = 1;
7567                                 goto bailout;
7568                         }
7569                         break;
7570                 case 'M':
7571                         /*
7572                          * We don't do extensive checking here, so this
7573                          * will continue to work when new speeds come out.
7574                          */
7575                         max_plr = strtoul(optarg, NULL, 0);
7576                         if ((max_plr == 0)
7577                          || (max_plr > 0xf)) {
7578                                 warnx("%s: invalid link rate %x",
7579                                       __func__, max_plr);
7580                                 retval = 1;
7581                                 goto bailout;
7582                         }
7583                         break;
7584                 case 'o': {
7585                         camcontrol_optret optreturn;
7586                         cam_argmask argnums;
7587                         const char *subopt;
7588
7589                         if (phy_op_set != 0) {
7590                                 warnx("%s: only one phy operation argument "
7591                                       "(-o) allowed", __func__);
7592                                 retval = 1;
7593                                 goto bailout;
7594                         }
7595
7596                         phy_op_set = 1;
7597
7598                         /*
7599                          * Allow the user to specify the phy operation
7600                          * numerically, as well as with a name.  This will
7601                          * future-proof it a bit, so options that are added
7602                          * in future specs can be used.
7603                          */
7604                         if (isdigit(optarg[0])) {
7605                                 phy_operation = strtoul(optarg, NULL, 0);
7606                                 if ((phy_operation == 0)
7607                                  || (phy_operation > 0xff)) {
7608                                         warnx("%s: invalid phy operation %#x",
7609                                               __func__, phy_operation);
7610                                         retval = 1;
7611                                         goto bailout;
7612                                 }
7613                                 break;
7614                         }
7615                         optreturn = getoption(phy_ops, optarg, &phy_operation,
7616                                               &argnums, &subopt);
7617
7618                         if (optreturn == CC_OR_AMBIGUOUS) {
7619                                 warnx("%s: ambiguous option %s", __func__,
7620                                       optarg);
7621                                 usage(0);
7622                                 retval = 1;
7623                                 goto bailout;
7624                         } else if (optreturn == CC_OR_NOT_FOUND) {
7625                                 warnx("%s: option %s not found", __func__,
7626                                       optarg);
7627                                 usage(0);
7628                                 retval = 1;
7629                                 goto bailout;
7630                         }
7631                         break;
7632                 }
7633                 case 'p':
7634                         phy = atoi(optarg);
7635                         break;
7636                 case 'T':
7637                         pp_timeout_val = strtoul(optarg, NULL, 0);
7638                         if (pp_timeout_val > 15) {
7639                                 warnx("%s: invalid partial pathway timeout "
7640                                       "value %u, need a value less than 16",
7641                                       __func__, pp_timeout_val);
7642                                 retval = 1;
7643                                 goto bailout;
7644                         }
7645                         set_pp_timeout_val = 1;
7646                         break;
7647                 default:
7648                         break;
7649                 }
7650         }
7651
7652         if (phy == -1) {
7653                 warnx("%s: a PHY (-p phy) argument is required",__func__);
7654                 retval = 1;
7655                 goto bailout;
7656         }
7657
7658         if (((dev_name_set != 0)
7659           && (phy_operation != SMP_PC_PHY_OP_SET_ATT_DEV_NAME))
7660          || ((phy_operation == SMP_PC_PHY_OP_SET_ATT_DEV_NAME)
7661           && (dev_name_set == 0))) {
7662                 warnx("%s: -d name and -o setdevname arguments both "
7663                       "required to set device name", __func__);
7664                 retval = 1;
7665                 goto bailout;
7666         }
7667
7668         request = malloc(sizeof(*request));
7669         if (request == NULL) {
7670                 warn("%s: unable to allocate %zd bytes", __func__,
7671                      sizeof(*request));
7672                 retval = 1;
7673                 goto bailout;
7674         }
7675
7676         response = malloc(sizeof(*response));
7677         if (response == NULL) {
7678                 warn("%s: unable to allocate %zd bytes", __func__,
7679                      sizeof(*response));
7680                 retval = 1;
7681                 goto bailout;
7682         }
7683
7684         smp_phy_control(&ccb->smpio,
7685                         retry_count,
7686                         /*cbfcnp*/ NULL,
7687                         request,
7688                         sizeof(*request),
7689                         (uint8_t *)response,
7690                         sizeof(*response),
7691                         long_response,
7692                         /*expected_exp_change_count*/ 0,
7693                         phy,
7694                         phy_operation,
7695                         (set_pp_timeout_val != 0) ? 1 : 0,
7696                         attached_dev_name,
7697                         min_plr,
7698                         max_plr,
7699                         slumber_partial,
7700                         pp_timeout_val,
7701                         timeout);
7702
7703         if (((retval = cam_send_ccb(device, ccb)) < 0)
7704          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
7705                 const char warnstr[] = "error sending command";
7706
7707                 if (retval < 0)
7708                         warn(warnstr);
7709                 else
7710                         warnx(warnstr);
7711
7712                 if (arglist & CAM_ARG_VERBOSE) {
7713                         /*
7714                          * Use CAM_EPF_NORMAL so we only get one line of
7715                          * SMP command decoding.
7716                          */
7717                         cam_error_print(device, ccb, CAM_ESF_ALL,
7718                                         CAM_EPF_NORMAL, stderr);
7719                 }
7720                 retval = 1;
7721                 goto bailout;
7722         }
7723
7724         /* XXX KDM print out something here for success? */
7725 bailout:
7726         if (ccb != NULL)
7727                 cam_freeccb(ccb);
7728
7729         if (request != NULL)
7730                 free(request);
7731
7732         if (response != NULL)
7733                 free(response);
7734
7735         return (retval);
7736 }
7737
7738 static int
7739 smpmaninfo(struct cam_device *device, int argc, char **argv,
7740            char *combinedopt, int retry_count, int timeout)
7741 {
7742         union ccb *ccb;
7743         struct smp_report_manuf_info_request request;
7744         struct smp_report_manuf_info_response response;
7745         struct sbuf *sb = NULL;
7746         int long_response = 0;
7747         int retval = 0;
7748         int c;
7749
7750         /*
7751          * Note that at the moment we don't support sending SMP CCBs to
7752          * devices that aren't probed by CAM.
7753          */
7754         ccb = cam_getccb(device);
7755         if (ccb == NULL) {
7756                 warnx("%s: error allocating CCB", __func__);
7757                 return (1);
7758         }
7759
7760         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->smpio);
7761
7762         while ((c = getopt(argc, argv, combinedopt)) != -1) {
7763                 switch (c) {
7764                 case 'l':
7765                         long_response = 1;
7766                         break;
7767                 default:
7768                         break;
7769                 }
7770         }
7771         bzero(&request, sizeof(request));
7772         bzero(&response, sizeof(response));
7773
7774         smp_report_manuf_info(&ccb->smpio,
7775                               retry_count,
7776                               /*cbfcnp*/ NULL,
7777                               &request,
7778                               sizeof(request),
7779                               (uint8_t *)&response,
7780                               sizeof(response),
7781                               long_response,
7782                               timeout);
7783
7784         if (((retval = cam_send_ccb(device, ccb)) < 0)
7785          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
7786                 const char warnstr[] = "error sending command";
7787
7788                 if (retval < 0)
7789                         warn(warnstr);
7790                 else
7791                         warnx(warnstr);
7792
7793                 if (arglist & CAM_ARG_VERBOSE) {
7794                         cam_error_print(device, ccb, CAM_ESF_ALL,
7795                                         CAM_EPF_ALL, stderr);
7796                 }
7797                 retval = 1;
7798                 goto bailout;
7799         }
7800
7801         sb = sbuf_new_auto();
7802         if (sb == NULL) {
7803                 warnx("%s: error allocating sbuf", __func__);
7804                 goto bailout;
7805         }
7806
7807         smp_report_manuf_info_sbuf(&response, sizeof(response), sb);
7808
7809         if (sbuf_finish(sb) != 0) {
7810                 warnx("%s: sbuf_finish", __func__);
7811                 goto bailout;
7812         }
7813
7814         printf("%s", sbuf_data(sb));
7815
7816 bailout:
7817
7818         if (ccb != NULL)
7819                 cam_freeccb(ccb);
7820
7821         if (sb != NULL)
7822                 sbuf_delete(sb);
7823
7824         return (retval);
7825 }
7826
7827 static int
7828 getdevid(struct cam_devitem *item)
7829 {
7830         int retval = 0;
7831         union ccb *ccb = NULL;
7832
7833         struct cam_device *dev;
7834
7835         dev = cam_open_btl(item->dev_match.path_id,
7836                            item->dev_match.target_id,
7837                            item->dev_match.target_lun, O_RDWR, NULL);
7838
7839         if (dev == NULL) {
7840                 warnx("%s", cam_errbuf);
7841                 retval = 1;
7842                 goto bailout;
7843         }
7844
7845         item->device_id_len = 0;
7846
7847         ccb = cam_getccb(dev);
7848         if (ccb == NULL) {
7849                 warnx("%s: error allocating CCB", __func__);
7850                 retval = 1;
7851                 goto bailout;
7852         }
7853
7854         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->cdai);
7855
7856         /*
7857          * On the first try, we just probe for the size of the data, and
7858          * then allocate that much memory and try again.
7859          */
7860 retry:
7861         ccb->ccb_h.func_code = XPT_DEV_ADVINFO;
7862         ccb->ccb_h.flags = CAM_DIR_IN;
7863         ccb->cdai.flags = CDAI_FLAG_NONE;
7864         ccb->cdai.buftype = CDAI_TYPE_SCSI_DEVID;
7865         ccb->cdai.bufsiz = item->device_id_len;
7866         if (item->device_id_len != 0)
7867                 ccb->cdai.buf = (uint8_t *)item->device_id;
7868
7869         if (cam_send_ccb(dev, ccb) < 0) {
7870                 warn("%s: error sending XPT_GDEV_ADVINFO CCB", __func__);
7871                 retval = 1;
7872                 goto bailout;
7873         }
7874
7875         if (ccb->ccb_h.status != CAM_REQ_CMP) {
7876                 warnx("%s: CAM status %#x", __func__, ccb->ccb_h.status);
7877                 retval = 1;
7878                 goto bailout;
7879         }
7880
7881         if (item->device_id_len == 0) {
7882                 /*
7883                  * This is our first time through.  Allocate the buffer,
7884                  * and then go back to get the data.
7885                  */
7886                 if (ccb->cdai.provsiz == 0) {
7887                         warnx("%s: invalid .provsiz field returned with "
7888                              "XPT_GDEV_ADVINFO CCB", __func__);
7889                         retval = 1;
7890                         goto bailout;
7891                 }
7892                 item->device_id_len = ccb->cdai.provsiz;
7893                 item->device_id = malloc(item->device_id_len);
7894                 if (item->device_id == NULL) {
7895                         warn("%s: unable to allocate %d bytes", __func__,
7896                              item->device_id_len);
7897                         retval = 1;
7898                         goto bailout;
7899                 }
7900                 ccb->ccb_h.status = CAM_REQ_INPROG;
7901                 goto retry;
7902         }
7903
7904 bailout:
7905         if (dev != NULL)
7906                 cam_close_device(dev);
7907
7908         if (ccb != NULL)
7909                 cam_freeccb(ccb);
7910
7911         return (retval);
7912 }
7913
7914 /*
7915  * XXX KDM merge this code with getdevtree()?
7916  */
7917 static int
7918 buildbusdevlist(struct cam_devlist *devlist)
7919 {
7920         union ccb ccb;
7921         int bufsize, fd = -1;
7922         struct dev_match_pattern *patterns;
7923         struct cam_devitem *item = NULL;
7924         int skip_device = 0;
7925         int retval = 0;
7926
7927         if ((fd = open(XPT_DEVICE, O_RDWR)) == -1) {
7928                 warn("couldn't open %s", XPT_DEVICE);
7929                 return(1);
7930         }
7931
7932         bzero(&ccb, sizeof(union ccb));
7933
7934         ccb.ccb_h.path_id = CAM_XPT_PATH_ID;
7935         ccb.ccb_h.target_id = CAM_TARGET_WILDCARD;
7936         ccb.ccb_h.target_lun = CAM_LUN_WILDCARD;
7937
7938         ccb.ccb_h.func_code = XPT_DEV_MATCH;
7939         bufsize = sizeof(struct dev_match_result) * 100;
7940         ccb.cdm.match_buf_len = bufsize;
7941         ccb.cdm.matches = (struct dev_match_result *)malloc(bufsize);
7942         if (ccb.cdm.matches == NULL) {
7943                 warnx("can't malloc memory for matches");
7944                 close(fd);
7945                 return(1);
7946         }
7947         ccb.cdm.num_matches = 0;
7948         ccb.cdm.num_patterns = 2;
7949         ccb.cdm.pattern_buf_len = sizeof(struct dev_match_pattern) *
7950                 ccb.cdm.num_patterns;
7951
7952         patterns = (struct dev_match_pattern *)malloc(ccb.cdm.pattern_buf_len);
7953         if (patterns == NULL) {
7954                 warnx("can't malloc memory for patterns");
7955                 retval = 1;
7956                 goto bailout;
7957         }
7958
7959         ccb.cdm.patterns = patterns;
7960         bzero(patterns, ccb.cdm.pattern_buf_len);
7961
7962         patterns[0].type = DEV_MATCH_DEVICE;
7963         patterns[0].pattern.device_pattern.flags = DEV_MATCH_PATH;
7964         patterns[0].pattern.device_pattern.path_id = devlist->path_id;
7965         patterns[1].type = DEV_MATCH_PERIPH;
7966         patterns[1].pattern.periph_pattern.flags = PERIPH_MATCH_PATH;
7967         patterns[1].pattern.periph_pattern.path_id = devlist->path_id;
7968
7969         /*
7970          * We do the ioctl multiple times if necessary, in case there are
7971          * more than 100 nodes in the EDT.
7972          */
7973         do {
7974                 unsigned int i;
7975
7976                 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
7977                         warn("error sending CAMIOCOMMAND ioctl");
7978                         retval = 1;
7979                         goto bailout;
7980                 }
7981
7982                 if ((ccb.ccb_h.status != CAM_REQ_CMP)
7983                  || ((ccb.cdm.status != CAM_DEV_MATCH_LAST)
7984                     && (ccb.cdm.status != CAM_DEV_MATCH_MORE))) {
7985                         warnx("got CAM error %#x, CDM error %d\n",
7986                               ccb.ccb_h.status, ccb.cdm.status);
7987                         retval = 1;
7988                         goto bailout;
7989                 }
7990
7991                 for (i = 0; i < ccb.cdm.num_matches; i++) {
7992                         switch (ccb.cdm.matches[i].type) {
7993                         case DEV_MATCH_DEVICE: {
7994                                 struct device_match_result *dev_result;
7995
7996                                 dev_result =
7997                                      &ccb.cdm.matches[i].result.device_result;
7998
7999                                 if (dev_result->flags &
8000                                     DEV_RESULT_UNCONFIGURED) {
8001                                         skip_device = 1;
8002                                         break;
8003                                 } else
8004                                         skip_device = 0;
8005
8006                                 item = malloc(sizeof(*item));
8007                                 if (item == NULL) {
8008                                         warn("%s: unable to allocate %zd bytes",
8009                                              __func__, sizeof(*item));
8010                                         retval = 1;
8011                                         goto bailout;
8012                                 }
8013                                 bzero(item, sizeof(*item));
8014                                 bcopy(dev_result, &item->dev_match,
8015                                       sizeof(*dev_result));
8016                                 STAILQ_INSERT_TAIL(&devlist->dev_queue, item,
8017                                                    links);
8018
8019                                 if (getdevid(item) != 0) {
8020                                         retval = 1;
8021                                         goto bailout;
8022                                 }
8023                                 break;
8024                         }
8025                         case DEV_MATCH_PERIPH: {
8026                                 struct periph_match_result *periph_result;
8027
8028                                 periph_result =
8029                                       &ccb.cdm.matches[i].result.periph_result;
8030
8031                                 if (skip_device != 0)
8032                                         break;
8033                                 item->num_periphs++;
8034                                 item->periph_matches = realloc(
8035                                         item->periph_matches,
8036                                         item->num_periphs *
8037                                         sizeof(struct periph_match_result));
8038                                 if (item->periph_matches == NULL) {
8039                                         warn("%s: error allocating periph "
8040                                              "list", __func__);
8041                                         retval = 1;
8042                                         goto bailout;
8043                                 }
8044                                 bcopy(periph_result, &item->periph_matches[
8045                                       item->num_periphs - 1],
8046                                       sizeof(*periph_result));
8047                                 break;
8048                         }
8049                         default:
8050                                 fprintf(stderr, "%s: unexpected match "
8051                                         "type %d\n", __func__,
8052                                         ccb.cdm.matches[i].type);
8053                                 retval = 1;
8054                                 goto bailout;
8055                                 break; /*NOTREACHED*/
8056                         }
8057                 }
8058         } while ((ccb.ccb_h.status == CAM_REQ_CMP)
8059                 && (ccb.cdm.status == CAM_DEV_MATCH_MORE));
8060 bailout:
8061
8062         if (fd != -1)
8063                 close(fd);
8064
8065         free(patterns);
8066
8067         free(ccb.cdm.matches);
8068
8069         if (retval != 0)
8070                 freebusdevlist(devlist);
8071
8072         return (retval);
8073 }
8074
8075 static void
8076 freebusdevlist(struct cam_devlist *devlist)
8077 {
8078         struct cam_devitem *item, *item2;
8079
8080         STAILQ_FOREACH_SAFE(item, &devlist->dev_queue, links, item2) {
8081                 STAILQ_REMOVE(&devlist->dev_queue, item, cam_devitem,
8082                               links);
8083                 free(item->device_id);
8084                 free(item->periph_matches);
8085                 free(item);
8086         }
8087 }
8088
8089 static struct cam_devitem *
8090 findsasdevice(struct cam_devlist *devlist, uint64_t sasaddr)
8091 {
8092         struct cam_devitem *item;
8093
8094         STAILQ_FOREACH(item, &devlist->dev_queue, links) {
8095                 struct scsi_vpd_id_descriptor *idd;
8096
8097                 /*
8098                  * XXX KDM look for LUN IDs as well?
8099                  */
8100                 idd = scsi_get_devid(item->device_id,
8101                                            item->device_id_len,
8102                                            scsi_devid_is_sas_target);
8103                 if (idd == NULL)
8104                         continue;
8105
8106                 if (scsi_8btou64(idd->identifier) == sasaddr)
8107                         return (item);
8108         }
8109
8110         return (NULL);
8111 }
8112
8113 static int
8114 smpphylist(struct cam_device *device, int argc, char **argv,
8115            char *combinedopt, int retry_count, int timeout)
8116 {
8117         struct smp_report_general_request *rgrequest = NULL;
8118         struct smp_report_general_response *rgresponse = NULL;
8119         struct smp_discover_request *disrequest = NULL;
8120         struct smp_discover_response *disresponse = NULL;
8121         struct cam_devlist devlist;
8122         union ccb *ccb;
8123         int long_response = 0;
8124         int num_phys = 0;
8125         int quiet = 0;
8126         int retval;
8127         int i, c;
8128
8129         /*
8130          * Note that at the moment we don't support sending SMP CCBs to
8131          * devices that aren't probed by CAM.
8132          */
8133         ccb = cam_getccb(device);
8134         if (ccb == NULL) {
8135                 warnx("%s: error allocating CCB", __func__);
8136                 return (1);
8137         }
8138
8139         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->smpio);
8140         STAILQ_INIT(&devlist.dev_queue);
8141
8142         rgrequest = malloc(sizeof(*rgrequest));
8143         if (rgrequest == NULL) {
8144                 warn("%s: unable to allocate %zd bytes", __func__,
8145                      sizeof(*rgrequest));
8146                 retval = 1;
8147                 goto bailout;
8148         }
8149
8150         rgresponse = malloc(sizeof(*rgresponse));
8151         if (rgresponse == NULL) {
8152                 warn("%s: unable to allocate %zd bytes", __func__,
8153                      sizeof(*rgresponse));
8154                 retval = 1;
8155                 goto bailout;
8156         }
8157
8158         while ((c = getopt(argc, argv, combinedopt)) != -1) {
8159                 switch (c) {
8160                 case 'l':
8161                         long_response = 1;
8162                         break;
8163                 case 'q':
8164                         quiet = 1;
8165                         break;
8166                 default:
8167                         break;
8168                 }
8169         }
8170
8171         smp_report_general(&ccb->smpio,
8172                            retry_count,
8173                            /*cbfcnp*/ NULL,
8174                            rgrequest,
8175                            /*request_len*/ sizeof(*rgrequest),
8176                            (uint8_t *)rgresponse,
8177                            /*response_len*/ sizeof(*rgresponse),
8178                            /*long_response*/ long_response,
8179                            timeout);
8180
8181         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
8182
8183         if (((retval = cam_send_ccb(device, ccb)) < 0)
8184          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
8185                 const char warnstr[] = "error sending command";
8186
8187                 if (retval < 0)
8188                         warn(warnstr);
8189                 else
8190                         warnx(warnstr);
8191
8192                 if (arglist & CAM_ARG_VERBOSE) {
8193                         cam_error_print(device, ccb, CAM_ESF_ALL,
8194                                         CAM_EPF_ALL, stderr);
8195                 }
8196                 retval = 1;
8197                 goto bailout;
8198         }
8199
8200         num_phys = rgresponse->num_phys;
8201
8202         if (num_phys == 0) {
8203                 if (quiet == 0)
8204                         fprintf(stdout, "%s: No Phys reported\n", __func__);
8205                 retval = 1;
8206                 goto bailout;
8207         }
8208
8209         devlist.path_id = device->path_id;
8210
8211         retval = buildbusdevlist(&devlist);
8212         if (retval != 0)
8213                 goto bailout;
8214
8215         if (quiet == 0) {
8216                 fprintf(stdout, "%d PHYs:\n", num_phys);
8217                 fprintf(stdout, "PHY  Attached SAS Address\n");
8218         }
8219
8220         disrequest = malloc(sizeof(*disrequest));
8221         if (disrequest == NULL) {
8222                 warn("%s: unable to allocate %zd bytes", __func__,
8223                      sizeof(*disrequest));
8224                 retval = 1;
8225                 goto bailout;
8226         }
8227
8228         disresponse = malloc(sizeof(*disresponse));
8229         if (disresponse == NULL) {
8230                 warn("%s: unable to allocate %zd bytes", __func__,
8231                      sizeof(*disresponse));
8232                 retval = 1;
8233                 goto bailout;
8234         }
8235
8236         for (i = 0; i < num_phys; i++) {
8237                 struct cam_devitem *item;
8238                 struct device_match_result *dev_match;
8239                 char vendor[16], product[48], revision[16];
8240                 char tmpstr[256];
8241                 int j;
8242
8243                 CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->smpio);
8244
8245                 ccb->ccb_h.status = CAM_REQ_INPROG;
8246                 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
8247
8248                 smp_discover(&ccb->smpio,
8249                              retry_count,
8250                              /*cbfcnp*/ NULL,
8251                              disrequest,
8252                              sizeof(*disrequest),
8253                              (uint8_t *)disresponse,
8254                              sizeof(*disresponse),
8255                              long_response,
8256                              /*ignore_zone_group*/ 0,
8257                              /*phy*/ i,
8258                              timeout);
8259
8260                 if (((retval = cam_send_ccb(device, ccb)) < 0)
8261                  || (((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)
8262                   && (disresponse->function_result != SMP_FR_PHY_VACANT))) {
8263                         const char warnstr[] = "error sending command";
8264
8265                         if (retval < 0)
8266                                 warn(warnstr);
8267                         else
8268                                 warnx(warnstr);
8269
8270                         if (arglist & CAM_ARG_VERBOSE) {
8271                                 cam_error_print(device, ccb, CAM_ESF_ALL,
8272                                                 CAM_EPF_ALL, stderr);
8273                         }
8274                         retval = 1;
8275                         goto bailout;
8276                 }
8277
8278                 if (disresponse->function_result == SMP_FR_PHY_VACANT) {
8279                         if (quiet == 0)
8280                                 fprintf(stdout, "%3d  <vacant>\n", i);
8281                         continue;
8282                 }
8283
8284                 if (disresponse->attached_device == SMP_DIS_AD_TYPE_NONE) {
8285                         item = NULL;
8286                 } else {
8287                         item = findsasdevice(&devlist,
8288                             scsi_8btou64(disresponse->attached_sas_address));
8289                 }
8290
8291                 if ((quiet == 0)
8292                  || (item != NULL)) {
8293                         fprintf(stdout, "%3d  0x%016jx", i,
8294                                 (uintmax_t)scsi_8btou64(
8295                                 disresponse->attached_sas_address));
8296                         if (item == NULL) {
8297                                 fprintf(stdout, "\n");
8298                                 continue;
8299                         }
8300                 } else if (quiet != 0)
8301                         continue;
8302
8303                 dev_match = &item->dev_match;
8304
8305                 if (dev_match->protocol == PROTO_SCSI) {
8306                         cam_strvis(vendor, dev_match->inq_data.vendor,
8307                                    sizeof(dev_match->inq_data.vendor),
8308                                    sizeof(vendor));
8309                         cam_strvis(product, dev_match->inq_data.product,
8310                                    sizeof(dev_match->inq_data.product),
8311                                    sizeof(product));
8312                         cam_strvis(revision, dev_match->inq_data.revision,
8313                                    sizeof(dev_match->inq_data.revision),
8314                                    sizeof(revision));
8315                         sprintf(tmpstr, "<%s %s %s>", vendor, product,
8316                                 revision);
8317                 } else if ((dev_match->protocol == PROTO_ATA)
8318                         || (dev_match->protocol == PROTO_SATAPM)) {
8319                         cam_strvis(product, dev_match->ident_data.model,
8320                                    sizeof(dev_match->ident_data.model),
8321                                    sizeof(product));
8322                         cam_strvis(revision, dev_match->ident_data.revision,
8323                                    sizeof(dev_match->ident_data.revision),
8324                                    sizeof(revision));
8325                         sprintf(tmpstr, "<%s %s>", product, revision);
8326                 } else {
8327                         sprintf(tmpstr, "<>");
8328                 }
8329                 fprintf(stdout, "   %-33s ", tmpstr);
8330
8331                 /*
8332                  * If we have 0 periphs, that's a bug...
8333                  */
8334                 if (item->num_periphs == 0) {
8335                         fprintf(stdout, "\n");
8336                         continue;
8337                 }
8338
8339                 fprintf(stdout, "(");
8340                 for (j = 0; j < item->num_periphs; j++) {
8341                         if (j > 0)
8342                                 fprintf(stdout, ",");
8343
8344                         fprintf(stdout, "%s%d",
8345                                 item->periph_matches[j].periph_name,
8346                                 item->periph_matches[j].unit_number);
8347
8348                 }
8349                 fprintf(stdout, ")\n");
8350         }
8351 bailout:
8352         if (ccb != NULL)
8353                 cam_freeccb(ccb);
8354
8355         free(rgrequest);
8356
8357         free(rgresponse);
8358
8359         free(disrequest);
8360
8361         free(disresponse);
8362
8363         freebusdevlist(&devlist);
8364
8365         return (retval);
8366 }
8367
8368 static int
8369 atapm(struct cam_device *device, int argc, char **argv,
8370                  char *combinedopt, int retry_count, int timeout)
8371 {
8372         union ccb *ccb;
8373         int retval = 0;
8374         int t = -1;
8375         int c;
8376         u_char cmd, sc;
8377
8378         ccb = cam_getccb(device);
8379
8380         if (ccb == NULL) {
8381                 warnx("%s: error allocating ccb", __func__);
8382                 return (1);
8383         }
8384
8385         while ((c = getopt(argc, argv, combinedopt)) != -1) {
8386                 switch (c) {
8387                 case 't':
8388                         t = atoi(optarg);
8389                         break;
8390                 default:
8391                         break;
8392                 }
8393         }
8394         if (strcmp(argv[1], "idle") == 0) {
8395                 if (t == -1)
8396                         cmd = ATA_IDLE_IMMEDIATE;
8397                 else
8398                         cmd = ATA_IDLE_CMD;
8399         } else if (strcmp(argv[1], "standby") == 0) {
8400                 if (t == -1)
8401                         cmd = ATA_STANDBY_IMMEDIATE;
8402                 else
8403                         cmd = ATA_STANDBY_CMD;
8404         } else {
8405                 cmd = ATA_SLEEP;
8406                 t = -1;
8407         }
8408
8409         if (t < 0)
8410                 sc = 0;
8411         else if (t <= (240 * 5))
8412                 sc = (t + 4) / 5;
8413         else if (t <= (252 * 5))
8414                 /* special encoding for 21 minutes */
8415                 sc = 252;
8416         else if (t <= (11 * 30 * 60))
8417                 sc = (t - 1) / (30 * 60) + 241;
8418         else
8419                 sc = 253;
8420
8421         retval = ata_do_28bit_cmd(device,
8422             ccb,
8423             /*retries*/retry_count,
8424             /*flags*/CAM_DIR_NONE,
8425             /*protocol*/AP_PROTO_NON_DATA,
8426             /*tag_action*/MSG_SIMPLE_Q_TAG,
8427             /*command*/cmd,
8428             /*features*/0,
8429             /*lba*/0,
8430             /*sector_count*/sc,
8431             /*data_ptr*/NULL,
8432             /*dxfer_len*/0,
8433             /*timeout*/timeout ? timeout : 30 * 1000,
8434             /*quiet*/1);
8435
8436         cam_freeccb(ccb);
8437         return (retval);
8438 }
8439
8440 static int
8441 ataaxm(struct cam_device *device, int argc, char **argv,
8442                  char *combinedopt, int retry_count, int timeout)
8443 {
8444         union ccb *ccb;
8445         int retval = 0;
8446         int l = -1;
8447         int c;
8448         u_char cmd, sc;
8449
8450         ccb = cam_getccb(device);
8451
8452         if (ccb == NULL) {
8453                 warnx("%s: error allocating ccb", __func__);
8454                 return (1);
8455         }
8456
8457         while ((c = getopt(argc, argv, combinedopt)) != -1) {
8458                 switch (c) {
8459                 case 'l':
8460                         l = atoi(optarg);
8461                         break;
8462                 default:
8463                         break;
8464                 }
8465         }
8466         sc = 0;
8467         if (strcmp(argv[1], "apm") == 0) {
8468                 if (l == -1)
8469                         cmd = 0x85;
8470                 else {
8471                         cmd = 0x05;
8472                         sc = l;
8473                 }
8474         } else /* aam */ {
8475                 if (l == -1)
8476                         cmd = 0xC2;
8477                 else {
8478                         cmd = 0x42;
8479                         sc = l;
8480                 }
8481         }
8482
8483         retval = ata_do_28bit_cmd(device,
8484             ccb,
8485             /*retries*/retry_count,
8486             /*flags*/CAM_DIR_NONE,
8487             /*protocol*/AP_PROTO_NON_DATA,
8488             /*tag_action*/MSG_SIMPLE_Q_TAG,
8489             /*command*/ATA_SETFEATURES,
8490             /*features*/cmd,
8491             /*lba*/0,
8492             /*sector_count*/sc,
8493             /*data_ptr*/NULL,
8494             /*dxfer_len*/0,
8495             /*timeout*/timeout ? timeout : 30 * 1000,
8496             /*quiet*/1);
8497
8498         cam_freeccb(ccb);
8499         return (retval);
8500 }
8501
8502 int
8503 scsigetopcodes(struct cam_device *device, int opcode_set, int opcode,
8504                int show_sa_errors, int sa_set, int service_action,
8505                int timeout_desc, int task_attr, int retry_count, int timeout,
8506                int verbosemode, uint32_t *fill_len, uint8_t **data_ptr)
8507 {
8508         union ccb *ccb = NULL;
8509         uint8_t *buf = NULL;
8510         uint32_t alloc_len = 0, num_opcodes;
8511         uint32_t valid_len = 0;
8512         uint32_t avail_len = 0;
8513         struct scsi_report_supported_opcodes_all *all_hdr;
8514         struct scsi_report_supported_opcodes_one *one;
8515         int options = 0;
8516         int retval = 0;
8517
8518         /*
8519          * Make it clear that we haven't yet allocated or filled anything.
8520          */
8521         *fill_len = 0;
8522         *data_ptr = NULL;
8523
8524         ccb = cam_getccb(device);
8525         if (ccb == NULL) {
8526                 warnx("couldn't allocate CCB");
8527                 retval = 1;
8528                 goto bailout;
8529         }
8530
8531         /* cam_getccb cleans up the header, caller has to zero the payload */
8532         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
8533
8534         if (opcode_set != 0) {
8535                 options |= RSO_OPTIONS_OC;
8536                 num_opcodes = 1;
8537                 alloc_len = sizeof(*one) + CAM_MAX_CDBLEN;
8538         } else {
8539                 num_opcodes = 256;
8540                 alloc_len = sizeof(*all_hdr) + (num_opcodes *
8541                     sizeof(struct scsi_report_supported_opcodes_descr));
8542         }
8543
8544         if (timeout_desc != 0) {
8545                 options |= RSO_RCTD;
8546                 alloc_len += num_opcodes *
8547                     sizeof(struct scsi_report_supported_opcodes_timeout);
8548         }
8549
8550         if (sa_set != 0) {
8551                 options |= RSO_OPTIONS_OC_SA;
8552                 if (show_sa_errors != 0)
8553                         options &= ~RSO_OPTIONS_OC;
8554         }
8555
8556 retry_alloc:
8557         if (buf != NULL) {
8558                 free(buf);
8559                 buf = NULL;
8560         }
8561
8562         buf = malloc(alloc_len);
8563         if (buf == NULL) {
8564                 warn("Unable to allocate %u bytes", alloc_len);
8565                 retval = 1;
8566                 goto bailout;
8567         }
8568         bzero(buf, alloc_len);
8569
8570         scsi_report_supported_opcodes(&ccb->csio,
8571                                       /*retries*/ retry_count,
8572                                       /*cbfcnp*/ NULL,
8573                                       /*tag_action*/ task_attr,
8574                                       /*options*/ options,
8575                                       /*req_opcode*/ opcode,
8576                                       /*req_service_action*/ service_action,
8577                                       /*data_ptr*/ buf,
8578                                       /*dxfer_len*/ alloc_len,
8579                                       /*sense_len*/ SSD_FULL_SIZE,
8580                                       /*timeout*/ timeout ? timeout : 10000);
8581
8582         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
8583
8584         if (retry_count != 0)
8585                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
8586
8587         if (cam_send_ccb(device, ccb) < 0) {
8588                 perror("error sending REPORT SUPPORTED OPERATION CODES");
8589                 retval = 1;
8590                 goto bailout;
8591         }
8592
8593         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
8594                 if (verbosemode != 0)
8595                         cam_error_print(device, ccb, CAM_ESF_ALL,
8596                                         CAM_EPF_ALL, stderr);
8597
8598                 retval = 1;
8599                 goto bailout;
8600         }
8601
8602         valid_len = ccb->csio.dxfer_len - ccb->csio.resid;
8603
8604         if (((options & RSO_OPTIONS_MASK) == RSO_OPTIONS_ALL)
8605          && (valid_len >= sizeof(*all_hdr))) {
8606                 all_hdr = (struct scsi_report_supported_opcodes_all *)buf;
8607                 avail_len = scsi_4btoul(all_hdr->length) + sizeof(*all_hdr);
8608         } else if (((options & RSO_OPTIONS_MASK) != RSO_OPTIONS_ALL)
8609                 && (valid_len >= sizeof(*one))) {
8610                 uint32_t cdb_length;
8611
8612                 one = (struct scsi_report_supported_opcodes_one *)buf;
8613                 cdb_length = scsi_2btoul(one->cdb_length);
8614                 avail_len = sizeof(*one) + cdb_length;
8615                 if (one->support & RSO_ONE_CTDP) {
8616                         struct scsi_report_supported_opcodes_timeout *td;
8617
8618                         td = (struct scsi_report_supported_opcodes_timeout *)
8619                             &buf[avail_len];
8620                         if (valid_len >= (avail_len + sizeof(td->length))) {
8621                                 avail_len += scsi_2btoul(td->length) +
8622                                     sizeof(td->length);
8623                         } else {
8624                                 avail_len += sizeof(*td);
8625                         }
8626                 }
8627         }
8628
8629         /*
8630          * avail_len could be zero if we didn't get enough data back from
8631          * thet target to determine
8632          */
8633         if ((avail_len != 0)
8634          && (avail_len > valid_len)) {
8635                 alloc_len = avail_len;
8636                 goto retry_alloc;
8637         }
8638
8639         *fill_len = valid_len;
8640         *data_ptr = buf;
8641 bailout:
8642         if (retval != 0)
8643                 free(buf);
8644
8645         cam_freeccb(ccb);
8646
8647         return (retval);
8648 }
8649
8650 static int
8651 scsiprintoneopcode(struct cam_device *device, int req_opcode, int sa_set,
8652                    int req_sa, uint8_t *buf, uint32_t valid_len)
8653 {
8654         struct scsi_report_supported_opcodes_one *one;
8655         struct scsi_report_supported_opcodes_timeout *td;
8656         uint32_t cdb_len = 0, td_len = 0;
8657         const char *op_desc = NULL;
8658         unsigned int i;
8659         int retval = 0;
8660
8661         one = (struct scsi_report_supported_opcodes_one *)buf;
8662
8663         /*
8664          * If we don't have the full single opcode descriptor, no point in
8665          * continuing.
8666          */
8667         if (valid_len < __offsetof(struct scsi_report_supported_opcodes_one,
8668             cdb_length)) {
8669                 warnx("Only %u bytes returned, not enough to verify support",
8670                       valid_len);
8671                 retval = 1;
8672                 goto bailout;
8673         }
8674
8675         op_desc = scsi_op_desc(req_opcode, &device->inq_data);
8676
8677         printf("%s (0x%02x)", op_desc != NULL ? op_desc : "UNKNOWN",
8678                req_opcode);
8679         if (sa_set != 0)
8680                 printf(", SA 0x%x", req_sa);
8681         printf(": ");
8682
8683         switch (one->support & RSO_ONE_SUP_MASK) {
8684         case RSO_ONE_SUP_UNAVAIL:
8685                 printf("No command support information currently available\n");
8686                 break;
8687         case RSO_ONE_SUP_NOT_SUP:
8688                 printf("Command not supported\n");
8689                 retval = 1;
8690                 goto bailout;
8691                 break; /*NOTREACHED*/
8692         case RSO_ONE_SUP_AVAIL:
8693                 printf("Command is supported, complies with a SCSI standard\n");
8694                 break;
8695         case RSO_ONE_SUP_VENDOR:
8696                 printf("Command is supported, vendor-specific "
8697                        "implementation\n");
8698                 break;
8699         default:
8700                 printf("Unknown command support flags 0x%#x\n",
8701                        one->support & RSO_ONE_SUP_MASK);
8702                 break;
8703         }
8704
8705         /*
8706          * If we don't have the CDB length, it isn't exactly an error, the
8707          * command probably isn't supported.
8708          */
8709         if (valid_len < __offsetof(struct scsi_report_supported_opcodes_one,
8710             cdb_usage))
8711                 goto bailout;
8712
8713         cdb_len = scsi_2btoul(one->cdb_length);
8714
8715         /*
8716          * If our valid data doesn't include the full reported length,
8717          * return.  The caller should have detected this and adjusted his
8718          * allocation length to get all of the available data.
8719          */
8720         if (valid_len < sizeof(*one) + cdb_len) {
8721                 retval = 1;
8722                 goto bailout;
8723         }
8724
8725         /*
8726          * If all we have is the opcode, there is no point in printing out
8727          * the usage bitmap.
8728          */
8729         if (cdb_len <= 1) {
8730                 retval = 1;
8731                 goto bailout;
8732         }
8733
8734         printf("CDB usage bitmap:");
8735         for (i = 0; i < cdb_len; i++) {
8736                 printf(" %02x", one->cdb_usage[i]);
8737         }
8738         printf("\n");
8739
8740         /*
8741          * If we don't have a timeout descriptor, we're done.
8742          */
8743         if ((one->support & RSO_ONE_CTDP) == 0)
8744                 goto bailout;
8745
8746         /*
8747          * If we don't have enough valid length to include the timeout
8748          * descriptor length, we're done.
8749          */
8750         if (valid_len < (sizeof(*one) + cdb_len + sizeof(td->length)))
8751                 goto bailout;
8752
8753         td = (struct scsi_report_supported_opcodes_timeout *)
8754             &buf[sizeof(*one) + cdb_len];
8755         td_len = scsi_2btoul(td->length);
8756         td_len += sizeof(td->length);
8757
8758         /*
8759          * If we don't have the full timeout descriptor, we're done.
8760          */
8761         if (td_len < sizeof(*td))
8762                 goto bailout;
8763
8764         /*
8765          * If we don't have enough valid length to contain the full timeout
8766          * descriptor, we're done.
8767          */
8768         if (valid_len < (sizeof(*one) + cdb_len + td_len))
8769                 goto bailout;
8770
8771         printf("Timeout information:\n");
8772         printf("Command-specific:    0x%02x\n", td->cmd_specific);
8773         printf("Nominal timeout:     %u seconds\n",
8774                scsi_4btoul(td->nominal_time));
8775         printf("Recommended timeout: %u seconds\n",
8776                scsi_4btoul(td->recommended_time));
8777
8778 bailout:
8779         return (retval);
8780 }
8781
8782 static int
8783 scsiprintopcodes(struct cam_device *device, int td_req, uint8_t *buf,
8784                  uint32_t valid_len)
8785 {
8786         struct scsi_report_supported_opcodes_all *hdr;
8787         struct scsi_report_supported_opcodes_descr *desc;
8788         uint32_t avail_len = 0, used_len = 0;
8789         uint8_t *cur_ptr;
8790         int retval = 0;
8791
8792         if (valid_len < sizeof(*hdr)) {
8793                 warnx("%s: not enough returned data (%u bytes) opcode list",
8794                       __func__, valid_len);
8795                 retval = 1;
8796                 goto bailout;
8797         }
8798         hdr = (struct scsi_report_supported_opcodes_all *)buf;
8799         avail_len = scsi_4btoul(hdr->length);
8800         avail_len += sizeof(hdr->length);
8801         /*
8802          * Take the lesser of the amount of data the drive claims is
8803          * available, and the amount of data the HBA says was returned.
8804          */
8805         avail_len = MIN(avail_len, valid_len);
8806
8807         used_len = sizeof(hdr->length);
8808
8809         printf("%-6s %4s %8s ",
8810                "Opcode", "SA", "CDB len" );
8811
8812         if (td_req != 0)
8813                 printf("%5s %6s %6s ", "CS", "Nom", "Rec");
8814         printf(" Description\n");
8815
8816         while ((avail_len - used_len) > sizeof(*desc)) {
8817                 struct scsi_report_supported_opcodes_timeout *td;
8818                 uint32_t td_len;
8819                 const char *op_desc = NULL;
8820
8821                 cur_ptr = &buf[used_len];
8822                 desc = (struct scsi_report_supported_opcodes_descr *)cur_ptr;
8823
8824                 op_desc = scsi_op_desc(desc->opcode, &device->inq_data);
8825                 if (op_desc == NULL)
8826                         op_desc = "UNKNOWN";
8827
8828                 printf("0x%02x   %#4x %8u ", desc->opcode,
8829                        scsi_2btoul(desc->service_action),
8830                        scsi_2btoul(desc->cdb_length));
8831
8832                 used_len += sizeof(*desc);
8833
8834                 if ((desc->flags & RSO_CTDP) == 0) {
8835                         printf(" %s\n", op_desc);
8836                         continue;
8837                 }
8838
8839                 /*
8840                  * If we don't have enough space to fit a timeout
8841                  * descriptor, then we're done.
8842                  */
8843                 if (avail_len - used_len < sizeof(*td)) {
8844                         used_len = avail_len;
8845                         printf(" %s\n", op_desc);
8846                         continue;
8847                 }
8848                 cur_ptr = &buf[used_len];
8849                 td = (struct scsi_report_supported_opcodes_timeout *)cur_ptr;
8850                 td_len = scsi_2btoul(td->length);
8851                 td_len += sizeof(td->length);
8852
8853                 used_len += td_len;
8854                 /*
8855                  * If the given timeout descriptor length is less than what
8856                  * we understand, skip it.
8857                  */
8858                 if (td_len < sizeof(*td)) {
8859                         printf(" %s\n", op_desc);
8860                         continue;
8861                 }
8862
8863                 printf(" 0x%02x %6u %6u  %s\n", td->cmd_specific,
8864                        scsi_4btoul(td->nominal_time),
8865                        scsi_4btoul(td->recommended_time), op_desc);
8866         }
8867 bailout:
8868         return (retval);
8869 }
8870
8871 static int
8872 scsiopcodes(struct cam_device *device, int argc, char **argv,
8873             char *combinedopt, int task_attr, int retry_count, int timeout,
8874             int verbosemode)
8875 {
8876         int c;
8877         uint32_t opcode = 0, service_action = 0;
8878         int td_set = 0, opcode_set = 0, sa_set = 0;
8879         int show_sa_errors = 1;
8880         uint32_t valid_len = 0;
8881         uint8_t *buf = NULL;
8882         char *endptr;
8883         int retval = 0;
8884
8885         while ((c = getopt(argc, argv, combinedopt)) != -1) {
8886                 switch (c) {
8887                 case 'N':
8888                         show_sa_errors = 0;
8889                         break;
8890                 case 'o':
8891                         opcode = strtoul(optarg, &endptr, 0);
8892                         if (*endptr != '\0') {
8893                                 warnx("Invalid opcode \"%s\", must be a number",
8894                                       optarg);
8895                                 retval = 1;
8896                                 goto bailout;
8897                         }
8898                         if (opcode > 0xff) {
8899                                 warnx("Invalid opcode 0x%#x, must be between"
8900                                       "0 and 0xff inclusive", opcode);
8901                                 retval = 1;
8902                                 goto bailout;
8903                         }
8904                         opcode_set = 1;
8905                         break;
8906                 case 's':
8907                         service_action = strtoul(optarg, &endptr, 0);
8908                         if (*endptr != '\0') {
8909                                 warnx("Invalid service action \"%s\", must "
8910                                       "be a number", optarg);
8911                                 retval = 1;
8912                                 goto bailout;
8913                         }
8914                         if (service_action > 0xffff) {
8915                                 warnx("Invalid service action 0x%#x, must "
8916                                       "be between 0 and 0xffff inclusive",
8917                                       service_action);
8918                                 retval = 1;
8919                         }
8920                         sa_set = 1;
8921                         break;
8922                 case 'T':
8923                         td_set = 1;
8924                         break;
8925                 default:
8926                         break;
8927                 }
8928         }
8929
8930         if ((sa_set != 0)
8931          && (opcode_set == 0)) {
8932                 warnx("You must specify an opcode with -o if a service "
8933                       "action is given");
8934                 retval = 1;
8935                 goto bailout;
8936         }
8937         retval = scsigetopcodes(device, opcode_set, opcode, show_sa_errors,
8938                                 sa_set, service_action, td_set, task_attr,
8939                                 retry_count, timeout, verbosemode, &valid_len,
8940                                 &buf);
8941         if (retval != 0)
8942                 goto bailout;
8943
8944         if ((opcode_set != 0)
8945          || (sa_set != 0)) {
8946                 retval = scsiprintoneopcode(device, opcode, sa_set,
8947                                             service_action, buf, valid_len);
8948         } else {
8949                 retval = scsiprintopcodes(device, td_set, buf, valid_len);
8950         }
8951
8952 bailout:
8953         free(buf);
8954
8955         return (retval);
8956 }
8957
8958 #endif /* MINIMALISTIC */
8959
8960 static int
8961 scsireprobe(struct cam_device *device)
8962 {
8963         union ccb *ccb;
8964         int retval = 0;
8965
8966         ccb = cam_getccb(device);
8967
8968         if (ccb == NULL) {
8969                 warnx("%s: error allocating ccb", __func__);
8970                 return (1);
8971         }
8972
8973         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
8974
8975         ccb->ccb_h.func_code = XPT_REPROBE_LUN;
8976
8977         if (cam_send_ccb(device, ccb) < 0) {
8978                 warn("error sending XPT_REPROBE_LUN CCB");
8979                 retval = 1;
8980                 goto bailout;
8981         }
8982
8983         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
8984                 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr);
8985                 retval = 1;
8986                 goto bailout;
8987         }
8988
8989 bailout:
8990         cam_freeccb(ccb);
8991
8992         return (retval);
8993 }
8994
8995 void
8996 usage(int printlong)
8997 {
8998
8999         fprintf(printlong ? stdout : stderr,
9000 "usage:  camcontrol <command>  [device id][generic args][command args]\n"
9001 "        camcontrol devlist    [-b] [-v]\n"
9002 #ifndef MINIMALISTIC
9003 "        camcontrol periphlist [dev_id][-n dev_name] [-u unit]\n"
9004 "        camcontrol tur        [dev_id][generic args]\n"
9005 "        camcontrol inquiry    [dev_id][generic args] [-D] [-S] [-R]\n"
9006 "        camcontrol identify   [dev_id][generic args] [-v]\n"
9007 "        camcontrol reportluns [dev_id][generic args] [-c] [-l] [-r report]\n"
9008 "        camcontrol readcap    [dev_id][generic args] [-b] [-h] [-H] [-N]\n"
9009 "                              [-q] [-s]\n"
9010 "        camcontrol start      [dev_id][generic args]\n"
9011 "        camcontrol stop       [dev_id][generic args]\n"
9012 "        camcontrol load       [dev_id][generic args]\n"
9013 "        camcontrol eject      [dev_id][generic args]\n"
9014 "        camcontrol reprobe    [dev_id][generic args]\n"
9015 #endif /* MINIMALISTIC */
9016 "        camcontrol rescan     <all | bus[:target:lun] | dev_id>\n"
9017 "        camcontrol reset      <all | bus[:target:lun] | dev_id>\n"
9018 #ifndef MINIMALISTIC
9019 "        camcontrol defects    [dev_id][generic args] <-f format> [-P][-G]\n"
9020 "                              [-q][-s][-S offset][-X]\n"
9021 "        camcontrol modepage   [dev_id][generic args] <-m page | -l>\n"
9022 "                              [-P pagectl][-e | -b][-d]\n"
9023 "        camcontrol cmd        [dev_id][generic args]\n"
9024 "                              <-a cmd [args] | -c cmd [args]>\n"
9025 "                              [-d] [-f] [-i len fmt|-o len fmt [args]] [-r fmt]\n"
9026 "        camcontrol smpcmd     [dev_id][generic args]\n"
9027 "                              <-r len fmt [args]> <-R len fmt [args]>\n"
9028 "        camcontrol smprg      [dev_id][generic args][-l]\n"
9029 "        camcontrol smppc      [dev_id][generic args] <-p phy> [-l]\n"
9030 "                              [-o operation][-d name][-m rate][-M rate]\n"
9031 "                              [-T pp_timeout][-a enable|disable]\n"
9032 "                              [-A enable|disable][-s enable|disable]\n"
9033 "                              [-S enable|disable]\n"
9034 "        camcontrol smpphylist [dev_id][generic args][-l][-q]\n"
9035 "        camcontrol smpmaninfo [dev_id][generic args][-l]\n"
9036 "        camcontrol debug      [-I][-P][-T][-S][-X][-c]\n"
9037 "                              <all|bus[:target[:lun]]|off>\n"
9038 "        camcontrol tags       [dev_id][generic args] [-N tags] [-q] [-v]\n"
9039 "        camcontrol negotiate  [dev_id][generic args] [-a][-c]\n"
9040 "                              [-D <enable|disable>][-M mode][-O offset]\n"
9041 "                              [-q][-R syncrate][-v][-T <enable|disable>]\n"
9042 "                              [-U][-W bus_width]\n"
9043 "        camcontrol format     [dev_id][generic args][-q][-r][-w][-y]\n"
9044 "        camcontrol sanitize   [dev_id][generic args]\n"
9045 "                              [-a overwrite|block|crypto|exitfailure]\n"
9046 "                              [-c passes][-I][-P pattern][-q][-U][-r][-w]\n"
9047 "                              [-y]\n"
9048 "        camcontrol idle       [dev_id][generic args][-t time]\n"
9049 "        camcontrol standby    [dev_id][generic args][-t time]\n"
9050 "        camcontrol sleep      [dev_id][generic args]\n"
9051 "        camcontrol apm        [dev_id][generic args][-l level]\n"
9052 "        camcontrol aam        [dev_id][generic args][-l level]\n"
9053 "        camcontrol fwdownload [dev_id][generic args] <-f fw_image> [-q]\n"
9054 "                              [-s][-y]\n"
9055 "        camcontrol security   [dev_id][generic args]\n"
9056 "                              <-d pwd | -e pwd | -f | -h pwd | -k pwd>\n"
9057 "                              [-l <high|maximum>] [-q] [-s pwd] [-T timeout]\n"
9058 "                              [-U <user|master>] [-y]\n"
9059 "        camcontrol hpa        [dev_id][generic args] [-f] [-l] [-P] [-p pwd]\n"
9060 "                              [-q] [-s max_sectors] [-U pwd] [-y]\n"
9061 "        camcontrol persist    [dev_id][generic args] <-i action|-o action>\n"
9062 "                              [-a][-I tid][-k key][-K sa_key][-p][-R rtp]\n"
9063 "                              [-s scope][-S][-T type][-U]\n"
9064 "        camcontrol attrib     [dev_id][generic args] <-r action|-w attr>\n"
9065 "                              [-a attr_num][-c][-e elem][-F form1,form1]\n"
9066 "                              [-p part][-s start][-T type][-V vol]\n"
9067 "        camcontrol opcodes    [dev_id][generic args][-o opcode][-s SA]\n"
9068 "                              [-N][-T]\n"
9069 "        camcontrol zone       [dev_id][generic args]<-c cmd> [-a] [-l LBA]\n"
9070 "                              [-o rep_opts] [-P print_opts]\n"
9071 "        camcontrol epc        [dev_id][generic_args]<-c cmd> [-d] [-D] [-e]\n"
9072 "                              [-H] [-p power_cond] [-P] [-r rst_src] [-s]\n"
9073 "                              [-S power_src] [-T timer]\n"
9074 "        camcontrol timestamp  [dev_id][generic_args] <-r [-f format|-m|-U]>|\n"
9075 "                              <-s <-f format -T time | -U >>\n"
9076 "                              \n"
9077 #endif /* MINIMALISTIC */
9078 "        camcontrol help\n");
9079         if (!printlong)
9080                 return;
9081 #ifndef MINIMALISTIC
9082         fprintf(stdout,
9083 "Specify one of the following options:\n"
9084 "devlist     list all CAM devices\n"
9085 "periphlist  list all CAM peripheral drivers attached to a device\n"
9086 "tur         send a test unit ready to the named device\n"
9087 "inquiry     send a SCSI inquiry command to the named device\n"
9088 "identify    send a ATA identify command to the named device\n"
9089 "reportluns  send a SCSI report luns command to the device\n"
9090 "readcap     send a SCSI read capacity command to the device\n"
9091 "start       send a Start Unit command to the device\n"
9092 "stop        send a Stop Unit command to the device\n"
9093 "load        send a Start Unit command to the device with the load bit set\n"
9094 "eject       send a Stop Unit command to the device with the eject bit set\n"
9095 "reprobe     update capacity information of the given device\n"
9096 "rescan      rescan all buses, the given bus, bus:target:lun or device\n"
9097 "reset       reset all buses, the given bus, bus:target:lun or device\n"
9098 "defects     read the defect list of the specified device\n"
9099 "modepage    display or edit (-e) the given mode page\n"
9100 "cmd         send the given SCSI command, may need -i or -o as well\n"
9101 "smpcmd      send the given SMP command, requires -o and -i\n"
9102 "smprg       send the SMP Report General command\n"
9103 "smppc       send the SMP PHY Control command, requires -p\n"
9104 "smpphylist  display phys attached to a SAS expander\n"
9105 "smpmaninfo  send the SMP Report Manufacturer Info command\n"
9106 "debug       turn debugging on/off for a bus, target, or lun, or all devices\n"
9107 "tags        report or set the number of transaction slots for a device\n"
9108 "negotiate   report or set device negotiation parameters\n"
9109 "format      send the SCSI FORMAT UNIT command to the named device\n"
9110 "sanitize    send the SCSI SANITIZE command to the named device\n"
9111 "idle        send the ATA IDLE command to the named device\n"
9112 "standby     send the ATA STANDBY command to the named device\n"
9113 "sleep       send the ATA SLEEP command to the named device\n"
9114 "fwdownload  program firmware of the named device with the given image\n"
9115 "security    report or send ATA security commands to the named device\n"
9116 "persist     send the SCSI PERSISTENT RESERVE IN or OUT commands\n"
9117 "attrib      send the SCSI READ or WRITE ATTRIBUTE commands\n"
9118 "opcodes     send the SCSI REPORT SUPPORTED OPCODES command\n"
9119 "zone        manage Zoned Block (Shingled) devices\n"
9120 "epc         send ATA Extended Power Conditions commands\n"
9121 "timestamp   report or set the device's timestamp\n"
9122 "help        this message\n"
9123 "Device Identifiers:\n"
9124 "bus:target        specify the bus and target, lun defaults to 0\n"
9125 "bus:target:lun    specify the bus, target and lun\n"
9126 "deviceUNIT        specify the device name, like \"da4\" or \"cd2\"\n"
9127 "Generic arguments:\n"
9128 "-v                be verbose, print out sense information\n"
9129 "-t timeout        command timeout in seconds, overrides default timeout\n"
9130 "-n dev_name       specify device name, e.g. \"da\", \"cd\"\n"
9131 "-u unit           specify unit number, e.g. \"0\", \"5\"\n"
9132 "-E                have the kernel attempt to perform SCSI error recovery\n"
9133 "-C count          specify the SCSI command retry count (needs -E to work)\n"
9134 "-Q task_attr      specify ordered, simple or head tag type for SCSI cmds\n"
9135 "modepage arguments:\n"
9136 "-l                list all available mode pages\n"
9137 "-m page           specify the mode page to view or edit\n"
9138 "-e                edit the specified mode page\n"
9139 "-b                force view to binary mode\n"
9140 "-d                disable block descriptors for mode sense\n"
9141 "-P pgctl          page control field 0-3\n"
9142 "defects arguments:\n"
9143 "-f format         specify defect list format (block, bfi or phys)\n"
9144 "-G                get the grown defect list\n"
9145 "-P                get the permanent defect list\n"
9146 "inquiry arguments:\n"
9147 "-D                get the standard inquiry data\n"
9148 "-S                get the serial number\n"
9149 "-R                get the transfer rate, etc.\n"
9150 "reportluns arguments:\n"
9151 "-c                only report a count of available LUNs\n"
9152 "-l                only print out luns, and not a count\n"
9153 "-r <reporttype>   specify \"default\", \"wellknown\" or \"all\"\n"
9154 "readcap arguments\n"
9155 "-b                only report the blocksize\n"
9156 "-h                human readable device size, base 2\n"
9157 "-H                human readable device size, base 10\n"
9158 "-N                print the number of blocks instead of last block\n"
9159 "-q                quiet, print numbers only\n"
9160 "-s                only report the last block/device size\n"
9161 "cmd arguments:\n"
9162 "-c cdb [args]     specify the SCSI CDB\n"
9163 "-i len fmt        specify input data and input data format\n"
9164 "-o len fmt [args] specify output data and output data fmt\n"
9165 "smpcmd arguments:\n"
9166 "-r len fmt [args] specify the SMP command to be sent\n"
9167 "-R len fmt [args] specify SMP response format\n"
9168 "smprg arguments:\n"
9169 "-l                specify the long response format\n"
9170 "smppc arguments:\n"
9171 "-p phy            specify the PHY to operate on\n"
9172 "-l                specify the long request/response format\n"
9173 "-o operation      specify the phy control operation\n"
9174 "-d name           set the attached device name\n"
9175 "-m rate           set the minimum physical link rate\n"
9176 "-M rate           set the maximum physical link rate\n"
9177 "-T pp_timeout     set the partial pathway timeout value\n"
9178 "-a enable|disable enable or disable SATA slumber\n"
9179 "-A enable|disable enable or disable SATA partial phy power\n"
9180 "-s enable|disable enable or disable SAS slumber\n"
9181 "-S enable|disable enable or disable SAS partial phy power\n"
9182 "smpphylist arguments:\n"
9183 "-l                specify the long response format\n"
9184 "-q                only print phys with attached devices\n"
9185 "smpmaninfo arguments:\n"
9186 "-l                specify the long response format\n"
9187 "debug arguments:\n"
9188 "-I                CAM_DEBUG_INFO -- scsi commands, errors, data\n"
9189 "-T                CAM_DEBUG_TRACE -- routine flow tracking\n"
9190 "-S                CAM_DEBUG_SUBTRACE -- internal routine command flow\n"
9191 "-c                CAM_DEBUG_CDB -- print out SCSI CDBs only\n"
9192 "tags arguments:\n"
9193 "-N tags           specify the number of tags to use for this device\n"
9194 "-q                be quiet, don't report the number of tags\n"
9195 "-v                report a number of tag-related parameters\n"
9196 "negotiate arguments:\n"
9197 "-a                send a test unit ready after negotiation\n"
9198 "-c                report/set current negotiation settings\n"
9199 "-D <arg>          \"enable\" or \"disable\" disconnection\n"
9200 "-M mode           set ATA mode\n"
9201 "-O offset         set command delay offset\n"
9202 "-q                be quiet, don't report anything\n"
9203 "-R syncrate       synchronization rate in MHz\n"
9204 "-T <arg>          \"enable\" or \"disable\" tagged queueing\n"
9205 "-U                report/set user negotiation settings\n"
9206 "-W bus_width      set the bus width in bits (8, 16 or 32)\n"
9207 "-v                also print a Path Inquiry CCB for the controller\n"
9208 "format arguments:\n"
9209 "-q                be quiet, don't print status messages\n"
9210 "-r                run in report only mode\n"
9211 "-w                don't send immediate format command\n"
9212 "-y                don't ask any questions\n"
9213 "sanitize arguments:\n"
9214 "-a operation      operation mode: overwrite, block, crypto or exitfailure\n"
9215 "-c passes         overwrite passes to perform (1 to 31)\n"
9216 "-I                invert overwrite pattern after each pass\n"
9217 "-P pattern        path to overwrite pattern file\n"
9218 "-q                be quiet, don't print status messages\n"
9219 "-r                run in report only mode\n"
9220 "-U                run operation in unrestricted completion exit mode\n"
9221 "-w                don't send immediate sanitize command\n"
9222 "-y                don't ask any questions\n"
9223 "idle/standby arguments:\n"
9224 "-t <arg>          number of seconds before respective state.\n"
9225 "fwdownload arguments:\n"
9226 "-f fw_image       path to firmware image file\n"
9227 "-q                don't print informational messages, only errors\n"
9228 "-s                run in simulation mode\n"
9229 "-v                print info for every firmware segment sent to device\n"
9230 "-y                don't ask any questions\n"
9231 "security arguments:\n"
9232 "-d pwd            disable security using the given password for the selected\n"
9233 "                  user\n"
9234 "-e pwd            erase the device using the given pwd for the selected user\n"
9235 "-f                freeze the security configuration of the specified device\n"
9236 "-h pwd            enhanced erase the device using the given pwd for the\n"
9237 "                  selected user\n"
9238 "-k pwd            unlock the device using the given pwd for the selected\n"
9239 "                  user\n"
9240 "-l <high|maximum> specifies which security level to set: high or maximum\n"
9241 "-q                be quiet, do not print any status messages\n"
9242 "-s pwd            password the device (enable security) using the given\n"
9243 "                  pwd for the selected user\n"
9244 "-T timeout        overrides the timeout (seconds) used for erase operation\n"
9245 "-U <user|master>  specifies which user to set: user or master\n"
9246 "-y                don't ask any questions\n"
9247 "hpa arguments:\n"
9248 "-f                freeze the HPA configuration of the device\n"
9249 "-l                lock the HPA configuration of the device\n"
9250 "-P                make the HPA max sectors persist\n"
9251 "-p pwd            Set the HPA configuration password required for unlock\n"
9252 "                  calls\n"
9253 "-q                be quiet, do not print any status messages\n"
9254 "-s sectors        configures the maximum user accessible sectors of the\n"
9255 "                  device\n"
9256 "-U pwd            unlock the HPA configuration of the device\n"
9257 "-y                don't ask any questions\n"
9258 "persist arguments:\n"
9259 "-i action         specify read_keys, read_reservation, report_cap, or\n"
9260 "                  read_full_status\n"
9261 "-o action         specify register, register_ignore, reserve, release,\n"
9262 "                  clear, preempt, preempt_abort, register_move, replace_lost\n"
9263 "-a                set the All Target Ports (ALL_TG_PT) bit\n"
9264 "-I tid            specify a Transport ID, e.g.: sas,0x1234567812345678\n"
9265 "-k key            specify the Reservation Key\n"
9266 "-K sa_key         specify the Service Action Reservation Key\n"
9267 "-p                set the Activate Persist Through Power Loss bit\n"
9268 "-R rtp            specify the Relative Target Port\n"
9269 "-s scope          specify the scope: lun, extent, element or a number\n"
9270 "-S                specify Transport ID for register, requires -I\n"
9271 "-T res_type       specify the reservation type: read_shared, wr_ex, rd_ex,\n"
9272 "                  ex_ac, wr_ex_ro, ex_ac_ro, wr_ex_ar, ex_ac_ar\n"
9273 "-U                unregister the current initiator for register_move\n"
9274 "attrib arguments:\n"
9275 "-r action         specify attr_values, attr_list, lv_list, part_list, or\n"
9276 "                  supp_attr\n"
9277 "-w attr           specify an attribute to write, one -w argument per attr\n"
9278 "-a attr_num       only display this attribute number\n"
9279 "-c                get cached attributes\n"
9280 "-e elem_addr      request attributes for the given element in a changer\n"
9281 "-F form1,form2    output format, comma separated list: text_esc, text_raw,\n"
9282 "                  nonascii_esc, nonascii_trim, nonascii_raw, field_all,\n"
9283 "                  field_none, field_desc, field_num, field_size, field_rw\n"
9284 "-p partition      request attributes for the given partition\n"
9285 "-s start_attr     request attributes starting at the given number\n"
9286 "-T elem_type      specify the element type (used with -e)\n"
9287 "-V logical_vol    specify the logical volume ID\n"
9288 "opcodes arguments:\n"
9289 "-o opcode         specify the individual opcode to list\n"
9290 "-s service_action specify the service action for the opcode\n"
9291 "-N                do not return SCSI error for unsupported SA\n"
9292 "-T                request nominal and recommended timeout values\n"
9293 "zone arguments:\n"
9294 "-c cmd            required: rz, open, close, finish, or rwp\n"
9295 "-a                apply the action to all zones\n"
9296 "-l LBA            specify the zone starting LBA\n"
9297 "-o rep_opts       report zones options: all, empty, imp_open, exp_open,\n"
9298 "                  closed, full, ro, offline, reset, nonseq, nonwp\n"
9299 "-P print_opt      report zones printing:  normal, summary, script\n"
9300 "epc arguments:\n"
9301 "-c cmd            required: restore, goto, timer, state, enable, disable,\n"
9302 "                  source, status, list\n"
9303 "-d                disable power mode (timer, state)\n"
9304 "-D                delayed entry (goto)\n"
9305 "-e                enable power mode (timer, state)\n"
9306 "-H                hold power mode (goto)\n"
9307 "-p power_cond     Idle_a, Idle_b, Idle_c, Standby_y, Standby_z (timer,\n"
9308 "                  state, goto)\n"
9309 "-P                only display power mode (status)\n"
9310 "-r rst_src        restore settings from: default, saved (restore)\n"
9311 "-s                save mode (timer, state, restore)\n"
9312 "-S power_src      set power source: battery, nonbattery (source)\n"
9313 "-T timer          set timer, seconds, .1 sec resolution (timer)\n"
9314 "timestamp arguments:\n"
9315 "-r                report the timestamp of the device\n"
9316 "-f format         report the timestamp of the device with the given\n"
9317 "                  strftime(3) format string\n"
9318 "-m                report the timestamp of the device as milliseconds since\n"
9319 "                  January 1st, 1970\n"
9320 "-U                report the time with UTC instead of the local time zone\n"
9321 "-s                set the timestamp of the device\n"
9322 "-f format         the format of the time string passed into strptime(3)\n"
9323 "-T time           the time value passed into strptime(3)\n"
9324 "-U                set the timestamp of the device to UTC time\n"
9325 );
9326 #endif /* MINIMALISTIC */
9327 }
9328
9329 int
9330 main(int argc, char **argv)
9331 {
9332         int c;
9333         char *device = NULL;
9334         int unit = 0;
9335         struct cam_device *cam_dev = NULL;
9336         int timeout = 0, retry_count = 1;
9337         camcontrol_optret optreturn;
9338         char *tstr;
9339         const char *mainopt = "C:En:Q:t:u:v";
9340         const char *subopt = NULL;
9341         char combinedopt[256];
9342         int error = 0, optstart = 2;
9343         int task_attr = MSG_SIMPLE_Q_TAG;
9344         int devopen = 1;
9345 #ifndef MINIMALISTIC
9346         path_id_t bus;
9347         target_id_t target;
9348         lun_id_t lun;
9349 #endif /* MINIMALISTIC */
9350
9351         cmdlist = CAM_CMD_NONE;
9352         arglist = CAM_ARG_NONE;
9353
9354         if (argc < 2) {
9355                 usage(0);
9356                 exit(1);
9357         }
9358
9359         /*
9360          * Get the base option.
9361          */
9362         optreturn = getoption(option_table,argv[1], &cmdlist, &arglist,&subopt);
9363
9364         if (optreturn == CC_OR_AMBIGUOUS) {
9365                 warnx("ambiguous option %s", argv[1]);
9366                 usage(0);
9367                 exit(1);
9368         } else if (optreturn == CC_OR_NOT_FOUND) {
9369                 warnx("option %s not found", argv[1]);
9370                 usage(0);
9371                 exit(1);
9372         }
9373
9374         /*
9375          * Ahh, getopt(3) is a pain.
9376          *
9377          * This is a gross hack.  There really aren't many other good
9378          * options (excuse the pun) for parsing options in a situation like
9379          * this.  getopt is kinda braindead, so you end up having to run
9380          * through the options twice, and give each invocation of getopt
9381          * the option string for the other invocation.
9382          *
9383          * You would think that you could just have two groups of options.
9384          * The first group would get parsed by the first invocation of
9385          * getopt, and the second group would get parsed by the second
9386          * invocation of getopt.  It doesn't quite work out that way.  When
9387          * the first invocation of getopt finishes, it leaves optind pointing
9388          * to the argument _after_ the first argument in the second group.
9389          * So when the second invocation of getopt comes around, it doesn't
9390          * recognize the first argument it gets and then bails out.
9391          *
9392          * A nice alternative would be to have a flag for getopt that says
9393          * "just keep parsing arguments even when you encounter an unknown
9394          * argument", but there isn't one.  So there's no real clean way to
9395          * easily parse two sets of arguments without having one invocation
9396          * of getopt know about the other.
9397          *
9398          * Without this hack, the first invocation of getopt would work as
9399          * long as the generic arguments are first, but the second invocation
9400          * (in the subfunction) would fail in one of two ways.  In the case
9401          * where you don't set optreset, it would fail because optind may be
9402          * pointing to the argument after the one it should be pointing at.
9403          * In the case where you do set optreset, and reset optind, it would
9404          * fail because getopt would run into the first set of options, which
9405          * it doesn't understand.
9406          *
9407          * All of this would "sort of" work if you could somehow figure out
9408          * whether optind had been incremented one option too far.  The
9409          * mechanics of that, however, are more daunting than just giving
9410          * both invocations all of the expect options for either invocation.
9411          *
9412          * Needless to say, I wouldn't mind if someone invented a better
9413          * (non-GPL!) command line parsing interface than getopt.  I
9414          * wouldn't mind if someone added more knobs to getopt to make it
9415          * work better.  Who knows, I may talk myself into doing it someday,
9416          * if the standards weenies let me.  As it is, it just leads to
9417          * hackery like this and causes people to avoid it in some cases.
9418          *
9419          * KDM, September 8th, 1998
9420          */
9421         if (subopt != NULL)
9422                 sprintf(combinedopt, "%s%s", mainopt, subopt);
9423         else
9424                 sprintf(combinedopt, "%s", mainopt);
9425
9426         /*
9427          * For these options we do not parse optional device arguments and
9428          * we do not open a passthrough device.
9429          */
9430         if ((cmdlist == CAM_CMD_RESCAN)
9431          || (cmdlist == CAM_CMD_RESET)
9432          || (cmdlist == CAM_CMD_DEVTREE)
9433          || (cmdlist == CAM_CMD_USAGE)
9434          || (cmdlist == CAM_CMD_DEBUG))
9435                 devopen = 0;
9436
9437 #ifndef MINIMALISTIC
9438         if ((devopen == 1)
9439          && (argc > 2 && argv[2][0] != '-')) {
9440                 char name[30];
9441                 int rv;
9442
9443                 if (isdigit(argv[2][0])) {
9444                         /* device specified as bus:target[:lun] */
9445                         rv = parse_btl(argv[2], &bus, &target, &lun, &arglist);
9446                         if (rv < 2)
9447                                 errx(1, "numeric device specification must "
9448                                      "be either bus:target, or "
9449                                      "bus:target:lun");
9450                         /* default to 0 if lun was not specified */
9451                         if ((arglist & CAM_ARG_LUN) == 0) {
9452                                 lun = 0;
9453                                 arglist |= CAM_ARG_LUN;
9454                         }
9455                         optstart++;
9456                 } else {
9457                         if (cam_get_device(argv[2], name, sizeof name, &unit)
9458                             == -1)
9459                                 errx(1, "%s", cam_errbuf);
9460                         device = strdup(name);
9461                         arglist |= CAM_ARG_DEVICE | CAM_ARG_UNIT;
9462                         optstart++;
9463                 }
9464         }
9465 #endif /* MINIMALISTIC */
9466         /*
9467          * Start getopt processing at argv[2/3], since we've already
9468          * accepted argv[1..2] as the command name, and as a possible
9469          * device name.
9470          */
9471         optind = optstart;
9472
9473         /*
9474          * Now we run through the argument list looking for generic
9475          * options, and ignoring options that possibly belong to
9476          * subfunctions.
9477          */
9478         while ((c = getopt(argc, argv, combinedopt))!= -1){
9479                 switch(c) {
9480                         case 'C':
9481                                 retry_count = strtol(optarg, NULL, 0);
9482                                 if (retry_count < 0)
9483                                         errx(1, "retry count %d is < 0",
9484                                              retry_count);
9485                                 arglist |= CAM_ARG_RETRIES;
9486                                 break;
9487                         case 'E':
9488                                 arglist |= CAM_ARG_ERR_RECOVER;
9489                                 break;
9490                         case 'n':
9491                                 arglist |= CAM_ARG_DEVICE;
9492                                 tstr = optarg;
9493                                 while (isspace(*tstr) && (*tstr != '\0'))
9494                                         tstr++;
9495                                 device = (char *)strdup(tstr);
9496                                 break;
9497                         case 'Q': {
9498                                 char *endptr;
9499                                 int table_entry = 0;
9500
9501                                 tstr = optarg;
9502                                 while (isspace(*tstr) && (*tstr != '\0'))
9503                                         tstr++;
9504                                 if (isdigit(*tstr)) {
9505                                         task_attr = strtol(tstr, &endptr, 0);
9506                                         if (*endptr != '\0') {
9507                                                 errx(1, "Invalid queue option "
9508                                                     "%s", tstr);
9509                                         }
9510                                 } else {
9511                                         size_t table_size;
9512                                         scsi_nv_status status;
9513
9514                                         table_size = sizeof(task_attrs) /
9515                                                      sizeof(task_attrs[0]);
9516                                         status = scsi_get_nv(task_attrs,
9517                                             table_size, tstr, &table_entry,
9518                                             SCSI_NV_FLAG_IG_CASE);
9519                                         if (status == SCSI_NV_FOUND)
9520                                                 task_attr = task_attrs[
9521                                                     table_entry].value;
9522                                         else {
9523                                                 errx(1, "%s option %s",
9524                                                   (status == SCSI_NV_AMBIGUOUS)?
9525                                                     "ambiguous" : "invalid",
9526                                                     tstr);
9527                                         }
9528                                 }
9529                                 break;
9530                         }
9531                         case 't':
9532                                 timeout = strtol(optarg, NULL, 0);
9533                                 if (timeout < 0)
9534                                         errx(1, "invalid timeout %d", timeout);
9535                                 /* Convert the timeout from seconds to ms */
9536                                 timeout *= 1000;
9537                                 arglist |= CAM_ARG_TIMEOUT;
9538                                 break;
9539                         case 'u':
9540                                 arglist |= CAM_ARG_UNIT;
9541                                 unit = strtol(optarg, NULL, 0);
9542                                 break;
9543                         case 'v':
9544                                 arglist |= CAM_ARG_VERBOSE;
9545                                 break;
9546                         default:
9547                                 break;
9548                 }
9549         }
9550
9551 #ifndef MINIMALISTIC
9552         /*
9553          * For most commands we'll want to open the passthrough device
9554          * associated with the specified device.  In the case of the rescan
9555          * commands, we don't use a passthrough device at all, just the
9556          * transport layer device.
9557          */
9558         if (devopen == 1) {
9559                 if (((arglist & (CAM_ARG_BUS|CAM_ARG_TARGET)) == 0)
9560                  && (((arglist & CAM_ARG_DEVICE) == 0)
9561                   || ((arglist & CAM_ARG_UNIT) == 0))) {
9562                         errx(1, "subcommand \"%s\" requires a valid device "
9563                              "identifier", argv[1]);
9564                 }
9565
9566                 if ((cam_dev = ((arglist & (CAM_ARG_BUS | CAM_ARG_TARGET))?
9567                                 cam_open_btl(bus, target, lun, O_RDWR, NULL) :
9568                                 cam_open_spec_device(device,unit,O_RDWR,NULL)))
9569                      == NULL)
9570                         errx(1,"%s", cam_errbuf);
9571         }
9572 #endif /* MINIMALISTIC */
9573
9574         /*
9575          * Reset optind to 2, and reset getopt, so these routines can parse
9576          * the arguments again.
9577          */
9578         optind = optstart;
9579         optreset = 1;
9580
9581         switch(cmdlist) {
9582 #ifndef MINIMALISTIC
9583                 case CAM_CMD_DEVLIST:
9584                         error = getdevlist(cam_dev);
9585                         break;
9586                 case CAM_CMD_HPA:
9587                         error = atahpa(cam_dev, retry_count, timeout,
9588                                        argc, argv, combinedopt);
9589                         break;
9590 #endif /* MINIMALISTIC */
9591                 case CAM_CMD_DEVTREE:
9592                         error = getdevtree(argc, argv, combinedopt);
9593                         break;
9594 #ifndef MINIMALISTIC
9595                 case CAM_CMD_TUR:
9596                         error = testunitready(cam_dev, task_attr, retry_count,
9597                             timeout, 0);
9598                         break;
9599                 case CAM_CMD_INQUIRY:
9600                         error = scsidoinquiry(cam_dev, argc, argv, combinedopt,
9601                                               task_attr, retry_count, timeout);
9602                         break;
9603                 case CAM_CMD_IDENTIFY:
9604                         error = ataidentify(cam_dev, retry_count, timeout);
9605                         break;
9606                 case CAM_CMD_STARTSTOP:
9607                         error = scsistart(cam_dev, arglist & CAM_ARG_START_UNIT,
9608                                           arglist & CAM_ARG_EJECT, task_attr,
9609                                           retry_count, timeout);
9610                         break;
9611 #endif /* MINIMALISTIC */
9612                 case CAM_CMD_RESCAN:
9613                         error = dorescan_or_reset(argc, argv, 1);
9614                         break;
9615                 case CAM_CMD_RESET:
9616                         error = dorescan_or_reset(argc, argv, 0);
9617                         break;
9618 #ifndef MINIMALISTIC
9619                 case CAM_CMD_READ_DEFECTS:
9620                         error = readdefects(cam_dev, argc, argv, combinedopt,
9621                                             task_attr, retry_count, timeout);
9622                         break;
9623                 case CAM_CMD_MODE_PAGE:
9624                         modepage(cam_dev, argc, argv, combinedopt,
9625                                  task_attr, retry_count, timeout);
9626                         break;
9627                 case CAM_CMD_SCSI_CMD:
9628                         error = scsicmd(cam_dev, argc, argv, combinedopt,
9629                                         task_attr, retry_count, timeout);
9630                         break;
9631                 case CAM_CMD_SMP_CMD:
9632                         error = smpcmd(cam_dev, argc, argv, combinedopt,
9633                                        retry_count, timeout);
9634                         break;
9635                 case CAM_CMD_SMP_RG:
9636                         error = smpreportgeneral(cam_dev, argc, argv,
9637                                                  combinedopt, retry_count,
9638                                                  timeout);
9639                         break;
9640                 case CAM_CMD_SMP_PC:
9641                         error = smpphycontrol(cam_dev, argc, argv, combinedopt,
9642                                               retry_count, timeout);
9643                         break;
9644                 case CAM_CMD_SMP_PHYLIST:
9645                         error = smpphylist(cam_dev, argc, argv, combinedopt,
9646                                            retry_count, timeout);
9647                         break;
9648                 case CAM_CMD_SMP_MANINFO:
9649                         error = smpmaninfo(cam_dev, argc, argv, combinedopt,
9650                                            retry_count, timeout);
9651                         break;
9652                 case CAM_CMD_DEBUG:
9653                         error = camdebug(argc, argv, combinedopt);
9654                         break;
9655                 case CAM_CMD_TAG:
9656                         error = tagcontrol(cam_dev, argc, argv, combinedopt);
9657                         break;
9658                 case CAM_CMD_RATE:
9659                         error = ratecontrol(cam_dev, task_attr, retry_count,
9660                                             timeout, argc, argv, combinedopt);
9661                         break;
9662                 case CAM_CMD_FORMAT:
9663                         error = scsiformat(cam_dev, argc, argv,
9664                                            combinedopt, task_attr, retry_count,
9665                                            timeout);
9666                         break;
9667                 case CAM_CMD_REPORTLUNS:
9668                         error = scsireportluns(cam_dev, argc, argv,
9669                                                combinedopt, task_attr,
9670                                                retry_count, timeout);
9671                         break;
9672                 case CAM_CMD_READCAP:
9673                         error = scsireadcapacity(cam_dev, argc, argv,
9674                                                  combinedopt, task_attr,
9675                                                  retry_count, timeout);
9676                         break;
9677                 case CAM_CMD_IDLE:
9678                 case CAM_CMD_STANDBY:
9679                 case CAM_CMD_SLEEP:
9680                         error = atapm(cam_dev, argc, argv,
9681                                       combinedopt, retry_count, timeout);
9682                         break;
9683                 case CAM_CMD_APM:
9684                 case CAM_CMD_AAM:
9685                         error = ataaxm(cam_dev, argc, argv,
9686                                       combinedopt, retry_count, timeout);
9687                         break;
9688                 case CAM_CMD_SECURITY:
9689                         error = atasecurity(cam_dev, retry_count, timeout,
9690                                             argc, argv, combinedopt);
9691                         break;
9692                 case CAM_CMD_DOWNLOAD_FW:
9693                         error = fwdownload(cam_dev, argc, argv, combinedopt,
9694                             arglist & CAM_ARG_VERBOSE, task_attr, retry_count,
9695                             timeout);
9696                         break;
9697                 case CAM_CMD_SANITIZE:
9698                         error = scsisanitize(cam_dev, argc, argv,
9699                                              combinedopt, task_attr,
9700                                              retry_count, timeout);
9701                         break;
9702                 case CAM_CMD_PERSIST:
9703                         error = scsipersist(cam_dev, argc, argv, combinedopt,
9704                             task_attr, retry_count, timeout,
9705                             arglist & CAM_ARG_VERBOSE,
9706                             arglist & CAM_ARG_ERR_RECOVER);
9707                         break;
9708                 case CAM_CMD_ATTRIB:
9709                         error = scsiattrib(cam_dev, argc, argv, combinedopt,
9710                             task_attr, retry_count, timeout,
9711                             arglist & CAM_ARG_VERBOSE,
9712                             arglist & CAM_ARG_ERR_RECOVER);
9713                         break;
9714                 case CAM_CMD_OPCODES:
9715                         error = scsiopcodes(cam_dev, argc, argv, combinedopt,
9716                             task_attr, retry_count, timeout,
9717                             arglist & CAM_ARG_VERBOSE);
9718                         break;
9719                 case CAM_CMD_REPROBE:
9720                         error = scsireprobe(cam_dev);
9721                         break;
9722                 case CAM_CMD_ZONE:
9723                         error = zone(cam_dev, argc, argv, combinedopt,
9724                             task_attr, retry_count, timeout,
9725                             arglist & CAM_ARG_VERBOSE);
9726                         break;
9727                 case CAM_CMD_EPC:
9728                         error = epc(cam_dev, argc, argv, combinedopt,
9729                             retry_count, timeout, arglist & CAM_ARG_VERBOSE);
9730                         break;
9731                 case CAM_CMD_TIMESTAMP:
9732                         error = timestamp(cam_dev, argc, argv, combinedopt,
9733                             task_attr, retry_count, timeout,
9734                             arglist & CAM_ARG_VERBOSE);
9735                         break;
9736 #endif /* MINIMALISTIC */
9737                 case CAM_CMD_USAGE:
9738                         usage(1);
9739                         break;
9740                 default:
9741                         usage(0);
9742                         error = 1;
9743                         break;
9744         }
9745
9746         if (cam_dev != NULL)
9747                 cam_close_device(cam_dev);
9748
9749         exit(error);
9750 }