iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

perf/tools improvements and fixes:

Browse Source 
. Honour -m option in 'trace', the tool was offering the option to
   set the mmap size, but wasn't using it when doing the actual mmap
   on the events file descriptors, fix from Jiri Olsa.
 
 . Correct the message in feature-libnuma checking, swowing the right
   devel package names for various distros, from Dongsheng Yang.
 
 . Polish 'readn' function and introduce its counterpart, 'writen', from
   Jiri Olsa.
 
 . Start moving timechart state from global variables to a 'perf_tool' derived
   'timechart' struct.
 
 Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
 -----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1.4.15 (GNU/Linux)
 
 iQIcBAABAgAGBQJSnPG2AAoJENZQFvNTUqpAyrwP/jT4RQcwSBLBZ7Fn749Yxv41
 lNlL3WtUdsECH43StGYBJwkicbdti7UdrFomG9VDV6Am8jOhCU11Tvbd8UOZrAKC
 6B1EBpyLEITnbHcbGXlBUzIxXHbCX8LYFs2HSYLtxzVaR3v2BfWqNa/Ayvn3ZwNO
 aqD+iqg3jtn/ynJWkbzmld1PJ1XzXAt6RupGCTIP5lO3WLMfCCWAJOi4Frk/kDBL
 AhxDno3lLnBs66L0pYNQFqEfmoWt2KndLg+hGEIGDtUX83i07QMSd4+QkRjrdl2A
 JY+0W9Q15u4pYYUkLeZe3J772iwTfMrv1QnbhTFf/2GyaVqPC939uET6m9Rofrnm
 Xfrm1V5tWIw90EmD7ADbQTauVpUCppFlLQ2UXsWXbR3VRTUZqFWcdmOndVODJFW3
 nRTI4kNYRUFb/Qy9kyEHdjGO0tQLvKPWEHmA2pa4hB1mVaV8G5Iws46fR5MyAGQu
 JzTkgr8e6fPhIh7phTH75z00IO7SKqM6uHcJvTZFMuSpm5uZMBUh4E3Gnj/rpM85
 JbzNDeTT/VQC2vbqmq3C0dIDvW5KfV42DXHuxaq+zcdztLxBx7WKm85gxHW9+nz2
 HFFyxNhPRyj2c7c3bSYy7mDewfdAx67OZXuKDQBKFFyp6kPKgwo3VMC7DefJ1eaa
 h9gYiuRlkunYUhfBVTkT
 =Of0h
 -----END PGP SIGNATURE-----

Merge tag 'perf-core-for-mingo' of git://git.kernel.org/pub/scm/linux/kernel/git/acme/linux into perf/core

Pull perf/tools improvements and fixes from Arnaldo Carvalho de Melo:

  * Honour -m option in 'trace', the tool was offering the option to
    set the mmap size, but wasn't using it when doing the actual mmap
    on the events file descriptors, fix from Jiri Olsa.

  * Correct the message in feature-libnuma checking, swowing the right
    devel package names for various distros, from Dongsheng Yang.

  * Polish 'readn' function and introduce its counterpart, 'writen', from
    Jiri Olsa.

  * Start moving timechart state from global variables to a 'perf_tool' derived
    'timechart' struct.

Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@kernel.org>
This commit is contained in:
Ingo Molnar 2013-12-04 10:17:17 +01:00
commit 89e3bbd58a
11 changed files with 255 additions and 211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -76,7 +76,7 @@ struct perf_record {
long samples;
};
static int do_write_output(struct perf_record *rec, void *buf, size_t size)
static int perf_record__write(struct perf_record *rec, void *buf, size_t size)
{
struct perf_data_file *file = &rec->file;
@ -97,21 +97,13 @@ static int do_write_output(struct perf_record *rec, void *buf, size_t size)
return 0;
}
static int write_output(struct perf_record *rec, void *buf, size_t size)
{
return do_write_output(rec, buf, size);
}
static int process_synthesized_event(struct perf_tool *tool,
union perf_event *event,
struct perf_sample *sample __maybe_unused,
struct machine *machine __maybe_unused)
{
struct perf_record *rec = container_of(tool, struct perf_record, tool);
if (write_output(rec, event, event->header.size) < 0)
return -1;
return 0;
return perf_record__write(rec, event, event->header.size);
}
static int perf_record__mmap_read(struct perf_record *rec,
@ -136,7 +128,7 @@ static int perf_record__mmap_read(struct perf_record *rec,
size = md->mask + 1 - (old & md->mask);
old += size;
if (write_output(rec, buf, size) < 0) {
if (perf_record__write(rec, buf, size) < 0) {
rc = -1;
goto out;
}
@ -146,7 +138,7 @@ static int perf_record__mmap_read(struct perf_record *rec,
size = head - old;
old += size;
if (write_output(rec, buf, size) < 0) {
if (perf_record__write(rec, buf, size) < 0) {
rc = -1;
goto out;
}
@ -335,8 +327,8 @@ static int perf_record__mmap_read_all(struct perf_record *rec)
}
if (perf_header__has_feat(&rec->session->header, HEADER_TRACING_DATA))
rc = write_output(rec, &finished_round_event,
sizeof(finished_round_event));
rc = perf_record__write(rec, &finished_round_event,
sizeof(finished_round_event));
out:
return rc;

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

@ -41,19 +41,25 @@
#define SUPPORT_OLD_POWER_EVENTS 1
#define PWR_EVENT_EXIT -1
static int proc_num = 15;
static unsigned int numcpus;
static u64 min_freq; /* Lowest CPU frequency seen */
static u64 max_freq; /* Highest CPU frequency seen */
static u64 turbo_frequency;
static u64 first_time, last_time;
static bool power_only;
static bool tasks_only;
static bool with_backtrace;
struct per_pid;
struct power_event;
struct wake_event;
struct timechart {
struct perf_tool tool;
struct per_pid *all_data;
struct power_event *power_events;
struct wake_event *wake_events;
int proc_num;
unsigned int numcpus;
u64 min_freq, /* Lowest CPU frequency seen */
max_freq, /* Highest CPU frequency seen */
turbo_frequency,
first_time, last_time;
bool power_only,
tasks_only,
with_backtrace;
};
struct per_pidcomm;
struct cpu_sample;
@ -124,8 +130,6 @@ struct cpu_sample {
const char *backtrace;
};
static struct per_pid *all_data;
#define CSTATE 1
#define PSTATE 2
@ -146,9 +150,6 @@ struct wake_event {
const char *backtrace;
};
static struct power_event *power_events;
static struct wake_event *wake_events;
struct process_filter {
char *name;
int pid;
@ -158,9 +159,9 @@ struct process_filter {
static struct process_filter *process_filter;
static struct per_pid *find_create_pid(int pid)
static struct per_pid *find_create_pid(struct timechart *tchart, int pid)
{
struct per_pid *cursor = all_data;
struct per_pid *cursor = tchart->all_data;
while (cursor) {
if (cursor->pid == pid)
@ -170,16 +171,16 @@ static struct per_pid *find_create_pid(int pid)
cursor = zalloc(sizeof(*cursor));
assert(cursor != NULL);
cursor->pid = pid;
cursor->next = all_data;
all_data = cursor;
cursor->next = tchart->all_data;
tchart->all_data = cursor;
return cursor;
}
static void pid_set_comm(int pid, char *comm)
static void pid_set_comm(struct timechart *tchart, int pid, char *comm)
{
struct per_pid *p;
struct per_pidcomm *c;
p = find_create_pid(pid);
p = find_create_pid(tchart, pid);
c = p->all;
while (c) {
if (c->comm && strcmp(c->comm, comm) == 0) {
@ -201,14 +202,14 @@ static void pid_set_comm(int pid, char *comm)
p->all = c;
}
static void pid_fork(int pid, int ppid, u64 timestamp)
static void pid_fork(struct timechart *tchart, int pid, int ppid, u64 timestamp)
{
struct per_pid *p, *pp;
p = find_create_pid(pid);
pp = find_create_pid(ppid);
p = find_create_pid(tchart, pid);
pp = find_create_pid(tchart, ppid);
p->ppid = ppid;
if (pp->current && pp->current->comm && !p->current)
pid_set_comm(pid, pp->current->comm);
pid_set_comm(tchart, pid, pp->current->comm);
p->start_time = timestamp;
if (p->current) {
@ -217,24 +218,24 @@ static void pid_fork(int pid, int ppid, u64 timestamp)
}
}
static void pid_exit(int pid, u64 timestamp)
static void pid_exit(struct timechart *tchart, int pid, u64 timestamp)
{
struct per_pid *p;
p = find_create_pid(pid);
p = find_create_pid(tchart, pid);
p->end_time = timestamp;
if (p->current)
p->current->end_time = timestamp;
}
static void
pid_put_sample(int pid, int type, unsigned int cpu, u64 start, u64 end,
const char *backtrace)
static void pid_put_sample(struct timechart *tchart, int pid, int type,
unsigned int cpu, u64 start, u64 end,
const char *backtrace)
{
struct per_pid *p;
struct per_pidcomm *c;
struct cpu_sample *sample;
p = find_create_pid(pid);
p = find_create_pid(tchart, pid);
c = p->current;
if (!c) {
c = zalloc(sizeof(*c));
@ -272,30 +273,33 @@ static int cpus_cstate_state[MAX_CPUS];
static u64 cpus_pstate_start_times[MAX_CPUS];
static u64 cpus_pstate_state[MAX_CPUS];
static int process_comm_event(struct perf_tool *tool __maybe_unused,
static int process_comm_event(struct perf_tool *tool,
union perf_event *event,
struct perf_sample *sample __maybe_unused,
struct machine *machine __maybe_unused)
{
pid_set_comm(event->comm.tid, event->comm.comm);
struct timechart *tchart = container_of(tool, struct timechart, tool);
pid_set_comm(tchart, event->comm.tid, event->comm.comm);
return 0;
}
static int process_fork_event(struct perf_tool *tool __maybe_unused,
static int process_fork_event(struct perf_tool *tool,
union perf_event *event,
struct perf_sample *sample __maybe_unused,
struct machine *machine __maybe_unused)
{
pid_fork(event->fork.pid, event->fork.ppid, event->fork.time);
struct timechart *tchart = container_of(tool, struct timechart, tool);
pid_fork(tchart, event->fork.pid, event->fork.ppid, event->fork.time);
return 0;
}
static int process_exit_event(struct perf_tool *tool __maybe_unused,
static int process_exit_event(struct perf_tool *tool,
union perf_event *event,
struct perf_sample *sample __maybe_unused,
struct machine *machine __maybe_unused)
{
pid_exit(event->fork.pid, event->fork.time);
struct timechart *tchart = container_of(tool, struct timechart, tool);
pid_exit(tchart, event->fork.pid, event->fork.time);
return 0;
}
@ -309,7 +313,7 @@ static void c_state_start(int cpu, u64 timestamp, int state)
cpus_cstate_state[cpu] = state;
}
static void c_state_end(int cpu, u64 timestamp)
static void c_state_end(struct timechart *tchart, int cpu, u64 timestamp)
{
struct power_event *pwr = zalloc(sizeof(*pwr));
@ -321,12 +325,12 @@ static void c_state_end(int cpu, u64 timestamp)
pwr->end_time = timestamp;
pwr->cpu = cpu;
pwr->type = CSTATE;
pwr->next = power_events;
pwr->next = tchart->power_events;
power_events = pwr;
tchart->power_events = pwr;
}
static void p_state_change(int cpu, u64 timestamp, u64 new_freq)
static void p_state_change(struct timechart *tchart, int cpu, u64 timestamp, u64 new_freq)
{
struct power_event *pwr;
@ -342,28 +346,28 @@ static void p_state_change(int cpu, u64 timestamp, u64 new_freq)
pwr->end_time = timestamp;
pwr->cpu = cpu;
pwr->type = PSTATE;
pwr->next = power_events;
pwr->next = tchart->power_events;
if (!pwr->start_time)
pwr->start_time = first_time;
pwr->start_time = tchart->first_time;
power_events = pwr;
tchart->power_events = pwr;
cpus_pstate_state[cpu] = new_freq;
cpus_pstate_start_times[cpu] = timestamp;
if ((u64)new_freq > max_freq)
max_freq = new_freq;
if ((u64)new_freq > tchart->max_freq)
tchart->max_freq = new_freq;
if (new_freq < min_freq || min_freq == 0)
min_freq = new_freq;
if (new_freq < tchart->min_freq || tchart->min_freq == 0)
tchart->min_freq = new_freq;
if (new_freq == max_freq - 1000)
turbo_frequency = max_freq;
if (new_freq == tchart->max_freq - 1000)
tchart->turbo_frequency = tchart->max_freq;
}
static void sched_wakeup(int cpu, u64 timestamp, int waker, int wakee,
u8 flags, const char *backtrace)
static void sched_wakeup(struct timechart *tchart, int cpu, u64 timestamp,
int waker, int wakee, u8 flags, const char *backtrace)
{
struct per_pid *p;
struct wake_event *we = zalloc(sizeof(*we));
@ -379,38 +383,39 @@ static void sched_wakeup(int cpu, u64 timestamp, int waker, int wakee,
we->waker = -1;
we->wakee = wakee;
we->next = wake_events;
wake_events = we;
p = find_create_pid(we->wakee);
we->next = tchart->wake_events;
tchart->wake_events = we;
p = find_create_pid(tchart, we->wakee);
if (p && p->current && p->current->state == TYPE_NONE) {
p->current->state_since = timestamp;
p->current->state = TYPE_WAITING;
}
if (p && p->current && p->current->state == TYPE_BLOCKED) {
pid_put_sample(p->pid, p->current->state, cpu,
pid_put_sample(tchart, p->pid, p->current->state, cpu,
p->current->state_since, timestamp, NULL);
p->current->state_since = timestamp;
p->current->state = TYPE_WAITING;
}
}
static void sched_switch(int cpu, u64 timestamp, int prev_pid, int next_pid,
u64 prev_state, const char *backtrace)
static void sched_switch(struct timechart *tchart, int cpu, u64 timestamp,
int prev_pid, int next_pid, u64 prev_state,
const char *backtrace)
{
struct per_pid *p = NULL, *prev_p;
prev_p = find_create_pid(prev_pid);
prev_p = find_create_pid(tchart, prev_pid);
p = find_create_pid(next_pid);
p = find_create_pid(tchart, next_pid);
if (prev_p->current && prev_p->current->state != TYPE_NONE)
pid_put_sample(prev_pid, TYPE_RUNNING, cpu,
pid_put_sample(tchart, prev_pid, TYPE_RUNNING, cpu,
prev_p->current->state_since, timestamp,
backtrace);
if (p && p->current) {
if (p->current->state != TYPE_NONE)
pid_put_sample(next_pid, p->current->state, cpu,
pid_put_sample(tchart, next_pid, p->current->state, cpu,
p->current->state_since, timestamp,
backtrace);
@ -506,36 +511,40 @@ exit:
return p;
}
typedef int (*tracepoint_handler)(struct perf_evsel *evsel,
typedef int (*tracepoint_handler)(struct timechart *tchart,
struct perf_evsel *evsel,
struct perf_sample *sample,
const char *backtrace);
static int process_sample_event(struct perf_tool *tool __maybe_unused,
static int process_sample_event(struct perf_tool *tool,
union perf_event *event,
struct perf_sample *sample,
struct perf_evsel *evsel,
struct machine *machine __maybe_unused)
struct machine *machine)
{
struct timechart *tchart = container_of(tool, struct timechart, tool);
if (evsel->attr.sample_type & PERF_SAMPLE_TIME) {
if (!first_time || first_time > sample->time)
first_time = sample->time;
if (last_time < sample->time)
last_time = sample->time;
if (!tchart->first_time || tchart->first_time > sample->time)
tchart->first_time = sample->time;
if (tchart->last_time < sample->time)
tchart->last_time = sample->time;
}
if (sample->cpu > numcpus)
numcpus = sample->cpu;
if (sample->cpu > tchart->numcpus)
tchart->numcpus = sample->cpu;
if (evsel->handler != NULL) {
tracepoint_handler f = evsel->handler;
return f(evsel, sample, cat_backtrace(event, sample, machine));
return f(tchart, evsel, sample, cat_backtrace(event, sample, machine));
}
return 0;
}
static int
process_sample_cpu_idle(struct perf_evsel *evsel,
process_sample_cpu_idle(struct timechart *tchart __maybe_unused,
struct perf_evsel *evsel,
struct perf_sample *sample,
const char *backtrace __maybe_unused)
{
@ -543,26 +552,28 @@ process_sample_cpu_idle(struct perf_evsel *evsel,
u32 cpu_id = perf_evsel__intval(evsel, sample, "cpu_id");
if (state == (u32)PWR_EVENT_EXIT)
c_state_end(cpu_id, sample->time);
c_state_end(tchart, cpu_id, sample->time);
else
c_state_start(cpu_id, sample->time, state);
return 0;
}
static int
process_sample_cpu_frequency(struct perf_evsel *evsel,
process_sample_cpu_frequency(struct timechart *tchart,
struct perf_evsel *evsel,
struct perf_sample *sample,
const char *backtrace __maybe_unused)
{
u32 state = perf_evsel__intval(evsel, sample, "state");
u32 cpu_id = perf_evsel__intval(evsel, sample, "cpu_id");
p_state_change(cpu_id, sample->time, state);
p_state_change(tchart, cpu_id, sample->time, state);
return 0;
}
static int
process_sample_sched_wakeup(struct perf_evsel *evsel,
process_sample_sched_wakeup(struct timechart *tchart,
struct perf_evsel *evsel,
struct perf_sample *sample,
const char *backtrace)
{
@ -570,12 +581,13 @@ process_sample_sched_wakeup(struct perf_evsel *evsel,
int waker = perf_evsel__intval(evsel, sample, "common_pid");
int wakee = perf_evsel__intval(evsel, sample, "pid");
sched_wakeup(sample->cpu, sample->time, waker, wakee, flags, backtrace);
sched_wakeup(tchart, sample->cpu, sample->time, waker, wakee, flags, backtrace);
return 0;
}
static int
process_sample_sched_switch(struct perf_evsel *evsel,
process_sample_sched_switch(struct timechart *tchart,
struct perf_evsel *evsel,
struct perf_sample *sample,
const char *backtrace)
{
@ -583,14 +595,15 @@ process_sample_sched_switch(struct perf_evsel *evsel,
int next_pid = perf_evsel__intval(evsel, sample, "next_pid");
u64 prev_state = perf_evsel__intval(evsel, sample, "prev_state");
sched_switch(sample->cpu, sample->time, prev_pid, next_pid, prev_state,
backtrace);
sched_switch(tchart, sample->cpu, sample->time, prev_pid, next_pid,
prev_state, backtrace);
return 0;
}
#ifdef SUPPORT_OLD_POWER_EVENTS
static int
process_sample_power_start(struct perf_evsel *evsel,
process_sample_power_start(struct timechart *tchart __maybe_unused,
struct perf_evsel *evsel,
struct perf_sample *sample,
const char *backtrace __maybe_unused)
{
@ -602,23 +615,25 @@ process_sample_power_start(struct perf_evsel *evsel,
}
static int
process_sample_power_end(struct perf_evsel *evsel __maybe_unused,
process_sample_power_end(struct timechart *tchart,
struct perf_evsel *evsel __maybe_unused,
struct perf_sample *sample,
const char *backtrace __maybe_unused)
{
c_state_end(sample->cpu, sample->time);
c_state_end(tchart, sample->cpu, sample->time);
return 0;
}
static int
process_sample_power_frequency(struct perf_evsel *evsel,
process_sample_power_frequency(struct timechart *tchart,
struct perf_evsel *evsel,
struct perf_sample *sample,
const char *backtrace __maybe_unused)
{
u64 cpu_id = perf_evsel__intval(evsel, sample, "cpu_id");
u64 value = perf_evsel__intval(evsel, sample, "value");
p_state_change(cpu_id, sample->time, value);
p_state_change(tchart, cpu_id, sample->time, value);
return 0;
}
#endif /* SUPPORT_OLD_POWER_EVENTS */
@ -627,12 +642,12 @@ process_sample_power_frequency(struct perf_evsel *evsel,
* After the last sample we need to wrap up the current C/P state
* and close out each CPU for these.
*/
static void end_sample_processing(void)
static void end_sample_processing(struct timechart *tchart)
{
u64 cpu;
struct power_event *pwr;
for (cpu = 0; cpu <= numcpus; cpu++) {
for (cpu = 0; cpu <= tchart->numcpus; cpu++) {
/* C state */
#if 0
pwr = zalloc(sizeof(*pwr));
@ -641,12 +656,12 @@ static void end_sample_processing(void)
pwr->state = cpus_cstate_state[cpu];
pwr->start_time = cpus_cstate_start_times[cpu];
pwr->end_time = last_time;
pwr->end_time = tchart->last_time;
pwr->cpu = cpu;
pwr->type = CSTATE;
pwr->next = power_events;
pwr->next = tchart->power_events;
power_events = pwr;
tchart->power_events = pwr;
#endif
/* P state */
@ -656,32 +671,32 @@ static void end_sample_processing(void)
pwr->state = cpus_pstate_state[cpu];
pwr->start_time = cpus_pstate_start_times[cpu];
pwr->end_time = last_time;
pwr->end_time = tchart->last_time;
pwr->cpu = cpu;
pwr->type = PSTATE;
pwr->next = power_events;
pwr->next = tchart->power_events;
if (!pwr->start_time)
pwr->start_time = first_time;
pwr->start_time = tchart->first_time;
if (!pwr->state)
pwr->state = min_freq;
power_events = pwr;
pwr->state = tchart->min_freq;
tchart->power_events = pwr;
}
}
/*
* Sort the pid datastructure
*/
static void sort_pids(void)
static void sort_pids(struct timechart *tchart)
{
struct per_pid *new_list, *p, *cursor, *prev;
/* sort by ppid first, then by pid, lowest to highest */
new_list = NULL;
while (all_data) {
p = all_data;
all_data = p->next;
while (tchart->all_data) {
p = tchart->all_data;
tchart->all_data = p->next;
p->next = NULL;
if (new_list == NULL) {
@ -714,14 +729,14 @@ static void sort_pids(void)
prev->next = p;
}
}
all_data = new_list;
tchart->all_data = new_list;
}
static void draw_c_p_states(void)
static void draw_c_p_states(struct timechart *tchart)
{
struct power_event *pwr;
pwr = power_events;
pwr = tchart->power_events;
/*
* two pass drawing so that the P state bars are on top of the C state blocks
@ -732,30 +747,30 @@ static void draw_c_p_states(void)
pwr = pwr->next;
}
pwr = power_events;
pwr = tchart->power_events;
while (pwr) {
if (pwr->type == PSTATE) {
if (!pwr->state)
pwr->state = min_freq;
pwr->state = tchart->min_freq;
svg_pstate(pwr->cpu, pwr->start_time, pwr->end_time, pwr->state);
}
pwr = pwr->next;
}
}
static void draw_wakeups(void)
static void draw_wakeups(struct timechart *tchart)
{
struct wake_event *we;
struct per_pid *p;
struct per_pidcomm *c;
we = wake_events;
we = tchart->wake_events;
while (we) {
int from = 0, to = 0;
char *task_from = NULL, *task_to = NULL;
/* locate the column of the waker and wakee */
p = all_data;
p = tchart->all_data;
while (p) {
if (p->pid == we->waker || p->pid == we->wakee) {
c = p->all;
@ -811,12 +826,12 @@ static void draw_wakeups(void)
}
}
static void draw_cpu_usage(void)
static void draw_cpu_usage(struct timechart *tchart)
{
struct per_pid *p;
struct per_pidcomm *c;
struct cpu_sample *sample;
p = all_data;
p = tchart->all_data;
while (p) {
c = p->all;
while (c) {
@ -833,16 +848,16 @@ static void draw_cpu_usage(void)
}
}
static void draw_process_bars(void)
static void draw_process_bars(struct timechart *tchart)
{
struct per_pid *p;
struct per_pidcomm *c;
struct cpu_sample *sample;
int Y = 0;
Y = 2 * numcpus + 2;
Y = 2 * tchart->numcpus + 2;
p = all_data;
p = tchart->all_data;
while (p) {
c = p->all;
while (c) {
@ -922,21 +937,21 @@ static int passes_filter(struct per_pid *p, struct per_pidcomm *c)
return 0;
}
static int determine_display_tasks_filtered(void)
static int determine_display_tasks_filtered(struct timechart *tchart)
{
struct per_pid *p;
struct per_pidcomm *c;
int count = 0;
p = all_data;
p = tchart->all_data;
while (p) {
p->display = 0;
if (p->start_time == 1)
p->start_time = first_time;
p->start_time = tchart->first_time;
/* no exit marker, task kept running to the end */
if (p->end_time == 0)
p->end_time = last_time;
p->end_time = tchart->last_time;
c = p->all;
@ -944,7 +959,7 @@ static int determine_display_tasks_filtered(void)
c->display = 0;
if (c->start_time == 1)
c->start_time = first_time;
c->start_time = tchart->first_time;
if (passes_filter(p, c)) {
c->display = 1;
@ -953,7 +968,7 @@ static int determine_display_tasks_filtered(void)
}
if (c->end_time == 0)
c->end_time = last_time;
c->end_time = tchart->last_time;
c = c->next;
}
@ -962,24 +977,24 @@ static int determine_display_tasks_filtered(void)
return count;
}
static int determine_display_tasks(u64 threshold)
static int determine_display_tasks(struct timechart *tchart, u64 threshold)
{
struct per_pid *p;
struct per_pidcomm *c;
int count = 0;
if (process_filter)
return determine_display_tasks_filtered();
return determine_display_tasks_filtered(tchart);
p = all_data;
p = tchart->all_data;
while (p) {
p->display = 0;
if (p->start_time == 1)
p->start_time = first_time;
p->start_time = tchart->first_time;
/* no exit marker, task kept running to the end */
if (p->end_time == 0)
p->end_time = last_time;
p->end_time = tchart->last_time;
if (p->total_time >= threshold)
p->display = 1;
@ -989,7 +1004,7 @@ static int determine_display_tasks(u64 threshold)
c->display = 0;
if (c->start_time == 1)
c->start_time = first_time;
c->start_time = tchart->first_time;
if (c->total_time >= threshold) {
c->display = 1;
@ -997,7 +1012,7 @@ static int determine_display_tasks(u64 threshold)
}
if (c->end_time == 0)
c->end_time = last_time;
c->end_time = tchart->last_time;
c = c->next;
}
@ -1010,52 +1025,45 @@ static int determine_display_tasks(u64 threshold)
#define TIME_THRESH 10000000
static void write_svg_file(const char *filename)
static void write_svg_file(struct timechart *tchart, const char *filename)
{
u64 i;
int count;
int thresh = TIME_THRESH;
numcpus++;
tchart->numcpus++;
if (power_only)
proc_num = 0;
if (tchart->power_only)
tchart->proc_num = 0;
/* We'd like to show at least proc_num tasks;
* be less picky if we have fewer */
do {
count = determine_display_tasks(thresh);
count = determine_display_tasks(tchart, thresh);
thresh /= 10;
} while (!process_filter && thresh && count < proc_num);
} while (!process_filter && thresh && count < tchart->proc_num);
open_svg(filename, numcpus, count, first_time, last_time);
open_svg(filename, tchart->numcpus, count, tchart->first_time, tchart->last_time);
svg_time_grid();
svg_legenda();
for (i = 0; i < numcpus; i++)
svg_cpu_box(i, max_freq, turbo_frequency);
for (i = 0; i < tchart->numcpus; i++)
svg_cpu_box(i, tchart->max_freq, tchart->turbo_frequency);
draw_cpu_usage();
if (proc_num)
draw_process_bars();
if (!tasks_only)
draw_c_p_states();
if (proc_num)
draw_wakeups();
draw_cpu_usage(tchart);
if (tchart->proc_num)
draw_process_bars(tchart);
if (!tchart->tasks_only)
draw_c_p_states(tchart);
if (tchart->proc_num)
draw_wakeups(tchart);
svg_close();
}
static int __cmd_timechart(const char *output_name)
static int __cmd_timechart(struct timechart *tchart, const char *output_name)
{
struct perf_tool perf_timechart = {
.comm = process_comm_event,
.fork = process_fork_event,
.exit = process_exit_event,
.sample = process_sample_event,
.ordered_samples = true,
};
const struct perf_evsel_str_handler power_tracepoints[] = {
{ "power:cpu_idle", process_sample_cpu_idle },
{ "power:cpu_frequency", process_sample_cpu_frequency },
@ -1073,7 +1081,7 @@ static int __cmd_timechart(const char *output_name)
};
struct perf_session *session = perf_session__new(&file, false,
&perf_timechart);
&tchart->tool);
int ret = -EINVAL;
if (session == NULL)
@ -1088,24 +1096,24 @@ static int __cmd_timechart(const char *output_name)
goto out_delete;
}
ret = perf_session__process_events(session, &perf_timechart);
ret = perf_session__process_events(session, &tchart->tool);
if (ret)
goto out_delete;
end_sample_processing();
end_sample_processing(tchart);
sort_pids();
sort_pids(tchart);
write_svg_file(output_name);
write_svg_file(tchart, output_name);
pr_info("Written %2.1f seconds of trace to %s.\n",
(last_time - first_time) / 1000000000.0, output_name);
(tchart->last_time - tchart->first_time) / 1000000000.0, output_name);
out_delete:
perf_session__delete(session);
return ret;
}
static int __cmd_record(int argc, const char **argv)
static int timechart__record(struct timechart *tchart, int argc, const char **argv)
{
unsigned int rec_argc, i, j;
const char **rec_argv;
@ -1153,15 +1161,15 @@ static int __cmd_record(int argc, const char **argv)
}
#endif
if (power_only)
if (tchart->power_only)
tasks_args_nr = 0;
if (tasks_only) {
if (tchart->tasks_only) {
power_args_nr = 0;
old_power_args_nr = 0;
}
if (!with_backtrace)
if (!tchart->with_backtrace)
backtrace_args_no = 0;
record_elems = common_args_nr + tasks_args_nr +
@ -1207,20 +1215,30 @@ parse_process(const struct option *opt __maybe_unused, const char *arg,
int cmd_timechart(int argc, const char **argv,
const char *prefix __maybe_unused)
{
struct timechart tchart = {
.tool = {
.comm = process_comm_event,
.fork = process_fork_event,
.exit = process_exit_event,
.sample = process_sample_event,
.ordered_samples = true,
},
.proc_num = 15,
};
const char *output_name = "output.svg";
const struct option timechart_options[] = {
OPT_STRING('i', "input", &input_name, "file", "input file name"),
OPT_STRING('o', "output", &output_name, "file", "output file name"),
OPT_INTEGER('w', "width", &svg_page_width, "page width"),
OPT_BOOLEAN('P', "power-only", &power_only, "output power data only"),
OPT_BOOLEAN('T', "tasks-only", &tasks_only,
OPT_BOOLEAN('P', "power-only", &tchart.power_only, "output power data only"),
OPT_BOOLEAN('T', "tasks-only", &tchart.tasks_only,
"output processes data only"),
OPT_CALLBACK('p', "process", NULL, "process",
"process selector. Pass a pid or process name.",
parse_process),
OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
"Look for files with symbols relative to this directory"),
OPT_INTEGER('n', "proc-num", &proc_num,
OPT_INTEGER('n', "proc-num", &tchart.proc_num,
"min. number of tasks to print"),
OPT_END()
};
@ -1230,10 +1248,10 @@ int cmd_timechart(int argc, const char **argv,
};
const struct option record_options[] = {
OPT_BOOLEAN('P', "power-only", &power_only, "output power data only"),
OPT_BOOLEAN('T', "tasks-only", &tasks_only,
OPT_BOOLEAN('P', "power-only", &tchart.power_only, "output power data only"),
OPT_BOOLEAN('T', "tasks-only", &tchart.tasks_only,
"output processes data only"),
OPT_BOOLEAN('g', "callchain", &with_backtrace, "record callchain"),
OPT_BOOLEAN('g', "callchain", &tchart.with_backtrace, "record callchain"),
OPT_END()
};
const char * const record_usage[] = {
@ -1243,7 +1261,7 @@ int cmd_timechart(int argc, const char **argv,
argc = parse_options(argc, argv, timechart_options, timechart_usage,
PARSE_OPT_STOP_AT_NON_OPTION);
if (power_only && tasks_only) {
if (tchart.power_only && tchart.tasks_only) {
pr_err("-P and -T options cannot be used at the same time.\n");
return -1;
}
@ -1254,16 +1272,16 @@ int cmd_timechart(int argc, const char **argv,
argc = parse_options(argc, argv, record_options, record_usage,
PARSE_OPT_STOP_AT_NON_OPTION);
if (power_only && tasks_only) {
if (tchart.power_only && tchart.tasks_only) {
pr_err("-P and -T options cannot be used at the same time.\n");
return -1;
}
return __cmd_record(argc, argv);
return timechart__record(&tchart, argc, argv);
} else if (argc)
usage_with_options(timechart_usage, timechart_options);
setup_pager();
return __cmd_timechart(output_name);
return __cmd_timechart(&tchart, output_name);
}

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

@ -1890,7 +1890,7 @@ static int trace__run(struct trace *trace, int argc, const char **argv)
if (err < 0)
goto out_error_open;
err = perf_evlist__mmap(evlist, UINT_MAX, false);
err = perf_evlist__mmap(evlist, trace->opts.mmap_pages, false);
if (err < 0) {
fprintf(trace->output, "Couldn't mmap the events: %s\n", strerror(errno));
goto out_close_evlist;

2
tools/perf/config/Makefile
View File

@ -533,7 +533,7 @@ endif
ifndef NO_LIBNUMA
ifeq ($(feature-libnuma), 0)
msg := $(warning No numa.h found, disables 'perf bench numa mem' benchmark, please install numa-libs-devel or libnuma-dev);
msg := $(warning No numa.h found, disables 'perf bench numa mem' benchmark, please install numactl-devel/libnuma-devel/libnuma-dev);
NO_LIBNUMA := 1
else
CFLAGS += -DHAVE_LIBNUMA_SUPPORT

5
tools/perf/config/feature-checks/test-all.c
View File

@ -85,6 +85,10 @@
# include "test-timerfd.c"
#undef main
#define main main_test_stackprotector_all
# include "test-stackprotector-all.c"
#undef main
int main(int argc, char *argv[])
{
main_test_libpython();
@ -106,6 +110,7 @@ int main(int argc, char *argv[])
main_test_backtrace();
main_test_libnuma();
main_test_timerfd();
main_test_stackprotector_all();
return 0;
}

6
tools/perf/util/data.c
View File

@ -118,3 +118,9 @@ void perf_data_file__close(struct perf_data_file *file)
{
close(file->fd);
}
ssize_t perf_data_file__write(struct perf_data_file *file,
void *buf, size_t size)
{
return writen(file->fd, buf, size);
}

14
tools/perf/util/data.h
View File

@ -9,12 +9,12 @@ enum perf_data_mode {
};
struct perf_data_file {
const char *path;
int fd;
bool is_pipe;
bool force;
unsigned long size;
enum perf_data_mode mode;
const char *path;
int fd;
bool is_pipe;
bool force;
unsigned long size;
enum perf_data_mode mode;
};
static inline bool perf_data_file__is_read(struct perf_data_file *file)
@ -44,5 +44,7 @@ static inline unsigned long perf_data_file__size(struct perf_data_file *file)
int perf_data_file__open(struct perf_data_file *file);
void perf_data_file__close(struct perf_data_file *file);
ssize_t perf_data_file__write(struct perf_data_file *file,
void *buf, size_t size);
#endif /* __PERF_DATA_H */

18
tools/perf/util/header.c
View File

@ -1709,7 +1709,7 @@ static int process_nrcpus(struct perf_file_section *section __maybe_unused,
struct perf_header *ph, int fd,
void *data __maybe_unused)
{
size_t ret;
ssize_t ret;
u32 nr;
ret = readn(fd, &nr, sizeof(nr));
@ -1753,7 +1753,7 @@ static int process_total_mem(struct perf_file_section *section __maybe_unused,
void *data __maybe_unused)
{
uint64_t mem;
size_t ret;
ssize_t ret;
ret = readn(fd, &mem, sizeof(mem));
if (ret != sizeof(mem))
@ -1822,7 +1822,7 @@ static int process_cmdline(struct perf_file_section *section __maybe_unused,
struct perf_header *ph, int fd,
void *data __maybe_unused)
{
size_t ret;
ssize_t ret;
char *str;
u32 nr, i;
struct strbuf sb;
@ -1858,7 +1858,7 @@ static int process_cpu_topology(struct perf_file_section *section __maybe_unused
struct perf_header *ph, int fd,
void *data __maybe_unused)
{
size_t ret;
ssize_t ret;
u32 nr, i;
char *str;
struct strbuf sb;
@ -1914,7 +1914,7 @@ static int process_numa_topology(struct perf_file_section *section __maybe_unuse
struct perf_header *ph, int fd,
void *data __maybe_unused)
{
size_t ret;
ssize_t ret;
u32 nr, node, i;
char *str;
uint64_t mem_total, mem_free;
@ -1974,7 +1974,7 @@ static int process_pmu_mappings(struct perf_file_section *section __maybe_unused
struct perf_header *ph, int fd,
void *data __maybe_unused)
{
size_t ret;
ssize_t ret;
char *name;
u32 pmu_num;
u32 type;
@ -2534,7 +2534,7 @@ static int check_magic_endian(u64 magic, uint64_t hdr_sz,
int perf_file_header__read(struct perf_file_header *header,
struct perf_header *ph, int fd)
{
int ret;
ssize_t ret;
lseek(fd, 0, SEEK_SET);
@ -2628,7 +2628,7 @@ static int perf_file_header__read_pipe(struct perf_pipe_file_header *header,
struct perf_header *ph, int fd,
bool repipe)
{
int ret;
ssize_t ret;
ret = readn(fd, header, sizeof(*header));
if (ret <= 0)
@ -2669,7 +2669,7 @@ static int read_attr(int fd, struct perf_header *ph,
struct perf_event_attr *attr = &f_attr->attr;
size_t sz, left;
size_t our_sz = sizeof(f_attr->attr);
int ret;
ssize_t ret;
memset(f_attr, 0, sizeof(*f_attr));

2
tools/perf/util/session.c
View File

@ -1158,7 +1158,7 @@ static int __perf_session__process_pipe_events(struct perf_session *session,
void *buf = NULL;
int skip = 0;
u64 head;
int err;
ssize_t err;
void *p;
perf_tool__fill_defaults(tool);

32
tools/perf/util/util.c
View File

@ -6,6 +6,7 @@
#endif
#include <stdio.h>
#include <stdlib.h>
#include <linux/kernel.h>
/*
* XXX We need to find a better place for these things...
@ -151,21 +152,40 @@ unsigned long convert_unit(unsigned long value, char *unit)
return value;
}
int readn(int fd, void *buf, size_t n)
static ssize_t ion(bool is_read, int fd, void *buf, size_t n)
{
void *buf_start = buf;
size_t left = n;
while (n) {
int ret = read(fd, buf, n);
while (left) {
ssize_t ret = is_read ? read(fd, buf, left) :
write(fd, buf, left);
if (ret <= 0)
return ret;
n -= ret;
buf += ret;
left -= ret;
buf += ret;
}
return buf - buf_start;
BUG_ON((size_t)(buf - buf_start) != n);
return n;
}
/*
* Read exactly 'n' bytes or return an error.
*/
ssize_t readn(int fd, void *buf, size_t n)
{
return ion(true, fd, buf, n);
}
/*
* Write exactly 'n' bytes or return an error.
*/
ssize_t writen(int fd, void *buf, size_t n)
{
return ion(false, fd, buf, n);
}
size_t hex_width(u64 v)

3
tools/perf/util/util.h
View File

@ -253,7 +253,8 @@ bool strlazymatch(const char *str, const char *pat);
int strtailcmp(const char *s1, const char *s2);
char *strxfrchar(char *s, char from, char to);
unsigned long convert_unit(unsigned long value, char *unit);
int readn(int fd, void *buf, size_t size);
ssize_t readn(int fd, void *buf, size_t n);
ssize_t writen(int fd, void *buf, size_t n);
struct perf_event_attr;