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