自学教程：C++ wake_up_new_task函数代码示例

/* *  Ok, this is the main fork-routine. * * It copies the process, and if successful kick-starts * it and waits for it to finish using the VM if required. */long do_fork(unsigned long clone_flags,	      unsigned long stack_start,	      struct pt_regs *regs,	      unsigned long stack_size,	      int __user *parent_tidptr,	      int __user *child_tidptr){	struct task_struct *p;	int trace = 0;	long pid = alloc_pidmap();	if (pid < 0)		return -EAGAIN;	if (unlikely(current->ptrace)) {		trace = fork_traceflag (clone_flags);		if (trace)			clone_flags |= CLONE_PTRACE;	}	p = copy_process(clone_flags, stack_start, regs, stack_size, parent_tidptr, child_tidptr, pid);	/*	 * Do this prior waking up the new thread - the thread pointer	 * might get invalid after that point, if the thread exits quickly.	 */	if (!IS_ERR(p)) {		struct completion vfork;		if (clone_flags & CLONE_VFORK) {			p->vfork_done = &vfork;			init_completion(&vfork);		}		if ((p->ptrace & PT_PTRACED) || (clone_flags & CLONE_STOPPED)) {			/*			 * We'll start up with an immediate SIGSTOP.			 */			sigaddset(&p->pending.signal, SIGSTOP);			set_tsk_thread_flag(p, TIF_SIGPENDING);		}		if (!(clone_flags & CLONE_STOPPED))			wake_up_new_task(p, clone_flags);		else			p->state = TASK_STOPPED;		if (unlikely (trace)) {			current->ptrace_message = pid;			ptrace_notify ((trace << 8) | SIGTRAP);		}		if (clone_flags & CLONE_VFORK) {			wait_for_completion(&vfork);			if (unlikely (current->ptrace & PT_TRACE_VFORK_DONE))				ptrace_notify ((PTRACE_EVENT_VFORK_DONE << 8) | SIGTRAP);		}	} else {		free_pidmap(pid);		pid = PTR_ERR(p);	}	return pid;}

/* *  Ok, this is the main fork-routine. * * It copies the process, and if successful kick-starts * it and waits for it to finish using the VM if required. */long do_fork(unsigned long clone_flags,	      unsigned long stack_start,	      struct pt_regs *regs,	      unsigned long stack_size,	      int __user *parent_tidptr,	      int __user *child_tidptr){	struct task_struct *p;	int trace = 0;	long nr;	/*	 * Do some preliminary argument and permissions checking before we	 * actually start allocating stuff	 */	if (clone_flags & CLONE_NEWUSER) {		if (clone_flags & CLONE_THREAD)			return -EINVAL;		/* hopefully this check will go away when userns support is		 * complete		 */		if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SETUID) ||				!capable(CAP_SETGID))			return -EPERM;	}	/*	 * We hope to recycle these flags after 2.6.26	 */	if (unlikely(clone_flags & CLONE_STOPPED)) {		static int __read_mostly count = 100;		if (count > 0 && printk_ratelimit()) {			char comm[TASK_COMM_LEN];			count--;			printk(KERN_INFO "fork(): process `%s' used deprecated "					"clone flags 0x%lx/n",				get_task_comm(comm, current),				clone_flags & CLONE_STOPPED);		}	}	/*	 * When called from kernel_thread, don't do user tracing stuff.	 */	if (likely(user_mode(regs)))		trace = tracehook_prepare_clone(clone_flags);	p = copy_process(clone_flags, stack_start, regs, stack_size,			 child_tidptr, NULL, trace);	/*	 * Do this prior waking up the new thread - the thread pointer	 * might get invalid after that point, if the thread exits quickly.	 */	if (!IS_ERR(p)) {		struct completion vfork;		trace_sched_process_fork(current, p);		nr = task_pid_vnr(p);		if (clone_flags & CLONE_PARENT_SETTID)			put_user(nr, parent_tidptr);		if (clone_flags & CLONE_VFORK) {			p->vfork_done = &vfork;			init_completion(&vfork);		}		audit_finish_fork(p);		tracehook_report_clone(regs, clone_flags, nr, p);		/*		 * We set PF_STARTING at creation in case tracing wants to		 * use this to distinguish a fully live task from one that		 * hasn't gotten to tracehook_report_clone() yet.  Now we		 * clear it and set the child going.		 */		p->flags &= ~PF_STARTING;		if (unlikely(clone_flags & CLONE_STOPPED)) {			/*			 * We'll start up with an immediate SIGSTOP.			 */			sigaddset(&p->pending.signal, SIGSTOP);			set_tsk_thread_flag(p, TIF_SIGPENDING);			__set_task_state(p, TASK_STOPPED);		} else {			wake_up_new_task(p, clone_flags);		}		tracehook_report_clone_complete(trace, regs,						clone_flags, nr, p);//.........这里部分代码省略.........

/* *  Ok, this is the main fork-routine. * * It copies the process, and if successful kick-starts * it and waits for it to finish using the VM if required. */long do_fork(unsigned long clone_flags,             unsigned long stack_start,             struct pt_regs *regs,             unsigned long stack_size,             int __user *parent_tidptr,             int __user *child_tidptr){    struct task_struct *p;    int trace = 0;    long nr;    /*     * Do some preliminary argument and permissions checking before we     * actually start allocating stuff     */    if (clone_flags & CLONE_NEWUSER) {        if (clone_flags & CLONE_THREAD)            return -EINVAL;        /* hopefully this check will go away when userns support is         * complete         */        if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SETUID) ||                !capable(CAP_SETGID))            return -EPERM;    }    /*     * When called from kernel_thread, don't do user tracing stuff.     */    if (likely(user_mode(regs)))        trace = tracehook_prepare_clone(clone_flags);    p = copy_process(clone_flags, stack_start, regs, stack_size,                     child_tidptr, NULL, trace);    /*     * Do this prior waking up the new thread - the thread pointer     * might get invalid after that point, if the thread exits quickly.     */    if (!IS_ERR(p)) {        struct completion vfork;        trace_sched_process_fork(current, p);        nr = task_pid_vnr(p);        if (clone_flags & CLONE_PARENT_SETTID)            put_user(nr, parent_tidptr);        if (clone_flags & CLONE_VFORK) {            p->vfork_done = &vfork;            init_completion(&vfork);        }        audit_finish_fork(p);        tracehook_report_clone(regs, clone_flags, nr, p);        /*         * We set PF_STARTING at creation in case tracing wants to         * use this to distinguish a fully live task from one that         * hasn't gotten to tracehook_report_clone() yet.  Now we         * clear it and set the child going.         */        p->flags &= ~PF_STARTING;        wake_up_new_task(p);        tracehook_report_clone_complete(trace, regs,                                        clone_flags, nr, p);        if (clone_flags & CLONE_VFORK) {            freezer_do_not_count();            wait_for_completion(&vfork);            freezer_count();            tracehook_report_vfork_done(p, nr);        }    } else {        nr = PTR_ERR(p);    }    return nr;}

/* *  Ok, this is the main fork-routine. * * It copies the process, and if successful kick-starts * it and waits for it to finish using the VM if required. */long do_fork(unsigned long clone_flags,	      unsigned long stack_start,	      unsigned long stack_size,	      int __user *parent_tidptr,	      int __user *child_tidptr){	struct task_struct *p;	int trace = 0;	long nr;	/*	 * Determine whether and which event to report to ptracer.  When	 * called from kernel_thread or CLONE_UNTRACED is explicitly	 * requested, no event is reported; otherwise, report if the event	 * for the type of forking is enabled.	 */	if (!(clone_flags & CLONE_UNTRACED)) {		if (clone_flags & CLONE_VFORK)			trace = PTRACE_EVENT_VFORK;		else if ((clone_flags & CSIGNAL) != SIGCHLD)			trace = PTRACE_EVENT_CLONE;		else			trace = PTRACE_EVENT_FORK;		if (likely(!ptrace_event_enabled(current, trace)))			trace = 0;	}	p = copy_process(clone_flags, stack_start, stack_size,			 child_tidptr, NULL, trace);	/*	 * Do this prior waking up the new thread - the thread pointer	 * might get invalid after that point, if the thread exits quickly.	 */	if (!IS_ERR(p)) {		struct completion vfork;		struct pid *pid;		trace_sched_process_fork(current, p);		pid = get_task_pid(p, PIDTYPE_PID);		nr = pid_vnr(pid);		if (clone_flags & CLONE_PARENT_SETTID)			put_user(nr, parent_tidptr);		if (clone_flags & CLONE_VFORK) {			p->vfork_done = &vfork;			init_completion(&vfork);			get_task_struct(p);		}		wake_up_new_task(p);		/* forking complete and child started to run, tell ptracer */		if (unlikely(trace))			ptrace_event_pid(trace, pid);		if (clone_flags & CLONE_VFORK) {			if (!wait_for_vfork_done(p, &vfork))				ptrace_event_pid(PTRACE_EVENT_VFORK_DONE, pid);		}		put_pid(pid);	} else {		nr = PTR_ERR(p);	}	return nr;}

long do_fork(unsigned long clone_flags,	      unsigned long stack_start,	      unsigned long stack_size,	      int __user *parent_tidptr,	      int __user *child_tidptr){	struct task_struct *p;	int trace = 0;	long nr;	/*	 * Do some preliminary argument and permissions checking before we	 * actually start allocating stuff	 */	if (clone_flags & (CLONE_NEWUSER | CLONE_NEWPID)) {		if (clone_flags & (CLONE_THREAD|CLONE_PARENT)) {			printk("[%d:%s] fork fail at clone_thread, flags:0x%x/n", current->pid, current->comm, (unsigned int)clone_flags);			return -EINVAL;		}	}	/*	 * Determine whether and which event to report to ptracer.  When	 * called from kernel_thread or CLONE_UNTRACED is explicitly	 * requested, no event is reported; otherwise, report if the event	 * for the type of forking is enabled.	 */	if (!(clone_flags & CLONE_UNTRACED)) {		if (clone_flags & CLONE_VFORK)			trace = PTRACE_EVENT_VFORK;		else if ((clone_flags & CSIGNAL) != SIGCHLD)			trace = PTRACE_EVENT_CLONE;		else			trace = PTRACE_EVENT_FORK;		if (likely(!ptrace_event_enabled(current, trace)))			trace = 0;	}	p = copy_process(clone_flags, stack_start, stack_size,			 child_tidptr, NULL, trace);	/*	 * Do this prior waking up the new thread - the thread pointer	 * might get invalid after that point, if the thread exits quickly.	 */	if (!IS_ERR(p)) {		struct completion vfork;		struct pid *pid;		trace_sched_process_fork(current, p);		pid = get_task_pid(p, PIDTYPE_PID);		nr = pid_vnr(pid);		if (clone_flags & CLONE_PARENT_SETTID)			put_user(nr, parent_tidptr);		if (clone_flags & CLONE_VFORK) {			p->vfork_done = &vfork;			init_completion(&vfork);			get_task_struct(p);		}#ifdef CONFIG_SCHEDSTATS        /* mt shceduler profiling*/        save_mtproc_info(p, sched_clock());	        printk(KERN_DEBUG "[%d:%s] fork [%d:%s]/n", current->pid, current->comm, p->pid, p->comm);#endif		wake_up_new_task(p);		/* forking complete and child started to run, tell ptracer */		if (unlikely(trace))			ptrace_event_pid(trace, pid);		if (clone_flags & CLONE_VFORK) {			if (!wait_for_vfork_done(p, &vfork))				ptrace_event_pid(PTRACE_EVENT_VFORK_DONE, pid);		}		put_pid(pid);#ifdef CONFIG_MT_PRIO_TRACER		create_prio_tracer(task_pid_nr(p));		update_prio_tracer(task_pid_nr(p), p->prio, p->policy, PTS_KRNL);#endif	} else {		nr = PTR_ERR(p);		printk("[%d:%s] fork fail:[0x%x, %d]/n", current->pid, current->comm, (unsigned int)p,(int) nr);	}	return nr;}

long do_fork(unsigned long clone_flags,	      unsigned long stack_start,	      struct pt_regs *regs,	      unsigned long stack_size,	      int __user *parent_tidptr,	      int __user *child_tidptr){	struct task_struct *p;	int trace = 0;	long nr;	if (clone_flags & CLONE_NEWUSER) {		if (clone_flags & CLONE_THREAD)			return -EINVAL;		if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SETUID) ||				!capable(CAP_SETGID))			return -EPERM;	}	if (likely(user_mode(regs)) && !(clone_flags & CLONE_UNTRACED)) {		if (clone_flags & CLONE_VFORK)			trace = PTRACE_EVENT_VFORK;		else if ((clone_flags & CSIGNAL) != SIGCHLD)			trace = PTRACE_EVENT_CLONE;		else			trace = PTRACE_EVENT_FORK;		if (likely(!ptrace_event_enabled(current, trace)))			trace = 0;	}	p = copy_process(clone_flags, stack_start, regs, stack_size,			 child_tidptr, NULL, trace);	if (!IS_ERR(p)) {		struct completion vfork;		trace_sched_process_fork(current, p);		nr = task_pid_vnr(p);		if (clone_flags & CLONE_PARENT_SETTID)			put_user(nr, parent_tidptr);		if (clone_flags & CLONE_VFORK) {			p->vfork_done = &vfork;			init_completion(&vfork);			get_task_struct(p);		}		wake_up_new_task(p);				if (unlikely(trace))			ptrace_event(trace, nr);		if (clone_flags & CLONE_VFORK) {			if (!wait_for_vfork_done(p, &vfork))				ptrace_event(PTRACE_EVENT_VFORK_DONE, nr);		}	} else {		nr = PTR_ERR(p);	}	return nr;}

/* *  Ok, this is the main fork-routine. * * It copies the process, and if successful kick-starts * it and waits for it to finish using the VM if required. */long do_fork(unsigned long clone_flags,	      unsigned long stack_start,	      struct pt_regs *regs,	      unsigned long stack_size,	      int __user *parent_tidptr,	      int __user *child_tidptr){	struct task_struct *p;	int trace = 0;	long nr;	if (unlikely(current->ptrace)) {		trace = fork_traceflag (clone_flags);		if (trace)			clone_flags |= CLONE_PTRACE;	}	p = copy_process(clone_flags, stack_start, regs, stack_size,			child_tidptr, NULL);	/*	 * Do this prior waking up the new thread - the thread pointer	 * might get invalid after that point, if the thread exits quickly.	 */	if (!IS_ERR(p)) {		struct completion vfork;		/*		 * this is enough to call pid_nr_ns here, but this if		 * improves optimisation of regular fork()		 */		nr = (clone_flags & CLONE_NEWPID) ?			task_pid_nr_ns(p, current->nsproxy->pid_ns) :				task_pid_vnr(p);		if (clone_flags & CLONE_PARENT_SETTID)			put_user(nr, parent_tidptr);		if (clone_flags & CLONE_VFORK) {			p->vfork_done = &vfork;			init_completion(&vfork);		}		if ((p->ptrace & PT_PTRACED) || (clone_flags & CLONE_STOPPED)) {			/*			 * We'll start up with an immediate SIGSTOP.			 */			sigaddset(&p->pending.signal, SIGSTOP);			set_tsk_thread_flag(p, TIF_SIGPENDING);		}		if (!(clone_flags & CLONE_STOPPED))			wake_up_new_task(p, clone_flags);		else			p->state = TASK_STOPPED;		if (unlikely (trace)) {			current->ptrace_message = nr;			ptrace_notify ((trace << 8) | SIGTRAP);		}		if (clone_flags & CLONE_VFORK) {			freezer_do_not_count();			wait_for_completion(&vfork);			freezer_count();			if (unlikely (current->ptrace & PT_TRACE_VFORK_DONE)) {				current->ptrace_message = nr;				ptrace_notify ((PTRACE_EVENT_VFORK_DONE << 8) | SIGTRAP);			}		}	} else {		nr = PTR_ERR(p);	}	return nr;}