On 64-bit powerpc, __u64 is defined to be unsigned long rather than
unsigned long long. This causes compiler warnings every time we
print a __u64 value with %Lx.
Rather than changing __u64, we define our own u64 to be unsigned long
long on all architectures, and similarly s64 as signed long long.
For consistency we also define u32, s32, u16, s16, u8 and s8. These
definitions are put in a new header, types.h, because these definitions
are needed in util/string.h and util/symbol.h.
The main change here is the mechanical change of __[us]{64,32,16,8}
to remove the "__". The other changes are:
* Create types.h
* Include types.h in perf.h, util/string.h and util/symbol.h
* Add types.h to the LIB_H definition in Makefile
* Added (u64) casts in process_overflow_event() and print_sym_table()
to kill two remaining warnings.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: benh@kernel.crashing.org
LKML-Reference: <19003.33494.495844.956580@cargo.ozlabs.ibm.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
13 files changed:
LIB_H += ../../include/linux/perf_counter.h
LIB_H += perf.h
LIB_H += ../../include/linux/perf_counter.h
LIB_H += perf.h
LIB_H += util/list.h
LIB_H += util/rbtree.h
LIB_H += util/levenshtein.h
LIB_H += util/list.h
LIB_H += util/rbtree.h
LIB_H += util/levenshtein.h
struct ip_event {
struct perf_event_header header;
struct ip_event {
struct perf_event_header header;
- __u64 ip;
- __u32 pid, tid;
+ u64 ip;
+ u32 pid, tid;
};
struct mmap_event {
struct perf_event_header header;
};
struct mmap_event {
struct perf_event_header header;
- __u32 pid, tid;
- __u64 start;
- __u64 len;
- __u64 pgoff;
+ u32 pid, tid;
+ u64 start;
+ u64 len;
+ u64 pgoff;
char filename[PATH_MAX];
};
struct comm_event {
struct perf_event_header header;
char filename[PATH_MAX];
};
struct comm_event {
struct perf_event_header header;
char comm[16];
};
struct fork_event {
struct perf_event_header header;
char comm[16];
};
struct fork_event {
struct perf_event_header header;
};
struct period_event {
struct perf_event_header header;
};
struct period_event {
struct perf_event_header header;
- __u64 time;
- __u64 id;
- __u64 sample_period;
+ u64 time;
+ u64 id;
+ u64 sample_period;
};
typedef union event_union {
};
typedef union event_union {
-static struct symbol *vdso__find_symbol(struct dso *dso, __u64 ip)
+static struct symbol *vdso__find_symbol(struct dso *dso, u64 ip)
{
return dso__find_symbol(kernel_dso, ip);
}
{
return dso__find_symbol(kernel_dso, ip);
}
struct map {
struct list_head node;
struct map {
struct list_head node;
- __u64 start;
- __u64 end;
- __u64 pgoff;
- __u64 (*map_ip)(struct map *, __u64);
+ u64 start;
+ u64 end;
+ u64 pgoff;
+ u64 (*map_ip)(struct map *, u64);
-static __u64 map__map_ip(struct map *map, __u64 ip)
+static u64 map__map_ip(struct map *map, u64 ip)
{
return ip - map->start + map->pgoff;
}
{
return ip - map->start + map->pgoff;
}
-static __u64 vdso__map_ip(struct map *map, __u64 ip)
+static u64 vdso__map_ip(struct map *map, u64 ip)
-static struct map *thread__find_map(struct thread *self, __u64 ip)
+static struct map *thread__find_map(struct thread *self, u64 ip)
struct map *map;
struct dso *dso;
struct symbol *sym;
struct map *map;
struct dso *dso;
struct symbol *sym;
char level;
uint32_t count;
char level;
uint32_t count;
if (self->dso)
return fprintf(fp, "%-25s", self->dso->name);
if (self->dso)
return fprintf(fp, "%-25s", self->dso->name);
- return fprintf(fp, "%016llx ", (__u64)self->ip);
+ return fprintf(fp, "%016llx ", (u64)self->ip);
}
static struct sort_entry sort_dso = {
}
static struct sort_entry sort_dso = {
static int64_t
sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
{
static int64_t
sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
{
if (left->sym == right->sym)
return 0;
if (left->sym == right->sym)
return 0;
size_t ret = 0;
if (verbose)
size_t ret = 0;
if (verbose)
- ret += fprintf(fp, "%#018llx ", (__u64)self->ip);
+ ret += fprintf(fp, "%#018llx ", (u64)self->ip);
if (self->sym) {
ret += fprintf(fp, "[%c] %s",
self->dso == kernel_dso ? 'k' : '.', self->sym->name);
} else {
if (self->sym) {
ret += fprintf(fp, "[%c] %s",
self->dso == kernel_dso ? 'k' : '.', self->sym->name);
} else {
- ret += fprintf(fp, "%#016llx", (__u64)self->ip);
+ ret += fprintf(fp, "%#016llx", (u64)self->ip);
/*
* collect histogram counts
*/
/*
* collect histogram counts
*/
-static void hist_hit(struct hist_entry *he, __u64 ip)
+static void hist_hit(struct hist_entry *he, u64 ip)
{
unsigned int sym_size, offset;
struct symbol *sym = he->sym;
{
unsigned int sym_size, offset;
struct symbol *sym = he->sym;
static int
hist_entry__add(struct thread *thread, struct map *map, struct dso *dso,
static int
hist_entry__add(struct thread *thread, struct map *map, struct dso *dso,
- struct symbol *sym, __u64 ip, char level)
+ struct symbol *sym, u64 ip, char level)
{
struct rb_node **p = &hist.rb_node;
struct rb_node *parent = NULL;
{
struct rb_node **p = &hist.rb_node;
struct rb_node *parent = NULL;
int show = 0;
struct dso *dso = NULL;
struct thread *thread = threads__findnew(event->ip.pid);
int show = 0;
struct dso *dso = NULL;
struct thread *thread = threads__findnew(event->ip.pid);
- __u64 ip = event->ip.ip;
struct map *map = NULL;
dprintf("%p [%p]: PERF_EVENT (IP, %d): %d: %p\n",
struct map *map = NULL;
dprintf("%p [%p]: PERF_EVENT (IP, %d): %d: %p\n",
-parse_line(FILE *file, struct symbol *sym, __u64 start, __u64 len)
+parse_line(FILE *file, struct symbol *sym, u64 start, u64 len)
{
char *line = NULL, *tmp, *tmp2;
static const char *prev_line;
static const char *prev_color;
unsigned int offset;
size_t line_len;
{
char *line = NULL, *tmp, *tmp2;
static const char *prev_line;
static const char *prev_color;
unsigned int offset;
size_t line_len;
/* Get the filename:line for the colored entries */
static void
/* Get the filename:line for the colored entries */
static void
-get_source_line(struct symbol *sym, __u64 start, int len, char *filename)
+get_source_line(struct symbol *sym, u64 start, int len, char *filename)
{
int i;
char cmd[PATH_MAX * 2];
{
int i;
char cmd[PATH_MAX * 2];
for (i = 0; i < len; i++) {
char *path = NULL;
size_t line_len;
for (i = 0; i < len; i++) {
char *path = NULL;
size_t line_len;
FILE *fp;
sym_ext[i].percent = 100.0 * sym->hist[i] / sym->hist_sum;
FILE *fp;
sym_ext[i].percent = 100.0 * sym->hist[i] / sym->hist_sum;
static void annotate_sym(struct dso *dso, struct symbol *sym)
{
char *filename = dso->name;
static void annotate_sym(struct dso *dso, struct symbol *sym)
{
char *filename = dso->name;
char command[PATH_MAX*2];
FILE *file;
char command[PATH_MAX*2];
FILE *file;
if (verbose >= 2)
printf("annotating [%p] %30s : [%p] %30s\n", dso, dso->name, sym, sym->name);
if (verbose >= 2)
printf("annotating [%p] %30s : [%p] %30s\n", dso, dso->name, sym, sym->name);
- sprintf(command, "objdump --start-address=0x%016Lx --stop-address=0x%016Lx -dS %s", (__u64)start, (__u64)end, filename);
+ sprintf(command, "objdump --start-address=0x%016Lx --stop-address=0x%016Lx -dS %s", (u64)start, (u64)end, filename);
if (verbose >= 3)
printf("doing: %s\n", command);
if (verbose >= 3)
printf("doing: %s\n", command);
static struct timeval last_read;
static struct timeval this_read;
static struct timeval last_read;
static struct timeval this_read;
-static __u64 bytes_written;
+static u64 bytes_written;
static struct pollfd event_array[MAX_NR_CPUS * MAX_COUNTERS];
static struct pollfd event_array[MAX_NR_CPUS * MAX_COUNTERS];
struct mmap_event {
struct perf_event_header header;
struct mmap_event {
struct perf_event_header header;
- __u32 pid;
- __u32 tid;
- __u64 start;
- __u64 len;
- __u64 pgoff;
+ u32 pid;
+ u32 tid;
+ u64 start;
+ u64 len;
+ u64 pgoff;
char filename[PATH_MAX];
};
struct comm_event {
struct perf_event_header header;
char filename[PATH_MAX];
};
struct comm_event {
struct perf_event_header header;
- __u32 pid;
- __u32 tid;
comm_ev.pid = pid;
comm_ev.header.type = PERF_EVENT_COMM;
comm_ev.pid = pid;
comm_ev.header.type = PERF_EVENT_COMM;
- size = ALIGN(size, sizeof(__u64));
+ size = ALIGN(size, sizeof(u64));
comm_ev.header.size = sizeof(comm_ev) - (sizeof(comm_ev.comm) - size);
if (!full) {
comm_ev.header.size = sizeof(comm_ev) - (sizeof(comm_ev.comm) - size);
if (!full) {
size = strlen(execname);
execname[size - 1] = '\0'; /* Remove \n */
memcpy(mmap_ev.filename, execname, size);
size = strlen(execname);
execname[size - 1] = '\0'; /* Remove \n */
memcpy(mmap_ev.filename, execname, size);
- size = ALIGN(size, sizeof(__u64));
+ size = ALIGN(size, sizeof(u64));
mmap_ev.len -= mmap_ev.start;
mmap_ev.header.size = (sizeof(mmap_ev) -
(sizeof(mmap_ev.filename) - size));
mmap_ev.len -= mmap_ev.start;
mmap_ev.header.size = (sizeof(mmap_ev) -
(sizeof(mmap_ev.filename) - size));
struct ip_event {
struct perf_event_header header;
struct ip_event {
struct perf_event_header header;
- __u64 ip;
- __u32 pid, tid;
+ u64 ip;
+ u32 pid, tid;
unsigned char __more_data[];
};
struct ip_callchain {
unsigned char __more_data[];
};
struct ip_callchain {
- __u64 nr;
- __u64 ips[0];
};
struct mmap_event {
struct perf_event_header header;
};
struct mmap_event {
struct perf_event_header header;
- __u32 pid, tid;
- __u64 start;
- __u64 len;
- __u64 pgoff;
+ u32 pid, tid;
+ u64 start;
+ u64 len;
+ u64 pgoff;
char filename[PATH_MAX];
};
struct comm_event {
struct perf_event_header header;
char filename[PATH_MAX];
};
struct comm_event {
struct perf_event_header header;
char comm[16];
};
struct fork_event {
struct perf_event_header header;
char comm[16];
};
struct fork_event {
struct perf_event_header header;
};
struct period_event {
struct perf_event_header header;
};
struct period_event {
struct perf_event_header header;
- __u64 time;
- __u64 id;
- __u64 sample_period;
+ u64 time;
+ u64 id;
+ u64 sample_period;
};
struct lost_event {
struct perf_event_header header;
};
struct lost_event {
struct perf_event_header header;
- __u64 id;
- __u64 lost;
};
typedef union event_union {
};
typedef union event_union {
-static struct symbol *vdso__find_symbol(struct dso *dso, __u64 ip)
+static struct symbol *vdso__find_symbol(struct dso *dso, u64 ip)
{
return dso__find_symbol(kernel_dso, ip);
}
{
return dso__find_symbol(kernel_dso, ip);
}
struct map {
struct list_head node;
struct map {
struct list_head node;
- __u64 start;
- __u64 end;
- __u64 pgoff;
- __u64 (*map_ip)(struct map *, __u64);
+ u64 start;
+ u64 end;
+ u64 pgoff;
+ u64 (*map_ip)(struct map *, u64);
-static __u64 map__map_ip(struct map *map, __u64 ip)
+static u64 map__map_ip(struct map *map, u64 ip)
{
return ip - map->start + map->pgoff;
}
{
return ip - map->start + map->pgoff;
}
-static __u64 vdso__map_ip(struct map *map, __u64 ip)
+static u64 vdso__map_ip(struct map *map, u64 ip)
-static struct map *thread__find_map(struct thread *self, __u64 ip)
+static struct map *thread__find_map(struct thread *self, u64 ip)
struct dso *dso;
struct symbol *sym;
struct symbol *parent;
struct dso *dso;
struct symbol *sym;
struct symbol *parent;
if (self->dso)
return fprintf(fp, "%-25s", self->dso->name);
if (self->dso)
return fprintf(fp, "%-25s", self->dso->name);
- return fprintf(fp, "%016llx ", (__u64)self->ip);
+ return fprintf(fp, "%016llx ", (u64)self->ip);
}
static struct sort_entry sort_dso = {
}
static struct sort_entry sort_dso = {
static int64_t
sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
{
static int64_t
sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
{
if (left->sym == right->sym)
return 0;
if (left->sym == right->sym)
return 0;
size_t ret = 0;
if (verbose)
size_t ret = 0;
if (verbose)
- ret += fprintf(fp, "%#018llx ", (__u64)self->ip);
+ ret += fprintf(fp, "%#018llx ", (u64)self->ip);
if (self->sym) {
ret += fprintf(fp, "[%c] %s",
self->dso == kernel_dso ? 'k' : '.', self->sym->name);
} else {
if (self->sym) {
ret += fprintf(fp, "[%c] %s",
self->dso == kernel_dso ? 'k' : '.', self->sym->name);
} else {
- ret += fprintf(fp, "%#016llx", (__u64)self->ip);
+ ret += fprintf(fp, "%#016llx", (u64)self->ip);
-hist_entry__fprintf(FILE *fp, struct hist_entry *self, __u64 total_samples)
+hist_entry__fprintf(FILE *fp, struct hist_entry *self, u64 total_samples)
{
struct sort_entry *se;
size_t ret;
{
struct sort_entry *se;
size_t ret;
static struct symbol *
resolve_symbol(struct thread *thread, struct map **mapp,
static struct symbol *
resolve_symbol(struct thread *thread, struct map **mapp,
- struct dso **dsop, __u64 *ipp)
+ struct dso **dsop, u64 *ipp)
{
struct dso *dso = dsop ? *dsop : NULL;
struct map *map = mapp ? *mapp : NULL;
{
struct dso *dso = dsop ? *dsop : NULL;
struct map *map = mapp ? *mapp : NULL;
static int
hist_entry__add(struct thread *thread, struct map *map, struct dso *dso,
static int
hist_entry__add(struct thread *thread, struct map *map, struct dso *dso,
- struct symbol *sym, __u64 ip, struct ip_callchain *chain,
- char level, __u64 count)
+ struct symbol *sym, u64 ip, struct ip_callchain *chain,
+ char level, u64 count)
{
struct rb_node **p = &hist.rb_node;
struct rb_node *parent = NULL;
{
struct rb_node **p = &hist.rb_node;
struct rb_node *parent = NULL;
int cmp;
if (sort__has_parent && chain) {
int cmp;
if (sort__has_parent && chain) {
- __u64 context = PERF_CONTEXT_MAX;
+ u64 context = PERF_CONTEXT_MAX;
int i;
for (i = 0; i < chain->nr; i++) {
int i;
for (i = 0; i < chain->nr; i++) {
- __u64 ip = chain->ips[i];
+ u64 ip = chain->ips[i];
struct dso *dso = NULL;
struct symbol *sym;
struct dso *dso = NULL;
struct symbol *sym;
-static size_t output__fprintf(FILE *fp, __u64 total_samples)
+static size_t output__fprintf(FILE *fp, u64 total_samples)
{
struct hist_entry *pos;
struct sort_entry *se;
{
struct hist_entry *pos;
struct sort_entry *se;
fprintf(fp, "\n");
fprintf(fp, "#\n");
fprintf(fp, "\n");
fprintf(fp, "#\n");
- fprintf(fp, "# (%Ld samples)\n", (__u64)total_samples);
+ fprintf(fp, "# (%Ld samples)\n", (u64)total_samples);
fprintf(fp, "#\n");
fprintf(fp, "# Overhead");
fprintf(fp, "#\n");
fprintf(fp, "# Overhead");
chain_size = event->header.size;
chain_size -= (unsigned long)&event->ip.__more_data - (unsigned long)event;
chain_size = event->header.size;
chain_size -= (unsigned long)&event->ip.__more_data - (unsigned long)event;
- if (chain->nr*sizeof(__u64) > chain_size)
+ if (chain->nr*sizeof(u64) > chain_size)
int show = 0;
struct dso *dso = NULL;
struct thread *thread = threads__findnew(event->ip.pid);
int show = 0;
struct dso *dso = NULL;
struct thread *thread = threads__findnew(event->ip.pid);
- __u64 ip = event->ip.ip;
- __u64 period = 1;
+ u64 ip = event->ip.ip;
+ u64 period = 1;
struct map *map = NULL;
void *more_data = event->ip.__more_data;
struct ip_callchain *chain = NULL;
if (event->header.type & PERF_SAMPLE_PERIOD) {
struct map *map = NULL;
void *more_data = event->ip.__more_data;
struct ip_callchain *chain = NULL;
if (event->header.type & PERF_SAMPLE_PERIOD) {
- period = *(__u64 *)more_data;
- more_data += sizeof(__u64);
+ period = *(u64 *)more_data;
+ more_data += sizeof(u64);
}
dprintf("%p [%p]: PERF_EVENT (IP, %d): %d: %p period: %Ld\n",
}
dprintf("%p [%p]: PERF_EVENT (IP, %d): %d: %p period: %Ld\n",
static int run_count = 1;
static int run_idx = 0;
static int run_count = 1;
static int run_idx = 0;
-static __u64 event_res[MAX_RUN][MAX_COUNTERS][3];
-static __u64 event_scaled[MAX_RUN][MAX_COUNTERS];
+static u64 event_res[MAX_RUN][MAX_COUNTERS][3];
+static u64 event_scaled[MAX_RUN][MAX_COUNTERS];
-//static __u64 event_hist[MAX_RUN][MAX_COUNTERS][3];
+//static u64 event_hist[MAX_RUN][MAX_COUNTERS][3];
-static __u64 runtime_nsecs[MAX_RUN];
-static __u64 walltime_nsecs[MAX_RUN];
-static __u64 runtime_cycles[MAX_RUN];
+static u64 runtime_nsecs[MAX_RUN];
+static u64 walltime_nsecs[MAX_RUN];
+static u64 runtime_cycles[MAX_RUN];
-static __u64 event_res_avg[MAX_COUNTERS][3];
-static __u64 event_res_noise[MAX_COUNTERS][3];
+static u64 event_res_avg[MAX_COUNTERS][3];
+static u64 event_res_noise[MAX_COUNTERS][3];
-static __u64 event_scaled_avg[MAX_COUNTERS];
+static u64 event_scaled_avg[MAX_COUNTERS];
-static __u64 runtime_nsecs_avg;
-static __u64 runtime_nsecs_noise;
+static u64 runtime_nsecs_avg;
+static u64 runtime_nsecs_noise;
-static __u64 walltime_nsecs_avg;
-static __u64 walltime_nsecs_noise;
+static u64 walltime_nsecs_avg;
+static u64 walltime_nsecs_noise;
-static __u64 runtime_cycles_avg;
-static __u64 runtime_cycles_noise;
+static u64 runtime_cycles_avg;
+static u64 runtime_cycles_noise;
static void create_perf_stat_counter(int counter)
{
static void create_perf_stat_counter(int counter)
{
*/
static void read_counter(int counter)
{
*/
static void read_counter(int counter)
{
- __u64 *count, single_count[3];
+ u64 *count, single_count[3];
ssize_t res;
int cpu, nv;
int scaled;
ssize_t res;
int cpu, nv;
int scaled;
if (fd[cpu][counter] < 0)
continue;
if (fd[cpu][counter] < 0)
continue;
- res = read(fd[cpu][counter], single_count, nv * sizeof(__u64));
- assert(res == nv * sizeof(__u64));
+ res = read(fd[cpu][counter], single_count, nv * sizeof(u64));
+ assert(res == nv * sizeof(u64));
close(fd[cpu][counter]);
fd[cpu][counter] = -1;
close(fd[cpu][counter]);
fd[cpu][counter] = -1;
return WEXITSTATUS(status);
}
return WEXITSTATUS(status);
}
-static void print_noise(__u64 *count, __u64 *noise)
+static void print_noise(u64 *count, u64 *noise)
{
if (run_count > 1)
fprintf(stderr, " ( +- %7.3f%% )",
(double)noise[0]/(count[0]+1)*100.0);
}
{
if (run_count > 1)
fprintf(stderr, " ( +- %7.3f%% )",
(double)noise[0]/(count[0]+1)*100.0);
}
-static void nsec_printout(int counter, __u64 *count, __u64 *noise)
+static void nsec_printout(int counter, u64 *count, u64 *noise)
{
double msecs = (double)count[0] / 1000000;
{
double msecs = (double)count[0] / 1000000;
print_noise(count, noise);
}
print_noise(count, noise);
}
-static void abs_printout(int counter, __u64 *count, __u64 *noise)
+static void abs_printout(int counter, u64 *count, u64 *noise)
{
fprintf(stderr, " %14Ld %-20s", count[0], event_name(counter));
{
fprintf(stderr, " %14Ld %-20s", count[0], event_name(counter));
*/
static void print_counter(int counter)
{
*/
static void print_counter(int counter)
{
int scaled;
count = event_res_avg[counter];
int scaled;
count = event_res_avg[counter];
/*
* normalize_noise noise values down to stddev:
*/
/*
* normalize_noise noise values down to stddev:
*/
-static void normalize_noise(__u64 *val)
+static void normalize_noise(u64 *val)
{
double res;
res = (double)*val / (run_count * sqrt((double)run_count));
{
double res;
res = (double)*val / (run_count * sqrt((double)run_count));
-static void update_avg(const char *name, int idx, __u64 *avg, __u64 *val)
+static void update_avg(const char *name, int idx, u64 *avg, u64 *val)
for (i = 0; i < run_count; i++) {
runtime_nsecs_noise +=
for (i = 0; i < run_count; i++) {
runtime_nsecs_noise +=
- abs((__s64)(runtime_nsecs[i] - runtime_nsecs_avg));
+ abs((s64)(runtime_nsecs[i] - runtime_nsecs_avg));
- abs((__s64)(walltime_nsecs[i] - walltime_nsecs_avg));
+ abs((s64)(walltime_nsecs[i] - walltime_nsecs_avg));
- abs((__s64)(runtime_cycles[i] - runtime_cycles_avg));
+ abs((s64)(runtime_cycles[i] - runtime_cycles_avg));
for (j = 0; j < nr_counters; j++) {
event_res_noise[j][0] +=
for (j = 0; j < nr_counters; j++) {
event_res_noise[j][0] +=
- abs((__s64)(event_res[i][j][0] - event_res_avg[j][0]));
+ abs((s64)(event_res[i][j][0] - event_res_avg[j][0]));
- abs((__s64)(event_res[i][j][1] - event_res_avg[j][1]));
+ abs((s64)(event_res[i][j][1] - event_res_avg[j][1]));
- abs((__s64)(event_res[i][j][2] - event_res_avg[j][2]));
+ abs((s64)(event_res[i][j][2] - event_res_avg[j][2]));
static int default_interval = 100000;
static int default_interval = 100000;
-static __u64 count_filter = 5;
+static u64 count_filter = 5;
static int print_entries = 15;
static int target_pid = -1;
static int print_entries = 15;
static int target_pid = -1;
-static __u64 min_ip;
-static __u64 max_ip = -1ll;
+static u64 min_ip;
+static u64 max_ip = -1ll;
struct sym_entry {
struct rb_node rb_node;
struct sym_entry {
struct rb_node rb_node;
100.0 - (100.0*((samples_per_sec-ksamples_per_sec)/samples_per_sec)));
if (nr_counters == 1) {
100.0 - (100.0*((samples_per_sec-ksamples_per_sec)/samples_per_sec)));
if (nr_counters == 1) {
- printf("%Ld", attrs[0].sample_period);
+ printf("%Ld", (u64)attrs[0].sample_period);
if (freq)
printf("Hz ");
else
if (freq)
printf("Hz ");
else
/*
* Binary search in the histogram table and record the hit:
*/
/*
* Binary search in the histogram table and record the hit:
*/
-static void record_ip(__u64 ip, int counter)
+static void record_ip(u64 ip, int counter)
{
struct symbol *sym = dso__find_symbol(kernel_dso, ip);
{
struct symbol *sym = dso__find_symbol(kernel_dso, ip);
-static void process_event(__u64 ip, int counter)
+static void process_event(u64 ip, int counter)
for (; old != head;) {
struct ip_event {
struct perf_event_header header;
for (; old != head;) {
struct ip_event {
struct perf_event_header header;
- __u64 ip;
- __u32 pid, target_pid;
+ u64 ip;
+ u32 pid, target_pid;
};
struct mmap_event {
struct perf_event_header header;
};
struct mmap_event {
struct perf_event_header header;
- __u32 pid, target_pid;
- __u64 start;
- __u64 len;
- __u64 pgoff;
+ u32 pid, target_pid;
+ u64 start;
+ u64 len;
+ u64 pgoff;
char filename[PATH_MAX];
};
char filename[PATH_MAX];
};
#include <sys/syscall.h>
#include "../../include/linux/perf_counter.h"
#include <sys/syscall.h>
#include "../../include/linux/perf_counter.h"
/*
* prctl(PR_TASK_PERF_COUNTERS_DISABLE) will (cheaply) disable all
/*
* prctl(PR_TASK_PERF_COUNTERS_DISABLE) will (cheaply) disable all
#define MAX_NR_CPUS 256
struct perf_file_header {
#define MAX_NR_CPUS 256
struct perf_file_header {
- __u64 version;
- __u64 sample_type;
- __u64 data_size;
+ u64 version;
+ u64 sample_type;
+ u64 data_size;
--- /dev/null
+#ifndef _PERF_TYPES_H
+#define _PERF_TYPES_H
+
+/*
+ * We define u64 as unsigned long long for every architecture
+ * so that we can print it with %Lx without getting warnings.
+ */
+typedef unsigned long long u64;
+typedef signed long long s64;
+typedef unsigned int u32;
+typedef signed int s32;
+typedef unsigned short u16;
+typedef signed short s16;
+typedef unsigned char u8;
+typedef signed char s8;
+
+#endif /* _PERF_TYPES_H */
struct perf_counter_attr attrs[MAX_COUNTERS];
struct event_symbol {
struct perf_counter_attr attrs[MAX_COUNTERS];
struct event_symbol {
- __u8 type;
- __u64 config;
char *event_name(int counter)
{
char *event_name(int counter)
{
- __u64 config = attrs[counter].config;
+ u64 config = attrs[counter].config;
int type = attrs[counter].type;
static char buf[32];
int type = attrs[counter].type;
static char buf[32];
return "unknown-hardware";
case PERF_TYPE_HW_CACHE: {
return "unknown-hardware";
case PERF_TYPE_HW_CACHE: {
- __u8 cache_type, cache_op, cache_result;
+ u8 cache_type, cache_op, cache_result;
static char name[100];
cache_type = (config >> 0) & 0xff;
static char name[100];
cache_type = (config >> 0) & 0xff;
*/
static int parse_event_symbols(const char *str, struct perf_counter_attr *attr)
{
*/
static int parse_event_symbols(const char *str, struct perf_counter_attr *attr)
{
int type;
unsigned int i;
const char *sep, *pstr;
int type;
unsigned int i;
const char *sep, *pstr;
* While we find nice hex chars, build a long_val.
* Return number of chars processed.
*/
* While we find nice hex chars, build a long_val.
* Return number of chars processed.
*/
-int hex2u64(const char *ptr, __u64 *long_val)
+int hex2u64(const char *ptr, u64 *long_val)
{
const char *p = ptr;
*long_val = 0;
{
const char *p = ptr;
*long_val = 0;
#ifndef _PERF_STRING_H_
#define _PERF_STRING_H_
#ifndef _PERF_STRING_H_
#define _PERF_STRING_H_
-#include <linux/types.h>
-int hex2u64(const char *ptr, __u64 *val);
+int hex2u64(const char *ptr, u64 *val);
const char *sym_hist_filter;
const char *sym_hist_filter;
-static struct symbol *symbol__new(__u64 start, __u64 len,
+static struct symbol *symbol__new(u64 start, u64 len,
const char *name, unsigned int priv_size,
const char *name, unsigned int priv_size,
- __u64 obj_start, int verbose)
+ u64 obj_start, int verbose)
{
size_t namelen = strlen(name) + 1;
struct symbol *self = calloc(1, priv_size + sizeof(*self) + namelen);
{
size_t namelen = strlen(name) + 1;
struct symbol *self = calloc(1, priv_size + sizeof(*self) + namelen);
if (verbose >= 2)
printf("new symbol: %016Lx [%08lx]: %s, hist: %p, obj_start: %p\n",
if (verbose >= 2)
printf("new symbol: %016Lx [%08lx]: %s, hist: %p, obj_start: %p\n",
- (__u64)start, (unsigned long)len, name, self->hist, (void *)(unsigned long)obj_start);
+ (u64)start, (unsigned long)len, name, self->hist, (void *)(unsigned long)obj_start);
self->obj_start= obj_start;
self->hist = NULL;
self->hist_sum = 0;
if (sym_hist_filter && !strcmp(name, sym_hist_filter))
self->obj_start= obj_start;
self->hist = NULL;
self->hist_sum = 0;
if (sym_hist_filter && !strcmp(name, sym_hist_filter))
- self->hist = calloc(sizeof(__u64), len);
+ self->hist = calloc(sizeof(u64), len);
if (priv_size) {
memset(self, 0, priv_size);
if (priv_size) {
memset(self, 0, priv_size);
{
struct rb_node **p = &self->syms.rb_node;
struct rb_node *parent = NULL;
{
struct rb_node **p = &self->syms.rb_node;
struct rb_node *parent = NULL;
- const __u64 ip = sym->start;
+ const u64 ip = sym->start;
struct symbol *s;
while (*p != NULL) {
struct symbol *s;
while (*p != NULL) {
rb_insert_color(&sym->rb_node, &self->syms);
}
rb_insert_color(&sym->rb_node, &self->syms);
}
-struct symbol *dso__find_symbol(struct dso *self, __u64 ip)
+struct symbol *dso__find_symbol(struct dso *self, u64 ip)
goto out_failure;
while (!feof(file)) {
goto out_failure;
while (!feof(file)) {
struct symbol *sym;
int line_len, len;
char symbol_type;
struct symbol *sym;
int line_len, len;
char symbol_type;
goto out_failure;
while (!feof(file)) {
goto out_failure;
while (!feof(file)) {
struct symbol *sym;
int line_len, len;
struct symbol *sym;
int line_len, len;
{
uint32_t nr_rel_entries, idx;
GElf_Sym sym;
{
uint32_t nr_rel_entries, idx;
GElf_Sym sym;
GElf_Shdr shdr_plt;
struct symbol *f;
GElf_Shdr shdr_rel_plt;
GElf_Shdr shdr_plt;
struct symbol *f;
GElf_Shdr shdr_rel_plt;
elf_symtab__for_each_symbol(syms, nr_syms, index, sym) {
struct symbol *f;
elf_symtab__for_each_symbol(syms, nr_syms, index, sym) {
struct symbol *f;
if (!elf_sym__is_function(&sym))
continue;
if (!elf_sym__is_function(&sym))
continue;
#define _PERF_SYMBOL_ 1
#include <linux/types.h>
#define _PERF_SYMBOL_ 1
#include <linux/types.h>
#include "list.h"
#include "rbtree.h"
struct symbol {
struct rb_node rb_node;
#include "list.h"
#include "rbtree.h"
struct symbol {
struct rb_node rb_node;
- __u64 start;
- __u64 end;
- __u64 obj_start;
- __u64 hist_sum;
- __u64 *hist;
+ u64 start;
+ u64 end;
+ u64 obj_start;
+ u64 hist_sum;
+ u64 *hist;
void *priv;
char name[0];
};
void *priv;
char name[0];
};
struct list_head node;
struct rb_root syms;
unsigned int sym_priv_size;
struct list_head node;
struct rb_root syms;
unsigned int sym_priv_size;
- struct symbol *(*find_symbol)(struct dso *, __u64 ip);
+ struct symbol *(*find_symbol)(struct dso *, u64 ip);
return ((void *)sym) - self->sym_priv_size;
}
return ((void *)sym) - self->sym_priv_size;
}
-struct symbol *dso__find_symbol(struct dso *self, __u64 ip);
+struct symbol *dso__find_symbol(struct dso *self, u64 ip);
int dso__load_kernel(struct dso *self, const char *vmlinux,
symbol_filter_t filter, int verbose);
int dso__load_kernel(struct dso *self, const char *vmlinux,
symbol_filter_t filter, int verbose);