134 lines
2.8 KiB
C
134 lines
2.8 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* trace helpers.
|
|
*
|
|
* Copyright (C) 2022 Red Hat Inc, Daniel Bristot de Oliveira <bristot@kernel.org>
|
|
*/
|
|
|
|
#include <sys/sendfile.h>
|
|
#include <tracefs.h>
|
|
#include <signal.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <errno.h>
|
|
|
|
#include <rv.h>
|
|
#include <trace.h>
|
|
#include <utils.h>
|
|
|
|
/*
|
|
* create_instance - create a trace instance with *instance_name
|
|
*/
|
|
static struct tracefs_instance *create_instance(char *instance_name)
|
|
{
|
|
return tracefs_instance_create(instance_name);
|
|
}
|
|
|
|
/*
|
|
* destroy_instance - remove a trace instance and free the data
|
|
*/
|
|
static void destroy_instance(struct tracefs_instance *inst)
|
|
{
|
|
tracefs_instance_destroy(inst);
|
|
tracefs_instance_free(inst);
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* Returns 0 if the event was collected, 1 if the tool should stop collecting trace.
|
|
*/
|
|
int
|
|
collect_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 (should_stop())
|
|
return 1;
|
|
|
|
if (!event->handler)
|
|
return 0;
|
|
|
|
event->handler(s, record, event, context);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* trace_instance_destroy - destroy and free a rv trace instance
|
|
*/
|
|
void trace_instance_destroy(struct trace_instance *trace)
|
|
{
|
|
if (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 a 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.
|
|
*
|
|
* Returns 0 on success, non-zero otherwise.
|
|
*/
|
|
int trace_instance_init(struct trace_instance *trace, char *name)
|
|
{
|
|
trace->seq = calloc(1, sizeof(*trace->seq));
|
|
if (!trace->seq)
|
|
goto out_err;
|
|
|
|
trace_seq_init(trace->seq);
|
|
|
|
trace->inst = create_instance(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);
|
|
|
|
return 0;
|
|
|
|
out_err:
|
|
trace_instance_destroy(trace);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* trace_instance_start - start tracing a given rv instance
|
|
*
|
|
* Returns 0 on success, -1 otherwise.
|
|
*/
|
|
int trace_instance_start(struct trace_instance *trace)
|
|
{
|
|
return tracefs_trace_on(trace->inst);
|
|
}
|