1 /* $NetBSD: kern_history.c,v 1.19 2019/10/09 05:59:51 skrll Exp $ */
2
3 /*
4 * Copyright (c) 1997 Charles D. Cranor and Washington University.
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 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 *
27 * from: NetBSD: uvm_stat.c,v 1.36 2011/02/02 15:13:34 chuck Exp
28 * from: Id: uvm_stat.c,v 1.1.2.3 1997/12/19 15:01:00 mrg Exp
29 */
30
31 /*
32 * subr_kernhist.c
33 */
34
35 #include <sys/cdefs.h>
36 __KERNEL_RCSID(0, "$NetBSD: kern_history.c,v 1.19 2019/10/09 05:59:51 skrll Exp $");
37
38 #include "opt_ddb.h"
39 #include "opt_kernhist.h"
40 #include "opt_syscall_debug.h"
41 #include "opt_usb.h"
42 #include "opt_uvmhist.h"
43 #include "opt_biohist.h"
44 #include "opt_sysctl.h"
45
46 #include <sys/atomic.h>
47 #include <sys/param.h>
48 #include <sys/systm.h>
49 #include <sys/cpu.h>
50 #include <sys/sysctl.h>
51 #include <sys/kernhist.h>
52 #include <sys/kmem.h>
53
54 #ifdef UVMHIST
55 #include <uvm/uvm.h>
56 #endif
57
58 #ifdef USB_DEBUG
59 #include <dev/usb/usbhist.h>
60 #endif
61
62 #ifdef BIOHIST
63 #include <sys/biohist.h>
64 #endif
65
66 #ifdef SYSCALL_DEBUG
67 KERNHIST_DECL(scdebughist);
68 #endif
69
70 struct addr_xlt {
71 const char *addr;
72 size_t len;
73 uint32_t offset;
74 };
75
76 /*
77 * globals
78 */
79
80 struct kern_history_head kern_histories;
81 bool kernhist_sysctl_ready = 0;
82
83 int kernhist_print_enabled = 1;
84
85 int sysctl_hist_node;
86
87 static int sysctl_kernhist_helper(SYSCTLFN_PROTO);
88
89 #ifdef DDB
90
91 /*
92 * prototypes
93 */
94
95 void kernhist_dump(struct kern_history *, size_t count,
96 void (*)(const char *, ...) __printflike(1, 2));
97 static void kernhist_info(struct kern_history *,
98 void (*)(const char *, ...));
99 void kernhist_dumpmask(uint32_t);
100 static void kernhist_dump_histories(struct kern_history *[], size_t count,
101 void (*)(const char *, ...) __printflike(1, 2));
102
103 /* display info about one kernhist */
104 static void
kernhist_info(struct kern_history * l,void (* pr)(const char *,...))105 kernhist_info(struct kern_history *l, void (*pr)(const char *, ...))
106 {
107
108 pr("kernhist '%s': at %p total %u next free %u\n",
109 l->name, l, l->n, l->f);
110 }
111
112 /*
113 * call this from ddb
114 *
115 * expects the system to be quiesced, no locking
116 */
117 void
kernhist_dump(struct kern_history * l,size_t count,void (* pr)(const char *,...))118 kernhist_dump(struct kern_history *l, size_t count,
119 void (*pr)(const char *, ...))
120 {
121 int lcv;
122
123 lcv = l->f;
124 if (count > l->n)
125 pr("%s: count %zu > size %u\n", __func__, count, l->n);
126 else if (count)
127 lcv = (lcv - count) % l->n;
128
129 do {
130 if (l->e[lcv].fmt)
131 kernhist_entry_print(&l->e[lcv], pr);
132 lcv = (lcv + 1) % l->n;
133 } while (lcv != l->f);
134 }
135
136 /*
137 * print a merged list of kern_history structures. count is unused so far.
138 */
139 static void
kernhist_dump_histories(struct kern_history * hists[],size_t count,void (* pr)(const char *,...))140 kernhist_dump_histories(struct kern_history *hists[], size_t count,
141 void (*pr)(const char *, ...))
142 {
143 struct bintime bt;
144 int cur[MAXHISTS];
145 int lcv, hi;
146
147 /* find the first of each list */
148 for (lcv = 0; hists[lcv]; lcv++)
149 cur[lcv] = hists[lcv]->f;
150
151 /*
152 * here we loop "forever", finding the next earliest
153 * history entry and printing it. cur[X] is the current
154 * entry to test for the history in hists[X]. if it is
155 * -1, then this history is finished.
156 */
157 for (;;) {
158 hi = -1;
159 bt.sec = 0; bt.frac = 0;
160
161 /* loop over each history */
162 for (lcv = 0; hists[lcv]; lcv++) {
163 restart:
164 if (cur[lcv] == -1)
165 continue;
166 if (!hists[lcv]->e)
167 continue;
168
169 /*
170 * if the format is empty, go to the next entry
171 * and retry.
172 */
173 if (hists[lcv]->e[cur[lcv]].fmt == NULL) {
174 cur[lcv] = (cur[lcv] + 1) % (hists[lcv]->n);
175 if (cur[lcv] == hists[lcv]->f)
176 cur[lcv] = -1;
177 goto restart;
178 }
179
180 /*
181 * if the time hasn't been set yet, or this entry is
182 * earlier than the current bt, set the time and history
183 * index.
184 */
185 if (bt.sec == 0 ||
186 bintimecmp(&hists[lcv]->e[cur[lcv]].bt, &bt, <)) {
187 bt = hists[lcv]->e[cur[lcv]].bt;
188 hi = lcv;
189 }
190 }
191
192 /* if we didn't find any entries, we must be done */
193 if (hi == -1)
194 break;
195
196 /* print and move to the next entry */
197 kernhist_entry_print(&hists[hi]->e[cur[hi]], pr);
198
199 cur[hi] = (cur[hi] + 1) % (hists[hi]->n);
200 if (cur[hi] == hists[hi]->f)
201 cur[hi] = -1;
202 }
203 }
204
205 /*
206 * call this from ddb. `bitmask' is from <sys/kernhist.h>. it
207 * merges the named histories.
208 *
209 * expects the system to be quiesced, no locking
210 */
211 void
kernhist_dumpmask(uint32_t bitmask)212 kernhist_dumpmask(uint32_t bitmask) /* XXX only support 32 hists */
213 {
214 struct kern_history *hists[MAXHISTS + 1];
215 int i = 0;
216
217 #ifdef UVMHIST
218 if ((bitmask & KERNHIST_UVMMAPHIST) || bitmask == 0)
219 hists[i++] = &maphist;
220
221 if ((bitmask & KERNHIST_UVMPDHIST) || bitmask == 0)
222 hists[i++] = &pdhist;
223
224 if ((bitmask & KERNHIST_UVMUBCHIST) || bitmask == 0)
225 hists[i++] = &ubchist;
226
227 if ((bitmask & KERNHIST_UVMLOANHIST) || bitmask == 0)
228 hists[i++] = &loanhist;
229 #endif
230
231 #ifdef USB_DEBUG
232 if ((bitmask & KERNHIST_USBHIST) || bitmask == 0)
233 hists[i++] = &usbhist;
234 #endif
235
236 #ifdef SYSCALL_DEBUG
237 if ((bitmask & KERNHIST_SCDEBUGHIST) || bitmask == 0)
238 hists[i++] = &scdebughist;
239 #endif
240
241 #ifdef BIOHIST
242 if ((bitmask & KERNHIST_BIOHIST) || bitmask == 0)
243 hists[i++] = &biohist;
244 #endif
245
246 hists[i] = NULL;
247
248 kernhist_dump_histories(hists, 0, printf);
249 }
250
251 /*
252 * kernhist_print: ddb hook to print kern history.
253 */
254 void
255 kernhist_print(void *addr, size_t count, const char *modif,
256 void (*pr)(const char *, ...) __printflike(1,2))
257 {
258 struct kern_history *h;
259
260 LIST_FOREACH(h, &kern_histories, list) {
261 if (h == addr)
262 break;
263 }
264
265 if (h == NULL) {
266 struct kern_history *hists[MAXHISTS + 1];
267 int i = 0;
268 #ifdef UVMHIST
269 hists[i++] = &maphist;
270 hists[i++] = &pdhist;
271 hists[i++] = &ubchist;
272 hists[i++] = &loanhist;
273 #endif
274 #ifdef USB_DEBUG
275 hists[i++] = &usbhist;
276 #endif
277
278 #ifdef SYSCALL_DEBUG
279 hists[i++] = &scdebughist;
280 #endif
281 #ifdef BIOHIST
282 hists[i++] = &biohist;
283 #endif
284 hists[i] = NULL;
285
286 if (*modif == 'i') {
287 int lcv;
288
289 for (lcv = 0; hists[lcv]; lcv++)
290 kernhist_info(hists[lcv], pr);
291 } else {
292 kernhist_dump_histories(hists, count, pr);
293 }
294 } else {
295 if (*modif == 'i')
296 kernhist_info(h, pr);
297 else
298 kernhist_dump(h, count, pr);
299 }
300 }
301
302 #endif
303
304 /*
305 * sysctl interface
306 */
307
308 /*
309 * sysctl_kernhist_new()
310 *
311 * If the specified history (or, if no history is specified, any
312 * history) does not already have a sysctl node (under kern.hist)
313 * we create a new one and record it's node number.
314 */
315 void
sysctl_kernhist_new(struct kern_history * hist)316 sysctl_kernhist_new(struct kern_history *hist)
317 {
318 int error;
319 struct kern_history *h;
320 const struct sysctlnode *rnode = NULL;
321
322 membar_consumer();
323 if (kernhist_sysctl_ready == 0)
324 return;
325
326 LIST_FOREACH(h, &kern_histories, list) {
327 if (hist && h != hist)
328 continue;
329 if (h->s != 0)
330 continue;
331 error = sysctl_createv(NULL, 0, NULL, &rnode,
332 CTLFLAG_PERMANENT,
333 CTLTYPE_STRUCT, h->name,
334 SYSCTL_DESCR("history data"),
335 sysctl_kernhist_helper, 0, NULL, 0,
336 CTL_KERN, sysctl_hist_node, CTL_CREATE, CTL_EOL);
337 if (error == 0)
338 h->s = rnode->sysctl_num;
339 if (hist == h)
340 break;
341 }
342 }
343
344 /*
345 * sysctl_kerhnist_init()
346 *
347 * Create the 2nd level "hw.hist" sysctl node
348 */
349 void
sysctl_kernhist_init(void)350 sysctl_kernhist_init(void)
351 {
352 const struct sysctlnode *rnode = NULL;
353
354 sysctl_createv(NULL, 0, NULL, &rnode,
355 CTLFLAG_PERMANENT,
356 CTLTYPE_NODE, "hist",
357 SYSCTL_DESCR("kernel history tables"),
358 sysctl_kernhist_helper, 0, NULL, 0,
359 CTL_KERN, CTL_CREATE, CTL_EOL);
360 sysctl_hist_node = rnode->sysctl_num;
361
362 kernhist_sysctl_ready = 1;
363 membar_producer();
364
365 sysctl_kernhist_new(NULL);
366 }
367
368 /*
369 * find_string()
370 *
371 * Search the address-to-offset translation table for matching an
372 * address and len, and return the index of the entry we found. If
373 * not found, returns index 0 which points to the "?" entry. (We
374 * start matching at index 1, ignoring any matches of the "?" entry
375 * itself.)
376 */
377 static int
find_string(struct addr_xlt table[],size_t * count,const char * string,size_t len)378 find_string(struct addr_xlt table[], size_t *count, const char *string,
379 size_t len)
380 {
381 int i;
382
383 for (i = 1; i < *count; i++)
384 if (string == table[i].addr && len == table[i].len)
385 return i;
386
387 return 0;
388 }
389
390 /*
391 * add_string()
392 *
393 * If the string and len are unique, add a new address-to-offset
394 * entry in the translation table and set the offset of the next
395 * entry.
396 */
397 static void
add_string(struct addr_xlt table[],size_t * count,const char * string,size_t len)398 add_string(struct addr_xlt table[], size_t *count, const char *string,
399 size_t len)
400 {
401
402 if (find_string(table, count, string, len) == 0) {
403 table[*count].addr = string;
404 table[*count].len = len;
405 table[*count + 1].offset = table[*count].offset + len + 1;
406 (*count)++;
407 }
408 }
409
410 /*
411 * sysctl_kernhist_helper
412 *
413 * This helper routine is called for all accesses to the kern.hist
414 * hierarchy.
415 */
416 static int
sysctl_kernhist_helper(SYSCTLFN_ARGS)417 sysctl_kernhist_helper(SYSCTLFN_ARGS)
418 {
419 struct kern_history *h;
420 struct kern_history_ent *in_evt;
421 struct sysctl_history_event *out_evt;
422 struct sysctl_history *buf;
423 struct addr_xlt *xlate_t, *xlt;
424 size_t bufsize, xlate_s;
425 size_t xlate_c;
426 const char *strp __diagused;
427 char *next;
428 int i, j;
429 int error;
430
431 if (namelen == 1 && name[0] == CTL_QUERY)
432 return sysctl_query(SYSCTLFN_CALL(rnode));
433
434 /*
435 * Disallow userland updates, verify that we arrived at a
436 * valid history rnode
437 */
438 if (newp)
439 return EPERM;
440 if (namelen != 1 || name[0] != CTL_EOL)
441 return EINVAL;
442
443 /* Find the correct kernhist for this sysctl node */
444 LIST_FOREACH(h, &kern_histories, list) {
445 if (h->s == rnode->sysctl_num)
446 break;
447 }
448 if (h == NULL)
449 return ENOENT;
450
451 /*
452 * Worst case is two string pointers per history entry, plus
453 * two for the history name and "?" string; allocate an extra
454 * entry since we pre-set the "next" entry's offset member.
455 */
456 xlate_s = sizeof(struct addr_xlt) * h->n * 2 + 3;
457 xlate_t = kmem_alloc(xlate_s, KM_SLEEP);
458 xlate_c = 0;
459
460 /* offset 0 reserved for NULL pointer, ie unused history entry */
461 xlate_t[0].offset = 1;
462
463 /*
464 * If the history gets updated and an unexpected string is
465 * found later, we'll point it here. Otherwise, we'd have to
466 * repeat this process iteratively, and it could take multiple
467 * iterations before terminating.
468 */
469 add_string(xlate_t, &xlate_c, "?", 0);
470
471 /* Copy the history name itself to the export structure */
472 add_string(xlate_t, &xlate_c, h->name, h->namelen);
473
474 /*
475 * Loop through all used history entries to find the unique
476 * fn and fmt strings
477 */
478 for (i = 0, in_evt = h->e; i < h->n; i++, in_evt++) {
479 if (in_evt->fn == NULL)
480 continue;
481 add_string(xlate_t, &xlate_c, in_evt->fn, in_evt->fnlen);
482 add_string(xlate_t, &xlate_c, in_evt->fmt, in_evt->fmtlen);
483 }
484
485 /* Total buffer size includes header, events, and string table */
486 bufsize = sizeof(struct sysctl_history) +
487 h->n * sizeof(struct sysctl_history_event) +
488 xlate_t[xlate_c].offset;
489 buf = kmem_alloc(bufsize, KM_SLEEP);
490
491 /*
492 * Copy history header info to the export structure
493 */
494 j = find_string(xlate_t, &xlate_c, h->name, h->namelen);
495 buf->sh_nameoffset = xlate_t[j].offset;
496 buf->sh_numentries = h->n;
497 buf->sh_nextfree = h->f;
498
499 /*
500 * Loop through the history events again, copying the data to
501 * the export structure
502 */
503 for (i = 0, in_evt = h->e, out_evt = buf->sh_events; i < h->n;
504 i++, in_evt++, out_evt++) {
505 if (in_evt->fn == NULL) { /* skip unused entries */
506 out_evt->she_funcoffset = 0;
507 out_evt->she_fmtoffset = 0;
508 continue;
509 }
510 out_evt->she_bintime = in_evt->bt;
511 out_evt->she_callnumber = in_evt->call;
512 out_evt->she_cpunum = in_evt->cpunum;
513 out_evt->she_values[0] = in_evt->v[0];
514 out_evt->she_values[1] = in_evt->v[1];
515 out_evt->she_values[2] = in_evt->v[2];
516 out_evt->she_values[3] = in_evt->v[3];
517 j = find_string(xlate_t, &xlate_c, in_evt->fn, in_evt->fnlen);
518 out_evt->she_funcoffset = xlate_t[j].offset;
519 j = find_string(xlate_t, &xlate_c, in_evt->fmt, in_evt->fmtlen);
520 out_evt->she_fmtoffset = xlate_t[j].offset;
521 }
522
523 /*
524 * Finally, fill the text string area with all the unique
525 * strings we found earlier.
526 *
527 * Skip the initial byte, since we use an offset of 0 to mean
528 * a NULL pointer (which means an unused history event).
529 */
530 strp = next = (char *)(&buf->sh_events[h->n]);
531 *next++ = '\0';
532
533 /*
534 * Then copy each string into the export structure, making
535 * sure to terminate each string with a '\0' character
536 */
537 for (i = 0, xlt = xlate_t; i < xlate_c; i++, xlt++) {
538 KASSERTMSG((next - strp) == xlt->offset,
539 "entry %d at wrong offset %"PRIu32, i, xlt->offset);
540 memcpy(next, xlt->addr, xlt->len);
541 next += xlt->len;
542 *next++ = '\0';
543 }
544
545 /* Copy data to userland */
546 error = copyout(buf, oldp, uimin(bufsize, *oldlenp));
547
548 /* If copyout was successful but only partial, report ENOMEM */
549 if (error == 0 && *oldlenp < bufsize)
550 error = ENOMEM;
551
552 *oldlenp = bufsize; /* inform userland of space requirements */
553
554 /* Free up the stuff we allocated */
555 kmem_free(buf, bufsize);
556 kmem_free(xlate_t, xlate_s);
557
558 return error;
559 }
560