perf python: Add missing perf_event__parse_sample 'swapped' parm
[linux-2.6.git] / tools / perf / builtin-script.c
index 6cf811a..09024ec 100644 (file)
 #include "util/symbol.h"
 #include "util/thread.h"
 #include "util/trace-event.h"
-#include "util/parse-options.h"
 #include "util/util.h"
 #include "util/evlist.h"
 #include "util/evsel.h"
+#include <linux/bitmap.h>
 
 static char const              *script_name;
 static char const              *generate_script_lang;
@@ -22,6 +22,8 @@ static u64                    last_timestamp;
 static u64                     nr_unordered;
 extern const struct option     record_options[];
 static bool                    no_callchain;
+static const char              *cpu_list;
+static DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
 
 enum perf_output_field {
        PERF_OUTPUT_COMM            = 1U << 0,
@@ -31,7 +33,10 @@ enum perf_output_field {
        PERF_OUTPUT_CPU             = 1U << 4,
        PERF_OUTPUT_EVNAME          = 1U << 5,
        PERF_OUTPUT_TRACE           = 1U << 6,
-       PERF_OUTPUT_SYM             = 1U << 7,
+       PERF_OUTPUT_IP              = 1U << 7,
+       PERF_OUTPUT_SYM             = 1U << 8,
+       PERF_OUTPUT_DSO             = 1U << 9,
+       PERF_OUTPUT_ADDR            = 1U << 10,
 };
 
 struct output_option {
@@ -45,12 +50,16 @@ struct output_option {
        {.str = "cpu",   .field = PERF_OUTPUT_CPU},
        {.str = "event", .field = PERF_OUTPUT_EVNAME},
        {.str = "trace", .field = PERF_OUTPUT_TRACE},
+       {.str = "ip",    .field = PERF_OUTPUT_IP},
        {.str = "sym",   .field = PERF_OUTPUT_SYM},
+       {.str = "dso",   .field = PERF_OUTPUT_DSO},
+       {.str = "addr",  .field = PERF_OUTPUT_ADDR},
 };
 
 /* default set to maintain compatibility with current format */
 static struct {
        bool user_set;
+       bool wildcard_set;
        u64 fields;
        u64 invalid_fields;
 } output[PERF_TYPE_MAX] = {
@@ -60,7 +69,8 @@ static struct {
 
                .fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
                              PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
-                             PERF_OUTPUT_EVNAME | PERF_OUTPUT_SYM,
+                             PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
+                                 PERF_OUTPUT_SYM | PERF_OUTPUT_DSO,
 
                .invalid_fields = PERF_OUTPUT_TRACE,
        },
@@ -70,7 +80,8 @@ static struct {
 
                .fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
                              PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
-                             PERF_OUTPUT_EVNAME | PERF_OUTPUT_SYM,
+                             PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
+                                 PERF_OUTPUT_SYM | PERF_OUTPUT_DSO,
 
                .invalid_fields = PERF_OUTPUT_TRACE,
        },
@@ -82,6 +93,17 @@ static struct {
                                  PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
                                  PERF_OUTPUT_EVNAME | PERF_OUTPUT_TRACE,
        },
+
+       [PERF_TYPE_RAW] = {
+               .user_set = false,
+
+               .fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
+                             PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
+                             PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
+                                 PERF_OUTPUT_SYM | PERF_OUTPUT_DSO,
+
+               .invalid_fields = PERF_OUTPUT_TRACE,
+       },
 };
 
 static bool output_set_by_user(void)
@@ -94,41 +116,131 @@ static bool output_set_by_user(void)
        return false;
 }
 
+static const char *output_field2str(enum perf_output_field field)
+{
+       int i, imax = ARRAY_SIZE(all_output_options);
+       const char *str = "";
+
+       for (i = 0; i < imax; ++i) {
+               if (all_output_options[i].field == field) {
+                       str = all_output_options[i].str;
+                       break;
+               }
+       }
+       return str;
+}
+
 #define PRINT_FIELD(x)  (output[attr->type].fields & PERF_OUTPUT_##x)
 
-static int perf_session__check_attr(struct perf_session *session,
-                                   struct perf_event_attr *attr)
+static int perf_event_attr__check_stype(struct perf_event_attr *attr,
+                                 u64 sample_type, const char *sample_msg,
+                                 enum perf_output_field field)
+{
+       int type = attr->type;
+       const char *evname;
+
+       if (attr->sample_type & sample_type)
+               return 0;
+
+       if (output[type].user_set) {
+               evname = __event_name(attr->type, attr->config);
+               pr_err("Samples for '%s' event do not have %s attribute set. "
+                      "Cannot print '%s' field.\n",
+                      evname, sample_msg, output_field2str(field));
+               return -1;
+       }
+
+       /* user did not ask for it explicitly so remove from the default list */
+       output[type].fields &= ~field;
+       evname = __event_name(attr->type, attr->config);
+       pr_debug("Samples for '%s' event do not have %s attribute set. "
+                "Skipping '%s' field.\n",
+                evname, sample_msg, output_field2str(field));
+
+       return 0;
+}
+
+static int perf_evsel__check_attr(struct perf_evsel *evsel,
+                                 struct perf_session *session)
 {
+       struct perf_event_attr *attr = &evsel->attr;
+
        if (PRINT_FIELD(TRACE) &&
                !perf_session__has_traces(session, "record -R"))
                return -EINVAL;
 
-       if (PRINT_FIELD(SYM)) {
-               if (!(session->sample_type & PERF_SAMPLE_IP)) {
-                       pr_err("Samples do not contain IP data.\n");
+       if (PRINT_FIELD(IP)) {
+               if (perf_event_attr__check_stype(attr, PERF_SAMPLE_IP, "IP",
+                                          PERF_OUTPUT_IP))
                        return -EINVAL;
-               }
+
                if (!no_callchain &&
-                   !(session->sample_type & PERF_SAMPLE_CALLCHAIN))
+                   !(attr->sample_type & PERF_SAMPLE_CALLCHAIN))
                        symbol_conf.use_callchain = false;
        }
 
-       if ((PRINT_FIELD(PID) || PRINT_FIELD(TID)) &&
-               !(session->sample_type & PERF_SAMPLE_TID)) {
-               pr_err("Samples do not contain TID/PID data.\n");
+       if (PRINT_FIELD(ADDR) &&
+               perf_event_attr__check_stype(attr, PERF_SAMPLE_ADDR, "ADDR",
+                                      PERF_OUTPUT_ADDR))
+               return -EINVAL;
+
+       if (PRINT_FIELD(SYM) && !PRINT_FIELD(IP) && !PRINT_FIELD(ADDR)) {
+               pr_err("Display of symbols requested but neither sample IP nor "
+                          "sample address\nis selected. Hence, no addresses to convert "
+                      "to symbols.\n");
                return -EINVAL;
        }
+       if (PRINT_FIELD(DSO) && !PRINT_FIELD(IP) && !PRINT_FIELD(ADDR)) {
+               pr_err("Display of DSO requested but neither sample IP nor "
+                          "sample address\nis selected. Hence, no addresses to convert "
+                      "to DSO.\n");
+               return -EINVAL;
+       }
+
+       if ((PRINT_FIELD(PID) || PRINT_FIELD(TID)) &&
+               perf_event_attr__check_stype(attr, PERF_SAMPLE_TID, "TID",
+                                      PERF_OUTPUT_TID|PERF_OUTPUT_PID))
+               return -EINVAL;
 
        if (PRINT_FIELD(TIME) &&
-               !(session->sample_type & PERF_SAMPLE_TIME)) {
-               pr_err("Samples do not contain timestamps.\n");
+               perf_event_attr__check_stype(attr, PERF_SAMPLE_TIME, "TIME",
+                                      PERF_OUTPUT_TIME))
                return -EINVAL;
-       }
 
        if (PRINT_FIELD(CPU) &&
-               !(session->sample_type & PERF_SAMPLE_CPU)) {
-               pr_err("Samples do not contain cpu.\n");
+               perf_event_attr__check_stype(attr, PERF_SAMPLE_CPU, "CPU",
+                                      PERF_OUTPUT_CPU))
                return -EINVAL;
+
+       return 0;
+}
+
+/*
+ * verify all user requested events exist and the samples
+ * have the expected data
+ */
+static int perf_session__check_output_opt(struct perf_session *session)
+{
+       int j;
+       struct perf_evsel *evsel;
+
+       for (j = 0; j < PERF_TYPE_MAX; ++j) {
+               evsel = perf_session__find_first_evtype(session, j);
+
+               /*
+                * even if fields is set to 0 (ie., show nothing) event must
+                * exist if user explicitly includes it on the command line
+                */
+               if (!evsel && output[j].user_set && !output[j].wildcard_set) {
+                       pr_err("%s events do not exist. "
+                              "Remove corresponding -f option to proceed.\n",
+                              event_type(j));
+                       return -1;
+               }
+
+               if (evsel && output[j].fields &&
+                       perf_evsel__check_attr(evsel, session))
+                       return -1;
        }
 
        return 0;
@@ -148,7 +260,7 @@ static void print_sample_start(struct perf_sample *sample,
        if (PRINT_FIELD(COMM)) {
                if (latency_format)
                        printf("%8.8s ", thread->comm);
-               else if (PRINT_FIELD(SYM) && symbol_conf.use_callchain)
+               else if (PRINT_FIELD(IP) && symbol_conf.use_callchain)
                        printf("%s ", thread->comm);
                else
                        printf("%16s ", thread->comm);
@@ -189,6 +301,63 @@ static void print_sample_start(struct perf_sample *sample,
        }
 }
 
+static bool sample_addr_correlates_sym(struct perf_event_attr *attr)
+{
+       if ((attr->type == PERF_TYPE_SOFTWARE) &&
+           ((attr->config == PERF_COUNT_SW_PAGE_FAULTS) ||
+            (attr->config == PERF_COUNT_SW_PAGE_FAULTS_MIN) ||
+            (attr->config == PERF_COUNT_SW_PAGE_FAULTS_MAJ)))
+               return true;
+
+       return false;
+}
+
+static void print_sample_addr(union perf_event *event,
+                         struct perf_sample *sample,
+                         struct perf_session *session,
+                         struct thread *thread,
+                         struct perf_event_attr *attr)
+{
+       struct addr_location al;
+       u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
+       const char *symname, *dsoname;
+
+       printf("%16" PRIx64, sample->addr);
+
+       if (!sample_addr_correlates_sym(attr))
+               return;
+
+       thread__find_addr_map(thread, session, cpumode, MAP__FUNCTION,
+                             event->ip.pid, sample->addr, &al);
+       if (!al.map)
+               thread__find_addr_map(thread, session, cpumode, MAP__VARIABLE,
+                                     event->ip.pid, sample->addr, &al);
+
+       al.cpu = sample->cpu;
+       al.sym = NULL;
+
+       if (al.map)
+               al.sym = map__find_symbol(al.map, al.addr, NULL);
+
+       if (PRINT_FIELD(SYM)) {
+               if (al.sym && al.sym->name)
+                       symname = al.sym->name;
+               else
+                       symname = "";
+
+               printf(" %16s", symname);
+       }
+
+       if (PRINT_FIELD(DSO)) {
+               if (al.map && al.map->dso && al.map->dso->name)
+                       dsoname = al.map->dso->name;
+               else
+                       dsoname = "";
+
+               printf(" (%s)", dsoname);
+       }
+}
+
 static void process_event(union perf_event *event __unused,
                          struct perf_sample *sample,
                          struct perf_evsel *evsel,
@@ -200,21 +369,22 @@ static void process_event(union perf_event *event __unused,
        if (output[attr->type].fields == 0)
                return;
 
-       if (perf_session__check_attr(session, attr) < 0)
-               return;
-
        print_sample_start(sample, thread, attr);
 
        if (PRINT_FIELD(TRACE))
                print_trace_event(sample->cpu, sample->raw_data,
                                  sample->raw_size);
 
-       if (PRINT_FIELD(SYM)) {
+       if (PRINT_FIELD(ADDR))
+               print_sample_addr(event, sample, session, thread, attr);
+
+       if (PRINT_FIELD(IP)) {
                if (!symbol_conf.use_callchain)
                        printf(" ");
                else
                        printf("\n");
-               perf_session__print_symbols(event, sample, session);
+               perf_session__print_ip(event, sample, session,
+                                             PRINT_FIELD(SYM), PRINT_FIELD(DSO));
        }
 
        printf("\n");
@@ -286,6 +456,10 @@ static int process_sample_event(union perf_event *event,
                last_timestamp = sample->time;
                return 0;
        }
+
+       if (cpu_list && !test_bit(sample->cpu, cpu_bitmap))
+               return 0;
+
        scripting_ops->process_event(event, sample, evsel, session, thread);
 
        session->hists.stats.total_period += sample->period;
@@ -502,6 +676,8 @@ static int parse_output_fields(const struct option *opt __used,
                        type = PERF_TYPE_SOFTWARE;
                else if (!strcmp(str, "trace"))
                        type = PERF_TYPE_TRACEPOINT;
+               else if (!strcmp(str, "raw"))
+                       type = PERF_TYPE_RAW;
                else {
                        fprintf(stderr, "Invalid event type in field string.\n");
                        return -EINVAL;
@@ -513,6 +689,7 @@ static int parse_output_fields(const struct option *opt __used,
 
                output[type].fields = 0;
                output[type].user_set = true;
+               output[type].wildcard_set = false;
 
        } else {
                tok = str;
@@ -529,6 +706,7 @@ static int parse_output_fields(const struct option *opt __used,
                for (j = 0; j < PERF_TYPE_MAX; ++j) {
                        output[j].fields = 0;
                        output[j].user_set = true;
+                       output[j].wildcard_set = true;
                }
        }
 
@@ -902,8 +1080,9 @@ static const struct option options[] = {
        OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
                    "Look for files with symbols relative to this directory"),
        OPT_CALLBACK('f', "fields", NULL, "str",
-                    "comma separated output fields prepend with 'type:'. Valid types: hw,sw,trace. Fields: comm,tid,pid,time,cpu,event,trace,sym",
+                    "comma separated output fields prepend with 'type:'. Valid types: hw,sw,trace,raw. Fields: comm,tid,pid,time,cpu,event,trace,ip,sym,dso,addr",
                     parse_output_fields),
+       OPT_STRING('c', "cpu", &cpu_list, "cpu", "list of cpus to profile"),
 
        OPT_END()
 };
@@ -1084,6 +1263,11 @@ int cmd_script(int argc, const char **argv, const char *prefix __used)
        if (session == NULL)
                return -ENOMEM;
 
+       if (cpu_list) {
+               if (perf_session__cpu_bitmap(session, cpu_list, cpu_bitmap))
+                       return -1;
+       }
+
        if (!no_callchain)
                symbol_conf.use_callchain = true;
        else
@@ -1133,6 +1317,11 @@ int cmd_script(int argc, const char **argv, const char *prefix __used)
                pr_debug("perf script started with script %s\n\n", script_name);
        }
 
+
+       err = perf_session__check_output_opt(session);
+       if (err < 0)
+               goto out;
+
        err = __cmd_script(session);
 
        perf_session__delete(session);