Add comments to kmod functions

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

diff --git a/src/bin/lttng-sessiond/modprobe.c b/src/bin/lttng-sessiond/modprobe.c
index 6f9a9978a75496f2510b9302b0b058008d3cc206..3e41f5c1b6539a9eaa3af8706700c074c473c2b9 100644 (file)
--- a/src/bin/lttng-sessiond/modprobe.c
+++ b/src/bin/lttng-sessiond/modprobe.c
@@ -16,6 +16,13 @@
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
+/**
+ * @file modprobe.c
+ *
+ * @brief modprobe related functions.
+ *
+ */
+
 #define _LGPL_SOURCE
 #include <assert.h>
 #include <stdio.h>
@@ -92,6 +99,10 @@ static int probes_capacity;
 
 #if HAVE_KMOD
 #include <libkmod.h>
+
+/**
+ * @brief Logging function for libkmod integration.
+ */
 static void log_kmod(void *data, int priority, const char *file, int line,
                const char *fn, const char *format, va_list args)
 {
@@ -104,21 +115,61 @@ static void log_kmod(void *data, int priority, const char *file, int line,
        DBG("libkmod: %s", str);
        free(str);
 }
-static int modprobe_lttng(struct kern_modules_param *modules,
-               int entries, int required)
+
+/**
+ * @brief Setup the libkmod context.
+ *
+ * Create the context, add a custom logging function and preload the
+ * ressources for faster operation.
+ *
+ * @returns    \c 0 on success
+ *             \c < 0 on error
+ */
+static int setup_kmod_ctx(struct kmod_ctx **ctx)
 {
-       int ret = 0, i;
-       struct kmod_ctx *ctx;
+       int ret = 0;
 
-       ctx = kmod_new(NULL, NULL);
+       *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);
+       kmod_set_log_fn(*ctx, log_kmod, NULL);
+       ret = kmod_load_resources(*ctx);
+       if (ret < 0) {
+               ERR("Failed to load kmod library resources");
+               goto error;
+       }
+
+error:
+       return ret;
+}
+
+/**
+ * @brief Loads the kernel modules in \p modules
+ *
+ * @param modules      List of modules to load
+ * @param entries      Number of modules in the list
+ * @param required     Are the modules required or optionnal
+ *
+ * If the modules are required, we will return with error after the
+ * first failed module load, otherwise we continue loading.
+ *
+ * @returns            \c 0 on success
+ *                     \c < 0 on error
+ */
+static int modprobe_lttng(struct kern_modules_param *modules,
+               int entries, int required)
+{
+       int ret = 0, i;
+       struct kmod_ctx *ctx;
+
+       ret = setup_kmod_ctx(&ctx);
+       if (ret < 0) {
+               goto error;
+       }
 
        for (i = 0; i < entries; i++) {
                struct kmod_module *mod = NULL;
@@ -155,6 +206,93 @@ error:
        return ret;
 }
 
+/**
+ * @brief Recursively unload modules.
+ *
+ * This function implements the same modules unloading behavior as
+ * 'modprobe -r' or rmmod, it will recursevily go trought the \p module
+ * dependencies and unload modules with a refcount of 0.
+ *
+ * @param mod          The module to unload
+ *
+ * @returns            \c 0 on success
+ *                     \c < 0 on error
+ */
+static int rmmod_recurse(struct kmod_module *mod) {
+       int ret = 0;
+       struct kmod_list *deps, *itr;
+
+       if (kmod_module_get_initstate(mod) == KMOD_MODULE_BUILTIN) {
+               DBG("Module %s is builtin", kmod_module_get_name(mod));
+               return ret;
+       }
+
+       ret = kmod_module_remove_module(mod, 0);
+
+       deps = kmod_module_get_dependencies(mod);
+       if (deps != NULL) {
+               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));
+                               rmmod_recurse(dep);
+                       }
+                       kmod_module_unref(dep);
+               }
+               kmod_module_unref_list(deps);
+       }
+
+       return ret;
+}
+
+/**
+ * @brief Unloads the kernel modules in \p modules
+ *
+ * @param modules      List of modules to unload
+ * @param entries      Number of modules in the list
+ * @param required     Are the modules required or optionnal
+ *
+ */
+static void modprobe_remove_lttng(const struct kern_modules_param *modules,
+               int entries, int required)
+{
+       int ret = 0, i;
+       struct kmod_ctx *ctx;
+
+       ret = setup_kmod_ctx(&ctx);
+       if (ret < 0) {
+               goto error;
+       }
+
+       for (i = entries - 1; i >= 0; 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 = rmmod_recurse(mod);
+               if (ret == -EEXIST) {
+                       DBG("Module %s is not in kernel.", modules[i].name);
+               } else if (required && ret < 0) {
+                       ERR("Unable to remove module %s", modules[i].name);
+               } else {
+                       DBG("Modprobe removal successful %s",
+                               modules[i].name);
+               }
+
+               kmod_module_unref(mod);
+       }
+
+error:
+       if (ctx) {
+               kmod_unref(ctx);
+       }
+}
+
 #else /* HAVE_KMOD */
 
 static int modprobe_lttng(struct kern_modules_param *modules,
@@ -203,8 +341,6 @@ error:
        return ret;
 }
 
-#endif /* HAVE_KMOD */
-
 static void modprobe_remove_lttng(const struct kern_modules_param *modules,
                int entries, int required)
 {
@@ -234,6 +370,8 @@ static void modprobe_remove_lttng(const struct kern_modules_param *modules,
        }
 }
 
+#endif /* HAVE_KMOD */
+
 /*
  * Remove control kernel module(s) in reverse load order.
  */