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