kernel/kmod.c

   1 /*
   2         kmod, the new module loader (replaces kerneld)
   3         Kirk Petersen
   4
   5         Reorganized not to be a daemon by Adam Richter, with guidance
   6         from Greg Zornetzer.
   7
   8         Modified to avoid chroot and file sharing problems.
   9         Mikael Pettersson
  10
  11         Limit the concurrent number of kmod modprobes to catch loops from
  12         "modprobe needs a service that is in a module".
  13         Keith Owens <kaos@ocs.com.au> December 1999
  14
  15         Unblock all signals when we exec a usermode process.
  16         Shuu Yamaguchi <shuu@wondernetworkresources.com> December 2000
  17 */
  18
  19 #define __KERNEL_SYSCALLS__
  20
  21 #include <linux/config.h>
  22 #include <linux/module.h>
  23 #include <linux/sched.h>
  24 #include <linux/unistd.h>
  25 #include <linux/kmod.h>
  26 #include <linux/smp_lock.h>
  27 #include <linux/slab.h>
  28 #include <linux/namespace.h>
  29 #include <linux/completion.h>
  30
  31 #include <asm/uaccess.h>
  32
  33 extern int max_threads;
  34
  35 static inline void
  36 use_init_fs_context(void)
  37 {
  38         struct fs_struct *our_fs, *init_fs;
  39         struct dentry *root, *pwd;
  40         struct vfsmount *rootmnt, *pwdmnt;
  41         struct namespace *our_ns, *init_ns;
  42
  43         /*
  44          * Make modprobe's fs context be a copy of init's.
  45          *
  46          * We cannot use the user's fs context, because it
  47          * may have a different root than init.
  48          * Since init was created with CLONE_FS, we can grab
  49          * its fs context from "init_task".
  50          *
  51          * The fs context has to be a copy. If it is shared
  52          * with init, then any chdir() call in modprobe will
  53          * also affect init and the other threads sharing
  54          * init_task's fs context.
  55          *
  56          * We created the exec_modprobe thread without CLONE_FS,
  57          * so we can update the fields in our fs context freely.
  58          */
  59
  60         init_fs = init_task.fs;
  61         init_ns = init_task.namespace;
  62         get_namespace(init_ns);
  63         our_ns = current->namespace;
  64         current->namespace = init_ns;
  65         put_namespace(our_ns);
  66         read_lock(&init_fs->lock);
  67         rootmnt = mntget(init_fs->rootmnt);
  68         root = dget(init_fs->root);
  69         pwdmnt = mntget(init_fs->pwdmnt);
  70         pwd = dget(init_fs->pwd);
  71         read_unlock(&init_fs->lock);
  72
  73         /* FIXME - unsafe ->fs access */
  74         our_fs = current->fs;
  75         our_fs->umask = init_fs->umask;
  76         set_fs_root(our_fs, rootmnt, root);
  77         set_fs_pwd(our_fs, pwdmnt, pwd);
  78         write_lock(&our_fs->lock);
  79         if (our_fs->altroot) {
  80                 struct vfsmount *mnt = our_fs->altrootmnt;
  81                 struct dentry *dentry = our_fs->altroot;
  82                 our_fs->altrootmnt = NULL;
  83                 our_fs->altroot = NULL;
  84                 write_unlock(&our_fs->lock);
  85                 dput(dentry);
  86                 mntput(mnt);
  87         } else
  88                 write_unlock(&our_fs->lock);
  89         dput(root);
  90         mntput(rootmnt);
  91         dput(pwd);
  92         mntput(pwdmnt);
  93 }
  94
  95 int exec_usermodehelper(char *program_path, char *argv[], char *envp[])
  96 {
  97         int i;
  98         struct task_struct *curtask = current;
  99
 100         curtask->session = 1;
 101         curtask->pgrp = 1;
 102
 103         use_init_fs_context();
 104
 105         /* Prevent parent user process from sending signals to child.
 106            Otherwise, if the modprobe program does not exist, it might
 107            be possible to get a user defined signal handler to execute
 108            as the super user right after the execve fails if you time
 109            the signal just right.
 110         */
 111         spin_lock_irq(&curtask->sigmask_lock);
 112         sigemptyset(&curtask->blocked);
 113         flush_signals(curtask);
 114         flush_signal_handlers(curtask);
 115         recalc_sigpending(curtask);
 116         spin_unlock_irq(&curtask->sigmask_lock);
 117
 118         for (i = 0; i < curtask->files->max_fds; i++ ) {
 119                 if (curtask->files->fd[i]) close(i);
 120         }
 121
 122         switch_uid(INIT_USER);
 123
 124         /* Give kmod all effective privileges.. */
 125         curtask->euid = curtask->uid = curtask->suid = curtask->fsuid = 0;
 126         curtask->egid = curtask->gid = curtask->sgid = curtask->fsgid = 0;
 127
 128         memcpy(&curtask->rlim, &init_task.rlim, sizeof(struct rlimit)*RLIM_NLIMITS);
 129
 130         curtask->ngroups = 0;
 131
 132         cap_set_full(curtask->cap_effective);
 133
 134         /* Allow execve args to be in kernel space. */
 135         set_fs(KERNEL_DS);
 136
 137         /* Go, go, go... */
 138         if (execve(program_path, argv, envp) < 0)
 139                 return -errno;
 140         return 0;
 141 }
 142
 143 #ifdef CONFIG_KMOD
 144
 145 /*
 146         modprobe_path is set via /proc/sys.
 147 */
 148 char modprobe_path[256] = "/sbin/modprobe";
 149
 150 static int exec_modprobe(void * module_name)
 151 {
 152         static char * envp[] = { "HOME=/", "TERM=linux", "PATH=/sbin:/usr/sbin:/bin:/usr/bin", NULL };
 153         char *argv[] = { modprobe_path, "-s", "-k", "--", (char*)module_name, NULL };
 154         int ret;
 155
 156         ret = exec_usermodehelper(modprobe_path, argv, envp);
 157         if (ret) {
 158                 printk(KERN_ERR
 159                        "kmod: failed to exec %s -s -k %s, errno = %d\n",
 160                        modprobe_path, (char*) module_name, errno);
 161         }
 162         return ret;
 163 }
 164
 165 /**
 166  * request_module - try to load a kernel module
 167  * @module_name: Name of module
 168  *
 169  * Load a module using the user mode module loader. The function returns
 170  * zero on success or a negative errno code on failure. Note that a
 171  * successful module load does not mean the module did not then unload
 172  * and exit on an error of its own. Callers must check that the service
 173  * they requested is now available not blindly invoke it.
 174  *
 175  * If module auto-loading support is disabled then this function
 176  * becomes a no-operation.
 177  */
 178 int request_module(const char * module_name)
 179 {
 180         pid_t pid;
 181         int waitpid_result;
 182         sigset_t tmpsig;
 183         int i;
 184         static atomic_t kmod_concurrent = ATOMIC_INIT(0);
 185 #define MAX_KMOD_CONCURRENT 50  /* Completely arbitrary value - KAO */
 186         static int kmod_loop_msg;
 187
 188         /* Don't allow request_module() before the root fs is mounted!  */
 189         if ( ! current->fs->root ) {
 190                 printk(KERN_ERR "request_module[%s]: Root fs not mounted\n",
 191                         module_name);
 192                 return -EPERM;
 193         }
 194
 195         /* If modprobe needs a service that is in a module, we get a recursive
 196          * loop.  Limit the number of running kmod threads to max_threads/2 or
 197          * MAX_KMOD_CONCURRENT, whichever is the smaller.  A cleaner method
 198          * would be to run the parents of this process, counting how many times
 199          * kmod was invoked.  That would mean accessing the internals of the
 200          * process tables to get the command line, proc_pid_cmdline is static
 201          * and it is not worth changing the proc code just to handle this case.
 202          * KAO.
 203          */
 204         i = max_threads/2;
 205         if (i > MAX_KMOD_CONCURRENT)
 206                 i = MAX_KMOD_CONCURRENT;
 207         atomic_inc(&kmod_concurrent);
 208         if (atomic_read(&kmod_concurrent) > i) {
 209                 if (kmod_loop_msg++ < 5)
 210                         printk(KERN_ERR
 211                                "kmod: runaway modprobe loop assumed and stopped\n");
 212                 atomic_dec(&kmod_concurrent);
 213                 return -ENOMEM;
 214         }
 215
 216         pid = kernel_thread(exec_modprobe, (void*) module_name, 0);
 217         if (pid < 0) {
 218                 printk(KERN_ERR "request_module[%s]: fork failed, errno %d\n", module_name, -pid);
 219                 atomic_dec(&kmod_concurrent);
 220                 return pid;
 221         }
 222
 223         /* Block everything but SIGKILL/SIGSTOP */
 224         spin_lock_irq(&current->sigmask_lock);
 225         tmpsig = current->blocked;
 226         siginitsetinv(&current->blocked, sigmask(SIGKILL) | sigmask(SIGSTOP));
 227         recalc_sigpending(current);
 228         spin_unlock_irq(&current->sigmask_lock);
 229
 230         waitpid_result = waitpid(pid, NULL, __WCLONE);
 231         atomic_dec(&kmod_concurrent);
 232
 233         /* Allow signals again.. */
 234         spin_lock_irq(&current->sigmask_lock);
 235         current->blocked = tmpsig;
 236         recalc_sigpending(current);
 237         spin_unlock_irq(&current->sigmask_lock);
 238
 239         if (waitpid_result != pid) {
 240                 printk(KERN_ERR "request_module[%s]: waitpid(%d,...) failed, errno %d\n",
 241                        module_name, pid, -waitpid_result);
 242         }
 243         return 0;
 244 }
 245 #endif /* CONFIG_KMOD */
 246
 247
 248 #ifdef CONFIG_HOTPLUG
 249 /*
 250         hotplug path is set via /proc/sys
 251         invoked by hotplug-aware bus drivers,
 252         with exec_usermodehelper and some thread-spawner
 253
 254         argv [0] = hotplug_path;
 255         argv [1] = "usb", "scsi", "pci", "network", etc;
 256         ... plus optional type-specific parameters
 257         argv [n] = 0;
 258
 259         envp [*] = HOME, PATH; optional type-specific parameters
 260
 261         a hotplug bus should invoke this for device add/remove
 262         events.  the command is expected to load drivers when
 263         necessary, and may perform additional system setup.
 264 */
 265 char hotplug_path[256] = "/sbin/hotplug";
 266
 267 EXPORT_SYMBOL(hotplug_path);
 268
 269 #endif /* CONFIG_HOTPLUG */
 270
 271 struct subprocess_info {
 272         struct completion *complete;
 273         char *path;
 274         char **argv;
 275         char **envp;
 276         pid_t retval;
 277 };
 278
 279 /*
 280  * This is the task which runs the usermode application
 281  */
 282 static int ____call_usermodehelper(void *data)
 283 {
 284         struct subprocess_info *sub_info = data;
 285         int retval;
 286
 287         retval = -EPERM;
 288         if (current->fs->root)
 289                 retval = exec_usermodehelper(sub_info->path, sub_info->argv, sub_info->envp);
 290
 291         /* Exec failed? */
 292         sub_info->retval = (pid_t)retval;
 293         do_exit(0);
 294 }
 295
 296 /*
 297  * This is run by keventd.
 298  */
 299 static void __call_usermodehelper(void *data)
 300 {
 301         struct subprocess_info *sub_info = data;
 302         pid_t pid;
 303
 304         /*
 305          * CLONE_VFORK: wait until the usermode helper has execve'd successfully
 306          * We need the data structures to stay around until that is done.
 307          */
 308         pid = kernel_thread(____call_usermodehelper, sub_info, CLONE_VFORK | SIGCHLD);
 309         if (pid < 0)
 310                 sub_info->retval = pid;
 311         complete(sub_info->complete);
 312 }
 313
 314 /**
 315  * call_usermodehelper - start a usermode application
 316  * @path: pathname for the application
 317  * @argv: null-terminated argument list
 318  * @envp: null-terminated environment list
 319  *
 320  * Runs a user-space application.  The application is started asynchronously.  It
 321  * runs as a child of keventd.  It runs with full root capabilities.  keventd silently
 322  * reaps the child when it exits.
 323  *
 324  * Must be called from process context.  Returns zero on success, else a negative
 325  * error code.
 326  */
 327 int call_usermodehelper(char *path, char **argv, char **envp)
 328 {
 329         DECLARE_COMPLETION(work);
 330         struct subprocess_info sub_info = {
 331                 complete:       &work,
 332                 path:           path,
 333                 argv:           argv,
 334                 envp:           envp,
 335                 retval:         0,
 336         };
 337         struct tq_struct tqs = {
 338                 routine:        __call_usermodehelper,
 339                 data:           &sub_info,
 340         };
 341
 342         if (path[0] == '\0')
 343                 goto out;
 344
 345         if (current_is_keventd()) {
 346                 /* We can't wait on keventd! */
 347                 __call_usermodehelper(&sub_info);
 348         } else {
 349                 schedule_task(&tqs);
 350                 wait_for_completion(&work);
 351         }
 352 out:
 353         return sub_info.retval;
 354 }
 355
 356 /*
 357  * This is for the serialisation of device probe() functions
 358  * against device open() functions
 359  */
 360 static DECLARE_MUTEX(dev_probe_sem);
 361
 362 void dev_probe_lock(void)
 363 {
 364         down(&dev_probe_sem);
 365 }
 366
 367 void dev_probe_unlock(void)
 368 {
 369         up(&dev_probe_sem);
 370 }
 371
 372 EXPORT_SYMBOL(exec_usermodehelper);
 373 EXPORT_SYMBOL(call_usermodehelper);
 374
 375 #ifdef CONFIG_KMOD
 376 EXPORT_SYMBOL(request_module);
 377 #endif
 378