[linux-block.git] / tools / perf / util / trace-event-info.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2008,2009, Steven Rostedt <srostedt@redhat.com>
 */
#include <dirent.h>
#include <mntent.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <stdbool.h>
#include <linux/list.h>
#include <linux/kernel.h>
#include <linux/zalloc.h>
#include <internal/lib.h> // page_size
#include <sys/param.h>

#include "trace-event.h"
#include "tracepoint.h"
#include <api/fs/tracing_path.h>
#include "evsel.h"
#include "debug.h"
#include "util.h"

#define VERSION "0.6"
#define MAX_EVENT_LENGTH 512

static int output_fd;

struct tracepoint_path {
	char *system;
	char *name;
	struct tracepoint_path *next;
};

/* unfortunately, you can not stat debugfs or proc files for size */
static int record_file(const char *file, ssize_t hdr_sz)
{
	unsigned long long size = 0;
	char buf[BUFSIZ], *sizep;
	off_t hdr_pos = lseek(output_fd, 0, SEEK_CUR);
	int r, fd;
	int err = -EIO;

	fd = open(file, O_RDONLY);
	if (fd < 0) {
		pr_debug("Can't read '%s'", file);
		return -errno;
	}

	/* put in zeros for file size, then fill true size later */
	if (hdr_sz) {
		if (write(output_fd, &size, hdr_sz) != hdr_sz)
			goto out;
	}

	do {
		r = read(fd, buf, BUFSIZ);
		if (r > 0) {
			size += r;
			if (write(output_fd, buf, r) != r)
				goto out;
		}
	} while (r > 0);

	/* ugh, handle big-endian hdr_size == 4 */
	sizep = (char*)&size;
	if (host_is_bigendian())
		sizep += sizeof(u64) - hdr_sz;

	if (hdr_sz && pwrite(output_fd, sizep, hdr_sz, hdr_pos) < 0) {
		pr_debug("writing file size failed\n");
		goto out;
	}

	err = 0;
out:
	close(fd);
	return err;
}

static int record_header_files(void)
{
	char *path = get_events_file("header_page");
	struct stat st;
	int err = -EIO;

	if (!path) {
		pr_debug("can't get tracing/events/header_page");
		return -ENOMEM;
	}

	if (stat(path, &st) < 0) {
		pr_debug("can't read '%s'", path);
		goto out;
	}

	if (write(output_fd, "header_page", 12) != 12) {
		pr_debug("can't write header_page\n");
		goto out;
	}

	if (record_file(path, 8) < 0) {
		pr_debug("can't record header_page file\n");
		goto out;
	}

	put_events_file(path);

	path = get_events_file("header_event");
	if (!path) {
		pr_debug("can't get tracing/events/header_event");
		err = -ENOMEM;
		goto out;
	}

	if (stat(path, &st) < 0) {
		pr_debug("can't read '%s'", path);
		goto out;
	}

	if (write(output_fd, "header_event", 13) != 13) {
		pr_debug("can't write header_event\n");
		goto out;
	}

	if (record_file(path, 8) < 0) {
		pr_debug("can't record header_event file\n");
		goto out;
	}

	err = 0;
out:
	put_events_file(path);
	return err;
}

static bool name_in_tp_list(char *sys, struct tracepoint_path *tps)
{
	while (tps) {
		if (!strcmp(sys, tps->name))
			return true;
		tps = tps->next;
	}

	return false;
}

#define for_each_event_tps(dir, dent, tps)			\
	while ((dent = readdir(dir)))				\
		if (dent->d_type == DT_DIR &&			\
		    (strcmp(dent->d_name, ".")) &&		\
		    (strcmp(dent->d_name, "..")))		\

static int copy_event_system(const char *sys, struct tracepoint_path *tps)
{
	struct dirent *dent;
	struct stat st;
	char *format;
	DIR *dir;
	int count = 0;
	int ret;
	int err;

	dir = opendir(sys);
	if (!dir) {
		pr_debug("can't read directory '%s'", sys);
		return -errno;
	}

	for_each_event_tps(dir, dent, tps) {
		if (!name_in_tp_list(dent->d_name, tps))
			continue;

		if (asprintf(&format, "%s/%s/format", sys, dent->d_name) < 0) {
			err = -ENOMEM;
			goto out;
		}
		ret = stat(format, &st);
		free(format);
		if (ret < 0)
			continue;
		count++;
	}

	if (write(output_fd, &count, 4) != 4) {
		err = -EIO;
		pr_debug("can't write count\n");
		goto out;
	}

	rewinddir(dir);
	for_each_event_tps(dir, dent, tps) {
		if (!name_in_tp_list(dent->d_name, tps))
			continue;

		if (asprintf(&format, "%s/%s/format", sys, dent->d_name) < 0) {
			err = -ENOMEM;
			goto out;
		}
		ret = stat(format, &st);

		if (ret >= 0) {
			err = record_file(format, 8);
			if (err) {
				free(format);
				goto out;
			}
		}
		free(format);
	}
	err = 0;
out:
	closedir(dir);
	return err;
}

static int record_ftrace_files(struct tracepoint_path *tps)
{
	char *path;
	int ret;

	path = get_events_file("ftrace");
	if (!path) {
		pr_debug("can't get tracing/events/ftrace");
		return -ENOMEM;
	}

	ret = copy_event_system(path, tps);

	put_tracing_file(path);

	return ret;
}

static bool system_in_tp_list(char *sys, struct tracepoint_path *tps)
{
	while (tps) {
		if (!strcmp(sys, tps->system))
			return true;
		tps = tps->next;
	}

	return false;
}

static int record_event_files(struct tracepoint_path *tps)
{
	struct dirent *dent;
	struct stat st;
	char *path;
	char *sys;
	DIR *dir;
	int count = 0;
	int ret;
	int err;

	path = get_tracing_file("events");
	if (!path) {
		pr_debug("can't get tracing/events");
		return -ENOMEM;
	}

	dir = opendir(path);
	if (!dir) {
		err = -errno;
		pr_debug("can't read directory '%s'", path);
		goto out;
	}

	for_each_event_tps(dir, dent, tps) {
		if (strcmp(dent->d_name, "ftrace") == 0 ||
		    !system_in_tp_list(dent->d_name, tps))
			continue;

		count++;
	}

	if (write(output_fd, &count, 4) != 4) {
		err = -EIO;
		pr_debug("can't write count\n");
		goto out;
	}

	rewinddir(dir);
	for_each_event_tps(dir, dent, tps) {
		if (strcmp(dent->d_name, "ftrace") == 0 ||
		    !system_in_tp_list(dent->d_name, tps))
			continue;

		if (asprintf(&sys, "%s/%s", path, dent->d_name) < 0) {
			err = -ENOMEM;
			goto out;
		}
		ret = stat(sys, &st);
		if (ret >= 0) {
			ssize_t size = strlen(dent->d_name) + 1;

			if (write(output_fd, dent->d_name, size) != size ||
			    copy_event_system(sys, tps) < 0) {
				err = -EIO;
				free(sys);
				goto out;
			}
		}
		free(sys);
	}
	err = 0;
out:
	if (dir)
		closedir(dir);
	put_tracing_file(path);

	return err;
}

static int record_proc_kallsyms(void)
{
	unsigned long long size = 0;
	/*
	 * Just to keep older perf.data file parsers happy, record a zero
	 * sized kallsyms file, i.e. do the same thing that was done when
	 * /proc/kallsyms (or something specified via --kallsyms, in a
	 * different path) couldn't be read.
	 */
	return write(output_fd, &size, 4) != 4 ? -EIO : 0;
}

static int record_ftrace_printk(void)
{
	unsigned int size;
	char *path;
	struct stat st;
	int ret, err = 0;

	path = get_tracing_file("printk_formats");
	if (!path) {
		pr_debug("can't get tracing/printk_formats");
		return -ENOMEM;
	}

	ret = stat(path, &st);
	if (ret < 0) {
		/* not found */
		size = 0;
		if (write(output_fd, &size, 4) != 4)
			err = -EIO;
		goto out;
	}
	err = record_file(path, 4);

out:
	put_tracing_file(path);
	return err;
}

static int record_saved_cmdline(void)
{
	unsigned long long size;
	char *path;
	struct stat st;
	int ret, err = 0;

	path = get_tracing_file("saved_cmdlines");
	if (!path) {
		pr_debug("can't get tracing/saved_cmdline");
		return -ENOMEM;
	}

	ret = stat(path, &st);
	if (ret < 0) {
		/* not found */
		size = 0;
		if (write(output_fd, &size, 8) != 8)
			err = -EIO;
		goto out;
	}
	err = record_file(path, 8);

out:
	put_tracing_file(path);
	return err;
}

static void
put_tracepoints_path(struct tracepoint_path *tps)
{
	while (tps) {
		struct tracepoint_path *t = tps;

		tps = tps->next;
		zfree(&t->name);
		zfree(&t->system);
		free(t);
	}
}

static struct tracepoint_path *tracepoint_id_to_path(u64 config)
{
	struct tracepoint_path *path = NULL;
	DIR *sys_dir, *evt_dir;
	struct dirent *sys_dirent, *evt_dirent;
	char id_buf[24];
	int fd;
	u64 id;
	char evt_path[MAXPATHLEN];
	char *dir_path;

	sys_dir = tracing_events__opendir();
	if (!sys_dir)
		return NULL;

	for_each_subsystem(sys_dir, sys_dirent) {
		dir_path = get_events_file(sys_dirent->d_name);
		if (!dir_path)
			continue;
		evt_dir = opendir(dir_path);
		if (!evt_dir)
			goto next;

		for_each_event(dir_path, evt_dir, evt_dirent) {

			scnprintf(evt_path, MAXPATHLEN, "%s/%s/id", dir_path,
				  evt_dirent->d_name);
			fd = open(evt_path, O_RDONLY);
			if (fd < 0)
				continue;
			if (read(fd, id_buf, sizeof(id_buf)) < 0) {
				close(fd);
				continue;
			}
			close(fd);
			id = atoll(id_buf);
			if (id == config) {
				put_events_file(dir_path);
				closedir(evt_dir);
				closedir(sys_dir);
				path = zalloc(sizeof(*path));
				if (!path)
					return NULL;
				if (asprintf(&path->system, "%.*s",
					     MAX_EVENT_LENGTH, sys_dirent->d_name) < 0) {
					free(path);
					return NULL;
				}
				if (asprintf(&path->name, "%.*s",
					     MAX_EVENT_LENGTH, evt_dirent->d_name) < 0) {
					zfree(&path->system);
					free(path);
					return NULL;
				}
				return path;
			}
		}
		closedir(evt_dir);
next:
		put_events_file(dir_path);
	}

	closedir(sys_dir);
	return NULL;
}

char *tracepoint_id_to_name(u64 config)
{
	struct tracepoint_path *path = tracepoint_id_to_path(config);
	char *buf = NULL;

	if (path && asprintf(&buf, "%s:%s", path->system, path->name) < 0)
		buf = NULL;

	put_tracepoints_path(path);
	return buf;
}

static struct tracepoint_path *tracepoint_name_to_path(const char *name)
{
	struct tracepoint_path *path = zalloc(sizeof(*path));
	char *str = strchr(name, ':');

	if (path == NULL || str == NULL) {
		free(path);
		return NULL;
	}

	path->system = strndup(name, str - name);
	path->name = strdup(str+1);

	if (path->system == NULL || path->name == NULL) {
		zfree(&path->system);
		zfree(&path->name);
		zfree(&path);
	}

	return path;
}

static struct tracepoint_path *
get_tracepoints_path(struct list_head *pattrs)
{
	struct tracepoint_path path, *ppath = &path;
	struct evsel *pos;
	int nr_tracepoints = 0;

	list_for_each_entry(pos, pattrs, core.node) {
		if (pos->core.attr.type != PERF_TYPE_TRACEPOINT)
			continue;
		++nr_tracepoints;

		if (pos->name) {
			ppath->next = tracepoint_name_to_path(pos->name);
			if (ppath->next)
				goto next;

			if (strchr(pos->name, ':') == NULL)
				goto try_id;

			goto error;
		}

try_id:
		ppath->next = tracepoint_id_to_path(pos->core.attr.config);
		if (!ppath->next) {
error:
			pr_debug("No memory to alloc tracepoints list\n");
			put_tracepoints_path(path.next);
			return NULL;
		}
next:
		ppath = ppath->next;
	}

	return nr_tracepoints > 0 ? path.next : NULL;
}

bool have_tracepoints(struct list_head *pattrs)
{
	struct evsel *pos;

	list_for_each_entry(pos, pattrs, core.node)
		if (pos->core.attr.type == PERF_TYPE_TRACEPOINT)
			return true;

	return false;
}

static int tracing_data_header(void)
{
	char buf[20];
	ssize_t size;

	/* just guessing this is someone's birthday.. ;) */
	buf[0] = 23;
	buf[1] = 8;
	buf[2] = 68;
	memcpy(buf + 3, "tracing", 7);

	if (write(output_fd, buf, 10) != 10)
		return -1;

	size = strlen(VERSION) + 1;
	if (write(output_fd, VERSION, size) != size)
		return -1;

	/* save endian */
	if (host_is_bigendian())
		buf[0] = 1;
	else
		buf[0] = 0;

	if (write(output_fd, buf, 1) != 1)
		return -1;

	/* save size of long */
	buf[0] = sizeof(long);
	if (write(output_fd, buf, 1) != 1)
		return -1;

	/* save page_size */
	if (write(output_fd, &page_size, 4) != 4)
		return -1;

	return 0;
}

struct tracing_data *tracing_data_get(struct list_head *pattrs,
				      int fd, bool temp)
{
	struct tracepoint_path *tps;
	struct tracing_data *tdata;
	int err;

	output_fd = fd;

	tps = get_tracepoints_path(pattrs);
	if (!tps)
		return NULL;

	tdata = malloc(sizeof(*tdata));
	if (!tdata)
		return NULL;

	tdata->temp = temp;
	tdata->size = 0;

	if (temp) {
		int temp_fd;

		snprintf(tdata->temp_file, sizeof(tdata->temp_file),
			 "/tmp/perf-XXXXXX");
		if (!mkstemp(tdata->temp_file)) {
			pr_debug("Can't make temp file");
			free(tdata);
			return NULL;
		}

		temp_fd = open(tdata->temp_file, O_RDWR);
		if (temp_fd < 0) {
			pr_debug("Can't read '%s'", tdata->temp_file);
			free(tdata);
			return NULL;
		}

		/*
		 * Set the temp file the default output, so all the
		 * tracing data are stored into it.
		 */
		output_fd = temp_fd;
	}

	err = tracing_data_header();
	if (err)
		goto out;
	err = record_header_files();
	if (err)
		goto out;
	err = record_ftrace_files(tps);
	if (err)
		goto out;
	err = record_event_files(tps);
	if (err)
		goto out;
	err = record_proc_kallsyms();
	if (err)
		goto out;
	err = record_ftrace_printk();
	if (err)
		goto out;
	err = record_saved_cmdline();

out:
	/*
	 * All tracing data are stored by now, we can restore
	 * the default output file in case we used temp file.
	 */
	if (temp) {
		tdata->size = lseek(output_fd, 0, SEEK_CUR);
		close(output_fd);
		output_fd = fd;
	}

	if (err)
		zfree(&tdata);

	put_tracepoints_path(tps);
	return tdata;
}

int tracing_data_put(struct tracing_data *tdata)
{
	int err = 0;

	if (tdata->temp) {
		err = record_file(tdata->temp_file, 0);
		unlink(tdata->temp_file);
	}

	free(tdata);
	return err;
}

int read_tracing_data(int fd, struct list_head *pattrs)
{
	int err;
	struct tracing_data *tdata;

	/*
	 * We work over the real file, so we can write data
	 * directly, no temp file is needed.
	 */
	tdata = tracing_data_get(pattrs, fd, false);
	if (!tdata)
		return -ENOMEM;

	err = tracing_data_put(tdata);
	return err;
}
Commit	Line	Data
5a8e0ff9	1	// SPDX-License-Identifier: GPL-2.0-only
52050943 SR	2	/*
52050943 SR	3	* Copyright (C) 2008,2009, Steven Rostedt <srostedt@redhat.com>
52050943	4	*/
52050943	5	#include <dirent.h>
659d8cfb	6	#include <mntent.h>
52050943 SR	7	#include <stdio.h>
	8	#include <stdlib.h>
	9	#include <string.h>
	10	#include <stdarg.h>
	11	#include <sys/types.h>
	12	#include <sys/stat.h>
	13	#include <sys/wait.h>
52050943 SR	14	#include <fcntl.h>
52050943 SR	15	#include <unistd.h>
52050943	16	#include <errno.h>
1ef2ed10	17	#include <stdbool.h>
69aad6f1	18	#include <linux/list.h>
e2561368	19	#include <linux/kernel.h>
7f7c536f	20	#include <linux/zalloc.h>
20f2be1d	21	#include <internal/lib.h> // page_size
9b7c7728	22	#include <sys/param.h>
52050943 SR	23
52050943 SR	24	#include "trace-event.h"
9b7c7728	25	#include "tracepoint.h"
592d5a6b	26	#include <api/fs/tracing_path.h>
69aad6f1	27	#include "evsel.h"
84f5d36f	28	#include "debug.h"
5b7a29fb	29	#include "util.h"
52050943	30
cd4ceb63	31	#define VERSION "0.6"
9b7c7728	32	#define MAX_EVENT_LENGTH 512
52050943	33
52050943 SR	34	static int output_fd;
52050943 SR	35
9b7c7728 IR	36	struct tracepoint_path {
	37	char *system;
	38	char *name;
	39	struct tracepoint_path *next;
	40	};
52050943	41
259032bf	42	/* unfortunately, you can not stat debugfs or proc files for size */
8755d5e2	43	static int record_file(const char *file, ssize_t hdr_sz)
52050943 SR	44	{
52050943 SR	45	unsigned long long size = 0;
259032bf SR	46	char buf[BUFSIZ], *sizep;
	47	off_t hdr_pos = lseek(output_fd, 0, SEEK_CUR);
	48	int r, fd;
8755d5e2	49	int err = -EIO;
52050943 SR	50
52050943 SR	51	fd = open(file, O_RDONLY);
7f42b950 NK	52	if (fd < 0) {
	53	pr_debug("Can't read '%s'", file);
	54	return -errno;
	55	}
52050943	56
259032bf	57	/* put in zeros for file size, then fill true size later */
8755d5e2 NK	58	if (hdr_sz) {
	59	if (write(output_fd, &size, hdr_sz) != hdr_sz)
	60	goto out;
	61	}
52050943 SR	62
	63	do {
	64	r = read(fd, buf, BUFSIZ);
259032bf	65	if (r > 0) {
52050943	66	size += r;
8755d5e2 NK	67	if (write(output_fd, buf, r) != r)
8755d5e2 NK	68	goto out;
259032bf	69	}
52050943	70	} while (r > 0);
52050943	71
259032bf SR	72	/* ugh, handle big-endian hdr_size == 4 */
259032bf SR	73	sizep = (char*)&size;
5b7a29fb	74	if (host_is_bigendian())
259032bf SR	75	sizep += sizeof(u64) - hdr_sz;
259032bf SR	76
7f42b950 NK	77	if (hdr_sz && pwrite(output_fd, sizep, hdr_sz, hdr_pos) < 0) {
	78	pr_debug("writing file size failed\n");
	79	goto out;
	80	}
8755d5e2 NK	81
	82	err = 0;
	83	out:
	84	close(fd);
	85	return err;
52050943 SR	86	}
52050943 SR	87
077f159d	88	static int record_header_files(void)
52050943	89	{
40c3c0c9	90	char *path = get_events_file("header_page");
259032bf	91	struct stat st;
8755d5e2	92	int err = -EIO;
52050943	93
7f42b950 NK	94	if (!path) {
	95	pr_debug("can't get tracing/events/header_page");
	96	return -ENOMEM;
	97	}
454f8c7d	98
7f42b950 NK	99	if (stat(path, &st) < 0) {
	100	pr_debug("can't read '%s'", path);
	101	goto out;
	102	}
52050943	103
8755d5e2 NK	104	if (write(output_fd, "header_page", 12) != 12) {
	105	pr_debug("can't write header_page\n");
	106	goto out;
	107	}
	108
	109	if (record_file(path, 8) < 0) {
	110	pr_debug("can't record header_page file\n");
	111	goto out;
	112	}
	113
40c3c0c9	114	put_events_file(path);
52050943	115
40c3c0c9	116	path = get_events_file("header_event");
7f42b950 NK	117	if (!path) {
	118	pr_debug("can't get tracing/events/header_event");
	119	err = -ENOMEM;
	120	goto out;
	121	}
454f8c7d	122
7f42b950 NK	123	if (stat(path, &st) < 0) {
	124	pr_debug("can't read '%s'", path);
	125	goto out;
	126	}
52050943	127
8755d5e2 NK	128	if (write(output_fd, "header_event", 13) != 13) {
	129	pr_debug("can't write header_event\n");
	130	goto out;
	131	}
	132
	133	if (record_file(path, 8) < 0) {
	134	pr_debug("can't record header_event file\n");
	135	goto out;
	136	}
	137
	138	err = 0;
	139	out:
40c3c0c9	140	put_events_file(path);
8755d5e2	141	return err;
52050943 SR	142	}
52050943 SR	143
1ef2ed10 FW	144	static bool name_in_tp_list(char sys, struct tracepoint_path tps)
	145	{
	146	while (tps) {
	147	if (!strcmp(sys, tps->name))
	148	return true;
	149	tps = tps->next;
	150	}
	151
	152	return false;
	153	}
	154
d2e31d7e	155	#define for_each_event_tps(dir, dent, tps) \
43d41deb TS	156	while ((dent = readdir(dir))) \
	157	if (dent->d_type == DT_DIR && \
	158	(strcmp(dent->d_name, ".")) && \
	159	(strcmp(dent->d_name, ".."))) \
	160
5a6fd27a	161	static int copy_event_system(const char sys, struct tracepoint_path tps)
52050943	162	{
52050943 SR	163	struct dirent *dent;
	164	struct stat st;
	165	char *format;
	166	DIR *dir;
	167	int count = 0;
	168	int ret;
5a6fd27a	169	int err;
52050943 SR	170
52050943 SR	171	dir = opendir(sys);
7f42b950 NK	172	if (!dir) {
	173	pr_debug("can't read directory '%s'", sys);
	174	return -errno;
	175	}
52050943	176
d2e31d7e	177	for_each_event_tps(dir, dent, tps) {
43d41deb	178	if (!name_in_tp_list(dent->d_name, tps))
52050943	179	continue;
43d41deb	180
d400a68d	181	if (asprintf(&format, "%s/%s/format", sys, dent->d_name) < 0) {
5a6fd27a NK	182	err = -ENOMEM;
	183	goto out;
	184	}
52050943 SR	185	ret = stat(format, &st);
	186	free(format);
	187	if (ret < 0)
	188	continue;
	189	count++;
	190	}
	191
8755d5e2 NK	192	if (write(output_fd, &count, 4) != 4) {
	193	err = -EIO;
	194	pr_debug("can't write count\n");
	195	goto out;
	196	}
52050943 SR	197
52050943 SR	198	rewinddir(dir);
d2e31d7e	199	for_each_event_tps(dir, dent, tps) {
43d41deb	200	if (!name_in_tp_list(dent->d_name, tps))
52050943	201	continue;
43d41deb	202
d400a68d	203	if (asprintf(&format, "%s/%s/format", sys, dent->d_name) < 0) {
5a6fd27a NK	204	err = -ENOMEM;
	205	goto out;
	206	}
52050943 SR	207	ret = stat(format, &st);
52050943 SR	208
8755d5e2 NK	209	if (ret >= 0) {
	210	err = record_file(format, 8);
	211	if (err) {
	212	free(format);
	213	goto out;
	214	}
	215	}
52050943 SR	216	free(format);
52050943 SR	217	}
5a6fd27a NK	218	err = 0;
5a6fd27a NK	219	out:
9967411e	220	closedir(dir);
5a6fd27a	221	return err;
52050943 SR	222	}
52050943 SR	223
077f159d	224	static int record_ftrace_files(struct tracepoint_path *tps)
52050943 SR	225	{
52050943 SR	226	char *path;
8755d5e2	227	int ret;
52050943	228
40c3c0c9	229	path = get_events_file("ftrace");
7f42b950 NK	230	if (!path) {
	231	pr_debug("can't get tracing/events/ftrace");
	232	return -ENOMEM;
	233	}
52050943	234
8755d5e2	235	ret = copy_event_system(path, tps);
52050943 SR	236
52050943 SR	237	put_tracing_file(path);
8755d5e2 NK	238
8755d5e2 NK	239	return ret;
52050943 SR	240	}
52050943 SR	241
1ef2ed10 FW	242	static bool system_in_tp_list(char sys, struct tracepoint_path tps)
	243	{
	244	while (tps) {
	245	if (!strcmp(sys, tps->system))
	246	return true;
	247	tps = tps->next;
	248	}
	249
	250	return false;
	251	}
	252
077f159d	253	static int record_event_files(struct tracepoint_path *tps)
52050943 SR	254	{
	255	struct dirent *dent;
	256	struct stat st;
	257	char *path;
	258	char *sys;
	259	DIR *dir;
	260	int count = 0;
	261	int ret;
5a6fd27a	262	int err;
52050943 SR	263
52050943 SR	264	path = get_tracing_file("events");
7f42b950 NK	265	if (!path) {
	266	pr_debug("can't get tracing/events");
	267	return -ENOMEM;
	268	}
52050943 SR	269
52050943 SR	270	dir = opendir(path);
7f42b950 NK	271	if (!dir) {
	272	err = -errno;
	273	pr_debug("can't read directory '%s'", path);
	274	goto out;
	275	}
52050943	276
d2e31d7e	277	for_each_event_tps(dir, dent, tps) {
43d41deb	278	if (strcmp(dent->d_name, "ftrace") == 0 \|\|
1ef2ed10	279	!system_in_tp_list(dent->d_name, tps))
52050943	280	continue;
43d41deb	281
659d8cfb	282	count++;
52050943 SR	283	}
52050943 SR	284
8755d5e2 NK	285	if (write(output_fd, &count, 4) != 4) {
	286	err = -EIO;
	287	pr_debug("can't write count\n");
	288	goto out;
	289	}
52050943 SR	290
52050943 SR	291	rewinddir(dir);
d2e31d7e	292	for_each_event_tps(dir, dent, tps) {
43d41deb	293	if (strcmp(dent->d_name, "ftrace") == 0 \|\|
1ef2ed10	294	!system_in_tp_list(dent->d_name, tps))
52050943	295	continue;
43d41deb	296
d400a68d	297	if (asprintf(&sys, "%s/%s", path, dent->d_name) < 0) {
5a6fd27a NK	298	err = -ENOMEM;
	299	goto out;
	300	}
52050943 SR	301	ret = stat(sys, &st);
52050943 SR	302	if (ret >= 0) {
8755d5e2 NK	303	ssize_t size = strlen(dent->d_name) + 1;
	304
	305	if (write(output_fd, dent->d_name, size) != size \|\|
	306	copy_event_system(sys, tps) < 0) {
	307	err = -EIO;
	308	free(sys);
	309	goto out;
	310	}
52050943 SR	311	}
	312	free(sys);
	313	}
5a6fd27a NK	314	err = 0;
5a6fd27a NK	315	out:
97fe0383 IR	316	if (dir)
97fe0383 IR	317	closedir(dir);
52050943	318	put_tracing_file(path);
5a6fd27a NK	319
5a6fd27a NK	320	return err;
52050943 SR	321	}
52050943 SR	322
077f159d	323	static int record_proc_kallsyms(void)
52050943	324	{
6e5259e9 ACM	325	unsigned long long size = 0;
	326	/*
	327	* Just to keep older perf.data file parsers happy, record a zero
	328	* sized kallsyms file, i.e. do the same thing that was done when
	329	* /proc/kallsyms (or something specified via --kallsyms, in a
	330	* different path) couldn't be read.
	331	*/
	332	return write(output_fd, &size, 4) != 4 ? -EIO : 0;
52050943 SR	333	}
52050943 SR	334
077f159d	335	static int record_ftrace_printk(void)
52050943	336	{
259032bf	337	unsigned int size;
6706ccf8	338	char *path;
52050943	339	struct stat st;
8755d5e2	340	int ret, err = 0;
52050943 SR	341
52050943 SR	342	path = get_tracing_file("printk_formats");
7f42b950 NK	343	if (!path) {
	344	pr_debug("can't get tracing/printk_formats");
	345	return -ENOMEM;
	346	}
454f8c7d	347
52050943 SR	348	ret = stat(path, &st);
	349	if (ret < 0) {
	350	/* not found */
	351	size = 0;
8755d5e2 NK	352	if (write(output_fd, &size, 4) != 4)
8755d5e2 NK	353	err = -EIO;
6706ccf8	354	goto out;
52050943	355	}
8755d5e2	356	err = record_file(path, 4);
259032bf	357
6706ccf8 LZ	358	out:
6706ccf8 LZ	359	put_tracing_file(path);
8755d5e2	360	return err;
52050943 SR	361	}
52050943 SR	362
cd4ceb63 NK	363	static int record_saved_cmdline(void)
cd4ceb63 NK	364	{
a72f6426	365	unsigned long long size;
cd4ceb63 NK	366	char *path;
	367	struct stat st;
	368	int ret, err = 0;
	369
	370	path = get_tracing_file("saved_cmdlines");
	371	if (!path) {
	372	pr_debug("can't get tracing/saved_cmdline");
	373	return -ENOMEM;
	374	}
	375
	376	ret = stat(path, &st);
	377	if (ret < 0) {
	378	/* not found */
	379	size = 0;
	380	if (write(output_fd, &size, 8) != 8)
	381	err = -EIO;
	382	goto out;
	383	}
	384	err = record_file(path, 8);
	385
	386	out:
	387	put_tracing_file(path);
	388	return err;
	389	}
	390
7f42b950 NK	391	static void
	392	put_tracepoints_path(struct tracepoint_path *tps)
	393	{
	394	while (tps) {
	395	struct tracepoint_path *t = tps;
	396
	397	tps = tps->next;
74cf249d ACM	398	zfree(&t->name);
74cf249d ACM	399	zfree(&t->system);
7f42b950 NK	400	free(t);
	401	}
	402	}
	403
9b7c7728 IR	404	static struct tracepoint_path *tracepoint_id_to_path(u64 config)
	405	{
	406	struct tracepoint_path *path = NULL;
	407	DIR sys_dir, evt_dir;
	408	struct dirent sys_dirent, evt_dirent;
	409	char id_buf[24];
	410	int fd;
	411	u64 id;
	412	char evt_path[MAXPATHLEN];
	413	char *dir_path;
	414
	415	sys_dir = tracing_events__opendir();
	416	if (!sys_dir)
	417	return NULL;
	418
	419	for_each_subsystem(sys_dir, sys_dirent) {
	420	dir_path = get_events_file(sys_dirent->d_name);
	421	if (!dir_path)
	422	continue;
	423	evt_dir = opendir(dir_path);
	424	if (!evt_dir)
	425	goto next;
	426
	427	for_each_event(dir_path, evt_dir, evt_dirent) {
	428
	429	scnprintf(evt_path, MAXPATHLEN, "%s/%s/id", dir_path,
	430	evt_dirent->d_name);
	431	fd = open(evt_path, O_RDONLY);
	432	if (fd < 0)
	433	continue;
	434	if (read(fd, id_buf, sizeof(id_buf)) < 0) {
	435	close(fd);
	436	continue;
	437	}
	438	close(fd);
	439	id = atoll(id_buf);
	440	if (id == config) {
	441	put_events_file(dir_path);
	442	closedir(evt_dir);
	443	closedir(sys_dir);
	444	path = zalloc(sizeof(*path));
	445	if (!path)
	446	return NULL;
	447	if (asprintf(&path->system, "%.*s",
	448	MAX_EVENT_LENGTH, sys_dirent->d_name) < 0) {
	449	free(path);
	450	return NULL;
	451	}
	452	if (asprintf(&path->name, "%.*s",
	453	MAX_EVENT_LENGTH, evt_dirent->d_name) < 0) {
	454	zfree(&path->system);
	455	free(path);
	456	return NULL;
	457	}
	458	return path;
	459	}
	460	}
	461	closedir(evt_dir);
	462	next:
	463	put_events_file(dir_path);
	464	}
	465
	466	closedir(sys_dir);
	467	return NULL;
468	}
469
220f88b5 YJ	470	char *tracepoint_id_to_name(u64 config)
	471	{
	472	struct tracepoint_path *path = tracepoint_id_to_path(config);
	473	char *buf = NULL;
	474
	475	if (path && asprintf(&buf, "%s:%s", path->system, path->name) < 0)
	476	buf = NULL;
	477
	478	put_tracepoints_path(path);
	479	return buf;
	480	}
	481
9b7c7728 IR	482	static struct tracepoint_path tracepoint_name_to_path(const char name)
	483	{
	484	struct tracepoint_path path = zalloc(sizeof(path));
	485	char *str = strchr(name, ':');
	486
	487	if (path == NULL \|\| str == NULL) {
	488	free(path);
	489	return NULL;
	490	}
	491
	492	path->system = strndup(name, str - name);
	493	path->name = strdup(str+1);
	494
	495	if (path->system == NULL \|\| path->name == NULL) {
	496	zfree(&path->system);
	497	zfree(&path->name);
	498	zfree(&path);
	499	}
	500
	501	return path;
	502	}
	503
1ef2ed10	504	static struct tracepoint_path *
69aad6f1	505	get_tracepoints_path(struct list_head *pattrs)
1ef2ed10 FW	506	{
1ef2ed10 FW	507	struct tracepoint_path path, *ppath = &path;
32dcd021	508	struct evsel *pos;
69aad6f1	509	int nr_tracepoints = 0;
1ef2ed10	510
b27c4ece	511	list_for_each_entry(pos, pattrs, core.node) {
1fc632ce	512	if (pos->core.attr.type != PERF_TYPE_TRACEPOINT)
1ef2ed10	513	continue;
e2561368	514	++nr_tracepoints;
e7c93f09 NK	515
	516	if (pos->name) {
	517	ppath->next = tracepoint_name_to_path(pos->name);
	518	if (ppath->next)
	519	goto next;
	520
	521	if (strchr(pos->name, ':') == NULL)
	522	goto try_id;
	523
	524	goto error;
	525	}
	526
	527	try_id:
1fc632ce	528	ppath->next = tracepoint_id_to_path(pos->core.attr.config);
7f42b950	529	if (!ppath->next) {
e7c93f09	530	error:
7f42b950	531	pr_debug("No memory to alloc tracepoints list\n");
fa99ce82	532	put_tracepoints_path(path.next);
7f42b950 NK	533	return NULL;
7f42b950 NK	534	}
e7c93f09	535	next:
1ef2ed10 FW	536	ppath = ppath->next;
	537	}
	538
e2561368	539	return nr_tracepoints > 0 ? path.next : NULL;
1ef2ed10	540	}
e2561368	541
69aad6f1	542	bool have_tracepoints(struct list_head *pattrs)
63e0c771	543	{
32dcd021	544	struct evsel *pos;
db620b1c	545
b27c4ece	546	list_for_each_entry(pos, pattrs, core.node)
1fc632ce	547	if (pos->core.attr.type == PERF_TYPE_TRACEPOINT)
db620b1c TZ	548	return true;
	549
	550	return false;
63e0c771 TZ	551	}
63e0c771 TZ	552
8755d5e2	553	static int tracing_data_header(void)
52050943	554	{
29208e57	555	char buf[20];
8755d5e2	556	ssize_t size;
52050943	557
29208e57	558	/* just guessing this is someone's birthday.. ;) */
52050943 SR	559	buf[0] = 23;
	560	buf[1] = 8;
	561	buf[2] = 68;
	562	memcpy(buf + 3, "tracing", 7);
	563
8755d5e2 NK	564	if (write(output_fd, buf, 10) != 10)
8755d5e2 NK	565	return -1;
52050943	566
8755d5e2 NK	567	size = strlen(VERSION) + 1;
	568	if (write(output_fd, VERSION, size) != size)
	569	return -1;
52050943 SR	570
52050943 SR	571	/* save endian */
5b7a29fb	572	if (host_is_bigendian())
52050943 SR	573	buf[0] = 1;
	574	else
	575	buf[0] = 0;
	576
8755d5e2 NK	577	if (write(output_fd, buf, 1) != 1)
8755d5e2 NK	578	return -1;
52050943 SR	579
	580	/* save size of long */
	581	buf[0] = sizeof(long);
8755d5e2 NK	582	if (write(output_fd, buf, 1) != 1)
8755d5e2 NK	583	return -1;
52050943 SR	584
52050943 SR	585	/* save page_size */
8755d5e2 NK	586	if (write(output_fd, &page_size, 4) != 4)
	587	return -1;
	588
	589	return 0;
29208e57 JO	590	}
	591
	592	struct tracing_data tracing_data_get(struct list_head pattrs,
	593	int fd, bool temp)
	594	{
	595	struct tracepoint_path *tps;
	596	struct tracing_data *tdata;
8755d5e2	597	int err;
29208e57 JO	598
	599	output_fd = fd;
	600
	601	tps = get_tracepoints_path(pattrs);
	602	if (!tps)
	603	return NULL;
52050943	604
5a6fd27a NK	605	tdata = malloc(sizeof(*tdata));
	606	if (!tdata)
	607	return NULL;
	608
29208e57 JO	609	tdata->temp = temp;
	610	tdata->size = 0;
	611
	612	if (temp) {
	613	int temp_fd;
	614
	615	snprintf(tdata->temp_file, sizeof(tdata->temp_file),
	616	"/tmp/perf-XXXXXX");
7f42b950 NK	617	if (!mkstemp(tdata->temp_file)) {
7f42b950 NK	618	pr_debug("Can't make temp file");
faedbf3f	619	free(tdata);
7f42b950 NK	620	return NULL;
7f42b950 NK	621	}
29208e57 JO	622
29208e57 JO	623	temp_fd = open(tdata->temp_file, O_RDWR);
7f42b950 NK	624	if (temp_fd < 0) {
7f42b950 NK	625	pr_debug("Can't read '%s'", tdata->temp_file);
faedbf3f	626	free(tdata);
7f42b950 NK	627	return NULL;
7f42b950 NK	628	}
29208e57 JO	629
	630	/*
	631	* Set the temp file the default output, so all the
	632	* tracing data are stored into it.
	633	*/
	634	output_fd = temp_fd;
	635	}
	636
8755d5e2 NK	637	err = tracing_data_header();
	638	if (err)
	639	goto out;
077f159d	640	err = record_header_files();
8755d5e2 NK	641	if (err)
8755d5e2 NK	642	goto out;
077f159d	643	err = record_ftrace_files(tps);
8755d5e2 NK	644	if (err)
8755d5e2 NK	645	goto out;
077f159d	646	err = record_event_files(tps);
8755d5e2 NK	647	if (err)
8755d5e2 NK	648	goto out;
077f159d	649	err = record_proc_kallsyms();
8755d5e2 NK	650	if (err)
8755d5e2 NK	651	goto out;
077f159d	652	err = record_ftrace_printk();
cd4ceb63 NK	653	if (err)
	654	goto out;
	655	err = record_saved_cmdline();
e2561368	656
8755d5e2	657	out:
29208e57 JO	658	/*
	659	* All tracing data are stored by now, we can restore
	660	* the default output file in case we used temp file.
	661	*/
	662	if (temp) {
	663	tdata->size = lseek(output_fd, 0, SEEK_CUR);
	664	close(output_fd);
	665	output_fd = fd;
	666	}
	667
04662523 ACM	668	if (err)
04662523 ACM	669	zfree(&tdata);
8755d5e2	670
29208e57 JO	671	put_tracepoints_path(tps);
29208e57 JO	672	return tdata;
52050943	673	}
9215545e	674
8755d5e2	675	int tracing_data_put(struct tracing_data *tdata)
9215545e	676	{
8755d5e2 NK	677	int err = 0;
8755d5e2 NK	678
29208e57	679	if (tdata->temp) {
8755d5e2	680	err = record_file(tdata->temp_file, 0);
29208e57 JO	681	unlink(tdata->temp_file);
29208e57 JO	682	}
9215545e	683
29208e57	684	free(tdata);
8755d5e2	685	return err;
29208e57	686	}
9215545e	687
29208e57 JO	688	int read_tracing_data(int fd, struct list_head *pattrs)
29208e57 JO	689	{
8755d5e2	690	int err;
29208e57	691	struct tracing_data *tdata;
9215545e	692
29208e57 JO	693	/*
	694	* We work over the real file, so we can write data
	695	* directly, no temp file is needed.
	696	*/
	697	tdata = tracing_data_get(pattrs, fd, false);
	698	if (!tdata)
	699	return -ENOMEM;
	700
8755d5e2 NK	701	err = tracing_data_put(tdata);
8755d5e2 NK	702	return err;
9215545e	703	}