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 
23 #include "trace-event.h"
24 #include <api/fs/tracing_path.h>
25 #include "evsel.h"
26 #include "debug.h"
27 
28 #define VERSION "0.6"
29 
30 static int output_fd;
31 
32 
33 int bigendian(void)
34 {
35 	unsigned char str[] = { 0x1, 0x2, 0x3, 0x4, 0x0, 0x0, 0x0, 0x0};
36 	unsigned int *ptr;
37 
38 	ptr = (unsigned int *)(void *)str;
39 	return *ptr == 0x01020304;
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 (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 *
404 get_tracepoints_path(struct list_head *pattrs)
405 {
406 	struct tracepoint_path path, *ppath = &path;
407 	struct evsel *pos;
408 	int nr_tracepoints = 0;
409 
410 	list_for_each_entry(pos, pattrs, core.node) {
411 		if (pos->core.attr.type != PERF_TYPE_TRACEPOINT)
412 			continue;
413 		++nr_tracepoints;
414 
415 		if (pos->name) {
416 			ppath->next = tracepoint_name_to_path(pos->name);
417 			if (ppath->next)
418 				goto next;
419 
420 			if (strchr(pos->name, ':') == NULL)
421 				goto try_id;
422 
423 			goto error;
424 		}
425 
426 try_id:
427 		ppath->next = tracepoint_id_to_path(pos->core.attr.config);
428 		if (!ppath->next) {
429 error:
430 			pr_debug("No memory to alloc tracepoints list\n");
431 			put_tracepoints_path(path.next);
432 			return NULL;
433 		}
434 next:
435 		ppath = ppath->next;
436 	}
437 
438 	return nr_tracepoints > 0 ? path.next : NULL;
439 }
440 
441 bool have_tracepoints(struct list_head *pattrs)
442 {
443 	struct evsel *pos;
444 
445 	list_for_each_entry(pos, pattrs, core.node)
446 		if (pos->core.attr.type == PERF_TYPE_TRACEPOINT)
447 			return true;
448 
449 	return false;
450 }
451 
452 static int tracing_data_header(void)
453 {
454 	char buf[20];
455 	ssize_t size;
456 
457 	/* just guessing this is someone's birthday.. ;) */
458 	buf[0] = 23;
459 	buf[1] = 8;
460 	buf[2] = 68;
461 	memcpy(buf + 3, "tracing", 7);
462 
463 	if (write(output_fd, buf, 10) != 10)
464 		return -1;
465 
466 	size = strlen(VERSION) + 1;
467 	if (write(output_fd, VERSION, size) != size)
468 		return -1;
469 
470 	/* save endian */
471 	if (bigendian())
472 		buf[0] = 1;
473 	else
474 		buf[0] = 0;
475 
476 	if (write(output_fd, buf, 1) != 1)
477 		return -1;
478 
479 	/* save size of long */
480 	buf[0] = sizeof(long);
481 	if (write(output_fd, buf, 1) != 1)
482 		return -1;
483 
484 	/* save page_size */
485 	if (write(output_fd, &page_size, 4) != 4)
486 		return -1;
487 
488 	return 0;
489 }
490 
491 struct tracing_data *tracing_data_get(struct list_head *pattrs,
492 				      int fd, bool temp)
493 {
494 	struct tracepoint_path *tps;
495 	struct tracing_data *tdata;
496 	int err;
497 
498 	output_fd = fd;
499 
500 	tps = get_tracepoints_path(pattrs);
501 	if (!tps)
502 		return NULL;
503 
504 	tdata = malloc(sizeof(*tdata));
505 	if (!tdata)
506 		return NULL;
507 
508 	tdata->temp = temp;
509 	tdata->size = 0;
510 
511 	if (temp) {
512 		int temp_fd;
513 
514 		snprintf(tdata->temp_file, sizeof(tdata->temp_file),
515 			 "/tmp/perf-XXXXXX");
516 		if (!mkstemp(tdata->temp_file)) {
517 			pr_debug("Can't make temp file");
518 			free(tdata);
519 			return NULL;
520 		}
521 
522 		temp_fd = open(tdata->temp_file, O_RDWR);
523 		if (temp_fd < 0) {
524 			pr_debug("Can't read '%s'", tdata->temp_file);
525 			free(tdata);
526 			return NULL;
527 		}
528 
529 		/*
530 		 * Set the temp file the default output, so all the
531 		 * tracing data are stored into it.
532 		 */
533 		output_fd = temp_fd;
534 	}
535 
536 	err = tracing_data_header();
537 	if (err)
538 		goto out;
539 	err = record_header_files();
540 	if (err)
541 		goto out;
542 	err = record_ftrace_files(tps);
543 	if (err)
544 		goto out;
545 	err = record_event_files(tps);
546 	if (err)
547 		goto out;
548 	err = record_proc_kallsyms();
549 	if (err)
550 		goto out;
551 	err = record_ftrace_printk();
552 	if (err)
553 		goto out;
554 	err = record_saved_cmdline();
555 
556 out:
557 	/*
558 	 * All tracing data are stored by now, we can restore
559 	 * the default output file in case we used temp file.
560 	 */
561 	if (temp) {
562 		tdata->size = lseek(output_fd, 0, SEEK_CUR);
563 		close(output_fd);
564 		output_fd = fd;
565 	}
566 
567 	if (err)
568 		zfree(&tdata);
569 
570 	put_tracepoints_path(tps);
571 	return tdata;
572 }
573 
574 int tracing_data_put(struct tracing_data *tdata)
575 {
576 	int err = 0;
577 
578 	if (tdata->temp) {
579 		err = record_file(tdata->temp_file, 0);
580 		unlink(tdata->temp_file);
581 	}
582 
583 	free(tdata);
584 	return err;
585 }
586 
587 int read_tracing_data(int fd, struct list_head *pattrs)
588 {
589 	int err;
590 	struct tracing_data *tdata;
591 
592 	/*
593 	 * We work over the real file, so we can write data
594 	 * directly, no temp file is needed.
595 	 */
596 	tdata = tracing_data_get(pattrs, fd, false);
597 	if (!tdata)
598 		return -ENOMEM;
599 
600 	err = tracing_data_put(tdata);
601 	return err;
602 }
603