d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
6b1b791da6
freebsd-dev/sys/kern/kern_sdt.c

340 lines
8.1 KiB
C
Raw Normal View History

Add kernel support for the Statically Defined Trace provider. This is BSD licensed code written specifically for FreeBSD. It initialises using SYSINIT so that the SDT provider, probe and argument description linkage is done whenever a module is loaded, regardless of whether the DTrace modules are loaded or not. This file is optionally compiled into the kernel if the KDTRACE_HOOKS option is defined.
2008-05-18 19:32:36 +00:00
/*-
* Copyright 2006-2008 John Birrell <jb@FreeBSD.org>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*
* Backend for the Statically Defined Tracing (SDT) kernel support. This is
* required to allow a module to load even though DTrace kernel support may
* not be present. A module may be built with SDT probes in it which are
* registered and deregistered via SYSINIT/SYSUNINIT.
*
*/
#include "opt_kdtrace.h"
#include <sys/cdefs.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/linker.h>
#include <sys/lock.h>
#include <sys/proc.h>
#include <sys/sx.h>
#include <sys/sdt.h>
/*
* This is the list of statically defined tracing providers.
*/
static TAILQ_HEAD(sdt_provider_list_head, sdt_provider) sdt_provider_list;
/*
* Mutex to serialise access to the SDT provider list.
*/
static struct sx sdt_sx;
/*
* Hook for the DTrace probe function. The 'sdt' provider will set this
* to dtrace_probe when it loads.
*/
sdt_probe_func_t sdt_probe_func = sdt_probe_stub;
Instead of only iterating over the set of known SDT probes when sdt.ko is loaded and unloaded, also have sdt.ko register callbacks with kern_sdt.c that will be called when a newly loaded KLD module adds more probes or a module with probes is unloaded. This fixes two issues: first, if a module with SDT probes was loaded after sdt.ko was loaded, those new probes would not be available in DTrace. Second, if a module with SDT probes was unloaded while sdt.ko was loaded, the kernel would panic the next time DTrace had cause to try and do anything with the no-longer-existent probes. This makes it possible to create SDT probes in KLD modules, although there are still two caveats: first, any SDT probes in a KLD module must be part of a DTrace provider that is defined in that module. At present DTrace only destroys probes when the provider is destroyed, so you can still panic the system if a KLD module creates new probes in a provider from a different module(including the kernel) and then unload the the first module. Second, the system will panic if you unload a module containing SDT probes while there is an active D script that has enabled those probes. MFC after: 1 month
2012-03-27 15:07:43 +00:00
static sdt_provider_listall_func_t sdt_provider_register_func = NULL;
static sdt_provider_listall_func_t sdt_provider_deregister_func = NULL;
static sdt_probe_listall_func_t sdt_probe_register_func = NULL;
static void *sdt_provider_register_arg;
static void *sdt_provider_deregister_arg;
static void *sdt_probe_register_arg;
static int sdt_provider_listall_locked(sdt_provider_listall_func_t, void *);
Add kernel support for the Statically Defined Trace provider. This is BSD licensed code written specifically for FreeBSD. It initialises using SYSINIT so that the SDT provider, probe and argument description linkage is done whenever a module is loaded, regardless of whether the DTrace modules are loaded or not. This file is optionally compiled into the kernel if the KDTRACE_HOOKS option is defined.
2008-05-18 19:32:36 +00:00
/*
* This is a stub for probe calls in case kernel DTrace support isn't
* compiled in. It should never get called because there is no DTrace
* support to enable it.
*/
void
Use ISO C99 integer types in sys/kern where possible. There are only about 100 occurences of the BSD-specific u_int*_t datatypes in sys/kern. The ISO C99 integer types are used here more often.
2010-06-21 09:55:56 +00:00
sdt_probe_stub(uint32_t id, uintptr_t arg0, uintptr_t arg1,
Add kernel support for the Statically Defined Trace provider. This is BSD licensed code written specifically for FreeBSD. It initialises using SYSINIT so that the SDT provider, probe and argument description linkage is done whenever a module is loaded, regardless of whether the DTrace modules are loaded or not. This file is optionally compiled into the kernel if the KDTRACE_HOOKS option is defined.
2008-05-18 19:32:36 +00:00
uintptr_t arg2, uintptr_t arg3, uintptr_t arg4)
{
printf("sdt_probe_stub: Why did this get called?\n");
}
/*
* Called from SYSINIT to register a provider.
*/
void
sdt_provider_register(void *arg)
{
struct sdt_provider *prov = arg;
sx_xlock(&sdt_sx);
TAILQ_INSERT_TAIL(&sdt_provider_list, prov, prov_entry);
TAILQ_INIT(&prov->probe_list);
Instead of only iterating over the set of known SDT probes when sdt.ko is loaded and unloaded, also have sdt.ko register callbacks with kern_sdt.c that will be called when a newly loaded KLD module adds more probes or a module with probes is unloaded. This fixes two issues: first, if a module with SDT probes was loaded after sdt.ko was loaded, those new probes would not be available in DTrace. Second, if a module with SDT probes was unloaded while sdt.ko was loaded, the kernel would panic the next time DTrace had cause to try and do anything with the no-longer-existent probes. This makes it possible to create SDT probes in KLD modules, although there are still two caveats: first, any SDT probes in a KLD module must be part of a DTrace provider that is defined in that module. At present DTrace only destroys probes when the provider is destroyed, so you can still panic the system if a KLD module creates new probes in a provider from a different module(including the kernel) and then unload the the first module. Second, the system will panic if you unload a module containing SDT probes while there is an active D script that has enabled those probes. MFC after: 1 month
2012-03-27 15:07:43 +00:00
if (sdt_provider_register_func != NULL)
sdt_provider_register_func(prov, sdt_provider_register_arg);
Add kernel support for the Statically Defined Trace provider. This is BSD licensed code written specifically for FreeBSD. It initialises using SYSINIT so that the SDT provider, probe and argument description linkage is done whenever a module is loaded, regardless of whether the DTrace modules are loaded or not. This file is optionally compiled into the kernel if the KDTRACE_HOOKS option is defined.
2008-05-18 19:32:36 +00:00
sx_xunlock(&sdt_sx);
}
/*
* Called from SYSUNINIT to de-register a provider.
*/
void
sdt_provider_deregister(void *arg)
{
struct sdt_provider *prov = arg;
sx_xlock(&sdt_sx);
TAILQ_REMOVE(&sdt_provider_list, prov, prov_entry);
Instead of only iterating over the set of known SDT probes when sdt.ko is loaded and unloaded, also have sdt.ko register callbacks with kern_sdt.c that will be called when a newly loaded KLD module adds more probes or a module with probes is unloaded. This fixes two issues: first, if a module with SDT probes was loaded after sdt.ko was loaded, those new probes would not be available in DTrace. Second, if a module with SDT probes was unloaded while sdt.ko was loaded, the kernel would panic the next time DTrace had cause to try and do anything with the no-longer-existent probes. This makes it possible to create SDT probes in KLD modules, although there are still two caveats: first, any SDT probes in a KLD module must be part of a DTrace provider that is defined in that module. At present DTrace only destroys probes when the provider is destroyed, so you can still panic the system if a KLD module creates new probes in a provider from a different module(including the kernel) and then unload the the first module. Second, the system will panic if you unload a module containing SDT probes while there is an active D script that has enabled those probes. MFC after: 1 month
2012-03-27 15:07:43 +00:00
if (sdt_provider_deregister_func != NULL)
sdt_provider_deregister_func(prov, sdt_provider_deregister_arg);
Add kernel support for the Statically Defined Trace provider. This is BSD licensed code written specifically for FreeBSD. It initialises using SYSINIT so that the SDT provider, probe and argument description linkage is done whenever a module is loaded, regardless of whether the DTrace modules are loaded or not. This file is optionally compiled into the kernel if the KDTRACE_HOOKS option is defined.
2008-05-18 19:32:36 +00:00
sx_xunlock(&sdt_sx);
}
/*
* Called from SYSINIT to register a statically defined trace probe.
*/
void
sdt_probe_register(void *arg)
{
struct sdt_probe *probe = arg;
/*
* Check the reference structure version. Only version 1 is
* supported at the moment.
*/
if (probe->version != sizeof(struct sdt_probe)) {
printf("%s:%s:%s has version %d when %d required\n", probe->mod, probe->func, probe->name, probe->version, (int) sizeof(struct sdt_probe));
return;
}
sx_xlock(&sdt_sx);
TAILQ_INSERT_TAIL(&probe->prov->probe_list, probe, probe_entry);
TAILQ_INIT(&probe->argtype_list);
probe->state = SDT_INIT;
Instead of only iterating over the set of known SDT probes when sdt.ko is loaded and unloaded, also have sdt.ko register callbacks with kern_sdt.c that will be called when a newly loaded KLD module adds more probes or a module with probes is unloaded. This fixes two issues: first, if a module with SDT probes was loaded after sdt.ko was loaded, those new probes would not be available in DTrace. Second, if a module with SDT probes was unloaded while sdt.ko was loaded, the kernel would panic the next time DTrace had cause to try and do anything with the no-longer-existent probes. This makes it possible to create SDT probes in KLD modules, although there are still two caveats: first, any SDT probes in a KLD module must be part of a DTrace provider that is defined in that module. At present DTrace only destroys probes when the provider is destroyed, so you can still panic the system if a KLD module creates new probes in a provider from a different module(including the kernel) and then unload the the first module. Second, the system will panic if you unload a module containing SDT probes while there is an active D script that has enabled those probes. MFC after: 1 month
2012-03-27 15:07:43 +00:00
if (sdt_probe_register_func != NULL)
sdt_probe_register_func(probe, sdt_provider_register_arg);
Add kernel support for the Statically Defined Trace provider. This is BSD licensed code written specifically for FreeBSD. It initialises using SYSINIT so that the SDT provider, probe and argument description linkage is done whenever a module is loaded, regardless of whether the DTrace modules are loaded or not. This file is optionally compiled into the kernel if the KDTRACE_HOOKS option is defined.
2008-05-18 19:32:36 +00:00
sx_xunlock(&sdt_sx);
}
/*
* Called from SYSUNINIT to de-register a statically defined trace probe.
*/
void
sdt_probe_deregister(void *arg)
{
struct sdt_probe *probe = arg;
sx_xlock(&sdt_sx);
if (probe->state == SDT_INIT) {
TAILQ_REMOVE(&probe->prov->probe_list, probe, probe_entry);
probe->state = SDT_UNINIT;
}
sx_xunlock(&sdt_sx);
}
/*
* Called from SYSINIT to register a statically defined trace probe argument.
*/
void
sdt_argtype_register(void *arg)
{
struct sdt_argtype *argtype = arg;
sx_xlock(&sdt_sx);
TAILQ_INSERT_TAIL(&argtype->probe->argtype_list, argtype, argtype_entry);
argtype->probe->n_args++;
sx_xunlock(&sdt_sx);
}
/*
* Called from SYSUNINIT to de-register a statically defined trace probe argument.
*/
void
sdt_argtype_deregister(void *arg)
{
struct sdt_argtype *argtype = arg;
sx_xlock(&sdt_sx);
TAILQ_REMOVE(&argtype->probe->argtype_list, argtype, argtype_entry);
sx_xunlock(&sdt_sx);
}
static void
sdt_init(void *arg)
{
sx_init_flags(&sdt_sx, "Statically Defined Tracing", SX_NOWITNESS);
TAILQ_INIT(&sdt_provider_list);
}
SYSINIT(sdt, SI_SUB_KDTRACE, SI_ORDER_FIRST, sdt_init, NULL);
static void
sdt_uninit(void *arg)
{
sx_destroy(&sdt_sx);
}
SYSUNINIT(sdt, SI_SUB_KDTRACE, SI_ORDER_FIRST, sdt_uninit, NULL);
/*
* List statically defined tracing providers.
*/
int
Instead of only iterating over the set of known SDT probes when sdt.ko is loaded and unloaded, also have sdt.ko register callbacks with kern_sdt.c that will be called when a newly loaded KLD module adds more probes or a module with probes is unloaded. This fixes two issues: first, if a module with SDT probes was loaded after sdt.ko was loaded, those new probes would not be available in DTrace. Second, if a module with SDT probes was unloaded while sdt.ko was loaded, the kernel would panic the next time DTrace had cause to try and do anything with the no-longer-existent probes. This makes it possible to create SDT probes in KLD modules, although there are still two caveats: first, any SDT probes in a KLD module must be part of a DTrace provider that is defined in that module. At present DTrace only destroys probes when the provider is destroyed, so you can still panic the system if a KLD module creates new probes in a provider from a different module(including the kernel) and then unload the the first module. Second, the system will panic if you unload a module containing SDT probes while there is an active D script that has enabled those probes. MFC after: 1 month
2012-03-27 15:07:43 +00:00
sdt_provider_listall(sdt_provider_listall_func_t callback_func, void *arg)
{
int error;
sx_xlock(&sdt_sx);
error = sdt_provider_listall_locked(callback_func, arg);
sx_xunlock(&sdt_sx);
return (error);
}
static int
sdt_provider_listall_locked(sdt_provider_listall_func_t callback_func,
void *arg)
Add kernel support for the Statically Defined Trace provider. This is BSD licensed code written specifically for FreeBSD. It initialises using SYSINIT so that the SDT provider, probe and argument description linkage is done whenever a module is loaded, regardless of whether the DTrace modules are loaded or not. This file is optionally compiled into the kernel if the KDTRACE_HOOKS option is defined.
2008-05-18 19:32:36 +00:00
{
int error = 0;
struct sdt_provider *prov;
Instead of only iterating over the set of known SDT probes when sdt.ko is loaded and unloaded, also have sdt.ko register callbacks with kern_sdt.c that will be called when a newly loaded KLD module adds more probes or a module with probes is unloaded. This fixes two issues: first, if a module with SDT probes was loaded after sdt.ko was loaded, those new probes would not be available in DTrace. Second, if a module with SDT probes was unloaded while sdt.ko was loaded, the kernel would panic the next time DTrace had cause to try and do anything with the no-longer-existent probes. This makes it possible to create SDT probes in KLD modules, although there are still two caveats: first, any SDT probes in a KLD module must be part of a DTrace provider that is defined in that module. At present DTrace only destroys probes when the provider is destroyed, so you can still panic the system if a KLD module creates new probes in a provider from a different module(including the kernel) and then unload the the first module. Second, the system will panic if you unload a module containing SDT probes while there is an active D script that has enabled those probes. MFC after: 1 month
2012-03-27 15:07:43 +00:00
sx_assert(&sdt_sx, SX_XLOCKED);
Add kernel support for the Statically Defined Trace provider. This is BSD licensed code written specifically for FreeBSD. It initialises using SYSINIT so that the SDT provider, probe and argument description linkage is done whenever a module is loaded, regardless of whether the DTrace modules are loaded or not. This file is optionally compiled into the kernel if the KDTRACE_HOOKS option is defined.
2008-05-18 19:32:36 +00:00
TAILQ_FOREACH(prov, &sdt_provider_list, prov_entry) {
if ((error = callback_func(prov, arg)) != 0)
break;
}
return (error);
}
/*
* List statically defined tracing probes.
*/
int
sdt_probe_listall(struct sdt_provider *prov,
sdt_probe_listall_func_t callback_func,void *arg)
{
int error = 0;
int locked;
struct sdt_probe *probe;
locked = sx_xlocked(&sdt_sx);
if (!locked)
sx_xlock(&sdt_sx);
TAILQ_FOREACH(probe, &prov->probe_list, probe_entry) {
if ((error = callback_func(probe, arg)) != 0)
break;
}
if (!locked)
sx_xunlock(&sdt_sx);
return (error);
}
/*
* List statically defined tracing probe arguments.
*/
int
sdt_argtype_listall(struct sdt_probe *probe,
sdt_argtype_listall_func_t callback_func,void *arg)
{
int error = 0;
int locked;
struct sdt_argtype *argtype;
locked = sx_xlocked(&sdt_sx);
if (!locked)
sx_xlock(&sdt_sx);
TAILQ_FOREACH(argtype, &probe->argtype_list, argtype_entry) {
if ((error = callback_func(argtype, arg)) != 0)
break;
}
if (!locked)
sx_xunlock(&sdt_sx);
return (error);
}
Instead of only iterating over the set of known SDT probes when sdt.ko is loaded and unloaded, also have sdt.ko register callbacks with kern_sdt.c that will be called when a newly loaded KLD module adds more probes or a module with probes is unloaded. This fixes two issues: first, if a module with SDT probes was loaded after sdt.ko was loaded, those new probes would not be available in DTrace. Second, if a module with SDT probes was unloaded while sdt.ko was loaded, the kernel would panic the next time DTrace had cause to try and do anything with the no-longer-existent probes. This makes it possible to create SDT probes in KLD modules, although there are still two caveats: first, any SDT probes in a KLD module must be part of a DTrace provider that is defined in that module. At present DTrace only destroys probes when the provider is destroyed, so you can still panic the system if a KLD module creates new probes in a provider from a different module(including the kernel) and then unload the the first module. Second, the system will panic if you unload a module containing SDT probes while there is an active D script that has enabled those probes. MFC after: 1 month
2012-03-27 15:07:43 +00:00
void sdt_register_callbacks(sdt_provider_listall_func_t register_prov,
void *reg_prov_arg, sdt_provider_listall_func_t deregister_prov,
void *dereg_prov_arg, sdt_probe_listall_func_t register_probe,
void * reg_probe_arg)
{
sx_xlock(&sdt_sx);
sdt_provider_register_func = register_prov;
sdt_provider_deregister_func = deregister_prov;
sdt_probe_register_func = register_probe;
sdt_provider_register_arg = reg_prov_arg;
sdt_provider_deregister_arg = dereg_prov_arg;
sdt_probe_register_arg = reg_probe_arg;
sdt_provider_listall_locked(register_prov, reg_prov_arg);
sx_xunlock(&sdt_sx);
}
void sdt_deregister_callbacks(void)
{
sx_xlock(&sdt_sx);
sdt_provider_listall_locked(sdt_provider_deregister_func,
sdt_provider_deregister_arg);
sdt_provider_register_func = NULL;
sdt_provider_deregister_func = NULL;
sdt_probe_register_func = NULL;
sdt_provider_register_arg = NULL;
sdt_provider_deregister_arg = NULL;
sdt_probe_register_arg = NULL;
sx_xunlock(&sdt_sx);
}
Reference in New Issue Copy Permalink