Kernel

Kernel Git Source Tree

Root/kernel/trace/trace_events_filter.c

1	/*
2	* trace_events_filter - generic event filtering
3	*
4	* This program is free software; you can redistribute it and/or modify
5	* it under the terms of the GNU General Public License as published by
6	* the Free Software Foundation; either version 2 of the License, or
7	* (at your option) any later version.
8	*
9	* This program is distributed in the hope that it will be useful,
10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	* GNU General Public License for more details.
13	*
14	* You should have received a copy of the GNU General Public License
15	* along with this program; if not, write to the Free Software
16	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17	*
18	* Copyright (C) 2009 Tom Zanussi <tzanussi@gmail.com>
19	*/
20
21	#include <linux/module.h>
22	#include <linux/ctype.h>
23	#include <linux/mutex.h>
24	#include <linux/perf_event.h>
25	#include <linux/slab.h>
26
27	#include "trace.h"
28	#include "trace_output.h"
29
30	enum filter_op_ids
31	{
32	OP_OR,
33	OP_AND,
34	OP_GLOB,
35	OP_NE,
36	OP_EQ,
37	OP_LT,
38	OP_LE,
39	OP_GT,
40	OP_GE,
41	OP_NONE,
42	OP_OPEN_PAREN,
43	};
44
45	struct filter_op {
46	int id;
47	char *string;
48	int precedence;
49	};
50
51	static struct filter_op filter_ops[] = {
52	{ OP_OR, "\|\|", 1 },
53	{ OP_AND, "&&", 2 },
54	{ OP_GLOB, "~", 4 },
55	{ OP_NE, "!=", 4 },
56	{ OP_EQ, "==", 4 },
57	{ OP_LT, "<", 5 },
58	{ OP_LE, "<=", 5 },
59	{ OP_GT, ">", 5 },
60	{ OP_GE, ">=", 5 },
61	{ OP_NONE, "OP_NONE", 0 },
62	{ OP_OPEN_PAREN, "(", 0 },
63	};
64
65	enum {
66	FILT_ERR_NONE,
67	FILT_ERR_INVALID_OP,
68	FILT_ERR_UNBALANCED_PAREN,
69	FILT_ERR_TOO_MANY_OPERANDS,
70	FILT_ERR_OPERAND_TOO_LONG,
71	FILT_ERR_FIELD_NOT_FOUND,
72	FILT_ERR_ILLEGAL_FIELD_OP,
73	FILT_ERR_ILLEGAL_INTVAL,
74	FILT_ERR_BAD_SUBSYS_FILTER,
75	FILT_ERR_TOO_MANY_PREDS,
76	FILT_ERR_MISSING_FIELD,
77	FILT_ERR_INVALID_FILTER,
78	};
79
80	static char *err_text[] = {
81	"No error",
82	"Invalid operator",
83	"Unbalanced parens",
84	"Too many operands",
85	"Operand too long",
86	"Field not found",
87	"Illegal operation for field type",
88	"Illegal integer value",
89	"Couldn't find or set field in one of a subsystem's events",
90	"Too many terms in predicate expression",
91	"Missing field name and/or value",
92	"Meaningless filter expression",
93	};
94
95	struct opstack_op {
96	int op;
97	struct list_head list;
98	};
99
100	struct postfix_elt {
101	int op;
102	char *operand;
103	struct list_head list;
104	};
105
106	struct filter_parse_state {
107	struct filter_op *ops;
108	struct list_head opstack;
109	struct list_head postfix;
110	int lasterr;
111	int lasterr_pos;
112
113	struct {
114	char *string;
115	unsigned int cnt;
116	unsigned int tail;
117	} infix;
118
119	struct {
120	char string[MAX_FILTER_STR_VAL];
121	int pos;
122	unsigned int tail;
123	} operand;
124	};
125
126	#define DEFINE_COMPARISON_PRED(type) \
127	static int filter_pred_##type(struct filter_pred pred, void event, \
128	int val1, int val2) \
129	{ \
130	type addr = (type )(event + pred->offset); \
131	type val = (type)pred->val; \
132	int match = 0; \
133	\
134	switch (pred->op) { \
135	case OP_LT: \
136	match = (*addr < val); \
137	break; \
138	case OP_LE: \
139	match = (*addr <= val); \
140	break; \
141	case OP_GT: \
142	match = (*addr > val); \
143	break; \
144	case OP_GE: \
145	match = (*addr >= val); \
146	break; \
147	default: \
148	break; \
149	} \
150	\
151	return match; \
152	}
153
154	#define DEFINE_EQUALITY_PRED(size) \
155	static int filter_pred_##size(struct filter_pred pred, void event, \
156	int val1, int val2) \
157	{ \
158	u##size addr = (u##size )(event + pred->offset); \
159	u##size val = (u##size)pred->val; \
160	int match; \
161	\
162	match = (val == *addr) ^ pred->not; \
163	\
164	return match; \
165	}
166
167	DEFINE_COMPARISON_PRED(s64);
168	DEFINE_COMPARISON_PRED(u64);
169	DEFINE_COMPARISON_PRED(s32);
170	DEFINE_COMPARISON_PRED(u32);
171	DEFINE_COMPARISON_PRED(s16);
172	DEFINE_COMPARISON_PRED(u16);
173	DEFINE_COMPARISON_PRED(s8);
174	DEFINE_COMPARISON_PRED(u8);
175
176	DEFINE_EQUALITY_PRED(64);
177	DEFINE_EQUALITY_PRED(32);
178	DEFINE_EQUALITY_PRED(16);
179	DEFINE_EQUALITY_PRED(8);
180
181	static int filter_pred_and(struct filter_pred *pred __attribute((unused)),
182	void *event __attribute((unused)),
183	int val1, int val2)
184	{
185	return val1 && val2;
186	}
187
188	static int filter_pred_or(struct filter_pred *pred __attribute((unused)),
189	void *event __attribute((unused)),
190	int val1, int val2)
191	{
192	return val1 \|\| val2;
193	}
194
195	/* Filter predicate for fixed sized arrays of characters */
196	static int filter_pred_string(struct filter_pred pred, void event,
197	int val1, int val2)
198	{
199	char addr = (char )(event + pred->offset);
200	int cmp, match;
201
202	cmp = pred->regex.match(addr, &pred->regex, pred->regex.field_len);
203
204	match = cmp ^ pred->not;
205
206	return match;
207	}
208
209	/* Filter predicate for char * pointers */
210	static int filter_pred_pchar(struct filter_pred pred, void event,
211	int val1, int val2)
212	{
213	char addr = (char )(event + pred->offset);
214	int cmp, match;
215	int len = strlen(addr) + 1; / including tailing '\0' */
216
217	cmp = pred->regex.match(*addr, &pred->regex, len);
218
219	match = cmp ^ pred->not;
220
221	return match;
222	}
223
224	/*
225	* Filter predicate for dynamic sized arrays of characters.
226	* These are implemented through a list of strings at the end
227	* of the entry.
228	* Also each of these strings have a field in the entry which
229	* contains its offset from the beginning of the entry.
230	* We have then first to get this field, dereference it
231	* and add it to the address of the entry, and at last we have
232	* the address of the string.
233	*/
234	static int filter_pred_strloc(struct filter_pred pred, void event,
235	int val1, int val2)
236	{
237	u32 str_item = (u32 )(event + pred->offset);
238	int str_loc = str_item & 0xffff;
239	int str_len = str_item >> 16;
240	char addr = (char )(event + str_loc);
241	int cmp, match;
242
243	cmp = pred->regex.match(addr, &pred->regex, str_len);
244
245	match = cmp ^ pred->not;
246
247	return match;
248	}
249
250	static int filter_pred_none(struct filter_pred pred, void event,
251	int val1, int val2)
252	{
253	return 0;
254	}
255
256	/*
257	* regex_match_foo - Basic regex callbacks
258	*
259	* @str: the string to be searched
260	* @r: the regex structure containing the pattern string
261	* @len: the length of the string to be searched (including '\0')
262	*
263	* Note:
264	* - @str might not be NULL-terminated if it's of type DYN_STRING
265	* or STATIC_STRING
266	*/
267
268	static int regex_match_full(char str, struct regex r, int len)
269	{
270	if (strncmp(str, r->pattern, len) == 0)
271	return 1;
272	return 0;
273	}
274
275	static int regex_match_front(char str, struct regex r, int len)
276	{
277	if (strncmp(str, r->pattern, r->len) == 0)
278	return 1;
279	return 0;
280	}
281
282	static int regex_match_middle(char str, struct regex r, int len)
283	{
284	if (strnstr(str, r->pattern, len))
285	return 1;
286	return 0;
287	}
288
289	static int regex_match_end(char str, struct regex r, int len)
290	{
291	int strlen = len - 1;
292
293	if (strlen >= r->len &&
294	memcmp(str + strlen - r->len, r->pattern, r->len) == 0)
295	return 1;
296	return 0;
297	}
298
299	/**
300	* filter_parse_regex - parse a basic regex
301	* @buff: the raw regex
302	* @len: length of the regex
303	* @search: will point to the beginning of the string to compare
304	* @not: tell whether the match will have to be inverted
305	*
306	* This passes in a buffer containing a regex and this function will
307	* set search to point to the search part of the buffer and
308	* return the type of search it is (see enum above).
309	* This does modify buff.
310	*
311	* Returns enum type.
312	* search returns the pointer to use for comparison.
313	* not returns 1 if buff started with a '!'
314	* 0 otherwise.
315	*/
316	enum regex_type filter_parse_regex(char buff, int len, char search, int not)
317	{
318	int type = MATCH_FULL;
319	int i;
320
321	if (buff[0] == '!') {
322	*not = 1;
323	buff++;
324	len--;
325	} else
326	*not = 0;
327
328	*search = buff;
329
330	for (i = 0; i < len; i++) {
331	if (buff[i] == '*') {
332	if (!i) {
333	*search = buff + 1;
334	type = MATCH_END_ONLY;
335	} else {
336	if (type == MATCH_END_ONLY)
337	type = MATCH_MIDDLE_ONLY;
338	else
339	type = MATCH_FRONT_ONLY;
340	buff[i] = 0;
341	break;
342	}
343	}
344	}
345
346	return type;
347	}
348
349	static void filter_build_regex(struct filter_pred *pred)
350	{
351	struct regex *r = &pred->regex;
352	char *search;
353	enum regex_type type = MATCH_FULL;
354	int not = 0;
355
356	if (pred->op == OP_GLOB) {
357	type = filter_parse_regex(r->pattern, r->len, &search, &not);
358	r->len = strlen(search);
359	memmove(r->pattern, search, r->len+1);
360	}
361
362	switch (type) {
363	case MATCH_FULL:
364	r->match = regex_match_full;
365	break;
366	case MATCH_FRONT_ONLY:
367	r->match = regex_match_front;
368	break;
369	case MATCH_MIDDLE_ONLY:
370	r->match = regex_match_middle;
371	break;
372	case MATCH_END_ONLY:
373	r->match = regex_match_end;
374	break;
375	}
376
377	pred->not ^= not;
378	}
379
380	/* return 1 if event matches, 0 otherwise (discard) */
381	int filter_match_preds(struct event_filter filter, void rec)
382	{
383	int match, top = 0, val1 = 0, val2 = 0;
384	int stack[MAX_FILTER_PRED];
385	struct filter_pred *pred;
386	int i;
387
388	for (i = 0; i < filter->n_preds; i++) {
389	pred = filter->preds[i];
390	if (!pred->pop_n) {
391	match = pred->fn(pred, rec, val1, val2);
392	stack[top++] = match;
393	continue;
394	}
395	if (pred->pop_n > top) {
396	WARN_ON_ONCE(1);
397	return 0;
398	}
399	val1 = stack[--top];
400	val2 = stack[--top];
401	match = pred->fn(pred, rec, val1, val2);
402	stack[top++] = match;
403	}
404
405	return stack[--top];
406	}
407	EXPORT_SYMBOL_GPL(filter_match_preds);
408
409	static void parse_error(struct filter_parse_state *ps, int err, int pos)
410	{
411	ps->lasterr = err;
412	ps->lasterr_pos = pos;
413	}
414
415	static void remove_filter_string(struct event_filter *filter)
416	{
417	kfree(filter->filter_string);
418	filter->filter_string = NULL;
419	}
420
421	static int replace_filter_string(struct event_filter *filter,
422	char *filter_string)
423	{
424	kfree(filter->filter_string);
425	filter->filter_string = kstrdup(filter_string, GFP_KERNEL);
426	if (!filter->filter_string)
427	return -ENOMEM;
428
429	return 0;
430	}
431
432	static int append_filter_string(struct event_filter *filter,
433	char *string)
434	{
435	int newlen;
436	char *new_filter_string;
437
438	BUG_ON(!filter->filter_string);
439	newlen = strlen(filter->filter_string) + strlen(string) + 1;
440	new_filter_string = kmalloc(newlen, GFP_KERNEL);
441	if (!new_filter_string)
442	return -ENOMEM;
443
444	strcpy(new_filter_string, filter->filter_string);
445	strcat(new_filter_string, string);
446	kfree(filter->filter_string);
447	filter->filter_string = new_filter_string;
448
449	return 0;
450	}
451
452	static void append_filter_err(struct filter_parse_state *ps,
453	struct event_filter *filter)
454	{
455	int pos = ps->lasterr_pos;
456	char buf, pbuf;
457
458	buf = (char *)__get_free_page(GFP_TEMPORARY);
459	if (!buf)
460	return;
461
462	append_filter_string(filter, "\n");
463	memset(buf, ' ', PAGE_SIZE);
464	if (pos > PAGE_SIZE - 128)
465	pos = 0;
466	buf[pos] = '^';
467	pbuf = &buf[pos] + 1;
468
469	sprintf(pbuf, "\nparse_error: %s\n", err_text[ps->lasterr]);
470	append_filter_string(filter, buf);
471	free_page((unsigned long) buf);
472	}
473
474	void print_event_filter(struct ftrace_event_call call, struct trace_seq s)
475	{
476	struct event_filter *filter = call->filter;
477
478	mutex_lock(&event_mutex);
479	if (filter && filter->filter_string)
480	trace_seq_printf(s, "%s\n", filter->filter_string);
481	else
482	trace_seq_printf(s, "none\n");
483	mutex_unlock(&event_mutex);
484	}
485
486	void print_subsystem_event_filter(struct event_subsystem *system,
487	struct trace_seq *s)
488	{
489	struct event_filter *filter = system->filter;
490
491	mutex_lock(&event_mutex);
492	if (filter && filter->filter_string)
493	trace_seq_printf(s, "%s\n", filter->filter_string);
494	else
495	trace_seq_printf(s, "none\n");
496	mutex_unlock(&event_mutex);
497	}
498
499	static struct ftrace_event_field *
500	__find_event_field(struct list_head head, char name)
501	{
502	struct ftrace_event_field *field;
503
504	list_for_each_entry(field, head, link) {
505	if (!strcmp(field->name, name))
506	return field;
507	}
508
509	return NULL;
510	}
511
512	static struct ftrace_event_field *
513	find_event_field(struct ftrace_event_call call, char name)
514	{
515	struct ftrace_event_field *field;
516	struct list_head *head;
517
518	field = __find_event_field(&ftrace_common_fields, name);
519	if (field)
520	return field;
521
522	head = trace_get_fields(call);
523	return __find_event_field(head, name);
524	}
525
526	static void filter_free_pred(struct filter_pred *pred)
527	{
528	if (!pred)
529	return;
530
531	kfree(pred->field_name);
532	kfree(pred);
533	}
534
535	static void filter_clear_pred(struct filter_pred *pred)
536	{
537	kfree(pred->field_name);
538	pred->field_name = NULL;
539	pred->regex.len = 0;
540	}
541
542	static int filter_set_pred(struct filter_pred *dest,
543	struct filter_pred *src,
544	filter_pred_fn_t fn)
545	{
546	dest = src;
547	if (src->field_name) {
548	dest->field_name = kstrdup(src->field_name, GFP_KERNEL);
549	if (!dest->field_name)
550	return -ENOMEM;
551	}
552	dest->fn = fn;
553
554	return 0;
555	}
556
557	static void filter_disable_preds(struct ftrace_event_call *call)
558	{
559	struct event_filter *filter = call->filter;
560	int i;
561
562	call->flags &= ~TRACE_EVENT_FL_FILTERED;
563	filter->n_preds = 0;
564
565	for (i = 0; i < MAX_FILTER_PRED; i++)
566	filter->preds[i]->fn = filter_pred_none;
567	}
568
569	static void __free_preds(struct event_filter *filter)
570	{
571	int i;
572
573	if (!filter)
574	return;
575
576	for (i = 0; i < MAX_FILTER_PRED; i++) {
577	if (filter->preds[i])
578	filter_free_pred(filter->preds[i]);
579	}
580	kfree(filter->preds);
581	kfree(filter->filter_string);
582	kfree(filter);
583	}
584
585	void destroy_preds(struct ftrace_event_call *call)
586	{
587	__free_preds(call->filter);
588	call->filter = NULL;
589	call->flags &= ~TRACE_EVENT_FL_FILTERED;
590	}
591
592	static struct event_filter *__alloc_preds(void)
593	{
594	struct event_filter *filter;
595	struct filter_pred *pred;
596	int i;
597
598	filter = kzalloc(sizeof(*filter), GFP_KERNEL);
599	if (!filter)
600	return ERR_PTR(-ENOMEM);
601
602	filter->n_preds = 0;
603
604	filter->preds = kzalloc(MAX_FILTER_PRED * sizeof(pred), GFP_KERNEL);
605	if (!filter->preds)
606	goto oom;
607
608	for (i = 0; i < MAX_FILTER_PRED; i++) {
609	pred = kzalloc(sizeof(*pred), GFP_KERNEL);
610	if (!pred)
611	goto oom;
612	pred->fn = filter_pred_none;
613	filter->preds[i] = pred;
614	}
615
616	return filter;
617
618	oom:
619	__free_preds(filter);
620	return ERR_PTR(-ENOMEM);
621	}
622
623	static int init_preds(struct ftrace_event_call *call)
624	{
625	if (call->filter)
626	return 0;
627
628	call->flags &= ~TRACE_EVENT_FL_FILTERED;
629	call->filter = __alloc_preds();
630	if (IS_ERR(call->filter))
631	return PTR_ERR(call->filter);
632
633	return 0;
634	}
635
636	static int init_subsystem_preds(struct event_subsystem *system)
637	{
638	struct ftrace_event_call *call;
639	int err;
640
641	list_for_each_entry(call, &ftrace_events, list) {
642	if (strcmp(call->class->system, system->name) != 0)
643	continue;
644
645	err = init_preds(call);
646	if (err)
647	return err;
648	}
649
650	return 0;
651	}
652
653	static void filter_free_subsystem_preds(struct event_subsystem *system)
654	{
655	struct ftrace_event_call *call;
656
657	list_for_each_entry(call, &ftrace_events, list) {
658	if (strcmp(call->class->system, system->name) != 0)
659	continue;
660
661	filter_disable_preds(call);
662	remove_filter_string(call->filter);
663	}
664	}
665
666	static int filter_add_pred_fn(struct filter_parse_state *ps,
667	struct ftrace_event_call *call,
668	struct event_filter *filter,
669	struct filter_pred *pred,
670	filter_pred_fn_t fn)
671	{
672	int idx, err;
673
674	if (filter->n_preds == MAX_FILTER_PRED) {
675	parse_error(ps, FILT_ERR_TOO_MANY_PREDS, 0);
676	return -ENOSPC;
677	}
678
679	idx = filter->n_preds;
680	filter_clear_pred(filter->preds[idx]);
681	err = filter_set_pred(filter->preds[idx], pred, fn);
682	if (err)
683	return err;
684
685	filter->n_preds++;
686
687	return 0;
688	}
689
690	int filter_assign_type(const char *type)
691	{
692	if (strstr(type, "__data_loc") && strstr(type, "char"))
693	return FILTER_DYN_STRING;
694
695	if (strchr(type, '[') && strstr(type, "char"))
696	return FILTER_STATIC_STRING;
697
698	return FILTER_OTHER;
699	}
700
701	static bool is_string_field(struct ftrace_event_field *field)
702	{
703	return field->filter_type == FILTER_DYN_STRING \|\|
704	field->filter_type == FILTER_STATIC_STRING \|\|
705	field->filter_type == FILTER_PTR_STRING;
706	}
707
708	static int is_legal_op(struct ftrace_event_field *field, int op)
709	{
710	if (is_string_field(field) &&
711	(op != OP_EQ && op != OP_NE && op != OP_GLOB))
712	return 0;
713	if (!is_string_field(field) && op == OP_GLOB)
714	return 0;
715
716	return 1;
717	}
718
719	static filter_pred_fn_t select_comparison_fn(int op, int field_size,
720	int field_is_signed)
721	{
722	filter_pred_fn_t fn = NULL;
723
724	switch (field_size) {
725	case 8:
726	if (op == OP_EQ \|\| op == OP_NE)
727	fn = filter_pred_64;
728	else if (field_is_signed)
729	fn = filter_pred_s64;
730	else
731	fn = filter_pred_u64;
732	break;
733	case 4:
734	if (op == OP_EQ \|\| op == OP_NE)
735	fn = filter_pred_32;
736	else if (field_is_signed)
737	fn = filter_pred_s32;
738	else
739	fn = filter_pred_u32;
740	break;
741	case 2:
742	if (op == OP_EQ \|\| op == OP_NE)
743	fn = filter_pred_16;
744	else if (field_is_signed)
745	fn = filter_pred_s16;
746	else
747	fn = filter_pred_u16;
748	break;
749	case 1:
750	if (op == OP_EQ \|\| op == OP_NE)
751	fn = filter_pred_8;
752	else if (field_is_signed)
753	fn = filter_pred_s8;
754	else
755	fn = filter_pred_u8;
756	break;
757	}
758
759	return fn;
760	}
761
762	static int filter_add_pred(struct filter_parse_state *ps,
763	struct ftrace_event_call *call,
764	struct event_filter *filter,
765	struct filter_pred *pred,
766	bool dry_run)
767	{
768	struct ftrace_event_field *field;
769	filter_pred_fn_t fn;
770	unsigned long long val;
771	int ret;
772
773	pred->fn = filter_pred_none;
774
775	if (pred->op == OP_AND) {
776	pred->pop_n = 2;
777	fn = filter_pred_and;
778	goto add_pred_fn;
779	} else if (pred->op == OP_OR) {
780	pred->pop_n = 2;
781	fn = filter_pred_or;
782	goto add_pred_fn;
783	}
784
785	field = find_event_field(call, pred->field_name);
786	if (!field) {
787	parse_error(ps, FILT_ERR_FIELD_NOT_FOUND, 0);
788	return -EINVAL;
789	}
790
791	pred->offset = field->offset;
792
793	if (!is_legal_op(field, pred->op)) {
794	parse_error(ps, FILT_ERR_ILLEGAL_FIELD_OP, 0);
795	return -EINVAL;
796	}
797
798	if (is_string_field(field)) {
799	filter_build_regex(pred);
800
801	if (field->filter_type == FILTER_STATIC_STRING) {
802	fn = filter_pred_string;
803	pred->regex.field_len = field->size;
804	} else if (field->filter_type == FILTER_DYN_STRING)
805	fn = filter_pred_strloc;
806	else
807	fn = filter_pred_pchar;
808	} else {
809	if (field->is_signed)
810	ret = strict_strtoll(pred->regex.pattern, 0, &val);
811	else
812	ret = strict_strtoull(pred->regex.pattern, 0, &val);
813	if (ret) {
814	parse_error(ps, FILT_ERR_ILLEGAL_INTVAL, 0);
815	return -EINVAL;
816	}
817	pred->val = val;
818
819	fn = select_comparison_fn(pred->op, field->size,
820	field->is_signed);
821	if (!fn) {
822	parse_error(ps, FILT_ERR_INVALID_OP, 0);
823	return -EINVAL;
824	}
825	}
826
827	if (pred->op == OP_NE)
828	pred->not = 1;
829
830	add_pred_fn:
831	if (!dry_run)
832	return filter_add_pred_fn(ps, call, filter, pred, fn);
833	return 0;
834	}
835
836	static void parse_init(struct filter_parse_state *ps,
837	struct filter_op *ops,
838	char *infix_string)
839	{
840	memset(ps, '\0', sizeof(*ps));
841
842	ps->infix.string = infix_string;
843	ps->infix.cnt = strlen(infix_string);
844	ps->ops = ops;
845
846	INIT_LIST_HEAD(&ps->opstack);
847	INIT_LIST_HEAD(&ps->postfix);
848	}
849
850	static char infix_next(struct filter_parse_state *ps)
851	{
852	ps->infix.cnt--;
853
854	return ps->infix.string[ps->infix.tail++];
855	}
856
857	static char infix_peek(struct filter_parse_state *ps)
858	{
859	if (ps->infix.tail == strlen(ps->infix.string))
860	return 0;
861
862	return ps->infix.string[ps->infix.tail];
863	}
864
865	static void infix_advance(struct filter_parse_state *ps)
866	{
867	ps->infix.cnt--;
868	ps->infix.tail++;
869	}
870
871	static inline int is_precedence_lower(struct filter_parse_state *ps,
872	int a, int b)
873	{
874	return ps->ops[a].precedence < ps->ops[b].precedence;
875	}
876
877	static inline int is_op_char(struct filter_parse_state *ps, char c)
878	{
879	int i;
880
881	for (i = 0; strcmp(ps->ops[i].string, "OP_NONE"); i++) {
882	if (ps->ops[i].string[0] == c)
883	return 1;
884	}
885
886	return 0;
887	}
888
889	static int infix_get_op(struct filter_parse_state *ps, char firstc)
890	{
891	char nextc = infix_peek(ps);
892	char opstr[3];
893	int i;
894
895	opstr[0] = firstc;
896	opstr[1] = nextc;
897	opstr[2] = '\0';
898
899	for (i = 0; strcmp(ps->ops[i].string, "OP_NONE"); i++) {
900	if (!strcmp(opstr, ps->ops[i].string)) {
901	infix_advance(ps);
902	return ps->ops[i].id;
903	}
904	}
905
906	opstr[1] = '\0';
907
908	for (i = 0; strcmp(ps->ops[i].string, "OP_NONE"); i++) {
909	if (!strcmp(opstr, ps->ops[i].string))
910	return ps->ops[i].id;
911	}
912
913	return OP_NONE;
914	}
915
916	static inline void clear_operand_string(struct filter_parse_state *ps)
917	{
918	memset(ps->operand.string, '\0', MAX_FILTER_STR_VAL);
919	ps->operand.tail = 0;
920	}
921
922	static inline int append_operand_char(struct filter_parse_state *ps, char c)
923	{
924	if (ps->operand.tail == MAX_FILTER_STR_VAL - 1)
925	return -EINVAL;
926
927	ps->operand.string[ps->operand.tail++] = c;
928
929	return 0;
930	}
931
932	static int filter_opstack_push(struct filter_parse_state *ps, int op)
933	{
934	struct opstack_op *opstack_op;
935
936	opstack_op = kmalloc(sizeof(*opstack_op), GFP_KERNEL);
937	if (!opstack_op)
938	return -ENOMEM;
939
940	opstack_op->op = op;
941	list_add(&opstack_op->list, &ps->opstack);
942
943	return 0;
944	}
945
946	static int filter_opstack_empty(struct filter_parse_state *ps)
947	{
948	return list_empty(&ps->opstack);
949	}
950
951	static int filter_opstack_top(struct filter_parse_state *ps)
952	{
953	struct opstack_op *opstack_op;
954
955	if (filter_opstack_empty(ps))
956	return OP_NONE;
957
958	opstack_op = list_first_entry(&ps->opstack, struct opstack_op, list);
959
960	return opstack_op->op;
961	}
962
963	static int filter_opstack_pop(struct filter_parse_state *ps)
964	{
965	struct opstack_op *opstack_op;
966	int op;
967
968	if (filter_opstack_empty(ps))
969	return OP_NONE;
970
971	opstack_op = list_first_entry(&ps->opstack, struct opstack_op, list);
972	op = opstack_op->op;
973	list_del(&opstack_op->list);
974
975	kfree(opstack_op);
976
977	return op;
978	}
979
980	static void filter_opstack_clear(struct filter_parse_state *ps)
981	{
982	while (!filter_opstack_empty(ps))
983	filter_opstack_pop(ps);
984	}
985
986	static char curr_operand(struct filter_parse_state ps)
987	{
988	return ps->operand.string;
989	}
990
991	static int postfix_append_operand(struct filter_parse_state ps, char operand)
992	{
993	struct postfix_elt *elt;
994
995	elt = kmalloc(sizeof(*elt), GFP_KERNEL);
996	if (!elt)
997	return -ENOMEM;
998
999	elt->op = OP_NONE;
1000	elt->operand = kstrdup(operand, GFP_KERNEL);
1001	if (!elt->operand) {
1002	kfree(elt);
1003	return -ENOMEM;
1004	}
1005
1006	list_add_tail(&elt->list, &ps->postfix);
1007
1008	return 0;
1009	}
1010
1011	static int postfix_append_op(struct filter_parse_state *ps, int op)
1012	{
1013	struct postfix_elt *elt;
1014
1015	elt = kmalloc(sizeof(*elt), GFP_KERNEL);
1016	if (!elt)
1017	return -ENOMEM;
1018
1019	elt->op = op;
1020	elt->operand = NULL;
1021
1022	list_add_tail(&elt->list, &ps->postfix);
1023
1024	return 0;
1025	}
1026
1027	static void postfix_clear(struct filter_parse_state *ps)
1028	{
1029	struct postfix_elt *elt;
1030
1031	while (!list_empty(&ps->postfix)) {
1032	elt = list_first_entry(&ps->postfix, struct postfix_elt, list);
1033	list_del(&elt->list);
1034	kfree(elt->operand);
1035	kfree(elt);
1036	}
1037	}
1038
1039	static int filter_parse(struct filter_parse_state *ps)
1040	{
1041	int in_string = 0;
1042	int op, top_op;
1043	char ch;
1044
1045	while ((ch = infix_next(ps))) {
1046	if (ch == '"') {
1047	in_string ^= 1;
1048	continue;
1049	}
1050
1051	if (in_string)
1052	goto parse_operand;
1053
1054	if (isspace(ch))
1055	continue;
1056
1057	if (is_op_char(ps, ch)) {
1058	op = infix_get_op(ps, ch);
1059	if (op == OP_NONE) {
1060	parse_error(ps, FILT_ERR_INVALID_OP, 0);
1061	return -EINVAL;
1062	}
1063
1064	if (strlen(curr_operand(ps))) {
1065	postfix_append_operand(ps, curr_operand(ps));
1066	clear_operand_string(ps);
1067	}
1068
1069	while (!filter_opstack_empty(ps)) {
1070	top_op = filter_opstack_top(ps);
1071	if (!is_precedence_lower(ps, top_op, op)) {
1072	top_op = filter_opstack_pop(ps);
1073	postfix_append_op(ps, top_op);
1074	continue;
1075	}
1076	break;
1077	}
1078
1079	filter_opstack_push(ps, op);
1080	continue;
1081	}
1082
1083	if (ch == '(') {
1084	filter_opstack_push(ps, OP_OPEN_PAREN);
1085	continue;
1086	}
1087
1088	if (ch == ')') {
1089	if (strlen(curr_operand(ps))) {
1090	postfix_append_operand(ps, curr_operand(ps));
1091	clear_operand_string(ps);
1092	}
1093
1094	top_op = filter_opstack_pop(ps);
1095	while (top_op != OP_NONE) {
1096	if (top_op == OP_OPEN_PAREN)
1097	break;
1098	postfix_append_op(ps, top_op);
1099	top_op = filter_opstack_pop(ps);
1100	}
1101	if (top_op == OP_NONE) {
1102	parse_error(ps, FILT_ERR_UNBALANCED_PAREN, 0);
1103	return -EINVAL;
1104	}
1105	continue;
1106	}
1107	parse_operand:
1108	if (append_operand_char(ps, ch)) {
1109	parse_error(ps, FILT_ERR_OPERAND_TOO_LONG, 0);
1110	return -EINVAL;
1111	}
1112	}
1113
1114	if (strlen(curr_operand(ps)))
1115	postfix_append_operand(ps, curr_operand(ps));
1116
1117	while (!filter_opstack_empty(ps)) {
1118	top_op = filter_opstack_pop(ps);
1119	if (top_op == OP_NONE)
1120	break;
1121	if (top_op == OP_OPEN_PAREN) {
1122	parse_error(ps, FILT_ERR_UNBALANCED_PAREN, 0);
1123	return -EINVAL;
1124	}
1125	postfix_append_op(ps, top_op);
1126	}
1127
1128	return 0;
1129	}
1130
1131	static struct filter_pred create_pred(int op, char operand1, char *operand2)
1132	{
1133	struct filter_pred *pred;
1134
1135	pred = kzalloc(sizeof(*pred), GFP_KERNEL);
1136	if (!pred)
1137	return NULL;
1138
1139	pred->field_name = kstrdup(operand1, GFP_KERNEL);
1140	if (!pred->field_name) {
1141	kfree(pred);
1142	return NULL;
1143	}
1144
1145	strcpy(pred->regex.pattern, operand2);
1146	pred->regex.len = strlen(pred->regex.pattern);
1147
1148	pred->op = op;
1149
1150	return pred;
1151	}
1152
1153	static struct filter_pred *create_logical_pred(int op)
1154	{
1155	struct filter_pred *pred;
1156
1157	pred = kzalloc(sizeof(*pred), GFP_KERNEL);
1158	if (!pred)
1159	return NULL;
1160
1161	pred->op = op;
1162
1163	return pred;
1164	}
1165
1166	static int check_preds(struct filter_parse_state *ps)
1167	{
1168	int n_normal_preds = 0, n_logical_preds = 0;
1169	struct postfix_elt *elt;
1170
1171	list_for_each_entry(elt, &ps->postfix, list) {
1172	if (elt->op == OP_NONE)
1173	continue;
1174
1175	if (elt->op == OP_AND \|\| elt->op == OP_OR) {
1176	n_logical_preds++;
1177	continue;
1178	}
1179	n_normal_preds++;
1180	}
1181
1182	if (!n_normal_preds \|\| n_logical_preds >= n_normal_preds) {
1183	parse_error(ps, FILT_ERR_INVALID_FILTER, 0);
1184	return -EINVAL;
1185	}
1186
1187	return 0;
1188	}
1189
1190	static int replace_preds(struct ftrace_event_call *call,
1191	struct event_filter *filter,
1192	struct filter_parse_state *ps,
1193	char *filter_string,
1194	bool dry_run)
1195	{
1196	char operand1 = NULL, operand2 = NULL;
1197	struct filter_pred *pred;
1198	struct postfix_elt *elt;
1199	int err;
1200	int n_preds = 0;
1201
1202	err = check_preds(ps);
1203	if (err)
1204	return err;
1205
1206	list_for_each_entry(elt, &ps->postfix, list) {
1207	if (elt->op == OP_NONE) {
1208	if (!operand1)
1209	operand1 = elt->operand;
1210	else if (!operand2)
1211	operand2 = elt->operand;
1212	else {
1213	parse_error(ps, FILT_ERR_TOO_MANY_OPERANDS, 0);
1214	return -EINVAL;
1215	}
1216	continue;
1217	}
1218
1219	if (n_preds++ == MAX_FILTER_PRED) {
1220	parse_error(ps, FILT_ERR_TOO_MANY_PREDS, 0);
1221	return -ENOSPC;
1222	}
1223
1224	if (elt->op == OP_AND \|\| elt->op == OP_OR) {
1225	pred = create_logical_pred(elt->op);
1226	goto add_pred;
1227	}
1228
1229	if (!operand1 \|\| !operand2) {
1230	parse_error(ps, FILT_ERR_MISSING_FIELD, 0);
1231	return -EINVAL;
1232	}
1233
1234	pred = create_pred(elt->op, operand1, operand2);
1235	add_pred:
1236	if (!pred)
1237	return -ENOMEM;
1238	err = filter_add_pred(ps, call, filter, pred, dry_run);
1239	filter_free_pred(pred);
1240	if (err)
1241	return err;
1242
1243	operand1 = operand2 = NULL;
1244	}
1245
1246	return 0;
1247	}
1248
1249	static int replace_system_preds(struct event_subsystem *system,
1250	struct filter_parse_state *ps,
1251	char *filter_string)
1252	{
1253	struct ftrace_event_call *call;
1254	bool fail = true;
1255	int err;
1256
1257	list_for_each_entry(call, &ftrace_events, list) {
1258	struct event_filter *filter = call->filter;
1259
1260	if (strcmp(call->class->system, system->name) != 0)
1261	continue;
1262
1263	/* try to see if the filter can be applied */
1264	err = replace_preds(call, filter, ps, filter_string, true);
1265	if (err)
1266	continue;
1267
1268	/* really apply the filter */
1269	filter_disable_preds(call);
1270	err = replace_preds(call, filter, ps, filter_string, false);
1271	if (err)
1272	filter_disable_preds(call);
1273	else {
1274	call->flags \|= TRACE_EVENT_FL_FILTERED;
1275	replace_filter_string(filter, filter_string);
1276	}
1277	fail = false;
1278	}
1279
1280	if (fail) {
1281	parse_error(ps, FILT_ERR_BAD_SUBSYS_FILTER, 0);
1282	return -EINVAL;
1283	}
1284	return 0;
1285	}
1286
1287	int apply_event_filter(struct ftrace_event_call call, char filter_string)
1288	{
1289	int err;
1290	struct filter_parse_state *ps;
1291
1292	mutex_lock(&event_mutex);
1293
1294	err = init_preds(call);
1295	if (err)
1296	goto out_unlock;
1297
1298	if (!strcmp(strstrip(filter_string), "0")) {
1299	filter_disable_preds(call);
1300	remove_filter_string(call->filter);
1301	goto out_unlock;
1302	}
1303
1304	err = -ENOMEM;
1305	ps = kzalloc(sizeof(*ps), GFP_KERNEL);
1306	if (!ps)
1307	goto out_unlock;
1308
1309	filter_disable_preds(call);
1310	replace_filter_string(call->filter, filter_string);
1311
1312	parse_init(ps, filter_ops, filter_string);
1313	err = filter_parse(ps);
1314	if (err) {
1315	append_filter_err(ps, call->filter);
1316	goto out;
1317	}
1318
1319	err = replace_preds(call, call->filter, ps, filter_string, false);
1320	if (err)
1321	append_filter_err(ps, call->filter);
1322	else
1323	call->flags \|= TRACE_EVENT_FL_FILTERED;
1324	out:
1325	filter_opstack_clear(ps);
1326	postfix_clear(ps);
1327	kfree(ps);
1328	out_unlock:
1329	mutex_unlock(&event_mutex);
1330
1331	return err;
1332	}
1333
1334	int apply_subsystem_event_filter(struct event_subsystem *system,
1335	char *filter_string)
1336	{
1337	int err;
1338	struct filter_parse_state *ps;
1339
1340	mutex_lock(&event_mutex);
1341
1342	err = init_subsystem_preds(system);
1343	if (err)
1344	goto out_unlock;
1345
1346	if (!strcmp(strstrip(filter_string), "0")) {
1347	filter_free_subsystem_preds(system);
1348	remove_filter_string(system->filter);
1349	goto out_unlock;
1350	}
1351
1352	err = -ENOMEM;
1353	ps = kzalloc(sizeof(*ps), GFP_KERNEL);
1354	if (!ps)
1355	goto out_unlock;
1356
1357	replace_filter_string(system->filter, filter_string);
1358
1359	parse_init(ps, filter_ops, filter_string);
1360	err = filter_parse(ps);
1361	if (err) {
1362	append_filter_err(ps, system->filter);
1363	goto out;
1364	}
1365
1366	err = replace_system_preds(system, ps, filter_string);
1367	if (err)
1368	append_filter_err(ps, system->filter);
1369
1370	out:
1371	filter_opstack_clear(ps);
1372	postfix_clear(ps);
1373	kfree(ps);
1374	out_unlock:
1375	mutex_unlock(&event_mutex);
1376
1377	return err;
1378	}
1379
1380	#ifdef CONFIG_PERF_EVENTS
1381
1382	void ftrace_profile_free_filter(struct perf_event *event)
1383	{
1384	struct event_filter *filter = event->filter;
1385
1386	event->filter = NULL;
1387	__free_preds(filter);
1388	}
1389
1390	int ftrace_profile_set_filter(struct perf_event *event, int event_id,
1391	char *filter_str)
1392	{
1393	int err;
1394	struct event_filter *filter;
1395	struct filter_parse_state *ps;
1396	struct ftrace_event_call *call = NULL;
1397
1398	mutex_lock(&event_mutex);
1399
1400	list_for_each_entry(call, &ftrace_events, list) {
1401	if (call->event.type == event_id)
1402	break;
1403	}
1404
1405	err = -EINVAL;
1406	if (&call->list == &ftrace_events)
1407	goto out_unlock;
1408
1409	err = -EEXIST;
1410	if (event->filter)
1411	goto out_unlock;
1412
1413	filter = __alloc_preds();
1414	if (IS_ERR(filter)) {
1415	err = PTR_ERR(filter);
1416	goto out_unlock;
1417	}
1418
1419	err = -ENOMEM;
1420	ps = kzalloc(sizeof(*ps), GFP_KERNEL);
1421	if (!ps)
1422	goto free_preds;
1423
1424	parse_init(ps, filter_ops, filter_str);
1425	err = filter_parse(ps);
1426	if (err)
1427	goto free_ps;
1428
1429	err = replace_preds(call, filter, ps, filter_str, false);
1430	if (!err)
1431	event->filter = filter;
1432
1433	free_ps:
1434	filter_opstack_clear(ps);
1435	postfix_clear(ps);
1436	kfree(ps);
1437
1438	free_preds:
1439	if (err)
1440	__free_preds(filter);
1441
1442	out_unlock:
1443	mutex_unlock(&event_mutex);
1444
1445	return err;
1446	}
1447
1448	#endif /* CONFIG_PERF_EVENTS */
1449
1450

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/kernel/trace/trace_events_filter.c

interactive