Differences

This shows you the differences between two versions of the page.

--- lk_usermodehelper [2019/02/13 21:26] – [Standard calls] rpjday
+++ lk_usermodehelper [2019/02/14 15:18] (current) – [init/do_mounts_initrd.c] rpjday
@@ Line 42: / Line 42: @@
 ==== Standard calls ====
+Common combination:
 <code>
@@ Line 52: / Line 53: @@
 extern int
 call_usermodehelper_exec(struct subprocess_info *info, int wait);
+</code>
+or combination of the above:
+<code>
 extern int
 call_usermodehelper(const char *path, char **argv, char **envp, int wait);
@@ Line 62: / Line 67: @@
 <code>
-/**
- * call_usermodehelper_setup - prepare to call a usermode helper
- * @path: path to usermode executable
- * @argv: arg vector for process
- * @envp: environment for process
- * @gfp_mask: gfp mask for memory allocation
- * @cleanup: a cleanup function
- * @init: an init function
- * @data: arbitrary context sensitive data
- *
- * Returns either %NULL on allocation failure, or a subprocess_info
- * structure.  This should be passed to call_usermodehelper_exec to
- * exec the process and free the structure.
- *
- * The init function is used to customize the helper process prior to
- * exec.  A non-zero return code causes the process to error out, exit,
- * and return the failure to the calling process
- *
- * The cleanup function is just before ethe subprocess_info is about to
- * be freed.  This can be used for freeing the argv and envp.  The
- * Function must be runnable in either a process context or the
- * context in which call_usermodehelper_exec is called.
- */
 struct subprocess_info *call_usermodehelper_setup(const char *path, char **argv,
 		char **envp, gfp_t gfp_mask,
@@ Line 171: / Line 153: @@
 	helper_unlock();
 	return retval;
+}
+</code>
+==== call_usermodehelper() ====
+Combination of the above two:
+<code>
+int call_usermodehelper(const char *path, char **argv, char **envp, int wait)
+{
+	struct subprocess_info *info;
+	gfp_t gfp_mask = (wait == UMH_NO_WAIT) ? GFP_ATOMIC : GFP_KERNEL;
+	info = call_usermodehelper_setup(path, argv, envp, gfp_mask,
+					 NULL, NULL, NULL);
+	if (info == NULL)
+		return -ENOMEM;
+	return call_usermodehelper_exec(info, wait);
 }
 </code>
@@ Line 222: / Line 223: @@
         sub_info->path = path;
 #endif
+</code>
+===== Examples =====
+==== kernel/kmod.c ====
+<code>
+static int call_modprobe(char *module_name, int wait)
+{
+        struct subprocess_info *info;
+        static char *envp[] = {
+                "HOME=/",
+                "TERM=linux",
+                "PATH=/sbin:/usr/sbin:/bin:/usr/bin",
+                NULL
+        };
+        char **argv = kmalloc(sizeof(char *[5]), GFP_KERNEL);
+        if (!argv)
+                goto out;
+        module_name = kstrdup(module_name, GFP_KERNEL);
+        if (!module_name)
+                goto free_argv;
+        argv[0] = modprobe_path;
+        argv[1] = "-q";
+        argv[2] = "--";
+        argv[3] = module_name;  /* check free_modprobe_argv() */
+        argv[4] = NULL;
+        info = call_usermodehelper_setup(modprobe_path, argv, envp, GFP_KERNEL,
+                                         NULL, free_modprobe_argv, NULL);
+        if (!info)
+                goto free_module_name;
+        return call_usermodehelper_exec(info, wait | UMH_KILLABLE);
+free_module_name:
+        kfree(module_name);
+free_argv:
+        kfree(argv);
+out:
+        return -ENOMEM;
+}
+</code>
+==== drivers/video/fbdev/uvesafb.c ====
+<code>
+static char v86d_path[PATH_MAX] = "/sbin/v86d";
+...
+static int uvesafb_helper_start(void)
+{
+        char *envp[] = {
+                "HOME=/",
+                "PATH=/sbin:/bin",
+                NULL,
+        };
+        char *argv[] = {
+                v86d_path,
+                NULL,
+        };
+        return call_usermodehelper(v86d_path, argv, envp, UMH_WAIT_PROC);
+}
+</code>
+==== drivers/macintosh/windfarm_core.c ====
+<code>
+static int wf_critical_overtemp(void)
+{
+        static char const critical_overtemp_path[] = "/sbin/critical_overtemp";
+        char *argv[] = { (char *)critical_overtemp_path, NULL };
+        static char *envp[] = { "HOME=/",
+                                "TERM=linux",
+                                "PATH=/sbin:/usr/sbin:/bin:/usr/bin",
+                                NULL };
+        return call_usermodehelper(critical_overtemp_path,
+                                   argv, envp, UMH_WAIT_EXEC);
+}
+</code>
+==== init/do_mounts_initrd.c ====
+<code>
+static void __init handle_initrd(void)
+{
+        struct subprocess_info *info;
+        static char *argv[] = { "linuxrc", NULL, };
+        extern char *envp_init[];
+        int error;
+        real_root_dev = new_encode_dev(ROOT_DEV);
+        create_dev("/dev/root.old", Root_RAM0);
+        /* mount initrd on rootfs' /root */
+        mount_block_root("/dev/root.old", root_mountflags & ~MS_RDONLY);
+        ksys_mkdir("/old", 0700);
+        ksys_chdir("/old");
+        /*
+         * In case that a resume from disk is carried out by linuxrc or one of
+         * its children, we need to tell the freezer not to wait for us.
+         */
+        current->flags |= PF_FREEZER_SKIP;
+        info = call_usermodehelper_setup("/linuxrc", argv, envp_init,
+                                         GFP_KERNEL, init_linuxrc, NULL, NULL);
+        if (!info)
+                return;
+        call_usermodehelper_exec(info, UMH_WAIT_PROC);
+        ...
+</code>
+==== kernel/reboot.c ====
+<code>
+char poweroff_cmd[POWEROFF_CMD_PATH_LEN] = "/sbin/poweroff";
+static const char reboot_cmd[] = "/sbin/reboot";
+static int run_cmd(const char *cmd)
+{
+        char **argv;
+        static char *envp[] = {
+                "HOME=/",
+                "PATH=/sbin:/bin:/usr/sbin:/usr/bin",
+                NULL
+        };
+        int ret;
+        argv = argv_split(GFP_KERNEL, cmd, NULL);
+        if (argv) {
+                ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC);
+                argv_free(argv);
+        } else {
+                ret = -ENOMEM;
+        }
+        return ret;
+}
 </code>