版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/THEANARKH/article/details/89048926
进程的地址有三种，分别是虚拟地址（逻辑地址）、线性地址、物理地址。在分析之前先讲一下进程执行的时候，地址的解析过程。在保护模式下，段寄存器保存的是段选择子，当进程被系统选中执行时，会把tss和ldt等信息加载到寄存器中，tss是保存进程上下文的，ldt是保存进程代码和数据段的首地址偏移以及权限等信息的。假设当前执行cs:ip指向的代码，系统根据ldt的值从gdt中选择一个元素，里面保存的是idt结构的首地址。然后根据cs的值选择idt表格中的一项，从而得到代码段的基地址和限长，用基地址加上ip指向的偏移得到一个线性地址，这个线性地址分为三个部分，分别是页目录索引，页表索引，物理地址偏移。然后到页目录吧和页表中找到物理地址基地址，再加线性地址中的偏移部分，得到物理地址。下面我们看看这些内容是怎么设置的，使得执行的时候能正确找到我们想要的地址去执行代码。我们从fork函数开始。到进程被调度执行时所发生的事情。fork函数的具体调用过程之前已经分析过。下面贴一下主要的代码。
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;
// 申请一页存pcb
p = (struct task_struct *) get_free_page();
if (!p)
return -EAGAIN;
// 挂载到全局pcb数组
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;
// 调用fork时压入栈的ip，子进程创建完成会从这开始执行，即if (__res >= 0)
p->tss.eip = eip;
p->tss.eflags = eflags;
// 子进程从fork返回的是0，eax会赋值给__res
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;
// 段选择子是16位
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;
/*
计算第nr进程在GDT中关于LDT的索引，切换任务的时候，
这个索引会被加载到ldt寄存器，cpu会自动根据ldt的值，把
GDT中相应位置的段描述符加载到ldt寄存器(共16+32+16位)
*/
p->tss.ldt = _LDT(nr);
p->tss.trace_bitmap = 0x80000000;
if (last_task_used_math == current)
__asm__("clts ; fnsave %0"::"m" (p->tss.i387));
/*
设置线性地址范围，挂载线性地址首地址和限长到idt，赋值页目录项和页表
执行进程的时候，tss选择子被加载到tss寄存器，然后把tss里的上下文
也加载到对应的寄存器，比如cr3，ldt选择子。tss信息中的idt索引首先从gdt找到进程idt
结构体数据的首地址，然后根据当前段的属性，比如代码段，
则从cs中取得选择子，系统从idt表中取得进程线性空间
的首地址、限长、权限等信息。用线性地址的首地址加上ip
中的偏移，得到线性地址，然后再通过页目录和页表得到物理
地址，物理地址还没有分配则进行缺页异常等处理。
*/
if (copy_mem(nr,p)) {
task[nr] = NULL;
free_page((long) p);
return -EAGAIN;
}
// 父子进程都有同样的文件描述符，file结构体加一
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++;
/*
挂载tss和idt地址到gdt，nr << 1即乘以2，这里算出的是第nr个进程距离第一个tss描述符地址的偏移，
单位是8个字节，即选择描述符大小
*/
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;
}
fork函数收到分配一页的物理内存保存PCB结构，然后把父进程的信息复制过来，再修改某些字段。接着计算一个在全局描述符GDT中的一个索引，这个索引是ldt选择子。后面会讲到。然后计算进程的代码和数据的线性地址首地址和限长，写到ldt的描述符中。接着复制页表，但是不分配物理地址。最后把tss结构和ldt结构挂载到GDT中。fork函数就完成了。下面看看选择子和描述符的格式。
下面选择子的计算
/*
* Entry into gdt where to find first TSS. 0-nul, 1-cs, 2-ds, 3-syscall
* 4-TSS0, 5-LDT0, 6-TSS1 etc ...
*/
#define FIRST_TSS_ENTRY 4
#define FIRST_LDT_ENTRY (FIRST_TSS_ENTRY+1)
// 第一个tss选择子的偏移是4<<3，4乘以8，等于32，即从GDT的偏移为32开始算，第一个进程的n是0，tss是32
#define _TSS(n) ((((unsigned long) n)<<4)+(FIRST_TSS_ENTRY<<3))
// 第一个ldt选择子的偏移是5<<3，5乘以8，等于40，即从GDT的偏移为40开始算，第一个进程的n是0，ldt是40
#define _LDT(n) ((((unsigned long) n)<<4)+(FIRST_LDT_ENTRY<<3))
下面是段描述符的设置。
#define PAGE_ALIGN(n) (((n)+0xfff)&0xfffff000)
/*
段描述符的地3,4,5,7四个字节是保存基地址
把edx的两个字节保存在addr+2，即第3,4位
edx右移16位，把低位给addr的第四个字节
把高位给addr的第七个字节
*/
#define _set_base(addr,base) \
__asm__("movw %%dx,%0\n\t" \
"rorl $16,%%edx\n\t" \
"movb %%dl,%1\n\t" \
"movb %%dh,%2" \
// 四个输入
::"m" (*((addr)+2)), \
"m" (*((addr)+4)), \
"m" (*((addr)+7)), \
"d" (base) \
:"dx")
/*
段描述符的地第1,2字节和16-19位保存段限长
把dx的两个字节给addr的第1,2个字节，edx右移16位
把addr的第六个字节赋值给dh，
把dh的前四个比特清0，再把dh高四位复制到dl高四位，
dl的低四位和高四位组成新的比特顺序，把dl写回addr的第六个字节
*/
#define _set_limit(addr,limit) \
__asm__("movw %%dx,%0\n\t" \
"rorl $16,%%edx\n\t" \
"movb %1,%%dh\n\t" \
"andb $0xf0,%%dh\n\t" \
"orb %%dh,%%dl\n\t" \
"movb %%dl,%1" \
// 三个输入
::"m" (*(addr)), \
"m" (*((addr)+6)), \
"d" (limit) \
:"dx")
#define set_base(ldt,base) _set_base( ((char *)&(ldt)) , base )
#define set_limit(ldt,limit) _set_limit( ((char *)&(ldt)) , (limit-1)>>12 )
// 把三个字节逐个复制到__base
#define _get_base(addr) ({\
unsigned long __base; \
__asm__("movb %3,%%dh\n\t" \
"movb %2,%%dl\n\t" \
// edx=edx左移16位
"shll $16,%%edx\n\t" \
"movw %1,%%dx" \
// edx寄存器的值写到__base
:"=d" (__base) \
// 输入
:"m" (*((addr)+2)), \
"m" (*((addr)+4)), \
"m" (*((addr)+7))); \
__base;})
#define get_base(ldt) _get_base( ((char *)&(ldt)) )
// 加载段限长，把segment对应的段描述符中的段界限字段加载到limit
#define get_limit(segment) ({ \
unsigned long __limit; \
__asm__("lsll %1,%0\n\tincl %0":"=r" (__limit):"r" (segment)); \
__limit;})
设置完后，在进程被系统选中执行时，下面首先看看进程切换的代码。
#define switch_to(n) {\
struct {long a,b;} __tmp; \
// ecx是第n个进程对应的pcb首地址，判断切换的下一个进程是不是就是当前执行的进程，是就不需要切换了
__asm__("cmpl %%ecx,_current\n\t" \
"je 1f\n\t" \
// 把第n个进程的tss选择子复制到__tmp.b
"movw %%dx,%1\n\t" \
// 更新current变量，使current变量执行ecx，ecx指向task[n]
"xchgl %%ecx,_current\n\t" \
// ljmp 跟一个tss选择子实现进程切换
"ljmp %0\n\t" \
// 忽略
"cmpl %%ecx,_last_task_used_math\n\t" \
"jne 1f\n\t" \
"clts\n" \
"1:" \
::"m" (*&__tmp.a),"m" (*&__tmp.b), \
"d" (_TSS(n)),"c" ((long) task[n])); \
}
ljmp tss描述符后，系统会加载第n个进程的tss选择子到ltr（保存tss选择子和首地址偏移信息的寄存器），根据选择子从GDT拿到tss的段选择符，然后找到tss的内容，再把某些内容加载到相应寄存器，比如idt信息。最后根据tss中的cs和ip执行进程。这就是文章开头的过程。这就是linux0.11版本中进程地址管理的实现。下面是fork后的结构图。
