[apple/xnu.git] / bsd / dev / dtrace / dtrace_subr.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * #pragma ident	"@(#)dtrace_subr.c	1.8	07/06/05 SMI"
 */

#include <stdarg.h>
#include <string.h>
#include <sys/malloc.h>
#include <sys/time.h>
#include <sys/dtrace.h>
#include <sys/dtrace_impl.h>
#include <kern/debug.h>

#if defined(__APPLE__)
/* Solaris proc_t is the struct. Darwin's proc_t is a pointer to it. */
#define proc_t struct proc /* Steer clear of the Darwin typedef for proc_t */
#endif

/* Copied from an arch specific dtrace_subr.c. */
int (*dtrace_fasttrap_probe_ptr)(struct regs *);

/*
 * Following DTrace hooks are taken from Solaris' dtrace_subr.c
 * They're assigned in dtrace.c but Darwin never calls them.
 */
void (*dtrace_cpu_init)(processorid_t);
#if !defined(__APPLE__)
void (*dtrace_modload)(struct modctl *);
void (*dtrace_modunload)(struct modctl *);
#else
int (*dtrace_modload)(struct kmod_info *, uint32_t);
int (*dtrace_modunload)(struct kmod_info *);
void (*dtrace_helpers_cleanup)(proc_t *);
#endif  /*__APPLE__*/
void (*dtrace_helpers_fork)(proc_t *, proc_t *);
void (*dtrace_cpustart_init)(void);
void (*dtrace_cpustart_fini)(void);

void (*dtrace_debugger_init)(void);
void (*dtrace_debugger_fini)(void);

dtrace_vtime_state_t dtrace_vtime_active = 0;
dtrace_cacheid_t dtrace_predcache_id = DTRACE_CACHEIDNONE + 1;

void (*dtrace_fasttrap_fork_ptr)(proc_t *, proc_t *);
void (*dtrace_fasttrap_exec_ptr)(proc_t *);
void (*dtrace_fasttrap_exit_ptr)(proc_t *);

/*
 * This function is called by cfork() in the event that it appears that
 * there may be dtrace tracepoints active in the parent process's address
 * space. This first confirms the existence of dtrace tracepoints in the
 * parent process and calls into the fasttrap module to remove the
 * corresponding tracepoints from the child. By knowing that there are
 * existing tracepoints, and ensuring they can't be removed, we can rely
 * on the fasttrap module remaining loaded.
 */
void
dtrace_fasttrap_fork(proc_t *p, proc_t *cp)
{
#if !defined(__APPLE__)
	ASSERT(p->p_proc_flag & P_PR_LOCK);
	ASSERT(p->p_dtrace_count > 0);
#endif /* __APPLE__ */

	if (dtrace_fasttrap_fork_ptr) {
		(*dtrace_fasttrap_fork_ptr)(p, cp);
	}
}

typedef struct dtrace_invop_hdlr {
	int (*dtih_func)(uintptr_t, uintptr_t *, uintptr_t);
	struct dtrace_invop_hdlr *dtih_next;
} dtrace_invop_hdlr_t;

dtrace_invop_hdlr_t *dtrace_invop_hdlr;

int
dtrace_invop(uintptr_t, uintptr_t *, uintptr_t);

int
dtrace_invop(uintptr_t addr, uintptr_t *stack, uintptr_t eax)
{
	dtrace_invop_hdlr_t *hdlr;
	int rval;

	for (hdlr = dtrace_invop_hdlr; hdlr != NULL; hdlr = hdlr->dtih_next) {
		if ((rval = hdlr->dtih_func(addr, stack, eax)) != 0)
			return (rval);
	}

	return (0);
}

void
dtrace_invop_add(int (*func)(uintptr_t, uintptr_t *, uintptr_t))
{
	dtrace_invop_hdlr_t *hdlr;

	hdlr = kmem_alloc(sizeof (dtrace_invop_hdlr_t), KM_SLEEP);
	hdlr->dtih_func = func;
	hdlr->dtih_next = dtrace_invop_hdlr;
	dtrace_invop_hdlr = hdlr;
}

void
dtrace_invop_remove(int (*func)(uintptr_t, uintptr_t *, uintptr_t))
{
	dtrace_invop_hdlr_t *hdlr = dtrace_invop_hdlr, *prev = NULL;

	for (;;) {
		if (hdlr == NULL)
			panic("attempt to remove non-existent invop handler");

		if (hdlr->dtih_func == func)
			break;

		prev = hdlr;
		hdlr = hdlr->dtih_next;
	}

	if (prev == NULL) {
		ASSERT(dtrace_invop_hdlr == hdlr);
		dtrace_invop_hdlr = hdlr->dtih_next;
	} else {
		ASSERT(dtrace_invop_hdlr != hdlr);
		prev->dtih_next = hdlr->dtih_next;
	}

	kmem_free(hdlr, sizeof (dtrace_invop_hdlr_t));
}
Commit	Line	Data
2d21ac55 A	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	/*
b0d623f7	23	* Copyright 2007 Sun Microsystems, Inc. All rights reserved.
2d21ac55 A	24	* Use is subject to license terms.
	25	*/
	26
	27	/*
b0d623f7	28	* #pragma ident "@(#)dtrace_subr.c 1.8 07/06/05 SMI"
2d21ac55 A	29	*/
	30
	31	#include <stdarg.h>
	32	#include <string.h>
	33	#include <sys/malloc.h>
	34	#include <sys/time.h>
	35	#include <sys/dtrace.h>
	36	#include <sys/dtrace_impl.h>
	37	#include <kern/debug.h>
	38
	39	#if defined(__APPLE__)
b0d623f7 A	40	/* Solaris proc_t is the struct. Darwin's proc_t is a pointer to it. */
b0d623f7 A	41	#define proc_t struct proc /* Steer clear of the Darwin typedef for proc_t */
2d21ac55 A	42	#endif
	43
	44	/* Copied from an arch specific dtrace_subr.c. */
	45	int (dtrace_fasttrap_probe_ptr)(struct regs );
	46
	47	/*
	48	* Following DTrace hooks are taken from Solaris' dtrace_subr.c
	49	* They're assigned in dtrace.c but Darwin never calls them.
	50	*/
	51	void (*dtrace_cpu_init)(processorid_t);
6d2010ae	52	#if !defined(__APPLE__)
2d21ac55 A	53	void (dtrace_modload)(struct modctl );
2d21ac55 A	54	void (dtrace_modunload)(struct modctl );
6d2010ae	55	#else
316670eb	56	int (dtrace_modload)(struct kmod_info , uint32_t);
6d2010ae	57	int (dtrace_modunload)(struct kmod_info );
2d21ac55	58	void (dtrace_helpers_cleanup)(proc_t );
6d2010ae	59	#endif /__APPLE__/
2d21ac55 A	60	void (dtrace_helpers_fork)(proc_t , proc_t *);
	61	void (*dtrace_cpustart_init)(void);
	62	void (*dtrace_cpustart_fini)(void);
	63
2d21ac55 A	64	void (*dtrace_debugger_init)(void);
	65	void (*dtrace_debugger_fini)(void);
	66
	67	dtrace_vtime_state_t dtrace_vtime_active = 0;
	68	dtrace_cacheid_t dtrace_predcache_id = DTRACE_CACHEIDNONE + 1;
	69
	70	void (dtrace_fasttrap_fork_ptr)(proc_t , proc_t *);
	71	void (dtrace_fasttrap_exec_ptr)(proc_t );
	72	void (dtrace_fasttrap_exit_ptr)(proc_t );
	73
	74	/*
	75	* This function is called by cfork() in the event that it appears that
	76	* there may be dtrace tracepoints active in the parent process's address
	77	* space. This first confirms the existence of dtrace tracepoints in the
	78	* parent process and calls into the fasttrap module to remove the
	79	* corresponding tracepoints from the child. By knowing that there are
	80	* existing tracepoints, and ensuring they can't be removed, we can rely
	81	* on the fasttrap module remaining loaded.
	82	*/
	83	void
	84	dtrace_fasttrap_fork(proc_t p, proc_t cp)
	85	{
	86	#if !defined(__APPLE__)
	87	ASSERT(p->p_proc_flag & P_PR_LOCK);
	88	ASSERT(p->p_dtrace_count > 0);
	89	#endif /* __APPLE__ */
	90
	91	if (dtrace_fasttrap_fork_ptr) {
	92	(*dtrace_fasttrap_fork_ptr)(p, cp);
	93	}
	94	}
	95
	96	typedef struct dtrace_invop_hdlr {
	97	int (dtih_func)(uintptr_t, uintptr_t , uintptr_t);
	98	struct dtrace_invop_hdlr *dtih_next;
	99	} dtrace_invop_hdlr_t;
	100
	101	dtrace_invop_hdlr_t *dtrace_invop_hdlr;
	102
	103	int
	104	dtrace_invop(uintptr_t, uintptr_t *, uintptr_t);
	105
	106	int
	107	dtrace_invop(uintptr_t addr, uintptr_t *stack, uintptr_t eax)
	108	{
	109	dtrace_invop_hdlr_t *hdlr;
	110	int rval;
	111
	112	for (hdlr = dtrace_invop_hdlr; hdlr != NULL; hdlr = hdlr->dtih_next) {
	113	if ((rval = hdlr->dtih_func(addr, stack, eax)) != 0)
	114	return (rval);
	115	}
	116
	117	return (0);
	118	}
	119
	120	void
	121	dtrace_invop_add(int (func)(uintptr_t, uintptr_t , uintptr_t))
	122	{
	123	dtrace_invop_hdlr_t *hdlr;
	124
	125	hdlr = kmem_alloc(sizeof (dtrace_invop_hdlr_t), KM_SLEEP);
	126	hdlr->dtih_func = func;
	127	hdlr->dtih_next = dtrace_invop_hdlr;
128	dtrace_invop_hdlr = hdlr;
129	}
130
131	void
132	dtrace_invop_remove(int (func)(uintptr_t, uintptr_t , uintptr_t))
133	{
134	dtrace_invop_hdlr_t hdlr = dtrace_invop_hdlr, prev = NULL;
135
136	for (;;) {
137	if (hdlr == NULL)
138	panic("attempt to remove non-existent invop handler");
139
140	if (hdlr->dtih_func == func)
141	break;
142
143	prev = hdlr;
144	hdlr = hdlr->dtih_next;
145	}
146
147	if (prev == NULL) {
148	ASSERT(dtrace_invop_hdlr == hdlr);
149	dtrace_invop_hdlr = hdlr->dtih_next;
150	} else {
151	ASSERT(dtrace_invop_hdlr != hdlr);
152	prev->dtih_next = hdlr->dtih_next;
153	}
154
155	kmem_free(hdlr, sizeof (dtrace_invop_hdlr_t));
156	}
157