fork是linux 下创建进程的方法,更贴切说应该是复制进程。该函数效果为在fork开始把操作系统进程拷贝一个副本。然后各自从fork的代码处接着往后执行。在子进程视角里他的fork返回的值是0,在父进程视角里fork返回的值是子进程的pid。所以在fork后按pid的逻辑判断实现在父进程和子进程执行的逻辑。在父进程的逻辑可以wait子进程结束。
fork作为系统调用会调入kernel的system_call.s
在0.11版本通过call _find_empty_process先找到一个空的进程槽位,然后调用call _copy_process拷贝进程。
是实实在在的拷贝task_struct额
/*
* 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;
*p = *current; /* NOTE! this doesn't copy the supervisor stack */
p->state = TASK_RUNNING;
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__("fnsave %0"::"m" (p->tss.i387));
if (copy_mem(nr,p)) {
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++;
set_tss_desc(gdt+(nr<<1)+FIRST_TSS_ENTRY,&(p->tss));
set_ldt_desc(gdt+(nr<<1)+FIRST_LDT_ENTRY,&(p->ldt));
task[nr] = p; /* do this last, just in case */
return last_pid;
}
那么为啥说fork是linux创建进程的方法,不是明明是拷贝进程吗。需要拷贝的进程变新进程,在fork之后就调用execve加载程序到进程代码段,覆盖拷贝的进程的代码段,这是一条不归路,如果执行成功,那么用新的代码段覆盖进程的代码段,这样就变成一个和父进程不同的进程执行。
测试代码(编译gcc -o forktest forktest.c -l pthread)
#include "unistd.h"
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
//计数器
static int count=0;
//线程增加
void * ThreadAdd(void *arg);
//主函数
int main(int argc, char* argv[])
{
printf("两个进程各给静态变量加1万!\n");
//开启新进程
pid_t pid=fork();
//状态
int status;
//创建进程失败就返回-1
if(pid==-1)
{
printf("创建进程失败!\n");
exit(1);
}
//子进程逻辑,pid为0就是在子进程逻辑
if(pid==0)
{
//增加记数
for(int i=0;i<10000;i++)
{
count++;
}
printf("子进程结果为:%d\n",count);
exit(0);
}
//父进程逻辑
else if (pid>0)
{
//增加记数
for(int i=0;i<10000;i++)
{
count++;
}
wait(&status);
printf("父进程结果为:%d\n",count);
//用线程加,测试原子性
printf("两个线程各给静态变量加1万!\n");
count=0;
pthread_t tid;
if(pthread_create(&tid,NULL,ThreadAdd,NULL))
{
perror("创建失败\n");
return -1;
}
if(pthread_create(&tid,NULL,ThreadAdd,NULL))
{
perror("创建失败\n");
return -1;
}
getchar();
}
return 0;
}
//线程增加
void * ThreadAdd(void *arg)
{
//增加记数
for(int i=0;i<10000;i++)
{
if(i%1000==0)
{
sleep(0.1);
}
count++;
}
printf("线程结束的值:%d\n",count);
}
同时用线程测试原子性。我们常常理解的i++感觉是一个原子操作。其实i++编译成汇编是几条指令。
如下:
mov eax,[i]
inc eax
mov [i],eax
那么在三个指令之间OS发送调度,如果另一个线程也执行i++,如果每个线程都给i加1万次,那么最终结果就可能不是2万。第一个进程执行到inc eax被调度到第二个线程执行。如果第二个线程执行完i++后第一个线程恢复执行mov [i] eax,这时候i就少加了一次。
测试fork.c
测试结果是fork拷贝的两个进程都有自己的count,所以两个给count加1万次之后都是1万,不要看count是静态变量就以为父进程的输出是2万额。fork之后各是各的变量空间了。在主进程开启两个线程给静态变量各加1万次,最后结果一般小于2万,就是因为i++不是原子操作导致的。
在OS底层专门用汇编实现原子操作,x86多cpu借助lock指令保证原子性
#ifdef CONFIG_SMP
#define LOCK "lock ; "
#else
#define LOCK ""
#endif
static __inline__ void atomic_inc(atomic_t *v)
{
__asm__ __volatile__(
LOCK "incl %0"
:"=m" (v->counter)
:"m" (v->counter));
}
ARM架构通过一个跳转循环检测实现原子性
1:
ldrex [result], [v->counter]
add [result], [result], [i]
strex [temp], [result], [v->counter]
teq [temp], #0
bne 1b
互斥和信号量要借助原子性保证信号量的准确性。