kernel/trace/trace_events_filter.c

19 	"### global filter ###\n"					\
115 	C(INVALID_FILTER,	"Meaningless filter expression"),	\
121 	C(NO_FILTER,		"No filter found")
145  * struct prog_entry - a singe entry in the filter program
1171 int filter_match_preds(struct event_filter *filter, void *rec)
1176 	/* no filter is considered a match */
1177 	if (!filter)
1181 	prog = rcu_dereference_raw(filter->prog);
1195 static void remove_filter_string(struct event_filter *filter)
1197 	if (!filter)
1200 	kfree(filter->filter_string);
1201 	filter->filter_string = NULL;
1206 			      struct event_filter *filter)
1213 	if (WARN_ON(!filter->filter_string))
1221 	len = strlen(filter->filter_string);
1229 	trace_seq_puts(s, filter->filter_string);
1233 		tracing_log_err(tr, "event filter parse error",
1234 				filter->filter_string, err_text,
1238 		tracing_log_err(tr, "event filter parse error",
1239 				filter->filter_string, err_text,
1245 		kfree(filter->filter_string);
1246 		filter->filter_string = buf;
1253 	return file->filter;
1259 	struct event_filter *filter = event_filter(file);
1261 	if (filter && filter->filter_string)
1262 		trace_seq_printf(s, "%s\n", filter->filter_string);
1270 	struct event_filter *filter;
1273 	filter = system->filter;
1274 	if (filter && filter->filter_string)
1275 		trace_seq_printf(s, "%s\n", filter->filter_string);
1281 static void free_prog(struct event_filter *filter)
1286 	prog = rcu_access_pointer(filter->prog);
1305 static void __free_filter(struct event_filter *filter)
1307 	if (!filter)
1310 	free_prog(filter);
1311 	kfree(filter->filter_string);
1312 	kfree(filter);
1315 void free_event_filter(struct event_filter *filter)
1317 	__free_filter(filter);
1323 	remove_filter_string(file->filter);
1340 	__free_filter(file->filter);
1341 	file->filter = NULL;
1969  * Read the filter string once to calculate the number of predicates
2077 			 struct event_filter *filter,
2109 	rcu_assign_pointer(filter->prog, prog);
2124 				    struct event_filter *filter)
2126 	rcu_assign_pointer(file->filter, filter);
2131 	RCU_INIT_POINTER(file->filter, NULL);
2136 	struct event_filter	*filter;
2146 	struct event_filter *filter = NULL;
2157 		filter = kzalloc(sizeof(*filter), GFP_KERNEL);
2158 		if (!filter)
2161 		filter->filter_string = kstrdup(filter_string, GFP_KERNEL);
2162 		if (!filter->filter_string)
2165 		err = process_preds(file->event_call, filter_string, filter, pe);
2169 			append_filter_err(tr, pe, filter);
2181 		 * replace the filter for the call.
2183 		filter_item->filter = event_filter(file);
2184 		event_set_filter(file, filter);
2185 		filter = NULL;
2200 		__free_filter(filter_item->filter);
2214 	__free_filter(filter);
2219 		__free_filter(filter_item->filter);
2230 	struct event_filter *filter;
2237 	filter = kzalloc(sizeof(*filter), GFP_KERNEL);
2238 	if (filter && set_str) {
2239 		filter->filter_string = kstrdup(filter_string, GFP_KERNEL);
2240 		if (!filter->filter_string)
2246 	if (!filter || !pe || err) {
2248 		__free_filter(filter);
2252 	/* we're committed to creating a new filter */
2253 	*filterp = filter;
2265  * create_filter - create a filter for a trace_event_call
2267  * @call: trace_event_call to create a filter for
2268  * @filter_string: filter string
2269  * @set_str: remember @filter_str and enable detailed error in filter
2270  * @filterp: out param for created filter (always updated on return)
2273  * Creates a filter for @call with @filter_str.  If @set_str is %true,
2274  * @filter_str is copied and recorded in the new filter.
2276  * On success, returns 0 and *@filterp points to the new filter.  On
2278  * filter.  In the latter case, the returned filter contains error
2315  * create_system_filter - create a filter for an event subsystem
2317  * @filter_str: filter string
2318  * @filterp: out param for created filter (always updated on return)
2320  * Identical to create_filter() except that it creates a subsystem filter
2349 	struct event_filter *filter = NULL;
2357 		filter = event_filter(file);
2359 		if (!filter)
2364 		/* Make sure the filter is not being used */
2366 		__free_filter(filter);
2371 	err = create_filter(file->tr, call, filter_string, true, &filter);
2374 	 * Always swap the call filter with the new filter
2376 	 * in the filter, we disable the filter and show the error
2379 	if (filter) {
2388 		event_set_filter(file, filter);
2391 			/* Make sure the call is done with the filter */
2405 	struct event_filter *filter = NULL;
2418 		remove_filter_string(system->filter);
2419 		filter = system->filter;
2420 		system->filter = NULL;
2424 		__free_filter(filter);
2428 	err = create_system_filter(dir, filter_string, &filter);
2429 	if (filter) {
2431 		 * No event actually uses the system filter
2434 		__free_filter(system->filter);
2435 		system->filter = filter;
2447 	struct event_filter *filter = event->filter;
2449 	event->filter = NULL;
2450 	__free_filter(filter);
2480 static int ftrace_function_set_regexp(struct ftrace_ops *ops, int filter,
2485 	if (filter)
2493 static int __ftrace_function_set_filter(int filter, char *buf, int len,
2500 	reset = filter ? &data->first_filter : &data->first_notrace;
2504 	 * either by space or comma. We first cut the filter and apply
2512 		ret = ftrace_function_set_regexp(data->ops, filter, *reset,
2578 				      struct event_filter *filter)
2580 	struct prog_entry *prog = rcu_dereference_protected(filter->prog,
2602 				      struct event_filter *filter)
2612 	struct event_filter *filter = NULL;
2624 	if (event->filter)
2627 	err = create_filter(NULL, call, filter_str, false, &filter);
2632 		err = ftrace_function_set_filter(event, filter);
2634 		event->filter = filter;
2638 		__free_filter(filter);
2658 	.filter = FILTER, \
2668 	char *filter;
2741 static void update_pred_fn(struct event_filter *filter, char *fields)
2743 	struct prog_entry *prog = rcu_dereference_protected(filter->prog,
2769 	printk(KERN_INFO "Testing ftrace filter: ");
2772 		struct event_filter *filter = NULL;
2777 				    d->filter, false, &filter);
2780 			       "Failed to get filter for '%s', err %d\n",
2781 			       d->filter, err);
2782 			__free_filter(filter);
2786 		/* Needed to dereference filter->prog */
2794 			update_pred_fn(filter, d->not_visited);
2797 		err = filter_match_preds(filter, &d->rec);
2802 		__free_filter(filter);
2806 			       "Failed, unwanted pred visited for filter %s\n",
2807 			       d->filter);
2813 			       "Failed to match filter '%s', expected %d\n",
2814 			       d->filter, d->match);