?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ZTS: Add additional exceptions
[zfs.git] / cmd / zed / zed_event.c
blob7e58676922342d5c9646cf6061371bc5a0f4cdea
1 /*
2 * This file is part of the ZFS Event Daemon (ZED).
3 *
4 * Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
5 * Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
6 * Refer to the OpenZFS git commit log for authoritative copyright attribution.
7 *
8 * The contents of this file are subject to the terms of the
9 * Common Development and Distribution License Version 1.0 (CDDL-1.0).
10 * You can obtain a copy of the license from the top-level file
11 * "OPENSOLARIS.LICENSE" or at <http://opensource.org/licenses/CDDL-1.0>.
12 * You may not use this file except in compliance with the license.
13 */
14
15 #include <ctype.h>
16 #include <errno.h>
17 #include <fcntl.h>
18 #include <libzfs_core.h>
19 #include <paths.h>
20 #include <stdarg.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <sys/zfs_ioctl.h>
25 #include <time.h>
26 #include <unistd.h>
27 #include <sys/fm/fs/zfs.h>
28 #include "zed.h"
29 #include "zed_conf.h"
30 #include "zed_disk_event.h"
31 #include "zed_event.h"
32 #include "zed_exec.h"
33 #include "zed_file.h"
34 #include "zed_log.h"
35 #include "zed_strings.h"
36
37 #include "agents/zfs_agents.h"
38 #include <libzutil.h>
39
40 #define MAXBUF 4096
41
42 static int max_zevent_buf_len = 1 << 20;
43
44 /*
45 * Open the libzfs interface.
46 */
47 int
48 zed_event_init(struct zed_conf *zcp)
49 {
50 if (!zcp)
51 zed_log_die("Failed zed_event_init: %s", strerror(EINVAL));
52
53 zcp->zfs_hdl = libzfs_init();
54 if (!zcp->zfs_hdl) {
55 if (zcp->do_idle)
56 return (-1);
57 zed_log_die("Failed to initialize libzfs");
58 }
59
60 zcp->zevent_fd = open(ZFS_DEV, O_RDWR | O_CLOEXEC);
61 if (zcp->zevent_fd < 0) {
62 if (zcp->do_idle)
63 return (-1);
64 zed_log_die("Failed to open \"%s\": %s",
65 ZFS_DEV, strerror(errno));
66 }
67
68 zfs_agent_init(zcp->zfs_hdl);
69
70 if (zed_disk_event_init() != 0) {
71 if (zcp->do_idle)
72 return (-1);
73 zed_log_die("Failed to initialize disk events");
74 }
75
76 if (zcp->max_zevent_buf_len != 0)
77 max_zevent_buf_len = zcp->max_zevent_buf_len;
78
79 return (0);
80 }
81
82 /*
83 * Close the libzfs interface.
84 */
85 void
86 zed_event_fini(struct zed_conf *zcp)
87 {
88 if (!zcp)
89 zed_log_die("Failed zed_event_fini: %s", strerror(EINVAL));
90
91 zed_disk_event_fini();
92 zfs_agent_fini();
93
94 if (zcp->zevent_fd >= 0) {
95 if (close(zcp->zevent_fd) < 0)
96 zed_log_msg(LOG_WARNING, "Failed to close \"%s\": %s",
97 ZFS_DEV, strerror(errno));
98
99 zcp->zevent_fd = -1;
100 }
101 if (zcp->zfs_hdl) {
102 libzfs_fini(zcp->zfs_hdl);
103 zcp->zfs_hdl = NULL;
104 }
105
106 zed_exec_fini();
107 }
108
109 static void
110 _bump_event_queue_length(void)
111 {
112 int zzlm = -1, wr;
113 char qlen_buf[12] = {0}; /* parameter is int => max "-2147483647\n" */
114 long int qlen, orig_qlen;
115
116 zzlm = open("/sys/module/zfs/parameters/zfs_zevent_len_max", O_RDWR);
117 if (zzlm < 0)
118 goto done;
119
120 if (read(zzlm, qlen_buf, sizeof (qlen_buf)) < 0)
121 goto done;
122 qlen_buf[sizeof (qlen_buf) - 1] = '\0';
123
124 errno = 0;
125 orig_qlen = qlen = strtol(qlen_buf, NULL, 10);
126 if (errno == ERANGE)
127 goto done;
128
129 if (qlen <= 0)
130 qlen = 512; /* default zfs_zevent_len_max value */
131 else
132 qlen *= 2;
133
134 /*
135 * Don't consume all of kernel memory with event logs if something
136 * goes wrong.
137 */
138 if (qlen > max_zevent_buf_len)
139 qlen = max_zevent_buf_len;
140 if (qlen == orig_qlen)
141 goto done;
142 wr = snprintf(qlen_buf, sizeof (qlen_buf), "%ld", qlen);
143 if (wr >= sizeof (qlen_buf)) {
144 wr = sizeof (qlen_buf) - 1;
145 zed_log_msg(LOG_WARNING, "Truncation in %s()", __func__);
146 }
147
148 if (pwrite(zzlm, qlen_buf, wr + 1, 0) < 0)
149 goto done;
150
151 zed_log_msg(LOG_WARNING, "Bumping queue length to %ld", qlen);
152
153 done:
154 if (zzlm > -1)
155 (void) close(zzlm);
156 }
157
158 /*
159 * Seek to the event specified by [saved_eid] and [saved_etime].
160 * This protects against processing a given event more than once.
161 * Return 0 upon a successful seek to the specified event, or -1 otherwise.
162 *
163 * A zevent is considered to be uniquely specified by its (eid,time) tuple.
164 * The unsigned 64b eid is set to 1 when the kernel module is loaded, and
165 * incremented by 1 for each new event. Since the state file can persist
166 * across a kernel module reload, the time must be checked to ensure a match.
167 */
168 int
169 zed_event_seek(struct zed_conf *zcp, uint64_t saved_eid, int64_t saved_etime[])
170 {
171 uint64_t eid;
172 int found;
173 nvlist_t *nvl;
174 int n_dropped;
175 int64_t *etime;
176 uint_t nelem;
177 int rv;
178
179 if (!zcp) {
180 errno = EINVAL;
181 zed_log_msg(LOG_ERR, "Failed to seek zevent: %s",
182 strerror(errno));
183 return (-1);
184 }
185 eid = 0;
186 found = 0;
187 while ((eid < saved_eid) && !found) {
188 rv = zpool_events_next(zcp->zfs_hdl, &nvl, &n_dropped,
189 ZEVENT_NONBLOCK, zcp->zevent_fd);
190
191 if ((rv != 0) || !nvl)
192 break;
193
194 if (n_dropped > 0) {
195 zed_log_msg(LOG_WARNING, "Missed %d events", n_dropped);
196 _bump_event_queue_length();
197 }
198 if (nvlist_lookup_uint64(nvl, "eid", &eid) != 0) {
199 zed_log_msg(LOG_WARNING, "Failed to lookup zevent eid");
200 } else if (nvlist_lookup_int64_array(nvl, "time",
201 &etime, &nelem) != 0) {
202 zed_log_msg(LOG_WARNING,
203 "Failed to lookup zevent time (eid=%llu)", eid);
204 } else if (nelem != 2) {
205 zed_log_msg(LOG_WARNING,
206 "Failed to lookup zevent time (eid=%llu, nelem=%u)",
207 eid, nelem);
208 } else if ((eid != saved_eid) ||
209 (etime[0] != saved_etime[0]) ||
210 (etime[1] != saved_etime[1])) {
211 /* no-op */
212 } else {
213 found = 1;
214 }
215 free(nvl);
216 }
217 if (!found && (saved_eid > 0)) {
218 if (zpool_events_seek(zcp->zfs_hdl, ZEVENT_SEEK_START,
219 zcp->zevent_fd) < 0)
220 zed_log_msg(LOG_WARNING, "Failed to seek to eid=0");
221 else
222 eid = 0;
223 }
224 zed_log_msg(LOG_NOTICE, "Processing events since eid=%llu", eid);
225 return (found ? 0 : -1);
226 }
227
228 /*
229 * Return non-zero if nvpair [name] should be formatted in hex; o/w, return 0.
230 */
231 static int
232 _zed_event_value_is_hex(const char *name)
233 {
234 const char *hex_suffix[] = {
235 "_guid",
236 "_guids",
237 NULL
238 };
239 const char **pp;
240 char *p;
241
242 if (!name)
243 return (0);
244
245 for (pp = hex_suffix; *pp; pp++) {
246 p = strstr(name, *pp);
247 if (p && strlen(p) == strlen(*pp))
248 return (1);
249 }
250 return (0);
251 }
252
253 /*
254 * Add an environment variable for [eid] to the container [zsp].
255 *
256 * The variable name is the concatenation of [prefix] and [name] converted to
257 * uppercase with non-alphanumeric characters converted to underscores;
258 * [prefix] is optional, and [name] must begin with an alphabetic character.
259 * If the converted variable name already exists within the container [zsp],
260 * its existing value will be replaced with the new value.
261 *
262 * The variable value is specified by the format string [fmt].
263 *
264 * Returns 0 on success, and -1 on error (with errno set).
265 *
266 * All environment variables in [zsp] should be added through this function.
267 */
268 static __attribute__((format(printf, 5, 6))) int
269 _zed_event_add_var(uint64_t eid, zed_strings_t *zsp,
270 const char *prefix, const char *name, const char *fmt, ...)
271 {
272 char keybuf[MAXBUF];
273 char valbuf[MAXBUF];
274 char *dstp;
275 const char *srcp;
276 const char *lastp;
277 int n;
278 int buflen;
279 va_list vargs;
280
281 assert(zsp != NULL);
282 assert(fmt != NULL);
283
284 if (!name) {
285 errno = EINVAL;
286 zed_log_msg(LOG_WARNING,
287 "Failed to add variable for eid=%llu: Name is empty", eid);
288 return (-1);
289 } else if (!isalpha(name[0])) {
290 errno = EINVAL;
291 zed_log_msg(LOG_WARNING,
292 "Failed to add variable for eid=%llu: "
293 "Name \"%s\" is invalid", eid, name);
294 return (-1);
295 }
296 /*
297 * Construct the string key by converting PREFIX (if present) and NAME.
298 */
299 dstp = keybuf;
300 lastp = keybuf + sizeof (keybuf);
301 if (prefix) {
302 for (srcp = prefix; *srcp && (dstp < lastp); srcp++)
303 *dstp++ = isalnum(*srcp) ? toupper(*srcp) : '_';
304 }
305 for (srcp = name; *srcp && (dstp < lastp); srcp++)
306 *dstp++ = isalnum(*srcp) ? toupper(*srcp) : '_';
307
308 if (dstp == lastp) {
309 errno = ENAMETOOLONG;
310 zed_log_msg(LOG_WARNING,
311 "Failed to add variable for eid=%llu: Name too long", eid);
312 return (-1);
313 }
314 *dstp = '\0';
315 /*
316 * Construct the string specified by "[PREFIX][NAME]=[FMT]".
317 */
318 dstp = valbuf;
319 buflen = sizeof (valbuf);
320 n = strlcpy(dstp, keybuf, buflen);
321 if (n >= sizeof (valbuf)) {
322 errno = EMSGSIZE;
323 zed_log_msg(LOG_WARNING, "Failed to add %s for eid=%llu: %s",
324 keybuf, eid, "Exceeded buffer size");
325 return (-1);
326 }
327 dstp += n;
328 buflen -= n;
329
330 *dstp++ = '=';
331 buflen--;
332
333 if (buflen <= 0) {
334 errno = EMSGSIZE;
335 zed_log_msg(LOG_WARNING, "Failed to add %s for eid=%llu: %s",
336 keybuf, eid, "Exceeded buffer size");
337 return (-1);
338 }
339
340 va_start(vargs, fmt);
341 n = vsnprintf(dstp, buflen, fmt, vargs);
342 va_end(vargs);
343
344 if ((n < 0) || (n >= buflen)) {
345 errno = EMSGSIZE;
346 zed_log_msg(LOG_WARNING, "Failed to add %s for eid=%llu: %s",
347 keybuf, eid, "Exceeded buffer size");
348 return (-1);
349 } else if (zed_strings_add(zsp, keybuf, valbuf) < 0) {
350 zed_log_msg(LOG_WARNING, "Failed to add %s for eid=%llu: %s",
351 keybuf, eid, strerror(errno));
352 return (-1);
353 }
354 return (0);
355 }
356
357 static int
358 _zed_event_add_array_err(uint64_t eid, const char *name)
359 {
360 errno = EMSGSIZE;
361 zed_log_msg(LOG_WARNING,
362 "Failed to convert nvpair \"%s\" for eid=%llu: "
363 "Exceeded buffer size", name, eid);
364 return (-1);
365 }
366
367 static int
368 _zed_event_add_int8_array(uint64_t eid, zed_strings_t *zsp,
369 const char *prefix, nvpair_t *nvp)
370 {
371 char buf[MAXBUF];
372 int buflen = sizeof (buf);
373 const char *name;
374 int8_t *i8p;
375 uint_t nelem;
376 uint_t i;
377 char *p;
378 int n;
379
380 assert((nvp != NULL) && (nvpair_type(nvp) == DATA_TYPE_INT8_ARRAY));
381
382 name = nvpair_name(nvp);
383 (void) nvpair_value_int8_array(nvp, &i8p, &nelem);
384 for (i = 0, p = buf; (i < nelem) && (buflen > 0); i++) {
385 n = snprintf(p, buflen, "%d ", i8p[i]);
386 if ((n < 0) || (n >= buflen))
387 return (_zed_event_add_array_err(eid, name));
388 p += n;
389 buflen -= n;
390 }
391 if (nelem > 0)
392 *--p = '\0';
393
394 return (_zed_event_add_var(eid, zsp, prefix, name, "%s", buf));
395 }
396
397 static int
398 _zed_event_add_uint8_array(uint64_t eid, zed_strings_t *zsp,
399 const char *prefix, nvpair_t *nvp)
400 {
401 char buf[MAXBUF];
402 int buflen = sizeof (buf);
403 const char *name;
404 uint8_t *u8p;
405 uint_t nelem;
406 uint_t i;
407 char *p;
408 int n;
409
410 assert((nvp != NULL) && (nvpair_type(nvp) == DATA_TYPE_UINT8_ARRAY));
411
412 name = nvpair_name(nvp);
413 (void) nvpair_value_uint8_array(nvp, &u8p, &nelem);
414 for (i = 0, p = buf; (i < nelem) && (buflen > 0); i++) {
415 n = snprintf(p, buflen, "%u ", u8p[i]);
416 if ((n < 0) || (n >= buflen))
417 return (_zed_event_add_array_err(eid, name));
418 p += n;
419 buflen -= n;
420 }
421 if (nelem > 0)
422 *--p = '\0';
423
424 return (_zed_event_add_var(eid, zsp, prefix, name, "%s", buf));
425 }
426
427 static int
428 _zed_event_add_int16_array(uint64_t eid, zed_strings_t *zsp,
429 const char *prefix, nvpair_t *nvp)
430 {
431 char buf[MAXBUF];
432 int buflen = sizeof (buf);
433 const char *name;
434 int16_t *i16p;
435 uint_t nelem;
436 uint_t i;
437 char *p;
438 int n;
439
440 assert((nvp != NULL) && (nvpair_type(nvp) == DATA_TYPE_INT16_ARRAY));
441
442 name = nvpair_name(nvp);
443 (void) nvpair_value_int16_array(nvp, &i16p, &nelem);
444 for (i = 0, p = buf; (i < nelem) && (buflen > 0); i++) {
445 n = snprintf(p, buflen, "%d ", i16p[i]);
446 if ((n < 0) || (n >= buflen))
447 return (_zed_event_add_array_err(eid, name));
448 p += n;
449 buflen -= n;
450 }
451 if (nelem > 0)
452 *--p = '\0';
453
454 return (_zed_event_add_var(eid, zsp, prefix, name, "%s", buf));
455 }
456
457 static int
458 _zed_event_add_uint16_array(uint64_t eid, zed_strings_t *zsp,
459 const char *prefix, nvpair_t *nvp)
460 {
461 char buf[MAXBUF];
462 int buflen = sizeof (buf);
463 const char *name;
464 uint16_t *u16p;
465 uint_t nelem;
466 uint_t i;
467 char *p;
468 int n;
469
470 assert((nvp != NULL) && (nvpair_type(nvp) == DATA_TYPE_UINT16_ARRAY));
471
472 name = nvpair_name(nvp);
473 (void) nvpair_value_uint16_array(nvp, &u16p, &nelem);
474 for (i = 0, p = buf; (i < nelem) && (buflen > 0); i++) {
475 n = snprintf(p, buflen, "%u ", u16p[i]);
476 if ((n < 0) || (n >= buflen))
477 return (_zed_event_add_array_err(eid, name));
478 p += n;
479 buflen -= n;
480 }
481 if (nelem > 0)
482 *--p = '\0';
483
484 return (_zed_event_add_var(eid, zsp, prefix, name, "%s", buf));
485 }
486
487 static int
488 _zed_event_add_int32_array(uint64_t eid, zed_strings_t *zsp,
489 const char *prefix, nvpair_t *nvp)
490 {
491 char buf[MAXBUF];
492 int buflen = sizeof (buf);
493 const char *name;
494 int32_t *i32p;
495 uint_t nelem;
496 uint_t i;
497 char *p;
498 int n;
499
500 assert((nvp != NULL) && (nvpair_type(nvp) == DATA_TYPE_INT32_ARRAY));
501
502 name = nvpair_name(nvp);
503 (void) nvpair_value_int32_array(nvp, &i32p, &nelem);
504 for (i = 0, p = buf; (i < nelem) && (buflen > 0); i++) {
505 n = snprintf(p, buflen, "%d ", i32p[i]);
506 if ((n < 0) || (n >= buflen))
507 return (_zed_event_add_array_err(eid, name));
508 p += n;
509 buflen -= n;
510 }
511 if (nelem > 0)
512 *--p = '\0';
513
514 return (_zed_event_add_var(eid, zsp, prefix, name, "%s", buf));
515 }
516
517 static int
518 _zed_event_add_uint32_array(uint64_t eid, zed_strings_t *zsp,
519 const char *prefix, nvpair_t *nvp)
520 {
521 char buf[MAXBUF];
522 int buflen = sizeof (buf);
523 const char *name;
524 uint32_t *u32p;
525 uint_t nelem;
526 uint_t i;
527 char *p;
528 int n;
529
530 assert((nvp != NULL) && (nvpair_type(nvp) == DATA_TYPE_UINT32_ARRAY));
531
532 name = nvpair_name(nvp);
533 (void) nvpair_value_uint32_array(nvp, &u32p, &nelem);
534 for (i = 0, p = buf; (i < nelem) && (buflen > 0); i++) {
535 n = snprintf(p, buflen, "%u ", u32p[i]);
536 if ((n < 0) || (n >= buflen))
537 return (_zed_event_add_array_err(eid, name));
538 p += n;
539 buflen -= n;
540 }
541 if (nelem > 0)
542 *--p = '\0';
543
544 return (_zed_event_add_var(eid, zsp, prefix, name, "%s", buf));
545 }
546
547 static int
548 _zed_event_add_int64_array(uint64_t eid, zed_strings_t *zsp,
549 const char *prefix, nvpair_t *nvp)
550 {
551 char buf[MAXBUF];
552 int buflen = sizeof (buf);
553 const char *name;
554 int64_t *i64p;
555 uint_t nelem;
556 uint_t i;
557 char *p;
558 int n;
559
560 assert((nvp != NULL) && (nvpair_type(nvp) == DATA_TYPE_INT64_ARRAY));
561
562 name = nvpair_name(nvp);
563 (void) nvpair_value_int64_array(nvp, &i64p, &nelem);
564 for (i = 0, p = buf; (i < nelem) && (buflen > 0); i++) {
565 n = snprintf(p, buflen, "%lld ", (u_longlong_t)i64p[i]);
566 if ((n < 0) || (n >= buflen))
567 return (_zed_event_add_array_err(eid, name));
568 p += n;
569 buflen -= n;
570 }
571 if (nelem > 0)
572 *--p = '\0';
573
574 return (_zed_event_add_var(eid, zsp, prefix, name, "%s", buf));
575 }
576
577 static int
578 _zed_event_add_uint64_array(uint64_t eid, zed_strings_t *zsp,
579 const char *prefix, nvpair_t *nvp)
580 {
581 char buf[MAXBUF];
582 int buflen = sizeof (buf);
583 const char *name;
584 const char *fmt;
585 uint64_t *u64p;
586 uint_t nelem;
587 uint_t i;
588 char *p;
589 int n;
590
591 assert((nvp != NULL) && (nvpair_type(nvp) == DATA_TYPE_UINT64_ARRAY));
592
593 name = nvpair_name(nvp);
594 fmt = _zed_event_value_is_hex(name) ? "0x%.16llX " : "%llu ";
595 (void) nvpair_value_uint64_array(nvp, &u64p, &nelem);
596 for (i = 0, p = buf; (i < nelem) && (buflen > 0); i++) {
597 n = snprintf(p, buflen, fmt, (u_longlong_t)u64p[i]);
598 if ((n < 0) || (n >= buflen))
599 return (_zed_event_add_array_err(eid, name));
600 p += n;
601 buflen -= n;
602 }
603 if (nelem > 0)
604 *--p = '\0';
605
606 return (_zed_event_add_var(eid, zsp, prefix, name, "%s", buf));
607 }
608
609 static int
610 _zed_event_add_string_array(uint64_t eid, zed_strings_t *zsp,
611 const char *prefix, nvpair_t *nvp)
612 {
613 char buf[MAXBUF];
614 int buflen = sizeof (buf);
615 const char *name;
616 const char **strp;
617 uint_t nelem;
618 uint_t i;
619 char *p;
620 int n;
621
622 assert((nvp != NULL) && (nvpair_type(nvp) == DATA_TYPE_STRING_ARRAY));
623
624 name = nvpair_name(nvp);
625 (void) nvpair_value_string_array(nvp, &strp, &nelem);
626 for (i = 0, p = buf; (i < nelem) && (buflen > 0); i++) {
627 n = snprintf(p, buflen, "%s ", strp[i] ? strp[i] : "<NULL>");
628 if ((n < 0) || (n >= buflen))
629 return (_zed_event_add_array_err(eid, name));
630 p += n;
631 buflen -= n;
632 }
633 if (nelem > 0)
634 *--p = '\0';
635
636 return (_zed_event_add_var(eid, zsp, prefix, name, "%s", buf));
637 }
638
639 /*
640 * Convert the nvpair [nvp] to a string which is added to the environment
641 * of the child process.
642 * Return 0 on success, -1 on error.
643 */
644 static void
645 _zed_event_add_nvpair(uint64_t eid, zed_strings_t *zsp, nvpair_t *nvp)
646 {
647 const char *name;
648 data_type_t type;
649 const char *prefix = ZEVENT_VAR_PREFIX;
650 boolean_t b;
651 double d;
652 uint8_t i8;
653 uint16_t i16;
654 uint32_t i32;
655 uint64_t i64;
656 const char *str;
657
658 assert(zsp != NULL);
659 assert(nvp != NULL);
660
661 name = nvpair_name(nvp);
662 type = nvpair_type(nvp);
663
664 switch (type) {
665 case DATA_TYPE_BOOLEAN:
666 _zed_event_add_var(eid, zsp, prefix, name, "%s", "1");
667 break;
668 case DATA_TYPE_BOOLEAN_VALUE:
669 (void) nvpair_value_boolean_value(nvp, &b);
670 _zed_event_add_var(eid, zsp, prefix, name, "%s", b ? "1" : "0");
671 break;
672 case DATA_TYPE_BYTE:
673 (void) nvpair_value_byte(nvp, &i8);
674 _zed_event_add_var(eid, zsp, prefix, name, "%d", i8);
675 break;
676 case DATA_TYPE_INT8:
677 (void) nvpair_value_int8(nvp, (int8_t *)&i8);
678 _zed_event_add_var(eid, zsp, prefix, name, "%d", i8);
679 break;
680 case DATA_TYPE_UINT8:
681 (void) nvpair_value_uint8(nvp, &i8);
682 _zed_event_add_var(eid, zsp, prefix, name, "%u", i8);
683 break;
684 case DATA_TYPE_INT16:
685 (void) nvpair_value_int16(nvp, (int16_t *)&i16);
686 _zed_event_add_var(eid, zsp, prefix, name, "%d", i16);
687 break;
688 case DATA_TYPE_UINT16:
689 (void) nvpair_value_uint16(nvp, &i16);
690 _zed_event_add_var(eid, zsp, prefix, name, "%u", i16);
691 break;
692 case DATA_TYPE_INT32:
693 (void) nvpair_value_int32(nvp, (int32_t *)&i32);
694 _zed_event_add_var(eid, zsp, prefix, name, "%d", i32);
695 break;
696 case DATA_TYPE_UINT32:
697 (void) nvpair_value_uint32(nvp, &i32);
698 _zed_event_add_var(eid, zsp, prefix, name, "%u", i32);
699 break;
700 case DATA_TYPE_INT64:
701 (void) nvpair_value_int64(nvp, (int64_t *)&i64);
702 _zed_event_add_var(eid, zsp, prefix, name,
703 "%lld", (longlong_t)i64);
704 break;
705 case DATA_TYPE_UINT64:
706 (void) nvpair_value_uint64(nvp, &i64);
707 _zed_event_add_var(eid, zsp, prefix, name,
708 (_zed_event_value_is_hex(name) ? "0x%.16llX" : "%llu"),
709 (u_longlong_t)i64);
710 /*
711 * shadow readable strings for vdev state pairs
712 */
713 if (strcmp(name, FM_EREPORT_PAYLOAD_ZFS_VDEV_STATE) == 0 ||
714 strcmp(name, FM_EREPORT_PAYLOAD_ZFS_VDEV_LASTSTATE) == 0) {
715 char alt[32];
716
717 (void) snprintf(alt, sizeof (alt), "%s_str", name);
718 _zed_event_add_var(eid, zsp, prefix, alt, "%s",
719 zpool_state_to_name(i64, VDEV_AUX_NONE));
720 } else
721 /*
722 * shadow readable strings for pool state
723 */
724 if (strcmp(name, FM_EREPORT_PAYLOAD_ZFS_POOL_STATE) == 0) {
725 char alt[32];
726
727 (void) snprintf(alt, sizeof (alt), "%s_str", name);
728 _zed_event_add_var(eid, zsp, prefix, alt, "%s",
729 zpool_pool_state_to_name(i64));
730 }
731 break;
732 case DATA_TYPE_DOUBLE:
733 (void) nvpair_value_double(nvp, &d);
734 _zed_event_add_var(eid, zsp, prefix, name, "%g", d);
735 break;
736 case DATA_TYPE_HRTIME:
737 (void) nvpair_value_hrtime(nvp, (hrtime_t *)&i64);
738 _zed_event_add_var(eid, zsp, prefix, name,
739 "%llu", (u_longlong_t)i64);
740 break;
741 case DATA_TYPE_STRING:
742 (void) nvpair_value_string(nvp, &str);
743 _zed_event_add_var(eid, zsp, prefix, name,
744 "%s", (str ? str : "<NULL>"));
745 break;
746 case DATA_TYPE_INT8_ARRAY:
747 _zed_event_add_int8_array(eid, zsp, prefix, nvp);
748 break;
749 case DATA_TYPE_UINT8_ARRAY:
750 _zed_event_add_uint8_array(eid, zsp, prefix, nvp);
751 break;
752 case DATA_TYPE_INT16_ARRAY:
753 _zed_event_add_int16_array(eid, zsp, prefix, nvp);
754 break;
755 case DATA_TYPE_UINT16_ARRAY:
756 _zed_event_add_uint16_array(eid, zsp, prefix, nvp);
757 break;
758 case DATA_TYPE_INT32_ARRAY:
759 _zed_event_add_int32_array(eid, zsp, prefix, nvp);
760 break;
761 case DATA_TYPE_UINT32_ARRAY:
762 _zed_event_add_uint32_array(eid, zsp, prefix, nvp);
763 break;
764 case DATA_TYPE_INT64_ARRAY:
765 _zed_event_add_int64_array(eid, zsp, prefix, nvp);
766 break;
767 case DATA_TYPE_UINT64_ARRAY:
768 _zed_event_add_uint64_array(eid, zsp, prefix, nvp);
769 break;
770 case DATA_TYPE_STRING_ARRAY:
771 _zed_event_add_string_array(eid, zsp, prefix, nvp);
772 break;
773 case DATA_TYPE_NVLIST:
774 case DATA_TYPE_BOOLEAN_ARRAY:
775 case DATA_TYPE_BYTE_ARRAY:
776 case DATA_TYPE_NVLIST_ARRAY:
777 _zed_event_add_var(eid, zsp, prefix, name, "_NOT_IMPLEMENTED_");
778 break;
779 default:
780 errno = EINVAL;
781 zed_log_msg(LOG_WARNING,
782 "Failed to convert nvpair \"%s\" for eid=%llu: "
783 "Unrecognized type=%u", name, eid, (unsigned int) type);
784 break;
785 }
786 }
787
788 /*
789 * Restrict various environment variables to safe and sane values
790 * when constructing the environment for the child process, unless
791 * we're running with a custom $PATH (like under the ZFS test suite).
792 *
793 * Reference: Secure Programming Cookbook by Viega & Messier, Section 1.1.
794 */
795 static void
796 _zed_event_add_env_restrict(uint64_t eid, zed_strings_t *zsp,
797 const char *path)
798 {
799 const char *env_restrict[][2] = {
800 { "IFS", " \t\n" },
801 { "PATH", _PATH_STDPATH },
802 { "ZDB", SBINDIR "/zdb" },
803 { "ZED", SBINDIR "/zed" },
804 { "ZFS", SBINDIR "/zfs" },
805 { "ZINJECT", SBINDIR "/zinject" },
806 { "ZPOOL", SBINDIR "/zpool" },
807 { "ZFS_ALIAS", ZFS_META_ALIAS },
808 { "ZFS_VERSION", ZFS_META_VERSION },
809 { "ZFS_RELEASE", ZFS_META_RELEASE },
810 { NULL, NULL }
811 };
812
813 /*
814 * If we have a custom $PATH, use the default ZFS binary locations
815 * instead of the hard-coded ones.
816 */
817 const char *env_path[][2] = {
818 { "IFS", " \t\n" },
819 { "PATH", NULL }, /* $PATH copied in later on */
820 { "ZDB", "zdb" },
821 { "ZED", "zed" },
822 { "ZFS", "zfs" },
823 { "ZINJECT", "zinject" },
824 { "ZPOOL", "zpool" },
825 { "ZFS_ALIAS", ZFS_META_ALIAS },
826 { "ZFS_VERSION", ZFS_META_VERSION },
827 { "ZFS_RELEASE", ZFS_META_RELEASE },
828 { NULL, NULL }
829 };
830 const char *(*pa)[2];
831
832 assert(zsp != NULL);
833
834 pa = path != NULL ? env_path : env_restrict;
835
836 for (; *(*pa); pa++) {
837 /* Use our custom $PATH if we have one */
838 if (path != NULL && strcmp((*pa)[0], "PATH") == 0)
839 (*pa)[1] = path;
840
841 _zed_event_add_var(eid, zsp, NULL, (*pa)[0], "%s", (*pa)[1]);
842 }
843 }
844
845 /*
846 * Preserve specified variables from the parent environment
847 * when constructing the environment for the child process.
848 *
849 * Reference: Secure Programming Cookbook by Viega & Messier, Section 1.1.
850 */
851 static void
852 _zed_event_add_env_preserve(uint64_t eid, zed_strings_t *zsp)
853 {
854 const char *env_preserve[] = {
855 "TZ",
856 NULL
857 };
858 const char **keyp;
859 const char *val;
860
861 assert(zsp != NULL);
862
863 for (keyp = env_preserve; *keyp; keyp++) {
864 if ((val = getenv(*keyp)))
865 _zed_event_add_var(eid, zsp, NULL, *keyp, "%s", val);
866 }
867 }
868
869 /*
870 * Compute the "subclass" by removing the first 3 components of [class]
871 * (which will always be of the form "*.fs.zfs"). Return a pointer inside
872 * the string [class], or NULL if insufficient components exist.
873 */
874 static const char *
875 _zed_event_get_subclass(const char *class)
876 {
877 const char *p;
878 int i;
879
880 if (!class)
881 return (NULL);
882
883 p = class;
884 for (i = 0; i < 3; i++) {
885 p = strchr(p, '.');
886 if (!p)
887 break;
888 p++;
889 }
890 return (p);
891 }
892
893 /*
894 * Convert the zevent time from a 2-element array of 64b integers
895 * into a more convenient form:
896 * - TIME_SECS is the second component of the time.
897 * - TIME_NSECS is the nanosecond component of the time.
898 * - TIME_STRING is an almost-RFC3339-compliant string representation.
899 */
900 static void
901 _zed_event_add_time_strings(uint64_t eid, zed_strings_t *zsp, int64_t etime[])
902 {
903 struct tm stp;
904 char buf[32];
905
906 assert(zsp != NULL);
907 assert(etime != NULL);
908
909 _zed_event_add_var(eid, zsp, ZEVENT_VAR_PREFIX, "TIME_SECS",
910 "%" PRId64, etime[0]);
911 _zed_event_add_var(eid, zsp, ZEVENT_VAR_PREFIX, "TIME_NSECS",
912 "%" PRId64, etime[1]);
913
914 if (!localtime_r((const time_t *) &etime[0], &stp)) {
915 zed_log_msg(LOG_WARNING, "Failed to add %s%s for eid=%llu: %s",
916 ZEVENT_VAR_PREFIX, "TIME_STRING", eid, "localtime error");
917 } else if (!strftime(buf, sizeof (buf), "%Y-%m-%d %H:%M:%S%z", &stp)) {
918 zed_log_msg(LOG_WARNING, "Failed to add %s%s for eid=%llu: %s",
919 ZEVENT_VAR_PREFIX, "TIME_STRING", eid, "strftime error");
920 } else {
921 _zed_event_add_var(eid, zsp, ZEVENT_VAR_PREFIX, "TIME_STRING",
922 "%s", buf);
923 }
924 }
925
926
927 static void
928 _zed_event_update_enc_sysfs_path(nvlist_t *nvl)
929 {
930 const char *vdev_path;
931
932 if (nvlist_lookup_string(nvl, FM_EREPORT_PAYLOAD_ZFS_VDEV_PATH,
933 &vdev_path) != 0) {
934 return; /* some other kind of event, ignore it */
935 }
936
937 if (vdev_path == NULL) {
938 return;
939 }
940
941 update_vdev_config_dev_sysfs_path(nvl, vdev_path,
942 FM_EREPORT_PAYLOAD_ZFS_VDEV_ENC_SYSFS_PATH);
943 }
944
945 /*
946 * Service the next zevent, blocking until one is available.
947 */
948 int
949 zed_event_service(struct zed_conf *zcp)
950 {
951 nvlist_t *nvl;
952 nvpair_t *nvp;
953 int n_dropped;
954 zed_strings_t *zsp;
955 uint64_t eid;
956 int64_t *etime;
957 uint_t nelem;
958 const char *class;
959 const char *subclass;
960 int rv;
961
962 if (!zcp) {
963 errno = EINVAL;
964 zed_log_msg(LOG_ERR, "Failed to service zevent: %s",
965 strerror(errno));
966 return (EINVAL);
967 }
968 rv = zpool_events_next(zcp->zfs_hdl, &nvl, &n_dropped, ZEVENT_NONE,
969 zcp->zevent_fd);
970
971 if ((rv != 0) || !nvl)
972 return (errno);
973
974 if (n_dropped > 0) {
975 zed_log_msg(LOG_WARNING, "Missed %d events", n_dropped);
976 _bump_event_queue_length();
977 }
978 if (nvlist_lookup_uint64(nvl, "eid", &eid) != 0) {
979 zed_log_msg(LOG_WARNING, "Failed to lookup zevent eid");
980 } else if (nvlist_lookup_int64_array(
981 nvl, "time", &etime, &nelem) != 0) {
982 zed_log_msg(LOG_WARNING,
983 "Failed to lookup zevent time (eid=%llu)", eid);
984 } else if (nelem != 2) {
985 zed_log_msg(LOG_WARNING,
986 "Failed to lookup zevent time (eid=%llu, nelem=%u)",
987 eid, nelem);
988 } else if (nvlist_lookup_string(nvl, "class", &class) != 0) {
989 zed_log_msg(LOG_WARNING,
990 "Failed to lookup zevent class (eid=%llu)", eid);
991 } else {
992 /*
993 * Special case: If we can dynamically detect an enclosure sysfs
994 * path, then use that value rather than the one stored in the
995 * vd->vdev_enc_sysfs_path. There have been rare cases where
996 * vd->vdev_enc_sysfs_path becomes outdated. However, there
997 * will be other times when we can not dynamically detect the
998 * sysfs path (like if a disk disappears) and have to rely on
999 * the old value for things like turning on the fault LED.
1000 */
1001 _zed_event_update_enc_sysfs_path(nvl);
1002
1003 /* let internal modules see this event first */
1004 zfs_agent_post_event(class, NULL, nvl);
1005
1006 zsp = zed_strings_create();
1007
1008 nvp = NULL;
1009 while ((nvp = nvlist_next_nvpair(nvl, nvp)))
1010 _zed_event_add_nvpair(eid, zsp, nvp);
1011
1012 _zed_event_add_env_restrict(eid, zsp, zcp->path);
1013 _zed_event_add_env_preserve(eid, zsp);
1014
1015 _zed_event_add_var(eid, zsp, ZED_VAR_PREFIX, "PID",
1016 "%d", (int)getpid());
1017 _zed_event_add_var(eid, zsp, ZED_VAR_PREFIX, "ZEDLET_DIR",
1018 "%s", zcp->zedlet_dir);
1019 subclass = _zed_event_get_subclass(class);
1020 _zed_event_add_var(eid, zsp, ZEVENT_VAR_PREFIX, "SUBCLASS",
1021 "%s", (subclass ? subclass : class));
1022
1023 _zed_event_add_time_strings(eid, zsp, etime);
1024
1025 zed_exec_process(eid, class, subclass, zcp, zsp);
1026
1027 zed_conf_write_state(zcp, eid, etime);
1028
1029 zed_strings_destroy(zsp);
1030 }
1031 nvlist_free(nvl);
1032 return (0);
1033 }
OpenZFS on Linux and FreeBSD