// 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, ¶ms->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);
}