kernel/trace/trace_events_filter.c

93  * pred functions are OP_LE, OP_LT, OP_GE, OP_GT, and OP_BAND
148  * @pred:	     The predicate to execute.
153 	struct filter_pred	*pred;
192 			     struct filter_pred **pred);
200 static void free_predicate(struct filter_pred *pred)
202 	if (pred) {
203 		kfree(pred->regex);
204 		kfree(pred->mask);
205 		kfree(pred);
331  *  "a"  - prog[0] = { "a", X, -1 } // pred, when_to_branch, target
536 		len = parse_pred(next, data, ptr - str, pe, &prog[N].pred);
613 	prog[N].pred = NULL;					/* #13 */
615 	prog[N+1].pred = NULL;
645 		for (i = 0; prog_stack[i].pred; i++)
646 			free_predicate(prog_stack[i].pred);
714 static int filter_pred_##type(struct filter_pred *pred, void *event)	\
716 	switch (pred->op) {						\
718 		type *addr = (type *)(event + pred->offset);		\
719 		type val = (type)pred->val;				\
723 		type *addr = (type *)(event + pred->offset);		\
724 		type val = (type)pred->val;				\
728 		type *addr = (type *)(event + pred->offset);		\
729 		type val = (type)pred->val;				\
733 		type *addr = (type *)(event + pred->offset);		\
734 		type val = (type)pred->val;				\
738 		type *addr = (type *)(event + pred->offset);		\
739 		type val = (type)pred->val;				\
748 static int filter_pred_##size##_cpumask(struct filter_pred *pred, void *event)	\
750 	u##size *addr = (u##size *)(event + pred->offset);			\
756 	return do_filter_scalar_cpumask(pred->op, cpu, pred->mask);		\
760 static int filter_pred_##size(struct filter_pred *pred, void *event)	\
762 	u##size *addr = (u##size *)(event + pred->offset);		\
763 	u##size val = (u##size)pred->val;				\
766 	match = (val == *addr) ^ pred->not;				\
837 static int filter_pred_string(struct filter_pred *pred, void *event)
839 	char *addr = (char *)(event + pred->offset);
842 	cmp = pred->regex->match(addr, pred->regex, pred->regex->field_len);
844 	match = cmp ^ pred->not;
849 static __always_inline int filter_pchar(struct filter_pred *pred, char *str)
855 	cmp = pred->regex->match(str, pred->regex, len);
857 	match = cmp ^ pred->not;
862 static int filter_pred_pchar(struct filter_pred *pred, void *event)
864 	char **addr = (char **)(event + pred->offset);
871 	return filter_pchar(pred, str);
875 static int filter_pred_pchar_user(struct filter_pred *pred, void *event)
877 	char **addr = (char **)(event + pred->offset);
884 	return filter_pchar(pred, str);
897 static int filter_pred_strloc(struct filter_pred *pred, void *event)
899 	u32 str_item = *(u32 *)(event + pred->offset);
905 	cmp = pred->regex->match(addr, pred->regex, str_len);
907 	match = cmp ^ pred->not;
919 static int filter_pred_strrelloc(struct filter_pred *pred, void *event)
921 	u32 *item = (u32 *)(event + pred->offset);
928 	cmp = pred->regex->match(addr, pred->regex, str_len);
930 	match = cmp ^ pred->not;
936 static int filter_pred_cpu(struct filter_pred *pred, void *event)
941 	cmp = pred->val;
943 	switch (pred->op) {
962 static int filter_pred_cpu_cpumask(struct filter_pred *pred, void *event)
966 	return do_filter_scalar_cpumask(pred->op, cpu, pred->mask);
970 static int filter_pred_cpumask(struct filter_pred *pred, void *event)
972 	u32 item = *(u32 *)(event + pred->offset);
975 	const struct cpumask *cmp = pred->mask;
977 	return do_filter_cpumask(pred->op, mask, cmp);
981 static int filter_pred_cpumask_cpu(struct filter_pred *pred, void *event)
983 	u32 item = *(u32 *)(event + pred->offset);
986 	unsigned int cpu = pred->val;
988 	return do_filter_cpumask_scalar(pred->op, mask, cpu);
992 static int filter_pred_comm(struct filter_pred *pred, void *event)
996 	cmp = pred->regex->match(current->comm, pred->regex,
998 	return cmp ^ pred->not;
1002 static int filter_pred_function(struct filter_pred *pred, void *event)
1004 	unsigned long *addr = (unsigned long *)(event + pred->offset);
1005 	unsigned long start = (unsigned long)pred->val;
1006 	unsigned long end = (unsigned long)pred->val2;
1009 	return pred->op == OP_EQ ? ret : !ret;
1124 static void filter_build_regex(struct filter_pred *pred)
1126 	struct regex *r = pred->regex;
1130 	if (pred->op == OP_GLOB) {
1131 		type = filter_parse_regex(r->pattern, r->len, &search, &pred->not);
1159 static int test_pred_visited_fn(struct filter_pred *pred, void *event);
1161 static int test_pred_visited_fn(struct filter_pred *pred, void *event)
1168 static int filter_pred_fn_call(struct filter_pred *pred, void *event);
1185 	for (i = 0; prog[i].pred; i++) {
1186 		struct filter_pred *pred = prog[i].pred;
1187 		int match = filter_pred_fn_call(pred, rec);
1290 	for (i = 0; prog[i].pred; i++)
1291 		free_predicate(prog[i].pred);
1434 static int filter_pred_fn_call(struct filter_pred *pred, void *event)
1436 	switch (pred->fn_num) {
1438 		return filter_pred_64(pred, event);
1440 		return filter_pred_64_cpumask(pred, event);
1442 		return filter_pred_s64(pred, event);
1444 		return filter_pred_u64(pred, event);
1446 		return filter_pred_32(pred, event);
1448 		return filter_pred_32_cpumask(pred, event);
1450 		return filter_pred_s32(pred, event);
1452 		return filter_pred_u32(pred, event);
1454 		return filter_pred_16(pred, event);
1456 		return filter_pred_16_cpumask(pred, event);
1458 		return filter_pred_s16(pred, event);
1460 		return filter_pred_u16(pred, event);
1462 		return filter_pred_8(pred, event);
1464 		return filter_pred_8_cpumask(pred, event);
1466 		return filter_pred_s8(pred, event);
1468 		return filter_pred_u8(pred, event);
1470 		return filter_pred_comm(pred, event);
1472 		return filter_pred_string(pred, event);
1474 		return filter_pred_strloc(pred, event);
1476 		return filter_pred_strrelloc(pred, event);
1478 		return filter_pred_pchar_user(pred, event);
1480 		return filter_pred_pchar(pred, event);
1482 		return filter_pred_cpu(pred, event);
1484 		return filter_pred_cpu_cpumask(pred, event);
1486 		return filter_pred_cpumask(pred, event);
1488 		return filter_pred_cpumask_cpu(pred, event);
1490 		return filter_pred_function(pred, event);
1492 		return test_pred_visited_fn(pred, event);
1505 	struct filter_pred *pred = NULL;
1582 	pred = kzalloc(sizeof(*pred), GFP_KERNEL);
1583 	if (!pred)
1586 	pred->field = field;
1587 	pred->offset = field->offset;
1588 	pred->op = op;
1650 		pred->fn_num = FILTER_PRED_FN_FUNCTION;
1651 		pred->val = ip - offset;
1652 		pred->val2 = pred->val + size;
1666 		pred->fn_num = FILTER_PRED_FN_NOP;
1693 		pred->regex = kzalloc(sizeof(*pred->regex), GFP_KERNEL);
1694 		if (!pred->regex)
1696 		pred->regex->len = len;
1697 		strncpy(pred->regex->pattern, str + s, len);
1698 		pred->regex->pattern[len] = 0;
1753 		pred->mask = kzalloc(cpumask_size(), GFP_KERNEL);
1754 		if (!pred->mask) {
1760 		if (cpulist_parse(tmp, pred->mask)) {
1774 		single = cpumask_weight(pred->mask) == 1;
1776 			pred->val = cpumask_first(pred->mask);
1777 			kfree(pred->mask);
1778 			pred->mask = NULL;
1782 			pred->fn_num = single ?
1787 				if (pred->op == OP_BAND)
1788 					pred->op = OP_EQ;
1790 				pred->fn_num = FILTER_PRED_FN_CPU;
1792 				pred->fn_num = FILTER_PRED_FN_CPU_CPUMASK;
1795 			if (pred->op == OP_BAND)
1796 				pred->op = OP_EQ;
1798 			pred->fn_num = select_comparison_fn(pred->op, field->size, false);
1799 			if (pred->op == OP_NE)
1800 				pred->not = 1;
1804 				pred->fn_num = FILTER_PRED_FN_64_CPUMASK;
1807 				pred->fn_num = FILTER_PRED_FN_32_CPUMASK;
1810 				pred->fn_num = FILTER_PRED_FN_16_CPUMASK;
1813 				pred->fn_num = FILTER_PRED_FN_8_CPUMASK;
1825 			pred->not = 1;
1858 		pred->regex = kzalloc(sizeof(*pred->regex), GFP_KERNEL);
1859 		if (!pred->regex)
1861 		pred->regex->len = len;
1862 		strncpy(pred->regex->pattern, str + s, len);
1863 		pred->regex->pattern[len] = 0;
1865 		filter_build_regex(pred);
1868 			pred->fn_num = FILTER_PRED_FN_COMM;
1871 			pred->fn_num = FILTER_PRED_FN_STRING;
1872 			pred->regex->field_len = field->size;
1875 			pred->fn_num = FILTER_PRED_FN_STRLOC;
1877 			pred->fn_num = FILTER_PRED_FN_STRRELLOC;
1888 				pred->fn_num = FILTER_PRED_FN_PCHAR_USER;
1890 				pred->fn_num = FILTER_PRED_FN_PCHAR;
1935 		pred->val = val;
1938 			pred->fn_num = FILTER_PRED_FN_CPU;
1940 			pred->fn_num = select_comparison_fn(pred->op, field->size,
1942 			if (pred->op == OP_NE)
1943 				pred->not = 1;
1951 	*pred_ptr = pred;
1955 	free_predicate(pred);
1958 	free_predicate(pred);
2525 static int ftrace_function_check_pred(struct filter_pred *pred)
2527 	struct ftrace_event_field *field = pred->field;
2534 	if ((pred->op != OP_EQ) && (pred->op != OP_NE))
2543 static int ftrace_function_set_filter_pred(struct filter_pred *pred,
2549 	ret = ftrace_function_check_pred(pred);
2553 	return __ftrace_function_set_filter(pred->op == OP_EQ,
2554 					    pred->regex->pattern,
2555 					    pred->regex->len,
2570 	if (prog[target].pred)
2589 	for (i = 0; prog[i].pred; i++) {
2590 		struct filter_pred *pred = prog[i].pred;
2595 		if (ftrace_function_set_filter_pred(pred, &data) < 0)
2732 static int test_pred_visited_fn(struct filter_pred *pred, void *event)
2734 	struct ftrace_event_field *field = pred->field;
2747 	for (i = 0; prog[i].pred; i++) {
2748 		struct filter_pred *pred = prog[i].pred;
2749 		struct ftrace_event_field *field = pred->field;
2751 		WARN_ON_ONCE(pred->fn_num == FILTER_PRED_FN_NOP);
2761 		pred->fn_num = FILTER_PRED_TEST_VISITED;
2806 			       "Failed, unwanted pred visited for filter %s\n",