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()正常执行后如何区分父子进程。
1 #代码示例：
2 #include <stdio.h>
3 #include <stdlib.h>
4 #include <unistd.h>
5
6 int main (int argc, char ** argv) {
7 int flag = 0;
8 pid_t pId = fork();
9 if (pId == -1) {
10 perror("fork error");
11 exit(EXIT_FAILURE);
12 } else if (pId == 0) {
13 int myPid = getpid();
14 int parentPid = getppid();
15
16 printf("Child:SelfID=%d ParentID=%d \n", myPid, parentPid);
17 flag = 123;
18 printf("Child:flag=%d %p \n", flag, &flag);
19 int count = 0;
20 do {
21 count++;
22 sleep(1);
23 printf("Child count=%d \n", count);
24 if (count >= 5) {
25 break;
26 }
27 } while (1);
28 return EXIT_SUCCESS;
29 } else {
30 printf("Parent:SelfID=%d MyChildPID=%d \n", getpid(), pId);
31 flag = 456;
32 printf("Parent:flag=%d %p \n", flag, &flag); // 连地址都一样,说明是真的完全拷贝,但值已经是不同的了..
33 int count = 0;
34 do {
35 count++;
36 sleep(1);
37 printf("Parent count=%d \n", count);
38 if (count >= 2) {
39 break;
40 }
41 } while (1);
42 }
43
44 return EXIT_SUCCESS;
45 }
（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[0];
};
内核把所有处于TASK_RUNNING状态的进程组织成一个可运行双向循环队列。调度函数通过扫描整个可运行队列，取得最值得执行的进程投入执行。避免扫描所有进程，提高调度效率。
#进程调度使用schedule()函数来完成，下面我们从分析该函数开始，代码如下：
1 asmlinkage __visible void __sched schedule(void)
2 {
3 struct task_struct *tsk = current;
4
5 sched_submit_work(tsk);
6 __schedule();
7 }
8 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()函数来完成进程调度，接下来就来看看进程调度的代码以及实现过程吧。
1 asmlinkage __visible void __sched schedule(void)
2 {
3 struct task_struct *tsk = current;
4
5 sched_submit_work(tsk);
6 __schedule();
7 }
8 EXPORT_SYMBOL(schedule);
第3行获取当前进程描述符指针，存放在本地变量tsk中。第6行调用__schedule()，代码如下（kernel/sched/core.c）：
1 static void __sched __schedule(void)
2 {
3 struct task_struct *prev, *next;
4 unsigned long *switch_count;
5 struct rq *rq;
6 int cpu;
7
8 need_resched:
9 preempt_disable();
10 cpu = smp_processor_id();
11 rq = cpu_rq(cpu);
12 rcu_note_context_switch(cpu);
13 prev = rq->curr;
14
15 schedule_debug(prev);
16
17 if (sched_feat(HRTICK))
18 hrtick_clear(rq);
19
20 /*
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 */
25 smp_mb__before_spinlock();
26 raw_spin_lock_irq(&rq->lock);
27
28 switch_count = &prev->nivcsw;
29 if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) {
30 if (unlikely(signal_pending_state(prev->state, prev))) {
31 prev->state = TASK_RUNNING;
32 } else {
33 deactivate_task(rq, prev, DEQUEUE_SLEEP);
34 prev->on_rq = 0;
35
36 /*
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 */
41 if (prev->flags & PF_WQ_WORKER) {
42 struct task_struct *to_wakeup;
43
44 to_wakeup = wq_worker_sleeping(prev, cpu);
45 if (to_wakeup)
46 try_to_wake_up_local(to_wakeup);
47 }
48 }
49 switch_count = &prev->nvcsw;
50 }
51
52 if (prev->on_rq || rq->skip_clock_update < 0)
53 update_rq_clock(rq);
54
55 next = pick_next_task(rq, prev);
56 clear_tsk_need_resched(prev);
57 clear_preempt_need_resched();
58 rq->skip_clock_update = 0;
59
60 if (likely(prev != next)) {
61 rq->nr_switches++;
62 rq->curr = next;
63 ++*switch_count;
64
65 context_switch(rq, prev, next); /* unlocks the rq */
66 /*
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 */
72 cpu = smp_processor_id();
73 rq = cpu_rq(cpu);
74 } else
75 raw_spin_unlock_irq(&rq->lock);
76
77 post_schedule(rq);
78
79 sched_preempt_enable_no_resched();
80 if (need_resched())
81 goto need_resched;
82 }
static void __sched __schedule(void)
第9行禁止内核抢占。第10行获取当前的cpu号。第11行获取当前cpu的进程运行队列。第13行将当前进程的描述符指针保存在prev变量中。第55行将下一个被调度的进程描述符指针存放在next变量中。第56行清除当前进程的内核抢占标记。第60行判断当前进程和下一个调度的是不是同一个进程，如果不是的话，就要进行调度。第65行，对当前进程和下一个进程的上下文进行切换（调度之前要先切换上下文）。下面看看该函数（kernel/sched/core.c）：
1 context_switch(struct rq *rq, struct task_struct *prev,
2 struct task_struct *next)
3 {
4 struct mm_struct *mm, *oldmm;
5
6 prepare_task_switch(rq, prev, next);
7
8 mm = next->mm;
9 oldmm = prev->active_mm;
10 /*
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 */
15 arch_start_context_switch(prev);
16
17 if (!mm) {
18 next->active_mm = oldmm;
19 atomic_inc(&oldmm->mm_count);
20 enter_lazy_tlb(oldmm, next);
21 } else
22 switch_mm(oldmm, mm, next);
23
24 if (!prev->mm) {
25 prev->active_mm = NULL;
26 rq->prev_mm = oldmm;
27 }
28 /*
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 */
34 #ifndef __ARCH_WANT_UNLOCKED_CTXSW
35 spin_release(&rq->lock.dep_map, 1, _THIS_IP_);
36 #endif
37
38 context_tracking_task_switch(prev, next);
39 /* Here we just switch the register state and the stack. */
40 switch_to(prev, next, prev);
41
42 barrier();
43 /*
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 */
48 finish_task_switch(this_rq(), prev);
49 }
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）：
1 __visible __notrace_funcgraph struct task_struct *
2 __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
3 {
4 struct thread_struct *prev = &prev_p->thread,
5 *next = &next_p->thread;
6 int cpu = smp_processor_id();
7 struct tss_struct *tss = &per_cpu(init_tss, cpu);
8 fpu_switch_t fpu;
9
10 /* never put a printk in __switch_to... printk() calls wake_up*() indirectly */
11
12 fpu = switch_fpu_prepare(prev_p, next_p, cpu);
13
14 /*
15 * Reload esp0.
16 */
17 load_sp0(tss, next);
18
19 /*
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 */
29 lazy_save_gs(prev->gs);
30
31 /*
32 * Load the per-thread Thread-Local Storage descriptor.
33 */
34 load_TLS(next, cpu);
35
36 /*
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 */
42 if (get_kernel_rpl() && unlikely(prev->iopl != next->iopl))
43 set_iopl_mask(next->iopl);
44
45 /*
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 */
50 task_thread_info(prev_p)->saved_preempt_count = this_cpu_read(__preempt_count);
51 this_cpu_write(__preempt_count, task_thread_info(next_p)->saved_preempt_count);
52
53 /*
54 * Now maybe handle debug registers and/or IO bitmaps
55 */
56 if (unlikely(task_thread_info(prev_p)->flags & _TIF_WORK_CTXSW_PREV ||
57 task_thread_info(next_p)->flags & _TIF_WORK_CTXSW_NEXT))
58 __switch_to_xtra(prev_p, next_p, tss);
59
60 /*
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 */
67 arch_end_context_switch(next_p);
68
69 this_cpu_write(kernel_stack,
70 (unsigned long)task_stack_page(next_p) +
71 THREAD_SIZE - KERNEL_STACK_OFFSET);
72
73 /*
74 * Restore %gs if needed (which is common)
75 */
76 if (prev->gs | next->gs)
77 lazy_load_gs(next->gs);
78
79 switch_fpu_finish(next_p, fpu);
80
81 this_cpu_write(current_task, next_p);
82
83 return prev_p;
84 }
__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.参考资料
源码地址（https://elixir.bootlin.com/linux/v4.6/source）
脚本之家（http://www.jb51.net/）
CSDN博客（https://blog.csdn.net/）
百度知道（https://zhidao.baidu.com/）
原文地址：https://www.cnblogs.com/maishistar/p/8974598.html