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 static struct tracepoint_path *tracepoint_name_to_path(const char *name)
470 {
471 	struct tracepoint_path *path = zalloc(sizeof(*path));
472 	char *str = strchr(name, ':');
473 
474 	if (path == NULL || str == NULL) {
475 		free(path);
476 		return NULL;
477 	}
478 
479 	path->system = strndup(name, str - name);
480 	path->name = strdup(str+1);
481 
482 	if (path->system == NULL || path->name == NULL) {
483 		zfree(&path->system);
484 		zfree(&path->name);
485 		zfree(&path);
486 	}
487 
488 	return path;
489 }
490 
491 static struct tracepoint_path *
492 get_tracepoints_path(struct list_head *pattrs)
493 {
494 	struct tracepoint_path path, *ppath = &path;
495 	struct evsel *pos;
496 	int nr_tracepoints = 0;
497 
498 	list_for_each_entry(pos, pattrs, core.node) {
499 		if (pos->core.attr.type != PERF_TYPE_TRACEPOINT)
500 			continue;
501 		++nr_tracepoints;
502 
503 		if (pos->name) {
504 			ppath->next = tracepoint_name_to_path(pos->name);
505 			if (ppath->next)
506 				goto next;
507 
508 			if (strchr(pos->name, ':') == NULL)
509 				goto try_id;
510 
511 			goto error;
512 		}
513 
514 try_id:
515 		ppath->next = tracepoint_id_to_path(pos->core.attr.config);
516 		if (!ppath->next) {
517 error:
518 			pr_debug("No memory to alloc tracepoints list\n");
519 			put_tracepoints_path(path.next);
520 			return NULL;
521 		}
522 next:
523 		ppath = ppath->next;
524 	}
525 
526 	return nr_tracepoints > 0 ? path.next : NULL;
527 }
528 
529 bool have_tracepoints(struct list_head *pattrs)
530 {
531 	struct evsel *pos;
532 
533 	list_for_each_entry(pos, pattrs, core.node)
534 		if (pos->core.attr.type == PERF_TYPE_TRACEPOINT)
535 			return true;
536 
537 	return false;
538 }
539 
540 static int tracing_data_header(void)
541 {
542 	char buf[20];
543 	ssize_t size;
544 
545 	/* just guessing this is someone's birthday.. ;) */
546 	buf[0] = 23;
547 	buf[1] = 8;
548 	buf[2] = 68;
549 	memcpy(buf + 3, "tracing", 7);
550 
551 	if (write(output_fd, buf, 10) != 10)
552 		return -1;
553 
554 	size = strlen(VERSION) + 1;
555 	if (write(output_fd, VERSION, size) != size)
556 		return -1;
557 
558 	/* save endian */
559 	if (host_is_bigendian())
560 		buf[0] = 1;
561 	else
562 		buf[0] = 0;
563 
564 	if (write(output_fd, buf, 1) != 1)
565 		return -1;
566 
567 	/* save size of long */
568 	buf[0] = sizeof(long);
569 	if (write(output_fd, buf, 1) != 1)
570 		return -1;
571 
572 	/* save page_size */
573 	if (write(output_fd, &page_size, 4) != 4)
574 		return -1;
575 
576 	return 0;
577 }
578 
579 struct tracing_data *tracing_data_get(struct list_head *pattrs,
580 				      int fd, bool temp)
581 {
582 	struct tracepoint_path *tps;
583 	struct tracing_data *tdata;
584 	int err;
585 
586 	output_fd = fd;
587 
588 	tps = get_tracepoints_path(pattrs);
589 	if (!tps)
590 		return NULL;
591 
592 	tdata = malloc(sizeof(*tdata));
593 	if (!tdata)
594 		return NULL;
595 
596 	tdata->temp = temp;
597 	tdata->size = 0;
598 
599 	if (temp) {
600 		int temp_fd;
601 
602 		snprintf(tdata->temp_file, sizeof(tdata->temp_file),
603 			 "/tmp/perf-XXXXXX");
604 		if (!mkstemp(tdata->temp_file)) {
605 			pr_debug("Can't make temp file");
606 			free(tdata);
607 			return NULL;
608 		}
609 
610 		temp_fd = open(tdata->temp_file, O_RDWR);
611 		if (temp_fd < 0) {
612 			pr_debug("Can't read '%s'", tdata->temp_file);
613 			free(tdata);
614 			return NULL;
615 		}
616 
617 		/*
618 		 * Set the temp file the default output, so all the
619 		 * tracing data are stored into it.
620 		 */
621 		output_fd = temp_fd;
622 	}
623 
624 	err = tracing_data_header();
625 	if (err)
626 		goto out;
627 	err = record_header_files();
628 	if (err)
629 		goto out;
630 	err = record_ftrace_files(tps);
631 	if (err)
632 		goto out;
633 	err = record_event_files(tps);
634 	if (err)
635 		goto out;
636 	err = record_proc_kallsyms();
637 	if (err)
638 		goto out;
639 	err = record_ftrace_printk();
640 	if (err)
641 		goto out;
642 	err = record_saved_cmdline();
643 
644 out:
645 	/*
646 	 * All tracing data are stored by now, we can restore
647 	 * the default output file in case we used temp file.
648 	 */
649 	if (temp) {
650 		tdata->size = lseek(output_fd, 0, SEEK_CUR);
651 		close(output_fd);
652 		output_fd = fd;
653 	}
654 
655 	if (err)
656 		zfree(&tdata);
657 
658 	put_tracepoints_path(tps);
659 	return tdata;
660 }
661 
662 int tracing_data_put(struct tracing_data *tdata)
663 {
664 	int err = 0;
665 
666 	if (tdata->temp) {
667 		err = record_file(tdata->temp_file, 0);
668 		unlink(tdata->temp_file);
669 	}
670 
671 	free(tdata);
672 	return err;
673 }
674 
675 int read_tracing_data(int fd, struct list_head *pattrs)
676 {
677 	int err;
678 	struct tracing_data *tdata;
679 
680 	/*
681 	 * We work over the real file, so we can write data
682 	 * directly, no temp file is needed.
683 	 */
684 	tdata = tracing_data_get(pattrs, fd, false);
685 	if (!tdata)
686 		return -ENOMEM;
687 
688 	err = tracing_data_put(tdata);
689 	return err;
690 }
691