/* * 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 intupdate_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 voidload_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 voidload_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 voidload_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;} voidtraceevent_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);	}}