[linux kernel] fork() syscall analysis

/* Internal name for fork function.  */
extern __pid_t __libc_fork (void);

pid_t
__libc_fork (void)
{
  /* Determine if we are running multiple threads.  We skip some fork
     handlers in the single-thread case, to make fork safer to use in
     signal handlers.  Although POSIX has dropped async-signal-safe
     requirement for fork (Austin Group tracker issue #62) this is
     best effort to make is async-signal-safe at least for single-thread
     case.  */
  bool multiple_threads = !SINGLE_THREAD_P;
  uint64_t lastrun;

  lastrun = __run_prefork_handlers (multiple_threads);

  struct nss_database_data nss_database_data;

  /* If we are not running multiple threads, we do not have to
     preserve lock state.  If fork runs from a signal handler, only
     async-signal-safe functions can be used in the child.  These data
     structures are only used by unsafe functions, so their state does
     not matter if fork was called from a signal handler.  */
  if (multiple_threads)
    {
      call_function_static_weak (__nss_database_fork_prepare_parent,
				 &nss_database_data);

      _IO_proc_file_chain_lock ();
      _IO_list_lock ();

      /* Acquire malloc locks.  This needs to come last because fork
	 handlers may use malloc, and the libio list lock has an
	 indirect malloc dependency as well (via the getdelim
	 function).  */
      call_function_static_weak (__malloc_fork_lock_parent);
    }

  pid_t pid = _Fork ();

  if (pid == 0)
    {
      fork_system_setup ();

      /* Reset the lock state in the multi-threaded case.  */
      if (multiple_threads)
	{
	  __libc_unwind_link_after_fork ();

	  fork_system_setup_after_fork ();

	  call_function_static_weak (__abort_fork_reset_child);

	  /* Release malloc locks.  */
	  call_function_static_weak (__malloc_fork_unlock_child);

	  /* Reset the file list.  These are recursive mutexes.  */
	  fresetlockfiles ();

	  /* Reset locks in the I/O code.  */
	  _IO_list_resetlock ();
	  _IO_proc_file_chain_resetlock ();

	  call_function_static_weak (__nss_database_fork_subprocess,
				     &nss_database_data);
	}

      /* Reset the lock the dynamic loader uses to protect its data.  */
      __rtld_lock_initialize (GL(dl_load_lock));

      /* Reset the lock protecting dynamic TLS related data.  */
      __rtld_lock_initialize (GL(dl_load_tls_lock));

      reclaim_stacks ();

      /* Run the handlers registered for the child.  */
      __run_postfork_handlers (atfork_run_child, multiple_threads, lastrun);
    }
  else
    {
      /* If _Fork failed, preserve its errno value.  */
      int save_errno = errno;

      /* Release acquired locks in the multi-threaded case.  */
      if (multiple_threads)
	{
	  /* Release malloc locks, parent process variant.  */
	  call_function_static_weak (__malloc_fork_unlock_parent);

	  /* We execute this even if the 'fork' call failed.  */
	  _IO_list_unlock ();
	  _IO_proc_file_chain_unlock ();
	}

      /* Run the handlers registered for the parent.  */
      __run_postfork_handlers (atfork_run_parent, multiple_threads, lastrun);

      if (pid < 0)
	__set_errno (save_errno);
    }

  return pid;
}
weak_alias (__libc_fork, __fork)
libc_hidden_def (__fork)
weak_alias (__libc_fork, fork)

// 중요하지 않는 부분은 뺐다.
SYSCALL_DEFINE2(clone3, struct clone_args __user *, uargs, size_t, size)
{
	int err;

	struct kernel_clone_args kargs;
	pid_t set_tid[MAX_PID_NS_LEVEL];

	kargs.set_tid = set_tid;

	err = copy_clone_args_from_user(&kargs, uargs, size);
	if (err)
		return err;

	if (!clone3_args_valid(&kargs))
		return -EINVAL;

	return kernel_clone(&kargs);
}

pid_t kernel_clone(struct kernel_clone_args *args)
{
	u64 clone_flags = args->flags;
	struct completion vfork;
	struct pid *pid;
	struct task_struct *p;
	int trace = 0;
	pid_t nr;

	/*
	 * For legacy clone() calls, CLONE_PIDFD uses the parent_tid argument
	 * to return the pidfd. Hence, CLONE_PIDFD and CLONE_PARENT_SETTID are
	 * mutually exclusive. With clone3() CLONE_PIDFD has grown a separate
	 * field in struct clone_args and it still doesn't make sense to have
	 * them both point at the same memory location. Performing this check
	 * here has the advantage that we don't need to have a separate helper
	 * to check for legacy clone().
	 */
	if ((clone_flags & CLONE_PIDFD) &&
	    (clone_flags & CLONE_PARENT_SETTID) &&
	    (args->pidfd == args->parent_tid))
		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 (args->exit_signal != SIGCHLD)
			trace = PTRACE_EVENT_CLONE;
		else
			trace = PTRACE_EVENT_FORK;

		if (likely(!ptrace_event_enabled(current, trace)))
			trace = 0;
	}

	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_WALKS_MMU) && !(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);

	/* 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);
	return nr;
}

// kernel config가 일반적이라고 가정하고 나머지 코드는 뺐다.

/*
 * copy_process - clone() 시스템 콜의 핵심 구현 함수 (단순화 버전)
 *
 * 이 함수는 부모 태스크(current)를 기반으로 새로운 자식 태스크(p)를 생성합니다.
 * clone_flags 값에 따라 어떤 자원을 공유하고, 어떤 자원을 복제할지 결정합니다.
 * 성공 시 새로운 task_struct 포인터를, 실패 시 ERR_PTR을 반환합니다.
 */
struct task_struct *copy_process(
			struct pid *pid,
			int trace,
			int node, /* NUMA 노드, 여기서는 무시 */
			struct kernel_clone_args *args)
{
	int pidfd = -1, retval;
	struct task_struct *p;
	const u64 clone_flags = args->flags;

	/*
	 * ===================================================================
	 * 1. clone 플래그 유효성 검사
	 * ===================================================================
	 * clone()으로 전달된 플래그들의 조합이 유효한지 검사합니다.
	 * 예를 들어, 스레드(CLONE_THREAD)는 반드시 시그널 핸들러(CLONE_SIGHAND)를 공유해야 하고,
	 * 시그널 핸들러를 공유하면 반드시 가상 메모리(CLONE_VM)도 공유해야 합니다.
	 */
	if ((clone_flags & (CLONE_NEWNS | CLONE_FS)) == (CLONE_NEWNS | CLONE_FS))
		return ERR_PTR(-EINVAL);

	if ((clone_flags & (CLONE_NEWUSER | CLONE_FS)) == (CLONE_NEWUSER | CLONE_FS))
		return ERR_PTR(-EINVAL);

	if ((clone_flags & CLONE_THREAD) && !(clone_flags & CLONE_SIGHAND))
		return ERR_PTR(-EINVAL);

	if ((clone_flags & CLONE_SIGHAND) && !(clone_flags & CLONE_VM))
		return ERR_PTR(-EINVAL);

	if ((clone_flags & CLONE_PARENT) &&
	    current->signal->flags & SIGNAL_UNKILLABLE)
		return ERR_PTR(-EINVAL);

	if (clone_flags & CLONE_THREAD) {
		if (clone_flags & (CLONE_NEWUSER | CLONE_NEWPID))
			return ERR_PTR(-EINVAL);
	}

	/*
	 * ===================================================================
	 * 2. 태스크 자료구조 복제 및 기본 초기화
	 * ===================================================================
	 */
	retval = -ENOMEM;
	p = dup_task_struct(current, node); // task_struct와 커널 스택을 복제
	if (!p)
		goto fork_out;

	retval = -EAGAIN;
	/* 프로세스 개수 제한(RLIMIT_NPROC)과 전체 스레드 개수 제한을 확인 */
	if (is_rlimit_overlimit(task_ucounts(p), UCOUNT_RLIMIT_NPROC, rlimit(RLIMIT_NPROC))) {
		if (p->real_cred->user != INIT_USER &&
		    !capable(CAP_SYS_RESOURCE) && !capable(CAP_SYS_ADMIN))
			goto bad_fork_free;
	}

	if (data_race(nr_threads >= max_threads))
		goto bad_fork_free;

	p->flags &= ~(PF_SUPERPRIV | PF_WQ_WORKER | PF_IDLE);
	p->flags |= PF_FORKNOEXEC; // exec()가 실행되기 전까지는 fork 상태임을 표시

	/* 자식/형제 리스트 초기화 */
	INIT_LIST_HEAD(&p->children);
	INIT_LIST_HEAD(&p->sibling);

	/*
	 * ===================================================================
	 * 3. 각종 서브시스템별로 자원 복제(copy) 또는 공유(share)
	 * ===================================================================
	 * 여기가 clone()의 동작을 결정하는 가장 중요한 부분입니다.
	 * 각 copy_* 함수는 clone_flags를 보고 자원을 복제할지,
	 * 아니면 부모와 공유(참조 카운트만 증가)할지 결정합니다.
	 */

	/* 사용자 자격증명(UID, GID 등) 복사 */
	retval = copy_creds(p, clone_flags);
	if (retval < 0)
		goto bad_fork_free;

	/* 스케줄러 관련 정보 설정. 이 태스크를 어떤 CPU에 할당할지 결정 */
	retval = sched_fork(clone_flags, p);
	if (retval)
		goto bad_fork_cleanup_creds;

	/*
	 * copy_xxx 함수들의 연속 호출. 하나라도 실패하면 goto로 에러 처리.
	 * 순서는 매우 중요합니다. (의존성 역순으로 정리)
	 */
	retval = copy_files(clone_flags, p, args->no_files); // 파일 디스크립터 테이블 복사/공유
	if (retval)
		goto bad_fork_sched_cancel;

	retval = copy_fs(clone_flags, p); // 파일 시스템 정보(root, pwd) 복사/공유
	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); // 메모리 공간(mm_struct) 복사/공유
	if (retval)
		goto bad_fork_cleanup_signal;

	retval = copy_namespaces(clone_flags, p); // 네임스페이스 복사/공유
	if (retval)
		goto bad_fork_cleanup_mm;

	retval = copy_thread(p, args); // 아키텍처 의존적 정보(레지스터, 스택) 설정
	if (retval)
		goto bad_fork_cleanup_namespaces;

	/*
	 * ===================================================================
	 * 4. PID 할당 및 마무리 작업
	 * ===================================================================
	 */
	if (pid != &init_struct_pid) {
		pid = alloc_pid(p->nsproxy->pid_ns_for_children, args->set_tid,
				  args->set_tid_size);
		if (IS_ERR(pid)) {
			retval = PTR_ERR(pid);
			goto bad_fork_cleanup_thread;
		}
	}

	// CLONE_PIDFD 플래그가 있으면 PID 파일 디스크립터를 생성해서 부모에게 전달
	if (clone_flags & CLONE_PIDFD) {
		retval = pidfd_prepare(pid, 0, &pidfile);
		if (retval < 0)
			goto bad_fork_free_pid;
		pidfd = retval;
	}

	/* ok, now we should be set up.. */
	p->pid = pid_nr(pid);
	if (clone_flags & CLONE_THREAD) {
		/* 스레드인 경우: 부모와 같은 스레드 그룹에 속함 */
		p->group_leader = current->group_leader;
		p->tgid = current->tgid;
	} else {
		/* 프로세스인 경우: 자기 자신이 스레드 그룹의 리더가 됨 */
		p->group_leader = p;
		p->tgid = p->pid;
	}

	p->start_time = ktime_get_ns();
	p->start_boottime = ktime_get_boottime_ns();

	/*
	 * ===================================================================
	 * 5. 새로운 태스크를 시스템에 등록 (tasklist_lock 잠금 하에 원자적으로 수행)
	 * ===================================================================
	 * 이 시점부터 새로운 태스크가 시스템에 보이게 됩니다.
	 */
	write_lock_irq(&tasklist_lock);

	/* 부모-자식 관계 설정 */
	if (clone_flags & (CLONE_PARENT | CLONE_THREAD)) {
		p->real_parent = current->real_parent;
		if (clone_flags & CLONE_THREAD)
			p->exit_signal = -1; // 스레드는 부모에게 종료 시그널을 보내지 않음
		else
			p->exit_signal = current->group_leader->exit_signal;
	} else {
		p->real_parent = current;
		p->exit_signal = args->exit_signal;
	}

	/* PID/TGID/PGID/SID를 태스크에 연결 */
	init_task_pid_links(p);
	if (likely(p->pid)) {
		init_task_pid(p, PIDTYPE_PID, pid);

		if (thread_group_leader(p)) {
			/* 프로세스인 경우 (스레드 그룹 리더) */
			init_task_pid(p, PIDTYPE_TGID, pid);
			init_task_pid(p, PIDTYPE_PGID, task_pgrp(current));
			init_task_pid(p, PIDTYPE_SID, task_session(current));

			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++;
			atomic_inc(&current->signal->live);
			refcount_inc(&current->signal->sigcnt);
			list_add_tail_rcu(&p->thread_node, &p->signal->thread_head);
		}
		attach_pid(p, PIDTYPE_PID);
		nr_threads++;
	}
	total_forks++;

	write_unlock_irq(&tasklist_lock);

	if (pidfd != -1)
		fd_install(pidfd, pidfile);

	/* fork 이후 후처리 작업들 */
	proc_fork_connector(p);
	sched_post_fork(p);
	trace_task_newtask(p, clone_flags);

	return p; /* 성공: 새로운 task_struct 포인터 반환 */

	/*
	 * ===================================================================
	 * 6. 에러 처리 경로 (goto 레이블)
	 * ===================================================================
	 * fork 과정 중 실패하면, 그 시점까지 할당했던 모든 자원을
	 * 역순으로 정리하고 에러를 반환합니다.
	 */
bad_fork_free_pid:
	if (pid != &init_struct_pid)
		free_pid(pid);
bad_fork_cleanup_thread:
	exit_thread(p);
bad_fork_cleanup_namespaces:
	exit_task_namespaces(p);
bad_fork_cleanup_mm:
	if (p->mm) {
		mm_clear_owner(p->mm, p);
		mmput(p->mm);
	}
bad_fork_cleanup_signal:
	if (!(clone_flags & CLONE_THREAD))
		free_signal_struct(p->signal);
bad_fork_cleanup_sighand:
	__cleanup_sighand(p->sighand);
bad_fork_cleanup_fs:
	exit_fs(p);
bad_fork_cleanup_files:
	exit_files(p);
bad_fork_sched_cancel:
	sched_cancel_fork(p);
bad_fork_cleanup_creds:
	exit_creds(p);
bad_fork_free:
	put_task_struct(p);
fork_out:
	return ERR_PTR(retval);
}