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/endian.h> 36 #include <sys/sbuf.h> 37 38 #include <stdio.h> 39 #include <stdlib.h> 40 #include <string.h> 41 #include <unistd.h> 42 #include <inttypes.h> 43 #include <limits.h> 44 #include <fcntl.h> 45 #include <ctype.h> 46 #include <err.h> 47 #include <libutil.h> 48 49 #include <cam/cam.h> 50 #include <cam/cam_debug.h> 51 #include <cam/cam_ccb.h> 52 #include <cam/scsi/scsi_all.h> 53 #include <cam/scsi/scsi_da.h> 54 #include <cam/scsi/scsi_pass.h> 55 #include <cam/scsi/scsi_message.h> 56 #include <cam/scsi/smp_all.h> 57 #include <cam/ata/ata_all.h> 58 #include <camlib.h> 59 #include "camcontrol.h" 60 61 typedef enum { 62 CAM_CMD_NONE = 0x00000000, 63 CAM_CMD_DEVLIST = 0x00000001, 64 CAM_CMD_TUR = 0x00000002, 65 CAM_CMD_INQUIRY = 0x00000003, 66 CAM_CMD_STARTSTOP = 0x00000004, 67 CAM_CMD_RESCAN = 0x00000005, 68 CAM_CMD_READ_DEFECTS = 0x00000006, 69 CAM_CMD_MODE_PAGE = 0x00000007, 70 CAM_CMD_SCSI_CMD = 0x00000008, 71 CAM_CMD_DEVTREE = 0x00000009, 72 CAM_CMD_USAGE = 0x0000000a, 73 CAM_CMD_DEBUG = 0x0000000b, 74 CAM_CMD_RESET = 0x0000000c, 75 CAM_CMD_FORMAT = 0x0000000d, 76 CAM_CMD_TAG = 0x0000000e, 77 CAM_CMD_RATE = 0x0000000f, 78 CAM_CMD_DETACH = 0x00000010, 79 CAM_CMD_REPORTLUNS = 0x00000011, 80 CAM_CMD_READCAP = 0x00000012, 81 CAM_CMD_IDENTIFY = 0x00000013, 82 CAM_CMD_IDLE = 0x00000014, 83 CAM_CMD_STANDBY = 0x00000015, 84 CAM_CMD_SLEEP = 0x00000016, 85 CAM_CMD_SMP_CMD = 0x00000017, 86 CAM_CMD_SMP_RG = 0x00000018, 87 CAM_CMD_SMP_PC = 0x00000019, 88 CAM_CMD_SMP_PHYLIST = 0x0000001a, 89 CAM_CMD_SMP_MANINFO = 0x0000001b 90 } cam_cmdmask; 91 92 typedef enum { 93 CAM_ARG_NONE = 0x00000000, 94 CAM_ARG_VERBOSE = 0x00000001, 95 CAM_ARG_DEVICE = 0x00000002, 96 CAM_ARG_BUS = 0x00000004, 97 CAM_ARG_TARGET = 0x00000008, 98 CAM_ARG_LUN = 0x00000010, 99 CAM_ARG_EJECT = 0x00000020, 100 CAM_ARG_UNIT = 0x00000040, 101 CAM_ARG_FORMAT_BLOCK = 0x00000080, 102 CAM_ARG_FORMAT_BFI = 0x00000100, 103 CAM_ARG_FORMAT_PHYS = 0x00000200, 104 CAM_ARG_PLIST = 0x00000400, 105 CAM_ARG_GLIST = 0x00000800, 106 CAM_ARG_GET_SERIAL = 0x00001000, 107 CAM_ARG_GET_STDINQ = 0x00002000, 108 CAM_ARG_GET_XFERRATE = 0x00004000, 109 CAM_ARG_INQ_MASK = 0x00007000, 110 CAM_ARG_MODE_EDIT = 0x00008000, 111 CAM_ARG_PAGE_CNTL = 0x00010000, 112 CAM_ARG_TIMEOUT = 0x00020000, 113 CAM_ARG_CMD_IN = 0x00040000, 114 CAM_ARG_CMD_OUT = 0x00080000, 115 CAM_ARG_DBD = 0x00100000, 116 CAM_ARG_ERR_RECOVER = 0x00200000, 117 CAM_ARG_RETRIES = 0x00400000, 118 CAM_ARG_START_UNIT = 0x00800000, 119 CAM_ARG_DEBUG_INFO = 0x01000000, 120 CAM_ARG_DEBUG_TRACE = 0x02000000, 121 CAM_ARG_DEBUG_SUBTRACE = 0x04000000, 122 CAM_ARG_DEBUG_CDB = 0x08000000, 123 CAM_ARG_DEBUG_XPT = 0x10000000, 124 CAM_ARG_DEBUG_PERIPH = 0x20000000, 125 } cam_argmask; 126 127 struct camcontrol_opts { 128 const char *optname; 129 uint32_t cmdnum; 130 cam_argmask argnum; 131 const char *subopt; 132 }; 133 134 #ifndef MINIMALISTIC 135 static const char scsicmd_opts[] = "a:c:dfi:o:r"; 136 static const char readdefect_opts[] = "f:GP"; 137 static const char negotiate_opts[] = "acD:M:O:qR:T:UW:"; 138 static const char smprg_opts[] = "l"; 139 static const char smppc_opts[] = "a:A:d:lm:M:o:p:s:S:T:"; 140 static const char smpphylist_opts[] = "lq"; 141 #endif 142 143 struct camcontrol_opts option_table[] = { 144 #ifndef MINIMALISTIC 145 {"tur", CAM_CMD_TUR, CAM_ARG_NONE, NULL}, 146 {"inquiry", CAM_CMD_INQUIRY, CAM_ARG_NONE, "DSR"}, 147 {"identify", CAM_CMD_IDENTIFY, CAM_ARG_NONE, NULL}, 148 {"start", CAM_CMD_STARTSTOP, CAM_ARG_START_UNIT, NULL}, 149 {"stop", CAM_CMD_STARTSTOP, CAM_ARG_NONE, NULL}, 150 {"load", CAM_CMD_STARTSTOP, CAM_ARG_START_UNIT | CAM_ARG_EJECT, NULL}, 151 {"eject", CAM_CMD_STARTSTOP, CAM_ARG_EJECT, NULL}, 152 {"reportluns", CAM_CMD_REPORTLUNS, CAM_ARG_NONE, "clr:"}, 153 {"readcapacity", CAM_CMD_READCAP, CAM_ARG_NONE, "bhHNqs"}, 154 #endif /* MINIMALISTIC */ 155 {"rescan", CAM_CMD_RESCAN, CAM_ARG_NONE, NULL}, 156 {"reset", CAM_CMD_RESET, CAM_ARG_NONE, NULL}, 157 #ifndef MINIMALISTIC 158 {"cmd", CAM_CMD_SCSI_CMD, CAM_ARG_NONE, scsicmd_opts}, 159 {"command", CAM_CMD_SCSI_CMD, CAM_ARG_NONE, scsicmd_opts}, 160 {"smpcmd", CAM_CMD_SMP_CMD, CAM_ARG_NONE, "r:R:"}, 161 {"smprg", CAM_CMD_SMP_RG, CAM_ARG_NONE, smprg_opts}, 162 {"smpreportgeneral", CAM_CMD_SMP_RG, CAM_ARG_NONE, smprg_opts}, 163 {"smppc", CAM_CMD_SMP_PC, CAM_ARG_NONE, smppc_opts}, 164 {"smpphycontrol", CAM_CMD_SMP_PC, CAM_ARG_NONE, smppc_opts}, 165 {"smpplist", CAM_CMD_SMP_PHYLIST, CAM_ARG_NONE, smpphylist_opts}, 166 {"smpphylist", CAM_CMD_SMP_PHYLIST, CAM_ARG_NONE, smpphylist_opts}, 167 {"smpmaninfo", CAM_CMD_SMP_MANINFO, CAM_ARG_NONE, "l"}, 168 {"defects", CAM_CMD_READ_DEFECTS, CAM_ARG_NONE, readdefect_opts}, 169 {"defectlist", CAM_CMD_READ_DEFECTS, CAM_ARG_NONE, readdefect_opts}, 170 #endif /* MINIMALISTIC */ 171 {"devlist", CAM_CMD_DEVTREE, CAM_ARG_NONE, NULL}, 172 #ifndef MINIMALISTIC 173 {"periphlist", CAM_CMD_DEVLIST, CAM_ARG_NONE, NULL}, 174 {"modepage", CAM_CMD_MODE_PAGE, CAM_ARG_NONE, "bdelm:P:"}, 175 {"tags", CAM_CMD_TAG, CAM_ARG_NONE, "N:q"}, 176 {"negotiate", CAM_CMD_RATE, CAM_ARG_NONE, negotiate_opts}, 177 {"rate", CAM_CMD_RATE, CAM_ARG_NONE, negotiate_opts}, 178 {"debug", CAM_CMD_DEBUG, CAM_ARG_NONE, "IPTSXc"}, 179 {"format", CAM_CMD_FORMAT, CAM_ARG_NONE, "qrwy"}, 180 {"idle", CAM_CMD_IDLE, CAM_ARG_NONE, "t:"}, 181 {"standby", CAM_CMD_STANDBY, CAM_ARG_NONE, "t:"}, 182 {"sleep", CAM_CMD_SLEEP, CAM_ARG_NONE, ""}, 183 #endif /* MINIMALISTIC */ 184 {"help", CAM_CMD_USAGE, CAM_ARG_NONE, NULL}, 185 {"-?", CAM_CMD_USAGE, CAM_ARG_NONE, NULL}, 186 {"-h", CAM_CMD_USAGE, CAM_ARG_NONE, NULL}, 187 {NULL, 0, 0, NULL} 188 }; 189 190 typedef enum { 191 CC_OR_NOT_FOUND, 192 CC_OR_AMBIGUOUS, 193 CC_OR_FOUND 194 } camcontrol_optret; 195 196 struct cam_devitem { 197 struct device_match_result dev_match; 198 int num_periphs; 199 struct periph_match_result *periph_matches; 200 struct scsi_vpd_device_id *device_id; 201 int device_id_len; 202 STAILQ_ENTRY(cam_devitem) links; 203 }; 204 205 struct cam_devlist { 206 STAILQ_HEAD(, cam_devitem) dev_queue; 207 path_id_t path_id; 208 }; 209 210 cam_cmdmask cmdlist; 211 cam_argmask arglist; 212 213 camcontrol_optret getoption(struct camcontrol_opts *table, char *arg, 214 uint32_t *cmdnum, cam_argmask *argnum, 215 const char **subopt); 216 #ifndef MINIMALISTIC 217 static int getdevlist(struct cam_device *device); 218 #endif /* MINIMALISTIC */ 219 static int getdevtree(void); 220 #ifndef MINIMALISTIC 221 static int testunitready(struct cam_device *device, int retry_count, 222 int timeout, int quiet); 223 static int scsistart(struct cam_device *device, int startstop, int loadeject, 224 int retry_count, int timeout); 225 static int scsidoinquiry(struct cam_device *device, int argc, char **argv, 226 char *combinedopt, int retry_count, int timeout); 227 static int scsiinquiry(struct cam_device *device, int retry_count, int timeout); 228 static int scsiserial(struct cam_device *device, int retry_count, int timeout); 229 static int camxferrate(struct cam_device *device); 230 #endif /* MINIMALISTIC */ 231 static int parse_btl(char *tstr, int *bus, int *target, int *lun, 232 cam_argmask *arglst); 233 static int dorescan_or_reset(int argc, char **argv, int rescan); 234 static int rescan_or_reset_bus(int bus, int rescan); 235 static int scanlun_or_reset_dev(int bus, int target, int lun, int scan); 236 #ifndef MINIMALISTIC 237 static int readdefects(struct cam_device *device, int argc, char **argv, 238 char *combinedopt, int retry_count, int timeout); 239 static void modepage(struct cam_device *device, int argc, char **argv, 240 char *combinedopt, int retry_count, int timeout); 241 static int scsicmd(struct cam_device *device, int argc, char **argv, 242 char *combinedopt, int retry_count, int timeout); 243 static int smpcmd(struct cam_device *device, int argc, char **argv, 244 char *combinedopt, int retry_count, int timeout); 245 static int smpreportgeneral(struct cam_device *device, int argc, char **argv, 246 char *combinedopt, int retry_count, int timeout); 247 static int smpphycontrol(struct cam_device *device, int argc, char **argv, 248 char *combinedopt, int retry_count, int timeout); 249 static int smpmaninfo(struct cam_device *device, int argc, char **argv, 250 char *combinedopt, int retry_count, int timeout); 251 static int getdevid(struct cam_devitem *item); 252 static int buildbusdevlist(struct cam_devlist *devlist); 253 static void freebusdevlist(struct cam_devlist *devlist); 254 static struct cam_devitem *findsasdevice(struct cam_devlist *devlist, 255 uint64_t sasaddr); 256 static int smpphylist(struct cam_device *device, int argc, char **argv, 257 char *combinedopt, int retry_count, int timeout); 258 static int tagcontrol(struct cam_device *device, int argc, char **argv, 259 char *combinedopt); 260 static void cts_print(struct cam_device *device, 261 struct ccb_trans_settings *cts); 262 static void cpi_print(struct ccb_pathinq *cpi); 263 static int get_cpi(struct cam_device *device, struct ccb_pathinq *cpi); 264 static int get_cgd(struct cam_device *device, struct ccb_getdev *cgd); 265 static int get_print_cts(struct cam_device *device, int user_settings, 266 int quiet, struct ccb_trans_settings *cts); 267 static int ratecontrol(struct cam_device *device, int retry_count, 268 int timeout, int argc, char **argv, char *combinedopt); 269 static int scsiformat(struct cam_device *device, int argc, char **argv, 270 char *combinedopt, int retry_count, int timeout); 271 static int scsireportluns(struct cam_device *device, int argc, char **argv, 272 char *combinedopt, int retry_count, int timeout); 273 static int scsireadcapacity(struct cam_device *device, int argc, char **argv, 274 char *combinedopt, int retry_count, int timeout); 275 static int atapm(struct cam_device *device, int argc, char **argv, 276 char *combinedopt, int retry_count, int timeout); 277 #endif /* MINIMALISTIC */ 278 #ifndef min 279 #define min(a,b) (((a)<(b))?(a):(b)) 280 #endif 281 #ifndef max 282 #define max(a,b) (((a)>(b))?(a):(b)) 283 #endif 284 285 camcontrol_optret 286 getoption(struct camcontrol_opts *table, char *arg, uint32_t *cmdnum, 287 cam_argmask *argnum, const char **subopt) 288 { 289 struct camcontrol_opts *opts; 290 int num_matches = 0; 291 292 for (opts = table; (opts != NULL) && (opts->optname != NULL); 293 opts++) { 294 if (strncmp(opts->optname, arg, strlen(arg)) == 0) { 295 *cmdnum = opts->cmdnum; 296 *argnum = opts->argnum; 297 *subopt = opts->subopt; 298 if (++num_matches > 1) 299 return(CC_OR_AMBIGUOUS); 300 } 301 } 302 303 if (num_matches > 0) 304 return(CC_OR_FOUND); 305 else 306 return(CC_OR_NOT_FOUND); 307 } 308 309 #ifndef MINIMALISTIC 310 static int 311 getdevlist(struct cam_device *device) 312 { 313 union ccb *ccb; 314 char status[32]; 315 int error = 0; 316 317 ccb = cam_getccb(device); 318 319 ccb->ccb_h.func_code = XPT_GDEVLIST; 320 ccb->ccb_h.flags = CAM_DIR_NONE; 321 ccb->ccb_h.retry_count = 1; 322 ccb->cgdl.index = 0; 323 ccb->cgdl.status = CAM_GDEVLIST_MORE_DEVS; 324 while (ccb->cgdl.status == CAM_GDEVLIST_MORE_DEVS) { 325 if (cam_send_ccb(device, ccb) < 0) { 326 perror("error getting device list"); 327 cam_freeccb(ccb); 328 return(1); 329 } 330 331 status[0] = '\0'; 332 333 switch (ccb->cgdl.status) { 334 case CAM_GDEVLIST_MORE_DEVS: 335 strcpy(status, "MORE"); 336 break; 337 case CAM_GDEVLIST_LAST_DEVICE: 338 strcpy(status, "LAST"); 339 break; 340 case CAM_GDEVLIST_LIST_CHANGED: 341 strcpy(status, "CHANGED"); 342 break; 343 case CAM_GDEVLIST_ERROR: 344 strcpy(status, "ERROR"); 345 error = 1; 346 break; 347 } 348 349 fprintf(stdout, "%s%d: generation: %d index: %d status: %s\n", 350 ccb->cgdl.periph_name, 351 ccb->cgdl.unit_number, 352 ccb->cgdl.generation, 353 ccb->cgdl.index, 354 status); 355 356 /* 357 * If the list has changed, we need to start over from the 358 * beginning. 359 */ 360 if (ccb->cgdl.status == CAM_GDEVLIST_LIST_CHANGED) 361 ccb->cgdl.index = 0; 362 } 363 364 cam_freeccb(ccb); 365 366 return(error); 367 } 368 #endif /* MINIMALISTIC */ 369 370 static int 371 getdevtree(void) 372 { 373 union ccb ccb; 374 int bufsize, fd; 375 unsigned int i; 376 int need_close = 0; 377 int error = 0; 378 int skip_device = 0; 379 380 if ((fd = open(XPT_DEVICE, O_RDWR)) == -1) { 381 warn("couldn't open %s", XPT_DEVICE); 382 return(1); 383 } 384 385 bzero(&ccb, sizeof(union ccb)); 386 387 ccb.ccb_h.path_id = CAM_XPT_PATH_ID; 388 ccb.ccb_h.target_id = CAM_TARGET_WILDCARD; 389 ccb.ccb_h.target_lun = CAM_LUN_WILDCARD; 390 391 ccb.ccb_h.func_code = XPT_DEV_MATCH; 392 bufsize = sizeof(struct dev_match_result) * 100; 393 ccb.cdm.match_buf_len = bufsize; 394 ccb.cdm.matches = (struct dev_match_result *)malloc(bufsize); 395 if (ccb.cdm.matches == NULL) { 396 warnx("can't malloc memory for matches"); 397 close(fd); 398 return(1); 399 } 400 ccb.cdm.num_matches = 0; 401 402 /* 403 * We fetch all nodes, since we display most of them in the default 404 * case, and all in the verbose case. 405 */ 406 ccb.cdm.num_patterns = 0; 407 ccb.cdm.pattern_buf_len = 0; 408 409 /* 410 * We do the ioctl multiple times if necessary, in case there are 411 * more than 100 nodes in the EDT. 412 */ 413 do { 414 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) { 415 warn("error sending CAMIOCOMMAND ioctl"); 416 error = 1; 417 break; 418 } 419 420 if ((ccb.ccb_h.status != CAM_REQ_CMP) 421 || ((ccb.cdm.status != CAM_DEV_MATCH_LAST) 422 && (ccb.cdm.status != CAM_DEV_MATCH_MORE))) { 423 warnx("got CAM error %#x, CDM error %d\n", 424 ccb.ccb_h.status, ccb.cdm.status); 425 error = 1; 426 break; 427 } 428 429 for (i = 0; i < ccb.cdm.num_matches; i++) { 430 switch (ccb.cdm.matches[i].type) { 431 case DEV_MATCH_BUS: { 432 struct bus_match_result *bus_result; 433 434 /* 435 * Only print the bus information if the 436 * user turns on the verbose flag. 437 */ 438 if ((arglist & CAM_ARG_VERBOSE) == 0) 439 break; 440 441 bus_result = 442 &ccb.cdm.matches[i].result.bus_result; 443 444 if (need_close) { 445 fprintf(stdout, ")\n"); 446 need_close = 0; 447 } 448 449 fprintf(stdout, "scbus%d on %s%d bus %d:\n", 450 bus_result->path_id, 451 bus_result->dev_name, 452 bus_result->unit_number, 453 bus_result->bus_id); 454 break; 455 } 456 case DEV_MATCH_DEVICE: { 457 struct device_match_result *dev_result; 458 char vendor[16], product[48], revision[16]; 459 char tmpstr[256]; 460 461 dev_result = 462 &ccb.cdm.matches[i].result.device_result; 463 464 if ((dev_result->flags 465 & DEV_RESULT_UNCONFIGURED) 466 && ((arglist & CAM_ARG_VERBOSE) == 0)) { 467 skip_device = 1; 468 break; 469 } else 470 skip_device = 0; 471 472 if (dev_result->protocol == PROTO_SCSI) { 473 cam_strvis(vendor, dev_result->inq_data.vendor, 474 sizeof(dev_result->inq_data.vendor), 475 sizeof(vendor)); 476 cam_strvis(product, 477 dev_result->inq_data.product, 478 sizeof(dev_result->inq_data.product), 479 sizeof(product)); 480 cam_strvis(revision, 481 dev_result->inq_data.revision, 482 sizeof(dev_result->inq_data.revision), 483 sizeof(revision)); 484 sprintf(tmpstr, "<%s %s %s>", vendor, product, 485 revision); 486 } else if (dev_result->protocol == PROTO_ATA || 487 dev_result->protocol == PROTO_SATAPM) { 488 cam_strvis(product, 489 dev_result->ident_data.model, 490 sizeof(dev_result->ident_data.model), 491 sizeof(product)); 492 cam_strvis(revision, 493 dev_result->ident_data.revision, 494 sizeof(dev_result->ident_data.revision), 495 sizeof(revision)); 496 sprintf(tmpstr, "<%s %s>", product, 497 revision); 498 } else { 499 sprintf(tmpstr, "<>"); 500 } 501 if (need_close) { 502 fprintf(stdout, ")\n"); 503 need_close = 0; 504 } 505 506 fprintf(stdout, "%-33s at scbus%d " 507 "target %d lun %d (", 508 tmpstr, 509 dev_result->path_id, 510 dev_result->target_id, 511 dev_result->target_lun); 512 513 need_close = 1; 514 515 break; 516 } 517 case DEV_MATCH_PERIPH: { 518 struct periph_match_result *periph_result; 519 520 periph_result = 521 &ccb.cdm.matches[i].result.periph_result; 522 523 if (skip_device != 0) 524 break; 525 526 if (need_close > 1) 527 fprintf(stdout, ","); 528 529 fprintf(stdout, "%s%d", 530 periph_result->periph_name, 531 periph_result->unit_number); 532 533 need_close++; 534 break; 535 } 536 default: 537 fprintf(stdout, "unknown match type\n"); 538 break; 539 } 540 } 541 542 } while ((ccb.ccb_h.status == CAM_REQ_CMP) 543 && (ccb.cdm.status == CAM_DEV_MATCH_MORE)); 544 545 if (need_close) 546 fprintf(stdout, ")\n"); 547 548 close(fd); 549 550 return(error); 551 } 552 553 #ifndef MINIMALISTIC 554 static int 555 testunitready(struct cam_device *device, int retry_count, int timeout, 556 int quiet) 557 { 558 int error = 0; 559 union ccb *ccb; 560 561 ccb = cam_getccb(device); 562 563 scsi_test_unit_ready(&ccb->csio, 564 /* retries */ retry_count, 565 /* cbfcnp */ NULL, 566 /* tag_action */ MSG_SIMPLE_Q_TAG, 567 /* sense_len */ SSD_FULL_SIZE, 568 /* timeout */ timeout ? timeout : 5000); 569 570 /* Disable freezing the device queue */ 571 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 572 573 if (arglist & CAM_ARG_ERR_RECOVER) 574 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER; 575 576 if (cam_send_ccb(device, ccb) < 0) { 577 if (quiet == 0) 578 perror("error sending test unit ready"); 579 580 if (arglist & CAM_ARG_VERBOSE) { 581 cam_error_print(device, ccb, CAM_ESF_ALL, 582 CAM_EPF_ALL, stderr); 583 } 584 585 cam_freeccb(ccb); 586 return(1); 587 } 588 589 if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) { 590 if (quiet == 0) 591 fprintf(stdout, "Unit is ready\n"); 592 } else { 593 if (quiet == 0) 594 fprintf(stdout, "Unit is not ready\n"); 595 error = 1; 596 597 if (arglist & CAM_ARG_VERBOSE) { 598 cam_error_print(device, ccb, CAM_ESF_ALL, 599 CAM_EPF_ALL, stderr); 600 } 601 } 602 603 cam_freeccb(ccb); 604 605 return(error); 606 } 607 608 static int 609 scsistart(struct cam_device *device, int startstop, int loadeject, 610 int retry_count, int timeout) 611 { 612 union ccb *ccb; 613 int error = 0; 614 615 ccb = cam_getccb(device); 616 617 /* 618 * If we're stopping, send an ordered tag so the drive in question 619 * will finish any previously queued writes before stopping. If 620 * the device isn't capable of tagged queueing, or if tagged 621 * queueing is turned off, the tag action is a no-op. 622 */ 623 scsi_start_stop(&ccb->csio, 624 /* retries */ retry_count, 625 /* cbfcnp */ NULL, 626 /* tag_action */ startstop ? MSG_SIMPLE_Q_TAG : 627 MSG_ORDERED_Q_TAG, 628 /* start/stop */ startstop, 629 /* load_eject */ loadeject, 630 /* immediate */ 0, 631 /* sense_len */ SSD_FULL_SIZE, 632 /* timeout */ timeout ? timeout : 120000); 633 634 /* Disable freezing the device queue */ 635 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 636 637 if (arglist & CAM_ARG_ERR_RECOVER) 638 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER; 639 640 if (cam_send_ccb(device, ccb) < 0) { 641 perror("error sending start unit"); 642 643 if (arglist & CAM_ARG_VERBOSE) { 644 cam_error_print(device, ccb, CAM_ESF_ALL, 645 CAM_EPF_ALL, stderr); 646 } 647 648 cam_freeccb(ccb); 649 return(1); 650 } 651 652 if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) 653 if (startstop) { 654 fprintf(stdout, "Unit started successfully"); 655 if (loadeject) 656 fprintf(stdout,", Media loaded\n"); 657 else 658 fprintf(stdout,"\n"); 659 } else { 660 fprintf(stdout, "Unit stopped successfully"); 661 if (loadeject) 662 fprintf(stdout, ", Media ejected\n"); 663 else 664 fprintf(stdout, "\n"); 665 } 666 else { 667 error = 1; 668 if (startstop) 669 fprintf(stdout, 670 "Error received from start unit command\n"); 671 else 672 fprintf(stdout, 673 "Error received from stop unit command\n"); 674 675 if (arglist & CAM_ARG_VERBOSE) { 676 cam_error_print(device, ccb, CAM_ESF_ALL, 677 CAM_EPF_ALL, stderr); 678 } 679 } 680 681 cam_freeccb(ccb); 682 683 return(error); 684 } 685 686 static int 687 scsidoinquiry(struct cam_device *device, int argc, char **argv, 688 char *combinedopt, int retry_count, int timeout) 689 { 690 int c; 691 int error = 0; 692 693 while ((c = getopt(argc, argv, combinedopt)) != -1) { 694 switch(c) { 695 case 'D': 696 arglist |= CAM_ARG_GET_STDINQ; 697 break; 698 case 'R': 699 arglist |= CAM_ARG_GET_XFERRATE; 700 break; 701 case 'S': 702 arglist |= CAM_ARG_GET_SERIAL; 703 break; 704 default: 705 break; 706 } 707 } 708 709 /* 710 * If the user didn't specify any inquiry options, he wants all of 711 * them. 712 */ 713 if ((arglist & CAM_ARG_INQ_MASK) == 0) 714 arglist |= CAM_ARG_INQ_MASK; 715 716 if (arglist & CAM_ARG_GET_STDINQ) 717 error = scsiinquiry(device, retry_count, timeout); 718 719 if (error != 0) 720 return(error); 721 722 if (arglist & CAM_ARG_GET_SERIAL) 723 scsiserial(device, retry_count, timeout); 724 725 if (error != 0) 726 return(error); 727 728 if (arglist & CAM_ARG_GET_XFERRATE) 729 error = camxferrate(device); 730 731 return(error); 732 } 733 734 static int 735 scsiinquiry(struct cam_device *device, int retry_count, int timeout) 736 { 737 union ccb *ccb; 738 struct scsi_inquiry_data *inq_buf; 739 int error = 0; 740 741 ccb = cam_getccb(device); 742 743 if (ccb == NULL) { 744 warnx("couldn't allocate CCB"); 745 return(1); 746 } 747 748 /* cam_getccb cleans up the header, caller has to zero the payload */ 749 bzero(&(&ccb->ccb_h)[1], 750 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr)); 751 752 inq_buf = (struct scsi_inquiry_data *)malloc( 753 sizeof(struct scsi_inquiry_data)); 754 755 if (inq_buf == NULL) { 756 cam_freeccb(ccb); 757 warnx("can't malloc memory for inquiry\n"); 758 return(1); 759 } 760 bzero(inq_buf, sizeof(*inq_buf)); 761 762 /* 763 * Note that although the size of the inquiry buffer is the full 764 * 256 bytes specified in the SCSI spec, we only tell the device 765 * that we have allocated SHORT_INQUIRY_LENGTH bytes. There are 766 * two reasons for this: 767 * 768 * - The SCSI spec says that when a length field is only 1 byte, 769 * a value of 0 will be interpreted as 256. Therefore 770 * scsi_inquiry() will convert an inq_len (which is passed in as 771 * a u_int32_t, but the field in the CDB is only 1 byte) of 256 772 * to 0. Evidently, very few devices meet the spec in that 773 * regard. Some devices, like many Seagate disks, take the 0 as 774 * 0, and don't return any data. One Pioneer DVD-R drive 775 * returns more data than the command asked for. 776 * 777 * So, since there are numerous devices that just don't work 778 * right with the full inquiry size, we don't send the full size. 779 * 780 * - The second reason not to use the full inquiry data length is 781 * that we don't need it here. The only reason we issue a 782 * standard inquiry is to get the vendor name, device name, 783 * and revision so scsi_print_inquiry() can print them. 784 * 785 * If, at some point in the future, more inquiry data is needed for 786 * some reason, this code should use a procedure similar to the 787 * probe code. i.e., issue a short inquiry, and determine from 788 * the additional length passed back from the device how much 789 * inquiry data the device supports. Once the amount the device 790 * supports is determined, issue an inquiry for that amount and no 791 * more. 792 * 793 * KDM, 2/18/2000 794 */ 795 scsi_inquiry(&ccb->csio, 796 /* retries */ retry_count, 797 /* cbfcnp */ NULL, 798 /* tag_action */ MSG_SIMPLE_Q_TAG, 799 /* inq_buf */ (u_int8_t *)inq_buf, 800 /* inq_len */ SHORT_INQUIRY_LENGTH, 801 /* evpd */ 0, 802 /* page_code */ 0, 803 /* sense_len */ SSD_FULL_SIZE, 804 /* timeout */ timeout ? timeout : 5000); 805 806 /* Disable freezing the device queue */ 807 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 808 809 if (arglist & CAM_ARG_ERR_RECOVER) 810 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER; 811 812 if (cam_send_ccb(device, ccb) < 0) { 813 perror("error sending SCSI inquiry"); 814 815 if (arglist & CAM_ARG_VERBOSE) { 816 cam_error_print(device, ccb, CAM_ESF_ALL, 817 CAM_EPF_ALL, stderr); 818 } 819 820 cam_freeccb(ccb); 821 return(1); 822 } 823 824 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 825 error = 1; 826 827 if (arglist & CAM_ARG_VERBOSE) { 828 cam_error_print(device, ccb, CAM_ESF_ALL, 829 CAM_EPF_ALL, stderr); 830 } 831 } 832 833 cam_freeccb(ccb); 834 835 if (error != 0) { 836 free(inq_buf); 837 return(error); 838 } 839 840 fprintf(stdout, "%s%d: ", device->device_name, 841 device->dev_unit_num); 842 scsi_print_inquiry(inq_buf); 843 844 free(inq_buf); 845 846 return(0); 847 } 848 849 static int 850 scsiserial(struct cam_device *device, int retry_count, int timeout) 851 { 852 union ccb *ccb; 853 struct scsi_vpd_unit_serial_number *serial_buf; 854 char serial_num[SVPD_SERIAL_NUM_SIZE + 1]; 855 int error = 0; 856 857 ccb = cam_getccb(device); 858 859 if (ccb == NULL) { 860 warnx("couldn't allocate CCB"); 861 return(1); 862 } 863 864 /* cam_getccb cleans up the header, caller has to zero the payload */ 865 bzero(&(&ccb->ccb_h)[1], 866 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr)); 867 868 serial_buf = (struct scsi_vpd_unit_serial_number *) 869 malloc(sizeof(*serial_buf)); 870 871 if (serial_buf == NULL) { 872 cam_freeccb(ccb); 873 warnx("can't malloc memory for serial number"); 874 return(1); 875 } 876 877 scsi_inquiry(&ccb->csio, 878 /*retries*/ retry_count, 879 /*cbfcnp*/ NULL, 880 /* tag_action */ MSG_SIMPLE_Q_TAG, 881 /* inq_buf */ (u_int8_t *)serial_buf, 882 /* inq_len */ sizeof(*serial_buf), 883 /* evpd */ 1, 884 /* page_code */ SVPD_UNIT_SERIAL_NUMBER, 885 /* sense_len */ SSD_FULL_SIZE, 886 /* timeout */ timeout ? timeout : 5000); 887 888 /* Disable freezing the device queue */ 889 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 890 891 if (arglist & CAM_ARG_ERR_RECOVER) 892 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER; 893 894 if (cam_send_ccb(device, ccb) < 0) { 895 warn("error getting serial number"); 896 897 if (arglist & CAM_ARG_VERBOSE) { 898 cam_error_print(device, ccb, CAM_ESF_ALL, 899 CAM_EPF_ALL, stderr); 900 } 901 902 cam_freeccb(ccb); 903 free(serial_buf); 904 return(1); 905 } 906 907 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 908 error = 1; 909 910 if (arglist & CAM_ARG_VERBOSE) { 911 cam_error_print(device, ccb, CAM_ESF_ALL, 912 CAM_EPF_ALL, stderr); 913 } 914 } 915 916 cam_freeccb(ccb); 917 918 if (error != 0) { 919 free(serial_buf); 920 return(error); 921 } 922 923 bcopy(serial_buf->serial_num, serial_num, serial_buf->length); 924 serial_num[serial_buf->length] = '\0'; 925 926 if ((arglist & CAM_ARG_GET_STDINQ) 927 || (arglist & CAM_ARG_GET_XFERRATE)) 928 fprintf(stdout, "%s%d: Serial Number ", 929 device->device_name, device->dev_unit_num); 930 931 fprintf(stdout, "%.60s\n", serial_num); 932 933 free(serial_buf); 934 935 return(0); 936 } 937 938 static int 939 camxferrate(struct cam_device *device) 940 { 941 struct ccb_pathinq cpi; 942 u_int32_t freq = 0; 943 u_int32_t speed = 0; 944 union ccb *ccb; 945 u_int mb; 946 int retval = 0; 947 948 if ((retval = get_cpi(device, &cpi)) != 0) 949 return (1); 950 951 ccb = cam_getccb(device); 952 953 if (ccb == NULL) { 954 warnx("couldn't allocate CCB"); 955 return(1); 956 } 957 958 bzero(&(&ccb->ccb_h)[1], 959 sizeof(struct ccb_trans_settings) - sizeof(struct ccb_hdr)); 960 961 ccb->ccb_h.func_code = XPT_GET_TRAN_SETTINGS; 962 ccb->cts.type = CTS_TYPE_CURRENT_SETTINGS; 963 964 if (((retval = cam_send_ccb(device, ccb)) < 0) 965 || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) { 966 const char error_string[] = "error getting transfer settings"; 967 968 if (retval < 0) 969 warn(error_string); 970 else 971 warnx(error_string); 972 973 if (arglist & CAM_ARG_VERBOSE) 974 cam_error_print(device, ccb, CAM_ESF_ALL, 975 CAM_EPF_ALL, stderr); 976 977 retval = 1; 978 979 goto xferrate_bailout; 980 981 } 982 983 speed = cpi.base_transfer_speed; 984 freq = 0; 985 if (ccb->cts.transport == XPORT_SPI) { 986 struct ccb_trans_settings_spi *spi = 987 &ccb->cts.xport_specific.spi; 988 989 if ((spi->valid & CTS_SPI_VALID_SYNC_RATE) != 0) { 990 freq = scsi_calc_syncsrate(spi->sync_period); 991 speed = freq; 992 } 993 if ((spi->valid & CTS_SPI_VALID_BUS_WIDTH) != 0) { 994 speed *= (0x01 << spi->bus_width); 995 } 996 } else if (ccb->cts.transport == XPORT_FC) { 997 struct ccb_trans_settings_fc *fc = 998 &ccb->cts.xport_specific.fc; 999 1000 if (fc->valid & CTS_FC_VALID_SPEED) 1001 speed = fc->bitrate; 1002 } else if (ccb->cts.transport == XPORT_SAS) { 1003 struct ccb_trans_settings_sas *sas = 1004 &ccb->cts.xport_specific.sas; 1005 1006 if (sas->valid & CTS_SAS_VALID_SPEED) 1007 speed = sas->bitrate; 1008 } else if (ccb->cts.transport == XPORT_ATA) { 1009 struct ccb_trans_settings_ata *ata = 1010 &ccb->cts.xport_specific.ata; 1011 1012 if (ata->valid & CTS_ATA_VALID_MODE) 1013 speed = ata_mode2speed(ata->mode); 1014 } else if (ccb->cts.transport == XPORT_SATA) { 1015 struct ccb_trans_settings_sata *sata = 1016 &ccb->cts.xport_specific.sata; 1017 1018 if (sata->valid & CTS_SATA_VALID_REVISION) 1019 speed = ata_revision2speed(sata->revision); 1020 } 1021 1022 mb = speed / 1000; 1023 if (mb > 0) { 1024 fprintf(stdout, "%s%d: %d.%03dMB/s transfers", 1025 device->device_name, device->dev_unit_num, 1026 mb, speed % 1000); 1027 } else { 1028 fprintf(stdout, "%s%d: %dKB/s transfers", 1029 device->device_name, device->dev_unit_num, 1030 speed); 1031 } 1032 1033 if (ccb->cts.transport == XPORT_SPI) { 1034 struct ccb_trans_settings_spi *spi = 1035 &ccb->cts.xport_specific.spi; 1036 1037 if (((spi->valid & CTS_SPI_VALID_SYNC_OFFSET) != 0) 1038 && (spi->sync_offset != 0)) 1039 fprintf(stdout, " (%d.%03dMHz, offset %d", freq / 1000, 1040 freq % 1000, spi->sync_offset); 1041 1042 if (((spi->valid & CTS_SPI_VALID_BUS_WIDTH) != 0) 1043 && (spi->bus_width > 0)) { 1044 if (((spi->valid & CTS_SPI_VALID_SYNC_OFFSET) != 0) 1045 && (spi->sync_offset != 0)) { 1046 fprintf(stdout, ", "); 1047 } else { 1048 fprintf(stdout, " ("); 1049 } 1050 fprintf(stdout, "%dbit)", 8 * (0x01 << spi->bus_width)); 1051 } else if (((spi->valid & CTS_SPI_VALID_SYNC_OFFSET) != 0) 1052 && (spi->sync_offset != 0)) { 1053 fprintf(stdout, ")"); 1054 } 1055 } else if (ccb->cts.transport == XPORT_ATA) { 1056 struct ccb_trans_settings_ata *ata = 1057 &ccb->cts.xport_specific.ata; 1058 1059 printf(" ("); 1060 if (ata->valid & CTS_ATA_VALID_MODE) 1061 printf("%s, ", ata_mode2string(ata->mode)); 1062 if ((ata->valid & CTS_ATA_VALID_ATAPI) && ata->atapi != 0) 1063 printf("ATAPI %dbytes, ", ata->atapi); 1064 if (ata->valid & CTS_ATA_VALID_BYTECOUNT) 1065 printf("PIO %dbytes", ata->bytecount); 1066 printf(")"); 1067 } else if (ccb->cts.transport == XPORT_SATA) { 1068 struct ccb_trans_settings_sata *sata = 1069 &ccb->cts.xport_specific.sata; 1070 1071 printf(" ("); 1072 if (sata->valid & CTS_SATA_VALID_REVISION) 1073 printf("SATA %d.x, ", sata->revision); 1074 else 1075 printf("SATA, "); 1076 if (sata->valid & CTS_SATA_VALID_MODE) 1077 printf("%s, ", ata_mode2string(sata->mode)); 1078 if ((sata->valid & CTS_SATA_VALID_ATAPI) && sata->atapi != 0) 1079 printf("ATAPI %dbytes, ", sata->atapi); 1080 if (sata->valid & CTS_SATA_VALID_BYTECOUNT) 1081 printf("PIO %dbytes", sata->bytecount); 1082 printf(")"); 1083 } 1084 1085 if (ccb->cts.protocol == PROTO_SCSI) { 1086 struct ccb_trans_settings_scsi *scsi = 1087 &ccb->cts.proto_specific.scsi; 1088 if (scsi->valid & CTS_SCSI_VALID_TQ) { 1089 if (scsi->flags & CTS_SCSI_FLAGS_TAG_ENB) { 1090 fprintf(stdout, ", Command Queueing Enabled"); 1091 } 1092 } 1093 } 1094 1095 fprintf(stdout, "\n"); 1096 1097 xferrate_bailout: 1098 1099 cam_freeccb(ccb); 1100 1101 return(retval); 1102 } 1103 1104 static void 1105 atacapprint(struct ata_params *parm) 1106 { 1107 u_int32_t lbasize = (u_int32_t)parm->lba_size_1 | 1108 ((u_int32_t)parm->lba_size_2 << 16); 1109 1110 u_int64_t lbasize48 = ((u_int64_t)parm->lba_size48_1) | 1111 ((u_int64_t)parm->lba_size48_2 << 16) | 1112 ((u_int64_t)parm->lba_size48_3 << 32) | 1113 ((u_int64_t)parm->lba_size48_4 << 48); 1114 1115 printf("\n"); 1116 printf("protocol "); 1117 printf("ATA/ATAPI-%d", ata_version(parm->version_major)); 1118 if (parm->satacapabilities && parm->satacapabilities != 0xffff) { 1119 if (parm->satacapabilities & ATA_SATA_GEN3) 1120 printf(" SATA 3.x\n"); 1121 else if (parm->satacapabilities & ATA_SATA_GEN2) 1122 printf(" SATA 2.x\n"); 1123 else if (parm->satacapabilities & ATA_SATA_GEN1) 1124 printf(" SATA 1.x\n"); 1125 else 1126 printf(" SATA\n"); 1127 } 1128 else 1129 printf("\n"); 1130 printf("device model %.40s\n", parm->model); 1131 printf("firmware revision %.8s\n", parm->revision); 1132 printf("serial number %.20s\n", parm->serial); 1133 if (parm->enabled.extension & ATA_SUPPORT_64BITWWN) { 1134 printf("WWN %02x%02x%02x%02x\n", 1135 parm->wwn[0], parm->wwn[1], parm->wwn[2], parm->wwn[3]); 1136 } 1137 if (parm->enabled.extension & ATA_SUPPORT_MEDIASN) { 1138 printf("media serial number %.30s\n", 1139 parm->media_serial); 1140 } 1141 1142 printf("cylinders %d\n", parm->cylinders); 1143 printf("heads %d\n", parm->heads); 1144 printf("sectors/track %d\n", parm->sectors); 1145 printf("sector size logical %u, physical %lu, offset %lu\n", 1146 ata_logical_sector_size(parm), 1147 (unsigned long)ata_physical_sector_size(parm), 1148 (unsigned long)ata_logical_sector_offset(parm)); 1149 1150 if (parm->config == ATA_PROTO_CFA || 1151 (parm->support.command2 & ATA_SUPPORT_CFA)) 1152 printf("CFA supported\n"); 1153 1154 printf("LBA%ssupported ", 1155 parm->capabilities1 & ATA_SUPPORT_LBA ? " " : " not "); 1156 if (lbasize) 1157 printf("%d sectors\n", lbasize); 1158 else 1159 printf("\n"); 1160 1161 printf("LBA48%ssupported ", 1162 parm->support.command2 & ATA_SUPPORT_ADDRESS48 ? " " : " not "); 1163 if (lbasize48) 1164 printf("%ju sectors\n", (uintmax_t)lbasize48); 1165 else 1166 printf("\n"); 1167 1168 printf("PIO supported PIO"); 1169 switch (ata_max_pmode(parm)) { 1170 case ATA_PIO4: 1171 printf("4"); 1172 break; 1173 case ATA_PIO3: 1174 printf("3"); 1175 break; 1176 case ATA_PIO2: 1177 printf("2"); 1178 break; 1179 case ATA_PIO1: 1180 printf("1"); 1181 break; 1182 default: 1183 printf("0"); 1184 } 1185 if ((parm->capabilities1 & ATA_SUPPORT_IORDY) == 0) 1186 printf(" w/o IORDY"); 1187 printf("\n"); 1188 1189 printf("DMA%ssupported ", 1190 parm->capabilities1 & ATA_SUPPORT_DMA ? " " : " not "); 1191 if (parm->capabilities1 & ATA_SUPPORT_DMA) { 1192 if (parm->mwdmamodes & 0xff) { 1193 printf("WDMA"); 1194 if (parm->mwdmamodes & 0x04) 1195 printf("2"); 1196 else if (parm->mwdmamodes & 0x02) 1197 printf("1"); 1198 else if (parm->mwdmamodes & 0x01) 1199 printf("0"); 1200 printf(" "); 1201 } 1202 if ((parm->atavalid & ATA_FLAG_88) && 1203 (parm->udmamodes & 0xff)) { 1204 printf("UDMA"); 1205 if (parm->udmamodes & 0x40) 1206 printf("6"); 1207 else if (parm->udmamodes & 0x20) 1208 printf("5"); 1209 else if (parm->udmamodes & 0x10) 1210 printf("4"); 1211 else if (parm->udmamodes & 0x08) 1212 printf("3"); 1213 else if (parm->udmamodes & 0x04) 1214 printf("2"); 1215 else if (parm->udmamodes & 0x02) 1216 printf("1"); 1217 else if (parm->udmamodes & 0x01) 1218 printf("0"); 1219 printf(" "); 1220 } 1221 } 1222 printf("\n"); 1223 1224 if (parm->media_rotation_rate == 1) { 1225 printf("media RPM non-rotating\n"); 1226 } else if (parm->media_rotation_rate >= 0x0401 && 1227 parm->media_rotation_rate <= 0xFFFE) { 1228 printf("media RPM %d\n", 1229 parm->media_rotation_rate); 1230 } 1231 1232 printf("\nFeature " 1233 "Support Enabled Value Vendor\n"); 1234 printf("read ahead %s %s\n", 1235 parm->support.command1 & ATA_SUPPORT_LOOKAHEAD ? "yes" : "no", 1236 parm->enabled.command1 & ATA_SUPPORT_LOOKAHEAD ? "yes" : "no"); 1237 printf("write cache %s %s\n", 1238 parm->support.command1 & ATA_SUPPORT_WRITECACHE ? "yes" : "no", 1239 parm->enabled.command1 & ATA_SUPPORT_WRITECACHE ? "yes" : "no"); 1240 printf("flush cache %s %s\n", 1241 parm->support.command2 & ATA_SUPPORT_FLUSHCACHE ? "yes" : "no", 1242 parm->enabled.command2 & ATA_SUPPORT_FLUSHCACHE ? "yes" : "no"); 1243 printf("overlap %s\n", 1244 parm->capabilities1 & ATA_SUPPORT_OVERLAP ? "yes" : "no"); 1245 printf("Tagged Command Queuing (TCQ) %s %s", 1246 parm->support.command2 & ATA_SUPPORT_QUEUED ? "yes" : "no", 1247 parm->enabled.command2 & ATA_SUPPORT_QUEUED ? "yes" : "no"); 1248 if (parm->support.command2 & ATA_SUPPORT_QUEUED) { 1249 printf(" %d tags\n", 1250 ATA_QUEUE_LEN(parm->queue) + 1); 1251 } else 1252 printf("\n"); 1253 printf("Native Command Queuing (NCQ) "); 1254 if (parm->satacapabilities != 0xffff && 1255 (parm->satacapabilities & ATA_SUPPORT_NCQ)) { 1256 printf("yes %d tags\n", 1257 ATA_QUEUE_LEN(parm->queue) + 1); 1258 } else 1259 printf("no\n"); 1260 printf("SMART %s %s\n", 1261 parm->support.command1 & ATA_SUPPORT_SMART ? "yes" : "no", 1262 parm->enabled.command1 & ATA_SUPPORT_SMART ? "yes" : "no"); 1263 printf("microcode download %s %s\n", 1264 parm->support.command2 & ATA_SUPPORT_MICROCODE ? "yes" : "no", 1265 parm->enabled.command2 & ATA_SUPPORT_MICROCODE ? "yes" : "no"); 1266 printf("security %s %s\n", 1267 parm->support.command1 & ATA_SUPPORT_SECURITY ? "yes" : "no", 1268 parm->enabled.command1 & ATA_SUPPORT_SECURITY ? "yes" : "no"); 1269 printf("power management %s %s\n", 1270 parm->support.command1 & ATA_SUPPORT_POWERMGT ? "yes" : "no", 1271 parm->enabled.command1 & ATA_SUPPORT_POWERMGT ? "yes" : "no"); 1272 printf("advanced power management %s %s", 1273 parm->support.command2 & ATA_SUPPORT_APM ? "yes" : "no", 1274 parm->enabled.command2 & ATA_SUPPORT_APM ? "yes" : "no"); 1275 if (parm->support.command2 & ATA_SUPPORT_APM) { 1276 printf(" %d/0x%02X\n", 1277 parm->apm_value, parm->apm_value); 1278 } else 1279 printf("\n"); 1280 printf("automatic acoustic management %s %s", 1281 parm->support.command2 & ATA_SUPPORT_AUTOACOUSTIC ? "yes" :"no", 1282 parm->enabled.command2 & ATA_SUPPORT_AUTOACOUSTIC ? "yes" :"no"); 1283 if (parm->support.command2 & ATA_SUPPORT_AUTOACOUSTIC) { 1284 printf(" %d/0x%02X %d/0x%02X\n", 1285 ATA_ACOUSTIC_CURRENT(parm->acoustic), 1286 ATA_ACOUSTIC_CURRENT(parm->acoustic), 1287 ATA_ACOUSTIC_VENDOR(parm->acoustic), 1288 ATA_ACOUSTIC_VENDOR(parm->acoustic)); 1289 } else 1290 printf("\n"); 1291 printf("media status notification %s %s\n", 1292 parm->support.command2 & ATA_SUPPORT_NOTIFY ? "yes" : "no", 1293 parm->enabled.command2 & ATA_SUPPORT_NOTIFY ? "yes" : "no"); 1294 printf("power-up in Standby %s %s\n", 1295 parm->support.command2 & ATA_SUPPORT_STANDBY ? "yes" : "no", 1296 parm->enabled.command2 & ATA_SUPPORT_STANDBY ? "yes" : "no"); 1297 printf("write-read-verify %s %s", 1298 parm->support2 & ATA_SUPPORT_WRITEREADVERIFY ? "yes" : "no", 1299 parm->enabled2 & ATA_SUPPORT_WRITEREADVERIFY ? "yes" : "no"); 1300 if (parm->support2 & ATA_SUPPORT_WRITEREADVERIFY) { 1301 printf(" %d/0x%x\n", 1302 parm->wrv_mode, parm->wrv_mode); 1303 } else 1304 printf("\n"); 1305 printf("unload %s %s\n", 1306 parm->support.extension & ATA_SUPPORT_UNLOAD ? "yes" : "no", 1307 parm->enabled.extension & ATA_SUPPORT_UNLOAD ? "yes" : "no"); 1308 printf("free-fall %s %s\n", 1309 parm->support2 & ATA_SUPPORT_FREEFALL ? "yes" : "no", 1310 parm->enabled2 & ATA_SUPPORT_FREEFALL ? "yes" : "no"); 1311 printf("data set management (TRIM) %s\n", 1312 parm->support_dsm & ATA_SUPPORT_DSM_TRIM ? "yes" : "no"); 1313 } 1314 1315 static int 1316 ataidentify(struct cam_device *device, int retry_count, int timeout) 1317 { 1318 union ccb *ccb; 1319 struct ata_params *ident_buf; 1320 struct ccb_getdev cgd; 1321 u_int i, error = 0; 1322 int16_t *ptr; 1323 1324 if (get_cgd(device, &cgd) != 0) { 1325 warnx("couldn't get CGD"); 1326 return(1); 1327 } 1328 ccb = cam_getccb(device); 1329 1330 if (ccb == NULL) { 1331 warnx("couldn't allocate CCB"); 1332 return(1); 1333 } 1334 1335 /* cam_getccb cleans up the header, caller has to zero the payload */ 1336 bzero(&(&ccb->ccb_h)[1], 1337 sizeof(struct ccb_ataio) - sizeof(struct ccb_hdr)); 1338 1339 ptr = (uint16_t *)malloc(sizeof(struct ata_params)); 1340 1341 if (ptr == NULL) { 1342 cam_freeccb(ccb); 1343 warnx("can't malloc memory for identify\n"); 1344 return(1); 1345 } 1346 bzero(ptr, sizeof(struct ata_params)); 1347 1348 cam_fill_ataio(&ccb->ataio, 1349 retry_count, 1350 NULL, 1351 /*flags*/CAM_DIR_IN, 1352 MSG_SIMPLE_Q_TAG, 1353 /*data_ptr*/(u_int8_t *)ptr, 1354 /*dxfer_len*/sizeof(struct ata_params), 1355 timeout ? timeout : 30 * 1000); 1356 if (cgd.protocol == PROTO_ATA) 1357 ata_28bit_cmd(&ccb->ataio, ATA_ATA_IDENTIFY, 0, 0, 0); 1358 else 1359 ata_28bit_cmd(&ccb->ataio, ATA_ATAPI_IDENTIFY, 0, 0, 0); 1360 1361 /* Disable freezing the device queue */ 1362 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 1363 1364 if (arglist & CAM_ARG_ERR_RECOVER) 1365 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER; 1366 1367 if (cam_send_ccb(device, ccb) < 0) { 1368 perror("error sending ATA identify"); 1369 1370 if (arglist & CAM_ARG_VERBOSE) { 1371 cam_error_print(device, ccb, CAM_ESF_ALL, 1372 CAM_EPF_ALL, stderr); 1373 } 1374 1375 free(ptr); 1376 cam_freeccb(ccb); 1377 return(1); 1378 } 1379 1380 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 1381 error = 1; 1382 1383 if (arglist & CAM_ARG_VERBOSE) { 1384 cam_error_print(device, ccb, CAM_ESF_ALL, 1385 CAM_EPF_ALL, stderr); 1386 } 1387 } 1388 1389 cam_freeccb(ccb); 1390 1391 if (error != 0) { 1392 free(ptr); 1393 return(error); 1394 } 1395 1396 for (i = 0; i < sizeof(struct ata_params) / 2; i++) 1397 ptr[i] = le16toh(ptr[i]); 1398 if (arglist & CAM_ARG_VERBOSE) { 1399 fprintf(stdout, "%s%d: Raw identify data:\n", 1400 device->device_name, device->dev_unit_num); 1401 for (i = 0; i < sizeof(struct ata_params) / 2; i++) { 1402 if ((i % 8) == 0) 1403 fprintf(stdout, " %3d: ", i); 1404 fprintf(stdout, "%04x ", (uint16_t)ptr[i]); 1405 if ((i % 8) == 7) 1406 fprintf(stdout, "\n"); 1407 } 1408 } 1409 ident_buf = (struct ata_params *)ptr; 1410 if (strncmp(ident_buf->model, "FX", 2) && 1411 strncmp(ident_buf->model, "NEC", 3) && 1412 strncmp(ident_buf->model, "Pioneer", 7) && 1413 strncmp(ident_buf->model, "SHARP", 5)) { 1414 ata_bswap(ident_buf->model, sizeof(ident_buf->model)); 1415 ata_bswap(ident_buf->revision, sizeof(ident_buf->revision)); 1416 ata_bswap(ident_buf->serial, sizeof(ident_buf->serial)); 1417 ata_bswap(ident_buf->media_serial, sizeof(ident_buf->media_serial)); 1418 } 1419 ata_btrim(ident_buf->model, sizeof(ident_buf->model)); 1420 ata_bpack(ident_buf->model, ident_buf->model, sizeof(ident_buf->model)); 1421 ata_btrim(ident_buf->revision, sizeof(ident_buf->revision)); 1422 ata_bpack(ident_buf->revision, ident_buf->revision, sizeof(ident_buf->revision)); 1423 ata_btrim(ident_buf->serial, sizeof(ident_buf->serial)); 1424 ata_bpack(ident_buf->serial, ident_buf->serial, sizeof(ident_buf->serial)); 1425 ata_btrim(ident_buf->media_serial, sizeof(ident_buf->media_serial)); 1426 ata_bpack(ident_buf->media_serial, ident_buf->media_serial, 1427 sizeof(ident_buf->media_serial)); 1428 1429 fprintf(stdout, "%s%d: ", device->device_name, 1430 device->dev_unit_num); 1431 ata_print_ident(ident_buf); 1432 camxferrate(device); 1433 atacapprint(ident_buf); 1434 1435 free(ident_buf); 1436 1437 return(0); 1438 } 1439 #endif /* MINIMALISTIC */ 1440 1441 /* 1442 * Parse out a bus, or a bus, target and lun in the following 1443 * format: 1444 * bus 1445 * bus:target 1446 * bus:target:lun 1447 * 1448 * Returns the number of parsed components, or 0. 1449 */ 1450 static int 1451 parse_btl(char *tstr, int *bus, int *target, int *lun, cam_argmask *arglst) 1452 { 1453 char *tmpstr; 1454 int convs = 0; 1455 1456 while (isspace(*tstr) && (*tstr != '\0')) 1457 tstr++; 1458 1459 tmpstr = (char *)strtok(tstr, ":"); 1460 if ((tmpstr != NULL) && (*tmpstr != '\0')) { 1461 *bus = strtol(tmpstr, NULL, 0); 1462 *arglst |= CAM_ARG_BUS; 1463 convs++; 1464 tmpstr = (char *)strtok(NULL, ":"); 1465 if ((tmpstr != NULL) && (*tmpstr != '\0')) { 1466 *target = strtol(tmpstr, NULL, 0); 1467 *arglst |= CAM_ARG_TARGET; 1468 convs++; 1469 tmpstr = (char *)strtok(NULL, ":"); 1470 if ((tmpstr != NULL) && (*tmpstr != '\0')) { 1471 *lun = strtol(tmpstr, NULL, 0); 1472 *arglst |= CAM_ARG_LUN; 1473 convs++; 1474 } 1475 } 1476 } 1477 1478 return convs; 1479 } 1480 1481 static int 1482 dorescan_or_reset(int argc, char **argv, int rescan) 1483 { 1484 static const char must[] = 1485 "you must specify \"all\", a bus, or a bus:target:lun to %s"; 1486 int rv, error = 0; 1487 int bus = -1, target = -1, lun = -1; 1488 char *tstr; 1489 1490 if (argc < 3) { 1491 warnx(must, rescan? "rescan" : "reset"); 1492 return(1); 1493 } 1494 1495 tstr = argv[optind]; 1496 while (isspace(*tstr) && (*tstr != '\0')) 1497 tstr++; 1498 if (strncasecmp(tstr, "all", strlen("all")) == 0) 1499 arglist |= CAM_ARG_BUS; 1500 else { 1501 rv = parse_btl(argv[optind], &bus, &target, &lun, &arglist); 1502 if (rv != 1 && rv != 3) { 1503 warnx(must, rescan? "rescan" : "reset"); 1504 return(1); 1505 } 1506 } 1507 1508 if ((arglist & CAM_ARG_BUS) 1509 && (arglist & CAM_ARG_TARGET) 1510 && (arglist & CAM_ARG_LUN)) 1511 error = scanlun_or_reset_dev(bus, target, lun, rescan); 1512 else 1513 error = rescan_or_reset_bus(bus, rescan); 1514 1515 return(error); 1516 } 1517 1518 static int 1519 rescan_or_reset_bus(int bus, int rescan) 1520 { 1521 union ccb ccb, matchccb; 1522 int fd, retval; 1523 int bufsize; 1524 1525 retval = 0; 1526 1527 if ((fd = open(XPT_DEVICE, O_RDWR)) < 0) { 1528 warnx("error opening transport layer device %s", XPT_DEVICE); 1529 warn("%s", XPT_DEVICE); 1530 return(1); 1531 } 1532 1533 if (bus != -1) { 1534 ccb.ccb_h.func_code = rescan ? XPT_SCAN_BUS : XPT_RESET_BUS; 1535 ccb.ccb_h.path_id = bus; 1536 ccb.ccb_h.target_id = CAM_TARGET_WILDCARD; 1537 ccb.ccb_h.target_lun = CAM_LUN_WILDCARD; 1538 ccb.crcn.flags = CAM_FLAG_NONE; 1539 1540 /* run this at a low priority */ 1541 ccb.ccb_h.pinfo.priority = 5; 1542 1543 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) { 1544 warn("CAMIOCOMMAND ioctl failed"); 1545 close(fd); 1546 return(1); 1547 } 1548 1549 if ((ccb.ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) { 1550 fprintf(stdout, "%s of bus %d was successful\n", 1551 rescan ? "Re-scan" : "Reset", bus); 1552 } else { 1553 fprintf(stdout, "%s of bus %d returned error %#x\n", 1554 rescan ? "Re-scan" : "Reset", bus, 1555 ccb.ccb_h.status & CAM_STATUS_MASK); 1556 retval = 1; 1557 } 1558 1559 close(fd); 1560 return(retval); 1561 1562 } 1563 1564 1565 /* 1566 * The right way to handle this is to modify the xpt so that it can 1567 * handle a wildcarded bus in a rescan or reset CCB. At the moment 1568 * that isn't implemented, so instead we enumerate the busses and 1569 * send the rescan or reset to those busses in the case where the 1570 * given bus is -1 (wildcard). We don't send a rescan or reset 1571 * to the xpt bus; sending a rescan to the xpt bus is effectively a 1572 * no-op, sending a rescan to the xpt bus would result in a status of 1573 * CAM_REQ_INVALID. 1574 */ 1575 bzero(&(&matchccb.ccb_h)[1], 1576 sizeof(struct ccb_dev_match) - sizeof(struct ccb_hdr)); 1577 matchccb.ccb_h.func_code = XPT_DEV_MATCH; 1578 matchccb.ccb_h.path_id = CAM_BUS_WILDCARD; 1579 bufsize = sizeof(struct dev_match_result) * 20; 1580 matchccb.cdm.match_buf_len = bufsize; 1581 matchccb.cdm.matches=(struct dev_match_result *)malloc(bufsize); 1582 if (matchccb.cdm.matches == NULL) { 1583 warnx("can't malloc memory for matches"); 1584 retval = 1; 1585 goto bailout; 1586 } 1587 matchccb.cdm.num_matches = 0; 1588 1589 matchccb.cdm.num_patterns = 1; 1590 matchccb.cdm.pattern_buf_len = sizeof(struct dev_match_pattern); 1591 1592 matchccb.cdm.patterns = (struct dev_match_pattern *)malloc( 1593 matchccb.cdm.pattern_buf_len); 1594 if (matchccb.cdm.patterns == NULL) { 1595 warnx("can't malloc memory for patterns"); 1596 retval = 1; 1597 goto bailout; 1598 } 1599 matchccb.cdm.patterns[0].type = DEV_MATCH_BUS; 1600 matchccb.cdm.patterns[0].pattern.bus_pattern.flags = BUS_MATCH_ANY; 1601 1602 do { 1603 unsigned int i; 1604 1605 if (ioctl(fd, CAMIOCOMMAND, &matchccb) == -1) { 1606 warn("CAMIOCOMMAND ioctl failed"); 1607 retval = 1; 1608 goto bailout; 1609 } 1610 1611 if ((matchccb.ccb_h.status != CAM_REQ_CMP) 1612 || ((matchccb.cdm.status != CAM_DEV_MATCH_LAST) 1613 && (matchccb.cdm.status != CAM_DEV_MATCH_MORE))) { 1614 warnx("got CAM error %#x, CDM error %d\n", 1615 matchccb.ccb_h.status, matchccb.cdm.status); 1616 retval = 1; 1617 goto bailout; 1618 } 1619 1620 for (i = 0; i < matchccb.cdm.num_matches; i++) { 1621 struct bus_match_result *bus_result; 1622 1623 /* This shouldn't happen. */ 1624 if (matchccb.cdm.matches[i].type != DEV_MATCH_BUS) 1625 continue; 1626 1627 bus_result = &matchccb.cdm.matches[i].result.bus_result; 1628 1629 /* 1630 * We don't want to rescan or reset the xpt bus. 1631 * See above. 1632 */ 1633 if ((int)bus_result->path_id == -1) 1634 continue; 1635 1636 ccb.ccb_h.func_code = rescan ? XPT_SCAN_BUS : 1637 XPT_RESET_BUS; 1638 ccb.ccb_h.path_id = bus_result->path_id; 1639 ccb.ccb_h.target_id = CAM_TARGET_WILDCARD; 1640 ccb.ccb_h.target_lun = CAM_LUN_WILDCARD; 1641 ccb.crcn.flags = CAM_FLAG_NONE; 1642 1643 /* run this at a low priority */ 1644 ccb.ccb_h.pinfo.priority = 5; 1645 1646 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) { 1647 warn("CAMIOCOMMAND ioctl failed"); 1648 retval = 1; 1649 goto bailout; 1650 } 1651 1652 if ((ccb.ccb_h.status & CAM_STATUS_MASK) ==CAM_REQ_CMP){ 1653 fprintf(stdout, "%s of bus %d was successful\n", 1654 rescan? "Re-scan" : "Reset", 1655 bus_result->path_id); 1656 } else { 1657 /* 1658 * Don't bail out just yet, maybe the other 1659 * rescan or reset commands will complete 1660 * successfully. 1661 */ 1662 fprintf(stderr, "%s of bus %d returned error " 1663 "%#x\n", rescan? "Re-scan" : "Reset", 1664 bus_result->path_id, 1665 ccb.ccb_h.status & CAM_STATUS_MASK); 1666 retval = 1; 1667 } 1668 } 1669 } while ((matchccb.ccb_h.status == CAM_REQ_CMP) 1670 && (matchccb.cdm.status == CAM_DEV_MATCH_MORE)); 1671 1672 bailout: 1673 1674 if (fd != -1) 1675 close(fd); 1676 1677 if (matchccb.cdm.patterns != NULL) 1678 free(matchccb.cdm.patterns); 1679 if (matchccb.cdm.matches != NULL) 1680 free(matchccb.cdm.matches); 1681 1682 return(retval); 1683 } 1684 1685 static int 1686 scanlun_or_reset_dev(int bus, int target, int lun, int scan) 1687 { 1688 union ccb ccb; 1689 struct cam_device *device; 1690 int fd; 1691 1692 device = NULL; 1693 1694 if (bus < 0) { 1695 warnx("invalid bus number %d", bus); 1696 return(1); 1697 } 1698 1699 if (target < 0) { 1700 warnx("invalid target number %d", target); 1701 return(1); 1702 } 1703 1704 if (lun < 0) { 1705 warnx("invalid lun number %d", lun); 1706 return(1); 1707 } 1708 1709 fd = -1; 1710 1711 bzero(&ccb, sizeof(union ccb)); 1712 1713 if (scan) { 1714 if ((fd = open(XPT_DEVICE, O_RDWR)) < 0) { 1715 warnx("error opening transport layer device %s\n", 1716 XPT_DEVICE); 1717 warn("%s", XPT_DEVICE); 1718 return(1); 1719 } 1720 } else { 1721 device = cam_open_btl(bus, target, lun, O_RDWR, NULL); 1722 if (device == NULL) { 1723 warnx("%s", cam_errbuf); 1724 return(1); 1725 } 1726 } 1727 1728 ccb.ccb_h.func_code = (scan)? XPT_SCAN_LUN : XPT_RESET_DEV; 1729 ccb.ccb_h.path_id = bus; 1730 ccb.ccb_h.target_id = target; 1731 ccb.ccb_h.target_lun = lun; 1732 ccb.ccb_h.timeout = 5000; 1733 ccb.crcn.flags = CAM_FLAG_NONE; 1734 1735 /* run this at a low priority */ 1736 ccb.ccb_h.pinfo.priority = 5; 1737 1738 if (scan) { 1739 if (ioctl(fd, CAMIOCOMMAND, &ccb) < 0) { 1740 warn("CAMIOCOMMAND ioctl failed"); 1741 close(fd); 1742 return(1); 1743 } 1744 } else { 1745 if (cam_send_ccb(device, &ccb) < 0) { 1746 warn("error sending XPT_RESET_DEV CCB"); 1747 cam_close_device(device); 1748 return(1); 1749 } 1750 } 1751 1752 if (scan) 1753 close(fd); 1754 else 1755 cam_close_device(device); 1756 1757 /* 1758 * An error code of CAM_BDR_SENT is normal for a BDR request. 1759 */ 1760 if (((ccb.ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) 1761 || ((!scan) 1762 && ((ccb.ccb_h.status & CAM_STATUS_MASK) == CAM_BDR_SENT))) { 1763 fprintf(stdout, "%s of %d:%d:%d was successful\n", 1764 scan? "Re-scan" : "Reset", bus, target, lun); 1765 return(0); 1766 } else { 1767 fprintf(stdout, "%s of %d:%d:%d returned error %#x\n", 1768 scan? "Re-scan" : "Reset", bus, target, lun, 1769 ccb.ccb_h.status & CAM_STATUS_MASK); 1770 return(1); 1771 } 1772 } 1773 1774 #ifndef MINIMALISTIC 1775 static int 1776 readdefects(struct cam_device *device, int argc, char **argv, 1777 char *combinedopt, int retry_count, int timeout) 1778 { 1779 union ccb *ccb = NULL; 1780 struct scsi_read_defect_data_10 *rdd_cdb; 1781 u_int8_t *defect_list = NULL; 1782 u_int32_t dlist_length = 65000; 1783 u_int32_t returned_length = 0; 1784 u_int32_t num_returned = 0; 1785 u_int8_t returned_format; 1786 unsigned int i; 1787 int c, error = 0; 1788 int lists_specified = 0; 1789 1790 while ((c = getopt(argc, argv, combinedopt)) != -1) { 1791 switch(c){ 1792 case 'f': 1793 { 1794 char *tstr; 1795 tstr = optarg; 1796 while (isspace(*tstr) && (*tstr != '\0')) 1797 tstr++; 1798 if (strcmp(tstr, "block") == 0) 1799 arglist |= CAM_ARG_FORMAT_BLOCK; 1800 else if (strcmp(tstr, "bfi") == 0) 1801 arglist |= CAM_ARG_FORMAT_BFI; 1802 else if (strcmp(tstr, "phys") == 0) 1803 arglist |= CAM_ARG_FORMAT_PHYS; 1804 else { 1805 error = 1; 1806 warnx("invalid defect format %s", tstr); 1807 goto defect_bailout; 1808 } 1809 break; 1810 } 1811 case 'G': 1812 arglist |= CAM_ARG_GLIST; 1813 break; 1814 case 'P': 1815 arglist |= CAM_ARG_PLIST; 1816 break; 1817 default: 1818 break; 1819 } 1820 } 1821 1822 ccb = cam_getccb(device); 1823 1824 /* 1825 * Hopefully 65000 bytes is enough to hold the defect list. If it 1826 * isn't, the disk is probably dead already. We'd have to go with 1827 * 12 byte command (i.e. alloc_length is 32 bits instead of 16) 1828 * to hold them all. 1829 */ 1830 defect_list = malloc(dlist_length); 1831 if (defect_list == NULL) { 1832 warnx("can't malloc memory for defect list"); 1833 error = 1; 1834 goto defect_bailout; 1835 } 1836 1837 rdd_cdb =(struct scsi_read_defect_data_10 *)&ccb->csio.cdb_io.cdb_bytes; 1838 1839 /* 1840 * cam_getccb() zeros the CCB header only. So we need to zero the 1841 * payload portion of the ccb. 1842 */ 1843 bzero(&(&ccb->ccb_h)[1], 1844 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr)); 1845 1846 cam_fill_csio(&ccb->csio, 1847 /*retries*/ retry_count, 1848 /*cbfcnp*/ NULL, 1849 /*flags*/ CAM_DIR_IN | ((arglist & CAM_ARG_ERR_RECOVER) ? 1850 CAM_PASS_ERR_RECOVER : 0), 1851 /*tag_action*/ MSG_SIMPLE_Q_TAG, 1852 /*data_ptr*/ defect_list, 1853 /*dxfer_len*/ dlist_length, 1854 /*sense_len*/ SSD_FULL_SIZE, 1855 /*cdb_len*/ sizeof(struct scsi_read_defect_data_10), 1856 /*timeout*/ timeout ? timeout : 5000); 1857 1858 rdd_cdb->opcode = READ_DEFECT_DATA_10; 1859 if (arglist & CAM_ARG_FORMAT_BLOCK) 1860 rdd_cdb->format = SRDD10_BLOCK_FORMAT; 1861 else if (arglist & CAM_ARG_FORMAT_BFI) 1862 rdd_cdb->format = SRDD10_BYTES_FROM_INDEX_FORMAT; 1863 else if (arglist & CAM_ARG_FORMAT_PHYS) 1864 rdd_cdb->format = SRDD10_PHYSICAL_SECTOR_FORMAT; 1865 else { 1866 error = 1; 1867 warnx("no defect list format specified"); 1868 goto defect_bailout; 1869 } 1870 if (arglist & CAM_ARG_PLIST) { 1871 rdd_cdb->format |= SRDD10_PLIST; 1872 lists_specified++; 1873 } 1874 1875 if (arglist & CAM_ARG_GLIST) { 1876 rdd_cdb->format |= SRDD10_GLIST; 1877 lists_specified++; 1878 } 1879 1880 scsi_ulto2b(dlist_length, rdd_cdb->alloc_length); 1881 1882 /* Disable freezing the device queue */ 1883 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 1884 1885 if (cam_send_ccb(device, ccb) < 0) { 1886 perror("error reading defect list"); 1887 1888 if (arglist & CAM_ARG_VERBOSE) { 1889 cam_error_print(device, ccb, CAM_ESF_ALL, 1890 CAM_EPF_ALL, stderr); 1891 } 1892 1893 error = 1; 1894 goto defect_bailout; 1895 } 1896 1897 returned_length = scsi_2btoul(((struct 1898 scsi_read_defect_data_hdr_10 *)defect_list)->length); 1899 1900 returned_format = ((struct scsi_read_defect_data_hdr_10 *) 1901 defect_list)->format; 1902 1903 if (((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_SCSI_STATUS_ERROR) 1904 && (ccb->csio.scsi_status == SCSI_STATUS_CHECK_COND) 1905 && ((ccb->ccb_h.status & CAM_AUTOSNS_VALID) != 0)) { 1906 struct scsi_sense_data *sense; 1907 int error_code, sense_key, asc, ascq; 1908 1909 sense = &ccb->csio.sense_data; 1910 scsi_extract_sense(sense, &error_code, &sense_key, &asc, &ascq); 1911 1912 /* 1913 * According to the SCSI spec, if the disk doesn't support 1914 * the requested format, it will generally return a sense 1915 * key of RECOVERED ERROR, and an additional sense code 1916 * of "DEFECT LIST NOT FOUND". So, we check for that, and 1917 * also check to make sure that the returned length is 1918 * greater than 0, and then print out whatever format the 1919 * disk gave us. 1920 */ 1921 if ((sense_key == SSD_KEY_RECOVERED_ERROR) 1922 && (asc == 0x1c) && (ascq == 0x00) 1923 && (returned_length > 0)) { 1924 warnx("requested defect format not available"); 1925 switch(returned_format & SRDDH10_DLIST_FORMAT_MASK) { 1926 case SRDD10_BLOCK_FORMAT: 1927 warnx("Device returned block format"); 1928 break; 1929 case SRDD10_BYTES_FROM_INDEX_FORMAT: 1930 warnx("Device returned bytes from index" 1931 " format"); 1932 break; 1933 case SRDD10_PHYSICAL_SECTOR_FORMAT: 1934 warnx("Device returned physical sector format"); 1935 break; 1936 default: 1937 error = 1; 1938 warnx("Device returned unknown defect" 1939 " data format %#x", returned_format); 1940 goto defect_bailout; 1941 break; /* NOTREACHED */ 1942 } 1943 } else { 1944 error = 1; 1945 warnx("Error returned from read defect data command"); 1946 if (arglist & CAM_ARG_VERBOSE) 1947 cam_error_print(device, ccb, CAM_ESF_ALL, 1948 CAM_EPF_ALL, stderr); 1949 goto defect_bailout; 1950 } 1951 } else if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 1952 error = 1; 1953 warnx("Error returned from read defect data command"); 1954 if (arglist & CAM_ARG_VERBOSE) 1955 cam_error_print(device, ccb, CAM_ESF_ALL, 1956 CAM_EPF_ALL, stderr); 1957 goto defect_bailout; 1958 } 1959 1960 /* 1961 * XXX KDM I should probably clean up the printout format for the 1962 * disk defects. 1963 */ 1964 switch (returned_format & SRDDH10_DLIST_FORMAT_MASK){ 1965 case SRDDH10_PHYSICAL_SECTOR_FORMAT: 1966 { 1967 struct scsi_defect_desc_phys_sector *dlist; 1968 1969 dlist = (struct scsi_defect_desc_phys_sector *) 1970 (defect_list + 1971 sizeof(struct scsi_read_defect_data_hdr_10)); 1972 1973 num_returned = returned_length / 1974 sizeof(struct scsi_defect_desc_phys_sector); 1975 1976 fprintf(stderr, "Got %d defect", num_returned); 1977 1978 if ((lists_specified == 0) || (num_returned == 0)) { 1979 fprintf(stderr, "s.\n"); 1980 break; 1981 } else if (num_returned == 1) 1982 fprintf(stderr, ":\n"); 1983 else 1984 fprintf(stderr, "s:\n"); 1985 1986 for (i = 0; i < num_returned; i++) { 1987 fprintf(stdout, "%d:%d:%d\n", 1988 scsi_3btoul(dlist[i].cylinder), 1989 dlist[i].head, 1990 scsi_4btoul(dlist[i].sector)); 1991 } 1992 break; 1993 } 1994 case SRDDH10_BYTES_FROM_INDEX_FORMAT: 1995 { 1996 struct scsi_defect_desc_bytes_from_index *dlist; 1997 1998 dlist = (struct scsi_defect_desc_bytes_from_index *) 1999 (defect_list + 2000 sizeof(struct scsi_read_defect_data_hdr_10)); 2001 2002 num_returned = returned_length / 2003 sizeof(struct scsi_defect_desc_bytes_from_index); 2004 2005 fprintf(stderr, "Got %d defect", num_returned); 2006 2007 if ((lists_specified == 0) || (num_returned == 0)) { 2008 fprintf(stderr, "s.\n"); 2009 break; 2010 } else if (num_returned == 1) 2011 fprintf(stderr, ":\n"); 2012 else 2013 fprintf(stderr, "s:\n"); 2014 2015 for (i = 0; i < num_returned; i++) { 2016 fprintf(stdout, "%d:%d:%d\n", 2017 scsi_3btoul(dlist[i].cylinder), 2018 dlist[i].head, 2019 scsi_4btoul(dlist[i].bytes_from_index)); 2020 } 2021 break; 2022 } 2023 case SRDDH10_BLOCK_FORMAT: 2024 { 2025 struct scsi_defect_desc_block *dlist; 2026 2027 dlist = (struct scsi_defect_desc_block *)(defect_list + 2028 sizeof(struct scsi_read_defect_data_hdr_10)); 2029 2030 num_returned = returned_length / 2031 sizeof(struct scsi_defect_desc_block); 2032 2033 fprintf(stderr, "Got %d defect", num_returned); 2034 2035 if ((lists_specified == 0) || (num_returned == 0)) { 2036 fprintf(stderr, "s.\n"); 2037 break; 2038 } else if (num_returned == 1) 2039 fprintf(stderr, ":\n"); 2040 else 2041 fprintf(stderr, "s:\n"); 2042 2043 for (i = 0; i < num_returned; i++) 2044 fprintf(stdout, "%u\n", 2045 scsi_4btoul(dlist[i].address)); 2046 break; 2047 } 2048 default: 2049 fprintf(stderr, "Unknown defect format %d\n", 2050 returned_format & SRDDH10_DLIST_FORMAT_MASK); 2051 error = 1; 2052 break; 2053 } 2054 defect_bailout: 2055 2056 if (defect_list != NULL) 2057 free(defect_list); 2058 2059 if (ccb != NULL) 2060 cam_freeccb(ccb); 2061 2062 return(error); 2063 } 2064 #endif /* MINIMALISTIC */ 2065 2066 #if 0 2067 void 2068 reassignblocks(struct cam_device *device, u_int32_t *blocks, int num_blocks) 2069 { 2070 union ccb *ccb; 2071 2072 ccb = cam_getccb(device); 2073 2074 cam_freeccb(ccb); 2075 } 2076 #endif 2077 2078 #ifndef MINIMALISTIC 2079 void 2080 mode_sense(struct cam_device *device, int mode_page, int page_control, 2081 int dbd, int retry_count, int timeout, u_int8_t *data, int datalen) 2082 { 2083 union ccb *ccb; 2084 int retval; 2085 2086 ccb = cam_getccb(device); 2087 2088 if (ccb == NULL) 2089 errx(1, "mode_sense: couldn't allocate CCB"); 2090 2091 bzero(&(&ccb->ccb_h)[1], 2092 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr)); 2093 2094 scsi_mode_sense(&ccb->csio, 2095 /* retries */ retry_count, 2096 /* cbfcnp */ NULL, 2097 /* tag_action */ MSG_SIMPLE_Q_TAG, 2098 /* dbd */ dbd, 2099 /* page_code */ page_control << 6, 2100 /* page */ mode_page, 2101 /* param_buf */ data, 2102 /* param_len */ datalen, 2103 /* sense_len */ SSD_FULL_SIZE, 2104 /* timeout */ timeout ? timeout : 5000); 2105 2106 if (arglist & CAM_ARG_ERR_RECOVER) 2107 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER; 2108 2109 /* Disable freezing the device queue */ 2110 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 2111 2112 if (((retval = cam_send_ccb(device, ccb)) < 0) 2113 || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) { 2114 if (arglist & CAM_ARG_VERBOSE) { 2115 cam_error_print(device, ccb, CAM_ESF_ALL, 2116 CAM_EPF_ALL, stderr); 2117 } 2118 cam_freeccb(ccb); 2119 cam_close_device(device); 2120 if (retval < 0) 2121 err(1, "error sending mode sense command"); 2122 else 2123 errx(1, "error sending mode sense command"); 2124 } 2125 2126 cam_freeccb(ccb); 2127 } 2128 2129 void 2130 mode_select(struct cam_device *device, int save_pages, int retry_count, 2131 int timeout, u_int8_t *data, int datalen) 2132 { 2133 union ccb *ccb; 2134 int retval; 2135 2136 ccb = cam_getccb(device); 2137 2138 if (ccb == NULL) 2139 errx(1, "mode_select: couldn't allocate CCB"); 2140 2141 bzero(&(&ccb->ccb_h)[1], 2142 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr)); 2143 2144 scsi_mode_select(&ccb->csio, 2145 /* retries */ retry_count, 2146 /* cbfcnp */ NULL, 2147 /* tag_action */ MSG_SIMPLE_Q_TAG, 2148 /* scsi_page_fmt */ 1, 2149 /* save_pages */ save_pages, 2150 /* param_buf */ data, 2151 /* param_len */ datalen, 2152 /* sense_len */ SSD_FULL_SIZE, 2153 /* timeout */ timeout ? timeout : 5000); 2154 2155 if (arglist & CAM_ARG_ERR_RECOVER) 2156 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER; 2157 2158 /* Disable freezing the device queue */ 2159 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 2160 2161 if (((retval = cam_send_ccb(device, ccb)) < 0) 2162 || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) { 2163 if (arglist & CAM_ARG_VERBOSE) { 2164 cam_error_print(device, ccb, CAM_ESF_ALL, 2165 CAM_EPF_ALL, stderr); 2166 } 2167 cam_freeccb(ccb); 2168 cam_close_device(device); 2169 2170 if (retval < 0) 2171 err(1, "error sending mode select command"); 2172 else 2173 errx(1, "error sending mode select command"); 2174 2175 } 2176 2177 cam_freeccb(ccb); 2178 } 2179 2180 void 2181 modepage(struct cam_device *device, int argc, char **argv, char *combinedopt, 2182 int retry_count, int timeout) 2183 { 2184 int c, mode_page = -1, page_control = 0; 2185 int binary = 0, list = 0; 2186 2187 while ((c = getopt(argc, argv, combinedopt)) != -1) { 2188 switch(c) { 2189 case 'b': 2190 binary = 1; 2191 break; 2192 case 'd': 2193 arglist |= CAM_ARG_DBD; 2194 break; 2195 case 'e': 2196 arglist |= CAM_ARG_MODE_EDIT; 2197 break; 2198 case 'l': 2199 list = 1; 2200 break; 2201 case 'm': 2202 mode_page = strtol(optarg, NULL, 0); 2203 if (mode_page < 0) 2204 errx(1, "invalid mode page %d", mode_page); 2205 break; 2206 case 'P': 2207 page_control = strtol(optarg, NULL, 0); 2208 if ((page_control < 0) || (page_control > 3)) 2209 errx(1, "invalid page control field %d", 2210 page_control); 2211 arglist |= CAM_ARG_PAGE_CNTL; 2212 break; 2213 default: 2214 break; 2215 } 2216 } 2217 2218 if (mode_page == -1 && list == 0) 2219 errx(1, "you must specify a mode page!"); 2220 2221 if (list) { 2222 mode_list(device, page_control, arglist & CAM_ARG_DBD, 2223 retry_count, timeout); 2224 } else { 2225 mode_edit(device, mode_page, page_control, 2226 arglist & CAM_ARG_DBD, arglist & CAM_ARG_MODE_EDIT, binary, 2227 retry_count, timeout); 2228 } 2229 } 2230 2231 static int 2232 scsicmd(struct cam_device *device, int argc, char **argv, char *combinedopt, 2233 int retry_count, int timeout) 2234 { 2235 union ccb *ccb; 2236 u_int32_t flags = CAM_DIR_NONE; 2237 u_int8_t *data_ptr = NULL; 2238 u_int8_t cdb[20]; 2239 u_int8_t atacmd[12]; 2240 struct get_hook hook; 2241 int c, data_bytes = 0; 2242 int cdb_len = 0; 2243 int atacmd_len = 0; 2244 int dmacmd = 0; 2245 int fpdmacmd = 0; 2246 int need_res = 0; 2247 char *datastr = NULL, *tstr, *resstr = NULL; 2248 int error = 0; 2249 int fd_data = 0, fd_res = 0; 2250 int retval; 2251 2252 ccb = cam_getccb(device); 2253 2254 if (ccb == NULL) { 2255 warnx("scsicmd: error allocating ccb"); 2256 return(1); 2257 } 2258 2259 bzero(&(&ccb->ccb_h)[1], 2260 sizeof(union ccb) - sizeof(struct ccb_hdr)); 2261 2262 while ((c = getopt(argc, argv, combinedopt)) != -1) { 2263 switch(c) { 2264 case 'a': 2265 tstr = optarg; 2266 while (isspace(*tstr) && (*tstr != '\0')) 2267 tstr++; 2268 hook.argc = argc - optind; 2269 hook.argv = argv + optind; 2270 hook.got = 0; 2271 atacmd_len = buff_encode_visit(atacmd, sizeof(atacmd), tstr, 2272 iget, &hook); 2273 /* 2274 * Increment optind by the number of arguments the 2275 * encoding routine processed. After each call to 2276 * getopt(3), optind points to the argument that 2277 * getopt should process _next_. In this case, 2278 * that means it points to the first command string 2279 * argument, if there is one. Once we increment 2280 * this, it should point to either the next command 2281 * line argument, or it should be past the end of 2282 * the list. 2283 */ 2284 optind += hook.got; 2285 break; 2286 case 'c': 2287 tstr = optarg; 2288 while (isspace(*tstr) && (*tstr != '\0')) 2289 tstr++; 2290 hook.argc = argc - optind; 2291 hook.argv = argv + optind; 2292 hook.got = 0; 2293 cdb_len = buff_encode_visit(cdb, sizeof(cdb), tstr, 2294 iget, &hook); 2295 /* 2296 * Increment optind by the number of arguments the 2297 * encoding routine processed. After each call to 2298 * getopt(3), optind points to the argument that 2299 * getopt should process _next_. In this case, 2300 * that means it points to the first command string 2301 * argument, if there is one. Once we increment 2302 * this, it should point to either the next command 2303 * line argument, or it should be past the end of 2304 * the list. 2305 */ 2306 optind += hook.got; 2307 break; 2308 case 'd': 2309 dmacmd = 1; 2310 break; 2311 case 'f': 2312 fpdmacmd = 1; 2313 break; 2314 case 'i': 2315 if (arglist & CAM_ARG_CMD_OUT) { 2316 warnx("command must either be " 2317 "read or write, not both"); 2318 error = 1; 2319 goto scsicmd_bailout; 2320 } 2321 arglist |= CAM_ARG_CMD_IN; 2322 flags = CAM_DIR_IN; 2323 data_bytes = strtol(optarg, NULL, 0); 2324 if (data_bytes <= 0) { 2325 warnx("invalid number of input bytes %d", 2326 data_bytes); 2327 error = 1; 2328 goto scsicmd_bailout; 2329 } 2330 hook.argc = argc - optind; 2331 hook.argv = argv + optind; 2332 hook.got = 0; 2333 optind++; 2334 datastr = cget(&hook, NULL); 2335 /* 2336 * If the user supplied "-" instead of a format, he 2337 * wants the data to be written to stdout. 2338 */ 2339 if ((datastr != NULL) 2340 && (datastr[0] == '-')) 2341 fd_data = 1; 2342 2343 data_ptr = (u_int8_t *)malloc(data_bytes); 2344 if (data_ptr == NULL) { 2345 warnx("can't malloc memory for data_ptr"); 2346 error = 1; 2347 goto scsicmd_bailout; 2348 } 2349 break; 2350 case 'o': 2351 if (arglist & CAM_ARG_CMD_IN) { 2352 warnx("command must either be " 2353 "read or write, not both"); 2354 error = 1; 2355 goto scsicmd_bailout; 2356 } 2357 arglist |= CAM_ARG_CMD_OUT; 2358 flags = CAM_DIR_OUT; 2359 data_bytes = strtol(optarg, NULL, 0); 2360 if (data_bytes <= 0) { 2361 warnx("invalid number of output bytes %d", 2362 data_bytes); 2363 error = 1; 2364 goto scsicmd_bailout; 2365 } 2366 hook.argc = argc - optind; 2367 hook.argv = argv + optind; 2368 hook.got = 0; 2369 datastr = cget(&hook, NULL); 2370 data_ptr = (u_int8_t *)malloc(data_bytes); 2371 if (data_ptr == NULL) { 2372 warnx("can't malloc memory for data_ptr"); 2373 error = 1; 2374 goto scsicmd_bailout; 2375 } 2376 bzero(data_ptr, data_bytes); 2377 /* 2378 * If the user supplied "-" instead of a format, he 2379 * wants the data to be read from stdin. 2380 */ 2381 if ((datastr != NULL) 2382 && (datastr[0] == '-')) 2383 fd_data = 1; 2384 else 2385 buff_encode_visit(data_ptr, data_bytes, datastr, 2386 iget, &hook); 2387 optind += hook.got; 2388 break; 2389 case 'r': 2390 need_res = 1; 2391 hook.argc = argc - optind; 2392 hook.argv = argv + optind; 2393 hook.got = 0; 2394 resstr = cget(&hook, NULL); 2395 if ((resstr != NULL) && (resstr[0] == '-')) 2396 fd_res = 1; 2397 optind += hook.got; 2398 break; 2399 default: 2400 break; 2401 } 2402 } 2403 2404 /* 2405 * If fd_data is set, and we're writing to the device, we need to 2406 * read the data the user wants written from stdin. 2407 */ 2408 if ((fd_data == 1) && (arglist & CAM_ARG_CMD_OUT)) { 2409 ssize_t amt_read; 2410 int amt_to_read = data_bytes; 2411 u_int8_t *buf_ptr = data_ptr; 2412 2413 for (amt_read = 0; amt_to_read > 0; 2414 amt_read = read(STDIN_FILENO, buf_ptr, amt_to_read)) { 2415 if (amt_read == -1) { 2416 warn("error reading data from stdin"); 2417 error = 1; 2418 goto scsicmd_bailout; 2419 } 2420 amt_to_read -= amt_read; 2421 buf_ptr += amt_read; 2422 } 2423 } 2424 2425 if (arglist & CAM_ARG_ERR_RECOVER) 2426 flags |= CAM_PASS_ERR_RECOVER; 2427 2428 /* Disable freezing the device queue */ 2429 flags |= CAM_DEV_QFRZDIS; 2430 2431 if (cdb_len) { 2432 /* 2433 * This is taken from the SCSI-3 draft spec. 2434 * (T10/1157D revision 0.3) 2435 * The top 3 bits of an opcode are the group code. 2436 * The next 5 bits are the command code. 2437 * Group 0: six byte commands 2438 * Group 1: ten byte commands 2439 * Group 2: ten byte commands 2440 * Group 3: reserved 2441 * Group 4: sixteen byte commands 2442 * Group 5: twelve byte commands 2443 * Group 6: vendor specific 2444 * Group 7: vendor specific 2445 */ 2446 switch((cdb[0] >> 5) & 0x7) { 2447 case 0: 2448 cdb_len = 6; 2449 break; 2450 case 1: 2451 case 2: 2452 cdb_len = 10; 2453 break; 2454 case 3: 2455 case 6: 2456 case 7: 2457 /* computed by buff_encode_visit */ 2458 break; 2459 case 4: 2460 cdb_len = 16; 2461 break; 2462 case 5: 2463 cdb_len = 12; 2464 break; 2465 } 2466 2467 /* 2468 * We should probably use csio_build_visit or something like that 2469 * here, but it's easier to encode arguments as you go. The 2470 * alternative would be skipping the CDB argument and then encoding 2471 * it here, since we've got the data buffer argument by now. 2472 */ 2473 bcopy(cdb, &ccb->csio.cdb_io.cdb_bytes, cdb_len); 2474 2475 cam_fill_csio(&ccb->csio, 2476 /*retries*/ retry_count, 2477 /*cbfcnp*/ NULL, 2478 /*flags*/ flags, 2479 /*tag_action*/ MSG_SIMPLE_Q_TAG, 2480 /*data_ptr*/ data_ptr, 2481 /*dxfer_len*/ data_bytes, 2482 /*sense_len*/ SSD_FULL_SIZE, 2483 /*cdb_len*/ cdb_len, 2484 /*timeout*/ timeout ? timeout : 5000); 2485 } else { 2486 atacmd_len = 12; 2487 bcopy(atacmd, &ccb->ataio.cmd.command, atacmd_len); 2488 if (need_res) 2489 ccb->ataio.cmd.flags |= CAM_ATAIO_NEEDRESULT; 2490 if (dmacmd) 2491 ccb->ataio.cmd.flags |= CAM_ATAIO_DMA; 2492 if (fpdmacmd) 2493 ccb->ataio.cmd.flags |= CAM_ATAIO_FPDMA; 2494 2495 cam_fill_ataio(&ccb->ataio, 2496 /*retries*/ retry_count, 2497 /*cbfcnp*/ NULL, 2498 /*flags*/ flags, 2499 /*tag_action*/ 0, 2500 /*data_ptr*/ data_ptr, 2501 /*dxfer_len*/ data_bytes, 2502 /*timeout*/ timeout ? timeout : 5000); 2503 } 2504 2505 if (((retval = cam_send_ccb(device, ccb)) < 0) 2506 || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) { 2507 const char *warnstr = "error sending command"; 2508 2509 if (retval < 0) 2510 warn(warnstr); 2511 else 2512 warnx(warnstr); 2513 2514 if (arglist & CAM_ARG_VERBOSE) { 2515 cam_error_print(device, ccb, CAM_ESF_ALL, 2516 CAM_EPF_ALL, stderr); 2517 } 2518 2519 error = 1; 2520 goto scsicmd_bailout; 2521 } 2522 2523 if (atacmd_len && need_res) { 2524 if (fd_res == 0) { 2525 buff_decode_visit(&ccb->ataio.res.status, 11, resstr, 2526 arg_put, NULL); 2527 fprintf(stdout, "\n"); 2528 } else { 2529 fprintf(stdout, 2530 "%02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n", 2531 ccb->ataio.res.status, 2532 ccb->ataio.res.error, 2533 ccb->ataio.res.lba_low, 2534 ccb->ataio.res.lba_mid, 2535 ccb->ataio.res.lba_high, 2536 ccb->ataio.res.device, 2537 ccb->ataio.res.lba_low_exp, 2538 ccb->ataio.res.lba_mid_exp, 2539 ccb->ataio.res.lba_high_exp, 2540 ccb->ataio.res.sector_count, 2541 ccb->ataio.res.sector_count_exp); 2542 fflush(stdout); 2543 } 2544 } 2545 2546 if (((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) 2547 && (arglist & CAM_ARG_CMD_IN) 2548 && (data_bytes > 0)) { 2549 if (fd_data == 0) { 2550 buff_decode_visit(data_ptr, data_bytes, datastr, 2551 arg_put, NULL); 2552 fprintf(stdout, "\n"); 2553 } else { 2554 ssize_t amt_written; 2555 int amt_to_write = data_bytes; 2556 u_int8_t *buf_ptr = data_ptr; 2557 2558 for (amt_written = 0; (amt_to_write > 0) && 2559 (amt_written =write(1, buf_ptr,amt_to_write))> 0;){ 2560 amt_to_write -= amt_written; 2561 buf_ptr += amt_written; 2562 } 2563 if (amt_written == -1) { 2564 warn("error writing data to stdout"); 2565 error = 1; 2566 goto scsicmd_bailout; 2567 } else if ((amt_written == 0) 2568 && (amt_to_write > 0)) { 2569 warnx("only wrote %u bytes out of %u", 2570 data_bytes - amt_to_write, data_bytes); 2571 } 2572 } 2573 } 2574 2575 scsicmd_bailout: 2576 2577 if ((data_bytes > 0) && (data_ptr != NULL)) 2578 free(data_ptr); 2579 2580 cam_freeccb(ccb); 2581 2582 return(error); 2583 } 2584 2585 static int 2586 camdebug(int argc, char **argv, char *combinedopt) 2587 { 2588 int c, fd; 2589 int bus = -1, target = -1, lun = -1; 2590 char *tstr, *tmpstr = NULL; 2591 union ccb ccb; 2592 int error = 0; 2593 2594 bzero(&ccb, sizeof(union ccb)); 2595 2596 while ((c = getopt(argc, argv, combinedopt)) != -1) { 2597 switch(c) { 2598 case 'I': 2599 arglist |= CAM_ARG_DEBUG_INFO; 2600 ccb.cdbg.flags |= CAM_DEBUG_INFO; 2601 break; 2602 case 'P': 2603 arglist |= CAM_ARG_DEBUG_PERIPH; 2604 ccb.cdbg.flags |= CAM_DEBUG_PERIPH; 2605 break; 2606 case 'S': 2607 arglist |= CAM_ARG_DEBUG_SUBTRACE; 2608 ccb.cdbg.flags |= CAM_DEBUG_SUBTRACE; 2609 break; 2610 case 'T': 2611 arglist |= CAM_ARG_DEBUG_TRACE; 2612 ccb.cdbg.flags |= CAM_DEBUG_TRACE; 2613 break; 2614 case 'X': 2615 arglist |= CAM_ARG_DEBUG_XPT; 2616 ccb.cdbg.flags |= CAM_DEBUG_XPT; 2617 break; 2618 case 'c': 2619 arglist |= CAM_ARG_DEBUG_CDB; 2620 ccb.cdbg.flags |= CAM_DEBUG_CDB; 2621 break; 2622 default: 2623 break; 2624 } 2625 } 2626 2627 if ((fd = open(XPT_DEVICE, O_RDWR)) < 0) { 2628 warnx("error opening transport layer device %s", XPT_DEVICE); 2629 warn("%s", XPT_DEVICE); 2630 return(1); 2631 } 2632 argc -= optind; 2633 argv += optind; 2634 2635 if (argc <= 0) { 2636 warnx("you must specify \"off\", \"all\" or a bus,"); 2637 warnx("bus:target, or bus:target:lun"); 2638 close(fd); 2639 return(1); 2640 } 2641 2642 tstr = *argv; 2643 2644 while (isspace(*tstr) && (*tstr != '\0')) 2645 tstr++; 2646 2647 if (strncmp(tstr, "off", 3) == 0) { 2648 ccb.cdbg.flags = CAM_DEBUG_NONE; 2649 arglist &= ~(CAM_ARG_DEBUG_INFO|CAM_ARG_DEBUG_PERIPH| 2650 CAM_ARG_DEBUG_TRACE|CAM_ARG_DEBUG_SUBTRACE| 2651 CAM_ARG_DEBUG_XPT); 2652 } else if (strncmp(tstr, "all", 3) != 0) { 2653 tmpstr = (char *)strtok(tstr, ":"); 2654 if ((tmpstr != NULL) && (*tmpstr != '\0')){ 2655 bus = strtol(tmpstr, NULL, 0); 2656 arglist |= CAM_ARG_BUS; 2657 tmpstr = (char *)strtok(NULL, ":"); 2658 if ((tmpstr != NULL) && (*tmpstr != '\0')){ 2659 target = strtol(tmpstr, NULL, 0); 2660 arglist |= CAM_ARG_TARGET; 2661 tmpstr = (char *)strtok(NULL, ":"); 2662 if ((tmpstr != NULL) && (*tmpstr != '\0')){ 2663 lun = strtol(tmpstr, NULL, 0); 2664 arglist |= CAM_ARG_LUN; 2665 } 2666 } 2667 } else { 2668 error = 1; 2669 warnx("you must specify \"all\", \"off\", or a bus,"); 2670 warnx("bus:target, or bus:target:lun to debug"); 2671 } 2672 } 2673 2674 if (error == 0) { 2675 2676 ccb.ccb_h.func_code = XPT_DEBUG; 2677 ccb.ccb_h.path_id = bus; 2678 ccb.ccb_h.target_id = target; 2679 ccb.ccb_h.target_lun = lun; 2680 2681 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) { 2682 warn("CAMIOCOMMAND ioctl failed"); 2683 error = 1; 2684 } 2685 2686 if (error == 0) { 2687 if ((ccb.ccb_h.status & CAM_STATUS_MASK) == 2688 CAM_FUNC_NOTAVAIL) { 2689 warnx("CAM debugging not available"); 2690 warnx("you need to put options CAMDEBUG in" 2691 " your kernel config file!"); 2692 error = 1; 2693 } else if ((ccb.ccb_h.status & CAM_STATUS_MASK) != 2694 CAM_REQ_CMP) { 2695 warnx("XPT_DEBUG CCB failed with status %#x", 2696 ccb.ccb_h.status); 2697 error = 1; 2698 } else { 2699 if (ccb.cdbg.flags == CAM_DEBUG_NONE) { 2700 fprintf(stderr, 2701 "Debugging turned off\n"); 2702 } else { 2703 fprintf(stderr, 2704 "Debugging enabled for " 2705 "%d:%d:%d\n", 2706 bus, target, lun); 2707 } 2708 } 2709 } 2710 close(fd); 2711 } 2712 2713 return(error); 2714 } 2715 2716 static int 2717 tagcontrol(struct cam_device *device, int argc, char **argv, 2718 char *combinedopt) 2719 { 2720 int c; 2721 union ccb *ccb; 2722 int numtags = -1; 2723 int retval = 0; 2724 int quiet = 0; 2725 char pathstr[1024]; 2726 2727 ccb = cam_getccb(device); 2728 2729 if (ccb == NULL) { 2730 warnx("tagcontrol: error allocating ccb"); 2731 return(1); 2732 } 2733 2734 while ((c = getopt(argc, argv, combinedopt)) != -1) { 2735 switch(c) { 2736 case 'N': 2737 numtags = strtol(optarg, NULL, 0); 2738 if (numtags < 0) { 2739 warnx("tag count %d is < 0", numtags); 2740 retval = 1; 2741 goto tagcontrol_bailout; 2742 } 2743 break; 2744 case 'q': 2745 quiet++; 2746 break; 2747 default: 2748 break; 2749 } 2750 } 2751 2752 cam_path_string(device, pathstr, sizeof(pathstr)); 2753 2754 if (numtags >= 0) { 2755 bzero(&(&ccb->ccb_h)[1], 2756 sizeof(struct ccb_relsim) - sizeof(struct ccb_hdr)); 2757 ccb->ccb_h.func_code = XPT_REL_SIMQ; 2758 ccb->crs.release_flags = RELSIM_ADJUST_OPENINGS; 2759 ccb->crs.openings = numtags; 2760 2761 2762 if (cam_send_ccb(device, ccb) < 0) { 2763 perror("error sending XPT_REL_SIMQ CCB"); 2764 retval = 1; 2765 goto tagcontrol_bailout; 2766 } 2767 2768 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 2769 warnx("XPT_REL_SIMQ CCB failed"); 2770 cam_error_print(device, ccb, CAM_ESF_ALL, 2771 CAM_EPF_ALL, stderr); 2772 retval = 1; 2773 goto tagcontrol_bailout; 2774 } 2775 2776 2777 if (quiet == 0) 2778 fprintf(stdout, "%stagged openings now %d\n", 2779 pathstr, ccb->crs.openings); 2780 } 2781 2782 bzero(&(&ccb->ccb_h)[1], 2783 sizeof(struct ccb_getdevstats) - sizeof(struct ccb_hdr)); 2784 2785 ccb->ccb_h.func_code = XPT_GDEV_STATS; 2786 2787 if (cam_send_ccb(device, ccb) < 0) { 2788 perror("error sending XPT_GDEV_STATS CCB"); 2789 retval = 1; 2790 goto tagcontrol_bailout; 2791 } 2792 2793 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 2794 warnx("XPT_GDEV_STATS CCB failed"); 2795 cam_error_print(device, ccb, CAM_ESF_ALL, 2796 CAM_EPF_ALL, stderr); 2797 retval = 1; 2798 goto tagcontrol_bailout; 2799 } 2800 2801 if (arglist & CAM_ARG_VERBOSE) { 2802 fprintf(stdout, "%s", pathstr); 2803 fprintf(stdout, "dev_openings %d\n", ccb->cgds.dev_openings); 2804 fprintf(stdout, "%s", pathstr); 2805 fprintf(stdout, "dev_active %d\n", ccb->cgds.dev_active); 2806 fprintf(stdout, "%s", pathstr); 2807 fprintf(stdout, "devq_openings %d\n", ccb->cgds.devq_openings); 2808 fprintf(stdout, "%s", pathstr); 2809 fprintf(stdout, "devq_queued %d\n", ccb->cgds.devq_queued); 2810 fprintf(stdout, "%s", pathstr); 2811 fprintf(stdout, "held %d\n", ccb->cgds.held); 2812 fprintf(stdout, "%s", pathstr); 2813 fprintf(stdout, "mintags %d\n", ccb->cgds.mintags); 2814 fprintf(stdout, "%s", pathstr); 2815 fprintf(stdout, "maxtags %d\n", ccb->cgds.maxtags); 2816 } else { 2817 if (quiet == 0) { 2818 fprintf(stdout, "%s", pathstr); 2819 fprintf(stdout, "device openings: "); 2820 } 2821 fprintf(stdout, "%d\n", ccb->cgds.dev_openings + 2822 ccb->cgds.dev_active); 2823 } 2824 2825 tagcontrol_bailout: 2826 2827 cam_freeccb(ccb); 2828 return(retval); 2829 } 2830 2831 static void 2832 cts_print(struct cam_device *device, struct ccb_trans_settings *cts) 2833 { 2834 char pathstr[1024]; 2835 2836 cam_path_string(device, pathstr, sizeof(pathstr)); 2837 2838 if (cts->transport == XPORT_SPI) { 2839 struct ccb_trans_settings_spi *spi = 2840 &cts->xport_specific.spi; 2841 2842 if ((spi->valid & CTS_SPI_VALID_SYNC_RATE) != 0) { 2843 2844 fprintf(stdout, "%ssync parameter: %d\n", pathstr, 2845 spi->sync_period); 2846 2847 if (spi->sync_offset != 0) { 2848 u_int freq; 2849 2850 freq = scsi_calc_syncsrate(spi->sync_period); 2851 fprintf(stdout, "%sfrequency: %d.%03dMHz\n", 2852 pathstr, freq / 1000, freq % 1000); 2853 } 2854 } 2855 2856 if (spi->valid & CTS_SPI_VALID_SYNC_OFFSET) { 2857 fprintf(stdout, "%soffset: %d\n", pathstr, 2858 spi->sync_offset); 2859 } 2860 2861 if (spi->valid & CTS_SPI_VALID_BUS_WIDTH) { 2862 fprintf(stdout, "%sbus width: %d bits\n", pathstr, 2863 (0x01 << spi->bus_width) * 8); 2864 } 2865 2866 if (spi->valid & CTS_SPI_VALID_DISC) { 2867 fprintf(stdout, "%sdisconnection is %s\n", pathstr, 2868 (spi->flags & CTS_SPI_FLAGS_DISC_ENB) ? 2869 "enabled" : "disabled"); 2870 } 2871 } 2872 if (cts->transport == XPORT_ATA) { 2873 struct ccb_trans_settings_ata *ata = 2874 &cts->xport_specific.ata; 2875 2876 if ((ata->valid & CTS_ATA_VALID_MODE) != 0) { 2877 fprintf(stdout, "%sATA mode: %s\n", pathstr, 2878 ata_mode2string(ata->mode)); 2879 } 2880 if ((ata->valid & CTS_ATA_VALID_ATAPI) != 0) { 2881 fprintf(stdout, "%sATAPI packet length: %d\n", pathstr, 2882 ata->atapi); 2883 } 2884 if ((ata->valid & CTS_ATA_VALID_BYTECOUNT) != 0) { 2885 fprintf(stdout, "%sPIO transaction length: %d\n", 2886 pathstr, ata->bytecount); 2887 } 2888 } 2889 if (cts->transport == XPORT_SATA) { 2890 struct ccb_trans_settings_sata *sata = 2891 &cts->xport_specific.sata; 2892 2893 if ((sata->valid & CTS_SATA_VALID_REVISION) != 0) { 2894 fprintf(stdout, "%sSATA revision: %d.x\n", pathstr, 2895 sata->revision); 2896 } 2897 if ((sata->valid & CTS_SATA_VALID_MODE) != 0) { 2898 fprintf(stdout, "%sATA mode: %s\n", pathstr, 2899 ata_mode2string(sata->mode)); 2900 } 2901 if ((sata->valid & CTS_SATA_VALID_ATAPI) != 0) { 2902 fprintf(stdout, "%sATAPI packet length: %d\n", pathstr, 2903 sata->atapi); 2904 } 2905 if ((sata->valid & CTS_SATA_VALID_BYTECOUNT) != 0) { 2906 fprintf(stdout, "%sPIO transaction length: %d\n", 2907 pathstr, sata->bytecount); 2908 } 2909 if ((sata->valid & CTS_SATA_VALID_PM) != 0) { 2910 fprintf(stdout, "%sPMP presence: %d\n", pathstr, 2911 sata->pm_present); 2912 } 2913 if ((sata->valid & CTS_SATA_VALID_TAGS) != 0) { 2914 fprintf(stdout, "%sNumber of tags: %d\n", pathstr, 2915 sata->tags); 2916 } 2917 if ((sata->valid & CTS_SATA_VALID_CAPS) != 0) { 2918 fprintf(stdout, "%sSATA capabilities: %08x\n", pathstr, 2919 sata->caps); 2920 } 2921 } 2922 if (cts->protocol == PROTO_SCSI) { 2923 struct ccb_trans_settings_scsi *scsi= 2924 &cts->proto_specific.scsi; 2925 2926 if (scsi->valid & CTS_SCSI_VALID_TQ) { 2927 fprintf(stdout, "%stagged queueing is %s\n", pathstr, 2928 (scsi->flags & CTS_SCSI_FLAGS_TAG_ENB) ? 2929 "enabled" : "disabled"); 2930 } 2931 } 2932 2933 } 2934 2935 /* 2936 * Get a path inquiry CCB for the specified device. 2937 */ 2938 static int 2939 get_cpi(struct cam_device *device, struct ccb_pathinq *cpi) 2940 { 2941 union ccb *ccb; 2942 int retval = 0; 2943 2944 ccb = cam_getccb(device); 2945 if (ccb == NULL) { 2946 warnx("get_cpi: couldn't allocate CCB"); 2947 return(1); 2948 } 2949 bzero(&(&ccb->ccb_h)[1], 2950 sizeof(struct ccb_pathinq) - sizeof(struct ccb_hdr)); 2951 ccb->ccb_h.func_code = XPT_PATH_INQ; 2952 if (cam_send_ccb(device, ccb) < 0) { 2953 warn("get_cpi: error sending Path Inquiry CCB"); 2954 if (arglist & CAM_ARG_VERBOSE) 2955 cam_error_print(device, ccb, CAM_ESF_ALL, 2956 CAM_EPF_ALL, stderr); 2957 retval = 1; 2958 goto get_cpi_bailout; 2959 } 2960 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 2961 if (arglist & CAM_ARG_VERBOSE) 2962 cam_error_print(device, ccb, CAM_ESF_ALL, 2963 CAM_EPF_ALL, stderr); 2964 retval = 1; 2965 goto get_cpi_bailout; 2966 } 2967 bcopy(&ccb->cpi, cpi, sizeof(struct ccb_pathinq)); 2968 2969 get_cpi_bailout: 2970 cam_freeccb(ccb); 2971 return(retval); 2972 } 2973 2974 /* 2975 * Get a get device CCB for the specified device. 2976 */ 2977 static int 2978 get_cgd(struct cam_device *device, struct ccb_getdev *cgd) 2979 { 2980 union ccb *ccb; 2981 int retval = 0; 2982 2983 ccb = cam_getccb(device); 2984 if (ccb == NULL) { 2985 warnx("get_cgd: couldn't allocate CCB"); 2986 return(1); 2987 } 2988 bzero(&(&ccb->ccb_h)[1], 2989 sizeof(struct ccb_pathinq) - sizeof(struct ccb_hdr)); 2990 ccb->ccb_h.func_code = XPT_GDEV_TYPE; 2991 if (cam_send_ccb(device, ccb) < 0) { 2992 warn("get_cgd: error sending Path Inquiry CCB"); 2993 if (arglist & CAM_ARG_VERBOSE) 2994 cam_error_print(device, ccb, CAM_ESF_ALL, 2995 CAM_EPF_ALL, stderr); 2996 retval = 1; 2997 goto get_cgd_bailout; 2998 } 2999 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 3000 if (arglist & CAM_ARG_VERBOSE) 3001 cam_error_print(device, ccb, CAM_ESF_ALL, 3002 CAM_EPF_ALL, stderr); 3003 retval = 1; 3004 goto get_cgd_bailout; 3005 } 3006 bcopy(&ccb->cgd, cgd, sizeof(struct ccb_getdev)); 3007 3008 get_cgd_bailout: 3009 cam_freeccb(ccb); 3010 return(retval); 3011 } 3012 3013 static void 3014 cpi_print(struct ccb_pathinq *cpi) 3015 { 3016 char adapter_str[1024]; 3017 int i; 3018 3019 snprintf(adapter_str, sizeof(adapter_str), 3020 "%s%d:", cpi->dev_name, cpi->unit_number); 3021 3022 fprintf(stdout, "%s SIM/HBA version: %d\n", adapter_str, 3023 cpi->version_num); 3024 3025 for (i = 1; i < 0xff; i = i << 1) { 3026 const char *str; 3027 3028 if ((i & cpi->hba_inquiry) == 0) 3029 continue; 3030 3031 fprintf(stdout, "%s supports ", adapter_str); 3032 3033 switch(i) { 3034 case PI_MDP_ABLE: 3035 str = "MDP message"; 3036 break; 3037 case PI_WIDE_32: 3038 str = "32 bit wide SCSI"; 3039 break; 3040 case PI_WIDE_16: 3041 str = "16 bit wide SCSI"; 3042 break; 3043 case PI_SDTR_ABLE: 3044 str = "SDTR message"; 3045 break; 3046 case PI_LINKED_CDB: 3047 str = "linked CDBs"; 3048 break; 3049 case PI_TAG_ABLE: 3050 str = "tag queue messages"; 3051 break; 3052 case PI_SOFT_RST: 3053 str = "soft reset alternative"; 3054 break; 3055 case PI_SATAPM: 3056 str = "SATA Port Multiplier"; 3057 break; 3058 default: 3059 str = "unknown PI bit set"; 3060 break; 3061 } 3062 fprintf(stdout, "%s\n", str); 3063 } 3064 3065 for (i = 1; i < 0xff; i = i << 1) { 3066 const char *str; 3067 3068 if ((i & cpi->hba_misc) == 0) 3069 continue; 3070 3071 fprintf(stdout, "%s ", adapter_str); 3072 3073 switch(i) { 3074 case PIM_SCANHILO: 3075 str = "bus scans from high ID to low ID"; 3076 break; 3077 case PIM_NOREMOVE: 3078 str = "removable devices not included in scan"; 3079 break; 3080 case PIM_NOINITIATOR: 3081 str = "initiator role not supported"; 3082 break; 3083 case PIM_NOBUSRESET: 3084 str = "user has disabled initial BUS RESET or" 3085 " controller is in target/mixed mode"; 3086 break; 3087 case PIM_NO_6_BYTE: 3088 str = "do not send 6-byte commands"; 3089 break; 3090 case PIM_SEQSCAN: 3091 str = "scan bus sequentially"; 3092 break; 3093 default: 3094 str = "unknown PIM bit set"; 3095 break; 3096 } 3097 fprintf(stdout, "%s\n", str); 3098 } 3099 3100 for (i = 1; i < 0xff; i = i << 1) { 3101 const char *str; 3102 3103 if ((i & cpi->target_sprt) == 0) 3104 continue; 3105 3106 fprintf(stdout, "%s supports ", adapter_str); 3107 switch(i) { 3108 case PIT_PROCESSOR: 3109 str = "target mode processor mode"; 3110 break; 3111 case PIT_PHASE: 3112 str = "target mode phase cog. mode"; 3113 break; 3114 case PIT_DISCONNECT: 3115 str = "disconnects in target mode"; 3116 break; 3117 case PIT_TERM_IO: 3118 str = "terminate I/O message in target mode"; 3119 break; 3120 case PIT_GRP_6: 3121 str = "group 6 commands in target mode"; 3122 break; 3123 case PIT_GRP_7: 3124 str = "group 7 commands in target mode"; 3125 break; 3126 default: 3127 str = "unknown PIT bit set"; 3128 break; 3129 } 3130 3131 fprintf(stdout, "%s\n", str); 3132 } 3133 fprintf(stdout, "%s HBA engine count: %d\n", adapter_str, 3134 cpi->hba_eng_cnt); 3135 fprintf(stdout, "%s maximum target: %d\n", adapter_str, 3136 cpi->max_target); 3137 fprintf(stdout, "%s maximum LUN: %d\n", adapter_str, 3138 cpi->max_lun); 3139 fprintf(stdout, "%s highest path ID in subsystem: %d\n", 3140 adapter_str, cpi->hpath_id); 3141 fprintf(stdout, "%s initiator ID: %d\n", adapter_str, 3142 cpi->initiator_id); 3143 fprintf(stdout, "%s SIM vendor: %s\n", adapter_str, cpi->sim_vid); 3144 fprintf(stdout, "%s HBA vendor: %s\n", adapter_str, cpi->hba_vid); 3145 fprintf(stdout, "%s HBA vendor ID: 0x%04x\n", 3146 adapter_str, cpi->hba_vendor); 3147 fprintf(stdout, "%s HBA device ID: 0x%04x\n", 3148 adapter_str, cpi->hba_device); 3149 fprintf(stdout, "%s HBA subvendor ID: 0x%04x\n", 3150 adapter_str, cpi->hba_subvendor); 3151 fprintf(stdout, "%s HBA subdevice ID: 0x%04x\n", 3152 adapter_str, cpi->hba_subdevice); 3153 fprintf(stdout, "%s bus ID: %d\n", adapter_str, cpi->bus_id); 3154 fprintf(stdout, "%s base transfer speed: ", adapter_str); 3155 if (cpi->base_transfer_speed > 1000) 3156 fprintf(stdout, "%d.%03dMB/sec\n", 3157 cpi->base_transfer_speed / 1000, 3158 cpi->base_transfer_speed % 1000); 3159 else 3160 fprintf(stdout, "%dKB/sec\n", 3161 (cpi->base_transfer_speed % 1000) * 1000); 3162 fprintf(stdout, "%s maximum transfer size: %u bytes\n", 3163 adapter_str, cpi->maxio); 3164 } 3165 3166 static int 3167 get_print_cts(struct cam_device *device, int user_settings, int quiet, 3168 struct ccb_trans_settings *cts) 3169 { 3170 int retval; 3171 union ccb *ccb; 3172 3173 retval = 0; 3174 ccb = cam_getccb(device); 3175 3176 if (ccb == NULL) { 3177 warnx("get_print_cts: error allocating ccb"); 3178 return(1); 3179 } 3180 3181 bzero(&(&ccb->ccb_h)[1], 3182 sizeof(struct ccb_trans_settings) - sizeof(struct ccb_hdr)); 3183 3184 ccb->ccb_h.func_code = XPT_GET_TRAN_SETTINGS; 3185 3186 if (user_settings == 0) 3187 ccb->cts.type = CTS_TYPE_CURRENT_SETTINGS; 3188 else 3189 ccb->cts.type = CTS_TYPE_USER_SETTINGS; 3190 3191 if (cam_send_ccb(device, ccb) < 0) { 3192 perror("error sending XPT_GET_TRAN_SETTINGS CCB"); 3193 if (arglist & CAM_ARG_VERBOSE) 3194 cam_error_print(device, ccb, CAM_ESF_ALL, 3195 CAM_EPF_ALL, stderr); 3196 retval = 1; 3197 goto get_print_cts_bailout; 3198 } 3199 3200 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 3201 warnx("XPT_GET_TRANS_SETTINGS CCB failed"); 3202 if (arglist & CAM_ARG_VERBOSE) 3203 cam_error_print(device, ccb, CAM_ESF_ALL, 3204 CAM_EPF_ALL, stderr); 3205 retval = 1; 3206 goto get_print_cts_bailout; 3207 } 3208 3209 if (quiet == 0) 3210 cts_print(device, &ccb->cts); 3211 3212 if (cts != NULL) 3213 bcopy(&ccb->cts, cts, sizeof(struct ccb_trans_settings)); 3214 3215 get_print_cts_bailout: 3216 3217 cam_freeccb(ccb); 3218 3219 return(retval); 3220 } 3221 3222 static int 3223 ratecontrol(struct cam_device *device, int retry_count, int timeout, 3224 int argc, char **argv, char *combinedopt) 3225 { 3226 int c; 3227 union ccb *ccb; 3228 int user_settings = 0; 3229 int retval = 0; 3230 int disc_enable = -1, tag_enable = -1; 3231 int mode = -1; 3232 int offset = -1; 3233 double syncrate = -1; 3234 int bus_width = -1; 3235 int quiet = 0; 3236 int change_settings = 0, send_tur = 0; 3237 struct ccb_pathinq cpi; 3238 3239 ccb = cam_getccb(device); 3240 if (ccb == NULL) { 3241 warnx("ratecontrol: error allocating ccb"); 3242 return(1); 3243 } 3244 while ((c = getopt(argc, argv, combinedopt)) != -1) { 3245 switch(c){ 3246 case 'a': 3247 send_tur = 1; 3248 break; 3249 case 'c': 3250 user_settings = 0; 3251 break; 3252 case 'D': 3253 if (strncasecmp(optarg, "enable", 6) == 0) 3254 disc_enable = 1; 3255 else if (strncasecmp(optarg, "disable", 7) == 0) 3256 disc_enable = 0; 3257 else { 3258 warnx("-D argument \"%s\" is unknown", optarg); 3259 retval = 1; 3260 goto ratecontrol_bailout; 3261 } 3262 change_settings = 1; 3263 break; 3264 case 'M': 3265 mode = ata_string2mode(optarg); 3266 if (mode < 0) { 3267 warnx("unknown mode '%s'", optarg); 3268 retval = 1; 3269 goto ratecontrol_bailout; 3270 } 3271 change_settings = 1; 3272 break; 3273 case 'O': 3274 offset = strtol(optarg, NULL, 0); 3275 if (offset < 0) { 3276 warnx("offset value %d is < 0", offset); 3277 retval = 1; 3278 goto ratecontrol_bailout; 3279 } 3280 change_settings = 1; 3281 break; 3282 case 'q': 3283 quiet++; 3284 break; 3285 case 'R': 3286 syncrate = atof(optarg); 3287 if (syncrate < 0) { 3288 warnx("sync rate %f is < 0", syncrate); 3289 retval = 1; 3290 goto ratecontrol_bailout; 3291 } 3292 change_settings = 1; 3293 break; 3294 case 'T': 3295 if (strncasecmp(optarg, "enable", 6) == 0) 3296 tag_enable = 1; 3297 else if (strncasecmp(optarg, "disable", 7) == 0) 3298 tag_enable = 0; 3299 else { 3300 warnx("-T argument \"%s\" is unknown", optarg); 3301 retval = 1; 3302 goto ratecontrol_bailout; 3303 } 3304 change_settings = 1; 3305 break; 3306 case 'U': 3307 user_settings = 1; 3308 break; 3309 case 'W': 3310 bus_width = strtol(optarg, NULL, 0); 3311 if (bus_width < 0) { 3312 warnx("bus width %d is < 0", bus_width); 3313 retval = 1; 3314 goto ratecontrol_bailout; 3315 } 3316 change_settings = 1; 3317 break; 3318 default: 3319 break; 3320 } 3321 } 3322 bzero(&(&ccb->ccb_h)[1], 3323 sizeof(struct ccb_pathinq) - sizeof(struct ccb_hdr)); 3324 /* 3325 * Grab path inquiry information, so we can determine whether 3326 * or not the initiator is capable of the things that the user 3327 * requests. 3328 */ 3329 ccb->ccb_h.func_code = XPT_PATH_INQ; 3330 if (cam_send_ccb(device, ccb) < 0) { 3331 perror("error sending XPT_PATH_INQ CCB"); 3332 if (arglist & CAM_ARG_VERBOSE) { 3333 cam_error_print(device, ccb, CAM_ESF_ALL, 3334 CAM_EPF_ALL, stderr); 3335 } 3336 retval = 1; 3337 goto ratecontrol_bailout; 3338 } 3339 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 3340 warnx("XPT_PATH_INQ CCB failed"); 3341 if (arglist & CAM_ARG_VERBOSE) { 3342 cam_error_print(device, ccb, CAM_ESF_ALL, 3343 CAM_EPF_ALL, stderr); 3344 } 3345 retval = 1; 3346 goto ratecontrol_bailout; 3347 } 3348 bcopy(&ccb->cpi, &cpi, sizeof(struct ccb_pathinq)); 3349 bzero(&(&ccb->ccb_h)[1], 3350 sizeof(struct ccb_trans_settings) - sizeof(struct ccb_hdr)); 3351 if (quiet == 0) { 3352 fprintf(stdout, "%s parameters:\n", 3353 user_settings ? "User" : "Current"); 3354 } 3355 retval = get_print_cts(device, user_settings, quiet, &ccb->cts); 3356 if (retval != 0) 3357 goto ratecontrol_bailout; 3358 3359 if (arglist & CAM_ARG_VERBOSE) 3360 cpi_print(&cpi); 3361 3362 if (change_settings) { 3363 int didsettings = 0; 3364 struct ccb_trans_settings_spi *spi = NULL; 3365 struct ccb_trans_settings_ata *ata = NULL; 3366 struct ccb_trans_settings_sata *sata = NULL; 3367 struct ccb_trans_settings_scsi *scsi = NULL; 3368 3369 if (ccb->cts.transport == XPORT_SPI) 3370 spi = &ccb->cts.xport_specific.spi; 3371 if (ccb->cts.transport == XPORT_ATA) 3372 ata = &ccb->cts.xport_specific.ata; 3373 if (ccb->cts.transport == XPORT_SATA) 3374 sata = &ccb->cts.xport_specific.sata; 3375 if (ccb->cts.protocol == PROTO_SCSI) 3376 scsi = &ccb->cts.proto_specific.scsi; 3377 ccb->cts.xport_specific.valid = 0; 3378 ccb->cts.proto_specific.valid = 0; 3379 if (spi && disc_enable != -1) { 3380 spi->valid |= CTS_SPI_VALID_DISC; 3381 if (disc_enable == 0) 3382 spi->flags &= ~CTS_SPI_FLAGS_DISC_ENB; 3383 else 3384 spi->flags |= CTS_SPI_FLAGS_DISC_ENB; 3385 } 3386 if (scsi && tag_enable != -1) { 3387 if ((cpi.hba_inquiry & PI_TAG_ABLE) == 0) { 3388 warnx("HBA does not support tagged queueing, " 3389 "so you cannot modify tag settings"); 3390 retval = 1; 3391 goto ratecontrol_bailout; 3392 } 3393 scsi->valid |= CTS_SCSI_VALID_TQ; 3394 if (tag_enable == 0) 3395 scsi->flags &= ~CTS_SCSI_FLAGS_TAG_ENB; 3396 else 3397 scsi->flags |= CTS_SCSI_FLAGS_TAG_ENB; 3398 didsettings++; 3399 } 3400 if (spi && offset != -1) { 3401 if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) { 3402 warnx("HBA is not capable of changing offset"); 3403 retval = 1; 3404 goto ratecontrol_bailout; 3405 } 3406 spi->valid |= CTS_SPI_VALID_SYNC_OFFSET; 3407 spi->sync_offset = offset; 3408 didsettings++; 3409 } 3410 if (spi && syncrate != -1) { 3411 int prelim_sync_period; 3412 u_int freq; 3413 3414 if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) { 3415 warnx("HBA is not capable of changing " 3416 "transfer rates"); 3417 retval = 1; 3418 goto ratecontrol_bailout; 3419 } 3420 spi->valid |= CTS_SPI_VALID_SYNC_RATE; 3421 /* 3422 * The sync rate the user gives us is in MHz. 3423 * We need to translate it into KHz for this 3424 * calculation. 3425 */ 3426 syncrate *= 1000; 3427 /* 3428 * Next, we calculate a "preliminary" sync period 3429 * in tenths of a nanosecond. 3430 */ 3431 if (syncrate == 0) 3432 prelim_sync_period = 0; 3433 else 3434 prelim_sync_period = 10000000 / syncrate; 3435 spi->sync_period = 3436 scsi_calc_syncparam(prelim_sync_period); 3437 freq = scsi_calc_syncsrate(spi->sync_period); 3438 didsettings++; 3439 } 3440 if (sata && syncrate != -1) { 3441 if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) { 3442 warnx("HBA is not capable of changing " 3443 "transfer rates"); 3444 retval = 1; 3445 goto ratecontrol_bailout; 3446 } 3447 sata->revision = ata_speed2revision(syncrate * 100); 3448 if (sata->revision < 0) { 3449 warnx("Invalid rate %f", syncrate); 3450 retval = 1; 3451 goto ratecontrol_bailout; 3452 } 3453 sata->valid |= CTS_SATA_VALID_REVISION; 3454 didsettings++; 3455 } 3456 if ((ata || sata) && mode != -1) { 3457 if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) { 3458 warnx("HBA is not capable of changing " 3459 "transfer rates"); 3460 retval = 1; 3461 goto ratecontrol_bailout; 3462 } 3463 if (ata) { 3464 ata->mode = mode; 3465 ata->valid |= CTS_ATA_VALID_MODE; 3466 } else { 3467 sata->mode = mode; 3468 sata->valid |= CTS_SATA_VALID_MODE; 3469 } 3470 didsettings++; 3471 } 3472 /* 3473 * The bus_width argument goes like this: 3474 * 0 == 8 bit 3475 * 1 == 16 bit 3476 * 2 == 32 bit 3477 * Therefore, if you shift the number of bits given on the 3478 * command line right by 4, you should get the correct 3479 * number. 3480 */ 3481 if (spi && bus_width != -1) { 3482 /* 3483 * We might as well validate things here with a 3484 * decipherable error message, rather than what 3485 * will probably be an indecipherable error message 3486 * by the time it gets back to us. 3487 */ 3488 if ((bus_width == 16) 3489 && ((cpi.hba_inquiry & PI_WIDE_16) == 0)) { 3490 warnx("HBA does not support 16 bit bus width"); 3491 retval = 1; 3492 goto ratecontrol_bailout; 3493 } else if ((bus_width == 32) 3494 && ((cpi.hba_inquiry & PI_WIDE_32) == 0)) { 3495 warnx("HBA does not support 32 bit bus width"); 3496 retval = 1; 3497 goto ratecontrol_bailout; 3498 } else if ((bus_width != 8) 3499 && (bus_width != 16) 3500 && (bus_width != 32)) { 3501 warnx("Invalid bus width %d", bus_width); 3502 retval = 1; 3503 goto ratecontrol_bailout; 3504 } 3505 spi->valid |= CTS_SPI_VALID_BUS_WIDTH; 3506 spi->bus_width = bus_width >> 4; 3507 didsettings++; 3508 } 3509 if (didsettings == 0) { 3510 goto ratecontrol_bailout; 3511 } 3512 if (!user_settings && (ata || sata)) { 3513 warnx("You can modify only user settings for ATA/SATA"); 3514 retval = 1; 3515 goto ratecontrol_bailout; 3516 } 3517 ccb->ccb_h.func_code = XPT_SET_TRAN_SETTINGS; 3518 if (cam_send_ccb(device, ccb) < 0) { 3519 perror("error sending XPT_SET_TRAN_SETTINGS CCB"); 3520 if (arglist & CAM_ARG_VERBOSE) { 3521 cam_error_print(device, ccb, CAM_ESF_ALL, 3522 CAM_EPF_ALL, stderr); 3523 } 3524 retval = 1; 3525 goto ratecontrol_bailout; 3526 } 3527 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 3528 warnx("XPT_SET_TRANS_SETTINGS CCB failed"); 3529 if (arglist & CAM_ARG_VERBOSE) { 3530 cam_error_print(device, ccb, CAM_ESF_ALL, 3531 CAM_EPF_ALL, stderr); 3532 } 3533 retval = 1; 3534 goto ratecontrol_bailout; 3535 } 3536 } 3537 if (send_tur) { 3538 retval = testunitready(device, retry_count, timeout, 3539 (arglist & CAM_ARG_VERBOSE) ? 0 : 1); 3540 /* 3541 * If the TUR didn't succeed, just bail. 3542 */ 3543 if (retval != 0) { 3544 if (quiet == 0) 3545 fprintf(stderr, "Test Unit Ready failed\n"); 3546 goto ratecontrol_bailout; 3547 } 3548 /* 3549 * If the user wants things quiet, there's no sense in 3550 * getting the transfer settings, if we're not going 3551 * to print them. 3552 */ 3553 if (quiet != 0) 3554 goto ratecontrol_bailout; 3555 fprintf(stdout, "New parameters:\n"); 3556 retval = get_print_cts(device, user_settings, 0, NULL); 3557 } 3558 3559 ratecontrol_bailout: 3560 cam_freeccb(ccb); 3561 return(retval); 3562 } 3563 3564 static int 3565 scsiformat(struct cam_device *device, int argc, char **argv, 3566 char *combinedopt, int retry_count, int timeout) 3567 { 3568 union ccb *ccb; 3569 int c; 3570 int ycount = 0, quiet = 0; 3571 int error = 0, response = 0, retval = 0; 3572 int use_timeout = 10800 * 1000; 3573 int immediate = 1; 3574 struct format_defect_list_header fh; 3575 u_int8_t *data_ptr = NULL; 3576 u_int32_t dxfer_len = 0; 3577 u_int8_t byte2 = 0; 3578 int num_warnings = 0; 3579 int reportonly = 0; 3580 3581 ccb = cam_getccb(device); 3582 3583 if (ccb == NULL) { 3584 warnx("scsiformat: error allocating ccb"); 3585 return(1); 3586 } 3587 3588 bzero(&(&ccb->ccb_h)[1], 3589 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr)); 3590 3591 while ((c = getopt(argc, argv, combinedopt)) != -1) { 3592 switch(c) { 3593 case 'q': 3594 quiet++; 3595 break; 3596 case 'r': 3597 reportonly = 1; 3598 break; 3599 case 'w': 3600 immediate = 0; 3601 break; 3602 case 'y': 3603 ycount++; 3604 break; 3605 } 3606 } 3607 3608 if (reportonly) 3609 goto doreport; 3610 3611 if (quiet == 0) { 3612 fprintf(stdout, "You are about to REMOVE ALL DATA from the " 3613 "following device:\n"); 3614 3615 error = scsidoinquiry(device, argc, argv, combinedopt, 3616 retry_count, timeout); 3617 3618 if (error != 0) { 3619 warnx("scsiformat: error sending inquiry"); 3620 goto scsiformat_bailout; 3621 } 3622 } 3623 3624 if (ycount == 0) { 3625 3626 do { 3627 char str[1024]; 3628 3629 fprintf(stdout, "Are you SURE you want to do " 3630 "this? (yes/no) "); 3631 3632 if (fgets(str, sizeof(str), stdin) != NULL) { 3633 3634 if (strncasecmp(str, "yes", 3) == 0) 3635 response = 1; 3636 else if (strncasecmp(str, "no", 2) == 0) 3637 response = -1; 3638 else { 3639 fprintf(stdout, "Please answer" 3640 " \"yes\" or \"no\"\n"); 3641 } 3642 } 3643 } while (response == 0); 3644 3645 if (response == -1) { 3646 error = 1; 3647 goto scsiformat_bailout; 3648 } 3649 } 3650 3651 if (timeout != 0) 3652 use_timeout = timeout; 3653 3654 if (quiet == 0) { 3655 fprintf(stdout, "Current format timeout is %d seconds\n", 3656 use_timeout / 1000); 3657 } 3658 3659 /* 3660 * If the user hasn't disabled questions and didn't specify a 3661 * timeout on the command line, ask them if they want the current 3662 * timeout. 3663 */ 3664 if ((ycount == 0) 3665 && (timeout == 0)) { 3666 char str[1024]; 3667 int new_timeout = 0; 3668 3669 fprintf(stdout, "Enter new timeout in seconds or press\n" 3670 "return to keep the current timeout [%d] ", 3671 use_timeout / 1000); 3672 3673 if (fgets(str, sizeof(str), stdin) != NULL) { 3674 if (str[0] != '\0') 3675 new_timeout = atoi(str); 3676 } 3677 3678 if (new_timeout != 0) { 3679 use_timeout = new_timeout * 1000; 3680 fprintf(stdout, "Using new timeout value %d\n", 3681 use_timeout / 1000); 3682 } 3683 } 3684 3685 /* 3686 * Keep this outside the if block below to silence any unused 3687 * variable warnings. 3688 */ 3689 bzero(&fh, sizeof(fh)); 3690 3691 /* 3692 * If we're in immediate mode, we've got to include the format 3693 * header 3694 */ 3695 if (immediate != 0) { 3696 fh.byte2 = FU_DLH_IMMED; 3697 data_ptr = (u_int8_t *)&fh; 3698 dxfer_len = sizeof(fh); 3699 byte2 = FU_FMT_DATA; 3700 } else if (quiet == 0) { 3701 fprintf(stdout, "Formatting..."); 3702 fflush(stdout); 3703 } 3704 3705 scsi_format_unit(&ccb->csio, 3706 /* retries */ retry_count, 3707 /* cbfcnp */ NULL, 3708 /* tag_action */ MSG_SIMPLE_Q_TAG, 3709 /* byte2 */ byte2, 3710 /* ileave */ 0, 3711 /* data_ptr */ data_ptr, 3712 /* dxfer_len */ dxfer_len, 3713 /* sense_len */ SSD_FULL_SIZE, 3714 /* timeout */ use_timeout); 3715 3716 /* Disable freezing the device queue */ 3717 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 3718 3719 if (arglist & CAM_ARG_ERR_RECOVER) 3720 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER; 3721 3722 if (((retval = cam_send_ccb(device, ccb)) < 0) 3723 || ((immediate == 0) 3724 && ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP))) { 3725 const char errstr[] = "error sending format command"; 3726 3727 if (retval < 0) 3728 warn(errstr); 3729 else 3730 warnx(errstr); 3731 3732 if (arglist & CAM_ARG_VERBOSE) { 3733 cam_error_print(device, ccb, CAM_ESF_ALL, 3734 CAM_EPF_ALL, stderr); 3735 } 3736 error = 1; 3737 goto scsiformat_bailout; 3738 } 3739 3740 /* 3741 * If we ran in non-immediate mode, we already checked for errors 3742 * above and printed out any necessary information. If we're in 3743 * immediate mode, we need to loop through and get status 3744 * information periodically. 3745 */ 3746 if (immediate == 0) { 3747 if (quiet == 0) { 3748 fprintf(stdout, "Format Complete\n"); 3749 } 3750 goto scsiformat_bailout; 3751 } 3752 3753 doreport: 3754 do { 3755 cam_status status; 3756 3757 bzero(&(&ccb->ccb_h)[1], 3758 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr)); 3759 3760 /* 3761 * There's really no need to do error recovery or 3762 * retries here, since we're just going to sit in a 3763 * loop and wait for the device to finish formatting. 3764 */ 3765 scsi_test_unit_ready(&ccb->csio, 3766 /* retries */ 0, 3767 /* cbfcnp */ NULL, 3768 /* tag_action */ MSG_SIMPLE_Q_TAG, 3769 /* sense_len */ SSD_FULL_SIZE, 3770 /* timeout */ 5000); 3771 3772 /* Disable freezing the device queue */ 3773 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 3774 3775 retval = cam_send_ccb(device, ccb); 3776 3777 /* 3778 * If we get an error from the ioctl, bail out. SCSI 3779 * errors are expected. 3780 */ 3781 if (retval < 0) { 3782 warn("error sending CAMIOCOMMAND ioctl"); 3783 if (arglist & CAM_ARG_VERBOSE) { 3784 cam_error_print(device, ccb, CAM_ESF_ALL, 3785 CAM_EPF_ALL, stderr); 3786 } 3787 error = 1; 3788 goto scsiformat_bailout; 3789 } 3790 3791 status = ccb->ccb_h.status & CAM_STATUS_MASK; 3792 3793 if ((status != CAM_REQ_CMP) 3794 && (status == CAM_SCSI_STATUS_ERROR) 3795 && ((ccb->ccb_h.status & CAM_AUTOSNS_VALID) != 0)) { 3796 struct scsi_sense_data *sense; 3797 int error_code, sense_key, asc, ascq; 3798 3799 sense = &ccb->csio.sense_data; 3800 scsi_extract_sense(sense, &error_code, &sense_key, 3801 &asc, &ascq); 3802 3803 /* 3804 * According to the SCSI-2 and SCSI-3 specs, a 3805 * drive that is in the middle of a format should 3806 * return NOT READY with an ASC of "logical unit 3807 * not ready, format in progress". The sense key 3808 * specific bytes will then be a progress indicator. 3809 */ 3810 if ((sense_key == SSD_KEY_NOT_READY) 3811 && (asc == 0x04) && (ascq == 0x04)) { 3812 if ((sense->extra_len >= 10) 3813 && ((sense->sense_key_spec[0] & 3814 SSD_SCS_VALID) != 0) 3815 && (quiet == 0)) { 3816 int val; 3817 u_int64_t percentage; 3818 3819 val = scsi_2btoul( 3820 &sense->sense_key_spec[1]); 3821 percentage = 10000 * val; 3822 3823 fprintf(stdout, 3824 "\rFormatting: %ju.%02u %% " 3825 "(%d/%d) done", 3826 (uintmax_t)(percentage / 3827 (0x10000 * 100)), 3828 (unsigned)((percentage / 3829 0x10000) % 100), 3830 val, 0x10000); 3831 fflush(stdout); 3832 } else if ((quiet == 0) 3833 && (++num_warnings <= 1)) { 3834 warnx("Unexpected SCSI Sense Key " 3835 "Specific value returned " 3836 "during format:"); 3837 scsi_sense_print(device, &ccb->csio, 3838 stderr); 3839 warnx("Unable to print status " 3840 "information, but format will " 3841 "proceed."); 3842 warnx("will exit when format is " 3843 "complete"); 3844 } 3845 sleep(1); 3846 } else { 3847 warnx("Unexpected SCSI error during format"); 3848 cam_error_print(device, ccb, CAM_ESF_ALL, 3849 CAM_EPF_ALL, stderr); 3850 error = 1; 3851 goto scsiformat_bailout; 3852 } 3853 3854 } else if (status != CAM_REQ_CMP) { 3855 warnx("Unexpected CAM status %#x", status); 3856 if (arglist & CAM_ARG_VERBOSE) 3857 cam_error_print(device, ccb, CAM_ESF_ALL, 3858 CAM_EPF_ALL, stderr); 3859 error = 1; 3860 goto scsiformat_bailout; 3861 } 3862 3863 } while((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP); 3864 3865 if (quiet == 0) 3866 fprintf(stdout, "\nFormat Complete\n"); 3867 3868 scsiformat_bailout: 3869 3870 cam_freeccb(ccb); 3871 3872 return(error); 3873 } 3874 3875 static int 3876 scsireportluns(struct cam_device *device, int argc, char **argv, 3877 char *combinedopt, int retry_count, int timeout) 3878 { 3879 union ccb *ccb; 3880 int c, countonly, lunsonly; 3881 struct scsi_report_luns_data *lundata; 3882 int alloc_len; 3883 uint8_t report_type; 3884 uint32_t list_len, i, j; 3885 int retval; 3886 3887 retval = 0; 3888 lundata = NULL; 3889 report_type = RPL_REPORT_DEFAULT; 3890 ccb = cam_getccb(device); 3891 3892 if (ccb == NULL) { 3893 warnx("%s: error allocating ccb", __func__); 3894 return (1); 3895 } 3896 3897 bzero(&(&ccb->ccb_h)[1], 3898 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr)); 3899 3900 countonly = 0; 3901 lunsonly = 0; 3902 3903 while ((c = getopt(argc, argv, combinedopt)) != -1) { 3904 switch (c) { 3905 case 'c': 3906 countonly++; 3907 break; 3908 case 'l': 3909 lunsonly++; 3910 break; 3911 case 'r': 3912 if (strcasecmp(optarg, "default") == 0) 3913 report_type = RPL_REPORT_DEFAULT; 3914 else if (strcasecmp(optarg, "wellknown") == 0) 3915 report_type = RPL_REPORT_WELLKNOWN; 3916 else if (strcasecmp(optarg, "all") == 0) 3917 report_type = RPL_REPORT_ALL; 3918 else { 3919 warnx("%s: invalid report type \"%s\"", 3920 __func__, optarg); 3921 retval = 1; 3922 goto bailout; 3923 } 3924 break; 3925 default: 3926 break; 3927 } 3928 } 3929 3930 if ((countonly != 0) 3931 && (lunsonly != 0)) { 3932 warnx("%s: you can only specify one of -c or -l", __func__); 3933 retval = 1; 3934 goto bailout; 3935 } 3936 /* 3937 * According to SPC-4, the allocation length must be at least 16 3938 * bytes -- enough for the header and one LUN. 3939 */ 3940 alloc_len = sizeof(*lundata) + 8; 3941 3942 retry: 3943 3944 lundata = malloc(alloc_len); 3945 3946 if (lundata == NULL) { 3947 warn("%s: error mallocing %d bytes", __func__, alloc_len); 3948 retval = 1; 3949 goto bailout; 3950 } 3951 3952 scsi_report_luns(&ccb->csio, 3953 /*retries*/ retry_count, 3954 /*cbfcnp*/ NULL, 3955 /*tag_action*/ MSG_SIMPLE_Q_TAG, 3956 /*select_report*/ report_type, 3957 /*rpl_buf*/ lundata, 3958 /*alloc_len*/ alloc_len, 3959 /*sense_len*/ SSD_FULL_SIZE, 3960 /*timeout*/ timeout ? timeout : 5000); 3961 3962 /* Disable freezing the device queue */ 3963 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 3964 3965 if (arglist & CAM_ARG_ERR_RECOVER) 3966 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER; 3967 3968 if (cam_send_ccb(device, ccb) < 0) { 3969 warn("error sending REPORT LUNS command"); 3970 3971 if (arglist & CAM_ARG_VERBOSE) 3972 cam_error_print(device, ccb, CAM_ESF_ALL, 3973 CAM_EPF_ALL, stderr); 3974 3975 retval = 1; 3976 goto bailout; 3977 } 3978 3979 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 3980 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr); 3981 retval = 1; 3982 goto bailout; 3983 } 3984 3985 3986 list_len = scsi_4btoul(lundata->length); 3987 3988 /* 3989 * If we need to list the LUNs, and our allocation 3990 * length was too short, reallocate and retry. 3991 */ 3992 if ((countonly == 0) 3993 && (list_len > (alloc_len - sizeof(*lundata)))) { 3994 alloc_len = list_len + sizeof(*lundata); 3995 free(lundata); 3996 goto retry; 3997 } 3998 3999 if (lunsonly == 0) 4000 fprintf(stdout, "%u LUN%s found\n", list_len / 8, 4001 ((list_len / 8) > 1) ? "s" : ""); 4002 4003 if (countonly != 0) 4004 goto bailout; 4005 4006 for (i = 0; i < (list_len / 8); i++) { 4007 int no_more; 4008 4009 no_more = 0; 4010 for (j = 0; j < sizeof(lundata->luns[i].lundata); j += 2) { 4011 if (j != 0) 4012 fprintf(stdout, ","); 4013 switch (lundata->luns[i].lundata[j] & 4014 RPL_LUNDATA_ATYP_MASK) { 4015 case RPL_LUNDATA_ATYP_PERIPH: 4016 if ((lundata->luns[i].lundata[j] & 4017 RPL_LUNDATA_PERIPH_BUS_MASK) != 0) 4018 fprintf(stdout, "%d:", 4019 lundata->luns[i].lundata[j] & 4020 RPL_LUNDATA_PERIPH_BUS_MASK); 4021 else if ((j == 0) 4022 && ((lundata->luns[i].lundata[j+2] & 4023 RPL_LUNDATA_PERIPH_BUS_MASK) == 0)) 4024 no_more = 1; 4025 4026 fprintf(stdout, "%d", 4027 lundata->luns[i].lundata[j+1]); 4028 break; 4029 case RPL_LUNDATA_ATYP_FLAT: { 4030 uint8_t tmplun[2]; 4031 tmplun[0] = lundata->luns[i].lundata[j] & 4032 RPL_LUNDATA_FLAT_LUN_MASK; 4033 tmplun[1] = lundata->luns[i].lundata[j+1]; 4034 4035 fprintf(stdout, "%d", scsi_2btoul(tmplun)); 4036 no_more = 1; 4037 break; 4038 } 4039 case RPL_LUNDATA_ATYP_LUN: 4040 fprintf(stdout, "%d:%d:%d", 4041 (lundata->luns[i].lundata[j+1] & 4042 RPL_LUNDATA_LUN_BUS_MASK) >> 5, 4043 lundata->luns[i].lundata[j] & 4044 RPL_LUNDATA_LUN_TARG_MASK, 4045 lundata->luns[i].lundata[j+1] & 4046 RPL_LUNDATA_LUN_LUN_MASK); 4047 break; 4048 case RPL_LUNDATA_ATYP_EXTLUN: { 4049 int field_len, field_len_code, eam_code; 4050 4051 eam_code = lundata->luns[i].lundata[j] & 4052 RPL_LUNDATA_EXT_EAM_MASK; 4053 field_len_code = (lundata->luns[i].lundata[j] & 4054 RPL_LUNDATA_EXT_LEN_MASK) >> 4; 4055 field_len = field_len_code * 2; 4056 4057 if ((eam_code == RPL_LUNDATA_EXT_EAM_WK) 4058 && (field_len_code == 0x00)) { 4059 fprintf(stdout, "%d", 4060 lundata->luns[i].lundata[j+1]); 4061 } else if ((eam_code == 4062 RPL_LUNDATA_EXT_EAM_NOT_SPEC) 4063 && (field_len_code == 0x03)) { 4064 uint8_t tmp_lun[8]; 4065 4066 /* 4067 * This format takes up all 8 bytes. 4068 * If we aren't starting at offset 0, 4069 * that's a bug. 4070 */ 4071 if (j != 0) { 4072 fprintf(stdout, "Invalid " 4073 "offset %d for " 4074 "Extended LUN not " 4075 "specified format", j); 4076 no_more = 1; 4077 break; 4078 } 4079 bzero(tmp_lun, sizeof(tmp_lun)); 4080 bcopy(&lundata->luns[i].lundata[j+1], 4081 &tmp_lun[1], sizeof(tmp_lun) - 1); 4082 fprintf(stdout, "%#jx", 4083 (intmax_t)scsi_8btou64(tmp_lun)); 4084 no_more = 1; 4085 } else { 4086 fprintf(stderr, "Unknown Extended LUN" 4087 "Address method %#x, length " 4088 "code %#x", eam_code, 4089 field_len_code); 4090 no_more = 1; 4091 } 4092 break; 4093 } 4094 default: 4095 fprintf(stderr, "Unknown LUN address method " 4096 "%#x\n", lundata->luns[i].lundata[0] & 4097 RPL_LUNDATA_ATYP_MASK); 4098 break; 4099 } 4100 /* 4101 * For the flat addressing method, there are no 4102 * other levels after it. 4103 */ 4104 if (no_more != 0) 4105 break; 4106 } 4107 fprintf(stdout, "\n"); 4108 } 4109 4110 bailout: 4111 4112 cam_freeccb(ccb); 4113 4114 free(lundata); 4115 4116 return (retval); 4117 } 4118 4119 static int 4120 scsireadcapacity(struct cam_device *device, int argc, char **argv, 4121 char *combinedopt, int retry_count, int timeout) 4122 { 4123 union ccb *ccb; 4124 int blocksizeonly, humanize, numblocks, quiet, sizeonly, baseten; 4125 struct scsi_read_capacity_data rcap; 4126 struct scsi_read_capacity_data_long rcaplong; 4127 uint64_t maxsector; 4128 uint32_t block_len; 4129 int retval; 4130 int c; 4131 4132 blocksizeonly = 0; 4133 humanize = 0; 4134 numblocks = 0; 4135 quiet = 0; 4136 sizeonly = 0; 4137 baseten = 0; 4138 retval = 0; 4139 4140 ccb = cam_getccb(device); 4141 4142 if (ccb == NULL) { 4143 warnx("%s: error allocating ccb", __func__); 4144 return (1); 4145 } 4146 4147 bzero(&(&ccb->ccb_h)[1], 4148 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr)); 4149 4150 while ((c = getopt(argc, argv, combinedopt)) != -1) { 4151 switch (c) { 4152 case 'b': 4153 blocksizeonly++; 4154 break; 4155 case 'h': 4156 humanize++; 4157 baseten = 0; 4158 break; 4159 case 'H': 4160 humanize++; 4161 baseten++; 4162 break; 4163 case 'N': 4164 numblocks++; 4165 break; 4166 case 'q': 4167 quiet++; 4168 break; 4169 case 's': 4170 sizeonly++; 4171 break; 4172 default: 4173 break; 4174 } 4175 } 4176 4177 if ((blocksizeonly != 0) 4178 && (numblocks != 0)) { 4179 warnx("%s: you can only specify one of -b or -N", __func__); 4180 retval = 1; 4181 goto bailout; 4182 } 4183 4184 if ((blocksizeonly != 0) 4185 && (sizeonly != 0)) { 4186 warnx("%s: you can only specify one of -b or -s", __func__); 4187 retval = 1; 4188 goto bailout; 4189 } 4190 4191 if ((humanize != 0) 4192 && (quiet != 0)) { 4193 warnx("%s: you can only specify one of -h/-H or -q", __func__); 4194 retval = 1; 4195 goto bailout; 4196 } 4197 4198 if ((humanize != 0) 4199 && (blocksizeonly != 0)) { 4200 warnx("%s: you can only specify one of -h/-H or -b", __func__); 4201 retval = 1; 4202 goto bailout; 4203 } 4204 4205 scsi_read_capacity(&ccb->csio, 4206 /*retries*/ retry_count, 4207 /*cbfcnp*/ NULL, 4208 /*tag_action*/ MSG_SIMPLE_Q_TAG, 4209 &rcap, 4210 SSD_FULL_SIZE, 4211 /*timeout*/ timeout ? timeout : 5000); 4212 4213 /* Disable freezing the device queue */ 4214 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 4215 4216 if (arglist & CAM_ARG_ERR_RECOVER) 4217 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER; 4218 4219 if (cam_send_ccb(device, ccb) < 0) { 4220 warn("error sending READ CAPACITY command"); 4221 4222 if (arglist & CAM_ARG_VERBOSE) 4223 cam_error_print(device, ccb, CAM_ESF_ALL, 4224 CAM_EPF_ALL, stderr); 4225 4226 retval = 1; 4227 goto bailout; 4228 } 4229 4230 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 4231 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr); 4232 retval = 1; 4233 goto bailout; 4234 } 4235 4236 maxsector = scsi_4btoul(rcap.addr); 4237 block_len = scsi_4btoul(rcap.length); 4238 4239 /* 4240 * A last block of 2^32-1 means that the true capacity is over 2TB, 4241 * and we need to issue the long READ CAPACITY to get the real 4242 * capacity. Otherwise, we're all set. 4243 */ 4244 if (maxsector != 0xffffffff) 4245 goto do_print; 4246 4247 scsi_read_capacity_16(&ccb->csio, 4248 /*retries*/ retry_count, 4249 /*cbfcnp*/ NULL, 4250 /*tag_action*/ MSG_SIMPLE_Q_TAG, 4251 /*lba*/ 0, 4252 /*reladdr*/ 0, 4253 /*pmi*/ 0, 4254 &rcaplong, 4255 /*sense_len*/ SSD_FULL_SIZE, 4256 /*timeout*/ timeout ? timeout : 5000); 4257 4258 /* Disable freezing the device queue */ 4259 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 4260 4261 if (arglist & CAM_ARG_ERR_RECOVER) 4262 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER; 4263 4264 if (cam_send_ccb(device, ccb) < 0) { 4265 warn("error sending READ CAPACITY (16) command"); 4266 4267 if (arglist & CAM_ARG_VERBOSE) 4268 cam_error_print(device, ccb, CAM_ESF_ALL, 4269 CAM_EPF_ALL, stderr); 4270 4271 retval = 1; 4272 goto bailout; 4273 } 4274 4275 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 4276 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr); 4277 retval = 1; 4278 goto bailout; 4279 } 4280 4281 maxsector = scsi_8btou64(rcaplong.addr); 4282 block_len = scsi_4btoul(rcaplong.length); 4283 4284 do_print: 4285 if (blocksizeonly == 0) { 4286 /* 4287 * Humanize implies !quiet, and also implies numblocks. 4288 */ 4289 if (humanize != 0) { 4290 char tmpstr[6]; 4291 int64_t tmpbytes; 4292 int ret; 4293 4294 tmpbytes = (maxsector + 1) * block_len; 4295 ret = humanize_number(tmpstr, sizeof(tmpstr), 4296 tmpbytes, "", HN_AUTOSCALE, 4297 HN_B | HN_DECIMAL | 4298 ((baseten != 0) ? 4299 HN_DIVISOR_1000 : 0)); 4300 if (ret == -1) { 4301 warnx("%s: humanize_number failed!", __func__); 4302 retval = 1; 4303 goto bailout; 4304 } 4305 fprintf(stdout, "Device Size: %s%s", tmpstr, 4306 (sizeonly == 0) ? ", " : "\n"); 4307 } else if (numblocks != 0) { 4308 fprintf(stdout, "%s%ju%s", (quiet == 0) ? 4309 "Blocks: " : "", (uintmax_t)maxsector + 1, 4310 (sizeonly == 0) ? ", " : "\n"); 4311 } else { 4312 fprintf(stdout, "%s%ju%s", (quiet == 0) ? 4313 "Last Block: " : "", (uintmax_t)maxsector, 4314 (sizeonly == 0) ? ", " : "\n"); 4315 } 4316 } 4317 if (sizeonly == 0) 4318 fprintf(stdout, "%s%u%s\n", (quiet == 0) ? 4319 "Block Length: " : "", block_len, (quiet == 0) ? 4320 " bytes" : ""); 4321 bailout: 4322 cam_freeccb(ccb); 4323 4324 return (retval); 4325 } 4326 4327 static int 4328 smpcmd(struct cam_device *device, int argc, char **argv, char *combinedopt, 4329 int retry_count, int timeout) 4330 { 4331 int c, error; 4332 union ccb *ccb; 4333 uint8_t *smp_request = NULL, *smp_response = NULL; 4334 int request_size = 0, response_size = 0; 4335 int fd_request = 0, fd_response = 0; 4336 char *datastr = NULL; 4337 struct get_hook hook; 4338 int retval; 4339 int flags = 0; 4340 4341 /* 4342 * Note that at the moment we don't support sending SMP CCBs to 4343 * devices that aren't probed by CAM. 4344 */ 4345 ccb = cam_getccb(device); 4346 if (ccb == NULL) { 4347 warnx("%s: error allocating CCB", __func__); 4348 return (1); 4349 } 4350 4351 bzero(&(&ccb->ccb_h)[1], 4352 sizeof(union ccb) - sizeof(struct ccb_hdr)); 4353 4354 while ((c = getopt(argc, argv, combinedopt)) != -1) { 4355 switch (c) { 4356 case 'R': 4357 arglist |= CAM_ARG_CMD_IN; 4358 response_size = strtol(optarg, NULL, 0); 4359 if (response_size <= 0) { 4360 warnx("invalid number of response bytes %d", 4361 response_size); 4362 error = 1; 4363 goto smpcmd_bailout; 4364 } 4365 hook.argc = argc - optind; 4366 hook.argv = argv + optind; 4367 hook.got = 0; 4368 optind++; 4369 datastr = cget(&hook, NULL); 4370 /* 4371 * If the user supplied "-" instead of a format, he 4372 * wants the data to be written to stdout. 4373 */ 4374 if ((datastr != NULL) 4375 && (datastr[0] == '-')) 4376 fd_response = 1; 4377 4378 smp_response = (u_int8_t *)malloc(response_size); 4379 if (smp_response == NULL) { 4380 warn("can't malloc memory for SMP response"); 4381 error = 1; 4382 goto smpcmd_bailout; 4383 } 4384 break; 4385 case 'r': 4386 arglist |= CAM_ARG_CMD_OUT; 4387 request_size = strtol(optarg, NULL, 0); 4388 if (request_size <= 0) { 4389 warnx("invalid number of request bytes %d", 4390 request_size); 4391 error = 1; 4392 goto smpcmd_bailout; 4393 } 4394 hook.argc = argc - optind; 4395 hook.argv = argv + optind; 4396 hook.got = 0; 4397 datastr = cget(&hook, NULL); 4398 smp_request = (u_int8_t *)malloc(request_size); 4399 if (smp_request == NULL) { 4400 warn("can't malloc memory for SMP request"); 4401 error = 1; 4402 goto smpcmd_bailout; 4403 } 4404 bzero(smp_request, request_size); 4405 /* 4406 * If the user supplied "-" instead of a format, he 4407 * wants the data to be read from stdin. 4408 */ 4409 if ((datastr != NULL) 4410 && (datastr[0] == '-')) 4411 fd_request = 1; 4412 else 4413 buff_encode_visit(smp_request, request_size, 4414 datastr, 4415 iget, &hook); 4416 optind += hook.got; 4417 break; 4418 default: 4419 break; 4420 } 4421 } 4422 4423 /* 4424 * If fd_data is set, and we're writing to the device, we need to 4425 * read the data the user wants written from stdin. 4426 */ 4427 if ((fd_request == 1) && (arglist & CAM_ARG_CMD_OUT)) { 4428 ssize_t amt_read; 4429 int amt_to_read = request_size; 4430 u_int8_t *buf_ptr = smp_request; 4431 4432 for (amt_read = 0; amt_to_read > 0; 4433 amt_read = read(STDIN_FILENO, buf_ptr, amt_to_read)) { 4434 if (amt_read == -1) { 4435 warn("error reading data from stdin"); 4436 error = 1; 4437 goto smpcmd_bailout; 4438 } 4439 amt_to_read -= amt_read; 4440 buf_ptr += amt_read; 4441 } 4442 } 4443 4444 if (((arglist & CAM_ARG_CMD_IN) == 0) 4445 || ((arglist & CAM_ARG_CMD_OUT) == 0)) { 4446 warnx("%s: need both the request (-r) and response (-R) " 4447 "arguments", __func__); 4448 error = 1; 4449 goto smpcmd_bailout; 4450 } 4451 4452 flags |= CAM_DEV_QFRZDIS; 4453 4454 cam_fill_smpio(&ccb->smpio, 4455 /*retries*/ retry_count, 4456 /*cbfcnp*/ NULL, 4457 /*flags*/ flags, 4458 /*smp_request*/ smp_request, 4459 /*smp_request_len*/ request_size, 4460 /*smp_response*/ smp_response, 4461 /*smp_response_len*/ response_size, 4462 /*timeout*/ timeout ? timeout : 5000); 4463 4464 ccb->smpio.flags = SMP_FLAG_NONE; 4465 4466 if (((retval = cam_send_ccb(device, ccb)) < 0) 4467 || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) { 4468 const char *warnstr = "error sending command"; 4469 4470 if (retval < 0) 4471 warn(warnstr); 4472 else 4473 warnx(warnstr); 4474 4475 if (arglist & CAM_ARG_VERBOSE) { 4476 cam_error_print(device, ccb, CAM_ESF_ALL, 4477 CAM_EPF_ALL, stderr); 4478 } 4479 } 4480 4481 if (((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) 4482 && (response_size > 0)) { 4483 if (fd_response == 0) { 4484 buff_decode_visit(smp_response, response_size, 4485 datastr, arg_put, NULL); 4486 fprintf(stdout, "\n"); 4487 } else { 4488 ssize_t amt_written; 4489 int amt_to_write = response_size; 4490 u_int8_t *buf_ptr = smp_response; 4491 4492 for (amt_written = 0; (amt_to_write > 0) && 4493 (amt_written = write(STDOUT_FILENO, buf_ptr, 4494 amt_to_write)) > 0;){ 4495 amt_to_write -= amt_written; 4496 buf_ptr += amt_written; 4497 } 4498 if (amt_written == -1) { 4499 warn("error writing data to stdout"); 4500 error = 1; 4501 goto smpcmd_bailout; 4502 } else if ((amt_written == 0) 4503 && (amt_to_write > 0)) { 4504 warnx("only wrote %u bytes out of %u", 4505 response_size - amt_to_write, 4506 response_size); 4507 } 4508 } 4509 } 4510 smpcmd_bailout: 4511 if (ccb != NULL) 4512 cam_freeccb(ccb); 4513 4514 if (smp_request != NULL) 4515 free(smp_request); 4516 4517 if (smp_response != NULL) 4518 free(smp_response); 4519 4520 return (error); 4521 } 4522 4523 static int 4524 smpreportgeneral(struct cam_device *device, int argc, char **argv, 4525 char *combinedopt, int retry_count, int timeout) 4526 { 4527 union ccb *ccb; 4528 struct smp_report_general_request *request = NULL; 4529 struct smp_report_general_response *response = NULL; 4530 struct sbuf *sb = NULL; 4531 int error = 0; 4532 int c, long_response = 0; 4533 int retval; 4534 4535 /* 4536 * Note that at the moment we don't support sending SMP CCBs to 4537 * devices that aren't probed by CAM. 4538 */ 4539 ccb = cam_getccb(device); 4540 if (ccb == NULL) { 4541 warnx("%s: error allocating CCB", __func__); 4542 return (1); 4543 } 4544 4545 bzero(&(&ccb->ccb_h)[1], 4546 sizeof(union ccb) - sizeof(struct ccb_hdr)); 4547 4548 while ((c = getopt(argc, argv, combinedopt)) != -1) { 4549 switch (c) { 4550 case 'l': 4551 long_response = 1; 4552 break; 4553 default: 4554 break; 4555 } 4556 } 4557 request = malloc(sizeof(*request)); 4558 if (request == NULL) { 4559 warn("%s: unable to allocate %zd bytes", __func__, 4560 sizeof(*request)); 4561 error = 1; 4562 goto bailout; 4563 } 4564 4565 response = malloc(sizeof(*response)); 4566 if (response == NULL) { 4567 warn("%s: unable to allocate %zd bytes", __func__, 4568 sizeof(*response)); 4569 error = 1; 4570 goto bailout; 4571 } 4572 4573 try_long: 4574 smp_report_general(&ccb->smpio, 4575 retry_count, 4576 /*cbfcnp*/ NULL, 4577 request, 4578 /*request_len*/ sizeof(*request), 4579 (uint8_t *)response, 4580 /*response_len*/ sizeof(*response), 4581 /*long_response*/ long_response, 4582 timeout); 4583 4584 if (((retval = cam_send_ccb(device, ccb)) < 0) 4585 || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) { 4586 const char *warnstr = "error sending command"; 4587 4588 if (retval < 0) 4589 warn(warnstr); 4590 else 4591 warnx(warnstr); 4592 4593 if (arglist & CAM_ARG_VERBOSE) { 4594 cam_error_print(device, ccb, CAM_ESF_ALL, 4595 CAM_EPF_ALL, stderr); 4596 } 4597 error = 1; 4598 goto bailout; 4599 } 4600 4601 /* 4602 * If the device supports the long response bit, try again and see 4603 * if we can get all of the data. 4604 */ 4605 if ((response->long_response & SMP_RG_LONG_RESPONSE) 4606 && (long_response == 0)) { 4607 ccb->ccb_h.status = CAM_REQ_INPROG; 4608 bzero(&(&ccb->ccb_h)[1], 4609 sizeof(union ccb) - sizeof(struct ccb_hdr)); 4610 long_response = 1; 4611 goto try_long; 4612 } 4613 4614 /* 4615 * XXX KDM detect and decode SMP errors here. 4616 */ 4617 sb = sbuf_new_auto(); 4618 if (sb == NULL) { 4619 warnx("%s: error allocating sbuf", __func__); 4620 goto bailout; 4621 } 4622 4623 smp_report_general_sbuf(response, sizeof(*response), sb); 4624 4625 sbuf_finish(sb); 4626 4627 printf("%s", sbuf_data(sb)); 4628 4629 bailout: 4630 if (ccb != NULL) 4631 cam_freeccb(ccb); 4632 4633 if (request != NULL) 4634 free(request); 4635 4636 if (response != NULL) 4637 free(response); 4638 4639 if (sb != NULL) 4640 sbuf_delete(sb); 4641 4642 return (error); 4643 } 4644 4645 struct camcontrol_opts phy_ops[] = { 4646 {"nop", SMP_PC_PHY_OP_NOP, CAM_ARG_NONE, NULL}, 4647 {"linkreset", SMP_PC_PHY_OP_LINK_RESET, CAM_ARG_NONE, NULL}, 4648 {"hardreset", SMP_PC_PHY_OP_HARD_RESET, CAM_ARG_NONE, NULL}, 4649 {"disable", SMP_PC_PHY_OP_DISABLE, CAM_ARG_NONE, NULL}, 4650 {"clearerrlog", SMP_PC_PHY_OP_CLEAR_ERR_LOG, CAM_ARG_NONE, NULL}, 4651 {"clearaffiliation", SMP_PC_PHY_OP_CLEAR_AFFILIATON, CAM_ARG_NONE,NULL}, 4652 {"sataportsel", SMP_PC_PHY_OP_TRANS_SATA_PSS, CAM_ARG_NONE, NULL}, 4653 {"clearitnl", SMP_PC_PHY_OP_CLEAR_STP_ITN_LS, CAM_ARG_NONE, NULL}, 4654 {"setdevname", SMP_PC_PHY_OP_SET_ATT_DEV_NAME, CAM_ARG_NONE, NULL}, 4655 {NULL, 0, 0, NULL} 4656 }; 4657 4658 static int 4659 smpphycontrol(struct cam_device *device, int argc, char **argv, 4660 char *combinedopt, int retry_count, int timeout) 4661 { 4662 union ccb *ccb; 4663 struct smp_phy_control_request *request = NULL; 4664 struct smp_phy_control_response *response = NULL; 4665 int long_response = 0; 4666 int retval = 0; 4667 int phy = -1; 4668 uint32_t phy_operation = SMP_PC_PHY_OP_NOP; 4669 int phy_op_set = 0; 4670 uint64_t attached_dev_name = 0; 4671 int dev_name_set = 0; 4672 uint32_t min_plr = 0, max_plr = 0; 4673 uint32_t pp_timeout_val = 0; 4674 int slumber_partial = 0; 4675 int set_pp_timeout_val = 0; 4676 int c; 4677 4678 /* 4679 * Note that at the moment we don't support sending SMP CCBs to 4680 * devices that aren't probed by CAM. 4681 */ 4682 ccb = cam_getccb(device); 4683 if (ccb == NULL) { 4684 warnx("%s: error allocating CCB", __func__); 4685 return (1); 4686 } 4687 4688 bzero(&(&ccb->ccb_h)[1], 4689 sizeof(union ccb) - sizeof(struct ccb_hdr)); 4690 4691 while ((c = getopt(argc, argv, combinedopt)) != -1) { 4692 switch (c) { 4693 case 'a': 4694 case 'A': 4695 case 's': 4696 case 'S': { 4697 int enable = -1; 4698 4699 if (strcasecmp(optarg, "enable") == 0) 4700 enable = 1; 4701 else if (strcasecmp(optarg, "disable") == 0) 4702 enable = 2; 4703 else { 4704 warnx("%s: Invalid argument %s", __func__, 4705 optarg); 4706 retval = 1; 4707 goto bailout; 4708 } 4709 switch (c) { 4710 case 's': 4711 slumber_partial |= enable << 4712 SMP_PC_SAS_SLUMBER_SHIFT; 4713 break; 4714 case 'S': 4715 slumber_partial |= enable << 4716 SMP_PC_SAS_PARTIAL_SHIFT; 4717 break; 4718 case 'a': 4719 slumber_partial |= enable << 4720 SMP_PC_SATA_SLUMBER_SHIFT; 4721 break; 4722 case 'A': 4723 slumber_partial |= enable << 4724 SMP_PC_SATA_PARTIAL_SHIFT; 4725 break; 4726 default: 4727 warnx("%s: programmer error", __func__); 4728 retval = 1; 4729 goto bailout; 4730 break; /*NOTREACHED*/ 4731 } 4732 break; 4733 } 4734 case 'd': 4735 attached_dev_name = (uintmax_t)strtoumax(optarg, 4736 NULL,0); 4737 dev_name_set = 1; 4738 break; 4739 case 'l': 4740 long_response = 1; 4741 break; 4742 case 'm': 4743 /* 4744 * We don't do extensive checking here, so this 4745 * will continue to work when new speeds come out. 4746 */ 4747 min_plr = strtoul(optarg, NULL, 0); 4748 if ((min_plr == 0) 4749 || (min_plr > 0xf)) { 4750 warnx("%s: invalid link rate %x", 4751 __func__, min_plr); 4752 retval = 1; 4753 goto bailout; 4754 } 4755 break; 4756 case 'M': 4757 /* 4758 * We don't do extensive checking here, so this 4759 * will continue to work when new speeds come out. 4760 */ 4761 max_plr = strtoul(optarg, NULL, 0); 4762 if ((max_plr == 0) 4763 || (max_plr > 0xf)) { 4764 warnx("%s: invalid link rate %x", 4765 __func__, max_plr); 4766 retval = 1; 4767 goto bailout; 4768 } 4769 break; 4770 case 'o': { 4771 camcontrol_optret optreturn; 4772 cam_argmask argnums; 4773 const char *subopt; 4774 4775 if (phy_op_set != 0) { 4776 warnx("%s: only one phy operation argument " 4777 "(-o) allowed", __func__); 4778 retval = 1; 4779 goto bailout; 4780 } 4781 4782 phy_op_set = 1; 4783 4784 /* 4785 * Allow the user to specify the phy operation 4786 * numerically, as well as with a name. This will 4787 * future-proof it a bit, so options that are added 4788 * in future specs can be used. 4789 */ 4790 if (isdigit(optarg[0])) { 4791 phy_operation = strtoul(optarg, NULL, 0); 4792 if ((phy_operation == 0) 4793 || (phy_operation > 0xff)) { 4794 warnx("%s: invalid phy operation %#x", 4795 __func__, phy_operation); 4796 retval = 1; 4797 goto bailout; 4798 } 4799 break; 4800 } 4801 optreturn = getoption(phy_ops, optarg, &phy_operation, 4802 &argnums, &subopt); 4803 4804 if (optreturn == CC_OR_AMBIGUOUS) { 4805 warnx("%s: ambiguous option %s", __func__, 4806 optarg); 4807 usage(0); 4808 retval = 1; 4809 goto bailout; 4810 } else if (optreturn == CC_OR_NOT_FOUND) { 4811 warnx("%s: option %s not found", __func__, 4812 optarg); 4813 usage(0); 4814 retval = 1; 4815 goto bailout; 4816 } 4817 break; 4818 } 4819 case 'p': 4820 phy = atoi(optarg); 4821 break; 4822 case 'T': 4823 pp_timeout_val = strtoul(optarg, NULL, 0); 4824 if (pp_timeout_val > 15) { 4825 warnx("%s: invalid partial pathway timeout " 4826 "value %u, need a value less than 16", 4827 __func__, pp_timeout_val); 4828 retval = 1; 4829 goto bailout; 4830 } 4831 set_pp_timeout_val = 1; 4832 break; 4833 default: 4834 break; 4835 } 4836 } 4837 4838 if (phy == -1) { 4839 warnx("%s: a PHY (-p phy) argument is required",__func__); 4840 retval = 1; 4841 goto bailout; 4842 } 4843 4844 if (((dev_name_set != 0) 4845 && (phy_operation != SMP_PC_PHY_OP_SET_ATT_DEV_NAME)) 4846 || ((phy_operation == SMP_PC_PHY_OP_SET_ATT_DEV_NAME) 4847 && (dev_name_set == 0))) { 4848 warnx("%s: -d name and -o setdevname arguments both " 4849 "required to set device name", __func__); 4850 retval = 1; 4851 goto bailout; 4852 } 4853 4854 request = malloc(sizeof(*request)); 4855 if (request == NULL) { 4856 warn("%s: unable to allocate %zd bytes", __func__, 4857 sizeof(*request)); 4858 retval = 1; 4859 goto bailout; 4860 } 4861 4862 response = malloc(sizeof(*response)); 4863 if (response == NULL) { 4864 warn("%s: unable to allocate %zd bytes", __func__, 4865 sizeof(*request)); 4866 retval = 1; 4867 goto bailout; 4868 } 4869 4870 smp_phy_control(&ccb->smpio, 4871 retry_count, 4872 /*cbfcnp*/ NULL, 4873 request, 4874 sizeof(*request), 4875 (uint8_t *)response, 4876 sizeof(*response), 4877 long_response, 4878 /*expected_exp_change_count*/ 0, 4879 phy, 4880 phy_operation, 4881 (set_pp_timeout_val != 0) ? 1 : 0, 4882 attached_dev_name, 4883 min_plr, 4884 max_plr, 4885 slumber_partial, 4886 pp_timeout_val, 4887 timeout); 4888 4889 if (((retval = cam_send_ccb(device, ccb)) < 0) 4890 || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) { 4891 const char *warnstr = "error sending command"; 4892 4893 if (retval < 0) 4894 warn(warnstr); 4895 else 4896 warnx(warnstr); 4897 4898 if (arglist & CAM_ARG_VERBOSE) { 4899 /* 4900 * Use CAM_EPF_NORMAL so we only get one line of 4901 * SMP command decoding. 4902 */ 4903 cam_error_print(device, ccb, CAM_ESF_ALL, 4904 CAM_EPF_NORMAL, stderr); 4905 } 4906 retval = 1; 4907 goto bailout; 4908 } 4909 4910 /* XXX KDM print out something here for success? */ 4911 bailout: 4912 if (ccb != NULL) 4913 cam_freeccb(ccb); 4914 4915 if (request != NULL) 4916 free(request); 4917 4918 if (response != NULL) 4919 free(response); 4920 4921 return (retval); 4922 } 4923 4924 static int 4925 smpmaninfo(struct cam_device *device, int argc, char **argv, 4926 char *combinedopt, int retry_count, int timeout) 4927 { 4928 union ccb *ccb; 4929 struct smp_report_manuf_info_request request; 4930 struct smp_report_manuf_info_response response; 4931 struct sbuf *sb = NULL; 4932 int long_response = 0; 4933 int retval = 0; 4934 int c; 4935 4936 /* 4937 * Note that at the moment we don't support sending SMP CCBs to 4938 * devices that aren't probed by CAM. 4939 */ 4940 ccb = cam_getccb(device); 4941 if (ccb == NULL) { 4942 warnx("%s: error allocating CCB", __func__); 4943 return (1); 4944 } 4945 4946 bzero(&(&ccb->ccb_h)[1], 4947 sizeof(union ccb) - sizeof(struct ccb_hdr)); 4948 4949 while ((c = getopt(argc, argv, combinedopt)) != -1) { 4950 switch (c) { 4951 case 'l': 4952 long_response = 1; 4953 break; 4954 default: 4955 break; 4956 } 4957 } 4958 bzero(&request, sizeof(request)); 4959 bzero(&response, sizeof(response)); 4960 4961 smp_report_manuf_info(&ccb->smpio, 4962 retry_count, 4963 /*cbfcnp*/ NULL, 4964 &request, 4965 sizeof(request), 4966 (uint8_t *)&response, 4967 sizeof(response), 4968 long_response, 4969 timeout); 4970 4971 if (((retval = cam_send_ccb(device, ccb)) < 0) 4972 || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) { 4973 const char *warnstr = "error sending command"; 4974 4975 if (retval < 0) 4976 warn(warnstr); 4977 else 4978 warnx(warnstr); 4979 4980 if (arglist & CAM_ARG_VERBOSE) { 4981 cam_error_print(device, ccb, CAM_ESF_ALL, 4982 CAM_EPF_ALL, stderr); 4983 } 4984 retval = 1; 4985 goto bailout; 4986 } 4987 4988 sb = sbuf_new_auto(); 4989 if (sb == NULL) { 4990 warnx("%s: error allocating sbuf", __func__); 4991 goto bailout; 4992 } 4993 4994 smp_report_manuf_info_sbuf(&response, sizeof(response), sb); 4995 4996 sbuf_finish(sb); 4997 4998 printf("%s", sbuf_data(sb)); 4999 5000 bailout: 5001 5002 if (ccb != NULL) 5003 cam_freeccb(ccb); 5004 5005 if (sb != NULL) 5006 sbuf_delete(sb); 5007 5008 return (retval); 5009 } 5010 5011 static int 5012 getdevid(struct cam_devitem *item) 5013 { 5014 int retval = 0; 5015 union ccb *ccb = NULL; 5016 5017 struct cam_device *dev; 5018 5019 dev = cam_open_btl(item->dev_match.path_id, 5020 item->dev_match.target_id, 5021 item->dev_match.target_lun, O_RDWR, NULL); 5022 5023 if (dev == NULL) { 5024 warnx("%s", cam_errbuf); 5025 retval = 1; 5026 goto bailout; 5027 } 5028 5029 item->device_id_len = 0; 5030 5031 ccb = cam_getccb(dev); 5032 if (ccb == NULL) { 5033 warnx("%s: error allocating CCB", __func__); 5034 retval = 1; 5035 goto bailout; 5036 } 5037 5038 bzero(&(&ccb->ccb_h)[1], 5039 sizeof(union ccb) - sizeof(struct ccb_hdr)); 5040 5041 /* 5042 * On the first try, we just probe for the size of the data, and 5043 * then allocate that much memory and try again. 5044 */ 5045 retry: 5046 ccb->ccb_h.func_code = XPT_GDEV_ADVINFO; 5047 ccb->ccb_h.flags = CAM_DIR_IN; 5048 ccb->cgdai.flags = CGDAI_FLAG_PROTO; 5049 ccb->cgdai.buftype = CGDAI_TYPE_SCSI_DEVID; 5050 ccb->cgdai.bufsiz = item->device_id_len; 5051 if (item->device_id_len != 0) 5052 ccb->cgdai.buf = (uint8_t *)item->device_id; 5053 5054 if (cam_send_ccb(dev, ccb) < 0) { 5055 warn("%s: error sending XPT_GDEV_ADVINFO CCB", __func__); 5056 retval = 1; 5057 goto bailout; 5058 } 5059 5060 if (ccb->ccb_h.status != CAM_REQ_CMP) { 5061 warnx("%s: CAM status %#x", __func__, ccb->ccb_h.status); 5062 retval = 1; 5063 goto bailout; 5064 } 5065 5066 if (item->device_id_len == 0) { 5067 /* 5068 * This is our first time through. Allocate the buffer, 5069 * and then go back to get the data. 5070 */ 5071 if (ccb->cgdai.provsiz == 0) { 5072 warnx("%s: invalid .provsiz field returned with " 5073 "XPT_GDEV_ADVINFO CCB", __func__); 5074 retval = 1; 5075 goto bailout; 5076 } 5077 item->device_id_len = ccb->cgdai.provsiz; 5078 item->device_id = malloc(item->device_id_len); 5079 if (item->device_id == NULL) { 5080 warn("%s: unable to allocate %d bytes", __func__, 5081 item->device_id_len); 5082 retval = 1; 5083 goto bailout; 5084 } 5085 ccb->ccb_h.status = CAM_REQ_INPROG; 5086 goto retry; 5087 } 5088 5089 bailout: 5090 if (dev != NULL) 5091 cam_close_device(dev); 5092 5093 if (ccb != NULL) 5094 cam_freeccb(ccb); 5095 5096 return (retval); 5097 } 5098 5099 /* 5100 * XXX KDM merge this code with getdevtree()? 5101 */ 5102 static int 5103 buildbusdevlist(struct cam_devlist *devlist) 5104 { 5105 union ccb ccb; 5106 int bufsize, fd = -1; 5107 struct dev_match_pattern *patterns; 5108 struct cam_devitem *item = NULL; 5109 int skip_device = 0; 5110 int retval = 0; 5111 5112 if ((fd = open(XPT_DEVICE, O_RDWR)) == -1) { 5113 warn("couldn't open %s", XPT_DEVICE); 5114 return(1); 5115 } 5116 5117 bzero(&ccb, sizeof(union ccb)); 5118 5119 ccb.ccb_h.path_id = CAM_XPT_PATH_ID; 5120 ccb.ccb_h.target_id = CAM_TARGET_WILDCARD; 5121 ccb.ccb_h.target_lun = CAM_LUN_WILDCARD; 5122 5123 ccb.ccb_h.func_code = XPT_DEV_MATCH; 5124 bufsize = sizeof(struct dev_match_result) * 100; 5125 ccb.cdm.match_buf_len = bufsize; 5126 ccb.cdm.matches = (struct dev_match_result *)malloc(bufsize); 5127 if (ccb.cdm.matches == NULL) { 5128 warnx("can't malloc memory for matches"); 5129 close(fd); 5130 return(1); 5131 } 5132 ccb.cdm.num_matches = 0; 5133 ccb.cdm.num_patterns = 2; 5134 ccb.cdm.pattern_buf_len = sizeof(struct dev_match_pattern) * 5135 ccb.cdm.num_patterns; 5136 5137 patterns = (struct dev_match_pattern *)malloc(ccb.cdm.pattern_buf_len); 5138 if (patterns == NULL) { 5139 warnx("can't malloc memory for patterns"); 5140 retval = 1; 5141 goto bailout; 5142 } 5143 5144 ccb.cdm.patterns = patterns; 5145 bzero(patterns, ccb.cdm.pattern_buf_len); 5146 5147 patterns[0].type = DEV_MATCH_DEVICE; 5148 patterns[0].pattern.device_pattern.flags = DEV_MATCH_PATH; 5149 patterns[0].pattern.device_pattern.path_id = devlist->path_id; 5150 patterns[1].type = DEV_MATCH_PERIPH; 5151 patterns[1].pattern.periph_pattern.flags = PERIPH_MATCH_PATH; 5152 patterns[1].pattern.periph_pattern.path_id = devlist->path_id; 5153 5154 /* 5155 * We do the ioctl multiple times if necessary, in case there are 5156 * more than 100 nodes in the EDT. 5157 */ 5158 do { 5159 unsigned int i; 5160 5161 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) { 5162 warn("error sending CAMIOCOMMAND ioctl"); 5163 retval = 1; 5164 goto bailout; 5165 } 5166 5167 if ((ccb.ccb_h.status != CAM_REQ_CMP) 5168 || ((ccb.cdm.status != CAM_DEV_MATCH_LAST) 5169 && (ccb.cdm.status != CAM_DEV_MATCH_MORE))) { 5170 warnx("got CAM error %#x, CDM error %d\n", 5171 ccb.ccb_h.status, ccb.cdm.status); 5172 retval = 1; 5173 goto bailout; 5174 } 5175 5176 for (i = 0; i < ccb.cdm.num_matches; i++) { 5177 switch (ccb.cdm.matches[i].type) { 5178 case DEV_MATCH_DEVICE: { 5179 struct device_match_result *dev_result; 5180 5181 dev_result = 5182 &ccb.cdm.matches[i].result.device_result; 5183 5184 if (dev_result->flags & 5185 DEV_RESULT_UNCONFIGURED) { 5186 skip_device = 1; 5187 break; 5188 } else 5189 skip_device = 0; 5190 5191 item = malloc(sizeof(*item)); 5192 if (item == NULL) { 5193 warn("%s: unable to allocate %zd bytes", 5194 __func__, sizeof(*item)); 5195 retval = 1; 5196 goto bailout; 5197 } 5198 bzero(item, sizeof(*item)); 5199 bcopy(dev_result, &item->dev_match, 5200 sizeof(*dev_result)); 5201 STAILQ_INSERT_TAIL(&devlist->dev_queue, item, 5202 links); 5203 5204 if (getdevid(item) != 0) { 5205 retval = 1; 5206 goto bailout; 5207 } 5208 break; 5209 } 5210 case DEV_MATCH_PERIPH: { 5211 struct periph_match_result *periph_result; 5212 5213 periph_result = 5214 &ccb.cdm.matches[i].result.periph_result; 5215 5216 if (skip_device != 0) 5217 break; 5218 item->num_periphs++; 5219 item->periph_matches = realloc( 5220 item->periph_matches, 5221 item->num_periphs * 5222 sizeof(struct periph_match_result)); 5223 if (item->periph_matches == NULL) { 5224 warn("%s: error allocating periph " 5225 "list", __func__); 5226 retval = 1; 5227 goto bailout; 5228 } 5229 bcopy(periph_result, &item->periph_matches[ 5230 item->num_periphs - 1], 5231 sizeof(*periph_result)); 5232 break; 5233 } 5234 default: 5235 fprintf(stderr, "%s: unexpected match " 5236 "type %d\n", __func__, 5237 ccb.cdm.matches[i].type); 5238 retval = 1; 5239 goto bailout; 5240 break; /*NOTREACHED*/ 5241 } 5242 } 5243 } while ((ccb.ccb_h.status == CAM_REQ_CMP) 5244 && (ccb.cdm.status == CAM_DEV_MATCH_MORE)); 5245 bailout: 5246 5247 if (fd != -1) 5248 close(fd); 5249 5250 free(patterns); 5251 5252 free(ccb.cdm.matches); 5253 5254 if (retval != 0) 5255 freebusdevlist(devlist); 5256 5257 return (retval); 5258 } 5259 5260 static void 5261 freebusdevlist(struct cam_devlist *devlist) 5262 { 5263 struct cam_devitem *item, *item2; 5264 5265 STAILQ_FOREACH_SAFE(item, &devlist->dev_queue, links, item2) { 5266 STAILQ_REMOVE(&devlist->dev_queue, item, cam_devitem, 5267 links); 5268 free(item->device_id); 5269 free(item->periph_matches); 5270 free(item); 5271 } 5272 } 5273 5274 static struct cam_devitem * 5275 findsasdevice(struct cam_devlist *devlist, uint64_t sasaddr) 5276 { 5277 struct cam_devitem *item; 5278 5279 STAILQ_FOREACH(item, &devlist->dev_queue, links) { 5280 uint8_t *item_addr; 5281 5282 /* 5283 * XXX KDM look for LUN IDs as well? 5284 */ 5285 item_addr = scsi_get_sas_addr(item->device_id, 5286 item->device_id_len); 5287 if (item_addr == NULL) 5288 continue; 5289 5290 if (scsi_8btou64(item_addr) == sasaddr) 5291 return (item); 5292 } 5293 5294 return (NULL); 5295 } 5296 5297 static int 5298 smpphylist(struct cam_device *device, int argc, char **argv, 5299 char *combinedopt, int retry_count, int timeout) 5300 { 5301 struct smp_report_general_request *rgrequest = NULL; 5302 struct smp_report_general_response *rgresponse = NULL; 5303 struct smp_discover_request *disrequest = NULL; 5304 struct smp_discover_response *disresponse = NULL; 5305 struct cam_devlist devlist; 5306 union ccb *ccb; 5307 int long_response = 0; 5308 int num_phys = 0; 5309 int quiet = 0; 5310 int retval; 5311 int i, c; 5312 5313 /* 5314 * Note that at the moment we don't support sending SMP CCBs to 5315 * devices that aren't probed by CAM. 5316 */ 5317 ccb = cam_getccb(device); 5318 if (ccb == NULL) { 5319 warnx("%s: error allocating CCB", __func__); 5320 return (1); 5321 } 5322 5323 bzero(&(&ccb->ccb_h)[1], 5324 sizeof(union ccb) - sizeof(struct ccb_hdr)); 5325 5326 rgrequest = malloc(sizeof(*rgrequest)); 5327 if (rgrequest == NULL) { 5328 warn("%s: unable to allocate %zd bytes", __func__, 5329 sizeof(*rgrequest)); 5330 retval = 1; 5331 goto bailout; 5332 } 5333 5334 rgresponse = malloc(sizeof(*rgresponse)); 5335 if (rgresponse == NULL) { 5336 warn("%s: unable to allocate %zd bytes", __func__, 5337 sizeof(*rgresponse)); 5338 retval = 1; 5339 goto bailout; 5340 } 5341 5342 while ((c = getopt(argc, argv, combinedopt)) != -1) { 5343 switch (c) { 5344 case 'l': 5345 long_response = 1; 5346 break; 5347 case 'q': 5348 quiet = 1; 5349 break; 5350 default: 5351 break; 5352 } 5353 } 5354 5355 smp_report_general(&ccb->smpio, 5356 retry_count, 5357 /*cbfcnp*/ NULL, 5358 rgrequest, 5359 /*request_len*/ sizeof(*rgrequest), 5360 (uint8_t *)rgresponse, 5361 /*response_len*/ sizeof(*rgresponse), 5362 /*long_response*/ long_response, 5363 timeout); 5364 5365 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 5366 5367 if (((retval = cam_send_ccb(device, ccb)) < 0) 5368 || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) { 5369 const char *warnstr = "error sending command"; 5370 5371 if (retval < 0) 5372 warn(warnstr); 5373 else 5374 warnx(warnstr); 5375 5376 if (arglist & CAM_ARG_VERBOSE) { 5377 cam_error_print(device, ccb, CAM_ESF_ALL, 5378 CAM_EPF_ALL, stderr); 5379 } 5380 retval = 1; 5381 goto bailout; 5382 } 5383 5384 num_phys = rgresponse->num_phys; 5385 5386 if (num_phys == 0) { 5387 if (quiet == 0) 5388 fprintf(stdout, "%s: No Phys reported\n", __func__); 5389 retval = 1; 5390 goto bailout; 5391 } 5392 5393 STAILQ_INIT(&devlist.dev_queue); 5394 devlist.path_id = device->path_id; 5395 5396 retval = buildbusdevlist(&devlist); 5397 if (retval != 0) 5398 goto bailout; 5399 5400 if (quiet == 0) { 5401 fprintf(stdout, "%d PHYs:\n", num_phys); 5402 fprintf(stdout, "PHY Attached SAS Address\n"); 5403 } 5404 5405 disrequest = malloc(sizeof(*disrequest)); 5406 if (disrequest == NULL) { 5407 warn("%s: unable to allocate %zd bytes", __func__, 5408 sizeof(*disrequest)); 5409 retval = 1; 5410 goto bailout; 5411 } 5412 5413 disresponse = malloc(sizeof(*disresponse)); 5414 if (disresponse == NULL) { 5415 warn("%s: unable to allocate %zd bytes", __func__, 5416 sizeof(*disresponse)); 5417 retval = 1; 5418 goto bailout; 5419 } 5420 5421 for (i = 0; i < num_phys; i++) { 5422 struct cam_devitem *item; 5423 struct device_match_result *dev_match; 5424 char vendor[16], product[48], revision[16]; 5425 char tmpstr[256]; 5426 int j; 5427 5428 bzero(&(&ccb->ccb_h)[1], 5429 sizeof(union ccb) - sizeof(struct ccb_hdr)); 5430 5431 ccb->ccb_h.status = CAM_REQ_INPROG; 5432 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 5433 5434 smp_discover(&ccb->smpio, 5435 retry_count, 5436 /*cbfcnp*/ NULL, 5437 disrequest, 5438 sizeof(*disrequest), 5439 (uint8_t *)disresponse, 5440 sizeof(*disresponse), 5441 long_response, 5442 /*ignore_zone_group*/ 0, 5443 /*phy*/ i, 5444 timeout); 5445 5446 if (((retval = cam_send_ccb(device, ccb)) < 0) 5447 || (((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) 5448 && (disresponse->function_result != SMP_FR_PHY_VACANT))) { 5449 const char *warnstr = "error sending command"; 5450 5451 if (retval < 0) 5452 warn(warnstr); 5453 else 5454 warnx(warnstr); 5455 5456 if (arglist & CAM_ARG_VERBOSE) { 5457 cam_error_print(device, ccb, CAM_ESF_ALL, 5458 CAM_EPF_ALL, stderr); 5459 } 5460 retval = 1; 5461 goto bailout; 5462 } 5463 5464 if (disresponse->function_result == SMP_FR_PHY_VACANT) { 5465 if (quiet == 0) 5466 fprintf(stdout, "%3d <vacant>\n", i); 5467 continue; 5468 } 5469 5470 item = findsasdevice(&devlist, 5471 scsi_8btou64(disresponse->attached_sas_address)); 5472 5473 if ((quiet == 0) 5474 || (item != NULL)) { 5475 fprintf(stdout, "%3d 0x%016jx", i, 5476 (uintmax_t)scsi_8btou64( 5477 disresponse->attached_sas_address)); 5478 if (item == NULL) { 5479 fprintf(stdout, "\n"); 5480 continue; 5481 } 5482 } else if (quiet != 0) 5483 continue; 5484 5485 dev_match = &item->dev_match; 5486 5487 if (dev_match->protocol == PROTO_SCSI) { 5488 cam_strvis(vendor, dev_match->inq_data.vendor, 5489 sizeof(dev_match->inq_data.vendor), 5490 sizeof(vendor)); 5491 cam_strvis(product, dev_match->inq_data.product, 5492 sizeof(dev_match->inq_data.product), 5493 sizeof(product)); 5494 cam_strvis(revision, dev_match->inq_data.revision, 5495 sizeof(dev_match->inq_data.revision), 5496 sizeof(revision)); 5497 sprintf(tmpstr, "<%s %s %s>", vendor, product, 5498 revision); 5499 } else if ((dev_match->protocol == PROTO_ATA) 5500 || (dev_match->protocol == PROTO_SATAPM)) { 5501 cam_strvis(product, dev_match->ident_data.model, 5502 sizeof(dev_match->ident_data.model), 5503 sizeof(product)); 5504 cam_strvis(revision, dev_match->ident_data.revision, 5505 sizeof(dev_match->ident_data.revision), 5506 sizeof(revision)); 5507 sprintf(tmpstr, "<%s %s>", product, revision); 5508 } else { 5509 sprintf(tmpstr, "<>"); 5510 } 5511 fprintf(stdout, " %-33s ", tmpstr); 5512 5513 /* 5514 * If we have 0 periphs, that's a bug... 5515 */ 5516 if (item->num_periphs == 0) { 5517 fprintf(stdout, "\n"); 5518 continue; 5519 } 5520 5521 fprintf(stdout, "("); 5522 for (j = 0; j < item->num_periphs; j++) { 5523 if (j > 0) 5524 fprintf(stdout, ","); 5525 5526 fprintf(stdout, "%s%d", 5527 item->periph_matches[j].periph_name, 5528 item->periph_matches[j].unit_number); 5529 5530 } 5531 fprintf(stdout, ")\n"); 5532 } 5533 bailout: 5534 if (ccb != NULL) 5535 cam_freeccb(ccb); 5536 5537 free(rgrequest); 5538 5539 free(rgresponse); 5540 5541 free(disrequest); 5542 5543 free(disresponse); 5544 5545 freebusdevlist(&devlist); 5546 5547 return (retval); 5548 } 5549 5550 static int 5551 atapm(struct cam_device *device, int argc, char **argv, 5552 char *combinedopt, int retry_count, int timeout) 5553 { 5554 union ccb *ccb; 5555 int retval = 0; 5556 int t = -1; 5557 int c; 5558 u_char cmd, sc; 5559 5560 ccb = cam_getccb(device); 5561 5562 if (ccb == NULL) { 5563 warnx("%s: error allocating ccb", __func__); 5564 return (1); 5565 } 5566 5567 while ((c = getopt(argc, argv, combinedopt)) != -1) { 5568 switch (c) { 5569 case 't': 5570 t = atoi(optarg); 5571 break; 5572 default: 5573 break; 5574 } 5575 } 5576 if (strcmp(argv[1], "idle") == 0) { 5577 if (t == -1) 5578 cmd = ATA_IDLE_IMMEDIATE; 5579 else 5580 cmd = ATA_IDLE_CMD; 5581 } else if (strcmp(argv[1], "standby") == 0) { 5582 if (t == -1) 5583 cmd = ATA_STANDBY_IMMEDIATE; 5584 else 5585 cmd = ATA_STANDBY_CMD; 5586 } else { 5587 cmd = ATA_SLEEP; 5588 t = -1; 5589 } 5590 5591 if (t < 0) 5592 sc = 0; 5593 else if (t <= (240 * 5)) 5594 sc = (t + 4) / 5; 5595 else if (t <= (252 * 5)) 5596 /* special encoding for 21 minutes */ 5597 sc = 252; 5598 else if (t <= (11 * 30 * 60)) 5599 sc = (t - 1) / (30 * 60) + 241; 5600 else 5601 sc = 253; 5602 5603 cam_fill_ataio(&ccb->ataio, 5604 retry_count, 5605 NULL, 5606 /*flags*/CAM_DIR_NONE, 5607 MSG_SIMPLE_Q_TAG, 5608 /*data_ptr*/NULL, 5609 /*dxfer_len*/0, 5610 timeout ? timeout : 30 * 1000); 5611 ata_28bit_cmd(&ccb->ataio, cmd, 0, 0, sc); 5612 5613 /* Disable freezing the device queue */ 5614 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 5615 5616 if (arglist & CAM_ARG_ERR_RECOVER) 5617 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER; 5618 5619 if (cam_send_ccb(device, ccb) < 0) { 5620 warn("error sending command"); 5621 5622 if (arglist & CAM_ARG_VERBOSE) 5623 cam_error_print(device, ccb, CAM_ESF_ALL, 5624 CAM_EPF_ALL, stderr); 5625 5626 retval = 1; 5627 goto bailout; 5628 } 5629 5630 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 5631 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr); 5632 retval = 1; 5633 goto bailout; 5634 } 5635 bailout: 5636 cam_freeccb(ccb); 5637 return (retval); 5638 } 5639 5640 #endif /* MINIMALISTIC */ 5641 5642 void 5643 usage(int verbose) 5644 { 5645 fprintf(verbose ? stdout : stderr, 5646 "usage: camcontrol <command> [device id][generic args][command args]\n" 5647 " camcontrol devlist [-v]\n" 5648 #ifndef MINIMALISTIC 5649 " camcontrol periphlist [dev_id][-n dev_name] [-u unit]\n" 5650 " camcontrol tur [dev_id][generic args]\n" 5651 " camcontrol inquiry [dev_id][generic args] [-D] [-S] [-R]\n" 5652 " camcontrol identify [dev_id][generic args] [-v]\n" 5653 " camcontrol reportluns [dev_id][generic args] [-c] [-l] [-r report]\n" 5654 " camcontrol readcap [dev_id][generic args] [-b] [-h] [-H] [-N]\n" 5655 " [-q] [-s]\n" 5656 " camcontrol start [dev_id][generic args]\n" 5657 " camcontrol stop [dev_id][generic args]\n" 5658 " camcontrol load [dev_id][generic args]\n" 5659 " camcontrol eject [dev_id][generic args]\n" 5660 #endif /* MINIMALISTIC */ 5661 " camcontrol rescan <all | bus[:target:lun]>\n" 5662 " camcontrol reset <all | bus[:target:lun]>\n" 5663 #ifndef MINIMALISTIC 5664 " camcontrol defects [dev_id][generic args] <-f format> [-P][-G]\n" 5665 " camcontrol modepage [dev_id][generic args] <-m page | -l>\n" 5666 " [-P pagectl][-e | -b][-d]\n" 5667 " camcontrol cmd [dev_id][generic args]\n" 5668 " <-a cmd [args] | -c cmd [args]>\n" 5669 " [-d] [-f] [-i len fmt|-o len fmt [args]] [-r fmt]\n" 5670 " camcontrol smpcmd [dev_id][generic args]\n" 5671 " <-r len fmt [args]> <-R len fmt [args]>\n" 5672 " camcontrol smprg [dev_id][generic args][-l]\n" 5673 " camcontrol smppc [dev_id][generic args] <-p phy> [-l]\n" 5674 " [-o operation][-d name][-m rate][-M rate]\n" 5675 " [-T pp_timeout][-a enable|disable]\n" 5676 " [-A enable|disable][-s enable|disable]\n" 5677 " [-S enable|disable]\n" 5678 " camcontrol smpphylist [dev_id][generic args][-l][-q]\n" 5679 " camcontrol smpmaninfo [dev_id][generic args][-l]\n" 5680 " camcontrol debug [-I][-P][-T][-S][-X][-c]\n" 5681 " <all|bus[:target[:lun]]|off>\n" 5682 " camcontrol tags [dev_id][generic args] [-N tags] [-q] [-v]\n" 5683 " camcontrol negotiate [dev_id][generic args] [-a][-c]\n" 5684 " [-D <enable|disable>][-M mode][-O offset]\n" 5685 " [-q][-R syncrate][-v][-T <enable|disable>]\n" 5686 " [-U][-W bus_width]\n" 5687 " camcontrol format [dev_id][generic args][-q][-r][-w][-y]\n" 5688 " camcontrol idle [dev_id][generic args][-t time]\n" 5689 " camcontrol standby [dev_id][generic args][-t time]\n" 5690 " camcontrol sleep [dev_id][generic args]\n" 5691 #endif /* MINIMALISTIC */ 5692 " camcontrol help\n"); 5693 if (!verbose) 5694 return; 5695 #ifndef MINIMALISTIC 5696 fprintf(stdout, 5697 "Specify one of the following options:\n" 5698 "devlist list all CAM devices\n" 5699 "periphlist list all CAM peripheral drivers attached to a device\n" 5700 "tur send a test unit ready to the named device\n" 5701 "inquiry send a SCSI inquiry command to the named device\n" 5702 "identify send a ATA identify command to the named device\n" 5703 "reportluns send a SCSI report luns command to the device\n" 5704 "readcap send a SCSI read capacity command to the device\n" 5705 "start send a Start Unit command to the device\n" 5706 "stop send a Stop Unit command to the device\n" 5707 "load send a Start Unit command to the device with the load bit set\n" 5708 "eject send a Stop Unit command to the device with the eject bit set\n" 5709 "rescan rescan all busses, the given bus, or bus:target:lun\n" 5710 "reset reset all busses, the given bus, or bus:target:lun\n" 5711 "defects read the defect list of the specified device\n" 5712 "modepage display or edit (-e) the given mode page\n" 5713 "cmd send the given SCSI command, may need -i or -o as well\n" 5714 "smpcmd send the given SMP command, requires -o and -i\n" 5715 "smprg send the SMP Report General command\n" 5716 "smppc send the SMP PHY Control command, requires -p\n" 5717 "smpphylist display phys attached to a SAS expander\n" 5718 "smpmaninfo send the SMP Report Manufacturer Info command\n" 5719 "debug turn debugging on/off for a bus, target, or lun, or all devices\n" 5720 "tags report or set the number of transaction slots for a device\n" 5721 "negotiate report or set device negotiation parameters\n" 5722 "format send the SCSI FORMAT UNIT command to the named device\n" 5723 "idle send the ATA IDLE command to the named device\n" 5724 "standby send the ATA STANDBY command to the named device\n" 5725 "sleep send the ATA SLEEP command to the named device\n" 5726 "help this message\n" 5727 "Device Identifiers:\n" 5728 "bus:target specify the bus and target, lun defaults to 0\n" 5729 "bus:target:lun specify the bus, target and lun\n" 5730 "deviceUNIT specify the device name, like \"da4\" or \"cd2\"\n" 5731 "Generic arguments:\n" 5732 "-v be verbose, print out sense information\n" 5733 "-t timeout command timeout in seconds, overrides default timeout\n" 5734 "-n dev_name specify device name, e.g. \"da\", \"cd\"\n" 5735 "-u unit specify unit number, e.g. \"0\", \"5\"\n" 5736 "-E have the kernel attempt to perform SCSI error recovery\n" 5737 "-C count specify the SCSI command retry count (needs -E to work)\n" 5738 "modepage arguments:\n" 5739 "-l list all available mode pages\n" 5740 "-m page specify the mode page to view or edit\n" 5741 "-e edit the specified mode page\n" 5742 "-b force view to binary mode\n" 5743 "-d disable block descriptors for mode sense\n" 5744 "-P pgctl page control field 0-3\n" 5745 "defects arguments:\n" 5746 "-f format specify defect list format (block, bfi or phys)\n" 5747 "-G get the grown defect list\n" 5748 "-P get the permanant defect list\n" 5749 "inquiry arguments:\n" 5750 "-D get the standard inquiry data\n" 5751 "-S get the serial number\n" 5752 "-R get the transfer rate, etc.\n" 5753 "reportluns arguments:\n" 5754 "-c only report a count of available LUNs\n" 5755 "-l only print out luns, and not a count\n" 5756 "-r <reporttype> specify \"default\", \"wellknown\" or \"all\"\n" 5757 "readcap arguments\n" 5758 "-b only report the blocksize\n" 5759 "-h human readable device size, base 2\n" 5760 "-H human readable device size, base 10\n" 5761 "-N print the number of blocks instead of last block\n" 5762 "-q quiet, print numbers only\n" 5763 "-s only report the last block/device size\n" 5764 "cmd arguments:\n" 5765 "-c cdb [args] specify the SCSI CDB\n" 5766 "-i len fmt specify input data and input data format\n" 5767 "-o len fmt [args] specify output data and output data fmt\n" 5768 "smpcmd arguments:\n" 5769 "-r len fmt [args] specify the SMP command to be sent\n" 5770 "-R len fmt [args] specify SMP response format\n" 5771 "smprg arguments:\n" 5772 "-l specify the long response format\n" 5773 "smppc arguments:\n" 5774 "-p phy specify the PHY to operate on\n" 5775 "-l specify the long request/response format\n" 5776 "-o operation specify the phy control operation\n" 5777 "-d name set the attached device name\n" 5778 "-m rate set the minimum physical link rate\n" 5779 "-M rate set the maximum physical link rate\n" 5780 "-T pp_timeout set the partial pathway timeout value\n" 5781 "-a enable|disable enable or disable SATA slumber\n" 5782 "-A enable|disable enable or disable SATA partial phy power\n" 5783 "-s enable|disable enable or disable SAS slumber\n" 5784 "-S enable|disable enable or disable SAS partial phy power\n" 5785 "smpphylist arguments:\n" 5786 "-l specify the long response format\n" 5787 "-q only print phys with attached devices\n" 5788 "smpmaninfo arguments:\n" 5789 "-l specify the long response format\n" 5790 "debug arguments:\n" 5791 "-I CAM_DEBUG_INFO -- scsi commands, errors, data\n" 5792 "-T CAM_DEBUG_TRACE -- routine flow tracking\n" 5793 "-S CAM_DEBUG_SUBTRACE -- internal routine command flow\n" 5794 "-c CAM_DEBUG_CDB -- print out SCSI CDBs only\n" 5795 "tags arguments:\n" 5796 "-N tags specify the number of tags to use for this device\n" 5797 "-q be quiet, don't report the number of tags\n" 5798 "-v report a number of tag-related parameters\n" 5799 "negotiate arguments:\n" 5800 "-a send a test unit ready after negotiation\n" 5801 "-c report/set current negotiation settings\n" 5802 "-D <arg> \"enable\" or \"disable\" disconnection\n" 5803 "-M mode set ATA mode\n" 5804 "-O offset set command delay offset\n" 5805 "-q be quiet, don't report anything\n" 5806 "-R syncrate synchronization rate in MHz\n" 5807 "-T <arg> \"enable\" or \"disable\" tagged queueing\n" 5808 "-U report/set user negotiation settings\n" 5809 "-W bus_width set the bus width in bits (8, 16 or 32)\n" 5810 "-v also print a Path Inquiry CCB for the controller\n" 5811 "format arguments:\n" 5812 "-q be quiet, don't print status messages\n" 5813 "-r run in report only mode\n" 5814 "-w don't send immediate format command\n" 5815 "-y don't ask any questions\n" 5816 "idle/standby arguments:\n" 5817 "-t <arg> number of seconds before respective state.\n"); 5818 #endif /* MINIMALISTIC */ 5819 } 5820 5821 int 5822 main(int argc, char **argv) 5823 { 5824 int c; 5825 char *device = NULL; 5826 int unit = 0; 5827 struct cam_device *cam_dev = NULL; 5828 int timeout = 0, retry_count = 1; 5829 camcontrol_optret optreturn; 5830 char *tstr; 5831 const char *mainopt = "C:En:t:u:v"; 5832 const char *subopt = NULL; 5833 char combinedopt[256]; 5834 int error = 0, optstart = 2; 5835 int devopen = 1; 5836 #ifndef MINIMALISTIC 5837 int bus, target, lun; 5838 #endif /* MINIMALISTIC */ 5839 5840 cmdlist = CAM_CMD_NONE; 5841 arglist = CAM_ARG_NONE; 5842 5843 if (argc < 2) { 5844 usage(0); 5845 exit(1); 5846 } 5847 5848 /* 5849 * Get the base option. 5850 */ 5851 optreturn = getoption(option_table,argv[1], &cmdlist, &arglist,&subopt); 5852 5853 if (optreturn == CC_OR_AMBIGUOUS) { 5854 warnx("ambiguous option %s", argv[1]); 5855 usage(0); 5856 exit(1); 5857 } else if (optreturn == CC_OR_NOT_FOUND) { 5858 warnx("option %s not found", argv[1]); 5859 usage(0); 5860 exit(1); 5861 } 5862 5863 /* 5864 * Ahh, getopt(3) is a pain. 5865 * 5866 * This is a gross hack. There really aren't many other good 5867 * options (excuse the pun) for parsing options in a situation like 5868 * this. getopt is kinda braindead, so you end up having to run 5869 * through the options twice, and give each invocation of getopt 5870 * the option string for the other invocation. 5871 * 5872 * You would think that you could just have two groups of options. 5873 * The first group would get parsed by the first invocation of 5874 * getopt, and the second group would get parsed by the second 5875 * invocation of getopt. It doesn't quite work out that way. When 5876 * the first invocation of getopt finishes, it leaves optind pointing 5877 * to the argument _after_ the first argument in the second group. 5878 * So when the second invocation of getopt comes around, it doesn't 5879 * recognize the first argument it gets and then bails out. 5880 * 5881 * A nice alternative would be to have a flag for getopt that says 5882 * "just keep parsing arguments even when you encounter an unknown 5883 * argument", but there isn't one. So there's no real clean way to 5884 * easily parse two sets of arguments without having one invocation 5885 * of getopt know about the other. 5886 * 5887 * Without this hack, the first invocation of getopt would work as 5888 * long as the generic arguments are first, but the second invocation 5889 * (in the subfunction) would fail in one of two ways. In the case 5890 * where you don't set optreset, it would fail because optind may be 5891 * pointing to the argument after the one it should be pointing at. 5892 * In the case where you do set optreset, and reset optind, it would 5893 * fail because getopt would run into the first set of options, which 5894 * it doesn't understand. 5895 * 5896 * All of this would "sort of" work if you could somehow figure out 5897 * whether optind had been incremented one option too far. The 5898 * mechanics of that, however, are more daunting than just giving 5899 * both invocations all of the expect options for either invocation. 5900 * 5901 * Needless to say, I wouldn't mind if someone invented a better 5902 * (non-GPL!) command line parsing interface than getopt. I 5903 * wouldn't mind if someone added more knobs to getopt to make it 5904 * work better. Who knows, I may talk myself into doing it someday, 5905 * if the standards weenies let me. As it is, it just leads to 5906 * hackery like this and causes people to avoid it in some cases. 5907 * 5908 * KDM, September 8th, 1998 5909 */ 5910 if (subopt != NULL) 5911 sprintf(combinedopt, "%s%s", mainopt, subopt); 5912 else 5913 sprintf(combinedopt, "%s", mainopt); 5914 5915 /* 5916 * For these options we do not parse optional device arguments and 5917 * we do not open a passthrough device. 5918 */ 5919 if ((cmdlist == CAM_CMD_RESCAN) 5920 || (cmdlist == CAM_CMD_RESET) 5921 || (cmdlist == CAM_CMD_DEVTREE) 5922 || (cmdlist == CAM_CMD_USAGE) 5923 || (cmdlist == CAM_CMD_DEBUG)) 5924 devopen = 0; 5925 5926 #ifndef MINIMALISTIC 5927 if ((devopen == 1) 5928 && (argc > 2 && argv[2][0] != '-')) { 5929 char name[30]; 5930 int rv; 5931 5932 if (isdigit(argv[2][0])) { 5933 /* device specified as bus:target[:lun] */ 5934 rv = parse_btl(argv[2], &bus, &target, &lun, &arglist); 5935 if (rv < 2) 5936 errx(1, "numeric device specification must " 5937 "be either bus:target, or " 5938 "bus:target:lun"); 5939 /* default to 0 if lun was not specified */ 5940 if ((arglist & CAM_ARG_LUN) == 0) { 5941 lun = 0; 5942 arglist |= CAM_ARG_LUN; 5943 } 5944 optstart++; 5945 } else { 5946 if (cam_get_device(argv[2], name, sizeof name, &unit) 5947 == -1) 5948 errx(1, "%s", cam_errbuf); 5949 device = strdup(name); 5950 arglist |= CAM_ARG_DEVICE | CAM_ARG_UNIT; 5951 optstart++; 5952 } 5953 } 5954 #endif /* MINIMALISTIC */ 5955 /* 5956 * Start getopt processing at argv[2/3], since we've already 5957 * accepted argv[1..2] as the command name, and as a possible 5958 * device name. 5959 */ 5960 optind = optstart; 5961 5962 /* 5963 * Now we run through the argument list looking for generic 5964 * options, and ignoring options that possibly belong to 5965 * subfunctions. 5966 */ 5967 while ((c = getopt(argc, argv, combinedopt))!= -1){ 5968 switch(c) { 5969 case 'C': 5970 retry_count = strtol(optarg, NULL, 0); 5971 if (retry_count < 0) 5972 errx(1, "retry count %d is < 0", 5973 retry_count); 5974 arglist |= CAM_ARG_RETRIES; 5975 break; 5976 case 'E': 5977 arglist |= CAM_ARG_ERR_RECOVER; 5978 break; 5979 case 'n': 5980 arglist |= CAM_ARG_DEVICE; 5981 tstr = optarg; 5982 while (isspace(*tstr) && (*tstr != '\0')) 5983 tstr++; 5984 device = (char *)strdup(tstr); 5985 break; 5986 case 't': 5987 timeout = strtol(optarg, NULL, 0); 5988 if (timeout < 0) 5989 errx(1, "invalid timeout %d", timeout); 5990 /* Convert the timeout from seconds to ms */ 5991 timeout *= 1000; 5992 arglist |= CAM_ARG_TIMEOUT; 5993 break; 5994 case 'u': 5995 arglist |= CAM_ARG_UNIT; 5996 unit = strtol(optarg, NULL, 0); 5997 break; 5998 case 'v': 5999 arglist |= CAM_ARG_VERBOSE; 6000 break; 6001 default: 6002 break; 6003 } 6004 } 6005 6006 #ifndef MINIMALISTIC 6007 /* 6008 * For most commands we'll want to open the passthrough device 6009 * associated with the specified device. In the case of the rescan 6010 * commands, we don't use a passthrough device at all, just the 6011 * transport layer device. 6012 */ 6013 if (devopen == 1) { 6014 if (((arglist & (CAM_ARG_BUS|CAM_ARG_TARGET)) == 0) 6015 && (((arglist & CAM_ARG_DEVICE) == 0) 6016 || ((arglist & CAM_ARG_UNIT) == 0))) { 6017 errx(1, "subcommand \"%s\" requires a valid device " 6018 "identifier", argv[1]); 6019 } 6020 6021 if ((cam_dev = ((arglist & (CAM_ARG_BUS | CAM_ARG_TARGET))? 6022 cam_open_btl(bus, target, lun, O_RDWR, NULL) : 6023 cam_open_spec_device(device,unit,O_RDWR,NULL))) 6024 == NULL) 6025 errx(1,"%s", cam_errbuf); 6026 } 6027 #endif /* MINIMALISTIC */ 6028 6029 /* 6030 * Reset optind to 2, and reset getopt, so these routines can parse 6031 * the arguments again. 6032 */ 6033 optind = optstart; 6034 optreset = 1; 6035 6036 switch(cmdlist) { 6037 #ifndef MINIMALISTIC 6038 case CAM_CMD_DEVLIST: 6039 error = getdevlist(cam_dev); 6040 break; 6041 #endif /* MINIMALISTIC */ 6042 case CAM_CMD_DEVTREE: 6043 error = getdevtree(); 6044 break; 6045 #ifndef MINIMALISTIC 6046 case CAM_CMD_TUR: 6047 error = testunitready(cam_dev, retry_count, timeout, 0); 6048 break; 6049 case CAM_CMD_INQUIRY: 6050 error = scsidoinquiry(cam_dev, argc, argv, combinedopt, 6051 retry_count, timeout); 6052 break; 6053 case CAM_CMD_IDENTIFY: 6054 error = ataidentify(cam_dev, retry_count, timeout); 6055 break; 6056 case CAM_CMD_STARTSTOP: 6057 error = scsistart(cam_dev, arglist & CAM_ARG_START_UNIT, 6058 arglist & CAM_ARG_EJECT, retry_count, 6059 timeout); 6060 break; 6061 #endif /* MINIMALISTIC */ 6062 case CAM_CMD_RESCAN: 6063 error = dorescan_or_reset(argc, argv, 1); 6064 break; 6065 case CAM_CMD_RESET: 6066 error = dorescan_or_reset(argc, argv, 0); 6067 break; 6068 #ifndef MINIMALISTIC 6069 case CAM_CMD_READ_DEFECTS: 6070 error = readdefects(cam_dev, argc, argv, combinedopt, 6071 retry_count, timeout); 6072 break; 6073 case CAM_CMD_MODE_PAGE: 6074 modepage(cam_dev, argc, argv, combinedopt, 6075 retry_count, timeout); 6076 break; 6077 case CAM_CMD_SCSI_CMD: 6078 error = scsicmd(cam_dev, argc, argv, combinedopt, 6079 retry_count, timeout); 6080 break; 6081 case CAM_CMD_SMP_CMD: 6082 error = smpcmd(cam_dev, argc, argv, combinedopt, 6083 retry_count, timeout); 6084 break; 6085 case CAM_CMD_SMP_RG: 6086 error = smpreportgeneral(cam_dev, argc, argv, 6087 combinedopt, retry_count, 6088 timeout); 6089 break; 6090 case CAM_CMD_SMP_PC: 6091 error = smpphycontrol(cam_dev, argc, argv, combinedopt, 6092 retry_count, timeout); 6093 break; 6094 case CAM_CMD_SMP_PHYLIST: 6095 error = smpphylist(cam_dev, argc, argv, combinedopt, 6096 retry_count, timeout); 6097 break; 6098 case CAM_CMD_SMP_MANINFO: 6099 error = smpmaninfo(cam_dev, argc, argv, combinedopt, 6100 retry_count, timeout); 6101 break; 6102 case CAM_CMD_DEBUG: 6103 error = camdebug(argc, argv, combinedopt); 6104 break; 6105 case CAM_CMD_TAG: 6106 error = tagcontrol(cam_dev, argc, argv, combinedopt); 6107 break; 6108 case CAM_CMD_RATE: 6109 error = ratecontrol(cam_dev, retry_count, timeout, 6110 argc, argv, combinedopt); 6111 break; 6112 case CAM_CMD_FORMAT: 6113 error = scsiformat(cam_dev, argc, argv, 6114 combinedopt, retry_count, timeout); 6115 break; 6116 case CAM_CMD_REPORTLUNS: 6117 error = scsireportluns(cam_dev, argc, argv, 6118 combinedopt, retry_count, 6119 timeout); 6120 break; 6121 case CAM_CMD_READCAP: 6122 error = scsireadcapacity(cam_dev, argc, argv, 6123 combinedopt, retry_count, 6124 timeout); 6125 break; 6126 case CAM_CMD_IDLE: 6127 case CAM_CMD_STANDBY: 6128 case CAM_CMD_SLEEP: 6129 error = atapm(cam_dev, argc, argv, 6130 combinedopt, retry_count, 6131 timeout); 6132 break; 6133 #endif /* MINIMALISTIC */ 6134 case CAM_CMD_USAGE: 6135 usage(1); 6136 break; 6137 default: 6138 usage(0); 6139 error = 1; 6140 break; 6141 } 6142 6143 if (cam_dev != NULL) 6144 cam_close_device(cam_dev); 6145 6146 exit(error); 6147 } 6148