1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2009, Steven Rostedt <srostedt@redhat.com> 4 */ 5 #include <dirent.h> 6 #include <stdio.h> 7 #include <stdlib.h> 8 #include <string.h> 9 #include <stdarg.h> 10 #include <sys/types.h> 11 #include <sys/stat.h> 12 #include <sys/wait.h> 13 #include <sys/mman.h> 14 #include <fcntl.h> 15 #include <unistd.h> 16 #include <errno.h> 17 18 #include "trace-event.h" 19 #include "debug.h" 20 21 static int input_fd; 22 23 static ssize_t trace_data_size; 24 static bool repipe; 25 26 static int __do_read(int fd, void *buf, int size) 27 { 28 int rsize = size; 29 30 while (size) { 31 int ret = read(fd, buf, size); 32 33 if (ret <= 0) 34 return -1; 35 36 if (repipe) { 37 int retw = write(STDOUT_FILENO, buf, ret); 38 39 if (retw <= 0 || retw != ret) { 40 pr_debug("repiping input file"); 41 return -1; 42 } 43 } 44 45 size -= ret; 46 buf += ret; 47 } 48 49 return rsize; 50 } 51 52 static int do_read(void *data, int size) 53 { 54 int r; 55 56 r = __do_read(input_fd, data, size); 57 if (r <= 0) { 58 pr_debug("reading input file (size expected=%d received=%d)", 59 size, r); 60 return -1; 61 } 62 63 trace_data_size += r; 64 65 return r; 66 } 67 68 /* If it fails, the next read will report it */ 69 static void skip(int size) 70 { 71 char buf[BUFSIZ]; 72 int r; 73 74 while (size) { 75 r = size > BUFSIZ ? BUFSIZ : size; 76 do_read(buf, r); 77 size -= r; 78 } 79 } 80 81 static unsigned int read4(struct tep_handle *pevent) 82 { 83 unsigned int data; 84 85 if (do_read(&data, 4) < 0) 86 return 0; 87 return tep_read_number(pevent, &data, 4); 88 } 89 90 static unsigned long long read8(struct tep_handle *pevent) 91 { 92 unsigned long long data; 93 94 if (do_read(&data, 8) < 0) 95 return 0; 96 return tep_read_number(pevent, &data, 8); 97 } 98 99 static char *read_string(void) 100 { 101 char buf[BUFSIZ]; 102 char *str = NULL; 103 int size = 0; 104 off_t r; 105 char c; 106 107 for (;;) { 108 r = read(input_fd, &c, 1); 109 if (r < 0) { 110 pr_debug("reading input file"); 111 goto out; 112 } 113 114 if (!r) { 115 pr_debug("no data"); 116 goto out; 117 } 118 119 if (repipe) { 120 int retw = write(STDOUT_FILENO, &c, 1); 121 122 if (retw <= 0 || retw != r) { 123 pr_debug("repiping input file string"); 124 goto out; 125 } 126 } 127 128 buf[size++] = c; 129 130 if (!c) 131 break; 132 } 133 134 trace_data_size += size; 135 136 str = malloc(size); 137 if (str) 138 memcpy(str, buf, size); 139 out: 140 return str; 141 } 142 143 static int read_proc_kallsyms(struct tep_handle *pevent) 144 { 145 unsigned int size; 146 147 size = read4(pevent); 148 if (!size) 149 return 0; 150 /* 151 * Just skip it, now that we configure libtraceevent to use the 152 * tools/perf/ symbol resolver. 153 * 154 * We need to skip it so that we can continue parsing old perf.data 155 * files, that contains this /proc/kallsyms payload. 156 * 157 * Newer perf.data files will have just the 4-bytes zeros "kallsyms 158 * payload", so that older tools can continue reading it and interpret 159 * it as "no kallsyms payload is present". 160 */ 161 lseek(input_fd, size, SEEK_CUR); 162 trace_data_size += size; 163 return 0; 164 } 165 166 static int read_ftrace_printk(struct tep_handle *pevent) 167 { 168 unsigned int size; 169 char *buf; 170 171 /* it can have 0 size */ 172 size = read4(pevent); 173 if (!size) 174 return 0; 175 176 buf = malloc(size + 1); 177 if (buf == NULL) 178 return -1; 179 180 if (do_read(buf, size) < 0) { 181 free(buf); 182 return -1; 183 } 184 185 buf[size] = '\0'; 186 187 parse_ftrace_printk(pevent, buf, size); 188 189 free(buf); 190 return 0; 191 } 192 193 static int read_header_files(struct tep_handle *pevent) 194 { 195 unsigned long long size; 196 char *header_page; 197 char buf[BUFSIZ]; 198 int ret = 0; 199 200 if (do_read(buf, 12) < 0) 201 return -1; 202 203 if (memcmp(buf, "header_page", 12) != 0) { 204 pr_debug("did not read header page"); 205 return -1; 206 } 207 208 size = read8(pevent); 209 210 header_page = malloc(size); 211 if (header_page == NULL) 212 return -1; 213 214 if (do_read(header_page, size) < 0) { 215 pr_debug("did not read header page"); 216 free(header_page); 217 return -1; 218 } 219 220 if (!tep_parse_header_page(pevent, header_page, size, 221 tep_get_long_size(pevent))) { 222 /* 223 * The commit field in the page is of type long, 224 * use that instead, since it represents the kernel. 225 */ 226 tep_set_long_size(pevent, tep_get_header_page_size(pevent)); 227 } 228 free(header_page); 229 230 if (do_read(buf, 13) < 0) 231 return -1; 232 233 if (memcmp(buf, "header_event", 13) != 0) { 234 pr_debug("did not read header event"); 235 return -1; 236 } 237 238 size = read8(pevent); 239 skip(size); 240 241 return ret; 242 } 243 244 static int read_ftrace_file(struct tep_handle *pevent, unsigned long long size) 245 { 246 int ret; 247 char *buf; 248 249 buf = malloc(size); 250 if (buf == NULL) { 251 pr_debug("memory allocation failure\n"); 252 return -1; 253 } 254 255 ret = do_read(buf, size); 256 if (ret < 0) { 257 pr_debug("error reading ftrace file.\n"); 258 goto out; 259 } 260 261 ret = parse_ftrace_file(pevent, buf, size); 262 if (ret < 0) 263 pr_debug("error parsing ftrace file.\n"); 264 out: 265 free(buf); 266 return ret; 267 } 268 269 static int read_event_file(struct tep_handle *pevent, char *sys, 270 unsigned long long size) 271 { 272 int ret; 273 char *buf; 274 275 buf = malloc(size); 276 if (buf == NULL) { 277 pr_debug("memory allocation failure\n"); 278 return -1; 279 } 280 281 ret = do_read(buf, size); 282 if (ret < 0) 283 goto out; 284 285 ret = parse_event_file(pevent, buf, size, sys); 286 if (ret < 0) 287 pr_debug("error parsing event file.\n"); 288 out: 289 free(buf); 290 return ret; 291 } 292 293 static int read_ftrace_files(struct tep_handle *pevent) 294 { 295 unsigned long long size; 296 int count; 297 int i; 298 int ret; 299 300 count = read4(pevent); 301 302 for (i = 0; i < count; i++) { 303 size = read8(pevent); 304 ret = read_ftrace_file(pevent, size); 305 if (ret) 306 return ret; 307 } 308 return 0; 309 } 310 311 static int read_event_files(struct tep_handle *pevent) 312 { 313 unsigned long long size; 314 char *sys; 315 int systems; 316 int count; 317 int i,x; 318 int ret; 319 320 systems = read4(pevent); 321 322 for (i = 0; i < systems; i++) { 323 sys = read_string(); 324 if (sys == NULL) 325 return -1; 326 327 count = read4(pevent); 328 329 for (x=0; x < count; x++) { 330 size = read8(pevent); 331 ret = read_event_file(pevent, sys, size); 332 if (ret) { 333 free(sys); 334 return ret; 335 } 336 } 337 free(sys); 338 } 339 return 0; 340 } 341 342 static int read_saved_cmdline(struct tep_handle *pevent) 343 { 344 unsigned long long size; 345 char *buf; 346 int ret; 347 348 /* it can have 0 size */ 349 size = read8(pevent); 350 if (!size) 351 return 0; 352 353 buf = malloc(size + 1); 354 if (buf == NULL) { 355 pr_debug("memory allocation failure\n"); 356 return -1; 357 } 358 359 ret = do_read(buf, size); 360 if (ret < 0) { 361 pr_debug("error reading saved cmdlines\n"); 362 goto out; 363 } 364 buf[ret] = '\0'; 365 366 parse_saved_cmdline(pevent, buf, size); 367 ret = 0; 368 out: 369 free(buf); 370 return ret; 371 } 372 373 ssize_t trace_report(int fd, struct trace_event *tevent, bool __repipe) 374 { 375 char buf[BUFSIZ]; 376 char test[] = { 23, 8, 68 }; 377 char *version; 378 int show_version = 0; 379 int show_funcs = 0; 380 int show_printk = 0; 381 ssize_t size = -1; 382 int file_bigendian; 383 int host_bigendian; 384 int file_long_size; 385 int file_page_size; 386 struct tep_handle *pevent = NULL; 387 int err; 388 389 repipe = __repipe; 390 input_fd = fd; 391 392 if (do_read(buf, 3) < 0) 393 return -1; 394 if (memcmp(buf, test, 3) != 0) { 395 pr_debug("no trace data in the file"); 396 return -1; 397 } 398 399 if (do_read(buf, 7) < 0) 400 return -1; 401 if (memcmp(buf, "tracing", 7) != 0) { 402 pr_debug("not a trace file (missing 'tracing' tag)"); 403 return -1; 404 } 405 406 version = read_string(); 407 if (version == NULL) 408 return -1; 409 if (show_version) 410 printf("version = %s\n", version); 411 412 if (do_read(buf, 1) < 0) { 413 free(version); 414 return -1; 415 } 416 file_bigendian = buf[0]; 417 host_bigendian = bigendian(); 418 419 if (trace_event__init(tevent)) { 420 pr_debug("trace_event__init failed"); 421 goto out; 422 } 423 424 pevent = tevent->pevent; 425 426 tep_set_flag(pevent, TEP_NSEC_OUTPUT); 427 tep_set_file_bigendian(pevent, file_bigendian); 428 tep_set_local_bigendian(pevent, host_bigendian); 429 430 if (do_read(buf, 1) < 0) 431 goto out; 432 file_long_size = buf[0]; 433 434 file_page_size = read4(pevent); 435 if (!file_page_size) 436 goto out; 437 438 tep_set_long_size(pevent, file_long_size); 439 tep_set_page_size(pevent, file_page_size); 440 441 err = read_header_files(pevent); 442 if (err) 443 goto out; 444 err = read_ftrace_files(pevent); 445 if (err) 446 goto out; 447 err = read_event_files(pevent); 448 if (err) 449 goto out; 450 err = read_proc_kallsyms(pevent); 451 if (err) 452 goto out; 453 err = read_ftrace_printk(pevent); 454 if (err) 455 goto out; 456 if (atof(version) >= 0.6) { 457 err = read_saved_cmdline(pevent); 458 if (err) 459 goto out; 460 } 461 462 size = trace_data_size; 463 repipe = false; 464 465 if (show_funcs) { 466 tep_print_funcs(pevent); 467 } else if (show_printk) { 468 tep_print_printk(pevent); 469 } 470 471 pevent = NULL; 472 473 out: 474 if (pevent) 475 trace_event__cleanup(tevent); 476 free(version); 477 return size; 478 } 479