[lttng-tools.git] / src / bin / lttng-sessiond / modprobe.c

/*
 * Copyright (C) 2011 - David Goulet <dgoulet@efficios.com>
 *               2014 - Jan Glauber <jan.glauber@gmail.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, version 2 only,
 * as published by the Free Software Foundation.
 *
 * 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>

#include <common/common.h>
#include <common/utils.h>

#include "modprobe.h"
#include "kern-modules.h"

#define LTTNG_MOD_REQUIRED	1
#define LTTNG_MOD_OPTIONAL	0

/* LTTng kernel tracer mandatory core modules list */
struct kern_modules_param kern_modules_control_core[] = {
	{ "lttng-tracer" },	/* MUST be loaded first so keep at top */
	{ "lttng-lib-ring-buffer" },
	{ "lttng-ring-buffer-client-discard" },
	{ "lttng-ring-buffer-client-overwrite" },
	{ "lttng-ring-buffer-metadata-client" },
	{ "lttng-ring-buffer-client-mmap-discard" },
	{ "lttng-ring-buffer-client-mmap-overwrite" },
	{ "lttng-ring-buffer-metadata-mmap-client" },
};

/* LTTng kernel tracer optional base modules list */
struct kern_modules_param kern_modules_control_opt[] = {
	{ "lttng-types" },
	{ "lttng-ftrace" },
	{ "lttng-kprobes" },
	{ "lttng-kretprobes" },
};

/* LTTng kernel tracer probe modules list */
struct kern_modules_param kern_modules_probes_default[] = {
	{ "lttng-probe-asoc" },
	{ "lttng-probe-block" },
	{ "lttng-probe-btrfs" },
	{ "lttng-probe-compaction" },
	{ "lttng-probe-ext3" },
	{ "lttng-probe-ext4" },
	{ "lttng-probe-gpio" },
	{ "lttng-probe-irq" },
	{ "lttng-probe-jbd" },
	{ "lttng-probe-jbd2" },
	{ "lttng-probe-kmem" },
	{ "lttng-probe-kvm" },
	{ "lttng-probe-kvm-x86" },
	{ "lttng-probe-kvm-x86-mmu" },
	{ "lttng-probe-lock" },
	{ "lttng-probe-module" },
	{ "lttng-probe-napi" },
	{ "lttng-probe-net" },
	{ "lttng-probe-power" },
	{ "lttng-probe-printk" },
	{ "lttng-probe-random" },
	{ "lttng-probe-rcu" },
	{ "lttng-probe-regmap" },
	{ "lttng-probe-regulator" },
	{ "lttng-probe-rpm" },
	{ "lttng-probe-sched" },
	{ "lttng-probe-scsi" },
	{ "lttng-probe-signal" },
	{ "lttng-probe-skb" },
	{ "lttng-probe-sock" },
	{ "lttng-probe-statedump" },
	{ "lttng-probe-sunrpc" },
	{ "lttng-probe-timer" },
	{ "lttng-probe-udp" },
	{ "lttng-probe-vmscan" },
	{ "lttng-probe-v4l2" },
	{ "lttng-probe-workqueue" },
	{ "lttng-probe-writeback" },
};

/* dynamic probe modules list */
static struct kern_modules_param *probes;
static int nr_probes;

void modprobe_remove_lttng(const struct kern_modules_param *modules,
			   int entries, int required)
{
	int ret = 0, i;
	char modprobe[256];

	for (i = entries - 1; i >= 0; i--) {
		ret = snprintf(modprobe, sizeof(modprobe),
				"/sbin/modprobe -r -q %s",
				modules[i].name);
		if (ret < 0) {
			PERROR("snprintf modprobe -r");
			return;
		}
		modprobe[sizeof(modprobe) - 1] = '\0';
		ret = system(modprobe);
		if (ret == -1) {
			ERR("Unable to launch modprobe -r for module %s",
					modules[i].name);
		} else if (required && WEXITSTATUS(ret) != 0) {
			ERR("Unable to remove module %s",
					modules[i].name);
		} else {
			DBG("Modprobe removal successful %s",
					modules[i].name);
		}
		if (probes)
			free(probes[i].name);
	}
}

/*
 * Remove control kernel module(s) in reverse load order.
 */
void modprobe_remove_lttng_control(void)
{
	modprobe_remove_lttng(kern_modules_control_opt,
			      ARRAY_SIZE(kern_modules_control_opt),
			      LTTNG_MOD_OPTIONAL);
	modprobe_remove_lttng(kern_modules_control_core,
			      ARRAY_SIZE(kern_modules_control_core),
			      LTTNG_MOD_REQUIRED);
}

/*
 * Remove data kernel modules in reverse load order.
 */
void modprobe_remove_lttng_data(void)
{
	if (probes) {
		modprobe_remove_lttng(probes, nr_probes, LTTNG_MOD_OPTIONAL);
		free(probes);
		probes = NULL;
	} else
		modprobe_remove_lttng(kern_modules_probes_default,
				      ARRAY_SIZE(kern_modules_probes_default),
				      LTTNG_MOD_OPTIONAL);
}

/*
 * Remove all kernel modules in reverse order.
 */
void modprobe_remove_lttng_all(void)
{
	modprobe_remove_lttng_data();
	modprobe_remove_lttng_control();
}

#if HAVE_KMOD
#include <libkmod.h>
static void log_kmod(void *data, int priority, const char *file, int line,
		const char *fn, const char *format, va_list args)
{
	char *str;

	if (vasprintf(&str, format, args) < 0) {
		return;
	}

	DBG("libkmod: %s", str);
	free(str);
}
static int modprobe_lttng(struct kern_modules_param *modules,
		int entries, int required)
{
	int ret = 0, i;
	struct kmod_ctx *ctx;

	ctx = kmod_new(NULL, NULL);
	if (!ctx) {
		PERROR("Unable to create kmod library context");
		ret = -ENOMEM;
		goto error;
	}

	kmod_set_log_fn(ctx, log_kmod, NULL);
	kmod_load_resources(ctx);

	for (i = 0; i < entries; i++) {
		struct kmod_module *mod = NULL;

		ret = kmod_module_new_from_name(ctx, modules[i].name, &mod);
		if (ret < 0) {
			PERROR("Failed to create kmod module for %s", modules[i].name);
			goto error;
		}

		ret = kmod_module_probe_insert_module(mod, KMOD_PROBE_IGNORE_LOADED,
				NULL, NULL, NULL, NULL);
		if (required && ret < 0) {
			ERR("Unable to load module %s", modules[i].name);
		} else {
			DBG("Modprobe successfully %s", modules[i].name);
		}

		kmod_module_unref(mod);
	}

error:
	if (ctx) {
		kmod_unref(ctx);
	}
	return ret;
}

#else /* HAVE_KMOD */

static int modprobe_lttng(struct kern_modules_param *modules,
		int entries, int required)
{
	int ret = 0, i;
	char modprobe[256];

	for (i = 0; i < entries; i++) {
		ret = snprintf(modprobe, sizeof(modprobe),
				"/sbin/modprobe %s%s",
				required ? "" : "-q ",
				modules[i].name);
		if (ret < 0) {
			PERROR("snprintf modprobe");
			goto error;
		}
		modprobe[sizeof(modprobe) - 1] = '\0';
		ret = system(modprobe);
		if (ret == -1) {
			ERR("Unable to launch modprobe for module %s",
					modules[i].name);
		} else if (required && WEXITSTATUS(ret) != 0) {
			ERR("Unable to load module %s", modules[i].name);
		} else {
			DBG("Modprobe successfully %s", modules[i].name);
		}
	}

error:
	return ret;
}

#endif /* HAVE_KMOD */

/*
 * Load control kernel module(s).
 */
int modprobe_lttng_control(void)
{
	int ret;

	ret = modprobe_lttng(kern_modules_control_core,
			     ARRAY_SIZE(kern_modules_control_core),
			     LTTNG_MOD_REQUIRED);
	if (ret != 0)
		return ret;
	ret = modprobe_lttng(kern_modules_control_opt,
			     ARRAY_SIZE(kern_modules_control_opt),
			     LTTNG_MOD_OPTIONAL);
	return ret;
}

/*
 * Load data kernel module(s).
 */
int modprobe_lttng_data(void)
{
	int i, ret;
	int entries = ARRAY_SIZE(kern_modules_probes_default);
	char *list, *next;

	/*
	 * First take command line option, if not available take environment
	 * variable.
	 */
	if (kmod_probes_list) {
		list = kmod_probes_list;
	} else {
		list = utils_get_kmod_probes_list();
	}
	/* The default is to load ALL probes */
	if (!list) {
		return modprobe_lttng(kern_modules_probes_default, entries,
				LTTNG_MOD_OPTIONAL);
	}

	/*
	 * A probe list is available, so use it.
	 * The number of probes is limited by the number of probes in the
	 * default list.
	 */
	probes = zmalloc(sizeof(struct kern_modules_param *) * entries);
	if (!probes) {
		PERROR("malloc probe list");
		return -ENOMEM;
	}

	for (i = 0; i < entries; i++) {
		size_t name_len;

		next = strtok(list, ",");
		if (!next) {
			goto out;
		}
		list = NULL;

		/* filter leading spaces */
		while (*next == ' ') {
			next++;
		}

		/* Length 13 is "lttng-probe-" + \0 */
		name_len = strlen(next) + 13;

		probes[i].name = zmalloc(name_len);
		if (!probes[i].name) {
			PERROR("malloc probe list");
			return -ENOMEM;
		}

		ret = snprintf(probes[i].name, name_len, "lttng-probe-%s", next);
		if (ret < 0) {
			PERROR("snprintf modprobe name");
			goto out;
		}
	}

out:
	nr_probes = i;
	return modprobe_lttng(probes, nr_probes, LTTNG_MOD_OPTIONAL);
}
Commit	Line	Data
096102bd DG	1	/*
096102bd DG	2	* Copyright (C) 2011 - David Goulet <dgoulet@efficios.com>
fbb9748b	3	* 2014 - Jan Glauber <jan.glauber@gmail.com>
096102bd	4	*
d14d33bf AM	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License, version 2 only,
	7	* as published by the Free Software Foundation.
096102bd	8	*
d14d33bf AM	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
096102bd	13	*
d14d33bf AM	14	* You should have received a copy of the GNU General Public License along
	15	* with this program; if not, write to the Free Software Foundation, Inc.,
	16	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
096102bd DG	17	*/
	18
	19	#define _GNU_SOURCE
	20	#include <stdio.h>
	21	#include <stdlib.h>
	22	#include <sys/wait.h>
	23
	24	#include <common/common.h>
fbb9748b	25	#include <common/utils.h>
096102bd DG	26
	27	#include "modprobe.h"
	28	#include "kern-modules.h"
	29
ab57d7d3 JG	30	#define LTTNG_MOD_REQUIRED 1
	31	#define LTTNG_MOD_OPTIONAL 0
	32
	33	/* LTTng kernel tracer mandatory core modules list */
	34	struct kern_modules_param kern_modules_control_core[] = {
	35	{ "lttng-tracer" }, /* MUST be loaded first so keep at top */
	36	{ "lttng-lib-ring-buffer" },
	37	{ "lttng-ring-buffer-client-discard" },
	38	{ "lttng-ring-buffer-client-overwrite" },
	39	{ "lttng-ring-buffer-metadata-client" },
	40	{ "lttng-ring-buffer-client-mmap-discard" },
	41	{ "lttng-ring-buffer-client-mmap-overwrite" },
	42	{ "lttng-ring-buffer-metadata-mmap-client" },
	43	};
	44
	45	/* LTTng kernel tracer optional base modules list */
	46	struct kern_modules_param kern_modules_control_opt[] = {
	47	{ "lttng-types" },
	48	{ "lttng-ftrace" },
	49	{ "lttng-kprobes" },
	50	{ "lttng-kretprobes" },
3fa9646c JG	51	};
	52
	53	/* LTTng kernel tracer probe modules list */
fbb9748b	54	struct kern_modules_param kern_modules_probes_default[] = {
ab57d7d3 JG	55	{ "lttng-probe-asoc" },
	56	{ "lttng-probe-block" },
	57	{ "lttng-probe-btrfs" },
	58	{ "lttng-probe-compaction" },
	59	{ "lttng-probe-ext3" },
	60	{ "lttng-probe-ext4" },
	61	{ "lttng-probe-gpio" },
	62	{ "lttng-probe-irq" },
	63	{ "lttng-probe-jbd" },
	64	{ "lttng-probe-jbd2" },
	65	{ "lttng-probe-kmem" },
	66	{ "lttng-probe-kvm" },
	67	{ "lttng-probe-kvm-x86" },
	68	{ "lttng-probe-kvm-x86-mmu" },
	69	{ "lttng-probe-lock" },
	70	{ "lttng-probe-module" },
	71	{ "lttng-probe-napi" },
	72	{ "lttng-probe-net" },
	73	{ "lttng-probe-power" },
	74	{ "lttng-probe-printk" },
	75	{ "lttng-probe-random" },
	76	{ "lttng-probe-rcu" },
	77	{ "lttng-probe-regmap" },
	78	{ "lttng-probe-regulator" },
	79	{ "lttng-probe-rpm" },
	80	{ "lttng-probe-sched" },
	81	{ "lttng-probe-scsi" },
	82	{ "lttng-probe-signal" },
	83	{ "lttng-probe-skb" },
	84	{ "lttng-probe-sock" },
	85	{ "lttng-probe-statedump" },
	86	{ "lttng-probe-sunrpc" },
	87	{ "lttng-probe-timer" },
	88	{ "lttng-probe-udp" },
	89	{ "lttng-probe-vmscan" },
	90	{ "lttng-probe-v4l2" },
	91	{ "lttng-probe-workqueue" },
	92	{ "lttng-probe-writeback" },
096102bd DG	93	};
096102bd DG	94
fbb9748b JG	95	/* dynamic probe modules list */
	96	static struct kern_modules_param *probes;
	97	static int nr_probes;
	98
e23b81ed	99	void modprobe_remove_lttng(const struct kern_modules_param *modules,
ab57d7d3	100	int entries, int required)
096102bd DG	101	{
	102	int ret = 0, i;
	103	char modprobe[256];
	104
e23b81ed	105	for (i = entries - 1; i >= 0; i--) {
096102bd DG	106	ret = snprintf(modprobe, sizeof(modprobe),
096102bd DG	107	"/sbin/modprobe -r -q %s",
e23b81ed	108	modules[i].name);
096102bd DG	109	if (ret < 0) {
096102bd DG	110	PERROR("snprintf modprobe -r");
ab57d7d3	111	return;
096102bd DG	112	}
	113	modprobe[sizeof(modprobe) - 1] = '\0';
	114	ret = system(modprobe);
	115	if (ret == -1) {
	116	ERR("Unable to launch modprobe -r for module %s",
ab57d7d3 JG	117	modules[i].name);
ab57d7d3 JG	118	} else if (required && WEXITSTATUS(ret) != 0) {
096102bd	119	ERR("Unable to remove module %s",
ab57d7d3	120	modules[i].name);
096102bd DG	121	} else {
096102bd DG	122	DBG("Modprobe removal successful %s",
ab57d7d3	123	modules[i].name);
096102bd	124	}
fbb9748b JG	125	if (probes)
fbb9748b JG	126	free(probes[i].name);
096102bd	127	}
e23b81ed JG	128	}
	129
	130	/*
	131	* Remove control kernel module(s) in reverse load order.
	132	*/
	133	void modprobe_remove_lttng_control(void)
	134	{
ab57d7d3	135	modprobe_remove_lttng(kern_modules_control_opt,
fbb9748b JG	136	ARRAY_SIZE(kern_modules_control_opt),
fbb9748b JG	137	LTTNG_MOD_OPTIONAL);
ab57d7d3	138	modprobe_remove_lttng(kern_modules_control_core,
fbb9748b JG	139	ARRAY_SIZE(kern_modules_control_core),
fbb9748b JG	140	LTTNG_MOD_REQUIRED);
096102bd DG	141	}
	142
	143	/*
	144	* Remove data kernel modules in reverse load order.
	145	*/
	146	void modprobe_remove_lttng_data(void)
	147	{
fbb9748b JG	148	if (probes) {
	149	modprobe_remove_lttng(probes, nr_probes, LTTNG_MOD_OPTIONAL);
	150	free(probes);
	151	probes = NULL;
	152	} else
	153	modprobe_remove_lttng(kern_modules_probes_default,
	154	ARRAY_SIZE(kern_modules_probes_default),
	155	LTTNG_MOD_OPTIONAL);
096102bd DG	156	}
	157
	158	/*
	159	* Remove all kernel modules in reverse order.
	160	*/
	161	void modprobe_remove_lttng_all(void)
	162	{
	163	modprobe_remove_lttng_data();
	164	modprobe_remove_lttng_control();
	165	}
	166
234170ac UTL	167	#if HAVE_KMOD
	168	#include <libkmod.h>
	169	static void log_kmod(void data, int priority, const char file, int line,
	170	const char fn, const char format, va_list args)
	171	{
	172	char *str;
	173
	174	if (vasprintf(&str, format, args) < 0) {
	175	return;
	176	}
	177
	178	DBG("libkmod: %s", str);
	179	free(str);
	180	}
	181	static int modprobe_lttng(struct kern_modules_param *modules,
	182	int entries, int required)
	183	{
	184	int ret = 0, i;
	185	struct kmod_ctx *ctx;
	186
	187	ctx = kmod_new(NULL, NULL);
	188	if (!ctx) {
	189	PERROR("Unable to create kmod library context");
	190	ret = -ENOMEM;
	191	goto error;
	192	}
	193
	194	kmod_set_log_fn(ctx, log_kmod, NULL);
	195	kmod_load_resources(ctx);
	196
	197	for (i = 0; i < entries; i++) {
	198	struct kmod_module *mod = NULL;
	199
	200	ret = kmod_module_new_from_name(ctx, modules[i].name, &mod);
	201	if (ret < 0) {
	202	PERROR("Failed to create kmod module for %s", modules[i].name);
	203	goto error;
	204	}
	205
	206	ret = kmod_module_probe_insert_module(mod, KMOD_PROBE_IGNORE_LOADED,
	207	NULL, NULL, NULL, NULL);
	208	if (required && ret < 0) {
	209	ERR("Unable to load module %s", modules[i].name);
	210	} else {
	211	DBG("Modprobe successfully %s", modules[i].name);
	212	}
	213
	214	kmod_module_unref(mod);
	215	}
	216
	217	error:
	218	if (ctx) {
	219	kmod_unref(ctx);
	220	}
	221	return ret;
	222	}
	223
	224	#else /* HAVE_KMOD */
	225
fbb9748b	226	static int modprobe_lttng(struct kern_modules_param *modules,
234170ac	227	int entries, int required)
096102bd DG	228	{
	229	int ret = 0, i;
	230	char modprobe[256];
	231
e23b81ed	232	for (i = 0; i < entries; i++) {
096102bd DG	233	ret = snprintf(modprobe, sizeof(modprobe),
096102bd DG	234	"/sbin/modprobe %s%s",
ab57d7d3	235	required ? "" : "-q ",
e23b81ed	236	modules[i].name);
096102bd DG	237	if (ret < 0) {
	238	PERROR("snprintf modprobe");
	239	goto error;
	240	}
	241	modprobe[sizeof(modprobe) - 1] = '\0';
	242	ret = system(modprobe);
	243	if (ret == -1) {
	244	ERR("Unable to launch modprobe for module %s",
e23b81ed	245	modules[i].name);
ab57d7d3 JG	246	} else if (required && WEXITSTATUS(ret) != 0) {
ab57d7d3 JG	247	ERR("Unable to load module %s", modules[i].name);
096102bd	248	} else {
ab57d7d3	249	DBG("Modprobe successfully %s", modules[i].name);
096102bd DG	250	}
	251	}
	252
	253	error:
	254	return ret;
	255	}
	256
234170ac UTL	257	#endif /* HAVE_KMOD */
234170ac UTL	258
e23b81ed JG	259	/*
	260	* Load control kernel module(s).
	261	*/
	262	int modprobe_lttng_control(void)
	263	{
ab57d7d3 JG	264	int ret;
	265
	266	ret = modprobe_lttng(kern_modules_control_core,
	267	ARRAY_SIZE(kern_modules_control_core),
	268	LTTNG_MOD_REQUIRED);
	269	if (ret != 0)
	270	return ret;
	271	ret = modprobe_lttng(kern_modules_control_opt,
fbb9748b JG	272	ARRAY_SIZE(kern_modules_control_opt),
fbb9748b JG	273	LTTNG_MOD_OPTIONAL);
ab57d7d3	274	return ret;
e23b81ed	275	}
ab57d7d3	276
096102bd DG	277	/*
	278	* Load data kernel module(s).
	279	*/
	280	int modprobe_lttng_data(void)
	281	{
fbb9748b JG	282	int i, ret;
	283	int entries = ARRAY_SIZE(kern_modules_probes_default);
	284	char list, next;
	285
	286	/*
	287	* First take command line option, if not available take environment
	288	* variable.
	289	*/
	290	if (kmod_probes_list) {
	291	list = kmod_probes_list;
	292	} else {
	293	list = utils_get_kmod_probes_list();
	294	}
	295	/* The default is to load ALL probes */
	296	if (!list) {
	297	return modprobe_lttng(kern_modules_probes_default, entries,
	298	LTTNG_MOD_OPTIONAL);
	299	}
	300
	301	/*
	302	* A probe list is available, so use it.
	303	* The number of probes is limited by the number of probes in the
	304	* default list.
	305	*/
	306	probes = zmalloc(sizeof(struct kern_modules_param ) entries);
	307	if (!probes) {
	308	PERROR("malloc probe list");
	309	return -ENOMEM;
	310	}
	311
	312	for (i = 0; i < entries; i++) {
	313	size_t name_len;
	314
	315	next = strtok(list, ",");
	316	if (!next) {
	317	goto out;
	318	}
	319	list = NULL;
	320
	321	/* filter leading spaces */
	322	while (*next == ' ') {
	323	next++;
	324	}
	325
	326	/* Length 13 is "lttng-probe-" + \0 */
	327	name_len = strlen(next) + 13;
	328
	329	probes[i].name = zmalloc(name_len);
	330	if (!probes[i].name) {
	331	PERROR("malloc probe list");
	332	return -ENOMEM;
	333	}
	334
	335	ret = snprintf(probes[i].name, name_len, "lttng-probe-%s", next);
	336	if (ret < 0) {
	337	PERROR("snprintf modprobe name");
	338	goto out;
	339	}
	340	}
	341
	342	out:
	343	nr_probes = i;
	344	return modprobe_lttng(probes, nr_probes, LTTNG_MOD_OPTIONAL);
096102bd	345	}