tools/tracing/rtla/src/trace.c

   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         if (!event->handler)
 122                 return 0;
 123
 124         event->handler(s, record, event, context);
 125
 126         return 0;
 127 }
 128
 129 /*
 130  * trace_instance_destroy - destroy and free a rtla trace instance
 131  */
 132 void trace_instance_destroy(struct trace_instance *trace)
 133 {
 134         if (trace->inst) {
 135                 disable_tracer(trace->inst);
 136                 destroy_instance(trace->inst);
 137                 trace->inst = NULL;
 138         }
 139
 140         if (trace->seq) {
 141                 free(trace->seq);
 142                 trace->seq = NULL;
 143         }
 144
 145         if (trace->tep) {
 146                 tep_free(trace->tep);
 147                 trace->tep = NULL;
 148         }
 149 }
 150
 151 /*
 152  * trace_instance_init - create an rtla trace instance
 153  *
 154  * It is more than the tracefs instance, as it contains other
 155  * things required for the tracing, such as the local events and
 156  * a seq file.
 157  *
 158  * Note that the trace instance is returned disabled. This allows
 159  * the tool to apply some other configs, like setting priority
 160  * to the kernel threads, before starting generating trace entries.
 161  */
 162 int trace_instance_init(struct trace_instance *trace, char *tool_name)
 163 {
 164         trace->seq = calloc(1, sizeof(*trace->seq));
 165         if (!trace->seq)
 166                 goto out_err;
 167
 168         trace_seq_init(trace->seq);
 169
 170         trace->inst = create_instance(tool_name);
 171         if (!trace->inst)
 172                 goto out_err;
 173
 174         trace->tep = tracefs_local_events(NULL);
 175         if (!trace->tep)
 176                 goto out_err;
 177
 178         /*
 179          * Let the main enable the record after setting some other
 180          * things such as the priority of the tracer's threads.
 181          */
 182         tracefs_trace_off(trace->inst);
 183
 184         return 0;
 185
 186 out_err:
 187         trace_instance_destroy(trace);
 188         return 1;
 189 }
 190
 191 /*
 192  * trace_instance_start - start tracing a given rtla instance
 193  */
 194 int trace_instance_start(struct trace_instance *trace)
 195 {
 196         return tracefs_trace_on(trace->inst);
 197 }
 198
 199 /*
 200  * trace_events_free - free a list of trace events
 201  */
 202 static void trace_events_free(struct trace_events *events)
 203 {
 204         struct trace_events *tevent = events;
 205         struct trace_events *free_event;
 206
 207         while (tevent) {
 208                 free_event = tevent;
 209
 210                 tevent = tevent->next;
 211
 212                 if (free_event->filter)
 213                         free(free_event->filter);
 214                 if (free_event->trigger)
 215                         free(free_event->trigger);
 216                 free(free_event->system);
 217                 free(free_event);
 218         }
 219 }
 220
 221 /*
 222  * trace_event_alloc - alloc and parse a single trace event
 223  */
 224 struct trace_events *trace_event_alloc(const char *event_string)
 225 {
 226         struct trace_events *tevent;
 227
 228         tevent = calloc(1, sizeof(*tevent));
 229         if (!tevent)
 230                 return NULL;
 231
 232         tevent->system = strdup(event_string);
 233         if (!tevent->system) {
 234                 free(tevent);
 235                 return NULL;
 236         }
 237
 238         tevent->event = strstr(tevent->system, ":");
 239         if (tevent->event) {
 240                 *tevent->event = '\0';
 241                 tevent->event = &tevent->event[1];
 242         }
 243
 244         return tevent;
 245 }
 246
 247 /*
 248  * trace_event_add_filter - record an event filter
 249  */
 250 int trace_event_add_filter(struct trace_events *event, char *filter)
 251 {
 252         if (event->filter)
 253                 free(event->filter);
 254
 255         event->filter = strdup(filter);
 256         if (!event->filter)
 257                 return 1;
 258
 259         return 0;
 260 }
 261
 262 /*
 263  * trace_event_add_trigger - record an event trigger action
 264  */
 265 int trace_event_add_trigger(struct trace_events *event, char *trigger)
 266 {
 267         if (event->trigger)
 268                 free(event->trigger);
 269
 270         event->trigger = strdup(trigger);
 271         if (!event->trigger)
 272                 return 1;
 273
 274         return 0;
 275 }
 276
 277 /*
 278  * trace_event_disable_filter - disable an event filter
 279  */
 280 static void trace_event_disable_filter(struct trace_instance *instance,
 281                                        struct trace_events *tevent)
 282 {
 283         char filter[1024];
 284         int retval;
 285
 286         if (!tevent->filter)
 287                 return;
 288
 289         if (!tevent->filter_enabled)
 290                 return;
 291
 292         debug_msg("Disabling %s:%s filter %s\n", tevent->system,
 293                   tevent->event ? : "*", tevent->filter);
 294
 295         snprintf(filter, 1024, "!%s\n", tevent->filter);
 296
 297         retval = tracefs_event_file_write(instance->inst, tevent->system,
 298                                           tevent->event, "filter", filter);
 299         if (retval < 0)
 300                 err_msg("Error disabling %s:%s filter %s\n", tevent->system,
 301                         tevent->event ? : "*", tevent->filter);
 302 }
 303
 304 /*
 305  * trace_event_save_hist - save the content of an event hist
 306  *
 307  * If the trigger is a hist: one, save the content of the hist file.
 308  */
 309 static void trace_event_save_hist(struct trace_instance *instance,
 310                                   struct trace_events *tevent)
 311 {
 312         int retval, index, out_fd;
 313         mode_t mode = 0644;
 314         char path[1024];
 315         char *hist;
 316
 317         if (!tevent)
 318                 return;
 319
 320         /* trigger enables hist */
 321         if (!tevent->trigger)
 322                 return;
 323
 324         /* is this a hist: trigger? */
 325         retval = strncmp(tevent->trigger, "hist:", strlen("hist:"));
 326         if (retval)
 327                 return;
 328
 329         snprintf(path, 1024, "%s_%s_hist.txt", tevent->system, tevent->event);
 330
 331         printf("  Saving event %s:%s hist to %s\n", tevent->system, tevent->event, path);
 332
 333         out_fd = creat(path, mode);
 334         if (out_fd < 0) {
 335                 err_msg("  Failed to create %s output file\n", path);
 336                 return;
 337         }
 338
 339         hist = tracefs_event_file_read(instance->inst, tevent->system, tevent->event, "hist", 0);
 340         if (!hist) {
 341                 err_msg("  Failed to read %s:%s hist file\n", tevent->system, tevent->event);
 342                 goto out_close;
 343         }
 344
 345         index = 0;
 346         do {
 347                 index += write(out_fd, &hist[index], strlen(hist) - index);
 348         } while (index < strlen(hist));
 349
 350         free(hist);
 351 out_close:
 352         close(out_fd);
 353 }
 354
 355 /*
 356  * trace_event_disable_trigger - disable an event trigger
 357  */
 358 static void trace_event_disable_trigger(struct trace_instance *instance,
 359                                         struct trace_events *tevent)
 360 {
 361         char trigger[1024];
 362         int retval;
 363
 364         if (!tevent->trigger)
 365                 return;
 366
 367         if (!tevent->trigger_enabled)
 368                 return;
 369
 370         debug_msg("Disabling %s:%s trigger %s\n", tevent->system,
 371                   tevent->event ? : "*", tevent->trigger);
 372
 373         trace_event_save_hist(instance, tevent);
 374
 375         snprintf(trigger, 1024, "!%s\n", tevent->trigger);
 376
 377         retval = tracefs_event_file_write(instance->inst, tevent->system,
 378                                           tevent->event, "trigger", trigger);
 379         if (retval < 0)
 380                 err_msg("Error disabling %s:%s trigger %s\n", tevent->system,
 381                         tevent->event ? : "*", tevent->trigger);
 382 }
 383
 384 /*
 385  * trace_events_disable - disable all trace events
 386  */
 387 void trace_events_disable(struct trace_instance *instance,
 388                           struct trace_events *events)
 389 {
 390         struct trace_events *tevent = events;
 391
 392         if (!events)
 393                 return;
 394
 395         while (tevent) {
 396                 debug_msg("Disabling event %s:%s\n", tevent->system, tevent->event ? : "*");
 397                 if (tevent->enabled) {
 398                         trace_event_disable_filter(instance, tevent);
 399                         trace_event_disable_trigger(instance, tevent);
 400                         tracefs_event_disable(instance->inst, tevent->system, tevent->event);
 401                 }
 402
 403                 tevent->enabled = 0;
 404                 tevent = tevent->next;
 405         }
 406 }
 407
 408 /*
 409  * trace_event_enable_filter - enable an event filter associated with an event
 410  */
 411 static int trace_event_enable_filter(struct trace_instance *instance,
 412                                      struct trace_events *tevent)
 413 {
 414         char filter[1024];
 415         int retval;
 416
 417         if (!tevent->filter)
 418                 return 0;
 419
 420         if (!tevent->event) {
 421                 err_msg("Filter %s applies only for single events, not for all %s:* events\n",
 422                         tevent->filter, tevent->system);
 423                 return 1;
 424         }
 425
 426         snprintf(filter, 1024, "%s\n", tevent->filter);
 427
 428         debug_msg("Enabling %s:%s filter %s\n", tevent->system,
 429                   tevent->event ? : "*", tevent->filter);
 430
 431         retval = tracefs_event_file_write(instance->inst, tevent->system,
 432                                           tevent->event, "filter", filter);
 433         if (retval < 0) {
 434                 err_msg("Error enabling %s:%s filter %s\n", tevent->system,
 435                         tevent->event ? : "*", tevent->filter);
 436                 return 1;
 437         }
 438
 439         tevent->filter_enabled = 1;
 440         return 0;
 441 }
 442
 443 /*
 444  * trace_event_enable_trigger - enable an event trigger associated with an event
 445  */
 446 static int trace_event_enable_trigger(struct trace_instance *instance,
 447                                       struct trace_events *tevent)
 448 {
 449         char trigger[1024];
 450         int retval;
 451
 452         if (!tevent->trigger)
 453                 return 0;
 454
 455         if (!tevent->event) {
 456                 err_msg("Trigger %s applies only for single events, not for all %s:* events\n",
 457                         tevent->trigger, tevent->system);
 458                 return 1;
 459         }
 460
 461         snprintf(trigger, 1024, "%s\n", tevent->trigger);
 462
 463         debug_msg("Enabling %s:%s trigger %s\n", tevent->system,
 464                   tevent->event ? : "*", tevent->trigger);
 465
 466         retval = tracefs_event_file_write(instance->inst, tevent->system,
 467                                           tevent->event, "trigger", trigger);
 468         if (retval < 0) {
 469                 err_msg("Error enabling %s:%s trigger %s\n", tevent->system,
 470                         tevent->event ? : "*", tevent->trigger);
 471                 return 1;
 472         }
 473
 474         tevent->trigger_enabled = 1;
 475
 476         return 0;
 477 }
 478
 479 /*
 480  * trace_events_enable - enable all events
 481  */
 482 int trace_events_enable(struct trace_instance *instance,
 483                         struct trace_events *events)
 484 {
 485         struct trace_events *tevent = events;
 486         int retval;
 487
 488         while (tevent) {
 489                 debug_msg("Enabling event %s:%s\n", tevent->system, tevent->event ? : "*");
 490                 retval = tracefs_event_enable(instance->inst, tevent->system, tevent->event);
 491                 if (retval < 0) {
 492                         err_msg("Error enabling event %s:%s\n", tevent->system,
 493                                 tevent->event ? : "*");
 494                         return 1;
 495                 }
 496
 497                 retval = trace_event_enable_filter(instance, tevent);
 498                 if (retval)
 499                         return 1;
 500
 501                 retval = trace_event_enable_trigger(instance, tevent);
 502                 if (retval)
 503                         return 1;
 504
 505                 tevent->enabled = 1;
 506                 tevent = tevent->next;
 507         }
 508
 509         return 0;
 510 }
 511
 512 /*
 513  * trace_events_destroy - disable and free all trace events
 514  */
 515 void trace_events_destroy(struct trace_instance *instance,
 516                           struct trace_events *events)
 517 {
 518         if (!events)
 519                 return;
 520
 521         trace_events_disable(instance, events);
 522         trace_events_free(events);
 523 }
 524
 525 int trace_is_off(struct trace_instance *tool, struct trace_instance *trace)
 526 {
 527         /*
 528          * The tool instance is always present, it is the one used to collect
 529          * data.
 530          */
 531         if (!tracefs_trace_is_on(tool->inst))
 532                 return 1;
 533
 534         /*
 535          * The trace instance is only enabled when -t is set. IOW, when the system
 536          * is tracing.
 537          */
 538         if (trace && !tracefs_trace_is_on(trace->inst))
 539                 return 1;
 540
 541         return 0;
 542 }
 543
 544 /*
 545  * trace_set_buffer_size - set the per-cpu tracing buffer size.
 546  */
 547 int trace_set_buffer_size(struct trace_instance *trace, int size)
 548 {
 549         int retval;
 550
 551         debug_msg("Setting trace buffer size to %d Kb\n", size);
 552         retval = tracefs_instance_set_buffer_size(trace->inst, size, -1);
 553         if (retval)
 554                 err_msg("Error setting trace buffer size\n");
 555
 556         return retval;
 557 }