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 /*
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26
27 #include <sys/modctl.h>
28 #include <sys/dtrace.h>
29 #include <sys/kobj.h>
30 #include <sys/stat.h>
31 #include <sys/ddi.h>
32 #include <sys/sunddi.h>
33 #include <sys/conf.h>
34
35 #define FBT_PUSHL_EBP 0x55
36 #define FBT_MOVL_ESP_EBP0_V0 0x8b
37 #define FBT_MOVL_ESP_EBP1_V0 0xec
38 #define FBT_MOVL_ESP_EBP0_V1 0x89
39 #define FBT_MOVL_ESP_EBP1_V1 0xe5
40 #define FBT_REX_RSP_RBP 0x48
41
42 #define FBT_POPL_EBP 0x5d
43 #define FBT_RET 0xc3
44 #define FBT_RET_IMM16 0xc2
45 #define FBT_LEAVE 0xc9
46
47 #ifdef __amd64
48 #define FBT_PATCHVAL 0xcc
49 #else
50 #define FBT_PATCHVAL 0xf0
51 #endif
52
53 #define FBT_ENTRY "entry"
54 #define FBT_RETURN "return"
55 #define FBT_ADDR2NDX(addr) ((((uintptr_t)(addr)) >> 4) & fbt_probetab_mask)
56 #define FBT_PROBETAB_SIZE 0x8000 /* 32k entries -- 128K total */
57
58 typedef struct fbt_probe {
59 struct fbt_probe *fbtp_hashnext;
60 uint8_t *fbtp_patchpoint;
61 int8_t fbtp_rval;
62 uint8_t fbtp_patchval;
63 uint8_t fbtp_savedval;
64 uintptr_t fbtp_roffset;
65 dtrace_id_t fbtp_id;
66 char *fbtp_name;
67 struct modctl *fbtp_ctl;
68 int fbtp_loadcnt;
69 int fbtp_symndx;
70 int fbtp_primary;
71 struct fbt_probe *fbtp_next;
72 } fbt_probe_t;
73
74 static dev_info_t *fbt_devi;
75 static dtrace_provider_id_t fbt_id;
76 static fbt_probe_t **fbt_probetab;
77 static int fbt_probetab_size;
78 static int fbt_probetab_mask;
79 static int fbt_verbose = 0;
80
81 static int
82 fbt_invop(uintptr_t addr, uintptr_t *stack, uintptr_t rval)
83 {
84 uintptr_t stack0, stack1, stack2, stack3, stack4;
85 fbt_probe_t *fbt = fbt_probetab[FBT_ADDR2NDX(addr)];
86
87 for (; fbt != NULL; fbt = fbt->fbtp_hashnext) {
88 if ((uintptr_t)fbt->fbtp_patchpoint == addr) {
89 if (fbt->fbtp_roffset == 0) {
90 int i = 0;
91 /*
92 * When accessing the arguments on the stack,
93 * we must protect against accessing beyond
94 * the stack. We can safely set NOFAULT here
95 * -- we know that interrupts are already
96 * disabled.
97 */
98 DTRACE_CPUFLAG_SET(CPU_DTRACE_NOFAULT);
99 CPU->cpu_dtrace_caller = stack[i++];
100 #ifdef __amd64
101 /*
102 * On amd64, stack[0] contains the dereferenced
103 * stack pointer, stack[1] contains savfp,
104 * stack[2] contains savpc. We want to step
105 * over these entries.
106 */
107 i += 2;
108 #endif
109 stack0 = stack[i++];
110 stack1 = stack[i++];
111 stack2 = stack[i++];
112 stack3 = stack[i++];
113 stack4 = stack[i++];
114 DTRACE_CPUFLAG_CLEAR(CPU_DTRACE_NOFAULT |
115 CPU_DTRACE_BADADDR);
116
117 dtrace_probe(fbt->fbtp_id, stack0, stack1,
118 stack2, stack3, stack4);
119
120 CPU->cpu_dtrace_caller = NULL;
121 } else {
122 #ifdef __amd64
123 /*
124 * On amd64, we instrument the ret, not the
125 * leave. We therefore need to set the caller
126 * to assure that the top frame of a stack()
127 * action is correct.
128 */
129 DTRACE_CPUFLAG_SET(CPU_DTRACE_NOFAULT);
130 CPU->cpu_dtrace_caller = stack[0];
131 DTRACE_CPUFLAG_CLEAR(CPU_DTRACE_NOFAULT |
132 CPU_DTRACE_BADADDR);
133 #endif
134
135 dtrace_probe(fbt->fbtp_id, fbt->fbtp_roffset,
136 rval, 0, 0, 0);
137 CPU->cpu_dtrace_caller = NULL;
138 }
139
140 return (fbt->fbtp_rval);
141 }
142 }
143
144 return (0);
145 }
146
147 /*ARGSUSED*/
148 static void
149 fbt_provide_module(void *arg, struct modctl *ctl)
150 {
151 struct module *mp = ctl->mod_mp;
152 char *str = mp->strings;
153 int nsyms = mp->nsyms;
154 Shdr *symhdr = mp->symhdr;
155 char *modname = ctl->mod_modname;
156 char *name;
157 fbt_probe_t *fbt, *retfbt;
158 size_t symsize;
159 int i, size;
160
161 /*
162 * Employees of dtrace and their families are ineligible. Void
163 * where prohibited.
164 */
165 if (strcmp(modname, "dtrace") == 0)
166 return;
167
168 if (ctl->mod_requisites != NULL) {
169 struct modctl_list *list;
170
171 list = (struct modctl_list *)ctl->mod_requisites;
172
173 for (; list != NULL; list = list->modl_next) {
174 if (strcmp(list->modl_modp->mod_modname, "dtrace") == 0)
175 return;
176 }
177 }
178
179 /*
180 * KMDB is ineligible for instrumentation -- it may execute in
181 * any context, including probe context.
182 */
183 if (strcmp(modname, "kmdbmod") == 0)
184 return;
185
186 if (str == NULL || symhdr == NULL || symhdr->sh_addr == NULL) {
187 /*
188 * If this module doesn't (yet) have its string or symbol
189 * table allocated, clear out.
190 */
191 return;
192 }
193
194 symsize = symhdr->sh_entsize;
195
196 if (mp->fbt_nentries) {
197 /*
198 * This module has some FBT entries allocated; we're afraid
199 * to screw with it.
200 */
201 return;
202 }
203
204 for (i = 1; i < nsyms; i++) {
205 uint8_t *instr, *limit;
206 Sym *sym = (Sym *)(symhdr->sh_addr + i * symsize);
207 int j;
208
209 if (ELF_ST_TYPE(sym->st_info) != STT_FUNC)
210 continue;
211
212 /*
213 * Weak symbols are not candidates. This could be made to
214 * work (where weak functions and their underlying function
215 * appear as two disjoint probes), but it's not simple.
216 */
217 if (ELF_ST_BIND(sym->st_info) == STB_WEAK)
218 continue;
219
220 name = str + sym->st_name;
221
222 if (strstr(name, "dtrace_") == name &&
223 strstr(name, "dtrace_safe_") != name) {
224 /*
225 * Anything beginning with "dtrace_" may be called
226 * from probe context unless it explitly indicates
227 * that it won't be called from probe context by
228 * using the prefix "dtrace_safe_".
229 */
230 continue;
231 }
232
233 if (strstr(name, "kdi_") == name ||
234 strstr(name, "_kdi_") != NULL) {
235 /*
236 * Any function name beginning with "kdi_" or
237 * containing the string "_kdi_" is a part of the
238 * kernel debugger interface and may be called in
239 * arbitrary context -- including probe context.
240 */
241 continue;
242 }
243
244 /*
245 * Due to 4524008, _init and _fini may have a bloated st_size.
246 * While this bug was fixed quite some time ago, old drivers
247 * may be lurking. We need to develop a better solution to
248 * this problem, such that correct _init and _fini functions
249 * (the vast majority) may be correctly traced. One solution
250 * may be to scan through the entire symbol table to see if
251 * any symbol overlaps with _init. If none does, set a bit in
252 * the module structure that this module has correct _init and
253 * _fini sizes. This will cause some pain the first time a
254 * module is scanned, but at least it would be O(N) instead of
255 * O(N log N)...
256 */
257 if (strcmp(name, "_init") == 0)
258 continue;
259
260 if (strcmp(name, "_fini") == 0)
261 continue;
262
263 /*
264 * In order to be eligible, the function must begin with the
265 * following sequence:
266 *
267 * pushl %esp
268 * movl %esp, %ebp
269 *
270 * Note that there are two variants of encodings that generate
271 * the movl; we must check for both. For 64-bit, we would
272 * normally insist that a function begin with the following
273 * sequence:
274 *
275 * pushq %rbp
276 * movq %rsp, %rbp
277 *
278 * However, the compiler for 64-bit often splits these two
279 * instructions -- and the first instruction in the function
280 * is often not the pushq. As a result, on 64-bit we look
281 * for any "pushq %rbp" in the function and we instrument
282 * this with a breakpoint instruction.
283 */
284 instr = (uint8_t *)sym->st_value;
285 limit = (uint8_t *)(sym->st_value + sym->st_size);
286
287 #ifdef __amd64
288 while (instr < limit) {
289 if (*instr == FBT_PUSHL_EBP)
290 break;
291
292 if ((size = dtrace_instr_size(instr)) <= 0)
293 break;
294
295 instr += size;
296 }
297
298 if (instr >= limit || *instr != FBT_PUSHL_EBP) {
299 /*
300 * We either don't save the frame pointer in this
301 * function, or we ran into some disassembly
302 * screw-up. Either way, we bail.
303 */
304 continue;
305 }
306 #else
307 if (instr[0] != FBT_PUSHL_EBP)
308 continue;
309
310 if (!(instr[1] == FBT_MOVL_ESP_EBP0_V0 &&
311 instr[2] == FBT_MOVL_ESP_EBP1_V0) &&
312 !(instr[1] == FBT_MOVL_ESP_EBP0_V1 &&
313 instr[2] == FBT_MOVL_ESP_EBP1_V1))
314 continue;
315 #endif
316
317 fbt = kmem_zalloc(sizeof (fbt_probe_t), KM_SLEEP);
318 fbt->fbtp_name = name;
319 fbt->fbtp_id = dtrace_probe_create(fbt_id, modname,
320 name, FBT_ENTRY, 3, fbt);
321 fbt->fbtp_patchpoint = instr;
322 fbt->fbtp_ctl = ctl;
323 fbt->fbtp_loadcnt = ctl->mod_loadcnt;
324 fbt->fbtp_rval = DTRACE_INVOP_PUSHL_EBP;
325 fbt->fbtp_savedval = *instr;
326 fbt->fbtp_patchval = FBT_PATCHVAL;
327
328 fbt->fbtp_hashnext = fbt_probetab[FBT_ADDR2NDX(instr)];
329 fbt->fbtp_symndx = i;
330 fbt_probetab[FBT_ADDR2NDX(instr)] = fbt;
331
332 mp->fbt_nentries++;
333
334 retfbt = NULL;
335 again:
336 if (instr >= limit)
337 continue;
338
339 /*
340 * If this disassembly fails, then we've likely walked off into
341 * a jump table or some other unsuitable area. Bail out of the
342 * disassembly now.
343 */
344 if ((size = dtrace_instr_size(instr)) <= 0)
345 continue;
346
347 #ifdef __amd64
348 /*
349 * We only instrument "ret" on amd64 -- we don't yet instrument
350 * ret imm16, largely because the compiler doesn't seem to
351 * (yet) emit them in the kernel...
352 */
353 if (*instr != FBT_RET) {
354 instr += size;
355 goto again;
356 }
357 #else
358 if (!(size == 1 &&
359 (*instr == FBT_POPL_EBP || *instr == FBT_LEAVE) &&
360 (*(instr + 1) == FBT_RET ||
361 *(instr + 1) == FBT_RET_IMM16))) {
362 instr += size;
363 goto again;
364 }
365 #endif
366
367 /*
368 * We (desperately) want to avoid erroneously instrumenting a
369 * jump table, especially given that our markers are pretty
370 * short: two bytes on x86, and just one byte on amd64. To
371 * determine if we're looking at a true instruction sequence
372 * or an inline jump table that happens to contain the same
373 * byte sequences, we resort to some heuristic sleeze: we
374 * treat this instruction as being contained within a pointer,
375 * and see if that pointer points to within the body of the
376 * function. If it does, we refuse to instrument it.
377 */
378 for (j = 0; j < sizeof (uintptr_t); j++) {
379 uintptr_t check = (uintptr_t)instr - j;
380 uint8_t *ptr;
381
382 if (check < sym->st_value)
383 break;
384
385 if (check + sizeof (uintptr_t) > (uintptr_t)limit)
386 continue;
387
388 ptr = *(uint8_t **)check;
389
390 if (ptr >= (uint8_t *)sym->st_value && ptr < limit) {
391 instr += size;
392 goto again;
393 }
394 }
395
396 /*
397 * We have a winner!
398 */
399 fbt = kmem_zalloc(sizeof (fbt_probe_t), KM_SLEEP);
400 fbt->fbtp_name = name;
401
402 if (retfbt == NULL) {
403 fbt->fbtp_id = dtrace_probe_create(fbt_id, modname,
404 name, FBT_RETURN, 3, fbt);
405 } else {
406 retfbt->fbtp_next = fbt;
407 fbt->fbtp_id = retfbt->fbtp_id;
408 }
409
410 retfbt = fbt;
411 fbt->fbtp_patchpoint = instr;
412 fbt->fbtp_ctl = ctl;
413 fbt->fbtp_loadcnt = ctl->mod_loadcnt;
414
415 #ifndef __amd64
416 if (*instr == FBT_POPL_EBP) {
417 fbt->fbtp_rval = DTRACE_INVOP_POPL_EBP;
418 } else {
419 ASSERT(*instr == FBT_LEAVE);
420 fbt->fbtp_rval = DTRACE_INVOP_LEAVE;
421 }
422 fbt->fbtp_roffset =
423 (uintptr_t)(instr - (uint8_t *)sym->st_value) + 1;
424
425 #else
426 ASSERT(*instr == FBT_RET);
427 fbt->fbtp_rval = DTRACE_INVOP_RET;
428 fbt->fbtp_roffset =
429 (uintptr_t)(instr - (uint8_t *)sym->st_value);
430 #endif
431
432 fbt->fbtp_savedval = *instr;
433 fbt->fbtp_patchval = FBT_PATCHVAL;
434 fbt->fbtp_hashnext = fbt_probetab[FBT_ADDR2NDX(instr)];
435 fbt->fbtp_symndx = i;
436 fbt_probetab[FBT_ADDR2NDX(instr)] = fbt;
437
438 mp->fbt_nentries++;
439
440 instr += size;
441 goto again;
442 }
443 }
444
445 /*ARGSUSED*/
446 static void
447 fbt_destroy(void *arg, dtrace_id_t id, void *parg)
448 {
449 fbt_probe_t *fbt = parg, *next, *hash, *last;
450 struct modctl *ctl = fbt->fbtp_ctl;
451 int ndx;
452
453 do {
454 if (ctl != NULL && ctl->mod_loadcnt == fbt->fbtp_loadcnt) {
455 if ((ctl->mod_loadcnt == fbt->fbtp_loadcnt &&
456 ctl->mod_loaded)) {
457 ((struct module *)
458 (ctl->mod_mp))->fbt_nentries--;
459 }
460 }
461
462 /*
463 * Now we need to remove this probe from the fbt_probetab.
464 */
465 ndx = FBT_ADDR2NDX(fbt->fbtp_patchpoint);
466 last = NULL;
467 hash = fbt_probetab[ndx];
468
469 while (hash != fbt) {
470 ASSERT(hash != NULL);
471 last = hash;
472 hash = hash->fbtp_hashnext;
473 }
474
475 if (last != NULL) {
476 last->fbtp_hashnext = fbt->fbtp_hashnext;
477 } else {
478 fbt_probetab[ndx] = fbt->fbtp_hashnext;
479 }
480
481 next = fbt->fbtp_next;
482 kmem_free(fbt, sizeof (fbt_probe_t));
483
484 fbt = next;
485 } while (fbt != NULL);
486 }
487
488 /*ARGSUSED*/
489 static int
490 fbt_enable(void *arg, dtrace_id_t id, void *parg)
491 {
492 fbt_probe_t *fbt = parg;
493 struct modctl *ctl = fbt->fbtp_ctl;
494
495 ctl->mod_nenabled++;
496
497 if (!ctl->mod_loaded) {
498 if (fbt_verbose) {
499 cmn_err(CE_NOTE, "fbt is failing for probe %s "
500 "(module %s unloaded)",
501 fbt->fbtp_name, ctl->mod_modname);
502 }
503
504 return (0);
505 }
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->mod_loadcnt != fbt->fbtp_loadcnt) {
513 if (fbt_verbose) {
514 cmn_err(CE_NOTE, "fbt is failing for probe %s "
515 "(module %s reloaded)",
516 fbt->fbtp_name, ctl->mod_modname);
517 }
518
519 return (0);
520 }
521
522 for (; fbt != NULL; fbt = fbt->fbtp_next)
523 *fbt->fbtp_patchpoint = fbt->fbtp_patchval;
524
525 return (0);
526 }
527
528 /*ARGSUSED*/
529 static void
530 fbt_disable(void *arg, dtrace_id_t id, void *parg)
531 {
532 fbt_probe_t *fbt = parg;
533 struct modctl *ctl = fbt->fbtp_ctl;
534
535 ASSERT(ctl->mod_nenabled > 0);
536 ctl->mod_nenabled--;
537
538 if (!ctl->mod_loaded || (ctl->mod_loadcnt != fbt->fbtp_loadcnt))
539 return;
540
541 for (; fbt != NULL; fbt = fbt->fbtp_next)
542 *fbt->fbtp_patchpoint = fbt->fbtp_savedval;
543 }
544
545 /*ARGSUSED*/
546 static void
547 fbt_suspend(void *arg, dtrace_id_t id, void *parg)
548 {
549 fbt_probe_t *fbt = parg;
550 struct modctl *ctl = fbt->fbtp_ctl;
551
552 ASSERT(ctl->mod_nenabled > 0);
553
554 if (!ctl->mod_loaded || (ctl->mod_loadcnt != fbt->fbtp_loadcnt))
555 return;
556
557 for (; fbt != NULL; fbt = fbt->fbtp_next)
558 *fbt->fbtp_patchpoint = fbt->fbtp_savedval;
559 }
560
561 /*ARGSUSED*/
562 static void
563 fbt_resume(void *arg, dtrace_id_t id, void *parg)
564 {
565 fbt_probe_t *fbt = parg;
566 struct modctl *ctl = fbt->fbtp_ctl;
567
568 ASSERT(ctl->mod_nenabled > 0);
569
570 if (!ctl->mod_loaded || (ctl->mod_loadcnt != fbt->fbtp_loadcnt))
571 return;
572
573 for (; fbt != NULL; fbt = fbt->fbtp_next)
574 *fbt->fbtp_patchpoint = fbt->fbtp_patchval;
575 }
576
577 /*ARGSUSED*/
578 static void
579 fbt_getargdesc(void *arg, dtrace_id_t id, void *parg, dtrace_argdesc_t *desc)
580 {
581 fbt_probe_t *fbt = parg;
582 struct modctl *ctl = fbt->fbtp_ctl;
583 struct module *mp = ctl->mod_mp;
584 ctf_file_t *fp = NULL, *pfp;
585 ctf_funcinfo_t f;
586 int error;
587 ctf_id_t argv[32], type;
588 int argc = sizeof (argv) / sizeof (ctf_id_t);
589 const char *parent;
590
591 if (!ctl->mod_loaded || (ctl->mod_loadcnt != fbt->fbtp_loadcnt))
592 goto err;
593
594 if (fbt->fbtp_roffset != 0 && desc->dtargd_ndx == 0) {
595 (void) strcpy(desc->dtargd_native, "int");
596 return;
597 }
598
599 if ((fp = ctf_modopen(mp, &error)) == NULL) {
600 /*
601 * We have no CTF information for this module -- and therefore
602 * no args[] information.
603 */
604 goto err;
605 }
606
607 /*
608 * If we have a parent container, we must manually import it.
609 */
610 if ((parent = ctf_parent_name(fp)) != NULL) {
611 struct modctl *mp = &modules;
612 struct modctl *mod = NULL;
613
614 /*
615 * We must iterate over all modules to find the module that
616 * is our parent.
617 */
618 do {
619 if (strcmp(mp->mod_modname, parent) == 0) {
620 mod = mp;
621 break;
622 }
623 } while ((mp = mp->mod_next) != &modules);
624
625 if (mod == NULL)
626 goto err;
627
628 if ((pfp = ctf_modopen(mod->mod_mp, &error)) == NULL) {
629 goto err;
630 }
631
632 if (ctf_import(fp, pfp) != 0) {
633 ctf_close(pfp);
634 goto err;
635 }
636
637 ctf_close(pfp);
638 }
639
640 if (ctf_func_info(fp, fbt->fbtp_symndx, &f) == CTF_ERR)
641 goto err;
642
643 if (fbt->fbtp_roffset != 0) {
644 if (desc->dtargd_ndx > 1)
645 goto err;
646
647 ASSERT(desc->dtargd_ndx == 1);
648 type = f.ctc_return;
649 } else {
650 if (desc->dtargd_ndx + 1 > f.ctc_argc)
651 goto err;
652
653 if (ctf_func_args(fp, fbt->fbtp_symndx, argc, argv) == CTF_ERR)
654 goto err;
655
656 type = argv[desc->dtargd_ndx];
657 }
658
659 if (ctf_type_name(fp, type, desc->dtargd_native,
660 DTRACE_ARGTYPELEN) != NULL) {
661 ctf_close(fp);
662 return;
663 }
664 err:
665 if (fp != NULL)
666 ctf_close(fp);
667
668 desc->dtargd_ndx = DTRACE_ARGNONE;
669 }
670
671 static dtrace_pattr_t fbt_attr = {
672 { DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_ISA },
673 { DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN },
674 { DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN },
675 { DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_ISA },
676 { DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_ISA },
677 };
678
679 static dtrace_pops_t fbt_pops = {
680 NULL,
681 fbt_provide_module,
682 fbt_enable,
683 fbt_disable,
684 fbt_suspend,
685 fbt_resume,
686 fbt_getargdesc,
687 NULL,
688 NULL,
689 fbt_destroy
690 };
691
692 static void
693 fbt_cleanup(dev_info_t *devi)
694 {
695 dtrace_invop_remove(fbt_invop);
696 ddi_remove_minor_node(devi, NULL);
697 kmem_free(fbt_probetab, fbt_probetab_size * sizeof (fbt_probe_t *));
698 fbt_probetab = NULL;
699 fbt_probetab_mask = 0;
700 }
701
702 static int
703 fbt_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
704 {
705 switch (cmd) {
706 case DDI_ATTACH:
707 break;
708 case DDI_RESUME:
709 return (DDI_SUCCESS);
710 default:
711 return (DDI_FAILURE);
712 }
713
714 if (fbt_probetab_size == 0)
715 fbt_probetab_size = FBT_PROBETAB_SIZE;
716
717 fbt_probetab_mask = fbt_probetab_size - 1;
718 fbt_probetab =
719 kmem_zalloc(fbt_probetab_size * sizeof (fbt_probe_t *), KM_SLEEP);
720
721 dtrace_invop_add(fbt_invop);
722
723 if (ddi_create_minor_node(devi, "fbt", S_IFCHR, 0,
724 DDI_PSEUDO, NULL) == DDI_FAILURE ||
725 dtrace_register("fbt", &fbt_attr, DTRACE_PRIV_KERNEL, NULL,
726 &fbt_pops, NULL, &fbt_id) != 0) {
727 fbt_cleanup(devi);
728 return (DDI_FAILURE);
729 }
730
731 ddi_report_dev(devi);
732 fbt_devi = devi;
733
734 return (DDI_SUCCESS);
735 }
736
737 static int
738 fbt_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
739 {
740 switch (cmd) {
741 case DDI_DETACH:
742 break;
743 case DDI_SUSPEND:
744 return (DDI_SUCCESS);
745 default:
746 return (DDI_FAILURE);
747 }
748
749 if (dtrace_unregister(fbt_id) != 0)
750 return (DDI_FAILURE);
751
752 fbt_cleanup(devi);
753
754 return (DDI_SUCCESS);
755 }
756
757 /*ARGSUSED*/
758 static int
759 fbt_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
760 {
761 int error;
762
763 switch (infocmd) {
764 case DDI_INFO_DEVT2DEVINFO:
765 *result = (void *)fbt_devi;
766 error = DDI_SUCCESS;
767 break;
768 case DDI_INFO_DEVT2INSTANCE:
769 *result = (void *)0;
770 error = DDI_SUCCESS;
771 break;
772 default:
773 error = DDI_FAILURE;
774 }
775 return (error);
776 }
777
778 /*ARGSUSED*/
779 static int
780 fbt_open(dev_t *devp, int flag, int otyp, cred_t *cred_p)
781 {
782 return (0);
783 }
784
785 static struct cb_ops fbt_cb_ops = {
786 fbt_open, /* open */
787 nodev, /* close */
788 nulldev, /* strategy */
789 nulldev, /* print */
790 nodev, /* dump */
791 nodev, /* read */
792 nodev, /* write */
793 nodev, /* ioctl */
794 nodev, /* devmap */
795 nodev, /* mmap */
796 nodev, /* segmap */
797 nochpoll, /* poll */
798 ddi_prop_op, /* cb_prop_op */
799 0, /* streamtab */
800 D_NEW | D_MP /* Driver compatibility flag */
801 };
802
803 static struct dev_ops fbt_ops = {
804 DEVO_REV, /* devo_rev */
805 0, /* refcnt */
806 fbt_info, /* get_dev_info */
807 nulldev, /* identify */
808 nulldev, /* probe */
809 fbt_attach, /* attach */
810 fbt_detach, /* detach */
811 nodev, /* reset */
812 &fbt_cb_ops, /* driver operations */
813 NULL, /* bus operations */
814 nodev, /* dev power */
815 ddi_quiesce_not_needed, /* quiesce */
816 };
817
818 /*
819 * Module linkage information for the kernel.
820 */
821 static struct modldrv modldrv = {
822 &mod_driverops, /* module type (this is a pseudo driver) */
823 "Function Boundary Tracing", /* name of module */
824 &fbt_ops, /* driver ops */
825 };
826
827 static struct modlinkage modlinkage = {
828 MODREV_1,
829 { (void *)&modldrv, NULL }
830 };
831
832 int
833 _init(void)
834 {
835 return (mod_install(&modlinkage));
836 }
837
838 int
839 _info(struct modinfo *modinfop)
840 {
841 return (mod_info(&modlinkage, modinfop));
842 }
843
844 int
845 _fini(void)
846 {
847 return (mod_remove(&modlinkage));
848 }