2 * Copyright (c) 2008, 2009 Yahoo!, Inc.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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
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
32 #include <sys/types.h>
33 #include <sys/errno.h>
46 format_stripe(char *buf, size_t buflen, uint8_t stripe)
49 humanize_number(buf, buflen, (1 << stripe) * 512, "", HN_AUTOSCALE,
54 show_adapter(int ac, char **av __unused)
56 struct mfi_ctrl_info info;
61 warnx("show adapter: extra arguments");
65 fd = mfi_open(mfi_unit, O_RDONLY);
72 if (mfi_ctrl_get_info(fd, &info, NULL) < 0) {
74 warn("Failed to get controller info");
78 printf("mfi%d Adapter:\n", mfi_unit);
79 printf(" Product Name: %.80s\n", info.product_name);
80 printf(" Serial Number: %.32s\n", info.serial_number);
81 if (info.package_version[0] != '\0')
82 printf(" Firmware: %s\n", info.package_version);
83 printf(" RAID Levels:");
85 printf(" (%#x)", info.raid_levels);
88 if (info.raid_levels & MFI_INFO_RAID_0) {
89 printf(" JBOD, RAID0");
92 if (info.raid_levels & MFI_INFO_RAID_1) {
93 printf("%s RAID1", comma ? "," : "");
96 if (info.raid_levels & MFI_INFO_RAID_5) {
97 printf("%s RAID5", comma ? "," : "");
100 if (info.raid_levels & MFI_INFO_RAID_1E) {
101 printf("%s RAID1E", comma ? "," : "");
104 if (info.raid_levels & MFI_INFO_RAID_6) {
105 printf("%s RAID6", comma ? "," : "");
108 if ((info.raid_levels & (MFI_INFO_RAID_0 | MFI_INFO_RAID_1)) ==
109 (MFI_INFO_RAID_0 | MFI_INFO_RAID_1)) {
110 printf("%s RAID10", comma ? "," : "");
113 if ((info.raid_levels & (MFI_INFO_RAID_0 | MFI_INFO_RAID_5)) ==
114 (MFI_INFO_RAID_0 | MFI_INFO_RAID_5)) {
115 printf("%s RAID50", comma ? "," : "");
119 printf(" Battery Backup: ");
120 if (info.hw_present & MFI_INFO_HW_BBU)
123 printf("not present\n");
124 if (info.hw_present & MFI_INFO_HW_NVRAM)
125 printf(" NVRAM: %uK\n", info.nvram_size);
126 printf(" Onboard Memory: %uM\n", info.memory_size);
127 format_stripe(stripe, sizeof(stripe), info.stripe_sz_ops.min);
128 printf(" Minimum Stripe: %s\n", stripe);
129 format_stripe(stripe, sizeof(stripe), info.stripe_sz_ops.max);
130 printf(" Maximum Stripe: %s\n", stripe);
136 MFI_COMMAND(show, adapter, show_adapter);
139 show_battery(int ac, char **av __unused)
141 struct mfi_bbu_capacity_info cap;
142 struct mfi_bbu_design_info design;
143 struct mfi_bbu_status stat;
145 int comma, error, fd, show_capacity;
148 warnx("show battery: extra arguments");
152 fd = mfi_open(mfi_unit, O_RDONLY);
159 if (mfi_dcmd_command(fd, MFI_DCMD_BBU_GET_CAPACITY_INFO, &cap,
160 sizeof(cap), NULL, 0, &status) < 0) {
162 warn("Failed to get capacity info");
166 if (status == MFI_STAT_NO_HW_PRESENT) {
167 printf("mfi%d: No battery present\n", mfi_unit);
171 show_capacity = (status == MFI_STAT_OK);
173 if (mfi_dcmd_command(fd, MFI_DCMD_BBU_GET_DESIGN_INFO, &design,
174 sizeof(design), NULL, 0, NULL) < 0) {
176 warn("Failed to get design info");
181 if (mfi_dcmd_command(fd, MFI_DCMD_BBU_GET_STATUS, &stat, sizeof(stat),
182 NULL, 0, NULL) < 0) {
184 warn("Failed to get status");
189 printf("mfi%d: Battery State:\n", mfi_unit);
190 printf(" Manufacture Date: %d/%d/%d\n", design.mfg_date >> 5 & 0x0f,
191 design.mfg_date & 0x1f, design.mfg_date >> 9 & 0xffff);
192 printf(" Serial Number: %d\n", design.serial_number);
193 printf(" Manufacturer: %s\n", design.mfg_name);
194 printf(" Model: %s\n", design.device_name);
195 printf(" Chemistry: %s\n", design.device_chemistry);
196 printf(" Design Capacity: %d mAh\n", design.design_capacity);
198 printf(" Full Charge Capacity: %d mAh\n",
199 cap.full_charge_capacity);
200 printf(" Current Capacity: %d mAh\n",
201 cap.remaining_capacity);
202 printf(" Charge Cycles: %d\n", cap.cycle_count);
203 printf(" Current Charge: %d%%\n", cap.relative_charge);
205 printf(" Design Voltage: %d mV\n", design.design_voltage);
206 printf(" Current Voltage: %d mV\n", stat.voltage);
207 printf(" Temperature: %d C\n", stat.temperature);
210 if (stat.fw_status & MFI_BBU_STATE_PACK_MISSING) {
211 printf(" PACK_MISSING");
214 if (stat.fw_status & MFI_BBU_STATE_VOLTAGE_LOW) {
215 printf("%s VOLTAGE_LOW", comma ? "," : "");
218 if (stat.fw_status & MFI_BBU_STATE_TEMPERATURE_HIGH) {
219 printf("%s TEMPERATURE_HIGH", comma ? "," : "");
222 if (stat.fw_status & MFI_BBU_STATE_CHARGE_ACTIVE) {
223 printf("%s CHARGING", comma ? "," : "");
226 if (stat.fw_status & MFI_BBU_STATE_DISCHARGE_ACTIVE) {
227 printf("%s DISCHARGING", comma ? "," : "");
230 if (stat.fw_status & MFI_BBU_STATE_LEARN_CYC_REQ) {
231 printf("%s LEARN_CYCLE_REQUESTED", comma ? "," : "");
234 if (stat.fw_status & MFI_BBU_STATE_LEARN_CYC_ACTIVE) {
235 printf("%s LEARN_CYCLE_ACTIVE", comma ? "," : "");
238 if (stat.fw_status & MFI_BBU_STATE_LEARN_CYC_FAIL) {
239 printf("%s LEARN_CYCLE_FAIL", comma ? "," : "");
242 if (stat.fw_status & MFI_BBU_STATE_LEARN_CYC_TIMEOUT) {
243 printf("%s LEARN_CYCLE_TIMEOUT", comma ? "," : "");
246 if (stat.fw_status & MFI_BBU_STATE_I2C_ERR_DETECT) {
247 printf("%s I2C_ERROR_DETECT", comma ? "," : "");
254 switch (stat.battery_type) {
255 case MFI_BBU_TYPE_BBU:
256 printf(" State of Health: %s\n",
257 stat.detail.bbu.is_SOH_good ? "good" : "bad");
265 MFI_COMMAND(show, battery, show_battery);
268 print_ld(struct mfi_ld_info *info, int state_len)
270 struct mfi_ld_params *params = &info->ld_config.params;
272 char size[6], stripe[5];
274 humanize_number(size, sizeof(size), info->size * 512,
275 "", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
276 format_stripe(stripe, sizeof(stripe),
277 info->ld_config.params.stripe_size);
278 level = mfi_raid_level(params->primary_raid_level,
279 params->secondary_raid_level);
281 printf("(%6s) %-8s %6s %-*s", size, level, stripe, state_len,
282 mfi_ldstate(params->state));
284 printf("(%s) %s %s %s", size, level, stripe,
285 mfi_ldstate(params->state));
289 print_pd(struct mfi_pd_info *info, int state_len)
294 humanize_number(buf, sizeof(buf), info->raw_size * 512, "",
295 HN_AUTOSCALE, HN_B | HN_NOSPACE |HN_DECIMAL);
296 printf("(%6s) ", buf);
298 printf("%-*s", state_len, mfi_pdstate(info->fw_state));
300 printf("%s", mfi_pdstate(info->fw_state));
301 s = mfi_pd_inq_string(info);
307 show_config(int ac, char **av __unused)
309 struct mfi_config_data *config;
310 struct mfi_array *ar;
311 struct mfi_ld_config *ld;
312 struct mfi_spare *sp;
313 struct mfi_ld_info linfo;
314 struct mfi_pd_info pinfo;
320 warnx("show config: extra arguments");
324 fd = mfi_open(mfi_unit, O_RDONLY);
331 /* Get the config from the controller. */
332 if (mfi_config_read(fd, &config) < 0) {
334 warn("Failed to get config");
339 /* Dump out the configuration. */
340 printf("mfi%d Configuration: %d arrays, %d volumes, %d spares\n",
341 mfi_unit, config->array_count, config->log_drv_count,
342 config->spares_count);
343 p = (char *)config->array;
345 for (i = 0; i < config->array_count; i++) {
346 ar = (struct mfi_array *)p;
347 printf(" array %u of %u drives:\n", ar->array_ref,
349 for (j = 0; j < ar->num_drives; j++) {
350 device_id = ar->pd[j].ref.v.device_id;
351 printf(" drive %s ", mfi_drive_name(NULL,
353 MFI_DNAME_DEVICE_ID|MFI_DNAME_HONOR_OPTS));
354 if (device_id != 0xffff) {
355 if (mfi_pd_get_info(fd, device_id, &pinfo,
358 mfi_pdstate(ar->pd[j].fw_state));
360 print_pd(&pinfo, -1);
364 p += config->array_size;
367 for (i = 0; i < config->log_drv_count; i++) {
368 ld = (struct mfi_ld_config *)p;
369 printf(" volume %s ",
370 mfi_volume_name(fd, ld->properties.ld.v.target_id));
371 if (mfi_ld_get_info(fd, ld->properties.ld.v.target_id, &linfo,
374 mfi_raid_level(ld->params.primary_raid_level,
375 ld->params.secondary_raid_level),
376 mfi_ldstate(ld->params.state));
378 print_ld(&linfo, -1);
379 if (ld->properties.name[0] != '\0')
380 printf(" <%s>", ld->properties.name);
382 for (j = 0; j < ld->params.span_depth; j++)
383 printf(" array %u\n", ld->span[j].array_ref);
384 p += config->log_drv_size;
387 for (i = 0; i < config->spares_count; i++) {
388 sp = (struct mfi_spare *)p;
389 printf(" %s spare %s ",
390 sp->spare_type & MFI_SPARE_DEDICATED ? "dedicated" :
391 "global", mfi_drive_name(NULL, sp->ref.v.device_id,
392 MFI_DNAME_DEVICE_ID|MFI_DNAME_HONOR_OPTS));
393 if (mfi_pd_get_info(fd, sp->ref.v.device_id, &pinfo, NULL) < 0)
394 printf("%s", mfi_pdstate(MFI_PD_STATE_HOT_SPARE));
396 print_pd(&pinfo, -1);
397 if (sp->spare_type & MFI_SPARE_DEDICATED) {
399 for (j = 0; j < sp->array_count; j++)
400 printf(" array %u\n", sp->array_ref[j]);
403 p += config->spares_size;
410 MFI_COMMAND(show, config, show_config);
413 show_volumes(int ac, char **av __unused)
415 struct mfi_ld_list list;
416 struct mfi_ld_info info;
418 u_int i, len, state_len;
421 warnx("show volumes: extra arguments");
425 fd = mfi_open(mfi_unit, O_RDONLY);
432 /* Get the logical drive list from the controller. */
433 if (mfi_ld_get_list(fd, &list, NULL) < 0) {
435 warn("Failed to get volume list");
440 /* List the volumes. */
441 printf("mfi%d Volumes:\n", mfi_unit);
442 state_len = strlen("State");
443 for (i = 0; i < list.ld_count; i++) {
444 len = strlen(mfi_ldstate(list.ld_list[i].state));
448 printf(" Id Size Level Stripe ");
449 len = state_len - strlen("State");
450 for (i = 0; i < (len + 1) / 2; i++)
453 for (i = 0; i < len / 2; i++)
455 printf(" Cache Name\n");
456 for (i = 0; i < list.ld_count; i++) {
457 if (mfi_ld_get_info(fd, list.ld_list[i].ld.v.target_id, &info,
460 warn("Failed to get info for volume %d",
461 list.ld_list[i].ld.v.target_id);
466 mfi_volume_name(fd, list.ld_list[i].ld.v.target_id));
467 print_ld(&info, state_len);
468 switch (info.ld_config.properties.current_cache_policy &
469 (MR_LD_CACHE_ALLOW_WRITE_CACHE |
470 MR_LD_CACHE_ALLOW_READ_CACHE)) {
474 case MR_LD_CACHE_ALLOW_READ_CACHE:
477 case MR_LD_CACHE_ALLOW_WRITE_CACHE:
480 case MR_LD_CACHE_ALLOW_WRITE_CACHE |
481 MR_LD_CACHE_ALLOW_READ_CACHE:
485 if (info.ld_config.properties.name[0] != '\0')
486 printf(" <%s>", info.ld_config.properties.name);
493 MFI_COMMAND(show, volumes, show_volumes);
496 show_drives(int ac, char **av __unused)
498 struct mfi_pd_list *list;
499 struct mfi_pd_info info;
500 u_int i, len, state_len;
504 warnx("show drives: extra arguments");
508 fd = mfi_open(mfi_unit, O_RDONLY);
516 if (mfi_pd_get_list(fd, &list, NULL) < 0) {
518 warn("Failed to get drive list");
522 /* Walk the list of drives to determine width of state column. */
524 for (i = 0; i < list->count; i++) {
525 if (list->addr[i].scsi_dev_type != 0)
528 if (mfi_pd_get_info(fd, list->addr[i].device_id, &info,
531 warn("Failed to fetch info for drive %u",
532 list->addr[i].device_id);
535 len = strlen(mfi_pdstate(info.fw_state));
540 /* List the drives. */
541 printf("mfi%d Physical Drives:\n", mfi_unit);
542 for (i = 0; i < list->count; i++) {
544 /* Skip non-hard disks. */
545 if (list->addr[i].scsi_dev_type != 0)
548 /* Fetch details for this drive. */
549 if (mfi_pd_get_info(fd, list->addr[i].device_id, &info,
552 warn("Failed to fetch info for drive %u",
553 list->addr[i].device_id);
557 printf("%s ", mfi_drive_name(&info, list->addr[i].device_id,
558 MFI_DNAME_DEVICE_ID));
559 print_pd(&info, state_len);
560 printf(" %s", mfi_drive_name(&info, list->addr[i].device_id,
571 MFI_COMMAND(show, drives, show_drives);
573 int fw_name_width, fw_version_width, fw_date_width, fw_time_width;
576 scan_firmware(struct mfi_info_component *comp)
580 len = strlen(comp->name);
581 if (fw_name_width < len)
583 len = strlen(comp->version);
584 if (fw_version_width < len)
585 fw_version_width = len;
586 len = strlen(comp->build_date);
587 if (fw_date_width < len)
589 len = strlen(comp->build_time);
590 if (fw_time_width < len)
595 display_firmware(struct mfi_info_component *comp, const char *tag)
598 printf("%-*s %-*s %-*s %-*s %s\n", fw_name_width, comp->name,
599 fw_version_width, comp->version, fw_date_width, comp->build_date,
600 fw_time_width, comp->build_time, tag);
604 show_firmware(int ac, char **av __unused)
606 struct mfi_ctrl_info info;
607 struct mfi_info_component header;
612 warnx("show firmware: extra arguments");
616 fd = mfi_open(mfi_unit, O_RDONLY);
623 if (mfi_ctrl_get_info(fd, &info, NULL) < 0) {
625 warn("Failed to get controller info");
630 if (info.package_version[0] != '\0')
631 printf("mfi%d Firmware Package Version: %s\n", mfi_unit,
632 info.package_version);
633 printf("mfi%d Firmware Images:\n", mfi_unit);
634 strcpy(header.name, "Name");
635 strcpy(header.version, "Version");
636 strcpy(header.build_date, "Date");
637 strcpy(header.build_time, "Time");
638 scan_firmware(&header);
639 if (info.image_component_count > 8)
640 info.image_component_count = 8;
641 for (i = 0; i < info.image_component_count; i++)
642 scan_firmware(&info.image_component[i]);
643 if (info.pending_image_component_count > 8)
644 info.pending_image_component_count = 8;
645 for (i = 0; i < info.pending_image_component_count; i++)
646 scan_firmware(&info.pending_image_component[i]);
647 display_firmware(&header, "Status");
648 for (i = 0; i < info.image_component_count; i++)
649 display_firmware(&info.image_component[i], "active");
650 for (i = 0; i < info.pending_image_component_count; i++)
651 display_firmware(&info.pending_image_component[i], "pending");
657 MFI_COMMAND(show, firmware, show_firmware);
660 show_progress(int ac, char **av __unused)
662 struct mfi_ld_list llist;
663 struct mfi_pd_list *plist;
664 struct mfi_ld_info linfo;
665 struct mfi_pd_info pinfo;
672 warnx("show progress: extra arguments");
676 fd = mfi_open(mfi_unit, O_RDONLY);
683 if (mfi_ld_get_list(fd, &llist, NULL) < 0) {
685 warn("Failed to get volume list");
689 if (mfi_pd_get_list(fd, &plist, NULL) < 0) {
691 warn("Failed to get drive list");
697 for (i = 0; i < llist.ld_count; i++) {
698 target_id = llist.ld_list[i].ld.v.target_id;
699 if (mfi_ld_get_info(fd, target_id, &linfo, NULL) < 0) {
701 warn("Failed to get info for volume %s",
702 mfi_volume_name(fd, target_id));
707 if (linfo.progress.active & MFI_LD_PROGRESS_CC) {
708 printf("volume %s ", mfi_volume_name(fd, target_id));
709 mfi_display_progress("Consistency Check",
713 if (linfo.progress.active & MFI_LD_PROGRESS_BGI) {
714 printf("volume %s ", mfi_volume_name(fd, target_id));
715 mfi_display_progress("Background Init",
716 &linfo.progress.bgi);
719 if (linfo.progress.active & MFI_LD_PROGRESS_FGI) {
720 printf("volume %s ", mfi_volume_name(fd, target_id));
721 mfi_display_progress("Foreground Init",
722 &linfo.progress.fgi);
725 if (linfo.progress.active & MFI_LD_PROGRESS_RECON) {
726 printf("volume %s ", mfi_volume_name(fd, target_id));
727 mfi_display_progress("Reconstruction",
728 &linfo.progress.recon);
733 for (i = 0; i < plist->count; i++) {
734 if (plist->addr[i].scsi_dev_type != 0)
737 device_id = plist->addr[i].device_id;
738 if (mfi_pd_get_info(fd, device_id, &pinfo, NULL) < 0) {
740 warn("Failed to fetch info for drive %u", device_id);
746 if (pinfo.prog_info.active & MFI_PD_PROGRESS_REBUILD) {
747 printf("drive %s ", mfi_drive_name(NULL, device_id,
748 MFI_DNAME_DEVICE_ID|MFI_DNAME_HONOR_OPTS));
749 mfi_display_progress("Rebuild", &pinfo.prog_info.rbld);
752 if (pinfo.prog_info.active & MFI_PD_PROGRESS_PATROL) {
753 printf("drive %s ", mfi_drive_name(NULL, device_id,
754 MFI_DNAME_DEVICE_ID|MFI_DNAME_HONOR_OPTS));
755 mfi_display_progress("Patrol Read",
756 &pinfo.prog_info.patrol);
759 if (pinfo.prog_info.active & MFI_PD_PROGRESS_CLEAR) {
760 printf("drive %s ", mfi_drive_name(NULL, device_id,
761 MFI_DNAME_DEVICE_ID|MFI_DNAME_HONOR_OPTS));
762 mfi_display_progress("Clear", &pinfo.prog_info.clear);
771 printf("No activity in progress for adapter mfi%d\n", mfi_unit);
775 MFI_COMMAND(show, progress, show_progress);