1 files changed, 295 insertions, 104 deletions

diff --git a/tools/lib/traceevent/event-parse.c b/tools/lib/traceevent/event-parse.c
index 554828219c33..5f34aa371b56 100644
--- a/tools/lib/traceevent/event-parse.c
+++ b/tools/lib/traceevent/event-parse.c
@@ -467,8 +467,10 @@ int pevent_register_function(struct pevent *pevent, char *func,
                 item->mod = NULL;
         item->addr = addr;
 
-        pevent->funclist = item;
+        if (!item->func || (mod && !item->mod))
+                die("malloc func");
 
+        pevent->funclist = item;
         pevent->func_count++;
 
         return 0;
@@ -511,12 +513,12 @@ struct printk_list {
 
 static int printk_cmp(const void *a, const void *b)
 {
-        const struct func_map *fa = a;
-        const struct func_map *fb = b;
+        const struct printk_map *pa = a;
+        const struct printk_map *pb = b;
 
-        if (fa->addr < fb->addr)
+        if (pa->addr < pb->addr)
                 return -1;
-        if (fa->addr > fb->addr)
+        if (pa->addr > pb->addr)
                 return 1;
 
         return 0;
@@ -583,10 +585,13 @@ int pevent_register_print_string(struct pevent *pevent, char *fmt,
         item = malloc_or_die(sizeof(*item));
 
         item->next = pevent->printklist;
-        pevent->printklist = item;
         item->printk = strdup(fmt);
         item->addr = addr;
 
+        if (!item->printk)
+                die("malloc fmt");
+
+        pevent->printklist = item;
         pevent->printk_count++;
 
         return 0;
@@ -616,7 +621,9 @@ static struct event_format *alloc_event(void)
 {
         struct event_format *event;
 
-        event = malloc_or_die(sizeof(*event));
+        event = malloc(sizeof(*event));
+        if (!event)
+                return NULL;
         memset(event, 0, sizeof(*event));
 
         return event;
@@ -626,12 +633,8 @@ static void add_event(struct pevent *pevent, struct event_format *event)
 {
         int i;
 
-        if (!pevent->events)
-                pevent->events = malloc_or_die(sizeof(event));
-        else
-                pevent->events =
-                        realloc(pevent->events, sizeof(event) *
-                                (pevent->nr_events + 1));
+        pevent->events = realloc(pevent->events, sizeof(event) *
+                                 (pevent->nr_events + 1));
         if (!pevent->events)
                 die("Can not allocate events");
 
@@ -697,6 +700,10 @@ static void free_arg(struct print_arg *arg)
                 free_arg(arg->symbol.field);
                 free_flag_sym(arg->symbol.symbols);
                 break;
+        case PRINT_HEX:
+                free_arg(arg->hex.field);
+                free_arg(arg->hex.size);
+                break;
         case PRINT_TYPE:
                 free(arg->typecast.type);
                 free_arg(arg->typecast.item);
@@ -775,6 +782,25 @@ int pevent_peek_char(void)
         return __peek_char();
 }
 
+static int extend_token(char **tok, char *buf, int size)
+{
+        char *newtok = realloc(*tok, size);
+
+        if (!newtok) {
+                free(*tok);
+                *tok = NULL;
+                return -1;
+        }
+
+        if (!*tok)
+                strcpy(newtok, buf);
+        else
+                strcat(newtok, buf);
+        *tok = newtok;
+
+        return 0;
+}
+
 static enum event_type force_token(const char *str, char **tok);
 
 static enum event_type __read_token(char **tok)
@@ -859,17 +885,10 @@ static enum event_type __read_token(char **tok)
                 do {
                         if (i == (BUFSIZ - 1)) {
                                 buf[i] = 0;
-                                if (*tok) {
-                                        *tok = realloc(*tok, tok_size + BUFSIZ);
-                                        if (!*tok)
-                                                return EVENT_NONE;
-                                        strcat(*tok, buf);
-                                } else
-                                        *tok = strdup(buf);
+                                tok_size += BUFSIZ;
 
-                                if (!*tok)
+                                if (extend_token(tok, buf, tok_size) < 0)
                                         return EVENT_NONE;
-                                tok_size += BUFSIZ;
                                 i = 0;
                         }
                         last_ch = ch;
@@ -908,17 +927,10 @@ static enum event_type __read_token(char **tok)
         while (get_type(__peek_char()) == type) {
                 if (i == (BUFSIZ - 1)) {
                         buf[i] = 0;
-                        if (*tok) {
-                                *tok = realloc(*tok, tok_size + BUFSIZ);
-                                if (!*tok)
-                                        return EVENT_NONE;
-                                strcat(*tok, buf);
-                        } else
-                                *tok = strdup(buf);
+                        tok_size += BUFSIZ;
 
-                        if (!*tok)
+                        if (extend_token(tok, buf, tok_size) < 0)
                                 return EVENT_NONE;
-                        tok_size += BUFSIZ;
                         i = 0;
                 }
                 ch = __read_char();
@@ -927,14 +939,7 @@ static enum event_type __read_token(char **tok)
 
  out:
         buf[i] = 0;
-        if (*tok) {
-                *tok = realloc(*tok, tok_size + i);
-                if (!*tok)
-                        return EVENT_NONE;
-                strcat(*tok, buf);
-        } else
-                *tok = strdup(buf);
-        if (!*tok)
+        if (extend_token(tok, buf, tok_size + i + 1) < 0)
                 return EVENT_NONE;
 
         if (type == EVENT_ITEM) {
@@ -1255,9 +1260,15 @@ static int event_read_fields(struct event_format *event, struct format_field **f
                                         field->flags |= FIELD_IS_POINTER;
 
                                 if (field->type) {
-                                        field->type = realloc(field->type,
-                                                              strlen(field->type) +
-                                                              strlen(last_token) + 2);
+                                        char *new_type;
+                                        new_type = realloc(field->type,
+                                                           strlen(field->type) +
+                                                           strlen(last_token) + 2);
+                                        if (!new_type) {
+                                                free(last_token);
+                                                goto fail;
+                                        }
+                                        field->type = new_type;
                                         strcat(field->type, " ");
                                         strcat(field->type, last_token);
                                         free(last_token);
@@ -1282,6 +1293,7 @@ static int event_read_fields(struct event_format *event, struct format_field **f
                 if (strcmp(token, "[") == 0) {
                         enum event_type last_type = type;
                         char *brackets = token;
+                        char *new_brackets;
                         int len;
 
                         field->flags |= FIELD_IS_ARRAY;
@@ -1301,9 +1313,14 @@ static int event_read_fields(struct event_format *event, struct format_field **f
                                         len = 1;
                                 last_type = type;
 
-                                brackets = realloc(brackets,
-                                                   strlen(brackets) +
-                                                   strlen(token) + len);
+                                new_brackets = realloc(brackets,
+                                                       strlen(brackets) +
+                                                       strlen(token) + len);
+                                if (!new_brackets) {
+                                        free(brackets);
+                                        goto fail;
+                                }
+                                brackets = new_brackets;
                                 if (len == 2)
                                         strcat(brackets, " ");
                                 strcat(brackets, token);
@@ -1319,7 +1336,12 @@ static int event_read_fields(struct event_format *event, struct format_field **f
 
                         free_token(token);
 
-                        brackets = realloc(brackets, strlen(brackets) + 2);
+                        new_brackets = realloc(brackets, strlen(brackets) + 2);
+                        if (!new_brackets) {
+                                free(brackets);
+                                goto fail;
+                        }
+                        brackets = new_brackets;
                         strcat(brackets, "]");
 
                         /* add brackets to type */
@@ -1330,10 +1352,16 @@ static int event_read_fields(struct event_format *event, struct format_field **f
                          * the format: type [] item;
                          */
                         if (type == EVENT_ITEM) {
-                                field->type = realloc(field->type,
-                                                      strlen(field->type) +
-                                                      strlen(field->name) +
-                                                      strlen(brackets) + 2);
+                                char *new_type;
+                                new_type = realloc(field->type,
+                                                   strlen(field->type) +
+                                                   strlen(field->name) +
+                                                   strlen(brackets) + 2);
+                                if (!new_type) {
+                                        free(brackets);
+                                        goto fail;
+                                }
+                                field->type = new_type;
                                 strcat(field->type, " ");
                                 strcat(field->type, field->name);
                                 free_token(field->name);
@@ -1341,9 +1369,15 @@ static int event_read_fields(struct event_format *event, struct format_field **f
                                 field->name = token;
                                 type = read_token(&token);
                         } else {
-                                field->type = realloc(field->type,
-                                                      strlen(field->type) +
-                                                      strlen(brackets) + 1);
+                                char *new_type;
+                                new_type = realloc(field->type,
+                                                   strlen(field->type) +
+                                                   strlen(brackets) + 1);
+                                if (!new_type) {
+                                        free(brackets);
+                                        goto fail;
+                                }
+                                field->type = new_type;
                                 strcat(field->type, brackets);
                         }
                         free(brackets);
@@ -1726,10 +1760,16 @@ process_op(struct event_format *event, struct print_arg *arg, char **tok)
                 /* could just be a type pointer */
                 if ((strcmp(arg->op.op, "*") == 0) &&
                     type == EVENT_DELIM && (strcmp(token, ")") == 0)) {
+                        char *new_atom;
+
                         if (left->type != PRINT_ATOM)
                                 die("bad pointer type");
-                        left->atom.atom = realloc(left->atom.atom,
+                        new_atom = realloc(left->atom.atom,
                                             strlen(left->atom.atom) + 3);
+                        if (!new_atom)
+                                goto out_free;
+
+                        left->atom.atom = new_atom;
                         strcat(left->atom.atom, " *");
                         free(arg->op.op);
                         *arg = *left;
@@ -2146,6 +2186,8 @@ process_fields(struct event_format *event, struct print_flag_sym **list, char **
                 if (value == NULL)
                         goto out_free;
                 field->value = strdup(value);
+                if (field->value == NULL)
+                        goto out_free;
 
                 free_arg(arg);
                 arg = alloc_arg();
@@ -2159,6 +2201,8 @@ process_fields(struct event_format *event, struct print_flag_sym **list, char **
                 if (value == NULL)
                         goto out_free;
                 field->str = strdup(value);
+                if (field->str == NULL)
+                        goto out_free;
                 free_arg(arg);
                 arg = NULL;
 
@@ -2260,6 +2304,45 @@ process_symbols(struct event_format *event, struct print_arg *arg, char **tok)
 }
 
 static enum event_type
+process_hex(struct event_format *event, struct print_arg *arg, char **tok)
+{
+        struct print_arg *field;
+        enum event_type type;
+        char *token;
+
+        memset(arg, 0, sizeof(*arg));
+        arg->type = PRINT_HEX;
+
+        field = alloc_arg();
+        type = process_arg(event, field, &token);
+
+        if (test_type_token(type, token, EVENT_DELIM, ","))
+                goto out_free;
+
+        arg->hex.field = field;
+
+        free_token(token);
+
+        field = alloc_arg();
+        type = process_arg(event, field, &token);
+
+        if (test_type_token(type, token, EVENT_DELIM, ")"))
+                goto out_free;
+
+        arg->hex.size = field;
+
+        free_token(token);
+        type = read_token_item(tok);
+        return type;
+
+ out_free:
+        free_arg(field);
+        free_token(token);
+        *tok = NULL;
+        return EVENT_ERROR;
+}
+
+static enum event_type
 process_dynamic_array(struct event_format *event, struct print_arg *arg, char **tok)
 {
         struct format_field *field;
@@ -2488,6 +2571,10 @@ process_function(struct event_format *event, struct print_arg *arg,
                 is_symbolic_field = 1;
                 return process_symbols(event, arg, tok);
         }
+        if (strcmp(token, "__print_hex") == 0) {
+                free_token(token);
+                return process_hex(event, arg, tok);
+        }
         if (strcmp(token, "__get_str") == 0) {
                 free_token(token);
                 return process_str(event, arg, tok);
@@ -2541,7 +2628,16 @@ process_arg_token(struct event_format *event, struct print_arg *arg,
                 }
                 /* atoms can be more than one token long */
                 while (type == EVENT_ITEM) {
-                        atom = realloc(atom, strlen(atom) + strlen(token) + 2);
+                        char *new_atom;
+                        new_atom = realloc(atom,
+                                           strlen(atom) + strlen(token) + 2);
+                        if (!new_atom) {
+                                free(atom);
+                                *tok = NULL;
+                                free_token(token);
+                                return EVENT_ERROR;
+                        }
+                        atom = new_atom;
                         strcat(atom, " ");
                         strcat(atom, token);
                         free_token(token);
@@ -2835,7 +2931,7 @@ static int get_common_info(struct pevent *pevent,
         event = pevent->events[0];
         field = pevent_find_common_field(event, type);
         if (!field)
-                die("field '%s' not found", type);
+                return -1;
 
         *offset = field->offset;
         *size = field->size;
@@ -2886,15 +2982,16 @@ static int parse_common_flags(struct pevent *pevent, void *data)
 
 static int parse_common_lock_depth(struct pevent *pevent, void *data)
 {
-        int ret;
-
-        ret = __parse_common(pevent, data,
-                             &pevent->ld_size, &pevent->ld_offset,
-                             "common_lock_depth");
-        if (ret < 0)
-                return -1;
+        return __parse_common(pevent, data,
+                              &pevent->ld_size, &pevent->ld_offset,
+                              "common_lock_depth");
+}
 
-        return ret;
+static int parse_common_migrate_disable(struct pevent *pevent, void *data)
+{
+        return __parse_common(pevent, data,
+                              &pevent->ld_size, &pevent->ld_offset,
+                              "common_migrate_disable");
 }
 
 static int events_id_cmp(const void *a, const void *b);
@@ -2995,6 +3092,7 @@ eval_num_arg(void *data, int size, struct event_format *event, struct print_arg
                 break;
         case PRINT_FLAGS:
         case PRINT_SYMBOL:
+        case PRINT_HEX:
                 break;
         case PRINT_TYPE:
                 val = eval_num_arg(data, size, event, arg->typecast.item);
@@ -3214,11 +3312,13 @@ static void print_str_arg(struct trace_seq *s, void *data, int size,
 {
         struct pevent *pevent = event->pevent;
         struct print_flag_sym *flag;
+        struct format_field *field;
         unsigned long long val, fval;
         unsigned long addr;
         char *str;
+        unsigned char *hex;
         int print;
-        int len;
+        int i, len;
 
         switch (arg->type) {
         case PRINT_NULL:
@@ -3228,27 +3328,29 @@ static void print_str_arg(struct trace_seq *s, void *data, int size,
                 print_str_to_seq(s, format, len_arg, arg->atom.atom);
                 return;
         case PRINT_FIELD:
-                if (!arg->field.field) {
-                        arg->field.field = pevent_find_any_field(event, arg->field.name);
-                        if (!arg->field.field)
+                field = arg->field.field;
+                if (!field) {
+                        field = pevent_find_any_field(event, arg->field.name);
+                        if (!field)
                                 die("field %s not found", arg->field.name);
+                        arg->field.field = field;
                 }
                 /* Zero sized fields, mean the rest of the data */
-                len = arg->field.field->size ? : size - arg->field.field->offset;
+                len = field->size ? : size - field->offset;
 
                 /*
                  * Some events pass in pointers. If this is not an array
                  * and the size is the same as long_size, assume that it
                  * is a pointer.
                  */
-                if (!(arg->field.field->flags & FIELD_IS_ARRAY) &&
-                    arg->field.field->size == pevent->long_size) {
-                        addr = *(unsigned long *)(data + arg->field.field->offset);
+                if (!(field->flags & FIELD_IS_ARRAY) &&
+                    field->size == pevent->long_size) {
+                        addr = *(unsigned long *)(data + field->offset);
                         trace_seq_printf(s, "%lx", addr);
                         break;
                 }
                 str = malloc_or_die(len + 1);
-                memcpy(str, data + arg->field.field->offset, len);
+                memcpy(str, data + field->offset, len);
                 str[len] = 0;
                 print_str_to_seq(s, format, len_arg, str);
                 free(str);
@@ -3281,6 +3383,23 @@ static void print_str_arg(struct trace_seq *s, void *data, int size,
                         }
                 }
                 break;
+        case PRINT_HEX:
+                field = arg->hex.field->field.field;
+                if (!field) {
+                        str = arg->hex.field->field.name;
+                        field = pevent_find_any_field(event, str);
+                        if (!field)
+                                die("field %s not found", str);
+                        arg->hex.field->field.field = field;
+                }
+                hex = data + field->offset;
+                len = eval_num_arg(data, size, event, arg->hex.size);
+                for (i = 0; i < len; i++) {
+                        if (i)
+                                trace_seq_putc(s, ' ');
+                        trace_seq_printf(s, "%02x", hex[i]);
+                }
+                break;
 
         case PRINT_TYPE:
                 break;
@@ -3299,7 +3418,7 @@ static void print_str_arg(struct trace_seq *s, void *data, int size,
                 break;
         }
         case PRINT_BSTRING:
-                trace_seq_printf(s, format, arg->string.string);
+                print_str_to_seq(s, format, len_arg, arg->string.string);
                 break;
         case PRINT_OP:
                 /*
@@ -3363,6 +3482,10 @@ process_defined_func(struct trace_seq *s, void *data, int size,
                         string = malloc_or_die(sizeof(*string));
                         string->next = strings;
                         string->str = strdup(str.buffer);
+                        if (!string->str)
+                                die("malloc str");
+
+                        args[i] = (unsigned long long)string->str;
                         strings = string;
                         trace_seq_destroy(&str);
                         break;
@@ -3400,6 +3523,7 @@ static struct print_arg *make_bprint_args(char *fmt, void *data, int size, struc
         unsigned long long ip, val;
         char *ptr;
         void *bptr;
+        int vsize;
 
         field = pevent->bprint_buf_field;
         ip_field = pevent->bprint_ip_field;
@@ -3448,6 +3572,8 @@ static struct print_arg *make_bprint_args(char *fmt, void *data, int size, struc
                                 goto process_again;
                         case '0' ... '9':
                                 goto process_again;
+                        case '.':
+                                goto process_again;
                         case 'p':
                                 ls = 1;
                                 /* fall through */
@@ -3455,23 +3581,30 @@ static struct print_arg *make_bprint_args(char *fmt, void *data, int size, struc
                         case 'u':
                         case 'x':
                         case 'i':
-                                /* the pointers are always 4 bytes aligned */
-                                bptr = (void *)(((unsigned long)bptr + 3) &
-                                                ~3);
                                 switch (ls) {
                                 case 0:
-                                        ls = 4;
+                                        vsize = 4;
                                         break;
                                 case 1:
-                                        ls = pevent->long_size;
+                                        vsize = pevent->long_size;
                                         break;
                                 case 2:
-                                        ls = 8;
+                                        vsize = 8;
+                                        break;
                                 default:
+                                        vsize = ls; /* ? */
                                         break;
                                 }
-                                val = pevent_read_number(pevent, bptr, ls);
-                                bptr += ls;
+                        /* fall through */
+                        case '*':
+                                if (*ptr == '*')
+                                        vsize = 4;
+
+                                /* the pointers are always 4 bytes aligned */
+                                bptr = (void *)(((unsigned long)bptr + 3) &
+                                                ~3);
+                                val = pevent_read_number(pevent, bptr, vsize);
+                                bptr += vsize;
                                 arg = alloc_arg();
                                 arg->next = NULL;
                                 arg->type = PRINT_ATOM;
@@ -3479,12 +3612,21 @@ static struct print_arg *make_bprint_args(char *fmt, void *data, int size, struc
                                 sprintf(arg->atom.atom, "%lld", val);
                                 *next = arg;
                                 next = &arg->next;
+                                /*
+                                 * The '*' case means that an arg is used as the length.
+                                 * We need to continue to figure out for what.
+                                 */
+                                if (*ptr == '*')
+                                        goto process_again;
+
                                 break;
                         case 's':
                                 arg = alloc_arg();
                                 arg->next = NULL;
                                 arg->type = PRINT_BSTRING;
                                 arg->string.string = strdup(bptr);
+                                if (!arg->string.string)
+                                        break;
                                 bptr += strlen(bptr) + 1;
                                 *next = arg;
                                 next = &arg->next;
@@ -3589,6 +3731,16 @@ static void print_mac_arg(struct trace_seq *s, int mac, void *data, int size,
         trace_seq_printf(s, fmt, buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]);
 }
 
+static int is_printable_array(char *p, unsigned int len)
+{
+        unsigned int i;
+
+        for (i = 0; i < len && p[i]; i++)
+                if (!isprint(p[i]))
+                    return 0;
+        return 1;
+}
+
 static void print_event_fields(struct trace_seq *s, void *data, int size,
                                struct event_format *event)
 {
@@ -3608,7 +3760,8 @@ static void print_event_fields(struct trace_seq *s, void *data, int size,
                                 len = offset >> 16;
                                 offset &= 0xffff;
                         }
-                        if (field->flags & FIELD_IS_STRING) {
+                        if (field->flags & FIELD_IS_STRING &&
+                            is_printable_array(data + offset, len)) {
                                 trace_seq_printf(s, "%s", (char *)data + offset);
                         } else {
                                 trace_seq_puts(s, "ARRAY[");
@@ -3619,6 +3772,7 @@ static void print_event_fields(struct trace_seq *s, void *data, int size,
                                                          *((unsigned char *)data + offset + i));
                                 }
                                 trace_seq_putc(s, ']');
+                                field->flags &= ~FIELD_IS_STRING;
                         }
                 } else {
                         val = pevent_read_number(event->pevent, data + field->offset,
@@ -3758,6 +3912,7 @@ static void pretty_print(struct trace_seq *s, void *data, int size, struct event
                                 } else if (*(ptr+1) == 'M' || *(ptr+1) == 'm') {
                                         print_mac_arg(s, *(ptr+1), data, size, event, arg);
                                         ptr++;
+                                        arg = arg->next;
                                         break;
                                 }
 
@@ -3794,14 +3949,15 @@ static void pretty_print(struct trace_seq *s, void *data, int size, struct event
                                                 break;
                                         }
                                 }
-                                if (pevent->long_size == 8 && ls) {
+                                if (pevent->long_size == 8 && ls &&
+                                    sizeof(long) != 8) {
                                         char *p;
 
                                         ls = 2;
                                         /* make %l into %ll */
                                         p = strchr(format, 'l');
                                         if (p)
-                                                memmove(p, p+1, strlen(p)+1);
+                                                memmove(p+1, p, strlen(p)+1);
                                         else if (strcmp(format, "%p") == 0)
                                                 strcpy(format, "0x%llx");
                                 }
@@ -3878,8 +4034,7 @@ static void pretty_print(struct trace_seq *s, void *data, int size, struct event
  * pevent_data_lat_fmt - parse the data for the latency format
  * @pevent: a handle to the pevent
  * @s: the trace_seq to write to
- * @data: the raw data to read from
- * @size: currently unused.
+ * @record: the record to read from
  *
  * This parses out the Latency format (interrupts disabled,
  * need rescheduling, in hard/soft interrupt, preempt count
@@ -3889,10 +4044,13 @@ void pevent_data_lat_fmt(struct pevent *pevent,
                          struct trace_seq *s, struct pevent_record *record)
 {
         static int check_lock_depth = 1;
+        static int check_migrate_disable = 1;
         static int lock_depth_exists;
+        static int migrate_disable_exists;
         unsigned int lat_flags;
         unsigned int pc;
         int lock_depth;
+        int migrate_disable;
         int hardirq;
         int softirq;
         void *data = record->data;
@@ -3900,18 +4058,26 @@ void pevent_data_lat_fmt(struct pevent *pevent,
         lat_flags = parse_common_flags(pevent, data);
         pc = parse_common_pc(pevent, data);
         /* lock_depth may not always exist */
-        if (check_lock_depth) {
-                struct format_field *field;
-                struct event_format *event;
-
-                check_lock_depth = 0;
-                event = pevent->events[0];
-                field = pevent_find_common_field(event, "common_lock_depth");
-                if (field)
-                        lock_depth_exists = 1;
-        }
         if (lock_depth_exists)
                 lock_depth = parse_common_lock_depth(pevent, data);
+        else if (check_lock_depth) {
+                lock_depth = parse_common_lock_depth(pevent, data);
+                if (lock_depth < 0)
+                        check_lock_depth = 0;
+                else
+                        lock_depth_exists = 1;
+        }
+
+        /* migrate_disable may not always exist */
+        if (migrate_disable_exists)
+                migrate_disable = parse_common_migrate_disable(pevent, data);
+        else if (check_migrate_disable) {
+                migrate_disable = parse_common_migrate_disable(pevent, data);
+                if (migrate_disable < 0)
+                        check_migrate_disable = 0;
+                else
+                        migrate_disable_exists = 1;
+        }
 
         hardirq = lat_flags & TRACE_FLAG_HARDIRQ;
         softirq = lat_flags & TRACE_FLAG_SOFTIRQ;
@@ -3930,6 +4096,13 @@ void pevent_data_lat_fmt(struct pevent *pevent,
         else
                 trace_seq_putc(s, '.');
 
+        if (migrate_disable_exists) {
+                if (migrate_disable < 0)
+                        trace_seq_putc(s, '.');
+                else
+                        trace_seq_printf(s, "%d", migrate_disable);
+        }
+
         if (lock_depth_exists) {
                 if (lock_depth < 0)
                         trace_seq_putc(s, '.');
@@ -3996,10 +4169,7 @@ const char *pevent_data_comm_from_pid(struct pevent *pevent, int pid)
  * pevent_data_comm_from_pid - parse the data into the print format
  * @s: the trace_seq to write to
  * @event: the handle to the event
- * @cpu: the cpu the event was recorded on
- * @data: the raw data
- * @size: the size of the raw data
- * @nsecs: the timestamp of the event
+ * @record: the record to read from
  *
  * This parses the raw @data using the given @event information and
  * writes the print format into the trace_seq.
@@ -4279,6 +4449,13 @@ static void print_args(struct print_arg *args)
                 trace_seq_destroy(&s);
                 printf(")");
                 break;
+        case PRINT_HEX:
+                printf("__print_hex(");
+                print_args(args->hex.field);
+                printf(", ");
+                print_args(args->hex.size);
+                printf(")");
+                break;
         case PRINT_STRING:
         case PRINT_BSTRING:
                 printf("__get_str(%s)", args->string.string);
@@ -4541,6 +4718,8 @@ int pevent_parse_event(struct pevent *pevent,
                 die("failed to read event id");
 
         event->system = strdup(sys);
+        if (!event->system)
+                die("failed to allocate system");
 
         /* Add pevent to event so that it can be referenced */
         event->pevent = pevent;
@@ -4582,6 +4761,11 @@ int pevent_parse_event(struct pevent *pevent,
                         list = &arg->next;
                         arg->type = PRINT_FIELD;
                         arg->field.name = strdup(field->name);
+                        if (!arg->field.name) {
+                                do_warning("failed to allocate field name");
+                                event->flags |= EVENT_FL_FAILED;
+                                return -1;
+                        }
                         arg->field.field = field;
                 }
                 return 0;
@@ -4753,7 +4937,7 @@ int pevent_get_any_field_val(struct trace_seq *s, struct event_format *event,
  * @record: The record with the field name.
  * @err: print default error if failed.
  *
- * Returns: 0 on success, -1 field not fould, or 1 if buffer is full.
+ * Returns: 0 on success, -1 field not found, or 1 if buffer is full.
  */
 int pevent_print_num_field(struct trace_seq *s, const char *fmt,
                            struct event_format *event, const char *name,
@@ -4795,11 +4979,12 @@ static void free_func_handle(struct pevent_function_handler *func)
  * pevent_register_print_function - register a helper function
  * @pevent: the handle to the pevent
  * @func: the function to process the helper function
+ * @ret_type: the return type of the helper function
  * @name: the name of the helper function
  * @parameters: A list of enum pevent_func_arg_type
  *
  * Some events may have helper functions in the print format arguments.
- * This allows a plugin to dynmically create a way to process one
+ * This allows a plugin to dynamically create a way to process one
  * of these functions.
  *
  * The @parameters is a variable list of pevent_func_arg_type enums that
@@ -4870,12 +5055,13 @@ int pevent_register_print_function(struct pevent *pevent,
 }
 
 /**
- * pevent_register_event_handle - register a way to parse an event
+ * pevent_register_event_handler - register a way to parse an event
  * @pevent: the handle to the pevent
  * @id: the id of the event to register
  * @sys_name: the system name the event belongs to
  * @event_name: the name of the event
  * @func: the function to call to parse the event information
+ * @context: the data to be passed to @func
  *
  * This function allows a developer to override the parsing of
  * a given event. If for some reason the default print format
@@ -4925,6 +5111,11 @@ int pevent_register_event_handler(struct pevent *pevent,
         if (sys_name)
                 handle->sys_name = strdup(sys_name);
 
+        if ((event_name && !handle->event_name) ||
+            (sys_name && !handle->sys_name)) {
+                die("Failed to allocate event/sys name");
+        }
+
         handle->func = func;
         handle->next = pevent->handlers;
         pevent->handlers = handle;