第一次作业：基于Linux操作系统深入源码进程模型分析

1.Linux操作系统的简易介绍

　　Linux系统一般有4个主要部分：内核、shell、文件系统和应用程序。内核、shell和文件系统一起形成了基本的操作系统结构，它们使得用户可以运行程序、管理文件并使用系统。　　　　

（1）内核

　　内核是操作系统的核心，具有很多最基本功能，如虚拟内存、多任务、共享库、需求加载、可执行程序和TCP/IP网络功能。Linux内核的模块分为以下几个部分：存储管理、CPU和进程管理、文件系统、设备管理和驱动、网络通信、系统的初始化和系统调用等。

（2）shell

　　shell是系统的用户界面，提供了用户与内核进行交互操作的一种接口。它接收用户输入的命令并把它送入内核去执行，是一个命令解释器。另外，shell编程语言具有普通编程语言的很多特点，用这种编程语言编写的shell程序与其他应用程序具有同样的效果。

（3）文件系统

　　文件系统是文件存放在磁盘等存储设备上的组织方法。Linux系统能支持多种目前流行的文件系统，如EXT2、EXT3、FAT、FAT32、VFAT和ISO9660。

（4）应用程序

　　标准的Linux系统一般都有一套都有称为应用程序的程序集，它包括文本编辑器、编程语言、XWindow、办公套件、Internet工具和数据库等。

2.Linux操作系统的进程组织

（1）什么是进程

　　进程是处于执行期的程序以及它所包含的所有资源的总称，包括虚拟处理器，虚拟空间，寄存器，堆栈，全局数据段等。

　　在Linux中，每个进程在创建时都会被分配一个数据结构，称为进程控制（Process Control Block，简称PCB）。PCB中包含了很多重要的信息，供系统调度和进程本身执行使用。所有进程的PCB都存放在内核空间中。PCB中最重要的信息就是进程PID，内核通过这个PID来唯一标识一个进程。PID可以循环使用，最大值是32768。init进程的pid为1，其他进程都是init进程的后代。

　　除了进程控制块（PCB）以外，每个进程都有独立的内核堆栈（8k），一个进程描述符结构，这些数据都作为进程的控制信息储存在内核空间中；而进程的用户空间主要存储代码和数据。

查看进程：

（2）进程创建

　　进程是通过调用::fork()，::vfork()【只复制task_struct和内核堆栈，所以生成的只是父进程的一个线程（无独立的用户空间）。】和::clone()【功能强大，带了许多参数。::clone()可以让你有选择性的继承父进程的资源，既可以选择像::vfork()一样和父进程共享一个虚拟空间，从而使创造的是线程，你也可以不和父进程共享，你甚至可以选择创造出来的进程和父进程不再是父子关系，而是兄弟关系。】系统调用创建新进程。在内核中，它们都是调用do_fork实现的。传统的fork函数直接把父进程的所有资源复制给子进程。而Linux的::fork()使用写时拷贝页实现，也就是说，父进程和子进程共享同一个资源拷贝，只有当数据发生改变时，数据才会发生复制。通常的情况，子进程创建后会立即调用exec()，这样就避免复制父进程的全部资源。

　　　　#fork()：父进程的所有数据结构都会复制一份给子进程（写时拷贝页）。当执行fork()函数后，会生成一个子进程，子进程的执行从fork()的返回值开始，且代码继续往下执行

以下代码中，使用fork()创建了一个子进程。返回值pId有两个作用：一是判断fork()是否正常执行；二是判断fork()正常执行后如何区分父子进程。

 #代码示例：
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>  

 int main (int argc, char ** argv) {
     int flag = ;
     pid_t pId = fork();
     if (pId == -) {
         perror("fork error");
         exit(EXIT_FAILURE);
     } else if (pId == ) {
         int myPid = getpid();
         int parentPid = getppid();  

         printf("Child:SelfID=%d ParentID=%d \n", myPid, parentPid);
         flag = ;
         printf("Child:flag=%d %p \n", flag, &flag);
         int count = ;
         do {
             count++;
             sleep();
             printf("Child count=%d \n", count);
             if (count >= ) {
                 break;
             }
         } while ();
         return EXIT_SUCCESS;
     } else {
         printf("Parent:SelfID=%d MyChildPID=%d \n", getpid(), pId);
         flag = ;
         printf("Parent:flag=%d %p \n", flag, &flag); // 连地址都一样,说明是真的完全拷贝,但值已经是不同的了..
         int count = ;
         do {
             count++;
             sleep();
             printf("Parent count=%d \n", count);
             if (count >= ) {
                 break;
             }
         } while ();
     }  

     return EXIT_SUCCESS;
 } 

（3）进程撤销

　　进程通过调用exit()退出执行，这个函数会终结进程并释放所有的资源。父进程可以通过wait4()查询子进程是否终结。进程退出执行后处于僵死状态，直到它的父进程调用wait()或者waitpid()为止。父进程退出时，内核会指定线程组的其他进程或者init进程作为其子进程的新父进程。当进程接收到一个不能处理或忽视的信号时，或当在内核态产生一个不可恢复的CPU异常而内核此时正代表该进程在运行，内核可以强迫进程终止。

（4）进程管理

　　内核把进程信息存放在叫做任务队列（task list）的双向循环链表中（内核空间）。链表中的每一项都是类型为task_struct，称为进程描述符结构（process descriptor），包含了一个具体进程的所有信息，包括打开的文件，进程的地址空间，挂起的信号，进程的状态等。

　　Linux通过slab分配器分配task_struct，这样能达到对象复用和缓存着色（通过预先分配和重复使用task_struct，可以避免动态分配和释放所带来的资源消耗）。

struct task_struct
{
volatile long state;
pid_t pid;
unsigned long timestamp;
unsigned long rt_priority;
struct mm_struct *mm, *active_mm
}

对于向下增长的栈来说，只需要在栈底(对于向上增长的栈则在栈顶)创建一个新的结构struct thread_info，使得在汇编代码中计算其偏移量变得容易。

#在x86上，thread_info结构在文件<asm/thread_info.h>中定义如下：
struct thread_info{
             struct task_struct              *任务
             struct exec_domain              *exec_domain;
             unsigned long                   flags;
             unsigned long                   status;
             __u32                           cpu;
             __s32                           preempt_count;
             mm_segment_t                    addr_limit;
             struct restart_block            restart_block;
             unsigned long                   previous_esp;
             _u8                             supervisor_stack[];
    };

　　内核把所有处于TASK_RUNNING状态的进程组织成一个可运行双向循环队列。调度函数通过扫描整个可运行队列，取得最值得执行的进程投入执行。避免扫描所有进程，提高调度效率。

#进程调度使用schedule()函数来完成，下面我们从分析该函数开始，代码如下：
 asmlinkage __visible void __sched schedule(void)
 {
     struct task_struct *tsk = current;

     sched_submit_work(tsk);
     __schedule();
 }
 EXPORT_SYMBOL(schedule);
#在第4段进程调度中将具体讲述功能实现

（5）进程内核堆栈

　　Linux为每个进程分配一个8KB大小的内存区域，用于存放该进程两个不同的数据结构：thread_info和进程的内核堆栈。

　　进程处于内核态时使用不同于用户态堆栈，内核控制路径所用的堆栈很少，因此对栈和描述符来说，8KB足够了。

3.Linux操作系统的进程状态转换

有以下进程状态：

进程状态的转换：

具体转换分析：

（1）进程的初始状态

进程是通过fork系列的系统调用（fork、clone、vfork）来创建的，内核（或内核模块）也可以通过kernel_thread函数创建内核进程。这些创建子进程的函数本质上都完成了相同的功能——将调用进程复制一份，得到子进程。（可以通过选项参数来决定各种资源是共享、还是私有。）那么既然调用进程处于TASK_RUNNING状态（否则，它若不是正在运行，又怎么进行调用？），则子进程默认也处于TASK_RUNNING状态。另外，在系统调用调用clone和内核函数kernel_thread也接受CLONE_STOPPED选项，从而将子进程的初始状态置为 TASK_STOPPED。

（2）进程状态变迁

进程自创建以后，状态可能发生一系列的变化，直到进程退出。而尽管进程状态有好几种，但是进程状态的变迁却只有两个方向——从TASK_RUNNING状态变为非TASK_RUNNING状态、或者从非TASK_RUNNING状态变为TASK_RUNNING状态。也就是说，如果给一个TASK_INTERRUPTIBLE状态的进程发送SIGKILL信号，这个进程将先被唤醒（进入 TASK_RUNNING状态），然后再响应SIGKILL信号而退出（变为TASK_DEAD状态）。并不会从TASK_INTERRUPTIBLE状态直接退出。进程从非TASK_RUNNING状态变为TASK_RUNNING状态，是由别的进程（也可能是中断处理程序）执行唤醒操作来实现的。执行唤醒的进程设置被唤醒进程的状态为TASK_RUNNING，然后将其task_struct结构加入到某个CPU的可执行队列中。于是被唤醒的进程将有机会被调度执行。

而进程从TASK_RUNNING状态变为非TASK_RUNNING状态，则有两种途径：

• 响应信号而进入TASK_STOPED状态、或TASK_DEAD状态；
• 执行系统调用主动进入TASK_INTERRUPTIBLE状态（如nanosleep系统调用）、或TASK_DEAD状态（如exit 系统调用）；或由于执行系统调用需要的资源得不到满足，而进入TASK_INTERRUPTIBLE状态或TASK_UNINTERRUPTIBLE状态（如select系统调用）。

4.Linux操作系统的进程调度

　毋庸置疑，我们使用schedule()函数来完成进程调度，接下来就来看看进程调度的代码以及实现过程吧。

 asmlinkage __visible void __sched schedule(void)
 {
     struct task_struct *tsk = current;

     sched_submit_work(tsk);
     __schedule();
 }
 EXPORT_SYMBOL(schedule);

　　第3行获取当前进程描述符指针，存放在本地变量tsk中。第6行调用__schedule()，代码如下（kernel/sched/core.c）：

  static void __sched __schedule(void)
  {
      struct task_struct *prev, *next;
      unsigned long *switch_count;
      struct rq *rq;
      int cpu;

  need_resched:
      preempt_disable();
     cpu = smp_processor_id();
     rq = cpu_rq(cpu);
     rcu_note_context_switch(cpu);
     prev = rq->curr;

     schedule_debug(prev);

     if (sched_feat(HRTICK))
         hrtick_clear(rq);

     /*
21      * Make sure that signal_pending_state()->signal_pending() below
22      * can't be reordered with __set_current_state(TASK_INTERRUPTIBLE)
23      * done by the caller to avoid the race with signal_wake_up().
24      */
     smp_mb__before_spinlock();
     raw_spin_lock_irq(&rq->lock);

     switch_count = &prev->nivcsw;
     if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) {
         if (unlikely(signal_pending_state(prev->state, prev))) {
             prev->state = TASK_RUNNING;
         } else {
             deactivate_task(rq, prev, DEQUEUE_SLEEP);
             prev->on_rq = ;

             /*
37              * If a worker went to sleep, notify and ask workqueue
38              * whether it wants to wake up a task to maintain
39              * concurrency.
40              */
             if (prev->flags & PF_WQ_WORKER) {
                 struct task_struct *to_wakeup;

                 to_wakeup = wq_worker_sleeping(prev, cpu);
                 if (to_wakeup)
                     try_to_wake_up_local(to_wakeup);
             }
         }
         switch_count = &prev->nvcsw;
     }

     if (prev->on_rq || rq->skip_clock_update < )
         update_rq_clock(rq);

     next = pick_next_task(rq, prev);
     clear_tsk_need_resched(prev);
     clear_preempt_need_resched();
     rq->skip_clock_update = ;

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

         context_switch(rq, prev, next); /* unlocks the rq */
         /*
67          * The context switch have flipped the stack from under us
68          * and restored the local variables which were saved when
69          * this task called schedule() in the past. prev == current
70          * is still correct, but it can be moved to another cpu/rq.
71          */
         cpu = smp_processor_id();
         rq = cpu_rq(cpu);
     } else
         raw_spin_unlock_irq(&rq->lock);

     post_schedule(rq);

     sched_preempt_enable_no_resched();
     if (need_resched())
         goto need_resched;
 }

static void __sched __schedule(void)

　　第9行禁止内核抢占。第10行获取当前的cpu号。第11行获取当前cpu的进程运行队列。第13行将当前进程的描述符指针保存在prev变量中。第55行将下一个被调度的进程描述符指针存放在next变量中。第56行清除当前进程的内核抢占标记。第60行判断当前进程和下一个调度的是不是同一个进程，如果不是的话，就要进行调度。第65行，对当前进程和下一个进程的上下文进行切换（调度之前要先切换上下文）。下面看看该函数（kernel/sched/core.c）：

  context_switch(struct rq *rq, struct task_struct *prev,
             struct task_struct *next)
  {
      struct mm_struct *mm, *oldmm;

      prepare_task_switch(rq, prev, next);

      mm = next->mm;
      oldmm = prev->active_mm;
     /*
11      * For paravirt, this is coupled with an exit in switch_to to
12      * combine the page table reload and the switch backend into
13      * one hypercall.
14      */
     arch_start_context_switch(prev);

     if (!mm) {
         next->active_mm = oldmm;
         atomic_inc(&oldmm->mm_count);
         enter_lazy_tlb(oldmm, next);
     } else
         switch_mm(oldmm, mm, next);

     if (!prev->mm) {
         prev->active_mm = NULL;
         rq->prev_mm = oldmm;
     }
     /*
29      * Since the runqueue lock will be released by the next
30      * task (which is an invalid locking op but in the case
31      * of the scheduler it's an obvious special-case), so we
32      * do an early lockdep release here:
33      */
 #ifndef __ARCH_WANT_UNLOCKED_CTXSW
     spin_release(&rq->lock.dep_map, , _THIS_IP_);
 #endif

     context_tracking_task_switch(prev, next);
     /* Here we just switch the register state and the stack. */
     switch_to(prev, next, prev);

     barrier();
     /*
44      * this_rq must be evaluated again because prev may have moved
45      * CPUs since it called schedule(), thus the 'rq' on its stack
46      * frame will be invalid.
47      */
     finish_task_switch(this_rq(), prev);
 }

context_switch(struct rq *rq, struct task_struct *prev, struct task_struct *next)

　　上下文切换一般分为两个，一个是硬件上下文切换（指的是cpu寄存器，要把当前进程使用的寄存器内容保存下来，再把下一个程序的寄存器内容恢复），另一个是切换进程的地址空间（说白了就是程序代码）。进程的地址空间（程序代码）主要保存在进程描述符中的struct mm_struct结构体中，因此该函数主要是操作这个结构体。第17行如果被调度的下一个进程地址空间mm为空，说明下个进程是个线程，没有独立的地址空间，共用所属进程的地址空间，因此第18行将上个进程所使用的地址空间active_mm指针赋给下一个进程的该域，下一个进程也使用这个地址空间。第22行，如果下个进程地址空间不为空，说明下个进程有自己的地址空间，那么执行switch_mm切换进程页表。第40行切换进程的硬件上下文。 switch_to函数代码如下（arch/x86/include/asm/switch_to.h）：

  __visible __notrace_funcgraph struct task_struct *
  __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
  {
      struct thread_struct *prev = &prev_p->thread,
                   *next = &next_p->thread;
      int cpu = smp_processor_id();
      struct tss_struct *tss = &per_cpu(init_tss, cpu);
      fpu_switch_t fpu;

     /* never put a printk in __switch_to... printk() calls wake_up*() indirectly */

     fpu = switch_fpu_prepare(prev_p, next_p, cpu);

     /*
15      * Reload esp0.
16      */
     load_sp0(tss, next);

     /*
20      * Save away %gs. No need to save %fs, as it was saved on the
21      * stack on entry.  No need to save %es and %ds, as those are
22      * always kernel segments while inside the kernel.  Doing this
23      * before setting the new TLS descriptors avoids the situation
24      * where we temporarily have non-reloadable segments in %fs
25      * and %gs.  This could be an issue if the NMI handler ever
26      * used %fs or %gs (it does not today), or if the kernel is
27      * running inside of a hypervisor layer.
28      */
     lazy_save_gs(prev->gs);

     /*
32      * Load the per-thread Thread-Local Storage descriptor.
33      */
     load_TLS(next, cpu);

     /*
37      * Restore IOPL if needed.  In normal use, the flags restore
38      * in the switch assembly will handle this.  But if the kernel
39      * is running virtualized at a non-zero CPL, the popf will
40      * not restore flags, so it must be done in a separate step.
41      */
     if (get_kernel_rpl() && unlikely(prev->iopl != next->iopl))
         set_iopl_mask(next->iopl);

     /*
46      * If it were not for PREEMPT_ACTIVE we could guarantee that the
47      * preempt_count of all tasks was equal here and this would not be
48      * needed.
49      */
     task_thread_info(prev_p)->saved_preempt_count = this_cpu_read(__preempt_count);
     this_cpu_write(__preempt_count, task_thread_info(next_p)->saved_preempt_count);

     /*
54      * Now maybe handle debug registers and/or IO bitmaps
55      */
     if (unlikely(task_thread_info(prev_p)->flags & _TIF_WORK_CTXSW_PREV ||
              task_thread_info(next_p)->flags & _TIF_WORK_CTXSW_NEXT))
         __switch_to_xtra(prev_p, next_p, tss);

     /*
61      * Leave lazy mode, flushing any hypercalls made here.
62      * This must be done before restoring TLS segments so
63      * the GDT and LDT are properly updated, and must be
64      * done before math_state_restore, so the TS bit is up
65      * to date.
66      */
     arch_end_context_switch(next_p);

     this_cpu_write(kernel_stack,
           (unsigned long)task_stack_page(next_p) +
           THREAD_SIZE - KERNEL_STACK_OFFSET);

     /*
74      * Restore %gs if needed (which is common)
75      */
     if (prev->gs | next->gs)
         lazy_load_gs(next->gs);

     switch_fpu_finish(next_p, fpu);

     this_cpu_write(current_task, next_p);

     return prev_p;
 }

__visible __notrace_funcgraph struct task_struct * __switch_to(struct task_struct *prev_p, struct task_struct *next_p)

　　该函数主要是对刚切换过来的新进程进一步做些初始化工作。比如第34将该进程使用的线程局部存储段（TLS）装入本地cpu的全局描述符表。第84行返回语句会被编译成两条汇编指令，一条是将返回值prev_p保存到eax寄存器，另外一个是ret指令，将内核栈顶的元素弹出eip寄存器，从这个eip指针处开始执行，也就是上个函数第17行所压入的那个指针。一般情况下，被压入的指针是上个函数第20行那个标号1所代表的地址，那么从__switch_to函数返回后，将从标号1处开始运行。

　　需要注意的是，对于已经被调度过的进程而言，从__switch_to函数返回后，将从标号1处开始运行；但是对于用fork(),clone()等函数刚创建的新进程（未调度过），将进入ret_from_fork()函数，因为do_fork()函数在创建好进程之后，会给进程的thread_info.ip赋予ret_from_fork函数的地址，而不是标号1的地址，因此它会跳入ret_from_fork函数。后边我们在分析fork系统调用的时候，就会看到。

5.对于Linux操作系统进程模型的一些个人看法

　　有一个形象的比喻：想象一位知识渊博、经验丰富的工程建筑设计师正在为一个公司设计总部。他有公司建筑的设计图，有所需的建筑材料和工具：水泥、钢筋、木板、挖掘机、吊升机、石钻头等。在这个比喻中，设计图就是程序（即用适当形式描述的算法），工程建筑师就是处理器（CPU），而建筑的各种材料就是输入数据。进程就是建筑工程设计师阅读设计图、取来各种材料和工具以及管理工人员工和分配资源、最后施工等一系列动作的总和，在过程中工程建筑师还需要遵循许多设计的规范和理念（模型），最后完成的公司总部就是软件或者可以实现某种功能的源代码。

　　这里说明的是进程是某种类型的一个活动，它有程序、输入、输出以及状态。单个处理器可以被若干进程共享，它使用某种调度算法决定何时停止一个进程的工作，并转而为另一个进程提供服务。那么Linux操作系统进程模型就是活动的规范，规范的出现创新让许多实现过程更加系统完整、安全可靠、速度效率等。

　　就像人类基于理论实践伟大的工程设计智慧经验结晶，Linux操作系统是系统、效率、安全的，而且通过商业公司、庞大的社区群体、操作系统爱好者是在往前改善的，但如果有一天Linux操作系统闭源了，只有国内开放了源代码，还尚未掌握核心技术，卡住脖子怎么办？我们不能拥有完完全全拿来即用的心态，还需扎实掌握基础知识，提高自我创新意识。对于Linux操作系统进程模型，深入理解它，你会发现在Linux操作系统的应用实践上会愈加效率，同时通过它你可以实现更多好玩的操作。

6.参考资料

Contiki学习笔记：目录。

源码地址（https://elixir.bootlin.com/linux/v4.6/source）

脚本之家（http://www.jb51.net/）

CSDN博客（https://blog.csdn.net/）

百度知道（https://zhidao.baidu.com/）