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