*/
#define _LGPL_SOURCE
+#include "kern-modules.hpp"
+#include "lttng-sessiond.hpp"
+#include "modprobe.hpp"
+
+#include <common/common.hpp>
+#include <common/utils.hpp>
+
#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"
-#include "lttng-sessiond.h"
-
/* LTTng kernel tracer mandatory core modules list */
struct kern_modules_param kern_modules_control_core[] = {
{
/**
* @brief Logging function for libkmod integration.
*/
-static ATTR_FORMAT_PRINTF(6, 0)
-void log_kmod(void *data __attribute__((unused)),
- int priority __attribute__((unused)),
- const char *file __attribute__((unused)),
- int line __attribute__((unused)),
- const char *fn __attribute__((unused)),
- const char *format, va_list args)
+static ATTR_FORMAT_PRINTF(6, 0) void log_kmod(void *data __attribute__((unused)),
+ int priority __attribute__((unused)),
+ const char *file __attribute__((unused)),
+ int line __attribute__((unused)),
+ const char *fn __attribute__((unused)),
+ const char *format,
+ va_list args)
{
char *str;
{
int ret = 0;
- *ctx = kmod_new(NULL, NULL);
+ *ctx = kmod_new(nullptr, nullptr);
if (!ctx) {
PERROR("Unable to create kmod library context");
ret = -ENOMEM;
*/
DIAGNOSTIC_PUSH
DIAGNOSTIC_IGNORE_SUGGEST_ATTRIBUTE_FORMAT
- kmod_set_log_fn(*ctx, log_kmod, NULL);
+ kmod_set_log_fn(*ctx, log_kmod, nullptr);
DIAGNOSTIC_POP
ret = kmod_load_resources(*ctx);
if (ret < 0) {
* @returns \c 0 on success
* \c < 0 on error
*/
-static int modprobe_lttng(struct kern_modules_param *modules,
- int entries)
+static int modprobe_lttng(struct kern_modules_param *modules, int entries)
{
int ret = 0, i;
struct kmod_ctx *ctx;
}
for (i = 0; i < entries; i++) {
- struct kmod_module *mod = NULL;
+ struct kmod_module *mod = nullptr;
ret = kmod_module_new_from_name(ctx, modules[i].name, &mod);
if (ret < 0) {
goto error;
}
- ret = kmod_module_probe_insert_module(mod, 0,
- NULL, NULL, NULL, NULL);
+ ret = kmod_module_probe_insert_module(mod, 0, nullptr, nullptr, nullptr, nullptr);
if (ret == -EEXIST) {
DBG("Module %s is already loaded", modules[i].name);
ret = 0;
} else if (ret < 0) {
if (modules[i].load_policy == KERNEL_MODULE_PROPERTY_LOAD_POLICY_REQUIRED) {
- ERR("Unable to load required module %s",
- modules[i].name);
+ ERR("Unable to load required module %s", modules[i].name);
goto error;
} else {
DBG("Unable to load optional module %s; continuing",
- modules[i].name);
+ modules[i].name);
ret = 0;
}
} else {
* @returns \c 0 on success
* \c < 0 on error
*/
-static int rmmod_recurse(struct kmod_module *mod) {
+static int rmmod_recurse(struct kmod_module *mod)
+{
int ret = 0;
struct kmod_list *deps, *itr;
ret = kmod_module_remove_module(mod, 0);
deps = kmod_module_get_dependencies(mod);
- if (deps != NULL) {
- kmod_list_foreach(itr, deps) {
+ if (deps != nullptr) {
+ kmod_list_foreach(itr, deps)
+ {
struct kmod_module *dep = kmod_module_get_module(itr);
if (kmod_module_get_refcnt(dep) == 0) {
- DBG("Recursive remove module %s",
- kmod_module_get_name(dep));
+ DBG("Recursive remove module %s", kmod_module_get_name(dep));
rmmod_recurse(dep);
}
kmod_module_unref(dep);
* @param entries Number of modules in the list
*
*/
-static void modprobe_remove_lttng(const struct kern_modules_param *modules,
- int entries)
+static void modprobe_remove_lttng(const struct kern_modules_param *modules, int entries)
{
int ret = 0, i;
struct kmod_ctx *ctx;
}
for (i = entries - 1; i >= 0; i--) {
- struct kmod_module *mod = NULL;
+ struct kmod_module *mod = nullptr;
if (!modules[i].loaded) {
continue;
ret = rmmod_recurse(mod);
if (ret == -EEXIST) {
DBG("Module %s is not in kernel.", modules[i].name);
- } else if (modules[i].load_policy == KERNEL_MODULE_PROPERTY_LOAD_POLICY_REQUIRED && ret < 0) {
+ } else if (modules[i].load_policy == KERNEL_MODULE_PROPERTY_LOAD_POLICY_REQUIRED &&
+ ret < 0) {
ERR("Unable to remove module %s", modules[i].name);
} else {
- DBG("Modprobe removal successful %s",
- modules[i].name);
+ DBG("Modprobe removal successful %s", modules[i].name);
}
kmod_module_unref(mod);
#else /* HAVE_KMOD */
-static int modprobe_lttng(struct kern_modules_param *modules,
- int entries)
+static int modprobe_lttng(struct kern_modules_param *modules, int entries)
{
int ret = 0, i;
char modprobe[256];
for (i = 0; i < entries; i++) {
- ret = snprintf(modprobe, sizeof(modprobe),
- "/sbin/modprobe %s%s",
- modules[i].load_policy == KERNEL_MODULE_PROPERTY_LOAD_POLICY_REQUIRED ? "" : "-q ",
- modules[i].name);
+ ret = snprintf(modprobe,
+ sizeof(modprobe),
+ "/sbin/modprobe %s%s",
+ modules[i].load_policy ==
+ KERNEL_MODULE_PROPERTY_LOAD_POLICY_REQUIRED ?
+ "" :
+ "-q ",
+ modules[i].name);
if (ret < 0) {
PERROR("snprintf modprobe");
goto error;
if (ret == -1) {
if (modules[i].load_policy == KERNEL_MODULE_PROPERTY_LOAD_POLICY_REQUIRED) {
ERR("Unable to launch modprobe for required module %s",
- modules[i].name);
+ modules[i].name);
goto error;
} else {
DBG("Unable to launch modprobe for optional module %s; continuing",
- modules[i].name);
+ modules[i].name);
ret = 0;
}
} else if (WEXITSTATUS(ret) != 0) {
if (modules[i].load_policy == KERNEL_MODULE_PROPERTY_LOAD_POLICY_REQUIRED) {
- ERR("Unable to load required module %s",
- modules[i].name);
+ ERR("Unable to load required module %s", modules[i].name);
goto error;
} else {
DBG("Unable to load optional module %s; continuing",
- modules[i].name);
+ modules[i].name);
ret = 0;
}
} else {
return ret;
}
-static void modprobe_remove_lttng(const struct kern_modules_param *modules,
- int entries)
+static void modprobe_remove_lttng(const struct kern_modules_param *modules, int entries)
{
int ret = 0, i;
char modprobe[256];
if (!modules[i].loaded) {
continue;
}
- ret = snprintf(modprobe, sizeof(modprobe),
- "/sbin/modprobe -r -q %s",
- modules[i].name);
+ ret = snprintf(
+ modprobe, sizeof(modprobe), "/sbin/modprobe -r -q %s", modules[i].name);
if (ret < 0) {
PERROR("snprintf modprobe -r");
return;
if (ret == -1) {
if (modules[i].load_policy == KERNEL_MODULE_PROPERTY_LOAD_POLICY_REQUIRED) {
ERR("Unable to launch modprobe -r for required module %s",
- modules[i].name);
+ modules[i].name);
} else {
DBG("Unable to launch modprobe -r for optional module %s",
- modules[i].name);
+ modules[i].name);
}
} else if (WEXITSTATUS(ret) != 0) {
if (modules[i].load_policy == KERNEL_MODULE_PROPERTY_LOAD_POLICY_REQUIRED) {
- ERR("Unable to remove required module %s",
- modules[i].name);
+ ERR("Unable to remove required module %s", modules[i].name);
} else {
- DBG("Unable to remove optional module %s",
- modules[i].name);
+ DBG("Unable to remove optional module %s", modules[i].name);
}
} else {
DBG("Modprobe removal successful %s", modules[i].name);
/*
* Remove control kernel module(s) in reverse load order.
*/
-void modprobe_remove_lttng_control(void)
+void modprobe_remove_lttng_control()
{
- modprobe_remove_lttng(kern_modules_control_core,
- ARRAY_SIZE(kern_modules_control_core));
+ modprobe_remove_lttng(kern_modules_control_core, ARRAY_SIZE(kern_modules_control_core));
}
-static void free_probes(void)
+static void free_probes()
{
int i;
free(probes[i].name);
}
free(probes);
- probes = NULL;
+ probes = nullptr;
nr_probes = 0;
}
/*
* Remove data kernel modules in reverse load order.
*/
-void modprobe_remove_lttng_data(void)
+void modprobe_remove_lttng_data()
{
if (!probes) {
return;
/*
* Remove all kernel modules in reverse order.
*/
-void modprobe_remove_lttng_all(void)
+void modprobe_remove_lttng_all()
{
modprobe_remove_lttng_data();
modprobe_remove_lttng_control();
/*
* Load control kernel module(s).
*/
-int modprobe_lttng_control(void)
+int modprobe_lttng_control()
{
- return modprobe_lttng(kern_modules_control_core,
- ARRAY_SIZE(kern_modules_control_core));
+ return modprobe_lttng(kern_modules_control_core, ARRAY_SIZE(kern_modules_control_core));
}
/**
* Grow global list of probes (double capacity or set it to 1 if
* currently 0 and copy existing data).
*/
-static int grow_probes(void)
+static int grow_probes()
{
int i;
struct kern_modules_param *tmp_probes;
/* Initialize capacity to 1 if 0. */
if (probes_capacity == 0) {
- probes = (kern_modules_param *) zmalloc(sizeof(*probes));
+ probes = zmalloc<kern_modules_param>();
if (!probes) {
PERROR("malloc probe list");
return -ENOMEM;
/* Double size. */
probes_capacity *= 2;
- tmp_probes = (kern_modules_param *) zmalloc(sizeof(*tmp_probes) * probes_capacity);
+ tmp_probes = calloc<kern_modules_param>(probes_capacity);
if (!tmp_probes) {
PERROR("malloc probe list");
return -ENOMEM;
if (!next) {
break;
}
- cur_list = NULL;
+ cur_list = nullptr;
/* filter leading spaces */
while (*next == ' ') {
name_len = strlen(next) + 13;
cur_mod = &probes[nr_probes];
- cur_mod->name = (char *) zmalloc(name_len);
+ cur_mod->name = calloc<char>(name_len);
if (!cur_mod->name) {
PERROR("malloc probe list");
ret = -ENOMEM;
/*
* Load data kernel module(s).
*/
-int modprobe_lttng_data(void)
+int modprobe_lttng_data()
{
int ret, i;
char *list;
/* Default probes. */
int def_len = ARRAY_SIZE(kern_modules_probes_default);
- probes = (kern_modules_param *) zmalloc(sizeof(*probes) * def_len);
+ probes = calloc<kern_modules_param>(def_len);
if (!probes) {
PERROR("malloc probe list");
return -ENOMEM;
nr_probes = probes_capacity = def_len;
for (i = 0; i < def_len; ++i) {
- char* name = strdup(kern_modules_probes_default[i].name);
+ char *name = strdup(kern_modules_probes_default[i].name);
if (!name) {
PERROR("strdup probe item");
projects / lttng-tools.git / blobdiff