![Tejun Heo](/assets/img/avatar_default.png)
There are four places where new filter for a given filter string is
created, which involves several different steps. This patch factors
those steps into create_[system_]filter() functions which in turn make
use of create_filter_{start|finish}() for common parts.
The only functional change is that if replace_filter_string() is
requested and fails, creation fails without any side effect instead of
being ignored.
Note that system filter is now installed after the processing is
complete which makes freeing before and then restoring filter string
on error unncessary.
-v2: Rebased to resolve conflict with 49aa29513e
and updated both
create_filter() functions to always set *filterp instead of
requiring the caller to clear it to %NULL on entry.
Link: http://lkml.kernel.org/r/1323988305-1469-2-git-send-email-tj@kernel.org
Signed-off-by: Tejun Heo <tj@kernel.org>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2162 lines
48 KiB
C
2162 lines
48 KiB
C
/*
|
|
* trace_events_filter - generic event filtering
|
|
*
|
|
* 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.
|
|
*
|
|
* Copyright (C) 2009 Tom Zanussi <tzanussi@gmail.com>
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/ctype.h>
|
|
#include <linux/mutex.h>
|
|
#include <linux/perf_event.h>
|
|
#include <linux/slab.h>
|
|
|
|
#include "trace.h"
|
|
#include "trace_output.h"
|
|
|
|
#define DEFAULT_SYS_FILTER_MESSAGE \
|
|
"### global filter ###\n" \
|
|
"# Use this to set filters for multiple events.\n" \
|
|
"# Only events with the given fields will be affected.\n" \
|
|
"# If no events are modified, an error message will be displayed here"
|
|
|
|
enum filter_op_ids
|
|
{
|
|
OP_OR,
|
|
OP_AND,
|
|
OP_GLOB,
|
|
OP_NE,
|
|
OP_EQ,
|
|
OP_LT,
|
|
OP_LE,
|
|
OP_GT,
|
|
OP_GE,
|
|
OP_NONE,
|
|
OP_OPEN_PAREN,
|
|
};
|
|
|
|
struct filter_op {
|
|
int id;
|
|
char *string;
|
|
int precedence;
|
|
};
|
|
|
|
static struct filter_op filter_ops[] = {
|
|
{ OP_OR, "||", 1 },
|
|
{ OP_AND, "&&", 2 },
|
|
{ OP_GLOB, "~", 4 },
|
|
{ OP_NE, "!=", 4 },
|
|
{ OP_EQ, "==", 4 },
|
|
{ OP_LT, "<", 5 },
|
|
{ OP_LE, "<=", 5 },
|
|
{ OP_GT, ">", 5 },
|
|
{ OP_GE, ">=", 5 },
|
|
{ OP_NONE, "OP_NONE", 0 },
|
|
{ OP_OPEN_PAREN, "(", 0 },
|
|
};
|
|
|
|
enum {
|
|
FILT_ERR_NONE,
|
|
FILT_ERR_INVALID_OP,
|
|
FILT_ERR_UNBALANCED_PAREN,
|
|
FILT_ERR_TOO_MANY_OPERANDS,
|
|
FILT_ERR_OPERAND_TOO_LONG,
|
|
FILT_ERR_FIELD_NOT_FOUND,
|
|
FILT_ERR_ILLEGAL_FIELD_OP,
|
|
FILT_ERR_ILLEGAL_INTVAL,
|
|
FILT_ERR_BAD_SUBSYS_FILTER,
|
|
FILT_ERR_TOO_MANY_PREDS,
|
|
FILT_ERR_MISSING_FIELD,
|
|
FILT_ERR_INVALID_FILTER,
|
|
};
|
|
|
|
static char *err_text[] = {
|
|
"No error",
|
|
"Invalid operator",
|
|
"Unbalanced parens",
|
|
"Too many operands",
|
|
"Operand too long",
|
|
"Field not found",
|
|
"Illegal operation for field type",
|
|
"Illegal integer value",
|
|
"Couldn't find or set field in one of a subsystem's events",
|
|
"Too many terms in predicate expression",
|
|
"Missing field name and/or value",
|
|
"Meaningless filter expression",
|
|
};
|
|
|
|
struct opstack_op {
|
|
int op;
|
|
struct list_head list;
|
|
};
|
|
|
|
struct postfix_elt {
|
|
int op;
|
|
char *operand;
|
|
struct list_head list;
|
|
};
|
|
|
|
struct filter_parse_state {
|
|
struct filter_op *ops;
|
|
struct list_head opstack;
|
|
struct list_head postfix;
|
|
int lasterr;
|
|
int lasterr_pos;
|
|
|
|
struct {
|
|
char *string;
|
|
unsigned int cnt;
|
|
unsigned int tail;
|
|
} infix;
|
|
|
|
struct {
|
|
char string[MAX_FILTER_STR_VAL];
|
|
int pos;
|
|
unsigned int tail;
|
|
} operand;
|
|
};
|
|
|
|
struct pred_stack {
|
|
struct filter_pred **preds;
|
|
int index;
|
|
};
|
|
|
|
#define DEFINE_COMPARISON_PRED(type) \
|
|
static int filter_pred_##type(struct filter_pred *pred, void *event) \
|
|
{ \
|
|
type *addr = (type *)(event + pred->offset); \
|
|
type val = (type)pred->val; \
|
|
int match = 0; \
|
|
\
|
|
switch (pred->op) { \
|
|
case OP_LT: \
|
|
match = (*addr < val); \
|
|
break; \
|
|
case OP_LE: \
|
|
match = (*addr <= val); \
|
|
break; \
|
|
case OP_GT: \
|
|
match = (*addr > val); \
|
|
break; \
|
|
case OP_GE: \
|
|
match = (*addr >= val); \
|
|
break; \
|
|
default: \
|
|
break; \
|
|
} \
|
|
\
|
|
return match; \
|
|
}
|
|
|
|
#define DEFINE_EQUALITY_PRED(size) \
|
|
static int filter_pred_##size(struct filter_pred *pred, void *event) \
|
|
{ \
|
|
u##size *addr = (u##size *)(event + pred->offset); \
|
|
u##size val = (u##size)pred->val; \
|
|
int match; \
|
|
\
|
|
match = (val == *addr) ^ pred->not; \
|
|
\
|
|
return match; \
|
|
}
|
|
|
|
DEFINE_COMPARISON_PRED(s64);
|
|
DEFINE_COMPARISON_PRED(u64);
|
|
DEFINE_COMPARISON_PRED(s32);
|
|
DEFINE_COMPARISON_PRED(u32);
|
|
DEFINE_COMPARISON_PRED(s16);
|
|
DEFINE_COMPARISON_PRED(u16);
|
|
DEFINE_COMPARISON_PRED(s8);
|
|
DEFINE_COMPARISON_PRED(u8);
|
|
|
|
DEFINE_EQUALITY_PRED(64);
|
|
DEFINE_EQUALITY_PRED(32);
|
|
DEFINE_EQUALITY_PRED(16);
|
|
DEFINE_EQUALITY_PRED(8);
|
|
|
|
/* Filter predicate for fixed sized arrays of characters */
|
|
static int filter_pred_string(struct filter_pred *pred, void *event)
|
|
{
|
|
char *addr = (char *)(event + pred->offset);
|
|
int cmp, match;
|
|
|
|
cmp = pred->regex.match(addr, &pred->regex, pred->regex.field_len);
|
|
|
|
match = cmp ^ pred->not;
|
|
|
|
return match;
|
|
}
|
|
|
|
/* Filter predicate for char * pointers */
|
|
static int filter_pred_pchar(struct filter_pred *pred, void *event)
|
|
{
|
|
char **addr = (char **)(event + pred->offset);
|
|
int cmp, match;
|
|
int len = strlen(*addr) + 1; /* including tailing '\0' */
|
|
|
|
cmp = pred->regex.match(*addr, &pred->regex, len);
|
|
|
|
match = cmp ^ pred->not;
|
|
|
|
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)
|
|
{
|
|
u32 str_item = *(u32 *)(event + pred->offset);
|
|
int str_loc = str_item & 0xffff;
|
|
int str_len = str_item >> 16;
|
|
char *addr = (char *)(event + str_loc);
|
|
int cmp, match;
|
|
|
|
cmp = pred->regex.match(addr, &pred->regex, str_len);
|
|
|
|
match = cmp ^ pred->not;
|
|
|
|
return match;
|
|
}
|
|
|
|
static int filter_pred_none(struct filter_pred *pred, void *event)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* regex_match_foo - Basic regex callbacks
|
|
*
|
|
* @str: the string to be searched
|
|
* @r: the regex structure containing the pattern string
|
|
* @len: the length of the string to be searched (including '\0')
|
|
*
|
|
* Note:
|
|
* - @str might not be NULL-terminated if it's of type DYN_STRING
|
|
* or STATIC_STRING
|
|
*/
|
|
|
|
static int regex_match_full(char *str, struct regex *r, int len)
|
|
{
|
|
if (strncmp(str, r->pattern, len) == 0)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static int regex_match_front(char *str, struct regex *r, int len)
|
|
{
|
|
if (strncmp(str, r->pattern, r->len) == 0)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static int regex_match_middle(char *str, struct regex *r, int len)
|
|
{
|
|
if (strnstr(str, r->pattern, len))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static int regex_match_end(char *str, struct regex *r, int len)
|
|
{
|
|
int strlen = len - 1;
|
|
|
|
if (strlen >= r->len &&
|
|
memcmp(str + strlen - r->len, r->pattern, r->len) == 0)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* filter_parse_regex - parse a basic regex
|
|
* @buff: the raw regex
|
|
* @len: length of the regex
|
|
* @search: will point to the beginning of the string to compare
|
|
* @not: tell whether the match will have to be inverted
|
|
*
|
|
* This passes in a buffer containing a regex and this function will
|
|
* set search to point to the search part of the buffer and
|
|
* return the type of search it is (see enum above).
|
|
* This does modify buff.
|
|
*
|
|
* Returns enum type.
|
|
* search returns the pointer to use for comparison.
|
|
* not returns 1 if buff started with a '!'
|
|
* 0 otherwise.
|
|
*/
|
|
enum regex_type filter_parse_regex(char *buff, int len, char **search, int *not)
|
|
{
|
|
int type = MATCH_FULL;
|
|
int i;
|
|
|
|
if (buff[0] == '!') {
|
|
*not = 1;
|
|
buff++;
|
|
len--;
|
|
} else
|
|
*not = 0;
|
|
|
|
*search = buff;
|
|
|
|
for (i = 0; i < len; i++) {
|
|
if (buff[i] == '*') {
|
|
if (!i) {
|
|
*search = buff + 1;
|
|
type = MATCH_END_ONLY;
|
|
} else {
|
|
if (type == MATCH_END_ONLY)
|
|
type = MATCH_MIDDLE_ONLY;
|
|
else
|
|
type = MATCH_FRONT_ONLY;
|
|
buff[i] = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
static void filter_build_regex(struct filter_pred *pred)
|
|
{
|
|
struct regex *r = &pred->regex;
|
|
char *search;
|
|
enum regex_type type = MATCH_FULL;
|
|
int not = 0;
|
|
|
|
if (pred->op == OP_GLOB) {
|
|
type = filter_parse_regex(r->pattern, r->len, &search, ¬);
|
|
r->len = strlen(search);
|
|
memmove(r->pattern, search, r->len+1);
|
|
}
|
|
|
|
switch (type) {
|
|
case MATCH_FULL:
|
|
r->match = regex_match_full;
|
|
break;
|
|
case MATCH_FRONT_ONLY:
|
|
r->match = regex_match_front;
|
|
break;
|
|
case MATCH_MIDDLE_ONLY:
|
|
r->match = regex_match_middle;
|
|
break;
|
|
case MATCH_END_ONLY:
|
|
r->match = regex_match_end;
|
|
break;
|
|
}
|
|
|
|
pred->not ^= not;
|
|
}
|
|
|
|
enum move_type {
|
|
MOVE_DOWN,
|
|
MOVE_UP_FROM_LEFT,
|
|
MOVE_UP_FROM_RIGHT
|
|
};
|
|
|
|
static struct filter_pred *
|
|
get_pred_parent(struct filter_pred *pred, struct filter_pred *preds,
|
|
int index, enum move_type *move)
|
|
{
|
|
if (pred->parent & FILTER_PRED_IS_RIGHT)
|
|
*move = MOVE_UP_FROM_RIGHT;
|
|
else
|
|
*move = MOVE_UP_FROM_LEFT;
|
|
pred = &preds[pred->parent & ~FILTER_PRED_IS_RIGHT];
|
|
|
|
return pred;
|
|
}
|
|
|
|
enum walk_return {
|
|
WALK_PRED_ABORT,
|
|
WALK_PRED_PARENT,
|
|
WALK_PRED_DEFAULT,
|
|
};
|
|
|
|
typedef int (*filter_pred_walkcb_t) (enum move_type move,
|
|
struct filter_pred *pred,
|
|
int *err, void *data);
|
|
|
|
static int walk_pred_tree(struct filter_pred *preds,
|
|
struct filter_pred *root,
|
|
filter_pred_walkcb_t cb, void *data)
|
|
{
|
|
struct filter_pred *pred = root;
|
|
enum move_type move = MOVE_DOWN;
|
|
int done = 0;
|
|
|
|
if (!preds)
|
|
return -EINVAL;
|
|
|
|
do {
|
|
int err = 0, ret;
|
|
|
|
ret = cb(move, pred, &err, data);
|
|
if (ret == WALK_PRED_ABORT)
|
|
return err;
|
|
if (ret == WALK_PRED_PARENT)
|
|
goto get_parent;
|
|
|
|
switch (move) {
|
|
case MOVE_DOWN:
|
|
if (pred->left != FILTER_PRED_INVALID) {
|
|
pred = &preds[pred->left];
|
|
continue;
|
|
}
|
|
goto get_parent;
|
|
case MOVE_UP_FROM_LEFT:
|
|
pred = &preds[pred->right];
|
|
move = MOVE_DOWN;
|
|
continue;
|
|
case MOVE_UP_FROM_RIGHT:
|
|
get_parent:
|
|
if (pred == root)
|
|
break;
|
|
pred = get_pred_parent(pred, preds,
|
|
pred->parent,
|
|
&move);
|
|
continue;
|
|
}
|
|
done = 1;
|
|
} while (!done);
|
|
|
|
/* We are fine. */
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* A series of AND or ORs where found together. Instead of
|
|
* climbing up and down the tree branches, an array of the
|
|
* ops were made in order of checks. We can just move across
|
|
* the array and short circuit if needed.
|
|
*/
|
|
static int process_ops(struct filter_pred *preds,
|
|
struct filter_pred *op, void *rec)
|
|
{
|
|
struct filter_pred *pred;
|
|
int match = 0;
|
|
int type;
|
|
int i;
|
|
|
|
/*
|
|
* Micro-optimization: We set type to true if op
|
|
* is an OR and false otherwise (AND). Then we
|
|
* just need to test if the match is equal to
|
|
* the type, and if it is, we can short circuit the
|
|
* rest of the checks:
|
|
*
|
|
* if ((match && op->op == OP_OR) ||
|
|
* (!match && op->op == OP_AND))
|
|
* return match;
|
|
*/
|
|
type = op->op == OP_OR;
|
|
|
|
for (i = 0; i < op->val; i++) {
|
|
pred = &preds[op->ops[i]];
|
|
if (!WARN_ON_ONCE(!pred->fn))
|
|
match = pred->fn(pred, rec);
|
|
if (!!match == type)
|
|
return match;
|
|
}
|
|
return match;
|
|
}
|
|
|
|
struct filter_match_preds_data {
|
|
struct filter_pred *preds;
|
|
int match;
|
|
void *rec;
|
|
};
|
|
|
|
static int filter_match_preds_cb(enum move_type move, struct filter_pred *pred,
|
|
int *err, void *data)
|
|
{
|
|
struct filter_match_preds_data *d = data;
|
|
|
|
*err = 0;
|
|
switch (move) {
|
|
case MOVE_DOWN:
|
|
/* only AND and OR have children */
|
|
if (pred->left != FILTER_PRED_INVALID) {
|
|
/* If ops is set, then it was folded. */
|
|
if (!pred->ops)
|
|
return WALK_PRED_DEFAULT;
|
|
/* We can treat folded ops as a leaf node */
|
|
d->match = process_ops(d->preds, pred, d->rec);
|
|
} else {
|
|
if (!WARN_ON_ONCE(!pred->fn))
|
|
d->match = pred->fn(pred, d->rec);
|
|
}
|
|
|
|
return WALK_PRED_PARENT;
|
|
case MOVE_UP_FROM_LEFT:
|
|
/*
|
|
* Check for short circuits.
|
|
*
|
|
* Optimization: !!match == (pred->op == OP_OR)
|
|
* is the same as:
|
|
* if ((match && pred->op == OP_OR) ||
|
|
* (!match && pred->op == OP_AND))
|
|
*/
|
|
if (!!d->match == (pred->op == OP_OR))
|
|
return WALK_PRED_PARENT;
|
|
break;
|
|
case MOVE_UP_FROM_RIGHT:
|
|
break;
|
|
}
|
|
|
|
return WALK_PRED_DEFAULT;
|
|
}
|
|
|
|
/* return 1 if event matches, 0 otherwise (discard) */
|
|
int filter_match_preds(struct event_filter *filter, void *rec)
|
|
{
|
|
struct filter_pred *preds;
|
|
struct filter_pred *root;
|
|
struct filter_match_preds_data data = {
|
|
/* match is currently meaningless */
|
|
.match = -1,
|
|
.rec = rec,
|
|
};
|
|
int n_preds, ret;
|
|
|
|
/* no filter is considered a match */
|
|
if (!filter)
|
|
return 1;
|
|
|
|
n_preds = filter->n_preds;
|
|
if (!n_preds)
|
|
return 1;
|
|
|
|
/*
|
|
* n_preds, root and filter->preds are protect with preemption disabled.
|
|
*/
|
|
root = rcu_dereference_sched(filter->root);
|
|
if (!root)
|
|
return 1;
|
|
|
|
data.preds = preds = rcu_dereference_sched(filter->preds);
|
|
ret = walk_pred_tree(preds, root, filter_match_preds_cb, &data);
|
|
WARN_ON(ret);
|
|
return data.match;
|
|
}
|
|
EXPORT_SYMBOL_GPL(filter_match_preds);
|
|
|
|
static void parse_error(struct filter_parse_state *ps, int err, int pos)
|
|
{
|
|
ps->lasterr = err;
|
|
ps->lasterr_pos = pos;
|
|
}
|
|
|
|
static void remove_filter_string(struct event_filter *filter)
|
|
{
|
|
if (!filter)
|
|
return;
|
|
|
|
kfree(filter->filter_string);
|
|
filter->filter_string = NULL;
|
|
}
|
|
|
|
static int replace_filter_string(struct event_filter *filter,
|
|
char *filter_string)
|
|
{
|
|
kfree(filter->filter_string);
|
|
filter->filter_string = kstrdup(filter_string, GFP_KERNEL);
|
|
if (!filter->filter_string)
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int append_filter_string(struct event_filter *filter,
|
|
char *string)
|
|
{
|
|
int newlen;
|
|
char *new_filter_string;
|
|
|
|
BUG_ON(!filter->filter_string);
|
|
newlen = strlen(filter->filter_string) + strlen(string) + 1;
|
|
new_filter_string = kmalloc(newlen, GFP_KERNEL);
|
|
if (!new_filter_string)
|
|
return -ENOMEM;
|
|
|
|
strcpy(new_filter_string, filter->filter_string);
|
|
strcat(new_filter_string, string);
|
|
kfree(filter->filter_string);
|
|
filter->filter_string = new_filter_string;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void append_filter_err(struct filter_parse_state *ps,
|
|
struct event_filter *filter)
|
|
{
|
|
int pos = ps->lasterr_pos;
|
|
char *buf, *pbuf;
|
|
|
|
buf = (char *)__get_free_page(GFP_TEMPORARY);
|
|
if (!buf)
|
|
return;
|
|
|
|
append_filter_string(filter, "\n");
|
|
memset(buf, ' ', PAGE_SIZE);
|
|
if (pos > PAGE_SIZE - 128)
|
|
pos = 0;
|
|
buf[pos] = '^';
|
|
pbuf = &buf[pos] + 1;
|
|
|
|
sprintf(pbuf, "\nparse_error: %s\n", err_text[ps->lasterr]);
|
|
append_filter_string(filter, buf);
|
|
free_page((unsigned long) buf);
|
|
}
|
|
|
|
void print_event_filter(struct ftrace_event_call *call, struct trace_seq *s)
|
|
{
|
|
struct event_filter *filter;
|
|
|
|
mutex_lock(&event_mutex);
|
|
filter = call->filter;
|
|
if (filter && filter->filter_string)
|
|
trace_seq_printf(s, "%s\n", filter->filter_string);
|
|
else
|
|
trace_seq_printf(s, "none\n");
|
|
mutex_unlock(&event_mutex);
|
|
}
|
|
|
|
void print_subsystem_event_filter(struct event_subsystem *system,
|
|
struct trace_seq *s)
|
|
{
|
|
struct event_filter *filter;
|
|
|
|
mutex_lock(&event_mutex);
|
|
filter = system->filter;
|
|
if (filter && filter->filter_string)
|
|
trace_seq_printf(s, "%s\n", filter->filter_string);
|
|
else
|
|
trace_seq_printf(s, DEFAULT_SYS_FILTER_MESSAGE "\n");
|
|
mutex_unlock(&event_mutex);
|
|
}
|
|
|
|
static struct ftrace_event_field *
|
|
__find_event_field(struct list_head *head, char *name)
|
|
{
|
|
struct ftrace_event_field *field;
|
|
|
|
list_for_each_entry(field, head, link) {
|
|
if (!strcmp(field->name, name))
|
|
return field;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static struct ftrace_event_field *
|
|
find_event_field(struct ftrace_event_call *call, char *name)
|
|
{
|
|
struct ftrace_event_field *field;
|
|
struct list_head *head;
|
|
|
|
field = __find_event_field(&ftrace_common_fields, name);
|
|
if (field)
|
|
return field;
|
|
|
|
head = trace_get_fields(call);
|
|
return __find_event_field(head, name);
|
|
}
|
|
|
|
static int __alloc_pred_stack(struct pred_stack *stack, int n_preds)
|
|
{
|
|
stack->preds = kzalloc(sizeof(*stack->preds)*(n_preds + 1), GFP_KERNEL);
|
|
if (!stack->preds)
|
|
return -ENOMEM;
|
|
stack->index = n_preds;
|
|
return 0;
|
|
}
|
|
|
|
static void __free_pred_stack(struct pred_stack *stack)
|
|
{
|
|
kfree(stack->preds);
|
|
stack->index = 0;
|
|
}
|
|
|
|
static int __push_pred_stack(struct pred_stack *stack,
|
|
struct filter_pred *pred)
|
|
{
|
|
int index = stack->index;
|
|
|
|
if (WARN_ON(index == 0))
|
|
return -ENOSPC;
|
|
|
|
stack->preds[--index] = pred;
|
|
stack->index = index;
|
|
return 0;
|
|
}
|
|
|
|
static struct filter_pred *
|
|
__pop_pred_stack(struct pred_stack *stack)
|
|
{
|
|
struct filter_pred *pred;
|
|
int index = stack->index;
|
|
|
|
pred = stack->preds[index++];
|
|
if (!pred)
|
|
return NULL;
|
|
|
|
stack->index = index;
|
|
return pred;
|
|
}
|
|
|
|
static int filter_set_pred(struct event_filter *filter,
|
|
int idx,
|
|
struct pred_stack *stack,
|
|
struct filter_pred *src)
|
|
{
|
|
struct filter_pred *dest = &filter->preds[idx];
|
|
struct filter_pred *left;
|
|
struct filter_pred *right;
|
|
|
|
*dest = *src;
|
|
dest->index = idx;
|
|
|
|
if (dest->op == OP_OR || dest->op == OP_AND) {
|
|
right = __pop_pred_stack(stack);
|
|
left = __pop_pred_stack(stack);
|
|
if (!left || !right)
|
|
return -EINVAL;
|
|
/*
|
|
* If both children can be folded
|
|
* and they are the same op as this op or a leaf,
|
|
* then this op can be folded.
|
|
*/
|
|
if (left->index & FILTER_PRED_FOLD &&
|
|
(left->op == dest->op ||
|
|
left->left == FILTER_PRED_INVALID) &&
|
|
right->index & FILTER_PRED_FOLD &&
|
|
(right->op == dest->op ||
|
|
right->left == FILTER_PRED_INVALID))
|
|
dest->index |= FILTER_PRED_FOLD;
|
|
|
|
dest->left = left->index & ~FILTER_PRED_FOLD;
|
|
dest->right = right->index & ~FILTER_PRED_FOLD;
|
|
left->parent = dest->index & ~FILTER_PRED_FOLD;
|
|
right->parent = dest->index | FILTER_PRED_IS_RIGHT;
|
|
} else {
|
|
/*
|
|
* Make dest->left invalid to be used as a quick
|
|
* way to know this is a leaf node.
|
|
*/
|
|
dest->left = FILTER_PRED_INVALID;
|
|
|
|
/* All leafs allow folding the parent ops. */
|
|
dest->index |= FILTER_PRED_FOLD;
|
|
}
|
|
|
|
return __push_pred_stack(stack, dest);
|
|
}
|
|
|
|
static void __free_preds(struct event_filter *filter)
|
|
{
|
|
if (filter->preds) {
|
|
kfree(filter->preds);
|
|
filter->preds = NULL;
|
|
}
|
|
filter->a_preds = 0;
|
|
filter->n_preds = 0;
|
|
}
|
|
|
|
static void filter_disable(struct ftrace_event_call *call)
|
|
{
|
|
call->flags &= ~TRACE_EVENT_FL_FILTERED;
|
|
}
|
|
|
|
static void __free_filter(struct event_filter *filter)
|
|
{
|
|
if (!filter)
|
|
return;
|
|
|
|
__free_preds(filter);
|
|
kfree(filter->filter_string);
|
|
kfree(filter);
|
|
}
|
|
|
|
/*
|
|
* Called when destroying the ftrace_event_call.
|
|
* The call is being freed, so we do not need to worry about
|
|
* the call being currently used. This is for module code removing
|
|
* the tracepoints from within it.
|
|
*/
|
|
void destroy_preds(struct ftrace_event_call *call)
|
|
{
|
|
__free_filter(call->filter);
|
|
call->filter = NULL;
|
|
}
|
|
|
|
static struct event_filter *__alloc_filter(void)
|
|
{
|
|
struct event_filter *filter;
|
|
|
|
filter = kzalloc(sizeof(*filter), GFP_KERNEL);
|
|
return filter;
|
|
}
|
|
|
|
static int __alloc_preds(struct event_filter *filter, int n_preds)
|
|
{
|
|
struct filter_pred *pred;
|
|
int i;
|
|
|
|
if (filter->preds)
|
|
__free_preds(filter);
|
|
|
|
filter->preds =
|
|
kzalloc(sizeof(*filter->preds) * n_preds, GFP_KERNEL);
|
|
|
|
if (!filter->preds)
|
|
return -ENOMEM;
|
|
|
|
filter->a_preds = n_preds;
|
|
filter->n_preds = 0;
|
|
|
|
for (i = 0; i < n_preds; i++) {
|
|
pred = &filter->preds[i];
|
|
pred->fn = filter_pred_none;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void filter_free_subsystem_preds(struct event_subsystem *system)
|
|
{
|
|
struct ftrace_event_call *call;
|
|
|
|
list_for_each_entry(call, &ftrace_events, list) {
|
|
if (strcmp(call->class->system, system->name) != 0)
|
|
continue;
|
|
|
|
filter_disable(call);
|
|
remove_filter_string(call->filter);
|
|
}
|
|
}
|
|
|
|
static void filter_free_subsystem_filters(struct event_subsystem *system)
|
|
{
|
|
struct ftrace_event_call *call;
|
|
|
|
list_for_each_entry(call, &ftrace_events, list) {
|
|
if (strcmp(call->class->system, system->name) != 0)
|
|
continue;
|
|
__free_filter(call->filter);
|
|
call->filter = NULL;
|
|
}
|
|
}
|
|
|
|
static int filter_add_pred(struct filter_parse_state *ps,
|
|
struct event_filter *filter,
|
|
struct filter_pred *pred,
|
|
struct pred_stack *stack)
|
|
{
|
|
int err;
|
|
|
|
if (WARN_ON(filter->n_preds == filter->a_preds)) {
|
|
parse_error(ps, FILT_ERR_TOO_MANY_PREDS, 0);
|
|
return -ENOSPC;
|
|
}
|
|
|
|
err = filter_set_pred(filter, filter->n_preds, stack, pred);
|
|
if (err)
|
|
return err;
|
|
|
|
filter->n_preds++;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int filter_assign_type(const char *type)
|
|
{
|
|
if (strstr(type, "__data_loc") && strstr(type, "char"))
|
|
return FILTER_DYN_STRING;
|
|
|
|
if (strchr(type, '[') && strstr(type, "char"))
|
|
return FILTER_STATIC_STRING;
|
|
|
|
return FILTER_OTHER;
|
|
}
|
|
|
|
static bool is_string_field(struct ftrace_event_field *field)
|
|
{
|
|
return field->filter_type == FILTER_DYN_STRING ||
|
|
field->filter_type == FILTER_STATIC_STRING ||
|
|
field->filter_type == FILTER_PTR_STRING;
|
|
}
|
|
|
|
static int is_legal_op(struct ftrace_event_field *field, int op)
|
|
{
|
|
if (is_string_field(field) &&
|
|
(op != OP_EQ && op != OP_NE && op != OP_GLOB))
|
|
return 0;
|
|
if (!is_string_field(field) && op == OP_GLOB)
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static filter_pred_fn_t select_comparison_fn(int op, int field_size,
|
|
int field_is_signed)
|
|
{
|
|
filter_pred_fn_t fn = NULL;
|
|
|
|
switch (field_size) {
|
|
case 8:
|
|
if (op == OP_EQ || op == OP_NE)
|
|
fn = filter_pred_64;
|
|
else if (field_is_signed)
|
|
fn = filter_pred_s64;
|
|
else
|
|
fn = filter_pred_u64;
|
|
break;
|
|
case 4:
|
|
if (op == OP_EQ || op == OP_NE)
|
|
fn = filter_pred_32;
|
|
else if (field_is_signed)
|
|
fn = filter_pred_s32;
|
|
else
|
|
fn = filter_pred_u32;
|
|
break;
|
|
case 2:
|
|
if (op == OP_EQ || op == OP_NE)
|
|
fn = filter_pred_16;
|
|
else if (field_is_signed)
|
|
fn = filter_pred_s16;
|
|
else
|
|
fn = filter_pred_u16;
|
|
break;
|
|
case 1:
|
|
if (op == OP_EQ || op == OP_NE)
|
|
fn = filter_pred_8;
|
|
else if (field_is_signed)
|
|
fn = filter_pred_s8;
|
|
else
|
|
fn = filter_pred_u8;
|
|
break;
|
|
}
|
|
|
|
return fn;
|
|
}
|
|
|
|
static int init_pred(struct filter_parse_state *ps,
|
|
struct ftrace_event_field *field,
|
|
struct filter_pred *pred)
|
|
|
|
{
|
|
filter_pred_fn_t fn = filter_pred_none;
|
|
unsigned long long val;
|
|
int ret;
|
|
|
|
pred->offset = field->offset;
|
|
|
|
if (!is_legal_op(field, pred->op)) {
|
|
parse_error(ps, FILT_ERR_ILLEGAL_FIELD_OP, 0);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (is_string_field(field)) {
|
|
filter_build_regex(pred);
|
|
|
|
if (field->filter_type == FILTER_STATIC_STRING) {
|
|
fn = filter_pred_string;
|
|
pred->regex.field_len = field->size;
|
|
} else if (field->filter_type == FILTER_DYN_STRING)
|
|
fn = filter_pred_strloc;
|
|
else
|
|
fn = filter_pred_pchar;
|
|
} else {
|
|
if (field->is_signed)
|
|
ret = strict_strtoll(pred->regex.pattern, 0, &val);
|
|
else
|
|
ret = strict_strtoull(pred->regex.pattern, 0, &val);
|
|
if (ret) {
|
|
parse_error(ps, FILT_ERR_ILLEGAL_INTVAL, 0);
|
|
return -EINVAL;
|
|
}
|
|
pred->val = val;
|
|
|
|
fn = select_comparison_fn(pred->op, field->size,
|
|
field->is_signed);
|
|
if (!fn) {
|
|
parse_error(ps, FILT_ERR_INVALID_OP, 0);
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
if (pred->op == OP_NE)
|
|
pred->not = 1;
|
|
|
|
pred->fn = fn;
|
|
return 0;
|
|
}
|
|
|
|
static void parse_init(struct filter_parse_state *ps,
|
|
struct filter_op *ops,
|
|
char *infix_string)
|
|
{
|
|
memset(ps, '\0', sizeof(*ps));
|
|
|
|
ps->infix.string = infix_string;
|
|
ps->infix.cnt = strlen(infix_string);
|
|
ps->ops = ops;
|
|
|
|
INIT_LIST_HEAD(&ps->opstack);
|
|
INIT_LIST_HEAD(&ps->postfix);
|
|
}
|
|
|
|
static char infix_next(struct filter_parse_state *ps)
|
|
{
|
|
ps->infix.cnt--;
|
|
|
|
return ps->infix.string[ps->infix.tail++];
|
|
}
|
|
|
|
static char infix_peek(struct filter_parse_state *ps)
|
|
{
|
|
if (ps->infix.tail == strlen(ps->infix.string))
|
|
return 0;
|
|
|
|
return ps->infix.string[ps->infix.tail];
|
|
}
|
|
|
|
static void infix_advance(struct filter_parse_state *ps)
|
|
{
|
|
ps->infix.cnt--;
|
|
ps->infix.tail++;
|
|
}
|
|
|
|
static inline int is_precedence_lower(struct filter_parse_state *ps,
|
|
int a, int b)
|
|
{
|
|
return ps->ops[a].precedence < ps->ops[b].precedence;
|
|
}
|
|
|
|
static inline int is_op_char(struct filter_parse_state *ps, char c)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; strcmp(ps->ops[i].string, "OP_NONE"); i++) {
|
|
if (ps->ops[i].string[0] == c)
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int infix_get_op(struct filter_parse_state *ps, char firstc)
|
|
{
|
|
char nextc = infix_peek(ps);
|
|
char opstr[3];
|
|
int i;
|
|
|
|
opstr[0] = firstc;
|
|
opstr[1] = nextc;
|
|
opstr[2] = '\0';
|
|
|
|
for (i = 0; strcmp(ps->ops[i].string, "OP_NONE"); i++) {
|
|
if (!strcmp(opstr, ps->ops[i].string)) {
|
|
infix_advance(ps);
|
|
return ps->ops[i].id;
|
|
}
|
|
}
|
|
|
|
opstr[1] = '\0';
|
|
|
|
for (i = 0; strcmp(ps->ops[i].string, "OP_NONE"); i++) {
|
|
if (!strcmp(opstr, ps->ops[i].string))
|
|
return ps->ops[i].id;
|
|
}
|
|
|
|
return OP_NONE;
|
|
}
|
|
|
|
static inline void clear_operand_string(struct filter_parse_state *ps)
|
|
{
|
|
memset(ps->operand.string, '\0', MAX_FILTER_STR_VAL);
|
|
ps->operand.tail = 0;
|
|
}
|
|
|
|
static inline int append_operand_char(struct filter_parse_state *ps, char c)
|
|
{
|
|
if (ps->operand.tail == MAX_FILTER_STR_VAL - 1)
|
|
return -EINVAL;
|
|
|
|
ps->operand.string[ps->operand.tail++] = c;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int filter_opstack_push(struct filter_parse_state *ps, int op)
|
|
{
|
|
struct opstack_op *opstack_op;
|
|
|
|
opstack_op = kmalloc(sizeof(*opstack_op), GFP_KERNEL);
|
|
if (!opstack_op)
|
|
return -ENOMEM;
|
|
|
|
opstack_op->op = op;
|
|
list_add(&opstack_op->list, &ps->opstack);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int filter_opstack_empty(struct filter_parse_state *ps)
|
|
{
|
|
return list_empty(&ps->opstack);
|
|
}
|
|
|
|
static int filter_opstack_top(struct filter_parse_state *ps)
|
|
{
|
|
struct opstack_op *opstack_op;
|
|
|
|
if (filter_opstack_empty(ps))
|
|
return OP_NONE;
|
|
|
|
opstack_op = list_first_entry(&ps->opstack, struct opstack_op, list);
|
|
|
|
return opstack_op->op;
|
|
}
|
|
|
|
static int filter_opstack_pop(struct filter_parse_state *ps)
|
|
{
|
|
struct opstack_op *opstack_op;
|
|
int op;
|
|
|
|
if (filter_opstack_empty(ps))
|
|
return OP_NONE;
|
|
|
|
opstack_op = list_first_entry(&ps->opstack, struct opstack_op, list);
|
|
op = opstack_op->op;
|
|
list_del(&opstack_op->list);
|
|
|
|
kfree(opstack_op);
|
|
|
|
return op;
|
|
}
|
|
|
|
static void filter_opstack_clear(struct filter_parse_state *ps)
|
|
{
|
|
while (!filter_opstack_empty(ps))
|
|
filter_opstack_pop(ps);
|
|
}
|
|
|
|
static char *curr_operand(struct filter_parse_state *ps)
|
|
{
|
|
return ps->operand.string;
|
|
}
|
|
|
|
static int postfix_append_operand(struct filter_parse_state *ps, char *operand)
|
|
{
|
|
struct postfix_elt *elt;
|
|
|
|
elt = kmalloc(sizeof(*elt), GFP_KERNEL);
|
|
if (!elt)
|
|
return -ENOMEM;
|
|
|
|
elt->op = OP_NONE;
|
|
elt->operand = kstrdup(operand, GFP_KERNEL);
|
|
if (!elt->operand) {
|
|
kfree(elt);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
list_add_tail(&elt->list, &ps->postfix);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int postfix_append_op(struct filter_parse_state *ps, int op)
|
|
{
|
|
struct postfix_elt *elt;
|
|
|
|
elt = kmalloc(sizeof(*elt), GFP_KERNEL);
|
|
if (!elt)
|
|
return -ENOMEM;
|
|
|
|
elt->op = op;
|
|
elt->operand = NULL;
|
|
|
|
list_add_tail(&elt->list, &ps->postfix);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void postfix_clear(struct filter_parse_state *ps)
|
|
{
|
|
struct postfix_elt *elt;
|
|
|
|
while (!list_empty(&ps->postfix)) {
|
|
elt = list_first_entry(&ps->postfix, struct postfix_elt, list);
|
|
list_del(&elt->list);
|
|
kfree(elt->operand);
|
|
kfree(elt);
|
|
}
|
|
}
|
|
|
|
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;
|
|
|
|
if (is_op_char(ps, ch)) {
|
|
op = infix_get_op(ps, ch);
|
|
if (op == OP_NONE) {
|
|
parse_error(ps, FILT_ERR_INVALID_OP, 0);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (strlen(curr_operand(ps))) {
|
|
postfix_append_operand(ps, curr_operand(ps));
|
|
clear_operand_string(ps);
|
|
}
|
|
|
|
while (!filter_opstack_empty(ps)) {
|
|
top_op = filter_opstack_top(ps);
|
|
if (!is_precedence_lower(ps, top_op, op)) {
|
|
top_op = filter_opstack_pop(ps);
|
|
postfix_append_op(ps, top_op);
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
|
|
filter_opstack_push(ps, op);
|
|
continue;
|
|
}
|
|
|
|
if (ch == '(') {
|
|
filter_opstack_push(ps, OP_OPEN_PAREN);
|
|
continue;
|
|
}
|
|
|
|
if (ch == ')') {
|
|
if (strlen(curr_operand(ps))) {
|
|
postfix_append_operand(ps, curr_operand(ps));
|
|
clear_operand_string(ps);
|
|
}
|
|
|
|
top_op = filter_opstack_pop(ps);
|
|
while (top_op != OP_NONE) {
|
|
if (top_op == OP_OPEN_PAREN)
|
|
break;
|
|
postfix_append_op(ps, top_op);
|
|
top_op = filter_opstack_pop(ps);
|
|
}
|
|
if (top_op == OP_NONE) {
|
|
parse_error(ps, FILT_ERR_UNBALANCED_PAREN, 0);
|
|
return -EINVAL;
|
|
}
|
|
continue;
|
|
}
|
|
parse_operand:
|
|
if (append_operand_char(ps, ch)) {
|
|
parse_error(ps, FILT_ERR_OPERAND_TOO_LONG, 0);
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
if (strlen(curr_operand(ps)))
|
|
postfix_append_operand(ps, curr_operand(ps));
|
|
|
|
while (!filter_opstack_empty(ps)) {
|
|
top_op = filter_opstack_pop(ps);
|
|
if (top_op == OP_NONE)
|
|
break;
|
|
if (top_op == OP_OPEN_PAREN) {
|
|
parse_error(ps, FILT_ERR_UNBALANCED_PAREN, 0);
|
|
return -EINVAL;
|
|
}
|
|
postfix_append_op(ps, top_op);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct filter_pred *create_pred(struct filter_parse_state *ps,
|
|
struct ftrace_event_call *call,
|
|
int op, char *operand1, char *operand2)
|
|
{
|
|
struct ftrace_event_field *field;
|
|
static struct filter_pred pred;
|
|
|
|
memset(&pred, 0, sizeof(pred));
|
|
pred.op = op;
|
|
|
|
if (op == OP_AND || op == OP_OR)
|
|
return &pred;
|
|
|
|
if (!operand1 || !operand2) {
|
|
parse_error(ps, FILT_ERR_MISSING_FIELD, 0);
|
|
return NULL;
|
|
}
|
|
|
|
field = find_event_field(call, operand1);
|
|
if (!field) {
|
|
parse_error(ps, FILT_ERR_FIELD_NOT_FOUND, 0);
|
|
return NULL;
|
|
}
|
|
|
|
strcpy(pred.regex.pattern, operand2);
|
|
pred.regex.len = strlen(pred.regex.pattern);
|
|
|
|
#ifdef CONFIG_FTRACE_STARTUP_TEST
|
|
pred.field = field;
|
|
#endif
|
|
return init_pred(ps, field, &pred) ? NULL : &pred;
|
|
}
|
|
|
|
static int check_preds(struct filter_parse_state *ps)
|
|
{
|
|
int n_normal_preds = 0, n_logical_preds = 0;
|
|
struct postfix_elt *elt;
|
|
|
|
list_for_each_entry(elt, &ps->postfix, list) {
|
|
if (elt->op == OP_NONE)
|
|
continue;
|
|
|
|
if (elt->op == OP_AND || elt->op == OP_OR) {
|
|
n_logical_preds++;
|
|
continue;
|
|
}
|
|
n_normal_preds++;
|
|
}
|
|
|
|
if (!n_normal_preds || n_logical_preds >= n_normal_preds) {
|
|
parse_error(ps, FILT_ERR_INVALID_FILTER, 0);
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int count_preds(struct filter_parse_state *ps)
|
|
{
|
|
struct postfix_elt *elt;
|
|
int n_preds = 0;
|
|
|
|
list_for_each_entry(elt, &ps->postfix, list) {
|
|
if (elt->op == OP_NONE)
|
|
continue;
|
|
n_preds++;
|
|
}
|
|
|
|
return n_preds;
|
|
}
|
|
|
|
struct check_pred_data {
|
|
int count;
|
|
int max;
|
|
};
|
|
|
|
static int check_pred_tree_cb(enum move_type move, struct filter_pred *pred,
|
|
int *err, void *data)
|
|
{
|
|
struct check_pred_data *d = data;
|
|
|
|
if (WARN_ON(d->count++ > d->max)) {
|
|
*err = -EINVAL;
|
|
return WALK_PRED_ABORT;
|
|
}
|
|
return WALK_PRED_DEFAULT;
|
|
}
|
|
|
|
/*
|
|
* The tree is walked at filtering of an event. If the tree is not correctly
|
|
* built, it may cause an infinite loop. Check here that the tree does
|
|
* indeed terminate.
|
|
*/
|
|
static int check_pred_tree(struct event_filter *filter,
|
|
struct filter_pred *root)
|
|
{
|
|
struct check_pred_data data = {
|
|
/*
|
|
* The max that we can hit a node is three times.
|
|
* Once going down, once coming up from left, and
|
|
* once coming up from right. This is more than enough
|
|
* since leafs are only hit a single time.
|
|
*/
|
|
.max = 3 * filter->n_preds,
|
|
.count = 0,
|
|
};
|
|
|
|
return walk_pred_tree(filter->preds, root,
|
|
check_pred_tree_cb, &data);
|
|
}
|
|
|
|
static int count_leafs_cb(enum move_type move, struct filter_pred *pred,
|
|
int *err, void *data)
|
|
{
|
|
int *count = data;
|
|
|
|
if ((move == MOVE_DOWN) &&
|
|
(pred->left == FILTER_PRED_INVALID))
|
|
(*count)++;
|
|
|
|
return WALK_PRED_DEFAULT;
|
|
}
|
|
|
|
static int count_leafs(struct filter_pred *preds, struct filter_pred *root)
|
|
{
|
|
int count = 0, ret;
|
|
|
|
ret = walk_pred_tree(preds, root, count_leafs_cb, &count);
|
|
WARN_ON(ret);
|
|
return count;
|
|
}
|
|
|
|
struct fold_pred_data {
|
|
struct filter_pred *root;
|
|
int count;
|
|
int children;
|
|
};
|
|
|
|
static int fold_pred_cb(enum move_type move, struct filter_pred *pred,
|
|
int *err, void *data)
|
|
{
|
|
struct fold_pred_data *d = data;
|
|
struct filter_pred *root = d->root;
|
|
|
|
if (move != MOVE_DOWN)
|
|
return WALK_PRED_DEFAULT;
|
|
if (pred->left != FILTER_PRED_INVALID)
|
|
return WALK_PRED_DEFAULT;
|
|
|
|
if (WARN_ON(d->count == d->children)) {
|
|
*err = -EINVAL;
|
|
return WALK_PRED_ABORT;
|
|
}
|
|
|
|
pred->index &= ~FILTER_PRED_FOLD;
|
|
root->ops[d->count++] = pred->index;
|
|
return WALK_PRED_DEFAULT;
|
|
}
|
|
|
|
static int fold_pred(struct filter_pred *preds, struct filter_pred *root)
|
|
{
|
|
struct fold_pred_data data = {
|
|
.root = root,
|
|
.count = 0,
|
|
};
|
|
int children;
|
|
|
|
/* No need to keep the fold flag */
|
|
root->index &= ~FILTER_PRED_FOLD;
|
|
|
|
/* If the root is a leaf then do nothing */
|
|
if (root->left == FILTER_PRED_INVALID)
|
|
return 0;
|
|
|
|
/* count the children */
|
|
children = count_leafs(preds, &preds[root->left]);
|
|
children += count_leafs(preds, &preds[root->right]);
|
|
|
|
root->ops = kzalloc(sizeof(*root->ops) * children, GFP_KERNEL);
|
|
if (!root->ops)
|
|
return -ENOMEM;
|
|
|
|
root->val = children;
|
|
data.children = children;
|
|
return walk_pred_tree(preds, root, fold_pred_cb, &data);
|
|
}
|
|
|
|
static int fold_pred_tree_cb(enum move_type move, struct filter_pred *pred,
|
|
int *err, void *data)
|
|
{
|
|
struct filter_pred *preds = data;
|
|
|
|
if (move != MOVE_DOWN)
|
|
return WALK_PRED_DEFAULT;
|
|
if (!(pred->index & FILTER_PRED_FOLD))
|
|
return WALK_PRED_DEFAULT;
|
|
|
|
*err = fold_pred(preds, pred);
|
|
if (*err)
|
|
return WALK_PRED_ABORT;
|
|
|
|
/* eveyrhing below is folded, continue with parent */
|
|
return WALK_PRED_PARENT;
|
|
}
|
|
|
|
/*
|
|
* To optimize the processing of the ops, if we have several "ors" or
|
|
* "ands" together, we can put them in an array and process them all
|
|
* together speeding up the filter logic.
|
|
*/
|
|
static int fold_pred_tree(struct event_filter *filter,
|
|
struct filter_pred *root)
|
|
{
|
|
return walk_pred_tree(filter->preds, root, fold_pred_tree_cb,
|
|
filter->preds);
|
|
}
|
|
|
|
static int replace_preds(struct ftrace_event_call *call,
|
|
struct event_filter *filter,
|
|
struct filter_parse_state *ps,
|
|
char *filter_string,
|
|
bool dry_run)
|
|
{
|
|
char *operand1 = NULL, *operand2 = NULL;
|
|
struct filter_pred *pred;
|
|
struct filter_pred *root;
|
|
struct postfix_elt *elt;
|
|
struct pred_stack stack = { }; /* init to NULL */
|
|
int err;
|
|
int n_preds = 0;
|
|
|
|
n_preds = count_preds(ps);
|
|
if (n_preds >= MAX_FILTER_PRED) {
|
|
parse_error(ps, FILT_ERR_TOO_MANY_PREDS, 0);
|
|
return -ENOSPC;
|
|
}
|
|
|
|
err = check_preds(ps);
|
|
if (err)
|
|
return err;
|
|
|
|
if (!dry_run) {
|
|
err = __alloc_pred_stack(&stack, n_preds);
|
|
if (err)
|
|
return err;
|
|
err = __alloc_preds(filter, n_preds);
|
|
if (err)
|
|
goto fail;
|
|
}
|
|
|
|
n_preds = 0;
|
|
list_for_each_entry(elt, &ps->postfix, list) {
|
|
if (elt->op == OP_NONE) {
|
|
if (!operand1)
|
|
operand1 = elt->operand;
|
|
else if (!operand2)
|
|
operand2 = elt->operand;
|
|
else {
|
|
parse_error(ps, FILT_ERR_TOO_MANY_OPERANDS, 0);
|
|
err = -EINVAL;
|
|
goto fail;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (WARN_ON(n_preds++ == MAX_FILTER_PRED)) {
|
|
parse_error(ps, FILT_ERR_TOO_MANY_PREDS, 0);
|
|
err = -ENOSPC;
|
|
goto fail;
|
|
}
|
|
|
|
pred = create_pred(ps, call, elt->op, operand1, operand2);
|
|
if (!pred) {
|
|
err = -EINVAL;
|
|
goto fail;
|
|
}
|
|
|
|
if (!dry_run) {
|
|
err = filter_add_pred(ps, filter, pred, &stack);
|
|
if (err)
|
|
goto fail;
|
|
}
|
|
|
|
operand1 = operand2 = NULL;
|
|
}
|
|
|
|
if (!dry_run) {
|
|
/* We should have one item left on the stack */
|
|
pred = __pop_pred_stack(&stack);
|
|
if (!pred)
|
|
return -EINVAL;
|
|
/* This item is where we start from in matching */
|
|
root = pred;
|
|
/* Make sure the stack is empty */
|
|
pred = __pop_pred_stack(&stack);
|
|
if (WARN_ON(pred)) {
|
|
err = -EINVAL;
|
|
filter->root = NULL;
|
|
goto fail;
|
|
}
|
|
err = check_pred_tree(filter, root);
|
|
if (err)
|
|
goto fail;
|
|
|
|
/* Optimize the tree */
|
|
err = fold_pred_tree(filter, root);
|
|
if (err)
|
|
goto fail;
|
|
|
|
/* We don't set root until we know it works */
|
|
barrier();
|
|
filter->root = root;
|
|
}
|
|
|
|
err = 0;
|
|
fail:
|
|
__free_pred_stack(&stack);
|
|
return err;
|
|
}
|
|
|
|
struct filter_list {
|
|
struct list_head list;
|
|
struct event_filter *filter;
|
|
};
|
|
|
|
static int replace_system_preds(struct event_subsystem *system,
|
|
struct filter_parse_state *ps,
|
|
char *filter_string)
|
|
{
|
|
struct ftrace_event_call *call;
|
|
struct filter_list *filter_item;
|
|
struct filter_list *tmp;
|
|
LIST_HEAD(filter_list);
|
|
bool fail = true;
|
|
int err;
|
|
|
|
list_for_each_entry(call, &ftrace_events, list) {
|
|
|
|
if (strcmp(call->class->system, system->name) != 0)
|
|
continue;
|
|
|
|
/*
|
|
* Try to see if the filter can be applied
|
|
* (filter arg is ignored on dry_run)
|
|
*/
|
|
err = replace_preds(call, NULL, ps, filter_string, true);
|
|
if (err)
|
|
call->flags |= TRACE_EVENT_FL_NO_SET_FILTER;
|
|
else
|
|
call->flags &= ~TRACE_EVENT_FL_NO_SET_FILTER;
|
|
}
|
|
|
|
list_for_each_entry(call, &ftrace_events, list) {
|
|
struct event_filter *filter;
|
|
|
|
if (strcmp(call->class->system, system->name) != 0)
|
|
continue;
|
|
|
|
if (call->flags & TRACE_EVENT_FL_NO_SET_FILTER)
|
|
continue;
|
|
|
|
filter_item = kzalloc(sizeof(*filter_item), GFP_KERNEL);
|
|
if (!filter_item)
|
|
goto fail_mem;
|
|
|
|
list_add_tail(&filter_item->list, &filter_list);
|
|
|
|
filter_item->filter = __alloc_filter();
|
|
if (!filter_item->filter)
|
|
goto fail_mem;
|
|
filter = filter_item->filter;
|
|
|
|
/* Can only fail on no memory */
|
|
err = replace_filter_string(filter, filter_string);
|
|
if (err)
|
|
goto fail_mem;
|
|
|
|
err = replace_preds(call, filter, ps, filter_string, false);
|
|
if (err) {
|
|
filter_disable(call);
|
|
parse_error(ps, FILT_ERR_BAD_SUBSYS_FILTER, 0);
|
|
append_filter_err(ps, filter);
|
|
} else
|
|
call->flags |= TRACE_EVENT_FL_FILTERED;
|
|
/*
|
|
* Regardless of if this returned an error, we still
|
|
* replace the filter for the call.
|
|
*/
|
|
filter = call->filter;
|
|
rcu_assign_pointer(call->filter, filter_item->filter);
|
|
filter_item->filter = filter;
|
|
|
|
fail = false;
|
|
}
|
|
|
|
if (fail)
|
|
goto fail;
|
|
|
|
/*
|
|
* The calls can still be using the old filters.
|
|
* Do a synchronize_sched() to ensure all calls are
|
|
* done with them before we free them.
|
|
*/
|
|
synchronize_sched();
|
|
list_for_each_entry_safe(filter_item, tmp, &filter_list, list) {
|
|
__free_filter(filter_item->filter);
|
|
list_del(&filter_item->list);
|
|
kfree(filter_item);
|
|
}
|
|
return 0;
|
|
fail:
|
|
/* No call succeeded */
|
|
list_for_each_entry_safe(filter_item, tmp, &filter_list, list) {
|
|
list_del(&filter_item->list);
|
|
kfree(filter_item);
|
|
}
|
|
parse_error(ps, FILT_ERR_BAD_SUBSYS_FILTER, 0);
|
|
return -EINVAL;
|
|
fail_mem:
|
|
/* If any call succeeded, we still need to sync */
|
|
if (!fail)
|
|
synchronize_sched();
|
|
list_for_each_entry_safe(filter_item, tmp, &filter_list, list) {
|
|
__free_filter(filter_item->filter);
|
|
list_del(&filter_item->list);
|
|
kfree(filter_item);
|
|
}
|
|
return -ENOMEM;
|
|
}
|
|
|
|
static int create_filter_start(char *filter_str, bool set_str,
|
|
struct filter_parse_state **psp,
|
|
struct event_filter **filterp)
|
|
{
|
|
struct event_filter *filter;
|
|
struct filter_parse_state *ps = NULL;
|
|
int err = 0;
|
|
|
|
WARN_ON_ONCE(*psp || *filterp);
|
|
|
|
/* allocate everything, and if any fails, free all and fail */
|
|
filter = __alloc_filter();
|
|
if (filter && set_str)
|
|
err = replace_filter_string(filter, filter_str);
|
|
|
|
ps = kzalloc(sizeof(*ps), GFP_KERNEL);
|
|
|
|
if (!filter || !ps || err) {
|
|
kfree(ps);
|
|
__free_filter(filter);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
/* we're committed to creating a new filter */
|
|
*filterp = filter;
|
|
*psp = ps;
|
|
|
|
parse_init(ps, filter_ops, filter_str);
|
|
err = filter_parse(ps);
|
|
if (err && set_str)
|
|
append_filter_err(ps, filter);
|
|
return err;
|
|
}
|
|
|
|
static void create_filter_finish(struct filter_parse_state *ps)
|
|
{
|
|
if (ps) {
|
|
filter_opstack_clear(ps);
|
|
postfix_clear(ps);
|
|
kfree(ps);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* create_filter - create a filter for a ftrace_event_call
|
|
* @call: ftrace_event_call to create a filter for
|
|
* @filter_str: filter string
|
|
* @set_str: remember @filter_str and enable detailed error in filter
|
|
* @filterp: out param for created filter (always updated on return)
|
|
*
|
|
* Creates a filter for @call with @filter_str. If @set_str is %true,
|
|
* @filter_str is copied and recorded in the new filter.
|
|
*
|
|
* On success, returns 0 and *@filterp points to the new filter. On
|
|
* failure, returns -errno and *@filterp may point to %NULL or to a new
|
|
* filter. In the latter case, the returned filter contains error
|
|
* information if @set_str is %true and the caller is responsible for
|
|
* freeing it.
|
|
*/
|
|
static int create_filter(struct ftrace_event_call *call,
|
|
char *filter_str, bool set_str,
|
|
struct event_filter **filterp)
|
|
{
|
|
struct event_filter *filter = NULL;
|
|
struct filter_parse_state *ps = NULL;
|
|
int err;
|
|
|
|
err = create_filter_start(filter_str, set_str, &ps, &filter);
|
|
if (!err) {
|
|
err = replace_preds(call, filter, ps, filter_str, false);
|
|
if (err && set_str)
|
|
append_filter_err(ps, filter);
|
|
}
|
|
create_filter_finish(ps);
|
|
|
|
*filterp = filter;
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* create_system_filter - create a filter for an event_subsystem
|
|
* @system: event_subsystem to create a filter for
|
|
* @filter_str: filter string
|
|
* @filterp: out param for created filter (always updated on return)
|
|
*
|
|
* Identical to create_filter() except that it creates a subsystem filter
|
|
* and always remembers @filter_str.
|
|
*/
|
|
static int create_system_filter(struct event_subsystem *system,
|
|
char *filter_str, struct event_filter **filterp)
|
|
{
|
|
struct event_filter *filter = NULL;
|
|
struct filter_parse_state *ps = NULL;
|
|
int err;
|
|
|
|
err = create_filter_start(filter_str, true, &ps, &filter);
|
|
if (!err) {
|
|
err = replace_system_preds(system, ps, filter_str);
|
|
if (!err) {
|
|
/* System filters just show a default message */
|
|
kfree(filter->filter_string);
|
|
filter->filter_string = NULL;
|
|
} else {
|
|
append_filter_err(ps, filter);
|
|
}
|
|
}
|
|
create_filter_finish(ps);
|
|
|
|
*filterp = filter;
|
|
return err;
|
|
}
|
|
|
|
int apply_event_filter(struct ftrace_event_call *call, char *filter_string)
|
|
{
|
|
struct event_filter *filter;
|
|
int err = 0;
|
|
|
|
mutex_lock(&event_mutex);
|
|
|
|
if (!strcmp(strstrip(filter_string), "0")) {
|
|
filter_disable(call);
|
|
filter = call->filter;
|
|
if (!filter)
|
|
goto out_unlock;
|
|
RCU_INIT_POINTER(call->filter, NULL);
|
|
/* Make sure the filter is not being used */
|
|
synchronize_sched();
|
|
__free_filter(filter);
|
|
goto out_unlock;
|
|
}
|
|
|
|
err = create_filter(call, filter_string, true, &filter);
|
|
|
|
/*
|
|
* Always swap the call filter with the new filter
|
|
* even if there was an error. If there was an error
|
|
* in the filter, we disable the filter and show the error
|
|
* string
|
|
*/
|
|
if (filter) {
|
|
struct event_filter *tmp = call->filter;
|
|
|
|
if (!err)
|
|
call->flags |= TRACE_EVENT_FL_FILTERED;
|
|
else
|
|
filter_disable(call);
|
|
|
|
rcu_assign_pointer(call->filter, filter);
|
|
|
|
if (tmp) {
|
|
/* Make sure the call is done with the filter */
|
|
synchronize_sched();
|
|
__free_filter(tmp);
|
|
}
|
|
}
|
|
out_unlock:
|
|
mutex_unlock(&event_mutex);
|
|
|
|
return err;
|
|
}
|
|
|
|
int apply_subsystem_event_filter(struct event_subsystem *system,
|
|
char *filter_string)
|
|
{
|
|
struct event_filter *filter;
|
|
int err = 0;
|
|
|
|
mutex_lock(&event_mutex);
|
|
|
|
/* Make sure the system still has events */
|
|
if (!system->nr_events) {
|
|
err = -ENODEV;
|
|
goto out_unlock;
|
|
}
|
|
|
|
if (!strcmp(strstrip(filter_string), "0")) {
|
|
filter_free_subsystem_preds(system);
|
|
remove_filter_string(system->filter);
|
|
filter = system->filter;
|
|
system->filter = NULL;
|
|
/* Ensure all filters are no longer used */
|
|
synchronize_sched();
|
|
filter_free_subsystem_filters(system);
|
|
__free_filter(filter);
|
|
goto out_unlock;
|
|
}
|
|
|
|
err = create_system_filter(system, filter_string, &filter);
|
|
if (filter) {
|
|
/*
|
|
* No event actually uses the system filter
|
|
* we can free it without synchronize_sched().
|
|
*/
|
|
__free_filter(system->filter);
|
|
system->filter = filter;
|
|
}
|
|
out_unlock:
|
|
mutex_unlock(&event_mutex);
|
|
|
|
return err;
|
|
}
|
|
|
|
#ifdef CONFIG_PERF_EVENTS
|
|
|
|
void ftrace_profile_free_filter(struct perf_event *event)
|
|
{
|
|
struct event_filter *filter = event->filter;
|
|
|
|
event->filter = NULL;
|
|
__free_filter(filter);
|
|
}
|
|
|
|
int ftrace_profile_set_filter(struct perf_event *event, int event_id,
|
|
char *filter_str)
|
|
{
|
|
int err;
|
|
struct event_filter *filter;
|
|
struct ftrace_event_call *call;
|
|
|
|
mutex_lock(&event_mutex);
|
|
|
|
call = event->tp_event;
|
|
|
|
err = -EINVAL;
|
|
if (!call)
|
|
goto out_unlock;
|
|
|
|
err = -EEXIST;
|
|
if (event->filter)
|
|
goto out_unlock;
|
|
|
|
err = create_filter(call, filter_str, false, &filter);
|
|
if (!err)
|
|
event->filter = filter;
|
|
else
|
|
__free_filter(filter);
|
|
|
|
out_unlock:
|
|
mutex_unlock(&event_mutex);
|
|
|
|
return err;
|
|
}
|
|
|
|
#endif /* CONFIG_PERF_EVENTS */
|
|
|
|
#ifdef CONFIG_FTRACE_STARTUP_TEST
|
|
|
|
#include <linux/types.h>
|
|
#include <linux/tracepoint.h>
|
|
|
|
#define CREATE_TRACE_POINTS
|
|
#include "trace_events_filter_test.h"
|
|
|
|
#define DATA_REC(m, va, vb, vc, vd, ve, vf, vg, vh, nvisit) \
|
|
{ \
|
|
.filter = FILTER, \
|
|
.rec = { .a = va, .b = vb, .c = vc, .d = vd, \
|
|
.e = ve, .f = vf, .g = vg, .h = vh }, \
|
|
.match = m, \
|
|
.not_visited = nvisit, \
|
|
}
|
|
#define YES 1
|
|
#define NO 0
|
|
|
|
static struct test_filter_data_t {
|
|
char *filter;
|
|
struct ftrace_raw_ftrace_test_filter rec;
|
|
int match;
|
|
char *not_visited;
|
|
} test_filter_data[] = {
|
|
#define FILTER "a == 1 && b == 1 && c == 1 && d == 1 && " \
|
|
"e == 1 && f == 1 && g == 1 && h == 1"
|
|
DATA_REC(YES, 1, 1, 1, 1, 1, 1, 1, 1, ""),
|
|
DATA_REC(NO, 0, 1, 1, 1, 1, 1, 1, 1, "bcdefgh"),
|
|
DATA_REC(NO, 1, 1, 1, 1, 1, 1, 1, 0, ""),
|
|
#undef FILTER
|
|
#define FILTER "a == 1 || b == 1 || c == 1 || d == 1 || " \
|
|
"e == 1 || f == 1 || g == 1 || h == 1"
|
|
DATA_REC(NO, 0, 0, 0, 0, 0, 0, 0, 0, ""),
|
|
DATA_REC(YES, 0, 0, 0, 0, 0, 0, 0, 1, ""),
|
|
DATA_REC(YES, 1, 0, 0, 0, 0, 0, 0, 0, "bcdefgh"),
|
|
#undef FILTER
|
|
#define FILTER "(a == 1 || b == 1) && (c == 1 || d == 1) && " \
|
|
"(e == 1 || f == 1) && (g == 1 || h == 1)"
|
|
DATA_REC(NO, 0, 0, 1, 1, 1, 1, 1, 1, "dfh"),
|
|
DATA_REC(YES, 0, 1, 0, 1, 0, 1, 0, 1, ""),
|
|
DATA_REC(YES, 1, 0, 1, 0, 0, 1, 0, 1, "bd"),
|
|
DATA_REC(NO, 1, 0, 1, 0, 0, 1, 0, 0, "bd"),
|
|
#undef FILTER
|
|
#define FILTER "(a == 1 && b == 1) || (c == 1 && d == 1) || " \
|
|
"(e == 1 && f == 1) || (g == 1 && h == 1)"
|
|
DATA_REC(YES, 1, 0, 1, 1, 1, 1, 1, 1, "efgh"),
|
|
DATA_REC(YES, 0, 0, 0, 0, 0, 0, 1, 1, ""),
|
|
DATA_REC(NO, 0, 0, 0, 0, 0, 0, 0, 1, ""),
|
|
#undef FILTER
|
|
#define FILTER "(a == 1 && b == 1) && (c == 1 && d == 1) && " \
|
|
"(e == 1 && f == 1) || (g == 1 && h == 1)"
|
|
DATA_REC(YES, 1, 1, 1, 1, 1, 1, 0, 0, "gh"),
|
|
DATA_REC(NO, 0, 0, 0, 0, 0, 0, 0, 1, ""),
|
|
DATA_REC(YES, 1, 1, 1, 1, 1, 0, 1, 1, ""),
|
|
#undef FILTER
|
|
#define FILTER "((a == 1 || b == 1) || (c == 1 || d == 1) || " \
|
|
"(e == 1 || f == 1)) && (g == 1 || h == 1)"
|
|
DATA_REC(YES, 1, 1, 1, 1, 1, 1, 0, 1, "bcdef"),
|
|
DATA_REC(NO, 0, 0, 0, 0, 0, 0, 0, 0, ""),
|
|
DATA_REC(YES, 1, 1, 1, 1, 1, 0, 1, 1, "h"),
|
|
#undef FILTER
|
|
#define FILTER "((((((((a == 1) && (b == 1)) || (c == 1)) && (d == 1)) || " \
|
|
"(e == 1)) && (f == 1)) || (g == 1)) && (h == 1))"
|
|
DATA_REC(YES, 1, 1, 1, 1, 1, 1, 1, 1, "ceg"),
|
|
DATA_REC(NO, 0, 1, 0, 1, 0, 1, 0, 1, ""),
|
|
DATA_REC(NO, 1, 0, 1, 0, 1, 0, 1, 0, ""),
|
|
#undef FILTER
|
|
#define FILTER "((((((((a == 1) || (b == 1)) && (c == 1)) || (d == 1)) && " \
|
|
"(e == 1)) || (f == 1)) && (g == 1)) || (h == 1))"
|
|
DATA_REC(YES, 1, 1, 1, 1, 1, 1, 1, 1, "bdfh"),
|
|
DATA_REC(YES, 0, 1, 0, 1, 0, 1, 0, 1, ""),
|
|
DATA_REC(YES, 1, 0, 1, 0, 1, 0, 1, 0, "bdfh"),
|
|
};
|
|
|
|
#undef DATA_REC
|
|
#undef FILTER
|
|
#undef YES
|
|
#undef NO
|
|
|
|
#define DATA_CNT (sizeof(test_filter_data)/sizeof(struct test_filter_data_t))
|
|
|
|
static int test_pred_visited;
|
|
|
|
static int test_pred_visited_fn(struct filter_pred *pred, void *event)
|
|
{
|
|
struct ftrace_event_field *field = pred->field;
|
|
|
|
test_pred_visited = 1;
|
|
printk(KERN_INFO "\npred visited %s\n", field->name);
|
|
return 1;
|
|
}
|
|
|
|
static int test_walk_pred_cb(enum move_type move, struct filter_pred *pred,
|
|
int *err, void *data)
|
|
{
|
|
char *fields = data;
|
|
|
|
if ((move == MOVE_DOWN) &&
|
|
(pred->left == FILTER_PRED_INVALID)) {
|
|
struct ftrace_event_field *field = pred->field;
|
|
|
|
if (!field) {
|
|
WARN(1, "all leafs should have field defined");
|
|
return WALK_PRED_DEFAULT;
|
|
}
|
|
if (!strchr(fields, *field->name))
|
|
return WALK_PRED_DEFAULT;
|
|
|
|
WARN_ON(!pred->fn);
|
|
pred->fn = test_pred_visited_fn;
|
|
}
|
|
return WALK_PRED_DEFAULT;
|
|
}
|
|
|
|
static __init int ftrace_test_event_filter(void)
|
|
{
|
|
int i;
|
|
|
|
printk(KERN_INFO "Testing ftrace filter: ");
|
|
|
|
for (i = 0; i < DATA_CNT; i++) {
|
|
struct event_filter *filter = NULL;
|
|
struct test_filter_data_t *d = &test_filter_data[i];
|
|
int err;
|
|
|
|
err = create_filter(&event_ftrace_test_filter, d->filter,
|
|
false, &filter);
|
|
if (err) {
|
|
printk(KERN_INFO
|
|
"Failed to get filter for '%s', err %d\n",
|
|
d->filter, err);
|
|
__free_filter(filter);
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* The preemption disabling is not really needed for self
|
|
* tests, but the rcu dereference will complain without it.
|
|
*/
|
|
preempt_disable();
|
|
if (*d->not_visited)
|
|
walk_pred_tree(filter->preds, filter->root,
|
|
test_walk_pred_cb,
|
|
d->not_visited);
|
|
|
|
test_pred_visited = 0;
|
|
err = filter_match_preds(filter, &d->rec);
|
|
preempt_enable();
|
|
|
|
__free_filter(filter);
|
|
|
|
if (test_pred_visited) {
|
|
printk(KERN_INFO
|
|
"Failed, unwanted pred visited for filter %s\n",
|
|
d->filter);
|
|
break;
|
|
}
|
|
|
|
if (err != d->match) {
|
|
printk(KERN_INFO
|
|
"Failed to match filter '%s', expected %d\n",
|
|
d->filter, d->match);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i == DATA_CNT)
|
|
printk(KERN_CONT "OK\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
late_initcall(ftrace_test_event_filter);
|
|
|
|
#endif /* CONFIG_FTRACE_STARTUP_TEST */
|