static int load_events(struct pevent *pevent, const char *system,
const char *sys_dir)
{
struct dirent *dent;
struct stat st;
DIR *dir;
int len = 0;
int ret = 0, failure = 0;
ret = stat(sys_dir, &st);
if (ret < 0 || !S_ISDIR(st.st_mode))
return EINVAL;
dir = opendir(sys_dir);
if (!dir)
return errno;
while ((dent = readdir(dir))) {
const char *name = dent->d_name;
char *event;
char *format;
char *buf;
if (strcmp(name, ".") == 0 ||
strcmp(name, "..") == 0)
continue;
event = append_file(sys_dir, name);
ret = stat(event, &st);
if (ret < 0 || !S_ISDIR(st.st_mode))
goto free_event;
format = append_file(event, "format");
ret = stat(format, &st);
if (ret < 0)
goto free_format;
len = read_file(format, &buf);
if (len < 0)
goto free_format;
ret = pevent_parse_event(pevent, buf, len, system);
free(buf);
free_format:
free(format);
free_event:
free(event);
if (ret)
failure = ret;
}
closedir(dir);
return failure;
}
int parse_event_file(struct pevent *pevent,
char *buf, unsigned long size, char *sys)
{
return pevent_parse_event(pevent, buf, size, sys);
}
int parse_ftrace_file(struct pevent *pevent, char *buf, unsigned long size)
{
return pevent_parse_event(pevent, buf, size, "ftrace");
}
int tracecmd_blk_hack(struct tracecmd_input *handle)
{
struct pevent *pevent;
struct event_format *event;
struct format_field *field;
char buf[4096]; /* way more than enough! */
int id;
int l;
int r;
pevent = tracecmd_get_pevent(handle);
/*
* Unfortunately, the TRACE_BLK has changed a bit.
* We need to test if various events exist to try
* to guess what event id TRACE_BLK would be.
*/
/* It was originally behind the "power" event */
event = pevent_find_event_by_name(pevent, "ftrace", "power");
if (event) {
id = event->id + 1;
goto found;
}
/*
* But the power tracer is now in perf.
* Then it was after kmem_free
*/
event = pevent_find_event_by_name(pevent, "ftrace", "kmem_free");
if (event) {
id = event->id + 1;
goto found;
}
/*
* But that then went away.
* Currently it should be behind the user stack.
*/
event = pevent_find_event_by_name(pevent, "ftrace", "user_stack");
if (event) {
id = event->id + 1;
goto found;
}
/* Give up :( */
return -1;
found:
/*
* Blk events are not exported in the events directory.
* This is a hack to attempt to create a block event
* that we can read.
*
* We'll make a format file to look like this:
*
* name: blktrace
* ID: 13
* format:
* field:unsigned short common_type; offset:0; size:2;
* field:unsigned char common_flags; offset:2; size:1;
* field:unsigned char common_preempt_count; offset:3; size:1;
* field:int common_pid; offset:4; size:4;
* field:int common_lock_depth; offset:8; size:4;
*
* field:u64 sector; offset:16; size:8;
* field:int bytes; offset:32; size:4;
* field:int action; offset:36; size:4;
* field:int pid; offset:40; size:4;
* field:int device; offset:44; size:4;
* field:int cpu; offset:48; size:4;
* field:short error; offset:52; size:2;
* field:short pdu_len; offset:54; size:2;
* field:void data; offset:60; size:0;
*
* print fmt: "%d", REC->pid
*
* Note: the struct blk_io_trace is used directly and
* just the first parts of the struct are not used in order
* to not write over the ftrace data.
*/
/* Make sure the common fields exist */
field = pevent_find_common_field(event, "common_type");
if (!field || field->offset != 0 || field->size != 2)
goto fail;
field = pevent_find_common_field(event, "common_flags");
if (!field || field->offset != 2 || field->size != 1)
goto fail;
field = pevent_find_common_field(event, "common_preempt_count");
if (!field || field->offset != 3 || field->size != 1)
goto fail;
field = pevent_find_common_field(event, "common_pid");
if (!field || field->offset != 4 || field->size != 4)
goto fail;
r = sprintf(buf, blk_event_start, id);
l = r;
/* lock depth is optional */
field = pevent_find_common_field(event, "common_lock_depth");
if (field) {
if (field->offset != 8 || field->size != 4)
return -1;
r = sprintf(buf+l, "\tfield:int common_lock_depth;\toffset:8;\tsize:4;\n");
l += r;
}
r = sprintf(buf+l, blk_body);
/* Parse this event */
l += r;
pevent_parse_event(pevent, buf, l, "ftrace");
return 0;
fail:
return -1;
}
