Linux 内核是一个模块化、分层的操作系统内核，它充当硬件和用户空间程序之间的桥梁。其架构旨在提供高效、稳定和可扩展的操作系统。

内核还包含一系列子系统，它们提供特定的功能：

用户空间程序通过系统调用与内核交互。系统调用是内核提供的特殊函数，允许用户空间程序执行受保护的操作，例如访问文件或分配内存。

内核通过中断与硬件设备交互。当硬件设备需要内核的关注时，它会引发中断。内核然后处理中断并采取适当的行动，例如处理网络数据包或更新设备状态。

Linux 内核把进程称为任务(task)，进程的虚拟地址空间分为用户虚拟地址空间和内核虚拟地址空间，所有进程共享内核虚拟地址空间，每个进程有独立的用户虚拟地址空间。

通常在不会引起混淆的情况下把用户线程简称为线程。共享同一个用户虚拟地址空间的所有用户线程组成一个线程组。

C 标准库进程术语和 Linux 内核进程术语对应关系如下：

四、task_struct 数据结构主要成员

struct task_struct {//进程描述符
#ifdef CONFIG_THREAD_INFO_IN_TASK
	/*
	 * For reasons of header soup (see current_thread_info()), this
	 * must be the first element of task_struct.
	 */
	struct thread_info		thread_info;
#endif
	unsigned int			__state;//指向进程状态

#ifdef CONFIG_PREEMPT_RT
	/* saved state for "spinlock sleepers" */
	unsigned int			saved_state;
#endif

	/*
	 * This begins the randomizable portion of task_struct. Only
	 * scheduling-critical items should be added above here.
	 */
	randomized_struct_fields_start

	void				*stack;//指向内核栈
	refcount_t			usage;
	/* Per task flags (PF_*), defined further below: */
	unsigned int			flags;
	unsigned int			ptrace;

       // ...... 
};

还有很多成员，这里就不一一列举。

在 Linux 内核中，新进程是从一个已经存在的进程复制出来的，内核使用静态数据结构造出 0 号内核线程，0 号内核线程分叉生成 1 号内核线程和 2 号内核线程（kthreadd 线程）。1 号内核线程完成初始化以后装载用户程序，变成 1 号进程，其他进程都是 1 号进程或者它的子孙进程分叉生成的；其他内核线程是 kthreadd 线程分叉生成的。

Linux 内核3 个系统调用创建新的进程：

clone 是功能最齐全的函数，参数多、使用复杂，fork 是 clone 的简化函数。

#ifdef __ARCH_WANT_SYS_FORK
SYSCALL_DEFINE0(fork)
{
#ifdef CONFIG_MMU
	struct kernel_clone_args args = {
		.exit_signal = SIGCHLD,
	};

	return _do_fork(&args);
#else
	/* can not support in nommu mode */
	return -EINVAL;
#endif
}
#endif

#ifdef __ARCH_WANT_SYS_VFORK
SYSCALL_DEFINE0(vfork)
{
	struct kernel_clone_args args = {
		.flags		= CLONE_VFORK | CLONE_VM,
		.exit_signal	= SIGCHLD,
	};

	return _do_fork(&args);
}
#endif


#ifdef __ARCH_WANT_SYS_CLONE
#ifdef CONFIG_CLONE_BACKWARDS
SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,
		 int __user *, parent_tidptr,
		 unsigned long, tls,
		 int __user *, child_tidptr)
#elif defined(CONFIG_CLONE_BACKWARDS2)
SYSCALL_DEFINE5(clone, unsigned long, newsp, unsigned long, clone_flags,
		 int __user *, parent_tidptr,
		 int __user *, child_tidptr,
		 unsigned long, tls)
#elif defined(CONFIG_CLONE_BACKWARDS3)
SYSCALL_DEFINE6(clone, unsigned long, clone_flags, unsigned long, newsp,
		int, stack_size,
		int __user *, parent_tidptr,
		int __user *, child_tidptr,
		unsigned long, tls)
#else
SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,
		 int __user *, parent_tidptr,
		 int __user *, child_tidptr,
		 unsigned long, tls)
#endif
{
	struct kernel_clone_args args = {
		.flags		= (lower_32_bits(clone_flags) & ~CSIGNAL),
		.pidfd		= parent_tidptr,
		.child_tid	= child_tidptr,
		.parent_tid	= parent_tidptr,
		.exit_signal	= (lower_32_bits(clone_flags) & CSIGNAL),
		.stack		= newsp,
		.tls		= tls,
	};

	if (!legacy_clone_args_valid(&args))
		return -EINVAL;

	return _do_fork(&args);
}
#endif

Linux 内核定义系统调用的独特方式，目前以系统调用 fork 为例：创建新进程的 3 个系统调用在文件kernel/fork.c中，它们把工作委托给函数_do_fork（从6.0开始，更名为kernel_clone）。具体源码分析如下：

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

// ......

}

Linux 内核函数_do_fork()执行流程如下图所示：

具体核心处理函数为 copy_process()内核源码如下：

/*
 * 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.
 */
static __latent_entropy struct task_struct *copy_process(
					struct pid *pid,
					int trace,
					int node,
					struct kernel_clone_args *args)
{
	int pidfd = -1, retval;
	struct task_struct *p;
	struct multiprocess_signals delayed;
	struct file *pidfile = NULL;
	u64 clone_flags = args->flags;
	struct nsproxy *nsp = current->nsproxy;

// ......

}

函数 copy_process()：创建新进程的主要工作由此函数完成， 具体处理流程如下图所示：

同一个线程组的所有线程必须属于相同的用户命名空间和进程号命名空间。

就绪：state是TASK_RUNING（没有严格区别就绪和运行），正在运行队列中等待调度器调度。

运行：state是TASK_RUNING，证明调度器选中，正在CPU上执行。

僵尸：state是TASK_DEAD，进程退出并且父进程关注子进程退出事件。

写时复制核心思想：只有在不得不复制数据内容时才去复制数据内容；降低资源浪费。

应用程序（进程 1）修改页面 C 之前：

应用程序（进程 1）修改页面 C 之后：

注意：只有可修改的页面才需要标记为写时复制，不能修改的页面可以由父进程和子进程共享。

Linux 进程剖析：深入内核源码，揭开进程运作机制

Linux 内核是操作系统的核心，作为一个模块化、分层的软件层，是硬件和用户空间应用程序的关键桥梁。设计目标是提供一个高效、稳定、可扩展的操作系统环境。

操作系统

后端

Linux内核架构解析：深入剖析进程管理、task_struct数据结构及进程创建机制。详解进程状态迁移、写时复制技术，揭示fork/vfork/clone系统调用实现原理。掌握Linux进程生命周期、调度策略及同步机制，提升操作系统内核理解深度。

设备驱动程序

数据结构

文件系统

内存管理

Linux

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

Linux 进程剖析：深入内核源码，揭开进程运作机制

Linux 进程剖析：深入内核源码，揭开进程运作机制

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐