Linux 源码阅读 进程管理

Linux 源码阅读 进程管理

版本：2.6.24

1.准备知识

1.1 Linux系统中，进程是最小的调度单位；

1.2 PCB数据结构：task_struct （Location：linux-2.6.24\include\linux\sched.h）（任务可以和进程混用）

task_struct结构体

2.设计思路图

3.数据结构

4.主要函数

4.1创建进程

 long do_fork(unsigned long clone_flags,
           unsigned long stack_start,
           struct pt_regs *regs,
           unsigned long stack_size,
           int __user *parent_tidptr,
           int __user *child_tidptr)
 {
     struct task_struct *p;
     int trace = ;
     long nr;

     if (unlikely(current->ptrace)) {
         trace = fork_traceflag (clone_flags);
         if (trace)
             clone_flags |= CLONE_PTRACE;
     }

     p = copy_process(clone_flags, stack_start, regs, stack_size,
             child_tidptr, NULL);
     /*
      * Do this prior waking up the new thread - the thread pointer
      * might get invalid after that point, if the thread exits quickly.
      */
     if (!IS_ERR(p)) {
         struct completion vfork;

         /*
          * this is enough to call pid_nr_ns here, but this if
          * improves optimisation of regular fork()
          */
         nr = (clone_flags & CLONE_NEWPID) ?
             task_pid_nr_ns(p, current->nsproxy->pid_ns) :
                 task_pid_vnr(p);

         if (clone_flags & CLONE_PARENT_SETTID)
             put_user(nr, parent_tidptr);

         if (clone_flags & CLONE_VFORK) {
             p->vfork_done = &vfork;
             init_completion(&vfork);
         }

         if ((p->ptrace & PT_PTRACED) || (clone_flags & CLONE_STOPPED)) {
             /*
              * We'll start up with an immediate SIGSTOP.
              */
             sigaddset(&p->pending.signal, SIGSTOP);
             set_tsk_thread_flag(p, TIF_SIGPENDING);
         }

         if (!(clone_flags & CLONE_STOPPED))
             wake_up_new_task(p, clone_flags);
         else
             p->state = TASK_STOPPED;

         if (unlikely (trace)) {
             current->ptrace_message = nr;
             ptrace_notify ((trace << ) | SIGTRAP);
         }

         if (clone_flags & CLONE_VFORK) {
             freezer_do_not_count();
             wait_for_completion(&vfork);
             freezer_count();
             if (unlikely (current->ptrace & PT_TRACE_VFORK_DONE)) {
                 current->ptrace_message = nr;
                 ptrace_notify ((PTRACE_EVENT_VFORK_DONE << ) | SIGTRAP);
             }
         }
     } else {
         nr = PTR_ERR(p);
     }
     return nr;
 }

do_fork()函数（Locatiion：linux-2.6.24\kernel\fork.c）

 asmlinkage int sys_vfork(struct pt_regs regs)
 {
     return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs.esp, &regs, , NULL, NULL);
 }

vfork()函数（location:linux-2.6.24\arch\x86\kernel\process_32.c）

 asmlinkage int sys_fork(struct pt_regs regs)
 {
     return do_fork(SIGCHLD, regs.esp, &regs, , NULL, NULL);
 }

fork()函数（location:linux-2.6.24\arch\x86\kernel\process_32.c）

asmlinkage int sys_clone(struct pt_regs regs)
{
    unsigned long clone_flags;
    unsigned long newsp;
    int __user *parent_tidptr, *child_tidptr;

    clone_flags = regs.ebx;
    newsp = regs.ecx;
    parent_tidptr = (int __user *)regs.edx;
    child_tidptr = (int __user *)regs.edi;
    if (!newsp)
        newsp = regs.esp;
    return do_fork(clone_flags, newsp, &regs, , parent_tidptr, child_tidptr);
}

clone()函数（location:linux-2.6.24\arch\x86\kernel\process_32.c）

 /*
  * schedule() is the main scheduler function.
  */
 asmlinkage void __sched schedule(void)
 {
     struct task_struct *prev, *next;
     long *switch_count;
     struct rq *rq;
     int cpu;

 need_resched:
     preempt_disable();
     cpu = smp_processor_id();
     rq = cpu_rq(cpu);
     rcu_qsctr_inc(cpu);
     prev = rq->curr;
     switch_count = &prev->nivcsw;

     release_kernel_lock(prev);
 need_resched_nonpreemptible:

     schedule_debug(prev);

     /*
      * Do the rq-clock update outside the rq lock:
      */
     local_irq_disable();
     __update_rq_clock(rq);
     spin_lock(&rq->lock);
     clear_tsk_need_resched(prev);

     if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) {
         if (unlikely((prev->state & TASK_INTERRUPTIBLE) &&
                 unlikely(signal_pending(prev)))) {
             prev->state = TASK_RUNNING;
         } else {
             deactivate_task(rq, prev, );
         }
         switch_count = &prev->nvcsw;
     }

     if (unlikely(!rq->nr_running))
         idle_balance(cpu, rq);

     prev->sched_class->put_prev_task(rq, prev);
     next = pick_next_task(rq, prev);

     sched_info_switch(prev, next);

     if (likely(prev != next)) {
         rq->nr_switches++;
         rq->curr = next;
         ++*switch_count;

         context_switch(rq, prev, next); /* unlocks the rq */
     } else
         spin_unlock_irq(&rq->lock);

     if (unlikely(reacquire_kernel_lock(current) < )) {
         cpu = smp_processor_id();
         rq = cpu_rq(cpu);
         goto need_resched_nonpreemptible;
     }
     preempt_enable_no_resched();
     if (unlikely(test_thread_flag(TIF_NEED_RESCHED)))
         goto need_resched;
 }

schdule()函数（Location:linux-2.6.24\kernel\sched.c

4.2进程调度