Merge branch 'perf/scripting' into perf/core

Merge reason: it's ready for v2.6.33.

Signed-off-by: Ingo Molnar <mingo@elte.hu>

4 files changed, 705 insertions, 8 deletions

diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
index 7021dc1b0ca6..0302405aa2ca 100644
--- a/tools/perf/util/trace-event-parse.c
+++ b/tools/perf/util/trace-event-parse.c
@@ -48,6 +48,11 @@ static unsigned long long input_buf_siz;
 
 static int cpus;
 static int long_size;
+static int is_flag_field;
+static int is_symbolic_field;
+
+static struct format_field *
+find_any_field(struct event *event, const char *name);
 
 static void init_input_buf(char *buf, unsigned long long size)
 {
@@ -1301,6 +1306,16 @@ process_entry(struct event *event __unused, struct print_arg *arg,
         arg->type = PRINT_FIELD;
         arg->field.name = field;
 
+        if (is_flag_field) {
+                arg->field.field = find_any_field(event, arg->field.name);
+                arg->field.field->flags |= FIELD_IS_FLAG;
+                is_flag_field = 0;
+        } else if (is_symbolic_field) {
+                arg->field.field = find_any_field(event, arg->field.name);
+                arg->field.field->flags |= FIELD_IS_SYMBOLIC;
+                is_symbolic_field = 0;
+        }
+
         type = read_token(&token);
         *tok = token;
 
@@ -1668,9 +1683,11 @@ process_arg_token(struct event *event, struct print_arg *arg,
                         type = process_entry(event, arg, &token);
                 } else if (strcmp(token, "__print_flags") == 0) {
                         free_token(token);
+                        is_flag_field = 1;
                         type = process_flags(event, arg, &token);
                 } else if (strcmp(token, "__print_symbolic") == 0) {
                         free_token(token);
+                        is_symbolic_field = 1;
                         type = process_symbols(event, arg, &token);
                 } else if (strcmp(token, "__get_str") == 0) {
                         free_token(token);
@@ -1871,7 +1888,7 @@ find_any_field(struct event *event, const char *name)
         return find_field(event, name);
 }
 
-static unsigned long long read_size(void *ptr, int size)
+unsigned long long read_size(void *ptr, int size)
 {
         switch (size) {
         case 1:
@@ -1956,7 +1973,7 @@ int trace_parse_common_type(void *data)
                               "common_type");
 }
 
-static int parse_common_pid(void *data)
+int trace_parse_common_pid(void *data)
 {
         static int pid_offset;
         static int pid_size;
@@ -1965,7 +1982,7 @@ static int parse_common_pid(void *data)
                               "common_pid");
 }
 
-static int parse_common_pc(void *data)
+int parse_common_pc(void *data)
 {
         static int pc_offset;
         static int pc_size;
@@ -1974,7 +1991,7 @@ static int parse_common_pc(void *data)
                               "common_preempt_count");
 }
 
-static int parse_common_flags(void *data)
+int parse_common_flags(void *data)
 {
         static int flags_offset;
         static int flags_size;
@@ -1983,7 +2000,7 @@ static int parse_common_flags(void *data)
                               "common_flags");
 }
 
-static int parse_common_lock_depth(void *data)
+int parse_common_lock_depth(void *data)
 {
         static int ld_offset;
         static int ld_size;
@@ -2008,6 +2025,14 @@ struct event *trace_find_event(int id)
         return event;
 }
 
+struct event *trace_find_next_event(struct event *event)
+{
+        if (!event)
+                return event_list;
+
+        return event->next;
+}
+
 static unsigned long long eval_num_arg(void *data, int size,
                                    struct event *event, struct print_arg *arg)
 {
@@ -2147,7 +2172,7 @@ static const struct flag flags[] = {
         { "HRTIMER_RESTART", 1 },
 };
 
-static unsigned long long eval_flag(const char *flag)
+unsigned long long eval_flag(const char *flag)
 {
         int i;
 
@@ -2677,7 +2702,7 @@ get_return_for_leaf(int cpu, int cur_pid, unsigned long long cur_func,
         if (!(event->flags & EVENT_FL_ISFUNCRET))
                 return NULL;
 
-        pid = parse_common_pid(next->data);
+        pid = trace_parse_common_pid(next->data);
         field = find_field(event, "func");
         if (!field)
                 die("function return does not have field func");
@@ -2963,7 +2988,7 @@ void print_event(int cpu, void *data, int size, unsigned long long nsecs,
                 return;
         }
 
-        pid = parse_common_pid(data);
+        pid = trace_parse_common_pid(data);
 
         if (event->flags & (EVENT_FL_ISFUNCENT | EVENT_FL_ISFUNCRET))
                 return pretty_print_func_graph(data, size, event, cpu,
diff --git a/tools/perf/util/trace-event-perl.c b/tools/perf/util/trace-event-perl.c
new file mode 100644
index 000000000000..51e833fd58c3
--- /dev/null
+++ b/tools/perf/util/trace-event-perl.c
@@ -0,0 +1,598 @@
+/*
+ * trace-event-perl.  Feed perf trace events to an embedded Perl interpreter.
+ *
+ * Copyright (C) 2009 Tom Zanussi <tzanussi@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include "../perf.h"
+#include "util.h"
+#include "trace-event.h"
+#include "trace-event-perl.h"
+
+void xs_init(pTHX);
+
+void boot_Perf__Trace__Context(pTHX_ CV *cv);
+void boot_DynaLoader(pTHX_ CV *cv);
+
+void xs_init(pTHX)
+{
+        const char *file = __FILE__;
+        dXSUB_SYS;
+
+        newXS("Perf::Trace::Context::bootstrap", boot_Perf__Trace__Context,
+              file);
+        newXS("DynaLoader::boot_DynaLoader", boot_DynaLoader, file);
+}
+
+INTERP my_perl;
+
+#define FTRACE_MAX_EVENT                                \
+        ((1 << (sizeof(unsigned short) * 8)) - 1)
+
+struct event *events[FTRACE_MAX_EVENT];
+
+static struct scripting_context *scripting_context;
+
+static char *cur_field_name;
+static int zero_flag_atom;
+
+static void define_symbolic_value(const char *ev_name,
+                                  const char *field_name,
+                                  const char *field_value,
+                                  const char *field_str)
+{
+        unsigned long long value;
+        dSP;
+
+        value = eval_flag(field_value);
+
+        ENTER;
+        SAVETMPS;
+        PUSHMARK(SP);
+
+        XPUSHs(sv_2mortal(newSVpv(ev_name, 0)));
+        XPUSHs(sv_2mortal(newSVpv(field_name, 0)));
+        XPUSHs(sv_2mortal(newSVuv(value)));
+        XPUSHs(sv_2mortal(newSVpv(field_str, 0)));
+
+        PUTBACK;
+        if (get_cv("main::define_symbolic_value", 0))
+                call_pv("main::define_symbolic_value", G_SCALAR);
+        SPAGAIN;
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+}
+
+static void define_symbolic_values(struct print_flag_sym *field,
+                                   const char *ev_name,
+                                   const char *field_name)
+{
+        define_symbolic_value(ev_name, field_name, field->value, field->str);
+        if (field->next)
+                define_symbolic_values(field->next, ev_name, field_name);
+}
+
+static void define_symbolic_field(const char *ev_name,
+                                  const char *field_name)
+{
+        dSP;
+
+        ENTER;
+        SAVETMPS;
+        PUSHMARK(SP);
+
+        XPUSHs(sv_2mortal(newSVpv(ev_name, 0)));
+        XPUSHs(sv_2mortal(newSVpv(field_name, 0)));
+
+        PUTBACK;
+        if (get_cv("main::define_symbolic_field", 0))
+                call_pv("main::define_symbolic_field", G_SCALAR);
+        SPAGAIN;
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+}
+
+static void define_flag_value(const char *ev_name,
+                              const char *field_name,
+                              const char *field_value,
+                              const char *field_str)
+{
+        unsigned long long value;
+        dSP;
+
+        value = eval_flag(field_value);
+
+        ENTER;
+        SAVETMPS;
+        PUSHMARK(SP);
+
+        XPUSHs(sv_2mortal(newSVpv(ev_name, 0)));
+        XPUSHs(sv_2mortal(newSVpv(field_name, 0)));
+        XPUSHs(sv_2mortal(newSVuv(value)));
+        XPUSHs(sv_2mortal(newSVpv(field_str, 0)));
+
+        PUTBACK;
+        if (get_cv("main::define_flag_value", 0))
+                call_pv("main::define_flag_value", G_SCALAR);
+        SPAGAIN;
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+}
+
+static void define_flag_values(struct print_flag_sym *field,
+                               const char *ev_name,
+                               const char *field_name)
+{
+        define_flag_value(ev_name, field_name, field->value, field->str);
+        if (field->next)
+                define_flag_values(field->next, ev_name, field_name);
+}
+
+static void define_flag_field(const char *ev_name,
+                              const char *field_name,
+                              const char *delim)
+{
+        dSP;
+
+        ENTER;
+        SAVETMPS;
+        PUSHMARK(SP);
+
+        XPUSHs(sv_2mortal(newSVpv(ev_name, 0)));
+        XPUSHs(sv_2mortal(newSVpv(field_name, 0)));
+        XPUSHs(sv_2mortal(newSVpv(delim, 0)));
+
+        PUTBACK;
+        if (get_cv("main::define_flag_field", 0))
+                call_pv("main::define_flag_field", G_SCALAR);
+        SPAGAIN;
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+}
+
+static void define_event_symbols(struct event *event,
+                                 const char *ev_name,
+                                 struct print_arg *args)
+{
+        switch (args->type) {
+        case PRINT_NULL:
+                break;
+        case PRINT_ATOM:
+                define_flag_value(ev_name, cur_field_name, "0",
+                                  args->atom.atom);
+                zero_flag_atom = 0;
+                break;
+        case PRINT_FIELD:
+                if (cur_field_name)
+                        free(cur_field_name);
+                cur_field_name = strdup(args->field.name);
+                break;
+        case PRINT_FLAGS:
+                define_event_symbols(event, ev_name, args->flags.field);
+                define_flag_field(ev_name, cur_field_name, args->flags.delim);
+                define_flag_values(args->flags.flags, ev_name, cur_field_name);
+                break;
+        case PRINT_SYMBOL:
+                define_event_symbols(event, ev_name, args->symbol.field);
+                define_symbolic_field(ev_name, cur_field_name);
+                define_symbolic_values(args->symbol.symbols, ev_name,
+                                       cur_field_name);
+                break;
+        case PRINT_STRING:
+                break;
+        case PRINT_TYPE:
+                define_event_symbols(event, ev_name, args->typecast.item);
+                break;
+        case PRINT_OP:
+                if (strcmp(args->op.op, ":") == 0)
+                        zero_flag_atom = 1;
+                define_event_symbols(event, ev_name, args->op.left);
+                define_event_symbols(event, ev_name, args->op.right);
+                break;
+        default:
+                /* we should warn... */
+                return;
+        }
+
+        if (args->next)
+                define_event_symbols(event, ev_name, args->next);
+}
+
+static inline struct event *find_cache_event(int type)
+{
+        static char ev_name[256];
+        struct event *event;
+
+        if (events[type])
+                return events[type];
+
+        events[type] = event = trace_find_event(type);
+        if (!event)
+                return NULL;
+
+        sprintf(ev_name, "%s::%s", event->system, event->name);
+
+        define_event_symbols(event, ev_name, event->print_fmt.args);
+
+        return event;
+}
+
+int common_pc(struct scripting_context *context)
+{
+        int pc;
+
+        pc = parse_common_pc(context->event_data);
+
+        return pc;
+}
+
+int common_flags(struct scripting_context *context)
+{
+        int flags;
+
+        flags = parse_common_flags(context->event_data);
+
+        return flags;
+}
+
+int common_lock_depth(struct scripting_context *context)
+{
+        int lock_depth;
+
+        lock_depth = parse_common_lock_depth(context->event_data);
+
+        return lock_depth;
+}
+
+static void perl_process_event(int cpu, void *data,
+                               int size __attribute((unused)),
+                               unsigned long long nsecs, char *comm)
+{
+        struct format_field *field;
+        static char handler[256];
+        unsigned long long val;
+        unsigned long s, ns;
+        struct event *event;
+        int type;
+        int pid;
+
+        dSP;
+
+        type = trace_parse_common_type(data);
+
+        event = find_cache_event(type);
+        if (!event)
+                die("ug! no event found for type %d", type);
+
+        pid = trace_parse_common_pid(data);
+
+        sprintf(handler, "%s::%s", event->system, event->name);
+
+        s = nsecs / NSECS_PER_SEC;
+        ns = nsecs - s * NSECS_PER_SEC;
+
+        scripting_context->event_data = data;
+
+        ENTER;
+        SAVETMPS;
+        PUSHMARK(SP);
+
+        XPUSHs(sv_2mortal(newSVpv(handler, 0)));
+        XPUSHs(sv_2mortal(newSViv(PTR2IV(scripting_context))));
+        XPUSHs(sv_2mortal(newSVuv(cpu)));
+        XPUSHs(sv_2mortal(newSVuv(s)));
+        XPUSHs(sv_2mortal(newSVuv(ns)));
+        XPUSHs(sv_2mortal(newSViv(pid)));
+        XPUSHs(sv_2mortal(newSVpv(comm, 0)));
+
+        /* common fields other than pid can be accessed via xsub fns */
+
+        for (field = event->format.fields; field; field = field->next) {
+                if (field->flags & FIELD_IS_STRING) {
+                        int offset;
+                        if (field->flags & FIELD_IS_DYNAMIC) {
+                                offset = *(int *)(data + field->offset);
+                                offset &= 0xffff;
+                        } else
+                                offset = field->offset;
+                        XPUSHs(sv_2mortal(newSVpv((char *)data + offset, 0)));
+                } else { /* FIELD_IS_NUMERIC */
+                        val = read_size(data + field->offset, field->size);
+                        if (field->flags & FIELD_IS_SIGNED) {
+                                XPUSHs(sv_2mortal(newSViv(val)));
+                        } else {
+                                XPUSHs(sv_2mortal(newSVuv(val)));
+                        }
+                }
+        }
+
+        PUTBACK;
+
+        if (get_cv(handler, 0))
+                call_pv(handler, G_SCALAR);
+        else if (get_cv("main::trace_unhandled", 0)) {
+                XPUSHs(sv_2mortal(newSVpv(handler, 0)));
+                XPUSHs(sv_2mortal(newSViv(PTR2IV(scripting_context))));
+                XPUSHs(sv_2mortal(newSVuv(cpu)));
+                XPUSHs(sv_2mortal(newSVuv(nsecs)));
+                XPUSHs(sv_2mortal(newSViv(pid)));
+                XPUSHs(sv_2mortal(newSVpv(comm, 0)));
+                call_pv("main::trace_unhandled", G_SCALAR);
+        }
+        SPAGAIN;
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+}
+
+static void run_start_sub(void)
+{
+        dSP; /* access to Perl stack */
+        PUSHMARK(SP);
+
+        if (get_cv("main::trace_begin", 0))
+                call_pv("main::trace_begin", G_DISCARD | G_NOARGS);
+}
+
+/*
+ * Start trace script
+ */
+static int perl_start_script(const char *script)
+{
+        const char *command_line[2] = { "", NULL };
+
+        command_line[1] = script;
+
+        my_perl = perl_alloc();
+        perl_construct(my_perl);
+
+        if (perl_parse(my_perl, xs_init, 2, (char **)command_line,
+                       (char **)NULL))
+                return -1;
+
+        perl_run(my_perl);
+        if (SvTRUE(ERRSV))
+                return -1;
+
+        run_start_sub();
+
+        fprintf(stderr, "perf trace started with Perl script %s\n\n", script);
+
+        return 0;
+}
+
+/*
+ * Stop trace script
+ */
+static int perl_stop_script(void)
+{
+        dSP; /* access to Perl stack */
+        PUSHMARK(SP);
+
+        if (get_cv("main::trace_end", 0))
+                call_pv("main::trace_end", G_DISCARD | G_NOARGS);
+
+        perl_destruct(my_perl);
+        perl_free(my_perl);
+
+        fprintf(stderr, "\nperf trace Perl script stopped\n");
+
+        return 0;
+}
+
+static int perl_generate_script(const char *outfile)
+{
+        struct event *event = NULL;
+        struct format_field *f;
+        char fname[PATH_MAX];
+        int not_first, count;
+        FILE *ofp;
+
+        sprintf(fname, "%s.pl", outfile);
+        ofp = fopen(fname, "w");
+        if (ofp == NULL) {
+                fprintf(stderr, "couldn't open %s\n", fname);
+                return -1;
+        }
+
+        fprintf(ofp, "# perf trace event handlers, "
+                "generated by perf trace -g perl\n");
+
+        fprintf(ofp, "# Licensed under the terms of the GNU GPL"
+                " License version 2\n\n");
+
+        fprintf(ofp, "# The common_* event handler fields are the most useful "
+                "fields common to\n");
+
+        fprintf(ofp, "# all events.  They don't necessarily correspond to "
+                "the 'common_*' fields\n");
+
+        fprintf(ofp, "# in the format files.  Those fields not available as "
+                "handler params can\n");
+
+        fprintf(ofp, "# be retrieved using Perl functions of the form "
+                "common_*($context).\n");
+
+        fprintf(ofp, "# See Context.pm for the list of available "
+                "functions.\n\n");
+
+        fprintf(ofp, "use lib \"$ENV{'PERF_EXEC_PATH'}/scripts/perl/"
+                "Perf-Trace-Util/lib\";\n");
+
+        fprintf(ofp, "use lib \"./Perf-Trace-Util/lib\";\n");
+        fprintf(ofp, "use Perf::Trace::Core;\n");
+        fprintf(ofp, "use Perf::Trace::Context;\n");
+        fprintf(ofp, "use Perf::Trace::Util;\n\n");
+
+        fprintf(ofp, "sub trace_begin\n{\n\t# optional\n}\n\n");
+        fprintf(ofp, "sub trace_end\n{\n\t# optional\n}\n\n");
+
+        while ((event = trace_find_next_event(event))) {
+                fprintf(ofp, "sub %s::%s\n{\n", event->system, event->name);
+                fprintf(ofp, "\tmy (");
+
+                fprintf(ofp, "$event_name, ");
+                fprintf(ofp, "$context, ");
+                fprintf(ofp, "$common_cpu, ");
+                fprintf(ofp, "$common_secs, ");
+                fprintf(ofp, "$common_nsecs,\n");
+                fprintf(ofp, "\t    $common_pid, ");
+                fprintf(ofp, "$common_comm,\n\t    ");
+
+                not_first = 0;
+                count = 0;
+
+                for (f = event->format.fields; f; f = f->next) {
+                        if (not_first++)
+                                fprintf(ofp, ", ");
+                        if (++count % 5 == 0)
+                                fprintf(ofp, "\n\t    ");
+
+                        fprintf(ofp, "$%s", f->name);
+                }
+                fprintf(ofp, ") = @_;\n\n");
+
+                fprintf(ofp, "\tprint_header($event_name, $common_cpu, "
+                        "$common_secs, $common_nsecs,\n\t             "
+                        "$common_pid, $common_comm);\n\n");
+
+                fprintf(ofp, "\tprintf(\"");
+
+                not_first = 0;
+                count = 0;
+
+                for (f = event->format.fields; f; f = f->next) {
+                        if (not_first++)
+                                fprintf(ofp, ", ");
+                        if (count && count % 4 == 0) {
+                                fprintf(ofp, "\".\n\t       \"");
+                        }
+                        count++;
+
+                        fprintf(ofp, "%s=", f->name);
+                        if (f->flags & FIELD_IS_STRING ||
+                            f->flags & FIELD_IS_FLAG ||
+                            f->flags & FIELD_IS_SYMBOLIC)
+                                fprintf(ofp, "%%s");
+                        else if (f->flags & FIELD_IS_SIGNED)
+                                fprintf(ofp, "%%d");
+                        else
+                                fprintf(ofp, "%%u");
+                }
+
+                fprintf(ofp, "\\n\",\n\t       ");
+
+                not_first = 0;
+                count = 0;
+
+                for (f = event->format.fields; f; f = f->next) {
+                        if (not_first++)
+                                fprintf(ofp, ", ");
+
+                        if (++count % 5 == 0)
+                                fprintf(ofp, "\n\t       ");
+
+                        if (f->flags & FIELD_IS_FLAG) {
+                                if ((count - 1) % 5 != 0) {
+                                        fprintf(ofp, "\n\t       ");
+                                        count = 4;
+                                }
+                                fprintf(ofp, "flag_str(\"");
+                                fprintf(ofp, "%s::%s\", ", event->system,
+                                        event->name);
+                                fprintf(ofp, "\"%s\", $%s)", f->name,
+                                        f->name);
+                        } else if (f->flags & FIELD_IS_SYMBOLIC) {
+                                if ((count - 1) % 5 != 0) {
+                                        fprintf(ofp, "\n\t       ");
+                                        count = 4;
+                                }
+                                fprintf(ofp, "symbol_str(\"");
+                                fprintf(ofp, "%s::%s\", ", event->system,
+                                        event->name);
+                                fprintf(ofp, "\"%s\", $%s)", f->name,
+                                        f->name);
+                        } else
+                                fprintf(ofp, "$%s", f->name);
+                }
+
+                fprintf(ofp, ");\n");
+                fprintf(ofp, "}\n\n");
+        }
+
+        fprintf(ofp, "sub trace_unhandled\n{\n\tmy ($event_name, $context, "
+                "$common_cpu, $common_secs, $common_nsecs,\n\t    "
+                "$common_pid, $common_comm) = @_;\n\n");
+
+        fprintf(ofp, "\tprint_header($event_name, $common_cpu, "
+                "$common_secs, $common_nsecs,\n\t             $common_pid, "
+                "$common_comm);\n}\n\n");
+
+        fprintf(ofp, "sub print_header\n{\n"
+                "\tmy ($event_name, $cpu, $secs, $nsecs, $pid, $comm) = @_;\n\n"
+                "\tprintf(\"%%-20s %%5u %%05u.%%09u %%8u %%-20s \",\n\t       "
+                "$event_name, $cpu, $secs, $nsecs, $pid, $comm);\n}");
+
+        fclose(ofp);
+
+        fprintf(stderr, "generated Perl script: %s\n", fname);
+
+        return 0;
+}
+
+struct scripting_ops perl_scripting_ops = {
+        .name = "Perl",
+        .start_script = perl_start_script,
+        .stop_script = perl_stop_script,
+        .process_event = perl_process_event,
+        .generate_script = perl_generate_script,
+};
+
+#ifdef NO_LIBPERL
+void setup_perl_scripting(void)
+{
+        fprintf(stderr, "Perl scripting not supported."
+                "  Install libperl and rebuild perf to enable it.  e.g. "
+                "apt-get install libperl-dev (ubuntu), yum install "
+                "perl-ExtUtils-Embed (Fedora), etc.\n");
+}
+#else
+void setup_perl_scripting(void)
+{
+        int err;
+        err = script_spec_register("Perl", &perl_scripting_ops);
+        if (err)
+                die("error registering Perl script extension");
+
+        err = script_spec_register("pl", &perl_scripting_ops);
+        if (err)
+                die("error registering pl script extension");
+
+        scripting_context = malloc(sizeof(struct scripting_context));
+}
+#endif
diff --git a/tools/perf/util/trace-event-perl.h b/tools/perf/util/trace-event-perl.h
new file mode 100644
index 000000000000..8fe0d866fe1a
--- /dev/null
+++ b/tools/perf/util/trace-event-perl.h
@@ -0,0 +1,51 @@
+#ifndef __PERF_TRACE_EVENT_PERL_H
+#define __PERF_TRACE_EVENT_PERL_H
+#ifdef NO_LIBPERL
+typedef int INTERP;
+#define dSP
+#define ENTER
+#define SAVETMPS
+#define PUTBACK
+#define SPAGAIN
+#define FREETMPS
+#define LEAVE
+#define SP
+#define ERRSV
+#define G_SCALAR                (0)
+#define G_DISCARD               (0)
+#define G_NOARGS                (0)
+#define PUSHMARK(a)
+#define SvTRUE(a)               (0)
+#define XPUSHs(s)
+#define sv_2mortal(a)
+#define newSVpv(a,b)
+#define newSVuv(a)
+#define newSViv(a)
+#define get_cv(a,b)             (0)
+#define call_pv(a,b)            (0)
+#define perl_alloc()            (0)
+#define perl_construct(a)       (0)
+#define perl_parse(a,b,c,d,e)   (0)
+#define perl_run(a)             (0)
+#define perl_destruct(a)        (0)
+#define perl_free(a)            (0)
+#define pTHX                    void
+#define CV                      void
+#define dXSUB_SYS
+#define pTHX_
+static inline void newXS(const char *a, void *b, const char *c) {}
+#else
+#include <EXTERN.h>
+#include <perl.h>
+typedef PerlInterpreter * INTERP;
+#endif
+
+struct scripting_context {
+        void *event_data;
+};
+
+int common_pc(struct scripting_context *context);
+int common_flags(struct scripting_context *context);
+int common_lock_depth(struct scripting_context *context);
+
+#endif /* __PERF_TRACE_EVENT_PERL_H */
diff --git a/tools/perf/util/trace-event.h b/tools/perf/util/trace-event.h
index dd51c6872a15..81698d5e6503 100644
--- a/tools/perf/util/trace-event.h
+++ b/tools/perf/util/trace-event.h
@@ -29,6 +29,8 @@ enum format_flags {
         FIELD_IS_SIGNED         = 4,
         FIELD_IS_STRING         = 8,
         FIELD_IS_DYNAMIC        = 16,
+        FIELD_IS_FLAG           = 32,
+        FIELD_IS_SYMBOLIC       = 64,
 };
 
 struct format_field {
@@ -243,10 +245,17 @@ extern int latency_format;
 
 int parse_header_page(char *buf, unsigned long size);
 int trace_parse_common_type(void *data);
+int trace_parse_common_pid(void *data);
+int parse_common_pc(void *data);
+int parse_common_flags(void *data);
+int parse_common_lock_depth(void *data);
 struct event *trace_find_event(int id);
+struct event *trace_find_next_event(struct event *event);
+unsigned long long read_size(void *ptr, int size);
 unsigned long long
 raw_field_value(struct event *event, const char *name, void *data);
 void *raw_field_ptr(struct event *event, const char *name, void *data);
+unsigned long long eval_flag(const char *flag);
 
 int read_tracing_data(int fd, struct perf_event_attr *pattrs, int nb_events);
 
@@ -259,4 +268,18 @@ enum trace_flag_type {
         TRACE_FLAG_SOFTIRQ              = 0x10,
 };
 
+struct scripting_ops {
+        const char *name;
+        int (*start_script) (const char *);
+        int (*stop_script) (void);
+        void (*process_event) (int cpu, void *data, int size,
+                               unsigned long long nsecs, char *comm);
+        int (*generate_script) (const char *outfile);
+};
+
+int script_spec_register(const char *spec, struct scripting_ops *ops);
+
+extern struct scripting_ops perl_scripting_ops;
+void setup_perl_scripting(void);
+
 #endif /* __PERF_TRACE_EVENTS_H */