// SPDX-License-Identifier: GPL-2.0-only/* *  linux/fs/exec.c * *  Copyright (C) 1991, 1992  Linus Torvalds */ /* * #!-checking implemented by tytso. *//* * Demand-loading implemented 01.12.91 - no need to read anything but * the header into memory. The inode of the executable is put into * "current->executable", and page faults do the actual loading. Clean. * * Once more I can proudly say that linux stood up to being changed: it * was less than 2 hours work to get demand-loading completely implemented. * * Demand loading changed July 1993 by Eric Youngdale.   Use mmap instead, * current->executable is only used by the procfs.  This allows a dispatch * table to check for several different types  of binary formats.  We keep * trying until we recognize the file or we run out of supported binary * formats. */ #include <linux/kernel_read_file.h>#include <linux/slab.h>#include <linux/file.h>#include <linux/fdtable.h>#include <linux/mm.h>#include <linux/vmacache.h>#include <linux/stat.h>#include <linux/fcntl.h>#include <linux/swap.h>#include <linux/string.h>#include <linux/init.h>#include <linux/sched/mm.h>#include <linux/sched/coredump.h>#include <linux/sched/signal.h>#include <linux/sched/numa_balancing.h>#include <linux/sched/task.h>#include <linux/pagemap.h>#include <linux/perf_event.h>#include <linux/highmem.h>#include <linux/spinlock.h>#include <linux/key.h>#include <linux/personality.h>#include <linux/binfmts.h>#include <linux/utsname.h>#include <linux/pid_namespace.h>#include <linux/module.h>#include <linux/namei.h>#include <linux/mount.h>#include <linux/security.h>#include <linux/syscalls.h>#include <linux/tsacct_kern.h>#include <linux/cn_proc.h>#include <linux/audit.h>#include <linux/kmod.h>#include <linux/fsnotify.h>#include <linux/fs_struct.h>#include <linux/oom.h>#include <linux/compat.h>#include <linux/vmalloc.h>#include <linux/io_uring.h>#include <linux/syscall_user_dispatch.h>#include <linux/coredump.h> #include <linux/uaccess.h>#include <asm/mmu_context.h>#include <asm/tlb.h> #include <trace/events/task.h>#include "internal.h" #include <trace/events/sched.h> static int bprm_creds_from_file(struct linux_binprm *bprm); int suid_dumpable = 0; static LIST_HEAD(formats);static DEFINE_RWLOCK(binfmt_lock); void __register_binfmt(struct linux_binfmt * fmt, int insert){	write_lock(&binfmt_lock);	insert ? list_add(&fmt->lh, &formats) :		 list_add_tail(&fmt->lh, &formats);	write_unlock(&binfmt_lock);} EXPORT_SYMBOL(__register_binfmt); void unregister_binfmt(struct linux_binfmt * fmt){	write_lock(&binfmt_lock);	list_del(&fmt->lh);	write_unlock(&binfmt_lock);} EXPORT_SYMBOL(unregister_binfmt); static inline void put_binfmt(struct linux_binfmt * fmt){	module_put(fmt->module);} bool path_noexec(const struct path *path){	return (path->mnt->mnt_flags & MNT_NOEXEC) ||	       (path->mnt->mnt_sb->s_iflags & SB_I_NOEXEC);} #ifdef CONFIG_USELIB/* * Note that a shared library must be both readable and executable due to * security reasons. * * Also note that we take the address to load from the file itself. */SYSCALL_DEFINE1(uselib, const char __user *, library){	struct linux_binfmt *fmt;	struct file *file;	struct filename *tmp = getname(library);	int error = PTR_ERR(tmp);	static const struct open_flags uselib_flags = {		.open_flag = O_LARGEFILE | O_RDONLY | __FMODE_EXEC,		.acc_mode = MAY_READ | MAY_EXEC,		.intent = LOOKUP_OPEN,		.lookup_flags = LOOKUP_FOLLOW,	}; 	if (IS_ERR(tmp))		goto out; 	file = do_filp_open(AT_FDCWD, tmp, &uselib_flags);	putname(tmp);	error = PTR_ERR(file);	if (IS_ERR(file))		goto out; 	/*	 * may_open() has already checked for this, so it should be	 * impossible to trip now. But we need to be extra cautious	 * and check again at the very end too.	 */	error = -EACCES;	if (WARN_ON_ONCE(!S_ISREG(file_inode(file)->i_mode) ||			 path_noexec(&file->f_path)))		goto exit; 	fsnotify_open(file); 	error = -ENOEXEC; 	read_lock(&binfmt_lock);	list_for_each_entry(fmt, &formats, lh) {		if (!fmt->load_shlib)			continue;		if (!try_module_get(fmt->module))			continue;		read_unlock(&binfmt_lock);		error = fmt->load_shlib(file);		read_lock(&binfmt_lock);		put_binfmt(fmt);		if (error != -ENOEXEC)			break;	}	read_unlock(&binfmt_lock);exit:	fput(file);out:  	return error;}#endif /* #ifdef CONFIG_USELIB */ #ifdef CONFIG_MMU/* * The nascent bprm->mm is not visible until exec_mmap() but it can * use a lot of memory, account these pages in current->mm temporary * for oom_badness()->get_mm_rss(). Once exec succeeds or fails, we * change the counter back via acct_arg_size(0). */static void acct_arg_size(struct linux_binprm *bprm, unsigned long pages){	struct mm_struct *mm = current->mm;	long diff = (long)(pages - bprm->vma_pages); 	if (!mm || !diff)		return; 	bprm->vma_pages = pages;	add_mm_counter(mm, MM_ANONPAGES, diff);} static struct page *get_arg_page(struct linux_binprm *bprm, unsigned long pos,		int write){	struct page *page;	int ret;	unsigned int gup_flags = FOLL_FORCE; #ifdef CONFIG_STACK_GROWSUP	if (write) {		ret = expand_downwards(bprm->vma, pos);		if (ret < 0)			return NULL;	}#endif 	if (write)		gup_flags |= FOLL_WRITE; 	/*	 * We are doing an exec().  'current' is the process	 * doing the exec and bprm->mm is the new process's mm.	 */	mmap_read_lock(bprm->mm);	ret = get_user_pages_remote(bprm->mm, pos, 1, gup_flags,			&page, NULL, NULL);	mmap_read_unlock(bprm->mm);	if (ret <= 0)		return NULL; 	if (write)		acct_arg_size(bprm, vma_pages(bprm->vma)); 	return page;} static void put_arg_page(struct page *page){	put_page(page);} static void free_arg_pages(struct linux_binprm *bprm){} static void flush_arg_page(struct linux_binprm *bprm, unsigned long pos,		struct page *page){	flush_cache_page(bprm->vma, pos, page_to_pfn(page));} static int __bprm_mm_init(struct linux_binprm *bprm){	int err;	struct vm_area_struct *vma = NULL;	struct mm_struct *mm = bprm->mm; 	bprm->vma = vma = vm_area_alloc(mm);	if (!vma)		return -ENOMEM;	vma_set_anonymous(vma); 	if (mmap_write_lock_killable(mm)) {		err = -EINTR;		goto err_free;	} 	/*	 * Place the stack at the largest stack address the architecture	 * supports. Later, we'll move this to an appropriate place. We don't	 * use STACK_TOP because that can depend on attributes which aren't	 * configured yet.	 */	BUILD_BUG_ON(VM_STACK_FLAGS & VM_STACK_INCOMPLETE_SETUP);	vma->vm_end = STACK_TOP_MAX;	vma->vm_start = vma->vm_end - PAGE_SIZE;	vma->vm_flags = VM_SOFTDIRTY | VM_STACK_FLAGS | VM_STACK_INCOMPLETE_SETUP;	vma->vm_page_prot = vm_get_page_prot(vma->vm_flags); 	err = insert_vm_struct(mm, vma);	if (err)		goto err; 	mm->stack_vm = mm->total_vm = 1;	mmap_write_unlock(mm);	bprm->p = vma->vm_end - sizeof(void *);	return 0;err:	mmap_write_unlock(mm);err_free:	bprm->vma = NULL;	vm_area_free(vma);	return err;} static bool valid_arg_len(struct linux_binprm *bprm, long len){	return len <= MAX_ARG_STRLEN;} #else static inline void acct_arg_size(struct linux_binprm *bprm, unsigned long pages){} static struct page *get_arg_page(struct linux_binprm *bprm, unsigned long pos,		int write){	struct page *page; 	page = bprm->page[pos / PAGE_SIZE];	if (!page && write) {		page = alloc_page(GFP_HIGHUSER|__GFP_ZERO);		if (!page)			return NULL;		bprm->page[pos / PAGE_SIZE] = page;	} 	return page;} static void put_arg_page(struct page *page){} static void free_arg_page(struct linux_binprm *bprm, int i){	if (bprm->page[i]) {		__free_page(bprm->page[i]);		bprm->page[i] = NULL;	}} static void free_arg_pages(struct linux_binprm *bprm){	int i; 	for (i = 0; i < MAX_ARG_PAGES; i++)		free_arg_page(bprm, i);} static void flush_arg_page(struct linux_binprm *bprm, unsigned long pos,		struct page *page){} static int __bprm_mm_init(struct linux_binprm *bprm){	bprm->p = PAGE_SIZE * MAX_ARG_PAGES - sizeof(void *);	return 0;} static bool valid_arg_len(struct linux_binprm *bprm, long len){	return len <= bprm->p;} #endif /* CONFIG_MMU */ /* * Create a new mm_struct and populate it with a temporary stack * vm_area_struct.  We don't have enough context at this point to set the stack * flags, permissions, and offset, so we use temporary values.  We'll update * them later in setup_arg_pages(). */static int bprm_mm_init(struct linux_binprm *bprm){	int err;	struct mm_struct *mm = NULL; 	bprm->mm = mm = mm_alloc();	err = -ENOMEM;	if (!mm)		goto err; 	/* Save current stack limit for all calculations made during exec. */	task_lock(current->group_leader);	bprm->rlim_stack = current->signal->rlim[RLIMIT_STACK];	task_unlock(current->group_leader); 	err = __bprm_mm_init(bprm);	if (err)		goto err; 	return 0; err:	if (mm) {		bprm->mm = NULL;		mmdrop(mm);	} 	return err;} struct user_arg_ptr {#ifdef CONFIG_COMPAT	bool is_compat;#endif	union {		const char __user *const __user *native;#ifdef CONFIG_COMPAT		const compat_uptr_t __user *compat;#endif	} ptr;}; static const char __user *get_user_arg_ptr(struct user_arg_ptr argv, int nr){	const char __user *native; #ifdef CONFIG_COMPAT	if (unlikely(argv.is_compat)) {		compat_uptr_t compat; 		if (get_user(compat, argv.ptr.compat + nr))			return ERR_PTR(-EFAULT); 		return compat_ptr(compat);	}#endif 	if (get_user(native, argv.ptr.native + nr))		return ERR_PTR(-EFAULT); 	return native;} /* * count() counts the number of strings in array ARGV. */static int count(struct user_arg_ptr argv, int max){	int i = 0; 	if (argv.ptr.native != NULL) {		for (;;) {			const char __user *p = get_user_arg_ptr(argv, i); 			if (!p)				break; 			if (IS_ERR(p))				return -EFAULT; 			if (i >= max)				return -E2BIG;			++i; 			if (fatal_signal_pending(current))				return -ERESTARTNOHAND;			cond_resched();		}	}	return i;} static int count_strings_kernel(const char *const *argv){	int i; 	if (!argv)		return 0; 	for (i = 0; argv[i]; ++i) {		if (i >= MAX_ARG_STRINGS)			return -E2BIG;		if (fatal_signal_pending(current))			return -ERESTARTNOHAND;		cond_resched();	}	return i;} static int bprm_stack_limits(struct linux_binprm *bprm){	unsigned long limit, ptr_size; 	/*	 * Limit to 1/4 of the max stack size or 3/4 of _STK_LIM	 * (whichever is smaller) for the argv+env strings.	 * This ensures that:	 *  - the remaining binfmt code will not run out of stack space,	 *  - the program will have a reasonable amount of stack left	 *    to work from.	 */	limit = _STK_LIM / 4 * 3;	limit = min(limit, bprm->rlim_stack.rlim_cur / 4);	/*	 * We've historically supported up to 32 pages (ARG_MAX)	 * of argument strings even with small stacks	 */	limit = max_t(unsigned long, limit, ARG_MAX);	/*	 * We must account for the size of all the argv and envp pointers to	 * the argv and envp strings, since they will also take up space in	 * the stack. They aren't stored until much later when we can't	 * signal to the parent that the child has run out of stack space.	 * Instead, calculate it here so it's possible to fail gracefully.	 *	 * In the case of argc = 0, make sure there is space for adding a	 * empty string (which will bump argc to 1), to ensure confused	 * userspace programs don't start processing from argv[1], thinking

Lines 1–500 of 2153. Load more