lk/linux-kernel-test
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

perf session: Pass the perf_session to the event handling operations

Browse Source 
They will need it to get the right threads list, etc.

Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1260741029-4430-1-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
This commit is contained in:
Arnaldo Carvalho de Melo
2009-12-13 19:50:24 -02:00
committed by Ingo Molnar
parent 2cd9046cc5
commit d8f66248d6
12 changed files with 103 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
tools/perf/builtin-annotate.c
View File

@@ -132,7 +132,7 @@ static int hist_entry__add(struct addr_location *al, u64 count)
return 0; return 0;
} }
static int process_sample_event(event_t *event) static int process_sample_event(event_t *event, struct perf_session *session __used)
{ {
struct addr_location al; struct addr_location al;

2
tools/perf/builtin-kmem.c
View File

@@ -312,7 +312,7 @@ process_raw_event(event_t *raw_event __used, void *data,
} }
} }
static int process_sample_event(event_t *event) static int process_sample_event(event_t *event, struct perf_session *session __used)
{ {
struct sample_data data; struct sample_data data;
struct thread *thread; struct thread *thread;

11
tools/perf/builtin-record.c
View File

@@ -123,7 +123,8 @@ static void write_event(event_t *buf, size_t size)
write_output(buf, size); write_output(buf, size);
} }
static int process_synthesized_event(event_t *event) static int process_synthesized_event(event_t *event,
struct perf_session *self __used)
{ {
write_event(event, event->header.size); write_event(event, event->header.size);
return 0; return 0;
@@ -488,9 +489,10 @@ static int __cmd_record(int argc, const char **argv)
} }
if (!system_wide) if (!system_wide)
event__synthesize_thread(pid, process_synthesized_event); event__synthesize_thread(pid, process_synthesized_event,
session);
else else
event__synthesize_threads(process_synthesized_event); event__synthesize_threads(process_synthesized_event, session);
if (target_pid == -1 && argc) { if (target_pid == -1 && argc) {
pid = fork(); pid = fork();
@@ -510,7 +512,8 @@ static int __cmd_record(int argc, const char **argv)
*/ */
usleep(1000); usleep(1000);
event__synthesize_thread(pid, event__synthesize_thread(pid,
process_synthesized_event); process_synthesized_event,
session);
} }
child_pid = pid; child_pid = pid;

9
tools/perf/builtin-report.c
View File

@@ -53,8 +53,6 @@ static int exclude_other = 1;
static char callchain_default_opt[] = "fractal,0.5"; static char callchain_default_opt[] = "fractal,0.5";
static struct perf_session *session;
static u64 sample_type; static u64 sample_type;
struct symbol_conf symbol_conf; struct symbol_conf symbol_conf;
@@ -604,7 +602,7 @@ static int validate_chain(struct ip_callchain *chain, event_t *event)
return 0; return 0;
} }
static int process_sample_event(event_t *event) static int process_sample_event(event_t *event, struct perf_session *session __used)
{ {
struct sample_data data; struct sample_data data;
int cpumode; int cpumode;
@@ -683,7 +681,7 @@ static int process_sample_event(event_t *event)
return 0; return 0;
} }
static int process_comm_event(event_t *event) static int process_comm_event(event_t *event, struct perf_session *session __used)
{ {
struct thread *thread = threads__findnew(event->comm.pid); struct thread *thread = threads__findnew(event->comm.pid);
@@ -698,7 +696,7 @@ static int process_comm_event(event_t *event)
return 0; return 0;
} }
static int process_read_event(event_t *event) static int process_read_event(event_t *event, struct perf_session *session __used)
{ {
struct perf_event_attr *attr; struct perf_event_attr *attr;
@@ -766,6 +764,7 @@ static int __cmd_report(void)
{ {
struct thread *idle; struct thread *idle;
int ret; int ret;
struct perf_session *session;
session = perf_session__new(input_name, O_RDONLY, force); session = perf_session__new(input_name, O_RDONLY, force);
if (session == NULL) if (session == NULL)

6
tools/perf/builtin-sched.c
View File

@@ -1594,7 +1594,8 @@ process_raw_event(event_t *raw_event __used, void *data,
process_sched_migrate_task_event(data, event, cpu, timestamp, thread); process_sched_migrate_task_event(data, event, cpu, timestamp, thread);
} }
static int process_sample_event(event_t *event) static int process_sample_event(event_t *event,
struct perf_session *session __used)
{ {
struct sample_data data; struct sample_data data;
struct thread *thread; struct thread *thread;
@@ -1632,7 +1633,8 @@ static int process_sample_event(event_t *event)
return 0; return 0;
} }
static int process_lost_event(event_t *event __used) static int process_lost_event(event_t *event __used,
struct perf_session *session __used)
{ {
nr_lost_chunks++; nr_lost_chunks++;
nr_lost_events += event->lost.lost; nr_lost_events += event->lost.lost;

13
tools/perf/builtin-timechart.c
View File

@@ -281,21 +281,19 @@ static int cpus_cstate_state[MAX_CPUS];
static u64 cpus_pstate_start_times[MAX_CPUS]; static u64 cpus_pstate_start_times[MAX_CPUS];
static u64 cpus_pstate_state[MAX_CPUS]; static u64 cpus_pstate_state[MAX_CPUS];
static int static int process_comm_event(event_t *event, struct perf_session *session __used)
process_comm_event(event_t *event)
{ {
pid_set_comm(event->comm.pid, event->comm.comm); pid_set_comm(event->comm.pid, event->comm.comm);
return 0; return 0;
} }
static int
process_fork_event(event_t *event) static int process_fork_event(event_t *event, struct perf_session *session __used)
{ {
pid_fork(event->fork.pid, event->fork.ppid, event->fork.time); pid_fork(event->fork.pid, event->fork.ppid, event->fork.time);
return 0; return 0;
} }
static int static int process_exit_event(event_t *event, struct perf_session *session __used)
process_exit_event(event_t *event)
{ {
pid_exit(event->fork.pid, event->fork.time); pid_exit(event->fork.pid, event->fork.time);
return 0; return 0;
@@ -594,8 +592,7 @@ static u64 sample_time(event_t *event)
* We first queue all events, sorted backwards by insertion. * We first queue all events, sorted backwards by insertion.
* The order will get flipped later. * The order will get flipped later.
*/ */
static int static int queue_sample_event(event_t *event, struct perf_session *session __used)
queue_sample_event(event_t *event)
{ {
struct sample_wrapper *copy, *prev; struct sample_wrapper *copy, *prev;
int size; int size;

28
tools/perf/builtin-top.c
View File

@@ -965,14 +965,14 @@ static void event__process_sample(const event_t *self, int counter)
} }
} }
static int event__process(event_t *event) static int event__process(event_t *event, struct perf_session *session)
{ {
switch (event->header.type) { switch (event->header.type) {
case PERF_RECORD_COMM: case PERF_RECORD_COMM:
event__process_comm(event); event__process_comm(event, session);
break; break;
case PERF_RECORD_MMAP: case PERF_RECORD_MMAP:
event__process_mmap(event); event__process_mmap(event, session);
break; break;
default: default:
break; break;
@@ -999,7 +999,8 @@ static unsigned int mmap_read_head(struct mmap_data *md)
return head; return head;
} }
static void mmap_read_counter(struct mmap_data *md) static void perf_session__mmap_read_counter(struct perf_session *self,
struct mmap_data *md)
{ {
unsigned int head = mmap_read_head(md); unsigned int head = mmap_read_head(md);
unsigned int old = md->prev; unsigned int old = md->prev;
@@ -1054,7 +1055,7 @@ static void mmap_read_counter(struct mmap_data *md)
if (event->header.type == PERF_RECORD_SAMPLE) if (event->header.type == PERF_RECORD_SAMPLE)
event__process_sample(event, md->counter); event__process_sample(event, md->counter);
else else
event__process(event); event__process(event, self);
old += size; old += size;
} }
@@ -1064,13 +1065,13 @@ static void mmap_read_counter(struct mmap_data *md)
static struct pollfd event_array[MAX_NR_CPUS * MAX_COUNTERS]; static struct pollfd event_array[MAX_NR_CPUS * MAX_COUNTERS];
static struct mmap_data mmap_array[MAX_NR_CPUS][MAX_COUNTERS]; static struct mmap_data mmap_array[MAX_NR_CPUS][MAX_COUNTERS];
static void mmap_read(void) static void perf_session__mmap_read(struct perf_session *self)
{ {
int i, counter; int i, counter;
for (i = 0; i < nr_cpus; i++) { for (i = 0; i < nr_cpus; i++) {
for (counter = 0; counter < nr_counters; counter++) for (counter = 0; counter < nr_counters; counter++)
mmap_read_counter(&mmap_array[i][counter]); perf_session__mmap_read_counter(self, &mmap_array[i][counter]);
} }
} }
@@ -1155,11 +1156,16 @@ static int __cmd_top(void)
pthread_t thread; pthread_t thread;
int i, counter; int i, counter;
int ret; int ret;
/*
* XXX perf_session__new should allow passing a O_MMAP, so that all this
* mmap reading, etc is encapsulated in it.
*/
struct perf_session *session = NULL;
if (target_pid != -1) if (target_pid != -1)
event__synthesize_thread(target_pid, event__process); event__synthesize_thread(target_pid, event__process, session);
else else
event__synthesize_threads(event__process); event__synthesize_threads(event__process, session);
for (i = 0; i < nr_cpus; i++) { for (i = 0; i < nr_cpus; i++) {
group_fd = -1; group_fd = -1;
@@ -1170,7 +1176,7 @@ static int __cmd_top(void)
/* Wait for a minimal set of events before starting the snapshot */ /* Wait for a minimal set of events before starting the snapshot */
poll(event_array, nr_poll, 100); poll(event_array, nr_poll, 100);
mmap_read(); perf_session__mmap_read(session);
if (pthread_create(&thread, NULL, display_thread, NULL)) { if (pthread_create(&thread, NULL, display_thread, NULL)) {
printf("Could not create display thread.\n"); printf("Could not create display thread.\n");
@@ -1190,7 +1196,7 @@ static int __cmd_top(void)
while (1) { while (1) {
int hits = samples; int hits = samples;
mmap_read(); perf_session__mmap_read(session);
if (hits == samples) if (hits == samples)
ret = poll(event_array, nr_poll, 100); ret = poll(event_array, nr_poll, 100);

23
tools/perf/builtin-trace.c
View File

@@ -62,10 +62,9 @@ static int cleanup_scripting(void)
static char const *input_name = "perf.data"; static char const *input_name = "perf.data";
static struct perf_session *session;
static u64 sample_type; static u64 sample_type;
static int process_sample_event(event_t *event) static int process_sample_event(event_t *event, struct perf_session *session __used)
{ {
struct sample_data data; struct sample_data data;
struct thread *thread; struct thread *thread;
@@ -125,20 +124,12 @@ static struct perf_file_handler file_handler = {
.sample_type_check = sample_type_check, .sample_type_check = sample_type_check,
}; };
static int __cmd_trace(void) static int __cmd_trace(struct perf_session *session)
{ {
int err;
session = perf_session__new(input_name, O_RDONLY, 0);
if (session == NULL)
return -ENOMEM;
register_idle_thread(); register_idle_thread();
register_perf_file_handler(&file_handler); register_perf_file_handler(&file_handler);
err = perf_session__process_events(session, 0, &event__cwdlen, &event__cwd); return perf_session__process_events(session, 0, &event__cwdlen, &event__cwd);
perf_session__delete(session);
return err;
} }
struct script_spec { struct script_spec {
@@ -313,6 +304,7 @@ static const struct option options[] = {
int cmd_trace(int argc, const char **argv, const char *prefix __used) int cmd_trace(int argc, const char **argv, const char *prefix __used)
{ {
int err; int err;
struct perf_session *session;
symbol__init(0); symbol__init(0);
@@ -330,6 +322,10 @@ int cmd_trace(int argc, const char **argv, const char *prefix __used)
setup_pager(); setup_pager();
session = perf_session__new(input_name, O_RDONLY, 0);
if (session == NULL)
return -ENOMEM;
if (generate_script_lang) { if (generate_script_lang) {
struct stat perf_stat; struct stat perf_stat;
@@ -367,8 +363,9 @@ int cmd_trace(int argc, const char **argv, const char *prefix __used)
goto out; goto out;
} }
err = __cmd_trace(); err = __cmd_trace(session);
perf_session__delete(session);
cleanup_scripting(); cleanup_scripting();
out: out:
return err; return err;

27
tools/perf/util/data_map.c
View File

@@ -8,7 +8,8 @@ static struct perf_file_handler *curr_handler;
static unsigned long mmap_window = 32; static unsigned long mmap_window = 32;
static char __cwd[PATH_MAX]; static char __cwd[PATH_MAX];
static int process_event_stub(event_t *event __used) static int process_event_stub(event_t *event __used,
struct perf_session *session __used)
{ {
dump_printf(": unhandled!\n"); dump_printf(": unhandled!\n");
return 0; return 0;
@@ -61,8 +62,8 @@ void event__print_totals(void)
event__name[i], event__total[i]); event__name[i], event__total[i]);
} }
static int static int process_event(event_t *event, struct perf_session *session,
process_event(event_t *event, unsigned long offset, unsigned long head) unsigned long offset, unsigned long head)
{ {
trace_event(event); trace_event(event);
@@ -77,23 +78,23 @@ process_event(event_t *event, unsigned long offset, unsigned long head)
switch (event->header.type) { switch (event->header.type) {
case PERF_RECORD_SAMPLE: case PERF_RECORD_SAMPLE:
return curr_handler->process_sample_event(event); return curr_handler->process_sample_event(event, session);
case PERF_RECORD_MMAP: case PERF_RECORD_MMAP:
return curr_handler->process_mmap_event(event); return curr_handler->process_mmap_event(event, session);
case PERF_RECORD_COMM: case PERF_RECORD_COMM:
return curr_handler->process_comm_event(event); return curr_handler->process_comm_event(event, session);
case PERF_RECORD_FORK: case PERF_RECORD_FORK:
return curr_handler->process_fork_event(event); return curr_handler->process_fork_event(event, session);
case PERF_RECORD_EXIT: case PERF_RECORD_EXIT:
return curr_handler->process_exit_event(event); return curr_handler->process_exit_event(event, session);
case PERF_RECORD_LOST: case PERF_RECORD_LOST:
return curr_handler->process_lost_event(event); return curr_handler->process_lost_event(event, session);
case PERF_RECORD_READ: case PERF_RECORD_READ:
return curr_handler->process_read_event(event); return curr_handler->process_read_event(event, session);
case PERF_RECORD_THROTTLE: case PERF_RECORD_THROTTLE:
return curr_handler->process_throttle_event(event); return curr_handler->process_throttle_event(event, session);
case PERF_RECORD_UNTHROTTLE: case PERF_RECORD_UNTHROTTLE:
return curr_handler->process_unthrottle_event(event); return curr_handler->process_unthrottle_event(event, session);
default: default:
curr_handler->total_unknown++; curr_handler->total_unknown++;
return -1; return -1;
@@ -209,7 +210,7 @@ more:
(void *)(long)event->header.size, (void *)(long)event->header.size,
event->header.type); event->header.type);
if (!size || process_event(event, offset, head) < 0) { if (!size || process_event(event, self, offset, head) < 0) {
dump_printf("%p [%p]: skipping unknown header type: %d\n", dump_printf("%p [%p]: skipping unknown header type: %d\n",
(void *)(offset + head), (void *)(offset + head),

5
tools/perf/util/data_map.h
View File

@@ -5,7 +5,10 @@
#include "header.h" #include "header.h"
#include "session.h" #include "session.h"
typedef int (*event_type_handler_t)(event_t *); struct perf_session;
typedef int (*event_type_handler_t)(event_t *self,
struct perf_session *session);
struct perf_file_handler { struct perf_file_handler {
event_type_handler_t process_sample_event; event_type_handler_t process_sample_event;

37
tools/perf/util/event.c
View File

@@ -5,7 +5,9 @@
#include "thread.h" #include "thread.h"
static pid_t event__synthesize_comm(pid_t pid, int full, static pid_t event__synthesize_comm(pid_t pid, int full,
int (*process)(event_t *event)) int (*process)(event_t *event,
struct perf_session *session),
struct perf_session *session)
{ {
event_t ev; event_t ev;
char filename[PATH_MAX]; char filename[PATH_MAX];
@@ -54,7 +56,7 @@ out_race:
if (!full) { if (!full) {
ev.comm.tid = pid; ev.comm.tid = pid;
process(&ev); process(&ev, session);
goto out_fclose; goto out_fclose;
} }
@@ -72,7 +74,7 @@ out_race:
ev.comm.tid = pid; ev.comm.tid = pid;
process(&ev); process(&ev, session);
} }
closedir(tasks); closedir(tasks);
@@ -86,7 +88,9 @@ out_failure:
} }
static int event__synthesize_mmap_events(pid_t pid, pid_t tgid, static int event__synthesize_mmap_events(pid_t pid, pid_t tgid,
int (*process)(event_t *event)) int (*process)(event_t *event,
struct perf_session *session),
struct perf_session *session)
{ {
char filename[PATH_MAX]; char filename[PATH_MAX];
FILE *fp; FILE *fp;
@@ -141,7 +145,7 @@ static int event__synthesize_mmap_events(pid_t pid, pid_t tgid,
ev.mmap.pid = tgid; ev.mmap.pid = tgid;
ev.mmap.tid = pid; ev.mmap.tid = pid;
process(&ev); process(&ev, session);
} }
} }
@@ -149,15 +153,20 @@ static int event__synthesize_mmap_events(pid_t pid, pid_t tgid,
return 0; return 0;
} }
int event__synthesize_thread(pid_t pid, int (*process)(event_t *event)) int event__synthesize_thread(pid_t pid,
int (*process)(event_t *event,
struct perf_session *session),
struct perf_session *session)
{ {
pid_t tgid = event__synthesize_comm(pid, 1, process); pid_t tgid = event__synthesize_comm(pid, 1, process, session);
if (tgid == -1) if (tgid == -1)
return -1; return -1;
return event__synthesize_mmap_events(pid, tgid, process); return event__synthesize_mmap_events(pid, tgid, process, session);
} }
void event__synthesize_threads(int (*process)(event_t *event)) void event__synthesize_threads(int (*process)(event_t *event,
struct perf_session *session),
struct perf_session *session)
{ {
DIR *proc; DIR *proc;
struct dirent dirent, *next; struct dirent dirent, *next;
@@ -171,7 +180,7 @@ void event__synthesize_threads(int (*process)(event_t *event))
if (*end) /* only interested in proper numerical dirents */ if (*end) /* only interested in proper numerical dirents */
continue; continue;
event__synthesize_thread(pid, process); event__synthesize_thread(pid, process, session);
} }
closedir(proc); closedir(proc);
@@ -182,7 +191,7 @@ int event__cwdlen;
struct events_stats event__stats; struct events_stats event__stats;
int event__process_comm(event_t *self) int event__process_comm(event_t *self, struct perf_session *session __used)
{ {
struct thread *thread = threads__findnew(self->comm.pid); struct thread *thread = threads__findnew(self->comm.pid);
@@ -196,14 +205,14 @@ int event__process_comm(event_t *self)
return 0; return 0;
} }
int event__process_lost(event_t *self) int event__process_lost(event_t *self, struct perf_session *session __used)
{ {
dump_printf(": id:%Ld: lost:%Ld\n", self->lost.id, self->lost.lost); dump_printf(": id:%Ld: lost:%Ld\n", self->lost.id, self->lost.lost);
event__stats.lost += self->lost.lost; event__stats.lost += self->lost.lost;
return 0; return 0;
} }
int event__process_mmap(event_t *self) int event__process_mmap(event_t *self, struct perf_session *session __used)
{ {
struct thread *thread = threads__findnew(self->mmap.pid); struct thread *thread = threads__findnew(self->mmap.pid);
struct map *map = map__new(&self->mmap, MAP__FUNCTION, struct map *map = map__new(&self->mmap, MAP__FUNCTION,
@@ -224,7 +233,7 @@ int event__process_mmap(event_t *self)
return 0; return 0;
} }
int event__process_task(event_t *self) int event__process_task(event_t *self, struct perf_session *session __used)
{ {
struct thread *thread = threads__findnew(self->fork.pid); struct thread *thread = threads__findnew(self->fork.pid);
struct thread *parent = threads__findnew(self->fork.ppid); struct thread *parent = threads__findnew(self->fork.ppid);

19
tools/perf/util/event.h
View File

@@ -156,18 +156,25 @@ struct symbol *map__find_symbol_by_name(struct map *self, const char *name,
void map__fixup_start(struct map *self); void map__fixup_start(struct map *self);
void map__fixup_end(struct map *self); void map__fixup_end(struct map *self);
int event__synthesize_thread(pid_t pid, int (*process)(event_t *event)); struct perf_session;
void event__synthesize_threads(int (*process)(event_t *event));
int event__synthesize_thread(pid_t pid,
int (*process)(event_t *event,
struct perf_session *session),
struct perf_session *session);
void event__synthesize_threads(int (*process)(event_t *event,
struct perf_session *session),
struct perf_session *session);
extern char *event__cwd; extern char *event__cwd;
extern int event__cwdlen; extern int event__cwdlen;
extern struct events_stats event__stats; extern struct events_stats event__stats;
extern unsigned long event__total[PERF_RECORD_MAX]; extern unsigned long event__total[PERF_RECORD_MAX];
int event__process_comm(event_t *self); int event__process_comm(event_t *self, struct perf_session *session);
int event__process_lost(event_t *self); int event__process_lost(event_t *self, struct perf_session *session);
int event__process_mmap(event_t *self); int event__process_mmap(event_t *self, struct perf_session *session);
int event__process_task(event_t *self); int event__process_task(event_t *self, struct perf_session *session);
struct addr_location; struct addr_location;
int event__preprocess_sample(const event_t *self, struct addr_location *al, int event__preprocess_sample(const event_t *self, struct addr_location *al,