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