tracing: Remove markers
Now that the last users of markers have migrated to the event tracer we can kill off the (now orphan) support code. Signed-off-by: Christoph Hellwig <hch@lst.de> Acked-by: Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca> Cc: Steven Rostedt <rostedt@goodmis.org> Cc: Frederic Weisbecker <fweisbec@gmail.com> LKML-Reference: <20090917173527.GA1699@lst.de> Signed-off-by: Ingo Molnar <mingo@elte.hu>
This commit is contained in:
Christoph Hellwig
Ingo Molnar
parent
df58bee21e
commit
fc5377668c
17 changed files with 1 additions and 1464 deletions
|
|
@ -1,104 +0,0 @@
|
||||||
Using the Linux Kernel Markers
|
|
||||||
|
|
||||||
Mathieu Desnoyers
|
|
||||||
|
|
||||||
|
|
||||||
This document introduces Linux Kernel Markers and their use. It provides
|
|
||||||
examples of how to insert markers in the kernel and connect probe functions to
|
|
||||||
them and provides some examples of probe functions.
|
|
||||||
|
|
||||||
|
|
||||||
* Purpose of markers
|
|
||||||
|
|
||||||
A marker placed in code provides a hook to call a function (probe) that you can
|
|
||||||
provide at runtime. A marker can be "on" (a probe is connected to it) or "off"
|
|
||||||
(no probe is attached). When a marker is "off" it has no effect, except for
|
|
||||||
adding a tiny time penalty (checking a condition for a branch) and space
|
|
||||||
penalty (adding a few bytes for the function call at the end of the
|
|
||||||
instrumented function and adds a data structure in a separate section). When a
|
|
||||||
marker is "on", the function you provide is called each time the marker is
|
|
||||||
executed, in the execution context of the caller. When the function provided
|
|
||||||
ends its execution, it returns to the caller (continuing from the marker site).
|
|
||||||
|
|
||||||
You can put markers at important locations in the code. Markers are
|
|
||||||
lightweight hooks that can pass an arbitrary number of parameters,
|
|
||||||
described in a printk-like format string, to the attached probe function.
|
|
||||||
|
|
||||||
They can be used for tracing and performance accounting.
|
|
||||||
|
|
||||||
|
|
||||||
* Usage
|
|
||||||
|
|
||||||
In order to use the macro trace_mark, you should include linux/marker.h.
|
|
||||||
|
|
||||||
#include <linux/marker.h>
|
|
||||||
|
|
||||||
And,
|
|
||||||
|
|
||||||
trace_mark(subsystem_event, "myint %d mystring %s", someint, somestring);
|
|
||||||
Where :
|
|
||||||
- subsystem_event is an identifier unique to your event
|
|
||||||
- subsystem is the name of your subsystem.
|
|
||||||
- event is the name of the event to mark.
|
|
||||||
- "myint %d mystring %s" is the formatted string for the serializer. "myint" and
|
|
||||||
"mystring" are repectively the field names associated with the first and
|
|
||||||
second parameter.
|
|
||||||
- someint is an integer.
|
|
||||||
- somestring is a char pointer.
|
|
||||||
|
|
||||||
Connecting a function (probe) to a marker is done by providing a probe (function
|
|
||||||
to call) for the specific marker through marker_probe_register() and can be
|
|
||||||
activated by calling marker_arm(). Marker deactivation can be done by calling
|
|
||||||
marker_disarm() as many times as marker_arm() has been called. Removing a probe
|
|
||||||
is done through marker_probe_unregister(); it will disarm the probe.
|
|
||||||
|
|
||||||
marker_synchronize_unregister() must be called between probe unregistration and
|
|
||||||
the first occurrence of
|
|
||||||
- the end of module exit function,
|
|
||||||
to make sure there is no caller left using the probe;
|
|
||||||
- the free of any resource used by the probes,
|
|
||||||
to make sure the probes wont be accessing invalid data.
|
|
||||||
This, and the fact that preemption is disabled around the probe call, make sure
|
|
||||||
that probe removal and module unload are safe. See the "Probe example" section
|
|
||||||
below for a sample probe module.
|
|
||||||
|
|
||||||
The marker mechanism supports inserting multiple instances of the same marker.
|
|
||||||
Markers can be put in inline functions, inlined static functions, and
|
|
||||||
unrolled loops as well as regular functions.
|
|
||||||
|
|
||||||
The naming scheme "subsystem_event" is suggested here as a convention intended
|
|
||||||
to limit collisions. Marker names are global to the kernel: they are considered
|
|
||||||
as being the same whether they are in the core kernel image or in modules.
|
|
||||||
Conflicting format strings for markers with the same name will cause the markers
|
|
||||||
to be detected to have a different format string not to be armed and will output
|
|
||||||
a printk warning which identifies the inconsistency:
|
|
||||||
|
|
||||||
"Format mismatch for probe probe_name (format), marker (format)"
|
|
||||||
|
|
||||||
Another way to use markers is to simply define the marker without generating any
|
|
||||||
function call to actually call into the marker. This is useful in combination
|
|
||||||
with tracepoint probes in a scheme like this :
|
|
||||||
|
|
||||||
void probe_tracepoint_name(unsigned int arg1, struct task_struct *tsk);
|
|
||||||
|
|
||||||
DEFINE_MARKER_TP(marker_eventname, tracepoint_name, probe_tracepoint_name,
|
|
||||||
"arg1 %u pid %d");
|
|
||||||
|
|
||||||
notrace void probe_tracepoint_name(unsigned int arg1, struct task_struct *tsk)
|
|
||||||
{
|
|
||||||
struct marker *marker = &GET_MARKER(kernel_irq_entry);
|
|
||||||
/* write data to trace buffers ... */
|
|
||||||
}
|
|
||||||
|
|
||||||
* Probe / marker example
|
|
||||||
|
|
||||||
See the example provided in samples/markers/src
|
|
||||||
|
|
||||||
Compile them with your kernel.
|
|
||||||
|
|
||||||
Run, as root :
|
|
||||||
modprobe marker-example (insmod order is not important)
|
|
||||||
modprobe probe-example
|
|
||||||
cat /proc/marker-example (returns an expected error)
|
|
||||||
rmmod marker-example probe-example
|
|
||||||
dmesg
|
|
||||||
|
|
@ -29,7 +29,6 @@
|
||||||
#include <linux/poll.h>
|
#include <linux/poll.h>
|
||||||
#include <linux/ptrace.h>
|
#include <linux/ptrace.h>
|
||||||
#include <linux/seq_file.h>
|
#include <linux/seq_file.h>
|
||||||
#include <linux/marker.h>
|
|
||||||
|
|
||||||
#include <asm/io.h>
|
#include <asm/io.h>
|
||||||
#include <asm/time.h>
|
#include <asm/time.h>
|
||||||
|
|
|
||||||
|
|
@ -39,7 +39,6 @@
|
||||||
#include <linux/pid_namespace.h>
|
#include <linux/pid_namespace.h>
|
||||||
#include <linux/proc_fs.h>
|
#include <linux/proc_fs.h>
|
||||||
#include <linux/seq_file.h>
|
#include <linux/seq_file.h>
|
||||||
#include <linux/marker.h>
|
|
||||||
|
|
||||||
#include <asm/io.h>
|
#include <asm/io.h>
|
||||||
#include <asm/mmu_context.h>
|
#include <asm/mmu_context.h>
|
||||||
|
|
|
||||||
|
|
@ -15,7 +15,6 @@
|
||||||
#include <linux/sched.h>
|
#include <linux/sched.h>
|
||||||
#include <linux/mm.h>
|
#include <linux/mm.h>
|
||||||
#include <linux/preempt.h>
|
#include <linux/preempt.h>
|
||||||
#include <linux/marker.h>
|
|
||||||
#include <linux/msi.h>
|
#include <linux/msi.h>
|
||||||
#include <asm/signal.h>
|
#include <asm/signal.h>
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -1,221 +0,0 @@
|
||||||
#ifndef _LINUX_MARKER_H
|
|
||||||
#define _LINUX_MARKER_H
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Code markup for dynamic and static tracing.
|
|
||||||
*
|
|
||||||
* See Documentation/marker.txt.
|
|
||||||
*
|
|
||||||
* (C) Copyright 2006 Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
|
|
||||||
*
|
|
||||||
* This file is released under the GPLv2.
|
|
||||||
* See the file COPYING for more details.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <stdarg.h>
|
|
||||||
#include <linux/types.h>
|
|
||||||
|
|
||||||
struct module;
|
|
||||||
struct marker;
|
|
||||||
|
|
||||||
/**
|
|
||||||
* marker_probe_func - Type of a marker probe function
|
|
||||||
* @probe_private: probe private data
|
|
||||||
* @call_private: call site private data
|
|
||||||
* @fmt: format string
|
|
||||||
* @args: variable argument list pointer. Use a pointer to overcome C's
|
|
||||||
* inability to pass this around as a pointer in a portable manner in
|
|
||||||
* the callee otherwise.
|
|
||||||
*
|
|
||||||
* Type of marker probe functions. They receive the mdata and need to parse the
|
|
||||||
* format string to recover the variable argument list.
|
|
||||||
*/
|
|
||||||
typedef void marker_probe_func(void *probe_private, void *call_private,
|
|
||||||
const char *fmt, va_list *args);
|
|
||||||
|
|
||||||
struct marker_probe_closure {
|
|
||||||
marker_probe_func *func; /* Callback */
|
|
||||||
void *probe_private; /* Private probe data */
|
|
||||||
};
|
|
||||||
|
|
||||||
struct marker {
|
|
||||||
const char *name; /* Marker name */
|
|
||||||
const char *format; /* Marker format string, describing the
|
|
||||||
* variable argument list.
|
|
||||||
*/
|
|
||||||
char state; /* Marker state. */
|
|
||||||
char ptype; /* probe type : 0 : single, 1 : multi */
|
|
||||||
/* Probe wrapper */
|
|
||||||
void (*call)(const struct marker *mdata, void *call_private, ...);
|
|
||||||
struct marker_probe_closure single;
|
|
||||||
struct marker_probe_closure *multi;
|
|
||||||
const char *tp_name; /* Optional tracepoint name */
|
|
||||||
void *tp_cb; /* Optional tracepoint callback */
|
|
||||||
} __attribute__((aligned(8)));
|
|
||||||
|
|
||||||
#ifdef CONFIG_MARKERS
|
|
||||||
|
|
||||||
#define _DEFINE_MARKER(name, tp_name_str, tp_cb, format) \
|
|
||||||
static const char __mstrtab_##name[] \
|
|
||||||
__attribute__((section("__markers_strings"))) \
|
|
||||||
= #name "\0" format; \
|
|
||||||
static struct marker __mark_##name \
|
|
||||||
__attribute__((section("__markers"), aligned(8))) = \
|
|
||||||
{ __mstrtab_##name, &__mstrtab_##name[sizeof(#name)], \
|
|
||||||
0, 0, marker_probe_cb, { __mark_empty_function, NULL},\
|
|
||||||
NULL, tp_name_str, tp_cb }
|
|
||||||
|
|
||||||
#define DEFINE_MARKER(name, format) \
|
|
||||||
_DEFINE_MARKER(name, NULL, NULL, format)
|
|
||||||
|
|
||||||
#define DEFINE_MARKER_TP(name, tp_name, tp_cb, format) \
|
|
||||||
_DEFINE_MARKER(name, #tp_name, tp_cb, format)
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Note : the empty asm volatile with read constraint is used here instead of a
|
|
||||||
* "used" attribute to fix a gcc 4.1.x bug.
|
|
||||||
* Make sure the alignment of the structure in the __markers section will
|
|
||||||
* not add unwanted padding between the beginning of the section and the
|
|
||||||
* structure. Force alignment to the same alignment as the section start.
|
|
||||||
*
|
|
||||||
* The "generic" argument controls which marker enabling mechanism must be used.
|
|
||||||
* If generic is true, a variable read is used.
|
|
||||||
* If generic is false, immediate values are used.
|
|
||||||
*/
|
|
||||||
#define __trace_mark(generic, name, call_private, format, args...) \
|
|
||||||
do { \
|
|
||||||
DEFINE_MARKER(name, format); \
|
|
||||||
__mark_check_format(format, ## args); \
|
|
||||||
if (unlikely(__mark_##name.state)) { \
|
|
||||||
(*__mark_##name.call) \
|
|
||||||
(&__mark_##name, call_private, ## args);\
|
|
||||||
} \
|
|
||||||
} while (0)
|
|
||||||
|
|
||||||
#define __trace_mark_tp(name, call_private, tp_name, tp_cb, format, args...) \
|
|
||||||
do { \
|
|
||||||
void __check_tp_type(void) \
|
|
||||||
{ \
|
|
||||||
register_trace_##tp_name(tp_cb); \
|
|
||||||
} \
|
|
||||||
DEFINE_MARKER_TP(name, tp_name, tp_cb, format); \
|
|
||||||
__mark_check_format(format, ## args); \
|
|
||||||
(*__mark_##name.call)(&__mark_##name, call_private, \
|
|
||||||
## args); \
|
|
||||||
} while (0)
|
|
||||||
|
|
||||||
extern void marker_update_probe_range(struct marker *begin,
|
|
||||||
struct marker *end);
|
|
||||||
|
|
||||||
#define GET_MARKER(name) (__mark_##name)
|
|
||||||
|
|
||||||
#else /* !CONFIG_MARKERS */
|
|
||||||
#define DEFINE_MARKER(name, tp_name, tp_cb, format)
|
|
||||||
#define __trace_mark(generic, name, call_private, format, args...) \
|
|
||||||
__mark_check_format(format, ## args)
|
|
||||||
#define __trace_mark_tp(name, call_private, tp_name, tp_cb, format, args...) \
|
|
||||||
do { \
|
|
||||||
void __check_tp_type(void) \
|
|
||||||
{ \
|
|
||||||
register_trace_##tp_name(tp_cb); \
|
|
||||||
} \
|
|
||||||
__mark_check_format(format, ## args); \
|
|
||||||
} while (0)
|
|
||||||
static inline void marker_update_probe_range(struct marker *begin,
|
|
||||||
struct marker *end)
|
|
||||||
{ }
|
|
||||||
#define GET_MARKER(name)
|
|
||||||
#endif /* CONFIG_MARKERS */
|
|
||||||
|
|
||||||
/**
|
|
||||||
* trace_mark - Marker using code patching
|
|
||||||
* @name: marker name, not quoted.
|
|
||||||
* @format: format string
|
|
||||||
* @args...: variable argument list
|
|
||||||
*
|
|
||||||
* Places a marker using optimized code patching technique (imv_read())
|
|
||||||
* to be enabled when immediate values are present.
|
|
||||||
*/
|
|
||||||
#define trace_mark(name, format, args...) \
|
|
||||||
__trace_mark(0, name, NULL, format, ## args)
|
|
||||||
|
|
||||||
/**
|
|
||||||
* _trace_mark - Marker using variable read
|
|
||||||
* @name: marker name, not quoted.
|
|
||||||
* @format: format string
|
|
||||||
* @args...: variable argument list
|
|
||||||
*
|
|
||||||
* Places a marker using a standard memory read (_imv_read()) to be
|
|
||||||
* enabled. Should be used for markers in code paths where instruction
|
|
||||||
* modification based enabling is not welcome. (__init and __exit functions,
|
|
||||||
* lockdep, some traps, printk).
|
|
||||||
*/
|
|
||||||
#define _trace_mark(name, format, args...) \
|
|
||||||
__trace_mark(1, name, NULL, format, ## args)
|
|
||||||
|
|
||||||
/**
|
|
||||||
* trace_mark_tp - Marker in a tracepoint callback
|
|
||||||
* @name: marker name, not quoted.
|
|
||||||
* @tp_name: tracepoint name, not quoted.
|
|
||||||
* @tp_cb: tracepoint callback. Should have an associated global symbol so it
|
|
||||||
* is not optimized away by the compiler (should not be static).
|
|
||||||
* @format: format string
|
|
||||||
* @args...: variable argument list
|
|
||||||
*
|
|
||||||
* Places a marker in a tracepoint callback.
|
|
||||||
*/
|
|
||||||
#define trace_mark_tp(name, tp_name, tp_cb, format, args...) \
|
|
||||||
__trace_mark_tp(name, NULL, tp_name, tp_cb, format, ## args)
|
|
||||||
|
|
||||||
/**
|
|
||||||
* MARK_NOARGS - Format string for a marker with no argument.
|
|
||||||
*/
|
|
||||||
#define MARK_NOARGS " "
|
|
||||||
|
|
||||||
/* To be used for string format validity checking with gcc */
|
|
||||||
static inline void __printf(1, 2) ___mark_check_format(const char *fmt, ...)
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
#define __mark_check_format(format, args...) \
|
|
||||||
do { \
|
|
||||||
if (0) \
|
|
||||||
___mark_check_format(format, ## args); \
|
|
||||||
} while (0)
|
|
||||||
|
|
||||||
extern marker_probe_func __mark_empty_function;
|
|
||||||
|
|
||||||
extern void marker_probe_cb(const struct marker *mdata,
|
|
||||||
void *call_private, ...);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Connect a probe to a marker.
|
|
||||||
* private data pointer must be a valid allocated memory address, or NULL.
|
|
||||||
*/
|
|
||||||
extern int marker_probe_register(const char *name, const char *format,
|
|
||||||
marker_probe_func *probe, void *probe_private);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Returns the private data given to marker_probe_register.
|
|
||||||
*/
|
|
||||||
extern int marker_probe_unregister(const char *name,
|
|
||||||
marker_probe_func *probe, void *probe_private);
|
|
||||||
/*
|
|
||||||
* Unregister a marker by providing the registered private data.
|
|
||||||
*/
|
|
||||||
extern int marker_probe_unregister_private_data(marker_probe_func *probe,
|
|
||||||
void *probe_private);
|
|
||||||
|
|
||||||
extern void *marker_get_private_data(const char *name, marker_probe_func *probe,
|
|
||||||
int num);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* marker_synchronize_unregister must be called between the last marker probe
|
|
||||||
* unregistration and the first one of
|
|
||||||
* - the end of module exit function
|
|
||||||
* - the free of any resource used by the probes
|
|
||||||
* to ensure the code and data are valid for any possibly running probes.
|
|
||||||
*/
|
|
||||||
#define marker_synchronize_unregister() synchronize_sched()
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
@ -15,7 +15,6 @@
|
||||||
#include <linux/stringify.h>
|
#include <linux/stringify.h>
|
||||||
#include <linux/kobject.h>
|
#include <linux/kobject.h>
|
||||||
#include <linux/moduleparam.h>
|
#include <linux/moduleparam.h>
|
||||||
#include <linux/marker.h>
|
|
||||||
#include <linux/tracepoint.h>
|
#include <linux/tracepoint.h>
|
||||||
|
|
||||||
#include <asm/local.h>
|
#include <asm/local.h>
|
||||||
|
|
@ -327,10 +326,6 @@ struct module
|
||||||
/* The command line arguments (may be mangled). People like
|
/* The command line arguments (may be mangled). People like
|
||||||
keeping pointers to this stuff */
|
keeping pointers to this stuff */
|
||||||
char *args;
|
char *args;
|
||||||
#ifdef CONFIG_MARKERS
|
|
||||||
struct marker *markers;
|
|
||||||
unsigned int num_markers;
|
|
||||||
#endif
|
|
||||||
#ifdef CONFIG_TRACEPOINTS
|
#ifdef CONFIG_TRACEPOINTS
|
||||||
struct tracepoint *tracepoints;
|
struct tracepoint *tracepoints;
|
||||||
unsigned int num_tracepoints;
|
unsigned int num_tracepoints;
|
||||||
|
|
@ -535,8 +530,6 @@ int unregister_module_notifier(struct notifier_block * nb);
|
||||||
|
|
||||||
extern void print_modules(void);
|
extern void print_modules(void);
|
||||||
|
|
||||||
extern void module_update_markers(void);
|
|
||||||
|
|
||||||
extern void module_update_tracepoints(void);
|
extern void module_update_tracepoints(void);
|
||||||
extern int module_get_iter_tracepoints(struct tracepoint_iter *iter);
|
extern int module_get_iter_tracepoints(struct tracepoint_iter *iter);
|
||||||
|
|
||||||
|
|
@ -651,10 +644,6 @@ static inline void print_modules(void)
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
static inline void module_update_markers(void)
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
static inline void module_update_tracepoints(void)
|
static inline void module_update_tracepoints(void)
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -1054,13 +1054,6 @@ config PROFILING
|
||||||
config TRACEPOINTS
|
config TRACEPOINTS
|
||||||
bool
|
bool
|
||||||
|
|
||||||
config MARKERS
|
|
||||||
bool "Activate markers"
|
|
||||||
select TRACEPOINTS
|
|
||||||
help
|
|
||||||
Place an empty function call at each marker site. Can be
|
|
||||||
dynamically changed for a probe function.
|
|
||||||
|
|
||||||
source "arch/Kconfig"
|
source "arch/Kconfig"
|
||||||
|
|
||||||
config SLOW_WORK
|
config SLOW_WORK
|
||||||
|
|
|
||||||
|
|
@ -87,7 +87,6 @@ obj-$(CONFIG_RELAY) += relay.o
|
||||||
obj-$(CONFIG_SYSCTL) += utsname_sysctl.o
|
obj-$(CONFIG_SYSCTL) += utsname_sysctl.o
|
||||||
obj-$(CONFIG_TASK_DELAY_ACCT) += delayacct.o
|
obj-$(CONFIG_TASK_DELAY_ACCT) += delayacct.o
|
||||||
obj-$(CONFIG_TASKSTATS) += taskstats.o tsacct.o
|
obj-$(CONFIG_TASKSTATS) += taskstats.o tsacct.o
|
||||||
obj-$(CONFIG_MARKERS) += marker.o
|
|
||||||
obj-$(CONFIG_TRACEPOINTS) += tracepoint.o
|
obj-$(CONFIG_TRACEPOINTS) += tracepoint.o
|
||||||
obj-$(CONFIG_LATENCYTOP) += latencytop.o
|
obj-$(CONFIG_LATENCYTOP) += latencytop.o
|
||||||
obj-$(CONFIG_FUNCTION_TRACER) += trace/
|
obj-$(CONFIG_FUNCTION_TRACER) += trace/
|
||||||
|
|
|
||||||
930
kernel/marker.c
930
kernel/marker.c
|
|
@ -1,930 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (C) 2007 Mathieu Desnoyers
|
|
||||||
*
|
|
||||||
* This program is free software; you can redistribute it and/or modify
|
|
||||||
* it under the terms of the GNU General Public License as published by
|
|
||||||
* the Free Software Foundation; either version 2 of the License, or
|
|
||||||
* (at your option) any later version.
|
|
||||||
*
|
|
||||||
* This program is distributed in the hope that it will be useful,
|
|
||||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
||||||
* GNU General Public License for more details.
|
|
||||||
*
|
|
||||||
* You should have received a copy of the GNU General Public License
|
|
||||||
* along with this program; if not, write to the Free Software
|
|
||||||
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
||||||
*/
|
|
||||||
#include <linux/module.h>
|
|
||||||
#include <linux/mutex.h>
|
|
||||||
#include <linux/types.h>
|
|
||||||
#include <linux/jhash.h>
|
|
||||||
#include <linux/list.h>
|
|
||||||
#include <linux/rcupdate.h>
|
|
||||||
#include <linux/marker.h>
|
|
||||||
#include <linux/err.h>
|
|
||||||
#include <linux/slab.h>
|
|
||||||
|
|
||||||
extern struct marker __start___markers[];
|
|
||||||
extern struct marker __stop___markers[];
|
|
||||||
|
|
||||||
/* Set to 1 to enable marker debug output */
|
|
||||||
static const int marker_debug;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* markers_mutex nests inside module_mutex. Markers mutex protects the builtin
|
|
||||||
* and module markers and the hash table.
|
|
||||||
*/
|
|
||||||
static DEFINE_MUTEX(markers_mutex);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Marker hash table, containing the active markers.
|
|
||||||
* Protected by module_mutex.
|
|
||||||
*/
|
|
||||||
#define MARKER_HASH_BITS 6
|
|
||||||
#define MARKER_TABLE_SIZE (1 << MARKER_HASH_BITS)
|
|
||||||
static struct hlist_head marker_table[MARKER_TABLE_SIZE];
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Note about RCU :
|
|
||||||
* It is used to make sure every handler has finished using its private data
|
|
||||||
* between two consecutive operation (add or remove) on a given marker. It is
|
|
||||||
* also used to delay the free of multiple probes array until a quiescent state
|
|
||||||
* is reached.
|
|
||||||
* marker entries modifications are protected by the markers_mutex.
|
|
||||||
*/
|
|
||||||
struct marker_entry {
|
|
||||||
struct hlist_node hlist;
|
|
||||||
char *format;
|
|
||||||
/* Probe wrapper */
|
|
||||||
void (*call)(const struct marker *mdata, void *call_private, ...);
|
|
||||||
struct marker_probe_closure single;
|
|
||||||
struct marker_probe_closure *multi;
|
|
||||||
int refcount; /* Number of times armed. 0 if disarmed. */
|
|
||||||
struct rcu_head rcu;
|
|
||||||
void *oldptr;
|
|
||||||
int rcu_pending;
|
|
||||||
unsigned char ptype:1;
|
|
||||||
unsigned char format_allocated:1;
|
|
||||||
char name[0]; /* Contains name'\0'format'\0' */
|
|
||||||
};
|
|
||||||
|
|
||||||
/**
|
|
||||||
* __mark_empty_function - Empty probe callback
|
|
||||||
* @probe_private: probe private data
|
|
||||||
* @call_private: call site private data
|
|
||||||
* @fmt: format string
|
|
||||||
* @...: variable argument list
|
|
||||||
*
|
|
||||||
* Empty callback provided as a probe to the markers. By providing this to a
|
|
||||||
* disabled marker, we make sure the execution flow is always valid even
|
|
||||||
* though the function pointer change and the marker enabling are two distinct
|
|
||||||
* operations that modifies the execution flow of preemptible code.
|
|
||||||
*/
|
|
||||||
notrace void __mark_empty_function(void *probe_private, void *call_private,
|
|
||||||
const char *fmt, va_list *args)
|
|
||||||
{
|
|
||||||
}
|
|
||||||
EXPORT_SYMBOL_GPL(__mark_empty_function);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* marker_probe_cb Callback that prepares the variable argument list for probes.
|
|
||||||
* @mdata: pointer of type struct marker
|
|
||||||
* @call_private: caller site private data
|
|
||||||
* @...: Variable argument list.
|
|
||||||
*
|
|
||||||
* Since we do not use "typical" pointer based RCU in the 1 argument case, we
|
|
||||||
* need to put a full smp_rmb() in this branch. This is why we do not use
|
|
||||||
* rcu_dereference() for the pointer read.
|
|
||||||
*/
|
|
||||||
notrace void marker_probe_cb(const struct marker *mdata,
|
|
||||||
void *call_private, ...)
|
|
||||||
{
|
|
||||||
va_list args;
|
|
||||||
char ptype;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* rcu_read_lock_sched does two things : disabling preemption to make
|
|
||||||
* sure the teardown of the callbacks can be done correctly when they
|
|
||||||
* are in modules and they insure RCU read coherency.
|
|
||||||
*/
|
|
||||||
rcu_read_lock_sched_notrace();
|
|
||||||
ptype = mdata->ptype;
|
|
||||||
if (likely(!ptype)) {
|
|
||||||
marker_probe_func *func;
|
|
||||||
/* Must read the ptype before ptr. They are not data dependant,
|
|
||||||
* so we put an explicit smp_rmb() here. */
|
|
||||||
smp_rmb();
|
|
||||||
func = mdata->single.func;
|
|
||||||
/* Must read the ptr before private data. They are not data
|
|
||||||
* dependant, so we put an explicit smp_rmb() here. */
|
|
||||||
smp_rmb();
|
|
||||||
va_start(args, call_private);
|
|
||||||
func(mdata->single.probe_private, call_private, mdata->format,
|
|
||||||
&args);
|
|
||||||
va_end(args);
|
|
||||||
} else {
|
|
||||||
struct marker_probe_closure *multi;
|
|
||||||
int i;
|
|
||||||
/*
|
|
||||||
* Read mdata->ptype before mdata->multi.
|
|
||||||
*/
|
|
||||||
smp_rmb();
|
|
||||||
multi = mdata->multi;
|
|
||||||
/*
|
|
||||||
* multi points to an array, therefore accessing the array
|
|
||||||
* depends on reading multi. However, even in this case,
|
|
||||||
* we must insure that the pointer is read _before_ the array
|
|
||||||
* data. Same as rcu_dereference, but we need a full smp_rmb()
|
|
||||||
* in the fast path, so put the explicit barrier here.
|
|
||||||
*/
|
|
||||||
smp_read_barrier_depends();
|
|
||||||
for (i = 0; multi[i].func; i++) {
|
|
||||||
va_start(args, call_private);
|
|
||||||
multi[i].func(multi[i].probe_private, call_private,
|
|
||||||
mdata->format, &args);
|
|
||||||
va_end(args);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
rcu_read_unlock_sched_notrace();
|
|
||||||
}
|
|
||||||
EXPORT_SYMBOL_GPL(marker_probe_cb);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* marker_probe_cb Callback that does not prepare the variable argument list.
|
|
||||||
* @mdata: pointer of type struct marker
|
|
||||||
* @call_private: caller site private data
|
|
||||||
* @...: Variable argument list.
|
|
||||||
*
|
|
||||||
* Should be connected to markers "MARK_NOARGS".
|
|
||||||
*/
|
|
||||||
static notrace void marker_probe_cb_noarg(const struct marker *mdata,
|
|
||||||
void *call_private, ...)
|
|
||||||
{
|
|
||||||
va_list args; /* not initialized */
|
|
||||||
char ptype;
|
|
||||||
|
|
||||||
rcu_read_lock_sched_notrace();
|
|
||||||
ptype = mdata->ptype;
|
|
||||||
if (likely(!ptype)) {
|
|
||||||
marker_probe_func *func;
|
|
||||||
/* Must read the ptype before ptr. They are not data dependant,
|
|
||||||
* so we put an explicit smp_rmb() here. */
|
|
||||||
smp_rmb();
|
|
||||||
func = mdata->single.func;
|
|
||||||
/* Must read the ptr before private data. They are not data
|
|
||||||
* dependant, so we put an explicit smp_rmb() here. */
|
|
||||||
smp_rmb();
|
|
||||||
func(mdata->single.probe_private, call_private, mdata->format,
|
|
||||||
&args);
|
|
||||||
} else {
|
|
||||||
struct marker_probe_closure *multi;
|
|
||||||
int i;
|
|
||||||
/*
|
|
||||||
* Read mdata->ptype before mdata->multi.
|
|
||||||
*/
|
|
||||||
smp_rmb();
|
|
||||||
multi = mdata->multi;
|
|
||||||
/*
|
|
||||||
* multi points to an array, therefore accessing the array
|
|
||||||
* depends on reading multi. However, even in this case,
|
|
||||||
* we must insure that the pointer is read _before_ the array
|
|
||||||
* data. Same as rcu_dereference, but we need a full smp_rmb()
|
|
||||||
* in the fast path, so put the explicit barrier here.
|
|
||||||
*/
|
|
||||||
smp_read_barrier_depends();
|
|
||||||
for (i = 0; multi[i].func; i++)
|
|
||||||
multi[i].func(multi[i].probe_private, call_private,
|
|
||||||
mdata->format, &args);
|
|
||||||
}
|
|
||||||
rcu_read_unlock_sched_notrace();
|
|
||||||
}
|
|
||||||
|
|
||||||
static void free_old_closure(struct rcu_head *head)
|
|
||||||
{
|
|
||||||
struct marker_entry *entry = container_of(head,
|
|
||||||
struct marker_entry, rcu);
|
|
||||||
kfree(entry->oldptr);
|
|
||||||
/* Make sure we free the data before setting the pending flag to 0 */
|
|
||||||
smp_wmb();
|
|
||||||
entry->rcu_pending = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
static void debug_print_probes(struct marker_entry *entry)
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
|
|
||||||
if (!marker_debug)
|
|
||||||
return;
|
|
||||||
|
|
||||||
if (!entry->ptype) {
|
|
||||||
printk(KERN_DEBUG "Single probe : %p %p\n",
|
|
||||||
entry->single.func,
|
|
||||||
entry->single.probe_private);
|
|
||||||
} else {
|
|
||||||
for (i = 0; entry->multi[i].func; i++)
|
|
||||||
printk(KERN_DEBUG "Multi probe %d : %p %p\n", i,
|
|
||||||
entry->multi[i].func,
|
|
||||||
entry->multi[i].probe_private);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static struct marker_probe_closure *
|
|
||||||
marker_entry_add_probe(struct marker_entry *entry,
|
|
||||||
marker_probe_func *probe, void *probe_private)
|
|
||||||
{
|
|
||||||
int nr_probes = 0;
|
|
||||||
struct marker_probe_closure *old, *new;
|
|
||||||
|
|
||||||
WARN_ON(!probe);
|
|
||||||
|
|
||||||
debug_print_probes(entry);
|
|
||||||
old = entry->multi;
|
|
||||||
if (!entry->ptype) {
|
|
||||||
if (entry->single.func == probe &&
|
|
||||||
entry->single.probe_private == probe_private)
|
|
||||||
return ERR_PTR(-EBUSY);
|
|
||||||
if (entry->single.func == __mark_empty_function) {
|
|
||||||
/* 0 -> 1 probes */
|
|
||||||
entry->single.func = probe;
|
|
||||||
entry->single.probe_private = probe_private;
|
|
||||||
entry->refcount = 1;
|
|
||||||
entry->ptype = 0;
|
|
||||||
debug_print_probes(entry);
|
|
||||||
return NULL;
|
|
||||||
} else {
|
|
||||||
/* 1 -> 2 probes */
|
|
||||||
nr_probes = 1;
|
|
||||||
old = NULL;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
/* (N -> N+1), (N != 0, 1) probes */
|
|
||||||
for (nr_probes = 0; old[nr_probes].func; nr_probes++)
|
|
||||||
if (old[nr_probes].func == probe
|
|
||||||
&& old[nr_probes].probe_private
|
|
||||||
== probe_private)
|
|
||||||
return ERR_PTR(-EBUSY);
|
|
||||||
}
|
|
||||||
/* + 2 : one for new probe, one for NULL func */
|
|
||||||
new = kzalloc((nr_probes + 2) * sizeof(struct marker_probe_closure),
|
|
||||||
GFP_KERNEL);
|
|
||||||
if (new == NULL)
|
|
||||||
return ERR_PTR(-ENOMEM);
|
|
||||||
if (!old)
|
|
||||||
new[0] = entry->single;
|
|
||||||
else
|
|
||||||
memcpy(new, old,
|
|
||||||
nr_probes * sizeof(struct marker_probe_closure));
|
|
||||||
new[nr_probes].func = probe;
|
|
||||||
new[nr_probes].probe_private = probe_private;
|
|
||||||
entry->refcount = nr_probes + 1;
|
|
||||||
entry->multi = new;
|
|
||||||
entry->ptype = 1;
|
|
||||||
debug_print_probes(entry);
|
|
||||||
return old;
|
|
||||||
}
|
|
||||||
|
|
||||||
static struct marker_probe_closure *
|
|
||||||
marker_entry_remove_probe(struct marker_entry *entry,
|
|
||||||
marker_probe_func *probe, void *probe_private)
|
|
||||||
{
|
|
||||||
int nr_probes = 0, nr_del = 0, i;
|
|
||||||
struct marker_probe_closure *old, *new;
|
|
||||||
|
|
||||||
old = entry->multi;
|
|
||||||
|
|
||||||
debug_print_probes(entry);
|
|
||||||
if (!entry->ptype) {
|
|
||||||
/* 0 -> N is an error */
|
|
||||||
WARN_ON(entry->single.func == __mark_empty_function);
|
|
||||||
/* 1 -> 0 probes */
|
|
||||||
WARN_ON(probe && entry->single.func != probe);
|
|
||||||
WARN_ON(entry->single.probe_private != probe_private);
|
|
||||||
entry->single.func = __mark_empty_function;
|
|
||||||
entry->refcount = 0;
|
|
||||||
entry->ptype = 0;
|
|
||||||
debug_print_probes(entry);
|
|
||||||
return NULL;
|
|
||||||
} else {
|
|
||||||
/* (N -> M), (N > 1, M >= 0) probes */
|
|
||||||
for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
|
|
||||||
if ((!probe || old[nr_probes].func == probe)
|
|
||||||
&& old[nr_probes].probe_private
|
|
||||||
== probe_private)
|
|
||||||
nr_del++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if (nr_probes - nr_del == 0) {
|
|
||||||
/* N -> 0, (N > 1) */
|
|
||||||
entry->single.func = __mark_empty_function;
|
|
||||||
entry->refcount = 0;
|
|
||||||
entry->ptype = 0;
|
|
||||||
} else if (nr_probes - nr_del == 1) {
|
|
||||||
/* N -> 1, (N > 1) */
|
|
||||||
for (i = 0; old[i].func; i++)
|
|
||||||
if ((probe && old[i].func != probe) ||
|
|
||||||
old[i].probe_private != probe_private)
|
|
||||||
entry->single = old[i];
|
|
||||||
entry->refcount = 1;
|
|
||||||
entry->ptype = 0;
|
|
||||||
} else {
|
|
||||||
int j = 0;
|
|
||||||
/* N -> M, (N > 1, M > 1) */
|
|
||||||
/* + 1 for NULL */
|
|
||||||
new = kzalloc((nr_probes - nr_del + 1)
|
|
||||||
* sizeof(struct marker_probe_closure), GFP_KERNEL);
|
|
||||||
if (new == NULL)
|
|
||||||
return ERR_PTR(-ENOMEM);
|
|
||||||
for (i = 0; old[i].func; i++)
|
|
||||||
if ((probe && old[i].func != probe) ||
|
|
||||||
old[i].probe_private != probe_private)
|
|
||||||
new[j++] = old[i];
|
|
||||||
entry->refcount = nr_probes - nr_del;
|
|
||||||
entry->ptype = 1;
|
|
||||||
entry->multi = new;
|
|
||||||
}
|
|
||||||
debug_print_probes(entry);
|
|
||||||
return old;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Get marker if the marker is present in the marker hash table.
|
|
||||||
* Must be called with markers_mutex held.
|
|
||||||
* Returns NULL if not present.
|
|
||||||
*/
|
|
||||||
static struct marker_entry *get_marker(const char *name)
|
|
||||||
{
|
|
||||||
struct hlist_head *head;
|
|
||||||
struct hlist_node *node;
|
|
||||||
struct marker_entry *e;
|
|
||||||
u32 hash = jhash(name, strlen(name), 0);
|
|
||||||
|
|
||||||
head = &marker_table[hash & ((1 << MARKER_HASH_BITS)-1)];
|
|
||||||
hlist_for_each_entry(e, node, head, hlist) {
|
|
||||||
if (!strcmp(name, e->name))
|
|
||||||
return e;
|
|
||||||
}
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Add the marker to the marker hash table. Must be called with markers_mutex
|
|
||||||
* held.
|
|
||||||
*/
|
|
||||||
static struct marker_entry *add_marker(const char *name, const char *format)
|
|
||||||
{
|
|
||||||
struct hlist_head *head;
|
|
||||||
struct hlist_node *node;
|
|
||||||
struct marker_entry *e;
|
|
||||||
size_t name_len = strlen(name) + 1;
|
|
||||||
size_t format_len = 0;
|
|
||||||
u32 hash = jhash(name, name_len-1, 0);
|
|
||||||
|
|
||||||
if (format)
|
|
||||||
format_len = strlen(format) + 1;
|
|
||||||
head = &marker_table[hash & ((1 << MARKER_HASH_BITS)-1)];
|
|
||||||
hlist_for_each_entry(e, node, head, hlist) {
|
|
||||||
if (!strcmp(name, e->name)) {
|
|
||||||
printk(KERN_NOTICE
|
|
||||||
"Marker %s busy\n", name);
|
|
||||||
return ERR_PTR(-EBUSY); /* Already there */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
/*
|
|
||||||
* Using kmalloc here to allocate a variable length element. Could
|
|
||||||
* cause some memory fragmentation if overused.
|
|
||||||
*/
|
|
||||||
e = kmalloc(sizeof(struct marker_entry) + name_len + format_len,
|
|
||||||
GFP_KERNEL);
|
|
||||||
if (!e)
|
|
||||||
return ERR_PTR(-ENOMEM);
|
|
||||||
memcpy(&e->name[0], name, name_len);
|
|
||||||
if (format) {
|
|
||||||
e->format = &e->name[name_len];
|
|
||||||
memcpy(e->format, format, format_len);
|
|
||||||
if (strcmp(e->format, MARK_NOARGS) == 0)
|
|
||||||
e->call = marker_probe_cb_noarg;
|
|
||||||
else
|
|
||||||
e->call = marker_probe_cb;
|
|
||||||
trace_mark(core_marker_format, "name %s format %s",
|
|
||||||
e->name, e->format);
|
|
||||||
} else {
|
|
||||||
e->format = NULL;
|
|
||||||
e->call = marker_probe_cb;
|
|
||||||
}
|
|
||||||
e->single.func = __mark_empty_function;
|
|
||||||
e->single.probe_private = NULL;
|
|
||||||
e->multi = NULL;
|
|
||||||
e->ptype = 0;
|
|
||||||
e->format_allocated = 0;
|
|
||||||
e->refcount = 0;
|
|
||||||
e->rcu_pending = 0;
|
|
||||||
hlist_add_head(&e->hlist, head);
|
|
||||||
return e;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Remove the marker from the marker hash table. Must be called with mutex_lock
|
|
||||||
* held.
|
|
||||||
*/
|
|
||||||
static int remove_marker(const char *name)
|
|
||||||
{
|
|
||||||
struct hlist_head *head;
|
|
||||||
struct hlist_node *node;
|
|
||||||
struct marker_entry *e;
|
|
||||||
int found = 0;
|
|
||||||
size_t len = strlen(name) + 1;
|
|
||||||
u32 hash = jhash(name, len-1, 0);
|
|
||||||
|
|
||||||
head = &marker_table[hash & ((1 << MARKER_HASH_BITS)-1)];
|
|
||||||
hlist_for_each_entry(e, node, head, hlist) {
|
|
||||||
if (!strcmp(name, e->name)) {
|
|
||||||
found = 1;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if (!found)
|
|
||||||
return -ENOENT;
|
|
||||||
if (e->single.func != __mark_empty_function)
|
|
||||||
return -EBUSY;
|
|
||||||
hlist_del(&e->hlist);
|
|
||||||
if (e->format_allocated)
|
|
||||||
kfree(e->format);
|
|
||||||
/* Make sure the call_rcu has been executed */
|
|
||||||
if (e->rcu_pending)
|
|
||||||
rcu_barrier_sched();
|
|
||||||
kfree(e);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Set the mark_entry format to the format found in the element.
|
|
||||||
*/
|
|
||||||
static int marker_set_format(struct marker_entry *entry, const char *format)
|
|
||||||
{
|
|
||||||
entry->format = kstrdup(format, GFP_KERNEL);
|
|
||||||
if (!entry->format)
|
|
||||||
return -ENOMEM;
|
|
||||||
entry->format_allocated = 1;
|
|
||||||
|
|
||||||
trace_mark(core_marker_format, "name %s format %s",
|
|
||||||
entry->name, entry->format);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Sets the probe callback corresponding to one marker.
|
|
||||||
*/
|
|
||||||
static int set_marker(struct marker_entry *entry, struct marker *elem,
|
|
||||||
int active)
|
|
||||||
{
|
|
||||||
int ret = 0;
|
|
||||||
WARN_ON(strcmp(entry->name, elem->name) != 0);
|
|
||||||
|
|
||||||
if (entry->format) {
|
|
||||||
if (strcmp(entry->format, elem->format) != 0) {
|
|
||||||
printk(KERN_NOTICE
|
|
||||||
"Format mismatch for probe %s "
|
|
||||||
"(%s), marker (%s)\n",
|
|
||||||
entry->name,
|
|
||||||
entry->format,
|
|
||||||
elem->format);
|
|
||||||
return -EPERM;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
ret = marker_set_format(entry, elem->format);
|
|
||||||
if (ret)
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* probe_cb setup (statically known) is done here. It is
|
|
||||||
* asynchronous with the rest of execution, therefore we only
|
|
||||||
* pass from a "safe" callback (with argument) to an "unsafe"
|
|
||||||
* callback (does not set arguments).
|
|
||||||
*/
|
|
||||||
elem->call = entry->call;
|
|
||||||
/*
|
|
||||||
* Sanity check :
|
|
||||||
* We only update the single probe private data when the ptr is
|
|
||||||
* set to a _non_ single probe! (0 -> 1 and N -> 1, N != 1)
|
|
||||||
*/
|
|
||||||
WARN_ON(elem->single.func != __mark_empty_function
|
|
||||||
&& elem->single.probe_private != entry->single.probe_private
|
|
||||||
&& !elem->ptype);
|
|
||||||
elem->single.probe_private = entry->single.probe_private;
|
|
||||||
/*
|
|
||||||
* Make sure the private data is valid when we update the
|
|
||||||
* single probe ptr.
|
|
||||||
*/
|
|
||||||
smp_wmb();
|
|
||||||
elem->single.func = entry->single.func;
|
|
||||||
/*
|
|
||||||
* We also make sure that the new probe callbacks array is consistent
|
|
||||||
* before setting a pointer to it.
|
|
||||||
*/
|
|
||||||
rcu_assign_pointer(elem->multi, entry->multi);
|
|
||||||
/*
|
|
||||||
* Update the function or multi probe array pointer before setting the
|
|
||||||
* ptype.
|
|
||||||
*/
|
|
||||||
smp_wmb();
|
|
||||||
elem->ptype = entry->ptype;
|
|
||||||
|
|
||||||
if (elem->tp_name && (active ^ elem->state)) {
|
|
||||||
WARN_ON(!elem->tp_cb);
|
|
||||||
/*
|
|
||||||
* It is ok to directly call the probe registration because type
|
|
||||||
* checking has been done in the __trace_mark_tp() macro.
|
|
||||||
*/
|
|
||||||
|
|
||||||
if (active) {
|
|
||||||
/*
|
|
||||||
* try_module_get should always succeed because we hold
|
|
||||||
* lock_module() to get the tp_cb address.
|
|
||||||
*/
|
|
||||||
ret = try_module_get(__module_text_address(
|
|
||||||
(unsigned long)elem->tp_cb));
|
|
||||||
BUG_ON(!ret);
|
|
||||||
ret = tracepoint_probe_register_noupdate(
|
|
||||||
elem->tp_name,
|
|
||||||
elem->tp_cb);
|
|
||||||
} else {
|
|
||||||
ret = tracepoint_probe_unregister_noupdate(
|
|
||||||
elem->tp_name,
|
|
||||||
elem->tp_cb);
|
|
||||||
/*
|
|
||||||
* tracepoint_probe_update_all() must be called
|
|
||||||
* before the module containing tp_cb is unloaded.
|
|
||||||
*/
|
|
||||||
module_put(__module_text_address(
|
|
||||||
(unsigned long)elem->tp_cb));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
elem->state = active;
|
|
||||||
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Disable a marker and its probe callback.
|
|
||||||
* Note: only waiting an RCU period after setting elem->call to the empty
|
|
||||||
* function insures that the original callback is not used anymore. This insured
|
|
||||||
* by rcu_read_lock_sched around the call site.
|
|
||||||
*/
|
|
||||||
static void disable_marker(struct marker *elem)
|
|
||||||
{
|
|
||||||
int ret;
|
|
||||||
|
|
||||||
/* leave "call" as is. It is known statically. */
|
|
||||||
if (elem->tp_name && elem->state) {
|
|
||||||
WARN_ON(!elem->tp_cb);
|
|
||||||
/*
|
|
||||||
* It is ok to directly call the probe registration because type
|
|
||||||
* checking has been done in the __trace_mark_tp() macro.
|
|
||||||
*/
|
|
||||||
ret = tracepoint_probe_unregister_noupdate(elem->tp_name,
|
|
||||||
elem->tp_cb);
|
|
||||||
WARN_ON(ret);
|
|
||||||
/*
|
|
||||||
* tracepoint_probe_update_all() must be called
|
|
||||||
* before the module containing tp_cb is unloaded.
|
|
||||||
*/
|
|
||||||
module_put(__module_text_address((unsigned long)elem->tp_cb));
|
|
||||||
}
|
|
||||||
elem->state = 0;
|
|
||||||
elem->single.func = __mark_empty_function;
|
|
||||||
/* Update the function before setting the ptype */
|
|
||||||
smp_wmb();
|
|
||||||
elem->ptype = 0; /* single probe */
|
|
||||||
/*
|
|
||||||
* Leave the private data and id there, because removal is racy and
|
|
||||||
* should be done only after an RCU period. These are never used until
|
|
||||||
* the next initialization anyway.
|
|
||||||
*/
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* marker_update_probe_range - Update a probe range
|
|
||||||
* @begin: beginning of the range
|
|
||||||
* @end: end of the range
|
|
||||||
*
|
|
||||||
* Updates the probe callback corresponding to a range of markers.
|
|
||||||
*/
|
|
||||||
void marker_update_probe_range(struct marker *begin,
|
|
||||||
struct marker *end)
|
|
||||||
{
|
|
||||||
struct marker *iter;
|
|
||||||
struct marker_entry *mark_entry;
|
|
||||||
|
|
||||||
mutex_lock(&markers_mutex);
|
|
||||||
for (iter = begin; iter < end; iter++) {
|
|
||||||
mark_entry = get_marker(iter->name);
|
|
||||||
if (mark_entry) {
|
|
||||||
set_marker(mark_entry, iter, !!mark_entry->refcount);
|
|
||||||
/*
|
|
||||||
* ignore error, continue
|
|
||||||
*/
|
|
||||||
} else {
|
|
||||||
disable_marker(iter);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
mutex_unlock(&markers_mutex);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Update probes, removing the faulty probes.
|
|
||||||
*
|
|
||||||
* Internal callback only changed before the first probe is connected to it.
|
|
||||||
* Single probe private data can only be changed on 0 -> 1 and 2 -> 1
|
|
||||||
* transitions. All other transitions will leave the old private data valid.
|
|
||||||
* This makes the non-atomicity of the callback/private data updates valid.
|
|
||||||
*
|
|
||||||
* "special case" updates :
|
|
||||||
* 0 -> 1 callback
|
|
||||||
* 1 -> 0 callback
|
|
||||||
* 1 -> 2 callbacks
|
|
||||||
* 2 -> 1 callbacks
|
|
||||||
* Other updates all behave the same, just like the 2 -> 3 or 3 -> 2 updates.
|
|
||||||
* Site effect : marker_set_format may delete the marker entry (creating a
|
|
||||||
* replacement).
|
|
||||||
*/
|
|
||||||
static void marker_update_probes(void)
|
|
||||||
{
|
|
||||||
/* Core kernel markers */
|
|
||||||
marker_update_probe_range(__start___markers, __stop___markers);
|
|
||||||
/* Markers in modules. */
|
|
||||||
module_update_markers();
|
|
||||||
tracepoint_probe_update_all();
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* marker_probe_register - Connect a probe to a marker
|
|
||||||
* @name: marker name
|
|
||||||
* @format: format string
|
|
||||||
* @probe: probe handler
|
|
||||||
* @probe_private: probe private data
|
|
||||||
*
|
|
||||||
* private data must be a valid allocated memory address, or NULL.
|
|
||||||
* Returns 0 if ok, error value on error.
|
|
||||||
* The probe address must at least be aligned on the architecture pointer size.
|
|
||||||
*/
|
|
||||||
int marker_probe_register(const char *name, const char *format,
|
|
||||||
marker_probe_func *probe, void *probe_private)
|
|
||||||
{
|
|
||||||
struct marker_entry *entry;
|
|
||||||
int ret = 0;
|
|
||||||
struct marker_probe_closure *old;
|
|
||||||
|
|
||||||
mutex_lock(&markers_mutex);
|
|
||||||
entry = get_marker(name);
|
|
||||||
if (!entry) {
|
|
||||||
entry = add_marker(name, format);
|
|
||||||
if (IS_ERR(entry))
|
|
||||||
ret = PTR_ERR(entry);
|
|
||||||
} else if (format) {
|
|
||||||
if (!entry->format)
|
|
||||||
ret = marker_set_format(entry, format);
|
|
||||||
else if (strcmp(entry->format, format))
|
|
||||||
ret = -EPERM;
|
|
||||||
}
|
|
||||||
if (ret)
|
|
||||||
goto end;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* If we detect that a call_rcu is pending for this marker,
|
|
||||||
* make sure it's executed now.
|
|
||||||
*/
|
|
||||||
if (entry->rcu_pending)
|
|
||||||
rcu_barrier_sched();
|
|
||||||
old = marker_entry_add_probe(entry, probe, probe_private);
|
|
||||||
if (IS_ERR(old)) {
|
|
||||||
ret = PTR_ERR(old);
|
|
||||||
goto end;
|
|
||||||
}
|
|
||||||
mutex_unlock(&markers_mutex);
|
|
||||||
marker_update_probes();
|
|
||||||
mutex_lock(&markers_mutex);
|
|
||||||
entry = get_marker(name);
|
|
||||||
if (!entry)
|
|
||||||
goto end;
|
|
||||||
if (entry->rcu_pending)
|
|
||||||
rcu_barrier_sched();
|
|
||||||
entry->oldptr = old;
|
|
||||||
entry->rcu_pending = 1;
|
|
||||||
/* write rcu_pending before calling the RCU callback */
|
|
||||||
smp_wmb();
|
|
||||||
call_rcu_sched(&entry->rcu, free_old_closure);
|
|
||||||
end:
|
|
||||||
mutex_unlock(&markers_mutex);
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
EXPORT_SYMBOL_GPL(marker_probe_register);
|
|
||||||
|
|
||||||
/**
|
|
||||||
* marker_probe_unregister - Disconnect a probe from a marker
|
|
||||||
* @name: marker name
|
|
||||||
* @probe: probe function pointer
|
|
||||||
* @probe_private: probe private data
|
|
||||||
*
|
|
||||||
* Returns the private data given to marker_probe_register, or an ERR_PTR().
|
|
||||||
* We do not need to call a synchronize_sched to make sure the probes have
|
|
||||||
* finished running before doing a module unload, because the module unload
|
|
||||||
* itself uses stop_machine(), which insures that every preempt disabled section
|
|
||||||
* have finished.
|
|
||||||
*/
|
|
||||||
int marker_probe_unregister(const char *name,
|
|
||||||
marker_probe_func *probe, void *probe_private)
|
|
||||||
{
|
|
||||||
struct marker_entry *entry;
|
|
||||||
struct marker_probe_closure *old;
|
|
||||||
int ret = -ENOENT;
|
|
||||||
|
|
||||||
mutex_lock(&markers_mutex);
|
|
||||||
entry = get_marker(name);
|
|
||||||
if (!entry)
|
|
||||||
goto end;
|
|
||||||
if (entry->rcu_pending)
|
|
||||||
rcu_barrier_sched();
|
|
||||||
old = marker_entry_remove_probe(entry, probe, probe_private);
|
|
||||||
mutex_unlock(&markers_mutex);
|
|
||||||
marker_update_probes();
|
|
||||||
mutex_lock(&markers_mutex);
|
|
||||||
entry = get_marker(name);
|
|
||||||
if (!entry)
|
|
||||||
goto end;
|
|
||||||
if (entry->rcu_pending)
|
|
||||||
rcu_barrier_sched();
|
|
||||||
entry->oldptr = old;
|
|
||||||
entry->rcu_pending = 1;
|
|
||||||
/* write rcu_pending before calling the RCU callback */
|
|
||||||
smp_wmb();
|
|
||||||
call_rcu_sched(&entry->rcu, free_old_closure);
|
|
||||||
remove_marker(name); /* Ignore busy error message */
|
|
||||||
ret = 0;
|
|
||||||
end:
|
|
||||||
mutex_unlock(&markers_mutex);
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
EXPORT_SYMBOL_GPL(marker_probe_unregister);
|
|
||||||
|
|
||||||
static struct marker_entry *
|
|
||||||
get_marker_from_private_data(marker_probe_func *probe, void *probe_private)
|
|
||||||
{
|
|
||||||
struct marker_entry *entry;
|
|
||||||
unsigned int i;
|
|
||||||
struct hlist_head *head;
|
|
||||||
struct hlist_node *node;
|
|
||||||
|
|
||||||
for (i = 0; i < MARKER_TABLE_SIZE; i++) {
|
|
||||||
head = &marker_table[i];
|
|
||||||
hlist_for_each_entry(entry, node, head, hlist) {
|
|
||||||
if (!entry->ptype) {
|
|
||||||
if (entry->single.func == probe
|
|
||||||
&& entry->single.probe_private
|
|
||||||
== probe_private)
|
|
||||||
return entry;
|
|
||||||
} else {
|
|
||||||
struct marker_probe_closure *closure;
|
|
||||||
closure = entry->multi;
|
|
||||||
for (i = 0; closure[i].func; i++) {
|
|
||||||
if (closure[i].func == probe &&
|
|
||||||
closure[i].probe_private
|
|
||||||
== probe_private)
|
|
||||||
return entry;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* marker_probe_unregister_private_data - Disconnect a probe from a marker
|
|
||||||
* @probe: probe function
|
|
||||||
* @probe_private: probe private data
|
|
||||||
*
|
|
||||||
* Unregister a probe by providing the registered private data.
|
|
||||||
* Only removes the first marker found in hash table.
|
|
||||||
* Return 0 on success or error value.
|
|
||||||
* We do not need to call a synchronize_sched to make sure the probes have
|
|
||||||
* finished running before doing a module unload, because the module unload
|
|
||||||
* itself uses stop_machine(), which insures that every preempt disabled section
|
|
||||||
* have finished.
|
|
||||||
*/
|
|
||||||
int marker_probe_unregister_private_data(marker_probe_func *probe,
|
|
||||||
void *probe_private)
|
|
||||||
{
|
|
||||||
struct marker_entry *entry;
|
|
||||||
int ret = 0;
|
|
||||||
struct marker_probe_closure *old;
|
|
||||||
|
|
||||||
mutex_lock(&markers_mutex);
|
|
||||||
entry = get_marker_from_private_data(probe, probe_private);
|
|
||||||
if (!entry) {
|
|
||||||
ret = -ENOENT;
|
|
||||||
goto end;
|
|
||||||
}
|
|
||||||
if (entry->rcu_pending)
|
|
||||||
rcu_barrier_sched();
|
|
||||||
old = marker_entry_remove_probe(entry, NULL, probe_private);
|
|
||||||
mutex_unlock(&markers_mutex);
|
|
||||||
marker_update_probes();
|
|
||||||
mutex_lock(&markers_mutex);
|
|
||||||
entry = get_marker_from_private_data(probe, probe_private);
|
|
||||||
if (!entry)
|
|
||||||
goto end;
|
|
||||||
if (entry->rcu_pending)
|
|
||||||
rcu_barrier_sched();
|
|
||||||
entry->oldptr = old;
|
|
||||||
entry->rcu_pending = 1;
|
|
||||||
/* write rcu_pending before calling the RCU callback */
|
|
||||||
smp_wmb();
|
|
||||||
call_rcu_sched(&entry->rcu, free_old_closure);
|
|
||||||
remove_marker(entry->name); /* Ignore busy error message */
|
|
||||||
end:
|
|
||||||
mutex_unlock(&markers_mutex);
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
EXPORT_SYMBOL_GPL(marker_probe_unregister_private_data);
|
|
||||||
|
|
||||||
/**
|
|
||||||
* marker_get_private_data - Get a marker's probe private data
|
|
||||||
* @name: marker name
|
|
||||||
* @probe: probe to match
|
|
||||||
* @num: get the nth matching probe's private data
|
|
||||||
*
|
|
||||||
* Returns the nth private data pointer (starting from 0) matching, or an
|
|
||||||
* ERR_PTR.
|
|
||||||
* Returns the private data pointer, or an ERR_PTR.
|
|
||||||
* The private data pointer should _only_ be dereferenced if the caller is the
|
|
||||||
* owner of the data, or its content could vanish. This is mostly used to
|
|
||||||
* confirm that a caller is the owner of a registered probe.
|
|
||||||
*/
|
|
||||||
void *marker_get_private_data(const char *name, marker_probe_func *probe,
|
|
||||||
int num)
|
|
||||||
{
|
|
||||||
struct hlist_head *head;
|
|
||||||
struct hlist_node *node;
|
|
||||||
struct marker_entry *e;
|
|
||||||
size_t name_len = strlen(name) + 1;
|
|
||||||
u32 hash = jhash(name, name_len-1, 0);
|
|
||||||
int i;
|
|
||||||
|
|
||||||
head = &marker_table[hash & ((1 << MARKER_HASH_BITS)-1)];
|
|
||||||
hlist_for_each_entry(e, node, head, hlist) {
|
|
||||||
if (!strcmp(name, e->name)) {
|
|
||||||
if (!e->ptype) {
|
|
||||||
if (num == 0 && e->single.func == probe)
|
|
||||||
return e->single.probe_private;
|
|
||||||
} else {
|
|
||||||
struct marker_probe_closure *closure;
|
|
||||||
int match = 0;
|
|
||||||
closure = e->multi;
|
|
||||||
for (i = 0; closure[i].func; i++) {
|
|
||||||
if (closure[i].func != probe)
|
|
||||||
continue;
|
|
||||||
if (match++ == num)
|
|
||||||
return closure[i].probe_private;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return ERR_PTR(-ENOENT);
|
|
||||||
}
|
|
||||||
EXPORT_SYMBOL_GPL(marker_get_private_data);
|
|
||||||
|
|
||||||
#ifdef CONFIG_MODULES
|
|
||||||
|
|
||||||
int marker_module_notify(struct notifier_block *self,
|
|
||||||
unsigned long val, void *data)
|
|
||||||
{
|
|
||||||
struct module *mod = data;
|
|
||||||
|
|
||||||
switch (val) {
|
|
||||||
case MODULE_STATE_COMING:
|
|
||||||
marker_update_probe_range(mod->markers,
|
|
||||||
mod->markers + mod->num_markers);
|
|
||||||
break;
|
|
||||||
case MODULE_STATE_GOING:
|
|
||||||
marker_update_probe_range(mod->markers,
|
|
||||||
mod->markers + mod->num_markers);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
struct notifier_block marker_module_nb = {
|
|
||||||
.notifier_call = marker_module_notify,
|
|
||||||
.priority = 0,
|
|
||||||
};
|
|
||||||
|
|
||||||
static int init_markers(void)
|
|
||||||
{
|
|
||||||
return register_module_notifier(&marker_module_nb);
|
|
||||||
}
|
|
||||||
__initcall(init_markers);
|
|
||||||
|
|
||||||
#endif /* CONFIG_MODULES */
|
|
||||||
|
|
@ -2237,10 +2237,6 @@ static noinline struct module *load_module(void __user *umod,
|
||||||
sizeof(*mod->ctors), &mod->num_ctors);
|
sizeof(*mod->ctors), &mod->num_ctors);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#ifdef CONFIG_MARKERS
|
|
||||||
mod->markers = section_objs(hdr, sechdrs, secstrings, "__markers",
|
|
||||||
sizeof(*mod->markers), &mod->num_markers);
|
|
||||||
#endif
|
|
||||||
#ifdef CONFIG_TRACEPOINTS
|
#ifdef CONFIG_TRACEPOINTS
|
||||||
mod->tracepoints = section_objs(hdr, sechdrs, secstrings,
|
mod->tracepoints = section_objs(hdr, sechdrs, secstrings,
|
||||||
"__tracepoints",
|
"__tracepoints",
|
||||||
|
|
@ -2958,20 +2954,6 @@ void module_layout(struct module *mod,
|
||||||
EXPORT_SYMBOL(module_layout);
|
EXPORT_SYMBOL(module_layout);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#ifdef CONFIG_MARKERS
|
|
||||||
void module_update_markers(void)
|
|
||||||
{
|
|
||||||
struct module *mod;
|
|
||||||
|
|
||||||
mutex_lock(&module_mutex);
|
|
||||||
list_for_each_entry(mod, &modules, list)
|
|
||||||
if (!mod->taints)
|
|
||||||
marker_update_probe_range(mod->markers,
|
|
||||||
mod->markers + mod->num_markers);
|
|
||||||
mutex_unlock(&module_mutex);
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef CONFIG_TRACEPOINTS
|
#ifdef CONFIG_TRACEPOINTS
|
||||||
void module_update_tracepoints(void)
|
void module_update_tracepoints(void)
|
||||||
{
|
{
|
||||||
|
|
|
||||||
|
|
@ -11,7 +11,6 @@
|
||||||
#include <linux/ftrace.h>
|
#include <linux/ftrace.h>
|
||||||
#include <linux/string.h>
|
#include <linux/string.h>
|
||||||
#include <linux/module.h>
|
#include <linux/module.h>
|
||||||
#include <linux/marker.h>
|
|
||||||
#include <linux/mutex.h>
|
#include <linux/mutex.h>
|
||||||
#include <linux/ctype.h>
|
#include <linux/ctype.h>
|
||||||
#include <linux/list.h>
|
#include <linux/list.h>
|
||||||
|
|
|
||||||
|
|
@ -7,12 +7,6 @@ menuconfig SAMPLES
|
||||||
|
|
||||||
if SAMPLES
|
if SAMPLES
|
||||||
|
|
||||||
config SAMPLE_MARKERS
|
|
||||||
tristate "Build markers examples -- loadable modules only"
|
|
||||||
depends on MARKERS && m
|
|
||||||
help
|
|
||||||
This build markers example modules.
|
|
||||||
|
|
||||||
config SAMPLE_TRACEPOINTS
|
config SAMPLE_TRACEPOINTS
|
||||||
tristate "Build tracepoints examples -- loadable modules only"
|
tristate "Build tracepoints examples -- loadable modules only"
|
||||||
depends on TRACEPOINTS && m
|
depends on TRACEPOINTS && m
|
||||||
|
|
|
||||||
|
|
@ -1,3 +1,3 @@
|
||||||
# Makefile for Linux samples code
|
# Makefile for Linux samples code
|
||||||
|
|
||||||
obj-$(CONFIG_SAMPLES) += markers/ kobject/ kprobes/ tracepoints/ trace_events/
|
obj-$(CONFIG_SAMPLES) += kobject/ kprobes/ tracepoints/ trace_events/
|
||||||
|
|
|
||||||
|
|
@ -1,4 +0,0 @@
|
||||||
# builds the kprobes example kernel modules;
|
|
||||||
# then to use one (as root): insmod <module_name.ko>
|
|
||||||
|
|
||||||
obj-$(CONFIG_SAMPLE_MARKERS) += probe-example.o marker-example.o
|
|
||||||
|
|
@ -1,53 +0,0 @@
|
||||||
/* marker-example.c
|
|
||||||
*
|
|
||||||
* Executes a marker when /proc/marker-example is opened.
|
|
||||||
*
|
|
||||||
* (C) Copyright 2007 Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
|
|
||||||
*
|
|
||||||
* This file is released under the GPLv2.
|
|
||||||
* See the file COPYING for more details.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <linux/module.h>
|
|
||||||
#include <linux/marker.h>
|
|
||||||
#include <linux/sched.h>
|
|
||||||
#include <linux/proc_fs.h>
|
|
||||||
|
|
||||||
struct proc_dir_entry *pentry_example;
|
|
||||||
|
|
||||||
static int my_open(struct inode *inode, struct file *file)
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
|
|
||||||
trace_mark(subsystem_event, "integer %d string %s", 123,
|
|
||||||
"example string");
|
|
||||||
for (i = 0; i < 10; i++)
|
|
||||||
trace_mark(subsystem_eventb, MARK_NOARGS);
|
|
||||||
return -EPERM;
|
|
||||||
}
|
|
||||||
|
|
||||||
static struct file_operations mark_ops = {
|
|
||||||
.open = my_open,
|
|
||||||
};
|
|
||||||
|
|
||||||
static int __init example_init(void)
|
|
||||||
{
|
|
||||||
printk(KERN_ALERT "example init\n");
|
|
||||||
pentry_example = proc_create("marker-example", 0444, NULL, &mark_ops);
|
|
||||||
if (!pentry_example)
|
|
||||||
return -EPERM;
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
static void __exit example_exit(void)
|
|
||||||
{
|
|
||||||
printk(KERN_ALERT "example exit\n");
|
|
||||||
remove_proc_entry("marker-example", NULL);
|
|
||||||
}
|
|
||||||
|
|
||||||
module_init(example_init)
|
|
||||||
module_exit(example_exit)
|
|
||||||
|
|
||||||
MODULE_LICENSE("GPL");
|
|
||||||
MODULE_AUTHOR("Mathieu Desnoyers");
|
|
||||||
MODULE_DESCRIPTION("Marker example");
|
|
||||||
|
|
@ -1,92 +0,0 @@
|
||||||
/* probe-example.c
|
|
||||||
*
|
|
||||||
* Connects two functions to marker call sites.
|
|
||||||
*
|
|
||||||
* (C) Copyright 2007 Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
|
|
||||||
*
|
|
||||||
* This file is released under the GPLv2.
|
|
||||||
* See the file COPYING for more details.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <linux/sched.h>
|
|
||||||
#include <linux/kernel.h>
|
|
||||||
#include <linux/module.h>
|
|
||||||
#include <linux/marker.h>
|
|
||||||
#include <asm/atomic.h>
|
|
||||||
|
|
||||||
struct probe_data {
|
|
||||||
const char *name;
|
|
||||||
const char *format;
|
|
||||||
marker_probe_func *probe_func;
|
|
||||||
};
|
|
||||||
|
|
||||||
void probe_subsystem_event(void *probe_data, void *call_data,
|
|
||||||
const char *format, va_list *args)
|
|
||||||
{
|
|
||||||
/* Declare args */
|
|
||||||
unsigned int value;
|
|
||||||
const char *mystr;
|
|
||||||
|
|
||||||
/* Assign args */
|
|
||||||
value = va_arg(*args, typeof(value));
|
|
||||||
mystr = va_arg(*args, typeof(mystr));
|
|
||||||
|
|
||||||
/* Call printk */
|
|
||||||
printk(KERN_INFO "Value %u, string %s\n", value, mystr);
|
|
||||||
|
|
||||||
/* or count, check rights, serialize data in a buffer */
|
|
||||||
}
|
|
||||||
|
|
||||||
atomic_t eventb_count = ATOMIC_INIT(0);
|
|
||||||
|
|
||||||
void probe_subsystem_eventb(void *probe_data, void *call_data,
|
|
||||||
const char *format, va_list *args)
|
|
||||||
{
|
|
||||||
/* Increment counter */
|
|
||||||
atomic_inc(&eventb_count);
|
|
||||||
}
|
|
||||||
|
|
||||||
static struct probe_data probe_array[] =
|
|
||||||
{
|
|
||||||
{ .name = "subsystem_event",
|
|
||||||
.format = "integer %d string %s",
|
|
||||||
.probe_func = probe_subsystem_event },
|
|
||||||
{ .name = "subsystem_eventb",
|
|
||||||
.format = MARK_NOARGS,
|
|
||||||
.probe_func = probe_subsystem_eventb },
|
|
||||||
};
|
|
||||||
|
|
||||||
static int __init probe_init(void)
|
|
||||||
{
|
|
||||||
int result;
|
|
||||||
int i;
|
|
||||||
|
|
||||||
for (i = 0; i < ARRAY_SIZE(probe_array); i++) {
|
|
||||||
result = marker_probe_register(probe_array[i].name,
|
|
||||||
probe_array[i].format,
|
|
||||||
probe_array[i].probe_func, &probe_array[i]);
|
|
||||||
if (result)
|
|
||||||
printk(KERN_INFO "Unable to register probe %s\n",
|
|
||||||
probe_array[i].name);
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
static void __exit probe_fini(void)
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
|
|
||||||
for (i = 0; i < ARRAY_SIZE(probe_array); i++)
|
|
||||||
marker_probe_unregister(probe_array[i].name,
|
|
||||||
probe_array[i].probe_func, &probe_array[i]);
|
|
||||||
printk(KERN_INFO "Number of event b : %u\n",
|
|
||||||
atomic_read(&eventb_count));
|
|
||||||
marker_synchronize_unregister();
|
|
||||||
}
|
|
||||||
|
|
||||||
module_init(probe_init);
|
|
||||||
module_exit(probe_fini);
|
|
||||||
|
|
||||||
MODULE_LICENSE("GPL");
|
|
||||||
MODULE_AUTHOR("Mathieu Desnoyers");
|
|
||||||
MODULE_DESCRIPTION("SUBSYSTEM Probe");
|
|
||||||
|
|
@ -13,7 +13,6 @@
|
||||||
# 2) modpost is then used to
|
# 2) modpost is then used to
|
||||||
# 3) create one <module>.mod.c file pr. module
|
# 3) create one <module>.mod.c file pr. module
|
||||||
# 4) create one Module.symvers file with CRC for all exported symbols
|
# 4) create one Module.symvers file with CRC for all exported symbols
|
||||||
# 4a) [CONFIG_MARKERS] create one Module.markers file listing defined markers
|
|
||||||
# 5) compile all <module>.mod.c files
|
# 5) compile all <module>.mod.c files
|
||||||
# 6) final link of the module to a <module.ko> file
|
# 6) final link of the module to a <module.ko> file
|
||||||
|
|
||||||
|
|
@ -59,10 +58,6 @@ include scripts/Makefile.lib
|
||||||
|
|
||||||
kernelsymfile := $(objtree)/Module.symvers
|
kernelsymfile := $(objtree)/Module.symvers
|
||||||
modulesymfile := $(firstword $(KBUILD_EXTMOD))/Module.symvers
|
modulesymfile := $(firstword $(KBUILD_EXTMOD))/Module.symvers
|
||||||
kernelmarkersfile := $(objtree)/Module.markers
|
|
||||||
modulemarkersfile := $(firstword $(KBUILD_EXTMOD))/Module.markers
|
|
||||||
|
|
||||||
markersfile = $(if $(KBUILD_EXTMOD),$(modulemarkersfile),$(kernelmarkersfile))
|
|
||||||
|
|
||||||
# Step 1), find all modules listed in $(MODVERDIR)/
|
# Step 1), find all modules listed in $(MODVERDIR)/
|
||||||
__modules := $(sort $(shell grep -h '\.ko' /dev/null $(wildcard $(MODVERDIR)/*.mod)))
|
__modules := $(sort $(shell grep -h '\.ko' /dev/null $(wildcard $(MODVERDIR)/*.mod)))
|
||||||
|
|
@ -85,8 +80,6 @@ modpost = scripts/mod/modpost \
|
||||||
$(if $(KBUILD_EXTRA_SYMBOLS), $(patsubst %, -e %,$(KBUILD_EXTRA_SYMBOLS))) \
|
$(if $(KBUILD_EXTRA_SYMBOLS), $(patsubst %, -e %,$(KBUILD_EXTRA_SYMBOLS))) \
|
||||||
$(if $(KBUILD_EXTMOD),-o $(modulesymfile)) \
|
$(if $(KBUILD_EXTMOD),-o $(modulesymfile)) \
|
||||||
$(if $(CONFIG_DEBUG_SECTION_MISMATCH),,-S) \
|
$(if $(CONFIG_DEBUG_SECTION_MISMATCH),,-S) \
|
||||||
$(if $(CONFIG_MARKERS),-K $(kernelmarkersfile)) \
|
|
||||||
$(if $(CONFIG_MARKERS),-M $(markersfile)) \
|
|
||||||
$(if $(KBUILD_EXTMOD)$(KBUILD_MODPOST_WARN),-w) \
|
$(if $(KBUILD_EXTMOD)$(KBUILD_MODPOST_WARN),-w) \
|
||||||
$(if $(cross_build),-c)
|
$(if $(cross_build),-c)
|
||||||
|
|
||||||
|
|
@ -101,17 +94,12 @@ quiet_cmd_kernel-mod = MODPOST $@
|
||||||
cmd_kernel-mod = $(modpost) $@
|
cmd_kernel-mod = $(modpost) $@
|
||||||
|
|
||||||
vmlinux.o: FORCE
|
vmlinux.o: FORCE
|
||||||
@rm -fr $(kernelmarkersfile)
|
|
||||||
$(call cmd,kernel-mod)
|
$(call cmd,kernel-mod)
|
||||||
|
|
||||||
# Declare generated files as targets for modpost
|
# Declare generated files as targets for modpost
|
||||||
$(symverfile): __modpost ;
|
$(symverfile): __modpost ;
|
||||||
$(modules:.ko=.mod.c): __modpost ;
|
$(modules:.ko=.mod.c): __modpost ;
|
||||||
|
|
||||||
ifdef CONFIG_MARKERS
|
|
||||||
$(markersfile): __modpost ;
|
|
||||||
endif
|
|
||||||
|
|
||||||
|
|
||||||
# Step 5), compile all *.mod.c files
|
# Step 5), compile all *.mod.c files
|
||||||
|
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue