3409 lines · 83.7 KB · C
RawDownload
	if (tsk->vfork_done)		complete_vfork_done(tsk);} void exit_mm_release(struct task_struct *tsk, struct mm_struct *mm){	futex_exit_release(tsk);	mm_release(tsk, mm);} void exec_mm_release(struct task_struct *tsk, struct mm_struct *mm){	futex_exec_release(tsk);	mm_release(tsk, mm);} /** * dup_mm() - duplicates an existing mm structure * @tsk: the task_struct with which the new mm will be associated. * @oldmm: the mm to duplicate. * * Allocates a new mm structure and duplicates the provided @oldmm structure * content into it. * * Return: the duplicated mm or NULL on failure. */static struct mm_struct *dup_mm(struct task_struct *tsk,				struct mm_struct *oldmm){	struct mm_struct *mm;	int err; 	mm = allocate_mm();	if (!mm)		goto fail_nomem; 	memcpy(mm, oldmm, sizeof(*mm)); 	if (!mm_init(mm, tsk))		goto fail_nomem; 	uprobe_start_dup_mmap();	err = dup_mmap(mm, oldmm);	if (err)		goto free_pt;	uprobe_end_dup_mmap(); 	mm->hiwater_rss = get_mm_rss(mm);	mm->hiwater_vm = mm->total_vm; 	if (mm->binfmt && !try_module_get(mm->binfmt->module))		goto free_pt; 	return mm; free_pt:	/* don't put binfmt in mmput, we haven't got module yet */	mm->binfmt = NULL;	mm_init_owner(mm, NULL);	mmput(mm);	if (err)		uprobe_end_dup_mmap(); fail_nomem:	return NULL;} static int copy_mm(u64 clone_flags, struct task_struct *tsk){	struct mm_struct *mm, *oldmm; 	tsk->min_flt = tsk->maj_flt = 0;	tsk->nvcsw = tsk->nivcsw = 0;#ifdef CONFIG_DETECT_HUNG_TASK	tsk->last_switch_count = tsk->nvcsw + tsk->nivcsw;	tsk->last_switch_time = 0;#endif 	tsk->mm = NULL;	tsk->active_mm = NULL; 	/*	 * Are we cloning a kernel thread?	 *	 * We need to steal a active VM for that..	 */	oldmm = current->mm;	if (!oldmm)		return 0; 	if (clone_flags & CLONE_VM) {		mmget(oldmm);		mm = oldmm;	} else {		mm = dup_mm(tsk, current->mm);		if (!mm)			return -ENOMEM;	} 	tsk->mm = mm;	tsk->active_mm = mm;	return 0;} static int copy_exec_state(u64 clone_flags, struct task_struct *tsk){	struct task_exec_state *exec_state; 	/* CLONE_VM siblings refcount-share the parent's exec_state. */	if (clone_flags & CLONE_VM) {		exec_state = rcu_dereference_protected(current->exec_state, true);		refcount_inc(&exec_state->count);		rcu_assign_pointer(tsk->exec_state, exec_state);		return 0;	} 	/* Everyone else inherits a fresh copy. */	return task_exec_state_copy(tsk);} static int copy_fs(u64 clone_flags, struct task_struct *tsk){	struct fs_struct *fs = current->fs;	if (clone_flags & CLONE_FS) {		/* tsk->fs is already what we want */		read_seqlock_excl(&fs->seq);		/* "users" and "in_exec" locked for check_unsafe_exec() */		if (fs->in_exec) {			read_sequnlock_excl(&fs->seq);			return -EAGAIN;		}		fs->users++;		read_sequnlock_excl(&fs->seq);		return 0;	}	tsk->fs = copy_fs_struct(fs);	if (!tsk->fs)		return -ENOMEM;	return 0;} static int copy_files(u64 clone_flags, struct task_struct *tsk,		      int no_files){	struct files_struct *oldf, *newf; 	/*	 * A background process may not have any files ...	 */	oldf = current->files;	if (!oldf)		return 0; 	if (no_files) {		tsk->files = NULL;		return 0;	} 	if (clone_flags & CLONE_FILES) {		atomic_inc(&oldf->count);		return 0;	} 	newf = dup_fd(oldf, NULL);	if (IS_ERR(newf))		return PTR_ERR(newf); 	tsk->files = newf;	return 0;} static int copy_sighand(u64 clone_flags, struct task_struct *tsk){	struct sighand_struct *sig; 	if (clone_flags & CLONE_SIGHAND) {		refcount_inc(&current->sighand->count);		return 0;	}	sig = kmem_cache_alloc(sighand_cachep, GFP_KERNEL);	RCU_INIT_POINTER(tsk->sighand, sig);	if (!sig)		return -ENOMEM; 	refcount_set(&sig->count, 1);	spin_lock_irq(&current->sighand->siglock);	memcpy(sig->action, current->sighand->action, sizeof(sig->action));	spin_unlock_irq(&current->sighand->siglock); 	/* Reset all signal handler not set to SIG_IGN to SIG_DFL. */	if (clone_flags & CLONE_CLEAR_SIGHAND)		flush_signal_handlers(tsk, 0); 	return 0;} void __cleanup_sighand(struct sighand_struct *sighand){	if (refcount_dec_and_test(&sighand->count)) {		signalfd_cleanup(sighand);		/*		 * sighand_cachep is SLAB_TYPESAFE_BY_RCU so we can free it		 * without an RCU grace period, see __lock_task_sighand().		 */		kmem_cache_free(sighand_cachep, sighand);	}} /* * Initialize POSIX timer handling for a thread group. */static void posix_cpu_timers_init_group(struct signal_struct *sig){	struct posix_cputimers *pct = &sig->posix_cputimers;	unsigned long cpu_limit; 	cpu_limit = READ_ONCE(sig->rlim[RLIMIT_CPU].rlim_cur);	posix_cputimers_group_init(pct, cpu_limit);} static int copy_signal(u64 clone_flags, struct task_struct *tsk){	struct signal_struct *sig; 	if (clone_flags & CLONE_THREAD)		return 0; 	sig = kmem_cache_zalloc(signal_cachep, GFP_KERNEL);	tsk->signal = sig;	if (!sig)		return -ENOMEM; 	sig->nr_threads = 1;	sig->quick_threads = 1;	atomic_set(&sig->live, 1);	refcount_set(&sig->sigcnt, 1); 	/* list_add(thread_node, thread_head) without INIT_LIST_HEAD() */	sig->thread_head = (struct list_head)LIST_HEAD_INIT(tsk->thread_node);	tsk->thread_node = (struct list_head)LIST_HEAD_INIT(sig->thread_head); 	init_waitqueue_head(&sig->wait_chldexit);	sig->curr_target = tsk;	init_sigpending(&sig->shared_pending);	INIT_HLIST_HEAD(&sig->multiprocess);	seqlock_init(&sig->stats_lock);	prev_cputime_init(&sig->prev_cputime); #ifdef CONFIG_POSIX_TIMERS	INIT_HLIST_HEAD(&sig->posix_timers);	INIT_HLIST_HEAD(&sig->ignored_posix_timers);	hrtimer_setup(&sig->real_timer, it_real_fn, CLOCK_MONOTONIC, HRTIMER_MODE_REL);#endif 	task_lock(current->group_leader);	memcpy(sig->rlim, current->signal->rlim, sizeof sig->rlim);	task_unlock(current->group_leader); 	posix_cpu_timers_init_group(sig); 	tty_audit_fork(sig);	sched_autogroup_fork(sig); #ifdef CONFIG_CGROUPS	init_rwsem(&sig->cgroup_threadgroup_rwsem);#endif 	sig->oom_score_adj = current->signal->oom_score_adj;	sig->oom_score_adj_min = current->signal->oom_score_adj_min; 	mutex_init(&sig->cred_guard_mutex);	init_rwsem(&sig->exec_update_lock); 	return 0;} static void copy_seccomp(struct task_struct *p){#ifdef CONFIG_SECCOMP	/*	 * Must be called with sighand->lock held, which is common to	 * all threads in the group. Holding cred_guard_mutex is not	 * needed because this new task is not yet running and cannot	 * be racing exec.	 */	assert_spin_locked(&current->sighand->siglock); 	/* Ref-count the new filter user, and assign it. */	get_seccomp_filter(current);	p->seccomp = current->seccomp; 	/*	 * Explicitly enable no_new_privs here in case it got set	 * between the task_struct being duplicated and holding the	 * sighand lock. The seccomp state and nnp must be in sync.	 */	if (task_no_new_privs(current))		task_set_no_new_privs(p); 	/*	 * If the parent gained a seccomp mode after copying thread	 * flags and between before we held the sighand lock, we have	 * to manually enable the seccomp thread flag here.	 */	if (p->seccomp.mode != SECCOMP_MODE_DISABLED)		set_task_syscall_work(p, SECCOMP);#endif} SYSCALL_DEFINE1(set_tid_address, int __user *, tidptr){	current->clear_child_tid = tidptr; 	return task_pid_vnr(current);} static void rt_mutex_init_task(struct task_struct *p){	raw_spin_lock_init(&p->pi_lock);#ifdef CONFIG_RT_MUTEXES	p->pi_waiters = RB_ROOT_CACHED;	p->pi_top_task = NULL;	p->pi_blocked_on = NULL;#endif} static inline void init_task_pid_links(struct task_struct *task){	enum pid_type type; 	for (type = PIDTYPE_PID; type < PIDTYPE_MAX; ++type)		INIT_HLIST_NODE(&task->pid_links[type]);} static inline voidinit_task_pid(struct task_struct *task, enum pid_type type, struct pid *pid){	if (type == PIDTYPE_PID)		task->thread_pid = pid;	else		task->signal->pids[type] = pid;} static inline void rcu_copy_process(struct task_struct *p){#ifdef CONFIG_PREEMPT_RCU	p->rcu_read_lock_nesting = 0;	p->rcu_read_unlock_special.s = 0;	p->rcu_blocked_node = NULL;	INIT_LIST_HEAD(&p->rcu_node_entry);#endif /* #ifdef CONFIG_PREEMPT_RCU */#ifdef CONFIG_TASKS_RCU	p->rcu_tasks_holdout = false;	INIT_LIST_HEAD(&p->rcu_tasks_holdout_list);	p->rcu_tasks_idle_cpu = -1;	INIT_LIST_HEAD(&p->rcu_tasks_exit_list);#endif /* #ifdef CONFIG_TASKS_RCU */#ifdef CONFIG_TASKS_TRACE_RCU	p->trc_reader_nesting = 0;#endif /* #ifdef CONFIG_TASKS_TRACE_RCU */} /** * pidfd_prepare - allocate a new pidfd_file and reserve a pidfd * @pid:   the struct pid for which to create a pidfd * @flags: flags of the new @pidfd * @ret_file: return the new pidfs file * * Allocate a new file that stashes @pid and reserve a new pidfd number in the * caller's file descriptor table. The pidfd is reserved but not installed yet. * * The helper verifies that @pid is still in use, without PIDFD_THREAD the * task identified by @pid must be a thread-group leader. * * If this function returns successfully the caller is responsible to either * call fd_install() passing the returned pidfd and pidfd file as arguments in * order to install the pidfd into its file descriptor table or they must use * put_unused_fd() and fput() on the returned pidfd and pidfd file * respectively. * * This function is useful when a pidfd must already be reserved but there * might still be points of failure afterwards and the caller wants to ensure * that no pidfd is leaked into its file descriptor table. * * Return: On success, a reserved pidfd is returned from the function and a new *         pidfd file is returned in the last argument to the function. On *         error, a negative error code is returned from the function and the *         last argument remains unchanged. */int pidfd_prepare(struct pid *pid, unsigned int flags, struct file **ret_file){	struct file *pidfs_file; 	/*	 * PIDFD_STALE is only allowed to be passed if the caller knows	 * that @pid is already registered in pidfs and thus	 * PIDFD_INFO_EXIT information is guaranteed to be available.	 */	if (!(flags & PIDFD_STALE)) {		/*		 * While holding the pidfd waitqueue lock removing the		 * task linkage for the thread-group leader pid		 * (PIDTYPE_TGID) isn't possible. Thus, if there's still		 * task linkage for PIDTYPE_PID not having thread-group		 * leader linkage for the pid means it wasn't a		 * thread-group leader in the first place.		 */		guard(spinlock_irq)(&pid->wait_pidfd.lock); 		/* Task has already been reaped. */		if (!pid_has_task(pid, PIDTYPE_PID))			return -ESRCH;		/*		 * If this struct pid isn't used as a thread-group		 * leader but the caller requested to create a		 * thread-group leader pidfd then report ENOENT.		 */		if (!(flags & PIDFD_THREAD) && !pid_has_task(pid, PIDTYPE_TGID))			return -ENOENT;	} 	CLASS(get_unused_fd, pidfd)(O_CLOEXEC);	if (pidfd < 0)		return pidfd; 	pidfs_file = pidfs_alloc_file(pid, flags | O_RDWR);	if (IS_ERR(pidfs_file))		return PTR_ERR(pidfs_file); 	*ret_file = pidfs_file;	return take_fd(pidfd);} static void __delayed_free_task(struct rcu_head *rhp){	struct task_struct *tsk = container_of(rhp, struct task_struct, rcu); 	free_task(tsk);} static __always_inline void delayed_free_task(struct task_struct *tsk){	if (IS_ENABLED(CONFIG_MEMCG))		call_rcu(&tsk->rcu, __delayed_free_task);	else		free_task(tsk);} static void copy_oom_score_adj(u64 clone_flags, struct task_struct *tsk){	/* Skip if kernel thread */	if (!tsk->mm)		return; 	/* Skip if spawning a thread or using vfork */	if ((clone_flags & (CLONE_VM | CLONE_THREAD | CLONE_VFORK)) != CLONE_VM)		return; 	/* We need to synchronize with __set_oom_adj */	mutex_lock(&oom_adj_mutex);	mm_flags_set(MMF_MULTIPROCESS, tsk->mm);	/* Update the values in case they were changed after copy_signal */	tsk->signal->oom_score_adj = current->signal->oom_score_adj;	tsk->signal->oom_score_adj_min = current->signal->oom_score_adj_min;	mutex_unlock(&oom_adj_mutex);} #ifdef CONFIG_RVstatic void rv_task_fork(struct task_struct *p){	memset(&p->rv, 0, sizeof(p->rv));}#else#define rv_task_fork(p) do {} while (0)#endif static bool need_futex_hash_allocate_default(u64 clone_flags){	/*	 * Allocate a default futex hash for any sibling that will	 * share the parent's mm, except vfork.	 */	return (clone_flags & (CLONE_VM | CLONE_VFORK)) == CLONE_VM;} /* * This creates a new process as a copy of the old one, * but does not actually start it yet. * * It copies the registers, and all the appropriate * parts of the process environment (as per the clone * flags). The actual kick-off is left to the caller. */__latent_entropy struct task_struct *copy_process(					struct pid *pid,					int trace,					int node,					struct kernel_clone_args *args){	int pidfd = -1, retval;

Lines 1501–2000 of 3409. 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