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 
34 static int output_fd;
35 
36 struct 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 */
43 static 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;
83 out:
84 	close(fd);
85 	return err;
86 }
87 
88 static 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;
139 out:
140 	put_events_file(path);
141 	return err;
142 }
143 
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 
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 
161 static 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;
219 out:
220 	closedir(dir);
221 	return err;
222 }
223 
224 static 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 
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 
253 static 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;
315 out:
316 	closedir(dir);
317 	put_tracing_file(path);
318 
319 	return err;
320 }
321 
322 static 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 
334 static 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 
357 out:
358 	put_tracing_file(path);
359 	return err;
360 }
361 
362 static 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 
385 out:
386 	put_tracing_file(path);
387 	return err;
388 }
389 
390 static void
391 put_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 
403 static 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);
461 next:
462 		put_events_file(dir_path);
463 	}
464 
465 	closedir(sys_dir);
466 	return NULL;
467 }
468 
469 char *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 
481 static 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 
503 static struct tracepoint_path *
504 get_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 
526 try_id:
527 		ppath->next = tracepoint_id_to_path(pos->core.attr.config);
528 		if (!ppath->next) {
529 error:
530 			pr_debug("No memory to alloc tracepoints list\n");
531 			put_tracepoints_path(path.next);
532 			return NULL;
533 		}
534 next:
535 		ppath = ppath->next;
536 	}
537 
538 	return nr_tracepoints > 0 ? path.next : NULL;
539 }
540 
541 bool 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 
552 static 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 
591 struct 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 
656 out:
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 
674 int 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 
687 int 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