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
58typedef 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
74static dev_info_t		*fbt_devi;
75static dtrace_provider_id_t	fbt_id;
76static fbt_probe_t		**fbt_probetab;
77static int			fbt_probetab_size;
78static int			fbt_probetab_mask;
79static int			fbt_verbose = 0;
80
81static int
82fbt_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*/
148static void
149fbt_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;
335again:
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*/
446static void
447fbt_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*/
489static int
490fbt_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*/
529static void
530fbt_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*/
546static void
547fbt_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*/
562static void
563fbt_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*/
578static void
579fbt_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	}
664err:
665	if (fp != NULL)
666		ctf_close(fp);
667
668	desc->dtargd_ndx = DTRACE_ARGNONE;
669}
670
671static 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
679static 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
692static void
693fbt_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
702static int
703fbt_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
737static int
738fbt_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*/
758static int
759fbt_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*/
779static int
780fbt_open(dev_t *devp, int flag, int otyp, cred_t *cred_p)
781{
782	return (0);
783}
784
785static 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
803static 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 */
821static 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
827static struct modlinkage modlinkage = {
828	MODREV_1,
829	(void *)&modldrv,
830	NULL
831};
832
833int
834_init(void)
835{
836	return (mod_install(&modlinkage));
837}
838
839int
840_info(struct modinfo *modinfop)
841{
842	return (mod_info(&modlinkage, modinfop));
843}
844
845int
846_fini(void)
847{
848	return (mod_remove(&modlinkage));
849}
850