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