mirror of
https://github.com/Fishwaldo/Star64_linux.git
synced 2025-06-21 22:21:21 +00:00
Some clean ups and small fixes, but the biggest change is the addition
of the TRACE_DEFINE_ENUM() macro that can be used by tracepoints.
Tracepoints have helper functions for the TP_printk() called
__print_symbolic() and __print_flags() that lets a numeric number be
displayed as a a human comprehensible text. What is placed in the
TP_printk() is also shown in the tracepoint format file such that
user space tools like perf and trace-cmd can parse the binary data
and express the values too. Unfortunately, the way the TRACE_EVENT()
macro works, anything placed in the TP_printk() will be shown pretty
much exactly as is. The problem arises when enums are used. That's
because unlike macros, enums will not be changed into their values
by the C pre-processor. Thus, the enum string is exported to the
format file, and this makes it useless for user space tools.
The TRACE_DEFINE_ENUM() solves this by converting the enum strings
in the TP_printk() format into their number, and that is what is
shown to user space. For example, the tracepoint tlb_flush currently
has this in its format file:
__print_symbolic(REC->reason,
{ TLB_FLUSH_ON_TASK_SWITCH, "flush on task switch" },
{ TLB_REMOTE_SHOOTDOWN, "remote shootdown" },
{ TLB_LOCAL_SHOOTDOWN, "local shootdown" },
{ TLB_LOCAL_MM_SHOOTDOWN, "local mm shootdown" })
After adding:
TRACE_DEFINE_ENUM(TLB_FLUSH_ON_TASK_SWITCH);
TRACE_DEFINE_ENUM(TLB_REMOTE_SHOOTDOWN);
TRACE_DEFINE_ENUM(TLB_LOCAL_SHOOTDOWN);
TRACE_DEFINE_ENUM(TLB_LOCAL_MM_SHOOTDOWN);
Its format file will contain this:
__print_symbolic(REC->reason,
{ 0, "flush on task switch" },
{ 1, "remote shootdown" },
{ 2, "local shootdown" },
{ 3, "local mm shootdown" })
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1
iQEcBAABAgAGBQJVLBTuAAoJEEjnJuOKh9ldjHMIALdRS755TXCZGOf0r7O2akOR
wMPeum7C+ae1mH+jCsJKUC0/jUfQKaMt/UxoHlipDgcGg8kD2jtGnGCw4Xlwvdsr
y4rFmcTRSl1mo0zDSsg6ujoupHlVYN0+JPjrd7S3cv/llJoY49zcanNLF7S2XLeM
dZCtWRLWYpBiWO68ai6AqJTnE/eGFIqBI048qb5Eg8dbK243SSeSIf9Ywhb+VsA+
aq6F7cWI/H6j4tbeza8tAN19dcwenDro5EfCDY8ARQHJu1f6Y3+DLf2imjkd6Aiu
JVAoGIjHIpI+djwCZC1u4gi4urjfOqYartrM3Q54tb3YWYqHeNqP2ASI2a4EpYk=
=Ixwt
-----END PGP SIGNATURE-----
Merge tag 'trace-v4.1' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace
Pull tracing updates from Steven Rostedt:
"Some clean ups and small fixes, but the biggest change is the addition
of the TRACE_DEFINE_ENUM() macro that can be used by tracepoints.
Tracepoints have helper functions for the TP_printk() called
__print_symbolic() and __print_flags() that lets a numeric number be
displayed as a a human comprehensible text. What is placed in the
TP_printk() is also shown in the tracepoint format file such that user
space tools like perf and trace-cmd can parse the binary data and
express the values too. Unfortunately, the way the TRACE_EVENT()
macro works, anything placed in the TP_printk() will be shown pretty
much exactly as is. The problem arises when enums are used. That's
because unlike macros, enums will not be changed into their values by
the C pre-processor. Thus, the enum string is exported to the format
file, and this makes it useless for user space tools.
The TRACE_DEFINE_ENUM() solves this by converting the enum strings in
the TP_printk() format into their number, and that is what is shown to
user space. For example, the tracepoint tlb_flush currently has this
in its format file:
__print_symbolic(REC->reason,
{ TLB_FLUSH_ON_TASK_SWITCH, "flush on task switch" },
{ TLB_REMOTE_SHOOTDOWN, "remote shootdown" },
{ TLB_LOCAL_SHOOTDOWN, "local shootdown" },
{ TLB_LOCAL_MM_SHOOTDOWN, "local mm shootdown" })
After adding:
TRACE_DEFINE_ENUM(TLB_FLUSH_ON_TASK_SWITCH);
TRACE_DEFINE_ENUM(TLB_REMOTE_SHOOTDOWN);
TRACE_DEFINE_ENUM(TLB_LOCAL_SHOOTDOWN);
TRACE_DEFINE_ENUM(TLB_LOCAL_MM_SHOOTDOWN);
Its format file will contain this:
__print_symbolic(REC->reason,
{ 0, "flush on task switch" },
{ 1, "remote shootdown" },
{ 2, "local shootdown" },
{ 3, "local mm shootdown" })"
* tag 'trace-v4.1' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace: (27 commits)
tracing: Add enum_map file to show enums that have been mapped
writeback: Export enums used by tracepoint to user space
v4l: Export enums used by tracepoints to user space
SUNRPC: Export enums in tracepoints to user space
mm: tracing: Export enums in tracepoints to user space
irq/tracing: Export enums in tracepoints to user space
f2fs: Export the enums in the tracepoints to userspace
net/9p/tracing: Export enums in tracepoints to userspace
x86/tlb/trace: Export enums in used by tlb_flush tracepoint
tracing/samples: Update the trace-event-sample.h with TRACE_DEFINE_ENUM()
tracing: Allow for modules to convert their enums to values
tracing: Add TRACE_DEFINE_ENUM() macro to map enums to their values
tracing: Update trace-event-sample with TRACE_SYSTEM_VAR documentation
tracing: Give system name a pointer
brcmsmac: Move each system tracepoints to their own header
iwlwifi: Move each system tracepoints to their own header
mac80211: Move message tracepoints to their own header
tracing: Add TRACE_SYSTEM_VAR to xhci-hcd
tracing: Add TRACE_SYSTEM_VAR to kvm-s390
tracing: Add TRACE_SYSTEM_VAR to intel-sst
...
This commit is contained in:
Linus Torvalds
commit
eeee78cf77
52 changed files with 1959 additions and 909 deletions
|
|
@ -2770,6 +2770,9 @@ static int find_module_sections(struct module *mod, struct load_info *info)
|
|||
mod->trace_events = section_objs(info, "_ftrace_events",
|
||||
sizeof(*mod->trace_events),
|
||||
&mod->num_trace_events);
|
||||
mod->trace_enums = section_objs(info, "_ftrace_enum_map",
|
||||
sizeof(*mod->trace_enums),
|
||||
&mod->num_trace_enums);
|
||||
#endif
|
||||
#ifdef CONFIG_TRACING
|
||||
mod->trace_bprintk_fmt_start = section_objs(info, "__trace_printk_fmt",
|
||||
|
|
|
|||
|
|
@ -599,6 +599,34 @@ config RING_BUFFER_STARTUP_TEST
|
|||
|
||||
If unsure, say N
|
||||
|
||||
config TRACE_ENUM_MAP_FILE
|
||||
bool "Show enum mappings for trace events"
|
||||
depends on TRACING
|
||||
help
|
||||
The "print fmt" of the trace events will show the enum names instead
|
||||
of their values. This can cause problems for user space tools that
|
||||
use this string to parse the raw data as user space does not know
|
||||
how to convert the string to its value.
|
||||
|
||||
To fix this, there's a special macro in the kernel that can be used
|
||||
to convert the enum into its value. If this macro is used, then the
|
||||
print fmt strings will have the enums converted to their values.
|
||||
|
||||
If something does not get converted properly, this option can be
|
||||
used to show what enums the kernel tried to convert.
|
||||
|
||||
This option is for debugging the enum conversions. A file is created
|
||||
in the tracing directory called "enum_map" that will show the enum
|
||||
names matched with their values and what trace event system they
|
||||
belong too.
|
||||
|
||||
Normally, the mapping of the strings to values will be freed after
|
||||
boot up or module load. With this option, they will not be freed, as
|
||||
they are needed for the "enum_map" file. Enabling this option will
|
||||
increase the memory footprint of the running kernel.
|
||||
|
||||
If unsure, say N
|
||||
|
||||
endif # FTRACE
|
||||
|
||||
endif # TRACING_SUPPORT
|
||||
|
|
|
|||
|
|
@ -249,6 +249,19 @@ static void update_function_graph_func(void);
|
|||
static inline void update_function_graph_func(void) { }
|
||||
#endif
|
||||
|
||||
|
||||
static ftrace_func_t ftrace_ops_get_list_func(struct ftrace_ops *ops)
|
||||
{
|
||||
/*
|
||||
* If this is a dynamic ops or we force list func,
|
||||
* then it needs to call the list anyway.
|
||||
*/
|
||||
if (ops->flags & FTRACE_OPS_FL_DYNAMIC || FTRACE_FORCE_LIST_FUNC)
|
||||
return ftrace_ops_list_func;
|
||||
|
||||
return ftrace_ops_get_func(ops);
|
||||
}
|
||||
|
||||
static void update_ftrace_function(void)
|
||||
{
|
||||
ftrace_func_t func;
|
||||
|
|
@ -270,7 +283,7 @@ static void update_ftrace_function(void)
|
|||
* then have the mcount trampoline call the function directly.
|
||||
*/
|
||||
} else if (ftrace_ops_list->next == &ftrace_list_end) {
|
||||
func = ftrace_ops_get_func(ftrace_ops_list);
|
||||
func = ftrace_ops_get_list_func(ftrace_ops_list);
|
||||
|
||||
} else {
|
||||
/* Just use the default ftrace_ops */
|
||||
|
|
@ -5208,13 +5221,6 @@ static void ftrace_ops_recurs_func(unsigned long ip, unsigned long parent_ip,
|
|||
*/
|
||||
ftrace_func_t ftrace_ops_get_func(struct ftrace_ops *ops)
|
||||
{
|
||||
/*
|
||||
* If this is a dynamic ops or we force list func,
|
||||
* then it needs to call the list anyway.
|
||||
*/
|
||||
if (ops->flags & FTRACE_OPS_FL_DYNAMIC || FTRACE_FORCE_LIST_FUNC)
|
||||
return ftrace_ops_list_func;
|
||||
|
||||
/*
|
||||
* If the func handles its own recursion, call it directly.
|
||||
* Otherwise call the recursion protected function that
|
||||
|
|
|
|||
|
|
@ -2679,7 +2679,7 @@ static DEFINE_PER_CPU(unsigned int, current_context);
|
|||
|
||||
static __always_inline int trace_recursive_lock(void)
|
||||
{
|
||||
unsigned int val = this_cpu_read(current_context);
|
||||
unsigned int val = __this_cpu_read(current_context);
|
||||
int bit;
|
||||
|
||||
if (in_interrupt()) {
|
||||
|
|
@ -2696,18 +2696,14 @@ static __always_inline int trace_recursive_lock(void)
|
|||
return 1;
|
||||
|
||||
val |= (1 << bit);
|
||||
this_cpu_write(current_context, val);
|
||||
__this_cpu_write(current_context, val);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static __always_inline void trace_recursive_unlock(void)
|
||||
{
|
||||
unsigned int val = this_cpu_read(current_context);
|
||||
|
||||
val--;
|
||||
val &= this_cpu_read(current_context);
|
||||
this_cpu_write(current_context, val);
|
||||
__this_cpu_and(current_context, __this_cpu_read(current_context) - 1);
|
||||
}
|
||||
|
||||
#else
|
||||
|
|
|
|||
|
|
@ -125,6 +125,42 @@ enum ftrace_dump_mode ftrace_dump_on_oops;
|
|||
/* When set, tracing will stop when a WARN*() is hit */
|
||||
int __disable_trace_on_warning;
|
||||
|
||||
#ifdef CONFIG_TRACE_ENUM_MAP_FILE
|
||||
/* Map of enums to their values, for "enum_map" file */
|
||||
struct trace_enum_map_head {
|
||||
struct module *mod;
|
||||
unsigned long length;
|
||||
};
|
||||
|
||||
union trace_enum_map_item;
|
||||
|
||||
struct trace_enum_map_tail {
|
||||
/*
|
||||
* "end" is first and points to NULL as it must be different
|
||||
* than "mod" or "enum_string"
|
||||
*/
|
||||
union trace_enum_map_item *next;
|
||||
const char *end; /* points to NULL */
|
||||
};
|
||||
|
||||
static DEFINE_MUTEX(trace_enum_mutex);
|
||||
|
||||
/*
|
||||
* The trace_enum_maps are saved in an array with two extra elements,
|
||||
* one at the beginning, and one at the end. The beginning item contains
|
||||
* the count of the saved maps (head.length), and the module they
|
||||
* belong to if not built in (head.mod). The ending item contains a
|
||||
* pointer to the next array of saved enum_map items.
|
||||
*/
|
||||
union trace_enum_map_item {
|
||||
struct trace_enum_map map;
|
||||
struct trace_enum_map_head head;
|
||||
struct trace_enum_map_tail tail;
|
||||
};
|
||||
|
||||
static union trace_enum_map_item *trace_enum_maps;
|
||||
#endif /* CONFIG_TRACE_ENUM_MAP_FILE */
|
||||
|
||||
static int tracing_set_tracer(struct trace_array *tr, const char *buf);
|
||||
|
||||
#define MAX_TRACER_SIZE 100
|
||||
|
|
@ -3910,6 +3946,182 @@ static const struct file_operations tracing_saved_cmdlines_size_fops = {
|
|||
.write = tracing_saved_cmdlines_size_write,
|
||||
};
|
||||
|
||||
#ifdef CONFIG_TRACE_ENUM_MAP_FILE
|
||||
static union trace_enum_map_item *
|
||||
update_enum_map(union trace_enum_map_item *ptr)
|
||||
{
|
||||
if (!ptr->map.enum_string) {
|
||||
if (ptr->tail.next) {
|
||||
ptr = ptr->tail.next;
|
||||
/* Set ptr to the next real item (skip head) */
|
||||
ptr++;
|
||||
} else
|
||||
return NULL;
|
||||
}
|
||||
return ptr;
|
||||
}
|
||||
|
||||
static void *enum_map_next(struct seq_file *m, void *v, loff_t *pos)
|
||||
{
|
||||
union trace_enum_map_item *ptr = v;
|
||||
|
||||
/*
|
||||
* Paranoid! If ptr points to end, we don't want to increment past it.
|
||||
* This really should never happen.
|
||||
*/
|
||||
ptr = update_enum_map(ptr);
|
||||
if (WARN_ON_ONCE(!ptr))
|
||||
return NULL;
|
||||
|
||||
ptr++;
|
||||
|
||||
(*pos)++;
|
||||
|
||||
ptr = update_enum_map(ptr);
|
||||
|
||||
return ptr;
|
||||
}
|
||||
|
||||
static void *enum_map_start(struct seq_file *m, loff_t *pos)
|
||||
{
|
||||
union trace_enum_map_item *v;
|
||||
loff_t l = 0;
|
||||
|
||||
mutex_lock(&trace_enum_mutex);
|
||||
|
||||
v = trace_enum_maps;
|
||||
if (v)
|
||||
v++;
|
||||
|
||||
while (v && l < *pos) {
|
||||
v = enum_map_next(m, v, &l);
|
||||
}
|
||||
|
||||
return v;
|
||||
}
|
||||
|
||||
static void enum_map_stop(struct seq_file *m, void *v)
|
||||
{
|
||||
mutex_unlock(&trace_enum_mutex);
|
||||
}
|
||||
|
||||
static int enum_map_show(struct seq_file *m, void *v)
|
||||
{
|
||||
union trace_enum_map_item *ptr = v;
|
||||
|
||||
seq_printf(m, "%s %ld (%s)\n",
|
||||
ptr->map.enum_string, ptr->map.enum_value,
|
||||
ptr->map.system);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct seq_operations tracing_enum_map_seq_ops = {
|
||||
.start = enum_map_start,
|
||||
.next = enum_map_next,
|
||||
.stop = enum_map_stop,
|
||||
.show = enum_map_show,
|
||||
};
|
||||
|
||||
static int tracing_enum_map_open(struct inode *inode, struct file *filp)
|
||||
{
|
||||
if (tracing_disabled)
|
||||
return -ENODEV;
|
||||
|
||||
return seq_open(filp, &tracing_enum_map_seq_ops);
|
||||
}
|
||||
|
||||
static const struct file_operations tracing_enum_map_fops = {
|
||||
.open = tracing_enum_map_open,
|
||||
.read = seq_read,
|
||||
.llseek = seq_lseek,
|
||||
.release = seq_release,
|
||||
};
|
||||
|
||||
static inline union trace_enum_map_item *
|
||||
trace_enum_jmp_to_tail(union trace_enum_map_item *ptr)
|
||||
{
|
||||
/* Return tail of array given the head */
|
||||
return ptr + ptr->head.length + 1;
|
||||
}
|
||||
|
||||
static void
|
||||
trace_insert_enum_map_file(struct module *mod, struct trace_enum_map **start,
|
||||
int len)
|
||||
{
|
||||
struct trace_enum_map **stop;
|
||||
struct trace_enum_map **map;
|
||||
union trace_enum_map_item *map_array;
|
||||
union trace_enum_map_item *ptr;
|
||||
|
||||
stop = start + len;
|
||||
|
||||
/*
|
||||
* The trace_enum_maps contains the map plus a head and tail item,
|
||||
* where the head holds the module and length of array, and the
|
||||
* tail holds a pointer to the next list.
|
||||
*/
|
||||
map_array = kmalloc(sizeof(*map_array) * (len + 2), GFP_KERNEL);
|
||||
if (!map_array) {
|
||||
pr_warning("Unable to allocate trace enum mapping\n");
|
||||
return;
|
||||
}
|
||||
|
||||
mutex_lock(&trace_enum_mutex);
|
||||
|
||||
if (!trace_enum_maps)
|
||||
trace_enum_maps = map_array;
|
||||
else {
|
||||
ptr = trace_enum_maps;
|
||||
for (;;) {
|
||||
ptr = trace_enum_jmp_to_tail(ptr);
|
||||
if (!ptr->tail.next)
|
||||
break;
|
||||
ptr = ptr->tail.next;
|
||||
|
||||
}
|
||||
ptr->tail.next = map_array;
|
||||
}
|
||||
map_array->head.mod = mod;
|
||||
map_array->head.length = len;
|
||||
map_array++;
|
||||
|
||||
for (map = start; (unsigned long)map < (unsigned long)stop; map++) {
|
||||
map_array->map = **map;
|
||||
map_array++;
|
||||
}
|
||||
memset(map_array, 0, sizeof(*map_array));
|
||||
|
||||
mutex_unlock(&trace_enum_mutex);
|
||||
}
|
||||
|
||||
static void trace_create_enum_file(struct dentry *d_tracer)
|
||||
{
|
||||
trace_create_file("enum_map", 0444, d_tracer,
|
||||
NULL, &tracing_enum_map_fops);
|
||||
}
|
||||
|
||||
#else /* CONFIG_TRACE_ENUM_MAP_FILE */
|
||||
static inline void trace_create_enum_file(struct dentry *d_tracer) { }
|
||||
static inline void trace_insert_enum_map_file(struct module *mod,
|
||||
struct trace_enum_map **start, int len) { }
|
||||
#endif /* !CONFIG_TRACE_ENUM_MAP_FILE */
|
||||
|
||||
static void trace_insert_enum_map(struct module *mod,
|
||||
struct trace_enum_map **start, int len)
|
||||
{
|
||||
struct trace_enum_map **map;
|
||||
|
||||
if (len <= 0)
|
||||
return;
|
||||
|
||||
map = start;
|
||||
|
||||
trace_event_enum_update(map, len);
|
||||
|
||||
trace_insert_enum_map_file(mod, start, len);
|
||||
}
|
||||
|
||||
static ssize_t
|
||||
tracing_set_trace_read(struct file *filp, char __user *ubuf,
|
||||
size_t cnt, loff_t *ppos)
|
||||
|
|
@ -6527,6 +6739,88 @@ struct dentry *tracing_init_dentry(void)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
extern struct trace_enum_map *__start_ftrace_enum_maps[];
|
||||
extern struct trace_enum_map *__stop_ftrace_enum_maps[];
|
||||
|
||||
static void __init trace_enum_init(void)
|
||||
{
|
||||
int len;
|
||||
|
||||
len = __stop_ftrace_enum_maps - __start_ftrace_enum_maps;
|
||||
trace_insert_enum_map(NULL, __start_ftrace_enum_maps, len);
|
||||
}
|
||||
|
||||
#ifdef CONFIG_MODULES
|
||||
static void trace_module_add_enums(struct module *mod)
|
||||
{
|
||||
if (!mod->num_trace_enums)
|
||||
return;
|
||||
|
||||
/*
|
||||
* Modules with bad taint do not have events created, do
|
||||
* not bother with enums either.
|
||||
*/
|
||||
if (trace_module_has_bad_taint(mod))
|
||||
return;
|
||||
|
||||
trace_insert_enum_map(mod, mod->trace_enums, mod->num_trace_enums);
|
||||
}
|
||||
|
||||
#ifdef CONFIG_TRACE_ENUM_MAP_FILE
|
||||
static void trace_module_remove_enums(struct module *mod)
|
||||
{
|
||||
union trace_enum_map_item *map;
|
||||
union trace_enum_map_item **last = &trace_enum_maps;
|
||||
|
||||
if (!mod->num_trace_enums)
|
||||
return;
|
||||
|
||||
mutex_lock(&trace_enum_mutex);
|
||||
|
||||
map = trace_enum_maps;
|
||||
|
||||
while (map) {
|
||||
if (map->head.mod == mod)
|
||||
break;
|
||||
map = trace_enum_jmp_to_tail(map);
|
||||
last = &map->tail.next;
|
||||
map = map->tail.next;
|
||||
}
|
||||
if (!map)
|
||||
goto out;
|
||||
|
||||
*last = trace_enum_jmp_to_tail(map)->tail.next;
|
||||
kfree(map);
|
||||
out:
|
||||
mutex_unlock(&trace_enum_mutex);
|
||||
}
|
||||
#else
|
||||
static inline void trace_module_remove_enums(struct module *mod) { }
|
||||
#endif /* CONFIG_TRACE_ENUM_MAP_FILE */
|
||||
|
||||
static int trace_module_notify(struct notifier_block *self,
|
||||
unsigned long val, void *data)
|
||||
{
|
||||
struct module *mod = data;
|
||||
|
||||
switch (val) {
|
||||
case MODULE_STATE_COMING:
|
||||
trace_module_add_enums(mod);
|
||||
break;
|
||||
case MODULE_STATE_GOING:
|
||||
trace_module_remove_enums(mod);
|
||||
break;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct notifier_block trace_module_nb = {
|
||||
.notifier_call = trace_module_notify,
|
||||
.priority = 0,
|
||||
};
|
||||
#endif /* CONFIG_MODULES */
|
||||
|
||||
static __init int tracer_init_tracefs(void)
|
||||
{
|
||||
struct dentry *d_tracer;
|
||||
|
|
@ -6551,6 +6845,14 @@ static __init int tracer_init_tracefs(void)
|
|||
trace_create_file("saved_cmdlines_size", 0644, d_tracer,
|
||||
NULL, &tracing_saved_cmdlines_size_fops);
|
||||
|
||||
trace_enum_init();
|
||||
|
||||
trace_create_enum_file(d_tracer);
|
||||
|
||||
#ifdef CONFIG_MODULES
|
||||
register_module_notifier(&trace_module_nb);
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_DYNAMIC_FTRACE
|
||||
trace_create_file("dyn_ftrace_total_info", 0444, d_tracer,
|
||||
&ftrace_update_tot_cnt, &tracing_dyn_info_fops);
|
||||
|
|
@ -6877,7 +7179,7 @@ void __init trace_init(void)
|
|||
tracepoint_printk = 0;
|
||||
}
|
||||
tracer_alloc_buffers();
|
||||
trace_event_init();
|
||||
trace_event_init();
|
||||
}
|
||||
|
||||
__init static int clear_boot_tracer(void)
|
||||
|
|
|
|||
|
|
@ -1309,8 +1309,10 @@ static inline void init_ftrace_syscalls(void) { }
|
|||
|
||||
#ifdef CONFIG_EVENT_TRACING
|
||||
void trace_event_init(void);
|
||||
void trace_event_enum_update(struct trace_enum_map **map, int len);
|
||||
#else
|
||||
static inline void __init trace_event_init(void) { }
|
||||
static inlin void trace_event_enum_update(struct trace_enum_map **map, int len) { }
|
||||
#endif
|
||||
|
||||
extern struct trace_iterator *tracepoint_print_iter;
|
||||
|
|
|
|||
|
|
@ -223,7 +223,7 @@ FTRACE_ENTRY(bprint, bprint_entry,
|
|||
__dynamic_array( u32, buf )
|
||||
),
|
||||
|
||||
F_printk("%pf: %s",
|
||||
F_printk("%ps: %s",
|
||||
(void *)__entry->ip, __entry->fmt),
|
||||
|
||||
FILTER_OTHER
|
||||
|
|
@ -238,7 +238,7 @@ FTRACE_ENTRY(print, print_entry,
|
|||
__dynamic_array( char, buf )
|
||||
),
|
||||
|
||||
F_printk("%pf: %s",
|
||||
F_printk("%ps: %s",
|
||||
(void *)__entry->ip, __entry->buf),
|
||||
|
||||
FILTER_OTHER
|
||||
|
|
@ -253,7 +253,7 @@ FTRACE_ENTRY(bputs, bputs_entry,
|
|||
__field( const char *, str )
|
||||
),
|
||||
|
||||
F_printk("%pf: %s",
|
||||
F_printk("%ps: %s",
|
||||
(void *)__entry->ip, __entry->str),
|
||||
|
||||
FILTER_OTHER
|
||||
|
|
|
|||
|
|
@ -1704,6 +1704,125 @@ __register_event(struct ftrace_event_call *call, struct module *mod)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static char *enum_replace(char *ptr, struct trace_enum_map *map, int len)
|
||||
{
|
||||
int rlen;
|
||||
int elen;
|
||||
|
||||
/* Find the length of the enum value as a string */
|
||||
elen = snprintf(ptr, 0, "%ld", map->enum_value);
|
||||
/* Make sure there's enough room to replace the string with the value */
|
||||
if (len < elen)
|
||||
return NULL;
|
||||
|
||||
snprintf(ptr, elen + 1, "%ld", map->enum_value);
|
||||
|
||||
/* Get the rest of the string of ptr */
|
||||
rlen = strlen(ptr + len);
|
||||
memmove(ptr + elen, ptr + len, rlen);
|
||||
/* Make sure we end the new string */
|
||||
ptr[elen + rlen] = 0;
|
||||
|
||||
return ptr + elen;
|
||||
}
|
||||
|
||||
static void update_event_printk(struct ftrace_event_call *call,
|
||||
struct trace_enum_map *map)
|
||||
{
|
||||
char *ptr;
|
||||
int quote = 0;
|
||||
int len = strlen(map->enum_string);
|
||||
|
||||
for (ptr = call->print_fmt; *ptr; ptr++) {
|
||||
if (*ptr == '\\') {
|
||||
ptr++;
|
||||
/* paranoid */
|
||||
if (!*ptr)
|
||||
break;
|
||||
continue;
|
||||
}
|
||||
if (*ptr == '"') {
|
||||
quote ^= 1;
|
||||
continue;
|
||||
}
|
||||
if (quote)
|
||||
continue;
|
||||
if (isdigit(*ptr)) {
|
||||
/* skip numbers */
|
||||
do {
|
||||
ptr++;
|
||||
/* Check for alpha chars like ULL */
|
||||
} while (isalnum(*ptr));
|
||||
/*
|
||||
* A number must have some kind of delimiter after
|
||||
* it, and we can ignore that too.
|
||||
*/
|
||||
continue;
|
||||
}
|
||||
if (isalpha(*ptr) || *ptr == '_') {
|
||||
if (strncmp(map->enum_string, ptr, len) == 0 &&
|
||||
!isalnum(ptr[len]) && ptr[len] != '_') {
|
||||
ptr = enum_replace(ptr, map, len);
|
||||
/* Hmm, enum string smaller than value */
|
||||
if (WARN_ON_ONCE(!ptr))
|
||||
return;
|
||||
/*
|
||||
* No need to decrement here, as enum_replace()
|
||||
* returns the pointer to the character passed
|
||||
* the enum, and two enums can not be placed
|
||||
* back to back without something in between.
|
||||
* We can skip that something in between.
|
||||
*/
|
||||
continue;
|
||||
}
|
||||
skip_more:
|
||||
do {
|
||||
ptr++;
|
||||
} while (isalnum(*ptr) || *ptr == '_');
|
||||
/*
|
||||
* If what comes after this variable is a '.' or
|
||||
* '->' then we can continue to ignore that string.
|
||||
*/
|
||||
if (*ptr == '.' || (ptr[0] == '-' && ptr[1] == '>')) {
|
||||
ptr += *ptr == '.' ? 1 : 2;
|
||||
goto skip_more;
|
||||
}
|
||||
/*
|
||||
* Once again, we can skip the delimiter that came
|
||||
* after the string.
|
||||
*/
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void trace_event_enum_update(struct trace_enum_map **map, int len)
|
||||
{
|
||||
struct ftrace_event_call *call, *p;
|
||||
const char *last_system = NULL;
|
||||
int last_i;
|
||||
int i;
|
||||
|
||||
down_write(&trace_event_sem);
|
||||
list_for_each_entry_safe(call, p, &ftrace_events, list) {
|
||||
/* events are usually grouped together with systems */
|
||||
if (!last_system || call->class->system != last_system) {
|
||||
last_i = 0;
|
||||
last_system = call->class->system;
|
||||
}
|
||||
|
||||
for (i = last_i; i < len; i++) {
|
||||
if (call->class->system == map[i]->system) {
|
||||
/* Save the first system if need be */
|
||||
if (!last_i)
|
||||
last_i = i;
|
||||
update_event_printk(call, map[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
up_write(&trace_event_sem);
|
||||
}
|
||||
|
||||
static struct ftrace_event_file *
|
||||
trace_create_new_event(struct ftrace_event_call *call,
|
||||
struct trace_array *tr)
|
||||
|
|
@ -1915,7 +2034,7 @@ static int trace_module_notify(struct notifier_block *self,
|
|||
|
||||
static struct notifier_block trace_module_nb = {
|
||||
.notifier_call = trace_module_notify,
|
||||
.priority = 0,
|
||||
.priority = 1, /* higher than trace.c module notify */
|
||||
};
|
||||
#endif /* CONFIG_MODULES */
|
||||
|
||||
|
|
|
|||
|
|
@ -177,7 +177,7 @@ struct ftrace_event_call __used event_##call = { \
|
|||
}, \
|
||||
.event.type = etype, \
|
||||
.print_fmt = print, \
|
||||
.flags = TRACE_EVENT_FL_IGNORE_ENABLE | TRACE_EVENT_FL_USE_CALL_FILTER, \
|
||||
.flags = TRACE_EVENT_FL_IGNORE_ENABLE, \
|
||||
}; \
|
||||
struct ftrace_event_call __used \
|
||||
__attribute__((section("_ftrace_events"))) *__event_##call = &event_##call;
|
||||
|
|
|
|||
|
|
@ -250,7 +250,7 @@ DEFINE_FETCH_symbol(string_size)
|
|||
#define fetch_file_offset_string_size NULL
|
||||
|
||||
/* Fetch type information table */
|
||||
const struct fetch_type kprobes_fetch_type_table[] = {
|
||||
static const struct fetch_type kprobes_fetch_type_table[] = {
|
||||
/* Special types */
|
||||
[FETCH_TYPE_STRING] = __ASSIGN_FETCH_TYPE("string", string, string,
|
||||
sizeof(u32), 1, "__data_loc char[]"),
|
||||
|
|
@ -760,7 +760,8 @@ static int create_trace_kprobe(int argc, char **argv)
|
|||
|
||||
/* Parse fetch argument */
|
||||
ret = traceprobe_parse_probe_arg(arg, &tk->tp.size, parg,
|
||||
is_return, true);
|
||||
is_return, true,
|
||||
kprobes_fetch_type_table);
|
||||
if (ret) {
|
||||
pr_info("Parse error at argument[%d]. (%d)\n", i, ret);
|
||||
goto error;
|
||||
|
|
|
|||
|
|
@ -356,17 +356,14 @@ static int parse_probe_vars(char *arg, const struct fetch_type *t,
|
|||
|
||||
/* Recursive argument parser */
|
||||
static int parse_probe_arg(char *arg, const struct fetch_type *t,
|
||||
struct fetch_param *f, bool is_return, bool is_kprobe)
|
||||
struct fetch_param *f, bool is_return, bool is_kprobe,
|
||||
const struct fetch_type *ftbl)
|
||||
{
|
||||
const struct fetch_type *ftbl;
|
||||
unsigned long param;
|
||||
long offset;
|
||||
char *tmp;
|
||||
int ret = 0;
|
||||
|
||||
ftbl = is_kprobe ? kprobes_fetch_type_table : uprobes_fetch_type_table;
|
||||
BUG_ON(ftbl == NULL);
|
||||
|
||||
switch (arg[0]) {
|
||||
case '$':
|
||||
ret = parse_probe_vars(arg + 1, t, f, is_return, is_kprobe);
|
||||
|
|
@ -447,7 +444,7 @@ static int parse_probe_arg(char *arg, const struct fetch_type *t,
|
|||
dprm->fetch_size = get_fetch_size_function(t,
|
||||
dprm->fetch, ftbl);
|
||||
ret = parse_probe_arg(arg, t2, &dprm->orig, is_return,
|
||||
is_kprobe);
|
||||
is_kprobe, ftbl);
|
||||
if (ret)
|
||||
kfree(dprm);
|
||||
else {
|
||||
|
|
@ -505,15 +502,12 @@ static int __parse_bitfield_probe_arg(const char *bf,
|
|||
|
||||
/* String length checking wrapper */
|
||||
int traceprobe_parse_probe_arg(char *arg, ssize_t *size,
|
||||
struct probe_arg *parg, bool is_return, bool is_kprobe)
|
||||
struct probe_arg *parg, bool is_return, bool is_kprobe,
|
||||
const struct fetch_type *ftbl)
|
||||
{
|
||||
const struct fetch_type *ftbl;
|
||||
const char *t;
|
||||
int ret;
|
||||
|
||||
ftbl = is_kprobe ? kprobes_fetch_type_table : uprobes_fetch_type_table;
|
||||
BUG_ON(ftbl == NULL);
|
||||
|
||||
if (strlen(arg) > MAX_ARGSTR_LEN) {
|
||||
pr_info("Argument is too long.: %s\n", arg);
|
||||
return -ENOSPC;
|
||||
|
|
@ -535,7 +529,8 @@ int traceprobe_parse_probe_arg(char *arg, ssize_t *size,
|
|||
}
|
||||
parg->offset = *size;
|
||||
*size += parg->type->size;
|
||||
ret = parse_probe_arg(arg, parg->type, &parg->fetch, is_return, is_kprobe);
|
||||
ret = parse_probe_arg(arg, parg->type, &parg->fetch, is_return,
|
||||
is_kprobe, ftbl);
|
||||
|
||||
if (ret >= 0 && t != NULL)
|
||||
ret = __parse_bitfield_probe_arg(t, parg->type, &parg->fetch);
|
||||
|
|
|
|||
|
|
@ -229,13 +229,6 @@ ASSIGN_FETCH_FUNC(file_offset, ftype), \
|
|||
#define FETCH_TYPE_STRING 0
|
||||
#define FETCH_TYPE_STRSIZE 1
|
||||
|
||||
/*
|
||||
* Fetch type information table.
|
||||
* It's declared as a weak symbol due to conditional compilation.
|
||||
*/
|
||||
extern __weak const struct fetch_type kprobes_fetch_type_table[];
|
||||
extern __weak const struct fetch_type uprobes_fetch_type_table[];
|
||||
|
||||
#ifdef CONFIG_KPROBE_EVENT
|
||||
struct symbol_cache;
|
||||
unsigned long update_symbol_cache(struct symbol_cache *sc);
|
||||
|
|
@ -333,7 +326,8 @@ find_event_file_link(struct trace_probe *tp, struct ftrace_event_file *file)
|
|||
}
|
||||
|
||||
extern int traceprobe_parse_probe_arg(char *arg, ssize_t *size,
|
||||
struct probe_arg *parg, bool is_return, bool is_kprobe);
|
||||
struct probe_arg *parg, bool is_return, bool is_kprobe,
|
||||
const struct fetch_type *ftbl);
|
||||
|
||||
extern int traceprobe_conflict_field_name(const char *name,
|
||||
struct probe_arg *args, int narg);
|
||||
|
|
|
|||
|
|
@ -196,7 +196,7 @@ DEFINE_FETCH_file_offset(string)
|
|||
DEFINE_FETCH_file_offset(string_size)
|
||||
|
||||
/* Fetch type information table */
|
||||
const struct fetch_type uprobes_fetch_type_table[] = {
|
||||
static const struct fetch_type uprobes_fetch_type_table[] = {
|
||||
/* Special types */
|
||||
[FETCH_TYPE_STRING] = __ASSIGN_FETCH_TYPE("string", string, string,
|
||||
sizeof(u32), 1, "__data_loc char[]"),
|
||||
|
|
@ -535,7 +535,8 @@ static int create_trace_uprobe(int argc, char **argv)
|
|||
|
||||
/* Parse fetch argument */
|
||||
ret = traceprobe_parse_probe_arg(arg, &tu->tp.size, parg,
|
||||
is_return, false);
|
||||
is_return, false,
|
||||
uprobes_fetch_type_table);
|
||||
if (ret) {
|
||||
pr_info("Parse error at argument[%d]. (%d)\n", i, ret);
|
||||
goto error;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue