Remove some more %D remains here and there.
[dragonfly.git] / usr.sbin / mfiutil / mfi_evt.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_evt.c,v 1.6 2011/12/05 15:11:35 jhb Exp $
249d29c8
SW
30 */
31
32#include <sys/types.h>
33#include <sys/errno.h>
34#include <err.h>
35#include <stdio.h>
36#include <stdlib.h>
37#include <strings.h>
38#include <time.h>
39#include <unistd.h>
40#include "mfiutil.h"
41
42static int
43mfi_event_get_info(int fd, struct mfi_evt_log_state *info, uint8_t *statusp)
44{
45
46 return (mfi_dcmd_command(fd, MFI_DCMD_CTRL_EVENT_GETINFO, info,
47 sizeof(struct mfi_evt_log_state), NULL, 0, statusp));
48}
49
50static int
51mfi_get_events(int fd, struct mfi_evt_list *list, int num_events,
52 union mfi_evt filter, uint32_t start_seq, uint8_t *statusp)
53{
54 uint32_t mbox[2];
55 size_t size;
56
57 mbox[0] = start_seq;
58 mbox[1] = filter.word;
59 size = sizeof(struct mfi_evt_list) + sizeof(struct mfi_evt_detail) *
60 (num_events - 1);
61 return (mfi_dcmd_command(fd, MFI_DCMD_CTRL_EVENT_GET, list, size,
62 (uint8_t *)&mbox, sizeof(mbox), statusp));
63}
64
65static int
0c57ebbb 66show_logstate(int ac, __unused char **av)
249d29c8
SW
67{
68 struct mfi_evt_log_state info;
69 int error, fd;
70
71 if (ac != 1) {
72 warnx("show logstate: extra arguments");
73 return (EINVAL);
74 }
75
76 fd = mfi_open(mfi_unit);
77 if (fd < 0) {
78 error = errno;
79 warn("mfi_open");
80 return (error);
81 }
82
83 if (mfi_event_get_info(fd, &info, NULL) < 0) {
84 error = errno;
85 warn("Failed to get event log info");
f26fa772 86 close(fd);
249d29c8
SW
87 return (error);
88 }
89
90 printf("mfi%d Event Log Sequence Numbers:\n", mfi_unit);
91 printf(" Newest Seq #: %u\n", info.newest_seq_num);
92 printf(" Oldest Seq #: %u\n", info.oldest_seq_num);
93 printf(" Clear Seq #: %u\n", info.clear_seq_num);
94 printf("Shutdown Seq #: %u\n", info.shutdown_seq_num);
95 printf(" Boot Seq #: %u\n", info.boot_seq_num);
96
97 close(fd);
98
99 return (0);
100}
101MFI_COMMAND(show, logstate, show_logstate);
102
103static int
104parse_seq(struct mfi_evt_log_state *info, char *arg, uint32_t *seq)
105{
106 char *cp;
107 long val;
108
109 if (strcasecmp(arg, "newest") == 0) {
110 *seq = info->newest_seq_num;
111 return (0);
112 }
113 if (strcasecmp(arg, "oldest") == 0) {
114 *seq = info->oldest_seq_num;
115 return (0);
116 }
117 if (strcasecmp(arg, "clear") == 0) {
118 *seq = info->clear_seq_num;
119 return (0);
120 }
121 if (strcasecmp(arg, "shutdown") == 0) {
122 *seq = info->shutdown_seq_num;
123 return (0);
124 }
125 if (strcasecmp(arg, "boot") == 0) {
126 *seq = info->boot_seq_num;
127 return (0);
128 }
129 val = strtol(arg, &cp, 0);
130 if (*cp != '\0' || val < 0) {
131 errno = EINVAL;
132 return (-1);
133 }
134 *seq = val;
135 return (0);
136}
137
138static int
139parse_locale(char *arg, uint16_t *locale)
140{
141 char *cp;
142 long val;
143
144 if (strncasecmp(arg, "vol", 3) == 0 || strcasecmp(arg, "ld") == 0) {
145 *locale = MFI_EVT_LOCALE_LD;
146 return (0);
147 }
148 if (strncasecmp(arg, "drive", 5) == 0 || strcasecmp(arg, "pd") == 0) {
149 *locale = MFI_EVT_LOCALE_PD;
150 return (0);
151 }
152 if (strncasecmp(arg, "encl", 4) == 0) {
153 *locale = MFI_EVT_LOCALE_ENCL;
154 return (0);
155 }
156 if (strncasecmp(arg, "batt", 4) == 0 ||
157 strncasecmp(arg, "bbu", 3) == 0) {
158 *locale = MFI_EVT_LOCALE_BBU;
159 return (0);
160 }
161 if (strcasecmp(arg, "sas") == 0) {
162 *locale = MFI_EVT_LOCALE_SAS;
163 return (0);
164 }
165 if (strcasecmp(arg, "ctrl") == 0 || strncasecmp(arg, "cont", 4) == 0) {
166 *locale = MFI_EVT_LOCALE_CTRL;
167 return (0);
168 }
169 if (strcasecmp(arg, "config") == 0) {
170 *locale = MFI_EVT_LOCALE_CONFIG;
171 return (0);
172 }
173 if (strcasecmp(arg, "cluster") == 0) {
174 *locale = MFI_EVT_LOCALE_CLUSTER;
175 return (0);
176 }
177 if (strcasecmp(arg, "all") == 0) {
178 *locale = MFI_EVT_LOCALE_ALL;
179 return (0);
180 }
181 val = strtol(arg, &cp, 0);
182 if (*cp != '\0' || val < 0 || val > 0xffff) {
183 errno = EINVAL;
184 return (-1);
185 }
186 *locale = val;
187 return (0);
188}
189
190static int
191parse_class(char *arg, int8_t *class)
192{
193 char *cp;
194 long val;
195
196 if (strcasecmp(arg, "debug") == 0) {
197 *class = MFI_EVT_CLASS_DEBUG;
198 return (0);
199 }
200 if (strncasecmp(arg, "prog", 4) == 0) {
201 *class = MFI_EVT_CLASS_PROGRESS;
202 return (0);
203 }
204 if (strncasecmp(arg, "info", 4) == 0) {
205 *class = MFI_EVT_CLASS_INFO;
206 return (0);
207 }
208 if (strncasecmp(arg, "warn", 4) == 0) {
209 *class = MFI_EVT_CLASS_WARNING;
210 return (0);
211 }
212 if (strncasecmp(arg, "crit", 4) == 0) {
213 *class = MFI_EVT_CLASS_CRITICAL;
214 return (0);
215 }
216 if (strcasecmp(arg, "fatal") == 0) {
217 *class = MFI_EVT_CLASS_FATAL;
218 return (0);
219 }
220 if (strcasecmp(arg, "dead") == 0) {
221 *class = MFI_EVT_CLASS_DEAD;
222 return (0);
223 }
224 val = strtol(arg, &cp, 0);
225 if (*cp != '\0' || val < -128 || val > 127) {
226 errno = EINVAL;
227 return (-1);
228 }
229 *class = val;
230 return (0);
231}
232
233/*
234 * The timestamp is the number of seconds since 00:00 Jan 1, 2000. If
235 * the bits in 24-31 are all set, then it is the number of seconds since
236 * boot.
237 */
238static const char *
239format_timestamp(uint32_t timestamp)
240{
241 static char buffer[32];
242 static time_t base;
243 time_t t;
244 struct tm tm;
245
246 if ((timestamp & 0xff000000) == 0xff000000) {
247 snprintf(buffer, sizeof(buffer), "boot + %us", timestamp &
248 0x00ffffff);
249 return (buffer);
250 }
251
252 if (base == 0) {
253 /* Compute 00:00 Jan 1, 2000 offset. */
254 bzero(&tm, sizeof(tm));
255 tm.tm_mday = 1;
256 tm.tm_year = (2000 - 1900);
257 base = mktime(&tm);
258 }
259 if (base == -1) {
260 snprintf(buffer, sizeof(buffer), "%us", timestamp);
261 return (buffer);
262 }
263 t = base + timestamp;
264 strftime(buffer, sizeof(buffer), "%+", localtime(&t));
265 return (buffer);
266}
267
268static const char *
269format_locale(uint16_t locale)
270{
271 static char buffer[8];
272
273 switch (locale) {
274 case MFI_EVT_LOCALE_LD:
275 return ("VOLUME");
276 case MFI_EVT_LOCALE_PD:
277 return ("DRIVE");
278 case MFI_EVT_LOCALE_ENCL:
279 return ("ENCL");
280 case MFI_EVT_LOCALE_BBU:
281 return ("BATTERY");
282 case MFI_EVT_LOCALE_SAS:
283 return ("SAS");
284 case MFI_EVT_LOCALE_CTRL:
285 return ("CTRL");
286 case MFI_EVT_LOCALE_CONFIG:
287 return ("CONFIG");
288 case MFI_EVT_LOCALE_CLUSTER:
289 return ("CLUSTER");
290 case MFI_EVT_LOCALE_ALL:
291 return ("ALL");
292 default:
293 snprintf(buffer, sizeof(buffer), "0x%04x", locale);
294 return (buffer);
295 }
296}
297
298static const char *
299format_class(int8_t class)
300{
301 static char buffer[6];
302
303 switch (class) {
304 case MFI_EVT_CLASS_DEBUG:
305 return ("debug");
306 case MFI_EVT_CLASS_PROGRESS:
307 return ("progress");
308 case MFI_EVT_CLASS_INFO:
309 return ("info");
310 case MFI_EVT_CLASS_WARNING:
311 return ("WARN");
312 case MFI_EVT_CLASS_CRITICAL:
313 return ("CRIT");
314 case MFI_EVT_CLASS_FATAL:
315 return ("FATAL");
316 case MFI_EVT_CLASS_DEAD:
317 return ("DEAD");
318 default:
319 snprintf(buffer, sizeof(buffer), "%d", class);
320 return (buffer);
321 }
322}
323
249d29c8
SW
324static void
325simple_hex(void *ptr, size_t length, const char *separator)
326{
327 unsigned char *cp;
328 u_int i;
329
330 if (length == 0)
331 return;
332 cp = ptr;
333 printf("%02x", cp[0]);
334 for (i = 1; i < length; i++)
335 printf("%s%02x", separator, cp[i]);
336}
337
338static const char *
339pdrive_location(struct mfi_evt_pd *pd)
340{
341 static char buffer[16];
342
343 if (pd->enclosure_index == 0)
344 snprintf(buffer, sizeof(buffer), "%02d(s%d)", pd->device_id,
345 pd->slot_number);
346 else
347 snprintf(buffer, sizeof(buffer), "%02d(e%d/s%d)", pd->device_id,
348 pd->enclosure_index, pd->slot_number);
349 return (buffer);
350}
351
352static const char *
353volume_name(int fd, struct mfi_evt_ld *ld)
354{
355
356 return (mfi_volume_name(fd, ld->target_id));
357}
358
359/* Ripped from sys/dev/mfi/mfi.c. */
360static void
361mfi_decode_evt(int fd, struct mfi_evt_detail *detail, int verbose)
362{
363
364 printf("%5d (%s/%s/%s) - ", detail->seq, format_timestamp(detail->time),
f26fa772
SW
365 format_locale(detail->evt_class.members.locale),
366 format_class(detail->evt_class.members.evt_class));
249d29c8
SW
367 switch (detail->arg_type) {
368 case MR_EVT_ARGS_NONE:
369 break;
370 case MR_EVT_ARGS_CDB_SENSE:
371 if (verbose) {
372 printf("PD %s CDB ",
373 pdrive_location(&detail->args.cdb_sense.pd)
374 );
375 simple_hex(detail->args.cdb_sense.cdb,
376 detail->args.cdb_sense.cdb_len, ":");
377 printf(" Sense ");
378 simple_hex(detail->args.cdb_sense.sense,
379 detail->args.cdb_sense.sense_len, ":");
380 printf(":\n ");
381 }
382 break;
383 case MR_EVT_ARGS_LD:
384 printf("VOL %s event: ", volume_name(fd, &detail->args.ld));
385 break;
386 case MR_EVT_ARGS_LD_COUNT:
387 printf("VOL %s", volume_name(fd, &detail->args.ld_count.ld));
388 if (verbose) {
389 printf(" count %lld: ",
390 (long long)detail->args.ld_count.count);
391 }
392 printf(": ");
393 break;
394 case MR_EVT_ARGS_LD_LBA:
395 printf("VOL %s", volume_name(fd, &detail->args.ld_count.ld));
396 if (verbose) {
397 printf(" lba %lld",
398 (long long)detail->args.ld_lba.lba);
399 }
400 printf(": ");
401 break;
402 case MR_EVT_ARGS_LD_OWNER:
403 printf("VOL %s", volume_name(fd, &detail->args.ld_count.ld));
404 if (verbose) {
405 printf(" owner changed: prior %d, new %d",
406 detail->args.ld_owner.pre_owner,
407 detail->args.ld_owner.new_owner);
408 }
409 printf(": ");
410 break;
411 case MR_EVT_ARGS_LD_LBA_PD_LBA:
412 printf("VOL %s", volume_name(fd, &detail->args.ld_count.ld));
413 if (verbose) {
414 printf(" lba %lld, physical drive PD %s lba %lld",
415 (long long)detail->args.ld_lba_pd_lba.ld_lba,
416 pdrive_location(&detail->args.ld_lba_pd_lba.pd),
417 (long long)detail->args.ld_lba_pd_lba.pd_lba);
418 }
419 printf(": ");
420 break;
421 case MR_EVT_ARGS_LD_PROG:
422 printf("VOL %s", volume_name(fd, &detail->args.ld_prog.ld));
423 if (verbose) {
424 printf(" progress %d%% in %ds",
425 detail->args.ld_prog.prog.progress/655,
426 detail->args.ld_prog.prog.elapsed_seconds);
427 }
428 printf(": ");
429 break;
430 case MR_EVT_ARGS_LD_STATE:
431 printf("VOL %s", volume_name(fd, &detail->args.ld_prog.ld));
432 if (verbose) {
433 printf(" state prior %s new %s",
434 mfi_ldstate(detail->args.ld_state.prev_state),
435 mfi_ldstate(detail->args.ld_state.new_state));
436 }
437 printf(": ");
438 break;
439 case MR_EVT_ARGS_LD_STRIP:
f0d8b1f2 440 printf("VOL %s", volume_name(fd, &detail->args.ld_strip.ld));
249d29c8
SW
441 if (verbose) {
442 printf(" strip %lld",
443 (long long)detail->args.ld_strip.strip);
444 }
445 printf(": ");
446 break;
447 case MR_EVT_ARGS_PD:
448 if (verbose) {
449 printf("PD %s event: ",
450 pdrive_location(&detail->args.pd));
451 }
452 break;
453 case MR_EVT_ARGS_PD_ERR:
454 if (verbose) {
455 printf("PD %s err %d: ",
456 pdrive_location(&detail->args.pd_err.pd),
457 detail->args.pd_err.err);
458 }
459 break;
460 case MR_EVT_ARGS_PD_LBA:
461 if (verbose) {
462 printf("PD %s lba %lld: ",
463 pdrive_location(&detail->args.pd_lba.pd),
464 (long long)detail->args.pd_lba.lba);
465 }
466 break;
467 case MR_EVT_ARGS_PD_LBA_LD:
468 if (verbose) {
469 printf("PD %s lba %lld VOL %s: ",
470 pdrive_location(&detail->args.pd_lba_ld.pd),
471 (long long)detail->args.pd_lba.lba,
472 volume_name(fd, &detail->args.pd_lba_ld.ld));
473 }
474 break;
475 case MR_EVT_ARGS_PD_PROG:
476 if (verbose) {
477 printf("PD %s progress %d%% seconds %ds: ",
478 pdrive_location(&detail->args.pd_prog.pd),
479 detail->args.pd_prog.prog.progress/655,
480 detail->args.pd_prog.prog.elapsed_seconds);
481 }
482 break;
483 case MR_EVT_ARGS_PD_STATE:
484 if (verbose) {
485 printf("PD %s state prior %s new %s: ",
486 pdrive_location(&detail->args.pd_prog.pd),
487 mfi_pdstate(detail->args.pd_state.prev_state),
488 mfi_pdstate(detail->args.pd_state.new_state));
489 }
490 break;
491 case MR_EVT_ARGS_PCI:
492 if (verbose) {
493 printf("PCI 0x%04x 0x%04x 0x%04x 0x%04x: ",
494 detail->args.pci.venderId,
495 detail->args.pci.deviceId,
496 detail->args.pci.subVenderId,
497 detail->args.pci.subDeviceId);
498 }
499 break;
500 case MR_EVT_ARGS_RATE:
501 if (verbose) {
502 printf("Rebuild rate %d: ", detail->args.rate);
503 }
504 break;
505 case MR_EVT_ARGS_TIME:
506 if (verbose) {
507 printf("Adapter time %s; %d seconds since power on: ",
508 format_timestamp(detail->args.time.rtc),
509 detail->args.time.elapsedSeconds);
510 }
511 break;
512 case MR_EVT_ARGS_ECC:
513 if (verbose) {
514 printf("Adapter ECC %x,%x: %s: ",
515 detail->args.ecc.ecar,
516 detail->args.ecc.elog,
517 detail->args.ecc.str);
518 }
519 break;
520 default:
521 if (verbose) {
522 printf("Type %d: ", detail->arg_type);
523 }
524 break;
525 }
526 printf("%s\n", detail->description);
527}
528
529static int
530show_events(int ac, char **av)
531{
532 struct mfi_evt_log_state info;
533 struct mfi_evt_list *list;
534 union mfi_evt filter;
535 long val;
536 char *cp;
537 ssize_t size;
538 uint32_t seq, start, stop;
539 uint8_t status;
540 int ch, error, fd, num_events, verbose;
541 u_int i;
542
543 fd = mfi_open(mfi_unit);
544 if (fd < 0) {
545 error = errno;
546 warn("mfi_open");
547 return (error);
548 }
549
550 if (mfi_event_get_info(fd, &info, NULL) < 0) {
551 error = errno;
552 warn("Failed to get event log info");
f26fa772 553 close(fd);
249d29c8
SW
554 return (error);
555 }
556
557 /* Default settings. */
558 num_events = 15;
559 filter.members.reserved = 0;
560 filter.members.locale = MFI_EVT_LOCALE_ALL;
f26fa772 561 filter.members.evt_class = MFI_EVT_CLASS_WARNING;
249d29c8
SW
562 start = info.boot_seq_num;
563 stop = info.newest_seq_num;
564 verbose = 0;
565
566 /* Parse any options. */
567 optind = 1;
568 while ((ch = getopt(ac, av, "c:l:n:v")) != -1) {
569 switch (ch) {
570 case 'c':
f26fa772 571 if (parse_class(optarg, &filter.members.evt_class) < 0) {
249d29c8
SW
572 error = errno;
573 warn("Error parsing event class");
f26fa772 574 close(fd);
249d29c8
SW
575 return (error);
576 }
577 break;
578 case 'l':
579 if (parse_locale(optarg, &filter.members.locale) < 0) {
580 error = errno;
581 warn("Error parsing event locale");
f26fa772 582 close(fd);
249d29c8
SW
583 return (error);
584 }
585 break;
586 case 'n':
587 val = strtol(optarg, &cp, 0);
588 if (*cp != '\0' || val <= 0) {
589 warnx("Invalid event count");
f26fa772 590 close(fd);
249d29c8
SW
591 return (EINVAL);
592 }
593 num_events = val;
594 break;
595 case 'v':
596 verbose = 1;
597 break;
598 case '?':
599 default:
f26fa772 600 close(fd);
249d29c8
SW
601 return (EINVAL);
602 }
603 }
604 ac -= optind;
605 av += optind;
606
607 /* Determine buffer size and validate it. */
608 size = sizeof(struct mfi_evt_list) + sizeof(struct mfi_evt_detail) *
609 (num_events - 1);
610 if (size > getpagesize()) {
611 warnx("Event count is too high");
f26fa772 612 close(fd);
249d29c8
SW
613 return (EINVAL);
614 }
615
616 /* Handle optional start and stop sequence numbers. */
617 if (ac > 2) {
618 warnx("show events: extra arguments");
f26fa772 619 close(fd);
249d29c8
SW
620 return (EINVAL);
621 }
622 if (ac > 0 && parse_seq(&info, av[0], &start) < 0) {
623 error = errno;
624 warn("Error parsing starting sequence number");
f26fa772 625 close(fd);
249d29c8
SW
626 return (error);
627 }
628 if (ac > 1 && parse_seq(&info, av[1], &stop) < 0) {
629 error = errno;
630 warn("Error parsing ending sequence number");
f26fa772 631 close(fd);
249d29c8
SW
632 return (error);
633 }
634
635 list = malloc(size);
636 if (list == NULL) {
637 warnx("malloc failed");
f26fa772 638 close(fd);
249d29c8
SW
639 return (ENOMEM);
640 }
641 for (seq = start;;) {
642 if (mfi_get_events(fd, list, num_events, filter, seq,
643 &status) < 0) {
644 error = errno;
645 warn("Failed to fetch events");
f26fa772
SW
646 free(list);
647 close(fd);
249d29c8
SW
648 return (error);
649 }
650 if (status == MFI_STAT_NOT_FOUND) {
651 if (seq == start)
652 warnx("No matching events found");
653 break;
654 }
655 if (status != MFI_STAT_OK) {
656 warnx("Error fetching events: %s", mfi_status(status));
f26fa772
SW
657 free(list);
658 close(fd);
249d29c8
SW
659 return (EIO);
660 }
661
662 for (i = 0; i < list->count; i++) {
663 /*
664 * If this event is newer than 'stop_seq' then
665 * break out of the loop. Note that the log
666 * is a circular buffer so we have to handle
667 * the case that our stop point is earlier in
668 * the buffer than our start point.
669 */
670 if (list->event[i].seq >= stop) {
671 if (start <= stop)
672 break;
673 else if (list->event[i].seq < start)
674 break;
675 }
676 mfi_decode_evt(fd, &list->event[i], verbose);
677 }
678
679 /*
680 * XXX: If the event's seq # is the end of the buffer
681 * then this probably won't do the right thing. We
682 * need to know the size of the buffer somehow.
683 */
684 seq = list->event[list->count - 1].seq + 1;
685
686 }
687
688 free(list);
689 close(fd);
690
691 return (0);
692}
693MFI_COMMAND(show, events, show_events);