// SPDX-License-Identifier: GPL-2.0-only/* * umh - the kernel usermode helper */#include <linux/module.h>#include <linux/sched.h>#include <linux/sched/task.h>#include <linux/binfmts.h>#include <linux/syscalls.h>#include <linux/unistd.h>#include <linux/kmod.h>#include <linux/slab.h>#include <linux/completion.h>#include <linux/cred.h>#include <linux/file.h>#include <linux/fdtable.h>#include <linux/workqueue.h>#include <linux/security.h>#include <linux/mount.h>#include <linux/kernel.h>#include <linux/init.h>#include <linux/resource.h>#include <linux/notifier.h>#include <linux/suspend.h>#include <linux/rwsem.h>#include <linux/ptrace.h>#include <linux/async.h>#include <linux/uaccess.h>#include <linux/shmem_fs.h>#include <linux/pipe_fs_i.h> #include <trace/events/module.h> #define CAP_BSET	(void *)1#define CAP_PI		(void *)2 static kernel_cap_t usermodehelper_bset = CAP_FULL_SET;static kernel_cap_t usermodehelper_inheritable = CAP_FULL_SET;static DEFINE_SPINLOCK(umh_sysctl_lock);static DECLARE_RWSEM(umhelper_sem);static LIST_HEAD(umh_list);static DEFINE_MUTEX(umh_list_lock); static void call_usermodehelper_freeinfo(struct subprocess_info *info){	if (info->cleanup)		(*info->cleanup)(info);	kfree(info);} static void umh_complete(struct subprocess_info *sub_info){	struct completion *comp = xchg(&sub_info->complete, NULL);	/*	 * See call_usermodehelper_exec(). If xchg() returns NULL	 * we own sub_info, the UMH_KILLABLE caller has gone away	 * or the caller used UMH_NO_WAIT.	 */	if (comp)		complete(comp);	else		call_usermodehelper_freeinfo(sub_info);} /* * This is the task which runs the usermode application */static int call_usermodehelper_exec_async(void *data){	struct subprocess_info *sub_info = data;	struct cred *new;	int retval; 	spin_lock_irq(&current->sighand->siglock);	flush_signal_handlers(current, 1);	spin_unlock_irq(&current->sighand->siglock); 	/*	 * Our parent (unbound workqueue) runs with elevated scheduling	 * priority. Avoid propagating that into the userspace child.	 */	set_user_nice(current, 0); 	retval = -ENOMEM;	new = prepare_kernel_cred(current);	if (!new)		goto out; 	spin_lock(&umh_sysctl_lock);	new->cap_bset = cap_intersect(usermodehelper_bset, new->cap_bset);	new->cap_inheritable = cap_intersect(usermodehelper_inheritable,					     new->cap_inheritable);	spin_unlock(&umh_sysctl_lock); 	if (sub_info->init) {		retval = sub_info->init(sub_info, new);		if (retval) {			abort_creds(new);			goto out;		}	} 	commit_creds(new); 	sub_info->pid = task_pid_nr(current);	if (sub_info->file) {		retval = do_execve_file(sub_info->file,					sub_info->argv, sub_info->envp);		if (!retval)			current->flags |= PF_UMH;	} else		retval = do_execve(getname_kernel(sub_info->path),				   (const char __user *const __user *)sub_info->argv,				   (const char __user *const __user *)sub_info->envp);out:	sub_info->retval = retval;	/*	 * call_usermodehelper_exec_sync() will call umh_complete	 * if UHM_WAIT_PROC.	 */	if (!(sub_info->wait & UMH_WAIT_PROC))		umh_complete(sub_info);	if (!retval)		return 0;	do_exit(0);} /* Handles UMH_WAIT_PROC.  */static void call_usermodehelper_exec_sync(struct subprocess_info *sub_info){	pid_t pid; 	/* If SIGCLD is ignored kernel_wait4 won't populate the status. */	kernel_sigaction(SIGCHLD, SIG_DFL);	pid = kernel_thread(call_usermodehelper_exec_async, sub_info, SIGCHLD);	if (pid < 0) {		sub_info->retval = pid;	} else {		int ret = -ECHILD;		/*		 * Normally it is bogus to call wait4() from in-kernel because		 * wait4() wants to write the exit code to a userspace address.		 * But call_usermodehelper_exec_sync() always runs as kernel		 * thread (workqueue) and put_user() to a kernel address works		 * OK for kernel threads, due to their having an mm_segment_t		 * which spans the entire address space.		 *		 * Thus the __user pointer cast is valid here.		 */		kernel_wait4(pid, (int __user *)&ret, 0, NULL); 		/*		 * If ret is 0, either call_usermodehelper_exec_async failed and		 * the real error code is already in sub_info->retval or		 * sub_info->retval is 0 anyway, so don't mess with it then.		 */		if (ret)			sub_info->retval = ret;	} 	/* Restore default kernel sig handler */	kernel_sigaction(SIGCHLD, SIG_IGN); 	umh_complete(sub_info);} /* * We need to create the usermodehelper kernel thread from a task that is affine * to an optimized set of CPUs (or nohz housekeeping ones) such that they * inherit a widest affinity irrespective of call_usermodehelper() callers with * possibly reduced affinity (eg: per-cpu workqueues). We don't want * usermodehelper targets to contend a busy CPU. * * Unbound workqueues provide such wide affinity and allow to block on * UMH_WAIT_PROC requests without blocking pending request (up to some limit). * * Besides, workqueues provide the privilege level that caller might not have * to perform the usermodehelper request. * */static void call_usermodehelper_exec_work(struct work_struct *work){	struct subprocess_info *sub_info =		container_of(work, struct subprocess_info, work); 	if (sub_info->wait & UMH_WAIT_PROC) {		call_usermodehelper_exec_sync(sub_info);	} else {		pid_t pid;		/*		 * Use CLONE_PARENT to reparent it to kthreadd; we do not		 * want to pollute current->children, and we need a parent		 * that always ignores SIGCHLD to ensure auto-reaping.		 */		pid = kernel_thread(call_usermodehelper_exec_async, sub_info,				    CLONE_PARENT | SIGCHLD);		if (pid < 0) {			sub_info->retval = pid;			umh_complete(sub_info);		}	}} /* * If set, call_usermodehelper_exec() will exit immediately returning -EBUSY * (used for preventing user land processes from being created after the user * land has been frozen during a system-wide hibernation or suspend operation). * Should always be manipulated under umhelper_sem acquired for write. */static enum umh_disable_depth usermodehelper_disabled = UMH_DISABLED; /* Number of helpers running */static atomic_t running_helpers = ATOMIC_INIT(0); /* * Wait queue head used by usermodehelper_disable() to wait for all running * helpers to finish. */static DECLARE_WAIT_QUEUE_HEAD(running_helpers_waitq); /* * Used by usermodehelper_read_lock_wait() to wait for usermodehelper_disabled * to become 'false'. */static DECLARE_WAIT_QUEUE_HEAD(usermodehelper_disabled_waitq); /* * Time to wait for running_helpers to become zero before the setting of * usermodehelper_disabled in usermodehelper_disable() fails */#define RUNNING_HELPERS_TIMEOUT	(5 * HZ) int usermodehelper_read_trylock(void){	DEFINE_WAIT(wait);	int ret = 0; 	down_read(&umhelper_sem);	for (;;) {		prepare_to_wait(&usermodehelper_disabled_waitq, &wait,				TASK_INTERRUPTIBLE);		if (!usermodehelper_disabled)			break; 		if (usermodehelper_disabled == UMH_DISABLED)			ret = -EAGAIN; 		up_read(&umhelper_sem); 		if (ret)			break; 		schedule();		try_to_freeze(); 		down_read(&umhelper_sem);	}	finish_wait(&usermodehelper_disabled_waitq, &wait);	return ret;}EXPORT_SYMBOL_GPL(usermodehelper_read_trylock); long usermodehelper_read_lock_wait(long timeout){	DEFINE_WAIT(wait); 	if (timeout < 0)		return -EINVAL; 	down_read(&umhelper_sem);	for (;;) {		prepare_to_wait(&usermodehelper_disabled_waitq, &wait,				TASK_UNINTERRUPTIBLE);		if (!usermodehelper_disabled)			break; 		up_read(&umhelper_sem); 		timeout = schedule_timeout(timeout);		if (!timeout)			break; 		down_read(&umhelper_sem);	}	finish_wait(&usermodehelper_disabled_waitq, &wait);	return timeout;}EXPORT_SYMBOL_GPL(usermodehelper_read_lock_wait); void usermodehelper_read_unlock(void){	up_read(&umhelper_sem);}EXPORT_SYMBOL_GPL(usermodehelper_read_unlock); /** * __usermodehelper_set_disable_depth - Modify usermodehelper_disabled. * @depth: New value to assign to usermodehelper_disabled. * * Change the value of usermodehelper_disabled (under umhelper_sem locked for * writing) and wakeup tasks waiting for it to change. */void __usermodehelper_set_disable_depth(enum umh_disable_depth depth){	down_write(&umhelper_sem);	usermodehelper_disabled = depth;	wake_up(&usermodehelper_disabled_waitq);	up_write(&umhelper_sem);} /** * __usermodehelper_disable - Prevent new helpers from being started. * @depth: New value to assign to usermodehelper_disabled. * * Set usermodehelper_disabled to @depth and wait for running helpers to exit. */int __usermodehelper_disable(enum umh_disable_depth depth){	long retval; 	if (!depth)		return -EINVAL; 	down_write(&umhelper_sem);	usermodehelper_disabled = depth;	up_write(&umhelper_sem); 	/*	 * From now on call_usermodehelper_exec() won't start any new	 * helpers, so it is sufficient if running_helpers turns out to	 * be zero at one point (it may be increased later, but that	 * doesn't matter).	 */	retval = wait_event_timeout(running_helpers_waitq,					atomic_read(&running_helpers) == 0,					RUNNING_HELPERS_TIMEOUT);	if (retval)		return 0; 	__usermodehelper_set_disable_depth(UMH_ENABLED);	return -EAGAIN;} static void helper_lock(void){	atomic_inc(&running_helpers);	smp_mb__after_atomic();} static void helper_unlock(void){	if (atomic_dec_and_test(&running_helpers))		wake_up(&running_helpers_waitq);} /** * 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,		int (*init)(struct subprocess_info *info, struct cred *new),		void (*cleanup)(struct subprocess_info *info),		void *data){	struct subprocess_info *sub_info;	sub_info = kzalloc(sizeof(struct subprocess_info), gfp_mask);	if (!sub_info)		goto out; 	INIT_WORK(&sub_info->work, call_usermodehelper_exec_work); #ifdef CONFIG_STATIC_USERMODEHELPER	sub_info->path = CONFIG_STATIC_USERMODEHELPER_PATH;#else	sub_info->path = path;#endif	sub_info->argv = argv;	sub_info->envp = envp; 	sub_info->cleanup = cleanup;	sub_info->init = init;	sub_info->data = data;  out:	return sub_info;}EXPORT_SYMBOL(call_usermodehelper_setup); struct subprocess_info *call_usermodehelper_setup_file(struct file *file,		int (*init)(struct subprocess_info *info, struct cred *new),		void (*cleanup)(struct subprocess_info *info), void *data){	struct subprocess_info *sub_info;	struct umh_info *info = data;	const char *cmdline = (info->cmdline) ? info->cmdline : "usermodehelper"; 	sub_info = kzalloc(sizeof(struct subprocess_info), GFP_KERNEL);	if (!sub_info)		return NULL; 	sub_info->argv = argv_split(GFP_KERNEL, cmdline, NULL);	if (!sub_info->argv) {		kfree(sub_info);		return NULL;	} 	INIT_WORK(&sub_info->work, call_usermodehelper_exec_work);	sub_info->path = "none";	sub_info->file = file;	sub_info->init = init;	sub_info->cleanup = cleanup;	sub_info->data = data;	return sub_info;} static int umh_pipe_setup(struct subprocess_info *info, struct cred *new){	struct umh_info *umh_info = info->data;	struct file *from_umh[2];	struct file *to_umh[2];	int err; 	/* create pipe to send data to umh */	err = create_pipe_files(to_umh, 0);	if (err)		return err;	err = replace_fd(0, to_umh[0], 0);	fput(to_umh[0]);	if (err < 0) {		fput(to_umh[1]);		return err;	} 	/* create pipe to receive data from umh */	err = create_pipe_files(from_umh, 0);	if (err) {		fput(to_umh[1]);		replace_fd(0, NULL, 0);		return err;	}	err = replace_fd(1, from_umh[1], 0);	fput(from_umh[1]);	if (err < 0) {		fput(to_umh[1]);		replace_fd(0, NULL, 0);		fput(from_umh[0]);		return err;	} 	umh_info->pipe_to_umh = to_umh[1];	umh_info->pipe_from_umh = from_umh[0];	return 0;} static void umh_clean_and_save_pid(struct subprocess_info *info){	struct umh_info *umh_info = info->data; 	argv_free(info->argv);	umh_info->pid = info->pid;} /** * fork_usermode_blob - fork a blob of bytes as a usermode process * @data: a blob of bytes that can be do_execv-ed as a file * @len: length of the blob * @info: information about usermode process (shouldn't be NULL) * * If info->cmdline is set it will be used as command line for the * user process, else "usermodehelper" is used. * * Returns either negative error or zero which indicates success * in executing a blob of bytes as a usermode process. In such * case 'struct umh_info *info' is populated with two pipes * and a pid of the process. The caller is responsible for health * check of the user process, killing it via pid, and closing the * pipes when user process is no longer needed. */int fork_usermode_blob(void *data, size_t len, struct umh_info *info){	struct subprocess_info *sub_info;

Lines 1–500 of 728. Load more