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         if (cts->protocol == PROTO_NVME) {
5171                 struct ccb_trans_settings_nvme *nvmex =
5172                     &cts->xport_specific.nvme;
5173
5174                 if (nvmex->valid & CTS_NVME_VALID_SPEC) {
5175                         fprintf(stdout, "%sNVMe Spec: %d.%d\n", pathstr,
5176                             NVME_MAJOR(nvmex->spec),
5177                             NVME_MINOR(nvmex->spec));
5178                 }
5179                 if (nvmex->valid & CTS_NVME_VALID_LINK) {
5180                         fprintf(stdout, "%sPCIe lanes: %d (%d max)\n", pathstr,
5181                             nvmex->lanes, nvmex->max_lanes);
5182                         fprintf(stdout, "%sPCIe Generation: %d (%d max)\n", pathstr,
5183                             nvmex->speed, nvmex->max_speed);
5184                 }
5185         }
5186 }
5187
5188 /*
5189  * Get a path inquiry CCB for the specified device.
5190  */
5191 static int
5192 get_cpi(struct cam_device *device, struct ccb_pathinq *cpi)
5193 {
5194         union ccb *ccb;
5195         int retval = 0;
5196
5197         ccb = cam_getccb(device);
5198         if (ccb == NULL) {
5199                 warnx("get_cpi: couldn't allocate CCB");
5200                 return (1);
5201         }
5202         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->cpi);
5203         ccb->ccb_h.func_code = XPT_PATH_INQ;
5204         if (cam_send_ccb(device, ccb) < 0) {
5205                 warn("get_cpi: error sending Path Inquiry CCB");
5206                 if (arglist & CAM_ARG_VERBOSE)
5207                         cam_error_print(device, ccb, CAM_ESF_ALL,
5208                                         CAM_EPF_ALL, stderr);
5209                 retval = 1;
5210                 goto get_cpi_bailout;
5211         }
5212         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
5213                 if (arglist & CAM_ARG_VERBOSE)
5214                         cam_error_print(device, ccb, CAM_ESF_ALL,
5215                                         CAM_EPF_ALL, stderr);
5216                 retval = 1;
5217                 goto get_cpi_bailout;
5218         }
5219         bcopy(&ccb->cpi, cpi, sizeof(struct ccb_pathinq));
5220
5221 get_cpi_bailout:
5222         cam_freeccb(ccb);
5223         return (retval);
5224 }
5225
5226 /*
5227  * Get a get device CCB for the specified device.
5228  */
5229 static int
5230 get_cgd(struct cam_device *device, struct ccb_getdev *cgd)
5231 {
5232         union ccb *ccb;
5233         int retval = 0;
5234
5235         ccb = cam_getccb(device);
5236         if (ccb == NULL) {
5237                 warnx("get_cgd: couldn't allocate CCB");
5238                 return (1);
5239         }
5240         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->cgd);
5241         ccb->ccb_h.func_code = XPT_GDEV_TYPE;
5242         if (cam_send_ccb(device, ccb) < 0) {
5243                 warn("get_cgd: error sending Path Inquiry CCB");
5244                 if (arglist & CAM_ARG_VERBOSE)
5245                         cam_error_print(device, ccb, CAM_ESF_ALL,
5246                                         CAM_EPF_ALL, stderr);
5247                 retval = 1;
5248                 goto get_cgd_bailout;
5249         }
5250         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
5251                 if (arglist & CAM_ARG_VERBOSE)
5252                         cam_error_print(device, ccb, CAM_ESF_ALL,
5253                                         CAM_EPF_ALL, stderr);
5254                 retval = 1;
5255                 goto get_cgd_bailout;
5256         }
5257         bcopy(&ccb->cgd, cgd, sizeof(struct ccb_getdev));
5258
5259 get_cgd_bailout:
5260         cam_freeccb(ccb);
5261         return (retval);
5262 }
5263
5264 /*
5265  * Returns 1 if the device has the VPD page, 0 if it does not, and -1 on an
5266  * error.
5267  */
5268 int
5269 dev_has_vpd_page(struct cam_device *dev, uint8_t page_id, int retry_count,
5270                  int timeout, int verbosemode)
5271 {
5272         union ccb *ccb = NULL;
5273         struct scsi_vpd_supported_page_list sup_pages;
5274         int i;
5275         int retval = 0;
5276
5277         ccb = cam_getccb(dev);
5278         if (ccb == NULL) {
5279                 warn("Unable to allocate CCB");
5280                 retval = -1;
5281                 goto bailout;
5282         }
5283
5284         /* cam_getccb cleans up the header, caller has to zero the payload */
5285         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
5286
5287         bzero(&sup_pages, sizeof(sup_pages));
5288
5289         scsi_inquiry(&ccb->csio,
5290                      /*retries*/ retry_count,
5291                      /*cbfcnp*/ NULL,
5292                      /* tag_action */ MSG_SIMPLE_Q_TAG,
5293                      /* inq_buf */ (u_int8_t *)&sup_pages,
5294                      /* inq_len */ sizeof(sup_pages),
5295                      /* evpd */ 1,
5296                      /* page_code */ SVPD_SUPPORTED_PAGE_LIST,
5297                      /* sense_len */ SSD_FULL_SIZE,
5298                      /* timeout */ timeout ? timeout : 5000);
5299
5300         /* Disable freezing the device queue */
5301         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
5302
5303         if (retry_count != 0)
5304                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
5305
5306         if (cam_send_ccb(dev, ccb) < 0) {
5307                 cam_freeccb(ccb);
5308                 ccb = NULL;
5309                 retval = -1;
5310                 goto bailout;
5311         }
5312
5313         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
5314                 if (verbosemode != 0)
5315                         cam_error_print(dev, ccb, CAM_ESF_ALL,
5316                                         CAM_EPF_ALL, stderr);
5317                 retval = -1;
5318                 goto bailout;
5319         }
5320
5321         for (i = 0; i < sup_pages.length; i++) {
5322                 if (sup_pages.list[i] == page_id) {
5323                         retval = 1;
5324                         goto bailout;
5325                 }
5326         }
5327 bailout:
5328         if (ccb != NULL)
5329                 cam_freeccb(ccb);
5330
5331         return (retval);
5332 }
5333
5334 /*
5335  * devtype is filled in with the type of device.
5336  * Returns 0 for success, non-zero for failure.
5337  */
5338 int
5339 get_device_type(struct cam_device *dev, int retry_count, int timeout,
5340                     int verbosemode, camcontrol_devtype *devtype)
5341 {
5342         struct ccb_getdev cgd;
5343         int retval = 0;
5344
5345         retval = get_cgd(dev, &cgd);
5346         if (retval != 0)
5347                 goto bailout;
5348
5349         switch (cgd.protocol) {
5350         case PROTO_SCSI:
5351                 break;
5352         case PROTO_ATA:
5353         case PROTO_ATAPI:
5354         case PROTO_SATAPM:
5355                 *devtype = CC_DT_ATA;
5356                 goto bailout;
5357                 break; /*NOTREACHED*/
5358         default:
5359                 *devtype = CC_DT_UNKNOWN;
5360                 goto bailout;
5361                 break; /*NOTREACHED*/
5362         }
5363
5364         /*
5365          * Check for the ATA Information VPD page (0x89).  If this is an
5366          * ATA device behind a SCSI to ATA translation layer, this VPD page
5367          * should be present.
5368          *
5369          * If that VPD page isn't present, or we get an error back from the
5370          * INQUIRY command, we'll just treat it as a normal SCSI device.
5371          */
5372         retval = dev_has_vpd_page(dev, SVPD_ATA_INFORMATION, retry_count,
5373                                   timeout, verbosemode);
5374         if (retval == 1)
5375                 *devtype = CC_DT_ATA_BEHIND_SCSI;
5376         else
5377                 *devtype = CC_DT_SCSI;
5378
5379         retval = 0;
5380
5381 bailout:
5382         return (retval);
5383 }
5384
5385 int
5386 build_ata_cmd(union ccb *ccb, uint32_t retry_count, uint32_t flags,
5387     uint8_t tag_action, uint8_t protocol, uint8_t ata_flags, uint16_t features,
5388     uint16_t sector_count, uint64_t lba, uint8_t command, uint32_t auxiliary,
5389     uint8_t *data_ptr, uint32_t dxfer_len, uint8_t *cdb_storage,
5390     size_t cdb_storage_len, uint8_t sense_len, uint32_t timeout,
5391     int is48bit, camcontrol_devtype devtype)
5392 {
5393         int retval = 0;
5394
5395         if (devtype == CC_DT_ATA) {
5396                 cam_fill_ataio(&ccb->ataio,
5397                     /*retries*/ retry_count,
5398                     /*cbfcnp*/ NULL,
5399                     /*flags*/ flags,
5400                     /*tag_action*/ tag_action,
5401                     /*data_ptr*/ data_ptr,
5402                     /*dxfer_len*/ dxfer_len,
5403                     /*timeout*/ timeout);
5404                 if (is48bit || lba > ATA_MAX_28BIT_LBA)
5405                         ata_48bit_cmd(&ccb->ataio, command, features, lba,
5406                             sector_count);
5407                 else
5408                         ata_28bit_cmd(&ccb->ataio, command, features, lba,
5409                             sector_count);
5410
5411                 if (auxiliary != 0) {
5412                         ccb->ataio.ata_flags |= ATA_FLAG_AUX;
5413                         ccb->ataio.aux = auxiliary;
5414                 }
5415
5416                 if (ata_flags & AP_FLAG_CHK_COND)
5417                         ccb->ataio.cmd.flags |= CAM_ATAIO_NEEDRESULT;
5418
5419                 if ((protocol & AP_PROTO_MASK) == AP_PROTO_DMA)
5420                         ccb->ataio.cmd.flags |= CAM_ATAIO_DMA;
5421                 else if ((protocol & AP_PROTO_MASK) == AP_PROTO_FPDMA)
5422                         ccb->ataio.cmd.flags |= CAM_ATAIO_FPDMA;
5423         } else {
5424                 if (is48bit || lba > ATA_MAX_28BIT_LBA)
5425                         protocol |= AP_EXTEND;
5426
5427                 retval = scsi_ata_pass(&ccb->csio,
5428                     /*retries*/ retry_count,
5429                     /*cbfcnp*/ NULL,
5430                     /*flags*/ flags,
5431                     /*tag_action*/ tag_action,
5432                     /*protocol*/ protocol,
5433                     /*ata_flags*/ ata_flags,
5434                     /*features*/ features,
5435                     /*sector_count*/ sector_count,
5436                     /*lba*/ lba,
5437                     /*command*/ command,
5438                     /*device*/ 0,
5439                     /*icc*/ 0,
5440                     /*auxiliary*/ auxiliary,
5441                     /*control*/ 0,
5442                     /*data_ptr*/ data_ptr,
5443                     /*dxfer_len*/ dxfer_len,
5444                     /*cdb_storage*/ cdb_storage,
5445                     /*cdb_storage_len*/ cdb_storage_len,
5446                     /*minimum_cmd_size*/ 0,
5447                     /*sense_len*/ sense_len,
5448                     /*timeout*/ timeout);
5449         }
5450
5451         return (retval);
5452 }
5453
5454 int
5455 get_ata_status(struct cam_device *dev, union ccb *ccb, uint8_t *error,
5456                uint16_t *count, uint64_t *lba, uint8_t *device, uint8_t *status)
5457 {
5458         int retval = 0;
5459
5460         switch (ccb->ccb_h.func_code) {
5461         case XPT_SCSI_IO: {
5462                 uint8_t opcode;
5463                 int error_code = 0, sense_key = 0, asc = 0, ascq = 0;
5464
5465                 /*
5466                  * In this case, we have SCSI ATA PASS-THROUGH command, 12
5467                  * or 16 byte, and need to see what
5468                  */
5469                 if (ccb->ccb_h.flags & CAM_CDB_POINTER)
5470                         opcode = ccb->csio.cdb_io.cdb_ptr[0];
5471                 else
5472                         opcode = ccb->csio.cdb_io.cdb_bytes[0];
5473                 if ((opcode != ATA_PASS_12)
5474                  && (opcode != ATA_PASS_16)) {
5475                         retval = 1;
5476                         warnx("%s: unsupported opcode %02x", __func__, opcode);
5477                         goto bailout;
5478                 }
5479
5480                 retval = scsi_extract_sense_ccb(ccb, &error_code, &sense_key,
5481                                                 &asc, &ascq);
5482                 /* Note: the _ccb() variant returns 0 for an error */
5483                 if (retval == 0) {
5484                         retval = 1;
5485                         goto bailout;
5486                 } else
5487                         retval = 0;
5488
5489                 switch (error_code) {
5490                 case SSD_DESC_CURRENT_ERROR:
5491                 case SSD_DESC_DEFERRED_ERROR: {
5492                         struct scsi_sense_data_desc *sense;
5493                         struct scsi_sense_ata_ret_desc *desc;
5494                         uint8_t *desc_ptr;
5495
5496                         sense = (struct scsi_sense_data_desc *)
5497                             &ccb->csio.sense_data;
5498
5499                         desc_ptr = scsi_find_desc(sense, ccb->csio.sense_len -
5500                             ccb->csio.sense_resid, SSD_DESC_ATA);
5501                         if (desc_ptr == NULL) {
5502                                 cam_error_print(dev, ccb, CAM_ESF_ALL,
5503                                     CAM_EPF_ALL, stderr);
5504                                 retval = 1;
5505                                 goto bailout;
5506                         }
5507                         desc = (struct scsi_sense_ata_ret_desc *)desc_ptr;
5508
5509                         *error = desc->error;
5510                         *count = (desc->count_15_8 << 8) |
5511                                   desc->count_7_0;
5512                         *lba = ((uint64_t)desc->lba_47_40 << 40) |
5513                                ((uint64_t)desc->lba_39_32 << 32) |
5514                                ((uint64_t)desc->lba_31_24 << 24) |
5515                                (desc->lba_23_16 << 16) |
5516                                (desc->lba_15_8  <<  8) |
5517                                 desc->lba_7_0;
5518                         *device = desc->device;
5519                         *status = desc->status;
5520
5521                         /*
5522                          * If the extend bit isn't set, the result is for a
5523                          * 12-byte ATA PASS-THROUGH command or a 16 or 32 byte
5524                          * command without the extend bit set.  This means
5525                          * that the device is supposed to return 28-bit
5526                          * status.  The count field is only 8 bits, and the
5527                          * LBA field is only 8 bits.
5528                          */
5529                         if ((desc->flags & SSD_DESC_ATA_FLAG_EXTEND) == 0){
5530                                 *count &= 0xff;
5531                                 *lba &= 0x0fffffff;
5532                         }
5533                         break;
5534                 }
5535                 case SSD_CURRENT_ERROR:
5536                 case SSD_DEFERRED_ERROR: {
5537 #if 0
5538                         struct scsi_sense_data_fixed *sense;
5539 #endif
5540                         /*
5541                          * XXX KDM need to support fixed sense data.
5542                          */
5543                         warnx("%s: Fixed sense data not supported yet",
5544                             __func__);
5545                         retval = 1;
5546                         goto bailout;
5547                         break; /*NOTREACHED*/
5548                 }
5549                 default:
5550                         retval = 1;
5551                         goto bailout;
5552                         break;
5553                 }
5554
5555                 break;
5556         }
5557         case XPT_ATA_IO: {
5558                 struct ata_res *res;
5559
5560                 /*
5561                  * In this case, we have an ATA command, and we need to
5562                  * fill in the requested values from the result register
5563                  * set.
5564                  */
5565                 res = &ccb->ataio.res;
5566                 *error = res->error;
5567                 *status = res->status;
5568                 *device = res->device;
5569                 *count = res->sector_count;
5570                 *lba = (res->lba_high << 16) |
5571                        (res->lba_mid << 8) |
5572                        (res->lba_low);
5573                 if (res->flags & CAM_ATAIO_48BIT) {
5574                         *count |= (res->sector_count_exp << 8);
5575                         *lba |= ((uint64_t)res->lba_low_exp << 24) |
5576                                 ((uint64_t)res->lba_mid_exp << 32) |
5577                                 ((uint64_t)res->lba_high_exp << 40);
5578                 } else {
5579                         *lba |= (res->device & 0xf) << 24;
5580                 }
5581                 break;
5582         }
5583         default:
5584                 retval = 1;
5585                 break;
5586         }
5587 bailout:
5588         return (retval);
5589 }
5590
5591 static void
5592 cpi_print(struct ccb_pathinq *cpi)
5593 {
5594         char adapter_str[1024];
5595         uint64_t i;
5596
5597         snprintf(adapter_str, sizeof(adapter_str),
5598                  "%s%d:", cpi->dev_name, cpi->unit_number);
5599
5600         fprintf(stdout, "%s SIM/HBA version: %d\n", adapter_str,
5601                 cpi->version_num);
5602
5603         for (i = 1; i < UINT8_MAX; i = i << 1) {
5604                 const char *str;
5605
5606                 if ((i & cpi->hba_inquiry) == 0)
5607                         continue;
5608
5609                 fprintf(stdout, "%s supports ", adapter_str);
5610
5611                 switch(i) {
5612                 case PI_MDP_ABLE:
5613                         str = "MDP message";
5614                         break;
5615                 case PI_WIDE_32:
5616                         str = "32 bit wide SCSI";
5617                         break;
5618                 case PI_WIDE_16:
5619                         str = "16 bit wide SCSI";
5620                         break;
5621                 case PI_SDTR_ABLE:
5622                         str = "SDTR message";
5623                         break;
5624                 case PI_LINKED_CDB:
5625                         str = "linked CDBs";
5626                         break;
5627                 case PI_TAG_ABLE:
5628                         str = "tag queue messages";
5629                         break;
5630                 case PI_SOFT_RST:
5631                         str = "soft reset alternative";
5632                         break;
5633                 case PI_SATAPM:
5634                         str = "SATA Port Multiplier";
5635                         break;
5636                 default:
5637                         str = "unknown PI bit set";
5638                         break;
5639                 }
5640                 fprintf(stdout, "%s\n", str);
5641         }
5642
5643         for (i = 1; i < UINT32_MAX; i = i << 1) {
5644                 const char *str;
5645
5646                 if ((i & cpi->hba_misc) == 0)
5647                         continue;
5648
5649                 fprintf(stdout, "%s ", adapter_str);
5650
5651                 switch(i) {
5652                 case PIM_ATA_EXT:
5653                         str = "can understand ata_ext requests";
5654                         break;
5655                 case PIM_EXTLUNS:
5656                         str = "64bit extended LUNs supported";
5657                         break;
5658                 case PIM_SCANHILO:
5659                         str = "bus scans from high ID to low ID";
5660                         break;
5661                 case PIM_NOREMOVE:
5662                         str = "removable devices not included in scan";
5663                         break;
5664                 case PIM_NOINITIATOR:
5665                         str = "initiator role not supported";
5666                         break;
5667                 case PIM_NOBUSRESET:
5668                         str = "user has disabled initial BUS RESET or"
5669                               " controller is in target/mixed mode";
5670                         break;
5671                 case PIM_NO_6_BYTE:
5672                         str = "do not send 6-byte commands";
5673                         break;
5674                 case PIM_SEQSCAN:
5675                         str = "scan bus sequentially";
5676                         break;
5677                 case PIM_UNMAPPED:
5678                         str = "unmapped I/O supported";
5679                         break;
5680                 case PIM_NOSCAN:
5681                         str = "does its own scanning";
5682                         break;
5683                 default:
5684                         str = "unknown PIM bit set";
5685                         break;
5686                 }
5687                 fprintf(stdout, "%s\n", str);
5688         }
5689
5690         for (i = 1; i < UINT16_MAX; i = i << 1) {
5691                 const char *str;
5692
5693                 if ((i & cpi->target_sprt) == 0)
5694                         continue;
5695
5696                 fprintf(stdout, "%s supports ", adapter_str);
5697                 switch(i) {
5698                 case PIT_PROCESSOR:
5699                         str = "target mode processor mode";
5700                         break;
5701                 case PIT_PHASE:
5702                         str = "target mode phase cog. mode";
5703                         break;
5704                 case PIT_DISCONNECT:
5705                         str = "disconnects in target mode";
5706                         break;
5707                 case PIT_TERM_IO:
5708                         str = "terminate I/O message in target mode";
5709                         break;
5710                 case PIT_GRP_6:
5711                         str = "group 6 commands in target mode";
5712                         break;
5713                 case PIT_GRP_7:
5714                         str = "group 7 commands in target mode";
5715                         break;
5716                 default:
5717                         str = "unknown PIT bit set";
5718                         break;
5719                 }
5720
5721                 fprintf(stdout, "%s\n", str);
5722         }
5723         fprintf(stdout, "%s HBA engine count: %d\n", adapter_str,
5724                 cpi->hba_eng_cnt);
5725         fprintf(stdout, "%s maximum target: %d\n", adapter_str,
5726                 cpi->max_target);
5727         fprintf(stdout, "%s maximum LUN: %d\n", adapter_str,
5728                 cpi->max_lun);
5729         fprintf(stdout, "%s highest path ID in subsystem: %d\n",
5730                 adapter_str, cpi->hpath_id);
5731         fprintf(stdout, "%s initiator ID: %d\n", adapter_str,
5732                 cpi->initiator_id);
5733         fprintf(stdout, "%s SIM vendor: %s\n", adapter_str, cpi->sim_vid);
5734         fprintf(stdout, "%s HBA vendor: %s\n", adapter_str, cpi->hba_vid);
5735         fprintf(stdout, "%s HBA vendor ID: 0x%04x\n",
5736             adapter_str, cpi->hba_vendor);
5737         fprintf(stdout, "%s HBA device ID: 0x%04x\n",
5738             adapter_str, cpi->hba_device);
5739         fprintf(stdout, "%s HBA subvendor ID: 0x%04x\n",
5740             adapter_str, cpi->hba_subvendor);
5741         fprintf(stdout, "%s HBA subdevice ID: 0x%04x\n",
5742             adapter_str, cpi->hba_subdevice);
5743         fprintf(stdout, "%s bus ID: %d\n", adapter_str, cpi->bus_id);
5744         fprintf(stdout, "%s base transfer speed: ", adapter_str);
5745         if (cpi->base_transfer_speed > 1000)
5746                 fprintf(stdout, "%d.%03dMB/sec\n",
5747                         cpi->base_transfer_speed / 1000,
5748                         cpi->base_transfer_speed % 1000);
5749         else
5750                 fprintf(stdout, "%dKB/sec\n",
5751                         (cpi->base_transfer_speed % 1000) * 1000);
5752         fprintf(stdout, "%s maximum transfer size: %u bytes\n",
5753             adapter_str, cpi->maxio);
5754 }
5755
5756 static int
5757 get_print_cts(struct cam_device *device, int user_settings, int quiet,
5758               struct ccb_trans_settings *cts)
5759 {
5760         int retval;
5761         union ccb *ccb;
5762
5763         retval = 0;
5764         ccb = cam_getccb(device);
5765
5766         if (ccb == NULL) {
5767                 warnx("get_print_cts: error allocating ccb");
5768                 return (1);
5769         }
5770
5771         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->cts);
5772
5773         ccb->ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
5774
5775         if (user_settings == 0)
5776                 ccb->cts.type = CTS_TYPE_CURRENT_SETTINGS;
5777         else
5778                 ccb->cts.type = CTS_TYPE_USER_SETTINGS;
5779
5780         if (cam_send_ccb(device, ccb) < 0) {
5781                 perror("error sending XPT_GET_TRAN_SETTINGS CCB");
5782                 if (arglist & CAM_ARG_VERBOSE)
5783                         cam_error_print(device, ccb, CAM_ESF_ALL,
5784                                         CAM_EPF_ALL, stderr);
5785                 retval = 1;
5786                 goto get_print_cts_bailout;
5787         }
5788
5789         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
5790                 warnx("XPT_GET_TRANS_SETTINGS CCB failed");
5791                 if (arglist & CAM_ARG_VERBOSE)
5792                         cam_error_print(device, ccb, CAM_ESF_ALL,
5793                                         CAM_EPF_ALL, stderr);
5794                 retval = 1;
5795                 goto get_print_cts_bailout;
5796         }
5797
5798         if (quiet == 0)
5799                 cts_print(device, &ccb->cts);
5800
5801         if (cts != NULL)
5802                 bcopy(&ccb->cts, cts, sizeof(struct ccb_trans_settings));
5803
5804 get_print_cts_bailout:
5805
5806         cam_freeccb(ccb);
5807
5808         return (retval);
5809 }
5810
5811 static int
5812 ratecontrol(struct cam_device *device, int task_attr, int retry_count,
5813             int timeout, int argc, char **argv, char *combinedopt)
5814 {
5815         int c;
5816         union ccb *ccb;
5817         int user_settings = 0;
5818         int retval = 0;
5819         int disc_enable = -1, tag_enable = -1;
5820         int mode = -1;
5821         int offset = -1;
5822         double syncrate = -1;
5823         int bus_width = -1;
5824         int quiet = 0;
5825         int change_settings = 0, send_tur = 0;
5826         struct ccb_pathinq cpi;
5827
5828         ccb = cam_getccb(device);
5829         if (ccb == NULL) {
5830                 warnx("ratecontrol: error allocating ccb");
5831                 return (1);
5832         }
5833         while ((c = getopt(argc, argv, combinedopt)) != -1) {
5834                 switch(c){
5835                 case 'a':
5836                         send_tur = 1;
5837                         break;
5838                 case 'c':
5839                         user_settings = 0;
5840                         break;
5841                 case 'D':
5842                         if (strncasecmp(optarg, "enable", 6) == 0)
5843                                 disc_enable = 1;
5844                         else if (strncasecmp(optarg, "disable", 7) == 0)
5845                                 disc_enable = 0;
5846                         else {
5847                                 warnx("-D argument \"%s\" is unknown", optarg);
5848                                 retval = 1;
5849                                 goto ratecontrol_bailout;
5850                         }
5851                         change_settings = 1;
5852                         break;
5853                 case 'M':
5854                         mode = ata_string2mode(optarg);
5855                         if (mode < 0) {
5856                                 warnx("unknown mode '%s'", optarg);
5857                                 retval = 1;
5858                                 goto ratecontrol_bailout;
5859                         }
5860                         change_settings = 1;
5861                         break;
5862                 case 'O':
5863                         offset = strtol(optarg, NULL, 0);
5864                         if (offset < 0) {
5865                                 warnx("offset value %d is < 0", offset);
5866                                 retval = 1;
5867                                 goto ratecontrol_bailout;
5868                         }
5869                         change_settings = 1;
5870                         break;
5871                 case 'q':
5872                         quiet++;
5873                         break;
5874                 case 'R':
5875                         syncrate = atof(optarg);
5876                         if (syncrate < 0) {
5877                                 warnx("sync rate %f is < 0", syncrate);
5878                                 retval = 1;
5879                                 goto ratecontrol_bailout;
5880                         }
5881                         change_settings = 1;
5882                         break;
5883                 case 'T':
5884                         if (strncasecmp(optarg, "enable", 6) == 0)
5885                                 tag_enable = 1;
5886                         else if (strncasecmp(optarg, "disable", 7) == 0)
5887                                 tag_enable = 0;
5888                         else {
5889                                 warnx("-T argument \"%s\" is unknown", optarg);
5890                                 retval = 1;
5891                                 goto ratecontrol_bailout;
5892                         }
5893                         change_settings = 1;
5894                         break;
5895                 case 'U':
5896                         user_settings = 1;
5897                         break;
5898                 case 'W':
5899                         bus_width = strtol(optarg, NULL, 0);
5900                         if (bus_width < 0) {
5901                                 warnx("bus width %d is < 0", bus_width);
5902                                 retval = 1;
5903                                 goto ratecontrol_bailout;
5904                         }
5905                         change_settings = 1;
5906                         break;
5907                 default:
5908                         break;
5909                 }
5910         }
5911         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->cpi);
5912         /*
5913          * Grab path inquiry information, so we can determine whether
5914          * or not the initiator is capable of the things that the user
5915          * requests.
5916          */
5917         ccb->ccb_h.func_code = XPT_PATH_INQ;
5918         if (cam_send_ccb(device, ccb) < 0) {
5919                 perror("error sending XPT_PATH_INQ CCB");
5920                 if (arglist & CAM_ARG_VERBOSE) {
5921                         cam_error_print(device, ccb, CAM_ESF_ALL,
5922                                         CAM_EPF_ALL, stderr);
5923                 }
5924                 retval = 1;
5925                 goto ratecontrol_bailout;
5926         }
5927         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
5928                 warnx("XPT_PATH_INQ CCB failed");
5929                 if (arglist & CAM_ARG_VERBOSE) {
5930                         cam_error_print(device, ccb, CAM_ESF_ALL,
5931                                         CAM_EPF_ALL, stderr);
5932                 }
5933                 retval = 1;
5934                 goto ratecontrol_bailout;
5935         }
5936         bcopy(&ccb->cpi, &cpi, sizeof(struct ccb_pathinq));
5937         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->cts);
5938         if (quiet == 0) {
5939                 fprintf(stdout, "%s parameters:\n",
5940                     user_settings ? "User" : "Current");
5941         }
5942         retval = get_print_cts(device, user_settings, quiet, &ccb->cts);
5943         if (retval != 0)
5944                 goto ratecontrol_bailout;
5945
5946         if (arglist & CAM_ARG_VERBOSE)
5947                 cpi_print(&cpi);
5948
5949         if (change_settings) {
5950                 int didsettings = 0;
5951                 struct ccb_trans_settings_spi *spi = NULL;
5952                 struct ccb_trans_settings_pata *pata = NULL;
5953                 struct ccb_trans_settings_sata *sata = NULL;
5954                 struct ccb_trans_settings_ata *ata = NULL;
5955                 struct ccb_trans_settings_scsi *scsi = NULL;
5956
5957                 if (ccb->cts.transport == XPORT_SPI)
5958                         spi = &ccb->cts.xport_specific.spi;
5959                 if (ccb->cts.transport == XPORT_ATA)
5960                         pata = &ccb->cts.xport_specific.ata;
5961                 if (ccb->cts.transport == XPORT_SATA)
5962                         sata = &ccb->cts.xport_specific.sata;
5963                 if (ccb->cts.protocol == PROTO_ATA)
5964                         ata = &ccb->cts.proto_specific.ata;
5965                 if (ccb->cts.protocol == PROTO_SCSI)
5966                         scsi = &ccb->cts.proto_specific.scsi;
5967                 ccb->cts.xport_specific.valid = 0;
5968                 ccb->cts.proto_specific.valid = 0;
5969                 if (spi && disc_enable != -1) {
5970                         spi->valid |= CTS_SPI_VALID_DISC;
5971                         if (disc_enable == 0)
5972                                 spi->flags &= ~CTS_SPI_FLAGS_DISC_ENB;
5973                         else
5974                                 spi->flags |= CTS_SPI_FLAGS_DISC_ENB;
5975                         didsettings++;
5976                 }
5977                 if (tag_enable != -1) {
5978                         if ((cpi.hba_inquiry & PI_TAG_ABLE) == 0) {
5979                                 warnx("HBA does not support tagged queueing, "
5980                                       "so you cannot modify tag settings");
5981                                 retval = 1;
5982                                 goto ratecontrol_bailout;
5983                         }
5984                         if (ata) {
5985                                 ata->valid |= CTS_SCSI_VALID_TQ;
5986                                 if (tag_enable == 0)
5987                                         ata->flags &= ~CTS_ATA_FLAGS_TAG_ENB;
5988                                 else
5989                                         ata->flags |= CTS_ATA_FLAGS_TAG_ENB;
5990                                 didsettings++;
5991                         } else if (scsi) {
5992                                 scsi->valid |= CTS_SCSI_VALID_TQ;
5993                                 if (tag_enable == 0)
5994                                         scsi->flags &= ~CTS_SCSI_FLAGS_TAG_ENB;
5995                                 else
5996                                         scsi->flags |= CTS_SCSI_FLAGS_TAG_ENB;
5997                                 didsettings++;
5998                         }
5999                 }
6000                 if (spi && offset != -1) {
6001                         if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) {
6002                                 warnx("HBA is not capable of changing offset");
6003                                 retval = 1;
6004                                 goto ratecontrol_bailout;
6005                         }
6006                         spi->valid |= CTS_SPI_VALID_SYNC_OFFSET;
6007                         spi->sync_offset = offset;
6008                         didsettings++;
6009                 }
6010                 if (spi && syncrate != -1) {
6011                         int prelim_sync_period;
6012
6013                         if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) {
6014                                 warnx("HBA is not capable of changing "
6015                                       "transfer rates");
6016                                 retval = 1;
6017                                 goto ratecontrol_bailout;
6018                         }
6019                         spi->valid |= CTS_SPI_VALID_SYNC_RATE;
6020                         /*
6021                          * The sync rate the user gives us is in MHz.
6022                          * We need to translate it into KHz for this
6023                          * calculation.
6024                          */
6025                         syncrate *= 1000;
6026                         /*
6027                          * Next, we calculate a "preliminary" sync period
6028                          * in tenths of a nanosecond.
6029                          */
6030                         if (syncrate == 0)
6031                                 prelim_sync_period = 0;
6032                         else
6033                                 prelim_sync_period = 10000000 / syncrate;
6034                         spi->sync_period =
6035                                 scsi_calc_syncparam(prelim_sync_period);
6036                         didsettings++;
6037                 }
6038                 if (sata && syncrate != -1) {
6039                         if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) {
6040                                 warnx("HBA is not capable of changing "
6041                                       "transfer rates");
6042                                 retval = 1;
6043                                 goto ratecontrol_bailout;
6044                         }
6045                         if  (!user_settings) {
6046                                 warnx("You can modify only user rate "
6047                                     "settings for SATA");
6048                                 retval = 1;
6049                                 goto ratecontrol_bailout;
6050                         }
6051                         sata->revision = ata_speed2revision(syncrate * 100);
6052                         if (sata->revision < 0) {
6053                                 warnx("Invalid rate %f", syncrate);
6054                                 retval = 1;
6055                                 goto ratecontrol_bailout;
6056                         }
6057                         sata->valid |= CTS_SATA_VALID_REVISION;
6058                         didsettings++;
6059                 }
6060                 if ((pata || sata) && mode != -1) {
6061                         if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) {
6062                                 warnx("HBA is not capable of changing "
6063                                       "transfer rates");
6064                                 retval = 1;
6065                                 goto ratecontrol_bailout;
6066                         }
6067                         if  (!user_settings) {
6068                                 warnx("You can modify only user mode "
6069                                     "settings for ATA/SATA");
6070                                 retval = 1;
6071                                 goto ratecontrol_bailout;
6072                         }
6073                         if (pata) {
6074                                 pata->mode = mode;
6075                                 pata->valid |= CTS_ATA_VALID_MODE;
6076                         } else {
6077                                 sata->mode = mode;
6078                                 sata->valid |= CTS_SATA_VALID_MODE;
6079                         }
6080                         didsettings++;
6081                 }
6082                 /*
6083                  * The bus_width argument goes like this:
6084                  * 0 == 8 bit
6085                  * 1 == 16 bit
6086                  * 2 == 32 bit
6087                  * Therefore, if you shift the number of bits given on the
6088                  * command line right by 4, you should get the correct
6089                  * number.
6090                  */
6091                 if (spi && bus_width != -1) {
6092                         /*
6093                          * We might as well validate things here with a
6094                          * decipherable error message, rather than what
6095                          * will probably be an indecipherable error message
6096                          * by the time it gets back to us.
6097                          */
6098                         if ((bus_width == 16)
6099                          && ((cpi.hba_inquiry & PI_WIDE_16) == 0)) {
6100                                 warnx("HBA does not support 16 bit bus width");
6101                                 retval = 1;
6102                                 goto ratecontrol_bailout;
6103                         } else if ((bus_width == 32)
6104                                 && ((cpi.hba_inquiry & PI_WIDE_32) == 0)) {
6105                                 warnx("HBA does not support 32 bit bus width");
6106                                 retval = 1;
6107                                 goto ratecontrol_bailout;
6108                         } else if ((bus_width != 8)
6109                                 && (bus_width != 16)
6110                                 && (bus_width != 32)) {
6111                                 warnx("Invalid bus width %d", bus_width);
6112                                 retval = 1;
6113                                 goto ratecontrol_bailout;
6114                         }
6115                         spi->valid |= CTS_SPI_VALID_BUS_WIDTH;
6116                         spi->bus_width = bus_width >> 4;
6117                         didsettings++;
6118                 }
6119                 if  (didsettings == 0) {
6120                         goto ratecontrol_bailout;
6121                 }
6122                 ccb->ccb_h.func_code = XPT_SET_TRAN_SETTINGS;
6123                 if (cam_send_ccb(device, ccb) < 0) {
6124                         perror("error sending XPT_SET_TRAN_SETTINGS CCB");
6125                         if (arglist & CAM_ARG_VERBOSE) {
6126                                 cam_error_print(device, ccb, CAM_ESF_ALL,
6127                                                 CAM_EPF_ALL, stderr);
6128                         }
6129                         retval = 1;
6130                         goto ratecontrol_bailout;
6131                 }
6132                 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
6133                         warnx("XPT_SET_TRANS_SETTINGS CCB failed");
6134                         if (arglist & CAM_ARG_VERBOSE) {
6135                                 cam_error_print(device, ccb, CAM_ESF_ALL,
6136                                                 CAM_EPF_ALL, stderr);
6137                         }
6138                         retval = 1;
6139                         goto ratecontrol_bailout;
6140                 }
6141         }
6142         if (send_tur) {
6143                 retval = testunitready(device, task_attr, retry_count, timeout,
6144                                        (arglist & CAM_ARG_VERBOSE) ? 0 : 1);
6145                 /*
6146                  * If the TUR didn't succeed, just bail.
6147                  */
6148                 if (retval != 0) {
6149                         if (quiet == 0)
6150                                 fprintf(stderr, "Test Unit Ready failed\n");
6151                         goto ratecontrol_bailout;
6152                 }
6153         }
6154         if ((change_settings || send_tur) && !quiet &&
6155             (ccb->cts.transport == XPORT_ATA ||
6156              ccb->cts.transport == XPORT_SATA || send_tur)) {
6157                 fprintf(stdout, "New parameters:\n");
6158                 retval = get_print_cts(device, user_settings, 0, NULL);
6159         }
6160
6161 ratecontrol_bailout:
6162         cam_freeccb(ccb);
6163         return (retval);
6164 }
6165
6166 static int
6167 scsiformat(struct cam_device *device, int argc, char **argv,
6168            char *combinedopt, int task_attr, int retry_count, int timeout)
6169 {
6170         union ccb *ccb;
6171         int c;
6172         int ycount = 0, quiet = 0;
6173         int error = 0, retval = 0;
6174         int use_timeout = 10800 * 1000;
6175         int immediate = 1;
6176         struct format_defect_list_header fh;
6177         u_int8_t *data_ptr = NULL;
6178         u_int32_t dxfer_len = 0;
6179         u_int8_t byte2 = 0;
6180         int num_warnings = 0;
6181         int reportonly = 0;
6182
6183         ccb = cam_getccb(device);
6184
6185         if (ccb == NULL) {
6186                 warnx("scsiformat: error allocating ccb");
6187                 return (1);
6188         }
6189
6190         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
6191
6192         while ((c = getopt(argc, argv, combinedopt)) != -1) {
6193                 switch(c) {
6194                 case 'q':
6195                         quiet++;
6196                         break;
6197                 case 'r':
6198                         reportonly = 1;
6199                         break;
6200                 case 'w':
6201                         immediate = 0;
6202                         break;
6203                 case 'y':
6204                         ycount++;
6205                         break;
6206                 }
6207         }
6208
6209         if (reportonly)
6210                 goto doreport;
6211
6212         if (quiet == 0) {
6213                 fprintf(stdout, "You are about to REMOVE ALL DATA from the "
6214                         "following device:\n");
6215
6216                 error = scsidoinquiry(device, argc, argv, combinedopt,
6217                                       task_attr, retry_count, timeout);
6218
6219                 if (error != 0) {
6220                         warnx("scsiformat: error sending inquiry");
6221                         goto scsiformat_bailout;
6222                 }
6223         }
6224
6225         if (ycount == 0) {
6226                 if (!get_confirmation()) {
6227                         error = 1;
6228                         goto scsiformat_bailout;
6229                 }
6230         }
6231
6232         if (timeout != 0)
6233                 use_timeout = timeout;
6234
6235         if (quiet == 0) {
6236                 fprintf(stdout, "Current format timeout is %d seconds\n",
6237                         use_timeout / 1000);
6238         }
6239
6240         /*
6241          * If the user hasn't disabled questions and didn't specify a
6242          * timeout on the command line, ask them if they want the current
6243          * timeout.
6244          */
6245         if ((ycount == 0)
6246          && (timeout == 0)) {
6247                 char str[1024];
6248                 int new_timeout = 0;
6249
6250                 fprintf(stdout, "Enter new timeout in seconds or press\n"
6251                         "return to keep the current timeout [%d] ",
6252                         use_timeout / 1000);
6253
6254                 if (fgets(str, sizeof(str), stdin) != NULL) {
6255                         if (str[0] != '\0')
6256                                 new_timeout = atoi(str);
6257                 }
6258
6259                 if (new_timeout != 0) {
6260                         use_timeout = new_timeout * 1000;
6261                         fprintf(stdout, "Using new timeout value %d\n",
6262                                 use_timeout / 1000);
6263                 }
6264         }
6265
6266         /*
6267          * Keep this outside the if block below to silence any unused
6268          * variable warnings.
6269          */
6270         bzero(&fh, sizeof(fh));
6271
6272         /*
6273          * If we're in immediate mode, we've got to include the format
6274          * header
6275          */
6276         if (immediate != 0) {
6277                 fh.byte2 = FU_DLH_IMMED;
6278                 data_ptr = (u_int8_t *)&fh;
6279                 dxfer_len = sizeof(fh);
6280                 byte2 = FU_FMT_DATA;
6281         } else if (quiet == 0) {
6282                 fprintf(stdout, "Formatting...");
6283                 fflush(stdout);
6284         }
6285
6286         scsi_format_unit(&ccb->csio,
6287                          /* retries */ retry_count,
6288                          /* cbfcnp */ NULL,
6289                          /* tag_action */ task_attr,
6290                          /* byte2 */ byte2,
6291                          /* ileave */ 0,
6292                          /* data_ptr */ data_ptr,
6293                          /* dxfer_len */ dxfer_len,
6294                          /* sense_len */ SSD_FULL_SIZE,
6295                          /* timeout */ use_timeout);
6296
6297         /* Disable freezing the device queue */
6298         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
6299
6300         if (arglist & CAM_ARG_ERR_RECOVER)
6301                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
6302
6303         if (((retval = cam_send_ccb(device, ccb)) < 0)
6304          || ((immediate == 0)
6305            && ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP))) {
6306                 const char errstr[] = "error sending format command";
6307
6308                 if (retval < 0)
6309                         warn(errstr);
6310                 else
6311                         warnx(errstr);
6312
6313                 if (arglist & CAM_ARG_VERBOSE) {
6314                         cam_error_print(device, ccb, CAM_ESF_ALL,
6315                                         CAM_EPF_ALL, stderr);
6316                 }
6317                 error = 1;
6318                 goto scsiformat_bailout;
6319         }
6320
6321         /*
6322          * If we ran in non-immediate mode, we already checked for errors
6323          * above and printed out any necessary information.  If we're in
6324          * immediate mode, we need to loop through and get status
6325          * information periodically.
6326          */
6327         if (immediate == 0) {
6328                 if (quiet == 0) {
6329                         fprintf(stdout, "Format Complete\n");
6330                 }
6331                 goto scsiformat_bailout;
6332         }
6333
6334 doreport:
6335         do {
6336                 cam_status status;
6337
6338                 CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
6339
6340                 /*
6341                  * There's really no need to do error recovery or
6342                  * retries here, since we're just going to sit in a
6343                  * loop and wait for the device to finish formatting.
6344                  */
6345                 scsi_test_unit_ready(&ccb->csio,
6346                                      /* retries */ 0,
6347                                      /* cbfcnp */ NULL,
6348                                      /* tag_action */ task_attr,
6349                                      /* sense_len */ SSD_FULL_SIZE,
6350                                      /* timeout */ 5000);
6351
6352                 /* Disable freezing the device queue */
6353                 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
6354
6355                 retval = cam_send_ccb(device, ccb);
6356
6357                 /*
6358                  * If we get an error from the ioctl, bail out.  SCSI
6359                  * errors are expected.
6360                  */
6361                 if (retval < 0) {
6362                         warn("error sending CAMIOCOMMAND ioctl");
6363                         if (arglist & CAM_ARG_VERBOSE) {
6364                                 cam_error_print(device, ccb, CAM_ESF_ALL,
6365                                                 CAM_EPF_ALL, stderr);
6366                         }
6367                         error = 1;
6368                         goto scsiformat_bailout;
6369                 }
6370
6371                 status = ccb->ccb_h.status & CAM_STATUS_MASK;
6372
6373                 if ((status != CAM_REQ_CMP)
6374                  && (status == CAM_SCSI_STATUS_ERROR)
6375                  && ((ccb->ccb_h.status & CAM_AUTOSNS_VALID) != 0)) {
6376                         struct scsi_sense_data *sense;
6377                         int error_code, sense_key, asc, ascq;
6378
6379                         sense = &ccb->csio.sense_data;
6380                         scsi_extract_sense_len(sense, ccb->csio.sense_len -
6381                             ccb->csio.sense_resid, &error_code, &sense_key,
6382                             &asc, &ascq, /*show_errors*/ 1);
6383
6384                         /*
6385                          * According to the SCSI-2 and SCSI-3 specs, a
6386                          * drive that is in the middle of a format should
6387                          * return NOT READY with an ASC of "logical unit
6388                          * not ready, format in progress".  The sense key
6389                          * specific bytes will then be a progress indicator.
6390                          */
6391                         if ((sense_key == SSD_KEY_NOT_READY)
6392                          && (asc == 0x04) && (ascq == 0x04)) {
6393                                 uint8_t sks[3];
6394
6395                                 if ((scsi_get_sks(sense, ccb->csio.sense_len -
6396                                      ccb->csio.sense_resid, sks) == 0)
6397                                  && (quiet == 0)) {
6398                                         uint32_t val;
6399                                         u_int64_t percentage;
6400
6401                                         val = scsi_2btoul(&sks[1]);
6402                                         percentage = 10000ull * val;
6403
6404                                         fprintf(stdout,
6405                                                 "\rFormatting:  %ju.%02u %% "
6406                                                 "(%u/%d) done",
6407                                                 (uintmax_t)(percentage /
6408                                                 (0x10000 * 100)),
6409                                                 (unsigned)((percentage /
6410                                                 0x10000) % 100),
6411                                                 val, 0x10000);
6412                                         fflush(stdout);
6413                                 } else if ((quiet == 0)
6414                                         && (++num_warnings <= 1)) {
6415                                         warnx("Unexpected SCSI Sense Key "
6416                                               "Specific value returned "
6417                                               "during format:");
6418                                         scsi_sense_print(device, &ccb->csio,
6419                                                          stderr);
6420                                         warnx("Unable to print status "
6421                                               "information, but format will "
6422                                               "proceed.");
6423                                         warnx("will exit when format is "
6424                                               "complete");
6425                                 }
6426                                 sleep(1);
6427                         } else {
6428                                 warnx("Unexpected SCSI error during format");
6429                                 cam_error_print(device, ccb, CAM_ESF_ALL,
6430                                                 CAM_EPF_ALL, stderr);
6431                                 error = 1;
6432                                 goto scsiformat_bailout;
6433                         }
6434
6435                 } else if (status != CAM_REQ_CMP) {
6436                         warnx("Unexpected CAM status %#x", status);
6437                         if (arglist & CAM_ARG_VERBOSE)
6438                                 cam_error_print(device, ccb, CAM_ESF_ALL,
6439                                                 CAM_EPF_ALL, stderr);
6440                         error = 1;
6441                         goto scsiformat_bailout;
6442                 }
6443
6444         } while((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP);
6445
6446         if (quiet == 0)
6447                 fprintf(stdout, "\nFormat Complete\n");
6448
6449 scsiformat_bailout:
6450
6451         cam_freeccb(ccb);
6452
6453         return (error);
6454 }
6455
6456 static int
6457 scsisanitize(struct cam_device *device, int argc, char **argv,
6458              char *combinedopt, int task_attr, int retry_count, int timeout)
6459 {
6460         union ccb *ccb;
6461         u_int8_t action = 0;
6462         int c;
6463         int ycount = 0, quiet = 0;
6464         int error = 0, retval = 0;
6465         int use_timeout = 10800 * 1000;
6466         int immediate = 1;
6467         int invert = 0;
6468         int passes = 0;
6469         int ause = 0;
6470         int fd = -1;
6471         const char *pattern = NULL;
6472         u_int8_t *data_ptr = NULL;
6473         u_int32_t dxfer_len = 0;
6474         u_int8_t byte2 = 0;
6475         int num_warnings = 0;
6476         int reportonly = 0;
6477
6478         ccb = cam_getccb(device);
6479
6480         if (ccb == NULL) {
6481                 warnx("scsisanitize: error allocating ccb");
6482                 return (1);
6483         }
6484
6485         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
6486
6487         while ((c = getopt(argc, argv, combinedopt)) != -1) {
6488                 switch(c) {
6489                 case 'a':
6490                         if (strcasecmp(optarg, "overwrite") == 0)
6491                                 action = SSZ_SERVICE_ACTION_OVERWRITE;
6492                         else if (strcasecmp(optarg, "block") == 0)
6493                                 action = SSZ_SERVICE_ACTION_BLOCK_ERASE;
6494                         else if (strcasecmp(optarg, "crypto") == 0)
6495                                 action = SSZ_SERVICE_ACTION_CRYPTO_ERASE;
6496                         else if (strcasecmp(optarg, "exitfailure") == 0)
6497                                 action = SSZ_SERVICE_ACTION_EXIT_MODE_FAILURE;
6498                         else {
6499                                 warnx("invalid service operation \"%s\"",
6500                                       optarg);
6501                                 error = 1;
6502                                 goto scsisanitize_bailout;
6503                         }
6504                         break;
6505                 case 'c':
6506                         passes = strtol(optarg, NULL, 0);
6507                         if (passes < 1 || passes > 31) {
6508                                 warnx("invalid passes value %d", passes);
6509                                 error = 1;
6510                                 goto scsisanitize_bailout;
6511                         }
6512                         break;
6513                 case 'I':
6514                         invert = 1;
6515                         break;
6516                 case 'P':
6517                         pattern = optarg;
6518                         break;
6519                 case 'q':
6520                         quiet++;
6521                         break;
6522                 case 'U':
6523                         ause = 1;
6524                         break;
6525                 case 'r':
6526                         reportonly = 1;
6527                         break;
6528                 case 'w':
6529                         immediate = 0;
6530                         break;
6531                 case 'y':
6532                         ycount++;
6533                         break;
6534                 }
6535         }
6536
6537         if (reportonly)
6538                 goto doreport;
6539
6540         if (action == 0) {
6541                 warnx("an action is required");
6542                 error = 1;
6543                 goto scsisanitize_bailout;
6544         } else if (action == SSZ_SERVICE_ACTION_OVERWRITE) {
6545                 struct scsi_sanitize_parameter_list *pl;
6546                 struct stat sb;
6547                 ssize_t sz, amt;
6548
6549                 if (pattern == NULL) {
6550                         warnx("overwrite action requires -P argument");
6551                         error = 1;
6552                         goto scsisanitize_bailout;
6553                 }
6554                 fd = open(pattern, O_RDONLY);
6555                 if (fd < 0) {
6556                         warn("cannot open pattern file %s", pattern);
6557                         error = 1;
6558                         goto scsisanitize_bailout;
6559                 }
6560                 if (fstat(fd, &sb) < 0) {
6561                         warn("cannot stat pattern file %s", pattern);
6562                         error = 1;
6563                         goto scsisanitize_bailout;
6564                 }
6565                 sz = sb.st_size;
6566                 if (sz > SSZPL_MAX_PATTERN_LENGTH) {
6567                         warnx("pattern file size exceeds maximum value %d",
6568                               SSZPL_MAX_PATTERN_LENGTH);
6569                         error = 1;
6570                         goto scsisanitize_bailout;
6571                 }
6572                 dxfer_len = sizeof(*pl) + sz;
6573                 data_ptr = calloc(1, dxfer_len);
6574                 if (data_ptr == NULL) {
6575                         warnx("cannot allocate parameter list buffer");
6576                         error = 1;
6577                         goto scsisanitize_bailout;
6578                 }
6579
6580                 amt = read(fd, data_ptr + sizeof(*pl), sz);
6581                 if (amt < 0) {
6582                         warn("cannot read pattern file");
6583                         error = 1;
6584                         goto scsisanitize_bailout;
6585                 } else if (amt != sz) {
6586                         warnx("short pattern file read");
6587                         error = 1;
6588                         goto scsisanitize_bailout;
6589                 }
6590
6591                 pl = (struct scsi_sanitize_parameter_list *)data_ptr;
6592                 if (passes == 0)
6593                         pl->byte1 = 1;
6594                 else
6595                         pl->byte1 = passes;
6596                 if (invert != 0)
6597                         pl->byte1 |= SSZPL_INVERT;
6598                 scsi_ulto2b(sz, pl->length);
6599         } else {
6600                 const char *arg;
6601
6602                 if (passes != 0)
6603                         arg = "-c";
6604                 else if (invert != 0)
6605                         arg = "-I";
6606                 else if (pattern != NULL)
6607                         arg = "-P";
6608                 else
6609                         arg = NULL;
6610                 if (arg != NULL) {
6611                         warnx("%s argument only valid with overwrite "
6612                               "operation", arg);
6613                         error = 1;
6614                         goto scsisanitize_bailout;
6615                 }
6616         }
6617
6618         if (quiet == 0) {
6619                 fprintf(stdout, "You are about to REMOVE ALL DATA from the "
6620                         "following device:\n");
6621
6622                 error = scsidoinquiry(device, argc, argv, combinedopt,
6623                                       task_attr, retry_count, timeout);
6624
6625                 if (error != 0) {
6626                         warnx("scsisanitize: error sending inquiry");
6627                         goto scsisanitize_bailout;
6628                 }
6629         }
6630
6631         if (ycount == 0) {
6632                 if (!get_confirmation()) {
6633                         error = 1;
6634                         goto scsisanitize_bailout;
6635                 }
6636         }
6637
6638         if (timeout != 0)
6639                 use_timeout = timeout;
6640
6641         if (quiet == 0) {
6642                 fprintf(stdout, "Current sanitize timeout is %d seconds\n",
6643                         use_timeout / 1000);
6644         }
6645
6646         /*
6647          * If the user hasn't disabled questions and didn't specify a
6648          * timeout on the command line, ask them if they want the current
6649          * timeout.
6650          */
6651         if ((ycount == 0)
6652          && (timeout == 0)) {
6653                 char str[1024];
6654                 int new_timeout = 0;
6655
6656                 fprintf(stdout, "Enter new timeout in seconds or press\n"
6657                         "return to keep the current timeout [%d] ",
6658                         use_timeout / 1000);
6659
6660                 if (fgets(str, sizeof(str), stdin) != NULL) {
6661                         if (str[0] != '\0')
6662                                 new_timeout = atoi(str);
6663                 }
6664
6665                 if (new_timeout != 0) {
6666                         use_timeout = new_timeout * 1000;
6667                         fprintf(stdout, "Using new timeout value %d\n",
6668                                 use_timeout / 1000);
6669                 }
6670         }
6671
6672         byte2 = action;
6673         if (ause != 0)
6674                 byte2 |= SSZ_UNRESTRICTED_EXIT;
6675         if (immediate != 0)
6676                 byte2 |= SSZ_IMMED;
6677
6678         scsi_sanitize(&ccb->csio,
6679                       /* retries */ retry_count,
6680                       /* cbfcnp */ NULL,
6681                       /* tag_action */ task_attr,
6682                       /* byte2 */ byte2,
6683                       /* control */ 0,
6684                       /* data_ptr */ data_ptr,
6685                       /* dxfer_len */ dxfer_len,
6686                       /* sense_len */ SSD_FULL_SIZE,
6687                       /* timeout */ use_timeout);
6688
6689         /* Disable freezing the device queue */
6690         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
6691
6692         if (arglist & CAM_ARG_ERR_RECOVER)
6693                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
6694
6695         if (cam_send_ccb(device, ccb) < 0) {
6696                 warn("error sending sanitize command");
6697                 error = 1;
6698                 goto scsisanitize_bailout;
6699         }
6700
6701         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
6702                 struct scsi_sense_data *sense;
6703                 int error_code, sense_key, asc, ascq;
6704
6705                 if ((ccb->ccb_h.status & CAM_STATUS_MASK) ==
6706                     CAM_SCSI_STATUS_ERROR) {
6707                         sense = &ccb->csio.sense_data;
6708                         scsi_extract_sense_len(sense, ccb->csio.sense_len -
6709                             ccb->csio.sense_resid, &error_code, &sense_key,
6710                             &asc, &ascq, /*show_errors*/ 1);
6711
6712                         if (sense_key == SSD_KEY_ILLEGAL_REQUEST &&
6713                             asc == 0x20 && ascq == 0x00)
6714                                 warnx("sanitize is not supported by "
6715                                       "this device");
6716                         else
6717                                 warnx("error sanitizing this device");
6718                 } else
6719                         warnx("error sanitizing this device");
6720
6721                 if (arglist & CAM_ARG_VERBOSE) {
6722                         cam_error_print(device, ccb, CAM_ESF_ALL,
6723                                         CAM_EPF_ALL, stderr);
6724                 }
6725                 error = 1;
6726                 goto scsisanitize_bailout;
6727         }
6728
6729         /*
6730          * If we ran in non-immediate mode, we already checked for errors
6731          * above and printed out any necessary information.  If we're in
6732          * immediate mode, we need to loop through and get status
6733          * information periodically.
6734          */
6735         if (immediate == 0) {
6736                 if (quiet == 0) {
6737                         fprintf(stdout, "Sanitize Complete\n");
6738                 }
6739                 goto scsisanitize_bailout;
6740         }
6741
6742 doreport:
6743         do {
6744                 cam_status status;
6745
6746                 CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
6747
6748                 /*
6749                  * There's really no need to do error recovery or
6750                  * retries here, since we're just going to sit in a
6751                  * loop and wait for the device to finish sanitizing.
6752                  */
6753                 scsi_test_unit_ready(&ccb->csio,
6754                                      /* retries */ 0,
6755                                      /* cbfcnp */ NULL,
6756                                      /* tag_action */ task_attr,
6757                                      /* sense_len */ SSD_FULL_SIZE,
6758                                      /* timeout */ 5000);
6759
6760                 /* Disable freezing the device queue */
6761                 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
6762
6763                 retval = cam_send_ccb(device, ccb);
6764
6765                 /*
6766                  * If we get an error from the ioctl, bail out.  SCSI
6767                  * errors are expected.
6768                  */
6769                 if (retval < 0) {
6770                         warn("error sending CAMIOCOMMAND ioctl");
6771                         if (arglist & CAM_ARG_VERBOSE) {
6772                                 cam_error_print(device, ccb, CAM_ESF_ALL,
6773                                                 CAM_EPF_ALL, stderr);
6774                         }
6775                         error = 1;
6776                         goto scsisanitize_bailout;
6777                 }
6778
6779                 status = ccb->ccb_h.status & CAM_STATUS_MASK;
6780
6781                 if ((status != CAM_REQ_CMP)
6782                  && (status == CAM_SCSI_STATUS_ERROR)
6783                  && ((ccb->ccb_h.status & CAM_AUTOSNS_VALID) != 0)) {
6784                         struct scsi_sense_data *sense;
6785                         int error_code, sense_key, asc, ascq;
6786
6787                         sense = &ccb->csio.sense_data;
6788                         scsi_extract_sense_len(sense, ccb->csio.sense_len -
6789                             ccb->csio.sense_resid, &error_code, &sense_key,
6790                             &asc, &ascq, /*show_errors*/ 1);
6791
6792                         /*
6793                          * According to the SCSI-3 spec, a drive that is in the
6794                          * middle of a sanitize should return NOT READY with an
6795                          * ASC of "logical unit not ready, sanitize in
6796                          * progress". The sense key specific bytes will then
6797                          * be a progress indicator.
6798                          */
6799                         if ((sense_key == SSD_KEY_NOT_READY)
6800                          && (asc == 0x04) && (ascq == 0x1b)) {
6801                                 uint8_t sks[3];
6802
6803                                 if ((scsi_get_sks(sense, ccb->csio.sense_len -
6804                                      ccb->csio.sense_resid, sks) == 0)
6805                                  && (quiet == 0)) {
6806                                         int val;
6807                                         u_int64_t percentage;
6808
6809                                         val = scsi_2btoul(&sks[1]);
6810                                         percentage = 10000 * val;
6811
6812                                         fprintf(stdout,
6813                                                 "\rSanitizing:  %ju.%02u %% "
6814                                                 "(%d/%d) done",
6815                                                 (uintmax_t)(percentage /
6816                                                 (0x10000 * 100)),
6817                                                 (unsigned)((percentage /
6818                                                 0x10000) % 100),
6819                                                 val, 0x10000);
6820                                         fflush(stdout);
6821                                 } else if ((quiet == 0)
6822                                         && (++num_warnings <= 1)) {
6823                                         warnx("Unexpected SCSI Sense Key "
6824                                               "Specific value returned "
6825                                               "during sanitize:");
6826                                         scsi_sense_print(device, &ccb->csio,
6827                                                          stderr);
6828                                         warnx("Unable to print status "
6829                                               "information, but sanitze will "
6830                                               "proceed.");
6831                                         warnx("will exit when sanitize is "
6832                                               "complete");
6833                                 }
6834                                 sleep(1);
6835                         } else {
6836                                 warnx("Unexpected SCSI error during sanitize");
6837                                 cam_error_print(device, ccb, CAM_ESF_ALL,
6838                                                 CAM_EPF_ALL, stderr);
6839                                 error = 1;
6840                                 goto scsisanitize_bailout;
6841                         }
6842
6843                 } else if (status != CAM_REQ_CMP) {
6844                         warnx("Unexpected CAM status %#x", status);
6845                         if (arglist & CAM_ARG_VERBOSE)
6846                                 cam_error_print(device, ccb, CAM_ESF_ALL,
6847                                                 CAM_EPF_ALL, stderr);
6848                         error = 1;
6849                         goto scsisanitize_bailout;
6850                 }
6851         } while((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP);
6852
6853         if (quiet == 0)
6854                 fprintf(stdout, "\nSanitize Complete\n");
6855
6856 scsisanitize_bailout:
6857         if (fd >= 0)
6858                 close(fd);
6859         if (data_ptr != NULL)
6860                 free(data_ptr);
6861         cam_freeccb(ccb);
6862
6863         return (error);
6864 }
6865
6866 static int
6867 scsireportluns(struct cam_device *device, int argc, char **argv,
6868                char *combinedopt, int task_attr, int retry_count, int timeout)
6869 {
6870         union ccb *ccb;
6871         int c, countonly, lunsonly;
6872         struct scsi_report_luns_data *lundata;
6873         int alloc_len;
6874         uint8_t report_type;
6875         uint32_t list_len, i, j;
6876         int retval;
6877
6878         retval = 0;
6879         lundata = NULL;
6880         report_type = RPL_REPORT_DEFAULT;
6881         ccb = cam_getccb(device);
6882
6883         if (ccb == NULL) {
6884                 warnx("%s: error allocating ccb", __func__);
6885                 return (1);
6886         }
6887
6888         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
6889
6890         countonly = 0;
6891         lunsonly = 0;
6892
6893         while ((c = getopt(argc, argv, combinedopt)) != -1) {
6894                 switch (c) {
6895                 case 'c':
6896                         countonly++;
6897                         break;
6898                 case 'l':
6899                         lunsonly++;
6900                         break;
6901                 case 'r':
6902                         if (strcasecmp(optarg, "default") == 0)
6903                                 report_type = RPL_REPORT_DEFAULT;
6904                         else if (strcasecmp(optarg, "wellknown") == 0)
6905                                 report_type = RPL_REPORT_WELLKNOWN;
6906                         else if (strcasecmp(optarg, "all") == 0)
6907                                 report_type = RPL_REPORT_ALL;
6908                         else {
6909                                 warnx("%s: invalid report type \"%s\"",
6910                                       __func__, optarg);
6911                                 retval = 1;
6912                                 goto bailout;
6913                         }
6914                         break;
6915                 default:
6916                         break;
6917                 }
6918         }
6919
6920         if ((countonly != 0)
6921          && (lunsonly != 0)) {
6922                 warnx("%s: you can only specify one of -c or -l", __func__);
6923                 retval = 1;
6924                 goto bailout;
6925         }
6926         /*
6927          * According to SPC-4, the allocation length must be at least 16
6928          * bytes -- enough for the header and one LUN.
6929          */
6930         alloc_len = sizeof(*lundata) + 8;
6931
6932 retry:
6933
6934         lundata = malloc(alloc_len);
6935
6936         if (lundata == NULL) {
6937                 warn("%s: error mallocing %d bytes", __func__, alloc_len);
6938                 retval = 1;
6939                 goto bailout;
6940         }
6941
6942         scsi_report_luns(&ccb->csio,
6943                          /*retries*/ retry_count,
6944                          /*cbfcnp*/ NULL,
6945                          /*tag_action*/ task_attr,
6946                          /*select_report*/ report_type,
6947                          /*rpl_buf*/ lundata,
6948                          /*alloc_len*/ alloc_len,
6949                          /*sense_len*/ SSD_FULL_SIZE,
6950                          /*timeout*/ timeout ? timeout : 5000);
6951
6952         /* Disable freezing the device queue */
6953         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
6954
6955         if (arglist & CAM_ARG_ERR_RECOVER)
6956                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
6957
6958         if (cam_send_ccb(device, ccb) < 0) {
6959                 warn("error sending REPORT LUNS command");
6960
6961                 if (arglist & CAM_ARG_VERBOSE)
6962                         cam_error_print(device, ccb, CAM_ESF_ALL,
6963                                         CAM_EPF_ALL, stderr);
6964
6965                 retval = 1;
6966                 goto bailout;
6967         }
6968
6969         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
6970                 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr);
6971                 retval = 1;
6972                 goto bailout;
6973         }
6974
6975
6976         list_len = scsi_4btoul(lundata->length);
6977
6978         /*
6979          * If we need to list the LUNs, and our allocation
6980          * length was too short, reallocate and retry.
6981          */
6982         if ((countonly == 0)
6983          && (list_len > (alloc_len - sizeof(*lundata)))) {
6984                 alloc_len = list_len + sizeof(*lundata);
6985                 free(lundata);
6986                 goto retry;
6987         }
6988
6989         if (lunsonly == 0)
6990                 fprintf(stdout, "%u LUN%s found\n", list_len / 8,
6991                         ((list_len / 8) > 1) ? "s" : "");
6992
6993         if (countonly != 0)
6994                 goto bailout;
6995
6996         for (i = 0; i < (list_len / 8); i++) {
6997                 int no_more;
6998
6999                 no_more = 0;
7000                 for (j = 0; j < sizeof(lundata->luns[i].lundata); j += 2) {
7001                         if (j != 0)
7002                                 fprintf(stdout, ",");
7003                         switch (lundata->luns[i].lundata[j] &
7004                                 RPL_LUNDATA_ATYP_MASK) {
7005                         case RPL_LUNDATA_ATYP_PERIPH:
7006                                 if ((lundata->luns[i].lundata[j] &
7007                                     RPL_LUNDATA_PERIPH_BUS_MASK) != 0)
7008                                         fprintf(stdout, "%d:",
7009                                                 lundata->luns[i].lundata[j] &
7010                                                 RPL_LUNDATA_PERIPH_BUS_MASK);
7011                                 else if ((j == 0)
7012                                       && ((lundata->luns[i].lundata[j+2] &
7013                                           RPL_LUNDATA_PERIPH_BUS_MASK) == 0))
7014                                         no_more = 1;
7015
7016                                 fprintf(stdout, "%d",
7017                                         lundata->luns[i].lundata[j+1]);
7018                                 break;
7019                         case RPL_LUNDATA_ATYP_FLAT: {
7020                                 uint8_t tmplun[2];
7021                                 tmplun[0] = lundata->luns[i].lundata[j] &
7022                                         RPL_LUNDATA_FLAT_LUN_MASK;
7023                                 tmplun[1] = lundata->luns[i].lundata[j+1];
7024
7025                                 fprintf(stdout, "%d", scsi_2btoul(tmplun));
7026                                 no_more = 1;
7027                                 break;
7028                         }
7029                         case RPL_LUNDATA_ATYP_LUN:
7030                                 fprintf(stdout, "%d:%d:%d",
7031                                         (lundata->luns[i].lundata[j+1] &
7032                                         RPL_LUNDATA_LUN_BUS_MASK) >> 5,
7033                                         lundata->luns[i].lundata[j] &
7034                                         RPL_LUNDATA_LUN_TARG_MASK,
7035                                         lundata->luns[i].lundata[j+1] &
7036                                         RPL_LUNDATA_LUN_LUN_MASK);
7037                                 break;
7038                         case RPL_LUNDATA_ATYP_EXTLUN: {
7039                                 int field_len_code, eam_code;
7040
7041                                 eam_code = lundata->luns[i].lundata[j] &
7042                                         RPL_LUNDATA_EXT_EAM_MASK;
7043                                 field_len_code = (lundata->luns[i].lundata[j] &
7044                                         RPL_LUNDATA_EXT_LEN_MASK) >> 4;
7045
7046                                 if ((eam_code == RPL_LUNDATA_EXT_EAM_WK)
7047                                  && (field_len_code == 0x00)) {
7048                                         fprintf(stdout, "%d",
7049                                                 lundata->luns[i].lundata[j+1]);
7050                                 } else if ((eam_code ==
7051                                             RPL_LUNDATA_EXT_EAM_NOT_SPEC)
7052                                         && (field_len_code == 0x03)) {
7053                                         uint8_t tmp_lun[8];
7054
7055                                         /*
7056                                          * This format takes up all 8 bytes.
7057                                          * If we aren't starting at offset 0,
7058                                          * that's a bug.
7059                                          */
7060                                         if (j != 0) {
7061                                                 fprintf(stdout, "Invalid "
7062                                                         "offset %d for "
7063                                                         "Extended LUN not "
7064                                                         "specified format", j);
7065                                                 no_more = 1;
7066                                                 break;
7067                                         }
7068                                         bzero(tmp_lun, sizeof(tmp_lun));
7069                                         bcopy(&lundata->luns[i].lundata[j+1],
7070                                               &tmp_lun[1], sizeof(tmp_lun) - 1);
7071                                         fprintf(stdout, "%#jx",
7072                                                (intmax_t)scsi_8btou64(tmp_lun));
7073                                         no_more = 1;
7074                                 } else {
7075                                         fprintf(stderr, "Unknown Extended LUN"
7076                                                 "Address method %#x, length "
7077                                                 "code %#x", eam_code,
7078                                                 field_len_code);
7079                                         no_more = 1;
7080                                 }
7081                                 break;
7082                         }
7083                         default:
7084                                 fprintf(stderr, "Unknown LUN address method "
7085                                         "%#x\n", lundata->luns[i].lundata[0] &
7086                                         RPL_LUNDATA_ATYP_MASK);
7087                                 break;
7088                         }
7089                         /*
7090                          * For the flat addressing method, there are no
7091                          * other levels after it.
7092                          */
7093                         if (no_more != 0)
7094                                 break;
7095                 }
7096                 fprintf(stdout, "\n");
7097         }
7098
7099 bailout:
7100
7101         cam_freeccb(ccb);
7102
7103         free(lundata);
7104
7105         return (retval);
7106 }
7107
7108 static int
7109 scsireadcapacity(struct cam_device *device, int argc, char **argv,
7110                  char *combinedopt, int task_attr, int retry_count, int timeout)
7111 {
7112         union ccb *ccb;
7113         int blocksizeonly, humanize, numblocks, quiet, sizeonly, baseten;
7114         struct scsi_read_capacity_data rcap;
7115         struct scsi_read_capacity_data_long rcaplong;
7116         uint64_t maxsector;
7117         uint32_t block_len;
7118         int retval;
7119         int c;
7120
7121         blocksizeonly = 0;
7122         humanize = 0;
7123         numblocks = 0;
7124         quiet = 0;
7125         sizeonly = 0;
7126         baseten = 0;
7127         retval = 0;
7128
7129         ccb = cam_getccb(device);
7130
7131         if (ccb == NULL) {
7132                 warnx("%s: error allocating ccb", __func__);
7133                 return (1);
7134         }
7135
7136         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
7137
7138         while ((c = getopt(argc, argv, combinedopt)) != -1) {
7139                 switch (c) {
7140                 case 'b':
7141                         blocksizeonly++;
7142                         break;
7143                 case 'h':
7144                         humanize++;
7145                         baseten = 0;
7146                         break;
7147                 case 'H':
7148                         humanize++;
7149                         baseten++;
7150                         break;
7151                 case 'N':
7152                         numblocks++;
7153                         break;
7154                 case 'q':
7155                         quiet++;
7156                         break;
7157                 case 's':
7158                         sizeonly++;
7159                         break;
7160                 default:
7161                         break;
7162                 }
7163         }
7164
7165         if ((blocksizeonly != 0)
7166          && (numblocks != 0)) {
7167                 warnx("%s: you can only specify one of -b or -N", __func__);
7168                 retval = 1;
7169                 goto bailout;
7170         }
7171
7172         if ((blocksizeonly != 0)
7173          && (sizeonly != 0)) {
7174                 warnx("%s: you can only specify one of -b or -s", __func__);
7175                 retval = 1;
7176                 goto bailout;
7177         }
7178
7179         if ((humanize != 0)
7180          && (quiet != 0)) {
7181                 warnx("%s: you can only specify one of -h/-H or -q", __func__);
7182                 retval = 1;
7183                 goto bailout;
7184         }
7185
7186         if ((humanize != 0)
7187          && (blocksizeonly != 0)) {
7188                 warnx("%s: you can only specify one of -h/-H or -b", __func__);
7189                 retval = 1;
7190                 goto bailout;
7191         }
7192
7193         scsi_read_capacity(&ccb->csio,
7194                            /*retries*/ retry_count,
7195                            /*cbfcnp*/ NULL,
7196                            /*tag_action*/ task_attr,
7197                            &rcap,
7198                            SSD_FULL_SIZE,
7199                            /*timeout*/ timeout ? timeout : 5000);
7200
7201         /* Disable freezing the device queue */
7202         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
7203
7204         if (arglist & CAM_ARG_ERR_RECOVER)
7205                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
7206
7207         if (cam_send_ccb(device, ccb) < 0) {
7208                 warn("error sending READ CAPACITY command");
7209
7210                 if (arglist & CAM_ARG_VERBOSE)
7211                         cam_error_print(device, ccb, CAM_ESF_ALL,
7212                                         CAM_EPF_ALL, stderr);
7213
7214                 retval = 1;
7215                 goto bailout;
7216         }
7217
7218         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
7219                 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr);
7220                 retval = 1;
7221                 goto bailout;
7222         }
7223
7224         maxsector = scsi_4btoul(rcap.addr);
7225         block_len = scsi_4btoul(rcap.length);
7226
7227         /*
7228          * A last block of 2^32-1 means that the true capacity is over 2TB,
7229          * and we need to issue the long READ CAPACITY to get the real
7230          * capacity.  Otherwise, we're all set.
7231          */
7232         if (maxsector != 0xffffffff)
7233                 goto do_print;
7234
7235         scsi_read_capacity_16(&ccb->csio,
7236                               /*retries*/ retry_count,
7237                               /*cbfcnp*/ NULL,
7238                               /*tag_action*/ task_attr,
7239                               /*lba*/ 0,
7240                               /*reladdr*/ 0,
7241                               /*pmi*/ 0,
7242                               /*rcap_buf*/ (uint8_t *)&rcaplong,
7243                               /*rcap_buf_len*/ sizeof(rcaplong),
7244                               /*sense_len*/ SSD_FULL_SIZE,
7245                               /*timeout*/ timeout ? timeout : 5000);
7246
7247         /* Disable freezing the device queue */
7248         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
7249
7250         if (arglist & CAM_ARG_ERR_RECOVER)
7251                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
7252
7253         if (cam_send_ccb(device, ccb) < 0) {
7254                 warn("error sending READ CAPACITY (16) command");
7255
7256                 if (arglist & CAM_ARG_VERBOSE)
7257                         cam_error_print(device, ccb, CAM_ESF_ALL,
7258                                         CAM_EPF_ALL, stderr);
7259
7260                 retval = 1;
7261                 goto bailout;
7262         }
7263
7264         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
7265                 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr);
7266                 retval = 1;
7267                 goto bailout;
7268         }
7269
7270         maxsector = scsi_8btou64(rcaplong.addr);
7271         block_len = scsi_4btoul(rcaplong.length);
7272
7273 do_print:
7274         if (blocksizeonly == 0) {
7275                 /*
7276                  * Humanize implies !quiet, and also implies numblocks.
7277                  */
7278                 if (humanize != 0) {
7279                         char tmpstr[6];
7280                         int64_t tmpbytes;
7281                         int ret;
7282
7283                         tmpbytes = (maxsector + 1) * block_len;
7284                         ret = humanize_number(tmpstr, sizeof(tmpstr),
7285                                               tmpbytes, "", HN_AUTOSCALE,
7286                                               HN_B | HN_DECIMAL |
7287                                               ((baseten != 0) ?
7288                                               HN_DIVISOR_1000 : 0));
7289                         if (ret == -1) {
7290                                 warnx("%s: humanize_number failed!", __func__);
7291                                 retval = 1;
7292                                 goto bailout;
7293                         }
7294                         fprintf(stdout, "Device Size: %s%s", tmpstr,
7295                                 (sizeonly == 0) ?  ", " : "\n");
7296                 } else if (numblocks != 0) {
7297                         fprintf(stdout, "%s%ju%s", (quiet == 0) ?
7298                                 "Blocks: " : "", (uintmax_t)maxsector + 1,
7299                                 (sizeonly == 0) ? ", " : "\n");
7300                 } else {
7301                         fprintf(stdout, "%s%ju%s", (quiet == 0) ?
7302                                 "Last Block: " : "", (uintmax_t)maxsector,
7303                                 (sizeonly == 0) ? ", " : "\n");
7304                 }
7305         }
7306         if (sizeonly == 0)
7307                 fprintf(stdout, "%s%u%s\n", (quiet == 0) ?
7308                         "Block Length: " : "", block_len, (quiet == 0) ?
7309                         " bytes" : "");
7310 bailout:
7311         cam_freeccb(ccb);
7312
7313         return (retval);
7314 }
7315
7316 static int
7317 smpcmd(struct cam_device *device, int argc, char **argv, char *combinedopt,
7318        int retry_count, int timeout)
7319 {
7320         int c, error = 0;
7321         union ccb *ccb;
7322         uint8_t *smp_request = NULL, *smp_response = NULL;
7323         int request_size = 0, response_size = 0;
7324         int fd_request = 0, fd_response = 0;
7325         char *datastr = NULL;
7326         struct get_hook hook;
7327         int retval;
7328         int flags = 0;
7329
7330         /*
7331          * Note that at the moment we don't support sending SMP CCBs to
7332          * devices that aren't probed by CAM.
7333          */
7334         ccb = cam_getccb(device);
7335         if (ccb == NULL) {
7336                 warnx("%s: error allocating CCB", __func__);
7337                 return (1);
7338         }
7339
7340         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->smpio);
7341
7342         while ((c = getopt(argc, argv, combinedopt)) != -1) {
7343                 switch (c) {
7344                 case 'R':
7345                         arglist |= CAM_ARG_CMD_IN;
7346                         response_size = strtol(optarg, NULL, 0);
7347                         if (response_size <= 0) {
7348                                 warnx("invalid number of response bytes %d",
7349                                       response_size);
7350                                 error = 1;
7351                                 goto smpcmd_bailout;
7352                         }
7353                         hook.argc = argc - optind;
7354                         hook.argv = argv + optind;
7355                         hook.got = 0;
7356                         optind++;
7357                         datastr = cget(&hook, NULL);
7358                         /*
7359                          * If the user supplied "-" instead of a format, he
7360                          * wants the data to be written to stdout.
7361                          */
7362                         if ((datastr != NULL)
7363                          && (datastr[0] == '-'))
7364                                 fd_response = 1;
7365
7366                         smp_response = (u_int8_t *)malloc(response_size);
7367                         if (smp_response == NULL) {
7368                                 warn("can't malloc memory for SMP response");
7369                                 error = 1;
7370                                 goto smpcmd_bailout;
7371                         }
7372                         break;
7373                 case 'r':
7374                         arglist |= CAM_ARG_CMD_OUT;
7375                         request_size = strtol(optarg, NULL, 0);
7376                         if (request_size <= 0) {
7377                                 warnx("invalid number of request bytes %d",
7378                                       request_size);
7379                                 error = 1;
7380                                 goto smpcmd_bailout;
7381                         }
7382                         hook.argc = argc - optind;
7383                         hook.argv = argv + optind;
7384                         hook.got = 0;
7385                         datastr = cget(&hook, NULL);
7386                         smp_request = (u_int8_t *)malloc(request_size);
7387                         if (smp_request == NULL) {
7388                                 warn("can't malloc memory for SMP request");
7389                                 error = 1;
7390                                 goto smpcmd_bailout;
7391                         }
7392                         bzero(smp_request, request_size);
7393                         /*
7394                          * If the user supplied "-" instead of a format, he
7395                          * wants the data to be read from stdin.
7396                          */
7397                         if ((datastr != NULL)
7398                          && (datastr[0] == '-'))
7399                                 fd_request = 1;
7400                         else
7401                                 buff_encode_visit(smp_request, request_size,
7402                                                   datastr,
7403                                                   iget, &hook);
7404                         optind += hook.got;
7405                         break;
7406                 default:
7407                         break;
7408                 }
7409         }
7410
7411         /*
7412          * If fd_data is set, and we're writing to the device, we need to
7413          * read the data the user wants written from stdin.
7414          */
7415         if ((fd_request == 1) && (arglist & CAM_ARG_CMD_OUT)) {
7416                 ssize_t amt_read;
7417                 int amt_to_read = request_size;
7418                 u_int8_t *buf_ptr = smp_request;
7419
7420                 for (amt_read = 0; amt_to_read > 0;
7421                      amt_read = read(STDIN_FILENO, buf_ptr, amt_to_read)) {
7422                         if (amt_read == -1) {
7423                                 warn("error reading data from stdin");
7424                                 error = 1;
7425                                 goto smpcmd_bailout;
7426                         }
7427                         amt_to_read -= amt_read;
7428                         buf_ptr += amt_read;
7429                 }
7430         }
7431
7432         if (((arglist & CAM_ARG_CMD_IN) == 0)
7433          || ((arglist & CAM_ARG_CMD_OUT) == 0)) {
7434                 warnx("%s: need both the request (-r) and response (-R) "
7435                       "arguments", __func__);
7436                 error = 1;
7437                 goto smpcmd_bailout;
7438         }
7439
7440         flags |= CAM_DEV_QFRZDIS;
7441
7442         cam_fill_smpio(&ccb->smpio,
7443                        /*retries*/ retry_count,
7444                        /*cbfcnp*/ NULL,
7445                        /*flags*/ flags,
7446                        /*smp_request*/ smp_request,
7447                        /*smp_request_len*/ request_size,
7448                        /*smp_response*/ smp_response,
7449                        /*smp_response_len*/ response_size,
7450                        /*timeout*/ timeout ? timeout : 5000);
7451
7452         ccb->smpio.flags = SMP_FLAG_NONE;
7453
7454         if (((retval = cam_send_ccb(device, ccb)) < 0)
7455          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
7456                 const char warnstr[] = "error sending command";
7457
7458                 if (retval < 0)
7459                         warn(warnstr);
7460                 else
7461                         warnx(warnstr);
7462
7463                 if (arglist & CAM_ARG_VERBOSE) {
7464                         cam_error_print(device, ccb, CAM_ESF_ALL,
7465                                         CAM_EPF_ALL, stderr);
7466                 }
7467         }
7468
7469         if (((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP)
7470          && (response_size > 0)) {
7471                 if (fd_response == 0) {
7472                         buff_decode_visit(smp_response, response_size,
7473                                           datastr, arg_put, NULL);
7474                         fprintf(stdout, "\n");
7475                 } else {
7476                         ssize_t amt_written;
7477                         int amt_to_write = response_size;
7478                         u_int8_t *buf_ptr = smp_response;
7479
7480                         for (amt_written = 0; (amt_to_write > 0) &&
7481                              (amt_written = write(STDOUT_FILENO, buf_ptr,
7482                                                   amt_to_write)) > 0;){
7483                                 amt_to_write -= amt_written;
7484                                 buf_ptr += amt_written;
7485                         }
7486                         if (amt_written == -1) {
7487                                 warn("error writing data to stdout");
7488                                 error = 1;
7489                                 goto smpcmd_bailout;
7490                         } else if ((amt_written == 0)
7491                                 && (amt_to_write > 0)) {
7492                                 warnx("only wrote %u bytes out of %u",
7493                                       response_size - amt_to_write,
7494                                       response_size);
7495                         }
7496                 }
7497         }
7498 smpcmd_bailout:
7499         if (ccb != NULL)
7500                 cam_freeccb(ccb);
7501
7502         if (smp_request != NULL)
7503                 free(smp_request);
7504
7505         if (smp_response != NULL)
7506                 free(smp_response);
7507
7508         return (error);
7509 }
7510
7511 static int
7512 mmcsdcmd(struct cam_device *device, int argc, char **argv, char *combinedopt,
7513        int retry_count, int timeout)
7514 {
7515         int c, error = 0;
7516         union ccb *ccb;
7517         int32_t mmc_opcode = 0, mmc_arg = 0;
7518         int32_t mmc_flags = -1;
7519         int retval;
7520         int is_write = 0;
7521         int is_bw_4 = 0, is_bw_1 = 0;
7522         int is_highspeed = 0, is_stdspeed = 0;
7523         int is_info_request = 0;
7524         int flags = 0;
7525         uint8_t mmc_data_byte = 0;
7526
7527         /* For IO_RW_EXTENDED command */
7528         uint8_t *mmc_data = NULL;
7529         struct mmc_data mmc_d;
7530         int mmc_data_len = 0;
7531
7532         /*
7533          * Note that at the moment we don't support sending SMP CCBs to
7534          * devices that aren't probed by CAM.
7535          */
7536         ccb = cam_getccb(device);
7537         if (ccb == NULL) {
7538                 warnx("%s: error allocating CCB", __func__);
7539                 return (1);
7540         }
7541
7542         bzero(&(&ccb->ccb_h)[1],
7543               sizeof(union ccb) - sizeof(struct ccb_hdr));
7544
7545         while ((c = getopt(argc, argv, combinedopt)) != -1) {
7546                 switch (c) {
7547                 case '4':
7548                         is_bw_4 = 1;
7549                         break;
7550                 case '1':
7551                         is_bw_1 = 1;
7552                         break;
7553                 case 'S':
7554                         if (!strcmp(optarg, "high"))
7555                                 is_highspeed = 1;
7556                         else
7557                                 is_stdspeed = 1;
7558                         break;
7559                 case 'I':
7560                         is_info_request = 1;
7561                         break;
7562                 case 'c':
7563                         mmc_opcode = strtol(optarg, NULL, 0);
7564                         if (mmc_opcode < 0) {
7565                                 warnx("invalid MMC opcode %d",
7566                                       mmc_opcode);
7567                                 error = 1;
7568                                 goto mmccmd_bailout;
7569                         }
7570                         break;
7571                 case 'a':
7572                         mmc_arg = strtol(optarg, NULL, 0);
7573                         if (mmc_arg < 0) {
7574                                 warnx("invalid MMC arg %d",
7575                                       mmc_arg);
7576                                 error = 1;
7577                                 goto mmccmd_bailout;
7578                         }
7579                         break;
7580                 case 'f':
7581                         mmc_flags = strtol(optarg, NULL, 0);
7582                         if (mmc_flags < 0) {
7583                                 warnx("invalid MMC flags %d",
7584                                       mmc_flags);
7585                                 error = 1;
7586                                 goto mmccmd_bailout;
7587                         }
7588                         break;
7589                 case 'l':
7590                         mmc_data_len = strtol(optarg, NULL, 0);
7591                         if (mmc_data_len <= 0) {
7592                                 warnx("invalid MMC data len %d",
7593                                       mmc_data_len);
7594                                 error = 1;
7595                                 goto mmccmd_bailout;
7596                         }
7597                         break;
7598                 case 'W':
7599                         is_write = 1;
7600                         break;
7601                 case 'b':
7602                         mmc_data_byte = strtol(optarg, NULL, 0);
7603                         break;
7604                 default:
7605                         break;
7606                 }
7607         }
7608         flags |= CAM_DEV_QFRZDIS; /* masks are broken?! */
7609
7610         /* If flags are left default, supply the right flags */
7611         if (mmc_flags < 0)
7612                 switch (mmc_opcode) {
7613                 case MMC_GO_IDLE_STATE:
7614                         mmc_flags = MMC_RSP_NONE | MMC_CMD_BC;
7615                         break;
7616                 case IO_SEND_OP_COND:
7617                         mmc_flags = MMC_RSP_R4;
7618                         break;
7619                 case SD_SEND_RELATIVE_ADDR:
7620                         mmc_flags = MMC_RSP_R6 | MMC_CMD_BCR;
7621                         break;
7622                 case MMC_SELECT_CARD:
7623                         mmc_flags = MMC_RSP_R1B | MMC_CMD_AC;
7624                         mmc_arg = mmc_arg << 16;
7625                         break;
7626                 case SD_IO_RW_DIRECT:
7627                         mmc_flags = MMC_RSP_R5 | MMC_CMD_AC;
7628                         mmc_arg = SD_IO_RW_ADR(mmc_arg);
7629                         if (is_write)
7630                                 mmc_arg |= SD_IO_RW_WR | SD_IO_RW_RAW | SD_IO_RW_DAT(mmc_data_byte);
7631                         break;
7632                 case SD_IO_RW_EXTENDED:
7633                         mmc_flags = MMC_RSP_R5 | MMC_CMD_ADTC;
7634                         mmc_arg = SD_IO_RW_ADR(mmc_arg);
7635                         int len_arg = mmc_data_len;
7636                         if (mmc_data_len == 512)
7637                                 len_arg = 0;
7638
7639                         // Byte mode
7640                         mmc_arg |= SD_IOE_RW_LEN(len_arg) | SD_IO_RW_INCR;
7641                         // Block mode
7642 //                        mmc_arg |= SD_IOE_RW_BLK | SD_IOE_RW_LEN(len_arg) | SD_IO_RW_INCR;
7643                         break;
7644                 default:
7645                         mmc_flags = MMC_RSP_R1;
7646                         break;
7647                 }
7648
7649         // Switch bus width instead of sending IO command
7650         if (is_bw_4 || is_bw_1) {
7651                 struct ccb_trans_settings_mmc *cts;
7652                 ccb->ccb_h.func_code = XPT_SET_TRAN_SETTINGS;
7653                 ccb->ccb_h.flags = 0;
7654                 cts = &ccb->cts.proto_specific.mmc;
7655                 cts->ios.bus_width = is_bw_4 == 1 ? bus_width_4 : bus_width_1;
7656                 cts->ios_valid = MMC_BW;
7657                 if (((retval = cam_send_ccb(device, ccb)) < 0)
7658                     || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
7659                         warn("Error sending command");
7660                 } else {
7661                         printf("Parameters set OK\n");
7662                 }
7663                 cam_freeccb(ccb);
7664                 return (retval);
7665         }
7666
7667         // Switch bus speed instead of sending IO command
7668         if (is_stdspeed || is_highspeed) {
7669                 struct ccb_trans_settings_mmc *cts;
7670                 ccb->ccb_h.func_code = XPT_SET_TRAN_SETTINGS;
7671                 ccb->ccb_h.flags = 0;
7672                 cts = &ccb->cts.proto_specific.mmc;
7673                 cts->ios.timing = is_highspeed == 1 ? bus_timing_hs : bus_timing_normal;
7674                 cts->ios_valid = MMC_BT;
7675                 if (((retval = cam_send_ccb(device, ccb)) < 0)
7676                     || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
7677                         warn("Error sending command");
7678                 } else {
7679                         printf("Speed set OK (HS: %d)\n", is_highspeed);
7680                 }
7681                 cam_freeccb(ccb);
7682                 return (retval);
7683         }
7684
7685         // Get information about controller and its settings
7686         if (is_info_request) {
7687                 ccb->ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
7688                 ccb->ccb_h.flags = 0;
7689                 struct ccb_trans_settings_mmc *cts;
7690                 cts = &ccb->cts.proto_specific.mmc;
7691                 if (((retval = cam_send_ccb(device, ccb)) < 0)
7692                     || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
7693                         warn("Error sending command");
7694                         return (retval);
7695                 }
7696                 printf("Host controller information\n");
7697                 printf("Host OCR: 0x%x\n", cts->host_ocr);
7698                 printf("Min frequency: %u KHz\n", cts->host_f_min / 1000);
7699                 printf("Max frequency: %u MHz\n", cts->host_f_max / 1000000);
7700                 printf("Supported bus width: ");
7701                 if (cts->host_caps & MMC_CAP_4_BIT_DATA)
7702                         printf(" 4 bit\n");
7703                 if (cts->host_caps & MMC_CAP_8_BIT_DATA)
7704                         printf(" 8 bit\n");
7705                 printf("\nCurrent settings:\n");
7706                 printf("Bus width: ");
7707                 switch (cts->ios.bus_width) {
7708                 case bus_width_1:
7709                         printf("1 bit\n");
7710                         break;
7711                 case bus_width_4:
7712                         printf("4 bit\n");
7713                         break;
7714                 case bus_width_8:
7715                         printf("8 bit\n");
7716                         break;
7717                 }
7718                 printf("Freq: %d.%03d MHz%s\n",
7719                        cts->ios.clock / 1000000,
7720                        (cts->ios.clock / 1000) % 1000,
7721                        cts->ios.timing == bus_timing_hs ? "(high-speed timing)" : "");
7722                 return (0);
7723         }
7724
7725         printf("CMD %d arg %d flags %02x\n", mmc_opcode, mmc_arg, mmc_flags);
7726
7727         if (mmc_data_len > 0) {
7728                 flags |= CAM_DIR_IN;
7729                 mmc_data = malloc(mmc_data_len);
7730                 memset(mmc_data, 0, mmc_data_len);
7731                 mmc_d.len = mmc_data_len;
7732                 mmc_d.data = mmc_data;
7733                 mmc_d.flags = MMC_DATA_READ;
7734         } else flags |= CAM_DIR_NONE;
7735
7736         cam_fill_mmcio(&ccb->mmcio,
7737                        /*retries*/ retry_count,
7738                        /*cbfcnp*/ NULL,
7739                        /*flags*/ flags,
7740                        /*mmc_opcode*/ mmc_opcode,
7741                        /*mmc_arg*/ mmc_arg,
7742                        /*mmc_flags*/ mmc_flags,
7743                        /*mmc_data*/ mmc_data_len > 0 ? &mmc_d : NULL,
7744                        /*timeout*/ timeout ? timeout : 5000);
7745
7746         if (((retval = cam_send_ccb(device, ccb)) < 0)
7747          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
7748                 const char warnstr[] = "error sending command";
7749
7750                 if (retval < 0)
7751                         warn(warnstr);
7752                 else
7753                         warnx(warnstr);
7754
7755                 if (arglist & CAM_ARG_VERBOSE) {
7756                         cam_error_print(device, ccb, CAM_ESF_ALL,
7757                                         CAM_EPF_ALL, stderr);
7758                 }
7759         }
7760
7761         if (((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP)) {
7762                 printf("MMCIO: error %d, %08x %08x %08x %08x\n",
7763                        ccb->mmcio.cmd.error, ccb->mmcio.cmd.resp[0],
7764                        ccb->mmcio.cmd.resp[1],
7765                        ccb->mmcio.cmd.resp[2],
7766                        ccb->mmcio.cmd.resp[3]);
7767
7768                 switch (mmc_opcode) {
7769                 case SD_IO_RW_DIRECT:
7770                         printf("IO_RW_DIRECT: resp byte %02x, cur state %d\n",
7771                                SD_R5_DATA(ccb->mmcio.cmd.resp),
7772                                (ccb->mmcio.cmd.resp[0] >> 12) & 0x3);
7773                         break;
7774                 case SD_IO_RW_EXTENDED:
7775                         printf("IO_RW_EXTENDED: read %d bytes w/o error:\n", mmc_data_len);
7776                         hexdump(mmc_data, mmc_data_len, NULL, 0);
7777                         break;
7778                 case SD_SEND_RELATIVE_ADDR:
7779                         printf("SEND_RELATIVE_ADDR: published RCA %02x\n", ccb->mmcio.cmd.resp[0] >> 16);
7780                         break;
7781                 default:
7782                         printf("No command-specific decoder for CMD %d\n", mmc_opcode);
7783                 }
7784         }
7785 mmccmd_bailout:
7786         if (ccb != NULL)
7787                 cam_freeccb(ccb);
7788
7789         if (mmc_data_len > 0 && mmc_data != NULL)
7790                 free(mmc_data);
7791
7792         return (error);
7793 }
7794
7795 static int
7796 smpreportgeneral(struct cam_device *device, int argc, char **argv,
7797                  char *combinedopt, int retry_count, int timeout)
7798 {
7799         union ccb *ccb;
7800         struct smp_report_general_request *request = NULL;
7801         struct smp_report_general_response *response = NULL;
7802         struct sbuf *sb = NULL;
7803         int error = 0;
7804         int c, long_response = 0;
7805         int retval;
7806
7807         /*
7808          * Note that at the moment we don't support sending SMP CCBs to
7809          * devices that aren't probed by CAM.
7810          */
7811         ccb = cam_getccb(device);
7812         if (ccb == NULL) {
7813                 warnx("%s: error allocating CCB", __func__);
7814                 return (1);
7815         }
7816
7817         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->smpio);
7818
7819         while ((c = getopt(argc, argv, combinedopt)) != -1) {
7820                 switch (c) {
7821                 case 'l':
7822                         long_response = 1;
7823                         break;
7824                 default:
7825                         break;
7826                 }
7827         }
7828         request = malloc(sizeof(*request));
7829         if (request == NULL) {
7830                 warn("%s: unable to allocate %zd bytes", __func__,
7831                      sizeof(*request));
7832                 error = 1;
7833                 goto bailout;
7834         }
7835
7836         response = malloc(sizeof(*response));
7837         if (response == NULL) {
7838                 warn("%s: unable to allocate %zd bytes", __func__,
7839                      sizeof(*response));
7840                 error = 1;
7841                 goto bailout;
7842         }
7843
7844 try_long:
7845         smp_report_general(&ccb->smpio,
7846                            retry_count,
7847                            /*cbfcnp*/ NULL,
7848                            request,
7849                            /*request_len*/ sizeof(*request),
7850                            (uint8_t *)response,
7851                            /*response_len*/ sizeof(*response),
7852                            /*long_response*/ long_response,
7853                            timeout);
7854
7855         if (((retval = cam_send_ccb(device, ccb)) < 0)
7856          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
7857                 const char warnstr[] = "error sending command";
7858
7859                 if (retval < 0)
7860                         warn(warnstr);
7861                 else
7862                         warnx(warnstr);
7863
7864                 if (arglist & CAM_ARG_VERBOSE) {
7865                         cam_error_print(device, ccb, CAM_ESF_ALL,
7866                                         CAM_EPF_ALL, stderr);
7867                 }
7868                 error = 1;
7869                 goto bailout;
7870         }
7871
7872         /*
7873          * If the device supports the long response bit, try again and see
7874          * if we can get all of the data.
7875          */
7876         if ((response->long_response & SMP_RG_LONG_RESPONSE)
7877          && (long_response == 0)) {
7878                 ccb->ccb_h.status = CAM_REQ_INPROG;
7879                 CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->smpio);
7880                 long_response = 1;
7881                 goto try_long;
7882         }
7883
7884         /*
7885          * XXX KDM detect and decode SMP errors here.
7886          */
7887         sb = sbuf_new_auto();
7888         if (sb == NULL) {
7889                 warnx("%s: error allocating sbuf", __func__);
7890                 goto bailout;
7891         }
7892
7893         smp_report_general_sbuf(response, sizeof(*response), sb);
7894
7895         if (sbuf_finish(sb) != 0) {
7896                 warnx("%s: sbuf_finish", __func__);
7897                 goto bailout;
7898         }
7899
7900         printf("%s", sbuf_data(sb));
7901
7902 bailout:
7903         if (ccb != NULL)
7904                 cam_freeccb(ccb);
7905
7906         if (request != NULL)
7907                 free(request);
7908
7909         if (response != NULL)
7910                 free(response);
7911
7912         if (sb != NULL)
7913                 sbuf_delete(sb);
7914
7915         return (error);
7916 }
7917
7918 static struct camcontrol_opts phy_ops[] = {
7919         {"nop", SMP_PC_PHY_OP_NOP, CAM_ARG_NONE, NULL},
7920         {"linkreset", SMP_PC_PHY_OP_LINK_RESET, CAM_ARG_NONE, NULL},
7921         {"hardreset", SMP_PC_PHY_OP_HARD_RESET, CAM_ARG_NONE, NULL},
7922         {"disable", SMP_PC_PHY_OP_DISABLE, CAM_ARG_NONE, NULL},
7923         {"clearerrlog", SMP_PC_PHY_OP_CLEAR_ERR_LOG, CAM_ARG_NONE, NULL},
7924         {"clearaffiliation", SMP_PC_PHY_OP_CLEAR_AFFILIATON, CAM_ARG_NONE,NULL},
7925         {"sataportsel", SMP_PC_PHY_OP_TRANS_SATA_PSS, CAM_ARG_NONE, NULL},
7926         {"clearitnl", SMP_PC_PHY_OP_CLEAR_STP_ITN_LS, CAM_ARG_NONE, NULL},
7927         {"setdevname", SMP_PC_PHY_OP_SET_ATT_DEV_NAME, CAM_ARG_NONE, NULL},
7928         {NULL, 0, 0, NULL}
7929 };
7930
7931 static int
7932 smpphycontrol(struct cam_device *device, int argc, char **argv,
7933               char *combinedopt, int retry_count, int timeout)
7934 {
7935         union ccb *ccb;
7936         struct smp_phy_control_request *request = NULL;
7937         struct smp_phy_control_response *response = NULL;
7938         int long_response = 0;
7939         int retval = 0;
7940         int phy = -1;
7941         uint32_t phy_operation = SMP_PC_PHY_OP_NOP;
7942         int phy_op_set = 0;
7943         uint64_t attached_dev_name = 0;
7944         int dev_name_set = 0;
7945         uint32_t min_plr = 0, max_plr = 0;
7946         uint32_t pp_timeout_val = 0;
7947         int slumber_partial = 0;
7948         int set_pp_timeout_val = 0;
7949         int c;
7950
7951         /*
7952          * Note that at the moment we don't support sending SMP CCBs to
7953          * devices that aren't probed by CAM.
7954          */
7955         ccb = cam_getccb(device);
7956         if (ccb == NULL) {
7957                 warnx("%s: error allocating CCB", __func__);
7958                 return (1);
7959         }
7960
7961         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->smpio);
7962
7963         while ((c = getopt(argc, argv, combinedopt)) != -1) {
7964                 switch (c) {
7965                 case 'a':
7966                 case 'A':
7967                 case 's':
7968                 case 'S': {
7969                         int enable = -1;
7970
7971                         if (strcasecmp(optarg, "enable") == 0)
7972                                 enable = 1;
7973                         else if (strcasecmp(optarg, "disable") == 0)
7974                                 enable = 2;
7975                         else {
7976                                 warnx("%s: Invalid argument %s", __func__,
7977                                       optarg);
7978                                 retval = 1;
7979                                 goto bailout;
7980                         }
7981                         switch (c) {
7982                         case 's':
7983                                 slumber_partial |= enable <<
7984                                                    SMP_PC_SAS_SLUMBER_SHIFT;
7985                                 break;
7986                         case 'S':
7987                                 slumber_partial |= enable <<
7988                                                    SMP_PC_SAS_PARTIAL_SHIFT;
7989                                 break;
7990                         case 'a':
7991                                 slumber_partial |= enable <<
7992                                                    SMP_PC_SATA_SLUMBER_SHIFT;
7993                                 break;
7994                         case 'A':
7995                                 slumber_partial |= enable <<
7996                                                    SMP_PC_SATA_PARTIAL_SHIFT;
7997                                 break;
7998                         default:
7999                                 warnx("%s: programmer error", __func__);
8000                                 retval = 1;
8001                                 goto bailout;
8002                                 break; /*NOTREACHED*/
8003                         }
8004                         break;
8005                 }
8006                 case 'd':
8007                         attached_dev_name = (uintmax_t)strtoumax(optarg,
8008                                                                  NULL,0);
8009                         dev_name_set = 1;
8010                         break;
8011                 case 'l':
8012                         long_response = 1;
8013                         break;
8014                 case 'm':
8015                         /*
8016                          * We don't do extensive checking here, so this
8017                          * will continue to work when new speeds come out.
8018                          */
8019                         min_plr = strtoul(optarg, NULL, 0);
8020                         if ((min_plr == 0)
8021                          || (min_plr > 0xf)) {
8022                                 warnx("%s: invalid link rate %x",
8023                                       __func__, min_plr);
8024                                 retval = 1;
8025                                 goto bailout;
8026                         }
8027                         break;
8028                 case 'M':
8029                         /*
8030                          * We don't do extensive checking here, so this
8031                          * will continue to work when new speeds come out.
8032                          */
8033                         max_plr = strtoul(optarg, NULL, 0);
8034                         if ((max_plr == 0)
8035                          || (max_plr > 0xf)) {
8036                                 warnx("%s: invalid link rate %x",
8037                                       __func__, max_plr);
8038                                 retval = 1;
8039                                 goto bailout;
8040                         }
8041                         break;
8042                 case 'o': {
8043                         camcontrol_optret optreturn;
8044                         cam_argmask argnums;
8045                         const char *subopt;
8046
8047                         if (phy_op_set != 0) {
8048                                 warnx("%s: only one phy operation argument "
8049                                       "(-o) allowed", __func__);
8050                                 retval = 1;
8051                                 goto bailout;
8052                         }
8053
8054                         phy_op_set = 1;
8055
8056                         /*
8057                          * Allow the user to specify the phy operation
8058                          * numerically, as well as with a name.  This will
8059                          * future-proof it a bit, so options that are added
8060                          * in future specs can be used.
8061                          */
8062                         if (isdigit(optarg[0])) {
8063                                 phy_operation = strtoul(optarg, NULL, 0);
8064                                 if ((phy_operation == 0)
8065                                  || (phy_operation > 0xff)) {
8066                                         warnx("%s: invalid phy operation %#x",
8067                                               __func__, phy_operation);
8068                                         retval = 1;
8069                                         goto bailout;
8070                                 }
8071                                 break;
8072                         }
8073                         optreturn = getoption(phy_ops, optarg, &phy_operation,
8074                                               &argnums, &subopt);
8075
8076                         if (optreturn == CC_OR_AMBIGUOUS) {
8077                                 warnx("%s: ambiguous option %s", __func__,
8078                                       optarg);
8079                                 usage(0);
8080                                 retval = 1;
8081                                 goto bailout;
8082                         } else if (optreturn == CC_OR_NOT_FOUND) {
8083                                 warnx("%s: option %s not found", __func__,
8084                                       optarg);
8085                                 usage(0);
8086                                 retval = 1;
8087                                 goto bailout;
8088                         }
8089                         break;
8090                 }
8091                 case 'p':
8092                         phy = atoi(optarg);
8093                         break;
8094                 case 'T':
8095                         pp_timeout_val = strtoul(optarg, NULL, 0);
8096                         if (pp_timeout_val > 15) {
8097                                 warnx("%s: invalid partial pathway timeout "
8098                                       "value %u, need a value less than 16",
8099                                       __func__, pp_timeout_val);
8100                                 retval = 1;
8101                                 goto bailout;
8102                         }
8103                         set_pp_timeout_val = 1;
8104                         break;
8105                 default:
8106                         break;
8107                 }
8108         }
8109
8110         if (phy == -1) {
8111                 warnx("%s: a PHY (-p phy) argument is required",__func__);
8112                 retval = 1;
8113                 goto bailout;
8114         }
8115
8116         if (((dev_name_set != 0)
8117           && (phy_operation != SMP_PC_PHY_OP_SET_ATT_DEV_NAME))
8118          || ((phy_operation == SMP_PC_PHY_OP_SET_ATT_DEV_NAME)
8119           && (dev_name_set == 0))) {
8120                 warnx("%s: -d name and -o setdevname arguments both "
8121                       "required to set device name", __func__);
8122                 retval = 1;
8123                 goto bailout;
8124         }
8125
8126         request = malloc(sizeof(*request));
8127         if (request == NULL) {
8128                 warn("%s: unable to allocate %zd bytes", __func__,
8129                      sizeof(*request));
8130                 retval = 1;
8131                 goto bailout;
8132         }
8133
8134         response = malloc(sizeof(*response));
8135         if (response == NULL) {
8136                 warn("%s: unable to allocate %zd bytes", __func__,
8137                      sizeof(*response));
8138                 retval = 1;
8139                 goto bailout;
8140         }
8141
8142         smp_phy_control(&ccb->smpio,
8143                         retry_count,
8144                         /*cbfcnp*/ NULL,
8145                         request,
8146                         sizeof(*request),
8147                         (uint8_t *)response,
8148                         sizeof(*response),
8149                         long_response,
8150                         /*expected_exp_change_count*/ 0,
8151                         phy,
8152                         phy_operation,
8153                         (set_pp_timeout_val != 0) ? 1 : 0,
8154                         attached_dev_name,
8155                         min_plr,
8156                         max_plr,
8157                         slumber_partial,
8158                         pp_timeout_val,
8159                         timeout);
8160
8161         if (((retval = cam_send_ccb(device, ccb)) < 0)
8162          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
8163                 const char warnstr[] = "error sending command";
8164
8165                 if (retval < 0)
8166                         warn(warnstr);
8167                 else
8168                         warnx(warnstr);
8169
8170                 if (arglist & CAM_ARG_VERBOSE) {
8171                         /*
8172                          * Use CAM_EPF_NORMAL so we only get one line of
8173                          * SMP command decoding.
8174                          */
8175                         cam_error_print(device, ccb, CAM_ESF_ALL,
8176                                         CAM_EPF_NORMAL, stderr);
8177                 }
8178                 retval = 1;
8179                 goto bailout;
8180         }
8181
8182         /* XXX KDM print out something here for success? */
8183 bailout:
8184         if (ccb != NULL)
8185                 cam_freeccb(ccb);
8186
8187         if (request != NULL)
8188                 free(request);
8189
8190         if (response != NULL)
8191                 free(response);
8192
8193         return (retval);
8194 }
8195
8196 static int
8197 smpmaninfo(struct cam_device *device, int argc, char **argv,
8198            char *combinedopt, int retry_count, int timeout)
8199 {
8200         union ccb *ccb;
8201         struct smp_report_manuf_info_request request;
8202         struct smp_report_manuf_info_response response;
8203         struct sbuf *sb = NULL;
8204         int long_response = 0;
8205         int retval = 0;
8206         int c;
8207
8208         /*
8209          * Note that at the moment we don't support sending SMP CCBs to
8210          * devices that aren't probed by CAM.
8211          */
8212         ccb = cam_getccb(device);
8213         if (ccb == NULL) {
8214                 warnx("%s: error allocating CCB", __func__);
8215                 return (1);
8216         }
8217
8218         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->smpio);
8219
8220         while ((c = getopt(argc, argv, combinedopt)) != -1) {
8221                 switch (c) {
8222                 case 'l':
8223                         long_response = 1;
8224                         break;
8225                 default:
8226                         break;
8227                 }
8228         }
8229         bzero(&request, sizeof(request));
8230         bzero(&response, sizeof(response));
8231
8232         smp_report_manuf_info(&ccb->smpio,
8233                               retry_count,
8234                               /*cbfcnp*/ NULL,
8235                               &request,
8236                               sizeof(request),
8237                               (uint8_t *)&response,
8238                               sizeof(response),
8239                               long_response,
8240                               timeout);
8241
8242         if (((retval = cam_send_ccb(device, ccb)) < 0)
8243          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
8244                 const char warnstr[] = "error sending command";
8245
8246                 if (retval < 0)
8247                         warn(warnstr);
8248                 else
8249                         warnx(warnstr);
8250
8251                 if (arglist & CAM_ARG_VERBOSE) {
8252                         cam_error_print(device, ccb, CAM_ESF_ALL,
8253                                         CAM_EPF_ALL, stderr);
8254                 }
8255                 retval = 1;
8256                 goto bailout;
8257         }
8258
8259         sb = sbuf_new_auto();
8260         if (sb == NULL) {
8261                 warnx("%s: error allocating sbuf", __func__);
8262                 goto bailout;
8263         }
8264
8265         smp_report_manuf_info_sbuf(&response, sizeof(response), sb);
8266
8267         if (sbuf_finish(sb) != 0) {
8268                 warnx("%s: sbuf_finish", __func__);
8269                 goto bailout;
8270         }
8271
8272         printf("%s", sbuf_data(sb));
8273
8274 bailout:
8275
8276         if (ccb != NULL)
8277                 cam_freeccb(ccb);
8278
8279         if (sb != NULL)
8280                 sbuf_delete(sb);
8281
8282         return (retval);
8283 }
8284
8285 static int
8286 getdevid(struct cam_devitem *item)
8287 {
8288         int retval = 0;
8289         union ccb *ccb = NULL;
8290
8291         struct cam_device *dev;
8292
8293         dev = cam_open_btl(item->dev_match.path_id,
8294                            item->dev_match.target_id,
8295                            item->dev_match.target_lun, O_RDWR, NULL);
8296
8297         if (dev == NULL) {
8298                 warnx("%s", cam_errbuf);
8299                 retval = 1;
8300                 goto bailout;
8301         }
8302
8303         item->device_id_len = 0;
8304
8305         ccb = cam_getccb(dev);
8306         if (ccb == NULL) {
8307                 warnx("%s: error allocating CCB", __func__);
8308                 retval = 1;
8309                 goto bailout;
8310         }
8311
8312         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->cdai);
8313
8314         /*
8315          * On the first try, we just probe for the size of the data, and
8316          * then allocate that much memory and try again.
8317          */
8318 retry:
8319         ccb->ccb_h.func_code = XPT_DEV_ADVINFO;
8320         ccb->ccb_h.flags = CAM_DIR_IN;
8321         ccb->cdai.flags = CDAI_FLAG_NONE;
8322         ccb->cdai.buftype = CDAI_TYPE_SCSI_DEVID;
8323         ccb->cdai.bufsiz = item->device_id_len;
8324         if (item->device_id_len != 0)
8325                 ccb->cdai.buf = (uint8_t *)item->device_id;
8326
8327         if (cam_send_ccb(dev, ccb) < 0) {
8328                 warn("%s: error sending XPT_GDEV_ADVINFO CCB", __func__);
8329                 retval = 1;
8330                 goto bailout;
8331         }
8332
8333         if (ccb->ccb_h.status != CAM_REQ_CMP) {
8334                 warnx("%s: CAM status %#x", __func__, ccb->ccb_h.status);
8335                 retval = 1;
8336                 goto bailout;
8337         }
8338
8339         if (item->device_id_len == 0) {
8340                 /*
8341                  * This is our first time through.  Allocate the buffer,
8342                  * and then go back to get the data.
8343                  */
8344                 if (ccb->cdai.provsiz == 0) {
8345                         warnx("%s: invalid .provsiz field returned with "
8346                              "XPT_GDEV_ADVINFO CCB", __func__);
8347                         retval = 1;
8348                         goto bailout;
8349                 }
8350                 item->device_id_len = ccb->cdai.provsiz;
8351                 item->device_id = malloc(item->device_id_len);
8352                 if (item->device_id == NULL) {
8353                         warn("%s: unable to allocate %d bytes", __func__,
8354                              item->device_id_len);
8355                         retval = 1;
8356                         goto bailout;
8357                 }
8358                 ccb->ccb_h.status = CAM_REQ_INPROG;
8359                 goto retry;
8360         }
8361
8362 bailout:
8363         if (dev != NULL)
8364                 cam_close_device(dev);
8365
8366         if (ccb != NULL)
8367                 cam_freeccb(ccb);
8368
8369         return (retval);
8370 }
8371
8372 /*
8373  * XXX KDM merge this code with getdevtree()?
8374  */
8375 static int
8376 buildbusdevlist(struct cam_devlist *devlist)
8377 {
8378         union ccb ccb;
8379         int bufsize, fd = -1;
8380         struct dev_match_pattern *patterns;
8381         struct cam_devitem *item = NULL;
8382         int skip_device = 0;
8383         int retval = 0;
8384
8385         if ((fd = open(XPT_DEVICE, O_RDWR)) == -1) {
8386                 warn("couldn't open %s", XPT_DEVICE);
8387                 return (1);
8388         }
8389
8390         bzero(&ccb, sizeof(union ccb));
8391
8392         ccb.ccb_h.path_id = CAM_XPT_PATH_ID;
8393         ccb.ccb_h.target_id = CAM_TARGET_WILDCARD;
8394         ccb.ccb_h.target_lun = CAM_LUN_WILDCARD;
8395
8396         ccb.ccb_h.func_code = XPT_DEV_MATCH;
8397         bufsize = sizeof(struct dev_match_result) * 100;
8398         ccb.cdm.match_buf_len = bufsize;
8399         ccb.cdm.matches = (struct dev_match_result *)malloc(bufsize);
8400         if (ccb.cdm.matches == NULL) {
8401                 warnx("can't malloc memory for matches");
8402                 close(fd);
8403                 return (1);
8404         }
8405         ccb.cdm.num_matches = 0;
8406         ccb.cdm.num_patterns = 2;
8407         ccb.cdm.pattern_buf_len = sizeof(struct dev_match_pattern) *
8408                 ccb.cdm.num_patterns;
8409
8410         patterns = (struct dev_match_pattern *)malloc(ccb.cdm.pattern_buf_len);
8411         if (patterns == NULL) {
8412                 warnx("can't malloc memory for patterns");
8413                 retval = 1;
8414                 goto bailout;
8415         }
8416
8417         ccb.cdm.patterns = patterns;
8418         bzero(patterns, ccb.cdm.pattern_buf_len);
8419
8420         patterns[0].type = DEV_MATCH_DEVICE;
8421         patterns[0].pattern.device_pattern.flags = DEV_MATCH_PATH;
8422         patterns[0].pattern.device_pattern.path_id = devlist->path_id;
8423         patterns[1].type = DEV_MATCH_PERIPH;
8424         patterns[1].pattern.periph_pattern.flags = PERIPH_MATCH_PATH;
8425         patterns[1].pattern.periph_pattern.path_id = devlist->path_id;
8426
8427         /*
8428          * We do the ioctl multiple times if necessary, in case there are
8429          * more than 100 nodes in the EDT.
8430          */
8431         do {
8432                 unsigned int i;
8433
8434                 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) {
8435                         warn("error sending CAMIOCOMMAND ioctl");
8436                         retval = 1;
8437                         goto bailout;
8438                 }
8439
8440                 if ((ccb.ccb_h.status != CAM_REQ_CMP)
8441                  || ((ccb.cdm.status != CAM_DEV_MATCH_LAST)
8442                     && (ccb.cdm.status != CAM_DEV_MATCH_MORE))) {
8443                         warnx("got CAM error %#x, CDM error %d\n",
8444                               ccb.ccb_h.status, ccb.cdm.status);
8445                         retval = 1;
8446                         goto bailout;
8447                 }
8448
8449                 for (i = 0; i < ccb.cdm.num_matches; i++) {
8450                         switch (ccb.cdm.matches[i].type) {
8451                         case DEV_MATCH_DEVICE: {
8452                                 struct device_match_result *dev_result;
8453
8454                                 dev_result =
8455                                      &ccb.cdm.matches[i].result.device_result;
8456
8457                                 if (dev_result->flags &
8458                                     DEV_RESULT_UNCONFIGURED) {
8459                                         skip_device = 1;
8460                                         break;
8461                                 } else
8462                                         skip_device = 0;
8463
8464                                 item = malloc(sizeof(*item));
8465                                 if (item == NULL) {
8466                                         warn("%s: unable to allocate %zd bytes",
8467                                              __func__, sizeof(*item));
8468                                         retval = 1;
8469                                         goto bailout;
8470                                 }
8471                                 bzero(item, sizeof(*item));
8472                                 bcopy(dev_result, &item->dev_match,
8473                                       sizeof(*dev_result));
8474                                 STAILQ_INSERT_TAIL(&devlist->dev_queue, item,
8475                                                    links);
8476
8477                                 if (getdevid(item) != 0) {
8478                                         retval = 1;
8479                                         goto bailout;
8480                                 }
8481                                 break;
8482                         }
8483                         case DEV_MATCH_PERIPH: {
8484                                 struct periph_match_result *periph_result;
8485
8486                                 periph_result =
8487                                       &ccb.cdm.matches[i].result.periph_result;
8488
8489                                 if (skip_device != 0)
8490                                         break;
8491                                 item->num_periphs++;
8492                                 item->periph_matches = realloc(
8493                                         item->periph_matches,
8494                                         item->num_periphs *
8495                                         sizeof(struct periph_match_result));
8496                                 if (item->periph_matches == NULL) {
8497                                         warn("%s: error allocating periph "
8498                                              "list", __func__);
8499                                         retval = 1;
8500                                         goto bailout;
8501                                 }
8502                                 bcopy(periph_result, &item->periph_matches[
8503                                       item->num_periphs - 1],
8504                                       sizeof(*periph_result));
8505                                 break;
8506                         }
8507                         default:
8508                                 fprintf(stderr, "%s: unexpected match "
8509                                         "type %d\n", __func__,
8510                                         ccb.cdm.matches[i].type);
8511                                 retval = 1;
8512                                 goto bailout;
8513                                 break; /*NOTREACHED*/
8514                         }
8515                 }
8516         } while ((ccb.ccb_h.status == CAM_REQ_CMP)
8517                 && (ccb.cdm.status == CAM_DEV_MATCH_MORE));
8518 bailout:
8519
8520         if (fd != -1)
8521                 close(fd);
8522
8523         free(patterns);
8524
8525         free(ccb.cdm.matches);
8526
8527         if (retval != 0)
8528                 freebusdevlist(devlist);
8529
8530         return (retval);
8531 }
8532
8533 static void
8534 freebusdevlist(struct cam_devlist *devlist)
8535 {
8536         struct cam_devitem *item, *item2;
8537
8538         STAILQ_FOREACH_SAFE(item, &devlist->dev_queue, links, item2) {
8539                 STAILQ_REMOVE(&devlist->dev_queue, item, cam_devitem,
8540                               links);
8541                 free(item->device_id);
8542                 free(item->periph_matches);
8543                 free(item);
8544         }
8545 }
8546
8547 static struct cam_devitem *
8548 findsasdevice(struct cam_devlist *devlist, uint64_t sasaddr)
8549 {
8550         struct cam_devitem *item;
8551
8552         STAILQ_FOREACH(item, &devlist->dev_queue, links) {
8553                 struct scsi_vpd_id_descriptor *idd;
8554
8555                 /*
8556                  * XXX KDM look for LUN IDs as well?
8557                  */
8558                 idd = scsi_get_devid(item->device_id,
8559                                            item->device_id_len,
8560                                            scsi_devid_is_sas_target);
8561                 if (idd == NULL)
8562                         continue;
8563
8564                 if (scsi_8btou64(idd->identifier) == sasaddr)
8565                         return (item);
8566         }
8567
8568         return (NULL);
8569 }
8570
8571 static int
8572 smpphylist(struct cam_device *device, int argc, char **argv,
8573            char *combinedopt, int retry_count, int timeout)
8574 {
8575         struct smp_report_general_request *rgrequest = NULL;
8576         struct smp_report_general_response *rgresponse = NULL;
8577         struct smp_discover_request *disrequest = NULL;
8578         struct smp_discover_response *disresponse = NULL;
8579         struct cam_devlist devlist;
8580         union ccb *ccb;
8581         int long_response = 0;
8582         int num_phys = 0;
8583         int quiet = 0;
8584         int retval;
8585         int i, c;
8586
8587         /*
8588          * Note that at the moment we don't support sending SMP CCBs to
8589          * devices that aren't probed by CAM.
8590          */
8591         ccb = cam_getccb(device);
8592         if (ccb == NULL) {
8593                 warnx("%s: error allocating CCB", __func__);
8594                 return (1);
8595         }
8596
8597         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->smpio);
8598         STAILQ_INIT(&devlist.dev_queue);
8599
8600         rgrequest = malloc(sizeof(*rgrequest));
8601         if (rgrequest == NULL) {
8602                 warn("%s: unable to allocate %zd bytes", __func__,
8603                      sizeof(*rgrequest));
8604                 retval = 1;
8605                 goto bailout;
8606         }
8607
8608         rgresponse = malloc(sizeof(*rgresponse));
8609         if (rgresponse == NULL) {
8610                 warn("%s: unable to allocate %zd bytes", __func__,
8611                      sizeof(*rgresponse));
8612                 retval = 1;
8613                 goto bailout;
8614         }
8615
8616         while ((c = getopt(argc, argv, combinedopt)) != -1) {
8617                 switch (c) {
8618                 case 'l':
8619                         long_response = 1;
8620                         break;
8621                 case 'q':
8622                         quiet = 1;
8623                         break;
8624                 default:
8625                         break;
8626                 }
8627         }
8628
8629         smp_report_general(&ccb->smpio,
8630                            retry_count,
8631                            /*cbfcnp*/ NULL,
8632                            rgrequest,
8633                            /*request_len*/ sizeof(*rgrequest),
8634                            (uint8_t *)rgresponse,
8635                            /*response_len*/ sizeof(*rgresponse),
8636                            /*long_response*/ long_response,
8637                            timeout);
8638
8639         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
8640
8641         if (((retval = cam_send_ccb(device, ccb)) < 0)
8642          || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
8643                 const char warnstr[] = "error sending command";
8644
8645                 if (retval < 0)
8646                         warn(warnstr);
8647                 else
8648                         warnx(warnstr);
8649
8650                 if (arglist & CAM_ARG_VERBOSE) {
8651                         cam_error_print(device, ccb, CAM_ESF_ALL,
8652                                         CAM_EPF_ALL, stderr);
8653                 }
8654                 retval = 1;
8655                 goto bailout;
8656         }
8657
8658         num_phys = rgresponse->num_phys;
8659
8660         if (num_phys == 0) {
8661                 if (quiet == 0)
8662                         fprintf(stdout, "%s: No Phys reported\n", __func__);
8663                 retval = 1;
8664                 goto bailout;
8665         }
8666
8667         devlist.path_id = device->path_id;
8668
8669         retval = buildbusdevlist(&devlist);
8670         if (retval != 0)
8671                 goto bailout;
8672
8673         if (quiet == 0) {
8674                 fprintf(stdout, "%d PHYs:\n", num_phys);
8675                 fprintf(stdout, "PHY  Attached SAS Address\n");
8676         }
8677
8678         disrequest = malloc(sizeof(*disrequest));
8679         if (disrequest == NULL) {
8680                 warn("%s: unable to allocate %zd bytes", __func__,
8681                      sizeof(*disrequest));
8682                 retval = 1;
8683                 goto bailout;
8684         }
8685
8686         disresponse = malloc(sizeof(*disresponse));
8687         if (disresponse == NULL) {
8688                 warn("%s: unable to allocate %zd bytes", __func__,
8689                      sizeof(*disresponse));
8690                 retval = 1;
8691                 goto bailout;
8692         }
8693
8694         for (i = 0; i < num_phys; i++) {
8695                 struct cam_devitem *item;
8696                 struct device_match_result *dev_match;
8697                 char vendor[16], product[48], revision[16];
8698                 char tmpstr[256];
8699                 int j;
8700
8701                 CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->smpio);
8702
8703                 ccb->ccb_h.status = CAM_REQ_INPROG;
8704                 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
8705
8706                 smp_discover(&ccb->smpio,
8707                              retry_count,
8708                              /*cbfcnp*/ NULL,
8709                              disrequest,
8710                              sizeof(*disrequest),
8711                              (uint8_t *)disresponse,
8712                              sizeof(*disresponse),
8713                              long_response,
8714                              /*ignore_zone_group*/ 0,
8715                              /*phy*/ i,
8716                              timeout);
8717
8718                 if (((retval = cam_send_ccb(device, ccb)) < 0)
8719                  || (((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)
8720                   && (disresponse->function_result != SMP_FR_PHY_VACANT))) {
8721                         const char warnstr[] = "error sending command";
8722
8723                         if (retval < 0)
8724                                 warn(warnstr);
8725                         else
8726                                 warnx(warnstr);
8727
8728                         if (arglist & CAM_ARG_VERBOSE) {
8729                                 cam_error_print(device, ccb, CAM_ESF_ALL,
8730                                                 CAM_EPF_ALL, stderr);
8731                         }
8732                         retval = 1;
8733                         goto bailout;
8734                 }
8735
8736                 if (disresponse->function_result == SMP_FR_PHY_VACANT) {
8737                         if (quiet == 0)
8738                                 fprintf(stdout, "%3d  <vacant>\n", i);
8739                         continue;
8740                 }
8741
8742                 if (disresponse->attached_device == SMP_DIS_AD_TYPE_NONE) {
8743                         item = NULL;
8744                 } else {
8745                         item = findsasdevice(&devlist,
8746                             scsi_8btou64(disresponse->attached_sas_address));
8747                 }
8748
8749                 if ((quiet == 0)
8750                  || (item != NULL)) {
8751                         fprintf(stdout, "%3d  0x%016jx", i,
8752                                 (uintmax_t)scsi_8btou64(
8753                                 disresponse->attached_sas_address));
8754                         if (item == NULL) {
8755                                 fprintf(stdout, "\n");
8756                                 continue;
8757                         }
8758                 } else if (quiet != 0)
8759                         continue;
8760
8761                 dev_match = &item->dev_match;
8762
8763                 if (dev_match->protocol == PROTO_SCSI) {
8764                         cam_strvis(vendor, dev_match->inq_data.vendor,
8765                                    sizeof(dev_match->inq_data.vendor),
8766                                    sizeof(vendor));
8767                         cam_strvis(product, dev_match->inq_data.product,
8768                                    sizeof(dev_match->inq_data.product),
8769                                    sizeof(product));
8770                         cam_strvis(revision, dev_match->inq_data.revision,
8771                                    sizeof(dev_match->inq_data.revision),
8772                                    sizeof(revision));
8773                         sprintf(tmpstr, "<%s %s %s>", vendor, product,
8774                                 revision);
8775                 } else if ((dev_match->protocol == PROTO_ATA)
8776                         || (dev_match->protocol == PROTO_SATAPM)) {
8777                         cam_strvis(product, dev_match->ident_data.model,
8778                                    sizeof(dev_match->ident_data.model),
8779                                    sizeof(product));
8780                         cam_strvis(revision, dev_match->ident_data.revision,
8781                                    sizeof(dev_match->ident_data.revision),
8782                                    sizeof(revision));
8783                         sprintf(tmpstr, "<%s %s>", product, revision);
8784                 } else {
8785                         sprintf(tmpstr, "<>");
8786                 }
8787                 fprintf(stdout, "   %-33s ", tmpstr);
8788
8789                 /*
8790                  * If we have 0 periphs, that's a bug...
8791                  */
8792                 if (item->num_periphs == 0) {
8793                         fprintf(stdout, "\n");
8794                         continue;
8795                 }
8796
8797                 fprintf(stdout, "(");
8798                 for (j = 0; j < item->num_periphs; j++) {
8799                         if (j > 0)
8800                                 fprintf(stdout, ",");
8801
8802                         fprintf(stdout, "%s%d",
8803                                 item->periph_matches[j].periph_name,
8804                                 item->periph_matches[j].unit_number);
8805
8806                 }
8807                 fprintf(stdout, ")\n");
8808         }
8809 bailout:
8810         if (ccb != NULL)
8811                 cam_freeccb(ccb);
8812
8813         free(rgrequest);
8814
8815         free(rgresponse);
8816
8817         free(disrequest);
8818
8819         free(disresponse);
8820
8821         freebusdevlist(&devlist);
8822
8823         return (retval);
8824 }
8825
8826 static int
8827 atapm(struct cam_device *device, int argc, char **argv,
8828                  char *combinedopt, int retry_count, int timeout)
8829 {
8830         union ccb *ccb;
8831         int retval = 0;
8832         int t = -1;
8833         int c;
8834         u_char cmd, sc;
8835
8836         ccb = cam_getccb(device);
8837
8838         if (ccb == NULL) {
8839                 warnx("%s: error allocating ccb", __func__);
8840                 return (1);
8841         }
8842
8843         while ((c = getopt(argc, argv, combinedopt)) != -1) {
8844                 switch (c) {
8845                 case 't':
8846                         t = atoi(optarg);
8847                         break;
8848                 default:
8849                         break;
8850                 }
8851         }
8852         if (strcmp(argv[1], "idle") == 0) {
8853                 if (t == -1)
8854                         cmd = ATA_IDLE_IMMEDIATE;
8855                 else
8856                         cmd = ATA_IDLE_CMD;
8857         } else if (strcmp(argv[1], "standby") == 0) {
8858                 if (t == -1)
8859                         cmd = ATA_STANDBY_IMMEDIATE;
8860                 else
8861                         cmd = ATA_STANDBY_CMD;
8862         } else {
8863                 cmd = ATA_SLEEP;
8864                 t = -1;
8865         }
8866
8867         if (t < 0)
8868                 sc = 0;
8869         else if (t <= (240 * 5))
8870                 sc = (t + 4) / 5;
8871         else if (t <= (252 * 5))
8872                 /* special encoding for 21 minutes */
8873                 sc = 252;
8874         else if (t <= (11 * 30 * 60))
8875                 sc = (t - 1) / (30 * 60) + 241;
8876         else
8877                 sc = 253;
8878
8879         retval = ata_do_28bit_cmd(device,
8880             ccb,
8881             /*retries*/retry_count,
8882             /*flags*/CAM_DIR_NONE,
8883             /*protocol*/AP_PROTO_NON_DATA,
8884             /*tag_action*/MSG_SIMPLE_Q_TAG,
8885             /*command*/cmd,
8886             /*features*/0,
8887             /*lba*/0,
8888             /*sector_count*/sc,
8889             /*data_ptr*/NULL,
8890             /*dxfer_len*/0,
8891             /*timeout*/timeout ? timeout : 30 * 1000,
8892             /*quiet*/1);
8893
8894         cam_freeccb(ccb);
8895         return (retval);
8896 }
8897
8898 static int
8899 ataaxm(struct cam_device *device, int argc, char **argv,
8900                  char *combinedopt, int retry_count, int timeout)
8901 {
8902         union ccb *ccb;
8903         int retval = 0;
8904         int l = -1;
8905         int c;
8906         u_char cmd, sc;
8907
8908         ccb = cam_getccb(device);
8909
8910         if (ccb == NULL) {
8911                 warnx("%s: error allocating ccb", __func__);
8912                 return (1);
8913         }
8914
8915         while ((c = getopt(argc, argv, combinedopt)) != -1) {
8916                 switch (c) {
8917                 case 'l':
8918                         l = atoi(optarg);
8919                         break;
8920                 default:
8921                         break;
8922                 }
8923         }
8924         sc = 0;
8925         if (strcmp(argv[1], "apm") == 0) {
8926                 if (l == -1)
8927                         cmd = 0x85;
8928                 else {
8929                         cmd = 0x05;
8930                         sc = l;
8931                 }
8932         } else /* aam */ {
8933                 if (l == -1)
8934                         cmd = 0xC2;
8935                 else {
8936                         cmd = 0x42;
8937                         sc = l;
8938                 }
8939         }
8940
8941         retval = ata_do_28bit_cmd(device,
8942             ccb,
8943             /*retries*/retry_count,
8944             /*flags*/CAM_DIR_NONE,
8945             /*protocol*/AP_PROTO_NON_DATA,
8946             /*tag_action*/MSG_SIMPLE_Q_TAG,
8947             /*command*/ATA_SETFEATURES,
8948             /*features*/cmd,
8949             /*lba*/0,
8950             /*sector_count*/sc,
8951             /*data_ptr*/NULL,
8952             /*dxfer_len*/0,
8953             /*timeout*/timeout ? timeout : 30 * 1000,
8954             /*quiet*/1);
8955
8956         cam_freeccb(ccb);
8957         return (retval);
8958 }
8959
8960 int
8961 scsigetopcodes(struct cam_device *device, int opcode_set, int opcode,
8962                int show_sa_errors, int sa_set, int service_action,
8963                int timeout_desc, int task_attr, int retry_count, int timeout,
8964                int verbosemode, uint32_t *fill_len, uint8_t **data_ptr)
8965 {
8966         union ccb *ccb = NULL;
8967         uint8_t *buf = NULL;
8968         uint32_t alloc_len = 0, num_opcodes;
8969         uint32_t valid_len = 0;
8970         uint32_t avail_len = 0;
8971         struct scsi_report_supported_opcodes_all *all_hdr;
8972         struct scsi_report_supported_opcodes_one *one;
8973         int options = 0;
8974         int retval = 0;
8975
8976         /*
8977          * Make it clear that we haven't yet allocated or filled anything.
8978          */
8979         *fill_len = 0;
8980         *data_ptr = NULL;
8981
8982         ccb = cam_getccb(device);
8983         if (ccb == NULL) {
8984                 warnx("couldn't allocate CCB");
8985                 retval = 1;
8986                 goto bailout;
8987         }
8988
8989         /* cam_getccb cleans up the header, caller has to zero the payload */
8990         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
8991
8992         if (opcode_set != 0) {
8993                 options |= RSO_OPTIONS_OC;
8994                 num_opcodes = 1;
8995                 alloc_len = sizeof(*one) + CAM_MAX_CDBLEN;
8996         } else {
8997                 num_opcodes = 256;
8998                 alloc_len = sizeof(*all_hdr) + (num_opcodes *
8999                     sizeof(struct scsi_report_supported_opcodes_descr));
9000         }
9001
9002         if (timeout_desc != 0) {
9003                 options |= RSO_RCTD;
9004                 alloc_len += num_opcodes *
9005                     sizeof(struct scsi_report_supported_opcodes_timeout);
9006         }
9007
9008         if (sa_set != 0) {
9009                 options |= RSO_OPTIONS_OC_SA;
9010                 if (show_sa_errors != 0)
9011                         options &= ~RSO_OPTIONS_OC;
9012         }
9013
9014 retry_alloc:
9015         if (buf != NULL) {
9016                 free(buf);
9017                 buf = NULL;
9018         }
9019
9020         buf = malloc(alloc_len);
9021         if (buf == NULL) {
9022                 warn("Unable to allocate %u bytes", alloc_len);
9023                 retval = 1;
9024                 goto bailout;
9025         }
9026         bzero(buf, alloc_len);
9027
9028         scsi_report_supported_opcodes(&ccb->csio,
9029                                       /*retries*/ retry_count,
9030                                       /*cbfcnp*/ NULL,
9031                                       /*tag_action*/ task_attr,
9032                                       /*options*/ options,
9033                                       /*req_opcode*/ opcode,
9034                                       /*req_service_action*/ service_action,
9035                                       /*data_ptr*/ buf,
9036                                       /*dxfer_len*/ alloc_len,
9037                                       /*sense_len*/ SSD_FULL_SIZE,
9038                                       /*timeout*/ timeout ? timeout : 10000);
9039
9040         ccb->ccb_h.flags |= CAM_DEV_QFRZDIS;
9041
9042         if (retry_count != 0)
9043                 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
9044
9045         if (cam_send_ccb(device, ccb) < 0) {
9046                 perror("error sending REPORT SUPPORTED OPERATION CODES");
9047                 retval = 1;
9048                 goto bailout;
9049         }
9050
9051         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
9052                 if (verbosemode != 0)
9053                         cam_error_print(device, ccb, CAM_ESF_ALL,
9054                                         CAM_EPF_ALL, stderr);
9055                 retval = 1;
9056                 goto bailout;
9057         }
9058
9059         valid_len = ccb->csio.dxfer_len - ccb->csio.resid;
9060
9061         if (((options & RSO_OPTIONS_MASK) == RSO_OPTIONS_ALL)
9062          && (valid_len >= sizeof(*all_hdr))) {
9063                 all_hdr = (struct scsi_report_supported_opcodes_all *)buf;
9064                 avail_len = scsi_4btoul(all_hdr->length) + sizeof(*all_hdr);
9065         } else if (((options & RSO_OPTIONS_MASK) != RSO_OPTIONS_ALL)
9066                 && (valid_len >= sizeof(*one))) {
9067                 uint32_t cdb_length;
9068
9069                 one = (struct scsi_report_supported_opcodes_one *)buf;
9070                 cdb_length = scsi_2btoul(one->cdb_length);
9071                 avail_len = sizeof(*one) + cdb_length;
9072                 if (one->support & RSO_ONE_CTDP) {
9073                         struct scsi_report_supported_opcodes_timeout *td;
9074
9075                         td = (struct scsi_report_supported_opcodes_timeout *)
9076                             &buf[avail_len];
9077                         if (valid_len >= (avail_len + sizeof(td->length))) {
9078                                 avail_len += scsi_2btoul(td->length) +
9079                                     sizeof(td->length);
9080                         } else {
9081                                 avail_len += sizeof(*td);
9082                         }
9083                 }
9084         }
9085
9086         /*
9087          * avail_len could be zero if we didn't get enough data back from
9088          * thet target to determine
9089          */
9090         if ((avail_len != 0)
9091          && (avail_len > valid_len)) {
9092                 alloc_len = avail_len;
9093                 goto retry_alloc;
9094         }
9095
9096         *fill_len = valid_len;
9097         *data_ptr = buf;
9098 bailout:
9099         if (retval != 0)
9100                 free(buf);
9101
9102         cam_freeccb(ccb);
9103
9104         return (retval);
9105 }
9106
9107 static int
9108 scsiprintoneopcode(struct cam_device *device, int req_opcode, int sa_set,
9109                    int req_sa, uint8_t *buf, uint32_t valid_len)
9110 {
9111         struct scsi_report_supported_opcodes_one *one;
9112         struct scsi_report_supported_opcodes_timeout *td;
9113         uint32_t cdb_len = 0, td_len = 0;
9114         const char *op_desc = NULL;
9115         unsigned int i;
9116         int retval = 0;
9117
9118         one = (struct scsi_report_supported_opcodes_one *)buf;
9119
9120         /*
9121          * If we don't have the full single opcode descriptor, no point in
9122          * continuing.
9123          */
9124         if (valid_len < __offsetof(struct scsi_report_supported_opcodes_one,
9125             cdb_length)) {
9126                 warnx("Only %u bytes returned, not enough to verify support",
9127                       valid_len);
9128                 retval = 1;
9129                 goto bailout;
9130         }
9131
9132         op_desc = scsi_op_desc(req_opcode, &device->inq_data);
9133
9134         printf("%s (0x%02x)", op_desc != NULL ? op_desc : "UNKNOWN",
9135                req_opcode);
9136         if (sa_set != 0)
9137                 printf(", SA 0x%x", req_sa);
9138         printf(": ");
9139
9140         switch (one->support & RSO_ONE_SUP_MASK) {
9141         case RSO_ONE_SUP_UNAVAIL:
9142                 printf("No command support information currently available\n");
9143                 break;
9144         case RSO_ONE_SUP_NOT_SUP:
9145                 printf("Command not supported\n");
9146                 retval = 1;
9147                 goto bailout;
9148                 break; /*NOTREACHED*/
9149         case RSO_ONE_SUP_AVAIL:
9150                 printf("Command is supported, complies with a SCSI standard\n");
9151                 break;
9152         case RSO_ONE_SUP_VENDOR:
9153                 printf("Command is supported, vendor-specific "
9154                        "implementation\n");
9155                 break;
9156         default:
9157                 printf("Unknown command support flags 0x%#x\n",
9158                        one->support & RSO_ONE_SUP_MASK);
9159                 break;
9160         }
9161
9162         /*
9163          * If we don't have the CDB length, it isn't exactly an error, the
9164          * command probably isn't supported.
9165          */
9166         if (valid_len < __offsetof(struct scsi_report_supported_opcodes_one,
9167             cdb_usage))
9168                 goto bailout;
9169
9170         cdb_len = scsi_2btoul(one->cdb_length);
9171
9172         /*
9173          * If our valid data doesn't include the full reported length,
9174          * return.  The caller should have detected this and adjusted his
9175          * allocation length to get all of the available data.
9176          */
9177         if (valid_len < sizeof(*one) + cdb_len) {
9178                 retval = 1;
9179                 goto bailout;
9180         }
9181
9182         /*
9183          * If all we have is the opcode, there is no point in printing out
9184          * the usage bitmap.
9185          */
9186         if (cdb_len <= 1) {
9187                 retval = 1;
9188                 goto bailout;
9189         }
9190
9191         printf("CDB usage bitmap:");
9192         for (i = 0; i < cdb_len; i++) {
9193                 printf(" %02x", one->cdb_usage[i]);
9194         }
9195         printf("\n");
9196
9197         /*
9198          * If we don't have a timeout descriptor, we're done.
9199          */
9200         if ((one->support & RSO_ONE_CTDP) == 0)
9201                 goto bailout;
9202
9203         /*
9204          * If we don't have enough valid length to include the timeout
9205          * descriptor length, we're done.
9206          */
9207         if (valid_len < (sizeof(*one) + cdb_len + sizeof(td->length)))
9208                 goto bailout;
9209
9210         td = (struct scsi_report_supported_opcodes_timeout *)
9211             &buf[sizeof(*one) + cdb_len];
9212         td_len = scsi_2btoul(td->length);
9213         td_len += sizeof(td->length);
9214
9215         /*
9216          * If we don't have the full timeout descriptor, we're done.
9217          */
9218         if (td_len < sizeof(*td))
9219                 goto bailout;
9220
9221         /*
9222          * If we don't have enough valid length to contain the full timeout
9223          * descriptor, we're done.
9224          */
9225         if (valid_len < (sizeof(*one) + cdb_len + td_len))
9226                 goto bailout;
9227
9228         printf("Timeout information:\n");
9229         printf("Command-specific:    0x%02x\n", td->cmd_specific);
9230         printf("Nominal timeout:     %u seconds\n",
9231                scsi_4btoul(td->nominal_time));
9232         printf("Recommended timeout: %u seconds\n",
9233                scsi_4btoul(td->recommended_time));
9234
9235 bailout:
9236         return (retval);
9237 }
9238
9239 static int
9240 scsiprintopcodes(struct cam_device *device, int td_req, uint8_t *buf,
9241                  uint32_t valid_len)
9242 {
9243         struct scsi_report_supported_opcodes_all *hdr;
9244         struct scsi_report_supported_opcodes_descr *desc;
9245         uint32_t avail_len = 0, used_len = 0;
9246         uint8_t *cur_ptr;
9247         int retval = 0;
9248
9249         if (valid_len < sizeof(*hdr)) {
9250                 warnx("%s: not enough returned data (%u bytes) opcode list",
9251                       __func__, valid_len);
9252                 retval = 1;
9253                 goto bailout;
9254         }
9255         hdr = (struct scsi_report_supported_opcodes_all *)buf;
9256         avail_len = scsi_4btoul(hdr->length);
9257         avail_len += sizeof(hdr->length);
9258         /*
9259          * Take the lesser of the amount of data the drive claims is
9260          * available, and the amount of data the HBA says was returned.
9261          */
9262         avail_len = MIN(avail_len, valid_len);
9263
9264         used_len = sizeof(hdr->length);
9265
9266         printf("%-6s %4s %8s ",
9267                "Opcode", "SA", "CDB len" );
9268
9269         if (td_req != 0)
9270                 printf("%5s %6s %6s ", "CS", "Nom", "Rec");
9271         printf(" Description\n");
9272
9273         while ((avail_len - used_len) > sizeof(*desc)) {
9274                 struct scsi_report_supported_opcodes_timeout *td;
9275                 uint32_t td_len;
9276                 const char *op_desc = NULL;
9277
9278                 cur_ptr = &buf[used_len];
9279                 desc = (struct scsi_report_supported_opcodes_descr *)cur_ptr;
9280
9281                 op_desc = scsi_op_desc(desc->opcode, &device->inq_data);
9282                 if (op_desc == NULL)
9283                         op_desc = "UNKNOWN";
9284
9285                 printf("0x%02x   %#4x %8u ", desc->opcode,
9286                        scsi_2btoul(desc->service_action),
9287                        scsi_2btoul(desc->cdb_length));
9288
9289                 used_len += sizeof(*desc);
9290
9291                 if ((desc->flags & RSO_CTDP) == 0) {
9292                         printf(" %s\n", op_desc);
9293                         continue;
9294                 }
9295
9296                 /*
9297                  * If we don't have enough space to fit a timeout
9298                  * descriptor, then we're done.
9299                  */
9300                 if (avail_len - used_len < sizeof(*td)) {
9301                         used_len = avail_len;
9302                         printf(" %s\n", op_desc);
9303                         continue;
9304                 }
9305                 cur_ptr = &buf[used_len];
9306                 td = (struct scsi_report_supported_opcodes_timeout *)cur_ptr;
9307                 td_len = scsi_2btoul(td->length);
9308                 td_len += sizeof(td->length);
9309
9310                 used_len += td_len;
9311                 /*
9312                  * If the given timeout descriptor length is less than what
9313                  * we understand, skip it.
9314                  */
9315                 if (td_len < sizeof(*td)) {
9316                         printf(" %s\n", op_desc);
9317                         continue;
9318                 }
9319
9320                 printf(" 0x%02x %6u %6u  %s\n", td->cmd_specific,
9321                        scsi_4btoul(td->nominal_time),
9322                        scsi_4btoul(td->recommended_time), op_desc);
9323         }
9324 bailout:
9325         return (retval);
9326 }
9327
9328 static int
9329 scsiopcodes(struct cam_device *device, int argc, char **argv,
9330             char *combinedopt, int task_attr, int retry_count, int timeout,
9331             int verbosemode)
9332 {
9333         int c;
9334         uint32_t opcode = 0, service_action = 0;
9335         int td_set = 0, opcode_set = 0, sa_set = 0;
9336         int show_sa_errors = 1;
9337         uint32_t valid_len = 0;
9338         uint8_t *buf = NULL;
9339         char *endptr;
9340         int retval = 0;
9341
9342         while ((c = getopt(argc, argv, combinedopt)) != -1) {
9343                 switch (c) {
9344                 case 'N':
9345                         show_sa_errors = 0;
9346                         break;
9347                 case 'o':
9348                         opcode = strtoul(optarg, &endptr, 0);
9349                         if (*endptr != '\0') {
9350                                 warnx("Invalid opcode \"%s\", must be a number",
9351                                       optarg);
9352                                 retval = 1;
9353                                 goto bailout;
9354                         }
9355                         if (opcode > 0xff) {
9356                                 warnx("Invalid opcode 0x%#x, must be between"
9357                                       "0 and 0xff inclusive", opcode);
9358                                 retval = 1;
9359                                 goto bailout;
9360                         }
9361                         opcode_set = 1;
9362                         break;
9363                 case 's':
9364                         service_action = strtoul(optarg, &endptr, 0);
9365                         if (*endptr != '\0') {
9366                                 warnx("Invalid service action \"%s\", must "
9367                                       "be a number", optarg);
9368                                 retval = 1;
9369                                 goto bailout;
9370                         }
9371                         if (service_action > 0xffff) {
9372                                 warnx("Invalid service action 0x%#x, must "
9373                                       "be between 0 and 0xffff inclusive",
9374                                       service_action);
9375                                 retval = 1;
9376                         }
9377                         sa_set = 1;
9378                         break;
9379                 case 'T':
9380                         td_set = 1;
9381                         break;
9382                 default:
9383                         break;
9384                 }
9385         }
9386
9387         if ((sa_set != 0)
9388          && (opcode_set == 0)) {
9389                 warnx("You must specify an opcode with -o if a service "
9390                       "action is given");
9391                 retval = 1;
9392                 goto bailout;
9393         }
9394         retval = scsigetopcodes(device, opcode_set, opcode, show_sa_errors,
9395                                 sa_set, service_action, td_set, task_attr,
9396                                 retry_count, timeout, verbosemode, &valid_len,
9397                                 &buf);
9398         if (retval != 0)
9399                 goto bailout;
9400
9401         if ((opcode_set != 0)
9402          || (sa_set != 0)) {
9403                 retval = scsiprintoneopcode(device, opcode, sa_set,
9404                                             service_action, buf, valid_len);
9405         } else {
9406                 retval = scsiprintopcodes(device, td_set, buf, valid_len);
9407         }
9408
9409 bailout:
9410         free(buf);
9411
9412         return (retval);
9413 }
9414
9415 #endif /* MINIMALISTIC */
9416
9417 static int
9418 scsireprobe(struct cam_device *device)
9419 {
9420         union ccb *ccb;
9421         int retval = 0;
9422
9423         ccb = cam_getccb(device);
9424
9425         if (ccb == NULL) {
9426                 warnx("%s: error allocating ccb", __func__);
9427                 return (1);
9428         }
9429
9430         CCB_CLEAR_ALL_EXCEPT_HDR(&ccb->csio);
9431
9432         ccb->ccb_h.func_code = XPT_REPROBE_LUN;
9433
9434         if (cam_send_ccb(device, ccb) < 0) {
9435                 warn("error sending XPT_REPROBE_LUN CCB");
9436                 retval = 1;
9437                 goto bailout;
9438         }
9439
9440         if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
9441                 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr);
9442                 retval = 1;
9443                 goto bailout;
9444         }
9445
9446 bailout:
9447         cam_freeccb(ccb);
9448
9449         return (retval);
9450 }
9451
9452 void
9453 usage(int printlong)
9454 {
9455
9456         fprintf(printlong ? stdout : stderr,
9457 "usage:  camcontrol <command>  [device id][generic args][command args]\n"
9458 "        camcontrol devlist    [-b] [-v]\n"
9459 #ifndef MINIMALISTIC
9460 "        camcontrol periphlist [dev_id][-n dev_name] [-u unit]\n"
9461 "        camcontrol tur        [dev_id][generic args]\n"
9462 "        camcontrol inquiry    [dev_id][generic args] [-D] [-S] [-R]\n"
9463 "        camcontrol identify   [dev_id][generic args] [-v]\n"
9464 "        camcontrol reportluns [dev_id][generic args] [-c] [-l] [-r report]\n"
9465 "        camcontrol readcap    [dev_id][generic args] [-b] [-h] [-H] [-N]\n"
9466 "                              [-q] [-s]\n"
9467 "        camcontrol start      [dev_id][generic args]\n"
9468 "        camcontrol stop       [dev_id][generic args]\n"
9469 "        camcontrol load       [dev_id][generic args]\n"
9470 "        camcontrol eject      [dev_id][generic args]\n"
9471 "        camcontrol reprobe    [dev_id][generic args]\n"
9472 #endif /* MINIMALISTIC */
9473 "        camcontrol rescan     <all | bus[:target:lun] | dev_id>\n"
9474 "        camcontrol reset      <all | bus[:target:lun] | dev_id>\n"
9475 #ifndef MINIMALISTIC
9476 "        camcontrol defects    [dev_id][generic args] <-f format> [-P][-G]\n"
9477 "                              [-q][-s][-S offset][-X]\n"
9478 "        camcontrol modepage   [dev_id][generic args] <-m page | -l>\n"
9479 "                              [-P pagectl][-e | -b][-d]\n"
9480 "        camcontrol cmd        [dev_id][generic args]\n"
9481 "                              <-a cmd [args] | -c cmd [args]>\n"
9482 "                              [-d] [-f] [-i len fmt|-o len fmt [args]] [-r fmt]\n"
9483 "        camcontrol smpcmd     [dev_id][generic args]\n"
9484 "                              <-r len fmt [args]> <-R len fmt [args]>\n"
9485 "        camcontrol smprg      [dev_id][generic args][-l]\n"
9486 "        camcontrol smppc      [dev_id][generic args] <-p phy> [-l]\n"
9487 "                              [-o operation][-d name][-m rate][-M rate]\n"
9488 "                              [-T pp_timeout][-a enable|disable]\n"
9489 "                              [-A enable|disable][-s enable|disable]\n"
9490 "                              [-S enable|disable]\n"
9491 "        camcontrol smpphylist [dev_id][generic args][-l][-q]\n"
9492 "        camcontrol smpmaninfo [dev_id][generic args][-l]\n"
9493 "        camcontrol debug      [-I][-P][-T][-S][-X][-c]\n"
9494 "                              <all|bus[:target[:lun]]|off>\n"
9495 "        camcontrol tags       [dev_id][generic args] [-N tags] [-q] [-v]\n"
9496 "        camcontrol negotiate  [dev_id][generic args] [-a][-c]\n"
9497 "                              [-D <enable|disable>][-M mode][-O offset]\n"
9498 "                              [-q][-R syncrate][-v][-T <enable|disable>]\n"
9499 "                              [-U][-W bus_width]\n"
9500 "        camcontrol format     [dev_id][generic args][-q][-r][-w][-y]\n"
9501 "        camcontrol sanitize   [dev_id][generic args]\n"
9502 "                              [-a overwrite|block|crypto|exitfailure]\n"
9503 "                              [-c passes][-I][-P pattern][-q][-U][-r][-w]\n"
9504 "                              [-y]\n"
9505 "        camcontrol idle       [dev_id][generic args][-t time]\n"
9506 "        camcontrol standby    [dev_id][generic args][-t time]\n"
9507 "        camcontrol sleep      [dev_id][generic args]\n"
9508 "        camcontrol apm        [dev_id][generic args][-l level]\n"
9509 "        camcontrol aam        [dev_id][generic args][-l level]\n"
9510 "        camcontrol fwdownload [dev_id][generic args] <-f fw_image> [-q]\n"
9511 "                              [-s][-y]\n"
9512 "        camcontrol security   [dev_id][generic args]\n"
9513 "                              <-d pwd | -e pwd | -f | -h pwd | -k pwd>\n"
9514 "                              [-l <high|maximum>] [-q] [-s pwd] [-T timeout]\n"
9515 "                              [-U <user|master>] [-y]\n"
9516 "        camcontrol hpa        [dev_id][generic args] [-f] [-l] [-P] [-p pwd]\n"
9517 "                              [-q] [-s max_sectors] [-U pwd] [-y]\n"
9518 "        camcontrol persist    [dev_id][generic args] <-i action|-o action>\n"
9519 "                              [-a][-I tid][-k key][-K sa_key][-p][-R rtp]\n"
9520 "                              [-s scope][-S][-T type][-U]\n"
9521 "        camcontrol attrib     [dev_id][generic args] <-r action|-w attr>\n"
9522 "                              [-a attr_num][-c][-e elem][-F form1,form1]\n"
9523 "                              [-p part][-s start][-T type][-V vol]\n"
9524 "        camcontrol opcodes    [dev_id][generic args][-o opcode][-s SA]\n"
9525 "                              [-N][-T]\n"
9526 "        camcontrol zone       [dev_id][generic args]<-c cmd> [-a] [-l LBA]\n"
9527 "                              [-o rep_opts] [-P print_opts]\n"
9528 "        camcontrol epc        [dev_id][generic_args]<-c cmd> [-d] [-D] [-e]\n"
9529 "                              [-H] [-p power_cond] [-P] [-r rst_src] [-s]\n"
9530 "                              [-S power_src] [-T timer]\n"
9531 "        camcontrol timestamp  [dev_id][generic_args] <-r [-f format|-m|-U]>|\n"
9532 "                              <-s <-f format -T time | -U >>\n"
9533 "                              \n"
9534 #endif /* MINIMALISTIC */
9535 "        camcontrol help\n");
9536         if (!printlong)
9537                 return;
9538 #ifndef MINIMALISTIC
9539         fprintf(stdout,
9540 "Specify one of the following options:\n"
9541 "devlist     list all CAM devices\n"
9542 "periphlist  list all CAM peripheral drivers attached to a device\n"
9543 "tur         send a test unit ready to the named device\n"
9544 "inquiry     send a SCSI inquiry command to the named device\n"
9545 "identify    send a ATA identify command to the named device\n"
9546 "reportluns  send a SCSI report luns command to the device\n"
9547 "readcap     send a SCSI read capacity command to the device\n"
9548 "start       send a Start Unit command to the device\n"
9549 "stop        send a Stop Unit command to the device\n"
9550 "load        send a Start Unit command to the device with the load bit set\n"
9551 "eject       send a Stop Unit command to the device with the eject bit set\n"
9552 "reprobe     update capacity information of the given device\n"
9553 "rescan      rescan all buses, the given bus, bus:target:lun or device\n"
9554 "reset       reset all buses, the given bus, bus:target:lun or device\n"
9555 "defects     read the defect list of the specified device\n"
9556 "modepage    display or edit (-e) the given mode page\n"
9557 "cmd         send the given SCSI command, may need -i or -o as well\n"
9558 "smpcmd      send the given SMP command, requires -o and -i\n"
9559 "smprg       send the SMP Report General command\n"
9560 "smppc       send the SMP PHY Control command, requires -p\n"
9561 "smpphylist  display phys attached to a SAS expander\n"
9562 "smpmaninfo  send the SMP Report Manufacturer Info command\n"
9563 "debug       turn debugging on/off for a bus, target, or lun, or all devices\n"
9564 "tags        report or set the number of transaction slots for a device\n"
9565 "negotiate   report or set device negotiation parameters\n"
9566 "format      send the SCSI FORMAT UNIT command to the named device\n"
9567 "sanitize    send the SCSI SANITIZE command to the named device\n"
9568 "idle        send the ATA IDLE command to the named device\n"
9569 "standby     send the ATA STANDBY command to the named device\n"
9570 "sleep       send the ATA SLEEP command to the named device\n"
9571 "fwdownload  program firmware of the named device with the given image\n"
9572 "security    report or send ATA security commands to the named device\n"
9573 "persist     send the SCSI PERSISTENT RESERVE IN or OUT commands\n"
9574 "attrib      send the SCSI READ or WRITE ATTRIBUTE commands\n"
9575 "opcodes     send the SCSI REPORT SUPPORTED OPCODES command\n"
9576 "zone        manage Zoned Block (Shingled) devices\n"
9577 "epc         send ATA Extended Power Conditions commands\n"
9578 "timestamp   report or set the device's timestamp\n"
9579 "help        this message\n"
9580 "Device Identifiers:\n"
9581 "bus:target        specify the bus and target, lun defaults to 0\n"
9582 "bus:target:lun    specify the bus, target and lun\n"
9583 "deviceUNIT        specify the device name, like \"da4\" or \"cd2\"\n"
9584 "Generic arguments:\n"
9585 "-v                be verbose, print out sense information\n"
9586 "-t timeout        command timeout in seconds, overrides default timeout\n"
9587 "-n dev_name       specify device name, e.g. \"da\", \"cd\"\n"
9588 "-u unit           specify unit number, e.g. \"0\", \"5\"\n"
9589 "-E                have the kernel attempt to perform SCSI error recovery\n"
9590 "-C count          specify the SCSI command retry count (needs -E to work)\n"
9591 "-Q task_attr      specify ordered, simple or head tag type for SCSI cmds\n"
9592 "modepage arguments:\n"
9593 "-l                list all available mode pages\n"
9594 "-m page           specify the mode page to view or edit\n"
9595 "-e                edit the specified mode page\n"
9596 "-b                force view to binary mode\n"
9597 "-d                disable block descriptors for mode sense\n"
9598 "-P pgctl          page control field 0-3\n"
9599 "defects arguments:\n"
9600 "-f format         specify defect list format (block, bfi or phys)\n"
9601 "-G                get the grown defect list\n"
9602 "-P                get the permanent defect list\n"
9603 "inquiry arguments:\n"
9604 "-D                get the standard inquiry data\n"
9605 "-S                get the serial number\n"
9606 "-R                get the transfer rate, etc.\n"
9607 "reportluns arguments:\n"
9608 "-c                only report a count of available LUNs\n"
9609 "-l                only print out luns, and not a count\n"
9610 "-r <reporttype>   specify \"default\", \"wellknown\" or \"all\"\n"
9611 "readcap arguments\n"
9612 "-b                only report the blocksize\n"
9613 "-h                human readable device size, base 2\n"
9614 "-H                human readable device size, base 10\n"
9615 "-N                print the number of blocks instead of last block\n"
9616 "-q                quiet, print numbers only\n"
9617 "-s                only report the last block/device size\n"
9618 "cmd arguments:\n"
9619 "-c cdb [args]     specify the SCSI CDB\n"
9620 "-i len fmt        specify input data and input data format\n"
9621 "-o len fmt [args] specify output data and output data fmt\n"
9622 "smpcmd arguments:\n"
9623 "-r len fmt [args] specify the SMP command to be sent\n"
9624 "-R len fmt [args] specify SMP response format\n"
9625 "smprg arguments:\n"
9626 "-l                specify the long response format\n"
9627 "smppc arguments:\n"
9628 "-p phy            specify the PHY to operate on\n"
9629 "-l                specify the long request/response format\n"
9630 "-o operation      specify the phy control operation\n"
9631 "-d name           set the attached device name\n"
9632 "-m rate           set the minimum physical link rate\n"
9633 "-M rate           set the maximum physical link rate\n"
9634 "-T pp_timeout     set the partial pathway timeout value\n"
9635 "-a enable|disable enable or disable SATA slumber\n"
9636 "-A enable|disable enable or disable SATA partial phy power\n"
9637 "-s enable|disable enable or disable SAS slumber\n"
9638 "-S enable|disable enable or disable SAS partial phy power\n"
9639 "smpphylist arguments:\n"
9640 "-l                specify the long response format\n"
9641 "-q                only print phys with attached devices\n"
9642 "smpmaninfo arguments:\n"
9643 "-l                specify the long response format\n"
9644 "debug arguments:\n"
9645 "-I                CAM_DEBUG_INFO -- scsi commands, errors, data\n"
9646 "-T                CAM_DEBUG_TRACE -- routine flow tracking\n"
9647 "-S                CAM_DEBUG_SUBTRACE -- internal routine command flow\n"
9648 "-c                CAM_DEBUG_CDB -- print out SCSI CDBs only\n"
9649 "tags arguments:\n"
9650 "-N tags           specify the number of tags to use for this device\n"
9651 "-q                be quiet, don't report the number of tags\n"
9652 "-v                report a number of tag-related parameters\n"
9653 "negotiate arguments:\n"
9654 "-a                send a test unit ready after negotiation\n"
9655 "-c                report/set current negotiation settings\n"
9656 "-D <arg>          \"enable\" or \"disable\" disconnection\n"
9657 "-M mode           set ATA mode\n"
9658 "-O offset         set command delay offset\n"
9659 "-q                be quiet, don't report anything\n"
9660 "-R syncrate       synchronization rate in MHz\n"
9661 "-T <arg>          \"enable\" or \"disable\" tagged queueing\n"
9662 "-U                report/set user negotiation settings\n"
9663 "-W bus_width      set the bus width in bits (8, 16 or 32)\n"
9664 "-v                also print a Path Inquiry CCB for the controller\n"
9665 "format arguments:\n"
9666 "-q                be quiet, don't print status messages\n"
9667 "-r                run in report only mode\n"
9668 "-w                don't send immediate format command\n"
9669 "-y                don't ask any questions\n"
9670 "sanitize arguments:\n"
9671 "-a operation      operation mode: overwrite, block, crypto or exitfailure\n"
9672 "-c passes         overwrite passes to perform (1 to 31)\n"
9673 "-I                invert overwrite pattern after each pass\n"
9674 "-P pattern        path to overwrite pattern file\n"
9675 "-q                be quiet, don't print status messages\n"
9676 "-r                run in report only mode\n"
9677 "-U                run operation in unrestricted completion exit mode\n"
9678 "-w                don't send immediate sanitize command\n"
9679 "-y                don't ask any questions\n"
9680 "idle/standby arguments:\n"
9681 "-t <arg>          number of seconds before respective state.\n"
9682 "fwdownload arguments:\n"
9683 "-f fw_image       path to firmware image file\n"
9684 "-q                don't print informational messages, only errors\n"
9685 "-s                run in simulation mode\n"
9686 "-v                print info for every firmware segment sent to device\n"
9687 "-y                don't ask any questions\n"
9688 "security arguments:\n"
9689 "-d pwd            disable security using the given password for the selected\n"
9690 "                  user\n"
9691 "-e pwd            erase the device using the given pwd for the selected user\n"
9692 "-f                freeze the security configuration of the specified device\n"
9693 "-h pwd            enhanced erase the device using the given pwd for the\n"
9694 "                  selected user\n"
9695 "-k pwd            unlock the device using the given pwd for the selected\n"
9696 "                  user\n"
9697 "-l <high|maximum> specifies which security level to set: high or maximum\n"
9698 "-q                be quiet, do not print any status messages\n"
9699 "-s pwd            password the device (enable security) using the given\n"
9700 "                  pwd for the selected user\n"
9701 "-T timeout        overrides the timeout (seconds) used for erase operation\n"
9702 "-U <user|master>  specifies which user to set: user or master\n"
9703 "-y                don't ask any questions\n"
9704 "hpa arguments:\n"
9705 "-f                freeze the HPA configuration of the device\n"
9706 "-l                lock the HPA configuration of the device\n"
9707 "-P                make the HPA max sectors persist\n"
9708 "-p pwd            Set the HPA configuration password required for unlock\n"
9709 "                  calls\n"
9710 "-q                be quiet, do not print any status messages\n"
9711 "-s sectors        configures the maximum user accessible sectors of the\n"
9712 "                  device\n"
9713 "-U pwd            unlock the HPA configuration of the device\n"
9714 "-y                don't ask any questions\n"
9715 "persist arguments:\n"
9716 "-i action         specify read_keys, read_reservation, report_cap, or\n"
9717 "                  read_full_status\n"
9718 "-o action         specify register, register_ignore, reserve, release,\n"
9719 "                  clear, preempt, preempt_abort, register_move, replace_lost\n"
9720 "-a                set the All Target Ports (ALL_TG_PT) bit\n"
9721 "-I tid            specify a Transport ID, e.g.: sas,0x1234567812345678\n"
9722 "-k key            specify the Reservation Key\n"
9723 "-K sa_key         specify the Service Action Reservation Key\n"
9724 "-p                set the Activate Persist Through Power Loss bit\n"
9725 "-R rtp            specify the Relative Target Port\n"
9726 "-s scope          specify the scope: lun, extent, element or a number\n"
9727 "-S                specify Transport ID for register, requires -I\n"
9728 "-T res_type       specify the reservation type: read_shared, wr_ex, rd_ex,\n"
9729 "                  ex_ac, wr_ex_ro, ex_ac_ro, wr_ex_ar, ex_ac_ar\n"
9730 "-U                unregister the current initiator for register_move\n"
9731 "attrib arguments:\n"
9732 "-r action         specify attr_values, attr_list, lv_list, part_list, or\n"
9733 "                  supp_attr\n"
9734 "-w attr           specify an attribute to write, one -w argument per attr\n"
9735 "-a attr_num       only display this attribute number\n"
9736 "-c                get cached attributes\n"
9737 "-e elem_addr      request attributes for the given element in a changer\n"
9738 "-F form1,form2    output format, comma separated list: text_esc, text_raw,\n"
9739 "                  nonascii_esc, nonascii_trim, nonascii_raw, field_all,\n"
9740 "                  field_none, field_desc, field_num, field_size, field_rw\n"
9741 "-p partition      request attributes for the given partition\n"
9742 "-s start_attr     request attributes starting at the given number\n"
9743 "-T elem_type      specify the element type (used with -e)\n"
9744 "-V logical_vol    specify the logical volume ID\n"
9745 "opcodes arguments:\n"
9746 "-o opcode         specify the individual opcode to list\n"
9747 "-s service_action specify the service action for the opcode\n"
9748 "-N                do not return SCSI error for unsupported SA\n"
9749 "-T                request nominal and recommended timeout values\n"
9750 "zone arguments:\n"
9751 "-c cmd            required: rz, open, close, finish, or rwp\n"
9752 "-a                apply the action to all zones\n"
9753 "-l LBA            specify the zone starting LBA\n"
9754 "-o rep_opts       report zones options: all, empty, imp_open, exp_open,\n"
9755 "                  closed, full, ro, offline, reset, nonseq, nonwp\n"
9756 "-P print_opt      report zones printing:  normal, summary, script\n"
9757 "epc arguments:\n"
9758 "-c cmd            required: restore, goto, timer, state, enable, disable,\n"
9759 "                  source, status, list\n"
9760 "-d                disable power mode (timer, state)\n"
9761 "-D                delayed entry (goto)\n"
9762 "-e                enable power mode (timer, state)\n"
9763 "-H                hold power mode (goto)\n"
9764 "-p power_cond     Idle_a, Idle_b, Idle_c, Standby_y, Standby_z (timer,\n"
9765 "                  state, goto)\n"
9766 "-P                only display power mode (status)\n"
9767 "-r rst_src        restore settings from: default, saved (restore)\n"
9768 "-s                save mode (timer, state, restore)\n"
9769 "-S power_src      set power source: battery, nonbattery (source)\n"
9770 "-T timer          set timer, seconds, .1 sec resolution (timer)\n"
9771 "timestamp arguments:\n"
9772 "-r                report the timestamp of the device\n"
9773 "-f format         report the timestamp of the device with the given\n"
9774 "                  strftime(3) format string\n"
9775 "-m                report the timestamp of the device as milliseconds since\n"
9776 "                  January 1st, 1970\n"
9777 "-U                report the time with UTC instead of the local time zone\n"
9778 "-s                set the timestamp of the device\n"
9779 "-f format         the format of the time string passed into strptime(3)\n"
9780 "-T time           the time value passed into strptime(3)\n"
9781 "-U                set the timestamp of the device to UTC time\n"
9782 );
9783 #endif /* MINIMALISTIC */
9784 }
9785
9786 int
9787 main(int argc, char **argv)
9788 {
9789         int c;
9790         char *device = NULL;
9791         int unit = 0;
9792         struct cam_device *cam_dev = NULL;
9793         int timeout = 0, retry_count = 1;
9794         camcontrol_optret optreturn;
9795         char *tstr;
9796         const char *mainopt = "C:En:Q:t:u:v";
9797         const char *subopt = NULL;
9798         char combinedopt[256];
9799         int error = 0, optstart = 2;
9800         int task_attr = MSG_SIMPLE_Q_TAG;
9801         int devopen = 1;
9802 #ifndef MINIMALISTIC
9803         path_id_t bus;
9804         target_id_t target;
9805         lun_id_t lun;
9806 #endif /* MINIMALISTIC */
9807
9808         cmdlist = CAM_CMD_NONE;
9809         arglist = CAM_ARG_NONE;
9810
9811         if (argc < 2) {
9812                 usage(0);
9813                 exit(1);
9814         }
9815
9816         /*
9817          * Get the base option.
9818          */
9819         optreturn = getoption(option_table,argv[1], &cmdlist, &arglist,&subopt);
9820
9821         if (optreturn == CC_OR_AMBIGUOUS) {
9822                 warnx("ambiguous option %s", argv[1]);
9823                 usage(0);
9824                 exit(1);
9825         } else if (optreturn == CC_OR_NOT_FOUND) {
9826                 warnx("option %s not found", argv[1]);
9827                 usage(0);
9828                 exit(1);
9829         }
9830
9831         /*
9832          * Ahh, getopt(3) is a pain.
9833          *
9834          * This is a gross hack.  There really aren't many other good
9835          * options (excuse the pun) for parsing options in a situation like
9836          * this.  getopt is kinda braindead, so you end up having to run
9837          * through the options twice, and give each invocation of getopt
9838          * the option string for the other invocation.
9839          *
9840          * You would think that you could just have two groups of options.
9841          * The first group would get parsed by the first invocation of
9842          * getopt, and the second group would get parsed by the second
9843          * invocation of getopt.  It doesn't quite work out that way.  When
9844          * the first invocation of getopt finishes, it leaves optind pointing
9845          * to the argument _after_ the first argument in the second group.
9846          * So when the second invocation of getopt comes around, it doesn't
9847          * recognize the first argument it gets and then bails out.
9848          *
9849          * A nice alternative would be to have a flag for getopt that says
9850          * "just keep parsing arguments even when you encounter an unknown
9851          * argument", but there isn't one.  So there's no real clean way to
9852          * easily parse two sets of arguments without having one invocation
9853          * of getopt know about the other.
9854          *
9855          * Without this hack, the first invocation of getopt would work as
9856          * long as the generic arguments are first, but the second invocation
9857          * (in the subfunction) would fail in one of two ways.  In the case
9858          * where you don't set optreset, it would fail because optind may be
9859          * pointing to the argument after the one it should be pointing at.
9860          * In the case where you do set optreset, and reset optind, it would
9861          * fail because getopt would run into the first set of options, which
9862          * it doesn't understand.
9863          *
9864          * All of this would "sort of" work if you could somehow figure out
9865          * whether optind had been incremented one option too far.  The
9866          * mechanics of that, however, are more daunting than just giving
9867          * both invocations all of the expect options for either invocation.
9868          *
9869          * Needless to say, I wouldn't mind if someone invented a better
9870          * (non-GPL!) command line parsing interface than getopt.  I
9871          * wouldn't mind if someone added more knobs to getopt to make it
9872          * work better.  Who knows, I may talk myself into doing it someday,
9873          * if the standards weenies let me.  As it is, it just leads to
9874          * hackery like this and causes people to avoid it in some cases.
9875          *
9876          * KDM, September 8th, 1998
9877          */
9878         if (subopt != NULL)
9879                 sprintf(combinedopt, "%s%s", mainopt, subopt);
9880         else
9881                 sprintf(combinedopt, "%s", mainopt);
9882
9883         /*
9884          * For these options we do not parse optional device arguments and
9885          * we do not open a passthrough device.
9886          */
9887         if ((cmdlist == CAM_CMD_RESCAN)
9888          || (cmdlist == CAM_CMD_RESET)
9889          || (cmdlist == CAM_CMD_DEVTREE)
9890          || (cmdlist == CAM_CMD_USAGE)
9891          || (cmdlist == CAM_CMD_DEBUG))
9892                 devopen = 0;
9893
9894 #ifndef MINIMALISTIC
9895         if ((devopen == 1)
9896          && (argc > 2 && argv[2][0] != '-')) {
9897                 char name[30];
9898                 int rv;
9899
9900                 if (isdigit(argv[2][0])) {
9901                         /* device specified as bus:target[:lun] */
9902                         rv = parse_btl(argv[2], &bus, &target, &lun, &arglist);
9903                         if (rv < 2)
9904                                 errx(1, "numeric device specification must "
9905                                      "be either bus:target, or "
9906                                      "bus:target:lun");
9907                         /* default to 0 if lun was not specified */
9908                         if ((arglist & CAM_ARG_LUN) == 0) {
9909                                 lun = 0;
9910                                 arglist |= CAM_ARG_LUN;
9911                         }
9912                         optstart++;
9913                 } else {
9914                         if (cam_get_device(argv[2], name, sizeof name, &unit)
9915                             == -1)
9916                                 errx(1, "%s", cam_errbuf);
9917                         device = strdup(name);
9918                         arglist |= CAM_ARG_DEVICE | CAM_ARG_UNIT;
9919                         optstart++;
9920                 }
9921         }
9922 #endif /* MINIMALISTIC */
9923         /*
9924          * Start getopt processing at argv[2/3], since we've already
9925          * accepted argv[1..2] as the command name, and as a possible
9926          * device name.
9927          */
9928         optind = optstart;
9929
9930         /*
9931          * Now we run through the argument list looking for generic
9932          * options, and ignoring options that possibly belong to
9933          * subfunctions.
9934          */
9935         while ((c = getopt(argc, argv, combinedopt))!= -1){
9936                 switch(c) {
9937                         case 'C':
9938                                 retry_count = strtol(optarg, NULL, 0);
9939                                 if (retry_count < 0)
9940                                         errx(1, "retry count %d is < 0",
9941                                              retry_count);
9942                                 arglist |= CAM_ARG_RETRIES;
9943                                 break;
9944                         case 'E':
9945                                 arglist |= CAM_ARG_ERR_RECOVER;
9946                                 break;
9947                         case 'n':
9948                                 arglist |= CAM_ARG_DEVICE;
9949                                 tstr = optarg;
9950                                 while (isspace(*tstr) && (*tstr != '\0'))
9951                                         tstr++;
9952                                 device = (char *)strdup(tstr);
9953                                 break;
9954                         case 'Q': {
9955                                 char *endptr;
9956                                 int table_entry = 0;
9957
9958                                 tstr = optarg;
9959                                 while (isspace(*tstr) && (*tstr != '\0'))
9960                                         tstr++;
9961                                 if (isdigit(*tstr)) {
9962                                         task_attr = strtol(tstr, &endptr, 0);
9963                                         if (*endptr != '\0') {
9964                                                 errx(1, "Invalid queue option "
9965                                                     "%s", tstr);
9966                                         }
9967                                 } else {
9968                                         size_t table_size;
9969                                         scsi_nv_status status;
9970
9971                                         table_size = sizeof(task_attrs) /
9972                                                      sizeof(task_attrs[0]);
9973                                         status = scsi_get_nv(task_attrs,
9974                                             table_size, tstr, &table_entry,
9975                                             SCSI_NV_FLAG_IG_CASE);
9976                                         if (status == SCSI_NV_FOUND)
9977                                                 task_attr = task_attrs[
9978                                                     table_entry].value;
9979                                         else {
9980                                                 errx(1, "%s option %s",
9981                                                   (status == SCSI_NV_AMBIGUOUS)?
9982                                                     "ambiguous" : "invalid",
9983                                                     tstr);
9984                                         }
9985                                 }
9986                                 break;
9987                         }
9988                         case 't':
9989                                 timeout = strtol(optarg, NULL, 0);
9990                                 if (timeout < 0)
9991                                         errx(1, "invalid timeout %d", timeout);
9992                                 /* Convert the timeout from seconds to ms */
9993                                 timeout *= 1000;
9994                                 arglist |= CAM_ARG_TIMEOUT;
9995                                 break;
9996                         case 'u':
9997                                 arglist |= CAM_ARG_UNIT;
9998                                 unit = strtol(optarg, NULL, 0);
9999                                 break;
10000                         case 'v':
10001                                 arglist |= CAM_ARG_VERBOSE;
10002                                 break;
10003                         default:
10004                                 break;
10005                 }
10006         }
10007
10008 #ifndef MINIMALISTIC
10009         /*
10010          * For most commands we'll want to open the passthrough device
10011          * associated with the specified device.  In the case of the rescan
10012          * commands, we don't use a passthrough device at all, just the
10013          * transport layer device.
10014          */
10015         if (devopen == 1) {
10016                 if (((arglist & (CAM_ARG_BUS|CAM_ARG_TARGET)) == 0)
10017                  && (((arglist & CAM_ARG_DEVICE) == 0)
10018                   || ((arglist & CAM_ARG_UNIT) == 0))) {
10019                         errx(1, "subcommand \"%s\" requires a valid device "
10020                              "identifier", argv[1]);
10021                 }
10022
10023                 if ((cam_dev = ((arglist & (CAM_ARG_BUS | CAM_ARG_TARGET))?
10024                                 cam_open_btl(bus, target, lun, O_RDWR, NULL) :
10025                                 cam_open_spec_device(device,unit,O_RDWR,NULL)))
10026                      == NULL)
10027                         errx(1,"%s", cam_errbuf);
10028         }
10029 #endif /* MINIMALISTIC */
10030
10031         /*
10032          * Reset optind to 2, and reset getopt, so these routines can parse
10033          * the arguments again.
10034          */
10035         optind = optstart;
10036         optreset = 1;
10037
10038         switch(cmdlist) {
10039 #ifndef MINIMALISTIC
10040         case CAM_CMD_DEVLIST:
10041                 error = getdevlist(cam_dev);
10042                 break;
10043         case CAM_CMD_HPA:
10044                 error = atahpa(cam_dev, retry_count, timeout,
10045                                argc, argv, combinedopt);
10046                 break;
10047 #endif /* MINIMALISTIC */
10048         case CAM_CMD_DEVTREE:
10049                 error = getdevtree(argc, argv, combinedopt);
10050                 break;
10051 #ifndef MINIMALISTIC
10052         case CAM_CMD_TUR:
10053                 error = testunitready(cam_dev, task_attr, retry_count,
10054                     timeout, 0);
10055                 break;
10056         case CAM_CMD_INQUIRY:
10057                 error = scsidoinquiry(cam_dev, argc, argv, combinedopt,
10058                                       task_attr, retry_count, timeout);
10059                 break;
10060         case CAM_CMD_IDENTIFY:
10061                 error = ataidentify(cam_dev, retry_count, timeout);
10062                 break;
10063         case CAM_CMD_STARTSTOP:
10064                 error = scsistart(cam_dev, arglist & CAM_ARG_START_UNIT,
10065                                   arglist & CAM_ARG_EJECT, task_attr,
10066                                   retry_count, timeout);
10067                 break;
10068 #endif /* MINIMALISTIC */
10069         case CAM_CMD_RESCAN:
10070                 error = dorescan_or_reset(argc, argv, 1);
10071                 break;
10072         case CAM_CMD_RESET:
10073                 error = dorescan_or_reset(argc, argv, 0);
10074                 break;
10075 #ifndef MINIMALISTIC
10076         case CAM_CMD_READ_DEFECTS:
10077                 error = readdefects(cam_dev, argc, argv, combinedopt,
10078                                     task_attr, retry_count, timeout);
10079                 break;
10080         case CAM_CMD_MODE_PAGE:
10081                 modepage(cam_dev, argc, argv, combinedopt,
10082                          task_attr, retry_count, timeout);
10083                 break;
10084         case CAM_CMD_SCSI_CMD:
10085                 error = scsicmd(cam_dev, argc, argv, combinedopt,
10086                                 task_attr, retry_count, timeout);
10087                 break;
10088         case CAM_CMD_MMCSD_CMD:
10089                 error = mmcsdcmd(cam_dev, argc, argv, combinedopt,
10090                                         retry_count, timeout);
10091                 break;
10092         case CAM_CMD_SMP_CMD:
10093                 error = smpcmd(cam_dev, argc, argv, combinedopt,
10094                                retry_count, timeout);
10095                 break;
10096         case CAM_CMD_SMP_RG:
10097                 error = smpreportgeneral(cam_dev, argc, argv,
10098                                          combinedopt, retry_count,
10099                                          timeout);
10100                 break;
10101         case CAM_CMD_SMP_PC:
10102                 error = smpphycontrol(cam_dev, argc, argv, combinedopt,
10103                                       retry_count, timeout);
10104                 break;
10105         case CAM_CMD_SMP_PHYLIST:
10106                 error = smpphylist(cam_dev, argc, argv, combinedopt,
10107                                    retry_count, timeout);
10108                 break;
10109         case CAM_CMD_SMP_MANINFO:
10110                 error = smpmaninfo(cam_dev, argc, argv, combinedopt,
10111                                    retry_count, timeout);
10112                 break;
10113         case CAM_CMD_DEBUG:
10114                 error = camdebug(argc, argv, combinedopt);
10115                 break;
10116         case CAM_CMD_TAG:
10117                 error = tagcontrol(cam_dev, argc, argv, combinedopt);
10118                 break;
10119         case CAM_CMD_RATE:
10120                 error = ratecontrol(cam_dev, task_attr, retry_count,
10121                                     timeout, argc, argv, combinedopt);
10122                 break;
10123         case CAM_CMD_FORMAT:
10124                 error = scsiformat(cam_dev, argc, argv,
10125                                    combinedopt, task_attr, retry_count,
10126                                    timeout);
10127                 break;
10128         case CAM_CMD_REPORTLUNS:
10129                 error = scsireportluns(cam_dev, argc, argv,
10130                                        combinedopt, task_attr,
10131                                        retry_count, timeout);
10132                 break;
10133         case CAM_CMD_READCAP:
10134                 error = scsireadcapacity(cam_dev, argc, argv,
10135                                          combinedopt, task_attr,
10136                                          retry_count, timeout);
10137                 break;
10138         case CAM_CMD_IDLE:
10139         case CAM_CMD_STANDBY:
10140         case CAM_CMD_SLEEP:
10141                 error = atapm(cam_dev, argc, argv,
10142                               combinedopt, retry_count, timeout);
10143                 break;
10144         case CAM_CMD_APM:
10145         case CAM_CMD_AAM:
10146                 error = ataaxm(cam_dev, argc, argv,
10147                               combinedopt, retry_count, timeout);
10148                 break;
10149         case CAM_CMD_SECURITY:
10150                 error = atasecurity(cam_dev, retry_count, timeout,
10151                                     argc, argv, combinedopt);
10152                 break;
10153         case CAM_CMD_DOWNLOAD_FW:
10154                 error = fwdownload(cam_dev, argc, argv, combinedopt,
10155                     arglist & CAM_ARG_VERBOSE, task_attr, retry_count,
10156                     timeout);
10157                 break;
10158         case CAM_CMD_SANITIZE:
10159                 error = scsisanitize(cam_dev, argc, argv,
10160                                      combinedopt, task_attr,
10161                                      retry_count, timeout);
10162                 break;
10163         case CAM_CMD_PERSIST:
10164                 error = scsipersist(cam_dev, argc, argv, combinedopt,
10165                     task_attr, retry_count, timeout,
10166                     arglist & CAM_ARG_VERBOSE,
10167                     arglist & CAM_ARG_ERR_RECOVER);
10168                 break;
10169         case CAM_CMD_ATTRIB:
10170                 error = scsiattrib(cam_dev, argc, argv, combinedopt,
10171                     task_attr, retry_count, timeout,
10172                     arglist & CAM_ARG_VERBOSE,
10173                     arglist & CAM_ARG_ERR_RECOVER);
10174                 break;
10175         case CAM_CMD_OPCODES:
10176                 error = scsiopcodes(cam_dev, argc, argv, combinedopt,
10177                     task_attr, retry_count, timeout,
10178                     arglist & CAM_ARG_VERBOSE);
10179                 break;
10180         case CAM_CMD_REPROBE:
10181                 error = scsireprobe(cam_dev);
10182                 break;
10183         case CAM_CMD_ZONE:
10184                 error = zone(cam_dev, argc, argv, combinedopt,
10185                     task_attr, retry_count, timeout,
10186                     arglist & CAM_ARG_VERBOSE);
10187                 break;
10188         case CAM_CMD_EPC:
10189                 error = epc(cam_dev, argc, argv, combinedopt,
10190                     retry_count, timeout, arglist & CAM_ARG_VERBOSE);
10191                 break;
10192         case CAM_CMD_TIMESTAMP:
10193                 error = timestamp(cam_dev, argc, argv, combinedopt,
10194                     task_attr, retry_count, timeout,
10195                     arglist & CAM_ARG_VERBOSE);
10196                 break;
10197 #endif /* MINIMALISTIC */
10198         case CAM_CMD_USAGE:
10199                 usage(1);
10200                 break;
10201         default:
10202                 usage(0);
10203                 error = 1;
10204                 break;
10205         }
10206
10207         if (cam_dev != NULL)
10208                 cam_close_device(cam_dev);
10209
10210         exit(error);
10211 }