[mirror_ubuntu-zesty-kernel.git] / tools / lib / traceevent / event-plugin.c

/*
 * Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License (not later!)
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this program; if not,  see <http://www.gnu.org/licenses>
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */

#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 "event-parse.h"
#include "event-utils.h"

#define LOCAL_PLUGIN_DIR ".traceevent/plugins"

static struct registered_plugin_options {
	struct registered_plugin_options	*next;
	struct pevent_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 plugin_list {
	struct plugin_list	*next;
	char			*name;
	void			*handle;
};

static void lower_case(char *str)
{
	if (!str)
		return;
	for (; *str; str++)
		*str = tolower(*str);
}

static int update_option_value(struct pevent_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;
}

/**
 * traceevent_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 traceevent_plugin_free_options_list().
 */
char **traceevent_plugin_list_options(void)
{
	struct registered_plugin_options *reg;
	struct pevent_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;

			name = malloc(strlen(op->name) + strlen(alias) + 2);
			if (!name)
				goto err;

			sprintf(name, "%s:%s", alias, op->name);
			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 traceevent_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 pevent_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;
}

/**
 * traceevent_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 traceevent_plugin_add_options(const char *name,
				  struct pevent_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;
}

/**
 * traceevent_plugin_remove_options - remove plugin options that were registered
 * @options: Options to removed that were registered with traceevent_plugin_add_options
 */
void traceevent_plugin_remove_options(struct pevent_plugin_option *options)
{
	struct registered_plugin_options **last;
	struct registered_plugin_options *reg;

	for (last = &registered_options; *last; last = &(*last)->next) {
		if ((*last)->options == options) {
			reg = *last;
			*last = reg->next;
			free(reg);
			return;
		}
	}
}

/**
 * traceevent_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 traceevent_load_plugins()
 *
 * Writes to the trace_seq @s the list of plugins (files) that is
 * returned by traceevent_load_plugins(). Use @prefix and @suffix for formating:
 * @prefix = "  ", @suffix = "\n".
 */
void traceevent_print_plugins(struct trace_seq *s,
			      const char *prefix, const char *suffix,
			      const struct plugin_list *list)
{
	while (list) {
		trace_seq_printf(s, "%s%s%s", prefix, list->name, suffix);
		list = list->next;
	}
}

static void
load_plugin(struct pevent *pevent, const char *path,
	    const char *file, void *data)
{
	struct plugin_list **plugin_list = data;
	pevent_plugin_load_func func;
	struct plugin_list *list;
	const char *alias;
	char *plugin;
	void *handle;

	plugin = malloc(strlen(path) + strlen(file) + 2);
	if (!plugin) {
		warning("could not allocate plugin memory\n");
		return;
	}

	strcpy(plugin, path);
	strcat(plugin, "/");
	strcat(plugin, file);

	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, PEVENT_PLUGIN_ALIAS_NAME);
	if (!alias)
		alias = file;

	func = dlsym(handle, PEVENT_PLUGIN_LOADER_NAME);
	if (!func) {
		warning("could not find func '%s' in plugin '%s'\n%s\n",
			PEVENT_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(pevent);
	return;

 out_free:
	free(plugin);
}

static void
load_plugins_dir(struct pevent *pevent, const char *suffix,
		 const char *path,
		 void (*load_plugin)(struct pevent *pevent,
				     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(pevent, path, name, data);
	}

	closedir(dir);
}

static void
load_plugins(struct pevent *pevent, const char *suffix,
	     void (*load_plugin)(struct pevent *pevent,
				 const char *path,
				 const char *name,
				 void *data),
	     void *data)
{
	char *home;
	char *path;
	char *envdir;

	if (pevent->flags & PEVENT_DISABLE_PLUGINS)
		return;

	/*
	 * If a system plugin directory was defined,
	 * check that first.
	 */
#ifdef PLUGIN_DIR
	if (!(pevent->flags & PEVENT_DISABLE_SYS_PLUGINS))
		load_plugins_dir(pevent, 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(pevent, suffix, envdir, load_plugin, data);

	/*
	 * Now let the home directory override the environment
	 * or system defaults.
	 */
	home = getenv("HOME");
	if (!home)
		return;

	path = malloc(strlen(home) + strlen(LOCAL_PLUGIN_DIR) + 2);
	if (!path) {
		warning("could not allocate plugin memory\n");
		return;
	}

	strcpy(path, home);
	strcat(path, "/");
	strcat(path, LOCAL_PLUGIN_DIR);

	load_plugins_dir(pevent, suffix, path, load_plugin, data);

	free(path);
}

struct plugin_list*
traceevent_load_plugins(struct pevent *pevent)
{
	struct plugin_list *list = NULL;

	load_plugins(pevent, ".so", load_plugin, &list);
	return list;
}

void
traceevent_unload_plugins(struct plugin_list *plugin_list, struct pevent *pevent)
{
	pevent_plugin_unload_func func;
	struct plugin_list *list;

	while (plugin_list) {
		list = plugin_list;
		plugin_list = list->next;
		func = dlsym(list->handle, PEVENT_PLUGIN_UNLOADER_NAME);
		if (func)
			func(pevent);
		dlclose(list->handle);
		free(list->name);
		free(list);
	}
}
Commit	Line	Data
c877bbd8 JO	1	/*
	2	* Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
	3	*
	4	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	5	* This program is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU Lesser General Public
	7	* License as published by the Free Software Foundation;
	8	* version 2.1 of the License (not later!)
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU Lesser General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU Lesser General Public
	16	* License along with this program; if not, see <http://www.gnu.org/licenses>
	17	*
	18	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	19	*/
	20
5dbcfd93	21	#include <ctype.h>
5827f2fa	22	#include <stdio.h>
c877bbd8 JO	23	#include <string.h>
	24	#include <dlfcn.h>
	25	#include <stdlib.h>
	26	#include <sys/types.h>
	27	#include <sys/stat.h>
	28	#include <unistd.h>
	29	#include <dirent.h>
	30	#include "event-parse.h"
	31	#include "event-utils.h"
	32
	33	#define LOCAL_PLUGIN_DIR ".traceevent/plugins"
	34
5827f2fa SR	35	static struct registered_plugin_options {
	36	struct registered_plugin_options *next;
	37	struct pevent_plugin_option *options;
	38	} *registered_options;
	39
	40	static struct trace_plugin_options {
	41	struct trace_plugin_options *next;
	42	char *plugin;
	43	char *option;
	44	char *value;
	45	} *trace_plugin_options;
	46
c877bbd8 JO	47	struct plugin_list {
	48	struct plugin_list *next;
	49	char *name;
	50	void *handle;
	51	};
	52
5dbcfd93 SR	53	static void lower_case(char *str)
	54	{
	55	if (!str)
	56	return;
	57	for (; *str; str++)
	58	str = tolower(str);
	59	}
	60
	61	static int update_option_value(struct pevent_plugin_option op, const char val)
	62	{
	63	char *op_val;
	64
	65	if (!val) {
	66	/* toggle, only if option is boolean */
	67	if (op->value)
	68	/* Warn? */
	69	return 0;
	70	op->set ^= 1;
	71	return 0;
	72	}
	73
	74	/*
	75	* If the option has a value then it takes a string
	76	* otherwise the option is a boolean.
	77	*/
	78	if (op->value) {
	79	op->value = val;
	80	return 0;
	81	}
	82
	83	/* Option is boolean, must be either "1", "0", "true" or "false" */
	84
	85	op_val = strdup(val);
	86	if (!op_val)
	87	return -1;
	88	lower_case(op_val);
	89
	90	if (strcmp(val, "1") == 0 \|\| strcmp(val, "true") == 0)
	91	op->set = 1;
	92	else if (strcmp(val, "0") == 0 \|\| strcmp(val, "false") == 0)
	93	op->set = 0;
	94	free(op_val);
	95
	96	return 0;
	97	}
	98
5827f2fa SR	99	/**
	100	* traceevent_plugin_list_options - get list of plugin options
	101	*
	102	* Returns an array of char strings that list the currently registered
	103	* plugin options in the format of <plugin>:<option>. This list can be
	104	* used by toggling the option.
	105	*
	106	* Returns NULL if there's no options registered. On error it returns
	107	* INVALID_PLUGIN_LIST_OPTION
	108	*
	109	* Must be freed with traceevent_plugin_free_options_list().
	110	*/
	111	char **traceevent_plugin_list_options(void)
	112	{
	113	struct registered_plugin_options *reg;
	114	struct pevent_plugin_option *op;
	115	char **list = NULL;
	116	char *name;
	117	int count = 0;
	118
	119	for (reg = registered_options; reg; reg = reg->next) {
	120	for (op = reg->options; op->name; op++) {
	121	char *alias = op->plugin_alias ? op->plugin_alias : op->file;
	122	char **temp = list;
	123
	124	name = malloc(strlen(op->name) + strlen(alias) + 2);
	125	if (!name)
	126	goto err;
	127
	128	sprintf(name, "%s:%s", alias, op->name);
	129	list = realloc(list, count + 2);
	130	if (!list) {
	131	list = temp;
	132	free(name);
	133	goto err;
	134	}
	135	list[count++] = name;
	136	list[count] = NULL;
	137	}
	138	}
	139	return list;
	140
	141	err:
	142	while (--count >= 0)
	143	free(list[count]);
	144	free(list);
	145
	146	return INVALID_PLUGIN_LIST_OPTION;
	147	}
	148
	149	void traceevent_plugin_free_options_list(char **list)
	150	{
	151	int i;
	152
	153	if (!list)
	154	return;
	155
	156	if (list == INVALID_PLUGIN_LIST_OPTION)
	157	return;
	158
	159	for (i = 0; list[i]; i++)
	160	free(list[i]);
	161
	162	free(list);
163	}
164
165	static int
166	update_option(const char file, struct pevent_plugin_option option)
167	{
168	struct trace_plugin_options *op;
169	char *plugin;
5dbcfd93	170	int ret = 0;
5827f2fa SR	171
	172	if (option->plugin_alias) {
	173	plugin = strdup(option->plugin_alias);
	174	if (!plugin)
	175	return -1;
	176	} else {
	177	char *p;
	178	plugin = strdup(file);
	179	if (!plugin)
	180	return -1;
	181	p = strstr(plugin, ".");
	182	if (p)
	183	*p = '\0';
	184	}
	185
	186	/* first look for named options */
	187	for (op = trace_plugin_options; op; op = op->next) {
	188	if (!op->plugin)
	189	continue;
	190	if (strcmp(op->plugin, plugin) != 0)
	191	continue;
	192	if (strcmp(op->option, option->name) != 0)
	193	continue;
	194
5dbcfd93 SR	195	ret = update_option_value(option, op->value);
	196	if (ret)
	197	goto out;
	198	break;
5827f2fa SR	199	}
	200
	201	/* first look for unnamed options */
	202	for (op = trace_plugin_options; op; op = op->next) {
	203	if (op->plugin)
	204	continue;
	205	if (strcmp(op->option, option->name) != 0)
	206	continue;
	207
5dbcfd93	208	ret = update_option_value(option, op->value);
5827f2fa SR	209	break;
	210	}
	211
	212	out:
	213	free(plugin);
5dbcfd93	214	return ret;
5827f2fa SR	215	}
	216
	217	/**
	218	* traceevent_plugin_add_options - Add a set of options by a plugin
	219	* @name: The name of the plugin adding the options
	220	* @options: The set of options being loaded
	221	*
	222	* Sets the options with the values that have been added by user.
	223	*/
	224	int traceevent_plugin_add_options(const char *name,
	225	struct pevent_plugin_option *options)
	226	{
	227	struct registered_plugin_options *reg;
	228
	229	reg = malloc(sizeof(*reg));
	230	if (!reg)
	231	return -1;
	232	reg->next = registered_options;
	233	reg->options = options;
	234	registered_options = reg;
	235
	236	while (options->name) {
	237	update_option(name, options);
	238	options++;
	239	}
	240	return 0;
	241	}
	242
	243	/**
	244	* traceevent_plugin_remove_options - remove plugin options that were registered
	245	* @options: Options to removed that were registered with traceevent_plugin_add_options
	246	*/
	247	void traceevent_plugin_remove_options(struct pevent_plugin_option *options)
	248	{
	249	struct registered_plugin_options **last;
	250	struct registered_plugin_options *reg;
	251
	252	for (last = &registered_options; last; last = &(last)->next) {
	253	if ((*last)->options == options) {
	254	reg = *last;
	255	*last = reg->next;
	256	free(reg);
	257	return;
	258	}
	259	}
	260	}
	261
	262	/**
	263	* traceevent_print_plugins - print out the list of plugins loaded
	264	* @s: the trace_seq descripter to write to
	265	* @prefix: The prefix string to add before listing the option name
	266	* @suffix: The suffix string ot append after the option name
	267	* @list: The list of plugins (usually returned by traceevent_load_plugins()
	268	*
	269	* Writes to the trace_seq @s the list of plugins (files) that is
	270	* returned by traceevent_load_plugins(). Use @prefix and @suffix for formating:
	271	* @prefix = " ", @suffix = "\n".
	272	*/
	273	void traceevent_print_plugins(struct trace_seq *s,
	274	const char prefix, const char suffix,
	275	const struct plugin_list *list)
	276	{
	277	while (list) {
	278	trace_seq_printf(s, "%s%s%s", prefix, list->name, suffix);
279	list = list->next;
280	}
281	}
282
c877bbd8 JO	283	static void
	284	load_plugin(struct pevent pevent, const char path,
	285	const char file, void data)
	286	{
	287	struct plugin_list **plugin_list = data;
	288	pevent_plugin_load_func func;
	289	struct plugin_list *list;
	290	const char *alias;
	291	char *plugin;
	292	void *handle;
	293
f9bb36af JO	294	plugin = malloc(strlen(path) + strlen(file) + 2);
	295	if (!plugin) {
	296	warning("could not allocate plugin memory\n");
	297	return;
	298	}
c877bbd8 JO	299
	300	strcpy(plugin, path);
	301	strcat(plugin, "/");
	302	strcat(plugin, file);
	303
	304	handle = dlopen(plugin, RTLD_NOW \| RTLD_GLOBAL);
	305	if (!handle) {
	306	warning("could not load plugin '%s'\n%s\n",
	307	plugin, dlerror());
	308	goto out_free;
	309	}
	310
	311	alias = dlsym(handle, PEVENT_PLUGIN_ALIAS_NAME);
	312	if (!alias)
	313	alias = file;
	314
	315	func = dlsym(handle, PEVENT_PLUGIN_LOADER_NAME);
	316	if (!func) {
	317	warning("could not find func '%s' in plugin '%s'\n%s\n",
	318	PEVENT_PLUGIN_LOADER_NAME, plugin, dlerror());
	319	goto out_free;
	320	}
	321
f9bb36af JO	322	list = malloc(sizeof(*list));
	323	if (!list) {
	324	warning("could not allocate plugin memory\n");
	325	goto out_free;
	326	}
	327
c877bbd8 JO	328	list->next = *plugin_list;
	329	list->handle = handle;
	330	list->name = plugin;
	331	*plugin_list = list;
	332
	333	pr_stat("registering plugin: %s", plugin);
	334	func(pevent);
	335	return;
	336
	337	out_free:
	338	free(plugin);
	339	}
	340
	341	static void
	342	load_plugins_dir(struct pevent pevent, const char suffix,
	343	const char *path,
	344	void (load_plugin)(struct pevent pevent,
	345	const char *path,
	346	const char *name,
	347	void *data),
	348	void *data)
	349	{
	350	struct dirent *dent;
	351	struct stat st;
	352	DIR *dir;
	353	int ret;
	354
	355	ret = stat(path, &st);
	356	if (ret < 0)
	357	return;
	358
	359	if (!S_ISDIR(st.st_mode))
	360	return;
	361
	362	dir = opendir(path);
	363	if (!dir)
	364	return;
	365
	366	while ((dent = readdir(dir))) {
	367	const char *name = dent->d_name;
	368
	369	if (strcmp(name, ".") == 0 \|\|
	370	strcmp(name, "..") == 0)
	371	continue;
	372
	373	/* Only load plugins that end in suffix */
	374	if (strcmp(name + (strlen(name) - strlen(suffix)), suffix) != 0)
	375	continue;
	376
	377	load_plugin(pevent, path, name, data);
	378	}
	379
	380	closedir(dir);
	381	}
	382
	383	static void
	384	load_plugins(struct pevent pevent, const char suffix,
	385	void (load_plugin)(struct pevent pevent,
	386	const char *path,
	387	const char *name,
	388	void *data),
	389	void *data)
	390	{
	391	char *home;
392	char *path;
393	char *envdir;
394
a7c3196c SRRH	395	if (pevent->flags & PEVENT_DISABLE_PLUGINS)
	396	return;
	397
c877bbd8 JO	398	/*
	399	* If a system plugin directory was defined,
	400	* check that first.
	401	*/
	402	#ifdef PLUGIN_DIR
a7c3196c SRRH	403	if (!(pevent->flags & PEVENT_DISABLE_SYS_PLUGINS))
	404	load_plugins_dir(pevent, suffix, PLUGIN_DIR,
	405	load_plugin, data);
c877bbd8 JO	406	#endif
	407
	408	/*
	409	* Next let the environment-set plugin directory
	410	* override the system defaults.
	411	*/
	412	envdir = getenv("TRACEEVENT_PLUGIN_DIR");
	413	if (envdir)
	414	load_plugins_dir(pevent, suffix, envdir, load_plugin, data);
	415
	416	/*
	417	* Now let the home directory override the environment
	418	* or system defaults.
	419	*/
	420	home = getenv("HOME");
	421	if (!home)
	422	return;
	423
f9bb36af JO	424	path = malloc(strlen(home) + strlen(LOCAL_PLUGIN_DIR) + 2);
	425	if (!path) {
	426	warning("could not allocate plugin memory\n");
	427	return;
	428	}
c877bbd8 JO	429
	430	strcpy(path, home);
	431	strcat(path, "/");
	432	strcat(path, LOCAL_PLUGIN_DIR);
	433
	434	load_plugins_dir(pevent, suffix, path, load_plugin, data);
	435
	436	free(path);
	437	}
	438
	439	struct plugin_list*
	440	traceevent_load_plugins(struct pevent *pevent)
	441	{
	442	struct plugin_list *list = NULL;
	443
	444	load_plugins(pevent, ".so", load_plugin, &list);
	445	return list;
	446	}
	447
	448	void
8d0c2224	449	traceevent_unload_plugins(struct plugin_list plugin_list, struct pevent pevent)
c877bbd8 JO	450	{
	451	pevent_plugin_unload_func func;
	452	struct plugin_list *list;
	453
	454	while (plugin_list) {
	455	list = plugin_list;
	456	plugin_list = list->next;
	457	func = dlsym(list->handle, PEVENT_PLUGIN_UNLOADER_NAME);
	458	if (func)
8d0c2224	459	func(pevent);
c877bbd8 JO	460	dlclose(list->handle);
	461	free(list->name);
	462	free(list);
	463	}
	464	}