2018-08-16 23:10:15 +08:00
|
|
|
// SPDX-License-Identifier: LGPL-2.1
|
2013-12-03 21:09:16 +08:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2015-03-24 21:57:54 +08:00
|
|
|
#include <ctype.h>
|
2014-06-04 06:41:54 +08:00
|
|
|
#include <stdio.h>
|
2013-12-03 21:09:16 +08:00
|
|
|
#include <string.h>
|
|
|
|
#include <dlfcn.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <dirent.h>
|
2020-07-03 02:53:48 +08:00
|
|
|
#include <errno.h>
|
2013-12-03 21:09:16 +08:00
|
|
|
#include "event-parse.h"
|
2018-10-06 00:22:25 +08:00
|
|
|
#include "event-parse-local.h"
|
2013-12-03 21:09:16 +08:00
|
|
|
#include "event-utils.h"
|
2018-08-29 06:50:38 +08:00
|
|
|
#include "trace-seq.h"
|
2013-12-03 21:09:16 +08:00
|
|
|
|
2019-08-06 04:43:15 +08:00
|
|
|
#define LOCAL_PLUGIN_DIR ".local/lib/traceevent/plugins/"
|
2013-12-03 21:09:16 +08:00
|
|
|
|
2014-06-04 06:41:54 +08:00
|
|
|
static struct registered_plugin_options {
|
|
|
|
struct registered_plugin_options *next;
|
2018-08-09 02:02:48 +08:00
|
|
|
struct tep_plugin_option *options;
|
2014-06-04 06:41:54 +08:00
|
|
|
} *registered_options;
|
|
|
|
|
|
|
|
static struct trace_plugin_options {
|
|
|
|
struct trace_plugin_options *next;
|
|
|
|
char *plugin;
|
|
|
|
char *option;
|
|
|
|
char *value;
|
|
|
|
} *trace_plugin_options;
|
|
|
|
|
2018-09-20 02:56:56 +08:00
|
|
|
struct tep_plugin_list {
|
|
|
|
struct tep_plugin_list *next;
|
2013-12-03 21:09:16 +08:00
|
|
|
char *name;
|
|
|
|
void *handle;
|
|
|
|
};
|
|
|
|
|
2020-07-03 02:53:49 +08:00
|
|
|
struct tep_plugins_dir {
|
|
|
|
struct tep_plugins_dir *next;
|
|
|
|
char *path;
|
|
|
|
enum tep_plugin_load_priority prio;
|
|
|
|
};
|
|
|
|
|
2015-03-24 21:57:54 +08:00
|
|
|
static void lower_case(char *str)
|
|
|
|
{
|
|
|
|
if (!str)
|
|
|
|
return;
|
|
|
|
for (; *str; str++)
|
|
|
|
*str = tolower(*str);
|
|
|
|
}
|
|
|
|
|
2018-08-09 02:02:48 +08:00
|
|
|
static int update_option_value(struct tep_plugin_option *op, const char *val)
|
2015-03-24 21:57:54 +08:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2014-06-04 06:41:54 +08:00
|
|
|
/**
|
2018-08-09 02:03:00 +08:00
|
|
|
* tep_plugin_list_options - get list of plugin options
|
2014-06-04 06:41:54 +08:00
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*
|
2018-08-09 02:03:00 +08:00
|
|
|
* Must be freed with tep_plugin_free_options_list().
|
2014-06-04 06:41:54 +08:00
|
|
|
*/
|
2018-08-09 02:03:00 +08:00
|
|
|
char **tep_plugin_list_options(void)
|
2014-06-04 06:41:54 +08:00
|
|
|
{
|
|
|
|
struct registered_plugin_options *reg;
|
2018-08-09 02:02:48 +08:00
|
|
|
struct tep_plugin_option *op;
|
2014-06-04 06:41:54 +08:00
|
|
|
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;
|
2018-01-12 08:47:48 +08:00
|
|
|
int ret;
|
2014-06-04 06:41:54 +08:00
|
|
|
|
2018-01-12 08:47:48 +08:00
|
|
|
ret = asprintf(&name, "%s:%s", alias, op->name);
|
|
|
|
if (ret < 0)
|
2014-06-04 06:41:54 +08:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2018-08-09 02:03:00 +08:00
|
|
|
void tep_plugin_free_options_list(char **list)
|
2014-06-04 06:41:54 +08:00
|
|
|
{
|
|
|
|
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
|
2018-08-09 02:02:48 +08:00
|
|
|
update_option(const char *file, struct tep_plugin_option *option)
|
2014-06-04 06:41:54 +08:00
|
|
|
{
|
|
|
|
struct trace_plugin_options *op;
|
|
|
|
char *plugin;
|
2015-03-24 21:57:54 +08:00
|
|
|
int ret = 0;
|
2014-06-04 06:41:54 +08:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
2015-03-24 21:57:54 +08:00
|
|
|
ret = update_option_value(option, op->value);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
break;
|
2014-06-04 06:41:54 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
2015-03-24 21:57:54 +08:00
|
|
|
ret = update_option_value(option, op->value);
|
2014-06-04 06:41:54 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
free(plugin);
|
2015-03-24 21:57:54 +08:00
|
|
|
return ret;
|
2014-06-04 06:41:54 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2018-08-09 02:03:00 +08:00
|
|
|
* tep_plugin_add_options - Add a set of options by a plugin
|
2014-06-04 06:41:54 +08:00
|
|
|
* @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.
|
|
|
|
*/
|
2018-08-09 02:03:00 +08:00
|
|
|
int tep_plugin_add_options(const char *name,
|
|
|
|
struct tep_plugin_option *options)
|
2014-06-04 06:41:54 +08:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2018-08-09 02:03:00 +08:00
|
|
|
* tep_plugin_remove_options - remove plugin options that were registered
|
|
|
|
* @options: Options to removed that were registered with tep_plugin_add_options
|
2014-06-04 06:41:54 +08:00
|
|
|
*/
|
2018-08-09 02:03:00 +08:00
|
|
|
void tep_plugin_remove_options(struct tep_plugin_option *options)
|
2014-06-04 06:41:54 +08:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-22 09:16:45 +08:00
|
|
|
static int parse_option_name(char **option, char **plugin)
|
2020-07-03 02:53:48 +08:00
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
|
|
|
|
*plugin = NULL;
|
|
|
|
|
|
|
|
if ((p = strstr(*option, ":"))) {
|
|
|
|
*plugin = *option;
|
|
|
|
*p = '\0';
|
|
|
|
*option = strdup(p + 1);
|
|
|
|
if (!*option)
|
2020-07-22 09:16:45 +08:00
|
|
|
return -1;
|
2020-07-03 02:53:48 +08:00
|
|
|
}
|
2020-07-22 09:16:45 +08:00
|
|
|
return 0;
|
2020-07-03 02:53:48 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
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>)
|
2020-07-22 09:16:46 +08:00
|
|
|
* @val: (optional) the value for the option
|
2020-07-03 02:53:48 +08:00
|
|
|
*
|
|
|
|
* 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;
|
|
|
|
|
2020-07-22 09:16:45 +08:00
|
|
|
if (parse_option_name(&option_str, &plugin) < 0)
|
|
|
|
return -ENOMEM;
|
2020-07-03 02:53:48 +08:00
|
|
|
|
|
|
|
/* 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)
|
2020-07-22 09:16:47 +08:00
|
|
|
goto out_free;
|
2020-07-03 02:53:48 +08:00
|
|
|
memset(op, 0, sizeof(*op));
|
|
|
|
op->plugin = plugin;
|
|
|
|
op->option = option_str;
|
|
|
|
if (val) {
|
|
|
|
op->value = strdup(val);
|
2020-07-22 09:16:47 +08:00
|
|
|
if (!op->value) {
|
|
|
|
free(op);
|
2020-07-03 02:53:48 +08:00
|
|
|
goto out_free;
|
2020-07-22 09:16:47 +08:00
|
|
|
}
|
2020-07-03 02:53:48 +08:00
|
|
|
}
|
2020-07-22 09:16:47 +08:00
|
|
|
op->next = trace_plugin_options;
|
|
|
|
trace_plugin_options = op;
|
2020-07-03 02:53:48 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return process_option(plugin, option_str, val);
|
2020-07-22 09:16:47 +08:00
|
|
|
|
|
|
|
out_free:
|
|
|
|
free(plugin);
|
2020-07-03 02:53:48 +08:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-04 06:41:54 +08:00
|
|
|
/**
|
2018-08-09 02:03:00 +08:00
|
|
|
* tep_print_plugins - print out the list of plugins loaded
|
2014-06-04 06:41:54 +08:00
|
|
|
* @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
|
2018-08-09 02:02:56 +08:00
|
|
|
* @list: The list of plugins (usually returned by tep_load_plugins()
|
2014-06-04 06:41:54 +08:00
|
|
|
*
|
|
|
|
* Writes to the trace_seq @s the list of plugins (files) that is
|
2018-08-09 02:02:56 +08:00
|
|
|
* returned by tep_load_plugins(). Use @prefix and @suffix for formating:
|
2014-06-04 06:41:54 +08:00
|
|
|
* @prefix = " ", @suffix = "\n".
|
|
|
|
*/
|
2018-08-09 02:03:00 +08:00
|
|
|
void tep_print_plugins(struct trace_seq *s,
|
|
|
|
const char *prefix, const char *suffix,
|
2018-09-20 02:56:56 +08:00
|
|
|
const struct tep_plugin_list *list)
|
2014-06-04 06:41:54 +08:00
|
|
|
{
|
|
|
|
while (list) {
|
|
|
|
trace_seq_printf(s, "%s%s%s", prefix, list->name, suffix);
|
|
|
|
list = list->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-12-03 21:09:16 +08:00
|
|
|
static void
|
2019-04-02 00:43:20 +08:00
|
|
|
load_plugin(struct tep_handle *tep, const char *path,
|
2013-12-03 21:09:16 +08:00
|
|
|
const char *file, void *data)
|
|
|
|
{
|
2018-09-20 02:56:56 +08:00
|
|
|
struct tep_plugin_list **plugin_list = data;
|
2020-07-03 02:53:48 +08:00
|
|
|
struct tep_plugin_option *options;
|
2018-08-09 02:02:48 +08:00
|
|
|
tep_plugin_load_func func;
|
2018-09-20 02:56:56 +08:00
|
|
|
struct tep_plugin_list *list;
|
2013-12-03 21:09:16 +08:00
|
|
|
const char *alias;
|
|
|
|
char *plugin;
|
|
|
|
void *handle;
|
2018-01-12 08:47:48 +08:00
|
|
|
int ret;
|
2013-12-03 21:09:16 +08:00
|
|
|
|
2018-01-12 08:47:48 +08:00
|
|
|
ret = asprintf(&plugin, "%s/%s", path, file);
|
|
|
|
if (ret < 0) {
|
2013-12-03 21:09:36 +08:00
|
|
|
warning("could not allocate plugin memory\n");
|
|
|
|
return;
|
|
|
|
}
|
2013-12-03 21:09:16 +08:00
|
|
|
|
|
|
|
handle = dlopen(plugin, RTLD_NOW | RTLD_GLOBAL);
|
|
|
|
if (!handle) {
|
|
|
|
warning("could not load plugin '%s'\n%s\n",
|
|
|
|
plugin, dlerror());
|
|
|
|
goto out_free;
|
|
|
|
}
|
|
|
|
|
2018-08-09 02:02:48 +08:00
|
|
|
alias = dlsym(handle, TEP_PLUGIN_ALIAS_NAME);
|
2013-12-03 21:09:16 +08:00
|
|
|
if (!alias)
|
|
|
|
alias = file;
|
|
|
|
|
2020-07-03 02:53:48 +08:00
|
|
|
options = dlsym(handle, TEP_PLUGIN_OPTIONS_NAME);
|
|
|
|
if (options) {
|
|
|
|
while (options->name) {
|
|
|
|
ret = update_option(alias, options);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out_free;
|
|
|
|
options++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-09 02:02:48 +08:00
|
|
|
func = dlsym(handle, TEP_PLUGIN_LOADER_NAME);
|
2013-12-03 21:09:16 +08:00
|
|
|
if (!func) {
|
|
|
|
warning("could not find func '%s' in plugin '%s'\n%s\n",
|
2018-08-09 02:02:48 +08:00
|
|
|
TEP_PLUGIN_LOADER_NAME, plugin, dlerror());
|
2013-12-03 21:09:16 +08:00
|
|
|
goto out_free;
|
|
|
|
}
|
|
|
|
|
2013-12-03 21:09:36 +08:00
|
|
|
list = malloc(sizeof(*list));
|
|
|
|
if (!list) {
|
|
|
|
warning("could not allocate plugin memory\n");
|
|
|
|
goto out_free;
|
|
|
|
}
|
|
|
|
|
2013-12-03 21:09:16 +08:00
|
|
|
list->next = *plugin_list;
|
|
|
|
list->handle = handle;
|
|
|
|
list->name = plugin;
|
|
|
|
*plugin_list = list;
|
|
|
|
|
|
|
|
pr_stat("registering plugin: %s", plugin);
|
2019-04-02 00:43:20 +08:00
|
|
|
func(tep);
|
2013-12-03 21:09:16 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
out_free:
|
|
|
|
free(plugin);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2019-04-02 00:43:20 +08:00
|
|
|
load_plugins_dir(struct tep_handle *tep, const char *suffix,
|
2013-12-03 21:09:16 +08:00
|
|
|
const char *path,
|
2019-04-02 00:43:20 +08:00
|
|
|
void (*load_plugin)(struct tep_handle *tep,
|
2013-12-03 21:09:16 +08:00
|
|
|
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;
|
|
|
|
|
2019-04-02 00:43:20 +08:00
|
|
|
load_plugin(tep, path, name, data);
|
2013-12-03 21:09:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
closedir(dir);
|
|
|
|
}
|
|
|
|
|
2020-07-22 09:16:44 +08:00
|
|
|
/**
|
|
|
|
* 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
|
|
|
|
*
|
|
|
|
*/
|
2020-07-03 02:53:47 +08:00
|
|
|
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)
|
2013-12-03 21:09:16 +08:00
|
|
|
{
|
2020-07-03 02:53:49 +08:00
|
|
|
struct tep_plugins_dir *dir = NULL;
|
2013-12-03 21:09:16 +08:00
|
|
|
char *home;
|
|
|
|
char *path;
|
|
|
|
char *envdir;
|
2018-01-12 08:47:48 +08:00
|
|
|
int ret;
|
2013-12-03 21:09:16 +08:00
|
|
|
|
2020-07-03 02:53:47 +08:00
|
|
|
if (tep && tep->flags & TEP_DISABLE_PLUGINS)
|
2014-06-03 11:20:13 +08:00
|
|
|
return;
|
|
|
|
|
2020-07-03 02:53:49 +08:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2013-12-03 21:09:16 +08:00
|
|
|
/*
|
|
|
|
* If a system plugin directory was defined,
|
|
|
|
* check that first.
|
|
|
|
*/
|
|
|
|
#ifdef PLUGIN_DIR
|
2020-07-03 02:53:47 +08:00
|
|
|
if (!tep || !(tep->flags & TEP_DISABLE_SYS_PLUGINS))
|
2019-04-02 00:43:20 +08:00
|
|
|
load_plugins_dir(tep, suffix, PLUGIN_DIR,
|
2014-06-03 11:20:13 +08:00
|
|
|
load_plugin, data);
|
2013-12-03 21:09:16 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Next let the environment-set plugin directory
|
|
|
|
* override the system defaults.
|
|
|
|
*/
|
|
|
|
envdir = getenv("TRACEEVENT_PLUGIN_DIR");
|
|
|
|
if (envdir)
|
2019-04-02 00:43:20 +08:00
|
|
|
load_plugins_dir(tep, suffix, envdir, load_plugin, data);
|
2013-12-03 21:09:16 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Now let the home directory override the environment
|
|
|
|
* or system defaults.
|
|
|
|
*/
|
|
|
|
home = getenv("HOME");
|
|
|
|
if (!home)
|
|
|
|
return;
|
|
|
|
|
2018-01-12 08:47:48 +08:00
|
|
|
ret = asprintf(&path, "%s/%s", home, LOCAL_PLUGIN_DIR);
|
|
|
|
if (ret < 0) {
|
2013-12-03 21:09:36 +08:00
|
|
|
warning("could not allocate plugin memory\n");
|
|
|
|
return;
|
|
|
|
}
|
2013-12-03 21:09:16 +08:00
|
|
|
|
2019-04-02 00:43:20 +08:00
|
|
|
load_plugins_dir(tep, suffix, path, load_plugin, data);
|
2013-12-03 21:09:16 +08:00
|
|
|
|
2020-07-03 02:53:49 +08:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2013-12-03 21:09:16 +08:00
|
|
|
free(path);
|
|
|
|
}
|
|
|
|
|
2018-09-20 02:56:56 +08:00
|
|
|
struct tep_plugin_list*
|
2019-04-02 00:43:17 +08:00
|
|
|
tep_load_plugins(struct tep_handle *tep)
|
2013-12-03 21:09:16 +08:00
|
|
|
{
|
2018-09-20 02:56:56 +08:00
|
|
|
struct tep_plugin_list *list = NULL;
|
2013-12-03 21:09:16 +08:00
|
|
|
|
2020-07-03 02:53:47 +08:00
|
|
|
tep_load_plugins_hook(tep, ".so", load_plugin, &list);
|
2013-12-03 21:09:16 +08:00
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
2020-07-03 02:53:49 +08:00
|
|
|
/**
|
|
|
|
* tep_add_plugin_path - Add a new plugin directory.
|
|
|
|
* @tep: Trace event handler.
|
2020-07-22 09:16:50 +08:00
|
|
|
* @path: Path to a directory. All plugin files in that
|
|
|
|
* directory will be loaded.
|
2020-07-03 02:53:49 +08:00
|
|
|
*@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);
|
2020-07-22 09:16:51 +08:00
|
|
|
if (!dir->path) {
|
|
|
|
free(dir);
|
|
|
|
return -1;
|
|
|
|
}
|
2020-07-03 02:53:49 +08:00
|
|
|
dir->prio = prio;
|
|
|
|
dir->next = tep->plugins_dir;
|
|
|
|
tep->plugins_dir = dir;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-09-30 19:07:33 +08:00
|
|
|
__hidden void free_tep_plugin_paths(struct tep_handle *tep)
|
2020-07-03 02:53:49 +08:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-12-03 21:09:16 +08:00
|
|
|
void
|
2019-04-02 00:43:17 +08:00
|
|
|
tep_unload_plugins(struct tep_plugin_list *plugin_list, struct tep_handle *tep)
|
2013-12-03 21:09:16 +08:00
|
|
|
{
|
2018-08-09 02:02:48 +08:00
|
|
|
tep_plugin_unload_func func;
|
2018-09-20 02:56:56 +08:00
|
|
|
struct tep_plugin_list *list;
|
2013-12-03 21:09:16 +08:00
|
|
|
|
|
|
|
while (plugin_list) {
|
|
|
|
list = plugin_list;
|
|
|
|
plugin_list = list->next;
|
2018-08-09 02:02:48 +08:00
|
|
|
func = dlsym(list->handle, TEP_PLUGIN_UNLOADER_NAME);
|
2013-12-03 21:09:16 +08:00
|
|
|
if (func)
|
2019-04-02 00:43:17 +08:00
|
|
|
func(tep);
|
2013-12-03 21:09:16 +08:00
|
|
|
dlclose(list->handle);
|
|
|
|
free(list->name);
|
|
|
|
free(list);
|
|
|
|
}
|
|
|
|
}
|