父进程fork子进程:

child = fork()

fork经过系统调用。来到了sys_fork。具体过程请參考Linux内核源码情景分析-系统调用

asmlinkage int sys_fork(struct pt_regs regs)
{
return do_fork(SIGCHLD, regs.esp, &regs, 0);
}
int do_fork(unsigned long clone_flags, unsigned long stack_start, //stack_start为用户空间堆栈指针
struct pt_regs *regs, unsigned long stack_size)
{
int retval = -ENOMEM;
struct task_struct *p;
DECLARE_MUTEX_LOCKED(sem); if (clone_flags & CLONE_PID) {
/* This is only allowed from the boot up thread */
if (current->pid)
return -EPERM;
} current->vfork_sem = &sem;//假设clone_flags中CLONE_VFORK位置1,这个信号量用于up(&sem)。使父进程唤醒 p = alloc_task_struct();//为子进程分配两个连续的物理页面,低端用作子进程的task_struct结构,高端则用作其系统空间堆栈
if (!p)
goto fork_out; *p = *current;//父进程的整个task_struct就被拷贝到了子进程的数据结构 retval = -EAGAIN;
if (atomic_read(&p->user->processes) >= p->rlim[RLIMIT_NPROC].rlim_cur)
goto bad_fork_free;
atomic_inc(&p->user->__count);
atomic_inc(&p->user->processes); /*
* Counter increases are protected by
* the kernel lock so nr_threads can't
* increase under us (but it may decrease).
*/
if (nr_threads >= max_threads)
goto bad_fork_cleanup_count; get_exec_domain(p->exec_domain); if (p->binfmt && p->binfmt->module)
__MOD_INC_USE_COUNT(p->binfmt->module); p->did_exec = 0;
p->swappable = 0;
p->state = TASK_UNINTERRUPTIBLE;//不可中断等待状态 copy_flags(clone_flags, p);//将參数clone_flags中的标志位略加补充和变换,然后写入p->flags
p->pid = get_pid(clone_flags);//获取进程pid p->run_list.next = NULL;
p->run_list.prev = NULL; if ((clone_flags & CLONE_VFORK) || !(clone_flags & CLONE_PARENT)) {
p->p_opptr = current;
if (!(p->ptrace & PT_PTRACED))
p->p_pptr = current;
}
p->p_cptr = NULL;
init_waitqueue_head(&p->wait_chldexit);
p->vfork_sem = NULL;
spin_lock_init(&p->alloc_lock); p->sigpending = 0;
init_sigpending(&p->pending); p->it_real_value = p->it_virt_value = p->it_prof_value = 0;
p->it_real_incr = p->it_virt_incr = p->it_prof_incr = 0;
init_timer(&p->real_timer);
p->real_timer.data = (unsigned long) p; p->leader = 0; /* session leadership doesn't inherit */
p->tty_old_pgrp = 0;
p->times.tms_utime = p->times.tms_stime = 0;
p->times.tms_cutime = p->times.tms_cstime = 0;
#ifdef CONFIG_SMP
{
int i;
p->has_cpu = 0;
p->processor = current->processor;
/* ?? should we just memset this ?? */
for(i = 0; i < smp_num_cpus; i++)
p->per_cpu_utime[i] = p->per_cpu_stime[i] = 0;
spin_lock_init(&p->sigmask_lock);
}
#endif
p->lock_depth = -1; /* -1 = no lock */
p->start_time = jiffies; retval = -ENOMEM;
/* copy all the process information */
if (copy_files(clone_flags, p))//有条件地复制已打开文件的控制结构files_struct,这样的复制仅仅有在clone_flags中CLONE_FILES标志位为0时才真正进行。否则就仅仅是共享父进程的指针
goto bad_fork_cleanup;
if (copy_fs(clone_flags, p))//有条件地拷贝文件系统相关结构files_structfs_struct,这样的复制仅仅有在clone_flags中CLONE_FS标志位为0时才真正进行。否则就仅仅是共享父进程的指针
goto bad_fork_cleanup_files;
if (copy_sighand(clone_flags, p))//有条件地复制信号处理相关结构signal_struct。这样的复制仅仅有在clone_flags中CLONE_SIGHAND标志位为0时才真正进行。否则就仅仅是共享父进程的指针
goto bad_fork_cleanup_fs;
if (copy_mm(clone_flags, p))//有条件地复制内存管理相关结构mm_struct及其下属的vm_area_struct,这样的复制仅仅有在clone_flags中CLONE_VM标志位为0时才真正进行。否则就仅仅是共享父进程的指针
goto bad_fork_cleanup_sighand;
retval = copy_thread(0, clone_flags, stack_start, stack_size, p, regs);//实际上却仅仅是复制父进程的系统空间堆栈
if (retval)
goto bad_fork_cleanup_sighand;
p->semundo = NULL; /* Our parent execution domain becomes current domain
These must match for thread signalling to apply */ p->parent_exec_id = p->self_exec_id; /* ok, now we should be set up.. */
p->swappable = 1;
p->exit_signal = clone_flags & CSIGNAL;//本进程运行exit()时应向父进程发出的信号,CSIGNAL
p->pdeath_signal = 0; /*
* "share" dynamic priority between parent and child, thus the
* total amount of dynamic priorities in the system doesnt change,
* more scheduling fairness. This is only important in the first
* timeslice, on the long run the scheduling behaviour is unchanged.
*/
p->counter = (current->counter + 1) >> 1;
current->counter >>= 1;//task_struct结构中counter字段的值就是进程的运行时间配额,这里将父进程的时间配额分成两半,让父、子进程各有原值的一半。
if (!current->counter)
current->need_resched = 1; /*
* Ok, add it to the run-queues and make it
* visible to the rest of the system.
*
* Let it rip!
*/
retval = p->pid;
p->tgid = retval;
INIT_LIST_HEAD(&p->thread_group);
write_lock_irq(&tasklist_lock);
if (clone_flags & CLONE_THREAD) {
p->tgid = current->tgid;
list_add(&p->thread_group, ¤t->thread_group);
}
SET_LINKS(p);//将子进程的task_struct结构链入内核的进程队列
hash_pid(p);//将其链入按其pid计算得的杂凑队列
nr_threads++;//进程数加1
write_unlock_irq(&tasklist_lock); if (p->ptrace & PT_PTRACED)
send_sig(SIGSTOP, p, 1); wake_up_process(p); //将子进程"唤醒",也就是将其挂入可运行进程队列等待调用
++total_forks; fork_out:
if ((clone_flags & CLONE_VFORK) && (retval > 0))//假设clone_flags中CLONE_VFORK位置1
down(&sem);//让父进程在一个信号量上运行一次down()操作。以达到扣留父进程的目的
return retval;//返回p->pid,也就是子进程的pid bad_fork_cleanup_sighand:
exit_sighand(p);
bad_fork_cleanup_fs:
exit_fs(p); /* blocking */
bad_fork_cleanup_files:
exit_files(p); /* blocking */
bad_fork_cleanup:
put_exec_domain(p->exec_domain);
if (p->binfmt && p->binfmt->module)
__MOD_DEC_USE_COUNT(p->binfmt->module);
bad_fork_cleanup_count:
atomic_dec(&p->user->processes);
free_uid(p->user);
bad_fork_free:
free_task_struct(p);
goto fork_out;
}

当中regs对父进程系统堆栈的指针,stack_start为用户空间堆栈指针。

alloc_task_struct为子进程分配两个连续的物理页面,低端用作子进程的task_struct结构,高端则用作其系统空间堆栈,代码例如以下:

#define alloc_task_struct() ((struct task_struct *) __get_free_pages(GFP_KERNEL,1)

copy_flags,将參数clone_flags中的标志位略加补充和变换,然后写入p->flags。

static inline void copy_flags(unsigned long clone_flags, struct task_struct *p)
{
unsigned long new_flags = p->flags; new_flags &= ~(PF_SUPERPRIV | PF_USEDFPU | PF_VFORK);
new_flags |= PF_FORKNOEXEC;
if (!(clone_flags & CLONE_PTRACE))
p->ptrace = 0;
if (clone_flags & CLONE_VFORK)
new_flags |= PF_VFORK;
p->flags = new_flags;
}

对于fork来说,clone_flags为SIGCHLD,copy_files,copy_fs,copy_sighand,copy_mm都是要真正复制。

copy_files。代码例如以下:

static int copy_files(unsigned long clone_flags, struct task_struct * tsk)
{
struct files_struct *oldf, *newf;
struct file **old_fds, **new_fds;
int open_files, nfds, size, i, error = 0; /*
* A background process may not have any files ...
*/
oldf = current->files;
if (!oldf)
goto out; if (clone_flags & CLONE_FILES) {//clone_flags中CLONE_FILES标志位为1
atomic_inc(&oldf->count);//仅仅是添加计数
goto out;
} tsk->files = NULL;
error = -ENOMEM;
newf = kmem_cache_alloc(files_cachep, SLAB_KERNEL);
if (!newf)
goto out; atomic_set(&newf->count, 1); newf->file_lock = RW_LOCK_UNLOCKED;
newf->next_fd = 0;
newf->max_fds = NR_OPEN_DEFAULT;
newf->max_fdset = __FD_SETSIZE;
newf->close_on_exec = &newf->close_on_exec_init;
newf->open_fds = &newf->open_fds_init;
newf->fd = &newf->fd_array[0]; /* We don't yet have the oldf readlock, but even if the old
fdset gets grown now, we'll only copy up to "size" fds */
size = oldf->max_fdset;
if (size > __FD_SETSIZE) {
newf->max_fdset = 0;
write_lock(&newf->file_lock);
error = expand_fdset(newf, size);
write_unlock(&newf->file_lock);
if (error)
goto out_release;
}
read_lock(&oldf->file_lock); open_files = count_open_files(oldf, size); /*
* Check whether we need to allocate a larger fd array.
* Note: we're not a clone task, so the open count won't
* change.
*/
nfds = NR_OPEN_DEFAULT;
if (open_files > nfds) {
read_unlock(&oldf->file_lock);
newf->max_fds = 0;
write_lock(&newf->file_lock);
error = expand_fd_array(newf, open_files);
write_unlock(&newf->file_lock);
if (error)
goto out_release;
nfds = newf->max_fds;
read_lock(&oldf->file_lock);
} old_fds = oldf->fd;
new_fds = newf->fd; memcpy(newf->open_fds->fds_bits, oldf->open_fds->fds_bits, open_files/8);
memcpy(newf->close_on_exec->fds_bits, oldf->close_on_exec->fds_bits, open_files/8); for (i = open_files; i != 0; i--) {
struct file *f = *old_fds++;
if (f)
get_file(f);
*new_fds++ = f;
}
read_unlock(&oldf->file_lock); /* compute the remainder to be cleared */
size = (newf->max_fds - open_files) * sizeof(struct file *); /* This is long word aligned thus could use a optimized version */
memset(new_fds, 0, size); if (newf->max_fdset > open_files) {
int left = (newf->max_fdset-open_files)/8;
int start = open_files / (8 * sizeof(unsigned long)); memset(&newf->open_fds->fds_bits[start], 0, left);
memset(&newf->close_on_exec->fds_bits[start], 0, left);
} tsk->files = newf;
error = 0;
out:
return error; out_release:
free_fdset (newf->close_on_exec, newf->max_fdset);
free_fdset (newf->open_fds, newf->max_fdset);
kmem_cache_free(files_cachep, newf);
goto out;
}

待我们学习了文件系统后再细致分析。

copy_fs。代码例如以下:

static inline int copy_fs(unsigned long clone_flags, struct task_struct * tsk)
{
if (clone_flags & CLONE_FS) {//clone_flags中CLONE_FS标志位为1
atomic_inc(current->fs->count);//仅仅是添加计数
return 0;
}
tsk->fs = __copy_fs_struct(current->fs);
if (!tsk->fs)
return -1;
return 0;
}
static inline struct fs_struct *__copy_fs_struct(struct fs_struct *old)
{
struct fs_struct *fs = kmem_cache_alloc(fs_cachep, GFP_KERNEL);
/* We don't need to lock fs - think why ;-) */
if (fs) {
atomic_set(&fs->count, 1);
fs->lock = RW_LOCK_UNLOCKED;
fs->umask = old->umask;
read_lock(&old->lock);
fs->rootmnt = mntget(old->rootmnt);
fs->root = dget(old->root);
fs->pwdmnt = mntget(old->pwdmnt);
fs->pwd = dget(old->pwd);
if (old->altroot) {
fs->altrootmnt = mntget(old->altrootmnt);
fs->altroot = dget(old->altroot);
} else {
fs->altrootmnt = NULL;
fs->altroot = NULL;
}
read_unlock(&old->lock);
}
return fs;
}

我们看到,在这里要复制的是fs_struct数据结构,而不复制更深层的数据结构。对于更深层的数据结构通过mntget()和dget()递增响应数据结构中共享计数。

copy_sighand。代码例如以下:

static inline int copy_sighand(unsigned long clone_flags, struct task_struct * tsk)
{
struct signal_struct *sig; if (clone_flags & CLONE_SIGHAND) {//假设clone_flags中CLONE_SIGHAND标志位为1
atomic_inc(current->sig->count);//添加计数
return 0;
}
sig = kmem_cache_alloc(sigact_cachep, GFP_KERNEL);
tsk->sig = sig;
if (!sig)
return -1;
spin_lock_init(&sig->siglock);
atomic_set(&sig->count, 1);
memcpy(tsk->sig->action, current->sig->action, sizeof(tsk->sig->action));
return 0;
}
struct signal_struct {
atomic_t count;
struct k_sigaction action[_NSIG];
spinlock_t siglock;
};

copy_mm,代码例如以下:

static int copy_mm(unsigned long clone_flags, struct task_struct * tsk)
{
struct mm_struct * mm, *oldmm;
int retval; tsk->min_flt = tsk->maj_flt = 0;
tsk->cmin_flt = tsk->cmaj_flt = 0;
tsk->nswap = tsk->cnswap = 0; tsk->mm = NULL;
tsk->active_mm = NULL; /*
* Are we cloning a kernel thread?
*
* We need to steal a active VM for that..
*/
oldmm = current->mm;
if (!oldmm)//假设是内核线程,那么oldmm为null,直接返回
return 0; if (clone_flags & CLONE_VM) {//假设clone_flags中CLONE_VM标志位为1
atomic_inc(&oldmm->mm_users);//添加mm_users计数
mm = oldmm;
goto good_mm;
} retval = -ENOMEM;//clone_flags中CLONE_VM标志位为0
mm = allocate_mm();//分配mm_struct
if (!mm)
goto fail_nomem; /* Copy the current MM stuff.. */
memcpy(mm, oldmm, sizeof(*mm));
if (!mm_init(mm))//初始化mm_struct
goto fail_nomem; down(&oldmm->mmap_sem);
retval = dup_mmap(mm);//vm_area_struct数据结构和页面映射表的复制
up(&oldmm->mmap_sem); /*
* Add it to the mmlist after the parent.
*
* Doing it this way means that we can order
* the list, and fork() won't mess up the
* ordering significantly.
*/
spin_lock(&mmlist_lock);
list_add(&mm->mmlist, &oldmm->mmlist);
spin_unlock(&mmlist_lock); if (retval)
goto free_pt; /*
* child gets a private LDT (if there was an LDT in the parent)
*/
copy_segments(tsk, mm);//对ldt来说。我们不关心 if (init_new_context(tsk,mm))//空语句
goto free_pt; good_mm:
tsk->mm = mm;
tsk->active_mm = mm;
return 0; free_pt:
mmput(mm);
fail_nomem:
return retval;
}

显然,对mm_struct的复制也仅仅是在clone_flags中CLONE_VM标志位为0时才真正进行,否则就仅仅是通过已经复制的指针共享父进程的用户空间。

对mm_struct的复制就不仅仅是局限于这个数据结构本身了,也包含了对更深层数据结构的复制。

当中最重要的是vm_area_struct数据结构和页面映射表的复制,这是由dup_mmap()复制的。

allocate_mm,分配mm_struct。代码例如以下:

#define allocate_mm()	(kmem_cache_alloc(mm_cachep, SLAB_KERNEL))

mm_init。初始化mm_struct。代码例如以下:

static struct mm_struct * mm_init(struct mm_struct * mm)
{
atomic_set(&mm->mm_users, 1);
atomic_set(&mm->mm_count, 1);
init_MUTEX(&mm->mmap_sem);
mm->page_table_lock = SPIN_LOCK_UNLOCKED;
mm->pgd = pgd_alloc();//指向新分配的页文件夹表
if (mm->pgd)
return mm;
free_mm(mm);
return NULL;
}

dup_mmap是vm_area_struct数据结构和页面映射表的复制。代码例如以下:

static inline int dup_mmap(struct mm_struct * mm)
{
struct vm_area_struct * mpnt, *tmp, **pprev;
int retval; flush_cache_mm(current->mm);
mm->locked_vm = 0;
mm->mmap = NULL;
mm->mmap_avl = NULL;
mm->mmap_cache = NULL;
mm->map_count = 0;
mm->cpu_vm_mask = 0;
mm->swap_cnt = 0;
mm->swap_address = 0;
pprev = &mm->mmap;
for (mpnt = current->mm->mmap ; mpnt ; mpnt = mpnt->vm_next) {//对于父进程的全部虚拟空间进行轮询
struct file *file; retval = -ENOMEM;
if(mpnt->vm_flags & VM_DONTCOPY)
continue;
tmp = kmem_cache_alloc(vm_area_cachep, SLAB_KERNEL);//分配子进程的vm_struct
if (!tmp)
goto fail_nomem;
*tmp = *mpnt;//父进程的vm_struct复制给子进程vm_struct
tmp->vm_flags &= ~VM_LOCKED;
tmp->vm_mm = mm;
mm->map_count++;//虚拟空间数加1
tmp->vm_next = NULL;
file = tmp->vm_file;
if (file) {//假设为null
struct inode *inode = file->f_dentry->d_inode;
get_file(file);
if (tmp->vm_flags & VM_DENYWRITE)
atomic_dec(&inode->i_writecount); /* insert tmp into the share list, just after mpnt */
spin_lock(&inode->i_mapping->i_shared_lock);
if((tmp->vm_next_share = mpnt->vm_next_share) != NULL)
mpnt->vm_next_share->vm_pprev_share =
&tmp->vm_next_share;
mpnt->vm_next_share = tmp;
tmp->vm_pprev_share = &mpnt->vm_next_share;
spin_unlock(&inode->i_mapping->i_shared_lock);
} /* Copy the pages, but defer checking for errors */
retval = copy_page_range(mm, current->mm, tmp);//复制虚拟空间对应的页文件夹表项和页表项
if (!retval && tmp->vm_ops && tmp->vm_ops->open)
tmp->vm_ops->open(tmp); /*
* Link in the new vma even if an error occurred,
* so that exit_mmap() can clean up the mess.
*/
*pprev = tmp;//下一个虚拟空间
pprev = &tmp->vm_next; if (retval)
goto fail_nomem;
}
retval = 0;
if (mm->map_count >= AVL_MIN_MAP_COUNT)//当虚拟空间数大于AVL_MIN_MAP_COUNT
build_mmap_avl(mm);//形成avl树,方便查找 fail_nomem:
flush_tlb_mm(current->mm);
return retval;
}

copy_page_range。代码例如以下:

int copy_page_range(struct mm_struct *dst, struct mm_struct *src,
struct vm_area_struct *vma)
{
pgd_t * src_pgd, * dst_pgd;
unsigned long address = vma->vm_start;
unsigned long end = vma->vm_end;
unsigned long cow = (vma->vm_flags & (VM_SHARED | VM_MAYWRITE)) == VM_MAYWRITE;//可写,而又不是共享 src_pgd = pgd_offset(src, address)-1;
dst_pgd = pgd_offset(dst, address)-1; for (;;) {
pmd_t * src_pmd, * dst_pmd; src_pgd++; dst_pgd++; /* copy_pmd_range */ if (pgd_none(*src_pgd))
goto skip_copy_pmd_range;
if (pgd_bad(*src_pgd)) {
pgd_ERROR(*src_pgd);
pgd_clear(src_pgd);
skip_copy_pmd_range: address = (address + PGDIR_SIZE) & PGDIR_MASK;
if (!address || (address >= end))
goto out;
continue;
}
if (pgd_none(*dst_pgd)) {
if (!pmd_alloc(dst_pgd, 0))
goto nomem;
} src_pmd = pmd_offset(src_pgd, address);
dst_pmd = pmd_offset(dst_pgd, address); do {
pte_t * src_pte, * dst_pte; /* copy_pte_range */ if (pmd_none(*src_pmd))
goto skip_copy_pte_range;
if (pmd_bad(*src_pmd)) {
pmd_ERROR(*src_pmd);
pmd_clear(src_pmd);
skip_copy_pte_range: address = (address + PMD_SIZE) & PMD_MASK;
if (address >= end)
goto out;
goto cont_copy_pmd_range;
}
if (pmd_none(*dst_pmd)) {
if (!pte_alloc(dst_pmd, 0))
goto nomem;
} src_pte = pte_offset(src_pmd, address);
dst_pte = pte_offset(dst_pmd, address); do {
pte_t pte = *src_pte;
struct page *ptepage; /* copy_one_pte */ if (pte_none(pte)) //第一种情况
goto cont_copy_pte_range_noset;
if (!pte_present(pte)) { //另外一种情况
swap_duplicate(pte_to_swp_entry(pte));
goto cont_copy_pte_range;
}
ptepage = pte_page(pte);//得到页表项所指的页面
if ((!VALID_PAGE(ptepage)) || //第三种情况
PageReserved(ptepage))
goto cont_copy_pte_range; /* If it's a COW mapping, write protect it both in the parent and the child */
if (cow) {//第四种情况
ptep_set_wrprotect(src_pte);//改成仅仅读
pte = *src_pte;
} /* If it's a shared mapping, mark it clean in the child */
if (vma->vm_flags & VM_SHARED)
pte = pte_mkclean(pte);
pte = pte_mkold(pte);
get_page(ptepage);//添加页面使用计数
//cow为0时,仅仅读页面。第五种情况
cont_copy_pte_range: set_pte(dst_pte, pte);//将此表项拷贝到子进程的页表项
cont_copy_pte_range_noset: address += PAGE_SIZE;
if (address >= end)
goto out;
src_pte++;
dst_pte++;
} while ((unsigned long)src_pte & PTE_TABLE_MASK); cont_copy_pmd_range: src_pmd++;
dst_pmd++;
} while ((unsigned long)src_pmd & PMD_TABLE_MASK);
}
out:
return 0; nomem:
return -ENOMEM;
}

开头是对页文件夹表项的循环,中间是对中间文件夹项的循环。最后是对页表项的循环,我们把注意力放在最后一层循环。也就是对页表项的循环。

循环中检查父进程一个页表中的每个表项,依据表项的内容决定具体的操作。

而表项的内容,则无非是以下这么一些可能:

1、表项的内容为全0。所以pte_none()返回1。说明该页面的映射尚未建立,或者说是个“空洞”,因此不须要做不论什么事。

2、表项的最低位,即_PAGE_PRESENT标志位为0,所以pte_present返回1。

说明映射已建立,可是该页面眼下不在内存中,已经被调出到交换设备上。此时表项的内容指向"盘面页面"的地点,而如今该盘上页面多了一个"用户"。所以要通过swap_duplicate()递增它的共享计数。就转到cont_copy_pte_range将此表项拷贝到子进程的页表项。

3、映射已建立。可是物理页面不是一个有效的内存页面。所以VALID_PAGE()返回0。

读者能够回想一下。我们曾经讲过有些物理页面在外设接口卡上,对应的地址为“总线地址”。而并非内存页面。

这样的页面,就转到cont_copy_pte_range将此表项拷贝到子进程的页表项。

4、须要从父进程复制的可写页面。

本来,此时应该分配一个空暇的内存页面。再从父进程的页面把内容复制过来,并为之建立映射。

显然,这个代价是不小的。然后,对这么辛辛苦苦复制下来的页面,子进程是否一定会用呢?特别是会有写訪问么?假设仅仅是读訪问。则仅仅要父进程从此不再写这个页面。就全然能够通过复制指针来共享这个页面,那不知要省事多少了。所以,Linux内核採用了一种称为"copy on write"的技术,先通过复制页表项临时共享这个页面。到子进程真的要写着个页面时再次分配页面和复制。

变量cow是"copy on write"的缩写。可写。而又不是共享。

实际上。对于绝大多数的可写虚拟区间,cow都是1。在通过复制页表项临时共享一个页表项时要做两件重要的事情,首先将父进程的页表项改成写保护(仅仅读)。然后把已经改成写保护的表项设置到子进程的页表项。

这样一来,响应的页面在两个进程中都变成"仅仅读"了。当无论是父进程或是子进程企图写入该页面时,都会引起一次页面异常。而页面异常处理程序对此的反应则是另行分配一个物理页面。并把内容真正地拷贝到新的物理页面中,让父、子进程各自拥有自己的物理页面,然后将两个页表项中对应的表项改成可写。可是copy_on_write仅仅有在父、子进程各自拥有自己的页表时才干实现。当CLONE_VM标志位为1时。由于父、子进程通过指针共享用户空间,copy_on_write就用不上了。

此时,父、子进程是在真正的意义上共享用户空间。父进程写入其用户空间的内容同一时候也“写入”子进程的用户空间。

5、父进程的仅仅读页面。这样的页面本来就不须要复制。因而能够复制页表项共享物理页面。

返回到do_fork。继续运行copy_thread。代码例如以下:

int copy_thread(int nr, unsigned long clone_flags, unsigned long esp,
unsigned long unused,
struct task_struct * p, struct pt_regs * regs)
{
struct pt_regs * childregs; childregs = ((struct pt_regs *) (THREAD_SIZE + (unsigned long) p)) - 1;//指向了子进程系统空间堆栈中的pt_regs结构
struct_cpy(childregs, regs);//把当前进程系统空间堆栈中的pt_regs结构复制过去
childregs->eax = 0;//子进程系统空间堆栈中的pt_regs结构eax置成0
childregs->esp = esp;//子进程系统空间堆栈中的pt_regs结构esp置成这里的參数esp,在fork中,则来自调用do_fork()前夕的regs.esp,所以实际上并没有改变 p->thread.esp = (unsigned long) childregs;//子进程系统空间堆栈中pt_regs结构的起始地址
p->thread.esp0 = (unsigned long) (childregs+1);//指向子进程的系统空间堆栈的顶端 p->thread.eip = (unsigned long) ret_from_fork; savesegment(fs,p->thread.fs);
savesegment(gs,p->thread.gs); unlazy_fpu(current);
struct_cpy(&p->thread.i387, ¤t->thread.i387); return 0;
}

最后形成例如以下图:

aaarticlea/png;base64,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" alt="" />

二、clone和vfork

clone的用户态接口是:int clone(int (*fn)(void *arg), void *child_stack, int flags, void *arg)。

    我们看下这clone、fork、vfork几个系统调用的差别:
asmlinkage int sys_fork(struct pt_regs regs)
{
return do_fork(SIGCHLD, regs.esp, &regs, 0);
} asmlinkage int sys_clone(struct pt_regs regs)
{
unsigned long clone_flags;
unsigned long newsp; clone_flags = regs.ebx;//就是用户态的flags
newsp = regs.ecx;//就是用户态的child_stack
if (!newsp)
newsp = regs.esp;
return do_fork(clone_flags, newsp, &regs, 0);
} /*
* This is trivial, and on the face of it looks like it
* could equally well be done in user mode.
*
* Not so, for quite unobvious reasons - register pressure.
* In user mode vfork() cannot have a stack frame, and if
* done by calling the "clone()" system call directly, you
* do not have enough call-clobbered registers to hold all
* the information you need.
*/
asmlinkage int sys_vfork(struct pt_regs regs)
{
return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs.esp, &regs, 0);//主要差别是有两个标志位CLONE_VFORK,CLONE_VM
}

假设全然没实用户空间,就称为"内核线程";而假设共享用户空间则就是为”用户线程“。

    那么vfork出来的是用户线程,共享用户空间。copy_mm中代码例如以下:
	if (clone_flags & CLONE_VM) {//假设clone_flags中CLONE_VM标志位为1
atomic_inc(&oldmm->mm_users);//添加mm_users计数
mm = oldmm;
goto good_mm;
}
    vfork和fork另一个差别就是CLONE_VFORK标志位,体如今代码中,do_fork的最后:
fork_out:
if ((clone_flags & CLONE_VFORK) && (retval > 0))//假设clone_flags中CLONE_VFORK位置1
down(&sem);//让父进程在一个信号量上运行一次down()操作,以达到扣留父进程的目的
return retval;

当调用do_fork的參数中CLONE_VFORK标志位为1时,一定要保证让子进程先运行。一直到子进程通过系统调用execve运行一个新的可运行程序或者通过系统调用exit()退出系统时,才干够恢复父进程的运行。为什么呢?在创建子进程时,假设CLONE_VM为1,仅仅是简单地复制父进程的task_struct结构中指向其mm_struct结构的指针来共享。

此时。父、子进程是在真正的意义上共享用户空间,父进程写入其用户空间的内容同一时候也“写入”子进程的用户空间。绝不能让两个进程都回到用户空间并发地运行;否则,必定是两个进程终于都乱来一气后者因非法越界訪问而死亡。解决的办法仅仅能是”扣留“当中一个进程,而仅仅让一个进程回到用户空间,直到两个进程不再共享它们的用户空间后者当中一个进程消亡为至。

所以才有了上面的操作。让父进程在一个信号量上运行一次down()操作,以达到扣留父进程的目的。

那么谁来运行up操作呢?
子进程在通过execve运行一个新的可运行程序时会做这件事,此外,子进程在通过exit()退出系统时也会做这件事。

代码例如以下:

void mm_release(void)
{
struct task_struct *tsk = current; /* notify parent sleeping on vfork() */
if (tsk->flags & PF_VFORK) {
tsk->flags &= ~PF_VFORK;
up(tsk->p_opptr->vfork_sem);
}
}

三、内核线程

int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
{
long retval, d0; __asm__ __volatile__(
"movl %%esp,%%esi\n\t" //系统调用前的堆栈指针赋值给esi
"int $0x80\n\t"
"cmpl %%esp,%%esi\n\t" //系统调用后的堆栈指针和系统调用前的堆栈指针相比,假设不同就是子进程,假设同样就是父进程
"je 1f\n\t" //跳到父进程 "movl %4,%%eax\n\t"//把參数arg压入堆栈,作为參数
"pushl %%eax\n\t"
"call *%5\n\t" //call fn
"movl %3,%0\n\t" //eax为_NR_exit
"int $0x80\n" //运行exit系统调用
"1:\t"
:"=&a" (retval), "=&S" (d0)
:"0" (__NR_clone), "i" (__NR_exit),//eax为_NR_clone
"r" (arg), "r" (fn),
"b" (flags | CLONE_VM)//ebx为flags | CLONE_VM
: "memory");
return retval;
}
刚開始eax为_NR_clone。ebx为flags | CLONE_VM,然后调用int 0x80系统调用。那么就进入了sys_clone,代码例如以下:
asmlinkage int sys_clone(struct pt_regs regs)
{
unsigned long clone_flags;
unsigned long newsp; clone_flags = regs.ebx;//就是用户态的flags | CLONE_VM
newsp = regs.ecx;//newsp为null
if (!newsp)
newsp = regs.esp;
return do_fork(clone_flags, newsp, &regs, 0);
}

那么kernel_thread出来的是内核线程,mm指针为null,copy_mm中代码例如以下:

	oldmm = current->mm;
if (!oldmm)//假设是内核线程,那么oldmm为null,直接返回
return 0;

最后附上,全部标志位的作用:

#define CSIGNAL		0x000000ff	/* signal mask to be sent at exit */
#define CLONE_VM 0x00000100 /* set if VM shared between processes */
#define CLONE_FS 0x00000200 /* set if fs info shared between processes */
#define CLONE_FILES 0x00000400 /* set if open files shared between processes */
#define CLONE_SIGHAND 0x00000800 /* set if signal handlers and blocked signals shared */
#define CLONE_PID 0x00001000 /* set if pid shared */
#define CLONE_PTRACE 0x00002000 /* set if we want to let tracing continue on the child too */
#define CLONE_VFORK 0x00004000 /* set if the parent wants the child to wake it up on mm_release */
#define CLONE_PARENT 0x00008000 /* set if we want to have the same parent as the cloner */
#define CLONE_THREAD 0x00010000 /* Same thread group? */ #define CLONE_SIGNAL (CLONE_SIGHAND | CLONE_THREAD)

版权声明:本文博客原创文章,博客,未经同意,不得转载。

最新文章

  1. Apache Solr查询语法(转)
  2. UVA 10025 (13.08.06)
  3. android 换肤模式总结
  4. &lt;转载&gt;模板声明中template &lt;typename T&gt;和template &lt;class T&gt;
  5. pb传输优化浅谈
  6. js设置元素class方法小结及classList相关
  7. Django 模版语法
  8. centos/linux 禁止root用户远程登录
  9. 论文笔记:SiamRPN++: Evolution of Siamese Visual Tracking with Very Deep Networks
  10. log4j 知识点
  11. BZOJ.3944.Sum(Min_25筛)
  12. SpringBoot------自动装配Mapper报错
  13. ros新建的包找不到
  14. d 属性: 赋予字段执行动作的能力
  15. How to import a GitHub project into Eclipse
  16. ScrollReveal.js 用于创建和管理元素进入可视区域时的动画效果,帮助你的网站增加吸引力。
  17. noip第2课资料
  18. Android动画(Animations)
  19. Tomcat路径下目录的介绍
  20. 关于Solr6.0中solrj使用简单例子

热门文章

  1. testng并发测试与测试并发
  2. get_mysql_conn_info.py
  3. POJ 3090 Visible Lattice Points (ZOJ 2777)
  4. 小白学开发(iOS)OC_ 使用继承来扩充类(2015-08-07)
  5. jquery画图插件jPainter
  6. Docker入门之 - 更换源为国内源,实现快速下载image
  7. 详解springmvc控制登录用户session失效后跳转登录页面
  8. spring 输出mvc
  9. ijkplayer阅读笔记02-创建音视频读取,解码,播放线程
  10. JavaEE分层知识点粗略解释