1 /*- 2 * Copyright (c) 2008, 2009 Yahoo!, Inc. 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 names of the authors may not be used to endorse or promote 14 * products derived from this software without specific prior written 15 * permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * $FreeBSD: src/usr.sbin/mfiutil/mfi_drive.c,v 1.6 2011/06/20 21:28:50 bz Exp $ 30 */ 31 32 #include <sys/types.h> 33 #include <sys/errno.h> 34 #include <ctype.h> 35 #include <err.h> 36 #include <libutil.h> 37 #include <limits.h> 38 #include <stdio.h> 39 #include <stdlib.h> 40 #include <string.h> 41 #include <strings.h> 42 #include <unistd.h> 43 #include <bus/cam/scsi/scsi_all.h> 44 #include "mfiutil.h" 45 46 MFI_TABLE(top, drive); 47 48 /* 49 * Print the name of a drive either by drive number as %2u or by enclosure:slot 50 * as Exx:Sxx (or both). Use default unless command line options override it 51 * and the command allows this (which we usually do unless we already print 52 * both). We prefer pinfo if given, otherwise try to look it up by device_id. 53 */ 54 const char * 55 mfi_drive_name(struct mfi_pd_info *pinfo, uint16_t device_id, uint32_t def) 56 { 57 struct mfi_pd_info info; 58 static char buf[16]; 59 char *p; 60 int error, fd, len; 61 62 if ((def & MFI_DNAME_HONOR_OPTS) != 0 && 63 (mfi_opts & (MFI_DNAME_ES|MFI_DNAME_DEVICE_ID)) != 0) 64 def = mfi_opts & (MFI_DNAME_ES|MFI_DNAME_DEVICE_ID); 65 66 buf[0] = '\0'; 67 if (pinfo == NULL && def & MFI_DNAME_ES) { 68 /* Fallback in case of error, just ignore flags. */ 69 if (device_id == 0xffff) 70 snprintf(buf, sizeof(buf), "MISSING"); 71 else 72 snprintf(buf, sizeof(buf), "%2u", device_id); 73 74 fd = mfi_open(mfi_unit); 75 if (fd < 0) { 76 warn("mfi_open"); 77 return (buf); 78 } 79 80 /* Get the info for this drive. */ 81 if (mfi_pd_get_info(fd, device_id, &info, NULL) < 0) { 82 warn("Failed to fetch info for drive %2u", device_id); 83 close(fd); 84 return (buf); 85 } 86 87 close(fd); 88 pinfo = &info; 89 } 90 91 p = buf; 92 len = sizeof(buf); 93 if (def & MFI_DNAME_DEVICE_ID) { 94 if (device_id == 0xffff) 95 error = snprintf(p, len, "MISSING"); 96 else 97 error = snprintf(p, len, "%2u", device_id); 98 if (error >= 0) { 99 p += error; 100 len -= error; 101 } 102 } 103 if ((def & (MFI_DNAME_ES|MFI_DNAME_DEVICE_ID)) == 104 (MFI_DNAME_ES|MFI_DNAME_DEVICE_ID) && len >= 2) { 105 *p++ = ' '; 106 len--; 107 *p = '\0'; 108 len--; 109 } 110 if (def & MFI_DNAME_ES) { 111 if (pinfo->encl_device_id == 0xffff) 112 error = snprintf(p, len, "S%u", 113 pinfo->slot_number); 114 else if (pinfo->encl_device_id == pinfo->ref.v.device_id) 115 error = snprintf(p, len, "E%u", 116 pinfo->encl_index); 117 else 118 error = snprintf(p, len, "E%u:S%u", 119 pinfo->encl_index, pinfo->slot_number); 120 if (error >= 0) { 121 p += error; 122 len -= error; 123 } 124 } 125 126 return (buf); 127 } 128 129 const char * 130 mfi_pdstate(enum mfi_pd_state state) 131 { 132 static char buf[16]; 133 134 switch (state) { 135 case MFI_PD_STATE_UNCONFIGURED_GOOD: 136 return ("UNCONFIGURED GOOD"); 137 case MFI_PD_STATE_UNCONFIGURED_BAD: 138 return ("UNCONFIGURED BAD"); 139 case MFI_PD_STATE_HOT_SPARE: 140 return ("HOT SPARE"); 141 case MFI_PD_STATE_OFFLINE: 142 return ("OFFLINE"); 143 case MFI_PD_STATE_FAILED: 144 return ("FAILED"); 145 case MFI_PD_STATE_REBUILD: 146 return ("REBUILD"); 147 case MFI_PD_STATE_ONLINE: 148 return ("ONLINE"); 149 case MFI_PD_STATE_COPYBACK: 150 return ("COPYBACK"); 151 case MFI_PD_STATE_SYSTEM: 152 return ("SYSTEM"); 153 default: 154 sprintf(buf, "PSTATE 0x%04x", state); 155 return (buf); 156 } 157 } 158 159 int 160 mfi_lookup_drive(int fd, char *drive, uint16_t *device_id) 161 { 162 struct mfi_pd_list *list; 163 long val; 164 int error; 165 u_int i; 166 char *cp; 167 uint8_t encl, slot; 168 169 /* Look for a raw device id first. */ 170 val = strtol(drive, &cp, 0); 171 if (*cp == '\0') { 172 if (val < 0 || val >= 0xffff) 173 goto bad; 174 *device_id = val; 175 return (0); 176 } 177 178 /* Support for MegaCli style [Exx]:Syy notation. */ 179 if (toupper(drive[0]) == 'E' || toupper(drive[0]) == 'S') { 180 if (drive[1] == '\0') 181 goto bad; 182 cp = drive; 183 if (toupper(drive[0]) == 'E') { 184 cp++; /* Eat 'E' */ 185 val = strtol(cp, &cp, 0); 186 if (val < 0 || val > 0xff || *cp != ':') 187 goto bad; 188 encl = val; 189 cp++; /* Eat ':' */ 190 if (toupper(*cp) != 'S') 191 goto bad; 192 } else 193 encl = 0xff; 194 cp++; /* Eat 'S' */ 195 if (*cp == '\0') 196 goto bad; 197 val = strtol(cp, &cp, 0); 198 if (val < 0 || val > 0xff || *cp != '\0') 199 goto bad; 200 slot = val; 201 202 if (mfi_pd_get_list(fd, &list, NULL) < 0) { 203 error = errno; 204 warn("Failed to fetch drive list"); 205 return (error); 206 } 207 208 for (i = 0; i < list->count; i++) { 209 if (list->addr[i].scsi_dev_type != 0) 210 continue; 211 212 if (((encl == 0xff && 213 list->addr[i].encl_device_id == 0xffff) || 214 list->addr[i].encl_index == encl) && 215 list->addr[i].slot_number == slot) { 216 *device_id = list->addr[i].device_id; 217 free(list); 218 return (0); 219 } 220 } 221 free(list); 222 warnx("Unknown drive %s", drive); 223 return (EINVAL); 224 } 225 226 bad: 227 warnx("Invalid drive number %s", drive); 228 return (EINVAL); 229 } 230 231 static void 232 mbox_store_device_id(uint8_t *mbox, uint16_t device_id) 233 { 234 235 mbox[0] = device_id & 0xff; 236 mbox[1] = device_id >> 8; 237 } 238 239 void 240 mbox_store_pdref(uint8_t *mbox, union mfi_pd_ref *ref) 241 { 242 243 mbox[0] = ref->v.device_id & 0xff; 244 mbox[1] = ref->v.device_id >> 8; 245 mbox[2] = ref->v.seq_num & 0xff; 246 mbox[3] = ref->v.seq_num >> 8; 247 } 248 249 int 250 mfi_pd_get_list(int fd, struct mfi_pd_list **listp, uint8_t *statusp) 251 { 252 struct mfi_pd_list *list; 253 uint32_t list_size; 254 255 /* 256 * Keep fetching the list in a loop until we have a large enough 257 * buffer to hold the entire list. 258 */ 259 list = NULL; 260 list_size = 1024; 261 fetch: 262 list = reallocf(list, list_size); 263 if (list == NULL) 264 return (-1); 265 if (mfi_dcmd_command(fd, MFI_DCMD_PD_GET_LIST, list, list_size, NULL, 266 0, statusp) < 0) { 267 free(list); 268 return (-1); 269 } 270 271 if (list->size > list_size) { 272 list_size = list->size; 273 goto fetch; 274 } 275 276 *listp = list; 277 return (0); 278 } 279 280 int 281 mfi_pd_get_info(int fd, uint16_t device_id, struct mfi_pd_info *info, 282 uint8_t *statusp) 283 { 284 uint8_t mbox[2]; 285 286 mbox_store_device_id(&mbox[0], device_id); 287 return (mfi_dcmd_command(fd, MFI_DCMD_PD_GET_INFO, info, 288 sizeof(struct mfi_pd_info), mbox, 2, statusp)); 289 } 290 291 static void 292 cam_strvis(char *dst, const char *src, int srclen, int dstlen) 293 { 294 295 /* Trim leading/trailing spaces, nulls. */ 296 while (srclen > 0 && src[0] == ' ') 297 src++, srclen--; 298 while (srclen > 0 299 && (src[srclen-1] == ' ' || src[srclen-1] == '\0')) 300 srclen--; 301 302 while (srclen > 0 && dstlen > 1) { 303 char *cur_pos = dst; 304 305 if (*src < 0x20) { 306 /* SCSI-II Specifies that these should never occur. */ 307 /* non-printable character */ 308 if (dstlen > 4) { 309 *cur_pos++ = '\\'; 310 *cur_pos++ = ((*src & 0300) >> 6) + '0'; 311 *cur_pos++ = ((*src & 0070) >> 3) + '0'; 312 *cur_pos++ = ((*src & 0007) >> 0) + '0'; 313 } else { 314 *cur_pos++ = '?'; 315 } 316 } else { 317 /* normal character */ 318 *cur_pos++ = *src; 319 } 320 src++; 321 srclen--; 322 dstlen -= cur_pos - dst; 323 dst = cur_pos; 324 } 325 *dst = '\0'; 326 } 327 328 /* Borrowed heavily from scsi_all.c:scsi_print_inquiry(). */ 329 const char * 330 mfi_pd_inq_string(struct mfi_pd_info *info) 331 { 332 struct scsi_inquiry_data *inq_data; 333 char vendor[16], product[48], revision[16], rstr[12], serial[SID_VENDOR_SPECIFIC_0_SIZE]; 334 static char inq_string[64]; 335 336 inq_data = (struct scsi_inquiry_data *)info->inquiry_data; 337 if (SID_QUAL_IS_VENDOR_UNIQUE(inq_data)) 338 return (NULL); 339 if (SID_TYPE(inq_data) != T_DIRECT) 340 return (NULL); 341 if (SID_QUAL(inq_data) != SID_QUAL_LU_CONNECTED) 342 return (NULL); 343 344 cam_strvis(vendor, inq_data->vendor, sizeof(inq_data->vendor), 345 sizeof(vendor)); 346 cam_strvis(product, inq_data->product, sizeof(inq_data->product), 347 sizeof(product)); 348 cam_strvis(revision, inq_data->revision, sizeof(inq_data->revision), 349 sizeof(revision)); 350 cam_strvis(serial, (char *)inq_data->vendor_specific0, sizeof(inq_data->vendor_specific0), 351 sizeof(serial)); 352 353 /* Hack for SATA disks, no idea how to tell speed. */ 354 if (strcmp(vendor, "ATA") == 0) { 355 snprintf(inq_string, sizeof(inq_string), "<%s %s serial=%s> SATA", 356 product, revision, serial); 357 return (inq_string); 358 } 359 360 switch (SID_ANSI_REV(inq_data)) { 361 case SCSI_REV_CCS: 362 strcpy(rstr, "SCSI-CCS"); 363 break; 364 case 5: 365 strcpy(rstr, "SAS"); 366 break; 367 default: 368 snprintf(rstr, sizeof (rstr), "SCSI-%d", 369 SID_ANSI_REV(inq_data)); 370 break; 371 } 372 snprintf(inq_string, sizeof(inq_string), "<%s %s %s serial=%s> %s", vendor, 373 product, revision, serial, rstr); 374 return (inq_string); 375 } 376 377 /* Helper function to set a drive to a given state. */ 378 static int 379 drive_set_state(char *drive, uint16_t new_state) 380 { 381 struct mfi_pd_info info; 382 uint16_t device_id; 383 uint8_t mbox[6]; 384 int error, fd; 385 386 fd = mfi_open(mfi_unit); 387 if (fd < 0) { 388 error = errno; 389 warn("mfi_open"); 390 return (error); 391 } 392 393 error = mfi_lookup_drive(fd, drive, &device_id); 394 if (error) { 395 close(fd); 396 return (error); 397 } 398 399 /* Get the info for this drive. */ 400 if (mfi_pd_get_info(fd, device_id, &info, NULL) < 0) { 401 error = errno; 402 warn("Failed to fetch info for drive %u", device_id); 403 close(fd); 404 return (error); 405 } 406 407 /* Try to change the state. */ 408 if (info.fw_state == new_state) { 409 warnx("Drive %u is already in the desired state", device_id); 410 close(fd); 411 return (EINVAL); 412 } 413 414 mbox_store_pdref(&mbox[0], &info.ref); 415 mbox[4] = new_state & 0xff; 416 mbox[5] = new_state >> 8; 417 if (mfi_dcmd_command(fd, MFI_DCMD_PD_STATE_SET, NULL, 0, mbox, 6, 418 NULL) < 0) { 419 error = errno; 420 warn("Failed to set drive %u to %s", device_id, 421 mfi_pdstate(new_state)); 422 close(fd); 423 return (error); 424 } 425 426 close(fd); 427 428 return (0); 429 } 430 431 static int 432 fail_drive(int ac, char **av) 433 { 434 435 if (ac != 2) { 436 warnx("fail: %s", ac > 2 ? "extra arguments" : 437 "drive required"); 438 return (EINVAL); 439 } 440 441 return (drive_set_state(av[1], MFI_PD_STATE_FAILED)); 442 } 443 MFI_COMMAND(top, fail, fail_drive); 444 445 static int 446 good_drive(int ac, char **av) 447 { 448 449 if (ac != 2) { 450 warnx("good: %s", ac > 2 ? "extra arguments" : 451 "drive required"); 452 return (EINVAL); 453 } 454 455 return (drive_set_state(av[1], MFI_PD_STATE_UNCONFIGURED_GOOD)); 456 } 457 MFI_COMMAND(top, good, good_drive); 458 459 static int 460 rebuild_drive(int ac, char **av) 461 { 462 463 if (ac != 2) { 464 warnx("rebuild: %s", ac > 2 ? "extra arguments" : 465 "drive required"); 466 return (EINVAL); 467 } 468 469 return (drive_set_state(av[1], MFI_PD_STATE_REBUILD)); 470 } 471 MFI_COMMAND(top, rebuild, rebuild_drive); 472 473 static int 474 start_rebuild(int ac, char **av) 475 { 476 struct mfi_pd_info info; 477 uint16_t device_id; 478 uint8_t mbox[4]; 479 int error, fd; 480 481 if (ac != 2) { 482 warnx("start rebuild: %s", ac > 2 ? "extra arguments" : 483 "drive required"); 484 return (EINVAL); 485 } 486 487 fd = mfi_open(mfi_unit); 488 if (fd < 0) { 489 error = errno; 490 warn("mfi_open"); 491 return (error); 492 } 493 494 error = mfi_lookup_drive(fd, av[1], &device_id); 495 if (error) { 496 close(fd); 497 return (error); 498 } 499 500 /* Get the info for this drive. */ 501 if (mfi_pd_get_info(fd, device_id, &info, NULL) < 0) { 502 error = errno; 503 warn("Failed to fetch info for drive %u", device_id); 504 close(fd); 505 return (error); 506 } 507 508 /* Check the state, must be REBUILD. */ 509 if (info.fw_state != MFI_PD_STATE_REBUILD) { 510 warnx("Drive %d is not in the REBUILD state", device_id); 511 close(fd); 512 return (EINVAL); 513 } 514 515 /* Start the rebuild. */ 516 mbox_store_pdref(&mbox[0], &info.ref); 517 if (mfi_dcmd_command(fd, MFI_DCMD_PD_REBUILD_START, NULL, 0, mbox, 4, 518 NULL) < 0) { 519 error = errno; 520 warn("Failed to start rebuild on drive %u", device_id); 521 close(fd); 522 return (error); 523 } 524 close(fd); 525 526 return (0); 527 } 528 MFI_COMMAND(start, rebuild, start_rebuild); 529 530 static int 531 abort_rebuild(int ac, char **av) 532 { 533 struct mfi_pd_info info; 534 uint16_t device_id; 535 uint8_t mbox[4]; 536 int error, fd; 537 538 if (ac != 2) { 539 warnx("abort rebuild: %s", ac > 2 ? "extra arguments" : 540 "drive required"); 541 return (EINVAL); 542 } 543 544 fd = mfi_open(mfi_unit); 545 if (fd < 0) { 546 error = errno; 547 warn("mfi_open"); 548 return (error); 549 } 550 551 error = mfi_lookup_drive(fd, av[1], &device_id); 552 if (error) { 553 close(fd); 554 return (error); 555 } 556 557 /* Get the info for this drive. */ 558 if (mfi_pd_get_info(fd, device_id, &info, NULL) < 0) { 559 error = errno; 560 warn("Failed to fetch info for drive %u", device_id); 561 close(fd); 562 return (error); 563 } 564 565 /* Check the state, must be REBUILD. */ 566 if (info.fw_state != MFI_PD_STATE_REBUILD) { 567 warn("Drive %d is not in the REBUILD state", device_id); 568 close(fd); 569 return (EINVAL); 570 } 571 572 /* Abort the rebuild. */ 573 mbox_store_pdref(&mbox[0], &info.ref); 574 if (mfi_dcmd_command(fd, MFI_DCMD_PD_REBUILD_ABORT, NULL, 0, mbox, 4, 575 NULL) < 0) { 576 error = errno; 577 warn("Failed to abort rebuild on drive %u", device_id); 578 close(fd); 579 return (error); 580 } 581 close(fd); 582 583 return (0); 584 } 585 MFI_COMMAND(abort, rebuild, abort_rebuild); 586 587 static int 588 drive_progress(int ac, char **av) 589 { 590 struct mfi_pd_info info; 591 uint16_t device_id; 592 int error, fd; 593 594 if (ac != 2) { 595 warnx("drive progress: %s", ac > 2 ? "extra arguments" : 596 "drive required"); 597 return (EINVAL); 598 } 599 600 fd = mfi_open(mfi_unit); 601 if (fd < 0) { 602 error = errno; 603 warn("mfi_open"); 604 return (error); 605 } 606 607 error = mfi_lookup_drive(fd, av[1], &device_id); 608 if (error) { 609 close(fd); 610 return (error); 611 } 612 613 /* Get the info for this drive. */ 614 if (mfi_pd_get_info(fd, device_id, &info, NULL) < 0) { 615 error = errno; 616 warn("Failed to fetch info for drive %u", device_id); 617 close(fd); 618 return (error); 619 } 620 close(fd); 621 622 /* Display any of the active events. */ 623 if (info.prog_info.active & MFI_PD_PROGRESS_REBUILD) 624 mfi_display_progress("Rebuild", &info.prog_info.rbld); 625 if (info.prog_info.active & MFI_PD_PROGRESS_PATROL) 626 mfi_display_progress("Patrol Read", &info.prog_info.patrol); 627 if (info.prog_info.active & MFI_PD_PROGRESS_CLEAR) 628 mfi_display_progress("Clear", &info.prog_info.clear); 629 if ((info.prog_info.active & (MFI_PD_PROGRESS_REBUILD | 630 MFI_PD_PROGRESS_PATROL | MFI_PD_PROGRESS_CLEAR)) == 0) 631 printf("No activity in progress for drive %s.\n", 632 mfi_drive_name(NULL, device_id, 633 MFI_DNAME_DEVICE_ID|MFI_DNAME_HONOR_OPTS)); 634 635 return (0); 636 } 637 MFI_COMMAND(drive, progress, drive_progress); 638 639 static int 640 drive_clear(int ac, char **av) 641 { 642 struct mfi_pd_info info; 643 uint32_t opcode; 644 uint16_t device_id; 645 uint8_t mbox[4]; 646 char *s1; 647 int error, fd; 648 649 if (ac != 3) { 650 warnx("drive clear: %s", ac > 3 ? "extra arguments" : 651 "drive and action required"); 652 return (EINVAL); 653 } 654 655 for (s1 = av[2]; *s1 != '\0'; s1++) 656 *s1 = tolower(*s1); 657 if (strcmp(av[2], "start") == 0) 658 opcode = MFI_DCMD_PD_CLEAR_START; 659 else if ((strcmp(av[2], "stop") == 0) || (strcmp(av[2], "abort") == 0)) 660 opcode = MFI_DCMD_PD_CLEAR_ABORT; 661 else { 662 warnx("drive clear: invalid action, must be 'start' or 'stop'\n"); 663 return (EINVAL); 664 } 665 666 fd = mfi_open(mfi_unit); 667 if (fd < 0) { 668 error = errno; 669 warn("mfi_open"); 670 return (error); 671 } 672 673 error = mfi_lookup_drive(fd, av[1], &device_id); 674 if (error) { 675 close(fd); 676 return (error); 677 } 678 679 /* Get the info for this drive. */ 680 if (mfi_pd_get_info(fd, device_id, &info, NULL) < 0) { 681 error = errno; 682 warn("Failed to fetch info for drive %u", device_id); 683 close(fd); 684 return (error); 685 } 686 687 mbox_store_pdref(&mbox[0], &info.ref); 688 if (mfi_dcmd_command(fd, opcode, NULL, 0, mbox, 4, NULL) < 0) { 689 error = errno; 690 warn("Failed to %s clear on drive %u", 691 opcode == MFI_DCMD_PD_CLEAR_START ? "start" : "stop", 692 device_id); 693 close(fd); 694 return (error); 695 } 696 697 close(fd); 698 return (0); 699 } 700 MFI_COMMAND(drive, clear, drive_clear); 701 702 static int 703 drive_locate(int ac, char **av) 704 { 705 uint16_t device_id; 706 uint32_t opcode; 707 int error, fd; 708 uint8_t mbox[4]; 709 710 if (ac != 3) { 711 warnx("locate: %s", ac > 3 ? "extra arguments" : 712 "drive and state required"); 713 return (EINVAL); 714 } 715 716 if (strcasecmp(av[2], "on") == 0 || strcasecmp(av[2], "start") == 0) 717 opcode = MFI_DCMD_PD_LOCATE_START; 718 else if (strcasecmp(av[2], "off") == 0 || 719 strcasecmp(av[2], "stop") == 0) 720 opcode = MFI_DCMD_PD_LOCATE_STOP; 721 else { 722 warnx("locate: invalid state %s", av[2]); 723 return (EINVAL); 724 } 725 726 fd = mfi_open(mfi_unit); 727 if (fd < 0) { 728 error = errno; 729 warn("mfi_open"); 730 return (error); 731 } 732 733 error = mfi_lookup_drive(fd, av[1], &device_id); 734 if (error) { 735 close(fd); 736 return (error); 737 } 738 739 740 mbox_store_device_id(&mbox[0], device_id); 741 mbox[2] = 0; 742 mbox[3] = 0; 743 if (mfi_dcmd_command(fd, opcode, NULL, 0, mbox, 4, NULL) < 0) { 744 error = errno; 745 warn("Failed to %s locate on drive %u", 746 opcode == MFI_DCMD_PD_LOCATE_START ? "start" : "stop", 747 device_id); 748 close(fd); 749 return (error); 750 } 751 close(fd); 752 753 return (0); 754 } 755 MFI_COMMAND(top, locate, drive_locate); 756