perf probe: Add argv_split() from lib/argv_split.c (e1c01d61) · Commits · e / devices / android_kernel_oneplus_sm7250

tools/perf/util/probe-event.c

+15 −40

Original line number	Original line	Diff line number	Diff line
	@@ -32,6 +32,7 @@

	#undef _GNU_SOURCE		#undef _GNU_SOURCE
	#include "event.h"		#include "event.h"
			#include "string.h"
	#include "debug.h"		#include "debug.h"
	#include "parse-events.h" /* For debugfs_path */		#include "parse-events.h" /* For debugfs_path */
	#include "probe-event.h"		#include "probe-event.h"
	@@ -132,62 +133,36 @@ static void parse_perf_probe_probepoint(char arg, struct probe_point pp)
	/* Parse perf-probe event definition */		/* Parse perf-probe event definition */
	int parse_perf_probe_event(const char str, struct probe_point pp)		int parse_perf_probe_event(const char str, struct probe_point pp)
	{		{
	char argv[MAX_PROBE_ARGS + 1]; / probe + args */		char **argv;
	int argc, i, need_dwarf = 0;		int argc, i, need_dwarf = 0;

	/* Separate arguments, similar to argv_split */		argv = argv_split(str, &argc);
	argc = 0;		if (!argv)
	do {		die("argv_split failed.");
	/* Skip separators */		if (argc > MAX_PROBE_ARGS + 1)
	while (isspace(*str))
	str++;

	/* Add an argument */
	if (*str != '\0') {
	const char *s = str;
	/* Check the limit number of arguments */
	if (argc == MAX_PROBE_ARGS + 1)
	semantic_error("Too many arguments");		semantic_error("Too many arguments");

	/* Skip the argument */
	while (!isspace(str) && str != '\0')
	str++;

	/* Duplicate the argument */
	argv[argc] = strndup(s, str - s);
	if (argv[argc] == NULL)
	die("strndup");
	pr_debug("argv[%d]=%s\n", argc, argv[argc]);
	argc++;
	}
	} while (*str != '\0');
	if (!argc)
	semantic_error("An empty argument.");

	/* Parse probe point */		/* Parse probe point */
	parse_perf_probe_probepoint(argv[0], pp);		parse_perf_probe_probepoint(argv[0], pp);
	free(argv[0]);
	if (pp->file \|\| pp->line)		if (pp->file \|\| pp->line)
	need_dwarf = 1;		need_dwarf = 1;

	/* Copy arguments */		/* Copy arguments and ensure return probe has no C argument */
	pp->nr_args = argc - 1;		pp->nr_args = argc - 1;
	if (pp->nr_args > 0) {		pp->args = zalloc(sizeof(char ) pp->nr_args);
	pp->args = (char *)malloc(sizeof(char ) * pp->nr_args);		for (i = 0; i < pp->nr_args; i++) {
	if (!pp->args)		pp->args[i] = strdup(argv[i + 1]);
	die("malloc");		if (!pp->args[i])
	memcpy(pp->args, &argv[1], sizeof(char ) pp->nr_args);		die("Failed to copy argument.");
	}

	/* Ensure return probe has no C argument */
	for (i = 0; i < pp->nr_args; i++)
	if (is_c_varname(pp->args[i])) {		if (is_c_varname(pp->args[i])) {
	if (pp->retprobe)		if (pp->retprobe)
	semantic_error("You can't specify local"		semantic_error("You can't specify local"
	" variable for kretprobe");		" variable for kretprobe");
	need_dwarf = 1;		need_dwarf = 1;
	}		}
			}

			argv_free(argv);
	return need_dwarf;		return need_dwarf;
	}		}

tools/perf/util/string.c

+101 −0

Original line number	Original line	Diff line number	Diff line
	@@ -127,3 +127,104 @@ s64 perf_atoll(const char *str)
	out:		out:
	return length;		return length;
	}		}

			/*
			* Helper function for splitting a string into an argv-like array.
			* originaly copied from lib/argv_split.c
			*/
			static const char skip_sep(const char cp)
			{
			while (cp && isspace(cp))
			cp++;

			return cp;
			}

			static const char skip_arg(const char cp)
			{
			while (cp && !isspace(cp))
			cp++;

			return cp;
			}

			static int count_argc(const char *str)
			{
			int count = 0;

			while (*str) {
			str = skip_sep(str);
			if (*str) {
			count++;
			str = skip_arg(str);
			}
			}

			return count;
			}

			/**
			* argv_free - free an argv
			* @argv - the argument vector to be freed
			*
			* Frees an argv and the strings it points to.
			*/
			void argv_free(char **argv)
			{
			char **p;
			for (p = argv; *p; p++)
			free(*p);

			free(argv);
			}

			/**
			* argv_split - split a string at whitespace, returning an argv
			* @str: the string to be split
			* @argcp: returned argument count
			*
			* Returns an array of pointers to strings which are split out from
			* @str. This is performed by strictly splitting on white-space; no
			* quote processing is performed. Multiple whitespace characters are
			* considered to be a single argument separator. The returned array
			* is always NULL-terminated. Returns NULL on memory allocation
			* failure.
			*/
			char *argv_split(const char str, int *argcp)
			{
			int argc = count_argc(str);
			char *argv = zalloc(sizeof(argv) * (argc+1));
			char **argvp;

			if (argv == NULL)
			goto out;

			if (argcp)
			*argcp = argc;

			argvp = argv;

			while (*str) {
			str = skip_sep(str);

			if (*str) {
			const char *p = str;
			char *t;

			str = skip_arg(str);

			t = strndup(p, str-p);
			if (t == NULL)
			goto fail;
			*argvp++ = t;
			}
			}
			*argvp = NULL;

			out:
			return argv;

			fail:
			argv_free(argv);
			return NULL;
			}

tools/perf/util/string.h

+2 −0

Original line number	Original line	Diff line number	Diff line
	@@ -6,6 +6,8 @@
	int hex2u64(const char ptr, u64 val);		int hex2u64(const char ptr, u64 val);
	char strxfrchar(char s, char from, char to);		char strxfrchar(char s, char from, char to);
	s64 perf_atoll(const char *str);		s64 perf_atoll(const char *str);
			char *argv_split(const char str, int *argcp);
			void argv_free(char **argv);

	#define _STR(x) #x		#define _STR(x) #x
	#define STR(x) _STR(x)		#define STR(x) _STR(x)