1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 2008, 2009 Yahoo!, Inc. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. The names of the authors may not be used to endorse or promote 16 * products derived from this software without specific prior written 17 * permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 * 31 * $FreeBSD$ 32 */ 33 34#include <sys/types.h> 35#include <sys/errno.h> 36#include <err.h> 37#include <fcntl.h> 38#include <libutil.h> 39#include <stdio.h> 40#include <stdlib.h> 41#include <string.h> 42#include <unistd.h> 43#include "mfiutil.h" 44 45 static const char* foreign_state = " (FOREIGN)"; 46 47 MFI_TABLE(top, show); 48 49 void 50 format_stripe(char *buf, size_t buflen, uint8_t stripe) 51{ 52 53 humanize_number(buf, buflen, (1 << stripe) * 512, "", HN_AUTOSCALE, 54 HN_B | HN_NOSPACE); 55} 56 57 static int 58 show_adapter(int ac, char **av __unused) 59{ 60 struct mfi_ctrl_info info; 61 char stripe[5]; 62 int error, fd, comma; 63 64 if (ac != 1) { 65 warnx("show adapter: extra arguments"); 66 return (EINVAL); 67 } 68 69 fd = mfi_open(mfi_unit, O_RDONLY); 70 if (fd < 0) { 71 error = errno; 72 warn("mfi_open"); 73 return (error); 74 } 75 76 if (mfi_ctrl_get_info(fd, &info, NULL) < 0) { 77 error = errno; 78 warn("Failed to get controller info"); 79 close(fd); 80 return (error); 81 } 82 printf("mfi%d Adapter:\n", mfi_unit); 83 printf(" Product Name: %.80s\n", info.product_name); 84 printf(" Serial Number: %.32s\n", info.serial_number); 85 if (info.package_version[0] != '0円') 86 printf(" Firmware: %s\n", info.package_version); 87 printf(" RAID Levels:"); 88#ifdef DEBUG 89 printf(" (%#x)", info.raid_levels); 90#endif 91 comma = 0; 92 if (info.raid_levels & MFI_INFO_RAID_0) { 93 printf(" JBOD, RAID0"); 94 comma = 1; 95 } 96 if (info.raid_levels & MFI_INFO_RAID_1) { 97 printf("%s RAID1", comma ? "," : ""); 98 comma = 1; 99 } 100 if (info.raid_levels & MFI_INFO_RAID_5) { 101 printf("%s RAID5", comma ? "," : ""); 102 comma = 1; 103 } 104 if (info.raid_levels & MFI_INFO_RAID_1E) { 105 printf("%s RAID1E", comma ? "," : ""); 106 comma = 1; 107 } 108 if (info.raid_levels & MFI_INFO_RAID_6) { 109 printf("%s RAID6", comma ? "," : ""); 110 comma = 1; 111 } 112 if ((info.raid_levels & (MFI_INFO_RAID_0 | MFI_INFO_RAID_1)) == 113 (MFI_INFO_RAID_0 | MFI_INFO_RAID_1)) { 114 printf("%s RAID10", comma ? "," : ""); 115 comma = 1; 116 } 117 if ((info.raid_levels & (MFI_INFO_RAID_0 | MFI_INFO_RAID_5)) == 118 (MFI_INFO_RAID_0 | MFI_INFO_RAID_5)) { 119 printf("%s RAID50", comma ? "," : ""); 120 comma = 1; 121 } 122 printf("\n"); 123 printf(" Battery Backup: "); 124 if (info.hw_present & MFI_INFO_HW_BBU) 125 printf("present\n"); 126 else 127 printf("not present\n"); 128 if (info.hw_present & MFI_INFO_HW_NVRAM) 129 printf(" NVRAM: %uK\n", info.nvram_size); 130 printf(" Onboard Memory: %uM\n", info.memory_size); 131 format_stripe(stripe, sizeof(stripe), info.stripe_sz_ops.min); 132 printf(" Minimum Stripe: %s\n", stripe); 133 format_stripe(stripe, sizeof(stripe), info.stripe_sz_ops.max); 134 printf(" Maximum Stripe: %s\n", stripe); 135 136 close(fd); 137 138 return (0); 139} 140 MFI_COMMAND(show, adapter, show_adapter); 141 142 static int 143 show_battery(int ac, char **av __unused) 144{ 145 struct mfi_bbu_capacity_info cap; 146 struct mfi_bbu_design_info design; 147 struct mfi_bbu_properties props; 148 struct mfi_bbu_status stat; 149 uint8_t status; 150 int comma, error, fd, show_capacity, show_props; 151 char buf[32]; 152 153 if (ac != 1) { 154 warnx("show battery: extra arguments"); 155 return (EINVAL); 156 } 157 158 fd = mfi_open(mfi_unit, O_RDONLY); 159 if (fd < 0) { 160 error = errno; 161 warn("mfi_open"); 162 return (error); 163 } 164 165 if (mfi_dcmd_command(fd, MFI_DCMD_BBU_GET_CAPACITY_INFO, &cap, 166 sizeof(cap), NULL, 0, &status) < 0) { 167 error = errno; 168 warn("Failed to get capacity info"); 169 close(fd); 170 return (error); 171 } 172 if (status == MFI_STAT_NO_HW_PRESENT) { 173 printf("mfi%d: No battery present\n", mfi_unit); 174 close(fd); 175 return (0); 176 } 177 show_capacity = (status == MFI_STAT_OK); 178 179 if (mfi_dcmd_command(fd, MFI_DCMD_BBU_GET_DESIGN_INFO, &design, 180 sizeof(design), NULL, 0, NULL) < 0) { 181 error = errno; 182 warn("Failed to get design info"); 183 close(fd); 184 return (error); 185 } 186 187 if (mfi_dcmd_command(fd, MFI_DCMD_BBU_GET_STATUS, &stat, sizeof(stat), 188 NULL, 0, NULL) < 0) { 189 error = errno; 190 warn("Failed to get status"); 191 close(fd); 192 return (error); 193 } 194 195 if (mfi_bbu_get_props(fd, &props, &status) < 0) { 196 error = errno; 197 warn("Failed to get properties"); 198 close(fd); 199 return (error); 200 } 201 show_props = (status == MFI_STAT_OK); 202 203 printf("mfi%d: Battery State:\n", mfi_unit); 204 printf(" Manufacture Date: %d/%d/%d\n", design.mfg_date >> 5 & 0x0f, 205 design.mfg_date & 0x1f, design.mfg_date >> 9 & 0xffff); 206 printf(" Serial Number: %d\n", design.serial_number); 207 printf(" Manufacturer: %s\n", design.mfg_name); 208 printf(" Model: %s\n", design.device_name); 209 printf(" Chemistry: %s\n", design.device_chemistry); 210 printf(" Design Capacity: %d mAh\n", design.design_capacity); 211 if (show_capacity) { 212 printf(" Full Charge Capacity: %d mAh\n", 213 cap.full_charge_capacity); 214 printf(" Current Capacity: %d mAh\n", 215 cap.remaining_capacity); 216 printf(" Charge Cycles: %d\n", cap.cycle_count); 217 printf(" Current Charge: %d%%\n", cap.relative_charge); 218 } 219 printf(" Design Voltage: %d mV\n", design.design_voltage); 220 printf(" Current Voltage: %d mV\n", stat.voltage); 221 printf(" Temperature: %d C\n", stat.temperature); 222 if (show_props) { 223 mfi_autolearn_period(props.auto_learn_period, buf, sizeof(buf)); 224 printf(" Autolearn period: %s\n", buf); 225 if (props.auto_learn_mode != 0) 226 snprintf(buf, sizeof(buf), "never"); 227 else 228 mfi_next_learn_time(props.next_learn_time, buf, 229 sizeof(buf)); 230 printf(" Next learn time: %s\n", buf); 231 printf(" Learn delay interval: %u hour%s\n", 232 props.learn_delay_interval, 233 props.learn_delay_interval != 1 ? "s" : ""); 234 mfi_autolearn_mode(props.auto_learn_mode, buf, sizeof(buf)); 235 printf(" Autolearn mode: %s\n", buf); 236 if (props.bbu_mode != 0) 237 printf(" BBU Mode: %d\n", props.bbu_mode); 238 } 239 printf(" Status:"); 240 comma = 0; 241 if (stat.fw_status & MFI_BBU_STATE_PACK_MISSING) { 242 printf(" PACK_MISSING"); 243 comma = 1; 244 } 245 if (stat.fw_status & MFI_BBU_STATE_VOLTAGE_LOW) { 246 printf("%s VOLTAGE_LOW", comma ? "," : ""); 247 comma = 1; 248 } 249 if (stat.fw_status & MFI_BBU_STATE_TEMPERATURE_HIGH) { 250 printf("%s TEMPERATURE_HIGH", comma ? "," : ""); 251 comma = 1; 252 } 253 if (stat.fw_status & MFI_BBU_STATE_CHARGE_ACTIVE) { 254 printf("%s CHARGING", comma ? "," : ""); 255 comma = 1; 256 } 257 if (stat.fw_status & MFI_BBU_STATE_DISCHARGE_ACTIVE) { 258 printf("%s DISCHARGING", comma ? "," : ""); 259 comma = 1; 260 } 261 if (stat.fw_status & MFI_BBU_STATE_LEARN_CYC_REQ) { 262 printf("%s LEARN_CYCLE_REQUESTED", comma ? "," : ""); 263 comma = 1; 264 } 265 if (stat.fw_status & MFI_BBU_STATE_LEARN_CYC_ACTIVE) { 266 printf("%s LEARN_CYCLE_ACTIVE", comma ? "," : ""); 267 comma = 1; 268 } 269 if (stat.fw_status & MFI_BBU_STATE_LEARN_CYC_FAIL) { 270 printf("%s LEARN_CYCLE_FAIL", comma ? "," : ""); 271 comma = 1; 272 } 273 if (stat.fw_status & MFI_BBU_STATE_LEARN_CYC_TIMEOUT) { 274 printf("%s LEARN_CYCLE_TIMEOUT", comma ? "," : ""); 275 comma = 1; 276 } 277 if (stat.fw_status & MFI_BBU_STATE_I2C_ERR_DETECT) { 278 printf("%s I2C_ERROR_DETECT", comma ? "," : ""); 279 comma = 1; 280 } 281 282 if (!comma) 283 printf(" normal"); 284 printf("\n"); 285 switch (stat.battery_type) { 286 case MFI_BBU_TYPE_BBU: 287 printf(" State of Health: %s\n", 288 stat.detail.bbu.is_SOH_good ? "good" : "bad"); 289 break; 290 } 291 292 close(fd); 293 294 return (0); 295} 296 MFI_COMMAND(show, battery, show_battery); 297 298 void 299 print_ld(struct mfi_ld_info *info, int state_len) 300{ 301 struct mfi_ld_params *params = &info->ld_config.params; 302 const char *level; 303 char size[6], stripe[5]; 304 305 humanize_number(size, sizeof(size), info->size * 512, 306 "", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL); 307 format_stripe(stripe, sizeof(stripe), 308 info->ld_config.params.stripe_size); 309 level = mfi_raid_level(params->primary_raid_level, 310 params->secondary_raid_level); 311 if (state_len > 0) 312 printf("(%6s) %-8s %6s %-*s", size, level, stripe, state_len, 313 mfi_ldstate(params->state)); 314 else 315 printf("(%s) %s %s %s", size, level, stripe, 316 mfi_ldstate(params->state)); 317} 318 319 void 320 print_pd(struct mfi_pd_info *info, int state_len) 321{ 322 const char *s; 323 char buf[256]; 324 325 humanize_number(buf, 6, info->raw_size * 512, "", 326 HN_AUTOSCALE, HN_B | HN_NOSPACE |HN_DECIMAL); 327 printf("(%6s) ", buf); 328 if (info->state.ddf.v.pd_type.is_foreign) { 329 sprintf(buf, "%s%s", mfi_pdstate(info->fw_state), foreign_state); 330 s = buf; 331 } else 332 s = mfi_pdstate(info->fw_state); 333 if (state_len > 0) 334 printf("%-*s", state_len, s); 335 else 336 printf("%s",s); 337 s = mfi_pd_inq_string(info); 338 if (s != NULL) 339 printf(" %s", s); 340} 341 342 static int 343 show_config(int ac, char **av __unused) 344{ 345 struct mfi_config_data *config; 346 struct mfi_array *ar; 347 struct mfi_ld_config *ld; 348 struct mfi_spare *sp; 349 struct mfi_ld_info linfo; 350 struct mfi_pd_info pinfo; 351 uint16_t device_id; 352 char *p; 353 int error, fd, i, j; 354 355 if (ac != 1) { 356 warnx("show config: extra arguments"); 357 return (EINVAL); 358 } 359 360 fd = mfi_open(mfi_unit, O_RDONLY); 361 if (fd < 0) { 362 error = errno; 363 warn("mfi_open"); 364 return (error); 365 } 366 367 /* Get the config from the controller. */ 368 if (mfi_config_read(fd, &config) < 0) { 369 error = errno; 370 warn("Failed to get config"); 371 close(fd); 372 return (error); 373 } 374 375 /* Dump out the configuration. */ 376 printf("mfi%d Configuration: %d arrays, %d volumes, %d spares\n", 377 mfi_unit, config->array_count, config->log_drv_count, 378 config->spares_count); 379 p = (char *)config->array; 380 381 for (i = 0; i < config->array_count; i++) { 382 ar = (struct mfi_array *)p; 383 printf(" array %u of %u drives:\n", ar->array_ref, 384 ar->num_drives); 385 for (j = 0; j < ar->num_drives; j++) { 386 device_id = ar->pd[j].ref.v.device_id; 387 printf(" drive %s ", mfi_drive_name(NULL, 388 device_id, 389 MFI_DNAME_DEVICE_ID|MFI_DNAME_HONOR_OPTS)); 390 if (device_id != 0xffff) { 391 if (mfi_pd_get_info(fd, device_id, &pinfo, 392 NULL) < 0) 393 printf("%s", 394 mfi_pdstate(ar->pd[j].fw_state)); 395 else 396 print_pd(&pinfo, -1); 397 } 398 printf("\n"); 399 } 400 p += config->array_size; 401 } 402 403 for (i = 0; i < config->log_drv_count; i++) { 404 ld = (struct mfi_ld_config *)p; 405 printf(" volume %s ", 406 mfi_volume_name(fd, ld->properties.ld.v.target_id)); 407 if (mfi_ld_get_info(fd, ld->properties.ld.v.target_id, &linfo, 408 NULL) < 0) { 409 printf("%s %s", 410 mfi_raid_level(ld->params.primary_raid_level, 411 ld->params.secondary_raid_level), 412 mfi_ldstate(ld->params.state)); 413 } else 414 print_ld(&linfo, -1); 415 if (ld->properties.name[0] != '0円') 416 printf(" <%s>", ld->properties.name); 417 printf(" spans:\n"); 418 for (j = 0; j < ld->params.span_depth; j++) 419 printf(" array %u\n", ld->span[j].array_ref); 420 p += config->log_drv_size; 421 } 422 423 for (i = 0; i < config->spares_count; i++) { 424 sp = (struct mfi_spare *)p; 425 printf(" %s spare %s ", 426 sp->spare_type & MFI_SPARE_DEDICATED ? "dedicated" : 427 "global", mfi_drive_name(NULL, sp->ref.v.device_id, 428 MFI_DNAME_DEVICE_ID|MFI_DNAME_HONOR_OPTS)); 429 if (mfi_pd_get_info(fd, sp->ref.v.device_id, &pinfo, NULL) < 0) 430 printf("%s", mfi_pdstate(MFI_PD_STATE_HOT_SPARE)); 431 else 432 print_pd(&pinfo, -1); 433 if (sp->spare_type & MFI_SPARE_DEDICATED) { 434 printf(" backs:\n"); 435 for (j = 0; j < sp->array_count; j++) 436 printf(" array %u\n", sp->array_ref[j]); 437 } else 438 printf("\n"); 439 p += config->spares_size; 440 } 441 free(config); 442 close(fd); 443 444 return (0); 445} 446 MFI_COMMAND(show, config, show_config); 447 448 static int 449 show_volumes(int ac, char **av __unused) 450{ 451 struct mfi_ld_list list; 452 struct mfi_ld_info info; 453 int error, fd; 454 u_int i, len, state_len; 455 456 if (ac != 1) { 457 warnx("show volumes: extra arguments"); 458 return (EINVAL); 459 } 460 461 fd = mfi_open(mfi_unit, O_RDONLY); 462 if (fd < 0) { 463 error = errno; 464 warn("mfi_open"); 465 return (error); 466 } 467 468 /* Get the logical drive list from the controller. */ 469 if (mfi_ld_get_list(fd, &list, NULL) < 0) { 470 error = errno; 471 warn("Failed to get volume list"); 472 close(fd); 473 return (error); 474 } 475 476 /* List the volumes. */ 477 printf("mfi%d Volumes:\n", mfi_unit); 478 state_len = strlen("State"); 479 for (i = 0; i < list.ld_count; i++) { 480 len = strlen(mfi_ldstate(list.ld_list[i].state)); 481 if (len > state_len) 482 state_len = len; 483 } 484 printf(" Id Size Level Stripe "); 485 len = state_len - strlen("State"); 486 for (i = 0; i < (len + 1) / 2; i++) 487 printf(" "); 488 printf("State"); 489 for (i = 0; i < len / 2; i++) 490 printf(" "); 491 printf(" Cache Name\n"); 492 for (i = 0; i < list.ld_count; i++) { 493 if (mfi_ld_get_info(fd, list.ld_list[i].ld.v.target_id, &info, 494 NULL) < 0) { 495 error = errno; 496 warn("Failed to get info for volume %d", 497 list.ld_list[i].ld.v.target_id); 498 close(fd); 499 return (error); 500 } 501 printf("%6s ", 502 mfi_volume_name(fd, list.ld_list[i].ld.v.target_id)); 503 print_ld(&info, state_len); 504 switch (info.ld_config.properties.current_cache_policy & 505 (MR_LD_CACHE_ALLOW_WRITE_CACHE | 506 MR_LD_CACHE_ALLOW_READ_CACHE)) { 507 case 0: 508 printf(" Disabled"); 509 break; 510 case MR_LD_CACHE_ALLOW_READ_CACHE: 511 printf(" Reads "); 512 break; 513 case MR_LD_CACHE_ALLOW_WRITE_CACHE: 514 printf(" Writes "); 515 break; 516 case MR_LD_CACHE_ALLOW_WRITE_CACHE | 517 MR_LD_CACHE_ALLOW_READ_CACHE: 518 printf(" Enabled "); 519 break; 520 } 521 if (info.ld_config.properties.name[0] != '0円') 522 printf(" <%s>", info.ld_config.properties.name); 523 printf("\n"); 524 } 525 close(fd); 526 527 return (0); 528} 529 MFI_COMMAND(show, volumes, show_volumes); 530 531 static int 532 show_drives(int ac, char **av __unused) 533{ 534 struct mfi_pd_list *list; 535 struct mfi_pd_info info; 536 u_int i, len, state_len; 537 int error, fd; 538 539 if (ac != 1) { 540 warnx("show drives: extra arguments"); 541 return (EINVAL); 542 } 543 544 fd = mfi_open(mfi_unit, O_RDONLY); 545 if (fd < 0) { 546 error = errno; 547 warn("mfi_open"); 548 return (error); 549 } 550 551 list = NULL; 552 if (mfi_pd_get_list(fd, &list, NULL) < 0) { 553 error = errno; 554 warn("Failed to get drive list"); 555 goto error; 556 } 557 558 /* Walk the list of drives to determine width of state column. */ 559 state_len = 0; 560 for (i = 0; i < list->count; i++) { 561 if (list->addr[i].scsi_dev_type != 0) 562 continue; 563 564 if (mfi_pd_get_info(fd, list->addr[i].device_id, &info, 565 NULL) < 0) { 566 error = errno; 567 warn("Failed to fetch info for drive %u", 568 list->addr[i].device_id); 569 goto error; 570 } 571 len = strlen(mfi_pdstate(info.fw_state)); 572 if (info.state.ddf.v.pd_type.is_foreign) 573 len += strlen(foreign_state); 574 if (len > state_len) 575 state_len = len; 576 } 577 578 /* List the drives. */ 579 printf("mfi%d Physical Drives:\n", mfi_unit); 580 for (i = 0; i < list->count; i++) { 581 582 /* Skip non-hard disks. */ 583 if (list->addr[i].scsi_dev_type != 0) 584 continue; 585 586 /* Fetch details for this drive. */ 587 if (mfi_pd_get_info(fd, list->addr[i].device_id, &info, 588 NULL) < 0) { 589 error = errno; 590 warn("Failed to fetch info for drive %u", 591 list->addr[i].device_id); 592 goto error; 593 } 594 595 printf("%s ", mfi_drive_name(&info, list->addr[i].device_id, 596 MFI_DNAME_DEVICE_ID)); 597 print_pd(&info, state_len); 598 printf(" %s", mfi_drive_name(&info, list->addr[i].device_id, 599 MFI_DNAME_ES)); 600 printf("\n"); 601 } 602 error = 0; 603 error: 604 free(list); 605 close(fd); 606 607 return (error); 608} 609 MFI_COMMAND(show, drives, show_drives); 610 611 static int 612 show_firmware(int ac, char **av __unused) 613{ 614 struct mfi_ctrl_info info; 615 struct mfi_info_component header; 616 int error, fd; 617 u_int i; 618 619 if (ac != 1) { 620 warnx("show firmware: extra arguments"); 621 return (EINVAL); 622 } 623 624 fd = mfi_open(mfi_unit, O_RDONLY); 625 if (fd < 0) { 626 error = errno; 627 warn("mfi_open"); 628 return (error); 629 } 630 631 if (mfi_ctrl_get_info(fd, &info, NULL) < 0) { 632 error = errno; 633 warn("Failed to get controller info"); 634 close(fd); 635 return (error); 636 } 637 638 if (info.package_version[0] != '0円') 639 printf("mfi%d Firmware Package Version: %s\n", mfi_unit, 640 info.package_version); 641 printf("mfi%d Firmware Images:\n", mfi_unit); 642 strcpy(header.name, "Name"); 643 strcpy(header.version, "Version"); 644 strcpy(header.build_date, "Date"); 645 strcpy(header.build_time, "Time"); 646 scan_firmware(&header); 647 if (info.image_component_count > 8) 648 info.image_component_count = 8; 649 for (i = 0; i < info.image_component_count; i++) 650 scan_firmware(&info.image_component[i]); 651 if (info.pending_image_component_count > 8) 652 info.pending_image_component_count = 8; 653 for (i = 0; i < info.pending_image_component_count; i++) 654 scan_firmware(&info.pending_image_component[i]); 655 display_firmware(&header, "Status"); 656 for (i = 0; i < info.image_component_count; i++) 657 display_firmware(&info.image_component[i], "active"); 658 for (i = 0; i < info.pending_image_component_count; i++) 659 display_firmware(&info.pending_image_component[i], "pending"); 660 661 close(fd); 662 663 return (0); 664} 665 MFI_COMMAND(show, firmware, show_firmware); 666 667 static int 668 show_progress(int ac, char **av __unused) 669{ 670 struct mfi_ld_list llist; 671 struct mfi_pd_list *plist; 672 struct mfi_ld_info linfo; 673 struct mfi_pd_info pinfo; 674 int busy, error, fd; 675 u_int i; 676 uint16_t device_id; 677 uint8_t target_id; 678 679 if (ac != 1) { 680 warnx("show progress: extra arguments"); 681 return (EINVAL); 682 } 683 684 fd = mfi_open(mfi_unit, O_RDONLY); 685 if (fd < 0) { 686 error = errno; 687 warn("mfi_open"); 688 return (error); 689 } 690 691 if (mfi_ld_get_list(fd, &llist, NULL) < 0) { 692 error = errno; 693 warn("Failed to get volume list"); 694 close(fd); 695 return (error); 696 } 697 if (mfi_pd_get_list(fd, &plist, NULL) < 0) { 698 error = errno; 699 warn("Failed to get drive list"); 700 close(fd); 701 return (error); 702 } 703 704 busy = 0; 705 for (i = 0; i < llist.ld_count; i++) { 706 target_id = llist.ld_list[i].ld.v.target_id; 707 if (mfi_ld_get_info(fd, target_id, &linfo, NULL) < 0) { 708 error = errno; 709 warn("Failed to get info for volume %s", 710 mfi_volume_name(fd, target_id)); 711 free(plist); 712 close(fd); 713 return (error); 714 } 715 if (linfo.progress.active & MFI_LD_PROGRESS_CC) { 716 printf("volume %s ", mfi_volume_name(fd, target_id)); 717 mfi_display_progress("Consistency Check", 718 &linfo.progress.cc); 719 busy = 1; 720 } 721 if (linfo.progress.active & MFI_LD_PROGRESS_BGI) { 722 printf("volume %s ", mfi_volume_name(fd, target_id)); 723 mfi_display_progress("Background Init", 724 &linfo.progress.bgi); 725 busy = 1; 726 } 727 if (linfo.progress.active & MFI_LD_PROGRESS_FGI) { 728 printf("volume %s ", mfi_volume_name(fd, target_id)); 729 mfi_display_progress("Foreground Init", 730 &linfo.progress.fgi); 731 busy = 1; 732 } 733 if (linfo.progress.active & MFI_LD_PROGRESS_RECON) { 734 printf("volume %s ", mfi_volume_name(fd, target_id)); 735 mfi_display_progress("Reconstruction", 736 &linfo.progress.recon); 737 busy = 1; 738 } 739 } 740 741 for (i = 0; i < plist->count; i++) { 742 if (plist->addr[i].scsi_dev_type != 0) 743 continue; 744 745 device_id = plist->addr[i].device_id; 746 if (mfi_pd_get_info(fd, device_id, &pinfo, NULL) < 0) { 747 error = errno; 748 warn("Failed to fetch info for drive %u", device_id); 749 free(plist); 750 close(fd); 751 return (error); 752 } 753 754 if (pinfo.prog_info.active & MFI_PD_PROGRESS_REBUILD) { 755 printf("drive %s ", mfi_drive_name(NULL, device_id, 756 MFI_DNAME_DEVICE_ID|MFI_DNAME_HONOR_OPTS)); 757 mfi_display_progress("Rebuild", &pinfo.prog_info.rbld); 758 busy = 1; 759 } 760 if (pinfo.prog_info.active & MFI_PD_PROGRESS_PATROL) { 761 printf("drive %s ", mfi_drive_name(NULL, device_id, 762 MFI_DNAME_DEVICE_ID|MFI_DNAME_HONOR_OPTS)); 763 mfi_display_progress("Patrol Read", 764 &pinfo.prog_info.patrol); 765 busy = 1; 766 } 767 if (pinfo.prog_info.active & MFI_PD_PROGRESS_CLEAR) { 768 printf("drive %s ", mfi_drive_name(NULL, device_id, 769 MFI_DNAME_DEVICE_ID|MFI_DNAME_HONOR_OPTS)); 770 mfi_display_progress("Clear", &pinfo.prog_info.clear); 771 busy = 1; 772 } 773 } 774 775 free(plist); 776 close(fd); 777 778 if (!busy) 779 printf("No activity in progress for adapter mfi%d\n", mfi_unit); 780 781 return (0); 782} 783 MFI_COMMAND(show, progress, show_progress); 784 785 static int 786 show_foreign(int ac, char **av) 787{ 788 return(display_format(ac, av, 0/*normal display*/, MFI_DCMD_CFG_FOREIGN_DISPLAY)); 789} 790 MFI_COMMAND(show, foreign, show_foreign); 791