mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-05 02:19:51 +00:00
![Tzvetomir Stoyanov (VMware)](/assets/img/avatar_default.png)
There are internal library functions, which are not declared as a static. They are used inside the library from different files. Hide them from the library users, as they are not part of the API. These functions are made hidden and are renamed without the prefix "tep_": tep_free_plugin_paths tep_peek_char tep_buffer_init tep_get_input_buf_ptr tep_get_input_buf tep_read_token tep_free_token tep_free_event tep_free_format_field __tep_parse_format Link: https://lore.kernel.org/linux-trace-devel/e4afdd82deb5e023d53231bb13e08dca78085fb0.camel@decadent.org.uk/ Reported-by: Ben Hutchings <ben@decadent.org.uk> Signed-off-by: Tzvetomir Stoyanov (VMware) <tz.stoyanov@gmail.com> Reviewed-by: Steven Rostedt (VMware) <rostedt@goodmis.org> Cc: linux-trace-devel@vger.kernel.org Link: http://lore.kernel.org/lkml/20200930110733.280534-1-tz.stoyanov@gmail.com Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
711 lines
15 KiB
C
711 lines
15 KiB
C
// SPDX-License-Identifier: LGPL-2.1
|
|
/*
|
|
* Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
|
|
*
|
|
*/
|
|
|
|
#include <ctype.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <dlfcn.h>
|
|
#include <stdlib.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#include <dirent.h>
|
|
#include <errno.h>
|
|
#include "event-parse.h"
|
|
#include "event-parse-local.h"
|
|
#include "event-utils.h"
|
|
#include "trace-seq.h"
|
|
|
|
#define LOCAL_PLUGIN_DIR ".local/lib/traceevent/plugins/"
|
|
|
|
static struct registered_plugin_options {
|
|
struct registered_plugin_options *next;
|
|
struct tep_plugin_option *options;
|
|
} *registered_options;
|
|
|
|
static struct trace_plugin_options {
|
|
struct trace_plugin_options *next;
|
|
char *plugin;
|
|
char *option;
|
|
char *value;
|
|
} *trace_plugin_options;
|
|
|
|
struct tep_plugin_list {
|
|
struct tep_plugin_list *next;
|
|
char *name;
|
|
void *handle;
|
|
};
|
|
|
|
struct tep_plugins_dir {
|
|
struct tep_plugins_dir *next;
|
|
char *path;
|
|
enum tep_plugin_load_priority prio;
|
|
};
|
|
|
|
static void lower_case(char *str)
|
|
{
|
|
if (!str)
|
|
return;
|
|
for (; *str; str++)
|
|
*str = tolower(*str);
|
|
}
|
|
|
|
static int update_option_value(struct tep_plugin_option *op, const char *val)
|
|
{
|
|
char *op_val;
|
|
|
|
if (!val) {
|
|
/* toggle, only if option is boolean */
|
|
if (op->value)
|
|
/* Warn? */
|
|
return 0;
|
|
op->set ^= 1;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* If the option has a value then it takes a string
|
|
* otherwise the option is a boolean.
|
|
*/
|
|
if (op->value) {
|
|
op->value = val;
|
|
return 0;
|
|
}
|
|
|
|
/* Option is boolean, must be either "1", "0", "true" or "false" */
|
|
|
|
op_val = strdup(val);
|
|
if (!op_val)
|
|
return -1;
|
|
lower_case(op_val);
|
|
|
|
if (strcmp(val, "1") == 0 || strcmp(val, "true") == 0)
|
|
op->set = 1;
|
|
else if (strcmp(val, "0") == 0 || strcmp(val, "false") == 0)
|
|
op->set = 0;
|
|
free(op_val);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* tep_plugin_list_options - get list of plugin options
|
|
*
|
|
* Returns an array of char strings that list the currently registered
|
|
* plugin options in the format of <plugin>:<option>. This list can be
|
|
* used by toggling the option.
|
|
*
|
|
* Returns NULL if there's no options registered. On error it returns
|
|
* INVALID_PLUGIN_LIST_OPTION
|
|
*
|
|
* Must be freed with tep_plugin_free_options_list().
|
|
*/
|
|
char **tep_plugin_list_options(void)
|
|
{
|
|
struct registered_plugin_options *reg;
|
|
struct tep_plugin_option *op;
|
|
char **list = NULL;
|
|
char *name;
|
|
int count = 0;
|
|
|
|
for (reg = registered_options; reg; reg = reg->next) {
|
|
for (op = reg->options; op->name; op++) {
|
|
char *alias = op->plugin_alias ? op->plugin_alias : op->file;
|
|
char **temp = list;
|
|
int ret;
|
|
|
|
ret = asprintf(&name, "%s:%s", alias, op->name);
|
|
if (ret < 0)
|
|
goto err;
|
|
|
|
list = realloc(list, count + 2);
|
|
if (!list) {
|
|
list = temp;
|
|
free(name);
|
|
goto err;
|
|
}
|
|
list[count++] = name;
|
|
list[count] = NULL;
|
|
}
|
|
}
|
|
return list;
|
|
|
|
err:
|
|
while (--count >= 0)
|
|
free(list[count]);
|
|
free(list);
|
|
|
|
return INVALID_PLUGIN_LIST_OPTION;
|
|
}
|
|
|
|
void tep_plugin_free_options_list(char **list)
|
|
{
|
|
int i;
|
|
|
|
if (!list)
|
|
return;
|
|
|
|
if (list == INVALID_PLUGIN_LIST_OPTION)
|
|
return;
|
|
|
|
for (i = 0; list[i]; i++)
|
|
free(list[i]);
|
|
|
|
free(list);
|
|
}
|
|
|
|
static int
|
|
update_option(const char *file, struct tep_plugin_option *option)
|
|
{
|
|
struct trace_plugin_options *op;
|
|
char *plugin;
|
|
int ret = 0;
|
|
|
|
if (option->plugin_alias) {
|
|
plugin = strdup(option->plugin_alias);
|
|
if (!plugin)
|
|
return -1;
|
|
} else {
|
|
char *p;
|
|
plugin = strdup(file);
|
|
if (!plugin)
|
|
return -1;
|
|
p = strstr(plugin, ".");
|
|
if (p)
|
|
*p = '\0';
|
|
}
|
|
|
|
/* first look for named options */
|
|
for (op = trace_plugin_options; op; op = op->next) {
|
|
if (!op->plugin)
|
|
continue;
|
|
if (strcmp(op->plugin, plugin) != 0)
|
|
continue;
|
|
if (strcmp(op->option, option->name) != 0)
|
|
continue;
|
|
|
|
ret = update_option_value(option, op->value);
|
|
if (ret)
|
|
goto out;
|
|
break;
|
|
}
|
|
|
|
/* first look for unnamed options */
|
|
for (op = trace_plugin_options; op; op = op->next) {
|
|
if (op->plugin)
|
|
continue;
|
|
if (strcmp(op->option, option->name) != 0)
|
|
continue;
|
|
|
|
ret = update_option_value(option, op->value);
|
|
break;
|
|
}
|
|
|
|
out:
|
|
free(plugin);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* tep_plugin_add_options - Add a set of options by a plugin
|
|
* @name: The name of the plugin adding the options
|
|
* @options: The set of options being loaded
|
|
*
|
|
* Sets the options with the values that have been added by user.
|
|
*/
|
|
int tep_plugin_add_options(const char *name,
|
|
struct tep_plugin_option *options)
|
|
{
|
|
struct registered_plugin_options *reg;
|
|
|
|
reg = malloc(sizeof(*reg));
|
|
if (!reg)
|
|
return -1;
|
|
reg->next = registered_options;
|
|
reg->options = options;
|
|
registered_options = reg;
|
|
|
|
while (options->name) {
|
|
update_option(name, options);
|
|
options++;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* tep_plugin_remove_options - remove plugin options that were registered
|
|
* @options: Options to removed that were registered with tep_plugin_add_options
|
|
*/
|
|
void tep_plugin_remove_options(struct tep_plugin_option *options)
|
|
{
|
|
struct registered_plugin_options **last;
|
|
struct registered_plugin_options *reg;
|
|
|
|
for (last = ®istered_options; *last; last = &(*last)->next) {
|
|
if ((*last)->options == options) {
|
|
reg = *last;
|
|
*last = reg->next;
|
|
free(reg);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
static int parse_option_name(char **option, char **plugin)
|
|
{
|
|
char *p;
|
|
|
|
*plugin = NULL;
|
|
|
|
if ((p = strstr(*option, ":"))) {
|
|
*plugin = *option;
|
|
*p = '\0';
|
|
*option = strdup(p + 1);
|
|
if (!*option)
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static struct tep_plugin_option *
|
|
find_registered_option(const char *plugin, const char *option)
|
|
{
|
|
struct registered_plugin_options *reg;
|
|
struct tep_plugin_option *op;
|
|
const char *op_plugin;
|
|
|
|
for (reg = registered_options; reg; reg = reg->next) {
|
|
for (op = reg->options; op->name; op++) {
|
|
if (op->plugin_alias)
|
|
op_plugin = op->plugin_alias;
|
|
else
|
|
op_plugin = op->file;
|
|
|
|
if (plugin && strcmp(plugin, op_plugin) != 0)
|
|
continue;
|
|
if (strcmp(option, op->name) != 0)
|
|
continue;
|
|
|
|
return op;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static int process_option(const char *plugin, const char *option, const char *val)
|
|
{
|
|
struct tep_plugin_option *op;
|
|
|
|
op = find_registered_option(plugin, option);
|
|
if (!op)
|
|
return 0;
|
|
|
|
return update_option_value(op, val);
|
|
}
|
|
|
|
/**
|
|
* tep_plugin_add_option - add an option/val pair to set plugin options
|
|
* @name: The name of the option (format: <plugin>:<option> or just <option>)
|
|
* @val: (optional) the value for the option
|
|
*
|
|
* Modify a plugin option. If @val is given than the value of the option
|
|
* is set (note, some options just take a boolean, so @val must be either
|
|
* "1" or "0" or "true" or "false").
|
|
*/
|
|
int tep_plugin_add_option(const char *name, const char *val)
|
|
{
|
|
struct trace_plugin_options *op;
|
|
char *option_str;
|
|
char *plugin;
|
|
|
|
option_str = strdup(name);
|
|
if (!option_str)
|
|
return -ENOMEM;
|
|
|
|
if (parse_option_name(&option_str, &plugin) < 0)
|
|
return -ENOMEM;
|
|
|
|
/* If the option exists, update the val */
|
|
for (op = trace_plugin_options; op; op = op->next) {
|
|
/* Both must be NULL or not NULL */
|
|
if ((!plugin || !op->plugin) && plugin != op->plugin)
|
|
continue;
|
|
if (plugin && strcmp(plugin, op->plugin) != 0)
|
|
continue;
|
|
if (strcmp(op->option, option_str) != 0)
|
|
continue;
|
|
|
|
/* update option */
|
|
free(op->value);
|
|
if (val) {
|
|
op->value = strdup(val);
|
|
if (!op->value)
|
|
goto out_free;
|
|
} else
|
|
op->value = NULL;
|
|
|
|
/* plugin and option_str don't get freed at the end */
|
|
free(plugin);
|
|
free(option_str);
|
|
|
|
plugin = op->plugin;
|
|
option_str = op->option;
|
|
break;
|
|
}
|
|
|
|
/* If not found, create */
|
|
if (!op) {
|
|
op = malloc(sizeof(*op));
|
|
if (!op)
|
|
goto out_free;
|
|
memset(op, 0, sizeof(*op));
|
|
op->plugin = plugin;
|
|
op->option = option_str;
|
|
if (val) {
|
|
op->value = strdup(val);
|
|
if (!op->value) {
|
|
free(op);
|
|
goto out_free;
|
|
}
|
|
}
|
|
op->next = trace_plugin_options;
|
|
trace_plugin_options = op;
|
|
}
|
|
|
|
return process_option(plugin, option_str, val);
|
|
|
|
out_free:
|
|
free(plugin);
|
|
free(option_str);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
static void print_op_data(struct trace_seq *s, const char *name,
|
|
const char *op)
|
|
{
|
|
if (op)
|
|
trace_seq_printf(s, "%8s:\t%s\n", name, op);
|
|
}
|
|
|
|
/**
|
|
* tep_plugin_print_options - print out the registered plugin options
|
|
* @s: The trace_seq descriptor to write the plugin options into
|
|
*
|
|
* Writes a list of options into trace_seq @s.
|
|
*/
|
|
void tep_plugin_print_options(struct trace_seq *s)
|
|
{
|
|
struct registered_plugin_options *reg;
|
|
struct tep_plugin_option *op;
|
|
|
|
for (reg = registered_options; reg; reg = reg->next) {
|
|
if (reg != registered_options)
|
|
trace_seq_printf(s, "============\n");
|
|
for (op = reg->options; op->name; op++) {
|
|
if (op != reg->options)
|
|
trace_seq_printf(s, "------------\n");
|
|
print_op_data(s, "file", op->file);
|
|
print_op_data(s, "plugin", op->plugin_alias);
|
|
print_op_data(s, "option", op->name);
|
|
print_op_data(s, "desc", op->description);
|
|
print_op_data(s, "value", op->value);
|
|
trace_seq_printf(s, "%8s:\t%d\n", "set", op->set);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* tep_print_plugins - print out the list of plugins loaded
|
|
* @s: the trace_seq descripter to write to
|
|
* @prefix: The prefix string to add before listing the option name
|
|
* @suffix: The suffix string ot append after the option name
|
|
* @list: The list of plugins (usually returned by tep_load_plugins()
|
|
*
|
|
* Writes to the trace_seq @s the list of plugins (files) that is
|
|
* returned by tep_load_plugins(). Use @prefix and @suffix for formating:
|
|
* @prefix = " ", @suffix = "\n".
|
|
*/
|
|
void tep_print_plugins(struct trace_seq *s,
|
|
const char *prefix, const char *suffix,
|
|
const struct tep_plugin_list *list)
|
|
{
|
|
while (list) {
|
|
trace_seq_printf(s, "%s%s%s", prefix, list->name, suffix);
|
|
list = list->next;
|
|
}
|
|
}
|
|
|
|
static void
|
|
load_plugin(struct tep_handle *tep, const char *path,
|
|
const char *file, void *data)
|
|
{
|
|
struct tep_plugin_list **plugin_list = data;
|
|
struct tep_plugin_option *options;
|
|
tep_plugin_load_func func;
|
|
struct tep_plugin_list *list;
|
|
const char *alias;
|
|
char *plugin;
|
|
void *handle;
|
|
int ret;
|
|
|
|
ret = asprintf(&plugin, "%s/%s", path, file);
|
|
if (ret < 0) {
|
|
warning("could not allocate plugin memory\n");
|
|
return;
|
|
}
|
|
|
|
handle = dlopen(plugin, RTLD_NOW | RTLD_GLOBAL);
|
|
if (!handle) {
|
|
warning("could not load plugin '%s'\n%s\n",
|
|
plugin, dlerror());
|
|
goto out_free;
|
|
}
|
|
|
|
alias = dlsym(handle, TEP_PLUGIN_ALIAS_NAME);
|
|
if (!alias)
|
|
alias = file;
|
|
|
|
options = dlsym(handle, TEP_PLUGIN_OPTIONS_NAME);
|
|
if (options) {
|
|
while (options->name) {
|
|
ret = update_option(alias, options);
|
|
if (ret < 0)
|
|
goto out_free;
|
|
options++;
|
|
}
|
|
}
|
|
|
|
func = dlsym(handle, TEP_PLUGIN_LOADER_NAME);
|
|
if (!func) {
|
|
warning("could not find func '%s' in plugin '%s'\n%s\n",
|
|
TEP_PLUGIN_LOADER_NAME, plugin, dlerror());
|
|
goto out_free;
|
|
}
|
|
|
|
list = malloc(sizeof(*list));
|
|
if (!list) {
|
|
warning("could not allocate plugin memory\n");
|
|
goto out_free;
|
|
}
|
|
|
|
list->next = *plugin_list;
|
|
list->handle = handle;
|
|
list->name = plugin;
|
|
*plugin_list = list;
|
|
|
|
pr_stat("registering plugin: %s", plugin);
|
|
func(tep);
|
|
return;
|
|
|
|
out_free:
|
|
free(plugin);
|
|
}
|
|
|
|
static void
|
|
load_plugins_dir(struct tep_handle *tep, const char *suffix,
|
|
const char *path,
|
|
void (*load_plugin)(struct tep_handle *tep,
|
|
const char *path,
|
|
const char *name,
|
|
void *data),
|
|
void *data)
|
|
{
|
|
struct dirent *dent;
|
|
struct stat st;
|
|
DIR *dir;
|
|
int ret;
|
|
|
|
ret = stat(path, &st);
|
|
if (ret < 0)
|
|
return;
|
|
|
|
if (!S_ISDIR(st.st_mode))
|
|
return;
|
|
|
|
dir = opendir(path);
|
|
if (!dir)
|
|
return;
|
|
|
|
while ((dent = readdir(dir))) {
|
|
const char *name = dent->d_name;
|
|
|
|
if (strcmp(name, ".") == 0 ||
|
|
strcmp(name, "..") == 0)
|
|
continue;
|
|
|
|
/* Only load plugins that end in suffix */
|
|
if (strcmp(name + (strlen(name) - strlen(suffix)), suffix) != 0)
|
|
continue;
|
|
|
|
load_plugin(tep, path, name, data);
|
|
}
|
|
|
|
closedir(dir);
|
|
}
|
|
|
|
/**
|
|
* tep_load_plugins_hook - call a user specified callback to load a plugin
|
|
* @tep: handler to traceevent context
|
|
* @suffix: filter only plugin files with given suffix
|
|
* @load_plugin: user specified callback, called for each plugin file
|
|
* @data: custom context, passed to @load_plugin
|
|
*
|
|
* Searches for traceevent plugin files and calls @load_plugin for each
|
|
* The order of plugins search is:
|
|
* - Directories, specified in @tep->plugins_dir and priority TEP_PLUGIN_FIRST
|
|
* - Directory, specified at compile time with PLUGIN_TRACEEVENT_DIR
|
|
* - Directory, specified by environment variable TRACEEVENT_PLUGIN_DIR
|
|
* - In user's home: ~/.local/lib/traceevent/plugins/
|
|
* - Directories, specified in @tep->plugins_dir and priority TEP_PLUGIN_LAST
|
|
*
|
|
*/
|
|
void tep_load_plugins_hook(struct tep_handle *tep, const char *suffix,
|
|
void (*load_plugin)(struct tep_handle *tep,
|
|
const char *path,
|
|
const char *name,
|
|
void *data),
|
|
void *data)
|
|
{
|
|
struct tep_plugins_dir *dir = NULL;
|
|
char *home;
|
|
char *path;
|
|
char *envdir;
|
|
int ret;
|
|
|
|
if (tep && tep->flags & TEP_DISABLE_PLUGINS)
|
|
return;
|
|
|
|
if (tep)
|
|
dir = tep->plugins_dir;
|
|
while (dir) {
|
|
if (dir->prio == TEP_PLUGIN_FIRST)
|
|
load_plugins_dir(tep, suffix, dir->path,
|
|
load_plugin, data);
|
|
dir = dir->next;
|
|
}
|
|
|
|
/*
|
|
* If a system plugin directory was defined,
|
|
* check that first.
|
|
*/
|
|
#ifdef PLUGIN_DIR
|
|
if (!tep || !(tep->flags & TEP_DISABLE_SYS_PLUGINS))
|
|
load_plugins_dir(tep, suffix, PLUGIN_DIR,
|
|
load_plugin, data);
|
|
#endif
|
|
|
|
/*
|
|
* Next let the environment-set plugin directory
|
|
* override the system defaults.
|
|
*/
|
|
envdir = getenv("TRACEEVENT_PLUGIN_DIR");
|
|
if (envdir)
|
|
load_plugins_dir(tep, suffix, envdir, load_plugin, data);
|
|
|
|
/*
|
|
* Now let the home directory override the environment
|
|
* or system defaults.
|
|
*/
|
|
home = getenv("HOME");
|
|
if (!home)
|
|
return;
|
|
|
|
ret = asprintf(&path, "%s/%s", home, LOCAL_PLUGIN_DIR);
|
|
if (ret < 0) {
|
|
warning("could not allocate plugin memory\n");
|
|
return;
|
|
}
|
|
|
|
load_plugins_dir(tep, suffix, path, load_plugin, data);
|
|
|
|
if (tep)
|
|
dir = tep->plugins_dir;
|
|
while (dir) {
|
|
if (dir->prio == TEP_PLUGIN_LAST)
|
|
load_plugins_dir(tep, suffix, dir->path,
|
|
load_plugin, data);
|
|
dir = dir->next;
|
|
}
|
|
|
|
free(path);
|
|
}
|
|
|
|
struct tep_plugin_list*
|
|
tep_load_plugins(struct tep_handle *tep)
|
|
{
|
|
struct tep_plugin_list *list = NULL;
|
|
|
|
tep_load_plugins_hook(tep, ".so", load_plugin, &list);
|
|
return list;
|
|
}
|
|
|
|
/**
|
|
* tep_add_plugin_path - Add a new plugin directory.
|
|
* @tep: Trace event handler.
|
|
* @path: Path to a directory. All plugin files in that
|
|
* directory will be loaded.
|
|
*@prio: Load priority of the plugins in that directory.
|
|
*
|
|
* Returns -1 in case of an error, 0 otherwise.
|
|
*/
|
|
int tep_add_plugin_path(struct tep_handle *tep, char *path,
|
|
enum tep_plugin_load_priority prio)
|
|
{
|
|
struct tep_plugins_dir *dir;
|
|
|
|
if (!tep || !path)
|
|
return -1;
|
|
|
|
dir = calloc(1, sizeof(*dir));
|
|
if (!dir)
|
|
return -1;
|
|
|
|
dir->path = strdup(path);
|
|
if (!dir->path) {
|
|
free(dir);
|
|
return -1;
|
|
}
|
|
dir->prio = prio;
|
|
dir->next = tep->plugins_dir;
|
|
tep->plugins_dir = dir;
|
|
|
|
return 0;
|
|
}
|
|
|
|
__hidden void free_tep_plugin_paths(struct tep_handle *tep)
|
|
{
|
|
struct tep_plugins_dir *dir;
|
|
|
|
if (!tep)
|
|
return;
|
|
|
|
dir = tep->plugins_dir;
|
|
while (dir) {
|
|
tep->plugins_dir = tep->plugins_dir->next;
|
|
free(dir->path);
|
|
free(dir);
|
|
dir = tep->plugins_dir;
|
|
}
|
|
}
|
|
|
|
void
|
|
tep_unload_plugins(struct tep_plugin_list *plugin_list, struct tep_handle *tep)
|
|
{
|
|
tep_plugin_unload_func func;
|
|
struct tep_plugin_list *list;
|
|
|
|
while (plugin_list) {
|
|
list = plugin_list;
|
|
plugin_list = list->next;
|
|
func = dlsym(list->handle, TEP_PLUGIN_UNLOADER_NAME);
|
|
if (func)
|
|
func(tep);
|
|
dlclose(list->handle);
|
|
free(list->name);
|
|
free(list);
|
|
}
|
|
}
|