Blackfin: BF518F-EZBRD: handle required portmuxing of async pins

[safe/jmp/linux-2.6] / kernel / trace / trace_events_filter.c

diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events_filter.c
index 7ac6910..db6e54b 100644 (file)
--- a/kernel/trace/trace_events_filter.c
+++ b/kernel/trace/trace_events_filter.c
@@ -151,6 +151,7 @@ static int filter_pred_or(struct filter_pred *pred __attribute((unused)),
        return val1 || val2;
 }
 
+/* Filter predicate for fixed sized arrays of characters */
 static int filter_pred_string(struct filter_pred *pred, void *event,
                              int val1, int val2)
 {
@@ -164,6 +165,30 @@ static int filter_pred_string(struct filter_pred *pred, void *event,
        return match;
 }
 
+/*
+ * Filter predicate for dynamic sized arrays of characters.
+ * These are implemented through a list of strings at the end
+ * of the entry.
+ * Also each of these strings have a field in the entry which
+ * contains its offset from the beginning of the entry.
+ * We have then first to get this field, dereference it
+ * and add it to the address of the entry, and at last we have
+ * the address of the string.
+ */
+static int filter_pred_strloc(struct filter_pred *pred, void *event,
+                             int val1, int val2)
+{
+       int str_loc = *(int *)(event + pred->offset);
+       char *addr = (char *)(event + str_loc);
+       int cmp, match;
+
+       cmp = strncmp(addr, pred->str_val, pred->str_len);
+
+       match = (!cmp) ^ pred->not;
+
+       return match;
+}
+
 static int filter_pred_none(struct filter_pred *pred, void *event,
                            int val1, int val2)
 {
@@ -446,10 +471,18 @@ static int filter_add_pred_fn(struct filter_parse_state *ps,
        return 0;
 }
 
+enum {
+       FILTER_STATIC_STRING = 1,
+       FILTER_DYN_STRING
+};
+
 static int is_string_field(const char *type)
 {
+       if (strstr(type, "__data_loc") && strstr(type, "char"))
+               return FILTER_DYN_STRING;
+
        if (strchr(type, '[') && strstr(type, "char"))
-               return 1;
+               return FILTER_STATIC_STRING;
 
        return 0;
 }
@@ -512,6 +545,7 @@ static int filter_add_pred(struct filter_parse_state *ps,
        struct ftrace_event_field *field;
        filter_pred_fn_t fn;
        unsigned long long val;
+       int string_type;
 
        pred->fn = filter_pred_none;
 
@@ -536,8 +570,12 @@ static int filter_add_pred(struct filter_parse_state *ps,
                return -EINVAL;
        }
 
-       if (is_string_field(field->type)) {
-               fn = filter_pred_string;
+       string_type = is_string_field(field->type);
+       if (string_type) {
+               if (string_type == FILTER_STATIC_STRING)
+                       fn = filter_pred_string;
+               else
+                       fn = filter_pred_strloc;
                pred->str_len = field->size;
                if (pred->op == OP_NE)
                        pred->not = 1;
@@ -598,14 +636,15 @@ static int filter_add_subsystem_pred(struct filter_parse_state *ps,
 
                err = filter_add_pred(ps, call, pred);
                if (err) {
+                       mutex_unlock(&event_mutex);
                        filter_free_subsystem_preds(system);
                        parse_error(ps, FILT_ERR_BAD_SUBSYS_FILTER, 0);
-                       break;
+                       goto out;
                }
                replace_filter_string(call->filter, filter_string);
        }
        mutex_unlock(&event_mutex);
-
+out:
        return err;
 }
 
@@ -697,7 +736,7 @@ static inline void clear_operand_string(struct filter_parse_state *ps)
 
 static inline int append_operand_char(struct filter_parse_state *ps, char c)
 {
-       if (ps->operand.tail == MAX_FILTER_STR_VAL)
+       if (ps->operand.tail == MAX_FILTER_STR_VAL - 1)
                return -EINVAL;
 
        ps->operand.string[ps->operand.tail++] = c;
@@ -813,10 +852,19 @@ static void postfix_clear(struct filter_parse_state *ps)
 
 static int filter_parse(struct filter_parse_state *ps)
 {
+       int in_string = 0;
        int op, top_op;
        char ch;
 
        while ((ch = infix_next(ps))) {
+               if (ch == '"') {
+                       in_string ^= 1;
+                       continue;
+               }
+
+               if (in_string)
+                       goto parse_operand;
+
                if (isspace(ch))
                        continue;
 
@@ -870,6 +918,7 @@ static int filter_parse(struct filter_parse_state *ps)
                        }
                        continue;
                }
+parse_operand:
                if (append_operand_char(ps, ch)) {
                        parse_error(ps, FILT_ERR_OPERAND_TOO_LONG, 0);
                        return -EINVAL;
@@ -1030,9 +1079,10 @@ int apply_event_filter(struct ftrace_event_call *call, char *filter_string)
                return 0;
        }
 
+       err = -ENOMEM;
        ps = kzalloc(sizeof(*ps), GFP_KERNEL);
        if (!ps)
-               return -ENOMEM;
+               goto out_unlock;
 
        filter_disable_preds(call);
        replace_filter_string(call->filter, filter_string);
@@ -1052,7 +1102,7 @@ out:
        filter_opstack_clear(ps);
        postfix_clear(ps);
        kfree(ps);
-
+out_unlock:
        mutex_unlock(&filter_mutex);
 
        return err;
@@ -1074,9 +1124,10 @@ int apply_subsystem_event_filter(struct event_subsystem *system,
                return 0;
        }
 
+       err = -ENOMEM;
        ps = kzalloc(sizeof(*ps), GFP_KERNEL);
        if (!ps)
-               return -ENOMEM;
+               goto out_unlock;
 
        filter_free_subsystem_preds(system);
        replace_filter_string(system->filter, filter_string);
@@ -1096,7 +1147,7 @@ out:
        filter_opstack_clear(ps);
        postfix_clear(ps);
        kfree(ps);
-
+out_unlock:
        mutex_unlock(&filter_mutex);
 
        return err;