linux进程创建fork函数详解

linux0.11版本的fork函数源码：

/*
 *  linux/kernel/fork.c
 *
 *  (C) 1991  Linus Torvalds
 */

/*
 *  'fork.c' contains the help-routines for the 'fork' system call
 * (see also system_call.s), and some misc functions ('verify_area').
 * Fork is rather simple, once you get the hang of it, but the memory
 * management can be a bitch. See 'mm/mm.c': 'copy_page_tables()'
 */
#include <errno.h>

#include <linux/sched.h>
#include <linux/kernel.h>
#include <asm/segment.h>
#include <asm/system.h>

extern void write_verify(unsigned long address);

long last_pid=0;

void verify_area(void * addr,int size)
{
	unsigned long start;

	start = (unsigned long) addr;
	size += start & 0xfff;
	start &= 0xfffff000;
	start += get_base(current->ldt[2]);
	while (size>0) {
		size -= 4096;
		write_verify(start);
		start += 4096;
	}
}

int copy_mem(int nr,struct task_struct * p)
{
	unsigned long old_data_base,new_data_base,data_limit;
	unsigned long old_code_base,new_code_base,code_limit;

	code_limit=get_limit(0x0f);
	data_limit=get_limit(0x17);
	old_code_base = get_base(current->ldt[1]);
	old_data_base = get_base(current->ldt[2]);
	if (old_data_base != old_code_base)
		panic("We don't support separate I&D");
	if (data_limit < code_limit)
		panic("Bad data_limit");
	new_data_base = new_code_base = nr * 0x4000000;
	p->start_code = new_code_base;
	set_base(p->ldt[1],new_code_base);
	set_base(p->ldt[2],new_data_base);
	if (copy_page_tables(old_data_base,new_data_base,data_limit)) {
		free_page_tables(new_data_base,data_limit);
		return -ENOMEM;
	}
	return 0;
}

/*
 *  Ok, this is the main fork-routine. It copies the system process
 * information (task[nr]) and sets up the necessary registers. It
 * also copies the data segment in it's entirety.
 */
int copy_process(int nr,long ebp,long edi,long esi,long gs,long none,
		long ebx,long ecx,long edx,
		long fs,long es,long ds,
		long eip,long cs,long eflags,long esp,long ss)
{
	struct task_struct *p;
	int i;
	struct file *f;

	p = (struct task_struct *) get_free_page();
	if (!p)
		return -EAGAIN;
	task[nr] = p;
	*p = *current;	/* NOTE! this doesn't copy the supervisor stack */
	p->state = TASK_UNINTERRUPTIBLE;
	p->pid = last_pid;
	p->father = current->pid;
	p->counter = p->priority;
	p->signal = 0;
	p->alarm = 0;
	p->leader = 0;		/* process leadership doesn't inherit */
	p->utime = p->stime = 0;
	p->cutime = p->cstime = 0;
	p->start_time = jiffies;
	p->tss.back_link = 0;
	p->tss.esp0 = PAGE_SIZE + (long) p;
	p->tss.ss0 = 0x10;
	p->tss.eip = eip;
	p->tss.eflags = eflags;
	p->tss.eax = 0;
	p->tss.ecx = ecx;
	p->tss.edx = edx;
	p->tss.ebx = ebx;
	p->tss.esp = esp;
	p->tss.ebp = ebp;
	p->tss.esi = esi;
	p->tss.edi = edi;
	p->tss.es = es & 0xffff;
	p->tss.cs = cs & 0xffff;
	p->tss.ss = ss & 0xffff;
	p->tss.ds = ds & 0xffff;
	p->tss.fs = fs & 0xffff;
	p->tss.gs = gs & 0xffff;
	p->tss.ldt = _LDT(nr);
	p->tss.trace_bitmap = 0x80000000;
	if (last_task_used_math == current)
		__asm__("clts ; fnsave %0"::"m" (p->tss.i387));
	if (copy_mem(nr,p)) {
		task[nr] = NULL;
		free_page((long) p);
		return -EAGAIN;
	}
	for (i=0; i<NR_OPEN;i++)
		if (f=p->filp[i])
			f->f_count++;
	if (current->pwd)
		current->pwd->i_count++;
	if (current->root)
		current->root->i_count++;
	if (current->executable)
		current->executable->i_count++;
	set_tss_desc(gdt+(nr<<1)+FIRST_TSS_ENTRY,&(p->tss));
	set_ldt_desc(gdt+(nr<<1)+FIRST_LDT_ENTRY,&(p->ldt));
	p->state = TASK_RUNNING;	/* do this last, just in case */
	return last_pid;
}

int find_empty_process(void)
{
	int i;

	repeat:
		if ((++last_pid)<0) last_pid=1;
		for(i=0 ; i<NR_TASKS ; i++)
			if (task[i] && task[i]->pid == last_pid) goto repeat;
	for(i=1 ; i<NR_TASKS ; i++)
		if (!task[i])
			return i;
	return -EAGAIN;
}

这段代码是 Linux 0.11 内核中实现 fork 系统调用。fork 用于创建一个新的进程，它是通过复制当前进程（父进程）的方式来实现的。

verify_area

void verify_area(void * addr,int size)

• verify_area 用于检查给定地址的内存区域是否可以被当前进程访问，并确保这部分内存已经被映射。如果没有映射，会触发缺页中断，从而分配新的页面。

void verify_area(void * addr,int size)
{
    // 定义一个变量来存储调整后的起始地址
    unsigned long start;

    // 将传入的地址转换为无符号长整型
    start = (unsigned long) addr;

    // 调整size以包含从addr到下一个页面边界的全部数据
    size += start & 0xfff; // 0xfff (4096 - 1) 用于获取addr相对于其页面开始的偏移量

    // 将start向下舍入到最近的页面边界
    start &= 0xfffff000; // 0xfffff000 是页面大小的掩码，用于向下舍入

    // 获取当前进程数据段的基址，并加到start上
    // 因为addr是相对于数据段基址的
    start += get_base(current->ldt[2]);

    // 开始循环，直到处理完整个指定的内存区域
    while (size > 0) {
        // 从size中减去一个页面的大小（4096字节）
        size -= 4096;

        // 调用write_verify来验证并触发start指向的页面
        // 如果页面未映射到物理内存，会触发缺页异常，导致页面被分配
        write_verify(start);

        // 将start增加一个页面大小，移至下一个页面
        start += 4096;
    }
}

copy_mem

int copy_mem(int nr,struct task_struct * p)

• copy_mem 函数用于为新进程复制父进程的内存。它设置了新进程的数据和代码段的基址，并复制页表。

int copy_mem(int nr,struct task_struct * p)
{
    // 定义用于存储旧的和新的数据、代码段基址以及它们的限制
    unsigned long old_data_base,new_data_base,data_limit;
    unsigned long old_code_base,new_code_base,code_limit;

    // 获取代码段和数据段的限制
    code_limit = get_limit(0x0f);
    data_limit = get_limit(0x17);

    // 获取当前进程（父进程）的代码段和数据段基址
    old_code_base = get_base(current->ldt[1]);
    old_data_base = get_base(current->ldt[2]);

    // 检查是否支持代码和数据分离（I&D），Linux 0.11不支持
    if (old_data_base != old_code_base)
        panic("We don't support separate I&D");

    // 检查数据限制是否小于代码限制
    if (data_limit < code_limit)
        panic("Bad data_limit");

    // 为新进程计算新的代码和数据段基址
    new_data_base = new_code_base = nr * 0x4000000;

    // 设置新进程的起始代码地址
    p->start_code = new_code_base;

    // 在局部描述符表中设置新进程的代码和数据段基址
    set_base(p->ldt[1],new_code_base);
    set_base(p->ldt[2],new_data_base);

    // 复制页表。如果复制失败，则清理并返回错误
    if (copy_page_tables(old_data_base,new_data_base,data_limit)) {
        free_page_tables(new_data_base,data_limit);
        return -ENOMEM;
    }

    // 成功复制内存，返回0
    return 0;
}

copy_process

int copy_process(int nr,long ebp,long edi,long esi,long gs,long none,
        long ebx,long ecx,long edx,
        long fs,long es,long ds,
        long eip,long cs,long eflags,long esp,long ss)

• copy_process 是创建新进程的主要函数。它执行以下步骤：
  • 分配任务结构：首先，为新进程分配 task_struct 结构，并初始化它。
  • 复制进程状态：将当前进程的状态复制到新进程的 task_struct 中。
  • 设置新进程的状态：包括 PID、信号、定时器、CPU 状态等。
  • 保存 CPU 寄存器状态：这些寄存器的值将被用于新进程的初始状态。
  • 处理浮点状态：如果当前进程使用了浮点单元，保存其状态。
  • 复制内存：调用 copy_mem 以复制父进程的内存空间。
  • 复制文件描述符：增加文件描述符和 inode 引用计数，共享文件描述符。
  • 设置 GDT 条目：为新进程在全局描述符表中设置任务状态段和局部描述符表。
  • 设置进程状态为运行：最后将新进程的状态设置为 TASK_RUNNING。

int copy_process(int nr,long ebp,long edi,long esi,long gs,long none,
		long ebx,long ecx,long edx,
		long fs,long es,long ds,
		long eip,long cs,long eflags,long esp,long ss)
{
    // 分配一个新的任务结构体
    struct task_struct *p;
    int i;
    struct file *f;

    // 从内存中获取一个空闲页面
    p = (struct task_struct *) get_free_page();
    // 如果没有空闲页面，返回错误
    if (!p)
        return -EAGAIN;

    // 在任务数组中存储新任务的指针
    task[nr] = p;
    // 复制当前任务的状态到新任务
    *p = *current;  // 注意：这不会复制监督者栈

    // 初始化新任务的各项参数
    p->state = TASK_UNINTERRUPTIBLE;
    p->pid = last_pid;
    p->father = current->pid;  // 设置父进程ID
    p->counter = p->priority;  // 初始化执行计数器
    p->signal = 0;             // 清除信号
    p->alarm = 0;              // 重置闹钟
    p->leader = 0;             // 进程领导权不继承
    p->utime = p->stime = 0;   // 初始化用户和系统时间
    p->cutime = p->cstime = 0;
    p->start_time = jiffies;   // 设置开始时间

    // 初始化任务状态段（TSS）
    p->tss.back_link = 0;
    p->tss.esp0 = PAGE_SIZE + (long) p;  // 设置内核栈
    p->tss.ss0 = 0x10;
    p->tss.eip = eip;                    // 设置指令指针
    p->tss.eflags = eflags;              // 设置标志寄存器
    p->tss.eax = 0;                      // 初始化寄存器
    p->tss.ecx = ecx;
    p->tss.edx = edx;
    p->tss.ebx = ebx;
    p->tss.esp = esp;                    // 设置栈指针
    p->tss.ebp = ebp;                    // 设置基指针
    p->tss.esi = esi;
    p->tss.edi = edi;
    p->tss.es = es & 0xffff;             // 设置额外段寄存器
    p->tss.cs = cs & 0xffff;             // 设置代码段寄存器
    p->tss.ss = ss & 0xffff;             // 设置栈段寄存器
    p->tss.ds = ds & 0xffff;             // 设置数据段寄存器
    p->tss.fs = fs & 0xffff;             // 设置fs寄存器
    p->tss.gs = gs & 0xffff;             // 设置gs寄存器
    p->tss.ldt = _LDT(nr);
    p->tss.trace_bitmap = 0x80000000;

    // 如果最后使用数学协处理器的任务是当前任务，保存其状态
    if (last_task_used_math == current)
        __asm__("clts ; fnsave %0"::"m" (p->tss.i387));

    // 复制内存页面。如果失败，释放已分配页面并返回错误
    if (copy_mem(nr,p)) {
        task[nr] = NULL;
        free_page((long) p);
        return -EAGAIN;
    }

    // 增加文件描述符的引用计数
    for (i=0; i<NR_OPEN;i++)
        if (f=p->filp[i])
            f->f_count++;

    // 增加inode的引用计数
    if (current->pwd)
        current->pwd->i_count++;
    if (current->root)
        current->root->i_count++;
    if (current->executable)
        current->executable->i_count++;

    // 设置全局描述符表（GDT）中的TSS和LDT描述符
    set_tss_desc(gdt+(nr<<1)+FIRST_TSS_ENTRY,&(p->tss));
    set_ldt_desc(gdt+(nr<<1)+FIRST_LDT_ENTRY,&(p->ldt));

    // 最后，将任务状态设置为运行
    p->state = TASK_RUNNING;
    
    // 返回最后的进程ID
    return last_pid;
}

find_empty_process

int find_empty_process(void)

• find_empty_process 函数用于在进程表中找到一个空闲的槽位来存放新进程的 task_struct。它确保新进程有一个唯一的 PID。

fork 的整体流程

1. 进程请求创建：当一个进程调用 fork 系统调用时，内核开始执行创建新进程的过程。

2. 查找空闲槽位：find_empty_process 函数被调用以在进程表中找到一个空闲位置。

3. 复制进程状态和内存：copy_process 被调用，执行实际的进程复制。它包括复制 CPU 寄存器状态、内存空间、文件描述符等。

4. 返回新进程 PID：新进程被创建后，其 PID 被返回给父进程。

int find_empty_process(void)
{
    int i; // 定义一个循环变量

    repeat: // 标签用于重复寻找空闲进程槽的操作
        // 增加 last_pid，并检查是否溢出，如果溢出则重置为1
        if ((++last_pid) < 0) last_pid = 1;

        // 遍历所有任务，检查是否有任务使用了当前的 last_pid
        for (i = 0; i < NR_TASKS; i++)
            if (task[i] && task[i]->pid == last_pid) goto repeat;
        // 如果发现有任务已经使用了这个 PID，则重新开始寻找

    // 遍历所有任务槽位，寻找一个空闲的槽位
    for (i = 1; i < NR_TASKS; i++)
        if (!task[i]) // 如果找到一个空闲的槽位
            return i; // 返回这个槽位的索引

    // 如果没有找到空闲槽位，返回错误
    return -EAGAIN;
}

这个过程实现了 Unix/Linux 系统中的典型的 fork 行为，即通过复制（包括内存空间和进程状态）创建一个新的进程。由于 Linux 0.11 使用了写时复制（copy-on-write）机制，这个过程在内存管理上是高效的。