camcontrol.c revision 164842
1/* 2 * Copyright (c) 1997, 1998, 1999, 2000, 2001, 2002, 2005, 2006 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: head/sbin/camcontrol/camcontrol.c 164842 2006-12-03 07:11:55Z mjacob $"); 31 32#include <sys/ioctl.h> 33#include <sys/stdint.h> 34#include <sys/types.h> 35 36#include <stdio.h> 37#include <stdlib.h> 38#include <string.h> 39#include <unistd.h> 40#include <fcntl.h> 41#include <ctype.h> 42#include <err.h> 43 44#include <cam/cam.h> 45#include <cam/cam_debug.h> 46#include <cam/cam_ccb.h> 47#include <cam/scsi/scsi_all.h> 48#include <cam/scsi/scsi_da.h> 49#include <cam/scsi/scsi_pass.h> 50#include <cam/scsi/scsi_message.h> 51#include <camlib.h> 52#include "camcontrol.h" 53 54typedef enum { 55 CAM_CMD_NONE = 0x00000000, 56 CAM_CMD_DEVLIST = 0x00000001, 57 CAM_CMD_TUR = 0x00000002, 58 CAM_CMD_INQUIRY = 0x00000003, 59 CAM_CMD_STARTSTOP = 0x00000004, 60 CAM_CMD_RESCAN = 0x00000005, 61 CAM_CMD_READ_DEFECTS = 0x00000006, 62 CAM_CMD_MODE_PAGE = 0x00000007, 63 CAM_CMD_SCSI_CMD = 0x00000008, 64 CAM_CMD_DEVTREE = 0x00000009, 65 CAM_CMD_USAGE = 0x0000000a, 66 CAM_CMD_DEBUG = 0x0000000b, 67 CAM_CMD_RESET = 0x0000000c, 68 CAM_CMD_FORMAT = 0x0000000d, 69 CAM_CMD_TAG = 0x0000000e, 70 CAM_CMD_RATE = 0x0000000f, 71 CAM_CMD_DETACH = 0x00000010, 72 CAM_CMD_REPORTLUNS = 0x00000011 73} cam_cmdmask; 74 75typedef enum { 76 CAM_ARG_NONE = 0x00000000, 77 CAM_ARG_VERBOSE = 0x00000001, 78 CAM_ARG_DEVICE = 0x00000002, 79 CAM_ARG_BUS = 0x00000004, 80 CAM_ARG_TARGET = 0x00000008, 81 CAM_ARG_LUN = 0x00000010, 82 CAM_ARG_EJECT = 0x00000020, 83 CAM_ARG_UNIT = 0x00000040, 84 CAM_ARG_FORMAT_BLOCK = 0x00000080, 85 CAM_ARG_FORMAT_BFI = 0x00000100, 86 CAM_ARG_FORMAT_PHYS = 0x00000200, 87 CAM_ARG_PLIST = 0x00000400, 88 CAM_ARG_GLIST = 0x00000800, 89 CAM_ARG_GET_SERIAL = 0x00001000, 90 CAM_ARG_GET_STDINQ = 0x00002000, 91 CAM_ARG_GET_XFERRATE = 0x00004000, 92 CAM_ARG_INQ_MASK = 0x00007000, 93 CAM_ARG_MODE_EDIT = 0x00008000, 94 CAM_ARG_PAGE_CNTL = 0x00010000, 95 CAM_ARG_TIMEOUT = 0x00020000, 96 CAM_ARG_CMD_IN = 0x00040000, 97 CAM_ARG_CMD_OUT = 0x00080000, 98 CAM_ARG_DBD = 0x00100000, 99 CAM_ARG_ERR_RECOVER = 0x00200000, 100 CAM_ARG_RETRIES = 0x00400000, 101 CAM_ARG_START_UNIT = 0x00800000, 102 CAM_ARG_DEBUG_INFO = 0x01000000, 103 CAM_ARG_DEBUG_TRACE = 0x02000000, 104 CAM_ARG_DEBUG_SUBTRACE = 0x04000000, 105 CAM_ARG_DEBUG_CDB = 0x08000000, 106 CAM_ARG_DEBUG_XPT = 0x10000000, 107 CAM_ARG_DEBUG_PERIPH = 0x20000000, 108} cam_argmask; 109 110struct camcontrol_opts { 111 const char *optname; 112 cam_cmdmask cmdnum; 113 cam_argmask argnum; 114 const char *subopt; 115}; 116 117#ifndef MINIMALISTIC 118static const char scsicmd_opts[] = "c:i:o:"; 119static const char readdefect_opts[] = "f:GP"; 120static const char negotiate_opts[] = "acD:O:qR:T:UW:"; 121#endif 122 123struct camcontrol_opts option_table[] = { 124#ifndef MINIMALISTIC 125 {"tur", CAM_CMD_TUR, CAM_ARG_NONE, NULL}, 126 {"inquiry", CAM_CMD_INQUIRY, CAM_ARG_NONE, "DSR"}, 127 {"start", CAM_CMD_STARTSTOP, CAM_ARG_START_UNIT, NULL}, 128 {"stop", CAM_CMD_STARTSTOP, CAM_ARG_NONE, NULL}, 129 {"load", CAM_CMD_STARTSTOP, CAM_ARG_START_UNIT | CAM_ARG_EJECT, NULL}, 130 {"eject", CAM_CMD_STARTSTOP, CAM_ARG_EJECT, NULL}, 131 {"reportluns", CAM_CMD_REPORTLUNS, CAM_ARG_NONE, "clr:"}, 132#endif /* MINIMALISTIC */ 133 {"rescan", CAM_CMD_RESCAN, CAM_ARG_NONE, NULL}, 134 {"reset", CAM_CMD_RESET, CAM_ARG_NONE, NULL}, 135#ifndef MINIMALISTIC 136 {"cmd", CAM_CMD_SCSI_CMD, CAM_ARG_NONE, scsicmd_opts}, 137 {"command", CAM_CMD_SCSI_CMD, CAM_ARG_NONE, scsicmd_opts}, 138 {"defects", CAM_CMD_READ_DEFECTS, CAM_ARG_NONE, readdefect_opts}, 139 {"defectlist", CAM_CMD_READ_DEFECTS, CAM_ARG_NONE, readdefect_opts}, 140#endif /* MINIMALISTIC */ 141 {"devlist", CAM_CMD_DEVTREE, CAM_ARG_NONE, NULL}, 142#ifndef MINIMALISTIC 143 {"periphlist", CAM_CMD_DEVLIST, CAM_ARG_NONE, NULL}, 144 {"modepage", CAM_CMD_MODE_PAGE, CAM_ARG_NONE, "bdelm:P:"}, 145 {"tags", CAM_CMD_TAG, CAM_ARG_NONE, "N:q"}, 146 {"negotiate", CAM_CMD_RATE, CAM_ARG_NONE, negotiate_opts}, 147 {"rate", CAM_CMD_RATE, CAM_ARG_NONE, negotiate_opts}, 148 {"debug", CAM_CMD_DEBUG, CAM_ARG_NONE, "IPTSXc"}, 149 {"format", CAM_CMD_FORMAT, CAM_ARG_NONE, "qrwy"}, 150#endif /* MINIMALISTIC */ 151 {"help", CAM_CMD_USAGE, CAM_ARG_NONE, NULL}, 152 {"-?", CAM_CMD_USAGE, CAM_ARG_NONE, NULL}, 153 {"-h", CAM_CMD_USAGE, CAM_ARG_NONE, NULL}, 154 {NULL, 0, 0, NULL} 155}; 156 157typedef enum { 158 CC_OR_NOT_FOUND, 159 CC_OR_AMBIGUOUS, 160 CC_OR_FOUND 161} camcontrol_optret; 162 163cam_cmdmask cmdlist; 164cam_argmask arglist; 165 166 167camcontrol_optret getoption(char *arg, cam_cmdmask *cmdnum, cam_argmask *argnum, 168 const char **subopt); 169#ifndef MINIMALISTIC 170static int getdevlist(struct cam_device *device); 171#endif /* MINIMALISTIC */ 172static int getdevtree(void); 173#ifndef MINIMALISTIC 174static int testunitready(struct cam_device *device, int retry_count, 175 int timeout, int quiet); 176static int scsistart(struct cam_device *device, int startstop, int loadeject, 177 int retry_count, int timeout); 178static int scsidoinquiry(struct cam_device *device, int argc, char **argv, 179 char *combinedopt, int retry_count, int timeout); 180static int scsiinquiry(struct cam_device *device, int retry_count, int timeout); 181static int scsiserial(struct cam_device *device, int retry_count, int timeout); 182static int scsixferrate(struct cam_device *device); 183#endif /* MINIMALISTIC */ 184static int parse_btl(char *tstr, int *bus, int *target, int *lun, 185 cam_argmask *arglst); 186static int dorescan_or_reset(int argc, char **argv, int rescan); 187static int rescan_or_reset_bus(int bus, int rescan); 188static int scanlun_or_reset_dev(int bus, int target, int lun, int scan); 189#ifndef MINIMALISTIC 190static int readdefects(struct cam_device *device, int argc, char **argv, 191 char *combinedopt, int retry_count, int timeout); 192static void modepage(struct cam_device *device, int argc, char **argv, 193 char *combinedopt, int retry_count, int timeout); 194static int scsicmd(struct cam_device *device, int argc, char **argv, 195 char *combinedopt, int retry_count, int timeout); 196static int tagcontrol(struct cam_device *device, int argc, char **argv, 197 char *combinedopt); 198static void cts_print(struct cam_device *device, 199 struct ccb_trans_settings *cts); 200static void cpi_print(struct ccb_pathinq *cpi); 201static int get_cpi(struct cam_device *device, struct ccb_pathinq *cpi); 202static int get_print_cts(struct cam_device *device, int user_settings, 203 int quiet, struct ccb_trans_settings *cts); 204static int ratecontrol(struct cam_device *device, int retry_count, 205 int timeout, int argc, char **argv, char *combinedopt); 206static int scsiformat(struct cam_device *device, int argc, char **argv, 207 char *combinedopt, int retry_count, int timeout); 208static int scsireportluns(struct cam_device *device, int argc, char **argv, 209 char *combinedopt, int retry_count, int timeout); 210#endif /* MINIMALISTIC */ 211 212camcontrol_optret 213getoption(char *arg, cam_cmdmask *cmdnum, cam_argmask *argnum, 214 const char **subopt) 215{ 216 struct camcontrol_opts *opts; 217 int num_matches = 0; 218 219 for (opts = option_table; (opts != NULL) && (opts->optname != NULL); 220 opts++) { 221 if (strncmp(opts->optname, arg, strlen(arg)) == 0) { 222 *cmdnum = opts->cmdnum; 223 *argnum = opts->argnum; 224 *subopt = opts->subopt; 225 if (++num_matches > 1) 226 return(CC_OR_AMBIGUOUS); 227 } 228 } 229 230 if (num_matches > 0) 231 return(CC_OR_FOUND); 232 else 233 return(CC_OR_NOT_FOUND); 234} 235 236#ifndef MINIMALISTIC 237static int 238getdevlist(struct cam_device *device) 239{ 240 union ccb *ccb; 241 char status[32]; 242 int error = 0; 243 244 ccb = cam_getccb(device); 245 246 ccb->ccb_h.func_code = XPT_GDEVLIST; 247 ccb->ccb_h.flags = CAM_DIR_NONE; 248 ccb->ccb_h.retry_count = 1; 249 ccb->cgdl.index = 0; 250 ccb->cgdl.status = CAM_GDEVLIST_MORE_DEVS; 251 while (ccb->cgdl.status == CAM_GDEVLIST_MORE_DEVS) { 252 if (cam_send_ccb(device, ccb) < 0) { 253 perror("error getting device list"); 254 cam_freeccb(ccb); 255 return(1); 256 } 257 258 status[0] = '\0'; 259 260 switch (ccb->cgdl.status) { 261 case CAM_GDEVLIST_MORE_DEVS: 262 strcpy(status, "MORE"); 263 break; 264 case CAM_GDEVLIST_LAST_DEVICE: 265 strcpy(status, "LAST"); 266 break; 267 case CAM_GDEVLIST_LIST_CHANGED: 268 strcpy(status, "CHANGED"); 269 break; 270 case CAM_GDEVLIST_ERROR: 271 strcpy(status, "ERROR"); 272 error = 1; 273 break; 274 } 275 276 fprintf(stdout, "%s%d: generation: %d index: %d status: %s\n", 277 ccb->cgdl.periph_name, 278 ccb->cgdl.unit_number, 279 ccb->cgdl.generation, 280 ccb->cgdl.index, 281 status); 282 283 /* 284 * If the list has changed, we need to start over from the 285 * beginning. 286 */ 287 if (ccb->cgdl.status == CAM_GDEVLIST_LIST_CHANGED) 288 ccb->cgdl.index = 0; 289 } 290 291 cam_freeccb(ccb); 292 293 return(error); 294} 295#endif /* MINIMALISTIC */ 296 297static int 298getdevtree(void) 299{ 300 union ccb ccb; 301 int bufsize, fd; 302 unsigned int i; 303 int need_close = 0; 304 int error = 0; 305 int skip_device = 0; 306 307 if ((fd = open(XPT_DEVICE, O_RDWR)) == -1) { 308 warn("couldn't open %s", XPT_DEVICE); 309 return(1); 310 } 311 312 bzero(&ccb, sizeof(union ccb)); 313 314 ccb.ccb_h.path_id = CAM_XPT_PATH_ID; 315 ccb.ccb_h.target_id = CAM_TARGET_WILDCARD; 316 ccb.ccb_h.target_lun = CAM_LUN_WILDCARD; 317 318 ccb.ccb_h.func_code = XPT_DEV_MATCH; 319 bufsize = sizeof(struct dev_match_result) * 100; 320 ccb.cdm.match_buf_len = bufsize; 321 ccb.cdm.matches = (struct dev_match_result *)malloc(bufsize); 322 if (ccb.cdm.matches == NULL) { 323 warnx("can't malloc memory for matches"); 324 close(fd); 325 return(1); 326 } 327 ccb.cdm.num_matches = 0; 328 329 /* 330 * We fetch all nodes, since we display most of them in the default 331 * case, and all in the verbose case. 332 */ 333 ccb.cdm.num_patterns = 0; 334 ccb.cdm.pattern_buf_len = 0; 335 336 /* 337 * We do the ioctl multiple times if necessary, in case there are 338 * more than 100 nodes in the EDT. 339 */ 340 do { 341 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) { 342 warn("error sending CAMIOCOMMAND ioctl"); 343 error = 1; 344 break; 345 } 346 347 if ((ccb.ccb_h.status != CAM_REQ_CMP) 348 || ((ccb.cdm.status != CAM_DEV_MATCH_LAST) 349 && (ccb.cdm.status != CAM_DEV_MATCH_MORE))) { 350 warnx("got CAM error %#x, CDM error %d\n", 351 ccb.ccb_h.status, ccb.cdm.status); 352 error = 1; 353 break; 354 } 355 356 for (i = 0; i < ccb.cdm.num_matches; i++) { 357 switch (ccb.cdm.matches[i].type) { 358 case DEV_MATCH_BUS: { 359 struct bus_match_result *bus_result; 360 361 /* 362 * Only print the bus information if the 363 * user turns on the verbose flag. 364 */ 365 if ((arglist & CAM_ARG_VERBOSE) == 0) 366 break; 367 368 bus_result = 369 &ccb.cdm.matches[i].result.bus_result; 370 371 if (need_close) { 372 fprintf(stdout, ")\n"); 373 need_close = 0; 374 } 375 376 fprintf(stdout, "scbus%d on %s%d bus %d:\n", 377 bus_result->path_id, 378 bus_result->dev_name, 379 bus_result->unit_number, 380 bus_result->bus_id); 381 break; 382 } 383 case DEV_MATCH_DEVICE: { 384 struct device_match_result *dev_result; 385 char vendor[16], product[48], revision[16]; 386 char tmpstr[256]; 387 388 dev_result = 389 &ccb.cdm.matches[i].result.device_result; 390 391 if ((dev_result->flags 392 & DEV_RESULT_UNCONFIGURED) 393 && ((arglist & CAM_ARG_VERBOSE) == 0)) { 394 skip_device = 1; 395 break; 396 } else 397 skip_device = 0; 398 399 cam_strvis(vendor, dev_result->inq_data.vendor, 400 sizeof(dev_result->inq_data.vendor), 401 sizeof(vendor)); 402 cam_strvis(product, 403 dev_result->inq_data.product, 404 sizeof(dev_result->inq_data.product), 405 sizeof(product)); 406 cam_strvis(revision, 407 dev_result->inq_data.revision, 408 sizeof(dev_result->inq_data.revision), 409 sizeof(revision)); 410 sprintf(tmpstr, "<%s %s %s>", vendor, product, 411 revision); 412 if (need_close) { 413 fprintf(stdout, ")\n"); 414 need_close = 0; 415 } 416 417 fprintf(stdout, "%-33s at scbus%d " 418 "target %d lun %d (", 419 tmpstr, 420 dev_result->path_id, 421 dev_result->target_id, 422 dev_result->target_lun); 423 424 need_close = 1; 425 426 break; 427 } 428 case DEV_MATCH_PERIPH: { 429 struct periph_match_result *periph_result; 430 431 periph_result = 432 &ccb.cdm.matches[i].result.periph_result; 433 434 if (skip_device != 0) 435 break; 436 437 if (need_close > 1) 438 fprintf(stdout, ","); 439 440 fprintf(stdout, "%s%d", 441 periph_result->periph_name, 442 periph_result->unit_number); 443 444 need_close++; 445 break; 446 } 447 default: 448 fprintf(stdout, "unknown match type\n"); 449 break; 450 } 451 } 452 453 } while ((ccb.ccb_h.status == CAM_REQ_CMP) 454 && (ccb.cdm.status == CAM_DEV_MATCH_MORE)); 455 456 if (need_close) 457 fprintf(stdout, ")\n"); 458 459 close(fd); 460 461 return(error); 462} 463 464#ifndef MINIMALISTIC 465static int 466testunitready(struct cam_device *device, int retry_count, int timeout, 467 int quiet) 468{ 469 int error = 0; 470 union ccb *ccb; 471 472 ccb = cam_getccb(device); 473 474 scsi_test_unit_ready(&ccb->csio, 475 /* retries */ retry_count, 476 /* cbfcnp */ NULL, 477 /* tag_action */ MSG_SIMPLE_Q_TAG, 478 /* sense_len */ SSD_FULL_SIZE, 479 /* timeout */ timeout ? timeout : 5000); 480 481 /* Disable freezing the device queue */ 482 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 483 484 if (arglist & CAM_ARG_ERR_RECOVER) 485 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER; 486 487 if (cam_send_ccb(device, ccb) < 0) { 488 if (quiet == 0) 489 perror("error sending test unit ready"); 490 491 if (arglist & CAM_ARG_VERBOSE) { 492 cam_error_print(device, ccb, CAM_ESF_ALL, 493 CAM_EPF_ALL, stderr); 494 } 495 496 cam_freeccb(ccb); 497 return(1); 498 } 499 500 if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) { 501 if (quiet == 0) 502 fprintf(stdout, "Unit is ready\n"); 503 } else { 504 if (quiet == 0) 505 fprintf(stdout, "Unit is not ready\n"); 506 error = 1; 507 508 if (arglist & CAM_ARG_VERBOSE) { 509 cam_error_print(device, ccb, CAM_ESF_ALL, 510 CAM_EPF_ALL, stderr); 511 } 512 } 513 514 cam_freeccb(ccb); 515 516 return(error); 517} 518 519static int 520scsistart(struct cam_device *device, int startstop, int loadeject, 521 int retry_count, int timeout) 522{ 523 union ccb *ccb; 524 int error = 0; 525 526 ccb = cam_getccb(device); 527 528 /* 529 * If we're stopping, send an ordered tag so the drive in question 530 * will finish any previously queued writes before stopping. If 531 * the device isn't capable of tagged queueing, or if tagged 532 * queueing is turned off, the tag action is a no-op. 533 */ 534 scsi_start_stop(&ccb->csio, 535 /* retries */ retry_count, 536 /* cbfcnp */ NULL, 537 /* tag_action */ startstop ? MSG_SIMPLE_Q_TAG : 538 MSG_ORDERED_Q_TAG, 539 /* start/stop */ startstop, 540 /* load_eject */ loadeject, 541 /* immediate */ 0, 542 /* sense_len */ SSD_FULL_SIZE, 543 /* timeout */ timeout ? timeout : 120000); 544 545 /* Disable freezing the device queue */ 546 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 547 548 if (arglist & CAM_ARG_ERR_RECOVER) 549 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER; 550 551 if (cam_send_ccb(device, ccb) < 0) { 552 perror("error sending start unit"); 553 554 if (arglist & CAM_ARG_VERBOSE) { 555 cam_error_print(device, ccb, CAM_ESF_ALL, 556 CAM_EPF_ALL, stderr); 557 } 558 559 cam_freeccb(ccb); 560 return(1); 561 } 562 563 if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) 564 if (startstop) { 565 fprintf(stdout, "Unit started successfully"); 566 if (loadeject) 567 fprintf(stdout,", Media loaded\n"); 568 else 569 fprintf(stdout,"\n"); 570 } else { 571 fprintf(stdout, "Unit stopped successfully"); 572 if (loadeject) 573 fprintf(stdout, ", Media ejected\n"); 574 else 575 fprintf(stdout, "\n"); 576 } 577 else { 578 error = 1; 579 if (startstop) 580 fprintf(stdout, 581 "Error received from start unit command\n"); 582 else 583 fprintf(stdout, 584 "Error received from stop unit command\n"); 585 586 if (arglist & CAM_ARG_VERBOSE) { 587 cam_error_print(device, ccb, CAM_ESF_ALL, 588 CAM_EPF_ALL, stderr); 589 } 590 } 591 592 cam_freeccb(ccb); 593 594 return(error); 595} 596 597static int 598scsidoinquiry(struct cam_device *device, int argc, char **argv, 599 char *combinedopt, int retry_count, int timeout) 600{ 601 int c; 602 int error = 0; 603 604 while ((c = getopt(argc, argv, combinedopt)) != -1) { 605 switch(c) { 606 case 'D': 607 arglist |= CAM_ARG_GET_STDINQ; 608 break; 609 case 'R': 610 arglist |= CAM_ARG_GET_XFERRATE; 611 break; 612 case 'S': 613 arglist |= CAM_ARG_GET_SERIAL; 614 break; 615 default: 616 break; 617 } 618 } 619 620 /* 621 * If the user didn't specify any inquiry options, he wants all of 622 * them. 623 */ 624 if ((arglist & CAM_ARG_INQ_MASK) == 0) 625 arglist |= CAM_ARG_INQ_MASK; 626 627 if (arglist & CAM_ARG_GET_STDINQ) 628 error = scsiinquiry(device, retry_count, timeout); 629 630 if (error != 0) 631 return(error); 632 633 if (arglist & CAM_ARG_GET_SERIAL) 634 scsiserial(device, retry_count, timeout); 635 636 if (error != 0) 637 return(error); 638 639 if (arglist & CAM_ARG_GET_XFERRATE) 640 error = scsixferrate(device); 641 642 return(error); 643} 644 645static int 646scsiinquiry(struct cam_device *device, int retry_count, int timeout) 647{ 648 union ccb *ccb; 649 struct scsi_inquiry_data *inq_buf; 650 int error = 0; 651 652 ccb = cam_getccb(device); 653 654 if (ccb == NULL) { 655 warnx("couldn't allocate CCB"); 656 return(1); 657 } 658 659 /* cam_getccb cleans up the header, caller has to zero the payload */ 660 bzero(&(&ccb->ccb_h)[1], 661 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr)); 662 663 inq_buf = (struct scsi_inquiry_data *)malloc( 664 sizeof(struct scsi_inquiry_data)); 665 666 if (inq_buf == NULL) { 667 cam_freeccb(ccb); 668 warnx("can't malloc memory for inquiry\n"); 669 return(1); 670 } 671 bzero(inq_buf, sizeof(*inq_buf)); 672 673 /* 674 * Note that although the size of the inquiry buffer is the full 675 * 256 bytes specified in the SCSI spec, we only tell the device 676 * that we have allocated SHORT_INQUIRY_LENGTH bytes. There are 677 * two reasons for this: 678 * 679 * - The SCSI spec says that when a length field is only 1 byte, 680 * a value of 0 will be interpreted as 256. Therefore 681 * scsi_inquiry() will convert an inq_len (which is passed in as 682 * a u_int32_t, but the field in the CDB is only 1 byte) of 256 683 * to 0. Evidently, very few devices meet the spec in that 684 * regard. Some devices, like many Seagate disks, take the 0 as 685 * 0, and don't return any data. One Pioneer DVD-R drive 686 * returns more data than the command asked for. 687 * 688 * So, since there are numerous devices that just don't work 689 * right with the full inquiry size, we don't send the full size. 690 * 691 * - The second reason not to use the full inquiry data length is 692 * that we don't need it here. The only reason we issue a 693 * standard inquiry is to get the vendor name, device name, 694 * and revision so scsi_print_inquiry() can print them. 695 * 696 * If, at some point in the future, more inquiry data is needed for 697 * some reason, this code should use a procedure similar to the 698 * probe code. i.e., issue a short inquiry, and determine from 699 * the additional length passed back from the device how much 700 * inquiry data the device supports. Once the amount the device 701 * supports is determined, issue an inquiry for that amount and no 702 * more. 703 * 704 * KDM, 2/18/2000 705 */ 706 scsi_inquiry(&ccb->csio, 707 /* retries */ retry_count, 708 /* cbfcnp */ NULL, 709 /* tag_action */ MSG_SIMPLE_Q_TAG, 710 /* inq_buf */ (u_int8_t *)inq_buf, 711 /* inq_len */ SHORT_INQUIRY_LENGTH, 712 /* evpd */ 0, 713 /* page_code */ 0, 714 /* sense_len */ SSD_FULL_SIZE, 715 /* timeout */ timeout ? timeout : 5000); 716 717 /* Disable freezing the device queue */ 718 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 719 720 if (arglist & CAM_ARG_ERR_RECOVER) 721 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER; 722 723 if (cam_send_ccb(device, ccb) < 0) { 724 perror("error sending SCSI inquiry"); 725 726 if (arglist & CAM_ARG_VERBOSE) { 727 cam_error_print(device, ccb, CAM_ESF_ALL, 728 CAM_EPF_ALL, stderr); 729 } 730 731 cam_freeccb(ccb); 732 return(1); 733 } 734 735 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 736 error = 1; 737 738 if (arglist & CAM_ARG_VERBOSE) { 739 cam_error_print(device, ccb, CAM_ESF_ALL, 740 CAM_EPF_ALL, stderr); 741 } 742 } 743 744 cam_freeccb(ccb); 745 746 if (error != 0) { 747 free(inq_buf); 748 return(error); 749 } 750 751 fprintf(stdout, "%s%d: ", device->device_name, 752 device->dev_unit_num); 753 scsi_print_inquiry(inq_buf); 754 755 free(inq_buf); 756 757 return(0); 758} 759 760static int 761scsiserial(struct cam_device *device, int retry_count, int timeout) 762{ 763 union ccb *ccb; 764 struct scsi_vpd_unit_serial_number *serial_buf; 765 char serial_num[SVPD_SERIAL_NUM_SIZE + 1]; 766 int error = 0; 767 768 ccb = cam_getccb(device); 769 770 if (ccb == NULL) { 771 warnx("couldn't allocate CCB"); 772 return(1); 773 } 774 775 /* cam_getccb cleans up the header, caller has to zero the payload */ 776 bzero(&(&ccb->ccb_h)[1], 777 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr)); 778 779 serial_buf = (struct scsi_vpd_unit_serial_number *) 780 malloc(sizeof(*serial_buf)); 781 782 if (serial_buf == NULL) { 783 cam_freeccb(ccb); 784 warnx("can't malloc memory for serial number"); 785 return(1); 786 } 787 788 scsi_inquiry(&ccb->csio, 789 /*retries*/ retry_count, 790 /*cbfcnp*/ NULL, 791 /* tag_action */ MSG_SIMPLE_Q_TAG, 792 /* inq_buf */ (u_int8_t *)serial_buf, 793 /* inq_len */ sizeof(*serial_buf), 794 /* evpd */ 1, 795 /* page_code */ SVPD_UNIT_SERIAL_NUMBER, 796 /* sense_len */ SSD_FULL_SIZE, 797 /* timeout */ timeout ? timeout : 5000); 798 799 /* Disable freezing the device queue */ 800 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 801 802 if (arglist & CAM_ARG_ERR_RECOVER) 803 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER; 804 805 if (cam_send_ccb(device, ccb) < 0) { 806 warn("error getting serial number"); 807 808 if (arglist & CAM_ARG_VERBOSE) { 809 cam_error_print(device, ccb, CAM_ESF_ALL, 810 CAM_EPF_ALL, stderr); 811 } 812 813 cam_freeccb(ccb); 814 free(serial_buf); 815 return(1); 816 } 817 818 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 819 error = 1; 820 821 if (arglist & CAM_ARG_VERBOSE) { 822 cam_error_print(device, ccb, CAM_ESF_ALL, 823 CAM_EPF_ALL, stderr); 824 } 825 } 826 827 cam_freeccb(ccb); 828 829 if (error != 0) { 830 free(serial_buf); 831 return(error); 832 } 833 834 bcopy(serial_buf->serial_num, serial_num, serial_buf->length); 835 serial_num[serial_buf->length] = '\0'; 836 837 if ((arglist & CAM_ARG_GET_STDINQ) 838 || (arglist & CAM_ARG_GET_XFERRATE)) 839 fprintf(stdout, "%s%d: Serial Number ", 840 device->device_name, device->dev_unit_num); 841 842 fprintf(stdout, "%.60s\n", serial_num); 843 844 free(serial_buf); 845 846 return(0); 847} 848 849static int 850scsixferrate(struct cam_device *device) 851{ 852 u_int32_t freq = 0; 853 u_int32_t speed = 0; 854 union ccb *ccb; 855 u_int mb; 856 int retval = 0; 857 858 ccb = cam_getccb(device); 859 860 if (ccb == NULL) { 861 warnx("couldn't allocate CCB"); 862 return(1); 863 } 864 865 bzero(&(&ccb->ccb_h)[1], 866 sizeof(struct ccb_trans_settings) - sizeof(struct ccb_hdr)); 867 868 ccb->ccb_h.func_code = XPT_GET_TRAN_SETTINGS; 869 ccb->cts.type = CTS_TYPE_CURRENT_SETTINGS; 870 871 if (((retval = cam_send_ccb(device, ccb)) < 0) 872 || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) { 873 const char error_string[] = "error getting transfer settings"; 874 875 if (retval < 0) 876 warn(error_string); 877 else 878 warnx(error_string); 879 880 if (arglist & CAM_ARG_VERBOSE) 881 cam_error_print(device, ccb, CAM_ESF_ALL, 882 CAM_EPF_ALL, stderr); 883 884 retval = 1; 885 886 goto xferrate_bailout; 887 888 } 889 890 if (ccb->cts.transport == XPORT_SPI) { 891 struct ccb_trans_settings_spi *spi = 892 &ccb->cts.xport_specific.spi; 893 894 if ((spi->valid & CTS_SPI_VALID_SYNC_RATE) != 0) { 895 freq = scsi_calc_syncsrate(spi->sync_period); 896 speed = freq; 897 } 898 899 fprintf(stdout, "%s%d: ", device->device_name, 900 device->dev_unit_num); 901 902 if ((spi->valid & CTS_SPI_VALID_BUS_WIDTH) != 0) { 903 speed *= (0x01 << spi->bus_width); 904 } 905 906 mb = speed / 1000; 907 908 if (mb > 0) 909 fprintf(stdout, "%d.%03dMB/s transfers ", 910 mb, speed % 1000); 911 else 912 fprintf(stdout, "%dKB/s transfers ", 913 speed); 914 915 if (((spi->valid & CTS_SPI_VALID_SYNC_OFFSET) != 0) 916 && (spi->sync_offset != 0)) 917 fprintf(stdout, "(%d.%03dMHz, offset %d", freq / 1000, 918 freq % 1000, spi->sync_offset); 919 920 if (((spi->valid & CTS_SPI_VALID_BUS_WIDTH) != 0) 921 && (spi->bus_width > 0)) { 922 if (((spi->valid & CTS_SPI_VALID_SYNC_OFFSET) != 0) 923 && (spi->sync_offset != 0)) { 924 fprintf(stdout, ", "); 925 } else { 926 fprintf(stdout, " ("); 927 } 928 fprintf(stdout, "%dbit)", 8 * (0x01 << spi->bus_width)); 929 } else if (((spi->valid & CTS_SPI_VALID_SYNC_OFFSET) != 0) 930 && (spi->sync_offset != 0)) { 931 fprintf(stdout, ")"); 932 } 933 } else { 934 struct ccb_pathinq cpi; 935 936 retval = get_cpi(device, &cpi); 937 938 if (retval != 0) 939 goto xferrate_bailout; 940 941 speed = cpi.base_transfer_speed; 942 freq = 0; 943 944 mb = speed / 1000; 945 946 if (mb > 0) 947 fprintf(stdout, "%d.%03dMB/s transfers ", 948 mb, speed % 1000); 949 else 950 fprintf(stdout, "%dKB/s transfers ", 951 speed); 952 } 953 954 if (ccb->cts.protocol == PROTO_SCSI) { 955 struct ccb_trans_settings_scsi *scsi = 956 &ccb->cts.proto_specific.scsi; 957 if (scsi->valid & CTS_SCSI_VALID_TQ) { 958 if (scsi->flags & CTS_SCSI_FLAGS_TAG_ENB) { 959 fprintf(stdout, ", Command Queueing Enabled"); 960 } 961 } 962 } 963 964 fprintf(stdout, "\n"); 965 966xferrate_bailout: 967 968 cam_freeccb(ccb); 969 970 return(retval); 971} 972#endif /* MINIMALISTIC */ 973 974/* 975 * Parse out a bus, or a bus, target and lun in the following 976 * format: 977 * bus 978 * bus:target 979 * bus:target:lun 980 * 981 * Returns the number of parsed components, or 0. 982 */ 983static int 984parse_btl(char *tstr, int *bus, int *target, int *lun, cam_argmask *arglst) 985{ 986 char *tmpstr; 987 int convs = 0; 988 989 while (isspace(*tstr) && (*tstr != '\0')) 990 tstr++; 991 992 tmpstr = (char *)strtok(tstr, ":"); 993 if ((tmpstr != NULL) && (*tmpstr != '\0')) { 994 *bus = strtol(tmpstr, NULL, 0); 995 *arglst |= CAM_ARG_BUS; 996 convs++; 997 tmpstr = (char *)strtok(NULL, ":"); 998 if ((tmpstr != NULL) && (*tmpstr != '\0')) { 999 *target = strtol(tmpstr, NULL, 0); 1000 *arglst |= CAM_ARG_TARGET; 1001 convs++; 1002 tmpstr = (char *)strtok(NULL, ":"); 1003 if ((tmpstr != NULL) && (*tmpstr != '\0')) { 1004 *lun = strtol(tmpstr, NULL, 0); 1005 *arglst |= CAM_ARG_LUN; 1006 convs++; 1007 } 1008 } 1009 } 1010 1011 return convs; 1012} 1013 1014static int 1015dorescan_or_reset(int argc, char **argv, int rescan) 1016{ 1017 static const char must[] = 1018 "you must specify \"all\", a bus, or a bus:target:lun to %s"; 1019 int rv, error = 0; 1020 int bus = -1, target = -1, lun = -1; 1021 char *tstr; 1022 1023 if (argc < 3) { 1024 warnx(must, rescan? "rescan" : "reset"); 1025 return(1); 1026 } 1027 1028 tstr = argv[optind]; 1029 while (isspace(*tstr) && (*tstr != '\0')) 1030 tstr++; 1031 if (strncasecmp(tstr, "all", strlen("all")) == 0) 1032 arglist |= CAM_ARG_BUS; 1033 else { 1034 rv = parse_btl(argv[optind], &bus, &target, &lun, &arglist); 1035 if (rv != 1 && rv != 3) { 1036 warnx(must, rescan? "rescan" : "reset"); 1037 return(1); 1038 } 1039 } 1040 1041 if ((arglist & CAM_ARG_BUS) 1042 && (arglist & CAM_ARG_TARGET) 1043 && (arglist & CAM_ARG_LUN)) 1044 error = scanlun_or_reset_dev(bus, target, lun, rescan); 1045 else 1046 error = rescan_or_reset_bus(bus, rescan); 1047 1048 return(error); 1049} 1050 1051static int 1052rescan_or_reset_bus(int bus, int rescan) 1053{ 1054 union ccb ccb, matchccb; 1055 int fd, retval; 1056 int bufsize; 1057 1058 retval = 0; 1059 1060 if ((fd = open(XPT_DEVICE, O_RDWR)) < 0) { 1061 warnx("error opening tranport layer device %s", XPT_DEVICE); 1062 warn("%s", XPT_DEVICE); 1063 return(1); 1064 } 1065 1066 if (bus != -1) { 1067 ccb.ccb_h.func_code = rescan ? XPT_SCAN_BUS : XPT_RESET_BUS; 1068 ccb.ccb_h.path_id = bus; 1069 ccb.ccb_h.target_id = CAM_TARGET_WILDCARD; 1070 ccb.ccb_h.target_lun = CAM_LUN_WILDCARD; 1071 ccb.crcn.flags = CAM_FLAG_NONE; 1072 1073 /* run this at a low priority */ 1074 ccb.ccb_h.pinfo.priority = 5; 1075 1076 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) { 1077 warn("CAMIOCOMMAND ioctl failed"); 1078 close(fd); 1079 return(1); 1080 } 1081 1082 if ((ccb.ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) { 1083 fprintf(stdout, "%s of bus %d was successful\n", 1084 rescan ? "Re-scan" : "Reset", bus); 1085 } else { 1086 fprintf(stdout, "%s of bus %d returned error %#x\n", 1087 rescan ? "Re-scan" : "Reset", bus, 1088 ccb.ccb_h.status & CAM_STATUS_MASK); 1089 retval = 1; 1090 } 1091 1092 close(fd); 1093 return(retval); 1094 1095 } 1096 1097 1098 /* 1099 * The right way to handle this is to modify the xpt so that it can 1100 * handle a wildcarded bus in a rescan or reset CCB. At the moment 1101 * that isn't implemented, so instead we enumerate the busses and 1102 * send the rescan or reset to those busses in the case where the 1103 * given bus is -1 (wildcard). We don't send a rescan or reset 1104 * to the xpt bus; sending a rescan to the xpt bus is effectively a 1105 * no-op, sending a rescan to the xpt bus would result in a status of 1106 * CAM_REQ_INVALID. 1107 */ 1108 bzero(&(&matchccb.ccb_h)[1], 1109 sizeof(struct ccb_dev_match) - sizeof(struct ccb_hdr)); 1110 matchccb.ccb_h.func_code = XPT_DEV_MATCH; 1111 bufsize = sizeof(struct dev_match_result) * 20; 1112 matchccb.cdm.match_buf_len = bufsize; 1113 matchccb.cdm.matches=(struct dev_match_result *)malloc(bufsize); 1114 if (matchccb.cdm.matches == NULL) { 1115 warnx("can't malloc memory for matches"); 1116 retval = 1; 1117 goto bailout; 1118 } 1119 matchccb.cdm.num_matches = 0; 1120 1121 matchccb.cdm.num_patterns = 1; 1122 matchccb.cdm.pattern_buf_len = sizeof(struct dev_match_pattern); 1123 1124 matchccb.cdm.patterns = (struct dev_match_pattern *)malloc( 1125 matchccb.cdm.pattern_buf_len); 1126 if (matchccb.cdm.patterns == NULL) { 1127 warnx("can't malloc memory for patterns"); 1128 retval = 1; 1129 goto bailout; 1130 } 1131 matchccb.cdm.patterns[0].type = DEV_MATCH_BUS; 1132 matchccb.cdm.patterns[0].pattern.bus_pattern.flags = BUS_MATCH_ANY; 1133 1134 do { 1135 unsigned int i; 1136 1137 if (ioctl(fd, CAMIOCOMMAND, &matchccb) == -1) { 1138 warn("CAMIOCOMMAND ioctl failed"); 1139 retval = 1; 1140 goto bailout; 1141 } 1142 1143 if ((matchccb.ccb_h.status != CAM_REQ_CMP) 1144 || ((matchccb.cdm.status != CAM_DEV_MATCH_LAST) 1145 && (matchccb.cdm.status != CAM_DEV_MATCH_MORE))) { 1146 warnx("got CAM error %#x, CDM error %d\n", 1147 matchccb.ccb_h.status, matchccb.cdm.status); 1148 retval = 1; 1149 goto bailout; 1150 } 1151 1152 for (i = 0; i < matchccb.cdm.num_matches; i++) { 1153 struct bus_match_result *bus_result; 1154 1155 /* This shouldn't happen. */ 1156 if (matchccb.cdm.matches[i].type != DEV_MATCH_BUS) 1157 continue; 1158 1159 bus_result = &matchccb.cdm.matches[i].result.bus_result; 1160 1161 /* 1162 * We don't want to rescan or reset the xpt bus. 1163 * See above. 1164 */ 1165 if ((int)bus_result->path_id == -1) 1166 continue; 1167 1168 ccb.ccb_h.func_code = rescan ? XPT_SCAN_BUS : 1169 XPT_RESET_BUS; 1170 ccb.ccb_h.path_id = bus_result->path_id; 1171 ccb.ccb_h.target_id = CAM_TARGET_WILDCARD; 1172 ccb.ccb_h.target_lun = CAM_LUN_WILDCARD; 1173 ccb.crcn.flags = CAM_FLAG_NONE; 1174 1175 /* run this at a low priority */ 1176 ccb.ccb_h.pinfo.priority = 5; 1177 1178 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) { 1179 warn("CAMIOCOMMAND ioctl failed"); 1180 retval = 1; 1181 goto bailout; 1182 } 1183 1184 if ((ccb.ccb_h.status & CAM_STATUS_MASK) ==CAM_REQ_CMP){ 1185 fprintf(stdout, "%s of bus %d was successful\n", 1186 rescan? "Re-scan" : "Reset", 1187 bus_result->path_id); 1188 } else { 1189 /* 1190 * Don't bail out just yet, maybe the other 1191 * rescan or reset commands will complete 1192 * successfully. 1193 */ 1194 fprintf(stderr, "%s of bus %d returned error " 1195 "%#x\n", rescan? "Re-scan" : "Reset", 1196 bus_result->path_id, 1197 ccb.ccb_h.status & CAM_STATUS_MASK); 1198 retval = 1; 1199 } 1200 } 1201 } while ((matchccb.ccb_h.status == CAM_REQ_CMP) 1202 && (matchccb.cdm.status == CAM_DEV_MATCH_MORE)); 1203 1204bailout: 1205 1206 if (fd != -1) 1207 close(fd); 1208 1209 if (matchccb.cdm.patterns != NULL) 1210 free(matchccb.cdm.patterns); 1211 if (matchccb.cdm.matches != NULL) 1212 free(matchccb.cdm.matches); 1213 1214 return(retval); 1215} 1216 1217static int 1218scanlun_or_reset_dev(int bus, int target, int lun, int scan) 1219{ 1220 union ccb ccb; 1221 struct cam_device *device; 1222 int fd; 1223 1224 device = NULL; 1225 1226 if (bus < 0) { 1227 warnx("invalid bus number %d", bus); 1228 return(1); 1229 } 1230 1231 if (target < 0) { 1232 warnx("invalid target number %d", target); 1233 return(1); 1234 } 1235 1236 if (lun < 0) { 1237 warnx("invalid lun number %d", lun); 1238 return(1); 1239 } 1240 1241 fd = -1; 1242 1243 bzero(&ccb, sizeof(union ccb)); 1244 1245 if (scan) { 1246 if ((fd = open(XPT_DEVICE, O_RDWR)) < 0) { 1247 warnx("error opening tranport layer device %s\n", 1248 XPT_DEVICE); 1249 warn("%s", XPT_DEVICE); 1250 return(1); 1251 } 1252 } else { 1253 device = cam_open_btl(bus, target, lun, O_RDWR, NULL); 1254 if (device == NULL) { 1255 warnx("%s", cam_errbuf); 1256 return(1); 1257 } 1258 } 1259 1260 ccb.ccb_h.func_code = (scan)? XPT_SCAN_LUN : XPT_RESET_DEV; 1261 ccb.ccb_h.path_id = bus; 1262 ccb.ccb_h.target_id = target; 1263 ccb.ccb_h.target_lun = lun; 1264 ccb.ccb_h.timeout = 5000; 1265 ccb.crcn.flags = CAM_FLAG_NONE; 1266 1267 /* run this at a low priority */ 1268 ccb.ccb_h.pinfo.priority = 5; 1269 1270 if (scan) { 1271 if (ioctl(fd, CAMIOCOMMAND, &ccb) < 0) { 1272 warn("CAMIOCOMMAND ioctl failed"); 1273 close(fd); 1274 return(1); 1275 } 1276 } else { 1277 if (cam_send_ccb(device, &ccb) < 0) { 1278 warn("error sending XPT_RESET_DEV CCB"); 1279 cam_close_device(device); 1280 return(1); 1281 } 1282 } 1283 1284 if (scan) 1285 close(fd); 1286 else 1287 cam_close_device(device); 1288 1289 /* 1290 * An error code of CAM_BDR_SENT is normal for a BDR request. 1291 */ 1292 if (((ccb.ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) 1293 || ((!scan) 1294 && ((ccb.ccb_h.status & CAM_STATUS_MASK) == CAM_BDR_SENT))) { 1295 fprintf(stdout, "%s of %d:%d:%d was successful\n", 1296 scan? "Re-scan" : "Reset", bus, target, lun); 1297 return(0); 1298 } else { 1299 fprintf(stdout, "%s of %d:%d:%d returned error %#x\n", 1300 scan? "Re-scan" : "Reset", bus, target, lun, 1301 ccb.ccb_h.status & CAM_STATUS_MASK); 1302 return(1); 1303 } 1304} 1305 1306#ifndef MINIMALISTIC 1307static int 1308readdefects(struct cam_device *device, int argc, char **argv, 1309 char *combinedopt, int retry_count, int timeout) 1310{ 1311 union ccb *ccb = NULL; 1312 struct scsi_read_defect_data_10 *rdd_cdb; 1313 u_int8_t *defect_list = NULL; 1314 u_int32_t dlist_length = 65000; 1315 u_int32_t returned_length = 0; 1316 u_int32_t num_returned = 0; 1317 u_int8_t returned_format; 1318 unsigned int i; 1319 int c, error = 0; 1320 int lists_specified = 0; 1321 1322 while ((c = getopt(argc, argv, combinedopt)) != -1) { 1323 switch(c){ 1324 case 'f': 1325 { 1326 char *tstr; 1327 tstr = optarg; 1328 while (isspace(*tstr) && (*tstr != '\0')) 1329 tstr++; 1330 if (strcmp(tstr, "block") == 0) 1331 arglist |= CAM_ARG_FORMAT_BLOCK; 1332 else if (strcmp(tstr, "bfi") == 0) 1333 arglist |= CAM_ARG_FORMAT_BFI; 1334 else if (strcmp(tstr, "phys") == 0) 1335 arglist |= CAM_ARG_FORMAT_PHYS; 1336 else { 1337 error = 1; 1338 warnx("invalid defect format %s", tstr); 1339 goto defect_bailout; 1340 } 1341 break; 1342 } 1343 case 'G': 1344 arglist |= CAM_ARG_GLIST; 1345 break; 1346 case 'P': 1347 arglist |= CAM_ARG_PLIST; 1348 break; 1349 default: 1350 break; 1351 } 1352 } 1353 1354 ccb = cam_getccb(device); 1355 1356 /* 1357 * Hopefully 65000 bytes is enough to hold the defect list. If it 1358 * isn't, the disk is probably dead already. We'd have to go with 1359 * 12 byte command (i.e. alloc_length is 32 bits instead of 16) 1360 * to hold them all. 1361 */ 1362 defect_list = malloc(dlist_length); 1363 if (defect_list == NULL) { 1364 warnx("can't malloc memory for defect list"); 1365 error = 1; 1366 goto defect_bailout; 1367 } 1368 1369 rdd_cdb =(struct scsi_read_defect_data_10 *)&ccb->csio.cdb_io.cdb_bytes; 1370 1371 /* 1372 * cam_getccb() zeros the CCB header only. So we need to zero the 1373 * payload portion of the ccb. 1374 */ 1375 bzero(&(&ccb->ccb_h)[1], 1376 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr)); 1377 1378 cam_fill_csio(&ccb->csio, 1379 /*retries*/ retry_count, 1380 /*cbfcnp*/ NULL, 1381 /*flags*/ CAM_DIR_IN | ((arglist & CAM_ARG_ERR_RECOVER) ? 1382 CAM_PASS_ERR_RECOVER : 0), 1383 /*tag_action*/ MSG_SIMPLE_Q_TAG, 1384 /*data_ptr*/ defect_list, 1385 /*dxfer_len*/ dlist_length, 1386 /*sense_len*/ SSD_FULL_SIZE, 1387 /*cdb_len*/ sizeof(struct scsi_read_defect_data_10), 1388 /*timeout*/ timeout ? timeout : 5000); 1389 1390 rdd_cdb->opcode = READ_DEFECT_DATA_10; 1391 if (arglist & CAM_ARG_FORMAT_BLOCK) 1392 rdd_cdb->format = SRDD10_BLOCK_FORMAT; 1393 else if (arglist & CAM_ARG_FORMAT_BFI) 1394 rdd_cdb->format = SRDD10_BYTES_FROM_INDEX_FORMAT; 1395 else if (arglist & CAM_ARG_FORMAT_PHYS) 1396 rdd_cdb->format = SRDD10_PHYSICAL_SECTOR_FORMAT; 1397 else { 1398 error = 1; 1399 warnx("no defect list format specified"); 1400 goto defect_bailout; 1401 } 1402 if (arglist & CAM_ARG_PLIST) { 1403 rdd_cdb->format |= SRDD10_PLIST; 1404 lists_specified++; 1405 } 1406 1407 if (arglist & CAM_ARG_GLIST) { 1408 rdd_cdb->format |= SRDD10_GLIST; 1409 lists_specified++; 1410 } 1411 1412 scsi_ulto2b(dlist_length, rdd_cdb->alloc_length); 1413 1414 /* Disable freezing the device queue */ 1415 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 1416 1417 if (cam_send_ccb(device, ccb) < 0) { 1418 perror("error reading defect list"); 1419 1420 if (arglist & CAM_ARG_VERBOSE) { 1421 cam_error_print(device, ccb, CAM_ESF_ALL, 1422 CAM_EPF_ALL, stderr); 1423 } 1424 1425 error = 1; 1426 goto defect_bailout; 1427 } 1428 1429 returned_length = scsi_2btoul(((struct 1430 scsi_read_defect_data_hdr_10 *)defect_list)->length); 1431 1432 returned_format = ((struct scsi_read_defect_data_hdr_10 *) 1433 defect_list)->format; 1434 1435 if (((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_SCSI_STATUS_ERROR) 1436 && (ccb->csio.scsi_status == SCSI_STATUS_CHECK_COND) 1437 && ((ccb->ccb_h.status & CAM_AUTOSNS_VALID) != 0)) { 1438 struct scsi_sense_data *sense; 1439 int error_code, sense_key, asc, ascq; 1440 1441 sense = &ccb->csio.sense_data; 1442 scsi_extract_sense(sense, &error_code, &sense_key, &asc, &ascq); 1443 1444 /* 1445 * According to the SCSI spec, if the disk doesn't support 1446 * the requested format, it will generally return a sense 1447 * key of RECOVERED ERROR, and an additional sense code 1448 * of "DEFECT LIST NOT FOUND". So, we check for that, and 1449 * also check to make sure that the returned length is 1450 * greater than 0, and then print out whatever format the 1451 * disk gave us. 1452 */ 1453 if ((sense_key == SSD_KEY_RECOVERED_ERROR) 1454 && (asc == 0x1c) && (ascq == 0x00) 1455 && (returned_length > 0)) { 1456 warnx("requested defect format not available"); 1457 switch(returned_format & SRDDH10_DLIST_FORMAT_MASK) { 1458 case SRDD10_BLOCK_FORMAT: 1459 warnx("Device returned block format"); 1460 break; 1461 case SRDD10_BYTES_FROM_INDEX_FORMAT: 1462 warnx("Device returned bytes from index" 1463 " format"); 1464 break; 1465 case SRDD10_PHYSICAL_SECTOR_FORMAT: 1466 warnx("Device returned physical sector format"); 1467 break; 1468 default: 1469 error = 1; 1470 warnx("Device returned unknown defect" 1471 " data format %#x", returned_format); 1472 goto defect_bailout; 1473 break; /* NOTREACHED */ 1474 } 1475 } else { 1476 error = 1; 1477 warnx("Error returned from read defect data command"); 1478 if (arglist & CAM_ARG_VERBOSE) 1479 cam_error_print(device, ccb, CAM_ESF_ALL, 1480 CAM_EPF_ALL, stderr); 1481 goto defect_bailout; 1482 } 1483 } else if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 1484 error = 1; 1485 warnx("Error returned from read defect data command"); 1486 if (arglist & CAM_ARG_VERBOSE) 1487 cam_error_print(device, ccb, CAM_ESF_ALL, 1488 CAM_EPF_ALL, stderr); 1489 goto defect_bailout; 1490 } 1491 1492 /* 1493 * XXX KDM I should probably clean up the printout format for the 1494 * disk defects. 1495 */ 1496 switch (returned_format & SRDDH10_DLIST_FORMAT_MASK){ 1497 case SRDDH10_PHYSICAL_SECTOR_FORMAT: 1498 { 1499 struct scsi_defect_desc_phys_sector *dlist; 1500 1501 dlist = (struct scsi_defect_desc_phys_sector *) 1502 (defect_list + 1503 sizeof(struct scsi_read_defect_data_hdr_10)); 1504 1505 num_returned = returned_length / 1506 sizeof(struct scsi_defect_desc_phys_sector); 1507 1508 fprintf(stderr, "Got %d defect", num_returned); 1509 1510 if ((lists_specified == 0) || (num_returned == 0)) { 1511 fprintf(stderr, "s.\n"); 1512 break; 1513 } else if (num_returned == 1) 1514 fprintf(stderr, ":\n"); 1515 else 1516 fprintf(stderr, "s:\n"); 1517 1518 for (i = 0; i < num_returned; i++) { 1519 fprintf(stdout, "%d:%d:%d\n", 1520 scsi_3btoul(dlist[i].cylinder), 1521 dlist[i].head, 1522 scsi_4btoul(dlist[i].sector)); 1523 } 1524 break; 1525 } 1526 case SRDDH10_BYTES_FROM_INDEX_FORMAT: 1527 { 1528 struct scsi_defect_desc_bytes_from_index *dlist; 1529 1530 dlist = (struct scsi_defect_desc_bytes_from_index *) 1531 (defect_list + 1532 sizeof(struct scsi_read_defect_data_hdr_10)); 1533 1534 num_returned = returned_length / 1535 sizeof(struct scsi_defect_desc_bytes_from_index); 1536 1537 fprintf(stderr, "Got %d defect", num_returned); 1538 1539 if ((lists_specified == 0) || (num_returned == 0)) { 1540 fprintf(stderr, "s.\n"); 1541 break; 1542 } else if (num_returned == 1) 1543 fprintf(stderr, ":\n"); 1544 else 1545 fprintf(stderr, "s:\n"); 1546 1547 for (i = 0; i < num_returned; i++) { 1548 fprintf(stdout, "%d:%d:%d\n", 1549 scsi_3btoul(dlist[i].cylinder), 1550 dlist[i].head, 1551 scsi_4btoul(dlist[i].bytes_from_index)); 1552 } 1553 break; 1554 } 1555 case SRDDH10_BLOCK_FORMAT: 1556 { 1557 struct scsi_defect_desc_block *dlist; 1558 1559 dlist = (struct scsi_defect_desc_block *)(defect_list + 1560 sizeof(struct scsi_read_defect_data_hdr_10)); 1561 1562 num_returned = returned_length / 1563 sizeof(struct scsi_defect_desc_block); 1564 1565 fprintf(stderr, "Got %d defect", num_returned); 1566 1567 if ((lists_specified == 0) || (num_returned == 0)) { 1568 fprintf(stderr, "s.\n"); 1569 break; 1570 } else if (num_returned == 1) 1571 fprintf(stderr, ":\n"); 1572 else 1573 fprintf(stderr, "s:\n"); 1574 1575 for (i = 0; i < num_returned; i++) 1576 fprintf(stdout, "%u\n", 1577 scsi_4btoul(dlist[i].address)); 1578 break; 1579 } 1580 default: 1581 fprintf(stderr, "Unknown defect format %d\n", 1582 returned_format & SRDDH10_DLIST_FORMAT_MASK); 1583 error = 1; 1584 break; 1585 } 1586defect_bailout: 1587 1588 if (defect_list != NULL) 1589 free(defect_list); 1590 1591 if (ccb != NULL) 1592 cam_freeccb(ccb); 1593 1594 return(error); 1595} 1596#endif /* MINIMALISTIC */ 1597 1598#if 0 1599void 1600reassignblocks(struct cam_device *device, u_int32_t *blocks, int num_blocks) 1601{ 1602 union ccb *ccb; 1603 1604 ccb = cam_getccb(device); 1605 1606 cam_freeccb(ccb); 1607} 1608#endif 1609 1610#ifndef MINIMALISTIC 1611void 1612mode_sense(struct cam_device *device, int mode_page, int page_control, 1613 int dbd, int retry_count, int timeout, u_int8_t *data, int datalen) 1614{ 1615 union ccb *ccb; 1616 int retval; 1617 1618 ccb = cam_getccb(device); 1619 1620 if (ccb == NULL) 1621 errx(1, "mode_sense: couldn't allocate CCB"); 1622 1623 bzero(&(&ccb->ccb_h)[1], 1624 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr)); 1625 1626 scsi_mode_sense(&ccb->csio, 1627 /* retries */ retry_count, 1628 /* cbfcnp */ NULL, 1629 /* tag_action */ MSG_SIMPLE_Q_TAG, 1630 /* dbd */ dbd, 1631 /* page_code */ page_control << 6, 1632 /* page */ mode_page, 1633 /* param_buf */ data, 1634 /* param_len */ datalen, 1635 /* sense_len */ SSD_FULL_SIZE, 1636 /* timeout */ timeout ? timeout : 5000); 1637 1638 if (arglist & CAM_ARG_ERR_RECOVER) 1639 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER; 1640 1641 /* Disable freezing the device queue */ 1642 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 1643 1644 if (((retval = cam_send_ccb(device, ccb)) < 0) 1645 || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) { 1646 if (arglist & CAM_ARG_VERBOSE) { 1647 cam_error_print(device, ccb, CAM_ESF_ALL, 1648 CAM_EPF_ALL, stderr); 1649 } 1650 cam_freeccb(ccb); 1651 cam_close_device(device); 1652 if (retval < 0) 1653 err(1, "error sending mode sense command"); 1654 else 1655 errx(1, "error sending mode sense command"); 1656 } 1657 1658 cam_freeccb(ccb); 1659} 1660 1661void 1662mode_select(struct cam_device *device, int save_pages, int retry_count, 1663 int timeout, u_int8_t *data, int datalen) 1664{ 1665 union ccb *ccb; 1666 int retval; 1667 1668 ccb = cam_getccb(device); 1669 1670 if (ccb == NULL) 1671 errx(1, "mode_select: couldn't allocate CCB"); 1672 1673 bzero(&(&ccb->ccb_h)[1], 1674 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr)); 1675 1676 scsi_mode_select(&ccb->csio, 1677 /* retries */ retry_count, 1678 /* cbfcnp */ NULL, 1679 /* tag_action */ MSG_SIMPLE_Q_TAG, 1680 /* scsi_page_fmt */ 1, 1681 /* save_pages */ save_pages, 1682 /* param_buf */ data, 1683 /* param_len */ datalen, 1684 /* sense_len */ SSD_FULL_SIZE, 1685 /* timeout */ timeout ? timeout : 5000); 1686 1687 if (arglist & CAM_ARG_ERR_RECOVER) 1688 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER; 1689 1690 /* Disable freezing the device queue */ 1691 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 1692 1693 if (((retval = cam_send_ccb(device, ccb)) < 0) 1694 || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) { 1695 if (arglist & CAM_ARG_VERBOSE) { 1696 cam_error_print(device, ccb, CAM_ESF_ALL, 1697 CAM_EPF_ALL, stderr); 1698 } 1699 cam_freeccb(ccb); 1700 cam_close_device(device); 1701 1702 if (retval < 0) 1703 err(1, "error sending mode select command"); 1704 else 1705 errx(1, "error sending mode select command"); 1706 1707 } 1708 1709 cam_freeccb(ccb); 1710} 1711 1712void 1713modepage(struct cam_device *device, int argc, char **argv, char *combinedopt, 1714 int retry_count, int timeout) 1715{ 1716 int c, mode_page = -1, page_control = 0; 1717 int binary = 0, list = 0; 1718 1719 while ((c = getopt(argc, argv, combinedopt)) != -1) { 1720 switch(c) { 1721 case 'b': 1722 binary = 1; 1723 break; 1724 case 'd': 1725 arglist |= CAM_ARG_DBD; 1726 break; 1727 case 'e': 1728 arglist |= CAM_ARG_MODE_EDIT; 1729 break; 1730 case 'l': 1731 list = 1; 1732 break; 1733 case 'm': 1734 mode_page = strtol(optarg, NULL, 0); 1735 if (mode_page < 0) 1736 errx(1, "invalid mode page %d", mode_page); 1737 break; 1738 case 'P': 1739 page_control = strtol(optarg, NULL, 0); 1740 if ((page_control < 0) || (page_control > 3)) 1741 errx(1, "invalid page control field %d", 1742 page_control); 1743 arglist |= CAM_ARG_PAGE_CNTL; 1744 break; 1745 default: 1746 break; 1747 } 1748 } 1749 1750 if (mode_page == -1 && list == 0) 1751 errx(1, "you must specify a mode page!"); 1752 1753 if (list) { 1754 mode_list(device, page_control, arglist & CAM_ARG_DBD, 1755 retry_count, timeout); 1756 } else { 1757 mode_edit(device, mode_page, page_control, 1758 arglist & CAM_ARG_DBD, arglist & CAM_ARG_MODE_EDIT, binary, 1759 retry_count, timeout); 1760 } 1761} 1762 1763static int 1764scsicmd(struct cam_device *device, int argc, char **argv, char *combinedopt, 1765 int retry_count, int timeout) 1766{ 1767 union ccb *ccb; 1768 u_int32_t flags = CAM_DIR_NONE; 1769 u_int8_t *data_ptr = NULL; 1770 u_int8_t cdb[20]; 1771 struct get_hook hook; 1772 int c, data_bytes = 0; 1773 int cdb_len = 0; 1774 char *datastr = NULL, *tstr; 1775 int error = 0; 1776 int fd_data = 0; 1777 int retval; 1778 1779 ccb = cam_getccb(device); 1780 1781 if (ccb == NULL) { 1782 warnx("scsicmd: error allocating ccb"); 1783 return(1); 1784 } 1785 1786 bzero(&(&ccb->ccb_h)[1], 1787 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr)); 1788 1789 while ((c = getopt(argc, argv, combinedopt)) != -1) { 1790 switch(c) { 1791 case 'c': 1792 tstr = optarg; 1793 while (isspace(*tstr) && (*tstr != '\0')) 1794 tstr++; 1795 hook.argc = argc - optind; 1796 hook.argv = argv + optind; 1797 hook.got = 0; 1798 cdb_len = buff_encode_visit(cdb, sizeof(cdb), tstr, 1799 iget, &hook); 1800 /* 1801 * Increment optind by the number of arguments the 1802 * encoding routine processed. After each call to 1803 * getopt(3), optind points to the argument that 1804 * getopt should process _next_. In this case, 1805 * that means it points to the first command string 1806 * argument, if there is one. Once we increment 1807 * this, it should point to either the next command 1808 * line argument, or it should be past the end of 1809 * the list. 1810 */ 1811 optind += hook.got; 1812 break; 1813 case 'i': 1814 if (arglist & CAM_ARG_CMD_OUT) { 1815 warnx("command must either be " 1816 "read or write, not both"); 1817 error = 1; 1818 goto scsicmd_bailout; 1819 } 1820 arglist |= CAM_ARG_CMD_IN; 1821 flags = CAM_DIR_IN; 1822 data_bytes = strtol(optarg, NULL, 0); 1823 if (data_bytes <= 0) { 1824 warnx("invalid number of input bytes %d", 1825 data_bytes); 1826 error = 1; 1827 goto scsicmd_bailout; 1828 } 1829 hook.argc = argc - optind; 1830 hook.argv = argv + optind; 1831 hook.got = 0; 1832 optind++; 1833 datastr = cget(&hook, NULL); 1834 /* 1835 * If the user supplied "-" instead of a format, he 1836 * wants the data to be written to stdout. 1837 */ 1838 if ((datastr != NULL) 1839 && (datastr[0] == '-')) 1840 fd_data = 1; 1841 1842 data_ptr = (u_int8_t *)malloc(data_bytes); 1843 if (data_ptr == NULL) { 1844 warnx("can't malloc memory for data_ptr"); 1845 error = 1; 1846 goto scsicmd_bailout; 1847 } 1848 break; 1849 case 'o': 1850 if (arglist & CAM_ARG_CMD_IN) { 1851 warnx("command must either be " 1852 "read or write, not both"); 1853 error = 1; 1854 goto scsicmd_bailout; 1855 } 1856 arglist |= CAM_ARG_CMD_OUT; 1857 flags = CAM_DIR_OUT; 1858 data_bytes = strtol(optarg, NULL, 0); 1859 if (data_bytes <= 0) { 1860 warnx("invalid number of output bytes %d", 1861 data_bytes); 1862 error = 1; 1863 goto scsicmd_bailout; 1864 } 1865 hook.argc = argc - optind; 1866 hook.argv = argv + optind; 1867 hook.got = 0; 1868 datastr = cget(&hook, NULL); 1869 data_ptr = (u_int8_t *)malloc(data_bytes); 1870 if (data_ptr == NULL) { 1871 warnx("can't malloc memory for data_ptr"); 1872 error = 1; 1873 goto scsicmd_bailout; 1874 } 1875 /* 1876 * If the user supplied "-" instead of a format, he 1877 * wants the data to be read from stdin. 1878 */ 1879 if ((datastr != NULL) 1880 && (datastr[0] == '-')) 1881 fd_data = 1; 1882 else 1883 buff_encode_visit(data_ptr, data_bytes, datastr, 1884 iget, &hook); 1885 optind += hook.got; 1886 break; 1887 default: 1888 break; 1889 } 1890 } 1891 1892 /* 1893 * If fd_data is set, and we're writing to the device, we need to 1894 * read the data the user wants written from stdin. 1895 */ 1896 if ((fd_data == 1) && (arglist & CAM_ARG_CMD_OUT)) { 1897 ssize_t amt_read; 1898 int amt_to_read = data_bytes; 1899 u_int8_t *buf_ptr = data_ptr; 1900 1901 for (amt_read = 0; amt_to_read > 0; 1902 amt_read = read(STDIN_FILENO, buf_ptr, amt_to_read)) { 1903 if (amt_read == -1) { 1904 warn("error reading data from stdin"); 1905 error = 1; 1906 goto scsicmd_bailout; 1907 } 1908 amt_to_read -= amt_read; 1909 buf_ptr += amt_read; 1910 } 1911 } 1912 1913 if (arglist & CAM_ARG_ERR_RECOVER) 1914 flags |= CAM_PASS_ERR_RECOVER; 1915 1916 /* Disable freezing the device queue */ 1917 flags |= CAM_DEV_QFRZDIS; 1918 1919 /* 1920 * This is taken from the SCSI-3 draft spec. 1921 * (T10/1157D revision 0.3) 1922 * The top 3 bits of an opcode are the group code. The next 5 bits 1923 * are the command code. 1924 * Group 0: six byte commands 1925 * Group 1: ten byte commands 1926 * Group 2: ten byte commands 1927 * Group 3: reserved 1928 * Group 4: sixteen byte commands 1929 * Group 5: twelve byte commands 1930 * Group 6: vendor specific 1931 * Group 7: vendor specific 1932 */ 1933 switch((cdb[0] >> 5) & 0x7) { 1934 case 0: 1935 cdb_len = 6; 1936 break; 1937 case 1: 1938 case 2: 1939 cdb_len = 10; 1940 break; 1941 case 3: 1942 case 6: 1943 case 7: 1944 /* computed by buff_encode_visit */ 1945 break; 1946 case 4: 1947 cdb_len = 16; 1948 break; 1949 case 5: 1950 cdb_len = 12; 1951 break; 1952 } 1953 1954 /* 1955 * We should probably use csio_build_visit or something like that 1956 * here, but it's easier to encode arguments as you go. The 1957 * alternative would be skipping the CDB argument and then encoding 1958 * it here, since we've got the data buffer argument by now. 1959 */ 1960 bcopy(cdb, &ccb->csio.cdb_io.cdb_bytes, cdb_len); 1961 1962 cam_fill_csio(&ccb->csio, 1963 /*retries*/ retry_count, 1964 /*cbfcnp*/ NULL, 1965 /*flags*/ flags, 1966 /*tag_action*/ MSG_SIMPLE_Q_TAG, 1967 /*data_ptr*/ data_ptr, 1968 /*dxfer_len*/ data_bytes, 1969 /*sense_len*/ SSD_FULL_SIZE, 1970 /*cdb_len*/ cdb_len, 1971 /*timeout*/ timeout ? timeout : 5000); 1972 1973 if (((retval = cam_send_ccb(device, ccb)) < 0) 1974 || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) { 1975 if (retval < 0) 1976 warn("error sending command"); 1977 else 1978 warnx("error sending command"); 1979 1980 if (arglist & CAM_ARG_VERBOSE) { 1981 cam_error_print(device, ccb, CAM_ESF_ALL, 1982 CAM_EPF_ALL, stderr); 1983 } 1984 1985 error = 1; 1986 goto scsicmd_bailout; 1987 } 1988 1989 1990 if (((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) 1991 && (arglist & CAM_ARG_CMD_IN) 1992 && (data_bytes > 0)) { 1993 if (fd_data == 0) { 1994 buff_decode_visit(data_ptr, data_bytes, datastr, 1995 arg_put, NULL); 1996 fprintf(stdout, "\n"); 1997 } else { 1998 ssize_t amt_written; 1999 int amt_to_write = data_bytes; 2000 u_int8_t *buf_ptr = data_ptr; 2001 2002 for (amt_written = 0; (amt_to_write > 0) && 2003 (amt_written =write(1, buf_ptr,amt_to_write))> 0;){ 2004 amt_to_write -= amt_written; 2005 buf_ptr += amt_written; 2006 } 2007 if (amt_written == -1) { 2008 warn("error writing data to stdout"); 2009 error = 1; 2010 goto scsicmd_bailout; 2011 } else if ((amt_written == 0) 2012 && (amt_to_write > 0)) { 2013 warnx("only wrote %u bytes out of %u", 2014 data_bytes - amt_to_write, data_bytes); 2015 } 2016 } 2017 } 2018 2019scsicmd_bailout: 2020 2021 if ((data_bytes > 0) && (data_ptr != NULL)) 2022 free(data_ptr); 2023 2024 cam_freeccb(ccb); 2025 2026 return(error); 2027} 2028 2029static int 2030camdebug(int argc, char **argv, char *combinedopt) 2031{ 2032 int c, fd; 2033 int bus = -1, target = -1, lun = -1; 2034 char *tstr, *tmpstr = NULL; 2035 union ccb ccb; 2036 int error = 0; 2037 2038 bzero(&ccb, sizeof(union ccb)); 2039 2040 while ((c = getopt(argc, argv, combinedopt)) != -1) { 2041 switch(c) { 2042 case 'I': 2043 arglist |= CAM_ARG_DEBUG_INFO; 2044 ccb.cdbg.flags |= CAM_DEBUG_INFO; 2045 break; 2046 case 'P': 2047 arglist |= CAM_ARG_DEBUG_PERIPH; 2048 ccb.cdbg.flags |= CAM_DEBUG_PERIPH; 2049 break; 2050 case 'S': 2051 arglist |= CAM_ARG_DEBUG_SUBTRACE; 2052 ccb.cdbg.flags |= CAM_DEBUG_SUBTRACE; 2053 break; 2054 case 'T': 2055 arglist |= CAM_ARG_DEBUG_TRACE; 2056 ccb.cdbg.flags |= CAM_DEBUG_TRACE; 2057 break; 2058 case 'X': 2059 arglist |= CAM_ARG_DEBUG_XPT; 2060 ccb.cdbg.flags |= CAM_DEBUG_XPT; 2061 break; 2062 case 'c': 2063 arglist |= CAM_ARG_DEBUG_CDB; 2064 ccb.cdbg.flags |= CAM_DEBUG_CDB; 2065 break; 2066 default: 2067 break; 2068 } 2069 } 2070 2071 if ((fd = open(XPT_DEVICE, O_RDWR)) < 0) { 2072 warnx("error opening transport layer device %s", XPT_DEVICE); 2073 warn("%s", XPT_DEVICE); 2074 return(1); 2075 } 2076 argc -= optind; 2077 argv += optind; 2078 2079 if (argc <= 0) { 2080 warnx("you must specify \"off\", \"all\" or a bus,"); 2081 warnx("bus:target, or bus:target:lun"); 2082 close(fd); 2083 return(1); 2084 } 2085 2086 tstr = *argv; 2087 2088 while (isspace(*tstr) && (*tstr != '\0')) 2089 tstr++; 2090 2091 if (strncmp(tstr, "off", 3) == 0) { 2092 ccb.cdbg.flags = CAM_DEBUG_NONE; 2093 arglist &= ~(CAM_ARG_DEBUG_INFO|CAM_ARG_DEBUG_PERIPH| 2094 CAM_ARG_DEBUG_TRACE|CAM_ARG_DEBUG_SUBTRACE| 2095 CAM_ARG_DEBUG_XPT); 2096 } else if (strncmp(tstr, "all", 3) != 0) { 2097 tmpstr = (char *)strtok(tstr, ":"); 2098 if ((tmpstr != NULL) && (*tmpstr != '\0')){ 2099 bus = strtol(tmpstr, NULL, 0); 2100 arglist |= CAM_ARG_BUS; 2101 tmpstr = (char *)strtok(NULL, ":"); 2102 if ((tmpstr != NULL) && (*tmpstr != '\0')){ 2103 target = strtol(tmpstr, NULL, 0); 2104 arglist |= CAM_ARG_TARGET; 2105 tmpstr = (char *)strtok(NULL, ":"); 2106 if ((tmpstr != NULL) && (*tmpstr != '\0')){ 2107 lun = strtol(tmpstr, NULL, 0); 2108 arglist |= CAM_ARG_LUN; 2109 } 2110 } 2111 } else { 2112 error = 1; 2113 warnx("you must specify \"all\", \"off\", or a bus,"); 2114 warnx("bus:target, or bus:target:lun to debug"); 2115 } 2116 } 2117 2118 if (error == 0) { 2119 2120 ccb.ccb_h.func_code = XPT_DEBUG; 2121 ccb.ccb_h.path_id = bus; 2122 ccb.ccb_h.target_id = target; 2123 ccb.ccb_h.target_lun = lun; 2124 2125 if (ioctl(fd, CAMIOCOMMAND, &ccb) == -1) { 2126 warn("CAMIOCOMMAND ioctl failed"); 2127 error = 1; 2128 } 2129 2130 if (error == 0) { 2131 if ((ccb.ccb_h.status & CAM_STATUS_MASK) == 2132 CAM_FUNC_NOTAVAIL) { 2133 warnx("CAM debugging not available"); 2134 warnx("you need to put options CAMDEBUG in" 2135 " your kernel config file!"); 2136 error = 1; 2137 } else if ((ccb.ccb_h.status & CAM_STATUS_MASK) != 2138 CAM_REQ_CMP) { 2139 warnx("XPT_DEBUG CCB failed with status %#x", 2140 ccb.ccb_h.status); 2141 error = 1; 2142 } else { 2143 if (ccb.cdbg.flags == CAM_DEBUG_NONE) { 2144 fprintf(stderr, 2145 "Debugging turned off\n"); 2146 } else { 2147 fprintf(stderr, 2148 "Debugging enabled for " 2149 "%d:%d:%d\n", 2150 bus, target, lun); 2151 } 2152 } 2153 } 2154 close(fd); 2155 } 2156 2157 return(error); 2158} 2159 2160static int 2161tagcontrol(struct cam_device *device, int argc, char **argv, 2162 char *combinedopt) 2163{ 2164 int c; 2165 union ccb *ccb; 2166 int numtags = -1; 2167 int retval = 0; 2168 int quiet = 0; 2169 char pathstr[1024]; 2170 2171 ccb = cam_getccb(device); 2172 2173 if (ccb == NULL) { 2174 warnx("tagcontrol: error allocating ccb"); 2175 return(1); 2176 } 2177 2178 while ((c = getopt(argc, argv, combinedopt)) != -1) { 2179 switch(c) { 2180 case 'N': 2181 numtags = strtol(optarg, NULL, 0); 2182 if (numtags < 0) { 2183 warnx("tag count %d is < 0", numtags); 2184 retval = 1; 2185 goto tagcontrol_bailout; 2186 } 2187 break; 2188 case 'q': 2189 quiet++; 2190 break; 2191 default: 2192 break; 2193 } 2194 } 2195 2196 cam_path_string(device, pathstr, sizeof(pathstr)); 2197 2198 if (numtags >= 0) { 2199 bzero(&(&ccb->ccb_h)[1], 2200 sizeof(struct ccb_relsim) - sizeof(struct ccb_hdr)); 2201 ccb->ccb_h.func_code = XPT_REL_SIMQ; 2202 ccb->crs.release_flags = RELSIM_ADJUST_OPENINGS; 2203 ccb->crs.openings = numtags; 2204 2205 2206 if (cam_send_ccb(device, ccb) < 0) { 2207 perror("error sending XPT_REL_SIMQ CCB"); 2208 retval = 1; 2209 goto tagcontrol_bailout; 2210 } 2211 2212 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 2213 warnx("XPT_REL_SIMQ CCB failed"); 2214 cam_error_print(device, ccb, CAM_ESF_ALL, 2215 CAM_EPF_ALL, stderr); 2216 retval = 1; 2217 goto tagcontrol_bailout; 2218 } 2219 2220 2221 if (quiet == 0) 2222 fprintf(stdout, "%stagged openings now %d\n", 2223 pathstr, ccb->crs.openings); 2224 } 2225 2226 bzero(&(&ccb->ccb_h)[1], 2227 sizeof(struct ccb_getdevstats) - sizeof(struct ccb_hdr)); 2228 2229 ccb->ccb_h.func_code = XPT_GDEV_STATS; 2230 2231 if (cam_send_ccb(device, ccb) < 0) { 2232 perror("error sending XPT_GDEV_STATS CCB"); 2233 retval = 1; 2234 goto tagcontrol_bailout; 2235 } 2236 2237 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 2238 warnx("XPT_GDEV_STATS CCB failed"); 2239 cam_error_print(device, ccb, CAM_ESF_ALL, 2240 CAM_EPF_ALL, stderr); 2241 retval = 1; 2242 goto tagcontrol_bailout; 2243 } 2244 2245 if (arglist & CAM_ARG_VERBOSE) { 2246 fprintf(stdout, "%s", pathstr); 2247 fprintf(stdout, "dev_openings %d\n", ccb->cgds.dev_openings); 2248 fprintf(stdout, "%s", pathstr); 2249 fprintf(stdout, "dev_active %d\n", ccb->cgds.dev_active); 2250 fprintf(stdout, "%s", pathstr); 2251 fprintf(stdout, "devq_openings %d\n", ccb->cgds.devq_openings); 2252 fprintf(stdout, "%s", pathstr); 2253 fprintf(stdout, "devq_queued %d\n", ccb->cgds.devq_queued); 2254 fprintf(stdout, "%s", pathstr); 2255 fprintf(stdout, "held %d\n", ccb->cgds.held); 2256 fprintf(stdout, "%s", pathstr); 2257 fprintf(stdout, "mintags %d\n", ccb->cgds.mintags); 2258 fprintf(stdout, "%s", pathstr); 2259 fprintf(stdout, "maxtags %d\n", ccb->cgds.maxtags); 2260 } else { 2261 if (quiet == 0) { 2262 fprintf(stdout, "%s", pathstr); 2263 fprintf(stdout, "device openings: "); 2264 } 2265 fprintf(stdout, "%d\n", ccb->cgds.dev_openings + 2266 ccb->cgds.dev_active); 2267 } 2268 2269tagcontrol_bailout: 2270 2271 cam_freeccb(ccb); 2272 return(retval); 2273} 2274 2275static void 2276cts_print(struct cam_device *device, struct ccb_trans_settings *cts) 2277{ 2278 char pathstr[1024]; 2279 2280 cam_path_string(device, pathstr, sizeof(pathstr)); 2281 2282 if (cts->transport == XPORT_SPI) { 2283 struct ccb_trans_settings_spi *spi = 2284 &cts->xport_specific.spi; 2285 2286 if ((spi->valid & CTS_SPI_VALID_SYNC_RATE) != 0) { 2287 2288 fprintf(stdout, "%ssync parameter: %d\n", pathstr, 2289 spi->sync_period); 2290 2291 if (spi->sync_offset != 0) { 2292 u_int freq; 2293 2294 freq = scsi_calc_syncsrate(spi->sync_period); 2295 fprintf(stdout, "%sfrequency: %d.%03dMHz\n", 2296 pathstr, freq / 1000, freq % 1000); 2297 } 2298 } 2299 2300 if (spi->valid & CTS_SPI_VALID_SYNC_OFFSET) { 2301 fprintf(stdout, "%soffset: %d\n", pathstr, 2302 spi->sync_offset); 2303 } 2304 2305 if (spi->valid & CTS_SPI_VALID_BUS_WIDTH) { 2306 fprintf(stdout, "%sbus width: %d bits\n", pathstr, 2307 (0x01 << spi->bus_width) * 8); 2308 } 2309 2310 if (spi->valid & CTS_SPI_VALID_DISC) { 2311 fprintf(stdout, "%sdisconnection is %s\n", pathstr, 2312 (spi->flags & CTS_SPI_FLAGS_DISC_ENB) ? 2313 "enabled" : "disabled"); 2314 } 2315 } 2316 2317 if (cts->protocol == PROTO_SCSI) { 2318 struct ccb_trans_settings_scsi *scsi= 2319 &cts->proto_specific.scsi; 2320 2321 if (scsi->valid & CTS_SCSI_VALID_TQ) { 2322 fprintf(stdout, "%stagged queueing is %s\n", pathstr, 2323 (scsi->flags & CTS_SCSI_FLAGS_TAG_ENB) ? 2324 "enabled" : "disabled"); 2325 } 2326 } 2327 2328} 2329 2330/* 2331 * Get a path inquiry CCB for the specified device. 2332 */ 2333static int 2334get_cpi(struct cam_device *device, struct ccb_pathinq *cpi) 2335{ 2336 union ccb *ccb; 2337 int retval = 0; 2338 2339 ccb = cam_getccb(device); 2340 2341 if (ccb == NULL) { 2342 warnx("get_cpi: couldn't allocate CCB"); 2343 return(1); 2344 } 2345 2346 bzero(&(&ccb->ccb_h)[1], 2347 sizeof(struct ccb_pathinq) - sizeof(struct ccb_hdr)); 2348 2349 ccb->ccb_h.func_code = XPT_PATH_INQ; 2350 2351 if (cam_send_ccb(device, ccb) < 0) { 2352 warn("get_cpi: error sending Path Inquiry CCB"); 2353 2354 if (arglist & CAM_ARG_VERBOSE) 2355 cam_error_print(device, ccb, CAM_ESF_ALL, 2356 CAM_EPF_ALL, stderr); 2357 2358 retval = 1; 2359 2360 goto get_cpi_bailout; 2361 } 2362 2363 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 2364 2365 if (arglist & CAM_ARG_VERBOSE) 2366 cam_error_print(device, ccb, CAM_ESF_ALL, 2367 CAM_EPF_ALL, stderr); 2368 2369 retval = 1; 2370 2371 goto get_cpi_bailout; 2372 } 2373 2374 bcopy(&ccb->cpi, cpi, sizeof(struct ccb_pathinq)); 2375 2376get_cpi_bailout: 2377 2378 cam_freeccb(ccb); 2379 2380 return(retval); 2381} 2382 2383static void 2384cpi_print(struct ccb_pathinq *cpi) 2385{ 2386 char adapter_str[1024]; 2387 int i; 2388 2389 snprintf(adapter_str, sizeof(adapter_str), 2390 "%s%d:", cpi->dev_name, cpi->unit_number); 2391 2392 fprintf(stdout, "%s SIM/HBA version: %d\n", adapter_str, 2393 cpi->version_num); 2394 2395 for (i = 1; i < 0xff; i = i << 1) { 2396 const char *str; 2397 2398 if ((i & cpi->hba_inquiry) == 0) 2399 continue; 2400 2401 fprintf(stdout, "%s supports ", adapter_str); 2402 2403 switch(i) { 2404 case PI_MDP_ABLE: 2405 str = "MDP message"; 2406 break; 2407 case PI_WIDE_32: 2408 str = "32 bit wide SCSI"; 2409 break; 2410 case PI_WIDE_16: 2411 str = "16 bit wide SCSI"; 2412 break; 2413 case PI_SDTR_ABLE: 2414 str = "SDTR message"; 2415 break; 2416 case PI_LINKED_CDB: 2417 str = "linked CDBs"; 2418 break; 2419 case PI_TAG_ABLE: 2420 str = "tag queue messages"; 2421 break; 2422 case PI_SOFT_RST: 2423 str = "soft reset alternative"; 2424 break; 2425 default: 2426 str = "unknown PI bit set"; 2427 break; 2428 } 2429 fprintf(stdout, "%s\n", str); 2430 } 2431 2432 for (i = 1; i < 0xff; i = i << 1) { 2433 const char *str; 2434 2435 if ((i & cpi->hba_misc) == 0) 2436 continue; 2437 2438 fprintf(stdout, "%s ", adapter_str); 2439 2440 switch(i) { 2441 case PIM_SCANHILO: 2442 str = "bus scans from high ID to low ID"; 2443 break; 2444 case PIM_NOREMOVE: 2445 str = "removable devices not included in scan"; 2446 break; 2447 case PIM_NOINITIATOR: 2448 str = "initiator role not supported"; 2449 break; 2450 case PIM_NOBUSRESET: 2451 str = "user has disabled initial BUS RESET or" 2452 " controller is in target/mixed mode"; 2453 break; 2454 default: 2455 str = "unknown PIM bit set"; 2456 break; 2457 } 2458 fprintf(stdout, "%s\n", str); 2459 } 2460 2461 for (i = 1; i < 0xff; i = i << 1) { 2462 const char *str; 2463 2464 if ((i & cpi->target_sprt) == 0) 2465 continue; 2466 2467 fprintf(stdout, "%s supports ", adapter_str); 2468 switch(i) { 2469 case PIT_PROCESSOR: 2470 str = "target mode processor mode"; 2471 break; 2472 case PIT_PHASE: 2473 str = "target mode phase cog. mode"; 2474 break; 2475 case PIT_DISCONNECT: 2476 str = "disconnects in target mode"; 2477 break; 2478 case PIT_TERM_IO: 2479 str = "terminate I/O message in target mode"; 2480 break; 2481 case PIT_GRP_6: 2482 str = "group 6 commands in target mode"; 2483 break; 2484 case PIT_GRP_7: 2485 str = "group 7 commands in target mode"; 2486 break; 2487 default: 2488 str = "unknown PIT bit set"; 2489 break; 2490 } 2491 2492 fprintf(stdout, "%s\n", str); 2493 } 2494 fprintf(stdout, "%s HBA engine count: %d\n", adapter_str, 2495 cpi->hba_eng_cnt); 2496 fprintf(stdout, "%s maximum target: %d\n", adapter_str, 2497 cpi->max_target); 2498 fprintf(stdout, "%s maximum LUN: %d\n", adapter_str, 2499 cpi->max_lun); 2500 fprintf(stdout, "%s highest path ID in subsystem: %d\n", 2501 adapter_str, cpi->hpath_id); 2502 fprintf(stdout, "%s initiator ID: %d\n", adapter_str, 2503 cpi->initiator_id); 2504 fprintf(stdout, "%s SIM vendor: %s\n", adapter_str, cpi->sim_vid); 2505 fprintf(stdout, "%s HBA vendor: %s\n", adapter_str, cpi->hba_vid); 2506 fprintf(stdout, "%s bus ID: %d\n", adapter_str, cpi->bus_id); 2507 fprintf(stdout, "%s base transfer speed: ", adapter_str); 2508 if (cpi->base_transfer_speed > 1000) 2509 fprintf(stdout, "%d.%03dMB/sec\n", 2510 cpi->base_transfer_speed / 1000, 2511 cpi->base_transfer_speed % 1000); 2512 else 2513 fprintf(stdout, "%dKB/sec\n", 2514 (cpi->base_transfer_speed % 1000) * 1000); 2515} 2516 2517static int 2518get_print_cts(struct cam_device *device, int user_settings, int quiet, 2519 struct ccb_trans_settings *cts) 2520{ 2521 int retval; 2522 union ccb *ccb; 2523 2524 retval = 0; 2525 ccb = cam_getccb(device); 2526 2527 if (ccb == NULL) { 2528 warnx("get_print_cts: error allocating ccb"); 2529 return(1); 2530 } 2531 2532 bzero(&(&ccb->ccb_h)[1], 2533 sizeof(struct ccb_trans_settings) - sizeof(struct ccb_hdr)); 2534 2535 ccb->ccb_h.func_code = XPT_GET_TRAN_SETTINGS; 2536 2537 if (user_settings == 0) 2538 ccb->cts.type = CTS_TYPE_CURRENT_SETTINGS; 2539 else 2540 ccb->cts.type = CTS_TYPE_USER_SETTINGS; 2541 2542 if (cam_send_ccb(device, ccb) < 0) { 2543 perror("error sending XPT_GET_TRAN_SETTINGS CCB"); 2544 if (arglist & CAM_ARG_VERBOSE) 2545 cam_error_print(device, ccb, CAM_ESF_ALL, 2546 CAM_EPF_ALL, stderr); 2547 retval = 1; 2548 goto get_print_cts_bailout; 2549 } 2550 2551 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 2552 warnx("XPT_GET_TRANS_SETTINGS CCB failed"); 2553 if (arglist & CAM_ARG_VERBOSE) 2554 cam_error_print(device, ccb, CAM_ESF_ALL, 2555 CAM_EPF_ALL, stderr); 2556 retval = 1; 2557 goto get_print_cts_bailout; 2558 } 2559 2560 if (quiet == 0) 2561 cts_print(device, &ccb->cts); 2562 2563 if (cts != NULL) 2564 bcopy(&ccb->cts, cts, sizeof(struct ccb_trans_settings)); 2565 2566get_print_cts_bailout: 2567 2568 cam_freeccb(ccb); 2569 2570 return(retval); 2571} 2572 2573static int 2574ratecontrol(struct cam_device *device, int retry_count, int timeout, 2575 int argc, char **argv, char *combinedopt) 2576{ 2577 int c; 2578 union ccb *ccb; 2579 int user_settings = 0; 2580 int retval = 0; 2581 int disc_enable = -1, tag_enable = -1; 2582 int offset = -1; 2583 double syncrate = -1; 2584 int bus_width = -1; 2585 int quiet = 0; 2586 int change_settings = 0, send_tur = 0; 2587 struct ccb_pathinq cpi; 2588 2589 ccb = cam_getccb(device); 2590 2591 if (ccb == NULL) { 2592 warnx("ratecontrol: error allocating ccb"); 2593 return(1); 2594 } 2595 2596 while ((c = getopt(argc, argv, combinedopt)) != -1) { 2597 switch(c){ 2598 case 'a': 2599 send_tur = 1; 2600 break; 2601 case 'c': 2602 user_settings = 0; 2603 break; 2604 case 'D': 2605 if (strncasecmp(optarg, "enable", 6) == 0) 2606 disc_enable = 1; 2607 else if (strncasecmp(optarg, "disable", 7) == 0) 2608 disc_enable = 0; 2609 else { 2610 warnx("-D argument \"%s\" is unknown", optarg); 2611 retval = 1; 2612 goto ratecontrol_bailout; 2613 } 2614 change_settings = 1; 2615 break; 2616 case 'O': 2617 offset = strtol(optarg, NULL, 0); 2618 if (offset < 0) { 2619 warnx("offset value %d is < 0", offset); 2620 retval = 1; 2621 goto ratecontrol_bailout; 2622 } 2623 change_settings = 1; 2624 break; 2625 case 'q': 2626 quiet++; 2627 break; 2628 case 'R': 2629 syncrate = atof(optarg); 2630 2631 if (syncrate < 0) { 2632 warnx("sync rate %f is < 0", syncrate); 2633 retval = 1; 2634 goto ratecontrol_bailout; 2635 } 2636 change_settings = 1; 2637 break; 2638 case 'T': 2639 if (strncasecmp(optarg, "enable", 6) == 0) 2640 tag_enable = 1; 2641 else if (strncasecmp(optarg, "disable", 7) == 0) 2642 tag_enable = 0; 2643 else { 2644 warnx("-T argument \"%s\" is unknown", optarg); 2645 retval = 1; 2646 goto ratecontrol_bailout; 2647 } 2648 change_settings = 1; 2649 break; 2650 case 'U': 2651 user_settings = 1; 2652 break; 2653 case 'W': 2654 bus_width = strtol(optarg, NULL, 0); 2655 if (bus_width < 0) { 2656 warnx("bus width %d is < 0", bus_width); 2657 retval = 1; 2658 goto ratecontrol_bailout; 2659 } 2660 change_settings = 1; 2661 break; 2662 default: 2663 break; 2664 } 2665 } 2666 2667 bzero(&(&ccb->ccb_h)[1], 2668 sizeof(struct ccb_pathinq) - sizeof(struct ccb_hdr)); 2669 2670 /* 2671 * Grab path inquiry information, so we can determine whether 2672 * or not the initiator is capable of the things that the user 2673 * requests. 2674 */ 2675 ccb->ccb_h.func_code = XPT_PATH_INQ; 2676 2677 if (cam_send_ccb(device, ccb) < 0) { 2678 perror("error sending XPT_PATH_INQ CCB"); 2679 if (arglist & CAM_ARG_VERBOSE) { 2680 cam_error_print(device, ccb, CAM_ESF_ALL, 2681 CAM_EPF_ALL, stderr); 2682 } 2683 retval = 1; 2684 goto ratecontrol_bailout; 2685 } 2686 2687 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 2688 warnx("XPT_PATH_INQ CCB failed"); 2689 if (arglist & CAM_ARG_VERBOSE) { 2690 cam_error_print(device, ccb, CAM_ESF_ALL, 2691 CAM_EPF_ALL, stderr); 2692 } 2693 retval = 1; 2694 goto ratecontrol_bailout; 2695 } 2696 2697 bcopy(&ccb->cpi, &cpi, sizeof(struct ccb_pathinq)); 2698 2699 bzero(&(&ccb->ccb_h)[1], 2700 sizeof(struct ccb_trans_settings) - sizeof(struct ccb_hdr)); 2701 2702 if (quiet == 0) 2703 fprintf(stdout, "Current Parameters:\n"); 2704 2705 retval = get_print_cts(device, user_settings, quiet, &ccb->cts); 2706 2707 if (retval != 0) 2708 goto ratecontrol_bailout; 2709 2710 if (arglist & CAM_ARG_VERBOSE) 2711 cpi_print(&cpi); 2712 2713 if (change_settings) { 2714 int didsettings = 0; 2715 struct ccb_trans_settings_spi *spi = NULL; 2716 struct ccb_trans_settings_scsi *scsi = NULL; 2717 2718 if (ccb->cts.transport == XPORT_SPI) { 2719 spi = &ccb->cts.xport_specific.spi; 2720 spi->valid = 0; 2721 } 2722 if (ccb->cts.protocol == PROTO_SCSI) { 2723 scsi = &ccb->cts.proto_specific.scsi; 2724 scsi->valid = 0; 2725 } 2726 if (spi && disc_enable != -1) { 2727 spi->valid |= CTS_SPI_VALID_DISC; 2728 if (disc_enable == 0) 2729 spi->flags &= ~CTS_SPI_FLAGS_DISC_ENB; 2730 else 2731 spi->flags |= CTS_SPI_FLAGS_DISC_ENB; 2732 } 2733 2734 if (scsi && tag_enable != -1) { 2735 if ((cpi.hba_inquiry & PI_TAG_ABLE) == 0) { 2736 warnx("HBA does not support tagged queueing, " 2737 "so you cannot modify tag settings"); 2738 retval = 1; 2739 goto ratecontrol_bailout; 2740 } 2741 2742 scsi->valid |= CTS_SCSI_VALID_TQ; 2743 2744 if (tag_enable == 0) 2745 scsi->flags &= ~CTS_SCSI_FLAGS_TAG_ENB; 2746 else 2747 scsi->flags |= CTS_SCSI_FLAGS_TAG_ENB; 2748 didsettings++; 2749 } 2750 2751 if (spi && offset != -1) { 2752 if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) { 2753 warnx("HBA at %s%d is not cable of changing " 2754 "offset", cpi.dev_name, 2755 cpi.unit_number); 2756 retval = 1; 2757 goto ratecontrol_bailout; 2758 } 2759 spi->valid |= CTS_SPI_VALID_SYNC_OFFSET; 2760 spi->sync_offset = offset; 2761 didsettings++; 2762 } 2763 2764 if (spi && syncrate != -1) { 2765 int prelim_sync_period; 2766 u_int freq; 2767 2768 if ((cpi.hba_inquiry & PI_SDTR_ABLE) == 0) { 2769 warnx("HBA at %s%d is not cable of changing " 2770 "transfer rates", cpi.dev_name, 2771 cpi.unit_number); 2772 retval = 1; 2773 goto ratecontrol_bailout; 2774 } 2775 2776 spi->valid |= CTS_SPI_VALID_SYNC_RATE; 2777 2778 /* 2779 * The sync rate the user gives us is in MHz. 2780 * We need to translate it into KHz for this 2781 * calculation. 2782 */ 2783 syncrate *= 1000; 2784 2785 /* 2786 * Next, we calculate a "preliminary" sync period 2787 * in tenths of a nanosecond. 2788 */ 2789 if (syncrate == 0) 2790 prelim_sync_period = 0; 2791 else 2792 prelim_sync_period = 10000000 / syncrate; 2793 2794 spi->sync_period = 2795 scsi_calc_syncparam(prelim_sync_period); 2796 2797 freq = scsi_calc_syncsrate(spi->sync_period); 2798 didsettings++; 2799 } 2800 2801 /* 2802 * The bus_width argument goes like this: 2803 * 0 == 8 bit 2804 * 1 == 16 bit 2805 * 2 == 32 bit 2806 * Therefore, if you shift the number of bits given on the 2807 * command line right by 4, you should get the correct 2808 * number. 2809 */ 2810 if (spi && bus_width != -1) { 2811 2812 /* 2813 * We might as well validate things here with a 2814 * decipherable error message, rather than what 2815 * will probably be an indecipherable error message 2816 * by the time it gets back to us. 2817 */ 2818 if ((bus_width == 16) 2819 && ((cpi.hba_inquiry & PI_WIDE_16) == 0)) { 2820 warnx("HBA does not support 16 bit bus width"); 2821 retval = 1; 2822 goto ratecontrol_bailout; 2823 } else if ((bus_width == 32) 2824 && ((cpi.hba_inquiry & PI_WIDE_32) == 0)) { 2825 warnx("HBA does not support 32 bit bus width"); 2826 retval = 1; 2827 goto ratecontrol_bailout; 2828 } else if ((bus_width != 8) 2829 && (bus_width != 16) 2830 && (bus_width != 32)) { 2831 warnx("Invalid bus width %d", bus_width); 2832 retval = 1; 2833 goto ratecontrol_bailout; 2834 } 2835 2836 spi->valid |= CTS_SPI_VALID_BUS_WIDTH; 2837 spi->bus_width = bus_width >> 4; 2838 didsettings++; 2839 } 2840 2841 if (didsettings == 0) { 2842 goto ratecontrol_bailout; 2843 } 2844 ccb->ccb_h.func_code = XPT_SET_TRAN_SETTINGS; 2845 2846 if (cam_send_ccb(device, ccb) < 0) { 2847 perror("error sending XPT_SET_TRAN_SETTINGS CCB"); 2848 if (arglist & CAM_ARG_VERBOSE) { 2849 cam_error_print(device, ccb, CAM_ESF_ALL, 2850 CAM_EPF_ALL, stderr); 2851 } 2852 retval = 1; 2853 goto ratecontrol_bailout; 2854 } 2855 2856 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 2857 warnx("XPT_SET_TRANS_SETTINGS CCB failed"); 2858 if (arglist & CAM_ARG_VERBOSE) { 2859 cam_error_print(device, ccb, CAM_ESF_ALL, 2860 CAM_EPF_ALL, stderr); 2861 } 2862 retval = 1; 2863 goto ratecontrol_bailout; 2864 } 2865 } 2866 2867 if (send_tur) { 2868 retval = testunitready(device, retry_count, timeout, 2869 (arglist & CAM_ARG_VERBOSE) ? 0 : 1); 2870 2871 /* 2872 * If the TUR didn't succeed, just bail. 2873 */ 2874 if (retval != 0) { 2875 if (quiet == 0) 2876 fprintf(stderr, "Test Unit Ready failed\n"); 2877 goto ratecontrol_bailout; 2878 } 2879 2880 /* 2881 * If the user wants things quiet, there's no sense in 2882 * getting the transfer settings, if we're not going 2883 * to print them. 2884 */ 2885 if (quiet != 0) 2886 goto ratecontrol_bailout; 2887 2888 fprintf(stdout, "New Parameters:\n"); 2889 retval = get_print_cts(device, user_settings, 0, NULL); 2890 } 2891 2892ratecontrol_bailout: 2893 2894 cam_freeccb(ccb); 2895 return(retval); 2896} 2897 2898static int 2899scsiformat(struct cam_device *device, int argc, char **argv, 2900 char *combinedopt, int retry_count, int timeout) 2901{ 2902 union ccb *ccb; 2903 int c; 2904 int ycount = 0, quiet = 0; 2905 int error = 0, response = 0, retval = 0; 2906 int use_timeout = 10800 * 1000; 2907 int immediate = 1; 2908 struct format_defect_list_header fh; 2909 u_int8_t *data_ptr = NULL; 2910 u_int32_t dxfer_len = 0; 2911 u_int8_t byte2 = 0; 2912 int num_warnings = 0; 2913 int reportonly = 0; 2914 2915 ccb = cam_getccb(device); 2916 2917 if (ccb == NULL) { 2918 warnx("scsiformat: error allocating ccb"); 2919 return(1); 2920 } 2921 2922 bzero(&(&ccb->ccb_h)[1], 2923 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr)); 2924 2925 while ((c = getopt(argc, argv, combinedopt)) != -1) { 2926 switch(c) { 2927 case 'q': 2928 quiet++; 2929 break; 2930 case 'r': 2931 reportonly = 1; 2932 break; 2933 case 'w': 2934 immediate = 0; 2935 break; 2936 case 'y': 2937 ycount++; 2938 break; 2939 } 2940 } 2941 2942 if (reportonly) 2943 goto doreport; 2944 2945 if (quiet == 0) { 2946 fprintf(stdout, "You are about to REMOVE ALL DATA from the " 2947 "following device:\n"); 2948 2949 error = scsidoinquiry(device, argc, argv, combinedopt, 2950 retry_count, timeout); 2951 2952 if (error != 0) { 2953 warnx("scsiformat: error sending inquiry"); 2954 goto scsiformat_bailout; 2955 } 2956 } 2957 2958 if (ycount == 0) { 2959 2960 do { 2961 char str[1024]; 2962 2963 fprintf(stdout, "Are you SURE you want to do " 2964 "this? (yes/no) "); 2965 2966 if (fgets(str, sizeof(str), stdin) != NULL) { 2967 2968 if (strncasecmp(str, "yes", 3) == 0) 2969 response = 1; 2970 else if (strncasecmp(str, "no", 2) == 0) 2971 response = -1; 2972 else { 2973 fprintf(stdout, "Please answer" 2974 " \"yes\" or \"no\"\n"); 2975 } 2976 } 2977 } while (response == 0); 2978 2979 if (response == -1) { 2980 error = 1; 2981 goto scsiformat_bailout; 2982 } 2983 } 2984 2985 if (timeout != 0) 2986 use_timeout = timeout; 2987 2988 if (quiet == 0) { 2989 fprintf(stdout, "Current format timeout is %d seconds\n", 2990 use_timeout / 1000); 2991 } 2992 2993 /* 2994 * If the user hasn't disabled questions and didn't specify a 2995 * timeout on the command line, ask them if they want the current 2996 * timeout. 2997 */ 2998 if ((ycount == 0) 2999 && (timeout == 0)) { 3000 char str[1024]; 3001 int new_timeout = 0; 3002 3003 fprintf(stdout, "Enter new timeout in seconds or press\n" 3004 "return to keep the current timeout [%d] ", 3005 use_timeout / 1000); 3006 3007 if (fgets(str, sizeof(str), stdin) != NULL) { 3008 if (str[0] != '\0') 3009 new_timeout = atoi(str); 3010 } 3011 3012 if (new_timeout != 0) { 3013 use_timeout = new_timeout * 1000; 3014 fprintf(stdout, "Using new timeout value %d\n", 3015 use_timeout / 1000); 3016 } 3017 } 3018 3019 /* 3020 * Keep this outside the if block below to silence any unused 3021 * variable warnings. 3022 */ 3023 bzero(&fh, sizeof(fh)); 3024 3025 /* 3026 * If we're in immediate mode, we've got to include the format 3027 * header 3028 */ 3029 if (immediate != 0) { 3030 fh.byte2 = FU_DLH_IMMED; 3031 data_ptr = (u_int8_t *)&fh; 3032 dxfer_len = sizeof(fh); 3033 byte2 = FU_FMT_DATA; 3034 } else if (quiet == 0) { 3035 fprintf(stdout, "Formatting..."); 3036 fflush(stdout); 3037 } 3038 3039 scsi_format_unit(&ccb->csio, 3040 /* retries */ retry_count, 3041 /* cbfcnp */ NULL, 3042 /* tag_action */ MSG_SIMPLE_Q_TAG, 3043 /* byte2 */ byte2, 3044 /* ileave */ 0, 3045 /* data_ptr */ data_ptr, 3046 /* dxfer_len */ dxfer_len, 3047 /* sense_len */ SSD_FULL_SIZE, 3048 /* timeout */ use_timeout); 3049 3050 /* Disable freezing the device queue */ 3051 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 3052 3053 if (arglist & CAM_ARG_ERR_RECOVER) 3054 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER; 3055 3056 if (((retval = cam_send_ccb(device, ccb)) < 0) 3057 || ((immediate == 0) 3058 && ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP))) { 3059 const char errstr[] = "error sending format command"; 3060 3061 if (retval < 0) 3062 warn(errstr); 3063 else 3064 warnx(errstr); 3065 3066 if (arglist & CAM_ARG_VERBOSE) { 3067 cam_error_print(device, ccb, CAM_ESF_ALL, 3068 CAM_EPF_ALL, stderr); 3069 } 3070 error = 1; 3071 goto scsiformat_bailout; 3072 } 3073 3074 /* 3075 * If we ran in non-immediate mode, we already checked for errors 3076 * above and printed out any necessary information. If we're in 3077 * immediate mode, we need to loop through and get status 3078 * information periodically. 3079 */ 3080 if (immediate == 0) { 3081 if (quiet == 0) { 3082 fprintf(stdout, "Format Complete\n"); 3083 } 3084 goto scsiformat_bailout; 3085 } 3086 3087doreport: 3088 do { 3089 cam_status status; 3090 3091 bzero(&(&ccb->ccb_h)[1], 3092 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr)); 3093 3094 /* 3095 * There's really no need to do error recovery or 3096 * retries here, since we're just going to sit in a 3097 * loop and wait for the device to finish formatting. 3098 */ 3099 scsi_test_unit_ready(&ccb->csio, 3100 /* retries */ 0, 3101 /* cbfcnp */ NULL, 3102 /* tag_action */ MSG_SIMPLE_Q_TAG, 3103 /* sense_len */ SSD_FULL_SIZE, 3104 /* timeout */ 5000); 3105 3106 /* Disable freezing the device queue */ 3107 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 3108 3109 retval = cam_send_ccb(device, ccb); 3110 3111 /* 3112 * If we get an error from the ioctl, bail out. SCSI 3113 * errors are expected. 3114 */ 3115 if (retval < 0) { 3116 warn("error sending CAMIOCOMMAND ioctl"); 3117 if (arglist & CAM_ARG_VERBOSE) { 3118 cam_error_print(device, ccb, CAM_ESF_ALL, 3119 CAM_EPF_ALL, stderr); 3120 } 3121 error = 1; 3122 goto scsiformat_bailout; 3123 } 3124 3125 status = ccb->ccb_h.status & CAM_STATUS_MASK; 3126 3127 if ((status != CAM_REQ_CMP) 3128 && (status == CAM_SCSI_STATUS_ERROR) 3129 && ((ccb->ccb_h.status & CAM_AUTOSNS_VALID) != 0)) { 3130 struct scsi_sense_data *sense; 3131 int error_code, sense_key, asc, ascq; 3132 3133 sense = &ccb->csio.sense_data; 3134 scsi_extract_sense(sense, &error_code, &sense_key, 3135 &asc, &ascq); 3136 3137 /* 3138 * According to the SCSI-2 and SCSI-3 specs, a 3139 * drive that is in the middle of a format should 3140 * return NOT READY with an ASC of "logical unit 3141 * not ready, format in progress". The sense key 3142 * specific bytes will then be a progress indicator. 3143 */ 3144 if ((sense_key == SSD_KEY_NOT_READY) 3145 && (asc == 0x04) && (ascq == 0x04)) { 3146 if ((sense->extra_len >= 10) 3147 && ((sense->sense_key_spec[0] & 3148 SSD_SCS_VALID) != 0) 3149 && (quiet == 0)) { 3150 int val; 3151 u_int64_t percentage; 3152 3153 val = scsi_2btoul( 3154 &sense->sense_key_spec[1]); 3155 percentage = 10000 * val; 3156 3157 fprintf(stdout, 3158 "\rFormatting: %ju.%02u %% " 3159 "(%d/%d) done", 3160 (uintmax_t)(percentage / 3161 (0x10000 * 100)), 3162 (unsigned)((percentage / 3163 0x10000) % 100), 3164 val, 0x10000); 3165 fflush(stdout); 3166 } else if ((quiet == 0) 3167 && (++num_warnings <= 1)) { 3168 warnx("Unexpected SCSI Sense Key " 3169 "Specific value returned " 3170 "during format:"); 3171 scsi_sense_print(device, &ccb->csio, 3172 stderr); 3173 warnx("Unable to print status " 3174 "information, but format will " 3175 "proceed."); 3176 warnx("will exit when format is " 3177 "complete"); 3178 } 3179 sleep(1); 3180 } else { 3181 warnx("Unexpected SCSI error during format"); 3182 cam_error_print(device, ccb, CAM_ESF_ALL, 3183 CAM_EPF_ALL, stderr); 3184 error = 1; 3185 goto scsiformat_bailout; 3186 } 3187 3188 } else if (status != CAM_REQ_CMP) { 3189 warnx("Unexpected CAM status %#x", status); 3190 if (arglist & CAM_ARG_VERBOSE) 3191 cam_error_print(device, ccb, CAM_ESF_ALL, 3192 CAM_EPF_ALL, stderr); 3193 error = 1; 3194 goto scsiformat_bailout; 3195 } 3196 3197 } while((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP); 3198 3199 if (quiet == 0) 3200 fprintf(stdout, "\nFormat Complete\n"); 3201 3202scsiformat_bailout: 3203 3204 cam_freeccb(ccb); 3205 3206 return(error); 3207} 3208 3209static int 3210scsireportluns(struct cam_device *device, int argc, char **argv, 3211 char *combinedopt, int retry_count, int timeout) 3212{ 3213 union ccb *ccb; 3214 int c, countonly, lunsonly; 3215 struct scsi_report_luns_data *lundata; 3216 int alloc_len; 3217 uint8_t report_type; 3218 uint32_t list_len, i, j; 3219 int retval; 3220 3221 retval = 0; 3222 lundata = NULL; 3223 report_type = RPL_REPORT_DEFAULT; 3224 ccb = cam_getccb(device); 3225 3226 if (ccb == NULL) { 3227 warnx("%s: error allocating ccb", __func__); 3228 return (1); 3229 } 3230 3231 bzero(&(&ccb->ccb_h)[1], 3232 sizeof(struct ccb_scsiio) - sizeof(struct ccb_hdr)); 3233 3234 countonly = 0; 3235 lunsonly = 0; 3236 3237 while ((c = getopt(argc, argv, combinedopt)) != -1) { 3238 switch (c) { 3239 case 'c': 3240 countonly++; 3241 break; 3242 case 'l': 3243 lunsonly++; 3244 break; 3245 case 'r': 3246 if (strcasecmp(optarg, "default") == 0) 3247 report_type = RPL_REPORT_DEFAULT; 3248 else if (strcasecmp(optarg, "wellknown") == 0) 3249 report_type = RPL_REPORT_WELLKNOWN; 3250 else if (strcasecmp(optarg, "all") == 0) 3251 report_type = RPL_REPORT_ALL; 3252 else { 3253 warnx("%s: invalid report type \"%s\"", 3254 __func__, optarg); 3255 retval = 1; 3256 goto bailout; 3257 } 3258 break; 3259 default: 3260 break; 3261 } 3262 } 3263 3264 if ((countonly != 0) 3265 && (lunsonly != 0)) { 3266 warnx("%s: you can only specify one of -c or -l", __func__); 3267 retval = 1; 3268 goto bailout; 3269 } 3270 /* 3271 * According to SPC-4, the allocation length must be at least 16 3272 * bytes -- enough for the header and one LUN. 3273 */ 3274 alloc_len = sizeof(*lundata) + 8; 3275 3276retry: 3277 3278 lundata = malloc(alloc_len); 3279 3280 if (lundata == NULL) { 3281 warn("%s: error mallocing %d bytes", __func__, alloc_len); 3282 retval = 1; 3283 goto bailout; 3284 } 3285 3286 scsi_report_luns(&ccb->csio, 3287 /*retries*/ retry_count, 3288 /*cbfcnp*/ NULL, 3289 /*tag_action*/ MSG_SIMPLE_Q_TAG, 3290 /*select_report*/ report_type, 3291 /*rpl_buf*/ lundata, 3292 /*alloc_len*/ alloc_len, 3293 /*sense_len*/ SSD_FULL_SIZE, 3294 /*timeout*/ timeout ? timeout : 5000); 3295 3296 /* Disable freezing the device queue */ 3297 ccb->ccb_h.flags |= CAM_DEV_QFRZDIS; 3298 3299 if (arglist & CAM_ARG_ERR_RECOVER) 3300 ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER; 3301 3302 if (cam_send_ccb(device, ccb) < 0) { 3303 warn("error sending REPORT LUNS command"); 3304 3305 if (arglist & CAM_ARG_VERBOSE) 3306 cam_error_print(device, ccb, CAM_ESF_ALL, 3307 CAM_EPF_ALL, stderr); 3308 3309 retval = 1; 3310 goto bailout; 3311 } 3312 3313 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 3314 cam_error_print(device, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr); 3315 retval = 1; 3316 goto bailout; 3317 } 3318 3319 3320 list_len = scsi_4btoul(lundata->length); 3321 3322 /* 3323 * If we need to list the LUNs, and our allocation 3324 * length was too short, reallocate and retry. 3325 */ 3326 if ((countonly == 0) 3327 && (list_len > (alloc_len - sizeof(*lundata)))) { 3328 alloc_len = list_len + sizeof(*lundata); 3329 free(lundata); 3330 goto retry; 3331 } 3332 3333 if (lunsonly == 0) 3334 fprintf(stdout, "%u LUN%s found\n", list_len / 8, 3335 ((list_len / 8) > 1) ? "s" : ""); 3336 3337 if (countonly != 0) 3338 goto bailout; 3339 3340 for (i = 0; i < (list_len / 8); i++) { 3341 int no_more; 3342 3343 no_more = 0; 3344 for (j = 0; j < sizeof(lundata->luns[i].lundata); j += 2) { 3345 if (j != 0) 3346 fprintf(stdout, ","); 3347 switch (lundata->luns[i].lundata[j] & 3348 RPL_LUNDATA_ATYP_MASK) { 3349 case RPL_LUNDATA_ATYP_PERIPH: 3350 if ((lundata->luns[i].lundata[j] & 3351 RPL_LUNDATA_PERIPH_BUS_MASK) != 0) 3352 fprintf(stdout, "%d:", 3353 lundata->luns[i].lundata[j] & 3354 RPL_LUNDATA_PERIPH_BUS_MASK); 3355 else if ((j == 0) 3356 && ((lundata->luns[i].lundata[j+2] & 3357 RPL_LUNDATA_PERIPH_BUS_MASK) == 0)) 3358 no_more = 1; 3359 3360 fprintf(stdout, "%d", 3361 lundata->luns[i].lundata[j+1]); 3362 break; 3363 case RPL_LUNDATA_ATYP_FLAT: { 3364 uint8_t tmplun[2]; 3365 tmplun[0] = lundata->luns[i].lundata[j] & 3366 RPL_LUNDATA_FLAT_LUN_MASK; 3367 tmplun[1] = lundata->luns[i].lundata[j+1]; 3368 3369 fprintf(stdout, "%d", scsi_2btoul(tmplun)); 3370 no_more = 1; 3371 break; 3372 } 3373 case RPL_LUNDATA_ATYP_LUN: 3374 fprintf(stdout, "%d:%d:%d", 3375 (lundata->luns[i].lundata[j+1] & 3376 RPL_LUNDATA_LUN_BUS_MASK) >> 5, 3377 lundata->luns[i].lundata[j] & 3378 RPL_LUNDATA_LUN_TARG_MASK, 3379 lundata->luns[i].lundata[j+1] & 3380 RPL_LUNDATA_LUN_LUN_MASK); 3381 break; 3382 case RPL_LUNDATA_ATYP_EXTLUN: { 3383 int field_len, field_len_code, eam_code; 3384 3385 eam_code = lundata->luns[i].lundata[j] & 3386 RPL_LUNDATA_EXT_EAM_MASK; 3387 field_len_code = (lundata->luns[i].lundata[j] & 3388 RPL_LUNDATA_EXT_LEN_MASK) >> 4; 3389 field_len = field_len_code * 2; 3390 3391 if ((eam_code == RPL_LUNDATA_EXT_EAM_WK) 3392 && (field_len_code == 0x00)) { 3393 fprintf(stdout, "%d", 3394 lundata->luns[i].lundata[j+1]); 3395 } else if ((eam_code == 3396 RPL_LUNDATA_EXT_EAM_NOT_SPEC) 3397 && (field_len_code == 0x03)) { 3398 uint8_t tmp_lun[8]; 3399 3400 /* 3401 * This format takes up all 8 bytes. 3402 * If we aren't starting at offset 0, 3403 * that's a bug. 3404 */ 3405 if (j != 0) { 3406 fprintf(stdout, "Invalid " 3407 "offset %d for " 3408 "Extended LUN not " 3409 "specified format", j); 3410 no_more = 1; 3411 break; 3412 } 3413 bzero(tmp_lun, sizeof(tmp_lun)); 3414 bcopy(&lundata->luns[i].lundata[j+1], 3415 &tmp_lun[1], sizeof(tmp_lun) - 1); 3416 fprintf(stdout, "%#jx", 3417 (intmax_t)scsi_8btou64(tmp_lun)); 3418 no_more = 1; 3419 } else { 3420 fprintf(stderr, "Unknown Extended LUN" 3421 "Address method %#x, length " 3422 "code %#x", eam_code, 3423 field_len_code); 3424 no_more = 1; 3425 } 3426 break; 3427 } 3428 default: 3429 fprintf(stderr, "Unknown LUN address method " 3430 "%#x\n", lundata->luns[i].lundata[0] & 3431 RPL_LUNDATA_ATYP_MASK); 3432 break; 3433 } 3434 /* 3435 * For the flat addressing method, there are no 3436 * other levels after it. 3437 */ 3438 if (no_more != 0) 3439 break; 3440 } 3441 fprintf(stdout, "\n"); 3442 } 3443 3444bailout: 3445 3446 cam_freeccb(ccb); 3447 3448 free(lundata); 3449 3450 return (retval); 3451} 3452 3453#endif /* MINIMALISTIC */ 3454 3455void 3456usage(int verbose) 3457{ 3458 fprintf(verbose ? stdout : stderr, 3459"usage: camcontrol <command> [device id][generic args][command args]\n" 3460" camcontrol devlist [-v]\n" 3461#ifndef MINIMALISTIC 3462" camcontrol periphlist [dev_id][-n dev_name] [-u unit]\n" 3463" camcontrol tur [dev_id][generic args]\n" 3464" camcontrol inquiry [dev_id][generic args] [-D] [-S] [-R]\n" 3465" camcontrol reportluns [dev_id][generic args] [-c] [-l] [-r report]\n" 3466" camcontrol start [dev_id][generic args]\n" 3467" camcontrol stop [dev_id][generic args]\n" 3468" camcontrol load [dev_id][generic args]\n" 3469" camcontrol eject [dev_id][generic args]\n" 3470#endif /* MINIMALISTIC */ 3471" camcontrol rescan <all | bus[:target:lun]>\n" 3472" camcontrol reset <all | bus[:target:lun]>\n" 3473#ifndef MINIMALISTIC 3474" camcontrol defects [dev_id][generic args] <-f format> [-P][-G]\n" 3475" camcontrol modepage [dev_id][generic args] <-m page | -l>\n" 3476" [-P pagectl][-e | -b][-d]\n" 3477" camcontrol cmd [dev_id][generic args] <-c cmd [args]>\n" 3478" [-i len fmt|-o len fmt [args]]\n" 3479" camcontrol debug [-I][-P][-T][-S][-X][-c]\n" 3480" <all|bus[:target[:lun]]|off>\n" 3481" camcontrol tags [dev_id][generic args] [-N tags] [-q] [-v]\n" 3482" camcontrol negotiate [dev_id][generic args] [-a][-c]\n" 3483" [-D <enable|disable>][-O offset][-q]\n" 3484" [-R syncrate][-v][-T <enable|disable>]\n" 3485" [-U][-W bus_width]\n" 3486" camcontrol format [dev_id][generic args][-q][-r][-w][-y]\n" 3487#endif /* MINIMALISTIC */ 3488" camcontrol help\n"); 3489 if (!verbose) 3490 return; 3491#ifndef MINIMALISTIC 3492 fprintf(stdout, 3493"Specify one of the following options:\n" 3494"devlist list all CAM devices\n" 3495"periphlist list all CAM peripheral drivers attached to a device\n" 3496"tur send a test unit ready to the named device\n" 3497"inquiry send a SCSI inquiry command to the named device\n" 3498"reportluns send a SCSI report luns command to the device\n" 3499"start send a Start Unit command to the device\n" 3500"stop send a Stop Unit command to the device\n" 3501"load send a Start Unit command to the device with the load bit set\n" 3502"eject send a Stop Unit command to the device with the eject bit set\n" 3503"rescan rescan all busses, the given bus, or bus:target:lun\n" 3504"reset reset all busses, the given bus, or bus:target:lun\n" 3505"defects read the defect list of the specified device\n" 3506"modepage display or edit (-e) the given mode page\n" 3507"cmd send the given scsi command, may need -i or -o as well\n" 3508"debug turn debugging on/off for a bus, target, or lun, or all devices\n" 3509"tags report or set the number of transaction slots for a device\n" 3510"negotiate report or set device negotiation parameters\n" 3511"format send the SCSI FORMAT UNIT command to the named device\n" 3512"help this message\n" 3513"Device Identifiers:\n" 3514"bus:target specify the bus and target, lun defaults to 0\n" 3515"bus:target:lun specify the bus, target and lun\n" 3516"deviceUNIT specify the device name, like \"da4\" or \"cd2\"\n" 3517"Generic arguments:\n" 3518"-v be verbose, print out sense information\n" 3519"-t timeout command timeout in seconds, overrides default timeout\n" 3520"-n dev_name specify device name, e.g. \"da\", \"cd\"\n" 3521"-u unit specify unit number, e.g. \"0\", \"5\"\n" 3522"-E have the kernel attempt to perform SCSI error recovery\n" 3523"-C count specify the SCSI command retry count (needs -E to work)\n" 3524"modepage arguments:\n" 3525"-l list all available mode pages\n" 3526"-m page specify the mode page to view or edit\n" 3527"-e edit the specified mode page\n" 3528"-b force view to binary mode\n" 3529"-d disable block descriptors for mode sense\n" 3530"-P pgctl page control field 0-3\n" 3531"defects arguments:\n" 3532"-f format specify defect list format (block, bfi or phys)\n" 3533"-G get the grown defect list\n" 3534"-P get the permanant defect list\n" 3535"inquiry arguments:\n" 3536"-D get the standard inquiry data\n" 3537"-S get the serial number\n" 3538"-R get the transfer rate, etc.\n" 3539"reportluns arguments:\n" 3540"-c only report a count of available LUNs\n" 3541"-l only print out luns, and not a count\n" 3542"-r <reporttype> specify \"default\", \"wellknown\" or \"all\"\n" 3543"cmd arguments:\n" 3544"-c cdb [args] specify the SCSI CDB\n" 3545"-i len fmt specify input data and input data format\n" 3546"-o len fmt [args] specify output data and output data fmt\n" 3547"debug arguments:\n" 3548"-I CAM_DEBUG_INFO -- scsi commands, errors, data\n" 3549"-T CAM_DEBUG_TRACE -- routine flow tracking\n" 3550"-S CAM_DEBUG_SUBTRACE -- internal routine command flow\n" 3551"-c CAM_DEBUG_CDB -- print out SCSI CDBs only\n" 3552"tags arguments:\n" 3553"-N tags specify the number of tags to use for this device\n" 3554"-q be quiet, don't report the number of tags\n" 3555"-v report a number of tag-related parameters\n" 3556"negotiate arguments:\n" 3557"-a send a test unit ready after negotiation\n" 3558"-c report/set current negotiation settings\n" 3559"-D <arg> \"enable\" or \"disable\" disconnection\n" 3560"-O offset set command delay offset\n" 3561"-q be quiet, don't report anything\n" 3562"-R syncrate synchronization rate in MHz\n" 3563"-T <arg> \"enable\" or \"disable\" tagged queueing\n" 3564"-U report/set user negotiation settings\n" 3565"-W bus_width set the bus width in bits (8, 16 or 32)\n" 3566"-v also print a Path Inquiry CCB for the controller\n" 3567"format arguments:\n" 3568"-q be quiet, don't print status messages\n" 3569"-r run in report only mode\n" 3570"-w don't send immediate format command\n" 3571"-y don't ask any questions\n"); 3572#endif /* MINIMALISTIC */ 3573} 3574 3575int 3576main(int argc, char **argv) 3577{ 3578 int c; 3579 char *device = NULL; 3580 int unit = 0; 3581 struct cam_device *cam_dev = NULL; 3582 int timeout = 0, retry_count = 1; 3583 camcontrol_optret optreturn; 3584 char *tstr; 3585 const char *mainopt = "C:En:t:u:v"; 3586 const char *subopt = NULL; 3587 char combinedopt[256]; 3588 int error = 0, optstart = 2; 3589 int devopen = 1; 3590#ifndef MINIMALISTIC 3591 int bus, target, lun; 3592#endif /* MINIMALISTIC */ 3593 3594 cmdlist = CAM_CMD_NONE; 3595 arglist = CAM_ARG_NONE; 3596 3597 if (argc < 2) { 3598 usage(0); 3599 exit(1); 3600 } 3601 3602 /* 3603 * Get the base option. 3604 */ 3605 optreturn = getoption(argv[1], &cmdlist, &arglist, &subopt); 3606 3607 if (optreturn == CC_OR_AMBIGUOUS) { 3608 warnx("ambiguous option %s", argv[1]); 3609 usage(0); 3610 exit(1); 3611 } else if (optreturn == CC_OR_NOT_FOUND) { 3612 warnx("option %s not found", argv[1]); 3613 usage(0); 3614 exit(1); 3615 } 3616 3617 /* 3618 * Ahh, getopt(3) is a pain. 3619 * 3620 * This is a gross hack. There really aren't many other good 3621 * options (excuse the pun) for parsing options in a situation like 3622 * this. getopt is kinda braindead, so you end up having to run 3623 * through the options twice, and give each invocation of getopt 3624 * the option string for the other invocation. 3625 * 3626 * You would think that you could just have two groups of options. 3627 * The first group would get parsed by the first invocation of 3628 * getopt, and the second group would get parsed by the second 3629 * invocation of getopt. It doesn't quite work out that way. When 3630 * the first invocation of getopt finishes, it leaves optind pointing 3631 * to the argument _after_ the first argument in the second group. 3632 * So when the second invocation of getopt comes around, it doesn't 3633 * recognize the first argument it gets and then bails out. 3634 * 3635 * A nice alternative would be to have a flag for getopt that says 3636 * "just keep parsing arguments even when you encounter an unknown 3637 * argument", but there isn't one. So there's no real clean way to 3638 * easily parse two sets of arguments without having one invocation 3639 * of getopt know about the other. 3640 * 3641 * Without this hack, the first invocation of getopt would work as 3642 * long as the generic arguments are first, but the second invocation 3643 * (in the subfunction) would fail in one of two ways. In the case 3644 * where you don't set optreset, it would fail because optind may be 3645 * pointing to the argument after the one it should be pointing at. 3646 * In the case where you do set optreset, and reset optind, it would 3647 * fail because getopt would run into the first set of options, which 3648 * it doesn't understand. 3649 * 3650 * All of this would "sort of" work if you could somehow figure out 3651 * whether optind had been incremented one option too far. The 3652 * mechanics of that, however, are more daunting than just giving 3653 * both invocations all of the expect options for either invocation. 3654 * 3655 * Needless to say, I wouldn't mind if someone invented a better 3656 * (non-GPL!) command line parsing interface than getopt. I 3657 * wouldn't mind if someone added more knobs to getopt to make it 3658 * work better. Who knows, I may talk myself into doing it someday, 3659 * if the standards weenies let me. As it is, it just leads to 3660 * hackery like this and causes people to avoid it in some cases. 3661 * 3662 * KDM, September 8th, 1998 3663 */ 3664 if (subopt != NULL) 3665 sprintf(combinedopt, "%s%s", mainopt, subopt); 3666 else 3667 sprintf(combinedopt, "%s", mainopt); 3668 3669 /* 3670 * For these options we do not parse optional device arguments and 3671 * we do not open a passthrough device. 3672 */ 3673 if ((cmdlist == CAM_CMD_RESCAN) 3674 || (cmdlist == CAM_CMD_RESET) 3675 || (cmdlist == CAM_CMD_DEVTREE) 3676 || (cmdlist == CAM_CMD_USAGE) 3677 || (cmdlist == CAM_CMD_DEBUG)) 3678 devopen = 0; 3679 3680#ifndef MINIMALISTIC 3681 if ((devopen == 1) 3682 && (argc > 2 && argv[2][0] != '-')) { 3683 char name[30]; 3684 int rv; 3685 3686 /* 3687 * First catch people who try to do things like: 3688 * camcontrol tur /dev/da0 3689 * camcontrol doesn't take device nodes as arguments. 3690 */ 3691 if (argv[2][0] == '/') { 3692 warnx("%s is not a valid device identifier", argv[2]); 3693 errx(1, "please read the camcontrol(8) man page"); 3694 } else if (isdigit(argv[2][0])) { 3695 /* device specified as bus:target[:lun] */ 3696 rv = parse_btl(argv[2], &bus, &target, &lun, &arglist); 3697 if (rv < 2) 3698 errx(1, "numeric device specification must " 3699 "be either bus:target, or " 3700 "bus:target:lun"); 3701 /* default to 0 if lun was not specified */ 3702 if ((arglist & CAM_ARG_LUN) == 0) { 3703 lun = 0; 3704 arglist |= CAM_ARG_LUN; 3705 } 3706 optstart++; 3707 } else { 3708 if (cam_get_device(argv[2], name, sizeof name, &unit) 3709 == -1) 3710 errx(1, "%s", cam_errbuf); 3711 device = strdup(name); 3712 arglist |= CAM_ARG_DEVICE | CAM_ARG_UNIT; 3713 optstart++; 3714 } 3715 } 3716#endif /* MINIMALISTIC */ 3717 /* 3718 * Start getopt processing at argv[2/3], since we've already 3719 * accepted argv[1..2] as the command name, and as a possible 3720 * device name. 3721 */ 3722 optind = optstart; 3723 3724 /* 3725 * Now we run through the argument list looking for generic 3726 * options, and ignoring options that possibly belong to 3727 * subfunctions. 3728 */ 3729 while ((c = getopt(argc, argv, combinedopt))!= -1){ 3730 switch(c) { 3731 case 'C': 3732 retry_count = strtol(optarg, NULL, 0); 3733 if (retry_count < 0) 3734 errx(1, "retry count %d is < 0", 3735 retry_count); 3736 arglist |= CAM_ARG_RETRIES; 3737 break; 3738 case 'E': 3739 arglist |= CAM_ARG_ERR_RECOVER; 3740 break; 3741 case 'n': 3742 arglist |= CAM_ARG_DEVICE; 3743 tstr = optarg; 3744 while (isspace(*tstr) && (*tstr != '\0')) 3745 tstr++; 3746 device = (char *)strdup(tstr); 3747 break; 3748 case 't': 3749 timeout = strtol(optarg, NULL, 0); 3750 if (timeout < 0) 3751 errx(1, "invalid timeout %d", timeout); 3752 /* Convert the timeout from seconds to ms */ 3753 timeout *= 1000; 3754 arglist |= CAM_ARG_TIMEOUT; 3755 break; 3756 case 'u': 3757 arglist |= CAM_ARG_UNIT; 3758 unit = strtol(optarg, NULL, 0); 3759 break; 3760 case 'v': 3761 arglist |= CAM_ARG_VERBOSE; 3762 break; 3763 default: 3764 break; 3765 } 3766 } 3767 3768#ifndef MINIMALISTIC 3769 /* 3770 * For most commands we'll want to open the passthrough device 3771 * associated with the specified device. In the case of the rescan 3772 * commands, we don't use a passthrough device at all, just the 3773 * transport layer device. 3774 */ 3775 if (devopen == 1) { 3776 if (((arglist & (CAM_ARG_BUS|CAM_ARG_TARGET)) == 0) 3777 && (((arglist & CAM_ARG_DEVICE) == 0) 3778 || ((arglist & CAM_ARG_UNIT) == 0))) { 3779 errx(1, "subcommand \"%s\" requires a valid device " 3780 "identifier", argv[1]); 3781 } 3782 3783 if ((cam_dev = ((arglist & (CAM_ARG_BUS | CAM_ARG_TARGET))? 3784 cam_open_btl(bus, target, lun, O_RDWR, NULL) : 3785 cam_open_spec_device(device,unit,O_RDWR,NULL))) 3786 == NULL) 3787 errx(1,"%s", cam_errbuf); 3788 } 3789#endif /* MINIMALISTIC */ 3790 3791 /* 3792 * Reset optind to 2, and reset getopt, so these routines can parse 3793 * the arguments again. 3794 */ 3795 optind = optstart; 3796 optreset = 1; 3797 3798 switch(cmdlist) { 3799#ifndef MINIMALISTIC 3800 case CAM_CMD_DEVLIST: 3801 error = getdevlist(cam_dev); 3802 break; 3803#endif /* MINIMALISTIC */ 3804 case CAM_CMD_DEVTREE: 3805 error = getdevtree(); 3806 break; 3807#ifndef MINIMALISTIC 3808 case CAM_CMD_TUR: 3809 error = testunitready(cam_dev, retry_count, timeout, 0); 3810 break; 3811 case CAM_CMD_INQUIRY: 3812 error = scsidoinquiry(cam_dev, argc, argv, combinedopt, 3813 retry_count, timeout); 3814 break; 3815 case CAM_CMD_STARTSTOP: 3816 error = scsistart(cam_dev, arglist & CAM_ARG_START_UNIT, 3817 arglist & CAM_ARG_EJECT, retry_count, 3818 timeout); 3819 break; 3820#endif /* MINIMALISTIC */ 3821 case CAM_CMD_RESCAN: 3822 error = dorescan_or_reset(argc, argv, 1); 3823 break; 3824 case CAM_CMD_RESET: 3825 error = dorescan_or_reset(argc, argv, 0); 3826 break; 3827#ifndef MINIMALISTIC 3828 case CAM_CMD_READ_DEFECTS: 3829 error = readdefects(cam_dev, argc, argv, combinedopt, 3830 retry_count, timeout); 3831 break; 3832 case CAM_CMD_MODE_PAGE: 3833 modepage(cam_dev, argc, argv, combinedopt, 3834 retry_count, timeout); 3835 break; 3836 case CAM_CMD_SCSI_CMD: 3837 error = scsicmd(cam_dev, argc, argv, combinedopt, 3838 retry_count, timeout); 3839 break; 3840 case CAM_CMD_DEBUG: 3841 error = camdebug(argc, argv, combinedopt); 3842 break; 3843 case CAM_CMD_TAG: 3844 error = tagcontrol(cam_dev, argc, argv, combinedopt); 3845 break; 3846 case CAM_CMD_RATE: 3847 error = ratecontrol(cam_dev, retry_count, timeout, 3848 argc, argv, combinedopt); 3849 break; 3850 case CAM_CMD_FORMAT: 3851 error = scsiformat(cam_dev, argc, argv, 3852 combinedopt, retry_count, timeout); 3853 break; 3854 case CAM_CMD_REPORTLUNS: 3855 error = scsireportluns(cam_dev, argc, argv, 3856 combinedopt, retry_count, 3857 timeout); 3858 break; 3859#endif /* MINIMALISTIC */ 3860 case CAM_CMD_USAGE: 3861 usage(1); 3862 break; 3863 default: 3864 usage(0); 3865 error = 1; 3866 break; 3867 } 3868 3869 if (cam_dev != NULL) 3870 cam_close_device(cam_dev); 3871 3872 exit(error); 3873} 3874