mfiutil(8): Fix building with -fno-common.
[dragonfly.git] / usr.sbin / mfiutil / mfi_show.c
CommitLineData
249d29c8
SW
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 *
f0d8b1f2 29 * $FreeBSD: src/usr.sbin/mfiutil/mfi_show.c,v 1.10 2011/09/27 14:28:07 emaste Exp $
249d29c8
SW
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
dd100166
SW
42const char* foreign_state = " (FOREIGN)";
43
249d29c8
SW
44MFI_TABLE(top, show);
45
dd100166 46void
249d29c8
SW
47format_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
54static int
0c57ebbb 55show_adapter(int ac, __unused char **av)
249d29c8
SW
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");
f26fa772 76 close(fd);
249d29c8
SW
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}
137MFI_COMMAND(show, adapter, show_adapter);
138
139static int
0c57ebbb 140show_battery(int ac, __unused char **av)
249d29c8
SW
141{
142 struct mfi_bbu_capacity_info cap;
143 struct mfi_bbu_design_info design;
f26fa772 144 struct mfi_bbu_status stat;
249d29c8 145 uint8_t status;
f0d8b1f2 146 int comma, error, fd, show_capacity;
249d29c8
SW
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) {
249d29c8
SW
162 error = errno;
163 warn("Failed to get capacity info");
f26fa772 164 close(fd);
249d29c8
SW
165 return (error);
166 }
f0d8b1f2
SW
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);
249d29c8
SW
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");
f26fa772
SW
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);
249d29c8
SW
187 return (error);
188 }
189
190 printf("mfi%d: Battery State:\n", mfi_unit);
f26fa772 191 printf(" Manufacture Date: %d/%d/%d\n", design.mfg_date >> 5 & 0x0f,
249d29c8 192 design.mfg_date & 0x1f, design.mfg_date >> 9 & 0xffff);
f26fa772
SW
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);
f0d8b1f2
SW
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 }
f26fa772
SW
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 }
249d29c8
SW
239
240 close(fd);
241
242 return (0);
243}
244MFI_COMMAND(show, battery, show_battery);
245
dd100166 246void
249d29c8
SW
247print_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
dd100166 267void
f26fa772 268print_pd(struct mfi_pd_info *info, int state_len)
249d29c8
SW
269{
270 const char *s;
dd100166 271 char buf[256];
249d29c8
SW
272
273 humanize_number(buf, sizeof(buf), info->raw_size * 512, "",
274 HN_AUTOSCALE, HN_B | HN_NOSPACE |HN_DECIMAL);
275 printf("(%6s) ", buf);
dd100166
SW
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);
249d29c8 281 if (state_len > 0)
dd100166 282 printf("%-*s", state_len, s);
249d29c8 283 else
9462167a 284 printf("%s", s);
249d29c8
SW
285 s = mfi_pd_inq_string(info);
286 if (s != NULL)
287 printf(" %s", s);
249d29c8
SW
288}
289
290static int
0c57ebbb 291show_config(int ac, __unused char **av)
249d29c8
SW
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");
f26fa772 319 close(fd);
249d29c8
SW
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;
f26fa772
SW
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) {
249d29c8
SW
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
f26fa772 344 print_pd(&pinfo, -1);
249d29c8 345 }
f0d8b1f2 346 printf("\n");
249d29c8
SW
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;
f26fa772 373 printf(" %s spare %s ",
249d29c8 374 sp->spare_type & MFI_SPARE_DEDICATED ? "dedicated" :
f26fa772
SW
375 "global", mfi_drive_name(NULL, sp->ref.v.device_id,
376 MFI_DNAME_DEVICE_ID|MFI_DNAME_HONOR_OPTS));
249d29c8
SW
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
f26fa772 380 print_pd(&pinfo, -1);
249d29c8
SW
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 }
f26fa772 389 free(config);
249d29c8
SW
390 close(fd);
391
392 return (0);
393}
394MFI_COMMAND(show, config, show_config);
395
396static int
0c57ebbb 397show_volumes(int ac, __unused char **av)
249d29c8
SW
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");
f26fa772 420 close(fd);
249d29c8
SW
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);
f26fa772 446 close(fd);
249d29c8
SW
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}
477MFI_COMMAND(show, volumes, show_volumes);
478
479static int
0c57ebbb 480show_drives(int ac, __unused char **av)
249d29c8
SW
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
f26fa772 499 list = NULL;
249d29c8
SW
500 if (mfi_pd_get_list(fd, &list, NULL) < 0) {
501 error = errno;
502 warn("Failed to get drive list");
f26fa772 503 goto error;
249d29c8
SW
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);
f26fa772 517 goto error;
249d29c8
SW
518 }
519 len = strlen(mfi_pdstate(info.fw_state));
dd100166
SW
520 if (info.state.ddf.v.pd_type.is_foreign)
521 len += strlen(foreign_state);
249d29c8
SW
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);
f26fa772 540 goto error;
249d29c8
SW
541 }
542
f26fa772
SW
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));
249d29c8
SW
548 printf("\n");
549 }
f26fa772
SW
550 error = 0;
551error:
552 free(list);
249d29c8
SW
553 close(fd);
554
f26fa772 555 return (error);
249d29c8
SW
556}
557MFI_COMMAND(show, drives, show_drives);
558
249d29c8 559static int
0c57ebbb 560show_firmware(int ac, __unused char **av)
249d29c8
SW
561{
562 struct mfi_ctrl_info info;
563 struct mfi_info_component header;
564 int error, fd;
565 u_int i;
566
567 if (ac != 1) {
f26fa772 568 warnx("show firmware: extra arguments");
249d29c8
SW
569 return (EINVAL);
570 }
571
572 fd = mfi_open(mfi_unit);
573 if (fd < 0) {
574 error = errno;
575 warn("mfi_open");
576 return (error);
577 }
578
579 if (mfi_ctrl_get_info(fd, &info, NULL) < 0) {
580 error = errno;
581 warn("Failed to get controller info");
f26fa772 582 close(fd);
249d29c8
SW
583 return (error);
584 }
585
586 if (info.package_version[0] != '\0')
587 printf("mfi%d Firmware Package Version: %s\n", mfi_unit,
588 info.package_version);
589 printf("mfi%d Firmware Images:\n", mfi_unit);
590 strcpy(header.name, "Name");
591 strcpy(header.version, "Version");
592 strcpy(header.build_date, "Date");
593 strcpy(header.build_time, "Time");
594 scan_firmware(&header);
595 if (info.image_component_count > 8)
596 info.image_component_count = 8;
597 for (i = 0; i < info.image_component_count; i++)
598 scan_firmware(&info.image_component[i]);
599 if (info.pending_image_component_count > 8)
600 info.pending_image_component_count = 8;
601 for (i = 0; i < info.pending_image_component_count; i++)
602 scan_firmware(&info.pending_image_component[i]);
603 display_firmware(&header, "Status");
604 for (i = 0; i < info.image_component_count; i++)
605 display_firmware(&info.image_component[i], "active");
606 for (i = 0; i < info.pending_image_component_count; i++)
607 display_firmware(&info.pending_image_component[i], "pending");
608
609 close(fd);
610
611 return (0);
612}
613MFI_COMMAND(show, firmware, show_firmware);
f26fa772
SW
614
615static int
0c57ebbb 616show_progress(int ac, __unused char **av)
f26fa772
SW
617{
618 struct mfi_ld_list llist;
619 struct mfi_pd_list *plist;
620 struct mfi_ld_info linfo;
621 struct mfi_pd_info pinfo;
622 int busy, error, fd;
623 u_int i;
624 uint16_t device_id;
625 uint8_t target_id;
626
627 if (ac != 1) {
628 warnx("show progress: extra arguments");
629 return (EINVAL);
630 }
631
632 fd = mfi_open(mfi_unit);
633 if (fd < 0) {
634 error = errno;
635 warn("mfi_open");
636 return (error);
637 }
638
639 if (mfi_ld_get_list(fd, &llist, NULL) < 0) {
640 error = errno;
641 warn("Failed to get volume list");
642 close(fd);
643 return (error);
644 }
645 if (mfi_pd_get_list(fd, &plist, NULL) < 0) {
646 error = errno;
647 warn("Failed to get drive list");
648 close(fd);
649 return (error);
650 }
651
652 busy = 0;
653 for (i = 0; i < llist.ld_count; i++) {
654 target_id = llist.ld_list[i].ld.v.target_id;
655 if (mfi_ld_get_info(fd, target_id, &linfo, NULL) < 0) {
656 error = errno;
657 warn("Failed to get info for volume %s",
658 mfi_volume_name(fd, target_id));
659 free(plist);
660 close(fd);
661 return (error);
662 }
663 if (linfo.progress.active & MFI_LD_PROGRESS_CC) {
664 printf("volume %s ", mfi_volume_name(fd, target_id));
665 mfi_display_progress("Consistency Check",
666 &linfo.progress.cc);
667 busy = 1;
668 }
669 if (linfo.progress.active & MFI_LD_PROGRESS_BGI) {
670 printf("volume %s ", mfi_volume_name(fd, target_id));
671 mfi_display_progress("Background Init",
672 &linfo.progress.bgi);
673 busy = 1;
674 }
675 if (linfo.progress.active & MFI_LD_PROGRESS_FGI) {
676 printf("volume %s ", mfi_volume_name(fd, target_id));
677 mfi_display_progress("Foreground Init",
678 &linfo.progress.fgi);
679 busy = 1;
680 }
681 if (linfo.progress.active & MFI_LD_PROGRESS_RECON) {
682 printf("volume %s ", mfi_volume_name(fd, target_id));
683 mfi_display_progress("Reconstruction",
684 &linfo.progress.recon);
685 busy = 1;
686 }
687 }
688
689 for (i = 0; i < plist->count; i++) {
690 if (plist->addr[i].scsi_dev_type != 0)
691 continue;
692
693 device_id = plist->addr[i].device_id;
694 if (mfi_pd_get_info(fd, device_id, &pinfo, NULL) < 0) {
695 error = errno;
696 warn("Failed to fetch info for drive %u", device_id);
697 free(plist);
698 close(fd);
699 return (error);
700 }
701
702 if (pinfo.prog_info.active & MFI_PD_PROGRESS_REBUILD) {
703 printf("drive %s ", mfi_drive_name(NULL, device_id,
704 MFI_DNAME_DEVICE_ID|MFI_DNAME_HONOR_OPTS));
705 mfi_display_progress("Rebuild", &pinfo.prog_info.rbld);
706 busy = 1;
707 }
708 if (pinfo.prog_info.active & MFI_PD_PROGRESS_PATROL) {
709 printf("drive %s ", mfi_drive_name(NULL, device_id,
710 MFI_DNAME_DEVICE_ID|MFI_DNAME_HONOR_OPTS));
711 mfi_display_progress("Patrol Read",
712 &pinfo.prog_info.patrol);
713 busy = 1;
714 }
715 if (pinfo.prog_info.active & MFI_PD_PROGRESS_CLEAR) {
716 printf("drive %s ", mfi_drive_name(NULL, device_id,
717 MFI_DNAME_DEVICE_ID|MFI_DNAME_HONOR_OPTS));
718 mfi_display_progress("Clear", &pinfo.prog_info.clear);
719 busy = 1;
720 }
721 }
722
723 free(plist);
724 close(fd);
725
726 if (!busy)
727 printf("No activity in progress for adapter mfi%d\n", mfi_unit);
728
729 return (0);
730}
731MFI_COMMAND(show, progress, show_progress);