// SPDX-License-Identifier: GPL-2.0#include "../../util/util.h" // perf_exe()#include "../util.h"#include "../../util/evlist.h"#include "../../util/hist.h"#include "../../util/debug.h"#include "../../util/session.h"#include "../../util/symbol.h"#include "../browser.h"#include "../libslang.h"#include "config.h"#include <linux/err.h>#include <linux/string.h>#include <linux/zalloc.h>#include <subcmd/exec-cmd.h>#include <stdlib.h> #define SCRIPT_NAMELEN	128#define SCRIPT_MAX_NO	64/* * Usually the full path for a script is: *	/home/username/libexec/perf-core/scripts/python/xxx.py *	/home/username/libexec/perf-core/scripts/perl/xxx.pl * So 256 should be long enough to contain the full path. */#define SCRIPT_FULLPATH_LEN	256 struct script_config {	const char **names;	char **paths;	int index;	const char *perf;	char extra_format[256];}; void attr_to_script(char *extra_format, struct perf_event_attr *attr){	extra_format[0] = 0;	if (attr->read_format & PERF_FORMAT_GROUP)		strcat(extra_format, " -F +metric");	if (attr->sample_type & PERF_SAMPLE_BRANCH_STACK)		strcat(extra_format, " -F +brstackinsn --xed");	if (attr->sample_type & PERF_SAMPLE_REGS_INTR)		strcat(extra_format, " -F +iregs");	if (attr->sample_type & PERF_SAMPLE_REGS_USER)		strcat(extra_format, " -F +uregs");	if (attr->sample_type & PERF_SAMPLE_PHYS_ADDR)		strcat(extra_format, " -F +phys_addr");} static int add_script_option(const char *name, const char *opt,			     struct script_config *c){	c->names[c->index] = name;	if (asprintf(&c->paths[c->index],		     "%s script %s -F +metric %s %s",		     c->perf, opt, symbol_conf.inline_name ? " --inline" : "",		     c->extra_format) < 0)		return -1;	c->index++;	return 0;} static int scripts_config(const char *var, const char *value, void *data){	struct script_config *c = data; 	if (!strstarts(var, "scripts."))		return -1;	if (c->index >= SCRIPT_MAX_NO)		return -1;	c->names[c->index] = strdup(var + 7);	if (!c->names[c->index])		return -1;	if (asprintf(&c->paths[c->index], "%s %s", value,		     c->extra_format) < 0)		return -1;	c->index++;	return 0;} /* * Some scripts specify the required events in their "xxx-record" file, * this function will check if the events in perf.data match those * mentioned in the "xxx-record". * * Fixme: All existing "xxx-record" are all in good formats "-e event ", * which is covered well now. And new parsing code should be added to * cover the future complex formats like event groups etc. */static int check_ev_match(int dir_fd, const char *scriptname, struct perf_session *session){	char line[BUFSIZ];	FILE *fp; 	{		char filename[NAME_MAX + 5];		int fd; 		scnprintf(filename, sizeof(filename), "bin/%s-record", scriptname);		fd = openat(dir_fd, filename, O_RDONLY);		if (fd == -1)			return -1;		fp = fdopen(fd, "r");		if (!fp)			return -1;	} 	while (fgets(line, sizeof(line), fp)) {		char *p = skip_spaces(line); 		if (*p == '#')			continue; 		while (strlen(p)) {			int match, len;			struct evsel *pos;			char evname[128]; 			p = strstr(p, "-e");			if (!p)				break; 			p += 2;			p = skip_spaces(p);			len = strcspn(p, " \t");			if (!len)				break; 			snprintf(evname, len + 1, "%s", p); 			match = 0;			evlist__for_each_entry(session->evlist, pos) {				if (evsel__name_is(pos, evname)) {					match = 1;					break;				}			} 			if (!match) {				fclose(fp);				return -1;			}		}	} 	fclose(fp);	return 0;} /* * Return -1 if none is found, otherwise the actual scripts number. * * Currently the only user of this function is the script browser, which * will list all statically runnable scripts, select one, execute it and * show the output in a perf browser. */static int find_scripts(char **scripts_array, char **scripts_path_array, int num,		 int pathlen){	struct dirent *script_dirent, *lang_dirent;	int scripts_dir_fd, lang_dir_fd;	DIR *scripts_dir, *lang_dir;	struct perf_session *session;	struct perf_data data = {		.path = input_name,		.mode = PERF_DATA_MODE_READ,	};	char *temp;	int i = 0;	const char *exec_path = get_argv_exec_path(); 	session = perf_session__new(&data, NULL);	if (IS_ERR(session))		return PTR_ERR(session); 	{		char scripts_path[PATH_MAX]; 		snprintf(scripts_path, sizeof(scripts_path), "%s/scripts", exec_path);		scripts_dir_fd = open(scripts_path, O_DIRECTORY);		pr_err("Failed to open directory '%s'", scripts_path);		if (scripts_dir_fd == -1) {			perf_session__delete(session);			return -1;		}	}	scripts_dir = fdopendir(scripts_dir_fd);	if (!scripts_dir) {		close(scripts_dir_fd);		perf_session__delete(session);		return -1;	} 	while ((lang_dirent = readdir(scripts_dir)) != NULL) {		if (lang_dirent->d_type != DT_DIR &&		    (lang_dirent->d_type == DT_UNKNOWN &&		     !is_directory_at(scripts_dir_fd, lang_dirent->d_name)))			continue;		if (!strcmp(lang_dirent->d_name, ".") || !strcmp(lang_dirent->d_name, ".."))			continue; #ifndef HAVE_LIBPERL_SUPPORT		if (strstr(lang_dirent->d_name, "perl"))			continue;#endif#ifndef HAVE_LIBPYTHON_SUPPORT		if (strstr(lang_dirent->d_name, "python"))			continue;#endif 		lang_dir_fd = openat(scripts_dir_fd, lang_dirent->d_name, O_DIRECTORY);		if (lang_dir_fd == -1)			continue;		lang_dir = fdopendir(lang_dir_fd);		if (!lang_dir) {			close(lang_dir_fd);			continue;		}		while ((script_dirent = readdir(lang_dir)) != NULL) {			if (script_dirent->d_type == DT_DIR)				continue;			if (script_dirent->d_type == DT_UNKNOWN &&			    is_directory_at(lang_dir_fd, script_dirent->d_name))				continue;			/* Skip those real time scripts: xxxtop.p[yl] */			if (strstr(script_dirent->d_name, "top."))				continue;			if (i >= num)				break;			scnprintf(scripts_path_array[i], pathlen, "%s/scripts/%s/%s",				exec_path,				lang_dirent->d_name,				script_dirent->d_name);			temp = strchr(script_dirent->d_name, '.');			snprintf(scripts_array[i],				(temp - script_dirent->d_name) + 1,				"%s", script_dirent->d_name); 			if (check_ev_match(lang_dir_fd, scripts_array[i], session))				continue; 			i++;		}		closedir(lang_dir);	} 	closedir(scripts_dir);	perf_session__delete(session);	return i;} /* * When success, will copy the full path of the selected script * into  the buffer pointed by script_name, and return 0. * Return -1 on failure. */static int list_scripts(char *script_name, bool *custom,			struct evsel *evsel){	char *buf, *paths[SCRIPT_MAX_NO], *names[SCRIPT_MAX_NO];	int i, num, choice;	int ret = 0;	int max_std, custom_perf;	char pbuf[256];	const char *perf = perf_exe(pbuf, sizeof pbuf);	struct script_config scriptc = {		.names = (const char **)names,		.paths = paths,		.perf = perf	}; 	script_name[0] = 0; 	/* Preset the script name to SCRIPT_NAMELEN */	buf = malloc(SCRIPT_MAX_NO * (SCRIPT_NAMELEN + SCRIPT_FULLPATH_LEN));	if (!buf)		return -1; 	if (evsel)		attr_to_script(scriptc.extra_format, &evsel->core.attr);	add_script_option("Show individual samples", "", &scriptc);	add_script_option("Show individual samples with assembler", "-F +disasm",			  &scriptc);	add_script_option("Show individual samples with source", "-F +srcline,+srccode",			  &scriptc);	perf_config(scripts_config, &scriptc);	custom_perf = scriptc.index;	add_script_option("Show samples with custom perf script arguments", "", &scriptc);	i = scriptc.index;	max_std = i; 	for (; i < SCRIPT_MAX_NO; i++) {		names[i] = buf + (i - max_std) * (SCRIPT_NAMELEN + SCRIPT_FULLPATH_LEN);		paths[i] = names[i] + SCRIPT_NAMELEN;	} 	num = find_scripts(names + max_std, paths + max_std, SCRIPT_MAX_NO - max_std,			SCRIPT_FULLPATH_LEN);	if (num < 0)		num = 0;	choice = ui__popup_menu(num + max_std, (char * const *)names, NULL);	if (choice < 0) {		ret = -1;		goto out;	}	if (choice == custom_perf) {		char script_args[50];		int key = ui_browser__input_window("perf script command",				"Enter perf script command line (without perf script prefix)",				script_args, "", 0);		if (key != K_ENTER) {			ret = -1;			goto out;		}		sprintf(script_name, "%s script %s", perf, script_args);	} else if (choice < num + max_std) {		strcpy(script_name, paths[choice]);	}	*custom = choice >= max_std; out:	free(buf);	for (i = 0; i < max_std; i++)		zfree(&paths[i]);	return ret;} void run_script(char *cmd){	pr_debug("Running %s\n", cmd);	SLang_reset_tty();	if (system(cmd) < 0)		pr_warning("Cannot run %s\n", cmd);	/*	 * SLang doesn't seem to reset the whole terminal, so be more	 * forceful to get back to the original state.	 */	printf("\033[c\033[H\033[J");	fflush(stdout);	SLang_init_tty(0, 0, 0);	SLtty_set_suspend_state(true);	SLsmg_refresh();} int script_browse(const char *script_opt, struct evsel *evsel){	char *cmd, script_name[SCRIPT_FULLPATH_LEN];	bool custom = false; 	memset(script_name, 0, SCRIPT_FULLPATH_LEN);	if (list_scripts(script_name, &custom, evsel))		return -1; 	if (asprintf(&cmd, "%s%s %s %s%s 2>&1 | less",			custom ? "perf script -s " : "",			script_name,			script_opt ? script_opt : "",			input_name ? "-i " : "",			input_name ? input_name : "") < 0)		return -1; 	run_script(cmd);	free(cmd); 	return 0;}