2009-02-24 08:21:36 -07:00
|
|
|
/*
|
|
|
|
* event tracer
|
|
|
|
*
|
|
|
|
* Copyright (C) 2008 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
|
|
|
|
*
|
2009-03-02 11:53:59 -07:00
|
|
|
* - Added format output of fields of the trace point.
|
|
|
|
* This was based off of work by Tom Zanussi <tzanussi@gmail.com>.
|
|
|
|
*
|
2009-02-24 08:21:36 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/debugfs.h>
|
|
|
|
#include <linux/uaccess.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/ctype.h>
|
|
|
|
|
2009-03-02 13:03:01 -07:00
|
|
|
#include "trace_output.h"
|
2009-02-24 08:21:36 -07:00
|
|
|
|
2009-02-27 21:32:58 -07:00
|
|
|
#define TRACE_SYSTEM "TRACE_SYSTEM"
|
|
|
|
|
2009-03-02 09:49:04 -07:00
|
|
|
static DEFINE_MUTEX(event_mutex);
|
|
|
|
|
2009-03-22 02:30:39 -06:00
|
|
|
int trace_define_field(struct ftrace_event_call *call, char *type,
|
|
|
|
char *name, int offset, int size)
|
|
|
|
{
|
|
|
|
struct ftrace_event_field *field;
|
|
|
|
|
|
|
|
field = kmalloc(sizeof(*field), GFP_KERNEL);
|
|
|
|
if (!field)
|
|
|
|
goto err;
|
|
|
|
field->name = kstrdup(name, GFP_KERNEL);
|
|
|
|
if (!field->name)
|
|
|
|
goto err;
|
|
|
|
field->type = kstrdup(type, GFP_KERNEL);
|
|
|
|
if (!field->type)
|
|
|
|
goto err;
|
|
|
|
field->offset = offset;
|
|
|
|
field->size = size;
|
|
|
|
list_add(&field->link, &call->fields);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
err:
|
|
|
|
if (field) {
|
|
|
|
kfree(field->name);
|
|
|
|
kfree(field->type);
|
|
|
|
}
|
|
|
|
kfree(field);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2009-02-24 08:21:36 -07:00
|
|
|
static void ftrace_clear_events(void)
|
|
|
|
{
|
|
|
|
struct ftrace_event_call *call = (void *)__start_ftrace_events;
|
|
|
|
|
|
|
|
|
|
|
|
while ((unsigned long)call < (unsigned long)__stop_ftrace_events) {
|
|
|
|
|
|
|
|
if (call->enabled) {
|
|
|
|
call->enabled = 0;
|
|
|
|
call->unregfunc();
|
|
|
|
}
|
|
|
|
call++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-28 00:41:25 -07:00
|
|
|
static void ftrace_event_enable_disable(struct ftrace_event_call *call,
|
|
|
|
int enable)
|
|
|
|
{
|
|
|
|
|
|
|
|
switch (enable) {
|
|
|
|
case 0:
|
|
|
|
if (call->enabled) {
|
|
|
|
call->enabled = 0;
|
|
|
|
call->unregfunc();
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 1:
|
tracing: new format for specialized trace points
Impact: clean up and enhancement
The TRACE_EVENT_FORMAT macro looks quite ugly and is limited in its
ability to save data as well as to print the record out. Working with
Ingo Molnar, we came up with a new format that is much more pleasing to
the eye of C developers. This new macro is more C style than the old
macro, and is more obvious to what it does.
Here's the example. The only updated macro in this patch is the
sched_switch trace point.
The old method looked like this:
TRACE_EVENT_FORMAT(sched_switch,
TP_PROTO(struct rq *rq, struct task_struct *prev,
struct task_struct *next),
TP_ARGS(rq, prev, next),
TP_FMT("task %s:%d ==> %s:%d",
prev->comm, prev->pid, next->comm, next->pid),
TRACE_STRUCT(
TRACE_FIELD(pid_t, prev_pid, prev->pid)
TRACE_FIELD(int, prev_prio, prev->prio)
TRACE_FIELD_SPECIAL(char next_comm[TASK_COMM_LEN],
next_comm,
TP_CMD(memcpy(TRACE_ENTRY->next_comm,
next->comm,
TASK_COMM_LEN)))
TRACE_FIELD(pid_t, next_pid, next->pid)
TRACE_FIELD(int, next_prio, next->prio)
),
TP_RAW_FMT("prev %d:%d ==> next %s:%d:%d")
);
The above method is hard to read and requires two format fields.
The new method:
/*
* Tracepoint for task switches, performed by the scheduler:
*
* (NOTE: the 'rq' argument is not used by generic trace events,
* but used by the latency tracer plugin. )
*/
TRACE_EVENT(sched_switch,
TP_PROTO(struct rq *rq, struct task_struct *prev,
struct task_struct *next),
TP_ARGS(rq, prev, next),
TP_STRUCT__entry(
__array( char, prev_comm, TASK_COMM_LEN )
__field( pid_t, prev_pid )
__field( int, prev_prio )
__array( char, next_comm, TASK_COMM_LEN )
__field( pid_t, next_pid )
__field( int, next_prio )
),
TP_printk("task %s:%d [%d] ==> %s:%d [%d]",
__entry->prev_comm, __entry->prev_pid, __entry->prev_prio,
__entry->next_comm, __entry->next_pid, __entry->next_prio),
TP_fast_assign(
memcpy(__entry->next_comm, next->comm, TASK_COMM_LEN);
__entry->prev_pid = prev->pid;
__entry->prev_prio = prev->prio;
memcpy(__entry->prev_comm, prev->comm, TASK_COMM_LEN);
__entry->next_pid = next->pid;
__entry->next_prio = next->prio;
)
);
This macro is called TRACE_EVENT, it is broken up into 5 parts:
TP_PROTO: the proto type of the trace point
TP_ARGS: the arguments of the trace point
TP_STRUCT_entry: the structure layout of the entry in the ring buffer
TP_printk: the printk format
TP_fast_assign: the method used to write the entry into the ring buffer
The structure is the definition of how the event will be saved in the
ring buffer. The printk is used by the internal tracing in case of
an oops, and the kernel needs to print out the format of the record
to the console. This the TP_printk gives a means to show the records
in a human readable format. It is also used to print out the data
from the trace file.
The TP_fast_assign is executed directly. It is basically like a C function,
where the __entry is the handle to the record.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
2009-03-09 15:14:30 -06:00
|
|
|
if (!call->enabled) {
|
2009-02-28 00:41:25 -07:00
|
|
|
call->enabled = 1;
|
|
|
|
call->regfunc();
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-24 08:21:36 -07:00
|
|
|
static int ftrace_set_clr_event(char *buf, int set)
|
|
|
|
{
|
2009-02-24 12:15:08 -07:00
|
|
|
struct ftrace_event_call *call = __start_ftrace_events;
|
2009-02-27 21:32:58 -07:00
|
|
|
char *event = NULL, *sub = NULL, *match;
|
|
|
|
int ret = -EINVAL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The buf format can be <subsystem>:<event-name>
|
|
|
|
* *:<event-name> means any event by that name.
|
|
|
|
* :<event-name> is the same.
|
|
|
|
*
|
|
|
|
* <subsystem>:* means all events in that subsystem
|
|
|
|
* <subsystem>: means the same.
|
|
|
|
*
|
|
|
|
* <name> (no ':') means all events in a subsystem with
|
|
|
|
* the name <name> or any event that matches <name>
|
|
|
|
*/
|
|
|
|
|
|
|
|
match = strsep(&buf, ":");
|
|
|
|
if (buf) {
|
|
|
|
sub = match;
|
|
|
|
event = buf;
|
|
|
|
match = NULL;
|
|
|
|
|
|
|
|
if (!strlen(sub) || strcmp(sub, "*") == 0)
|
|
|
|
sub = NULL;
|
|
|
|
if (!strlen(event) || strcmp(event, "*") == 0)
|
|
|
|
event = NULL;
|
|
|
|
}
|
2009-02-24 08:21:36 -07:00
|
|
|
|
2009-03-02 09:49:04 -07:00
|
|
|
mutex_lock(&event_mutex);
|
2009-03-19 13:26:15 -06:00
|
|
|
for_each_event(call) {
|
2009-02-24 08:21:36 -07:00
|
|
|
|
2009-03-10 09:32:40 -06:00
|
|
|
if (!call->name || !call->regfunc)
|
2009-02-24 12:15:08 -07:00
|
|
|
continue;
|
|
|
|
|
2009-02-27 21:32:58 -07:00
|
|
|
if (match &&
|
|
|
|
strcmp(match, call->name) != 0 &&
|
|
|
|
strcmp(match, call->system) != 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (sub && strcmp(sub, call->system) != 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (event && strcmp(event, call->name) != 0)
|
2009-02-24 08:21:36 -07:00
|
|
|
continue;
|
|
|
|
|
2009-02-28 00:41:25 -07:00
|
|
|
ftrace_event_enable_disable(call, set);
|
|
|
|
|
2009-02-27 21:32:58 -07:00
|
|
|
ret = 0;
|
2009-02-24 08:21:36 -07:00
|
|
|
}
|
2009-03-02 09:49:04 -07:00
|
|
|
mutex_unlock(&event_mutex);
|
|
|
|
|
2009-02-27 21:32:58 -07:00
|
|
|
return ret;
|
2009-02-24 08:21:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 128 should be much more than enough */
|
|
|
|
#define EVENT_BUF_SIZE 127
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
ftrace_event_write(struct file *file, const char __user *ubuf,
|
|
|
|
size_t cnt, loff_t *ppos)
|
|
|
|
{
|
|
|
|
size_t read = 0;
|
|
|
|
int i, set = 1;
|
|
|
|
ssize_t ret;
|
|
|
|
char *buf;
|
|
|
|
char ch;
|
|
|
|
|
|
|
|
if (!cnt || cnt < 0)
|
|
|
|
return 0;
|
|
|
|
|
2009-03-11 12:33:00 -06:00
|
|
|
ret = tracing_update_buffers();
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2009-02-24 08:21:36 -07:00
|
|
|
ret = get_user(ch, ubuf++);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
read++;
|
|
|
|
cnt--;
|
|
|
|
|
|
|
|
/* skip white space */
|
|
|
|
while (cnt && isspace(ch)) {
|
|
|
|
ret = get_user(ch, ubuf++);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
read++;
|
|
|
|
cnt--;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Only white space found? */
|
|
|
|
if (isspace(ch)) {
|
|
|
|
file->f_pos += read;
|
|
|
|
ret = read;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
buf = kmalloc(EVENT_BUF_SIZE+1, GFP_KERNEL);
|
|
|
|
if (!buf)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (cnt > EVENT_BUF_SIZE)
|
|
|
|
cnt = EVENT_BUF_SIZE;
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
while (cnt && !isspace(ch)) {
|
|
|
|
if (!i && ch == '!')
|
|
|
|
set = 0;
|
|
|
|
else
|
|
|
|
buf[i++] = ch;
|
|
|
|
|
|
|
|
ret = get_user(ch, ubuf++);
|
|
|
|
if (ret)
|
|
|
|
goto out_free;
|
|
|
|
read++;
|
|
|
|
cnt--;
|
|
|
|
}
|
|
|
|
buf[i] = 0;
|
|
|
|
|
|
|
|
file->f_pos += read;
|
|
|
|
|
|
|
|
ret = ftrace_set_clr_event(buf, set);
|
|
|
|
if (ret)
|
|
|
|
goto out_free;
|
|
|
|
|
|
|
|
ret = read;
|
|
|
|
|
|
|
|
out_free:
|
|
|
|
kfree(buf);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *
|
|
|
|
t_next(struct seq_file *m, void *v, loff_t *pos)
|
|
|
|
{
|
|
|
|
struct ftrace_event_call *call = m->private;
|
|
|
|
struct ftrace_event_call *next = call;
|
|
|
|
|
|
|
|
(*pos)++;
|
|
|
|
|
2009-03-10 09:32:40 -06:00
|
|
|
for (;;) {
|
|
|
|
if ((unsigned long)call >= (unsigned long)__stop_ftrace_events)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The ftrace subsystem is for showing formats only.
|
|
|
|
* They can not be enabled or disabled via the event files.
|
|
|
|
*/
|
|
|
|
if (call->regfunc)
|
|
|
|
break;
|
|
|
|
|
|
|
|
call++;
|
|
|
|
next = call;
|
|
|
|
}
|
2009-02-24 08:21:36 -07:00
|
|
|
|
|
|
|
m->private = ++next;
|
|
|
|
|
|
|
|
return call;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *t_start(struct seq_file *m, loff_t *pos)
|
|
|
|
{
|
|
|
|
return t_next(m, NULL, pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *
|
|
|
|
s_next(struct seq_file *m, void *v, loff_t *pos)
|
|
|
|
{
|
|
|
|
struct ftrace_event_call *call = m->private;
|
|
|
|
struct ftrace_event_call *next;
|
|
|
|
|
|
|
|
(*pos)++;
|
|
|
|
|
|
|
|
retry:
|
|
|
|
if ((unsigned long)call >= (unsigned long)__stop_ftrace_events)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (!call->enabled) {
|
|
|
|
call++;
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
|
|
|
|
next = call;
|
|
|
|
m->private = ++next;
|
|
|
|
|
|
|
|
return call;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *s_start(struct seq_file *m, loff_t *pos)
|
|
|
|
{
|
|
|
|
return s_next(m, NULL, pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int t_show(struct seq_file *m, void *v)
|
|
|
|
{
|
|
|
|
struct ftrace_event_call *call = v;
|
|
|
|
|
2009-02-27 21:32:58 -07:00
|
|
|
if (strcmp(call->system, TRACE_SYSTEM) != 0)
|
|
|
|
seq_printf(m, "%s:", call->system);
|
2009-02-24 08:21:36 -07:00
|
|
|
seq_printf(m, "%s\n", call->name);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void t_stop(struct seq_file *m, void *p)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
ftrace_event_seq_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
const struct seq_operations *seq_ops;
|
|
|
|
|
|
|
|
if ((file->f_mode & FMODE_WRITE) &&
|
|
|
|
!(file->f_flags & O_APPEND))
|
|
|
|
ftrace_clear_events();
|
|
|
|
|
|
|
|
seq_ops = inode->i_private;
|
|
|
|
ret = seq_open(file, seq_ops);
|
|
|
|
if (!ret) {
|
|
|
|
struct seq_file *m = file->private_data;
|
|
|
|
|
|
|
|
m->private = __start_ftrace_events;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-02-24 12:15:08 -07:00
|
|
|
static ssize_t
|
|
|
|
event_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
|
|
|
|
loff_t *ppos)
|
|
|
|
{
|
|
|
|
struct ftrace_event_call *call = filp->private_data;
|
|
|
|
char *buf;
|
|
|
|
|
tracing: new format for specialized trace points
Impact: clean up and enhancement
The TRACE_EVENT_FORMAT macro looks quite ugly and is limited in its
ability to save data as well as to print the record out. Working with
Ingo Molnar, we came up with a new format that is much more pleasing to
the eye of C developers. This new macro is more C style than the old
macro, and is more obvious to what it does.
Here's the example. The only updated macro in this patch is the
sched_switch trace point.
The old method looked like this:
TRACE_EVENT_FORMAT(sched_switch,
TP_PROTO(struct rq *rq, struct task_struct *prev,
struct task_struct *next),
TP_ARGS(rq, prev, next),
TP_FMT("task %s:%d ==> %s:%d",
prev->comm, prev->pid, next->comm, next->pid),
TRACE_STRUCT(
TRACE_FIELD(pid_t, prev_pid, prev->pid)
TRACE_FIELD(int, prev_prio, prev->prio)
TRACE_FIELD_SPECIAL(char next_comm[TASK_COMM_LEN],
next_comm,
TP_CMD(memcpy(TRACE_ENTRY->next_comm,
next->comm,
TASK_COMM_LEN)))
TRACE_FIELD(pid_t, next_pid, next->pid)
TRACE_FIELD(int, next_prio, next->prio)
),
TP_RAW_FMT("prev %d:%d ==> next %s:%d:%d")
);
The above method is hard to read and requires two format fields.
The new method:
/*
* Tracepoint for task switches, performed by the scheduler:
*
* (NOTE: the 'rq' argument is not used by generic trace events,
* but used by the latency tracer plugin. )
*/
TRACE_EVENT(sched_switch,
TP_PROTO(struct rq *rq, struct task_struct *prev,
struct task_struct *next),
TP_ARGS(rq, prev, next),
TP_STRUCT__entry(
__array( char, prev_comm, TASK_COMM_LEN )
__field( pid_t, prev_pid )
__field( int, prev_prio )
__array( char, next_comm, TASK_COMM_LEN )
__field( pid_t, next_pid )
__field( int, next_prio )
),
TP_printk("task %s:%d [%d] ==> %s:%d [%d]",
__entry->prev_comm, __entry->prev_pid, __entry->prev_prio,
__entry->next_comm, __entry->next_pid, __entry->next_prio),
TP_fast_assign(
memcpy(__entry->next_comm, next->comm, TASK_COMM_LEN);
__entry->prev_pid = prev->pid;
__entry->prev_prio = prev->prio;
memcpy(__entry->prev_comm, prev->comm, TASK_COMM_LEN);
__entry->next_pid = next->pid;
__entry->next_prio = next->prio;
)
);
This macro is called TRACE_EVENT, it is broken up into 5 parts:
TP_PROTO: the proto type of the trace point
TP_ARGS: the arguments of the trace point
TP_STRUCT_entry: the structure layout of the entry in the ring buffer
TP_printk: the printk format
TP_fast_assign: the method used to write the entry into the ring buffer
The structure is the definition of how the event will be saved in the
ring buffer. The printk is used by the internal tracing in case of
an oops, and the kernel needs to print out the format of the record
to the console. This the TP_printk gives a means to show the records
in a human readable format. It is also used to print out the data
from the trace file.
The TP_fast_assign is executed directly. It is basically like a C function,
where the __entry is the handle to the record.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
2009-03-09 15:14:30 -06:00
|
|
|
if (call->enabled)
|
2009-02-24 12:15:08 -07:00
|
|
|
buf = "1\n";
|
|
|
|
else
|
|
|
|
buf = "0\n";
|
|
|
|
|
|
|
|
return simple_read_from_buffer(ubuf, cnt, ppos, buf, 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
event_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
|
|
|
|
loff_t *ppos)
|
|
|
|
{
|
|
|
|
struct ftrace_event_call *call = filp->private_data;
|
|
|
|
char buf[64];
|
|
|
|
unsigned long val;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (cnt >= sizeof(buf))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (copy_from_user(&buf, ubuf, cnt))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
buf[cnt] = 0;
|
|
|
|
|
|
|
|
ret = strict_strtoul(buf, 10, &val);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2009-03-11 12:33:00 -06:00
|
|
|
ret = tracing_update_buffers();
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2009-02-24 12:15:08 -07:00
|
|
|
switch (val) {
|
|
|
|
case 0:
|
|
|
|
case 1:
|
2009-03-02 09:49:04 -07:00
|
|
|
mutex_lock(&event_mutex);
|
2009-02-28 00:41:25 -07:00
|
|
|
ftrace_event_enable_disable(call, val);
|
2009-03-02 09:49:04 -07:00
|
|
|
mutex_unlock(&event_mutex);
|
2009-02-24 12:15:08 -07:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
*ppos += cnt;
|
|
|
|
|
|
|
|
return cnt;
|
|
|
|
}
|
|
|
|
|
2009-03-02 13:03:01 -07:00
|
|
|
#undef FIELD
|
2009-03-06 08:50:53 -07:00
|
|
|
#define FIELD(type, name) \
|
2009-03-22 02:30:39 -06:00
|
|
|
#type, "common_" #name, offsetof(typeof(field), name), \
|
|
|
|
sizeof(field.name)
|
2009-03-02 13:03:01 -07:00
|
|
|
|
|
|
|
static int trace_write_header(struct trace_seq *s)
|
|
|
|
{
|
|
|
|
struct trace_entry field;
|
|
|
|
|
|
|
|
/* struct trace_entry */
|
|
|
|
return trace_seq_printf(s,
|
2009-03-10 08:14:35 -06:00
|
|
|
"\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
|
|
|
|
"\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
|
|
|
|
"\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
|
|
|
|
"\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
|
|
|
|
"\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
|
2009-03-02 13:03:01 -07:00
|
|
|
"\n",
|
|
|
|
FIELD(unsigned char, type),
|
|
|
|
FIELD(unsigned char, flags),
|
|
|
|
FIELD(unsigned char, preempt_count),
|
|
|
|
FIELD(int, pid),
|
|
|
|
FIELD(int, tgid));
|
|
|
|
}
|
tracing: new format for specialized trace points
Impact: clean up and enhancement
The TRACE_EVENT_FORMAT macro looks quite ugly and is limited in its
ability to save data as well as to print the record out. Working with
Ingo Molnar, we came up with a new format that is much more pleasing to
the eye of C developers. This new macro is more C style than the old
macro, and is more obvious to what it does.
Here's the example. The only updated macro in this patch is the
sched_switch trace point.
The old method looked like this:
TRACE_EVENT_FORMAT(sched_switch,
TP_PROTO(struct rq *rq, struct task_struct *prev,
struct task_struct *next),
TP_ARGS(rq, prev, next),
TP_FMT("task %s:%d ==> %s:%d",
prev->comm, prev->pid, next->comm, next->pid),
TRACE_STRUCT(
TRACE_FIELD(pid_t, prev_pid, prev->pid)
TRACE_FIELD(int, prev_prio, prev->prio)
TRACE_FIELD_SPECIAL(char next_comm[TASK_COMM_LEN],
next_comm,
TP_CMD(memcpy(TRACE_ENTRY->next_comm,
next->comm,
TASK_COMM_LEN)))
TRACE_FIELD(pid_t, next_pid, next->pid)
TRACE_FIELD(int, next_prio, next->prio)
),
TP_RAW_FMT("prev %d:%d ==> next %s:%d:%d")
);
The above method is hard to read and requires two format fields.
The new method:
/*
* Tracepoint for task switches, performed by the scheduler:
*
* (NOTE: the 'rq' argument is not used by generic trace events,
* but used by the latency tracer plugin. )
*/
TRACE_EVENT(sched_switch,
TP_PROTO(struct rq *rq, struct task_struct *prev,
struct task_struct *next),
TP_ARGS(rq, prev, next),
TP_STRUCT__entry(
__array( char, prev_comm, TASK_COMM_LEN )
__field( pid_t, prev_pid )
__field( int, prev_prio )
__array( char, next_comm, TASK_COMM_LEN )
__field( pid_t, next_pid )
__field( int, next_prio )
),
TP_printk("task %s:%d [%d] ==> %s:%d [%d]",
__entry->prev_comm, __entry->prev_pid, __entry->prev_prio,
__entry->next_comm, __entry->next_pid, __entry->next_prio),
TP_fast_assign(
memcpy(__entry->next_comm, next->comm, TASK_COMM_LEN);
__entry->prev_pid = prev->pid;
__entry->prev_prio = prev->prio;
memcpy(__entry->prev_comm, prev->comm, TASK_COMM_LEN);
__entry->next_pid = next->pid;
__entry->next_prio = next->prio;
)
);
This macro is called TRACE_EVENT, it is broken up into 5 parts:
TP_PROTO: the proto type of the trace point
TP_ARGS: the arguments of the trace point
TP_STRUCT_entry: the structure layout of the entry in the ring buffer
TP_printk: the printk format
TP_fast_assign: the method used to write the entry into the ring buffer
The structure is the definition of how the event will be saved in the
ring buffer. The printk is used by the internal tracing in case of
an oops, and the kernel needs to print out the format of the record
to the console. This the TP_printk gives a means to show the records
in a human readable format. It is also used to print out the data
from the trace file.
The TP_fast_assign is executed directly. It is basically like a C function,
where the __entry is the handle to the record.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
2009-03-09 15:14:30 -06:00
|
|
|
|
2009-03-02 11:53:59 -07:00
|
|
|
static ssize_t
|
|
|
|
event_format_read(struct file *filp, char __user *ubuf, size_t cnt,
|
|
|
|
loff_t *ppos)
|
|
|
|
{
|
|
|
|
struct ftrace_event_call *call = filp->private_data;
|
|
|
|
struct trace_seq *s;
|
|
|
|
char *buf;
|
|
|
|
int r;
|
|
|
|
|
2009-03-17 00:20:59 -06:00
|
|
|
if (*ppos)
|
|
|
|
return 0;
|
|
|
|
|
2009-03-02 11:53:59 -07:00
|
|
|
s = kmalloc(sizeof(*s), GFP_KERNEL);
|
|
|
|
if (!s)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
trace_seq_init(s);
|
|
|
|
|
2009-03-02 13:10:02 -07:00
|
|
|
/* If any of the first writes fail, so will the show_format. */
|
|
|
|
|
|
|
|
trace_seq_printf(s, "name: %s\n", call->name);
|
|
|
|
trace_seq_printf(s, "ID: %d\n", call->id);
|
|
|
|
trace_seq_printf(s, "format:\n");
|
2009-03-02 13:03:01 -07:00
|
|
|
trace_write_header(s);
|
|
|
|
|
2009-03-02 11:53:59 -07:00
|
|
|
r = call->show_format(s);
|
|
|
|
if (!r) {
|
|
|
|
/*
|
|
|
|
* ug! The format output is bigger than a PAGE!!
|
|
|
|
*/
|
|
|
|
buf = "FORMAT TOO BIG\n";
|
|
|
|
r = simple_read_from_buffer(ubuf, cnt, ppos,
|
|
|
|
buf, strlen(buf));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
r = simple_read_from_buffer(ubuf, cnt, ppos,
|
|
|
|
s->buffer, s->len);
|
|
|
|
out:
|
|
|
|
kfree(s);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2009-03-19 13:26:13 -06:00
|
|
|
static ssize_t
|
|
|
|
event_id_read(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
|
|
|
|
{
|
|
|
|
struct ftrace_event_call *call = filp->private_data;
|
|
|
|
struct trace_seq *s;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
if (*ppos)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
s = kmalloc(sizeof(*s), GFP_KERNEL);
|
|
|
|
if (!s)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
trace_seq_init(s);
|
|
|
|
trace_seq_printf(s, "%d\n", call->id);
|
|
|
|
|
|
|
|
r = simple_read_from_buffer(ubuf, cnt, ppos,
|
|
|
|
s->buffer, s->len);
|
|
|
|
kfree(s);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2009-03-22 02:31:04 -06:00
|
|
|
static ssize_t
|
|
|
|
event_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
|
|
|
|
loff_t *ppos)
|
|
|
|
{
|
|
|
|
struct ftrace_event_call *call = filp->private_data;
|
|
|
|
struct trace_seq *s;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
if (*ppos)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
s = kmalloc(sizeof(*s), GFP_KERNEL);
|
|
|
|
if (!s)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
trace_seq_init(s);
|
|
|
|
|
|
|
|
r = filter_print_preds(call->preds, s->buffer);
|
|
|
|
r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, r);
|
|
|
|
|
|
|
|
kfree(s);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
event_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
|
|
|
|
loff_t *ppos)
|
|
|
|
{
|
|
|
|
struct ftrace_event_call *call = filp->private_data;
|
|
|
|
char buf[64], *pbuf = buf;
|
|
|
|
struct filter_pred *pred;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (cnt >= sizeof(buf))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (copy_from_user(&buf, ubuf, cnt))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
pred = kzalloc(sizeof(*pred), GFP_KERNEL);
|
|
|
|
if (!pred)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
err = filter_parse(&pbuf, pred);
|
|
|
|
if (err < 0) {
|
|
|
|
filter_free_pred(pred);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pred->clear) {
|
|
|
|
filter_free_preds(call);
|
|
|
|
return cnt;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (filter_add_pred(call, pred)) {
|
|
|
|
filter_free_pred(pred);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
*ppos += cnt;
|
|
|
|
|
|
|
|
return cnt;
|
|
|
|
}
|
|
|
|
|
2009-02-24 08:21:36 -07:00
|
|
|
static const struct seq_operations show_event_seq_ops = {
|
|
|
|
.start = t_start,
|
|
|
|
.next = t_next,
|
|
|
|
.show = t_show,
|
|
|
|
.stop = t_stop,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct seq_operations show_set_event_seq_ops = {
|
|
|
|
.start = s_start,
|
|
|
|
.next = s_next,
|
|
|
|
.show = t_show,
|
|
|
|
.stop = t_stop,
|
|
|
|
};
|
|
|
|
|
2009-03-10 10:04:02 -06:00
|
|
|
static const struct file_operations ftrace_avail_fops = {
|
|
|
|
.open = ftrace_event_seq_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = seq_release,
|
|
|
|
};
|
|
|
|
|
2009-02-24 08:21:36 -07:00
|
|
|
static const struct file_operations ftrace_set_event_fops = {
|
|
|
|
.open = ftrace_event_seq_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.write = ftrace_event_write,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = seq_release,
|
|
|
|
};
|
|
|
|
|
2009-02-24 12:15:08 -07:00
|
|
|
static const struct file_operations ftrace_enable_fops = {
|
|
|
|
.open = tracing_open_generic,
|
|
|
|
.read = event_enable_read,
|
|
|
|
.write = event_enable_write,
|
|
|
|
};
|
|
|
|
|
2009-03-02 11:53:59 -07:00
|
|
|
static const struct file_operations ftrace_event_format_fops = {
|
|
|
|
.open = tracing_open_generic,
|
|
|
|
.read = event_format_read,
|
|
|
|
};
|
|
|
|
|
2009-03-19 13:26:13 -06:00
|
|
|
static const struct file_operations ftrace_event_id_fops = {
|
|
|
|
.open = tracing_open_generic,
|
|
|
|
.read = event_id_read,
|
|
|
|
};
|
|
|
|
|
2009-03-22 02:31:04 -06:00
|
|
|
static const struct file_operations ftrace_event_filter_fops = {
|
|
|
|
.open = tracing_open_generic,
|
|
|
|
.read = event_filter_read,
|
|
|
|
.write = event_filter_write,
|
|
|
|
};
|
|
|
|
|
2009-02-24 12:15:08 -07:00
|
|
|
static struct dentry *event_trace_events_dir(void)
|
|
|
|
{
|
|
|
|
static struct dentry *d_tracer;
|
|
|
|
static struct dentry *d_events;
|
|
|
|
|
|
|
|
if (d_events)
|
|
|
|
return d_events;
|
|
|
|
|
|
|
|
d_tracer = tracing_init_dentry();
|
|
|
|
if (!d_tracer)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
d_events = debugfs_create_dir("events", d_tracer);
|
|
|
|
if (!d_events)
|
|
|
|
pr_warning("Could not create debugfs "
|
|
|
|
"'events' directory\n");
|
|
|
|
|
|
|
|
return d_events;
|
|
|
|
}
|
|
|
|
|
2009-02-27 19:33:02 -07:00
|
|
|
struct event_subsystem {
|
|
|
|
struct list_head list;
|
|
|
|
const char *name;
|
|
|
|
struct dentry *entry;
|
|
|
|
};
|
|
|
|
|
|
|
|
static LIST_HEAD(event_subsystems);
|
|
|
|
|
|
|
|
static struct dentry *
|
|
|
|
event_subsystem_dir(const char *name, struct dentry *d_events)
|
|
|
|
{
|
|
|
|
struct event_subsystem *system;
|
|
|
|
|
|
|
|
/* First see if we did not already create this dir */
|
|
|
|
list_for_each_entry(system, &event_subsystems, list) {
|
|
|
|
if (strcmp(system->name, name) == 0)
|
|
|
|
return system->entry;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* need to create new entry */
|
|
|
|
system = kmalloc(sizeof(*system), GFP_KERNEL);
|
|
|
|
if (!system) {
|
|
|
|
pr_warning("No memory to create event subsystem %s\n",
|
|
|
|
name);
|
|
|
|
return d_events;
|
|
|
|
}
|
|
|
|
|
|
|
|
system->entry = debugfs_create_dir(name, d_events);
|
|
|
|
if (!system->entry) {
|
|
|
|
pr_warning("Could not create event subsystem %s\n",
|
|
|
|
name);
|
|
|
|
kfree(system);
|
|
|
|
return d_events;
|
|
|
|
}
|
|
|
|
|
|
|
|
system->name = name;
|
|
|
|
list_add(&system->list, &event_subsystems);
|
|
|
|
|
|
|
|
return system->entry;
|
|
|
|
}
|
|
|
|
|
2009-02-24 12:15:08 -07:00
|
|
|
static int
|
|
|
|
event_create_dir(struct ftrace_event_call *call, struct dentry *d_events)
|
|
|
|
{
|
|
|
|
struct dentry *entry;
|
2009-02-28 00:41:25 -07:00
|
|
|
int ret;
|
2009-02-24 12:15:08 -07:00
|
|
|
|
2009-02-27 19:33:02 -07:00
|
|
|
/*
|
|
|
|
* If the trace point header did not define TRACE_SYSTEM
|
|
|
|
* then the system would be called "TRACE_SYSTEM".
|
|
|
|
*/
|
|
|
|
if (strcmp(call->system, "TRACE_SYSTEM") != 0)
|
|
|
|
d_events = event_subsystem_dir(call->system, d_events);
|
|
|
|
|
2009-02-28 00:41:25 -07:00
|
|
|
if (call->raw_init) {
|
|
|
|
ret = call->raw_init();
|
|
|
|
if (ret < 0) {
|
|
|
|
pr_warning("Could not initialize trace point"
|
|
|
|
" events/%s\n", call->name);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-24 12:15:08 -07:00
|
|
|
call->dir = debugfs_create_dir(call->name, d_events);
|
|
|
|
if (!call->dir) {
|
|
|
|
pr_warning("Could not create debugfs "
|
|
|
|
"'%s' directory\n", call->name);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-03-05 19:35:29 -07:00
|
|
|
if (call->regfunc) {
|
|
|
|
entry = debugfs_create_file("enable", 0644, call->dir, call,
|
|
|
|
&ftrace_enable_fops);
|
|
|
|
if (!entry)
|
|
|
|
pr_warning("Could not create debugfs "
|
|
|
|
"'%s/enable' entry\n", call->name);
|
|
|
|
}
|
2009-02-24 12:15:08 -07:00
|
|
|
|
2009-03-19 13:26:13 -06:00
|
|
|
if (call->id) {
|
|
|
|
entry = debugfs_create_file("id", 0444, call->dir, call,
|
|
|
|
&ftrace_event_id_fops);
|
|
|
|
if (!entry)
|
|
|
|
pr_warning("Could not create debugfs '%s/id' entry\n",
|
|
|
|
call->name);
|
|
|
|
}
|
|
|
|
|
2009-03-22 02:30:39 -06:00
|
|
|
if (call->define_fields) {
|
|
|
|
ret = call->define_fields();
|
|
|
|
if (ret < 0) {
|
|
|
|
pr_warning("Could not initialize trace point"
|
|
|
|
" events/%s\n", call->name);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-03-22 02:31:04 -06:00
|
|
|
entry = debugfs_create_file("filter", 0444, call->dir, call,
|
|
|
|
&ftrace_event_filter_fops);
|
|
|
|
if (!entry)
|
|
|
|
pr_warning("Could not create debugfs "
|
|
|
|
"'%s/filter' entry\n", call->name);
|
|
|
|
|
2009-03-02 11:53:59 -07:00
|
|
|
/* A trace may not want to export its format */
|
|
|
|
if (!call->show_format)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
entry = debugfs_create_file("format", 0444, call->dir, call,
|
|
|
|
&ftrace_event_format_fops);
|
|
|
|
if (!entry)
|
|
|
|
pr_warning("Could not create debugfs "
|
|
|
|
"'%s/format' entry\n", call->name);
|
2009-02-28 00:41:25 -07:00
|
|
|
|
2009-02-24 12:15:08 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-02-24 08:21:36 -07:00
|
|
|
static __init int event_trace_init(void)
|
|
|
|
{
|
2009-02-24 12:15:08 -07:00
|
|
|
struct ftrace_event_call *call = __start_ftrace_events;
|
2009-02-24 08:21:36 -07:00
|
|
|
struct dentry *d_tracer;
|
|
|
|
struct dentry *entry;
|
2009-02-24 12:15:08 -07:00
|
|
|
struct dentry *d_events;
|
2009-02-24 08:21:36 -07:00
|
|
|
|
|
|
|
d_tracer = tracing_init_dentry();
|
|
|
|
if (!d_tracer)
|
|
|
|
return 0;
|
|
|
|
|
2009-03-10 10:04:02 -06:00
|
|
|
entry = debugfs_create_file("available_events", 0444, d_tracer,
|
|
|
|
(void *)&show_event_seq_ops,
|
|
|
|
&ftrace_avail_fops);
|
|
|
|
if (!entry)
|
|
|
|
pr_warning("Could not create debugfs "
|
|
|
|
"'available_events' entry\n");
|
|
|
|
|
2009-02-24 08:21:36 -07:00
|
|
|
entry = debugfs_create_file("set_event", 0644, d_tracer,
|
|
|
|
(void *)&show_set_event_seq_ops,
|
|
|
|
&ftrace_set_event_fops);
|
|
|
|
if (!entry)
|
|
|
|
pr_warning("Could not create debugfs "
|
|
|
|
"'set_event' entry\n");
|
|
|
|
|
2009-02-24 12:15:08 -07:00
|
|
|
d_events = event_trace_events_dir();
|
|
|
|
if (!d_events)
|
|
|
|
return 0;
|
|
|
|
|
2009-03-19 13:26:15 -06:00
|
|
|
for_each_event(call) {
|
2009-02-24 12:15:08 -07:00
|
|
|
/* The linker may leave blanks */
|
|
|
|
if (!call->name)
|
|
|
|
continue;
|
|
|
|
event_create_dir(call, d_events);
|
|
|
|
}
|
|
|
|
|
2009-02-24 08:21:36 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
fs_initcall(event_trace_init);
|