kernel/module/kmod.c

   1 /*
   2  * kmod - the kernel module loader
   3  *
   4  * Copyright (C) 2023 Luis Chamberlain <mcgrof@kernel.org>
   5  */
   6
   7 #include <linux/module.h>
   8 #include <linux/sched.h>
   9 #include <linux/sched/task.h>
  10 #include <linux/binfmts.h>
  11 #include <linux/syscalls.h>
  12 #include <linux/unistd.h>
  13 #include <linux/kmod.h>
  14 #include <linux/slab.h>
  15 #include <linux/completion.h>
  16 #include <linux/cred.h>
  17 #include <linux/file.h>
  18 #include <linux/fdtable.h>
  19 #include <linux/workqueue.h>
  20 #include <linux/security.h>
  21 #include <linux/mount.h>
  22 #include <linux/kernel.h>
  23 #include <linux/init.h>
  24 #include <linux/resource.h>
  25 #include <linux/notifier.h>
  26 #include <linux/suspend.h>
  27 #include <linux/rwsem.h>
  28 #include <linux/ptrace.h>
  29 #include <linux/async.h>
  30 #include <linux/uaccess.h>
  31
  32 #include <trace/events/module.h>
  33 #include "internal.h"
  34
  35 /*
  36  * Assuming:
  37  *
  38  * threads = div64_u64((u64) totalram_pages * (u64) PAGE_SIZE,
  39  *                     (u64) THREAD_SIZE * 8UL);
  40  *
  41  * If you need less than 50 threads would mean we're dealing with systems
  42  * smaller than 3200 pages. This assumes you are capable of having ~13M memory,
  43  * and this would only be an upper limit, after which the OOM killer would take
  44  * effect. Systems like these are very unlikely if modules are enabled.
  45  */
  46 #define MAX_KMOD_CONCURRENT 50
  47 static DEFINE_SEMAPHORE(kmod_concurrent_max, MAX_KMOD_CONCURRENT);
  48
  49 /*
  50  * This is a restriction on having *all* MAX_KMOD_CONCURRENT threads
  51  * running at the same time without returning. When this happens we
  52  * believe you've somehow ended up with a recursive module dependency
  53  * creating a loop.
  54  *
  55  * We have no option but to fail.
  56  *
  57  * Userspace should proactively try to detect and prevent these.
  58  */
  59 #define MAX_KMOD_ALL_BUSY_TIMEOUT 5
  60
  61 /*
  62         modprobe_path is set via /proc/sys.
  63 */
  64 char modprobe_path[KMOD_PATH_LEN] = CONFIG_MODPROBE_PATH;
  65
  66 static void free_modprobe_argv(struct subprocess_info *info)
  67 {
  68         kfree(info->argv[3]); /* check call_modprobe() */
  69         kfree(info->argv);
  70 }
  71
  72 static int call_modprobe(char *orig_module_name, int wait)
  73 {
  74         struct subprocess_info *info;
  75         static char *envp[] = {
  76                 "HOME=/",
  77                 "TERM=linux",
  78                 "PATH=/sbin:/usr/sbin:/bin:/usr/bin",
  79                 NULL
  80         };
  81         char *module_name;
  82         int ret;
  83
  84         char **argv = kmalloc(sizeof(char *[5]), GFP_KERNEL);
  85         if (!argv)
  86                 goto out;
  87
  88         module_name = kstrdup(orig_module_name, GFP_KERNEL);
  89         if (!module_name)
  90                 goto free_argv;
  91
  92         argv[0] = modprobe_path;
  93         argv[1] = "-q";
  94         argv[2] = "--";
  95         argv[3] = module_name;  /* check free_modprobe_argv() */
  96         argv[4] = NULL;
  97
  98         info = call_usermodehelper_setup(modprobe_path, argv, envp, GFP_KERNEL,
  99                                          NULL, free_modprobe_argv, NULL);
 100         if (!info)
 101                 goto free_module_name;
 102
 103         ret = call_usermodehelper_exec(info, wait | UMH_KILLABLE);
 104         kmod_dup_request_announce(orig_module_name, ret);
 105         return ret;
 106
 107 free_module_name:
 108         kfree(module_name);
 109 free_argv:
 110         kfree(argv);
 111 out:
 112         kmod_dup_request_announce(orig_module_name, -ENOMEM);
 113         return -ENOMEM;
 114 }
 115
 116 /**
 117  * __request_module - try to load a kernel module
 118  * @wait: wait (or not) for the operation to complete
 119  * @fmt: printf style format string for the name of the module
 120  * @...: arguments as specified in the format string
 121  *
 122  * Load a module using the user mode module loader. The function returns
 123  * zero on success or a negative errno code or positive exit code from
 124  * "modprobe" on failure. Note that a successful module load does not mean
 125  * the module did not then unload and exit on an error of its own. Callers
 126  * must check that the service they requested is now available not blindly
 127  * invoke it.
 128  *
 129  * If module auto-loading support is disabled then this function
 130  * simply returns -ENOENT.
 131  */
 132 int __request_module(bool wait, const char *fmt, ...)
 133 {
 134         va_list args;
 135         char module_name[MODULE_NAME_LEN];
 136         int ret, dup_ret;
 137
 138         /*
 139          * We don't allow synchronous module loading from async.  Module
 140          * init may invoke async_synchronize_full() which will end up
 141          * waiting for this task which already is waiting for the module
 142          * loading to complete, leading to a deadlock.
 143          */
 144         WARN_ON_ONCE(wait && current_is_async());
 145
 146         if (!modprobe_path[0])
 147                 return -ENOENT;
 148
 149         va_start(args, fmt);
 150         ret = vsnprintf(module_name, MODULE_NAME_LEN, fmt, args);
 151         va_end(args);
 152         if (ret >= MODULE_NAME_LEN)
 153                 return -ENAMETOOLONG;
 154
 155         ret = security_kernel_module_request(module_name);
 156         if (ret)
 157                 return ret;
 158
 159         ret = down_timeout(&kmod_concurrent_max, MAX_KMOD_ALL_BUSY_TIMEOUT * HZ);
 160         if (ret) {
 161                 pr_warn_ratelimited("request_module: modprobe %s cannot be processed, kmod busy with %d threads for more than %d seconds now",
 162                                     module_name, MAX_KMOD_CONCURRENT, MAX_KMOD_ALL_BUSY_TIMEOUT);
 163                 return ret;
 164         }
 165
 166         trace_module_request(module_name, wait, _RET_IP_);
 167
 168         if (kmod_dup_request_exists_wait(module_name, wait, &dup_ret)) {
 169                 ret = dup_ret;
 170                 goto out;
 171         }
 172
 173         ret = call_modprobe(module_name, wait ? UMH_WAIT_PROC : UMH_WAIT_EXEC);
 174
 175 out:
 176         up(&kmod_concurrent_max);
 177
 178         return ret;
 179 }
 180 EXPORT_SYMBOL(__request_module);