1 // SPDX-License-Identifier: GPL-2.0 2 #define _GNU_SOURCE 3 #include <sys/sendfile.h> 4 #include <tracefs.h> 5 #include <signal.h> 6 #include <stdlib.h> 7 #include <unistd.h> 8 #include <errno.h> 9 10 #include "trace.h" 11 #include "utils.h" 12 13 /* 14 * enable_tracer_by_name - enable a tracer on the given instance 15 */ 16 int enable_tracer_by_name(struct tracefs_instance *inst, const char *tracer_name) 17 { 18 enum tracefs_tracers tracer; 19 int retval; 20 21 tracer = TRACEFS_TRACER_CUSTOM; 22 23 debug_msg("Enabling %s tracer\n", tracer_name); 24 25 retval = tracefs_tracer_set(inst, tracer, tracer_name); 26 if (retval < 0) { 27 if (errno == ENODEV) 28 err_msg("Tracer %s not found!\n", tracer_name); 29 30 err_msg("Failed to enable the %s tracer\n", tracer_name); 31 return -1; 32 } 33 34 return 0; 35 } 36 37 /* 38 * disable_tracer - set nop tracer to the insta 39 */ 40 void disable_tracer(struct tracefs_instance *inst) 41 { 42 enum tracefs_tracers t = TRACEFS_TRACER_NOP; 43 int retval; 44 45 retval = tracefs_tracer_set(inst, t); 46 if (retval < 0) 47 err_msg("Oops, error disabling tracer\n"); 48 } 49 50 /* 51 * create_instance - create a trace instance with *instance_name 52 */ 53 struct tracefs_instance *create_instance(char *instance_name) 54 { 55 return tracefs_instance_create(instance_name); 56 } 57 58 /* 59 * destroy_instance - remove a trace instance and free the data 60 */ 61 void destroy_instance(struct tracefs_instance *inst) 62 { 63 tracefs_instance_destroy(inst); 64 tracefs_instance_free(inst); 65 } 66 67 /* 68 * save_trace_to_file - save the trace output of the instance to the file 69 */ 70 int save_trace_to_file(struct tracefs_instance *inst, const char *filename) 71 { 72 const char *file = "trace"; 73 mode_t mode = 0644; 74 char buffer[4096]; 75 int out_fd, in_fd; 76 int retval = -1; 77 78 in_fd = tracefs_instance_file_open(inst, file, O_RDONLY); 79 if (in_fd < 0) { 80 err_msg("Failed to open trace file\n"); 81 return -1; 82 } 83 84 out_fd = creat(filename, mode); 85 if (out_fd < 0) { 86 err_msg("Failed to create output file %s\n", filename); 87 goto out_close_in; 88 } 89 90 do { 91 retval = read(in_fd, buffer, sizeof(buffer)); 92 if (retval <= 0) 93 goto out_close; 94 95 retval = write(out_fd, buffer, retval); 96 if (retval < 0) 97 goto out_close; 98 } while (retval > 0); 99 100 retval = 0; 101 out_close: 102 close(out_fd); 103 out_close_in: 104 close(in_fd); 105 return retval; 106 } 107 108 /* 109 * collect_registered_events - call the existing callback function for the event 110 * 111 * If an event has a registered callback function, call it. 112 * Otherwise, ignore the event. 113 */ 114 int 115 collect_registered_events(struct tep_event *event, struct tep_record *record, 116 int cpu, void *context) 117 { 118 struct trace_instance *trace = context; 119 struct trace_seq *s = trace->seq; 120 121 trace->processed_events++; 122 123 if (!event->handler) 124 return 0; 125 126 event->handler(s, record, event, context); 127 128 return 0; 129 } 130 131 /* 132 * collect_missed_events - record number of missed events 133 * 134 * If rtla cannot keep up with events generated by tracer, events are going 135 * to fall out of the ring buffer. 136 * Collect how many events were missed so it can be reported to the user. 137 */ 138 static int 139 collect_missed_events(struct tep_event *event, struct tep_record *record, 140 int cpu, void *context) 141 { 142 struct trace_instance *trace = context; 143 144 if (trace->missed_events == UINT64_MAX) 145 return 0; 146 147 if (record->missed_events > 0) 148 trace->missed_events += record->missed_events; 149 else 150 /* Events missed but no data on how many */ 151 trace->missed_events = UINT64_MAX; 152 153 return 0; 154 } 155 156 /* 157 * trace_instance_destroy - destroy and free a rtla trace instance 158 */ 159 void trace_instance_destroy(struct trace_instance *trace) 160 { 161 if (trace->inst) { 162 disable_tracer(trace->inst); 163 destroy_instance(trace->inst); 164 trace->inst = NULL; 165 } 166 167 if (trace->seq) { 168 free(trace->seq); 169 trace->seq = NULL; 170 } 171 172 if (trace->tep) { 173 tep_free(trace->tep); 174 trace->tep = NULL; 175 } 176 } 177 178 /* 179 * trace_instance_init - create an rtla trace instance 180 * 181 * It is more than the tracefs instance, as it contains other 182 * things required for the tracing, such as the local events and 183 * a seq file. 184 * 185 * Note that the trace instance is returned disabled. This allows 186 * the tool to apply some other configs, like setting priority 187 * to the kernel threads, before starting generating trace entries. 188 */ 189 int trace_instance_init(struct trace_instance *trace, char *tool_name) 190 { 191 trace->seq = calloc(1, sizeof(*trace->seq)); 192 if (!trace->seq) 193 goto out_err; 194 195 trace_seq_init(trace->seq); 196 197 trace->inst = create_instance(tool_name); 198 if (!trace->inst) 199 goto out_err; 200 201 trace->tep = tracefs_local_events(NULL); 202 if (!trace->tep) 203 goto out_err; 204 205 /* 206 * Let the main enable the record after setting some other 207 * things such as the priority of the tracer's threads. 208 */ 209 tracefs_trace_off(trace->inst); 210 211 /* 212 * Collect the number of events missed due to tracefs buffer 213 * overflow. 214 */ 215 trace->missed_events = 0; 216 tracefs_follow_missed_events(trace->inst, 217 collect_missed_events, 218 trace); 219 220 trace->processed_events = 0; 221 222 return 0; 223 224 out_err: 225 trace_instance_destroy(trace); 226 return 1; 227 } 228 229 /* 230 * trace_instance_start - start tracing a given rtla instance 231 */ 232 int trace_instance_start(struct trace_instance *trace) 233 { 234 return tracefs_trace_on(trace->inst); 235 } 236 237 /* 238 * trace_instance_stop - stop tracing a given rtla instance 239 */ 240 int trace_instance_stop(struct trace_instance *trace) 241 { 242 return tracefs_trace_off(trace->inst); 243 } 244 245 /* 246 * trace_events_free - free a list of trace events 247 */ 248 static void trace_events_free(struct trace_events *events) 249 { 250 struct trace_events *tevent = events; 251 struct trace_events *free_event; 252 253 while (tevent) { 254 free_event = tevent; 255 256 tevent = tevent->next; 257 258 if (free_event->filter) 259 free(free_event->filter); 260 if (free_event->trigger) 261 free(free_event->trigger); 262 free(free_event->system); 263 free(free_event); 264 } 265 } 266 267 /* 268 * trace_event_alloc - alloc and parse a single trace event 269 */ 270 struct trace_events *trace_event_alloc(const char *event_string) 271 { 272 struct trace_events *tevent; 273 274 tevent = calloc(1, sizeof(*tevent)); 275 if (!tevent) 276 return NULL; 277 278 tevent->system = strdup(event_string); 279 if (!tevent->system) { 280 free(tevent); 281 return NULL; 282 } 283 284 tevent->event = strstr(tevent->system, ":"); 285 if (tevent->event) { 286 *tevent->event = '\0'; 287 tevent->event = &tevent->event[1]; 288 } 289 290 return tevent; 291 } 292 293 /* 294 * trace_event_add_filter - record an event filter 295 */ 296 int trace_event_add_filter(struct trace_events *event, char *filter) 297 { 298 if (event->filter) 299 free(event->filter); 300 301 event->filter = strdup(filter); 302 if (!event->filter) 303 return 1; 304 305 return 0; 306 } 307 308 /* 309 * trace_event_add_trigger - record an event trigger action 310 */ 311 int trace_event_add_trigger(struct trace_events *event, char *trigger) 312 { 313 if (event->trigger) 314 free(event->trigger); 315 316 event->trigger = strdup(trigger); 317 if (!event->trigger) 318 return 1; 319 320 return 0; 321 } 322 323 /* 324 * trace_event_disable_filter - disable an event filter 325 */ 326 static void trace_event_disable_filter(struct trace_instance *instance, 327 struct trace_events *tevent) 328 { 329 char filter[1024]; 330 int retval; 331 332 if (!tevent->filter) 333 return; 334 335 if (!tevent->filter_enabled) 336 return; 337 338 debug_msg("Disabling %s:%s filter %s\n", tevent->system, 339 tevent->event ? : "*", tevent->filter); 340 341 snprintf(filter, 1024, "!%s\n", tevent->filter); 342 343 retval = tracefs_event_file_write(instance->inst, tevent->system, 344 tevent->event, "filter", filter); 345 if (retval < 0) 346 err_msg("Error disabling %s:%s filter %s\n", tevent->system, 347 tevent->event ? : "*", tevent->filter); 348 } 349 350 /* 351 * trace_event_save_hist - save the content of an event hist 352 * 353 * If the trigger is a hist: one, save the content of the hist file. 354 */ 355 static void trace_event_save_hist(struct trace_instance *instance, 356 struct trace_events *tevent) 357 { 358 int retval, index, out_fd; 359 mode_t mode = 0644; 360 char path[1024]; 361 char *hist; 362 363 if (!tevent) 364 return; 365 366 /* trigger enables hist */ 367 if (!tevent->trigger) 368 return; 369 370 /* is this a hist: trigger? */ 371 retval = strncmp(tevent->trigger, "hist:", strlen("hist:")); 372 if (retval) 373 return; 374 375 snprintf(path, 1024, "%s_%s_hist.txt", tevent->system, tevent->event); 376 377 printf(" Saving event %s:%s hist to %s\n", tevent->system, tevent->event, path); 378 379 out_fd = creat(path, mode); 380 if (out_fd < 0) { 381 err_msg(" Failed to create %s output file\n", path); 382 return; 383 } 384 385 hist = tracefs_event_file_read(instance->inst, tevent->system, tevent->event, "hist", 0); 386 if (!hist) { 387 err_msg(" Failed to read %s:%s hist file\n", tevent->system, tevent->event); 388 goto out_close; 389 } 390 391 index = 0; 392 do { 393 index += write(out_fd, &hist[index], strlen(hist) - index); 394 } while (index < strlen(hist)); 395 396 free(hist); 397 out_close: 398 close(out_fd); 399 } 400 401 /* 402 * trace_event_disable_trigger - disable an event trigger 403 */ 404 static void trace_event_disable_trigger(struct trace_instance *instance, 405 struct trace_events *tevent) 406 { 407 char trigger[1024]; 408 int retval; 409 410 if (!tevent->trigger) 411 return; 412 413 if (!tevent->trigger_enabled) 414 return; 415 416 debug_msg("Disabling %s:%s trigger %s\n", tevent->system, 417 tevent->event ? : "*", tevent->trigger); 418 419 trace_event_save_hist(instance, tevent); 420 421 snprintf(trigger, 1024, "!%s\n", tevent->trigger); 422 423 retval = tracefs_event_file_write(instance->inst, tevent->system, 424 tevent->event, "trigger", trigger); 425 if (retval < 0) 426 err_msg("Error disabling %s:%s trigger %s\n", tevent->system, 427 tevent->event ? : "*", tevent->trigger); 428 } 429 430 /* 431 * trace_events_disable - disable all trace events 432 */ 433 void trace_events_disable(struct trace_instance *instance, 434 struct trace_events *events) 435 { 436 struct trace_events *tevent = events; 437 438 if (!events) 439 return; 440 441 while (tevent) { 442 debug_msg("Disabling event %s:%s\n", tevent->system, tevent->event ? : "*"); 443 if (tevent->enabled) { 444 trace_event_disable_filter(instance, tevent); 445 trace_event_disable_trigger(instance, tevent); 446 tracefs_event_disable(instance->inst, tevent->system, tevent->event); 447 } 448 449 tevent->enabled = 0; 450 tevent = tevent->next; 451 } 452 } 453 454 /* 455 * trace_event_enable_filter - enable an event filter associated with an event 456 */ 457 static int trace_event_enable_filter(struct trace_instance *instance, 458 struct trace_events *tevent) 459 { 460 char filter[1024]; 461 int retval; 462 463 if (!tevent->filter) 464 return 0; 465 466 if (!tevent->event) { 467 err_msg("Filter %s applies only for single events, not for all %s:* events\n", 468 tevent->filter, tevent->system); 469 return 1; 470 } 471 472 snprintf(filter, 1024, "%s\n", tevent->filter); 473 474 debug_msg("Enabling %s:%s filter %s\n", tevent->system, 475 tevent->event ? : "*", tevent->filter); 476 477 retval = tracefs_event_file_write(instance->inst, tevent->system, 478 tevent->event, "filter", filter); 479 if (retval < 0) { 480 err_msg("Error enabling %s:%s filter %s\n", tevent->system, 481 tevent->event ? : "*", tevent->filter); 482 return 1; 483 } 484 485 tevent->filter_enabled = 1; 486 return 0; 487 } 488 489 /* 490 * trace_event_enable_trigger - enable an event trigger associated with an event 491 */ 492 static int trace_event_enable_trigger(struct trace_instance *instance, 493 struct trace_events *tevent) 494 { 495 char trigger[1024]; 496 int retval; 497 498 if (!tevent->trigger) 499 return 0; 500 501 if (!tevent->event) { 502 err_msg("Trigger %s applies only for single events, not for all %s:* events\n", 503 tevent->trigger, tevent->system); 504 return 1; 505 } 506 507 snprintf(trigger, 1024, "%s\n", tevent->trigger); 508 509 debug_msg("Enabling %s:%s trigger %s\n", tevent->system, 510 tevent->event ? : "*", tevent->trigger); 511 512 retval = tracefs_event_file_write(instance->inst, tevent->system, 513 tevent->event, "trigger", trigger); 514 if (retval < 0) { 515 err_msg("Error enabling %s:%s trigger %s\n", tevent->system, 516 tevent->event ? : "*", tevent->trigger); 517 return 1; 518 } 519 520 tevent->trigger_enabled = 1; 521 522 return 0; 523 } 524 525 /* 526 * trace_events_enable - enable all events 527 */ 528 int trace_events_enable(struct trace_instance *instance, 529 struct trace_events *events) 530 { 531 struct trace_events *tevent = events; 532 int retval; 533 534 while (tevent) { 535 debug_msg("Enabling event %s:%s\n", tevent->system, tevent->event ? : "*"); 536 retval = tracefs_event_enable(instance->inst, tevent->system, tevent->event); 537 if (retval < 0) { 538 err_msg("Error enabling event %s:%s\n", tevent->system, 539 tevent->event ? : "*"); 540 return 1; 541 } 542 543 retval = trace_event_enable_filter(instance, tevent); 544 if (retval) 545 return 1; 546 547 retval = trace_event_enable_trigger(instance, tevent); 548 if (retval) 549 return 1; 550 551 tevent->enabled = 1; 552 tevent = tevent->next; 553 } 554 555 return 0; 556 } 557 558 /* 559 * trace_events_destroy - disable and free all trace events 560 */ 561 void trace_events_destroy(struct trace_instance *instance, 562 struct trace_events *events) 563 { 564 if (!events) 565 return; 566 567 trace_events_disable(instance, events); 568 trace_events_free(events); 569 } 570 571 /* 572 * trace_set_buffer_size - set the per-cpu tracing buffer size. 573 */ 574 int trace_set_buffer_size(struct trace_instance *trace, int size) 575 { 576 int retval; 577 578 debug_msg("Setting trace buffer size to %d Kb\n", size); 579 retval = tracefs_instance_set_buffer_size(trace->inst, size, -1); 580 if (retval) 581 err_msg("Error setting trace buffer size\n"); 582 583 return retval; 584 } 585