perf probe: Add variable filter support

--funcs::

	Show available functions in given module or kernel.

--filter=FILTER::

	(Only for --vars) Set filter for variables. FILTER is a combination of

	glob pattern, see FILTER PATTERN for details.

	Default FILTER is "!__k???tab_* & !__crc_*".

	If several filters are specified, only the last filter is valid.

-f::

--force::

	Forcibly add events with existing name.

This provides some sort of flexibility and robustness to probe point definitions against minor code changes. For example, actual 10th line of schedule() can be moved easily by modifying schedule(), but the same line matching 'rq=cpu_rq*' may still exist in the function.)

FILTER PATTERN

--------------

 The filter pattern is a glob matching pattern(s) to filter variables.

 In addition, you can use "!" for specifying filter-out rule. You also can give several rules combined with "&" or "|", and fold those rules as one rule by using "(" ")".

e.g.

 With --filter "foo* | bar*", perf probe -V shows variables which start with "foo" or "bar".

 With --filter "!foo* & *bar", perf probe -V shows variables which don't start with "foo" and end with "bar", like "fizzbar". But "foobar" is filtered out.

EXAMPLES

--------

#include "builtin.h"

#include "util/util.h"

#include "util/strlist.h"

#include "util/strfilter.h"

#include "util/symbol.h"

#include "util/debug.h"

#include "util/debugfs.h"

#include "util/probe-finder.h"

#include "util/probe-event.h"

#define DEFAULT_VAR_FILTER "!__k???tab_* & !__crc_*"

#define MAX_PATH_LEN 256

/* Session management structure */

	struct line_range line_range;

	const char *target_module;

	int max_probe_points;

	struct strfilter *filter;

} params;

/* Parse an event definition. Note that any error must die. */

	return ret;

}

static int opt_set_filter(const struct option *opt __used,

			  const char *str, int unset __used)

{

	const char *err;

	if (str) {

		pr_debug2("Set filter: %s\n", str);

		if (params.filter)

			strfilter__delete(params.filter);

		params.filter = strfilter__new(str, &err);

		if (!params.filter) {

			pr_err("Filter parse error at %ld.\n", err - str + 1);

			pr_err("Source: \"%s\"\n", str);

			pr_err("         %*c\n", (int)(err - str + 1), '^');

			return -EINVAL;

		}

	}

	return 0;

}

#endif

static const char * const probe_usage[] = {

		     "Show accessible variables on PROBEDEF", opt_show_vars),

	OPT_BOOLEAN('\0', "externs", &params.show_ext_vars,

		    "Show external variables too (with --vars only)"),

	OPT_CALLBACK('\0', "filter", NULL,

		     "[!]FILTER", "Set a variable filter (with --vars only)\n"

		     "\t\t\t(default: \"" DEFAULT_VAR_FILTER "\")",

		     opt_set_filter),

	OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,

		   "file", "vmlinux pathname"),

	OPT_STRING('s', "source", &symbol_conf.source_prefix,

			       " --add/--del.\n");

			usage_with_options(probe_usage, options);

		}

		if (!params.filter)

			params.filter = strfilter__new(DEFAULT_VAR_FILTER,

						       NULL);

		ret = show_available_vars(params.events, params.nevents,

					  params.max_probe_points,

					  params.target_module,

					  params.filter,

					  params.show_ext_vars);

		strfilter__delete(params.filter);

		if (ret < 0)

			pr_err("  Error: Failed to show vars. (%d)\n", ret);

		return ret;

}

static int show_available_vars_at(int fd, struct perf_probe_event *pev,

				  int max_vls, bool externs)

				  int max_vls, struct strfilter *_filter,

				  bool externs)

{

	char *buf;

	int ret, i;

	int ret, i, nvars;

	struct str_node *node;

	struct variable_list *vls = NULL, *vl;

	const char *var;

	buf = synthesize_perf_probe_point(&pev->point);

	if (!buf)

	pr_debug("Searching variables at %s\n", buf);

	ret = find_available_vars_at(fd, pev, &vls, max_vls, externs);

	if (ret > 0) {

		/* Some variables were found */

	if (ret <= 0) {

		pr_err("Failed to find variables at %s (%d)\n", buf, ret);

		goto end;

	}

	/* Some variables are found */

	fprintf(stdout, "Available variables at %s\n", buf);

	for (i = 0; i < ret; i++) {

		vl = &vls[i];

		fprintf(stdout, "\t@<%s+%lu>\n", vl->point.symbol,

			vl->point.offset);

		free(vl->point.symbol);

		nvars = 0;

		if (vl->vars) {

				strlist__for_each(node, vl->vars)

			strlist__for_each(node, vl->vars) {

				var = strchr(node->s, '\t') + 1;

				if (strfilter__compare(_filter, var)) {

					fprintf(stdout, "\t\t%s\n", node->s);

					nvars++;

				}

			}

			strlist__delete(vl->vars);

			} else

				fprintf(stdout, "(No variables)\n");

		}

		if (nvars == 0)

			fprintf(stdout, "\t\t(No matched variables)\n");

	}

	free(vls);

	} else

		pr_err("Failed to find variables at %s (%d)\n", buf, ret);

end:

	free(buf);

	return ret;

}

/* Show available variables on given probe point */

int show_available_vars(struct perf_probe_event *pevs, int npevs,

			int max_vls, const char *module, bool externs)

			int max_vls, const char *module,

			struct strfilter *_filter, bool externs)

{

	int i, fd, ret = 0;

	setup_pager();

	for (i = 0; i < npevs && ret >= 0; i++)

		ret = show_available_vars_at(fd, &pevs[i], max_vls, externs);

		ret = show_available_vars_at(fd, &pevs[i], max_vls, _filter,

					     externs);

	close(fd);

	return ret;

int show_available_vars(struct perf_probe_event *pevs __unused,

			int npevs __unused, int max_vls __unused,

			const char *module __unused, bool externs __unused)

			const char *module __unused,

			struct strfilter *filter __unused,

			bool externs __unused)

{

	pr_warning("Debuginfo-analysis is not supported.\n");

	return -ENOSYS;

#include <stdbool.h>

#include "strlist.h"

#include "strfilter.h"

extern bool probe_event_dry_run;

extern int show_line_range(struct line_range *lr, const char *module);

extern int show_available_vars(struct perf_probe_event *pevs, int npevs,

			       int max_probe_points, const char *module,

			       bool externs);

			       struct strfilter *filter, bool externs);

extern int show_available_funcs(const char *module);