Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625// SPDX-License-Identifier: GPL-2.0#define _GNU_SOURCE#include <sys/sendfile.h>#include <tracefs.h>#include <stdlib.h>#include <unistd.h>#include <errno.h>
#include "trace.h"#include "utils.h"
/* * enable_tracer_by_name - enable a tracer on the given instance */int enable_tracer_by_name(struct tracefs_instance *inst, const char *tracer_name){ enum tracefs_tracers tracer; int retval;
tracer = TRACEFS_TRACER_CUSTOM;
debug_msg("Enabling %s tracer\n", tracer_name);
retval = tracefs_tracer_set(inst, tracer, tracer_name); if (retval < 0) { if (errno == ENODEV) err_msg("Tracer %s not found!\n", tracer_name);
err_msg("Failed to enable the %s tracer\n", tracer_name); return -1; }
return 0;}
/* * disable_tracer - set nop tracer to the insta */void disable_tracer(struct tracefs_instance *inst){ enum tracefs_tracers t = TRACEFS_TRACER_NOP; int retval;
retval = tracefs_tracer_set(inst, t); if (retval < 0) err_msg("Oops, error disabling tracer\n");}
/* * create_instance - create a trace instance with *instance_name */struct tracefs_instance *create_instance(char *instance_name){ return tracefs_instance_create(instance_name);}
/* * destroy_instance - remove a trace instance and free the data */void destroy_instance(struct tracefs_instance *inst){ tracefs_instance_destroy(inst); tracefs_instance_free(inst);}
/* * save_trace_to_file - save the trace output of the instance to the file */int save_trace_to_file(struct tracefs_instance *inst, const char *filename){ const char *file = "trace"; mode_t mode = 0644; char buffer[4096]; int out_fd, in_fd; int retval = -1; ssize_t n_read; ssize_t n_written;
if (!inst || !filename) return 0;
in_fd = tracefs_instance_file_open(inst, file, O_RDONLY); if (in_fd < 0) { err_msg("Failed to open trace file\n"); return -1; }
printf(" Saving trace to %s\n", filename); out_fd = creat(filename, mode); if (out_fd < 0) { err_msg("Failed to create output file %s\n", filename); goto out_close_in; }
for (;;) { n_read = read(in_fd, buffer, sizeof(buffer)); if (n_read < 0) { if (errno == EINTR) continue; err_msg("Error reading trace file: %s\n", strerror(errno)); goto out_close; } if (n_read == 0) break;
n_written = 0; while (n_written < n_read) { const ssize_t w = write(out_fd, buffer + n_written, n_read - n_written);
if (w < 0) { if (errno == EINTR) continue; err_msg("Error writing trace file: %s\n", strerror(errno)); goto out_close; } n_written += w; } }
retval = 0;out_close: close(out_fd);out_close_in: close(in_fd); return retval;}
/* * collect_registered_events - call the existing callback function for the event * * If an event has a registered callback function, call it. * Otherwise, ignore the event. */intcollect_registered_events(struct tep_event *event, struct tep_record *record, int cpu, void *context){ struct trace_instance *trace = context; struct trace_seq *s = trace->seq;
if (cpu >= nr_cpus) { /* Kernel reports event on CPU we don't see, corrupt data? */ trace->invalid_events++; return 0; }
trace->processed_events++;
if (!event->handler) return 0;
event->handler(s, record, event, context);
return 0;}
/* * collect_missed_events - record number of missed events * * If rtla cannot keep up with events generated by tracer, events are going * to fall out of the ring buffer. * Collect how many events were missed so it can be reported to the user. */static intcollect_missed_events(struct tep_event *event, struct tep_record *record, int cpu, void *context){ struct trace_instance *trace = context;
if (trace->missed_events == UINT64_MAX) return 0;
if (record->missed_events > 0) trace->missed_events += record->missed_events; else /* Events missed but no data on how many */ trace->missed_events = UINT64_MAX;
return 0;}
/* * trace_instance_destroy - destroy and free a rtla trace instance */void trace_instance_destroy(struct trace_instance *trace){ if (trace->inst) { disable_tracer(trace->inst); destroy_instance(trace->inst); trace->inst = NULL; }
if (trace->seq) { free(trace->seq); trace->seq = NULL; }
if (trace->tep) { tep_free(trace->tep); trace->tep = NULL; }}
/* * trace_instance_init - create an rtla trace instance * * It is more than the tracefs instance, as it contains other * things required for the tracing, such as the local events and * a seq file. * * Note that the trace instance is returned disabled. This allows * the tool to apply some other configs, like setting priority * to the kernel threads, before starting generating trace entries. */int trace_instance_init(struct trace_instance *trace, char *tool_name){ trace->seq = calloc_fatal(1, sizeof(*trace->seq));
trace_seq_init(trace->seq);
trace->inst = create_instance(tool_name); if (!trace->inst) goto out_err;
trace->tep = tracefs_local_events(NULL); if (!trace->tep) goto out_err;
/* * Let the main enable the record after setting some other * things such as the priority of the tracer's threads. */ tracefs_trace_off(trace->inst);
/* * Collect the number of events missed due to tracefs buffer * overflow. */ trace->missed_events = 0; tracefs_follow_missed_events(trace->inst, collect_missed_events, trace);
trace->processed_events = 0; trace->invalid_events = 0;
return 0;
out_err: trace_instance_destroy(trace); return 1;}
/* * trace_instance_start - start tracing a given rtla instance */int trace_instance_start(struct trace_instance *trace){ return tracefs_trace_on(trace->inst);}
/* * trace_instance_stop - stop tracing a given rtla instance */int trace_instance_stop(struct trace_instance *trace){ return tracefs_trace_off(trace->inst);}
/* * trace_events_free - free a list of trace events */static void trace_events_free(struct trace_events *events){ struct trace_events *tevent = events; struct trace_events *free_event;
while (tevent) { free_event = tevent;
tevent = tevent->next;
if (free_event->filter) free(free_event->filter); if (free_event->trigger) free(free_event->trigger); free(free_event->system); free(free_event); }}
/* * trace_event_alloc - alloc and parse a single trace event */struct trace_events *trace_event_alloc(const char *event_string){ struct trace_events *tevent;
tevent = calloc_fatal(1, sizeof(*tevent));
tevent->system = strdup_fatal(event_string);
tevent->event = strstr(tevent->system, ":"); if (tevent->event) { *tevent->event = '\0'; tevent->event = &tevent->event[1]; }
return tevent;}
/* * trace_event_add_filter - record an event filter */void trace_event_add_filter(struct trace_events *event, char *filter){ if (event->filter) free(event->filter);
event->filter = strdup_fatal(filter);}
/* * trace_event_add_trigger - record an event trigger action */void trace_event_add_trigger(struct trace_events *event, char *trigger){ if (event->trigger) free(event->trigger);
event->trigger = strdup_fatal(trigger);}
/* * trace_event_disable_filter - disable an event filter */static void trace_event_disable_filter(struct trace_instance *instance, struct trace_events *tevent){ char filter[MAX_PATH]; int retval;
if (!tevent->filter) return;
if (!tevent->filter_enabled) return;
debug_msg("Disabling %s:%s filter %s\n", tevent->system, tevent->event ? : "*", tevent->filter);
snprintf(filter, ARRAY_SIZE(filter), "!%s\n", tevent->filter);
retval = tracefs_event_file_write(instance->inst, tevent->system, tevent->event, "filter", filter); if (retval < 0) err_msg("Error disabling %s:%s filter %s\n", tevent->system, tevent->event ? : "*", tevent->filter);}
/* * trace_event_save_hist - save the content of an event hist * * If the trigger is a hist: one, save the content of the hist file. */static void trace_event_save_hist(struct trace_instance *instance, struct trace_events *tevent){ size_t index, hist_len; mode_t mode = 0644; char path[MAX_PATH]; char *hist; int out_fd;
if (!tevent) return;
/* trigger enables hist */ if (!tevent->trigger) return;
/* is this a hist: trigger? */ if (!str_has_prefix(tevent->trigger, "hist:")) return;
snprintf(path, ARRAY_SIZE(path), "%s_%s_hist.txt", tevent->system, tevent->event);
printf(" Saving event %s:%s hist to %s\n", tevent->system, tevent->event, path);
out_fd = creat(path, mode); if (out_fd < 0) { err_msg(" Failed to create %s output file\n", path); return; }
hist = tracefs_event_file_read(instance->inst, tevent->system, tevent->event, "hist", 0); if (!hist) { err_msg(" Failed to read %s:%s hist file\n", tevent->system, tevent->event); goto out_close; }
index = 0; hist_len = strlen(hist); do { const ssize_t written = write(out_fd, &hist[index], hist_len - index);
if (written < 0) { if (errno == EINTR) continue; err_msg(" Error writing hist file: %s\n", strerror(errno)); break; } index += written; } while (index < hist_len);
free(hist);out_close: close(out_fd);}
/* * trace_event_disable_trigger - disable an event trigger */static void trace_event_disable_trigger(struct trace_instance *instance, struct trace_events *tevent){ char trigger[MAX_PATH]; int retval;
if (!tevent->trigger) return;
if (!tevent->trigger_enabled) return;
debug_msg("Disabling %s:%s trigger %s\n", tevent->system, tevent->event ? : "*", tevent->trigger);
trace_event_save_hist(instance, tevent);
snprintf(trigger, ARRAY_SIZE(trigger), "!%s\n", tevent->trigger);
retval = tracefs_event_file_write(instance->inst, tevent->system, tevent->event, "trigger", trigger); if (retval < 0) err_msg("Error disabling %s:%s trigger %s\n", tevent->system, tevent->event ? : "*", tevent->trigger);}
static inline struct trace_events *trace_events_tail(struct trace_events *tevent){ while (tevent && tevent->next) tevent = tevent->next;
return tevent;}
/* * Events are stashed in LIFO order; flip that to FIFO to process them in the * same order as they are defined by the user on the command line. */#define for_each_trace_event(tevent) \ for (tevent = trace_events_tail(tevent); tevent; tevent = tevent->prev)
/* * trace_events_disable - disable all trace events */void trace_events_disable(struct trace_instance *instance, struct trace_events *events){ struct trace_events *tevent = events;
if (!events) return;
for_each_trace_event(tevent) { debug_msg("Disabling event %s:%s\n", tevent->system, tevent->event ? : "*"); if (tevent->enabled) { trace_event_disable_filter(instance, tevent); trace_event_disable_trigger(instance, tevent); tracefs_event_disable(instance->inst, tevent->system, tevent->event); }
tevent->enabled = 0; }}
/* * trace_event_enable_filter - enable an event filter associated with an event */static int trace_event_enable_filter(struct trace_instance *instance, struct trace_events *tevent){ char filter[MAX_PATH]; int retval;
/* Unconditionally clean any pre-existing filters */ tracefs_event_file_write(instance->inst, tevent->system, tevent->event, "filter", "0");
if (!tevent->filter) return 0;
if (!tevent->event) { err_msg("Filter %s applies only for single events, not for all %s:* events\n", tevent->filter, tevent->system); return 1; }
snprintf(filter, ARRAY_SIZE(filter), "%s\n", tevent->filter);
debug_msg("Enabling %s:%s filter %s\n", tevent->system, tevent->event ? : "*", tevent->filter);
retval = tracefs_event_file_write(instance->inst, tevent->system, tevent->event, "filter", filter); if (retval < 0) { err_msg("Error enabling %s:%s filter %s\n", tevent->system, tevent->event ? : "*", tevent->filter); return 1; }
tevent->filter_enabled = 1; return 0;}
/* * trace_event_enable_trigger - enable an event trigger associated with an event */static int trace_event_enable_trigger(struct trace_instance *instance, struct trace_events *tevent){ char trigger[MAX_PATH]; int retval;
if (!tevent->trigger) return 0;
if (!tevent->event) { err_msg("Trigger %s applies only for single events, not for all %s:* events\n", tevent->trigger, tevent->system); return 1; }
snprintf(trigger, ARRAY_SIZE(trigger), "%s\n", tevent->trigger);
debug_msg("Enabling %s:%s trigger %s\n", tevent->system, tevent->event ? : "*", tevent->trigger);
retval = tracefs_event_file_write(instance->inst, tevent->system, tevent->event, "trigger", trigger); if (retval < 0) { err_msg("Error enabling %s:%s trigger %s\n", tevent->system, tevent->event ? : "*", tevent->trigger); return 1; }
tevent->trigger_enabled = 1;
return 0;}
/* * trace_events_enable - enable all events */int trace_events_enable(struct trace_instance *instance, struct trace_events *events){ struct trace_events *tevent = events; int retval;
if (!events) return 0;
for_each_trace_event(tevent) { debug_msg("Enabling event %s:%s\n", tevent->system, tevent->event ? : "*"); retval = tracefs_event_enable(instance->inst, tevent->system, tevent->event); if (retval < 0) { err_msg("Error enabling event %s:%s\n", tevent->system, tevent->event ? : "*"); return 1; }
retval = trace_event_enable_filter(instance, tevent); if (retval) return 1;
retval = trace_event_enable_trigger(instance, tevent); if (retval) return 1;
tevent->enabled = 1; }
return 0;}
/* * trace_events_destroy - disable and free all trace events */void trace_events_destroy(struct trace_instance *instance, struct trace_events *events){ if (!events) return;
trace_events_disable(instance, events); trace_events_free(events);}
/* * trace_set_buffer_size - set the per-cpu tracing buffer size. */int trace_set_buffer_size(struct trace_instance *trace, int size){ int retval;
debug_msg("Setting trace buffer size to %d Kb\n", size); retval = tracefs_instance_set_buffer_size(trace->inst, size, -1); if (retval) err_msg("Error setting trace buffer size\n");
return retval;}