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