1 /* 2 * Copyright (c) 2010 Pawel Jakub Dawidek <pjd@FreeBSD.org> 3 * Copyright (c) 2020 iXsystems, Inc. 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 */ 27 28 #include <sys/cdefs.h> 29 __FBSDID("$FreeBSD$"); 30 31 #include <sys/types.h> 32 #include <sys/param.h> 33 #include <sys/kernel.h> 34 #include <sys/systm.h> 35 #include <sys/malloc.h> 36 #include <sys/kmem.h> 37 #include <sys/list.h> 38 #include <sys/proc.h> 39 #include <sys/sbuf.h> 40 #include <sys/nvpair.h> 41 #include <sys/sunddi.h> 42 #include <sys/sysevent.h> 43 #include <sys/fm/protocol.h> 44 #include <sys/fm/util.h> 45 #include <sys/bus.h> 46 47 static int 48 log_sysevent(nvlist_t *event) 49 { 50 struct sbuf *sb; 51 const char *type; 52 char typestr[128]; 53 nvpair_t *elem = NULL; 54 55 sb = sbuf_new_auto(); 56 if (sb == NULL) 57 return (ENOMEM); 58 type = NULL; 59 60 while ((elem = nvlist_next_nvpair(event, elem)) != NULL) { 61 switch (nvpair_type(elem)) { 62 case DATA_TYPE_BOOLEAN: 63 { 64 boolean_t value; 65 66 (void) nvpair_value_boolean_value(elem, &value); 67 sbuf_printf(sb, " %s=%s", nvpair_name(elem), 68 value ? "true" : "false"); 69 break; 70 } 71 case DATA_TYPE_UINT8: 72 { 73 uint8_t value; 74 75 (void) nvpair_value_uint8(elem, &value); 76 sbuf_printf(sb, " %s=%hhu", nvpair_name(elem), value); 77 break; 78 } 79 case DATA_TYPE_INT32: 80 { 81 int32_t value; 82 83 (void) nvpair_value_int32(elem, &value); 84 sbuf_printf(sb, " %s=%jd", nvpair_name(elem), 85 (intmax_t)value); 86 break; 87 } 88 case DATA_TYPE_UINT32: 89 { 90 uint32_t value; 91 92 (void) nvpair_value_uint32(elem, &value); 93 sbuf_printf(sb, " %s=%ju", nvpair_name(elem), 94 (uintmax_t)value); 95 break; 96 } 97 case DATA_TYPE_INT64: 98 { 99 int64_t value; 100 101 (void) nvpair_value_int64(elem, &value); 102 sbuf_printf(sb, " %s=%jd", nvpair_name(elem), 103 (intmax_t)value); 104 break; 105 } 106 case DATA_TYPE_UINT64: 107 { 108 uint64_t value; 109 110 (void) nvpair_value_uint64(elem, &value); 111 sbuf_printf(sb, " %s=%ju", nvpair_name(elem), 112 (uintmax_t)value); 113 break; 114 } 115 case DATA_TYPE_STRING: 116 { 117 const char *value; 118 119 (void) nvpair_value_string(elem, &value); 120 sbuf_printf(sb, " %s=%s", nvpair_name(elem), value); 121 if (strcmp(FM_CLASS, nvpair_name(elem)) == 0) 122 type = value; 123 break; 124 } 125 case DATA_TYPE_UINT8_ARRAY: 126 { 127 uint8_t *value; 128 uint_t ii, nelem; 129 130 (void) nvpair_value_uint8_array(elem, &value, &nelem); 131 sbuf_printf(sb, " %s=", nvpair_name(elem)); 132 for (ii = 0; ii < nelem; ii++) 133 sbuf_printf(sb, "%02hhx", value[ii]); 134 break; 135 } 136 case DATA_TYPE_UINT16_ARRAY: 137 { 138 uint16_t *value; 139 uint_t ii, nelem; 140 141 (void) nvpair_value_uint16_array(elem, &value, &nelem); 142 sbuf_printf(sb, " %s=", nvpair_name(elem)); 143 for (ii = 0; ii < nelem; ii++) 144 sbuf_printf(sb, "%04hx", value[ii]); 145 break; 146 } 147 case DATA_TYPE_UINT32_ARRAY: 148 { 149 uint32_t *value; 150 uint_t ii, nelem; 151 152 (void) nvpair_value_uint32_array(elem, &value, &nelem); 153 sbuf_printf(sb, " %s=", nvpair_name(elem)); 154 for (ii = 0; ii < nelem; ii++) 155 sbuf_printf(sb, "%08jx", (uintmax_t)value[ii]); 156 break; 157 } 158 case DATA_TYPE_INT64_ARRAY: 159 { 160 int64_t *value; 161 uint_t ii, nelem; 162 163 (void) nvpair_value_int64_array(elem, &value, &nelem); 164 sbuf_printf(sb, " %s=", nvpair_name(elem)); 165 for (ii = 0; ii < nelem; ii++) 166 sbuf_printf(sb, "%016lld", 167 (long long)value[ii]); 168 break; 169 } 170 case DATA_TYPE_UINT64_ARRAY: 171 { 172 uint64_t *value; 173 uint_t ii, nelem; 174 175 (void) nvpair_value_uint64_array(elem, &value, &nelem); 176 sbuf_printf(sb, " %s=", nvpair_name(elem)); 177 for (ii = 0; ii < nelem; ii++) 178 sbuf_printf(sb, "%016jx", (uintmax_t)value[ii]); 179 break; 180 } 181 case DATA_TYPE_STRING_ARRAY: 182 { 183 const char **strarr; 184 uint_t ii, nelem; 185 186 (void) nvpair_value_string_array(elem, &strarr, &nelem); 187 188 for (ii = 0; ii < nelem; ii++) { 189 if (strarr[ii] == NULL) { 190 sbuf_printf(sb, " <NULL>"); 191 continue; 192 } 193 194 sbuf_printf(sb, " %s", strarr[ii]); 195 if (strcmp(FM_CLASS, strarr[ii]) == 0) 196 type = strarr[ii]; 197 } 198 break; 199 } 200 case DATA_TYPE_NVLIST: 201 /* XXX - requires recursing in log_sysevent */ 202 break; 203 default: 204 printf("%s: type %d is not implemented\n", __func__, 205 nvpair_type(elem)); 206 break; 207 } 208 } 209 210 if (sbuf_finish(sb) != 0) { 211 sbuf_delete(sb); 212 return (ENOMEM); 213 } 214 215 if (type == NULL) 216 type = ""; 217 if (strncmp(type, "ESC_ZFS_", 8) == 0) { 218 snprintf(typestr, sizeof (typestr), "misc.fs.zfs.%s", type + 8); 219 type = typestr; 220 } 221 devctl_notify("ZFS", "ZFS", type, sbuf_data(sb)); 222 sbuf_delete(sb); 223 224 return (0); 225 } 226 227 static void 228 sysevent_worker(void *arg __unused) 229 { 230 zfs_zevent_t *ze; 231 nvlist_t *event; 232 uint64_t dropped = 0; 233 uint64_t dst_size; 234 int error; 235 236 zfs_zevent_init(&ze); 237 for (;;) { 238 dst_size = 131072; 239 dropped = 0; 240 event = NULL; 241 error = zfs_zevent_next(ze, &event, 242 &dst_size, &dropped); 243 if (error) { 244 error = zfs_zevent_wait(ze); 245 if (error == ESHUTDOWN) 246 break; 247 } else { 248 VERIFY3P(event, !=, NULL); 249 log_sysevent(event); 250 nvlist_free(event); 251 } 252 } 253 254 /* 255 * We avoid zfs_zevent_destroy() here because we're otherwise racing 256 * against fm_fini() destroying the zevent_lock. zfs_zevent_destroy() 257 * will currently only clear `ze->ze_zevent` from an event list then 258 * free `ze`, so just inline the free() here -- events have already 259 * been drained. 260 */ 261 VERIFY3P(ze->ze_zevent, ==, NULL); 262 kmem_free(ze, sizeof (zfs_zevent_t)); 263 264 kthread_exit(); 265 } 266 267 void 268 ddi_sysevent_init(void) 269 { 270 kproc_kthread_add(sysevent_worker, NULL, &system_proc, NULL, 0, 0, 271 "zfskern", "sysevent"); 272 } 273