copy_process

전체 흐름

copy_process()는 새 task를 준비하고 부모·PID 관계에 연결해 아직 실행되지 않은 task_struct *를 반환한다. 일반적인 kernel_clone() 호출자는 그 반환값을 받은 뒤 별도로 wake_up_new_task()를 호출한다. 두 함수의 경계를 합치면 공개 시점과 실행 시작을 혼동한다 (kernel/fork.c:2735, kernel/fork.c:2940).

실선은 정상 경로, 주황색은 공개 전 실패 정리다. 그림 크게 열기.

create_io_thread()처럼 copy_process()를 직접 호출하는 경로도 있다. 이 함수는 비활성 task를 반환하며 호출자가 깨워야 한다 (kernel/fork.c:2838). 따라서 wakeup은 copy_process()의 일반적 내부 후속 단계가 아니다.

소스 코드 위치

아래 행 번호는 이 글의 Linux v6.6 고정 소스에 맞춘 것이다. 다른 버전의 유사 코드와 섞지 않는다.

원본 트리: kernel/fork.c, kernel/sched/core.c.

대표 코드

모든 발췌는 해당 고정 버전의 실제 연속 행이다. 이전의 “wake_up_new_task”라는 제목 아래 create_io_thread()와 kernel_clone() 시작 부분을 묶은 발췌는 실제 호출 지점과 스케줄러 구현으로 교체했다.

static struct task_struct *dup_task_struct(struct task_struct *orig, int node)
{
	struct task_struct *tsk;
	int err;

	if (node == NUMA_NO_NODE)
		node = tsk_fork_get_node(orig);
	tsk = alloc_task_struct_node(node);
	if (!tsk)
		return NULL;

	err = arch_dup_task_struct(tsk, orig);
	if (err)
		goto free_tsk;

	err = alloc_thread_stack_node(tsk, node);
	if (err)
		goto free_tsk;

	retval = copy_files(clone_flags, p, args->no_files);
	if (retval)
		goto bad_fork_cleanup_semundo;
	retval = copy_fs(clone_flags, p);
	if (retval)
		goto bad_fork_cleanup_files;
	retval = copy_sighand(clone_flags, p);
	if (retval)
		goto bad_fork_cleanup_fs;
	retval = copy_signal(clone_flags, p);
	if (retval)
		goto bad_fork_cleanup_sighand;
	retval = copy_mm(clone_flags, p);
	if (retval)
		goto bad_fork_cleanup_signal;
	retval = copy_namespaces(clone_flags, p);
	if (retval)
		goto bad_fork_cleanup_mm;
	retval = copy_io(clone_flags, p);
	if (retval)
		goto bad_fork_cleanup_namespaces;
	retval = copy_thread(p, args);
	if (retval)
		goto bad_fork_cleanup_io;

			list_add_tail(&p->sibling, &p->real_parent->children);
			list_add_tail_rcu(&p->tasks, &init_task.tasks);
			attach_pid(p, PIDTYPE_TGID);
			attach_pid(p, PIDTYPE_PGID);
			attach_pid(p, PIDTYPE_SID);
			__this_cpu_inc(process_counts);
		} else {
			current->signal->nr_threads++;
			current->signal->quick_threads++;
			atomic_inc(&current->signal->live);
			refcount_inc(&current->signal->sigcnt);
			task_join_group_stop(p);
			list_add_tail_rcu(&p->thread_group,
					  &p->group_leader->thread_group);
			list_add_tail_rcu(&p->thread_node,
					  &p->signal->thread_head);
		}
		attach_pid(p, PIDTYPE_PID);
		nr_threads++;

	p = copy_process(NULL, trace, NUMA_NO_NODE, args);
	add_latent_entropy();

	if (IS_ERR(p))
		return PTR_ERR(p);

	/*
	 * Do this prior waking up the new thread - the thread pointer
	 * might get invalid after that point, if the thread exits quickly.
	 */
	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, args->parent_tid);

	if (clone_flags & CLONE_VFORK) {
		p->vfork_done = &vfork;
		init_completion(&vfork);
		get_task_struct(p);
	}

	if (IS_ENABLED(CONFIG_LRU_GEN) && !(clone_flags & CLONE_VM)) {
		/* lock the task to synchronize with memcg migration */
		task_lock(p);
		lru_gen_add_mm(p->mm);
		task_unlock(p);
	}

	wake_up_new_task(p);

void wake_up_new_task(struct task_struct *p)
{
	struct rq_flags rf;
	struct rq *rq;

	raw_spin_lock_irqsave(&p->pi_lock, rf.flags);
	WRITE_ONCE(p->__state, TASK_RUNNING);
#ifdef CONFIG_SMP
	/*
	 * Fork balancing, do it here and not earlier because:
	 *  - cpus_ptr can change in the fork path
	 *  - any previously selected CPU might disappear through hotplug
	 *
	 * Use __set_task_cpu() to avoid calling sched_class::migrate_task_rq,
	 * as we're not fully set-up yet.
	 */
	p->recent_used_cpu = task_cpu(p);
	rseq_migrate(p);
	__set_task_cpu(p, select_task_rq(p, task_cpu(p), WF_FORK));
#endif
	rq = __task_rq_lock(p, &rf);
	update_rq_clock(rq);
	post_init_entity_util_avg(p);

	activate_task(rq, p, ENQUEUE_NOCLOCK);
	trace_sched_wakeup_new(p);
	check_preempt_curr(rq, p, WF_FORK);
#ifdef CONFIG_SMP
	if (p->sched_class->task_woken) {
		/*
		 * Nothing relies on rq->lock after this, so it's fine to
		 * drop it.
		 */
		rq_unpin_lock(rq, &rf);
		p->sched_class->task_woken(rq, p);
		rq_repin_lock(rq, &rf);
	}
#endif
	task_rq_unlock(rq, p, &rf);
}

함수별 분석

dup_task_struct(orig,node)에는 clone_flags 매개변수가 없다. flags 정책은 copy_process()의 검증과 각 copy_*() helper에서 처리한다 (kernel/fork.c:2327, kernel/fork.c:2489).

객체와 연결 관계

상태 전이와 오류 되감기

검토할 불변 조건

• flags 검증: CLONE_THREAD, CLONE_SIGHAND, CLONE_VM의 조합 제약을 자원 helper 진입 전에 확인한다 (kernel/fork.c:2240).
• 공개 전 준비: cgroup 및 scheduler 준비가 끝난 뒤 tasklist_lock 아래 연결한다 (kernel/fork.c:2596, kernel/fork.c:2626).
• 오류 정리: 각 goto bad_fork_*는 그 시점까지 성공한 작업에 맞는 레이블로 들어간다. 하나의 공통 “rollback” 함수로 단순화하지 않는다 (kernel/fork.c:2737).
• 호출자 경계: 성공한 copy_process()는 task를 깨우지 않는다. 일반 kernel_clone()과 create_io_thread()의 호출자 책임을 구별한다 (kernel/fork.c:2909).

계측과 검증

tracepoint는 소스에서 호출된 위치를 기준으로 해석한다. event가 보였다고 앞선 모든 사용자 관찰이나 자식의 실제 실행이 끝났다는 뜻은 아니다.

grep -E 'task_newtask|sched_process_fork|sched_wakeup_new' /sys/kernel/tracing/available_events

위 확인은 읽기 전용이다. 이벤트가 없는 커널 구성에서는 그 이벤트로 단계가 관찰된다고 가정하지 않는다.

추가 확인 사항

• CLONE_FILES나 CLONE_VM의 공유 참조 증가가 실패 unwind의 어느 해제 함수와 짝을 이루는가?
• CLONE_PARENT|CLONE_THREAD 여부에 따라 real_parent와 thread 목록 연결이 어떻게 달라지는가?
• 실패가 kernel/fork.c:2596 전후 어느 label에 도달하는가? 성공 시 kernel/fork.c:2940 호출 전에 무엇이 관찰 가능한가?
• sched_cgroup_fork()은 이 버전에서 void; 실패 분기 없음. 이 버전의 scheduler 상태를 kernel/sched/core.c:4848의 enqueue와 구분할 수 있는가?