21 #include <linux/module.h>
22 #include <linux/ctype.h>
24 #include <linux/perf_event.h>
25 #include <linux/slab.h>
30 #define DEFAULT_SYS_FILTER_MESSAGE \
31 "### global filter ###\n" \
32 "# Use this to set filters for multiple events.\n" \
33 "# Only events with the given fields will be affected.\n" \
34 "# If no events are modified, an error message will be displayed here"
87 static char *err_text[] = {
94 "Illegal operation for field type",
95 "Illegal integer value",
96 "Couldn't find or set field in one of a subsystem's events",
97 "Too many terms in predicate expression",
98 "Missing field name and/or value",
99 "Meaningless filter expression",
100 "Only 'ip' field is supported for function trace",
139 #define DEFINE_COMPARISON_PRED(type) \
140 static int filter_pred_##type(struct filter_pred *pred, void *event) \
142 type *addr = (type *)(event + pred->offset); \
143 type val = (type)pred->val; \
146 switch (pred->op) { \
148 match = (*addr < val); \
151 match = (*addr <= val); \
154 match = (*addr > val); \
157 match = (*addr >= val); \
166 #define DEFINE_EQUALITY_PRED(size) \
167 static int filter_pred_##size(struct filter_pred *pred, void *event) \
169 u##size *addr = (u##size *)(event + pred->offset); \
170 u##size val = (u##size)pred->val; \
173 match = (val == *addr) ^ pred->not; \
200 match = cmp ^ pred->
not;
206 static int filter_pred_pchar(
struct filter_pred *pred,
void *event)
208 char **addr = (
char **)(event + pred->
offset);
212 cmp = pred->
regex.match(*addr, &pred->
regex, len);
214 match = cmp ^ pred->
not;
229 static int filter_pred_strloc(
struct filter_pred *pred,
void *event)
232 int str_loc = str_item & 0xffff;
233 int str_len = str_item >> 16;
234 char *addr = (
char *)(event + str_loc);
237 cmp = pred->
regex.match(addr, &pred->
regex, str_len);
239 match = cmp ^ pred->
not;
244 static int filter_pred_none(
struct filter_pred *pred,
void *event)
261 static int regex_match_full(
char *
str,
struct regex *
r,
int len)
268 static int regex_match_front(
char *str,
struct regex *r,
int len)
275 static int regex_match_middle(
char *str,
struct regex *r,
int len)
282 static int regex_match_end(
char *str,
struct regex *r,
int len)
286 if (strlen >= r->
len &&
314 if (buff[0] ==
'!') {
323 for (i = 0; i < len; i++) {
324 if (buff[i] ==
'*') {
342 static void filter_build_regex(
struct filter_pred *pred)
357 r->
match = regex_match_full;
360 r->
match = regex_match_front;
363 r->
match = regex_match_middle;
366 r->
match = regex_match_end;
402 static int walk_pred_tree(
struct filter_pred *preds,
416 ret = cb(move, pred, &err, data);
425 pred = &preds[pred->
left];
430 pred = &preds[pred->
right];
437 pred = get_pred_parent(pred, preds,
476 for (i = 0; i < op->
val; i++) {
477 pred = &preds[op->
ops[
i]];
479 match = pred->
fn(pred, rec);
493 int *err,
void *
data)
560 ret = walk_pred_tree(preds, root, filter_match_preds_cb, &data);
581 static int replace_filter_string(
struct event_filter *filter,
592 static int append_filter_string(
struct event_filter *filter,
596 char *new_filter_string;
601 if (!new_filter_string)
605 strcat(new_filter_string,
string);
622 append_filter_string(filter,
"\n");
627 pbuf = &buf[
pos] + 1;
630 append_filter_string(filter, buf);
680 field = __find_event_field(&ftrace_common_fields, name);
685 return __find_event_field(head, name);
693 stack->
index = n_preds;
697 static void __free_pred_stack(
struct pred_stack *stack)
703 static int __push_pred_stack(
struct pred_stack *stack,
720 int index = stack->
index;
722 pred = stack->
preds[index++];
743 right = __pop_pred_stack(stack);
744 left = __pop_pred_stack(stack);
753 (left->
op == dest->
op ||
756 (right->
op == dest->
op ||
775 return __push_pred_stack(stack, dest);
798 __free_preds(filter);
811 __free_filter(call->
filter);
819 filter = kzalloc(
sizeof(*filter),
GFP_KERNEL);
823 static int __alloc_preds(
struct event_filter *filter,
int n_preds)
829 __free_preds(filter);
839 for (i = 0; i < n_preds; i++) {
841 pred->
fn = filter_pred_none;
855 filter_disable(call);
856 remove_filter_string(call->
filter);
860 static void filter_free_subsystem_filters(
struct event_subsystem *system)
867 __free_filter(call->
filter);
884 err = filter_set_pred(filter, filter->
n_preds, stack, pred);
918 if (is_string_field(field) &&
921 if (!is_string_field(field) && op ==
OP_GLOB)
932 switch (field_size) {
936 else if (field_is_signed)
937 fn = filter_pred_s64;
939 fn = filter_pred_u64;
944 else if (field_is_signed)
945 fn = filter_pred_s32;
947 fn = filter_pred_u32;
952 else if (field_is_signed)
953 fn = filter_pred_s16;
955 fn = filter_pred_u16;
960 else if (field_is_signed)
976 unsigned long long val;
981 if (!is_legal_op(field, pred->
op)) {
986 if (is_string_field(field)) {
987 filter_build_regex(pred);
990 fn = filter_pred_string;
993 fn = filter_pred_strloc;
995 fn = filter_pred_pchar;
996 }
else if (is_function_field(field)) {
1012 fn = select_comparison_fn(pred->
op, field->
size,
1031 memset(ps,
'\0',
sizeof(*ps));
1033 ps->
infix.string = infix_string;
1050 if (ps->
infix.tail == strlen(ps->
infix.string))
1065 return ps->
ops[
a].precedence < ps->
ops[
b].precedence;
1072 for (i = 0;
strcmp(ps->
ops[i].string,
"OP_NONE"); i++) {
1073 if (ps->
ops[i].string[0] == c)
1082 char nextc = infix_peek(ps);
1090 for (i = 0;
strcmp(ps->
ops[i].string,
"OP_NONE"); i++) {
1091 if (!
strcmp(opstr, ps->
ops[i].string)) {
1093 return ps->
ops[
i].id;
1099 for (i = 0;
strcmp(ps->
ops[i].string,
"OP_NONE"); i++) {
1101 return ps->
ops[i].id;
1131 opstack_op->
op =
op;
1139 return list_empty(&ps->
opstack);
1144 struct opstack_op *opstack_op;
1146 if (filter_opstack_empty(ps))
1151 return opstack_op->
op;
1156 struct opstack_op *opstack_op;
1159 if (filter_opstack_empty(ps))
1163 op = opstack_op->
op;
1173 while (!filter_opstack_empty(ps))
1174 filter_opstack_pop(ps);
1222 while (!list_empty(&ps->
postfix)) {
1236 while ((ch = infix_next(ps))) {
1248 if (is_op_char(ps, ch)) {
1249 op = infix_get_op(ps, ch);
1255 if (
strlen(curr_operand(ps))) {
1256 postfix_append_operand(ps, curr_operand(ps));
1257 clear_operand_string(ps);
1260 while (!filter_opstack_empty(ps)) {
1261 top_op = filter_opstack_top(ps);
1262 if (!is_precedence_lower(ps, top_op, op)) {
1263 top_op = filter_opstack_pop(ps);
1264 postfix_append_op(ps, top_op);
1270 filter_opstack_push(ps, op);
1280 if (
strlen(curr_operand(ps))) {
1281 postfix_append_operand(ps, curr_operand(ps));
1282 clear_operand_string(ps);
1285 top_op = filter_opstack_pop(ps);
1289 postfix_append_op(ps, top_op);
1290 top_op = filter_opstack_pop(ps);
1299 if (append_operand_char(ps, ch)) {
1305 if (
strlen(curr_operand(ps)))
1306 postfix_append_operand(ps, curr_operand(ps));
1308 while (!filter_opstack_empty(ps)) {
1309 top_op = filter_opstack_pop(ps);
1316 postfix_append_op(ps, top_op);
1324 int op,
char *operand1,
char *operand2)
1329 memset(&pred, 0,
sizeof(pred));
1335 if (!operand1 || !operand2) {
1340 field = find_event_field(call, operand1);
1349 return init_pred(ps, field, &pred) ?
NULL : &
pred;
1354 int n_normal_preds = 0, n_logical_preds = 0;
1368 if (!n_normal_preds || n_logical_preds >= n_normal_preds) {
1396 int *err,
void *
data)
1412 static int check_pred_tree(
struct event_filter *filter,
1426 return walk_pred_tree(filter->
preds, root,
1427 check_pred_tree_cb, &data);
1431 int *err,
void *
data)
1446 ret = walk_pred_tree(preds, root, count_leafs_cb, &count);
1458 int *err,
void *data)
1494 children = count_leafs(preds, &preds[root->
left]);
1495 children += count_leafs(preds, &preds[root->
right]);
1503 return walk_pred_tree(preds, root, fold_pred_cb, &data);
1507 int *err,
void *data)
1516 *err = fold_pred(preds, pred);
1532 return walk_pred_tree(filter->
preds, root, fold_pred_tree_cb,
1539 char *filter_string,
1542 char *operand1 =
NULL, *operand2 =
NULL;
1550 n_preds = count_preds(ps);
1556 err = check_preds(ps);
1561 err = __alloc_pred_stack(&stack, n_preds);
1564 err = __alloc_preds(filter, n_preds);
1590 pred = create_pred(ps, call, elt->
op, operand1, operand2);
1597 err = filter_add_pred(ps, filter, pred, &stack);
1602 operand1 = operand2 =
NULL;
1607 pred = __pop_pred_stack(&stack);
1613 pred = __pop_pred_stack(&stack);
1619 err = check_pred_tree(filter, root);
1624 err = fold_pred_tree(filter, root);
1630 filter->
root = root;
1635 __free_pred_stack(&stack);
1646 char *filter_string)
1664 err = replace_preds(call,
NULL, ps, filter_string,
true);
1680 filter_item = kzalloc(
sizeof(*filter_item),
GFP_KERNEL);
1686 filter_item->
filter = __alloc_filter();
1687 if (!filter_item->
filter)
1689 filter = filter_item->
filter;
1692 err = replace_filter_string(filter, filter_string);
1696 err = replace_preds(call, filter, ps, filter_string,
false);
1698 filter_disable(call);
1700 append_filter_err(ps, filter);
1724 __free_filter(filter_item->
filter);
1742 __free_filter(filter_item->
filter);
1749 static int create_filter_start(
char *filter_str,
bool set_str,
1760 filter = __alloc_filter();
1761 if (filter && set_str)
1762 err = replace_filter_string(filter, filter_str);
1766 if (!filter || !ps || err) {
1768 __free_filter(filter);
1776 parse_init(ps, filter_ops, filter_str);
1777 err = filter_parse(ps);
1779 append_filter_err(ps, filter);
1786 filter_opstack_clear(ps);
1809 char *filter_str,
bool set_str,
1816 err = create_filter_start(filter_str, set_str, &ps, &filter);
1818 err = replace_preds(call, filter, ps, filter_str,
false);
1820 append_filter_err(ps, filter);
1822 create_filter_finish(ps);
1844 err = create_filter_start(filter_str,
true, &ps, &filter);
1846 err = replace_system_preds(system, ps, filter_str);
1852 append_filter_err(ps, filter);
1855 create_filter_finish(ps);
1868 if (!
strcmp(strstrip(filter_string),
"0")) {
1869 filter_disable(call);
1876 __free_filter(filter);
1880 err = create_filter(call, filter_string,
true, &filter);
1894 filter_disable(call);
1911 char *filter_string)
1924 if (!
strcmp(strstrip(filter_string),
"0")) {
1925 filter_free_subsystem_preds(system);
1926 remove_filter_string(system->
filter);
1931 filter_free_subsystem_filters(system);
1932 __free_filter(filter);
1936 err = create_system_filter(system, filter_string, &filter);
1942 __free_filter(system->
filter);
1951 #ifdef CONFIG_PERF_EVENTS
1953 void ftrace_profile_free_filter(
struct perf_event *event)
1957 event->filter =
NULL;
1958 __free_filter(filter);
1961 struct function_filter_data {
1962 struct ftrace_ops *ops;
1967 #ifdef CONFIG_FUNCTION_TRACER
1969 ftrace_function_filter_re(
char *buf,
int len,
int *count)
1971 char *
str, *sep, **re;
1981 while ((sep =
strchr(str,
',')))
1989 static int ftrace_function_set_regexp(
struct ftrace_ops *ops,
int filter,
1990 int reset,
char *re,
int len)
2002 static int __ftrace_function_set_filter(
int filter,
char *buf,
int len,
2003 struct function_filter_data *data)
2009 reset = filter ? &data->first_filter : &data->first_notrace;
2016 re = ftrace_function_filter_re(buf, len, &re_cnt);
2020 for (i = 0; i < re_cnt; i++) {
2021 ret = ftrace_function_set_regexp(data->ops, filter, *reset,
2022 re[i], strlen(re[i]));
2034 static int ftrace_function_check_pred(
struct filter_pred *pred,
int leaf)
2061 static int ftrace_function_set_filter_cb(
enum move_type move,
2063 int *err,
void *data)
2068 *err = ftrace_function_check_pred(pred, 0);
2070 *err = ftrace_function_check_pred(pred, 1);
2074 *err = __ftrace_function_set_filter(pred->
op ==
OP_EQ,
2075 pred->
regex.pattern,
2083 static int ftrace_function_set_filter(
struct perf_event *event,
2086 struct function_filter_data data = {
2089 .ops = &
event->ftrace_ops,
2092 return walk_pred_tree(filter->
preds, filter->
root,
2093 ftrace_function_set_filter_cb, &data);
2096 static int ftrace_function_set_filter(
struct perf_event *event,
2112 call =
event->tp_event;
2122 err = create_filter(call, filter_str,
false, &filter);
2127 err = ftrace_function_set_filter(event, filter);
2133 __free_filter(filter);
2143 #ifdef CONFIG_FTRACE_STARTUP_TEST
2145 #include <linux/types.h>
2148 #define CREATE_TRACE_POINTS
2151 #define DATA_REC(m, va, vb, vc, vd, ve, vf, vg, vh, nvisit) \
2154 .rec = { .a = va, .b = vb, .c = vc, .d = vd, \
2155 .e = ve, .f = vf, .g = vg, .h = vh }, \
2157 .not_visited = nvisit, \
2162 static struct test_filter_data_t {
2164 struct ftrace_raw_ftrace_test_filter rec;
2167 } test_filter_data[] = {
2168 #define FILTER "a == 1 && b == 1 && c == 1 && d == 1 && " \
2169 "e == 1 && f == 1 && g == 1 && h == 1"
2170 DATA_REC(
YES, 1, 1, 1, 1, 1, 1, 1, 1,
""),
2171 DATA_REC(
NO, 0, 1, 1, 1, 1, 1, 1, 1,
"bcdefgh"),
2172 DATA_REC(
NO, 1, 1, 1, 1, 1, 1, 1, 0,
""),
2174 #define FILTER "a == 1 || b == 1 || c == 1 || d == 1 || " \
2175 "e == 1 || f == 1 || g == 1 || h == 1"
2176 DATA_REC(
NO, 0, 0, 0, 0, 0, 0, 0, 0,
""),
2177 DATA_REC(
YES, 0, 0, 0, 0, 0, 0, 0, 1,
""),
2178 DATA_REC(
YES, 1, 0, 0, 0, 0, 0, 0, 0,
"bcdefgh"),
2180 #define FILTER "(a == 1 || b == 1) && (c == 1 || d == 1) && " \
2181 "(e == 1 || f == 1) && (g == 1 || h == 1)"
2182 DATA_REC(
NO, 0, 0, 1, 1, 1, 1, 1, 1,
"dfh"),
2183 DATA_REC(
YES, 0, 1, 0, 1, 0, 1, 0, 1,
""),
2184 DATA_REC(
YES, 1, 0, 1, 0, 0, 1, 0, 1,
"bd"),
2185 DATA_REC(
NO, 1, 0, 1, 0, 0, 1, 0, 0,
"bd"),
2187 #define FILTER "(a == 1 && b == 1) || (c == 1 && d == 1) || " \
2188 "(e == 1 && f == 1) || (g == 1 && h == 1)"
2189 DATA_REC(
YES, 1, 0, 1, 1, 1, 1, 1, 1,
"efgh"),
2190 DATA_REC(
YES, 0, 0, 0, 0, 0, 0, 1, 1,
""),
2191 DATA_REC(
NO, 0, 0, 0, 0, 0, 0, 0, 1,
""),
2193 #define FILTER "(a == 1 && b == 1) && (c == 1 && d == 1) && " \
2194 "(e == 1 && f == 1) || (g == 1 && h == 1)"
2195 DATA_REC(
YES, 1, 1, 1, 1, 1, 1, 0, 0,
"gh"),
2196 DATA_REC(
NO, 0, 0, 0, 0, 0, 0, 0, 1,
""),
2197 DATA_REC(
YES, 1, 1, 1, 1, 1, 0, 1, 1,
""),
2199 #define FILTER "((a == 1 || b == 1) || (c == 1 || d == 1) || " \
2200 "(e == 1 || f == 1)) && (g == 1 || h == 1)"
2201 DATA_REC(
YES, 1, 1, 1, 1, 1, 1, 0, 1,
"bcdef"),
2202 DATA_REC(
NO, 0, 0, 0, 0, 0, 0, 0, 0,
""),
2203 DATA_REC(
YES, 1, 1, 1, 1, 1, 0, 1, 1,
"h"),
2205 #define FILTER "((((((((a == 1) && (b == 1)) || (c == 1)) && (d == 1)) || " \
2206 "(e == 1)) && (f == 1)) || (g == 1)) && (h == 1))"
2207 DATA_REC(
YES, 1, 1, 1, 1, 1, 1, 1, 1,
"ceg"),
2208 DATA_REC(
NO, 0, 1, 0, 1, 0, 1, 0, 1,
""),
2209 DATA_REC(
NO, 1, 0, 1, 0, 1, 0, 1, 0,
""),
2211 #define FILTER "((((((((a == 1) || (b == 1)) && (c == 1)) || (d == 1)) && " \
2212 "(e == 1)) || (f == 1)) && (g == 1)) || (h == 1))"
2213 DATA_REC(
YES, 1, 1, 1, 1, 1, 1, 1, 1,
"bdfh"),
2214 DATA_REC(
YES, 0, 1, 0, 1, 0, 1, 0, 1,
""),
2215 DATA_REC(
YES, 1, 0, 1, 0, 1, 0, 1, 0,
"bdfh"),
2223 #define DATA_CNT (sizeof(test_filter_data)/sizeof(struct test_filter_data_t))
2225 static int test_pred_visited;
2227 static int test_pred_visited_fn(
struct filter_pred *pred,
void *event)
2231 test_pred_visited = 1;
2237 int *err,
void *data)
2246 WARN(1,
"all leafs should have field defined");
2253 pred->
fn = test_pred_visited_fn;
2258 static __init int ftrace_test_event_filter(
void)
2264 for (i = 0; i < DATA_CNT; i++) {
2266 struct test_filter_data_t *
d = &test_filter_data[
i];
2269 err = create_filter(&event_ftrace_test_filter, d->filter,
2273 "Failed to get filter for '%s', err %d\n",
2275 __free_filter(filter);
2284 if (*d->not_visited)
2285 walk_pred_tree(filter->
preds, filter->
root,
2289 test_pred_visited = 0;
2293 __free_filter(filter);
2295 if (test_pred_visited) {
2297 "Failed, unwanted pred visited for filter %s\n",
2302 if (err != d->match) {
2304 "Failed to match filter '%s', expected %d\n",
2305 d->filter, d->match);