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