extern int verbose;
extern int dump_trace;

int eprintf(const char *fmt, …) __attribute__((format(printf, 1, 2)));
int dump_printf(const char *fmt, …) __attribute__((format(printf, 1, 2)));
void trace_event(event_t *event);

#include «../perf.h»

#include
#include
#include

#include «color.h»
#include «event.h»
#include «debug.h»

int verbose = 0;
int dump_trace = 0;

int eprintf(const char *fmt, …)
{
va_list args;
int ret = 0;

if (verbose) {
va_start(args, fmt);
ret = vfprintf(stderr, fmt, args);
va_end(args);
}

return ret;
}

int dump_printf(const char *fmt, …)
{
va_list args;
int ret = 0;

if (dump_trace) {
va_start(args, fmt);
ret = vprintf(fmt, args);
va_end(args);
}

return ret;
}

static int dump_printf_color(const char *fmt, const char *color, …)
{
va_list args;
int ret = 0;

if (dump_trace) {
va_start(args, color);
ret = color_vfprintf(stdout, color, fmt, args);
va_end(args);
}

return ret;
}

void trace_event(event_t *event)
{
unsigned char *raw_event = (void *)event;
const char *color = PERF_COLOR_BLUE;
int i, j;

if (!dump_trace)
return;

dump_printf(».»);
dump_printf_color(»\n. … raw event: size %d bytes\n», color,
event->header.size);

for (i = 0; i < event->header.size; i++) {
if ((i & 15) == 0) {
dump_printf(».»);
dump_printf_color(» %04x: «, color, i);
}

dump_printf_color(» %02x», color, raw_event[i]);

if (((i & 15) == 15) || i == event->header.size-1) {
dump_printf_color(» «, color);
for (j = 0; j < 15-(i & 15); j++)
dump_printf_color(» «, color);
for (j = 0; j < (i & 15); j++) {
if (isprint(raw_event[i-15+j]))
dump_printf_color(»%c», color,
raw_event[i-15+j]);
else
dump_printf_color(».», color);
}
dump_printf_color(»\n», color);
}
}
dump_printf(».\n»);
}

enum {
S = GIT_SPACE,
A = GIT_ALPHA,
D = GIT_DIGIT,
G = GIT_GLOB_SPECIAL, /* *, ?, [, \\ */
R = GIT_REGEX_SPECIAL, /* $, (, ), +, ., ^, {, | * */
P = GIT_PRINT_EXTRA, /* printable - alpha - digit - glob - regex */

PS = GIT_SPACE | GIT_PRINT_EXTRA,
};

unsigned char sane_ctype[256] = {
/* 0 1 2 3 4 5 6 7 8 9 A B C D E F */

0, 0, 0, 0, 0, 0, 0, 0, 0, S, S, 0, 0, S, 0, 0, /* 0.. 15 */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 16.. 31 */
PS,P, P, P, R, P, P, P, R, R, G, R, P, P, R, P, /* 32.. 47 */
D, D, D, D, D, D, D, D, D, D, P, P, P, P, P, G, /* 48.. 63 */
P, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, /* 64.. 79 */
A, A, A, A, A, A, A, A, A, A, A, G, G, P, R, P, /* 80.. 95 */
P, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, /* 96..111 */
A, A, A, A, A, A, A, A, A, A, A, R, R, P, P, 0, /* 112..127 */
/* Nothing in the 128.. range */
};

#define MAXNAME (256)

static FILE *config_file;
static const char *config_file_name;
static int config_linenr;
static int config_file_eof;

const char *config_exclusive_filename = NULL;

static int get_next_char(void)
{
int c;
FILE *f;

c = ‘\n’;
if ((f = config_file) != NULL) {
c = fgetc(f);
if (c == ‘\r’) {
/* DOS like systems */
c = fgetc(f);
if (c != ‘\n’) {
ungetc(c, f);
c = ‘\r’;
}
}
if (c == ‘\n’)
config_linenr++;
if (c == EOF) {
config_file_eof = 1;
c = ‘\n’;
}
}
return c;
}

static char *parse_value(void)
{
static char value[1024];
int quote = 0, comment = 0, space = 0;
size_t len = 0;

for (;;) {
int c = get_next_char();

if (len >= sizeof(value) – 1)
return NULL;
if (c == ‘\n’) {
if (quote)
return NULL;
value[len] = 0;
return value;
}
if (comment)
continue;
if (isspace(c) && !quote) {
space = 1;
continue;
}
if (!quote) {
if (c == ‘;’ || c == ‘#’) {
comment = 1;
continue;
}
}
if (space) {
if (len)
value[len++] = ‘ ‘;
space = 0;
}
if (c == ‘\\’) {
c = get_next_char();
switch (c) {
case ‘\n’:
continue;
case ‘t’:
c = ‘\t’;
break;
case ‘b’:
c = ‘\b’;
break;
case ‘n’:
c = ‘\n’;
break;
/* Some characters escape as themselves */
case ‘\\’: case ‘»‘:
break;
/* Reject unknown escape sequences */
default:
return NULL;
}
value[len++] = c;
continue;
}
if (c == ‘»‘) {
quote = 1-quote;
continue;
}
value[len++] = c;
}
}

static inline int iskeychar(int c)
{
return isalnum(c) || c == ‘-’;
}

static int get_value(config_fn_t fn, void *data, char *name, unsigned int len)
{
int c;
char *value;

/* Get the full name */
for (;;) {
c = get_next_char();
if (config_file_eof)
break;
if (!iskeychar(c))
break;
name[len++] = tolower(c);
if (len >= MAXNAME)
return -1;
}
name[len] = 0;
while (c == ‘ ‘ || c == ‘\t’)
c = get_next_char();

value = NULL;
if (c != ‘\n’) {
if (c != ‘=’)
return -1;
value = parse_value();
if (!value)
return -1;
}
return fn(name, value, data);
}

static int get_extended_base_var(char *name, int baselen, int c)
{
do {
if (c == ‘\n’)
return -1;
c = get_next_char();
} while (isspace(c));

/* We require the format to be ‘[base "extension"]‘ */
if (c != ‘»‘)
return -1;
name[baselen++] = ‘.’;

for (;;) {
int ch = get_next_char();

if (ch == ‘\n’)
return -1;
if (ch == ‘»‘)
break;
if (ch == ‘\\’) {
ch = get_next_char();
if (ch == ‘\n’)
return -1;
}
name[baselen++] = ch;
if (baselen > MAXNAME / 2)
return -1;
}

/* Final ‘]’ */
if (get_next_char() != ‘]’)
return -1;
return baselen;
}

static int get_base_var(char *name)
{
int baselen = 0;

for (;;) {
int c = get_next_char();
if (config_file_eof)
return -1;
if (c == ‘]’)
return baselen;
if (isspace(c))
return get_extended_base_var(name, baselen, c);
if (!iskeychar(c) && c != ‘.’)
return -1;
if (baselen > MAXNAME / 2)
return -1;
name[baselen++] = tolower(c);
}
}

static int perf_parse_file(config_fn_t fn, void *data)
{
int comment = 0;
int baselen = 0;
static char var[MAXNAME];

/* U+FEFF Byte Order Mark in UTF8 */
static const unsigned char *utf8_bom = (unsigned char *) «\xef\xbb\xbf»;
const unsigned char *bomptr = utf8_bom;

for (;;) {
int c = get_next_char();
if (bomptr && *bomptr) {
/* We are at the file beginning; skip UTF8-encoded BOM
* if present. Sane editors won’t put this in on their
* own, but e.g. Windows Notepad will do it happily. */
if ((unsigned char) c == *bomptr) {
bomptr++;
continue;
} else {
/* Do not tolerate partial BOM. */
if (bomptr != utf8_bom)
break;
/* No BOM at file beginning. Cool. */
bomptr = NULL;
}
}
if (c == ‘\n’) {
if (config_file_eof)
return 0;
comment = 0;
continue;
}
if (comment || isspace(c))
continue;
if (c == ‘#’ || c == ‘;’) {
comment = 1;
continue;
}
if (c == ‘[') {
baselen = get_base_var(var);
if (baselen <= 0)
break;
var[baselen++] = ‘.’;
var[baselen] = 0;
continue;
}
if (!isalpha(c))
break;
var[baselen] = tolower(c);
if (get_value(fn, data, var, baselen+1) < 0)
break;
}
die("bad config file line %d in %s", config_linenr, config_file_name);
}

static int parse_unit_factor(const char *end, unsigned long *val)
{
if (!*end)
return 1;
else if (!strcasecmp(end, "k")) {
*val *= 1024;
return 1;
}
else if (!strcasecmp(end, "m")) {
*val *= 1024 * 1024;
return 1;
}
else if (!strcasecmp(end, "g")) {
*val *= 1024 * 1024 * 1024;
return 1;
}
return 0;
}

static int perf_parse_long(const char *value, long *ret)
{
if (value && *value) {
char *end;
long val = strtol(value, &end, 0);
unsigned long factor = 1;
if (!parse_unit_factor(end, &factor))
return 0;
*ret = val * factor;
return 1;
}
return 0;
}

int perf_parse_ulong(const char *value, unsigned long *ret)
{
if (value && *value) {
char *end;
unsigned long val = strtoul(value, &end, 0);
if (!parse_unit_factor(end, &val))
return 0;
*ret = val;
return 1;
}
return 0;
}

static void die_bad_config(const char *name)
{
if (config_file_name)
die("bad config value for '%s' in %s", name, config_file_name);
die("bad config value for '%s'", name);
}

int perf_config_int(const char *name, const char *value)
{
long ret = 0;
if (!perf_parse_long(value, &ret))
die_bad_config(name);
return ret;
}

unsigned long perf_config_ulong(const char *name, const char *value)
{
unsigned long ret;
if (!perf_parse_ulong(value, &ret))
die_bad_config(name);
return ret;
}

int perf_config_bool_or_int(const char *name, const char *value, int *is_bool)
{
*is_bool = 1;
if (!value)
return 1;
if (!*value)
return 0;
if (!strcasecmp(value, "true") || !strcasecmp(value, "yes") || !strcasecmp(value, "on"))
return 1;
if (!strcasecmp(value, "false") || !strcasecmp(value, "no") || !strcasecmp(value, "off"))
return 0;
*is_bool = 0;
return perf_config_int(name, value);
}

int perf_config_bool(const char *name, const char *value)
{
int discard;
return !!perf_config_bool_or_int(name, value, &discard);
}

int perf_config_string(const char **dest, const char *var, const char *value)
{
if (!value)
return config_error_nonbool(var);
*dest = strdup(value);
return 0;
}

static int perf_default_core_config(const char *var __used, const char *value __used)
{
/* Add other config variables here and to Documentation/config.txt. */
return 0;
}

int perf_default_config(const char *var, const char *value, void *dummy __used)
{
if (!prefixcmp(var, "core."))
return perf_default_core_config(var, value);

/* Add other config variables here and to Documentation/config.txt. */
return 0;
}

int perf_config_from_file(config_fn_t fn, const char *filename, void *data)
{
int ret;
FILE *f = fopen(filename, "r");

ret = -1;
if (f) {
config_file = f;
config_file_name = filename;
config_linenr = 1;
config_file_eof = 0;
ret = perf_parse_file(fn, data);
fclose(f);
config_file_name = NULL;
}
return ret;
}

const char *perf_etc_perfconfig(void)
{
static const char *system_wide;
if (!system_wide)
system_wide = system_path(ETC_PERFCONFIG);
return system_wide;
}

static int perf_env_bool(const char *k, int def)
{
const char *v = getenv(k);
return v ? perf_config_bool(k, v) : def;
}

int perf_config_system(void)
{
return !perf_env_bool("PERF_CONFIG_NOSYSTEM", 0);
}

int perf_config_global(void)
{
return !perf_env_bool("PERF_CONFIG_NOGLOBAL", 0);
}

int perf_config(config_fn_t fn, void *data)
{
int ret = 0, found = 0;
char *repo_config = NULL;
const char *home = NULL;

/* Setting $PERF_CONFIG makes perf read _only_ the given config file. */
if (config_exclusive_filename)
return perf_config_from_file(fn, config_exclusive_filename, data);
if (perf_config_system() && !access(perf_etc_perfconfig(), R_OK)) {
ret += perf_config_from_file(fn, perf_etc_perfconfig(),
data);
found += 1;
}

home = getenv("HOME");
if (perf_config_global() && home) {
char *user_config = strdup(mkpath("%s/.perfconfig", home));
if (!access(user_config, R_OK)) {
ret += perf_config_from_file(fn, user_config, data);
found += 1;
}
free(user_config);
}

repo_config = perf_pathdup("config");
if (!access(repo_config, R_OK)) {
ret += perf_config_from_file(fn, repo_config, data);
found += 1;
}
free(repo_config);
if (found == 0)
return -1;
return ret;
}

/*
* Find all the stuff for perf_config_set() below.
*/

#define MAX_MATCHES 512

static struct {
int baselen;
char* key;
int do_not_match;
regex_t* value_regex;
int multi_replace;
size_t offset[MAX_MATCHES];
enum { START, SECTION_SEEN, SECTION_END_SEEN, KEY_SEEN } state;
int seen;
} store;

static int matches(const char* key, const char* value)
{
return !strcmp(key, store.key) &&
(store.value_regex == NULL ||
(store.do_not_match ^
!regexec(store.value_regex, value, 0, NULL, 0)));
}

static int store_aux(const char* key, const char* value, void *cb __used)
{
int section_len;
const char *ep;

switch (store.state) {
case KEY_SEEN:
if (matches(key, value)) {
if (store.seen == 1 && store.multi_replace == 0) {
warning("%s has multiple values", key);
} else if (store.seen >= MAX_MATCHES) {
error(»too many matches for %s», key);
return 1;
}

store.offset[store.seen] = ftell(config_file);
store.seen++;
}
break;
case SECTION_SEEN:
/*
* What we are looking for is in store.key (both
* section and var), and its section part is baselen
* long. We found key (again, both section and var).
* We would want to know if this key is in the same
* section as what we are looking for. We already
* know we are in the same section as what should
* hold store.key.
*/
ep = strrchr(key, ‘.’);
section_len = ep – key;

if ((section_len != store.baselen) ||
memcmp(key, store.key, section_len+1)) {
store.state = SECTION_END_SEEN;
break;
}

/*
* Do not increment matches: this is no match, but we
* just made sure we are in the desired section.
*/
store.offset[store.seen] = ftell(config_file);
/* fallthru */
case SECTION_END_SEEN:
case START:
if (matches(key, value)) {
store.offset[store.seen] = ftell(config_file);
store.state = KEY_SEEN;
store.seen++;
} else {
if (strrchr(key, ‘.’) – key == store.baselen &&
!strncmp(key, store.key, store.baselen)) {
store.state = SECTION_SEEN;
store.offset[store.seen] = ftell(config_file);
}
}
default:
break;
}
return 0;
}

static int store_write_section(int fd, const char* key)
{
const char *dot;
int i, success;
struct strbuf sb = STRBUF_INIT;

dot = memchr(key, ‘.’, store.baselen);
if (dot) {
strbuf_addf(&sb, «[%.*s \"", (int)(dot - key), key);
for (i = dot - key + 1; i < store.baselen; i++) {
if (key[i] == ‘»‘ || key[i] == ‘\\’)
strbuf_addch(&sb, ‘\\’);
strbuf_addch(&sb, key[i]);
}
strbuf_addstr(&sb, «\»]\n»);
} else {
strbuf_addf(&sb, «[%.*s]\n», store.baselen, key);
}

success = (write_in_full(fd, sb.buf, sb.len) == (ssize_t)sb.len);
strbuf_release(&sb);

return success;
}

static int store_write_pair(int fd, const char* key, const char* value)
{
int i, success;
int length = strlen(key + store.baselen + 1);
const char *quote = «»;
struct strbuf sb = STRBUF_INIT;

/*
* Check to see if the value needs to be surrounded with a dq pair.
* Note that problematic characters are always backslash-quoted; this
* check is about not losing leading or trailing SP and strings that
* follow beginning-of-comment characters (i.e. ‘;’ and ‘#’) by the
* configuration parser.
*/
if (value[0] == ‘ ‘)
quote = «\»";
for (i = 0; value[i]; i++)
if (value[i] == ‘;’ || value[i] == ‘#’)
quote = «\»";
if (i && value[i - 1] == ‘ ‘)
quote = «\»";

strbuf_addf(&sb, «\t%.*s = %s»,
length, key + store.baselen + 1, quote);

for (i = 0; value[i]; i++)
switch (value[i]) {
case ‘\n’:
strbuf_addstr(&sb, «\\n»);
break;
case ‘\t’:
strbuf_addstr(&sb, «\\t»);
break;
case ‘»‘:
case ‘\\’:
strbuf_addch(&sb, ‘\\’);
default:
strbuf_addch(&sb, value[i]);
break;
}
strbuf_addf(&sb, «%s\n», quote);

success = (write_in_full(fd, sb.buf, sb.len) == (ssize_t)sb.len);
strbuf_release(&sb);

return success;
}

static ssize_t find_beginning_of_line(const char* contents, size_t size,
size_t offset_, int* found_bracket)
{
size_t equal_offset = size, bracket_offset = size;
ssize_t offset;

contline:
for (offset = offset_-2; offset > 0
&& contents[offset] != ‘\n’; offset–)
switch (contents[offset]) {
case ‘=’: equal_offset = offset; break;
case ‘]’: bracket_offset = offset; break;
default: break;
}
if (offset > 0 && contents[offset-1] == ‘\\’) {
offset_ = offset;
goto contline;
}
if (bracket_offset < equal_offset) {
*found_bracket = 1;
offset = bracket_offset+1;
} else
offset++;

return offset;
}

int perf_config_set(const char* key, const char* value)
{
return perf_config_set_multivar(key, value, NULL, 0);
}

/*
* If value==NULL, unset in (remove from) config,
* if value_regex!=NULL, disregard key/value pairs where value does not match.
* if multi_replace==0, nothing, or only one matching key/value is replaced,
* else all matching key/values (regardless how many) are removed,
* before the new pair is written.
*
* Returns 0 on success.
*
* This function does this:
*
* - it locks the config file by creating ".perf/config.lock"
*
* - it then parses the config using store_aux() as validator to find
* the position on the key/value pair to replace. If it is to be unset,
* it must be found exactly once.
*
* - the config file is mmap()ed and the part before the match (if any) is
* written to the lock file, then the changed part and the rest.
*
* - the config file is removed and the lock file rename()d to it.
*
*/
int perf_config_set_multivar(const char* key, const char* value,
const char* value_regex, int multi_replace)
{
int i, dot;
int fd = -1, in_fd;
int ret = 0;
char* config_filename;
const char* last_dot = strrchr(key, '.');

if (config_exclusive_filename)
config_filename = strdup(config_exclusive_filename);
else
config_filename = perf_pathdup("config");

/*
* Since "key" actually contains the section name and the real
* key name separated by a dot, we have to know where the dot is.
*/

if (last_dot == NULL) {
error("key does not contain a section: %s", key);
ret = 2;
goto out_free;
}
store.baselen = last_dot - key;

store.multi_replace = multi_replace;

/*
* Validate the key and while at it, lower case it for matching.
*/
store.key = malloc(strlen(key) + 1);
dot = 0;
for (i = 0; key[i]; i++) {
unsigned char c = key[i];
if (c == '.')
dot = 1;
/* Leave the extended basename untouched.. */
if (!dot || i > store.baselen) {
if (!iskeychar(c) || (i == store.baselen+1 && !isalpha(c))) {
error(»invalid key: %s», key);
free(store.key);
ret = 1;
goto out_free;
}
c = tolower(c);
} else if (c == ‘\n’) {
error(»invalid key (newline): %s», key);
free(store.key);
ret = 1;
goto out_free;
}
store.key[i] = c;
}
store.key[i] = 0;

/*
* If .perf/config does not exist yet, write a minimal version.
*/
in_fd = open(config_filename, O_RDONLY);
if ( in_fd < 0 ) {
free(store.key);

if ( ENOENT != errno ) {
error("opening %s: %s", config_filename,
strerror(errno));
ret = 3; /* same as "invalid config file" */
goto out_free;
}
/* if nothing to unset, error out */
if (value == NULL) {
ret = 5;
goto out_free;
}

store.key = (char*)key;
if (!store_write_section(fd, key) ||
!store_write_pair(fd, key, value))
goto write_err_out;
} else {
struct stat st;
char *contents;
ssize_t contents_sz, copy_begin, copy_end;
int new_line = 0;

if (value_regex == NULL)
store.value_regex = NULL;
else {
if (value_regex[0] == '!') {
store.do_not_match = 1;
value_regex++;
} else
store.do_not_match = 0;

store.value_regex = (regex_t*)malloc(sizeof(regex_t));
if (regcomp(store.value_regex, value_regex,
REG_EXTENDED)) {
error("invalid pattern: %s", value_regex);
free(store.value_regex);
ret = 6;
goto out_free;
}
}

store.offset[0] = 0;
store.state = START;
store.seen = 0;

/*
* After this, store.offset will contain the *end* offset
* of the last match, or remain at 0 if no match was found.
* As a side effect, we make sure to transform only a valid
* existing config file.
*/
if (perf_config_from_file(store_aux, config_filename, NULL)) {
error("invalid config file %s", config_filename);
free(store.key);
if (store.value_regex != NULL) {
regfree(store.value_regex);
free(store.value_regex);
}
ret = 3;
goto out_free;
}

free(store.key);
if (store.value_regex != NULL) {
regfree(store.value_regex);
free(store.value_regex);
}

/* if nothing to unset, or too many matches, error out */
if ((store.seen == 0 && value == NULL) ||
(store.seen > 1 && multi_replace == 0)) {
ret = 5;
goto out_free;
}

fstat(in_fd, &st);
contents_sz = xsize_t(st.st_size);
contents = mmap(NULL, contents_sz, PROT_READ,
MAP_PRIVATE, in_fd, 0);
close(in_fd);

if (store.seen == 0)
store.seen = 1;

for (i = 0, copy_begin = 0; i < store.seen; i++) {
if (store.offset[i] == 0) {
store.offset[i] = copy_end = contents_sz;
} else if (store.state != KEY_SEEN) {
copy_end = store.offset[i];
} else
copy_end = find_beginning_of_line(
contents, contents_sz,
store.offset[i]-2, &new_line);

if (copy_end > 0 && contents[copy_end-1] != ‘\n’)
new_line = 1;

/* write the first part of the config */
if (copy_end > copy_begin) {
if (write_in_full(fd, contents + copy_begin,
copy_end – copy_begin) <
copy_end – copy_begin)
goto write_err_out;
if (new_line &&
write_in_full(fd, «\n», 1) != 1)
goto write_err_out;
}
copy_begin = store.offset[i];
}

/* write the pair (value == NULL means unset) */
if (value != NULL) {
if (store.state == START) {
if (!store_write_section(fd, key))
goto write_err_out;
}
if (!store_write_pair(fd, key, value))
goto write_err_out;
}

/* write the rest of the config */
if (copy_begin < contents_sz)
if (write_in_full(fd, contents + copy_begin,
contents_sz – copy_begin) <
contents_sz – copy_begin)
goto write_err_out;

munmap(contents, contents_sz);
}

ret = 0;

out_free:
free(config_filename);
return ret;

write_err_out:
goto out_free;

}

/*
* Call this to report error for your variable that should not
* get a boolean value (i.e. «[my] var» means «true»).
*/
int config_error_nonbool(const char *var)
{
return error(»Missing value for ‘%s’», var);
}

/* «\033[1;38;5;2xx;48;5;2xxm\0″ is 23 bytes */
#define COLOR_MAXLEN 24

#define PERF_COLOR_NORMAL «»
#define PERF_COLOR_RESET «\033[m»
#define PERF_COLOR_BOLD «\033[1m»
#define PERF_COLOR_RED «\033[31m»
#define PERF_COLOR_GREEN «\033[32m»
#define PERF_COLOR_YELLOW «\033[33m»
#define PERF_COLOR_BLUE «\033[34m»
#define PERF_COLOR_MAGENTA «\033[35m»
#define PERF_COLOR_CYAN «\033[36m»
#define PERF_COLOR_BG_RED «\033[41m»

#define MIN_GREEN 0.5
#define MIN_RED 5.0

/*
* This variable stores the value of color.ui
*/
extern int perf_use_color_default;

/*
* Use this instead of perf_default_config if you need the value of color.ui.
*/
int perf_color_default_config(const char *var, const char *value, void *cb);

int perf_config_colorbool(const char *var, const char *value, int stdout_is_tty);
void color_parse(const char *value, const char *var, char *dst);
void color_parse_mem(const char *value, int len, const char *var, char *dst);
int color_vfprintf(FILE *fp, const char *color, const char *fmt, va_list args);
int color_fprintf(FILE *fp, const char *color, const char *fmt, …);
int color_fprintf_ln(FILE *fp, const char *color, const char *fmt, …);
int color_fwrite_lines(FILE *fp, const char *color, size_t count, const char *buf);
int percent_color_fprintf(FILE *fp, const char *fmt, double percent);
const char *get_percent_color(double percent);

#endif /* COLOR_H */

int perf_use_color_default = -1;

static int parse_color(const char *name, int len)
{
static const char * const color_names[] = {
«normal», «black», «red», «green», «yellow»,
«blue», «magenta», «cyan», «white»
};
char *end;
int i;

for (i = 0; i < (int)ARRAY_SIZE(color_names); i++) {
const char *str = color_names[i];
if (!strncasecmp(name, str, len) && !str[len])
return i - 1;
}
i = strtol(name, &end, 10);
if (end - name == len && i >= -1 && i <= 255)
return i;
return -2;
}

static int parse_attr(const char *name, int len)
{
static const int attr_values[] = { 1, 2, 4, 5, 7 };
static const char * const attr_names[] = {
"bold", "dim", "ul", "blink", "reverse"
};
unsigned int i;

for (i = 0; i < ARRAY_SIZE(attr_names); i++) {
const char *str = attr_names[i];
if (!strncasecmp(name, str, len) && !str[len])
return attr_values[i];
}
return -1;
}

void color_parse(const char *value, const char *var, char *dst)
{
color_parse_mem(value, strlen(value), var, dst);
}

void color_parse_mem(const char *value, int value_len, const char *var,
char *dst)
{
const char *ptr = value;
int len = value_len;
int attr = -1;
int fg = -2;
int bg = -2;

if (!strncasecmp(value, "reset", len)) {
strcpy(dst, PERF_COLOR_RESET);
return;
}

/* [fg [bg]] [attr] */
while (len > 0) {
const char *word = ptr;
int val, wordlen = 0;

while (len > 0 && !isspace(word[wordlen])) {
wordlen++;
len–;
}

ptr = word + wordlen;
while (len > 0 && isspace(*ptr)) {
ptr++;
len–;
}

val = parse_color(word, wordlen);
if (val >= -1) {
if (fg == -2) {
fg = val;
continue;
}
if (bg == -2) {
bg = val;
continue;
}
goto bad;
}
val = parse_attr(word, wordlen);
if (val < 0 || attr != -1)
goto bad;
attr = val;
}

if (attr >= 0 || fg >= 0 || bg >= 0) {
int sep = 0;

*dst++ = ‘\033′;
*dst++ = ‘[’;
if (attr >= 0) {
*dst++ = ‘0′ + attr;
sep++;
}
if (fg >= 0) {
if (sep++)
*dst++ = ‘;’;
if (fg < {
*dst++ = '3';
*dst++ = '0' + fg;
} else {
dst += sprintf(dst, "38;5;%d", fg);
}
}
if (bg >= 0) {
if (sep++)
*dst++ = ‘;’;
if (bg < {
*dst++ = '4';
*dst++ = '0' + bg;
} else {
dst += sprintf(dst, "48;5;%d", bg);
}
}
*dst++ = 'm';
}
*dst = 0;
return;
bad:
die("bad color value '%.*s' for variable '%s'", value_len, value, var);
}

int perf_config_colorbool(const char *var, const char *value, int stdout_is_tty)
{
if (value) {
if (!strcasecmp(value, "never"))
return 0;
if (!strcasecmp(value, "always"))
return 1;
if (!strcasecmp(value, "auto"))
goto auto_color;
}

/* Missing or explicit false to turn off colorization */
if (!perf_config_bool(var, value))
return 0;

/* any normal truth value defaults to 'auto' */
auto_color:
if (stdout_is_tty < 0)
stdout_is_tty = isatty(1);
if (stdout_is_tty || (pager_in_use() && pager_use_color)) {
char *term = getenv("TERM");
if (term && strcmp(term, "dumb"))
return 1;
}
return 0;
}

int perf_color_default_config(const char *var, const char *value, void *cb)
{
if (!strcmp(var, "color.ui")) {
perf_use_color_default = perf_config_colorbool(var, value, -1);
return 0;
}

return perf_default_config(var, value, cb);
}

static int __color_vfprintf(FILE *fp, const char *color, const char *fmt,
va_list args, const char *trail)
{
int r = 0;

/*
* Auto-detect:
*/
if (perf_use_color_default < 0) {
if (isatty(1) || pager_in_use())
perf_use_color_default = 1;
else
perf_use_color_default = 0;
}

if (perf_use_color_default && *color)
r += fprintf(fp, "%s", color);
r += vfprintf(fp, fmt, args);
if (perf_use_color_default && *color)
r += fprintf(fp, "%s", PERF_COLOR_RESET);
if (trail)
r += fprintf(fp, "%s", trail);
return r;
}

int color_vfprintf(FILE *fp, const char *color, const char *fmt, va_list args)
{
return __color_vfprintf(fp, color, fmt, args, NULL);
}

int color_fprintf(FILE *fp, const char *color, const char *fmt, ...)
{
va_list args;
int r;

va_start(args, fmt);
r = color_vfprintf(fp, color, fmt, args);
va_end(args);
return r;
}

int color_fprintf_ln(FILE *fp, const char *color, const char *fmt, ...)
{
va_list args;
int r;
va_start(args, fmt);
r = __color_vfprintf(fp, color, fmt, args, "\n");
va_end(args);
return r;
}

/*
* This function splits the buffer by newlines and colors the lines individually.
*
* Returns 0 on success.
*/
int color_fwrite_lines(FILE *fp, const char *color,
size_t count, const char *buf)
{
if (!*color)
return fwrite(buf, count, 1, fp) != 1;

while (count) {
char *p = memchr(buf, '\n', count);

if (p != buf && (fputs(color, fp) < 0 ||
fwrite(buf, p ? (size_t)(p - buf) : count, 1, fp) != 1 ||
fputs(PERF_COLOR_RESET, fp) < 0))
return -1;
if (!p)
return 0;
if (fputc('\n', fp) < 0)
return -1;
count -= p + 1 - buf;
buf = p + 1;
}
return 0;
}

const char *get_percent_color(double percent)
{
const char *color = PERF_COLOR_NORMAL;

/*
* We color high-overhead entries in red, mid-overhead
* entries in green - and keep the low overhead places
* normal:
*/
if (percent >= MIN_RED)
color = PERF_COLOR_RED;
else {
if (percent > MIN_GREEN)
color = PERF_COLOR_GREEN;
}
return color;
}

int percent_color_fprintf(FILE *fp, const char *fmt, double percent)
{
int r;
const char *color;

color = get_percent_color(percent);
r = color_fprintf(fp, color, fmt, percent);

return r;
}

#include «../perf.h»
#include #include #include «util.h»
#include «symbol.h»

enum chain_mode {
CHAIN_NONE,
CHAIN_FLAT,
CHAIN_GRAPH_ABS,
CHAIN_GRAPH_REL
};

struct callchain_node {
struct callchain_node *parent;
struct list_head brothers;
struct list_head children;
struct list_head val;
struct rb_node rb_node; /* to sort nodes in an rbtree */
struct rb_root rb_root; /* sorted tree of children */
unsigned int val_nr;
u64 hit;
u64 children_hit;
};

struct callchain_param;

typedef void (*sort_chain_func_t)(struct rb_root *, struct callchain_node *,
u64, struct callchain_param *);

struct callchain_param {
enum chain_mode mode;
double min_percent;
sort_chain_func_t sort;
};

struct callchain_list {
u64 ip;
struct symbol *sym;
struct list_head list;
};

static inline void callchain_init(struct callchain_node *node)
{
INIT_LIST_HEAD(&node->brothers);
INIT_LIST_HEAD(&node->children);
INIT_LIST_HEAD(&node->val);
}

static inline u64 cumul_hits(struct callchain_node *node)
{
return node->hit + node->children_hit;
}

int register_callchain_param(struct callchain_param *param);
void append_chain(struct callchain_node *root, struct ip_callchain *chain,
struct symbol **syms);
#endif

static const char *alias_key;
static char *alias_val;

static int alias_lookup_cb(const char *k, const char *v, void *cb __used)
{
if (!prefixcmp(k, «alias.») && !strcmp(k+6, alias_key)) {
if (!v)
return config_error_nonbool(k);
alias_val = strdup(v);
return 0;
}
return 0;
}

char *alias_lookup(const char *alias)
{
alias_key = alias;
alias_val = NULL;
perf_config(alias_lookup_cb, NULL);
return alias_val;
}

int split_cmdline(char *cmdline, const char ***argv)
{
int src, dst, count = 0, size = 16;
char quoted = 0;

*argv = malloc(sizeof(char*) * size);

/* split alias_string */
(*argv)[count++] = cmdline;
for (src = dst = 0; cmdline[src];) {
char c = cmdline[src];
if (!quoted && isspace(c)) {
cmdline[dst++] = 0;
while (cmdline[++src]
&& isspace(cmdline[src]))
; /* skip */
if (count >= size) {
size += 16;
*argv = realloc(*argv, sizeof(char*) * size);
}
(*argv)[count++] = cmdline + dst;
} else if (!quoted && (c == ‘\» || c == ‘»‘)) {
quoted = c;
src++;
} else if (c == quoted) {
quoted = 0;
src++;
} else {
if (c == ‘\\’ && quoted != ‘\») {
src++;
c = cmdline[src];
if (!c) {
free(*argv);
*argv = NULL;
return error(»cmdline ends with \\»);
}
}
cmdline[dst++] = c;
src++;
}
}

cmdline[dst] = 0;

if (quoted) {
free(*argv);
*argv = NULL;
return error(»unclosed quote»);
}

return count;
}

/*
* Do not use this for inspecting *tracked* content. When path is a
* symlink to a directory, we do not want to say it is a directory when
* dealing with tracked content in the working tree.
*/
static int is_directory(const char *path)
{
struct stat st;
return (!stat(path, &st) && S_ISDIR(st.st_mode));
}

/* We allow «recursive» symbolic links. Only within reason, though. */
#define MAXDEPTH 5

const char *make_absolute_path(const char *path)
{
static char bufs[2][PATH_MAX + 1], *buf = bufs[0], *next_buf = bufs[1];
char cwd[1024] = «»;
int buf_index = 1, len;

int depth = MAXDEPTH;
char *last_elem = NULL;
struct stat st;

if (strlcpy(buf, path, PATH_MAX) >= PATH_MAX)
die (»Too long path: %.*s», 60, path);

while (depth–) {
if (!is_directory(buf)) {
char *last_slash = strrchr(buf, ‘/’);
if (last_slash) {
*last_slash = ‘\0′;
last_elem = xstrdup(last_slash + 1);
} else {
last_elem = xstrdup(buf);
*buf = ‘\0′;
}
}

if (*buf) {
if (!*cwd && !getcwd(cwd, sizeof(cwd)))
die (»Could not get current working directory»);

if (chdir(buf))
die (»Could not switch to ‘%s’», buf);
}
if (!getcwd(buf, PATH_MAX))
die (»Could not get current working directory»);

if (last_elem) {
len = strlen(buf);

if (len + strlen(last_elem) + 2 > PATH_MAX)
die (»Too long path name: ‘%s/%s’»,
buf, last_elem);
buf[len] = ‘/’;
strcpy(buf + len + 1, last_elem);
free(last_elem);
last_elem = NULL;
}

if (!lstat(buf, &st) && S_ISLNK(st.st_mode)) {
len = readlink(buf, next_buf, PATH_MAX);
if (len < 0)
die ("Invalid symlink: %s", buf);
if (PATH_MAX <= len)
die("symbolic link too long: %s", buf);
next_buf[len] = '\0';
buf = next_buf;
buf_index = 1 - buf_index;
next_buf = bufs[buf_index];
} else
break;
}

if (*cwd && chdir(cwd))
die ("Could not change back to '%s'", cwd);

return buf;
}

static const char *get_pwd_cwd(void)
{
static char cwd[PATH_MAX + 1];
char *pwd;
struct stat cwd_stat, pwd_stat;
if (getcwd(cwd, PATH_MAX) == NULL)
return NULL;
pwd = getenv("PWD");
if (pwd && strcmp(pwd, cwd)) {
stat(cwd, &cwd_stat);
if (!stat(pwd, &pwd_stat) &&
pwd_stat.st_dev == cwd_stat.st_dev &&
pwd_stat.st_ino == cwd_stat.st_ino) {
strlcpy(cwd, pwd, PATH_MAX);
}
}
return cwd;
}

const char *make_nonrelative_path(const char *path)
{
static char buf[PATH_MAX + 1];

if (is_absolute_path(path)) {
if (strlcpy(buf, path, PATH_MAX) >= PATH_MAX)
die(»Too long path: %.*s», 60, path);
} else {
const char *cwd = get_pwd_cwd();
if (!cwd)
die(»Cannot determine the current working directory»);
if (snprintf(buf, PATH_MAX, «%s/%s», cwd, path) >= PATH_MAX)
die(»Too long path: %.*s», 60, path);
}
return buf;
}

#include «util/exec_cmd.h»
#include «util/cache.h»
#include «util/quote.h»
#include «util/run-command.h»
#include «util/parse-events.h»
#include «util/string.h»

const char perf_usage_string[] =
«perf [--version] [--help] COMMAND [ARGS]«;

const char perf_more_info_string[] =
«See ‘perf help COMMAND’ for more information on a specific command.»;

static int use_pager = -1;
struct pager_config {
const char *cmd;
int val;
};

static char debugfs_mntpt[MAXPATHLEN];

static int pager_command_config(const char *var, const char *value, void *data)
{
struct pager_config *c = data;
if (!prefixcmp(var, «pager.») && !strcmp(var + 6, c->cmd))
c->val = perf_config_bool(var, value);
return 0;
}

/* returns 0 for «no pager», 1 for «use pager», and -1 for «not specified» */
int check_pager_config(const char *cmd)
{
struct pager_config c;
c.cmd = cmd;
c.val = -1;
perf_config(pager_command_config, &c);
return c.val;
}

static void commit_pager_choice(void) {
switch (use_pager) {
case 0:
setenv(»PERF_PAGER», «cat», 1);
break;
case 1:
/* setup_pager(); */
break;
default:
break;
}
}

static void set_debugfs_path(void)
{
char *path;

path = getenv(PERF_DEBUGFS_ENVIRONMENT);
snprintf(debugfs_path, MAXPATHLEN, «%s/%s», path ?: debugfs_mntpt,
«tracing/events»);
}

static int handle_options(const char*** argv, int* argc, int* envchanged)
{
int handled = 0;

while (*argc > 0) {
const char *cmd = (*argv)[0];
if (cmd[0] != ‘-’)
break;

/*
* For legacy reasons, the «version» and «help»
* commands can be written with «–» prepended
* to make them look like flags.
*/
if (!strcmp(cmd, «–help») || !strcmp(cmd, «–version»))
break;

/*
* Check remaining flags.
*/
if (!prefixcmp(cmd, «–exec-path»)) {
cmd += 11;
if (*cmd == ‘=’)
perf_set_argv_exec_path(cmd + 1);
else {
puts(perf_exec_path());
exit(0);
}
} else if (!strcmp(cmd, «–html-path»)) {
puts(system_path(PERF_HTML_PATH));
exit(0);
} else if (!strcmp(cmd, «-p») || !strcmp(cmd, «–paginate»)) {
use_pager = 1;
} else if (!strcmp(cmd, «–no-pager»)) {
use_pager = 0;
if (envchanged)
*envchanged = 1;
} else if (!strcmp(cmd, «–perf-dir»)) {
if (*argc < 2) {
fprintf(stderr, "No directory given for --perf-dir.\n" );
usage(perf_usage_string);
}
setenv(PERF_DIR_ENVIRONMENT, (*argv)[1], 1);
if (envchanged)
*envchanged = 1;
(*argv)++;
(*argc)--;
handled++;
} else if (!prefixcmp(cmd, "--perf-dir=")) {
setenv(PERF_DIR_ENVIRONMENT, cmd + 10, 1);
if (envchanged)
*envchanged = 1;
} else if (!strcmp(cmd, "--work-tree")) {
if (*argc < 2) {
fprintf(stderr, "No directory given for --work-tree.\n" );
usage(perf_usage_string);
}
setenv(PERF_WORK_TREE_ENVIRONMENT, (*argv)[1], 1);
if (envchanged)
*envchanged = 1;
(*argv)++;
(*argc)--;
} else if (!prefixcmp(cmd, "--work-tree=")) {
setenv(PERF_WORK_TREE_ENVIRONMENT, cmd + 12, 1);
if (envchanged)
*envchanged = 1;
} else if (!strcmp(cmd, "--debugfs-dir")) {
if (*argc < 2) {
fprintf(stderr, "No directory given for --debugfs-dir.\n");
usage(perf_usage_string);
}
strncpy(debugfs_mntpt, (*argv)[1], MAXPATHLEN);
debugfs_mntpt[MAXPATHLEN - 1] = '\0';
if (envchanged)
*envchanged = 1;
(*argv)++;
(*argc)--;
} else if (!prefixcmp(cmd, "--debugfs-dir=")) {
strncpy(debugfs_mntpt, cmd + 14, MAXPATHLEN);
debugfs_mntpt[MAXPATHLEN - 1] = '\0';
if (envchanged)
*envchanged = 1;
} else {
fprintf(stderr, "Unknown option: %s\n", cmd);
usage(perf_usage_string);
}

(*argv)++;
(*argc)--;
handled++;
}
return handled;
}

static int handle_alias(int *argcp, const char ***argv)
{
int envchanged = 0, ret = 0, saved_errno = errno;
int count, option_count;
const char** new_argv;
const char *alias_command;
char *alias_string;

alias_command = (*argv)[0];
alias_string = alias_lookup(alias_command);
if (alias_string) {
if (alias_string[0] == '!') {
if (*argcp > 1) {
struct strbuf buf;

strbuf_init(&buf, PATH_MAX);
strbuf_addstr(&buf, alias_string);
sq_quote_argv(&buf, (*argv) + 1, PATH_MAX);
free(alias_string);
alias_string = buf.buf;
}
ret = system(alias_string + 1);
if (ret >= 0 && WIFEXITED(ret) &&
WEXITSTATUS(ret) != 127)
exit(WEXITSTATUS(ret));
die(»Failed to run ‘%s’ when expanding alias ‘%s’»,
alias_string + 1, alias_command);
}
count = split_cmdline(alias_string, &new_argv);
if (count < 0)
die("Bad alias.%s string", alias_command);
option_count = handle_options(&new_argv, &count, &envchanged);
if (envchanged)
die("alias '%s' changes environment variables\n"
"You can use '!perf' in the alias to do this.",
alias_command);
memmove(new_argv - option_count, new_argv,
count * sizeof(char *));
new_argv -= option_count;

if (count < 1)
die("empty alias for %s", alias_command);

if (!strcmp(alias_command, new_argv[0]))
die("recursive alias: %s", alias_command);

new_argv = realloc(new_argv, sizeof(char*) *
(count + *argcp + 1));
/* insert after command name */
memcpy(new_argv + count, *argv + 1, sizeof(char*) * *argcp);
new_argv[count+*argcp] = NULL;

*argv = new_argv;
*argcp += count - 1;

ret = 1;
}

errno = saved_errno;

return ret;
}

const char perf_version_string[] = PERF_VERSION;

#define RUN_SETUP (1<<0)
#define USE_PAGER (1<<1)
/*
* require working tree to be present -- anything uses this needs
* RUN_SETUP for reading from the configuration file.
*/
#define NEED_WORK_TREE (1<<2)

struct cmd_struct {
const char *cmd;
int (*fn)(int, const char **, const char *);
int option;
};

static int run_builtin(struct cmd_struct *p, int argc, const char **argv)
{
int status;
struct stat st;
const char *prefix;

prefix = NULL;
if (p->option & RUN_SETUP)
prefix = NULL; /* setup_perf_directory(); */

if (use_pager == -1 && p->option & RUN_SETUP)
use_pager = check_pager_config(p->cmd);
if (use_pager == -1 && p->option & USE_PAGER)
use_pager = 1;
commit_pager_choice();
set_debugfs_path();

status = p->fn(argc, argv, prefix);
if (status)
return status & 0xff;

/* Somebody closed stdout? */
if (fstat(fileno(stdout), &st))
return 0;
/* Ignore write errors for pipes and sockets.. */
if (S_ISFIFO(st.st_mode) || S_ISSOCK(st.st_mode))
return 0;

/* Check for ENOSPC and EIO errors.. */
if (fflush(stdout))
die(»write failure on standard output: %s», strerror(errno));
if (ferror(stdout))
die(»unknown write failure on standard output»);
if (fclose(stdout))
die(»close failed on standard output: %s», strerror(errno));
return 0;
}

static void handle_internal_command(int argc, const char **argv)
{
const char *cmd = argv[0];
static struct cmd_struct commands[] = {
{ «help», cmd_help, 0 },
{ «list», cmd_list, 0 },
{ «record», cmd_record, 0 },
{ «report», cmd_report, 0 },
{ «stat», cmd_stat, 0 },
{ «timechart», cmd_timechart, 0 },
{ «top», cmd_top, 0 },
{ «annotate», cmd_annotate, 0 },
{ «version», cmd_version, 0 },
{ «trace», cmd_trace, 0 },
{ «sched», cmd_sched, 0 },
};
unsigned int i;
static const char ext[] = STRIP_EXTENSION;

if (sizeof(ext) > 1) {
i = strlen(argv[0]) – strlen(ext);
if (i > 0 && !strcmp(argv[0] + i, ext)) {
char *argv0 = strdup(argv[0]);
argv[0] = cmd = argv0;
argv0[i] = ‘\0′;
}
}

/* Turn «perf cmd –help» into «perf help cmd» */
if (argc > 1 && !strcmp(argv[1], «–help»)) {
argv[1] = argv[0];
argv[0] = cmd = «help»;
}

for (i = 0; i < ARRAY_SIZE(commands); i++) {
struct cmd_struct *p = commands+i;
if (strcmp(p->cmd, cmd))
continue;
exit(run_builtin(p, argc, argv));
}
}

static void execv_dashed_external(const char **argv)
{
struct strbuf cmd = STRBUF_INIT;
const char *tmp;
int status;

strbuf_addf(&cmd, «perf-%s», argv[0]);

/*
* argv[0] must be the perf command, but the argv array
* belongs to the caller, and may be reused in
* subsequent loop iterations. Save argv[0] and
* restore it on error.
*/
tmp = argv[0];
argv[0] = cmd.buf;

/*
* if we fail because the command is not found, it is
* OK to return. Otherwise, we just pass along the status code.
*/
status = run_command_v_opt(argv, 0);
if (status != -ERR_RUN_COMMAND_EXEC) {
if (IS_RUN_COMMAND_ERR(status))
die(»unable to run ‘%s’», argv[0]);
exit(-status);
}
errno = ENOENT; /* as if we called execvp */

argv[0] = tmp;

strbuf_release(&cmd);
}

static int run_argv(int *argcp, const char ***argv)
{
int done_alias = 0;

while (1) {
/* See if it’s an internal command */
handle_internal_command(*argcp, *argv);

/* .. then try the external ones */
execv_dashed_external(*argv);

/* It could be an alias — this works around the insanity
* of overriding «perf log» with «perf show» by having
* alias.log = show
*/
if (done_alias || !handle_alias(argcp, argv))
break;
done_alias = 1;
}

return done_alias;
}

/* mini /proc/mounts parser: searching for «^blah /mount/point debugfs» */
static void get_debugfs_mntpt(void)
{
FILE *file;
char fs_type[100];
char debugfs[MAXPATHLEN];

/*
* try the standard location
*/
if (valid_debugfs_mount(»/sys/kernel/debug/») == 0) {
strcpy(debugfs_mntpt, «/sys/kernel/debug/»);
return;
}

/*
* try the sane location
*/
if (valid_debugfs_mount(»/debug/») == 0) {
strcpy(debugfs_mntpt, «/debug/»);
return;
}

/*
* give up and parse /proc/mounts
*/
file = fopen(»/proc/mounts», «r»);
if (file == NULL)
return;

while (fscanf(file, «%*s %»
STR(MAXPATHLEN)
«s %99s %*s %*d %*d\n»,
debugfs, fs_type) == 2) {
if (strcmp(fs_type, «debugfs») == 0)
break;
}
fclose(file);
if (strcmp(fs_type, «debugfs») == 0) {
strncpy(debugfs_mntpt, debugfs, MAXPATHLEN);
debugfs_mntpt[MAXPATHLEN - 1] = ‘\0′;
}
}

int main(int argc, const char **argv)
{
const char *cmd;

cmd = perf_extract_argv0_path(argv[0]);
if (!cmd)
cmd = «perf-help»;
/* get debugfs mount point from /proc/mounts */
get_debugfs_mntpt();
/*
* «perf-xxxx» is the same as «perf xxxx», but we obviously:
*
* – cannot take flags in between the «perf» and the «xxxx».
* – cannot execute it externally (since it would just do
* the same thing over again)
*
* So we just directly call the internal command handler, and
* die if that one cannot handle it.
*/
if (!prefixcmp(cmd, «perf-»)) {
cmd += 5;
argv[0] = cmd;
handle_internal_command(argc, argv);
die(»cannot handle %s internally», cmd);
}

/* Look for flags.. */
argv++;
argc–;
handle_options(&argv, &argc, NULL);
commit_pager_choice();
set_debugfs_path();
if (argc > 0) {
if (!prefixcmp(argv[0], «–»))
argv[0] += 2;
} else {
/* The user didn’t specify a command; give them help */
printf(»\n usage: %s\n\n», perf_usage_string);
list_common_cmds_help();
printf(»\n %s\n\n», perf_more_info_string);
exit(1);
}
cmd = argv[0];

/*
* We use PATH to find perf commands, but we prepend some higher
* precidence paths: the «–exec-path» option, the PERF_EXEC_PATH
* environment, and the $(perfexecdir) from the Makefile at build
* time.
*/
setup_path();

while (1) {
static int done_help = 0;
static int was_alias = 0;

was_alias = run_argv(&argc, &argv);
if (errno != ENOENT)
break;

if (was_alias) {
fprintf(stderr, «Expansion of alias ‘%s’ failed; »
«‘%s’ is not a perf-command\n»,
cmd, argv[0]);
exit(1);
}
if (!done_help) {
cmd = argv[0] = help_unknown_cmd(cmd);
done_help = 1;
} else
break;
}

fprintf(stderr, «Failed to run command ‘%s’: %s\n»,
cmd, strerror(errno));

return 1;
}

# Define V=1 to have a more verbose compile.
#
# Define SNPRINTF_RETURNS_BOGUS if your are on a system which snprintf()
# or vsnprintf() return -1 instead of number of characters which would
# have been written to the final string if enough space had been available.
#
# Define FREAD_READS_DIRECTORIES if your are on a system which succeeds
# when attempting to read from an fopen’ed directory.
#
# Define NO_OPENSSL environment variable if you do not have OpenSSL.
# This also implies MOZILLA_SHA1.
#
# Define CURLDIR=/foo/bar if your curl header and library files are in
# /foo/bar/include and /foo/bar/lib directories.
#
# Define EXPATDIR=/foo/bar if your expat header and library files are in
# /foo/bar/include and /foo/bar/lib directories.
#
# Define NO_D_INO_IN_DIRENT if you don’t have d_ino in your struct dirent.
#
# Define NO_D_TYPE_IN_DIRENT if your platform defines DT_UNKNOWN but lacks
# d_type in struct dirent (latest Cygwin — will be fixed soonish).
#
# Define NO_C99_FORMAT if your formatted IO functions (printf/scanf et.al.)
# do not support the ’size specifiers’ introduced by C99, namely ll, hh,
# j, z, t. (representing long long int, char, intmax_t, size_t, ptrdiff_t).
# some C compilers supported these specifiers prior to C99 as an extension.
#
# Define NO_STRCASESTR if you don’t have strcasestr.
#
# Define NO_MEMMEM if you don’t have memmem.
#
# Define NO_STRTOUMAX if you don’t have strtoumax in the C library.
# If your compiler also does not support long long or does not have
# strtoull, define NO_STRTOULL.
#
# Define NO_SETENV if you don’t have setenv in the C library.
#
# Define NO_UNSETENV if you don’t have unsetenv in the C library.
#
# Define NO_MKDTEMP if you don’t have mkdtemp in the C library.
#
# Define NO_SYS_SELECT_H if you don’t have sys/select.h.
#
# Define NO_SYMLINK_HEAD if you never want .perf/HEAD to be a symbolic link.
# Enable it on Windows. By default, symrefs are still used.
#
# Define NO_SVN_TESTS if you want to skip time-consuming SVN interoperability
# tests. These tests take up a significant amount of the total test time
# but are not needed unless you plan to talk to SVN repos.
#
# Define NO_FINK if you are building on Darwin/Mac OS X, have Fink
# installed in /sw, but don’t want PERF to link against any libraries
# installed there. If defined you may specify your own (or Fink’s)
# include directories and library directories by defining CFLAGS
# and LDFLAGS appropriately.
#
# Define NO_DARWIN_PORTS if you are building on Darwin/Mac OS X,
# have DarwinPorts installed in /opt/local, but don’t want PERF to
# link against any libraries installed there. If defined you may
# specify your own (or DarwinPort’s) include directories and
# library directories by defining CFLAGS and LDFLAGS appropriately.
#
# Define PPC_SHA1 environment variable when running make to make use of
# a bundled SHA1 routine optimized for PowerPC.
#
# Define ARM_SHA1 environment variable when running make to make use of
# a bundled SHA1 routine optimized for ARM.
#
# Define MOZILLA_SHA1 environment variable when running make to make use of
# a bundled SHA1 routine coming from Mozilla. It is GPL’d and should be fast
# on non-x86 architectures (e.g. PowerPC), while the OpenSSL version (default
# choice) has very fast version optimized for i586.
#
# Define NEEDS_SSL_WITH_CRYPTO if you need -lcrypto with -lssl (Darwin).
#
# Define NEEDS_LIBICONV if linking with libc is not enough (Darwin).
#
# Define NEEDS_SOCKET if linking with libc is not enough (SunOS,
# Patrick Mauritz).
#
# Define NO_MMAP if you want to avoid mmap.
#
# Define NO_PTHREADS if you do not have or do not want to use Pthreads.
#
# Define NO_PREAD if you have a problem with pread() system call (e.g.
# cygwin.dll before v1.5.22).
#
# Define NO_FAST_WORKING_DIRECTORY if accessing objects in pack files is
# generally faster on your platform than accessing the working directory.
#
# Define NO_TRUSTABLE_FILEMODE if your filesystem may claim to support
# the executable mode bit, but doesn’t really do so.
#
# Define NO_IPV6 if you lack IPv6 support and getaddrinfo().
#
# Define NO_SOCKADDR_STORAGE if your platform does not have struct
# sockaddr_storage.
#
# Define NO_ICONV if your libc does not properly support iconv.
#
# Define OLD_ICONV if your library has an old iconv(), where the second
# (input buffer pointer) parameter is declared with type (const char **).
#
# Define NO_DEFLATE_BOUND if your zlib does not have deflateBound.
#
# Define NO_R_TO_GCC_LINKER if your gcc does not like «-R/path/lib»
# that tells runtime paths to dynamic libraries;
# «-Wl,-rpath=/path/lib» is used instead.
#
# Define USE_NSEC below if you want perf to care about sub-second file mtimes
# and ctimes. Note that you need recent glibc (at least 2.2.4) for this, and
# it will BREAK YOUR LOCAL DIFFS! show-diff and anything using it will likely
# randomly break unless your underlying filesystem supports those sub-second
# times (my ext3 doesn’t).
#
# Define USE_ST_TIMESPEC if your «struct stat» uses «st_ctimespec» instead of
# «st_ctim»
#
# Define NO_NSEC if your «struct stat» does not have «st_ctim.tv_nsec»
# available. This automatically turns USE_NSEC off.
#
# Define USE_STDEV below if you want perf to care about the underlying device
# change being considered an inode change from the update-index perspective.
#
# Define NO_ST_BLOCKS_IN_STRUCT_STAT if your platform does not have st_blocks
# field that counts the on-disk footprint in 512-byte blocks.
#
# Define ASCIIDOC8 if you want to format documentation with AsciiDoc 8
#
# Define DOCBOOK_XSL_172 if you want to format man pages with DocBook XSL v1.72.
#
# Define NO_PERL_MAKEMAKER if you cannot use Makefiles generated by perl’s
# MakeMaker (e.g. using ActiveState under Cygwin).
#
# Define NO_PERL if you do not want Perl scripts or libraries at all.
#
# Define INTERNAL_QSORT to use Git’s implementation of qsort(), which
# is a simplified version of the merge sort used in glibc. This is
# recommended if Git triggers O(n^2) behavior in your platform’s qsort().
#
# Define NO_EXTERNAL_GREP if you don’t want «perf grep» to ever call
# your external grep (e.g., if your system lacks grep, if its grep is
# broken, or spawning external process is slower than built-in grep perf has).

PERF-VERSION-FILE: .FORCE-PERF-VERSION-FILE
@$(SHELL_PATH) util/PERF-VERSION-GEN
-include PERF-VERSION-FILE

uname_S := $(shell sh -c ‘uname -s 2>/dev/null || echo not’)
uname_M := $(shell sh -c ‘uname -m 2>/dev/null || echo not’)
uname_O := $(shell sh -c ‘uname -o 2>/dev/null || echo not’)
uname_R := $(shell sh -c ‘uname -r 2>/dev/null || echo not’)
uname_P := $(shell sh -c ‘uname -p 2>/dev/null || echo not’)
uname_V := $(shell sh -c ‘uname -v 2>/dev/null || echo not’)

#
# Add -m32 for cross-builds:
#
ifdef NO_64BIT
MBITS := -m32
else
#
# If we’re on a 64-bit kernel, use -m64:
#
ifneq ($(patsubst %64,%,$(uname_M)),$(uname_M))
MBITS := -m64
endif
endif

# CFLAGS and LDFLAGS are for the users to override from the command line.

#
# Include saner warnings here, which can catch bugs:
#

EXTRA_WARNINGS := -Wformat
EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wformat-security
EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wformat-y2k
EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wshadow
EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Winit-self
EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wpacked
EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wredundant-decls
EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wstack-protector
EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wstrict-aliasing=3
EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wswitch-default
EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wswitch-enum
EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wno-system-headers
EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wundef
EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wvolatile-register-var
EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wwrite-strings
EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wbad-function-cast
EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wmissing-declarations
EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wmissing-prototypes
EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wnested-externs
EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wold-style-definition
EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wstrict-prototypes
EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wdeclaration-after-statement

CFLAGS = $(MBITS) -ggdb3 -Wall -Wextra -std=gnu99 -Werror -O6 -fstack-protector-all -D_FORTIFY_SOURCE=2 $(EXTRA_WARNINGS)
LDFLAGS = -lpthread -lrt -lelf -lm
ALL_CFLAGS = $(CFLAGS)
ALL_LDFLAGS = $(LDFLAGS)
STRIP ?= strip

# Among the variables below, these:
# perfexecdir
# template_dir
# mandir
# infodir
# htmldir
# ETC_PERFCONFIG (but not sysconfdir)
# can be specified as a relative path some/where/else;
# this is interpreted as relative to $(prefix) and «perf» at
# runtime figures out where they are based on the path to the executable.
# This can help installing the suite in a relocatable way.

prefix = $(HOME)
bindir_relative = bin
bindir = $(prefix)/$(bindir_relative)
mandir = share/man
infodir = share/info
perfexecdir = libexec/perf-core
sharedir = $(prefix)/share
template_dir = share/perf-core/templates
htmldir = share/doc/perf-doc
ifeq ($(prefix),/usr)
sysconfdir = /etc
ETC_PERFCONFIG = $(sysconfdir)/perfconfig
else
sysconfdir = $(prefix)/etc
ETC_PERFCONFIG = etc/perfconfig
endif
lib = lib
# DESTDIR=

export prefix bindir sharedir sysconfdir

CC = gcc
AR = ar
RM = rm -f
TAR = tar
FIND = find
INSTALL = install
RPMBUILD = rpmbuild
PTHREAD_LIBS = -lpthread

# sparse is architecture-neutral, which means that we need to tell it
# explicitly what architecture to check for. Fix this up for yours..
SPARSE_FLAGS = -D__BIG_ENDIAN__ -D__powerpc__

### — END CONFIGURATION SECTION —

# Those must not be GNU-specific; they are shared with perl/ which may
# be built by a different compiler. (Note that this is an artifact now
# but it still might be nice to keep that distinction.)
BASIC_CFLAGS = -Iutil/include
BASIC_LDFLAGS =

# Guard against environment variables
BUILTIN_OBJS =
BUILT_INS =
COMPAT_CFLAGS =
COMPAT_OBJS =
LIB_H =
LIB_OBJS =
SCRIPT_PERL =
SCRIPT_SH =
TEST_PROGRAMS =

#
# No scripts right now:
#

# SCRIPT_SH += perf-am.sh

#
# No Perl scripts right now:
#

# SCRIPT_PERL += perf-add–interactive.perl

SCRIPTS = $(patsubst %.sh,%,$(SCRIPT_SH)) \
$(patsubst %.perl,%,$(SCRIPT_PERL))

# Empty…
EXTRA_PROGRAMS =

# … and all the rest that could be moved out of bindir to perfexecdir
PROGRAMS += $(EXTRA_PROGRAMS)

#
# Single ‘perf’ binary right now:
#
PROGRAMS += perf

# List built-in command $C whose implementation cmd_$C() is not in
# builtin-$C.o but is linked in as part of some other command.
#
# None right now:
#
# BUILT_INS += perf-init $X

# what ‘all’ will build and ‘install’ will install, in perfexecdir
ALL_PROGRAMS = $(PROGRAMS) $(SCRIPTS)

# what ‘all’ will build but not install in perfexecdir
OTHER_PROGRAMS = perf$X

# Set paths to tools early so that they can be used for version tests.
ifndef SHELL_PATH
SHELL_PATH = /bin/sh
endif
ifndef PERL_PATH
PERL_PATH = /usr/bin/perl
endif

export PERL_PATH

LIB_FILE=libperf.a

LIB_H += ../../include/linux/perf_event.h
LIB_H += ../../include/linux/rbtree.h
LIB_H += ../../include/linux/list.h
LIB_H += util/include/linux/list.h
LIB_H += perf.h
LIB_H += util/types.h
LIB_H += util/levenshtein.h
LIB_H += util/parse-options.h
LIB_H += util/parse-events.h
LIB_H += util/quote.h
LIB_H += util/util.h
LIB_H += util/help.h
LIB_H += util/strbuf.h
LIB_H += util/string.h
LIB_H += util/strlist.h
LIB_H += util/run-command.h
LIB_H += util/sigchain.h
LIB_H += util/symbol.h
LIB_H += util/module.h
LIB_H += util/color.h
LIB_H += util/values.h

LIB_OBJS += util/abspath.o
LIB_OBJS += util/alias.o
LIB_OBJS += util/config.o
LIB_OBJS += util/ctype.o
LIB_OBJS += util/environment.o
LIB_OBJS += util/exec_cmd.o
LIB_OBJS += util/help.o
LIB_OBJS += util/levenshtein.o
LIB_OBJS += util/parse-options.o
LIB_OBJS += util/parse-events.o
LIB_OBJS += util/path.o
LIB_OBJS += util/rbtree.o
LIB_OBJS += util/run-command.o
LIB_OBJS += util/quote.o
LIB_OBJS += util/strbuf.o
LIB_OBJS += util/string.o
LIB_OBJS += util/strlist.o
LIB_OBJS += util/usage.o
LIB_OBJS += util/wrapper.o
LIB_OBJS += util/sigchain.o
LIB_OBJS += util/symbol.o
LIB_OBJS += util/module.o
LIB_OBJS += util/color.o
LIB_OBJS += util/pager.o
LIB_OBJS += util/header.o
LIB_OBJS += util/callchain.o
LIB_OBJS += util/values.o
LIB_OBJS += util/debug.o
LIB_OBJS += util/map.o
LIB_OBJS += util/thread.o
LIB_OBJS += util/trace-event-parse.o
LIB_OBJS += util/trace-event-read.o
LIB_OBJS += util/trace-event-info.o
LIB_OBJS += util/svghelper.o

BUILTIN_OBJS += builtin-annotate.o
BUILTIN_OBJS += builtin-help.o
BUILTIN_OBJS += builtin-sched.o
BUILTIN_OBJS += builtin-list.o
BUILTIN_OBJS += builtin-record.o
BUILTIN_OBJS += builtin-report.o
BUILTIN_OBJS += builtin-stat.o
BUILTIN_OBJS += builtin-timechart.o
BUILTIN_OBJS += builtin-top.o
BUILTIN_OBJS += builtin-trace.o

PERFLIBS = $(LIB_FILE)

#
# Platform specific tweaks
#

# We choose to avoid «if .. else if .. else .. endif endif»
# because maintaining the nesting to match is a pain. If
# we had «elif» things would have been much nicer…

-include config.mak.autogen
-include config.mak

ifeq ($(uname_S),Darwin)
ifndef NO_FINK
ifeq ($(shell test -d /sw/lib && echo y),y)
BASIC_CFLAGS += -I/sw/include
BASIC_LDFLAGS += -L/sw/lib
endif
endif
ifndef NO_DARWIN_PORTS
ifeq ($(shell test -d /opt/local/lib && echo y),y)
BASIC_CFLAGS += -I/opt/local/include
BASIC_LDFLAGS += -L/opt/local/lib
endif
endif
PTHREAD_LIBS =
endif

ifeq ($(shell sh -c «(echo ‘\#include ‘; echo ‘int main(void) { Elf * elf = elf_begin(0, ELF_C_READ, 0); return (long)elf; }’) | $(CC) -x c – $(ALL_CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -o /dev/null $(ALL_LDFLAGS) > /dev/null 2>&1 && echo y»), y)
ifneq ($(shell sh -c «(echo ‘\#include ‘; echo ‘int main(void) { Elf * elf = elf_begin(0, ELF_C_READ_MMAP, 0); return (long)elf; }’) | $(CC) -x c – $(ALL_CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -o /dev/null $(ALL_LDFLAGS) > /dev/null 2>&1 && echo y»), y)
BASIC_CFLAGS += -DLIBELF_NO_MMAP
endif
else
msg := $(error No libelf.h/libelf found, please install libelf-dev/elfutils-libelf-devel and glibc-dev[el]);
endif

ifdef NO_DEMANGLE
BASIC_CFLAGS += -DNO_DEMANGLE
else
has_bfd := $(shell sh -c «(echo ‘\#include ‘; echo ‘int main(void) { bfd_demangle(0, 0, 0); return 0; }’) | $(CC) -x c – $(ALL_CFLAGS) -o /dev/null $(ALL_LDFLAGS) -lbfd > /dev/null 2>&1 && echo y»)

ifeq ($(has_bfd),y)
EXTLIBS += -lbfd
else
has_bfd_iberty := $(shell sh -c «(echo ‘\#include ‘; echo ‘int main(void) { bfd_demangle(0, 0, 0); return 0; }’) | $(CC) -x c – $(ALL_CFLAGS) -o /dev/null $(ALL_LDFLAGS) -lbfd -liberty > /dev/null 2>&1 && echo y»)
ifeq ($(has_bfd_iberty),y)
EXTLIBS += -lbfd -liberty
else
has_bfd_iberty_z := $(shell sh -c «(echo ‘\#include ‘; echo ‘int main(void) { bfd_demangle(0, 0, 0); return 0; }’) | $(CC) -x c – $(ALL_CFLAGS) -o /dev/null $(ALL_LDFLAGS) -lbfd -liberty -lz > /dev/null 2>&1 && echo y»)
ifeq ($(has_bfd_iberty_z),y)
EXTLIBS += -lbfd -liberty -lz
else
has_cplus_demangle := $(shell sh -c «(echo ‘extern char *cplus_demangle(const char *, int);’; echo ‘int main(void) { cplus_demangle(0, 0); return 0; }’) | $(CC) -x c – $(ALL_CFLAGS) -o /dev/null $(ALL_LDFLAGS) -liberty > /dev/null 2>&1 && echo y»)
ifeq ($(has_cplus_demangle),y)
EXTLIBS += -liberty
BASIC_CFLAGS += -DHAVE_CPLUS_DEMANGLE
else
msg := $(warning No bfd.h/libbfd found, install binutils-dev[el] to gain symbol demangling)
BASIC_CFLAGS += -DNO_DEMANGLE
endif
endif
endif
endif
endif

ifndef CC_LD_DYNPATH
ifdef NO_R_TO_GCC_LINKER
# Some gcc does not accept and pass -R to the linker to specify
# the runtime dynamic library path.
CC_LD_DYNPATH = -Wl,-rpath,
else
CC_LD_DYNPATH = -R
endif
endif

ifdef NEEDS_SOCKET
EXTLIBS += -lsocket
endif
ifdef NEEDS_NSL
EXTLIBS += -lnsl
endif
ifdef NO_D_TYPE_IN_DIRENT
BASIC_CFLAGS += -DNO_D_TYPE_IN_DIRENT
endif
ifdef NO_D_INO_IN_DIRENT
BASIC_CFLAGS += -DNO_D_INO_IN_DIRENT
endif
ifdef NO_ST_BLOCKS_IN_STRUCT_STAT
BASIC_CFLAGS += -DNO_ST_BLOCKS_IN_STRUCT_STAT
endif
ifdef USE_NSEC
BASIC_CFLAGS += -DUSE_NSEC
endif
ifdef USE_ST_TIMESPEC
BASIC_CFLAGS += -DUSE_ST_TIMESPEC
endif
ifdef NO_NSEC
BASIC_CFLAGS += -DNO_NSEC
endif
ifdef NO_C99_FORMAT
BASIC_CFLAGS += -DNO_C99_FORMAT
endif
ifdef SNPRINTF_RETURNS_BOGUS
COMPAT_CFLAGS += -DSNPRINTF_RETURNS_BOGUS
COMPAT_OBJS += compat/snprintf.o
endif
ifdef FREAD_READS_DIRECTORIES
COMPAT_CFLAGS += -DFREAD_READS_DIRECTORIES
COMPAT_OBJS += compat/fopen.o
endif
ifdef NO_SYMLINK_HEAD
BASIC_CFLAGS += -DNO_SYMLINK_HEAD
endif
ifdef NO_STRCASESTR
COMPAT_CFLAGS += -DNO_STRCASESTR
COMPAT_OBJS += compat/strcasestr.o
endif
ifdef NO_STRTOUMAX
COMPAT_CFLAGS += -DNO_STRTOUMAX
COMPAT_OBJS += compat/strtoumax.o
endif
ifdef NO_STRTOULL
COMPAT_CFLAGS += -DNO_STRTOULL
endif
ifdef NO_SETENV
COMPAT_CFLAGS += -DNO_SETENV
COMPAT_OBJS += compat/setenv.o
endif
ifdef NO_MKDTEMP
COMPAT_CFLAGS += -DNO_MKDTEMP
COMPAT_OBJS += compat/mkdtemp.o
endif
ifdef NO_UNSETENV
COMPAT_CFLAGS += -DNO_UNSETENV
COMPAT_OBJS += compat/unsetenv.o
endif
ifdef NO_SYS_SELECT_H
BASIC_CFLAGS += -DNO_SYS_SELECT_H
endif
ifdef NO_MMAP
COMPAT_CFLAGS += -DNO_MMAP
COMPAT_OBJS += compat/mmap.o
else
ifdef USE_WIN32_MMAP
COMPAT_CFLAGS += -DUSE_WIN32_MMAP
COMPAT_OBJS += compat/win32mmap.o
endif
endif
ifdef NO_PREAD
COMPAT_CFLAGS += -DNO_PREAD
COMPAT_OBJS += compat/pread.o
endif
ifdef NO_FAST_WORKING_DIRECTORY
BASIC_CFLAGS += -DNO_FAST_WORKING_DIRECTORY
endif
ifdef NO_TRUSTABLE_FILEMODE
BASIC_CFLAGS += -DNO_TRUSTABLE_FILEMODE
endif
ifdef NO_IPV6
BASIC_CFLAGS += -DNO_IPV6
endif
ifdef NO_UINTMAX_T
BASIC_CFLAGS += -Duintmax_t=uint32_t
endif
ifdef NO_SOCKADDR_STORAGE
ifdef NO_IPV6
BASIC_CFLAGS += -Dsockaddr_storage=sockaddr_in
else
BASIC_CFLAGS += -Dsockaddr_storage=sockaddr_in6
endif
endif
ifdef NO_INET_NTOP
LIB_OBJS += compat/inet_ntop.o
endif
ifdef NO_INET_PTON
LIB_OBJS += compat/inet_pton.o
endif

ifdef NO_ICONV
BASIC_CFLAGS += -DNO_ICONV
endif

ifdef OLD_ICONV
BASIC_CFLAGS += -DOLD_ICONV
endif

ifdef NO_DEFLATE_BOUND
BASIC_CFLAGS += -DNO_DEFLATE_BOUND
endif

ifdef PPC_SHA1
SHA1_HEADER = «ppc/sha1.h»
LIB_OBJS += ppc/sha1.o ppc/sha1ppc.o
else
ifdef ARM_SHA1
SHA1_HEADER = «arm/sha1.h»
LIB_OBJS += arm/sha1.o arm/sha1_arm.o
else
ifdef MOZILLA_SHA1
SHA1_HEADER = «mozilla-sha1/sha1.h»
LIB_OBJS += mozilla-sha1/sha1.o
else
SHA1_HEADER =
EXTLIBS += $(LIB_4_CRYPTO)
endif
endif
endif
ifdef NO_PERL_MAKEMAKER
export NO_PERL_MAKEMAKER
endif
ifdef NO_HSTRERROR
COMPAT_CFLAGS += -DNO_HSTRERROR
COMPAT_OBJS += compat/hstrerror.o
endif
ifdef NO_MEMMEM
COMPAT_CFLAGS += -DNO_MEMMEM
COMPAT_OBJS += compat/memmem.o
endif
ifdef INTERNAL_QSORT
COMPAT_CFLAGS += -DINTERNAL_QSORT
COMPAT_OBJS += compat/qsort.o
endif
ifdef RUNTIME_PREFIX
COMPAT_CFLAGS += -DRUNTIME_PREFIX
endif

ifdef DIR_HAS_BSD_GROUP_SEMANTICS
COMPAT_CFLAGS += -DDIR_HAS_BSD_GROUP_SEMANTICS
endif
ifdef NO_EXTERNAL_GREP
BASIC_CFLAGS += -DNO_EXTERNAL_GREP
endif

ifeq ($(PERL_PATH),)
NO_PERL=NoThanks
endif

QUIET_SUBDIR0 = +$(MAKE) -C # space to separate -C and subdir
QUIET_SUBDIR1 =

ifneq ($(findstring $(MAKEFLAGS),w),w)
PRINT_DIR = –no-print-directory
else # «make -w»
NO_SUBDIR = :
endif

ifneq ($(findstring $(MAKEFLAGS),s),s)
ifndef V
QUIET_CC = @echo ‘ ‘ CC $@;
QUIET_AR = @echo ‘ ‘ AR $@;
QUIET_LINK = @echo ‘ ‘ LINK $@;
QUIET_BUILT_IN = @echo ‘ ‘ BUILTIN $@;
QUIET_GEN = @echo ‘ ‘ GEN $@;
QUIET_SUBDIR0 = +@subdir=
QUIET_SUBDIR1 = ;$(NO_SUBDIR) echo ‘ ‘ SUBDIR $$subdir; \
$(MAKE) $(PRINT_DIR) -C $$subdir
export V
export QUIET_GEN
export QUIET_BUILT_IN
endif
endif

ifdef ASCIIDOC8
export ASCIIDOC8
endif

# Shell quote (do not use $(call) to accommodate ancient setups);

SHA1_HEADER_SQ = $(subst ‘,’\»,$(SHA1_HEADER))
ETC_PERFCONFIG_SQ = $(subst ‘,’\»,$(ETC_PERFCONFIG))

DESTDIR_SQ = $(subst ‘,’\»,$(DESTDIR))
bindir_SQ = $(subst ‘,’\»,$(bindir))
bindir_relative_SQ = $(subst ‘,’\»,$(bindir_relative))
mandir_SQ = $(subst ‘,’\»,$(mandir))
infodir_SQ = $(subst ‘,’\»,$(infodir))
perfexecdir_SQ = $(subst ‘,’\»,$(perfexecdir))
template_dir_SQ = $(subst ‘,’\»,$(template_dir))
htmldir_SQ = $(subst ‘,’\»,$(htmldir))
prefix_SQ = $(subst ‘,’\»,$(prefix))

SHELL_PATH_SQ = $(subst ‘,’\»,$(SHELL_PATH))
PERL_PATH_SQ = $(subst ‘,’\»,$(PERL_PATH))

LIBS = $(PERFLIBS) $(EXTLIBS)

BASIC_CFLAGS += -DSHA1_HEADER=’$(SHA1_HEADER_SQ)’ \
$(COMPAT_CFLAGS)
LIB_OBJS += $(COMPAT_OBJS)

ALL_CFLAGS += $(BASIC_CFLAGS)
ALL_LDFLAGS += $(BASIC_LDFLAGS)

export TAR INSTALL DESTDIR SHELL_PATH

### Build rules

SHELL = $(SHELL_PATH)

all:: shell_compatibility_test $(ALL_PROGRAMS) $(BUILT_INS) $(OTHER_PROGRAMS) PERF-BUILD-OPTIONS
ifneq (,$X)
$(foreach p,$(patsubst %$X,%,$(filter %$X,$(ALL_PROGRAMS) $(BUILT_INS) perf$X)), test ‘$p’ -ef ‘$p$X’ || $(RM) ‘$p’;)
endif

all::

please_set_SHELL_PATH_to_a_more_modern_shell:
@$$(:)

shell_compatibility_test: please_set_SHELL_PATH_to_a_more_modern_shell

strip: $(PROGRAMS) perf$X
$(STRIP) $(STRIP_OPTS) $(PROGRAMS) perf$X

perf.o: perf.c common-cmds.h PERF-CFLAGS
$(QUIET_CC)$(CC) -DPERF_VERSION=’»$(PERF_VERSION)»‘ \
‘-DPERF_HTML_PATH=»$(htmldir_SQ)»‘ \
$(ALL_CFLAGS) -c $(filter %.c,$^)

perf$X: perf.o $(BUILTIN_OBJS) $(PERFLIBS)
$(QUIET_LINK)$(CC) $(ALL_CFLAGS) -o $@ perf.o \
$(BUILTIN_OBJS) $(ALL_LDFLAGS) $(LIBS)

builtin-help.o: builtin-help.c common-cmds.h PERF-CFLAGS
$(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) \
‘-DPERF_HTML_PATH=»$(htmldir_SQ)»‘ \
‘-DPERF_MAN_PATH=»$(mandir_SQ)»‘ \
‘-DPERF_INFO_PATH=»$(infodir_SQ)»‘ $<

builtin-timechart.o: builtin-timechart.c common-cmds.h PERF-CFLAGS
$(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) \
'-DPERF_HTML_PATH="$(htmldir_SQ)"' \
'-DPERF_MAN_PATH="$(mandir_SQ)"' \
'-DPERF_INFO_PATH="$(infodir_SQ)"' $<

$(BUILT_INS): perf$X
$(QUIET_BUILT_IN)$(RM) $@ && \
ln perf$X $@ 2>/dev/null || \
ln -s perf$X $@ 2>/dev/null || \
cp perf$X $@

common-cmds.h: util/generate-cmdlist.sh command-list.txt

common-cmds.h: $(wildcard Documentation/perf-*.txt)
$(QUIET_GEN). util/generate-cmdlist.sh > $@+ && mv $@+ $@

$(patsubst %.sh,%,$(SCRIPT_SH)) : % : %.sh
$(QUIET_GEN)$(RM) $@ $@+ && \
sed -e ‘1s|#!.*/sh|#!$(SHELL_PATH_SQ)|’ \
-e ’s|@SHELL_PATH@|$(SHELL_PATH_SQ)|’ \
-e ’s|@@PERL@@|$(PERL_PATH_SQ)|g’ \
-e ’s/@@PERF_VERSION@@/$(PERF_VERSION)/g’ \
-e ’s/@@NO_CURL@@/$(NO_CURL)/g’ \
$@.sh >$@+ && \
chmod +x $@+ && \
mv $@+ $@

configure: configure.ac
$(QUIET_GEN)$(RM) $@ $<+ && \
sed -e 's/@@PERF_VERSION@@/$(PERF_VERSION)/g' \
$< > $<+ && \
autoconf -o $@ $<+ && \
$(RM) $<+

# These can record PERF_VERSION
perf.o perf.spec \
$(patsubst %.sh,%,$(SCRIPT_SH)) \
$(patsubst %.perl,%,$(SCRIPT_PERL)) \
: PERF-VERSION-FILE

%.o: %.c PERF-CFLAGS
$(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) $<
%.s: %.c PERF-CFLAGS
$(QUIET_CC)$(CC) -S $(ALL_CFLAGS) $<
%.o: %.S
$(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) $<

util/exec_cmd.o: util/exec_cmd.c PERF-CFLAGS
$(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) \
'-DPERF_EXEC_PATH="$(perfexecdir_SQ)"' \
'-DBINDIR="$(bindir_relative_SQ)"' \
'-DPREFIX="$(prefix_SQ)"' \
$<

builtin-init-db.o: builtin-init-db.c PERF-CFLAGS
$(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) -DDEFAULT_PERF_TEMPLATE_DIR='"$(template_dir_SQ)"' $<

util/config.o: util/config.c PERF-CFLAGS
$(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<

util/rbtree.o: ../../lib/rbtree.c PERF-CFLAGS
$(QUIET_CC)$(CC) -o util/rbtree.o -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<

perf-%$X: %.o $(PERFLIBS)
$(QUIET_LINK)$(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $(filter %.o,$^) $(LIBS)

$(LIB_OBJS) $(BUILTIN_OBJS): $(LIB_H)
$(patsubst perf-%$X,%.o,$(PROGRAMS)): $(LIB_H) $(wildcard */*.h)
builtin-revert.o wt-status.o: wt-status.h

$(LIB_FILE): $(LIB_OBJS)
$(QUIET_AR)$(RM) $@ && $(AR) rcs $@ $(LIB_OBJS)

doc:
$(MAKE) -C Documentation all

man:
$(MAKE) -C Documentation man

html:
$(MAKE) -C Documentation html

info:
$(MAKE) -C Documentation info

pdf:
$(MAKE) -C Documentation pdf

TAGS:
$(RM) TAGS
$(FIND) . -name '*.[hcS]' -print | xargs etags -a

tags:
$(RM) tags
$(FIND) . -name '*.[hcS]' -print | xargs ctags -a

cscope:
$(RM) cscope*
$(FIND) . -name '*.[hcS]' -print | xargs cscope -b

### Detect prefix changes
TRACK_CFLAGS = $(subst ','\'',$(ALL_CFLAGS)):\
$(bindir_SQ):$(perfexecdir_SQ):$(template_dir_SQ):$(prefix_SQ)

PERF-CFLAGS: .FORCE-PERF-CFLAGS
@FLAGS='$(TRACK_CFLAGS)'; \
if test x"$$FLAGS" != x"`cat PERF-CFLAGS 2>/dev/null`» ; then \
echo 1>&2 » * new build flags or prefix»; \
echo «$$FLAGS» >PERF-CFLAGS; \
fi

# We need to apply sq twice, once to protect from the shell
# that runs PERF-BUILD-OPTIONS, and then again to protect it
# and the first level quoting from the shell that runs «echo».
PERF-BUILD-OPTIONS: .FORCE-PERF-BUILD-OPTIONS
@echo SHELL_PATH=\»$(subst ‘,’\»,$(SHELL_PATH_SQ))’\’ >$@
@echo TAR=\»$(subst ‘,’\»,$(subst ‘,’\»,$(TAR)))’\’ >>$@
@echo NO_CURL=\»$(subst ‘,’\»,$(subst ‘,’\»,$(NO_CURL)))’\’ >>$@
@echo NO_PERL=\»$(subst ‘,’\»,$(subst ‘,’\»,$(NO_PERL)))’\’ >>$@

### Testing rules

#
# None right now:
#
# TEST_PROGRAMS += test-something$X

all:: $(TEST_PROGRAMS)

# GNU make supports exporting all variables by «export» without parameters.
# However, the environment gets quite big, and some programs have problems
# with that.

export NO_SVN_TESTS

check: common-cmds.h
if sparse; \
then \
for i in *.c */*.c; \
do \
sparse $(ALL_CFLAGS) $(SPARSE_FLAGS) $$i || exit; \
done; \
else \
echo 2>&1 «Did you mean ‘make test’?»; \
exit 1; \
fi

remove-dashes:
./fixup-builtins $(BUILT_INS) $(PROGRAMS) $(SCRIPTS)

### Installation rules

ifneq ($(filter /%,$(firstword $(template_dir))),)
template_instdir = $(template_dir)
else
template_instdir = $(prefix)/$(template_dir)
endif
export template_instdir

ifneq ($(filter /%,$(firstword $(perfexecdir))),)
perfexec_instdir = $(perfexecdir)
else
perfexec_instdir = $(prefix)/$(perfexecdir)
endif
perfexec_instdir_SQ = $(subst ‘,’\»,$(perfexec_instdir))
export perfexec_instdir

install: all
$(INSTALL) -d -m 755 ‘$(DESTDIR_SQ)$(bindir_SQ)’
$(INSTALL) perf$X ‘$(DESTDIR_SQ)$(bindir_SQ)’
ifdef BUILT_INS
$(INSTALL) -d -m 755 ‘$(DESTDIR_SQ)$(perfexec_instdir_SQ)’
$(INSTALL) $(BUILT_INS) ‘$(DESTDIR_SQ)$(perfexec_instdir_SQ)’
ifneq (,$X)
$(foreach p,$(patsubst %$X,%,$(filter %$X,$(ALL_PROGRAMS) $(BUILT_INS) perf$X)), $(RM) ‘$(DESTDIR_SQ)$(perfexec_instdir_SQ)/$p’;)
endif
endif

install-doc:
$(MAKE) -C Documentation install

install-man:
$(MAKE) -C Documentation install-man

install-html:
$(MAKE) -C Documentation install-html

install-info:
$(MAKE) -C Documentation install-info

install-pdf:
$(MAKE) -C Documentation install-pdf

quick-install-doc:
$(MAKE) -C Documentation quick-install

quick-install-man:
$(MAKE) -C Documentation quick-install-man

quick-install-html:
$(MAKE) -C Documentation quick-install-html

### Maintainer’s dist rules
#
# None right now
#
#
# perf.spec: perf.spec.in
# sed -e ’s/@@VERSION@@/$(PERF_VERSION)/g’ < $< > $@+
# mv $@+ $@
#
# PERF_TARNAME=perf-$(PERF_VERSION)
# dist: perf.spec perf-archive$(X) configure
# ./perf-archive –format=tar \
# –prefix=$(PERF_TARNAME)/ HEAD^{tree} > $(PERF_TARNAME).tar
# @mkdir -p $(PERF_TARNAME)
# @cp perf.spec configure $(PERF_TARNAME)
# @echo $(PERF_VERSION) > $(PERF_TARNAME)/version
# $(TAR) rf $(PERF_TARNAME).tar \
# $(PERF_TARNAME)/perf.spec \
# $(PERF_TARNAME)/configure \
# $(PERF_TARNAME)/version
# @$(RM) -r $(PERF_TARNAME)
# gzip -f -9 $(PERF_TARNAME).tar
#
# htmldocs = perf-htmldocs-$(PERF_VERSION)
# manpages = perf-manpages-$(PERF_VERSION)
# dist-doc:
# $(RM) -r .doc-tmp-dir
# mkdir .doc-tmp-dir
# $(MAKE) -C Documentation WEBDOC_DEST=../.doc-tmp-dir install-webdoc
# cd .doc-tmp-dir && $(TAR) cf ../$(htmldocs).tar .
# gzip -n -9 -f $(htmldocs).tar
# :
# $(RM) -r .doc-tmp-dir
# mkdir -p .doc-tmp-dir/man1 .doc-tmp-dir/man5 .doc-tmp-dir/man7
# $(MAKE) -C Documentation DESTDIR=./ \
# man1dir=../.doc-tmp-dir/man1 \
# man5dir=../.doc-tmp-dir/man5 \
# man7dir=../.doc-tmp-dir/man7 \
# install
# cd .doc-tmp-dir && $(TAR) cf ../$(manpages).tar .
# gzip -n -9 -f $(manpages).tar
# $(RM) -r .doc-tmp-dir
#
# rpm: dist
# $(RPMBUILD) -ta $(PERF_TARNAME).tar.gz

### Cleaning rules

distclean: clean
# $(RM) configure

clean:
$(RM) *.o */*.o $(LIB_FILE)
$(RM) $(ALL_PROGRAMS) $(BUILT_INS) perf$X
$(RM) $(TEST_PROGRAMS)
$(RM) *.spec *.pyc *.pyo */*.pyc */*.pyo common-cmds.h TAGS tags cscope*
$(RM) -r autom4te.cache
$(RM) config.log config.mak.autogen config.mak.append config.status config.cache
$(RM) -r $(PERF_TARNAME) .doc-tmp-dir
$(RM) $(PERF_TARNAME).tar.gz perf-core_$(PERF_VERSION)-*.tar.gz
$(RM) $(htmldocs).tar.gz $(manpages).tar.gz
$(MAKE) -C Documentation/ clean
$(RM) PERF-VERSION-FILE PERF-CFLAGS PERF-BUILD-OPTIONS

.PHONY: all install clean strip
.PHONY: shell_compatibility_test please_set_SHELL_PATH_to_a_more_modern_shell
.PHONY: .FORCE-PERF-VERSION-FILE TAGS tags cscope .FORCE-PERF-CFLAGS
.PHONY: .FORCE-PERF-BUILD-OPTIONS

### Make sure built-ins do not have dups and listed in perf.c
#
check-builtins::
./check-builtins.sh

### Test suite coverage testing
#
# None right now
#
# .PHONY: coverage coverage-clean coverage-build coverage-report
#
# coverage:
# $(MAKE) coverage-build
# $(MAKE) coverage-report
#
# coverage-clean:
# rm -f *.gcda *.gcno
#
# COVERAGE_CFLAGS = $(CFLAGS) -O0 -ftest-coverage -fprofile-arcs
# COVERAGE_LDFLAGS = $(CFLAGS) -O0 -lgcov
#
# coverage-build: coverage-clean
# $(MAKE) CFLAGS=»$(COVERAGE_CFLAGS)» LDFLAGS=»$(COVERAGE_LDFLAGS)» all
# $(MAKE) CFLAGS=»$(COVERAGE_CFLAGS)» LDFLAGS=»$(COVERAGE_LDFLAGS)» \
# -j1 test
#
# coverage-report:
# gcov -b *.c */*.c
# grep ‘^function.*called 0 ‘ *.c.gcov */*.c.gcov \
# | sed -e ’s/\([^:]*\)\.gcov: *function \([^ ]*\) called.*/\1: \2/’ \
# | tee coverage-untested-functions

66996ec: Sync with 1.6.2.4

Here is an (incomplete!) list of main contributors to those files
in util/* and elsewhere:

Alex Riesen
Christian Couder
Dmitry Potapov
Jeff King
Johannes Schindelin
Johannes Sixt
Junio C Hamano
Linus Torvalds
Matthias Kestenholz
Michal Ostrowski
Miklos Vajna
Petr Baudis
Pierre Habouzit
René Scharfe
Samuel Tardieu
Shawn O. Pearce
Steffen Prohaska
Steve Haslam

Thanks guys!

The full history of the files can be found in the upstream Git commits.

66996ec: Sync with 1.6.2.4

Here is an (incomplete!) list of main contributors to those files
in util/* and elsewhere:

Alex Riesen
Christian Couder
Dmitry Potapov
Jeff King
Johannes Schindelin
Johannes Sixt
Junio C Hamano
Linus Torvalds
Matthias Kestenholz
Michal Ostrowski
Miklos Vajna
Petr Baudis
Pierre Habouzit
René Scharfe
Samuel Tardieu
Shawn O. Pearce
Steffen Prohaska
Steve Haslam

Thanks guys!

The full history of the files can be found in the upstream Git commits.

#include «util/util.h»
#include «util/strbuf.h»

extern const char perf_version_string[];
extern const char perf_usage_string[];
extern const char perf_more_info_string[];

extern void list_common_cmds_help(void);
extern const char *help_unknown_cmd(const char *cmd);
extern void prune_packed_objects(int);
extern int read_line_with_nul(char *buf, int size, FILE *file);
extern int check_pager_config(const char *cmd);

extern int cmd_annotate(int argc, const char **argv, const char *prefix);
extern int cmd_help(int argc, const char **argv, const char *prefix);
extern int cmd_sched(int argc, const char **argv, const char *prefix);
extern int cmd_list(int argc, const char **argv, const char *prefix);
extern int cmd_record(int argc, const char **argv, const char *prefix);
extern int cmd_report(int argc, const char **argv, const char *prefix);
extern int cmd_stat(int argc, const char **argv, const char *prefix);
extern int cmd_timechart(int argc, const char **argv, const char *prefix);
extern int cmd_top(int argc, const char **argv, const char *prefix);
extern int cmd_trace(int argc, const char **argv, const char *prefix);
extern int cmd_version(int argc, const char **argv, const char *prefix);

#endif

$ perf stat ~/hackbench 10
Time: 0.104

Performance counter stats for ‘/home/mingo/hackbench’:

1255.538611 task clock ticks # 10.143 CPU utilization factor
54011 context switches # 0.043 M/sec
385 CPU migrations # 0.000 M/sec
17755 pagefaults # 0.014 M/sec
3808323185 CPU cycles # 3033.219 M/sec
1575111190 instructions # 1254.530 M/sec
17367895 cache references # 13.833 M/sec
7674421 cache misses # 6.112 M/sec

Wall-clock time elapsed: 123.786620 msecs

*
* Copyright (C) 2008, Red Hat Inc, Ingo Molnar
*
* Improvements and fixes by:
*
* Arjan van de Ven
* Yanmin Zhang
* Wu Fengguang
* Mike Galbraith
* Paul Mackerras * Jaswinder Singh Rajput
*
* Released under the GPL v2. (and only v2, not any later version)
*/

#include «perf.h»
#include «builtin.h»
#include «util/util.h»
#include «util/parse-options.h»
#include «util/parse-events.h»
#include «util/event.h»
#include «util/debug.h»

#include
#include

static struct perf_event_attr default_attrs[] = {

{ .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_TASK_CLOCK },
{ .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CONTEXT_SWITCHES},
{ .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CPU_MIGRATIONS },
{ .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_PAGE_FAULTS },

{ .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CPU_CYCLES },
{ .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_INSTRUCTIONS },
{ .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CACHE_REFERENCES},
{ .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CACHE_MISSES },

};

static int system_wide = 0;
static unsigned int nr_cpus = 0;
static int run_idx = 0;

static int run_count = 1;
static int inherit = 1;
static int scale = 1;
static pid_t target_pid = -1;
static pid_t child_pid = -1;
static int null_run = 0;

static int fd[MAX_NR_CPUS][MAX_COUNTERS];

static int event_scaled[MAX_COUNTERS];

struct stats
{
double n, mean, M2;
};

static void update_stats(struct stats *stats, u64 val)
{
double delta;

stats->n++;
delta = val – stats->mean;
stats->mean += delta / stats->n;
stats->M2 += delta*(val – stats->mean);
}

static double avg_stats(struct stats *stats)
{
return stats->mean;
}

/*
* http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
*
* (\Sum n_i^2) – ((\Sum n_i)^2)/n
* s^2 = ——————————-
* n – 1
*
* http://en.wikipedia.org/wiki/Stddev
*
* The std dev of the mean is related to the std dev by:
*
* s
* s_mean = ——-
* sqrt(n)
*
*/
static double stddev_stats(struct stats *stats)
{
double variance = stats->M2 / (stats->n – 1);
double variance_mean = variance / stats->n;

return sqrt(variance_mean);
}

struct stats event_res_stats[MAX_COUNTERS][3];
struct stats runtime_nsecs_stats;
struct stats walltime_nsecs_stats;
struct stats runtime_cycles_stats;

#define MATCH_EVENT(t, c, counter) \
(attrs[counter].type == PERF_TYPE_##t && \
attrs[counter].config == PERF_COUNT_##c)

#define ERR_PERF_OPEN \
«Error: counter %d, sys_perf_event_open() syscall returned with %d (%s)\n»

static void create_perf_stat_counter(int counter, int pid)
{
struct perf_event_attr *attr = attrs + counter;

if (scale)
attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
PERF_FORMAT_TOTAL_TIME_RUNNING;

if (system_wide) {
unsigned int cpu;

for (cpu = 0; cpu < nr_cpus; cpu++) {
fd[cpu][counter] = sys_perf_event_open(attr, -1, cpu, -1, 0);
if (fd[cpu][counter] < 0 && verbose)
fprintf(stderr, ERR_PERF_OPEN, counter,
fd[cpu][counter], strerror(errno));
}
} else {
attr->inherit = inherit;
attr->disabled = 1;
attr->enable_on_exec = 1;

fd[0][counter] = sys_perf_event_open(attr, pid, -1, -1, 0);
if (fd[0][counter] < 0 && verbose)
fprintf(stderr, ERR_PERF_OPEN, counter,
fd[0][counter], strerror(errno));
}
}

/*
* Does the counter have nsecs as a unit?
*/
static inline int nsec_counter(int counter)
{
if (MATCH_EVENT(SOFTWARE, SW_CPU_CLOCK, counter) ||
MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter))
return 1;

return 0;
}

/*
* Read out the results of a single counter:
*/
static void read_counter(int counter)
{
u64 count[3], single_count[3];
unsigned int cpu;
size_t res, nv;
int scaled;
int i;

count[0] = count[1] = count[2] = 0;

nv = scale ? 3 : 1;
for (cpu = 0; cpu < nr_cpus; cpu++) {
if (fd[cpu][counter] < 0)
continue;

res = read(fd[cpu][counter], single_count, nv * sizeof(u64));
assert(res == nv * sizeof(u64));

close(fd[cpu][counter]);
fd[cpu][counter] = -1;

count[0] += single_count[0];
if (scale) {
count[1] += single_count[1];
count[2] += single_count[2];
}
}

scaled = 0;
if (scale) {
if (count[2] == 0) {
event_scaled[counter] = -1;
count[0] = 0;
return;
}

if (count[2] < count[1]) {
event_scaled[counter] = 1;
count[0] = (unsigned long long)
((double)count[0] * count[1] / count[2] + 0.5);
}
}

for (i = 0; i < 3; i++)
update_stats(&event_res_stats[counter][i], count[i]);

if (verbose) {
fprintf(stderr, "%s: %Ld %Ld %Ld\n", event_name(counter),
count[0], count[1], count[2]);
}

/*
* Save the full runtime - to allow normalization during printout:
*/
if (MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter))
update_stats(&runtime_nsecs_stats, count[0]);
if (MATCH_EVENT(HARDWARE, HW_CPU_CYCLES, counter))
update_stats(&runtime_cycles_stats, count[0]);
}

static int run_perf_stat(int argc __used, const char **argv)
{
unsigned long long t0, t1;
int status = 0;
int counter;
int pid;
int child_ready_pipe[2], go_pipe[2];
char buf;

if (!system_wide)
nr_cpus = 1;

if (pipe(child_ready_pipe) < 0 || pipe(go_pipe) < 0) {
perror("failed to create pipes");
exit(1);
}

if ((pid = fork()) < 0)
perror("failed to fork");

if (!pid) {
close(child_ready_pipe[0]);
close(go_pipe[1]);
fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);

/*
* Do a dummy execvp to get the PLT entry resolved,
* so we avoid the resolver overhead on the real
* execvp call.
*/
execvp("", (char **)argv);

/*
* Tell the parent we're ready to go
*/
close(child_ready_pipe[1]);

/*
* Wait until the parent tells us to go.
*/
if (read(go_pipe[0], &buf, 1) == -1)
perror("unable to read pipe");

execvp(argv[0], (char **)argv);

perror(argv[0]);
exit(-1);
}

child_pid = pid;

/*
* Wait for the child to be ready to exec.
*/
close(child_ready_pipe[1]);
close(go_pipe[0]);
if (read(child_ready_pipe[0], &buf, 1) == -1)
perror("unable to read pipe");
close(child_ready_pipe[0]);

for (counter = 0; counter < nr_counters; counter++)
create_perf_stat_counter(counter, pid);

/*
* Enable counters and exec the command:
*/
t0 = rdclock();

close(go_pipe[1]);
wait(&status);

t1 = rdclock();

update_stats(&walltime_nsecs_stats, t1 - t0);

for (counter = 0; counter < nr_counters; counter++)
read_counter(counter);

return WEXITSTATUS(status);
}

static void print_noise(int counter, double avg)
{
if (run_count == 1)
return;

fprintf(stderr, " ( +- %7.3f%% )",
100 * stddev_stats(&event_res_stats[counter][0]) / avg);
}

static void nsec_printout(int counter, double avg)
{
double msecs = avg / 1e6;

fprintf(stderr, " %14.6f %-24s", msecs, event_name(counter));

if (MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter)) {
fprintf(stderr, " # %10.3f CPUs ",
avg / avg_stats(&walltime_nsecs_stats));
}
}

static void abs_printout(int counter, double avg)
{
double total, ratio = 0.0;

fprintf(stderr, " %14.0f %-24s", avg, event_name(counter));

if (MATCH_EVENT(HARDWARE, HW_INSTRUCTIONS, counter)) {
total = avg_stats(&runtime_cycles_stats);

if (total)
ratio = avg / total;

fprintf(stderr, " # %10.3f IPC ", ratio);
} else {
total = avg_stats(&runtime_nsecs_stats);

if (total)
ratio = 1000.0 * avg / total;

fprintf(stderr, " # %10.3f M/sec", ratio);
}
}

/*
* Print out the results of a single counter:
*/
static void print_counter(int counter)
{
double avg = avg_stats(&event_res_stats[counter][0]);
int scaled = event_scaled[counter];

if (scaled == -1) {
fprintf(stderr, " %14s %-24s\n",
"«, event_name(counter));
return;
}

if (nsec_counter(counter))
nsec_printout(counter, avg);
else
abs_printout(counter, avg);

print_noise(counter, avg);

if (scaled) {
double avg_enabled, avg_running;

avg_enabled = avg_stats(&event_res_stats[counter][1]);
avg_running = avg_stats(&event_res_stats[counter][2]);

fprintf(stderr, » (scaled from %.2f%%)»,
100 * avg_running / avg_enabled);
}

fprintf(stderr, «\n»);
}

static void print_stat(int argc, const char **argv)
{
int i, counter;

fflush(stdout);

fprintf(stderr, «\n»);
fprintf(stderr, » Performance counter stats for \’%s», argv[0]);

for (i = 1; i < argc; i++)
fprintf(stderr, " %s", argv[i]);

fprintf(stderr, "\'");
if (run_count > 1)
fprintf(stderr, » (%d runs)», run_count);
fprintf(stderr, «:\n\n»);

for (counter = 0; counter < nr_counters; counter++)
print_counter(counter);

fprintf(stderr, "\n");
fprintf(stderr, " %14.9f seconds time elapsed",
avg_stats(&walltime_nsecs_stats)/1e9);
if (run_count > 1) {
fprintf(stderr, » ( +- %7.3f%% )»,
100*stddev_stats(&walltime_nsecs_stats) /
avg_stats(&walltime_nsecs_stats));
}
fprintf(stderr, «\n\n»);
}

static volatile int signr = -1;

static void skip_signal(int signo)
{
signr = signo;
}

static void sig_atexit(void)
{
if (child_pid != -1)
kill(child_pid, SIGTERM);

if (signr == -1)
return;

signal(signr, SIG_DFL);
kill(getpid(), signr);
}

static const char * const stat_usage[] = {
«perf stat [] «,
NULL
};

static const struct option options[] = {
OPT_CALLBACK(’e', «event», NULL, «event»,
«event selector. use ‘perf list’ to list available events»,
parse_events),
OPT_BOOLEAN(’i', «inherit», &inherit,
«child tasks inherit counters»),
OPT_INTEGER(’p', «pid», &target_pid,
«stat events on existing pid»),
OPT_BOOLEAN(’a', «all-cpus», &system_wide,
«system-wide collection from all CPUs»),
OPT_BOOLEAN(’c', «scale», &scale,
«scale/normalize counters»),
OPT_BOOLEAN(’v', «verbose», &verbose,
«be more verbose (show counter open errors, etc)»),
OPT_INTEGER(’r', «repeat», &run_count,
«repeat command and print average + stddev (max: 100)»),
OPT_BOOLEAN(’n', «null», &null_run,
«null run – dont start any counters»),
OPT_END()
};

int cmd_stat(int argc, const char **argv, const char *prefix __used)
{
int status;

argc = parse_options(argc, argv, options, stat_usage,
PARSE_OPT_STOP_AT_NON_OPTION);
if (!argc)
usage_with_options(stat_usage, options);
if (run_count <= 0)
usage_with_options(stat_usage, options);

/* Set attrs and nr_counters if no event is selected and !null_run */
if (!null_run && !nr_counters) {
memcpy(attrs, default_attrs, sizeof(default_attrs));
nr_counters = ARRAY_SIZE(default_attrs);
}

nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
assert(nr_cpus <= MAX_NR_CPUS);
assert((int)nr_cpus >= 0);

/*
* We dont want to block the signals – that would cause
* child tasks to inherit that and Ctrl-C would not work.
* What we want is for Ctrl-C to work in the exec()-ed
* task, but being ignored by perf stat itself:
*/
atexit(sig_atexit);
signal(SIGINT, skip_signal);
signal(SIGALRM, skip_signal);
signal(SIGABRT, skip_signal);

status = 0;
for (run_idx = 0; run_idx < run_count; run_idx++) {
if (run_count != 1 && verbose)
fprintf(stderr, «[ perf stat: executing run #%d ... ]\n», run_idx + 1);
status = run_perf_stat(argc, argv);
}

print_stat(argc, argv);

return status;
}

#include «util/util.h»
#include «util/cache.h»
#include «util/symbol.h»
#include «util/thread.h»
#include «util/header.h»

#include «util/parse-options.h»
#include «util/trace-event.h»

#include «util/debug.h»

#include
#include

#include
#include #include

static char const *input_name = «perf.data»;
static int input;
static unsigned long page_size;
static unsigned long mmap_window = 32;

static unsigned long total_comm = 0;

static struct rb_root threads;
static struct thread *last_match;

static struct perf_header *header;
static u64 sample_type;

static char default_sort_order[] = «avg, max, switch, runtime»;
static char *sort_order = default_sort_order;

#define PR_SET_NAME 15 /* Set process name */
#define MAX_CPUS 4096

#define BUG_ON(x) assert(!(x))

static u64 run_measurement_overhead;
static u64 sleep_measurement_overhead;

#define COMM_LEN 20
#define SYM_LEN 129

#define MAX_PID 65536

static unsigned long nr_tasks;

struct sched_atom;

struct task_desc {
unsigned long nr;
unsigned long pid;
char comm[COMM_LEN];

unsigned long nr_events;
unsigned long curr_event;
struct sched_atom **atoms;

pthread_t thread;
sem_t sleep_sem;

sem_t ready_for_work;
sem_t work_done_sem;

u64 cpu_usage;
};

enum sched_event_type {
SCHED_EVENT_RUN,
SCHED_EVENT_SLEEP,
SCHED_EVENT_WAKEUP,
};

struct sched_atom {
enum sched_event_type type;
u64 timestamp;
u64 duration;
unsigned long nr;
int specific_wait;
sem_t *wait_sem;
struct task_desc *wakee;
};

static struct task_desc *pid_to_task[MAX_PID];

static struct task_desc **tasks;

static pthread_mutex_t start_work_mutex = PTHREAD_MUTEX_INITIALIZER;
static u64 start_time;

static pthread_mutex_t work_done_wait_mutex = PTHREAD_MUTEX_INITIALIZER;

static unsigned long nr_run_events;
static unsigned long nr_sleep_events;
static unsigned long nr_wakeup_events;

static unsigned long nr_sleep_corrections;
static unsigned long nr_run_events_optimized;

static unsigned long targetless_wakeups;
static unsigned long multitarget_wakeups;

static u64 cpu_usage;
static u64 runavg_cpu_usage;
static u64 parent_cpu_usage;
static u64 runavg_parent_cpu_usage;

static unsigned long nr_runs;
static u64 sum_runtime;
static u64 sum_fluct;
static u64 run_avg;

static unsigned long replay_repeat = 10;
static unsigned long nr_timestamps;
static unsigned long nr_unordered_timestamps;
static unsigned long nr_state_machine_bugs;
static unsigned long nr_context_switch_bugs;
static unsigned long nr_events;
static unsigned long nr_lost_chunks;
static unsigned long nr_lost_events;

#define TASK_STATE_TO_CHAR_STR «RSDTtZX»

enum thread_state {
THREAD_SLEEPING = 0,
THREAD_WAIT_CPU,
THREAD_SCHED_IN,
THREAD_IGNORE
};

struct work_atom {
struct list_head list;
enum thread_state state;
u64 sched_out_time;
u64 wake_up_time;
u64 sched_in_time;
u64 runtime;
};

struct work_atoms {
struct list_head work_list;
struct thread *thread;
struct rb_node node;
u64 max_lat;
u64 total_lat;
u64 nb_atoms;
u64 total_runtime;
};

typedef int (*sort_fn_t)(struct work_atoms *, struct work_atoms *);

static struct rb_root atom_root, sorted_atom_root;

static u64 all_runtime;
static u64 all_count;

static u64 get_nsecs(void)
{
struct timespec ts;

clock_gettime(CLOCK_MONOTONIC, &ts);

return ts.tv_sec * 1000000000ULL + ts.tv_nsec;
}

static void burn_nsecs(u64 nsecs)
{
u64 T0 = get_nsecs(), T1;

do {
T1 = get_nsecs();
} while (T1 + run_measurement_overhead < T0 + nsecs);
}

static void sleep_nsecs(u64 nsecs)
{
struct timespec ts;

ts.tv_nsec = nsecs % 999999999;
ts.tv_sec = nsecs / 999999999;

nanosleep(&ts, NULL);
}

static void calibrate_run_measurement_overhead(void)
{
u64 T0, T1, delta, min_delta = 1000000000ULL;
int i;

for (i = 0; i < 10; i++) {
T0 = get_nsecs();
burn_nsecs(0);
T1 = get_nsecs();
delta = T1-T0;
min_delta = min(min_delta, delta);
}
run_measurement_overhead = min_delta;

printf("run measurement overhead: %Ld nsecs\n", min_delta);
}

static void calibrate_sleep_measurement_overhead(void)
{
u64 T0, T1, delta, min_delta = 1000000000ULL;
int i;

for (i = 0; i < 10; i++) {
T0 = get_nsecs();
sleep_nsecs(10000);
T1 = get_nsecs();
delta = T1-T0;
min_delta = min(min_delta, delta);
}
min_delta -= 10000;
sleep_measurement_overhead = min_delta;

printf("sleep measurement overhead: %Ld nsecs\n", min_delta);
}

static struct sched_atom *
get_new_event(struct task_desc *task, u64 timestamp)
{
struct sched_atom *event = calloc(1, sizeof(*event));
unsigned long idx = task->nr_events;
size_t size;

event->timestamp = timestamp;
event->nr = idx;

task->nr_events++;
size = sizeof(struct sched_atom *) * task->nr_events;
task->atoms = realloc(task->atoms, size);
BUG_ON(!task->atoms);

task->atoms[idx] = event;

return event;
}

static struct sched_atom *last_event(struct task_desc *task)
{
if (!task->nr_events)
return NULL;

return task->atoms[task->nr_events - 1];
}

static void
add_sched_event_run(struct task_desc *task, u64 timestamp, u64 duration)
{
struct sched_atom *event, *curr_event = last_event(task);

/*
* optimize an existing RUN event by merging this one
* to it:
*/
if (curr_event && curr_event->type == SCHED_EVENT_RUN) {
nr_run_events_optimized++;
curr_event->duration += duration;
return;
}

event = get_new_event(task, timestamp);

event->type = SCHED_EVENT_RUN;
event->duration = duration;

nr_run_events++;
}

static void
add_sched_event_wakeup(struct task_desc *task, u64 timestamp,
struct task_desc *wakee)
{
struct sched_atom *event, *wakee_event;

event = get_new_event(task, timestamp);
event->type = SCHED_EVENT_WAKEUP;
event->wakee = wakee;

wakee_event = last_event(wakee);
if (!wakee_event || wakee_event->type != SCHED_EVENT_SLEEP) {
targetless_wakeups++;
return;
}
if (wakee_event->wait_sem) {
multitarget_wakeups++;
return;
}

wakee_event->wait_sem = calloc(1, sizeof(*wakee_event->wait_sem));
sem_init(wakee_event->wait_sem, 0, 0);
wakee_event->specific_wait = 1;
event->wait_sem = wakee_event->wait_sem;

nr_wakeup_events++;
}

static void
add_sched_event_sleep(struct task_desc *task, u64 timestamp,
u64 task_state __used)
{
struct sched_atom *event = get_new_event(task, timestamp);

event->type = SCHED_EVENT_SLEEP;

nr_sleep_events++;
}

static struct task_desc *register_pid(unsigned long pid, const char *comm)
{
struct task_desc *task;

BUG_ON(pid >= MAX_PID);

task = pid_to_task[pid];

if (task)
return task;

task = calloc(1, sizeof(*task));
task->pid = pid;
task->nr = nr_tasks;
strcpy(task->comm, comm);
/*
* every task starts in sleeping state – this gets ignored
* if there’s no wakeup pointing to this sleep state:
*/
add_sched_event_sleep(task, 0, 0);

pid_to_task[pid] = task;
nr_tasks++;
tasks = realloc(tasks, nr_tasks*sizeof(struct task_task *));
BUG_ON(!tasks);
tasks[task->nr] = task;

if (verbose)
printf(»registered task #%ld, PID %ld (%s)\n», nr_tasks, pid, comm);

return task;
}

static void print_task_traces(void)
{
struct task_desc *task;
unsigned long i;

for (i = 0; i < nr_tasks; i++) {
task = tasks[i];
printf("task %6ld (%20s:%10ld), nr_events: %ld\n",
task->nr, task->comm, task->pid, task->nr_events);
}
}

static void add_cross_task_wakeups(void)
{
struct task_desc *task1, *task2;
unsigned long i, j;

for (i = 0; i < nr_tasks; i++) {
task1 = tasks[i];
j = i + 1;
if (j == nr_tasks)
j = 0;
task2 = tasks[j];
add_sched_event_wakeup(task1, 0, task2);
}
}

static void
process_sched_event(struct task_desc *this_task __used, struct sched_atom *atom)
{
int ret = 0;
u64 now;
long long delta;

now = get_nsecs();
delta = start_time + atom->timestamp – now;

switch (atom->type) {
case SCHED_EVENT_RUN:
burn_nsecs(atom->duration);
break;
case SCHED_EVENT_SLEEP:
if (atom->wait_sem)
ret = sem_wait(atom->wait_sem);
BUG_ON(ret);
break;
case SCHED_EVENT_WAKEUP:
if (atom->wait_sem)
ret = sem_post(atom->wait_sem);
BUG_ON(ret);
break;
default:
BUG_ON(1);
}
}

static u64 get_cpu_usage_nsec_parent(void)
{
struct rusage ru;
u64 sum;
int err;

err = getrusage(RUSAGE_SELF, &ru);
BUG_ON(err);

sum = ru.ru_utime.tv_sec*1e9 + ru.ru_utime.tv_usec*1e3;
sum += ru.ru_stime.tv_sec*1e9 + ru.ru_stime.tv_usec*1e3;

return sum;
}

static u64 get_cpu_usage_nsec_self(void)
{
char filename [] = «/proc/1234567890/sched»;
unsigned long msecs, nsecs;
char *line = NULL;
u64 total = 0;
size_t len = 0;
ssize_t chars;
FILE *file;
int ret;

sprintf(filename, «/proc/%d/sched», getpid());
file = fopen(filename, «r»);
BUG_ON(!file);

while ((chars = getline(&line, &len, file)) != -1) {
ret = sscanf(line, «se.sum_exec_runtime : %ld.%06ld\n»,
&msecs, &nsecs);
if (ret == 2) {
total = msecs*1e6 + nsecs;
break;
}
}
if (line)
free(line);
fclose(file);

return total;
}

static void *thread_func(void *ctx)
{
struct task_desc *this_task = ctx;
u64 cpu_usage_0, cpu_usage_1;
unsigned long i, ret;
char comm2[22];

sprintf(comm2, «:%s», this_task->comm);
prctl(PR_SET_NAME, comm2);

again:
ret = sem_post(&this_task->ready_for_work);
BUG_ON(ret);
ret = pthread_mutex_lock(&start_work_mutex);
BUG_ON(ret);
ret = pthread_mutex_unlock(&start_work_mutex);
BUG_ON(ret);

cpu_usage_0 = get_cpu_usage_nsec_self();

for (i = 0; i < this_task->nr_events; i++) {
this_task->curr_event = i;
process_sched_event(this_task, this_task->atoms[i]);
}

cpu_usage_1 = get_cpu_usage_nsec_self();
this_task->cpu_usage = cpu_usage_1 – cpu_usage_0;

ret = sem_post(&this_task->work_done_sem);
BUG_ON(ret);

ret = pthread_mutex_lock(&work_done_wait_mutex);
BUG_ON(ret);
ret = pthread_mutex_unlock(&work_done_wait_mutex);
BUG_ON(ret);

goto again;
}

static void create_tasks(void)
{
struct task_desc *task;
pthread_attr_t attr;
unsigned long i;
int err;

err = pthread_attr_init(&attr);
BUG_ON(err);
err = pthread_attr_setstacksize(&attr, (size_t)(16*1024));
BUG_ON(err);
err = pthread_mutex_lock(&start_work_mutex);
BUG_ON(err);
err = pthread_mutex_lock(&work_done_wait_mutex);
BUG_ON(err);
for (i = 0; i < nr_tasks; i++) {
task = tasks[i];
sem_init(&task->sleep_sem, 0, 0);
sem_init(&task->ready_for_work, 0, 0);
sem_init(&task->work_done_sem, 0, 0);
task->curr_event = 0;
err = pthread_create(&task->thread, &attr, thread_func, task);
BUG_ON(err);
}
}

static void wait_for_tasks(void)
{
u64 cpu_usage_0, cpu_usage_1;
struct task_desc *task;
unsigned long i, ret;

start_time = get_nsecs();
cpu_usage = 0;
pthread_mutex_unlock(&work_done_wait_mutex);

for (i = 0; i < nr_tasks; i++) {
task = tasks[i];
ret = sem_wait(&task->ready_for_work);
BUG_ON(ret);
sem_init(&task->ready_for_work, 0, 0);
}
ret = pthread_mutex_lock(&work_done_wait_mutex);
BUG_ON(ret);

cpu_usage_0 = get_cpu_usage_nsec_parent();

pthread_mutex_unlock(&start_work_mutex);

for (i = 0; i < nr_tasks; i++) {
task = tasks[i];
ret = sem_wait(&task->work_done_sem);
BUG_ON(ret);
sem_init(&task->work_done_sem, 0, 0);
cpu_usage += task->cpu_usage;
task->cpu_usage = 0;
}

cpu_usage_1 = get_cpu_usage_nsec_parent();
if (!runavg_cpu_usage)
runavg_cpu_usage = cpu_usage;
runavg_cpu_usage = (runavg_cpu_usage*9 + cpu_usage)/10;

parent_cpu_usage = cpu_usage_1 – cpu_usage_0;
if (!runavg_parent_cpu_usage)
runavg_parent_cpu_usage = parent_cpu_usage;
runavg_parent_cpu_usage = (runavg_parent_cpu_usage*9 +
parent_cpu_usage)/10;

ret = pthread_mutex_lock(&start_work_mutex);
BUG_ON(ret);

for (i = 0; i < nr_tasks; i++) {
task = tasks[i];
sem_init(&task->sleep_sem, 0, 0);
task->curr_event = 0;
}
}

static void run_one_test(void)
{
u64 T0, T1, delta, avg_delta, fluct, std_dev;

T0 = get_nsecs();
wait_for_tasks();
T1 = get_nsecs();

delta = T1 – T0;
sum_runtime += delta;
nr_runs++;

avg_delta = sum_runtime / nr_runs;
if (delta < avg_delta)
fluct = avg_delta - delta;
else
fluct = delta - avg_delta;
sum_fluct += fluct;
std_dev = sum_fluct / nr_runs / sqrt(nr_runs);
if (!run_avg)
run_avg = delta;
run_avg = (run_avg*9 + delta)/10;

printf("#%-3ld: %0.3f, ",
nr_runs, (double)delta/1000000.0);

printf("ravg: %0.2f, ",
(double)run_avg/1e6);

printf("cpu: %0.2f / %0.2f",
(double)cpu_usage/1e6, (double)runavg_cpu_usage/1e6);

#if 0
/*
* rusage statistics done by the parent, these are less
* accurate than the sum_exec_runtime based statistics:
*/
printf(" [%0.2f / %0.2f]",
(double)parent_cpu_usage/1e6,
(double)runavg_parent_cpu_usage/1e6);
#endif

printf("\n");

if (nr_sleep_corrections)
printf(" (%ld sleep corrections)\n", nr_sleep_corrections);
nr_sleep_corrections = 0;
}

static void test_calibrations(void)
{
u64 T0, T1;

T0 = get_nsecs();
burn_nsecs(1e6);
T1 = get_nsecs();

printf("the run test took %Ld nsecs\n", T1-T0);

T0 = get_nsecs();
sleep_nsecs(1e6);
T1 = get_nsecs();

printf("the sleep test took %Ld nsecs\n", T1-T0);
}

static int
process_comm_event(event_t *event, unsigned long offset, unsigned long head)
{
struct thread *thread;

thread = threads__findnew(event->comm.pid, &threads, &last_match);

dump_printf(»%p [%p]: perf_event_comm: %s:%d\n»,
(void *)(offset + head),
(void *)(long)(event->header.size),
event->comm.comm, event->comm.pid);

if (thread == NULL ||
thread__set_comm(thread, event->comm.comm)) {
dump_printf(»problem processing perf_event_comm, skipping event.\n»);
return -1;
}
total_comm++;

return 0;
}

struct raw_event_sample {
u32 size;
char data[0];
};

#define FILL_FIELD(ptr, field, event, data) \
ptr.field = (typeof(ptr.field)) raw_field_value(event, #field, data)

#define FILL_ARRAY(ptr, array, event, data) \
do { \
void *__array = raw_field_ptr(event, #array, data); \
memcpy(ptr.array, __array, sizeof(ptr.array)); \
} while(0)

#define FILL_COMMON_FIELDS(ptr, event, data) \
do { \
FILL_FIELD(ptr, common_type, event, data); \
FILL_FIELD(ptr, common_flags, event, data); \
FILL_FIELD(ptr, common_preempt_count, event, data); \
FILL_FIELD(ptr, common_pid, event, data); \
FILL_FIELD(ptr, common_tgid, event, data); \
} while (0)

struct trace_switch_event {
u32 size;

u16 common_type;
u8 common_flags;
u8 common_preempt_count;
u32 common_pid;
u32 common_tgid;

char prev_comm[16];
u32 prev_pid;
u32 prev_prio;
u64 prev_state;
char next_comm[16];
u32 next_pid;
u32 next_prio;
};

struct trace_runtime_event {
u32 size;

u16 common_type;
u8 common_flags;
u8 common_preempt_count;
u32 common_pid;
u32 common_tgid;

char comm[16];
u32 pid;
u64 runtime;
u64 vruntime;
};

struct trace_wakeup_event {
u32 size;

u16 common_type;
u8 common_flags;
u8 common_preempt_count;
u32 common_pid;
u32 common_tgid;

char comm[16];
u32 pid;

u32 prio;
u32 success;
u32 cpu;
};

struct trace_fork_event {
u32 size;

u16 common_type;
u8 common_flags;
u8 common_preempt_count;
u32 common_pid;
u32 common_tgid;

char parent_comm[16];
u32 parent_pid;
char child_comm[16];
u32 child_pid;
};

struct trace_sched_handler {
void (*switch_event)(struct trace_switch_event *,
struct event *,
int cpu,
u64 timestamp,
struct thread *thread);

void (*runtime_event)(struct trace_runtime_event *,
struct event *,
int cpu,
u64 timestamp,
struct thread *thread);

void (*wakeup_event)(struct trace_wakeup_event *,
struct event *,
int cpu,
u64 timestamp,
struct thread *thread);

void (*fork_event)(struct trace_fork_event *,
struct event *,
int cpu,
u64 timestamp,
struct thread *thread);
};

static void
replay_wakeup_event(struct trace_wakeup_event *wakeup_event,
struct event *event,
int cpu __used,
u64 timestamp __used,
struct thread *thread __used)
{
struct task_desc *waker, *wakee;

if (verbose) {
printf(»sched_wakeup event %p\n», event);

printf(» … pid %d woke up %s/%d\n»,
wakeup_event->common_pid,
wakeup_event->comm,
wakeup_event->pid);
}

waker = register_pid(wakeup_event->common_pid, ««);
wakee = register_pid(wakeup_event->pid, wakeup_event->comm);

add_sched_event_wakeup(waker, timestamp, wakee);
}

static u64 cpu_last_switched[MAX_CPUS];

static void
replay_switch_event(struct trace_switch_event *switch_event,
struct event *event,
int cpu,
u64 timestamp,
struct thread *thread __used)
{
struct task_desc *prev, *next;
u64 timestamp0;
s64 delta;

if (verbose)
printf(»sched_switch event %p\n», event);

if (cpu >= MAX_CPUS || cpu < 0)
return;

timestamp0 = cpu_last_switched[cpu];
if (timestamp0)
delta = timestamp - timestamp0;
else
delta = 0;

if (delta < 0)
die("hm, delta: %Ld < 0 ?\n", delta);

if (verbose) {
printf(" ... switch from %s/%d to %s/%d [ran %Ld nsecs]\n",
switch_event->prev_comm, switch_event->prev_pid,
switch_event->next_comm, switch_event->next_pid,
delta);
}

prev = register_pid(switch_event->prev_pid, switch_event->prev_comm);
next = register_pid(switch_event->next_pid, switch_event->next_comm);

cpu_last_switched[cpu] = timestamp;

add_sched_event_run(prev, timestamp, delta);
add_sched_event_sleep(prev, timestamp, switch_event->prev_state);
}

static void
replay_fork_event(struct trace_fork_event *fork_event,
struct event *event,
int cpu __used,
u64 timestamp __used,
struct thread *thread __used)
{
if (verbose) {
printf(»sched_fork event %p\n», event);
printf(»… parent: %s/%d\n», fork_event->parent_comm, fork_event->parent_pid);
printf(»… child: %s/%d\n», fork_event->child_comm, fork_event->child_pid);
}
register_pid(fork_event->parent_pid, fork_event->parent_comm);
register_pid(fork_event->child_pid, fork_event->child_comm);
}

static struct trace_sched_handler replay_ops = {
.wakeup_event = replay_wakeup_event,
.switch_event = replay_switch_event,
.fork_event = replay_fork_event,
};

struct sort_dimension {
const char *name;
sort_fn_t cmp;
struct list_head list;
};

static LIST_HEAD(cmp_pid);

static int
thread_lat_cmp(struct list_head *list, struct work_atoms *l, struct work_atoms *r)
{
struct sort_dimension *sort;
int ret = 0;

BUG_ON(list_empty(list));

list_for_each_entry(sort, list, list) {
ret = sort->cmp(l, r);
if (ret)
return ret;
}

return ret;
}

static struct work_atoms *
thread_atoms_search(struct rb_root *root, struct thread *thread,
struct list_head *sort_list)
{
struct rb_node *node = root->rb_node;
struct work_atoms key = { .thread = thread };

while (node) {
struct work_atoms *atoms;
int cmp;

atoms = container_of(node, struct work_atoms, node);

cmp = thread_lat_cmp(sort_list, &key, atoms);
if (cmp > 0)
node = node->rb_left;
else if (cmp < 0)
node = node->rb_right;
else {
BUG_ON(thread != atoms->thread);
return atoms;
}
}
return NULL;
}

static void
__thread_latency_insert(struct rb_root *root, struct work_atoms *data,
struct list_head *sort_list)
{
struct rb_node **new = &(root->rb_node), *parent = NULL;

while (*new) {
struct work_atoms *this;
int cmp;

this = container_of(*new, struct work_atoms, node);
parent = *new;

cmp = thread_lat_cmp(sort_list, data, this);

if (cmp > 0)
new = &((*new)->rb_left);
else
new = &((*new)->rb_right);
}

rb_link_node(&data->node, parent, new);
rb_insert_color(&data->node, root);
}

static void thread_atoms_insert(struct thread *thread)
{
struct work_atoms *atoms;

atoms = calloc(sizeof(*atoms), 1);
if (!atoms)
die(»No memory»);

atoms->thread = thread;
INIT_LIST_HEAD(&atoms->work_list);
__thread_latency_insert(&atom_root, atoms, &cmp_pid);
}

static void
latency_fork_event(struct trace_fork_event *fork_event __used,
struct event *event __used,
int cpu __used,
u64 timestamp __used,
struct thread *thread __used)
{
/* should insert the newcomer */
}

__used
static char sched_out_state(struct trace_switch_event *switch_event)
{
const char *str = TASK_STATE_TO_CHAR_STR;

return str[switch_event->prev_state];
}

static void
add_sched_out_event(struct work_atoms *atoms,
char run_state,
u64 timestamp)
{
struct work_atom *atom;

atom = calloc(sizeof(*atom), 1);
if (!atom)
die(»Non memory»);

atom->sched_out_time = timestamp;

if (run_state == ‘R’) {
atom->state = THREAD_WAIT_CPU;
atom->wake_up_time = atom->sched_out_time;
}

list_add_tail(&atom->list, &atoms->work_list);
}

static void
add_runtime_event(struct work_atoms *atoms, u64 delta, u64 timestamp __used)
{
struct work_atom *atom;

BUG_ON(list_empty(&atoms->work_list));

atom = list_entry(atoms->work_list.prev, struct work_atom, list);

atom->runtime += delta;
atoms->total_runtime += delta;
}

static void
add_sched_in_event(struct work_atoms *atoms, u64 timestamp)
{
struct work_atom *atom;
u64 delta;

if (list_empty(&atoms->work_list))
return;

atom = list_entry(atoms->work_list.prev, struct work_atom, list);

if (atom->state != THREAD_WAIT_CPU)
return;

if (timestamp < atom->wake_up_time) {
atom->state = THREAD_IGNORE;
return;
}

atom->state = THREAD_SCHED_IN;
atom->sched_in_time = timestamp;

delta = atom->sched_in_time – atom->wake_up_time;
atoms->total_lat += delta;
if (delta > atoms->max_lat)
atoms->max_lat = delta;
atoms->nb_atoms++;
}

static void
latency_switch_event(struct trace_switch_event *switch_event,
struct event *event __used,
int cpu,
u64 timestamp,
struct thread *thread __used)
{
struct work_atoms *out_events, *in_events;
struct thread *sched_out, *sched_in;
u64 timestamp0;
s64 delta;

BUG_ON(cpu >= MAX_CPUS || cpu < 0);

timestamp0 = cpu_last_switched[cpu];
cpu_last_switched[cpu] = timestamp;
if (timestamp0)
delta = timestamp - timestamp0;
else
delta = 0;

if (delta < 0)
die("hm, delta: %Ld < 0 ?\n", delta);

sched_out = threads__findnew(switch_event->prev_pid, &threads, &last_match);
sched_in = threads__findnew(switch_event->next_pid, &threads, &last_match);

out_events = thread_atoms_search(&atom_root, sched_out, &cmp_pid);
if (!out_events) {
thread_atoms_insert(sched_out);
out_events = thread_atoms_search(&atom_root, sched_out, &cmp_pid);
if (!out_events)
die(»out-event: Internal tree error»);
}
add_sched_out_event(out_events, sched_out_state(switch_event), timestamp);

in_events = thread_atoms_search(&atom_root, sched_in, &cmp_pid);
if (!in_events) {
thread_atoms_insert(sched_in);
in_events = thread_atoms_search(&atom_root, sched_in, &cmp_pid);
if (!in_events)
die(»in-event: Internal tree error»);
/*
* Take came in we have not heard about yet,
* add in an initial atom in runnable state:
*/
add_sched_out_event(in_events, ‘R’, timestamp);
}
add_sched_in_event(in_events, timestamp);
}

static void
latency_runtime_event(struct trace_runtime_event *runtime_event,
struct event *event __used,
int cpu,
u64 timestamp,
struct thread *this_thread __used)
{
struct work_atoms *atoms;
struct thread *thread;

BUG_ON(cpu >= MAX_CPUS || cpu < 0);

thread = threads__findnew(runtime_event->pid, &threads, &last_match);
atoms = thread_atoms_search(&atom_root, thread, &cmp_pid);
if (!atoms) {
thread_atoms_insert(thread);
atoms = thread_atoms_search(&atom_root, thread, &cmp_pid);
if (!atoms)
die(»in-event: Internal tree error»);
add_sched_out_event(atoms, ‘R’, timestamp);
}

add_runtime_event(atoms, runtime_event->runtime, timestamp);
}

static void
latency_wakeup_event(struct trace_wakeup_event *wakeup_event,
struct event *__event __used,
int cpu __used,
u64 timestamp,
struct thread *thread __used)
{
struct work_atoms *atoms;
struct work_atom *atom;
struct thread *wakee;

/* Note for later, it may be interesting to observe the failing cases */
if (!wakeup_event->success)
return;

wakee = threads__findnew(wakeup_event->pid, &threads, &last_match);
atoms = thread_atoms_search(&atom_root, wakee, &cmp_pid);
if (!atoms) {
thread_atoms_insert(wakee);
atoms = thread_atoms_search(&atom_root, wakee, &cmp_pid);
if (!atoms)
die(»wakeup-event: Internal tree error»);
add_sched_out_event(atoms, ‘S’, timestamp);
}

BUG_ON(list_empty(&atoms->work_list));

atom = list_entry(atoms->work_list.prev, struct work_atom, list);

if (atom->state != THREAD_SLEEPING)
nr_state_machine_bugs++;

nr_timestamps++;
if (atom->sched_out_time > timestamp) {
nr_unordered_timestamps++;
return;
}

atom->state = THREAD_WAIT_CPU;
atom->wake_up_time = timestamp;
}

static struct trace_sched_handler lat_ops = {
.wakeup_event = latency_wakeup_event,
.switch_event = latency_switch_event,
.runtime_event = latency_runtime_event,
.fork_event = latency_fork_event,
};

static void output_lat_thread(struct work_atoms *work_list)
{
int i;
int ret;
u64 avg;

if (!work_list->nb_atoms)
return;
/*
* Ignore idle threads:
*/
if (!strcmp(work_list->thread->comm, «swapper»))
return;

all_runtime += work_list->total_runtime;
all_count += work_list->nb_atoms;

ret = printf(» %s:%d «, work_list->thread->comm, work_list->thread->pid);

for (i = 0; i < 24 - ret; i++)
printf(" ");

avg = work_list->total_lat / work_list->nb_atoms;

printf(»|%11.3f ms |%9llu | avg:%9.3f ms | max:%9.3f ms |\n»,
(double)work_list->total_runtime / 1e6,
work_list->nb_atoms, (double)avg / 1e6,
(double)work_list->max_lat / 1e6);
}

static int pid_cmp(struct work_atoms *l, struct work_atoms *r)
{
if (l->thread->pid < r->thread->pid)
return -1;
if (l->thread->pid > r->thread->pid)
return 1;

return 0;
}

static struct sort_dimension pid_sort_dimension = {
.name = «pid»,
.cmp = pid_cmp,
};

static int avg_cmp(struct work_atoms *l, struct work_atoms *r)
{
u64 avgl, avgr;

if (!l->nb_atoms)
return -1;

if (!r->nb_atoms)
return 1;

avgl = l->total_lat / l->nb_atoms;
avgr = r->total_lat / r->nb_atoms;

if (avgl < avgr)
return -1;
if (avgl > avgr)
return 1;

return 0;
}

static struct sort_dimension avg_sort_dimension = {
.name = «avg»,
.cmp = avg_cmp,
};

static int max_cmp(struct work_atoms *l, struct work_atoms *r)
{
if (l->max_lat < r->max_lat)
return -1;
if (l->max_lat > r->max_lat)
return 1;

return 0;
}

static struct sort_dimension max_sort_dimension = {
.name = «max»,
.cmp = max_cmp,
};

static int switch_cmp(struct work_atoms *l, struct work_atoms *r)
{
if (l->nb_atoms < r->nb_atoms)
return -1;
if (l->nb_atoms > r->nb_atoms)
return 1;

return 0;
}

static struct sort_dimension switch_sort_dimension = {
.name = «switch»,
.cmp = switch_cmp,
};

static int runtime_cmp(struct work_atoms *l, struct work_atoms *r)
{
if (l->total_runtime < r->total_runtime)
return -1;
if (l->total_runtime > r->total_runtime)
return 1;

return 0;
}

static struct sort_dimension runtime_sort_dimension = {
.name = «runtime»,
.cmp = runtime_cmp,
};

static struct sort_dimension *available_sorts[] = {
&pid_sort_dimension,
&avg_sort_dimension,
&max_sort_dimension,
&switch_sort_dimension,
&runtime_sort_dimension,
};

#define NB_AVAILABLE_SORTS (int)(sizeof(available_sorts) / sizeof(struct sort_dimension *))

static LIST_HEAD(sort_list);

static int sort_dimension__add(const char *tok, struct list_head *list)
{
int i;

for (i = 0; i < NB_AVAILABLE_SORTS; i++) {
if (!strcmp(available_sorts[i]->name, tok)) {
list_add_tail(&available_sorts[i]->list, list);

return 0;
}
}

return -1;
}

static void setup_sorting(void);

static void sort_lat(void)
{
struct rb_node *node;

for (;;) {
struct work_atoms *data;
node = rb_first(&atom_root);
if (!node)
break;

rb_erase(node, &atom_root);
data = rb_entry(node, struct work_atoms, node);
__thread_latency_insert(&sorted_atom_root, data, &sort_list);
}
}

static struct trace_sched_handler *trace_handler;

static void
process_sched_wakeup_event(struct raw_event_sample *raw,
struct event *event,
int cpu __used,
u64 timestamp __used,
struct thread *thread __used)
{
struct trace_wakeup_event wakeup_event;

FILL_COMMON_FIELDS(wakeup_event, event, raw->data);

FILL_ARRAY(wakeup_event, comm, event, raw->data);
FILL_FIELD(wakeup_event, pid, event, raw->data);
FILL_FIELD(wakeup_event, prio, event, raw->data);
FILL_FIELD(wakeup_event, success, event, raw->data);
FILL_FIELD(wakeup_event, cpu, event, raw->data);

if (trace_handler->wakeup_event)
trace_handler->wakeup_event(&wakeup_event, event, cpu, timestamp, thread);
}

/*
* Track the current task – that way we can know whether there’s any
* weird events, such as a task being switched away that is not current.
*/
static int max_cpu;

static u32 curr_pid[MAX_CPUS] = { [0 ... MAX_CPUS-1] = -1 };

static struct thread *curr_thread[MAX_CPUS];

static char next_shortname1 = ‘A’;
static char next_shortname2 = ‘0′;

static void
map_switch_event(struct trace_switch_event *switch_event,
struct event *event __used,
int this_cpu,
u64 timestamp,
struct thread *thread __used)
{
struct thread *sched_out, *sched_in;
int new_shortname;
u64 timestamp0;
s64 delta;
int cpu;

BUG_ON(this_cpu >= MAX_CPUS || this_cpu < 0);

if (this_cpu > max_cpu)
max_cpu = this_cpu;

timestamp0 = cpu_last_switched[this_cpu];
cpu_last_switched[this_cpu] = timestamp;
if (timestamp0)
delta = timestamp – timestamp0;
else
delta = 0;

if (delta < 0)
die("hm, delta: %Ld < 0 ?\n", delta);

sched_out = threads__findnew(switch_event->prev_pid, &threads, &last_match);
sched_in = threads__findnew(switch_event->next_pid, &threads, &last_match);

curr_thread[this_cpu] = sched_in;

printf(» «);

new_shortname = 0;
if (!sched_in->shortname[0]) {
sched_in->shortname[0] = next_shortname1;
sched_in->shortname[1] = next_shortname2;

if (next_shortname1 < 'Z') {
next_shortname1++;
} else {
next_shortname1='A';
if (next_shortname2 < '9') {
next_shortname2++;
} else {
next_shortname2='0';
}
}
new_shortname = 1;
}

for (cpu = 0; cpu <= max_cpu; cpu++) {
if (cpu != this_cpu)
printf(" ");
else
printf("*");

if (curr_thread[cpu]) {
if (curr_thread[cpu]->pid)
printf(»%2s «, curr_thread[cpu]->shortname);
else
printf(». «);
} else
printf(» «);
}

printf(» %12.6f secs «, (double)timestamp/1e9);
if (new_shortname) {
printf(»%s => %s:%d\n»,
sched_in->shortname, sched_in->comm, sched_in->pid);
} else {
printf(»\n»);
}
}

static void
process_sched_switch_event(struct raw_event_sample *raw,
struct event *event,
int this_cpu,
u64 timestamp __used,
struct thread *thread __used)
{
struct trace_switch_event switch_event;

FILL_COMMON_FIELDS(switch_event, event, raw->data);

FILL_ARRAY(switch_event, prev_comm, event, raw->data);
FILL_FIELD(switch_event, prev_pid, event, raw->data);
FILL_FIELD(switch_event, prev_prio, event, raw->data);
FILL_FIELD(switch_event, prev_state, event, raw->data);
FILL_ARRAY(switch_event, next_comm, event, raw->data);
FILL_FIELD(switch_event, next_pid, event, raw->data);
FILL_FIELD(switch_event, next_prio, event, raw->data);

if (curr_pid[this_cpu] != (u32)-1) {
/*
* Are we trying to switch away a PID that is
* not current?
*/
if (curr_pid[this_cpu] != switch_event.prev_pid)
nr_context_switch_bugs++;
}
if (trace_handler->switch_event)
trace_handler->switch_event(&switch_event, event, this_cpu, timestamp, thread);

curr_pid[this_cpu] = switch_event.next_pid;
}

static void
process_sched_runtime_event(struct raw_event_sample *raw,
struct event *event,
int cpu __used,
u64 timestamp __used,
struct thread *thread __used)
{
struct trace_runtime_event runtime_event;

FILL_ARRAY(runtime_event, comm, event, raw->data);
FILL_FIELD(runtime_event, pid, event, raw->data);
FILL_FIELD(runtime_event, runtime, event, raw->data);
FILL_FIELD(runtime_event, vruntime, event, raw->data);

if (trace_handler->runtime_event)
trace_handler->runtime_event(&runtime_event, event, cpu, timestamp, thread);
}

static void
process_sched_fork_event(struct raw_event_sample *raw,
struct event *event,
int cpu __used,
u64 timestamp __used,
struct thread *thread __used)
{
struct trace_fork_event fork_event;

FILL_COMMON_FIELDS(fork_event, event, raw->data);

FILL_ARRAY(fork_event, parent_comm, event, raw->data);
FILL_FIELD(fork_event, parent_pid, event, raw->data);
FILL_ARRAY(fork_event, child_comm, event, raw->data);
FILL_FIELD(fork_event, child_pid, event, raw->data);

if (trace_handler->fork_event)
trace_handler->fork_event(&fork_event, event, cpu, timestamp, thread);
}

static void
process_sched_exit_event(struct event *event,
int cpu __used,
u64 timestamp __used,
struct thread *thread __used)
{
if (verbose)
printf(»sched_exit event %p\n», event);
}

static void
process_raw_event(event_t *raw_event __used, void *more_data,
int cpu, u64 timestamp, struct thread *thread)
{
struct raw_event_sample *raw = more_data;
struct event *event;
int type;

type = trace_parse_common_type(raw->data);
event = trace_find_event(type);

if (!strcmp(event->name, «sched_switch»))
process_sched_switch_event(raw, event, cpu, timestamp, thread);
if (!strcmp(event->name, «sched_stat_runtime»))
process_sched_runtime_event(raw, event, cpu, timestamp, thread);
if (!strcmp(event->name, «sched_wakeup»))
process_sched_wakeup_event(raw, event, cpu, timestamp, thread);
if (!strcmp(event->name, «sched_wakeup_new»))
process_sched_wakeup_event(raw, event, cpu, timestamp, thread);
if (!strcmp(event->name, «sched_process_fork»))
process_sched_fork_event(raw, event, cpu, timestamp, thread);
if (!strcmp(event->name, «sched_process_exit»))
process_sched_exit_event(event, cpu, timestamp, thread);
}

static int
process_sample_event(event_t *event, unsigned long offset, unsigned long head)
{
char level;
int show = 0;
struct dso *dso = NULL;
struct thread *thread;
u64 ip = event->ip.ip;
u64 timestamp = -1;
u32 cpu = -1;
u64 period = 1;
void *more_data = event->ip.__more_data;
int cpumode;

thread = threads__findnew(event->ip.pid, &threads, &last_match);

if (sample_type & PERF_SAMPLE_TIME) {
timestamp = *(u64 *)more_data;
more_data += sizeof(u64);
}

if (sample_type & PERF_SAMPLE_CPU) {
cpu = *(u32 *)more_data;
more_data += sizeof(u32);
more_data += sizeof(u32); /* reserved */
}

if (sample_type & PERF_SAMPLE_PERIOD) {
period = *(u64 *)more_data;
more_data += sizeof(u64);
}

dump_printf(»%p [%p]: PERF_RECORD_SAMPLE (IP, %d): %d/%d: %p period: %Ld\n»,
(void *)(offset + head),
(void *)(long)(event->header.size),
event->header.misc,
event->ip.pid, event->ip.tid,
(void *)(long)ip,
(long long)period);

dump_printf(» … thread: %s:%d\n», thread->comm, thread->pid);

if (thread == NULL) {
eprintf(»problem processing %d event, skipping it.\n»,
event->header.type);
return -1;
}

cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;

if (cpumode == PERF_RECORD_MISC_KERNEL) {
show = SHOW_KERNEL;
level = ‘k’;

dso = kernel_dso;

dump_printf(» …… dso: %s\n», dso->name);

} else if (cpumode == PERF_RECORD_MISC_USER) {

show = SHOW_USER;
level = ‘.’;

} else {
show = SHOW_HV;
level = ‘H’;

dso = hypervisor_dso;

dump_printf(» …… dso: [hypervisor]\n»);
}

if (sample_type & PERF_SAMPLE_RAW)
process_raw_event(event, more_data, cpu, timestamp, thread);

return 0;
}

static int
process_event(event_t *event, unsigned long offset, unsigned long head)
{
trace_event(event);

nr_events++;
switch (event->header.type) {
case PERF_RECORD_MMAP:
return 0;
case PERF_RECORD_LOST:
nr_lost_chunks++;
nr_lost_events += event->lost.lost;
return 0;

case PERF_RECORD_COMM:
return process_comm_event(event, offset, head);

case PERF_RECORD_EXIT … PERF_RECORD_READ:
return 0;

case PERF_RECORD_SAMPLE:
return process_sample_event(event, offset, head);

case PERF_RECORD_MAX:
default:
return -1;
}

return 0;
}

static int read_events(void)
{
int ret, rc = EXIT_FAILURE;
unsigned long offset = 0;
unsigned long head = 0;
struct stat perf_stat;
event_t *event;
uint32_t size;
char *buf;

trace_report();
register_idle_thread(&threads, &last_match);

input = open(input_name, O_RDONLY);
if (input < 0) {
perror("failed to open file");
exit(-1);
}

ret = fstat(input, &perf_stat);
if (ret < 0) {
perror("failed to stat file");
exit(-1);
}

if (!perf_stat.st_size) {
fprintf(stderr, "zero-sized file, nothing to do!\n");
exit(0);
}
header = perf_header__read(input);
head = header->data_offset;
sample_type = perf_header__sample_type(header);

if (!(sample_type & PERF_SAMPLE_RAW))
die(»No trace sample to read. Did you call perf record »
«without -R?»);

if (load_kernel() < 0) {
perror("failed to load kernel symbols");
return EXIT_FAILURE;
}

remap:
buf = (char *)mmap(NULL, page_size * mmap_window, PROT_READ,
MAP_SHARED, input, offset);
if (buf == MAP_FAILED) {
perror("failed to mmap file");
exit(-1);
}

more:
event = (event_t *)(buf + head);

size = event->header.size;
if (!size)
size = 8;

if (head + event->header.size >= page_size * mmap_window) {
unsigned long shift = page_size * (head / page_size);
int res;

res = munmap(buf, page_size * mmap_window);
assert(res == 0);

offset += shift;
head -= shift;
goto remap;
}

size = event->header.size;

if (!size || process_event(event, offset, head) < 0) {

/*
* assume we lost track of the stream, check alignment, and
* increment a single u64 in the hope to catch on again 'soon'.
*/

if (unlikely(head & 7))
head &= ~7ULL;

size = 8;
}

head += size;

if (offset + head < (unsigned long)perf_stat.st_size)
goto more;

rc = EXIT_SUCCESS;
close(input);

return rc;
}

static void print_bad_events(void)
{
if (nr_unordered_timestamps && nr_timestamps) {
printf(" INFO: %.3f%% unordered timestamps (%ld out of %ld)\n",
(double)nr_unordered_timestamps/(double)nr_timestamps*100.0,
nr_unordered_timestamps, nr_timestamps);
}
if (nr_lost_events && nr_events) {
printf(" INFO: %.3f%% lost events (%ld out of %ld, in %ld chunks)\n",
(double)nr_lost_events/(double)nr_events*100.0,
nr_lost_events, nr_events, nr_lost_chunks);
}
if (nr_state_machine_bugs && nr_timestamps) {
printf(" INFO: %.3f%% state machine bugs (%ld out of %ld)",
(double)nr_state_machine_bugs/(double)nr_timestamps*100.0,
nr_state_machine_bugs, nr_timestamps);
if (nr_lost_events)
printf(" (due to lost events?)");
printf("\n");
}
if (nr_context_switch_bugs && nr_timestamps) {
printf(" INFO: %.3f%% context switch bugs (%ld out of %ld)",
(double)nr_context_switch_bugs/(double)nr_timestamps*100.0,
nr_context_switch_bugs, nr_timestamps);
if (nr_lost_events)
printf(" (due to lost events?)");
printf("\n");
}
}

static void __cmd_lat(void)
{
struct rb_node *next;

setup_pager();
read_events();
sort_lat();

printf("\n -----------------------------------------------------------------------------------------\n");
printf(" Task | Runtime ms | Switches | Average delay ms | Maximum delay ms |\n");
printf(" -----------------------------------------------------------------------------------------\n");

next = rb_first(&sorted_atom_root);

while (next) {
struct work_atoms *work_list;

work_list = rb_entry(next, struct work_atoms, node);
output_lat_thread(work_list);
next = rb_next(next);
}

printf(" -----------------------------------------------------------------------------------------\n");
printf(" TOTAL: |%11.3f ms |%9Ld |\n",
(double)all_runtime/1e6, all_count);

printf(" ---------------------------------------------------\n");

print_bad_events();
printf("\n");

}

static struct trace_sched_handler map_ops = {
.wakeup_event = NULL,
.switch_event = map_switch_event,
.runtime_event = NULL,
.fork_event = NULL,
};

static void __cmd_map(void)
{
max_cpu = sysconf(_SC_NPROCESSORS_CONF);

setup_pager();
read_events();
print_bad_events();
}

static void __cmd_replay(void)
{
unsigned long i;

calibrate_run_measurement_overhead();
calibrate_sleep_measurement_overhead();

test_calibrations();

read_events();

printf("nr_run_events: %ld\n", nr_run_events);
printf("nr_sleep_events: %ld\n", nr_sleep_events);
printf("nr_wakeup_events: %ld\n", nr_wakeup_events);

if (targetless_wakeups)
printf("target-less wakeups: %ld\n", targetless_wakeups);
if (multitarget_wakeups)
printf("multi-target wakeups: %ld\n", multitarget_wakeups);
if (nr_run_events_optimized)
printf("run atoms optimized: %ld\n",
nr_run_events_optimized);

print_task_traces();
add_cross_task_wakeups();

create_tasks();
printf("------------------------------------------------------------\n");
for (i = 0; i < replay_repeat; i++)
run_one_test();
}

static const char * const sched_usage[] = {
"perf sched [] {record|latency|map|replay|trace}»,
NULL
};

static const struct option sched_options[] = {
OPT_STRING(’i', «input», &input_name, «file»,
«input file name»),
OPT_BOOLEAN(’v', «verbose», &verbose,
«be more verbose (show symbol address, etc)»),
OPT_BOOLEAN(’D', «dump-raw-trace», &dump_trace,
«dump raw trace in ASCII»),
OPT_END()
};

static const char * const latency_usage[] = {
«perf sched latency []«,
NULL
};

static const struct option latency_options[] = {
OPT_STRING(’s’, «sort», &sort_order, «key[,key2...]«,
«sort by key(s): runtime, switch, avg, max»),
OPT_BOOLEAN(’v', «verbose», &verbose,
«be more verbose (show symbol address, etc)»),
OPT_BOOLEAN(’D', «dump-raw-trace», &dump_trace,
«dump raw trace in ASCII»),
OPT_END()
};

static const char * const replay_usage[] = {
«perf sched replay []«,
NULL
};

static const struct option replay_options[] = {
OPT_INTEGER(’r', «repeat», &replay_repeat,
«repeat the workload replay N times (-1: infinite)»),
OPT_BOOLEAN(’v', «verbose», &verbose,
«be more verbose (show symbol address, etc)»),
OPT_BOOLEAN(’D', «dump-raw-trace», &dump_trace,
«dump raw trace in ASCII»),
OPT_END()
};

static void setup_sorting(void)
{
char *tmp, *tok, *str = strdup(sort_order);

for (tok = strtok_r(str, «, «, &tmp);
tok; tok = strtok_r(NULL, «, «, &tmp)) {
if (sort_dimension__add(tok, &sort_list) < 0) {
error("Unknown --sort key: `%s'", tok);
usage_with_options(latency_usage, latency_options);
}
}

free(str);

sort_dimension__add("pid", &cmp_pid);
}

static const char *record_args[] = {
"record",
"-a",
"-R",
"-M",
"-f",
"-m", "1024",
"-c", "1",
"-e", "sched:sched_switch:r",
"-e", "sched:sched_stat_wait:r",
"-e", "sched:sched_stat_sleep:r",
"-e", "sched:sched_stat_iowait:r",
"-e", "sched:sched_stat_runtime:r",
"-e", "sched:sched_process_exit:r",
"-e", "sched:sched_process_fork:r",
"-e", "sched:sched_wakeup:r",
"-e", "sched:sched_migrate_task:r",
};

static int __cmd_record(int argc, const char **argv)
{
unsigned int rec_argc, i, j;
const char **rec_argv;

rec_argc = ARRAY_SIZE(record_args) + argc - 1;
rec_argv = calloc(rec_argc + 1, sizeof(char *));

for (i = 0; i < ARRAY_SIZE(record_args); i++)
rec_argv[i] = strdup(record_args[i]);

for (j = 1; j < (unsigned int)argc; j++, i++)
rec_argv[i] = argv[j];

BUG_ON(i != rec_argc);

return cmd_record(i, rec_argv, NULL);
}

int cmd_sched(int argc, const char **argv, const char *prefix __used)
{
symbol__init();
page_size = getpagesize();

argc = parse_options(argc, argv, sched_options, sched_usage,
PARSE_OPT_STOP_AT_NON_OPTION);
if (!argc)
usage_with_options(sched_usage, sched_options);

if (!strncmp(argv[0], "rec", 3)) {
return __cmd_record(argc, argv);
} else if (!strncmp(argv[0], "lat", 3)) {
trace_handler = &lat_ops;
if (argc > 1) {
argc = parse_options(argc, argv, latency_options, latency_usage, 0);
if (argc)
usage_with_options(latency_usage, latency_options);
}
setup_sorting();
__cmd_lat();
} else if (!strcmp(argv[0], «map»)) {
trace_handler = &map_ops;
setup_sorting();
__cmd_map();
} else if (!strncmp(argv[0], «rep», 3)) {
trace_handler = &replay_ops;
if (argc) {
argc = parse_options(argc, argv, replay_options, replay_usage, 0);
if (argc)
usage_with_options(replay_usage, replay_options);
}
__cmd_replay();
} else if (!strcmp(argv[0], «trace»)) {
/*
* Aliased to ‘perf trace’ for now:
*/
return cmd_trace(argc, argv, prefix);
} else {
usage_with_options(sched_usage, sched_options);
}

return 0;
}

#include «util/util.h»

#include «util/color.h»
#include #include «util/cache.h»
#include #include «util/symbol.h»
#include «util/string.h»
#include «util/callchain.h»
#include «util/strlist.h»
#include «util/values.h»

#include «perf.h»
#include «util/debug.h»
#include «util/header.h»

#include «util/parse-options.h»
#include «util/parse-events.h»

#include «util/thread.h»

static char const *input_name = «perf.data»;

static char default_sort_order[] = «comm,dso,symbol»;
static char *sort_order = default_sort_order;
static char *dso_list_str, *comm_list_str, *sym_list_str,
*col_width_list_str;
static struct strlist *dso_list, *comm_list, *sym_list;
static char *field_sep;

static int force;
static int input;
static int show_mask = SHOW_KERNEL | SHOW_USER | SHOW_HV;

static int full_paths;
static int show_nr_samples;

static int show_threads;
static struct perf_read_values show_threads_values;

static char default_pretty_printing_style[] = «normal»;
static char *pretty_printing_style = default_pretty_printing_style;

static unsigned long page_size;
static unsigned long mmap_window = 32;

static char default_parent_pattern[] = «^sys_|^do_page_fault»;
static char *parent_pattern = default_parent_pattern;
static regex_t parent_regex;

static int exclude_other = 1;

static char callchain_default_opt[] = «fractal,0.5″;

static int callchain;

static char __cwd[PATH_MAX];
static char *cwd = __cwd;
static int cwdlen;

static struct rb_root threads;
static struct thread *last_match;

static struct perf_header *header;

static
struct callchain_param callchain_param = {
.mode = CHAIN_GRAPH_REL,
.min_percent = 0.5
};

static u64 sample_type;

static int repsep_fprintf(FILE *fp, const char *fmt, …)
{
int n;
va_list ap;

va_start(ap, fmt);
if (!field_sep)
n = vfprintf(fp, fmt, ap);
else {
char *bf = NULL;
n = vasprintf(&bf, fmt, ap);
if (n > 0) {
char *sep = bf;

while (1) {
sep = strchr(sep, *field_sep);
if (sep == NULL)
break;
*sep = ‘.’;
}
}
fputs(bf, fp);
free(bf);
}
va_end(ap);
return n;
}

static unsigned int dsos__col_width,
comms__col_width,
threads__col_width;

/*
* histogram, sorted on item, collects counts
*/

static struct rb_root hist;

struct hist_entry {
struct rb_node rb_node;

struct thread *thread;
struct map *map;
struct dso *dso;
struct symbol *sym;
struct symbol *parent;
u64 ip;
char level;
struct callchain_node callchain;
struct rb_root sorted_chain;

u64 count;
};

/*
* configurable sorting bits
*/

struct sort_entry {
struct list_head list;

const char *header;

int64_t (*cmp)(struct hist_entry *, struct hist_entry *);
int64_t (*collapse)(struct hist_entry *, struct hist_entry *);
size_t (*print)(FILE *fp, struct hist_entry *, unsigned int width);
unsigned int *width;
bool elide;
};

static int64_t cmp_null(void *l, void *r)
{
if (!l && !r)
return 0;
else if (!l)
return -1;
else
return 1;
}

/* –sort pid */

static int64_t
sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
{
return right->thread->pid – left->thread->pid;
}

static size_t
sort__thread_print(FILE *fp, struct hist_entry *self, unsigned int width)
{
return repsep_fprintf(fp, «%*s:%5d», width – 6,
self->thread->comm ?: «», self->thread->pid);
}

static struct sort_entry sort_thread = {
.header = «Command: Pid»,
.cmp = sort__thread_cmp,
.print = sort__thread_print,
.width = &threads__col_width,
};

/* –sort comm */

static int64_t
sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
{
return right->thread->pid – left->thread->pid;
}

static int64_t
sort__comm_collapse(struct hist_entry *left, struct hist_entry *right)
{
char *comm_l = left->thread->comm;
char *comm_r = right->thread->comm;

if (!comm_l || !comm_r)
return cmp_null(comm_l, comm_r);

return strcmp(comm_l, comm_r);
}

static size_t
sort__comm_print(FILE *fp, struct hist_entry *self, unsigned int width)
{
return repsep_fprintf(fp, «%*s», width, self->thread->comm);
}

static struct sort_entry sort_comm = {
.header = «Command»,
.cmp = sort__comm_cmp,
.collapse = sort__comm_collapse,
.print = sort__comm_print,
.width = &comms__col_width,
};

/* –sort dso */

static int64_t
sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
{
struct dso *dso_l = left->dso;
struct dso *dso_r = right->dso;

if (!dso_l || !dso_r)
return cmp_null(dso_l, dso_r);

return strcmp(dso_l->name, dso_r->name);
}

static size_t
sort__dso_print(FILE *fp, struct hist_entry *self, unsigned int width)
{
if (self->dso)
return repsep_fprintf(fp, «%-*s», width, self->dso->name);

return repsep_fprintf(fp, «%*llx», width, (u64)self->ip);
}

static struct sort_entry sort_dso = {
.header = «Shared Object»,
.cmp = sort__dso_cmp,
.print = sort__dso_print,
.width = &dsos__col_width,
};

/* –sort symbol */

static int64_t
sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
{
u64 ip_l, ip_r;

if (left->sym == right->sym)
return 0;

ip_l = left->sym ? left->sym->start : left->ip;
ip_r = right->sym ? right->sym->start : right->ip;

return (int64_t)(ip_r – ip_l);
}

static size_t
sort__sym_print(FILE *fp, struct hist_entry *self, unsigned int width __used)
{
size_t ret = 0;

if (verbose)
ret += repsep_fprintf(fp, «%#018llx %c «, (u64)self->ip,
dso__symtab_origin(self->dso));

ret += repsep_fprintf(fp, «[%c] «, self->level);
if (self->sym) {
ret += repsep_fprintf(fp, «%s», self->sym->name);

if (self->sym->module)
ret += repsep_fprintf(fp, «\t[%s]«,
self->sym->module->name);
} else {
ret += repsep_fprintf(fp, «%#016llx», (u64)self->ip);
}

return ret;
}

static struct sort_entry sort_sym = {
.header = «Symbol»,
.cmp = sort__sym_cmp,
.print = sort__sym_print,
};

/* –sort parent */

static int64_t
sort__parent_cmp(struct hist_entry *left, struct hist_entry *right)
{
struct symbol *sym_l = left->parent;
struct symbol *sym_r = right->parent;

if (!sym_l || !sym_r)
return cmp_null(sym_l, sym_r);

return strcmp(sym_l->name, sym_r->name);
}

static size_t
sort__parent_print(FILE *fp, struct hist_entry *self, unsigned int width)
{
return repsep_fprintf(fp, «%-*s», width,
self->parent ? self->parent->name : «[other]«);
}

static unsigned int parent_symbol__col_width;

static struct sort_entry sort_parent = {
.header = «Parent symbol»,
.cmp = sort__parent_cmp,
.print = sort__parent_print,
.width = &parent_symbol__col_width,
};

static int sort__need_collapse = 0;
static int sort__has_parent = 0;

struct sort_dimension {
const char *name;
struct sort_entry *entry;
int taken;
};

static struct sort_dimension sort_dimensions[] = {
{ .name = «pid», .entry = &sort_thread, },
{ .name = «comm», .entry = &sort_comm, },
{ .name = «dso», .entry = &sort_dso, },
{ .name = «symbol», .entry = &sort_sym, },
{ .name = «parent», .entry = &sort_parent, },
};

static LIST_HEAD(hist_entry__sort_list);

static int sort_dimension__add(const char *tok)
{
unsigned int i;

for (i = 0; i < ARRAY_SIZE(sort_dimensions); i++) {
struct sort_dimension *sd = &sort_dimensions[i];

if (sd->taken)
continue;

if (strncasecmp(tok, sd->name, strlen(tok)))
continue;

if (sd->entry->collapse)
sort__need_collapse = 1;

if (sd->entry == &sort_parent) {
int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED);
if (ret) {
char err[BUFSIZ];

regerror(ret, &parent_regex, err, sizeof(err));
fprintf(stderr, «Invalid regex: %s\n%s»,
parent_pattern, err);
exit(-1);
}
sort__has_parent = 1;
}

list_add_tail(&sd->entry->list, &hist_entry__sort_list);
sd->taken = 1;

return 0;
}

return -ESRCH;
}

static int64_t
hist_entry__cmp(struct hist_entry *left, struct hist_entry *right)
{
struct sort_entry *se;
int64_t cmp = 0;

list_for_each_entry(se, &hist_entry__sort_list, list) {
cmp = se->cmp(left, right);
if (cmp)
break;
}

return cmp;
}

static int64_t
hist_entry__collapse(struct hist_entry *left, struct hist_entry *right)
{
struct sort_entry *se;
int64_t cmp = 0;

list_for_each_entry(se, &hist_entry__sort_list, list) {
int64_t (*f)(struct hist_entry *, struct hist_entry *);

f = se->collapse ?: se->cmp;

cmp = f(left, right);
if (cmp)
break;
}

return cmp;
}

static size_t ipchain__fprintf_graph_line(FILE *fp, int depth, int depth_mask)
{
int i;
size_t ret = 0;

ret += fprintf(fp, «%s», » «);

for (i = 0; i < depth; i++)
if (depth_mask & (1 << i))
ret += fprintf(fp, "| ");
else
ret += fprintf(fp, " ");

ret += fprintf(fp, "\n");

return ret;
}
static size_t
ipchain__fprintf_graph(FILE *fp, struct callchain_list *chain, int depth,
int depth_mask, int count, u64 total_samples,
int hits)
{
int i;
size_t ret = 0;

ret += fprintf(fp, "%s", " ");
for (i = 0; i < depth; i++) {
if (depth_mask & (1 << i))
ret += fprintf(fp, "|");
else
ret += fprintf(fp, " ");
if (!count && i == depth - 1) {
double percent;

percent = hits * 100.0 / total_samples;
ret += percent_color_fprintf(fp, "--%2.2f%%-- ", percent);
} else
ret += fprintf(fp, "%s", " ");
}
if (chain->sym)
ret += fprintf(fp, «%s\n», chain->sym->name);
else
ret += fprintf(fp, «%p\n», (void *)(long)chain->ip);

return ret;
}

static struct symbol *rem_sq_bracket;
static struct callchain_list rem_hits;

static void init_rem_hits(void)
{
rem_sq_bracket = malloc(sizeof(*rem_sq_bracket) + 6);
if (!rem_sq_bracket) {
fprintf(stderr, «Not enough memory to display remaining hits\n»);
return;
}

strcpy(rem_sq_bracket->name, «[...]«);
rem_hits.sym = rem_sq_bracket;
}

static size_t
callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
u64 total_samples, int depth, int depth_mask)
{
struct rb_node *node, *next;
struct callchain_node *child;
struct callchain_list *chain;
int new_depth_mask = depth_mask;
u64 new_total;
u64 remaining;
size_t ret = 0;
int i;

if (callchain_param.mode == CHAIN_GRAPH_REL)
new_total = self->children_hit;
else
new_total = total_samples;

remaining = new_total;

node = rb_first(&self->rb_root);
while (node) {
u64 cumul;

child = rb_entry(node, struct callchain_node, rb_node);
cumul = cumul_hits(child);
remaining -= cumul;

/*
* The depth mask manages the output of pipes that show
* the depth. We don’t want to keep the pipes of the current
* level for the last child of this depth.
* Except if we have remaining filtered hits. They will
* supersede the last child
*/
next = rb_next(node);
if (!next && (callchain_param.mode != CHAIN_GRAPH_REL || !remaining))
new_depth_mask &= ~(1 << (depth - 1));

/*
* But we keep the older depth mask for the line seperator
* to keep the level link until we reach the last child
*/
ret += ipchain__fprintf_graph_line(fp, depth, depth_mask);
i = 0;
list_for_each_entry(chain, &child->val, list) {
if (chain->ip >= PERF_CONTEXT_MAX)
continue;
ret += ipchain__fprintf_graph(fp, chain, depth,
new_depth_mask, i++,
new_total,
cumul);
}
ret += callchain__fprintf_graph(fp, child, new_total,
depth + 1,
new_depth_mask | (1 << depth));
node = next;
}

if (callchain_param.mode == CHAIN_GRAPH_REL &&
remaining && remaining != new_total) {

if (!rem_sq_bracket)
return ret;

new_depth_mask &= ~(1 << (depth - 1));

ret += ipchain__fprintf_graph(fp, &rem_hits, depth,
new_depth_mask, 0, new_total,
remaining);
}

return ret;
}

static size_t
callchain__fprintf_flat(FILE *fp, struct callchain_node *self,
u64 total_samples)
{
struct callchain_list *chain;
size_t ret = 0;

if (!self)
return 0;

ret += callchain__fprintf_flat(fp, self->parent, total_samples);

list_for_each_entry(chain, &self->val, list) {
if (chain->ip >= PERF_CONTEXT_MAX)
continue;
if (chain->sym)
ret += fprintf(fp, » %s\n», chain->sym->name);
else
ret += fprintf(fp, » %p\n»,
(void *)(long)chain->ip);
}

return ret;
}

static size_t
hist_entry_callchain__fprintf(FILE *fp, struct hist_entry *self,
u64 total_samples)
{
struct rb_node *rb_node;
struct callchain_node *chain;
size_t ret = 0;

rb_node = rb_first(&self->sorted_chain);
while (rb_node) {
double percent;

chain = rb_entry(rb_node, struct callchain_node, rb_node);
percent = chain->hit * 100.0 / total_samples;
switch (callchain_param.mode) {
case CHAIN_FLAT:
ret += percent_color_fprintf(fp, » %6.2f%%\n»,
percent);
ret += callchain__fprintf_flat(fp, chain, total_samples);
break;
case CHAIN_GRAPH_ABS: /* Falldown */
case CHAIN_GRAPH_REL:
ret += callchain__fprintf_graph(fp, chain,
total_samples, 1, 1);
case CHAIN_NONE:
default:
break;
}
ret += fprintf(fp, «\n»);
rb_node = rb_next(rb_node);
}

return ret;
}

static size_t
hist_entry__fprintf(FILE *fp, struct hist_entry *self, u64 total_samples)
{
struct sort_entry *se;
size_t ret;

if (exclude_other && !self->parent)
return 0;

if (total_samples)
ret = percent_color_fprintf(fp,
field_sep ? «%.2f» : » %6.2f%%»,
(self->count * 100.0) / total_samples);
else
ret = fprintf(fp, field_sep ? «%lld» : «%12lld «, self->count);

if (show_nr_samples) {
if (field_sep)
fprintf(fp, «%c%lld», *field_sep, self->count);
else
fprintf(fp, «%11lld», self->count);
}

list_for_each_entry(se, &hist_entry__sort_list, list) {
if (se->elide)
continue;

fprintf(fp, «%s», field_sep ?: » «);
ret += se->print(fp, self, se->width ? *se->width : 0);
}

ret += fprintf(fp, «\n»);

if (callchain)
hist_entry_callchain__fprintf(fp, self, total_samples);

return ret;
}

/*
*
*/

static void dso__calc_col_width(struct dso *self)
{
if (!col_width_list_str && !field_sep &&
(!dso_list || strlist__has_entry(dso_list, self->name))) {
unsigned int slen = strlen(self->name);
if (slen > dsos__col_width)
dsos__col_width = slen;
}

self->slen_calculated = 1;
}

static void thread__comm_adjust(struct thread *self)
{
char *comm = self->comm;

if (!col_width_list_str && !field_sep &&
(!comm_list || strlist__has_entry(comm_list, comm))) {
unsigned int slen = strlen(comm);

if (slen > comms__col_width) {
comms__col_width = slen;
threads__col_width = slen + 6;
}
}
}

static int thread__set_comm_adjust(struct thread *self, const char *comm)
{
int ret = thread__set_comm(self, comm);

if (ret)
return ret;

thread__comm_adjust(self);

return 0;
}

static struct symbol *
resolve_symbol(struct thread *thread, struct map **mapp,
struct dso **dsop, u64 *ipp)
{
struct dso *dso = dsop ? *dsop : NULL;
struct map *map = mapp ? *mapp : NULL;
u64 ip = *ipp;

if (!thread)
return NULL;

if (dso)
goto got_dso;

if (map)
goto got_map;

map = thread__find_map(thread, ip);
if (map != NULL) {
/*
* We have to do this here as we may have a dso
* with no symbol hit that has a name longer than
* the ones with symbols sampled.
*/
if (!sort_dso.elide && !map->dso->slen_calculated)
dso__calc_col_width(map->dso);

if (mapp)
*mapp = map;
got_map:
ip = map->map_ip(map, ip);

dso = map->dso;
} else {
/*
* If this is outside of all known maps,
* and is a negative address, try to look it
* up in the kernel dso, as it might be a
* vsyscall (which executes in user-mode):
*/
if ((long long)ip < 0)
dso = kernel_dso;
}
dump_printf(" ...... dso: %s\n", dso ? dso->name : ««);
dump_printf(» …… map: %Lx -> %Lx\n», *ipp, ip);
*ipp = ip;

if (dsop)
*dsop = dso;

if (!dso)
return NULL;
got_dso:
return dso->find_symbol(dso, ip);
}