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