- 浏览: 44007 次
文章分类
最新评论
进程管理(三)
(一):进程创建
linux不同于其他操作系统,linux在进程的创建的时候,将进程的创建和执行程序分成了两个函数,fork()和exec()。进程在创建的过程中,首先通过fork()函数拷贝一份当前进程来创建一个子进程。子进程和父进程的区别仅仅在于PID,PPID(父进程的进程号,子进程将其设置为被拷贝进程的进程号)和某些资源以及统计量(被挂起的信号等)。exec()函数负责执行负责执行可执行文件并将其载入地址空间开始运行。
1:写时拷贝
在传统的fotk()函数中,直接将进程的所有的资源复制给新创建的进程,这样有一些不好的地方,首先,这样会使得进程创建缓慢,其次就是有很多没有必要继承的数据被无辜继承下来,后来还需要修改,这样就会造成效率低下。
现在有了写时拷贝(copy-on-write),这是一种推迟甚至免除拷贝数据的技术,在进程被创建的时候,内核并不是复制整个进程地址空间,而是让父进程和子进程共享同一个拷贝。只有在需要写入的时候,数据才会被复制。
2:fork()
Linux通过clone()系统调用实现fork()。这个调用通过一系列的参数标志来指明父,子进程需要共享的资源。其中fork(),vfork(),_clone()都根据各自需要的参数标志去调用clone(),然后clone()在去调用dk_fork()。最后do_fork()调用copy_process()让进程开始运行。下面我们来看一下该调用过程。其中基本上大部分定义在 kernel/fork.c中。
我们首先看一下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 struct task_struct *copy_process(unsigned long clone_flags,
unsigned long stack_start,
struct pt_regs *regs,
unsigned long stack_size,
int __user *parent_tidptr,
int __user *child_tidptr,
int pid)
{
int retval;
struct task_struct *p = NULL;
if ((clone_flags & (CLONE_NEWNS|CLONE_FS)) == (CLONE_NEWNS|CLONE_FS))
return ERR_PTR(-EINVAL);
/*
* Thread groups must share signals as well, and detached threads
* can only be started up within the thread group.
*
* 线程组一定要共享信号,并且分离的线程也仅仅能在线程组中运行。
*
*/
if ((clone_flags & CLONE_THREAD) && !(clone_flags & CLONE_SIGHAND))
return ERR_PTR(-EINVAL);
/*
* Shared signal handlers imply shared VM. By way of the above,
* thread groups also imply shared VM. Blocking this case allows
* for various simplifications in other code.
*/
if ((clone_flags & CLONE_SIGHAND) && !(clone_flags & CLONE_VM))
return ERR_PTR(-EINVAL);
retval = security_task_create(clone_flags);
if (retval)
goto fork_out;
retval = -ENOMEM;
/*
* 使用dump_task_struct()为新进程创建一个内核栈,thread_info结构和task_struct,这些值
* 与当前进程相同,此时,子进程和父进程的描述符是完全一样的。
*
*/
p = dup_task_struct(current);
/*
* 创建完成之后,检查新创建进程的正确性,以及当前拥有的进程数目没有
* 超过给他分配的资源的限制。
*
* 子进程开始着手将自己与父进程区别开来,进程描述符中的很多成员需要被清0
* 或被设置为初始值。
*/
if (!p)
goto fork_out;
#ifdef CONFIG_TRACE_IRQFLAGS
DEBUG_LOCKS_WARN_ON(!p->hardirqs_enabled);
DEBUG_LOCKS_WARN_ON(!p->softirqs_enabled);
#endif
retval = -EAGAIN;
if (atomic_read(&p->user->processes) >=
p->signal->rlim[RLIMIT_NPROC].rlim_cur) {
if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RESOURCE) &&
p->user != &root_user)
goto bad_fork_free;
}
atomic_inc(&p->user->__count);
atomic_inc(&p->user->processes);
get_group_info(p->group_info);
/*
* If multiple threads are within copy_process(), then this check
* triggers too late. This doesn't hurt, the check is only there
* to stop root fork bombs.
*/
if (nr_threads >= max_threads)
goto bad_fork_cleanup_count;
if (!try_module_get(task_thread_info(p)->exec_domain->module))
goto bad_fork_cleanup_count;
if (p->binfmt && !try_module_get(p->binfmt->module))
goto bad_fork_cleanup_put_domain;
p->did_exec = 0;
delayacct_tsk_init(p); /* Must remain after dup_task_struct() */
/*
* copy_flags()函数被调用,来更新task_struct的flags成员。表明进程
* 是否拥有超级权限的PF_SUPERPRIV标志被清0,表明进程还没有调用exec()
* 函数的PF_FORKNOEXEC标志被设置
*/
copy_flags(clone_flags, p);
/*
* 由于之前函数刚开始的时候,调用函数alloc_pid()函数已经为该进程
* 分配了pid,在这里只需设置新创建进程的pid即可。
*
*/
p->pid = pid;
retval = -EFAULT;
// 根据传递的参数标志,copy_process()拷贝或共享打开的文件,文件系统信息,
// 信号处理函数,进程地址空间和命名空间等。
if (clone_flags & CLONE_PARENT_SETTID)
if (put_user(p->pid, parent_tidptr))
goto bad_fork_cleanup_delays_binfmt;
INIT_LIST_HEAD(&p->children);
INIT_LIST_HEAD(&p->sibling);
p->vfork_done = NULL;
spin_lock_init(&p->alloc_lock);
clear_tsk_thread_flag(p, TIF_SIGPENDING);
init_sigpending(&p->pending);
p->utime = cputime_zero;
p->stime = cputime_zero;
p->sched_time = 0;
p->rchar = 0; /* I/O counter: bytes read */
p->wchar = 0; /* I/O counter: bytes written */
p->syscr = 0; /* I/O counter: read syscalls */
p->syscw = 0; /* I/O counter: write syscalls */
acct_clear_integrals(p);
p->it_virt_expires = cputime_zero;
p->it_prof_expires = cputime_zero;
p->it_sched_expires = 0;
INIT_LIST_HEAD(&p->cpu_timers[0]);
INIT_LIST_HEAD(&p->cpu_timers[1]);
INIT_LIST_HEAD(&p->cpu_timers[2]);
p->lock_depth = -1; /* -1 = no lock */
do_posix_clock_monotonic_gettime(&p->start_time);
p->security = NULL;
p->io_context = NULL;
p->io_wait = NULL;
p->audit_context = NULL;
cpuset_fork(p);
#ifdef CONFIG_NUMA
p->mempolicy = mpol_copy(p->mempolicy);
if (IS_ERR(p->mempolicy)) {
retval = PTR_ERR(p->mempolicy);
p->mempolicy = NULL;
goto bad_fork_cleanup_cpuset;
}
mpol_fix_fork_child_flag(p);
#endif
#ifdef CONFIG_TRACE_IRQFLAGS
p->irq_events = 0;
p->hardirqs_enabled = 0;
p->hardirq_enable_ip = 0;
p->hardirq_enable_event = 0;
p->hardirq_disable_ip = _THIS_IP_;
p->hardirq_disable_event = 0;
p->softirqs_enabled = 1;
p->softirq_enable_ip = _THIS_IP_;
p->softirq_enable_event = 0;
p->softirq_disable_ip = 0;
p->softirq_disable_event = 0;
p->hardirq_context = 0;
p->softirq_context = 0;
#endif
#ifdef CONFIG_LOCKDEP
p->lockdep_depth = 0; /* no locks held yet */
p->curr_chain_key = 0;
p->lockdep_recursion = 0;
#endif
rt_mutex_init_task(p);
#ifdef CONFIG_DEBUG_MUTEXES
p->blocked_on = NULL; /* not blocked yet */
#endif
p->tgid = p->pid;
if (clone_flags & CLONE_THREAD)
p->tgid = current->tgid;
if ((retval = security_task_alloc(p)))
goto bad_fork_cleanup_policy;
if ((retval = audit_alloc(p)))
goto bad_fork_cleanup_security;
/* copy all the process information */
if ((retval = copy_semundo(clone_flags, p)))
goto bad_fork_cleanup_audit;
if ((retval = copy_files(clone_flags, p)))
goto bad_fork_cleanup_semundo;
if ((retval = copy_fs(clone_flags, p)))
goto bad_fork_cleanup_files;
if ((retval = copy_sighand(clone_flags, p)))
goto bad_fork_cleanup_fs;
if ((retval = copy_signal(clone_flags, p)))
goto bad_fork_cleanup_sighand;
if ((retval = copy_mm(clone_flags, p)))
goto bad_fork_cleanup_signal;
if ((retval = copy_keys(clone_flags, p)))
goto bad_fork_cleanup_mm;
if ((retval = copy_namespace(clone_flags, p)))
goto bad_fork_cleanup_keys;
retval = copy_thread(0, clone_flags, stack_start, stack_size, p, regs);
if (retval)
goto bad_fork_cleanup_namespace;
p->set_child_tid = (clone_flags & CLONE_CHILD_SETTID) ? child_tidptr : NULL;
/*
* Clear TID on mm_release()?
*/
p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARTID) ? child_tidptr: NULL;
p->robust_list = NULL;
#ifdef CONFIG_COMPAT
p->compat_robust_list = NULL;
#endif
INIT_LIST_HEAD(&p->pi_state_list);
p->pi_state_cache = NULL;
/*
* sigaltstack should be cleared when sharing the same VM
*/
if ((clone_flags & (CLONE_VM|CLONE_VFORK)) == CLONE_VM)
p->sas_ss_sp = p->sas_ss_size = 0;
/*
* Syscall tracing should be turned off in the child regardless
* of CLONE_PTRACE.
*/
clear_tsk_thread_flag(p, TIF_SYSCALL_TRACE);
#ifdef TIF_SYSCALL_EMU
clear_tsk_thread_flag(p, TIF_SYSCALL_EMU);
#endif
/* 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->exit_signal = (clone_flags & CLONE_THREAD) ? -1 : (clone_flags & CSIGNAL);
p->pdeath_signal = 0;
p->exit_state = 0;
/*
* Ok, make it visible to the rest of the system.
* We dont wake it up yet.
*/
p->group_leader = p;
INIT_LIST_HEAD(&p->thread_group);
INIT_LIST_HEAD(&p->ptrace_children);
INIT_LIST_HEAD(&p->ptrace_list);
/* Perform scheduler related setup. Assign this task to a CPU. */
sched_fork(p, clone_flags);
/* Need tasklist lock for parent etc handling! */
write_lock_irq(&tasklist_lock);
/*
* The task hasn't been attached yet, so its cpus_allowed mask will
* not be changed, nor will its assigned CPU.
*
* The cpus_allowed mask of the parent may have changed after it was
* copied first time - so re-copy it here, then check the child's CPU
* to ensure it is on a valid CPU (and if not, just force it back to
* parent's CPU). This avoids alot of nasty races.
*/
p->cpus_allowed = current->cpus_allowed;
if (unlikely(!cpu_isset(task_cpu(p), p->cpus_allowed) ||
!cpu_online(task_cpu(p))))
set_task_cpu(p, smp_processor_id());
/* CLONE_PARENT re-uses the old parent */
if (clone_flags & (CLONE_PARENT|CLONE_THREAD))
p->real_parent = current->real_parent;
else
p->real_parent = current;
p->parent = p->real_parent;
spin_lock(¤t->sighand->siglock);
/*
* Process group and session signals need to be delivered to just the
* parent before the fork or both the parent and the child after the
* fork. Restart if a signal comes in before we add the new process to
* it's process group.
* A fatal signal pending means that current will exit, so the new
* thread can't slip out of an OOM kill (or normal SIGKILL).
*/
recalc_sigpending();
if (signal_pending(current)) {
spin_unlock(¤t->sighand->siglock);
write_unlock_irq(&tasklist_lock);
retval = -ERESTARTNOINTR;
goto bad_fork_cleanup_namespace;
}
if (clone_flags & CLONE_THREAD) {
p->group_leader = current->group_leader;
list_add_tail_rcu(&p->thread_group, &p->group_leader->thread_group);
if (!cputime_eq(current->signal->it_virt_expires,
cputime_zero) ||
!cputime_eq(current->signal->it_prof_expires,
cputime_zero) ||
current->signal->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY ||
!list_empty(¤t->signal->cpu_timers[0]) ||
!list_empty(¤t->signal->cpu_timers[1]) ||
!list_empty(¤t->signal->cpu_timers[2])) {
/*
* Have child wake up on its first tick to check
* for process CPU timers.
*/
p->it_prof_expires = jiffies_to_cputime(1);
}
}
/*
* inherit ioprioretval
*/
p->ioprio = current->ioprio;
if (likely(p->pid)) {
add_parent(p);
if (unlikely(p->ptrace & PT_PTRACED))
__ptrace_link(p, current->parent);
if (thread_group_leader(p)) {
p->signal->tty = current->signal->tty;
p->signal->pgrp = process_group(current);
p->signal->session = current->signal->session;
attach_pid(p, PIDTYPE_PGID, process_group(p));
attach_pid(p, PIDTYPE_SID, p->signal->session);
list_add_tail_rcu(&p->tasks, &init_task.tasks);
__get_cpu_var(process_counts)++;
}
attach_pid(p, PIDTYPE_PID, p->pid);
nr_threads++;
}
total_forks++;
spin_unlock(¤t->sighand->siglock);
write_unlock_irq(&tasklist_lock);
proc_fork_connector(p);
//最后返回新创建进程描述符的指针
return p;
bad_fork_cleanup_namespace:
exit_namespace(p);
bad_fork_cleanup_keys:
exit_keys(p);
bad_fork_cleanup_mm:
if (p->mm)
mmput(p->mm);
bad_fork_cleanup_signal:
cleanup_signal(p);
bad_fork_cleanup_sighand:
__cleanup_sighand(p->sighand);
bad_fork_cleanup_fs:
exit_fs(p); /* blocking */
bad_fork_cleanup_files:
exit_files(p); /* blocking */
bad_fork_cleanup_semundo:
exit_sem(p);
bad_fork_cleanup_audit:
audit_free(p);
bad_fork_cleanup_security:
security_task_free(p);
bad_fork_cleanup_policy:
#ifdef CONFIG_NUMA
mpol_free(p->mempolicy);
bad_fork_cleanup_cpuset:
#endif
cpuset_exit(p);
bad_fork_cleanup_delays_binfmt:
delayacct_tsk_free(p);
if (p->binfmt)
module_put(p->binfmt->module);
bad_fork_cleanup_put_domain:
module_put(task_thread_info(p)->exec_domain->module);
bad_fork_cleanup_count:
put_group_info(p->group_info);
atomic_dec(&p->user->processes);
free_uid(p->user);
bad_fork_free:
free_task(p);
fork_out:
return ERR_PTR(retval);
}
这样,我们来梳理一下copy_process()的工作流程。
根据代码,当该函数被调用的时候,首先会调用alloc_pid()函数分配一个新的pid。接着进程下面的操作:
1:调用dump_task_struct()函数为为新进程创建一个内核栈,thread_info结构和task_struct,这些值和当前进程的值相同。此时,子进程和父进程的进程描述符是完全一样的。
2:接着,程序会检查新创建的子进程的正确性,并且检查当前用户所拥有的进程数目没有超过给他分配的资源限制。
3:子进程着手将自己与父进程去被开来。进程描述符内的很多成员都要被清0或者是设置为初始值。
4:子进程的状态被设置为TASK_UNINTERRUPTIBLE,来保证不会投入运行
5:调用copy_flags()来更新task_struct的flags成员。表示用户是否拥有超级权限的标志PF_SUPERPRIV被清0.
6:设置新进程的pid
7:根据clone()传递的参数标志,copy_process()拷贝或共享打开的文件,文件系统信息,信号处理函数,进程地址空间和命名空间等。
8:最后,返回一个指向子进程的指针。
版权声明:本文为博主原创文章,未经博主允许不得转载。
相关推荐
view … 等三 实验步骤1 复习进程管理的内容2 按要求编写进程状态变迁的程序;3 上机调试 并完成实验报告 ">实验一:模拟进程管理一 目的:模拟进程管理实现进程的创建 撤销 封锁和唤醒功能 二 功能描述1 创建进程...
针对需求4:为进程管理器类编写调度函数,调度函数中内置上述三种算法,进程管理对象根据交互得到的信息决定使用哪一种调度算法; 针对需求5:为了能够及时的表征程序运行状态和提供良好的交互接口,可以利用Java....
实验二 进程管理 Windows所创建的每个进程都从调用CreateProcess() API函数开始,该函数的任务是在对象管理器子系统内初始化进程对象。每一进程都以调用ExitProcess() 或TerminateProcess() API函数终止。通常...
操作系统进程管理实验(C语言实现)
当前进程管理允许用户实时调整任意进程的优先级及获取特定模块的加载信息等;而系统服务管理提供了比 Windows 自身相对强大的处理特性,比如直接删除某个服务及高级分组管理等等。 新版里面很多特性都变得批量化起来...
一、目的:模拟进程管理实现进程的创建、撤销、封锁和唤醒功能。 二、功能描述 1 创建进程: 申请PCB表;填写PCB表;连接到就绪队列中 2 撤销功能:按给定进程的标识符从等待队列中撤销一个进程 3 封锁功能: 把当前...
用c语言模拟进程管理 1、首先构建进程的数据结构 2、实现建立进程 3、三种基本状态的队列 4、将进程入队 5、实现进程在队列之间的转换 6、进程通信
设每个进程处于运行E(excecuting)、就绪R(ready)和完成F(finish)三种状态之一,并假设起始状态都是就绪状态R。),以及进程队列指针NEXT(用来将PCB排成队列)等,可按照调度算法的不同而增删。 3.调度程序...
os实验,采用C#语言模拟进程管理问题,采用了时间片轮转调度、先来先服务、短进程优先调度三种算法模拟进程调度问题,可以时时查看进程调度情况和资源变化情况
该文档中包含操作系统三个实验的具体步骤和代码: 实验一 掌握进程同步与同步机制,了解Linux内核并发性和各种同步...了解x86的分段机制,知道什么是物理存储管理和进程虚拟存储管理。 统计系统和单个进程的缺页次数。
3.1 为什么要引入进程的概念 3.2 进程的表示和调度状态 3.3 进程的控制 3.4 进程调度 3.5 线程及其管理 3.6 进程通讯 3.7 死锁
UNIX Linux实验教程 3实验三Linux进程管理与控制.doc
vc课程设计 第三章 系统进程管理器的开发 Visual C++课程设计案例精编(第二版)光盘源码
实验三进程管理.pdf
第三章进程管理通信.ppt
signal()让父进程捕捉用alarm函数设置时钟的时间段终止时产生的信号,当捕捉到该信号后,父进程使用系统调用Kill()向两个子进程发出信号,子进程捕捉到信号后分别输出子进程被杀死信息后终止,父进程等待两个子...
三、实验主要仪器设备和材料 硬件环境:IBM-PC或兼容机 软件环境:C语言编程环境 四、实验原理及设计方案 1、进程调度算法:采用多级反馈队列调度算法。其基本思想是:当一个新进程进入内在后,首先将它放入第一个...
用C语言链表实现进程转换,阻塞变就绪,就绪变执行,执行变阻塞三种状态的转换
计算机三级进程管理.pptx
//a,b,c分别为A,B,C三类资源的总量 //i为进城计数,i=1…n //h为运行的时间片次数,time1Inteval为时间片大小(毫秒) //建立一个PCB结构体型的空链表 PCB *increat(void) { PCB *head=NULL; //head=NULL; ...