4bc4b131d4
This is the (user-space) runtime verification tool, named rv.
This tool aims to be the interface for in-kernel rv monitors, as
well as the home for monitors in user-space (online asynchronous),
and in *eBPF.
The tool receives a command as the first argument, the current
commands are:
list - list all available monitors
mon - run a given monitor
Each monitor is an independent piece of software inside the
tool and can have their own arguments.
There is no monitor implemented in this patch, it only
adds the basic structure of the tool, based on rtla.
# rv --help
rv version 6.1.0-rc4: help
usage: rv command [-h] [command_options]
-h/--help: print this menu
command: run one of the following command:
list: list all available monitors
mon: run a monitor
[command options]: each command has its own set of options
run rv command -h for further information
*dot2bpf is the next patch set, depends on this, doing cleanups.
Link: https://lkml.kernel.org/r/fb51184f3b95aea0d7bfdc33ec09f4153aee84fa.1668180100.git.bristot@kernel.org
Cc: Jonathan Corbet <corbet@lwn.net>
Signed-off-by: Daniel Bristot de Oliveira <bristot@kernel.org>
Signed-off-by: Steven Rostedt (Google) <rostedt@goodmis.org>
133 lines
2.8 KiB
C
133 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 an 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);
|
|
}
|