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