2316 lines · 53.2 KB · C
RawDownload
			}			cond_resched(); 			offset = pos % PAGE_SIZE;			if (offset == 0)				offset = PAGE_SIZE; 			bytes_to_copy = offset;			if (bytes_to_copy > len)				bytes_to_copy = len; 			offset -= bytes_to_copy;			pos -= bytes_to_copy;			str -= bytes_to_copy;			len -= bytes_to_copy; 			if (!kmapped_page || kpos != (pos & PAGE_MASK)) {				struct page *page; 				page = get_arg_page(bprm, pos, 1);				if (!page) {					ret = -E2BIG;					goto out;				} 				if (kmapped_page) {					flush_kernel_dcache_page(kmapped_page);					kunmap(kmapped_page);					put_arg_page(kmapped_page);				}				kmapped_page = page;				kaddr = kmap(kmapped_page);				kpos = pos & PAGE_MASK;				flush_arg_page(bprm, kpos, kmapped_page);			}			if (copy_from_user(kaddr+offset, str, bytes_to_copy)) {				ret = -EFAULT;				goto out;			}		}	}	ret = 0;out:	if (kmapped_page) {		flush_kernel_dcache_page(kmapped_page);		kunmap(kmapped_page);		put_arg_page(kmapped_page);	}	return ret;} /* * Like copy_strings, but get argv and its values from kernel memory. */int copy_strings_kernel(int argc, const char *const *__argv,			struct linux_binprm *bprm){	int r;	mm_segment_t oldfs = get_fs();	struct user_arg_ptr argv = {		.ptr.native = (const char __user *const  __user *)__argv,	}; 	set_fs(KERNEL_DS);	r = copy_strings(argc, argv, bprm);	set_fs(oldfs); 	return r;}EXPORT_SYMBOL(copy_strings_kernel); #ifdef CONFIG_MMU /* * During bprm_mm_init(), we create a temporary stack at STACK_TOP_MAX.  Once * the binfmt code determines where the new stack should reside, we shift it to * its final location.  The process proceeds as follows: * * 1) Use shift to calculate the new vma endpoints. * 2) Extend vma to cover both the old and new ranges.  This ensures the *    arguments passed to subsequent functions are consistent. * 3) Move vma's page tables to the new range. * 4) Free up any cleared pgd range. * 5) Shrink the vma to cover only the new range. */static int shift_arg_pages(struct vm_area_struct *vma, unsigned long shift){	struct mm_struct *mm = vma->vm_mm;	unsigned long old_start = vma->vm_start;	unsigned long old_end = vma->vm_end;	unsigned long length = old_end - old_start;	unsigned long new_start = old_start - shift;	unsigned long new_end = old_end - shift;	struct mmu_gather tlb; 	BUG_ON(new_start > new_end); 	/*	 * ensure there are no vmas between where we want to go	 * and where we are	 */	if (vma != find_vma(mm, new_start))		return -EFAULT; 	/*	 * cover the whole range: [new_start, old_end)	 */	if (vma_adjust(vma, new_start, old_end, vma->vm_pgoff, NULL))		return -ENOMEM; 	/*	 * move the page tables downwards, on failure we rely on	 * process cleanup to remove whatever mess we made.	 */	if (length != move_page_tables(vma, old_start,				       vma, new_start, length))		return -ENOMEM; 	lru_add_drain();	tlb_gather_mmu(&tlb, mm, 0);	if (new_end > old_start) {		/*		 * when the old and new regions overlap clear from new_end.		 */		free_pgd_range(&tlb, new_end, old_end, new_end,			vma->vm_next ? vma->vm_next->vm_start : 0);	} else {		/*		 * otherwise, clean from old_start; this is done to not touch		 * the address space in [new_end, old_start) some architectures		 * have constraints on va-space that make this illegal (IA64) -		 * for the others its just a little faster.		 */		free_pgd_range(&tlb, old_start, old_end, new_end,			vma->vm_next ? vma->vm_next->vm_start : 0);	}	tlb_finish_mmu(&tlb, new_end, old_end); 	/*	 * Shrink the vma to just the new range.  Always succeeds.	 */	vma_adjust(vma, new_start, new_end, vma->vm_pgoff, NULL); 	return 0;} /* * Finalizes the stack vm_area_struct. The flags and permissions are updated, * the stack is optionally relocated, and some extra space is added. */int setup_arg_pages(struct linux_binprm *bprm,		    unsigned long stack_top,		    int executable_stack){	unsigned long ret;	unsigned long stack_shift;	struct mm_struct *mm = current->mm;	struct vm_area_struct *vma = bprm->vma;	struct vm_area_struct *prev = NULL;	unsigned long vm_flags;	unsigned long stack_base;	unsigned long stack_size;	unsigned long stack_expand;	unsigned long rlim_stack; #ifdef CONFIG_STACK_GROWSUP	/* Limit stack size to 1GB */	stack_base = rlimit_max(RLIMIT_STACK);	if (stack_base > (1 << 30))		stack_base = 1 << 30; 	/* Make sure we didn't let the argument array grow too large. */	if (vma->vm_end - vma->vm_start > stack_base)		return -ENOMEM; 	stack_base = PAGE_ALIGN(stack_top - stack_base); 	stack_shift = vma->vm_start - stack_base;	mm->arg_start = bprm->p - stack_shift;	bprm->p = vma->vm_end - stack_shift;#else	stack_top = arch_align_stack(stack_top);	stack_top = PAGE_ALIGN(stack_top); 	if (unlikely(stack_top < mmap_min_addr) ||	    unlikely(vma->vm_end - vma->vm_start >= stack_top - mmap_min_addr))		return -ENOMEM; 	stack_shift = vma->vm_end - stack_top; 	bprm->p -= stack_shift;	mm->arg_start = bprm->p;#endif 	if (bprm->loader)		bprm->loader -= stack_shift;	bprm->exec -= stack_shift; 	down_write(&mm->mmap_sem);	vm_flags = VM_STACK_FLAGS; 	/*	 * Adjust stack execute permissions; explicitly enable for	 * EXSTACK_ENABLE_X, disable for EXSTACK_DISABLE_X and leave alone	 * (arch default) otherwise.	 */	if (unlikely(executable_stack == EXSTACK_ENABLE_X))		vm_flags |= VM_EXEC;	else if (executable_stack == EXSTACK_DISABLE_X)		vm_flags &= ~VM_EXEC;	vm_flags |= mm->def_flags;	vm_flags |= VM_STACK_INCOMPLETE_SETUP; 	ret = mprotect_fixup(vma, &prev, vma->vm_start, vma->vm_end,			vm_flags);	if (ret)		goto out_unlock;	BUG_ON(prev != vma); 	/* Move stack pages down in memory. */	if (stack_shift) {		ret = shift_arg_pages(vma, stack_shift);		if (ret)			goto out_unlock;	} 	/* mprotect_fixup is overkill to remove the temporary stack flags */	vma->vm_flags &= ~VM_STACK_INCOMPLETE_SETUP; 	stack_expand = 131072UL; /* randomly 32*4k (or 2*64k) pages */	stack_size = vma->vm_end - vma->vm_start;	/*	 * Align this down to a page boundary as expand_stack	 * will align it up.	 */	rlim_stack = rlimit(RLIMIT_STACK) & PAGE_MASK;#ifdef CONFIG_STACK_GROWSUP	if (stack_size + stack_expand > rlim_stack)		stack_base = vma->vm_start + rlim_stack;	else		stack_base = vma->vm_end + stack_expand;#else	if (stack_size + stack_expand > rlim_stack)		stack_base = vma->vm_end - rlim_stack;	else		stack_base = vma->vm_start - stack_expand;#endif	current->mm->start_stack = bprm->p;	ret = expand_stack(vma, stack_base);	if (ret)		ret = -EFAULT; out_unlock:	up_write(&mm->mmap_sem);	return ret;}EXPORT_SYMBOL(setup_arg_pages); #endif /* CONFIG_MMU */ struct file *open_exec(const char *name){	struct file *file;	int err;	static const struct open_flags open_exec_flags = {		.open_flag = O_LARGEFILE | O_RDONLY | __FMODE_EXEC,		.acc_mode = MAY_EXEC | MAY_OPEN,		.intent = LOOKUP_OPEN	}; 	file = do_filp_open(AT_FDCWD, name, &open_exec_flags, LOOKUP_FOLLOW);	if (IS_ERR(file))		goto out; 	err = -EACCES;	if (!S_ISREG(file->f_path.dentry->d_inode->i_mode))		goto exit; 	if (file->f_path.mnt->mnt_flags & MNT_NOEXEC)		goto exit; 	fsnotify_open(file); 	err = deny_write_access(file);	if (err)		goto exit; out:	return file; exit:	fput(file);	return ERR_PTR(err);}EXPORT_SYMBOL(open_exec); int kernel_read(struct file *file, loff_t offset,		char *addr, unsigned long count){	mm_segment_t old_fs;	loff_t pos = offset;	int result; 	old_fs = get_fs();	set_fs(get_ds());	/* The cast to a user pointer is valid due to the set_fs() */	result = vfs_read(file, (void __user *)addr, count, &pos);	set_fs(old_fs);	return result;} EXPORT_SYMBOL(kernel_read); static int exec_mmap(struct mm_struct *mm){	struct task_struct *tsk;	struct mm_struct * old_mm, *active_mm; 	/* Notify parent that we're no longer interested in the old VM */	tsk = current;	old_mm = current->mm;	sync_mm_rss(old_mm);	mm_release(tsk, old_mm); 	if (old_mm) {		/*		 * Make sure that if there is a core dump in progress		 * for the old mm, we get out and die instead of going		 * through with the exec.  We must hold mmap_sem around		 * checking core_state and changing tsk->mm.		 */		down_read(&old_mm->mmap_sem);		if (unlikely(old_mm->core_state)) {			up_read(&old_mm->mmap_sem);			return -EINTR;		}	}	task_lock(tsk);	active_mm = tsk->active_mm;	tsk->mm = mm;	tsk->active_mm = mm;	activate_mm(active_mm, mm);	task_unlock(tsk);	arch_pick_mmap_layout(mm);	if (old_mm) {		up_read(&old_mm->mmap_sem);		BUG_ON(active_mm != old_mm);		setmax_mm_hiwater_rss(&tsk->signal->maxrss, old_mm);		mm_update_next_owner(old_mm);		mmput(old_mm);		return 0;	}	mmdrop(active_mm);	return 0;} /* * This function makes sure the current process has its own signal table, * so that flush_signal_handlers can later reset the handlers without * disturbing other processes.  (Other processes might share the signal * table via the CLONE_SIGHAND option to clone().) */static int de_thread(struct task_struct *tsk){	struct signal_struct *sig = tsk->signal;	struct sighand_struct *oldsighand = tsk->sighand;	spinlock_t *lock = &oldsighand->siglock; 	if (thread_group_empty(tsk))		goto no_thread_group; 	/*	 * Kill all other threads in the thread group.	 */	spin_lock_irq(lock);	if (signal_group_exit(sig)) {		/*		 * Another group action in progress, just		 * return so that the signal is processed.		 */		spin_unlock_irq(lock);		return -EAGAIN;	} 	sig->group_exit_task = tsk;	sig->notify_count = zap_other_threads(tsk);	if (!thread_group_leader(tsk))		sig->notify_count--; 	while (sig->notify_count) {		__set_current_state(TASK_UNINTERRUPTIBLE);		spin_unlock_irq(lock);		schedule();		spin_lock_irq(lock);	}	spin_unlock_irq(lock); 	/*	 * At this point all other threads have exited, all we have to	 * do is to wait for the thread group leader to become inactive,	 * and to assume its PID:	 */	if (!thread_group_leader(tsk)) {		struct task_struct *leader = tsk->group_leader; 		sig->notify_count = -1;	/* for exit_notify() */		for (;;) {			write_lock_irq(&tasklist_lock);			if (likely(leader->exit_state))				break;			__set_current_state(TASK_UNINTERRUPTIBLE);			write_unlock_irq(&tasklist_lock);			schedule();		} 		/*		 * The only record we have of the real-time age of a		 * process, regardless of execs it's done, is start_time.		 * All the past CPU time is accumulated in signal_struct		 * from sister threads now dead.  But in this non-leader		 * exec, nothing survives from the original leader thread,		 * whose birth marks the true age of this process now.		 * When we take on its identity by switching to its PID, we		 * also take its birthdate (always earlier than our own).		 */		tsk->start_time = leader->start_time; 		BUG_ON(!same_thread_group(leader, tsk));		BUG_ON(has_group_leader_pid(tsk));		/*		 * An exec() starts a new thread group with the		 * TGID of the previous thread group. Rehash the		 * two threads with a switched PID, and release		 * the former thread group leader:		 */ 		/* Become a process group leader with the old leader's pid.		 * The old leader becomes a thread of the this thread group.		 * Note: The old leader also uses this pid until release_task		 *       is called.  Odd but simple and correct.		 */		detach_pid(tsk, PIDTYPE_PID);		tsk->pid = leader->pid;		attach_pid(tsk, PIDTYPE_PID,  task_pid(leader));		transfer_pid(leader, tsk, PIDTYPE_PGID);		transfer_pid(leader, tsk, PIDTYPE_SID); 		list_replace_rcu(&leader->tasks, &tsk->tasks);		list_replace_init(&leader->sibling, &tsk->sibling); 		tsk->group_leader = tsk;		leader->group_leader = tsk; 		tsk->exit_signal = SIGCHLD;		leader->exit_signal = -1; 		BUG_ON(leader->exit_state != EXIT_ZOMBIE);		leader->exit_state = EXIT_DEAD; 		/*		 * We are going to release_task()->ptrace_unlink() silently,		 * the tracer can sleep in do_wait(). EXIT_DEAD guarantees		 * the tracer wont't block again waiting for this thread.		 */		if (unlikely(leader->ptrace))			__wake_up_parent(leader, leader->parent);		write_unlock_irq(&tasklist_lock); 		release_task(leader);	} 	sig->group_exit_task = NULL;	sig->notify_count = 0; no_thread_group:	/* we have changed execution domain */	tsk->exit_signal = SIGCHLD; 	exit_itimers(sig);	flush_itimer_signals(); 	if (atomic_read(&oldsighand->count) != 1) {		struct sighand_struct *newsighand;		/*		 * This ->sighand is shared with the CLONE_SIGHAND		 * but not CLONE_THREAD task, switch to the new one.		 */		newsighand = kmem_cache_alloc(sighand_cachep, GFP_KERNEL);		if (!newsighand)			return -ENOMEM; 		atomic_set(&newsighand->count, 1);		memcpy(newsighand->action, oldsighand->action,		       sizeof(newsighand->action)); 		write_lock_irq(&tasklist_lock);		spin_lock(&oldsighand->siglock);		rcu_assign_pointer(tsk->sighand, newsighand);		spin_unlock(&oldsighand->siglock);		write_unlock_irq(&tasklist_lock);

Lines 501–1000 of 2316. Previous lines

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t