path: root/tools/tracing/rtla/src/osnoise.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2021 Red Hat Inc, Daniel Bristot de Oliveira <bristot@kernel.org>
 */

#define _GNU_SOURCE
#include <sys/types.h>
#include <sys/stat.h>
#include <pthread.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <sched.h>

#include <linux/compiler.h>

#include "osnoise.h"

#define DEFAULT_SAMPLE_PERIOD	1000000			/* 1s */
#define DEFAULT_SAMPLE_RUNTIME	1000000			/* 1s */

/*
 * osnoise_get_cpus - return the original "osnoise/cpus" content
 *
 * It also saves the value to be restored.
 */
char *osnoise_get_cpus(struct osnoise_context *context)
{
	if (context->curr_cpus)
		return context->curr_cpus;

	if (context->orig_cpus)
		return context->orig_cpus;

	context->orig_cpus = tracefs_instance_file_read(NULL, "osnoise/cpus", NULL);

	/*
	 * The error value (NULL) is the same for tracefs_instance_file_read()
	 * and this functions, so:
	 */
	return context->orig_cpus;
}

/*
 * osnoise_set_cpus - configure osnoise to run on *cpus
 *
 * "osnoise/cpus" file is used to set the cpus in which osnoise/timerlat
 * will run. This function opens this file, saves the current value,
 * and set the cpus passed as argument.
 */
int osnoise_set_cpus(struct osnoise_context *context, char *cpus)
{
	char *orig_cpus = osnoise_get_cpus(context);
	char buffer[1024];
	int retval;

	if (!orig_cpus)
		return -1;

	context->curr_cpus = strdup(cpus);
	if (!context->curr_cpus)
		return -1;

	snprintf(buffer, ARRAY_SIZE(buffer), "%s\n", cpus);

	debug_msg("setting cpus to %s from %s", cpus, context->orig_cpus);

	retval = tracefs_instance_file_write(NULL, "osnoise/cpus", buffer);
	if (retval < 0) {
		free(context->curr_cpus);
		context->curr_cpus = NULL;
		return -1;
	}

	return 0;
}

/*
 * osnoise_restore_cpus - restore the original "osnoise/cpus"
 *
 * osnoise_set_cpus() saves the original data for the "osnoise/cpus"
 * file. This function restore the original config it was previously
 * modified.
 */
void osnoise_restore_cpus(struct osnoise_context *context)
{
	int retval;

	if (!context->orig_cpus)
		return;

	if (!context->curr_cpus)
		return;

	/* nothing to do? */
	if (!strcmp(context->orig_cpus, context->curr_cpus))
		goto out_done;

	debug_msg("restoring cpus to %s", context->orig_cpus);

	retval = tracefs_instance_file_write(NULL, "osnoise/cpus", context->orig_cpus);
	if (retval < 0)
		err_msg("could not restore original osnoise cpus\n");

out_done:
	free(context->curr_cpus);
	context->curr_cpus = NULL;
}

/*
 * osnoise_put_cpus - restore cpus config and cleanup data
 */
void osnoise_put_cpus(struct osnoise_context *context)
{
	osnoise_restore_cpus(context);

	if (!context->orig_cpus)
		return;

	free(context->orig_cpus);
	context->orig_cpus = NULL;
}

/*
 * osnoise_get_cpu_count - get the number of CPUs as seen by the osnoise tracer
 *
 * Write "all" to osnoise/cpus and read back the real kernel-side list
 * of all possible cpus. Restore the original value afterwards.
 *
 * Returns the number of CPUs, or -1 on error.
 */
int osnoise_get_cpu_count(void)
{
	char *orig, *readback;
	int max_cpu;

	orig = tracefs_instance_file_read(NULL, "osnoise/cpus", NULL);
	if (!orig)
		return -1;

	if (tracefs_instance_file_write(NULL, "osnoise/cpus", "all\n") < 0) {
		free(orig);
		return -1;
	}

	readback = tracefs_instance_file_read(NULL, "osnoise/cpus", NULL);
	if (!readback) {
		tracefs_instance_file_write(NULL, "osnoise/cpus", orig);
		free(orig);
		return -1;
	}

	max_cpu = get_max_cpu_from_list(readback);
	free(readback);

	if (tracefs_instance_file_write(NULL, "osnoise/cpus", orig) < 0) {
		free(orig);
		return -1;
	}
	free(orig);

	if (max_cpu < 0)
		return -1;

	return max_cpu + 1;
}

/**
 * osnoise_read_ll_config - read a long long value from a tracefs config
 * @rel_path: tracefs-relative path to the config file
 * @set_value: pointer to the cached value set by RTLA, or -1 if unset
 * @orig_value: pointer to the cached original value read from tracefs, or -1 if unread
 *
 * Returns the current effective value for the config at @rel_path. If RTLA has
 * already written a value (@set_value != -1), that value is returned. If the
 * original has already been read (@orig_value != -1), that cached value is
 * returned. Otherwise, reads the value from tracefs, caches it in @orig_value
 * (so it can later be restored), and returns it.
 *
 * This is the shared read primitive used by both the manually implemented
 * get functions (osnoise_get_runtime, osnoise_get_period) and the
 * OSNOISE_LL_OPTION-generated set/restore/put functions.
 *
 * Returns the config value on success, -1 on error.
 */
static long long osnoise_read_ll_config(char *rel_path,
					long long *set_value,
					long long *orig_value)
{
	long long retval;
	char *buffer;

	if (*set_value != -1)
		/* option has been set by RTLA already */
		return *set_value;

	if (*orig_value != -1)
		/* RTLA has already read the option */
		return *orig_value;

	/* current value is not known to RTLA yet, read it from tracefs */
	buffer = tracefs_instance_file_read(NULL, rel_path, NULL);
	if (!buffer)
		return -1;

	/* get_llong_from_str returns -1 on error */
	retval = get_llong_from_str(buffer);

	debug_msg("reading %s returned %lld\n", rel_path, retval);

	free(buffer);

	if (retval < 0)
		goto out_err;

	/* save the value and return it */
	*orig_value = retval;
	return retval;

out_err:
	return -1;
}

/**
 * osnoise_write_ll_config - write a long long value to a tracefs config
 * @rel_path: tracefs-relative path to the config file
 * @value: the value to write
 * @set_value: pointer to the cached value set by RTLA, or -1 if unset
 * @orig_value: pointer to the cached original value read from tracefs, or -1 if unread
 *
 * Writes @value to the config at @rel_path. Before writing, calls
 * osnoise_read_ll_config() to ensure the original value is cached in
 * @orig_value (enabling later restoration). On successful write, records
 * the new value in @set_value.
 *
 * This is the shared write primitive used by both the manually implemented
 * write functions (__osnoise_write_runtime, __osnoise_write_period) and the
 * OSNOISE_LL_OPTION-generated set/restore/put functions.
 *
 * Returns 0 on success, -1 on read error (option likely unknown to kernel),
 * or -2 on write error.
 */
static int osnoise_write_ll_config(char *rel_path,
				   long long value,
				   long long *set_value,
				   long long *orig_value)
{
	long long curr = osnoise_read_ll_config(rel_path, set_value, orig_value);
	long long retval;
	char buffer[BUFF_U64_STR_SIZE];

	if (curr == -1)
		/* read failed, option likely unknown to kernel */
		return -1;

	snprintf(buffer, sizeof(buffer), "%lld\n", value);

	debug_msg("setting %s to %lld\n", rel_path, value);

	retval = tracefs_instance_file_write(NULL, rel_path, buffer);

	if (retval < 0)
		/* write failed, hard error */
		return -2;

	/* record the set value and return success */
	*set_value = value;
	return 0;
}

/**
 * osnoise_restore_ll_config - restore a long long config to its original value
 * @rel_path: tracefs-relative path to the config file
 * @set_value: pointer to the cached value set by RTLA, or -1 if unset
 * @orig_value: pointer to the cached original value read from tracefs, or -1 if unread
 *
 * Restores the config at @rel_path to the value cached in @orig_value (which
 * was saved by a prior osnoise_read_ll_config() or osnoise_write_ll_config()
 * call). If the original was never read, or if the current set value already
 * matches the original, no write is performed. After restoring, clears
 * @set_value to -1 to indicate RTLA no longer overrides this config.
 *
 * This is the shared restore primitive used by both the manually implemented
 * restore function (osnoise_restore_runtime_period) and the
 * OSNOISE_LL_OPTION-generated restore/put functions.
 */
static void osnoise_restore_ll_config(char *rel_path,
				      long long *set_value,
				      long long *orig_value)
{
	int retval;

	if (*orig_value == -1)
		return;

	if (*orig_value == *set_value)
		goto out_done;

	retval = osnoise_write_ll_config(rel_path, *orig_value, set_value, orig_value);
	if (retval < 0)
		err_msg("Could not restore original value for %s\n", rel_path);

out_done:
	*set_value = -1;
}

/*
 * osnoise_get_runtime - return the original "osnoise/runtime_us" value
 *
 * It also saves the value to be restored.
 */
long long osnoise_get_runtime(struct osnoise_context *context)
{
	return osnoise_read_ll_config("osnoise/runtime_us",
				      &context->runtime_us,
				      &context->orig_runtime_us);
}

/*
 * osnoise_get_period - return the original "osnoise/period_us" value
 *
 * It also saves the value to be restored.
 */
long long osnoise_get_period(struct osnoise_context *context)
{
	return osnoise_read_ll_config("osnoise/period_us",
				      &context->period_us,
				      &context->orig_period_us);
}

static int __osnoise_write_runtime(struct osnoise_context *context,
				   long long runtime)
{
	return osnoise_write_ll_config("osnoise/runtime_us",
				       runtime,
				       &context->runtime_us,
				       &context->orig_runtime_us);
}

static int __osnoise_write_period(struct osnoise_context *context,
				  long long period)
{
	return osnoise_write_ll_config("osnoise/period_us",
				       period,
				       &context->period_us,
				       &context->orig_period_us);
}

/*
 * osnoise_set_runtime_period - set osnoise runtime and period
 *
 * Osnoise's runtime and period are related as runtime <= period.
 * Thus, this function saves the original values, and then tries
 * to set the runtime and period if they are != 0.
 */
int osnoise_set_runtime_period(struct osnoise_context *context,
			       long long runtime,
			       long long period)
{
	long long curr_runtime_us;
	long long curr_period_us;
	int retval;

	if (!period && !runtime)
		return 0;

	curr_runtime_us = osnoise_get_runtime(context);
	curr_period_us = osnoise_get_period(context);

	/* error getting any value? */
	if (curr_period_us == -1 || curr_runtime_us == -1)
		return -1;

	if (!period) {
		if (runtime > curr_period_us)
			return -1;
		return __osnoise_write_runtime(context, runtime);
	} else if (!runtime) {
		if (period < curr_runtime_us)
			return -1;
		return __osnoise_write_period(context, period);
	}

	if (runtime > curr_period_us) {
		retval = __osnoise_write_period(context, period);
		if (retval)
			return -1;
		retval = __osnoise_write_runtime(context, runtime);
		if (retval)
			return -1;
	} else {
		retval = __osnoise_write_runtime(context, runtime);
		if (retval)
			return -1;
		retval = __osnoise_write_period(context, period);
		if (retval)
			return -1;
	}

	return 0;
}

/*
 * osnoise_restore_runtime_period - restore the original runtime and period
 */
void osnoise_restore_runtime_period(struct osnoise_context *context)
{
	long long orig_runtime = context->orig_runtime_us;
	long long orig_period = context->orig_period_us;
	long long curr_runtime = context->runtime_us;
	long long curr_period = context->period_us;
	int retval;

	if ((orig_runtime == -1) && (orig_period == -1))
		return;

	if ((orig_period == curr_period) && (orig_runtime == curr_runtime))
		goto out_done;

	retval = osnoise_set_runtime_period(context, orig_runtime, orig_period);
	if (retval)
		err_msg("Could not restore original osnoise runtime/period\n");

out_done:
	context->runtime_us = -1;
	context->period_us = -1;
}

/*
 * osnoise_put_runtime_period - restore original values and cleanup data
 */
void osnoise_put_runtime_period(struct osnoise_context *context)
{
	osnoise_restore_runtime_period(context);

	if (context->orig_runtime_us != -1)
		context->orig_runtime_us = -1;

	if (context->orig_period_us != -1)
		context->orig_period_us = -1;
}

/*
 * Long long option set/restore/put functions, generated from OSNOISE_LL_OPTIONS.
 */
#define OSNOISE_LL_OPTION(name, path)						\
int osnoise_set_##name(struct osnoise_context *context, long long value)	\
{										\
	return osnoise_write_ll_config(path,					\
				       value,					\
				       &context->name,				\
				       &context->orig_##name);			\
}										\
										\
void osnoise_restore_##name(struct osnoise_context *context)			\
{										\
	osnoise_restore_ll_config(path, &context->name, &context->orig_##name);	\
}										\
										\
static void osnoise_put_##name(struct osnoise_context *context)			\
{										\
	osnoise_restore_##name(context);					\
										\
	if (context->orig_##name == -1)						\
		return;								\
										\
	context->orig_##name = -1;						\
}
OSNOISE_LL_OPTIONS
#undef OSNOISE_LL_OPTION

/**
 * osnoise_get_option - read a boolean flag from osnoise/options
 * @option: the option name string to look for (e.g. "OSNOISE_IRQ_DISABLE")
 * @set_value: pointer to the cached value set by RTLA, or -1 if unset
 * @orig_value: pointer to the cached original value read from tracefs, or -1 if unread
 *
 * Returns the current state of the flag @option. If RTLA has already written a
 * value (@set_value != -1), that value is returned. If the original has already
 * been read (@orig_value != -1), that cached value is returned. Otherwise, reads
 * the "osnoise/options" file from tracefs, checks whether @option appears with or
 * without a "NO_" prefix, caches the result in @orig_value (so it can later be
 * restored), and returns it.
 *
 * This is the shared read primitive used by the OSNOISE_FLAG_OPTION-generated
 * set/restore/put functions.
 *
 * Returns 1 if enabled, 0 if disabled, or -1 on error (option unknown to kernel).
 */
static int osnoise_get_option(char *option,
			      int *set_value,
			      int *orig_value)
{
	char *options;
	char no_option[128];
	int retval = 0;
	char *opt;

	if (*set_value != -1)
		/* option has been set by RTLA already */
		return *set_value;

	if (*orig_value != -1)
		/* RTLA has already read the option */
		return *orig_value;

	/* current value is not known to RTLA yet, read it from tracefs */
	options = tracefs_instance_file_read(NULL, "osnoise/options", NULL);
	if (!options)
		return -1;

	/*
	 * Check first if the option is disabled.
	 */
	snprintf(no_option, sizeof(no_option), "NO_%s", option);

	opt = strstr(options, no_option);
	if (opt)
		goto out_free;

	/*
	 * Now that it is not disabled, if the string is there, it is
	 * enabled. If the string is not there, the option does not exist.
	 */
	opt = strstr(options, option);
	if (opt)
		retval = 1;
	else
		retval = -1;

out_free:
	free(options);

	if (retval < 0)
		goto out_err;

	/* save the value and return it */
	*orig_value = retval;
	return retval;

out_err:
	return -1;
}

/**
 * osnoise_set_option - write a boolean flag to osnoise/options
 * @option: the option name string (e.g. "OSNOISE_IRQ_DISABLE")
 * @onoff: the desired state (true to enable, false to disable)
 * @set_value: pointer to the cached value set by RTLA, or -1 if unset
 * @orig_value: pointer to the cached original value read from tracefs, or -1 if unread
 *
 * Sets the flag @option to the state @onoff. Before writing, calls
 * osnoise_get_option() to ensure the original value is cached in @orig_value
 * (enabling later restoration). If the current value already matches @onoff,
 * no write is performed. On successful write, records the new state in
 * @set_value.
 *
 * This is the shared write primitive used by the OSNOISE_FLAG_OPTION-generated
 * set/restore/put functions.
 *
 * Returns 0 on success, -1 on read error (option likely unknown to kernel),
 * or -2 on write error.
 */
static int osnoise_set_option(char *option,
			      bool onoff,
			      int *set_value,
			      int *orig_value)
{
	int curr = osnoise_get_option(option, set_value, orig_value);
	char no_option[128];
	int retval;

	if (curr == -1)
		/* read failed, option likely unknown to kernel */
		return -1;

	if (curr == onoff)
		return 0;

	if (onoff) {
		retval = tracefs_instance_file_write(NULL, "osnoise/options", option);
	} else {
		snprintf(no_option, sizeof(no_option), "NO_%s", option);
		retval = tracefs_instance_file_write(NULL, "osnoise/options", no_option);
	}

	if (retval < 0)
		/* write failed, hard error */
		return -2;

	/* record the set value and return success */
	*set_value = onoff;
	return 0;
}

/**
 * osnoise_restore_option - restore a boolean flag to its original value
 * @option: the option name string (e.g. "OSNOISE_IRQ_DISABLE")
 * @set_value: pointer to the cached value set by RTLA, or -1 if unset
 * @orig_value: pointer to the cached original value read from tracefs, or -1 if unread
 *
 * Restores the flag @option to the state cached in @orig_value (which was saved
 * by a prior osnoise_get_option() or osnoise_set_option() call). If the original
 * was never read, or if the current set value already matches the original, no
 * write is performed. After restoring, clears @set_value to -1 to indicate RTLA
 * no longer overrides this option.
 *
 * This is the shared restore primitive used by the OSNOISE_FLAG_OPTION-generated
 * restore/put functions.
 */
static void osnoise_restore_option(char *option,
				   int *set_value,
				   int *orig_value)
{
	int retval;

	if (*orig_value == -1)
		return;

	if (*orig_value == *set_value)
		goto out_done;

	retval = osnoise_set_option(option, *orig_value, set_value, orig_value);
	if (retval < 0)
		err_msg("Could not restore original %s option\n", option);

out_done:
	*set_value = -1;
}

/*
 * Flag option set/restore/put functions, generated from OSNOISE_FLAG_OPTIONS.
 */
#define OSNOISE_FLAG_OPTION(name, option_str)				\
int osnoise_set_##name(struct osnoise_context *context, bool onoff)	\
{									\
	return osnoise_set_option(option_str,				\
				  onoff,				\
				  &context->opt_##name,			\
				  &context->orig_opt_##name);		\
}									\
									\
void osnoise_restore_##name(struct osnoise_context *context)		\
{									\
	osnoise_restore_option(option_str,				\
			       &context->opt_##name,			\
			       &context->orig_opt_##name);		\
}									\
									\
static void osnoise_put_##name(struct osnoise_context *context)		\
{									\
	osnoise_restore_##name(context);				\
									\
	if (context->orig_opt_##name == -1)				\
		return;							\
									\
	context->orig_opt_##name = -1;					\
}
OSNOISE_FLAG_OPTIONS
#undef OSNOISE_FLAG_OPTION

enum {
	FLAG_CONTEXT_NEWLY_CREATED	= (1 << 0),
	FLAG_CONTEXT_DELETED		= (1 << 1),
};

/*
 * osnoise_get_context - increase the usage of a context and return it
 */
int osnoise_get_context(struct osnoise_context *context)
{
	int ret;

	if (context->flags & FLAG_CONTEXT_DELETED) {
		ret = -1;
	} else {
		context->ref++;
		ret = 0;
	}

	return ret;
}

/*
 * osnoise_context_alloc - alloc an osnoise_context
 *
 * The osnoise context contains the information of the "osnoise/" configs.
 * It is used to set and restore the config.
 */
struct osnoise_context *osnoise_context_alloc(void)
{
	struct osnoise_context *context;

	context = calloc_fatal(1, sizeof(*context));

	/* First allocate manually implemented options... */
	context->orig_runtime_us = -1;
	context->runtime_us	 = -1;
	context->orig_period_us	 = -1;
	context->period_us	 = -1;

	/* ...then the automatically generated ones. */
#define OSNOISE_LL_OPTION(name, path)		\
	context->orig_##name	 = -1;		\
	context->name		 = -1;
#define OSNOISE_FLAG_OPTION(name, option_str)	\
	context->orig_opt_##name = -1;		\
	context->opt_##name	 = -1;
	OSNOISE_LL_OPTIONS
	OSNOISE_FLAG_OPTIONS
#undef OSNOISE_LL_OPTION
#undef OSNOISE_FLAG_OPTION

	osnoise_get_context(context);

	return context;
}

/*
 * osnoise_put_context - put the osnoise_put_context
 *
 * If there is no other user for the context, the original data
 * is restored.
 */
void osnoise_put_context(struct osnoise_context *context)
{
	if (--context->ref < 1)
		context->flags |= FLAG_CONTEXT_DELETED;

	if (!(context->flags & FLAG_CONTEXT_DELETED))
		return;

	/* First restore the original values of the options... */
	osnoise_put_cpus(context);
	osnoise_put_runtime_period(context);

	/* ...then the automatically generated ones. */
#define OSNOISE_LL_OPTION(name, path)		osnoise_put_##name(context);
#define OSNOISE_FLAG_OPTION(name, option_str)	osnoise_put_##name(context);
	OSNOISE_LL_OPTIONS
	OSNOISE_FLAG_OPTIONS
#undef OSNOISE_LL_OPTION
#undef OSNOISE_FLAG_OPTION

	free(context);
}

/*
 * osnoise_destroy_tool - disable trace, restore configs and free data
 */
void osnoise_destroy_tool(struct osnoise_tool *top)
{
	if (!top)
		return;

	trace_instance_destroy(&top->trace);

	if (top->context)
		osnoise_put_context(top->context);

	free(top);
}

/*
 * osnoise_init_tool - init an osnoise tool
 *
 * It allocs data, create a context to store data and
 * creates a new trace instance for the tool.
 */
struct osnoise_tool *osnoise_init_tool(char *tool_name)
{
	struct osnoise_tool *top;

	top = calloc_fatal(1, sizeof(*top));
	top->context = osnoise_context_alloc();

	if (trace_instance_init(&top->trace, tool_name)) {
		osnoise_destroy_tool(top);
		return NULL;
	}

	return top;
}

/*
 * osnoise_init_ipi_filters - Initialize event filtering for IPI events
 */
int osnoise_init_ipi_filters(struct osnoise_tool *tool,
				    struct common_params *params,
				    bool *filters_enabled)
{
	char filter[MAX_PATH];
	int retval;
	/*
	 * If tracing on a subset of possible CPUs, leverage the kernel filtering
	 * infrastructure to only generate events on traced CPUs.
	 * Older kernels (pre v6.6) may have the IPI events but not the ability
	 * to filter them, so allow that to fail gracefully.
	 */

	snprintf(filter, ARRAY_SIZE(filter), "cpu & CPUS{%s}\n", params->cpus);
	retval = tracefs_event_file_write(tool->trace.inst,
					  "ipi", "ipi_send_cpu", "filter",
					  filter);
	if (retval < 0) {
		debug_msg("Could not set ipi_send_cpu CPU filter\n");
		*filters_enabled = false;
		return 0;
	}


	snprintf(filter, ARRAY_SIZE(filter), "cpumask & CPUS{%s}\n", params->cpus);
	retval = tracefs_event_file_write(tool->trace.inst,
					  "ipi", "ipi_send_cpumask", "filter",
					  filter);
	if (retval < 0) {
		/*
		 * If we managed to set up the previous filter but not
		 * this one, something's really wrong
		 */
		err_msg("Could not set ipi_send_cpumask CPU filter\n");
		*filters_enabled = false;
		return -1;
	}

	*filters_enabled = true;
	return 0;
}

/*
 * osnoise_init_trace_tool - init a tracer instance to trace osnoise events
 */
struct osnoise_tool *osnoise_init_trace_tool(struct common_params *params,
					     const char *tracer)
{
	struct osnoise_tool *trace;
	int retval;

	trace = osnoise_init_tool("osnoise_trace");
	if (!trace)
		return NULL;

	retval = tracefs_event_enable(trace->trace.inst, "osnoise", NULL);
	if (retval < 0 && !errno) {
		err_msg("Could not find osnoise events\n");
		goto out_err;
	}

	if (!params->ipi)
		goto done;

	retval = tracefs_event_enable(trace->trace.inst, "ipi", "ipi_send_cpu");
	if (retval < 0 && !errno) {
		err_msg("Could not find ipi_send_cpu event\n");
		goto out_err;
	}

	retval = tracefs_event_enable(trace->trace.inst, "ipi", "ipi_send_cpumask");
	if (retval < 0 && !errno) {
		err_msg("Could not find ipi_send_cpumask event\n");
		goto out_err;
	}

	if (params->cpus) {
		bool unused;

		retval = osnoise_init_ipi_filters(trace, params, &unused);
		if (retval < 0)
			goto out_err;
	}

done:
	retval = enable_tracer_by_name(trace->trace.inst, tracer);
	if (retval) {
		err_msg("Could not enable %s tracer for tracing\n", tracer);
		goto out_err;
	}

	return trace;
out_err:
	osnoise_destroy_tool(trace);
	return NULL;
}

bool osnoise_trace_is_off(struct osnoise_tool *tool, struct osnoise_tool *record)
{
	/*
	 * The tool instance is always present, it is the one used to collect
	 * data.
	 */
	if (!tracefs_trace_is_on(tool->trace.inst))
		return true;

	/*
	 * The trace record instance is only enabled when -t is set. IOW, when the system
	 * is tracing.
	 */
	return record && !tracefs_trace_is_on(record->trace.inst);
}

/*
 * osnoise_report_invalid_events - report number of invalid events
 */
void
osnoise_report_invalid_events(struct osnoise_tool *tool)
{
	unsigned long long total_events;

	if (tool->trace.invalid_events > 0) {
		if (tool->trace.missed_events != UINT64_MAX) {
			total_events = tool->trace.processed_events + tool->trace.invalid_events +
				tool->trace.missed_events;

			printf("%lld (%.2f%%) invalid events, results might not be accurate\n",
				tool->trace.invalid_events,
				(double) tool->trace.invalid_events / total_events * 100.0);
		} else {
			printf("%lld invalid events, results might not be accurate\n",
				tool->trace.invalid_events);
		}
	}
}

/*
 * osnoise_report_missed_events - report number of events dropped by trace
 * buffer
 */
void
osnoise_report_missed_events(struct osnoise_tool *tool)
{
	unsigned long long total_events;

	if (tool->trace.missed_events == UINT64_MAX)
		printf("unknown number of events missed, results might not be accurate\n");
	else if (tool->trace.missed_events > 0) {
		total_events = tool->trace.processed_events + tool->trace.invalid_events +
			tool->trace.missed_events;

		printf("%lld (%.2f%%) events missed, results might not be accurate\n",
		       tool->trace.missed_events,
		       (double) tool->trace.missed_events / total_events * 100.0);
	}
}

/*
 * osnoise_apply_config - apply osnoise configs to the initialized tool
 */
int
osnoise_apply_config(struct osnoise_tool *tool, struct osnoise_params *params)
{
	int retval;

	params->common.kernel_workload = true;

	if (params->runtime || params->period) {
		retval = osnoise_set_runtime_period(tool->context,
						    params->runtime,
						    params->period);
	} else {
		retval = osnoise_set_runtime_period(tool->context,
						    DEFAULT_SAMPLE_PERIOD,
						    DEFAULT_SAMPLE_RUNTIME);
	}

	if (retval) {
		err_msg("Failed to set runtime and/or period\n");
		goto out_err;
	}

	retval = osnoise_set_tracing_thresh(tool->context, params->threshold);
	if (retval) {
		err_msg("Failed to set tracing_thresh\n");
		goto out_err;
	}

	return common_apply_config(tool, &params->common);

out_err:
	return -1;
}

int osnoise_enable(struct osnoise_tool *tool)
{
	struct osnoise_params *params = to_osnoise_params(tool->params);
	int retval;

	/*
	 * Start the tracer here, after having set all instances.
	 *
	 * Let the trace instance start first for the case of hitting a stop
	 * tracing while enabling other instances. The trace instance is the
	 * one with most valuable information.
	 */
	if (tool->record)
		trace_instance_start(&tool->record->trace);
	trace_instance_start(&tool->trace);

	if (params->common.warmup > 0) {
		debug_msg("Warming up for %d seconds\n", params->common.warmup);
		sleep(params->common.warmup);
		if (stop_tracing)
			return -1;

		/*
		 * Clean up the buffer. The osnoise workload do not run
		 * with tracing off to avoid creating a performance penalty
		 * when not needed.
		 */
		retval = tracefs_instance_file_write(tool->trace.inst, "trace", "");
		if (retval < 0) {
			debug_msg("Error cleaning up the buffer");
			return retval;
		}
	}

	retval = osn_set_stop(tool);
	if (retval)
		return retval;

	return 0;
}

__noreturn static void osnoise_usage(int err)
{
	int i;

	static const char *msg[] = {
		"",
		"osnoise version " VERSION,
		"",
		"  usage: [rtla] osnoise [MODE] ...",
		"",
		"  modes:",
		"     top   - prints the summary from osnoise tracer",
		"     hist  - prints a histogram of osnoise samples",
		"",
		"if no MODE is given, the top mode is called, passing the arguments",
		NULL,
	};

	for (i = 0; msg[i]; i++)
		fprintf(stderr, "%s\n", msg[i]);
	exit(err);
}

int osnoise_main(int argc, char *argv[])
{
	if (argc == 0)
		goto usage;

	/*
	 * if osnoise was called without any argument, run the
	 * default cmdline.
	 */
	if (argc == 1) {
		run_tool(&osnoise_top_ops, argc, argv);
		exit(0);
	}

	if ((strcmp(argv[1], "-h") == 0) || (strcmp(argv[1], "--help") == 0)) {
		osnoise_usage(129);
	} else if (str_has_prefix(argv[1], "-")) {
		/* the user skipped the tool, call the default one */
		run_tool(&osnoise_top_ops, argc, argv);
		exit(0);
	} else if (strcmp(argv[1], "top") == 0) {
		run_tool(&osnoise_top_ops, argc-1, &argv[1]);
		exit(0);
	} else if (strcmp(argv[1], "hist") == 0) {
		run_tool(&osnoise_hist_ops, argc-1, &argv[1]);
		exit(0);
	}

usage:
	osnoise_usage(129);
}

int hwnoise_main(int argc, char *argv[])
{
	run_tool(&osnoise_top_ops, argc, argv);
	exit(0);
}