1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2002 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 #include "sysevent.h"
30
31 int
32 sysevent_buf(uintptr_t addr, uint_t flags, uint_t opt_flags)
33 {
34 sysevent_hdr_t evh;
35 sysevent_impl_t *ev;
36 int size;
37
38 if (DCMD_HDRSPEC(flags)) {
39 if ((opt_flags & SYSEVENT_VERBOSE) == 0) {
40 mdb_printf("%<u>%-?s %-16s %-9s %-10s "
41 "%-?s%</u>\n", "ADDRESS", "SEQUENCE ID",
42 "CLASS", "SUBCLASS", "NVPAIR BUF ADDR");
43 }
44 }
45
46 /*
47 * Read in the sysevent buffer header first. After extracting
48 * the size of the buffer, re-read the buffer in its entirety.
49 */
50 if (mdb_vread(&evh, sizeof (sysevent_hdr_t), addr) == -1) {
51 mdb_warn("failed to read event header at %p", addr);
52 return (DCMD_ERR);
53 }
54
55 size = SE_SIZE((sysevent_impl_t *)&evh);
56 ev = mdb_alloc(size, UM_SLEEP | UM_GC);
57
58 if (mdb_vread(ev, size, addr) == -1) {
59 mdb_warn("can not read sysevent at %p", addr);
60 return (DCMD_ERR);
61 }
62
63 if ((opt_flags & SYSEVENT_VERBOSE) == 0) {
64 char ev_class[CLASS_FIELD_MAX];
65 char ev_subclass[SUBCLASS_FIELD_MAX];
66
67 if (mdb_snprintf(ev_class, CLASS_FIELD_MAX, "%s",
68 SE_CLASS_NAME(ev)) >= CLASS_FIELD_MAX - 1)
69 (void) strcpy(&ev_class[CLASS_FIELD_MAX - 4], "...");
70
71 if (mdb_snprintf(ev_subclass, SUBCLASS_FIELD_MAX, "%s",
72 SE_SUBCLASS_NAME(ev)) >= SUBCLASS_FIELD_MAX - 1)
73 (void) strcpy(&ev_subclass[SUBCLASS_FIELD_MAX - 4],
74 "...");
75
76 mdb_printf("%-?p %-16llu %-9s %-10s %-?p%\n",
77 addr, SE_SEQ(ev), ev_class, ev_subclass,
78 addr + SE_ATTR_OFF(ev));
79 } else {
80 mdb_printf("%<b>Sequence ID\t : %llu%</b>\n", SE_SEQ(ev));
81 mdb_printf("%16s : %s\n", "publisher", SE_PUB_NAME(ev));
82 mdb_printf("%16s : %p\n", "event address", (caddr_t)addr);
83 mdb_printf("%16s : %s\n", "class", SE_CLASS_NAME(ev));
84 mdb_printf("%16s : %s\n", "subclass", SE_SUBCLASS_NAME(ev));
85 mdb_printf("%16s : %llu\n", "time stamp", SE_TIME(ev));
86 mdb_printf("%16s : %p\n", "nvpair buf addr",
87 addr + SE_ATTR_OFF(ev));
88 }
89
90 return (DCMD_OK);
91 }
92
93 int
94 sysevent_subclass_list(uintptr_t addr, uint_t flags, int argc,
95 const mdb_arg_t *argv)
96 {
97 int subclass_name_sz;
98 char subclass_name[CLASS_LIST_FIELD_MAX];
99 subclass_lst_t sclist;
100
101 if ((flags & DCMD_ADDRSPEC) == 0)
102 return (DCMD_USAGE);
103
104 if ((flags & DCMD_LOOP) == 0) {
105 if (mdb_pwalk_dcmd("sysevent_subclass_list",
106 "sysevent_subclass_list", argc, argv, addr) == -1) {
107 mdb_warn("can't walk sysevent subclass list");
108 return (DCMD_ERR);
109 }
110 return (DCMD_OK);
111 }
112
113 if (DCMD_HDRSPEC(flags)) {
114 mdb_printf("%<u>%-?s %-24s %-?s%</u>\n",
115 "ADDR", "NAME", "SUBSCRIBER DATA ADDR");
116 }
117 if (mdb_vread(&sclist, sizeof (sclist), (uintptr_t)addr) == -1) {
118 mdb_warn("failed to read subclass list at %p", addr);
119 return (DCMD_ERR);
120 }
121 if ((subclass_name_sz = mdb_readstr(subclass_name, CLASS_LIST_FIELD_MAX,
122 (uintptr_t)sclist.sl_name)) == -1) {
123 mdb_warn("failed to read class name at %p",
124 sclist.sl_name);
125 return (DCMD_ERR);
126 }
127 if (subclass_name_sz >= CLASS_LIST_FIELD_MAX - 1)
128 (void) strcpy(&subclass_name[CLASS_LIST_FIELD_MAX - 4], "...");
129
130 mdb_printf("%-?p %-24s %-?p\n", addr, subclass_name,
131 addr + offsetof(subclass_lst_t, sl_num));
132
133 return (DCMD_OK);
134 }
135
136
137 int
138 sysevent_class_list(uintptr_t addr, uint_t flags, int argc,
139 const mdb_arg_t *argv)
140 {
141 int class_name_sz;
142 char class_name[CLASS_LIST_FIELD_MAX];
143 class_lst_t clist;
144
145 if ((flags & DCMD_ADDRSPEC) == 0)
146 return (DCMD_USAGE);
147
148 if ((flags & DCMD_LOOP) == 0) {
149 if (mdb_pwalk_dcmd("sysevent_class_list", "sysevent_class_list",
150 argc, argv, addr) == -1) {
151 mdb_warn("can't walk sysevent class list");
152 return (DCMD_ERR);
153 }
154 return (DCMD_OK);
155 }
156
157 if (DCMD_HDRSPEC(flags))
158 mdb_printf("%<u>%-?s %-24s %-?s%</u>\n",
159 "ADDR", "NAME", "SUBCLASS LIST ADDR");
160
161 if (mdb_vread(&clist, sizeof (clist),
162 (uintptr_t)addr) == -1) {
163 mdb_warn("failed to read class clist at %p", addr);
164 return (DCMD_ERR);
165 }
166 if ((class_name_sz = mdb_readstr(class_name, CLASS_LIST_FIELD_MAX,
167 (uintptr_t)clist.cl_name)) == -1) {
168 mdb_warn("failed to read class name at %p",
169 clist.cl_name);
170 return (DCMD_ERR);
171 }
172 if (class_name_sz >= CLASS_LIST_FIELD_MAX - 1)
173 (void) strcpy(&class_name[CLASS_LIST_FIELD_MAX - 4], "...");
174
175 mdb_printf("%-?p %-24s %-?p\n", addr, class_name,
176 clist.cl_subclass_list);
177
178 return (DCMD_OK);
179 }
180
181 int
182 sysevent_subclass_list_walk_init(mdb_walk_state_t *wsp)
183 {
184 if (wsp->walk_addr == (uintptr_t)NULL) {
185 mdb_warn("sysevent_subclass_list does not support global "
186 "walks");
187 return (WALK_ERR);
188 }
189
190 wsp->walk_data = mdb_alloc(sizeof (subclass_lst_t), UM_SLEEP);
191 return (WALK_NEXT);
192 }
193
194 int
195 sysevent_subclass_list_walk_step(mdb_walk_state_t *wsp)
196 {
197 int status;
198
199 if (wsp->walk_addr == (uintptr_t)NULL)
200 return (WALK_DONE);
201
202 if (mdb_vread(wsp->walk_data, sizeof (subclass_lst_t),
203 wsp->walk_addr) == -1) {
204 mdb_warn("failed to read class list at %p", wsp->walk_addr);
205 return (WALK_ERR);
206 }
207
208 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
209 wsp->walk_cbdata);
210
211 wsp->walk_addr =
212 (uintptr_t)(((subclass_lst_t *)wsp->walk_data)->sl_next);
213
214 return (status);
215 }
216
217 void
218 sysevent_subclass_list_walk_fini(mdb_walk_state_t *wsp)
219 {
220 mdb_free(wsp->walk_data, sizeof (subclass_lst_t));
221 }
222
223 typedef struct class_walk_data {
224 int hash_index;
225 class_lst_t *hash_tbl[CLASS_HASH_SZ + 1];
226 } class_walk_data_t;
227
228 int
229 sysevent_class_list_walk_init(mdb_walk_state_t *wsp)
230 {
231 class_walk_data_t *cl_walker;
232
233 if (wsp->walk_addr == (uintptr_t)NULL) {
234 mdb_warn("sysevent_class_list does not support global walks");
235 return (WALK_ERR);
236 }
237
238 cl_walker = mdb_zalloc(sizeof (class_walk_data_t), UM_SLEEP);
239 if (mdb_vread(cl_walker->hash_tbl,
240 sizeof (cl_walker->hash_tbl), wsp->walk_addr) == -1) {
241 mdb_warn("failed to read class hash table at %p",
242 wsp->walk_addr);
243 return (WALK_ERR);
244 }
245
246 wsp->walk_addr = (uintptr_t)cl_walker->hash_tbl[0];
247 wsp->walk_data = cl_walker;
248
249 return (WALK_NEXT);
250 }
251
252 int
253 sysevent_class_list_walk_step(mdb_walk_state_t *wsp)
254 {
255 int status = WALK_NEXT;
256 class_walk_data_t *cl_walker;
257 class_lst_t clist;
258
259 cl_walker = (class_walk_data_t *)wsp->walk_data;
260
261 /* Skip over empty class table entries */
262 if (wsp->walk_addr != (uintptr_t)NULL) {
263 if (mdb_vread(&clist, sizeof (class_lst_t),
264 wsp->walk_addr) == -1) {
265 mdb_warn("failed to read class list at %p",
266 wsp->walk_addr);
267 return (WALK_ERR);
268 }
269
270 status = wsp->walk_callback(wsp->walk_addr, NULL,
271 wsp->walk_cbdata);
272 wsp->walk_addr = (uintptr_t)clist.cl_next;
273 } else {
274 if (cl_walker->hash_index > CLASS_HASH_SZ) {
275 return (WALK_DONE);
276 } else {
277 wsp->walk_addr = (uintptr_t)
278 cl_walker->hash_tbl[cl_walker->hash_index];
279 cl_walker->hash_index++;
280 }
281 }
282
283
284 return (status);
285 }
286
287 void
288 sysevent_class_list_walk_fini(mdb_walk_state_t *wsp)
289 {
290 class_walk_data_t *cl_walker = wsp->walk_data;
291
292 mdb_free(cl_walker, sizeof (cl_walker));
293 }
294
295 #ifdef _KERNEL
296 int
297 sysevent(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
298 {
299 uint_t sys_flags = FALSE;
300
301 if (mdb_getopts(argc, argv,
302 's', MDB_OPT_SETBITS, SYSEVENT_SENTQ, &sys_flags,
303 'v', MDB_OPT_SETBITS, SYSEVENT_VERBOSE, &sys_flags, NULL) != argc)
304 return (DCMD_USAGE);
305
306 if ((flags & DCMD_ADDRSPEC) == 0) {
307 if (sys_flags & SYSEVENT_SENTQ) {
308 if (mdb_walk_dcmd("sysevent_sent", "sysevent", argc,
309 argv) == -1) {
310 mdb_warn("can not walk sent queue");
311 return (DCMD_ERR);
312 }
313 } else {
314 if (mdb_walk_dcmd("sysevent_pend", "sysevent", argc,
315 argv) == -1) {
316 mdb_warn("can not walk pending queue");
317 return (DCMD_ERR);
318 }
319 }
320 return (DCMD_OK);
321 }
322
323 return (sysevent_buf(addr, flags, sys_flags));
324 }
325
326 int
327 sysevent_channel(uintptr_t addr, uint_t flags, int argc,
328 const mdb_arg_t *argv)
329 {
330 ssize_t channel_name_sz;
331 char channel_name[CHAN_FIELD_MAX];
332 sysevent_channel_descriptor_t chan_tbl;
333
334 if (argc != 0)
335 return (DCMD_USAGE);
336
337 if ((flags & DCMD_ADDRSPEC) == 0) {
338 if (mdb_walk_dcmd("sysevent_channel", "sysevent_channel",
339 argc, argv) == -1) {
340 mdb_warn("can't walk sysevent channel");
341 return (DCMD_ERR);
342 }
343 return (DCMD_OK);
344 }
345
346
347 if (DCMD_HDRSPEC(flags))
348 mdb_printf("%<u>%-?s %-16s %-8s %-?s%</u>\n",
349 "ADDR", "NAME", "REF CNT", "CLASS LST ADDR");
350
351 if (mdb_vread(&chan_tbl, sizeof (chan_tbl),
352 (uintptr_t)addr) == -1) {
353 mdb_warn("failed to read channel table at %p", addr);
354 return (DCMD_ERR);
355 }
356 if ((channel_name_sz = mdb_readstr(channel_name, CHAN_FIELD_MAX,
357 (uintptr_t)chan_tbl.scd_channel_name)) == -1) {
358 mdb_warn("failed to read channel name at %p",
359 chan_tbl.scd_channel_name);
360 return (DCMD_ERR);
361 }
362 if (channel_name_sz >= CHAN_FIELD_MAX - 1)
363 (void) strcpy(&channel_name[CHAN_FIELD_MAX - 4], "...");
364
365 mdb_printf("%-?p %-16s %-8lu %-?p\n",
366 addr, channel_name, chan_tbl.scd_ref_cnt,
367 addr + offsetof(sysevent_channel_descriptor_t,
368 scd_class_list_tbl));
369
370 return (DCMD_OK);
371 }
372
373 typedef struct channel_walk_data {
374 int hash_index;
375 sysevent_channel_descriptor_t *hash_tbl[CHAN_HASH_SZ];
376 } channel_walk_data_t;
377
378 int
379 sysevent_channel_walk_init(mdb_walk_state_t *wsp)
380 {
381 channel_walk_data_t *ch_walker;
382
383 if (wsp->walk_addr != NULL) {
384 mdb_warn("sysevent_channel supports only global walks");
385 return (WALK_ERR);
386 }
387
388 ch_walker = mdb_zalloc(sizeof (channel_walk_data_t), UM_SLEEP);
389 if (mdb_readvar(ch_walker->hash_tbl, "registered_channels")
390 == -1) {
391 mdb_warn("failed to read 'registered_channels'");
392 return (WALK_ERR);
393 }
394
395 wsp->walk_addr = (uintptr_t)ch_walker->hash_tbl[0];
396 wsp->walk_data = ch_walker;
397
398 return (WALK_NEXT);
399 }
400
401 int
402 sysevent_channel_walk_step(mdb_walk_state_t *wsp)
403 {
404 int status = WALK_NEXT;
405 channel_walk_data_t *ch_walker;
406 sysevent_channel_descriptor_t scd;
407
408 ch_walker = (channel_walk_data_t *)wsp->walk_data;
409
410 /* Skip over empty hash table entries */
411 if (wsp->walk_addr != NULL) {
412 if (mdb_vread(&scd, sizeof (sysevent_channel_descriptor_t),
413 wsp->walk_addr) == -1) {
414 mdb_warn("failed to read channel at %p",
415 wsp->walk_addr);
416 return (WALK_ERR);
417 }
418
419 status = wsp->walk_callback(wsp->walk_addr, NULL,
420 wsp->walk_cbdata);
421 wsp->walk_addr = (uintptr_t)scd.scd_next;
422 } else {
423 if (ch_walker->hash_index == CHAN_HASH_SZ) {
424 return (WALK_DONE);
425 } else {
426
427 wsp->walk_addr = (uintptr_t)
428 ch_walker->hash_tbl[ch_walker->hash_index];
429 ch_walker->hash_index++;
430 }
431 }
432
433 return (status);
434 }
435
436 void
437 sysevent_channel_walk_fini(mdb_walk_state_t *wsp)
438 {
439 channel_walk_data_t *ch_walker = wsp->walk_data;
440
441 mdb_free(ch_walker, sizeof (ch_walker));
442 }
443
444 int
445 sysevent_pend_walk_init(mdb_walk_state_t *wsp)
446 {
447 if (wsp->walk_addr == NULL) {
448 if (mdb_readvar(&wsp->walk_addr, "log_eventq_head") == -1) {
449 mdb_warn("failed to read 'log_eventq_head'");
450 return (WALK_ERR);
451 }
452 }
453
454 wsp->walk_data = mdb_alloc(sizeof (log_eventq_t), UM_SLEEP);
455 return (WALK_NEXT);
456 }
457
458 int
459 sysevent_walk_step(mdb_walk_state_t *wsp)
460 {
461 int status;
462 uintptr_t ev_arg_addr;
463
464 if (wsp->walk_addr == NULL)
465 return (WALK_DONE);
466
467 if (mdb_vread(wsp->walk_data, sizeof (log_eventq_t),
468 wsp->walk_addr) == -1) {
469 mdb_warn("failed to read event queue at %p", wsp->walk_addr);
470 return (WALK_ERR);
471 }
472 ev_arg_addr = wsp->walk_addr + offsetof(log_eventq_t, arg.buf);
473
474 status = wsp->walk_callback(ev_arg_addr, wsp->walk_data,
475 wsp->walk_cbdata);
476 wsp->walk_addr = (uintptr_t)(((log_eventq_t *)wsp->walk_data)->next);
477 return (status);
478 }
479
480 int
481 sysevent_sent_walk_init(mdb_walk_state_t *wsp)
482 {
483 if (wsp->walk_addr == NULL) {
484 if (mdb_readvar(&wsp->walk_addr, "log_eventq_sent") == -1) {
485 mdb_warn("failed to read 'log_eventq_sent'");
486 return (WALK_ERR);
487 }
488 }
489 wsp->walk_data = mdb_alloc(sizeof (log_eventq_t), UM_SLEEP);
490 return (WALK_NEXT);
491 }
492
493 void
494 sysevent_walk_fini(mdb_walk_state_t *wsp)
495 {
496 mdb_free(wsp->walk_data, sizeof (log_eventq_t));
497 }
498
499 #endif