initial commit
[freebsd-arm:freebsd-arm.git] / cddl / dev / fbt / fbt.c
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 (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  *
21  * Portions Copyright 2006-2008 John Birrell jb@freebsd.org
22  *
23  * $FreeBSD$
24  *
25  */
26
27 /*
28  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
29  * Use is subject to license terms.
30  */
31
32 #include <sys/cdefs.h>
33 #include <sys/param.h>
34 #include <sys/systm.h>
35 #include <sys/conf.h>
36 #include <sys/cpuvar.h>
37 #include <sys/fcntl.h>
38 #include <sys/filio.h>
39 #include <sys/kdb.h>
40 #include <sys/kernel.h>
41 #include <sys/kmem.h>
42 #include <sys/kthread.h>
43 #include <sys/limits.h>
44 #include <sys/linker.h>
45 #include <sys/lock.h>
46 #include <sys/malloc.h>
47 #include <sys/module.h>
48 #include <sys/mutex.h>
49 #include <sys/pcpu.h>
50 #include <sys/poll.h>
51 #include <sys/proc.h>
52 #include <sys/selinfo.h>
53 #include <sys/smp.h>
54 #include <sys/syscall.h>
55 #include <sys/sysent.h>
56 #include <sys/sysproto.h>
57 #include <sys/uio.h>
58 #include <sys/unistd.h>
59 #include <machine/stdarg.h>
60
61 #include <sys/dtrace.h>
62 #include <sys/dtrace_bsd.h>
63
64 MALLOC_DEFINE(M_FBT, "fbt", "Function Boundary Tracing");
65
66 #define FBT_PUSHL_EBP           0x55
67 #define FBT_MOVL_ESP_EBP0_V0    0x8b
68 #define FBT_MOVL_ESP_EBP1_V0    0xec
69 #define FBT_MOVL_ESP_EBP0_V1    0x89
70 #define FBT_MOVL_ESP_EBP1_V1    0xe5
71 #define FBT_REX_RSP_RBP         0x48
72
73 #define FBT_POPL_EBP            0x5d
74 #define FBT_RET                 0xc3
75 #define FBT_RET_IMM16           0xc2
76 #define FBT_LEAVE               0xc9
77
78 #ifdef __amd64__
79 #define FBT_PATCHVAL            0xcc
80 #else
81 #define FBT_PATCHVAL            0xf0
82 #endif
83
84 static d_open_t fbt_open;
85 static int      fbt_unload(void);
86 static void     fbt_getargdesc(void *, dtrace_id_t, void *, dtrace_argdesc_t *);
87 static void     fbt_provide_module(void *, modctl_t *);
88 static void     fbt_destroy(void *, dtrace_id_t, void *);
89 static void     fbt_enable(void *, dtrace_id_t, void *);
90 static void     fbt_disable(void *, dtrace_id_t, void *);
91 static void     fbt_load(void *);
92 static void     fbt_suspend(void *, dtrace_id_t, void *);
93 static void     fbt_resume(void *, dtrace_id_t, void *);
94
95 #define FBT_ENTRY       "entry"
96 #define FBT_RETURN      "return"
97 #define FBT_ADDR2NDX(addr)      ((((uintptr_t)(addr)) >> 4) & fbt_probetab_mask)
98 #define FBT_PROBETAB_SIZE       0x8000          /* 32k entries -- 128K total */
99
100 static struct cdevsw fbt_cdevsw = {
101         .d_version      = D_VERSION,
102         .d_open         = fbt_open,
103         .d_name         = "fbt",
104 };
105
106 static dtrace_pattr_t fbt_attr = {
107 { DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_COMMON },
108 { DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN },
109 { DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_ISA },
110 { DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_COMMON },
111 { DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_ISA },
112 };
113
114 static dtrace_pops_t fbt_pops = {
115         NULL,
116         fbt_provide_module,
117         fbt_enable,
118         fbt_disable,
119         fbt_suspend,
120         fbt_resume,
121         fbt_getargdesc,
122         NULL,
123         NULL,
124         fbt_destroy
125 };
126
127 typedef struct fbt_probe {
128         struct fbt_probe *fbtp_hashnext;
129         uint8_t         *fbtp_patchpoint;
130         int8_t          fbtp_rval;
131         uint8_t         fbtp_patchval;
132         uint8_t         fbtp_savedval;
133         uintptr_t       fbtp_roffset;
134         dtrace_id_t     fbtp_id;
135         const char      *fbtp_name;
136         modctl_t        *fbtp_ctl;
137         int             fbtp_loadcnt;
138         int             fbtp_primary;
139         int             fbtp_invop_cnt;
140         int             fbtp_symindx;
141         struct fbt_probe *fbtp_next;
142 } fbt_probe_t;
143
144 static struct cdev              *fbt_cdev;
145 static dtrace_provider_id_t     fbt_id;
146 static fbt_probe_t              **fbt_probetab;
147 static int                      fbt_probetab_size;
148 static int                      fbt_probetab_mask;
149 static int                      fbt_verbose = 0;
150
151 static void
152 fbt_doubletrap(void)
153 {
154         fbt_probe_t *fbt;
155         int i;
156
157         for (i = 0; i < fbt_probetab_size; i++) {
158                 fbt = fbt_probetab[i];
159
160                 for (; fbt != NULL; fbt = fbt->fbtp_next)
161                         *fbt->fbtp_patchpoint = fbt->fbtp_savedval;
162         }
163 }
164
165 static int
166 fbt_invop(uintptr_t addr, uintptr_t *stack, uintptr_t rval)
167 {
168         solaris_cpu_t *cpu = &solaris_cpu[curcpu];
169         uintptr_t stack0, stack1, stack2, stack3, stack4;
170         fbt_probe_t *fbt = fbt_probetab[FBT_ADDR2NDX(addr)];
171
172         for (; fbt != NULL; fbt = fbt->fbtp_hashnext) {
173                 if ((uintptr_t)fbt->fbtp_patchpoint == addr) {
174                         fbt->fbtp_invop_cnt++;
175                         if (fbt->fbtp_roffset == 0) {
176                                 int i = 0;
177                                 /*
178                                  * When accessing the arguments on the stack,
179                                  * we must protect against accessing beyond
180                                  * the stack.  We can safely set NOFAULT here
181                                  * -- we know that interrupts are already
182                                  * disabled.
183                                  */
184                                 DTRACE_CPUFLAG_SET(CPU_DTRACE_NOFAULT);
185                                 cpu->cpu_dtrace_caller = stack[i++];
186                                 stack0 = stack[i++];
187                                 stack1 = stack[i++];
188                                 stack2 = stack[i++];
189                                 stack3 = stack[i++];
190                                 stack4 = stack[i++];
191                                 DTRACE_CPUFLAG_CLEAR(CPU_DTRACE_NOFAULT |
192                                     CPU_DTRACE_BADADDR);
193
194                                 dtrace_probe(fbt->fbtp_id, stack0, stack1,
195                                     stack2, stack3, stack4);
196
197                                 cpu->cpu_dtrace_caller = 0;
198                         } else {
199 #ifdef __amd64__
200                                 /*
201                                  * On amd64, we instrument the ret, not the
202                                  * leave.  We therefore need to set the caller
203                                  * to assure that the top frame of a stack()
204                                  * action is correct.
205                                  */
206                                 DTRACE_CPUFLAG_SET(CPU_DTRACE_NOFAULT);
207                                 cpu->cpu_dtrace_caller = stack[0];
208                                 DTRACE_CPUFLAG_CLEAR(CPU_DTRACE_NOFAULT |
209                                     CPU_DTRACE_BADADDR);
210 #endif
211
212                                 dtrace_probe(fbt->fbtp_id, fbt->fbtp_roffset,
213                                     rval, 0, 0, 0);
214                                 cpu->cpu_dtrace_caller = 0;
215                         }
216
217                         return (fbt->fbtp_rval);
218                 }
219         }
220
221         return (0);
222 }
223
224 static int
225 fbt_provide_module_function(linker_file_t lf, int symindx,
226     linker_symval_t *symval, void *opaque)
227 {
228         char *modname = opaque;
229         const char *name = symval->name;
230         fbt_probe_t *fbt, *retfbt;
231         int j;
232         int size;
233         u_int8_t *instr, *limit;
234
235         if (strncmp(name, "dtrace_", 7) == 0 &&
236             strncmp(name, "dtrace_safe_", 12) != 0) {
237                 /*
238                  * Anything beginning with "dtrace_" may be called
239                  * from probe context unless it explicitly indicates
240                  * that it won't be called from probe context by
241                  * using the prefix "dtrace_safe_".
242                  */
243                 return (0);
244         }
245
246         if (name[0] == '_' && name[1] == '_')
247                 return (0);
248
249         size = symval->size;
250
251         instr = (u_int8_t *) symval->value;
252         limit = (u_int8_t *) symval->value + symval->size;
253
254 #ifdef __amd64__
255         while (instr < limit) {
256                 if (*instr == FBT_PUSHL_EBP)
257                         break;
258
259                 if ((size = dtrace_instr_size(instr)) <= 0)
260                         break;
261
262                 instr += size;
263         }
264
265         if (instr >= limit || *instr != FBT_PUSHL_EBP) {
266                 /*
267                  * We either don't save the frame pointer in this
268                  * function, or we ran into some disassembly
269                  * screw-up.  Either way, we bail.
270                  */
271                 return (0);
272         }
273 #else
274         if (instr[0] != FBT_PUSHL_EBP)
275                 return (0);
276
277         if (!(instr[1] == FBT_MOVL_ESP_EBP0_V0 &&
278             instr[2] == FBT_MOVL_ESP_EBP1_V0) &&
279             !(instr[1] == FBT_MOVL_ESP_EBP0_V1 &&
280             instr[2] == FBT_MOVL_ESP_EBP1_V1))
281                 return (0);
282 #endif
283
284         fbt = malloc(sizeof (fbt_probe_t), M_FBT, M_WAITOK | M_ZERO);
285         fbt->fbtp_name = name;
286         fbt->fbtp_id = dtrace_probe_create(fbt_id, modname,
287             name, FBT_ENTRY, 3, fbt);
288         fbt->fbtp_patchpoint = instr;
289         fbt->fbtp_ctl = lf;
290         fbt->fbtp_loadcnt = lf->loadcnt;
291         fbt->fbtp_rval = DTRACE_INVOP_PUSHL_EBP;
292         fbt->fbtp_savedval = *instr;
293         fbt->fbtp_patchval = FBT_PATCHVAL;
294         fbt->fbtp_symindx = symindx;
295
296         fbt->fbtp_hashnext = fbt_probetab[FBT_ADDR2NDX(instr)];
297         fbt_probetab[FBT_ADDR2NDX(instr)] = fbt;
298
299         lf->fbt_nentries++;
300
301         retfbt = NULL;
302 again:
303         if (instr >= limit)
304                 return (0);
305
306         /*
307          * If this disassembly fails, then we've likely walked off into
308          * a jump table or some other unsuitable area.  Bail out of the
309          * disassembly now.
310          */
311         if ((size = dtrace_instr_size(instr)) <= 0)
312                 return (0);
313
314 #ifdef __amd64__
315         /*
316          * We only instrument "ret" on amd64 -- we don't yet instrument
317          * ret imm16, largely because the compiler doesn't seem to
318          * (yet) emit them in the kernel...
319          */
320         if (*instr != FBT_RET) {
321                 instr += size;
322                 goto again;
323         }
324 #else
325         if (!(size == 1 &&
326             (*instr == FBT_POPL_EBP || *instr == FBT_LEAVE) &&
327             (*(instr + 1) == FBT_RET ||
328             *(instr + 1) == FBT_RET_IMM16))) {
329                 instr += size;
330                 goto again;
331         }
332 #endif
333
334         /*
335          * We (desperately) want to avoid erroneously instrumenting a
336          * jump table, especially given that our markers are pretty
337          * short:  two bytes on x86, and just one byte on amd64.  To
338          * determine if we're looking at a true instruction sequence
339          * or an inline jump table that happens to contain the same
340          * byte sequences, we resort to some heuristic sleeze:  we
341          * treat this instruction as being contained within a pointer,
342          * and see if that pointer points to within the body of the
343          * function.  If it does, we refuse to instrument it.
344          */
345         for (j = 0; j < sizeof (uintptr_t); j++) {
346                 caddr_t check = (caddr_t) instr - j;
347                 uint8_t *ptr;
348
349                 if (check < symval->value)
350                         break;
351
352                 if (check + sizeof (caddr_t) > (caddr_t)limit)
353                         continue;
354
355                 ptr = *(uint8_t **)check;
356
357                 if (ptr >= (uint8_t *) symval->value && ptr < limit) {
358                         instr += size;
359                         goto again;
360                 }
361         }
362
363         /*
364          * We have a winner!
365          */
366         fbt = malloc(sizeof (fbt_probe_t), M_FBT, M_WAITOK | M_ZERO);
367         fbt->fbtp_name = name;
368
369         if (retfbt == NULL) {
370                 fbt->fbtp_id = dtrace_probe_create(fbt_id, modname,
371                     name, FBT_RETURN, 3, fbt);
372         } else {
373                 retfbt->fbtp_next = fbt;
374                 fbt->fbtp_id = retfbt->fbtp_id;
375         }
376
377         retfbt = fbt;
378         fbt->fbtp_patchpoint = instr;
379         fbt->fbtp_ctl = lf;
380         fbt->fbtp_loadcnt = lf->loadcnt;
381         fbt->fbtp_symindx = symindx;
382
383 #ifndef __amd64__
384         if (*instr == FBT_POPL_EBP) {
385                 fbt->fbtp_rval = DTRACE_INVOP_POPL_EBP;
386         } else {
387                 ASSERT(*instr == FBT_LEAVE);
388                 fbt->fbtp_rval = DTRACE_INVOP_LEAVE;
389         }
390         fbt->fbtp_roffset =
391             (uintptr_t)(instr - (uint8_t *) symval->value) + 1;
392
393 #else
394         ASSERT(*instr == FBT_RET);
395         fbt->fbtp_rval = DTRACE_INVOP_RET;
396         fbt->fbtp_roffset =
397             (uintptr_t)(instr - (uint8_t *) symval->value);
398 #endif
399
400         fbt->fbtp_savedval = *instr;
401         fbt->fbtp_patchval = FBT_PATCHVAL;
402         fbt->fbtp_hashnext = fbt_probetab[FBT_ADDR2NDX(instr)];
403         fbt_probetab[FBT_ADDR2NDX(instr)] = fbt;
404
405         lf->fbt_nentries++;
406
407         instr += size;
408         goto again;
409 }
410
411 static void
412 fbt_provide_module(void *arg, modctl_t *lf)
413 {
414         char modname[MAXPATHLEN];
415         int i;
416         size_t len;
417
418         strlcpy(modname, lf->filename, sizeof(modname));
419         len = strlen(modname);
420         if (len > 3 && strcmp(modname + len - 3, ".ko") == 0)
421                 modname[len - 3] = '\0';
422
423         /*
424          * Employees of dtrace and their families are ineligible.  Void
425          * where prohibited.
426          */
427         if (strcmp(modname, "dtrace") == 0)
428                 return;
429
430         /*
431          * The cyclic timer subsystem can be built as a module and DTrace
432          * depends on that, so it is ineligible too.
433          */
434         if (strcmp(modname, "cyclic") == 0)
435                 return;
436
437         /*
438          * To register with DTrace, a module must list 'dtrace' as a
439          * dependency in order for the kernel linker to resolve
440          * symbols like dtrace_register(). All modules with such a
441          * dependency are ineligible for FBT tracing.
442          */
443         for (i = 0; i < lf->ndeps; i++)
444                 if (strncmp(lf->deps[i]->filename, "dtrace", 6) == 0)
445                         return;
446
447         if (lf->fbt_nentries) {
448                 /*
449                  * This module has some FBT entries allocated; we're afraid
450                  * to screw with it.
451                  */
452                 return;
453         }
454
455         /*
456          * List the functions in the module and the symbol values.
457          */
458         (void) linker_file_function_listall(lf, fbt_provide_module_function, modname);
459 }
460
461 static void
462 fbt_destroy(void *arg, dtrace_id_t id, void *parg)
463 {
464         fbt_probe_t *fbt = parg, *next, *hash, *last;
465         modctl_t *ctl;
466         int ndx;
467
468         do {
469                 ctl = fbt->fbtp_ctl;
470
471                 ctl->fbt_nentries--;
472
473                 /*
474                  * Now we need to remove this probe from the fbt_probetab.
475                  */
476                 ndx = FBT_ADDR2NDX(fbt->fbtp_patchpoint);
477                 last = NULL;
478                 hash = fbt_probetab[ndx];
479
480                 while (hash != fbt) {
481                         ASSERT(hash != NULL);
482                         last = hash;
483                         hash = hash->fbtp_hashnext;
484                 }
485
486                 if (last != NULL) {
487                         last->fbtp_hashnext = fbt->fbtp_hashnext;
488                 } else {
489                         fbt_probetab[ndx] = fbt->fbtp_hashnext;
490                 }
491
492                 next = fbt->fbtp_next;
493                 free(fbt, M_FBT);
494
495                 fbt = next;
496         } while (fbt != NULL);
497 }
498
499 static void
500 fbt_enable(void *arg, dtrace_id_t id, void *parg)
501 {
502         fbt_probe_t *fbt = parg;
503         modctl_t *ctl = fbt->fbtp_ctl;
504
505         ctl->nenabled++;
506
507         /*
508          * Now check that our modctl has the expected load count.  If it
509          * doesn't, this module must have been unloaded and reloaded -- and
510          * we're not going to touch it.
511          */
512         if (ctl->loadcnt != fbt->fbtp_loadcnt) {
513                 if (fbt_verbose) {
514                         printf("fbt is failing for probe %s "
515                             "(module %s reloaded)",
516                             fbt->fbtp_name, ctl->filename);
517                 }
518
519                 return;
520         }
521
522         for (; fbt != NULL; fbt = fbt->fbtp_next) {
523                 *fbt->fbtp_patchpoint = fbt->fbtp_patchval;
524         }
525 }
526
527 static void
528 fbt_disable(void *arg, dtrace_id_t id, void *parg)
529 {
530         fbt_probe_t *fbt = parg;
531         modctl_t *ctl = fbt->fbtp_ctl;
532
533         ASSERT(ctl->nenabled > 0);
534         ctl->nenabled--;
535
536         if ((ctl->loadcnt != fbt->fbtp_loadcnt))
537                 return;
538
539         for (; fbt != NULL; fbt = fbt->fbtp_next)
540                 *fbt->fbtp_patchpoint = fbt->fbtp_savedval;
541 }
542
543 static void
544 fbt_suspend(void *arg, dtrace_id_t id, void *parg)
545 {
546         fbt_probe_t *fbt = parg;
547         modctl_t *ctl = fbt->fbtp_ctl;
548
549         ASSERT(ctl->nenabled > 0);
550
551         if ((ctl->loadcnt != fbt->fbtp_loadcnt))
552                 return;
553
554         for (; fbt != NULL; fbt = fbt->fbtp_next)
555                 *fbt->fbtp_patchpoint = fbt->fbtp_savedval;
556 }
557
558 static void
559 fbt_resume(void *arg, dtrace_id_t id, void *parg)
560 {
561         fbt_probe_t *fbt = parg;
562         modctl_t *ctl = fbt->fbtp_ctl;
563
564         ASSERT(ctl->nenabled > 0);
565
566         if ((ctl->loadcnt != fbt->fbtp_loadcnt))
567                 return;
568
569         for (; fbt != NULL; fbt = fbt->fbtp_next)
570                 *fbt->fbtp_patchpoint = fbt->fbtp_patchval;
571 }
572
573 static int
574 fbt_ctfoff_init(modctl_t *lf, linker_ctf_t *lc)
575 {
576         const Elf_Sym *symp = lc->symtab;;
577         const char *name;
578         const ctf_header_t *hp = (const ctf_header_t *) lc->ctftab;
579         const uint8_t *ctfdata = lc->ctftab + sizeof(ctf_header_t);
580         int i;
581         uint32_t *ctfoff;
582         uint32_t objtoff = hp->cth_objtoff;
583         uint32_t funcoff = hp->cth_funcoff;
584         ushort_t info;
585         ushort_t vlen;
586
587         /* Sanity check. */
588         if (hp->cth_magic != CTF_MAGIC) {
589                 printf("Bad magic value in CTF data of '%s'\n",lf->pathname);
590                 return (EINVAL);
591         }
592
593         if (lc->symtab == NULL) {
594                 printf("No symbol table in '%s'\n",lf->pathname);
595                 return (EINVAL);
596         }
597
598         if ((ctfoff = malloc(sizeof(uint32_t) * lc->nsym, M_LINKER, M_WAITOK)) == NULL)
599                 return (ENOMEM);
600
601         *lc->ctfoffp = ctfoff;
602
603         for (i = 0; i < lc->nsym; i++, ctfoff++, symp++) {
604                 if (symp->st_name == 0 || symp->st_shndx == SHN_UNDEF) {
605                         *ctfoff = 0xffffffff;
606                         continue;
607                 }
608
609                 if (symp->st_name < lc->strcnt)
610                         name = lc->strtab + symp->st_name;
611                 else
612                         name = "(?)";
613
614                 switch (ELF_ST_TYPE(symp->st_info)) {
615                 case STT_OBJECT:
616                         if (objtoff >= hp->cth_funcoff ||
617                             (symp->st_shndx == SHN_ABS && symp->st_value == 0)) {
618                                 *ctfoff = 0xffffffff;
619                                 break;
620                         }
621
622                         *ctfoff = objtoff;
623                         objtoff += sizeof (ushort_t);
624                         break;
625
626                 case STT_FUNC:
627                         if (funcoff >= hp->cth_typeoff) {
628                                 *ctfoff = 0xffffffff;
629                                 break;
630                         }
631
632                         *ctfoff = funcoff;
633
634                         info = *((const ushort_t *)(ctfdata + funcoff));
635                         vlen = CTF_INFO_VLEN(info);
636
637                         /*
638                          * If we encounter a zero pad at the end, just skip it.
639                          * Otherwise skip over the function and its return type
640                          * (+2) and the argument list (vlen).
641                          */
642                         if (CTF_INFO_KIND(info) == CTF_K_UNKNOWN && vlen == 0)
643                                 funcoff += sizeof (ushort_t); /* skip pad */
644                         else
645                                 funcoff += sizeof (ushort_t) * (vlen + 2);
646                         break;
647
648                 default:
649                         *ctfoff = 0xffffffff;
650                         break;
651                 }
652         }
653
654         return (0);
655 }
656
657 static ssize_t
658 fbt_get_ctt_size(uint8_t version, const ctf_type_t *tp, ssize_t *sizep,
659     ssize_t *incrementp)
660 {
661         ssize_t size, increment;
662
663         if (version > CTF_VERSION_1 &&
664             tp->ctt_size == CTF_LSIZE_SENT) {
665                 size = CTF_TYPE_LSIZE(tp);
666                 increment = sizeof (ctf_type_t);
667         } else {
668                 size = tp->ctt_size;
669                 increment = sizeof (ctf_stype_t);
670         }
671
672         if (sizep)
673                 *sizep = size;
674         if (incrementp)
675                 *incrementp = increment;
676
677         return (size);
678 }
679
680 static int
681 fbt_typoff_init(linker_ctf_t *lc)
682 {
683         const ctf_header_t *hp = (const ctf_header_t *) lc->ctftab;
684         const ctf_type_t *tbuf;
685         const ctf_type_t *tend;
686         const ctf_type_t *tp;
687         const uint8_t *ctfdata = lc->ctftab + sizeof(ctf_header_t);
688         int ctf_typemax = 0;
689         uint32_t *xp;
690         ulong_t pop[CTF_K_MAX + 1] = { 0 };
691
692
693         /* Sanity check. */
694         if (hp->cth_magic != CTF_MAGIC)
695                 return (EINVAL);
696
697         tbuf = (const ctf_type_t *) (ctfdata + hp->cth_typeoff);
698         tend = (const ctf_type_t *) (ctfdata + hp->cth_stroff);
699
700         int child = hp->cth_parname != 0;
701
702         /*
703          * We make two passes through the entire type section.  In this first
704          * pass, we count the number of each type and the total number of types.
705          */
706         for (tp = tbuf; tp < tend; ctf_typemax++) {
707                 ushort_t kind = CTF_INFO_KIND(tp->ctt_info);
708                 ulong_t vlen = CTF_INFO_VLEN(tp->ctt_info);
709                 ssize_t size, increment;
710
711                 size_t vbytes;
712                 uint_t n;
713
714                 (void) fbt_get_ctt_size(hp->cth_version, tp, &size, &increment);
715
716                 switch (kind) {
717                 case CTF_K_INTEGER:
718                 case CTF_K_FLOAT:
719                         vbytes = sizeof (uint_t);
720                         break;
721                 case CTF_K_ARRAY:
722                         vbytes = sizeof (ctf_array_t);
723                         break;
724                 case CTF_K_FUNCTION:
725                         vbytes = sizeof (ushort_t) * (vlen + (vlen & 1));
726                         break;
727                 case CTF_K_STRUCT:
728                 case CTF_K_UNION:
729                         if (size < CTF_LSTRUCT_THRESH) {
730                                 ctf_member_t *mp = (ctf_member_t *)
731                                     ((uintptr_t)tp + increment);
732
733                                 vbytes = sizeof (ctf_member_t) * vlen;
734                                 for (n = vlen; n != 0; n--, mp++)
735                                         child |= CTF_TYPE_ISCHILD(mp->ctm_type);
736                         } else {
737                                 ctf_lmember_t *lmp = (ctf_lmember_t *)
738                                     ((uintptr_t)tp + increment);
739
740                                 vbytes = sizeof (ctf_lmember_t) * vlen;
741                                 for (n = vlen; n != 0; n--, lmp++)
742                                         child |=
743                                             CTF_TYPE_ISCHILD(lmp->ctlm_type);
744                         }
745                         break;
746                 case CTF_K_ENUM:
747                         vbytes = sizeof (ctf_enum_t) * vlen;
748                         break;
749                 case CTF_K_FORWARD:
750                         /*
751                          * For forward declarations, ctt_type is the CTF_K_*
752                          * kind for the tag, so bump that population count too.
753                          * If ctt_type is unknown, treat the tag as a struct.
754                          */
755                         if (tp->ctt_type == CTF_K_UNKNOWN ||
756                             tp->ctt_type >= CTF_K_MAX)
757                                 pop[CTF_K_STRUCT]++;
758                         else
759                                 pop[tp->ctt_type]++;
760                         /*FALLTHRU*/
761                 case CTF_K_UNKNOWN:
762                         vbytes = 0;
763                         break;
764                 case CTF_K_POINTER:
765                 case CTF_K_TYPEDEF:
766                 case CTF_K_VOLATILE:
767                 case CTF_K_CONST:
768                 case CTF_K_RESTRICT:
769                         child |= CTF_TYPE_ISCHILD(tp->ctt_type);
770                         vbytes = 0;
771                         break;
772                 default:
773                         printf("%s(%d): detected invalid CTF kind -- %u\n", __func__, __LINE__, kind);
774                         return (EIO);
775                 }
776                 tp = (ctf_type_t *)((uintptr_t)tp + increment + vbytes);
777                 pop[kind]++;
778         }
779
780         *lc->typlenp = ctf_typemax;
781
782         if ((xp = malloc(sizeof(uint32_t) * ctf_typemax, M_LINKER, M_ZERO | M_WAITOK)) == NULL)
783                 return (ENOMEM);
784
785         *lc->typoffp = xp;
786
787         /* type id 0 is used as a sentinel value */
788         *xp++ = 0;
789
790         /*
791          * In the second pass, fill in the type offset.
792          */
793         for (tp = tbuf; tp < tend; xp++) {
794                 ushort_t kind = CTF_INFO_KIND(tp->ctt_info);
795                 ulong_t vlen = CTF_INFO_VLEN(tp->ctt_info);
796                 ssize_t size, increment;
797
798                 size_t vbytes;
799                 uint_t n;
800
801                 (void) fbt_get_ctt_size(hp->cth_version, tp, &size, &increment);
802
803                 switch (kind) {
804                 case CTF_K_INTEGER:
805                 case CTF_K_FLOAT:
806                         vbytes = sizeof (uint_t);
807                         break;
808                 case CTF_K_ARRAY:
809                         vbytes = sizeof (ctf_array_t);
810                         break;
811                 case CTF_K_FUNCTION:
812                         vbytes = sizeof (ushort_t) * (vlen + (vlen & 1));
813                         break;
814                 case CTF_K_STRUCT:
815                 case CTF_K_UNION:
816                         if (size < CTF_LSTRUCT_THRESH) {
817                                 ctf_member_t *mp = (ctf_member_t *)
818                                     ((uintptr_t)tp + increment);
819
820                                 vbytes = sizeof (ctf_member_t) * vlen;
821                                 for (n = vlen; n != 0; n--, mp++)
822                                         child |= CTF_TYPE_ISCHILD(mp->ctm_type);
823                         } else {
824                                 ctf_lmember_t *lmp = (ctf_lmember_t *)
825                                     ((uintptr_t)tp + increment);
826
827                                 vbytes = sizeof (ctf_lmember_t) * vlen;
828                                 for (n = vlen; n != 0; n--, lmp++)
829                                         child |=
830                                             CTF_TYPE_ISCHILD(lmp->ctlm_type);
831                         }
832                         break;
833                 case CTF_K_ENUM:
834                         vbytes = sizeof (ctf_enum_t) * vlen;
835                         break;
836                 case CTF_K_FORWARD:
837                 case CTF_K_UNKNOWN:
838                         vbytes = 0;
839                         break;
840                 case CTF_K_POINTER:
841                 case CTF_K_TYPEDEF:
842                 case CTF_K_VOLATILE:
843                 case CTF_K_CONST:
844                 case CTF_K_RESTRICT:
845                         vbytes = 0;
846                         break;
847                 default:
848                         printf("%s(%d): detected invalid CTF kind -- %u\n", __func__, __LINE__, kind);
849                         return (EIO);
850                 }
851                 *xp = (uint32_t)((uintptr_t) tp - (uintptr_t) ctfdata);
852                 tp = (ctf_type_t *)((uintptr_t)tp + increment + vbytes);
853         }
854
855         return (0);
856 }
857
858 /*
859  * CTF Declaration Stack
860  *
861  * In order to implement ctf_type_name(), we must convert a type graph back
862  * into a C type declaration.  Unfortunately, a type graph represents a storage
863  * class ordering of the type whereas a type declaration must obey the C rules
864  * for operator precedence, and the two orderings are frequently in conflict.
865  * For example, consider these CTF type graphs and their C declarations:
866  *
867  * CTF_K_POINTER -> CTF_K_FUNCTION -> CTF_K_INTEGER  : int (*)()
868  * CTF_K_POINTER -> CTF_K_ARRAY -> CTF_K_INTEGER     : int (*)[]
869  *
870  * In each case, parentheses are used to raise operator * to higher lexical
871  * precedence, so the string form of the C declaration cannot be constructed by
872  * walking the type graph links and forming the string from left to right.
873  *
874  * The functions in this file build a set of stacks from the type graph nodes
875  * corresponding to the C operator precedence levels in the appropriate order.
876  * The code in ctf_type_name() can then iterate over the levels and nodes in
877  * lexical precedence order and construct the final C declaration string.
878  */
879 typedef struct ctf_list {
880         struct ctf_list *l_prev; /* previous pointer or tail pointer */
881         struct ctf_list *l_next; /* next pointer or head pointer */
882 } ctf_list_t;
883
884 #define ctf_list_prev(elem)     ((void *)(((ctf_list_t *)(elem))->l_prev))
885 #define ctf_list_next(elem)     ((void *)(((ctf_list_t *)(elem))->l_next))
886
887 typedef enum {
888         CTF_PREC_BASE,
889         CTF_PREC_POINTER,
890         CTF_PREC_ARRAY,
891         CTF_PREC_FUNCTION,
892         CTF_PREC_MAX
893 } ctf_decl_prec_t;
894
895 typedef struct ctf_decl_node {
896         ctf_list_t cd_list;                     /* linked list pointers */
897         ctf_id_t cd_type;                       /* type identifier */
898         uint_t cd_kind;                         /* type kind */
899         uint_t cd_n;                            /* type dimension if array */
900 } ctf_decl_node_t;
901
902 typedef struct ctf_decl {
903         ctf_list_t cd_nodes[CTF_PREC_MAX];      /* declaration node stacks */
904         int cd_order[CTF_PREC_MAX];             /* storage order of decls */
905         ctf_decl_prec_t cd_qualp;               /* qualifier precision */
906         ctf_decl_prec_t cd_ordp;                /* ordered precision */
907         char *cd_buf;                           /* buffer for output */
908         char *cd_ptr;                           /* buffer location */
909         char *cd_end;                           /* buffer limit */
910         size_t cd_len;                          /* buffer space required */
911         int cd_err;                             /* saved error value */
912 } ctf_decl_t;
913
914 /*
915  * Simple doubly-linked list append routine.  This implementation assumes that
916  * each list element contains an embedded ctf_list_t as the first member.
917  * An additional ctf_list_t is used to store the head (l_next) and tail
918  * (l_prev) pointers.  The current head and tail list elements have their
919  * previous and next pointers set to NULL, respectively.
920  */
921 static void
922 ctf_list_append(ctf_list_t *lp, void *new)
923 {
924         ctf_list_t *p = lp->l_prev;     /* p = tail list element */
925         ctf_list_t *q = new;            /* q = new list element */
926
927         lp->l_prev = q;
928         q->l_prev = p;
929         q->l_next = NULL;
930
931         if (p != NULL)
932                 p->l_next = q;
933         else
934                 lp->l_next = q;
935 }
936
937 /*
938  * Prepend the specified existing element to the given ctf_list_t.  The
939  * existing pointer should be pointing at a struct with embedded ctf_list_t.
940  */
941 static void
942 ctf_list_prepend(ctf_list_t *lp, void *new)
943 {
944         ctf_list_t *p = new;            /* p = new list element */
945         ctf_list_t *q = lp->l_next;     /* q = head list element */
946
947         lp->l_next = p;
948         p->l_prev = NULL;
949         p->l_next = q;
950
951         if (q != NULL)
952                 q->l_prev = p;
953         else
954                 lp->l_prev = p;
955 }
956
957 static void
958 ctf_decl_init(ctf_decl_t *cd, char *buf, size_t len)
959 {
960         int i;
961
962         bzero(cd, sizeof (ctf_decl_t));
963
964         for (i = CTF_PREC_BASE; i < CTF_PREC_MAX; i++)
965                 cd->cd_order[i] = CTF_PREC_BASE - 1;
966
967         cd->cd_qualp = CTF_PREC_BASE;
968         cd->cd_ordp = CTF_PREC_BASE;
969
970         cd->cd_buf = buf;
971         cd->cd_ptr = buf;
972         cd->cd_end = buf + len;
973 }
974
975 static void
976 ctf_decl_fini(ctf_decl_t *cd)
977 {
978         ctf_decl_node_t *cdp, *ndp;
979         int i;
980
981         for (i = CTF_PREC_BASE; i < CTF_PREC_MAX; i++) {
982                 for (cdp = ctf_list_next(&cd->cd_nodes[i]);
983                     cdp != NULL; cdp = ndp) {
984                         ndp = ctf_list_next(cdp);
985                         free(cdp, M_FBT);
986                 }
987         }
988 }
989
990 static const ctf_type_t *
991 ctf_lookup_by_id(linker_ctf_t *lc, ctf_id_t type)
992 {
993         const ctf_type_t *tp;
994         uint32_t offset;
995         uint32_t *typoff = *lc->typoffp;
996
997         if (type >= *lc->typlenp) {
998                 printf("%s(%d): type %d exceeds max %ld\n",__func__,__LINE__,(int) type,*lc->typlenp);
999                 return(NULL);
1000         }
1001
1002         /* Check if the type isn't cross-referenced. */
1003         if ((offset = typoff[type]) == 0) {
1004                 printf("%s(%d): type %d isn't cross referenced\n",__func__,__LINE__, (int) type);
1005                 return(NULL);
1006         }
1007
1008         tp = (const ctf_type_t *)(lc->ctftab + offset + sizeof(ctf_header_t));
1009
1010         return (tp);
1011 }
1012
1013 static void
1014 fbt_array_info(linker_ctf_t *lc, ctf_id_t type, ctf_arinfo_t *arp)
1015 {
1016         const ctf_header_t *hp = (const ctf_header_t *) lc->ctftab;
1017         const ctf_type_t *tp;
1018         const ctf_array_t *ap;
1019         ssize_t increment;
1020
1021         bzero(arp, sizeof(*arp));
1022
1023         if ((tp = ctf_lookup_by_id(lc, type)) == NULL)
1024                 return;
1025
1026         if (CTF_INFO_KIND(tp->ctt_info) != CTF_K_ARRAY)
1027                 return;
1028
1029         (void) fbt_get_ctt_size(hp->cth_version, tp, NULL, &increment);
1030
1031         ap = (const ctf_array_t *)((uintptr_t)tp + increment);
1032         arp->ctr_contents = ap->cta_contents;
1033         arp->ctr_index = ap->cta_index;
1034         arp->ctr_nelems = ap->cta_nelems;
1035 }
1036
1037 static const char *
1038 ctf_strptr(linker_ctf_t *lc, int name)
1039 {
1040         const ctf_header_t *hp = (const ctf_header_t *) lc->ctftab;;
1041         const char *strp = "";
1042
1043         if (name < 0 || name >= hp->cth_strlen)
1044                 return(strp);
1045
1046         strp = (const char *)(lc->ctftab + hp->cth_stroff + name + sizeof(ctf_header_t));
1047
1048         return (strp);
1049 }
1050
1051 static void
1052 ctf_decl_push(ctf_decl_t *cd, linker_ctf_t *lc, ctf_id_t type)
1053 {
1054         ctf_decl_node_t *cdp;
1055         ctf_decl_prec_t prec;
1056         uint_t kind, n = 1;
1057         int is_qual = 0;
1058
1059         const ctf_type_t *tp;
1060         ctf_arinfo_t ar;
1061
1062         if ((tp = ctf_lookup_by_id(lc, type)) == NULL) {
1063                 cd->cd_err = ENOENT;
1064                 return;
1065         }
1066
1067         switch (kind = CTF_INFO_KIND(tp->ctt_info)) {
1068         case CTF_K_ARRAY:
1069                 fbt_array_info(lc, type, &ar);
1070                 ctf_decl_push(cd, lc, ar.ctr_contents);
1071                 n = ar.ctr_nelems;
1072                 prec = CTF_PREC_ARRAY;
1073                 break;
1074
1075         case CTF_K_TYPEDEF:
1076                 if (ctf_strptr(lc, tp->ctt_name)[0] == '\0') {
1077                         ctf_decl_push(cd, lc, tp->ctt_type);
1078                         return;
1079                 }
1080                 prec = CTF_PREC_BASE;
1081                 break;
1082
1083         case CTF_K_FUNCTION:
1084                 ctf_decl_push(cd, lc, tp->ctt_type);
1085                 prec = CTF_PREC_FUNCTION;
1086                 break;
1087
1088         case CTF_K_POINTER:
1089                 ctf_decl_push(cd, lc, tp->ctt_type);
1090                 prec = CTF_PREC_POINTER;
1091                 break;
1092
1093         case CTF_K_VOLATILE:
1094         case CTF_K_CONST:
1095         case CTF_K_RESTRICT:
1096                 ctf_decl_push(cd, lc, tp->ctt_type);
1097                 prec = cd->cd_qualp;
1098                 is_qual++;
1099                 break;
1100
1101         default:
1102                 prec = CTF_PREC_BASE;
1103         }
1104
1105         if ((cdp = malloc(sizeof (ctf_decl_node_t), M_FBT, M_WAITOK)) == NULL) {
1106                 cd->cd_err = EAGAIN;
1107                 return;
1108         }
1109
1110         cdp->cd_type = type;
1111         cdp->cd_kind = kind;
1112         cdp->cd_n = n;
1113
1114         if (ctf_list_next(&cd->cd_nodes[prec]) == NULL)
1115                 cd->cd_order[prec] = cd->cd_ordp++;
1116
1117         /*
1118          * Reset cd_qualp to the highest precedence level that we've seen so
1119          * far that can be qualified (CTF_PREC_BASE or CTF_PREC_POINTER).
1120          */
1121         if (prec > cd->cd_qualp && prec < CTF_PREC_ARRAY)
1122                 cd->cd_qualp = prec;
1123
1124         /*
1125          * C array declarators are ordered inside out so prepend them.  Also by
1126          * convention qualifiers of base types precede the type specifier (e.g.
1127          * const int vs. int const) even though the two forms are equivalent.
1128          */
1129         if (kind == CTF_K_ARRAY || (is_qual && prec == CTF_PREC_BASE))
1130                 ctf_list_prepend(&cd->cd_nodes[prec], cdp);
1131         else
1132                 ctf_list_append(&cd->cd_nodes[prec], cdp);
1133 }
1134
1135 static void
1136 ctf_decl_sprintf(ctf_decl_t *cd, const char *format, ...)
1137 {
1138         size_t len = (size_t)(cd->cd_end - cd->cd_ptr);
1139         va_list ap;
1140         size_t n;
1141
1142         va_start(ap, format);
1143         n = vsnprintf(cd->cd_ptr, len, format, ap);
1144         va_end(ap);
1145
1146         cd->cd_ptr += MIN(n, len);
1147         cd->cd_len += n;
1148 }
1149
1150 static ssize_t
1151 fbt_type_name(linker_ctf_t *lc, ctf_id_t type, char *buf, size_t len)
1152 {
1153         ctf_decl_t cd;
1154         ctf_decl_node_t *cdp;
1155         ctf_decl_prec_t prec, lp, rp;
1156         int ptr, arr;
1157         uint_t k;
1158
1159         if (lc == NULL && type == CTF_ERR)
1160                 return (-1); /* simplify caller code by permitting CTF_ERR */
1161
1162         ctf_decl_init(&cd, buf, len);
1163         ctf_decl_push(&cd, lc, type);
1164
1165         if (cd.cd_err != 0) {
1166                 ctf_decl_fini(&cd);
1167                 return (-1);
1168         }
1169
1170         /*
1171          * If the type graph's order conflicts with lexical precedence order
1172          * for pointers or arrays, then we need to surround the declarations at
1173          * the corresponding lexical precedence with parentheses.  This can
1174          * result in either a parenthesized pointer (*) as in int (*)() or
1175          * int (*)[], or in a parenthesized pointer and array as in int (*[])().
1176          */
1177         ptr = cd.cd_order[CTF_PREC_POINTER] > CTF_PREC_POINTER;
1178         arr = cd.cd_order[CTF_PREC_ARRAY] > CTF_PREC_ARRAY;
1179
1180         rp = arr ? CTF_PREC_ARRAY : ptr ? CTF_PREC_POINTER : -1;
1181         lp = ptr ? CTF_PREC_POINTER : arr ? CTF_PREC_ARRAY : -1;
1182
1183         k = CTF_K_POINTER; /* avoid leading whitespace (see below) */
1184
1185         for (prec = CTF_PREC_BASE; prec < CTF_PREC_MAX; prec++) {
1186                 for (cdp = ctf_list_next(&cd.cd_nodes[prec]);
1187                     cdp != NULL; cdp = ctf_list_next(cdp)) {
1188
1189                         const ctf_type_t *tp =
1190                             ctf_lookup_by_id(lc, cdp->cd_type);
1191                         const char *name = ctf_strptr(lc, tp->ctt_name);
1192
1193                         if (k != CTF_K_POINTER && k != CTF_K_ARRAY)
1194                                 ctf_decl_sprintf(&cd, " ");
1195
1196                         if (lp == prec) {
1197                                 ctf_decl_sprintf(&cd, "(");
1198                                 lp = -1;
1199                         }
1200
1201                         switch (cdp->cd_kind) {
1202                         case CTF_K_INTEGER:
1203                         case CTF_K_FLOAT:
1204                         case CTF_K_TYPEDEF:
1205                                 ctf_decl_sprintf(&cd, "%s", name);
1206                                 break;
1207                         case CTF_K_POINTER:
1208                                 ctf_decl_sprintf(&cd, "*");
1209                                 break;
1210                         case CTF_K_ARRAY:
1211                                 ctf_decl_sprintf(&cd, "[%u]", cdp->cd_n);
1212                                 break;
1213                         case CTF_K_FUNCTION:
1214                                 ctf_decl_sprintf(&cd, "()");
1215                                 break;
1216                         case CTF_K_STRUCT:
1217                         case CTF_K_FORWARD:
1218                                 ctf_decl_sprintf(&cd, "struct %s", name);
1219                                 break;
1220                         case CTF_K_UNION:
1221                                 ctf_decl_sprintf(&cd, "union %s", name);
1222                                 break;
1223                         case CTF_K_ENUM:
1224                                 ctf_decl_sprintf(&cd, "enum %s", name);
1225                                 break;
1226                         case CTF_K_VOLATILE:
1227                                 ctf_decl_sprintf(&cd, "volatile");
1228                                 break;
1229                         case CTF_K_CONST:
1230                                 ctf_decl_sprintf(&cd, "const");
1231                                 break;
1232                         case CTF_K_RESTRICT:
1233                                 ctf_decl_sprintf(&cd, "restrict");
1234                                 break;
1235                         }
1236
1237                         k = cdp->cd_kind;
1238                 }
1239
1240                 if (rp == prec)
1241                         ctf_decl_sprintf(&cd, ")");
1242         }
1243
1244         ctf_decl_fini(&cd);
1245         return (cd.cd_len);
1246 }
1247
1248 static void
1249 fbt_getargdesc(void *arg __unused, dtrace_id_t id __unused, void *parg, dtrace_argdesc_t *desc)
1250 {
1251         const ushort_t *dp;
1252         fbt_probe_t *fbt = parg;
1253         linker_ctf_t lc;
1254         modctl_t *ctl = fbt->fbtp_ctl;
1255         int ndx = desc->dtargd_ndx;
1256         int symindx = fbt->fbtp_symindx;
1257         uint32_t *ctfoff;
1258         uint32_t offset;
1259         ushort_t info, kind, n;
1260
1261         desc->dtargd_ndx = DTRACE_ARGNONE;
1262
1263         /* Get a pointer to the CTF data and it's length. */
1264         if (linker_ctf_get(ctl, &lc) != 0)
1265                 /* No CTF data? Something wrong? *shrug* */
1266                 return;
1267
1268         /* Check if this module hasn't been initialised yet. */
1269         if (*lc.ctfoffp == NULL) {
1270                 /*
1271                  * Initialise the CTF object and function symindx to
1272                  * byte offset array.
1273                  */
1274                 if (fbt_ctfoff_init(ctl, &lc) != 0)
1275                         return;
1276
1277                 /* Initialise the CTF type to byte offset array. */
1278                 if (fbt_typoff_init(&lc) != 0)
1279                         return;
1280         }
1281
1282         ctfoff = *lc.ctfoffp;
1283
1284         if (ctfoff == NULL || *lc.typoffp == NULL)
1285                 return;
1286
1287         /* Check if the symbol index is out of range. */
1288         if (symindx >= lc.nsym)
1289                 return;
1290
1291         /* Check if the symbol isn't cross-referenced. */
1292         if ((offset = ctfoff[symindx]) == 0xffffffff)
1293                 return;
1294
1295         dp = (const ushort_t *)(lc.ctftab + offset + sizeof(ctf_header_t));
1296
1297         info = *dp++;
1298         kind = CTF_INFO_KIND(info);
1299         n = CTF_INFO_VLEN(info);
1300
1301         if (kind == CTF_K_UNKNOWN && n == 0) {
1302                 printf("%s(%d): Unknown function!\n",__func__,__LINE__);
1303                 return;
1304         }
1305
1306         if (kind != CTF_K_FUNCTION) {
1307                 printf("%s(%d): Expected a function!\n",__func__,__LINE__);
1308                 return;
1309         }
1310
1311         /* Check if the requested argument doesn't exist. */
1312         if (ndx >= n)
1313                 return;
1314
1315         /* Skip the return type and arguments up to the one requested. */
1316         dp += ndx + 1;
1317
1318         if (fbt_type_name(&lc, *dp, desc->dtargd_native, sizeof(desc->dtargd_native)) > 0)
1319                 desc->dtargd_ndx = ndx;
1320
1321         return;
1322 }
1323
1324 static void
1325 fbt_load(void *dummy)
1326 {
1327         /* Create the /dev/dtrace/fbt entry. */
1328         fbt_cdev = make_dev(&fbt_cdevsw, 0, UID_ROOT, GID_WHEEL, 0600,
1329             "dtrace/fbt");
1330
1331         /* Default the probe table size if not specified. */
1332         if (fbt_probetab_size == 0)
1333                 fbt_probetab_size = FBT_PROBETAB_SIZE;
1334
1335         /* Choose the hash mask for the probe table. */
1336         fbt_probetab_mask = fbt_probetab_size - 1;
1337
1338         /* Allocate memory for the probe table. */
1339         fbt_probetab =
1340             malloc(fbt_probetab_size * sizeof (fbt_probe_t *), M_FBT, M_WAITOK | M_ZERO);
1341
1342         dtrace_doubletrap_func = fbt_doubletrap;
1343         dtrace_invop_add(fbt_invop);
1344
1345         if (dtrace_register("fbt", &fbt_attr, DTRACE_PRIV_USER,
1346             NULL, &fbt_pops, NULL, &fbt_id) != 0)
1347                 return;
1348 }
1349
1350
1351 static int
1352 fbt_unload()
1353 {
1354         int error = 0;
1355
1356         /* De-register the invalid opcode handler. */
1357         dtrace_invop_remove(fbt_invop);
1358
1359         dtrace_doubletrap_func = NULL;
1360
1361         /* De-register this DTrace provider. */
1362         if ((error = dtrace_unregister(fbt_id)) != 0)
1363                 return (error);
1364
1365         /* Free the probe table. */
1366         free(fbt_probetab, M_FBT);
1367         fbt_probetab = NULL;
1368         fbt_probetab_mask = 0;
1369
1370         destroy_dev(fbt_cdev);
1371
1372         return (error);
1373 }
1374
1375 static int
1376 fbt_modevent(module_t mod __unused, int type, void *data __unused)
1377 {
1378         int error = 0;
1379
1380         switch (type) {
1381         case MOD_LOAD:
1382                 break;
1383
1384         case MOD_UNLOAD:
1385                 break;
1386
1387         case MOD_SHUTDOWN:
1388                 break;
1389
1390         default:
1391                 error = EOPNOTSUPP;
1392                 break;
1393
1394         }
1395
1396         return (error);
1397 }
1398
1399 static int
1400 fbt_open(struct cdev *dev __unused, int oflags __unused, int devtype __unused, struct thread *td __unused)
1401 {
1402         return (0);
1403 }
1404
1405 SYSINIT(fbt_load, SI_SUB_DTRACE_PROVIDER, SI_ORDER_ANY, fbt_load, NULL);
1406 SYSUNINIT(fbt_unload, SI_SUB_DTRACE_PROVIDER, SI_ORDER_ANY, fbt_unload, NULL);
1407
1408 DEV_MODULE(fbt, fbt_modevent, NULL);
1409 MODULE_VERSION(fbt, 1);
1410 MODULE_DEPEND(fbt, dtrace, 1, 1, 1);
1411 MODULE_DEPEND(fbt, opensolaris, 1, 1, 1);