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