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