linux内核设计与实现

一. linux内核简介

1. linux简介

1.1 unix的特色

• unix很简洁，仅提供几百个系统调用，并有很是明确的设计目的
• unix全部东西都看成文件对待，这种抽象使对数据和设备都经过一套相同的系统调用接口进行
• 内核用C语言编写，移植能力很强
• 进程建立迅速，独特的fork调用
• 提供了简洁可是稳定的进程间通信原语

1.2 unix和linux

• linux克隆unix，但不是unix
• linux借鉴了unix不少的设计，而且实现了 unix的api
• linux没有直接使用unix的源代码，但完整表达了unix的设计目标并保证编程接口一致

2. 操做系统和内核简介

• 内核通常包括：
  • 中断服务程序：负责响应中断
  • 调度程序：管理多进程，分配处理器时间
  • 内存管理程序：管理内存空间
  • 系统服务程序：包括网络，进程间通信
• 应用程序经过系统调用和内核通信来运行
• 应用程序一般调用库函数，库函数经过系统调用让内核带其完成各类任务
• 内核对硬件设备的管理：硬件想要通信时，发送异步信号去打断内核，内核经过中断号查找处理程序
• linux内核开发的特定
  • 不能连接标准c函数库。c库太大了，会影响大小和效率。不过大部分经常使用的c函数在内核中都有实现
  • 没有内存保护机制，要注意非法访问内存地址
  • 不要轻易使用浮点数，要人工保存和恢复浮点寄存器
  • 栈空间很小且固定。32为机器为8kb，64为16kb
  • 内核很容易产生竞争条件，注意同步和并发
  • 注意可移植性

二. 进程管理

1. 基本概念

• unix系统的两大抽象对象：进程，文件。具体可参考另外三篇关于unix进程和文件的文章序列
• 进程是处于执行期的程序，linux一般也把进程叫作任务
• 进程包括：代码段，数据段，打开的文件，挂起的信号，地址空间，线程等
• 线程是进程中活动的执行对象
• 每一个线程拥有独立的程序计数器，进程栈和一组进程寄存器
• 内核调度的对象是线程，而不是进程
• linux的线程实现很是特别，并不特别区分线程和进程
• 进程提供两种虚拟机制：虚拟处理器和虚拟内存
• 同一个进程内的线程能够共享虚拟内存，可是有各自的虚拟处理器

2. 进程描述符及任务队列

2.1 基本概念

• 内核把进程存放在叫作任务队列的双向循环链表中
• 链表中每一项都是task_struct类型，称为进程描述符，包括一个进程的全部信息。路径：/include/linux/sched.h

  

2.2 进程描述符如何分配

• linux经过slab分配其分配task_struct结构，这样能达到对象复用和缓存着色
• 经过预先分配和重复使用task_struct，避免动态分配和释放带来的性能损耗，这也是为何建立进程快的缘由
• task_struct放在内核栈的尾端，为了让寄存器少的硬件体系只经过栈指针就能算出位置，避免使用额外寄存器存储
• slab分配器在内核栈的尾部建立新的struct thread_info，内部的task指向实际的task_struct。thread_info位置：<asm/thread_info.h>

  

2.3 进程描述符存放在哪

• current宏能够查找当前正在运行进程的进程描述符
• 这个宏的具体实现根据各自硬件体系结构有所不一样
• x86体系，经过栈尾部的thread_info结构的task指针找到进程描述符
• 有的体系（IBM的RISC），分配一个专用的寄存器存放task_struct的地址

2.4 进程的状态

• 进程描述符的state字段描述了进程当前的状态，每一个进程都处于五种状态的一种
  • TASK_RUNNING：运行。进程是可执行的。
  • TASK_INTERRUPTIBLE：可中断。进程被阻塞，等待被唤醒
  • TASK_UNINTERRUPTIBLE：不可中断。收到信号不作任何响应。ps命令查看会显示D
  • TASK_ZOMBIE：僵死。进程已经结束了，可是父进程尚未调用wait4系统调用
  • TASK_STOPPED：中止。进程中止执行
• 状态变迁图

  

• 设置当前进程：set_task_state（task，state）或set_current_state

2.5 进程上下文

• 通常程序在用户空间执行，执行系统调用或触发异常时，进入内核空间，内核表明进程执行，并处于进程上下文中
• 系统调用和异常处理是内核明肯定义的接口，对内核的全部访问也只能经过这些接口
• linux进程有明显的继承关系，全部的进程都是pid为1的init进程的后代
• 系统中的每一个进程必有一个父进程，每一个进程能够拥有一个或多个子进程
• 进程间关系存放在进程描述符中。task_struct中的parent变量，指向一个task_struct，存放父进程地址。children变量是一个链表，指向全部的子进程

3. 进程建立

3.1 基本概念

• unix进程建立分为：fork和exec两步
• fork经过拷贝当前进程建立子进程。子进程和父进程仅有不多差别：pid，ppid，某些资源和统计量
• exec负责读取可执行文件并载入地址空间开始运行

3.2 写时拷贝（COW）

• 传统的fork直接拷贝资源效率低下，linux使用写时拷贝（copy on write）技术提升效率
• COW并不会复制整个地址空间，而是让父子进程以只读方式共享内存，数据的复制只有在写入时才进行

3.3 fork函数

• linux经过clone()系统调用实现fork(), 这个调用经过参数标识（不少种类型）指明须要共享的资源
• clone内部调用do_fork完成主要工做(kernel/fork.c)
• do_fork内部调用copy_process，而后让进程运行
• copy_process调用过程：
  • 调用dup_task_struct为新进程建立内核栈，thread_info结构和task_struct，这些值与当前进程相同，此时描述符彻底相同
  • 检查系统拥有的进程数是否超过限制
  • 将不少成员重置
  • 设置状态为TASK_UNINTERRUPTIBLE保证不会被运行
  • 调用copy_flags以更新task_struct的flags成员
  • 调用get_pid获取新的pid
  • 根据参数标识，拷贝或共享打开的文件，文件系统信息，信号处理函数，进程地址空间，命名空间等。通常状况下，这些资源是线程共享的
  • 父子进程平分时间片
  • 扫尾工做，并返回指向子进程的指针
• 新建立的进程被唤醒并让其投入运行，通常优先子进程首先执行

3.4 vfork函数

• 和fork功能相同，除了补考吧父进程的页表项
• 经过向clone系统调用传递一个特殊标志进行的
• 该函数的设计并非很优良的

4. 线程在linux中的实现

4.1 liunx线程概述

• 一组线程共享进程内的内存地址空间，打开的文件和其余资源
• 线程机制支持并发程序设计技术，多处理器上保证真正的并行处理
• linux实现线程的机制很是独特，从内核角度看，没有线程的概念
• linux把全部线程都当作进程来实现，内核没有特别的调度算法或数据结构来表征线程，被视为一个使用某些共享资源的进程
• 每一个线程有本身的task_struct，就像一个普通的进程，这个进程和其余进程共享某些资源
• 与其余系统（windows，solaris）实现差别巨大，这些系统内核专门提供线程的支持

4.2 linux线程建立

• 线程的建立和普通进程建立类型，只不过调用clone时须要传递一些参数标志，指明须要共享的资源
• 参数标志说明：
  • CLONE_VM：父子进程共享地址空间
  • CLONE_SIGHAND：父子进程共享信号处理函数
  • CLONE_THREAD：父子进程放入相同线程组
  • CLONE_FS：父子进程共享文件系统信息
  • CLONE_FILES：共享打开的文件 ...

4.3 内核线程

• 内核线程：独立运行在内核空间的标准进程
• 和普通进程的区别：没有独立的地址空间，只能在内核空间运行
• 建立只能由其余内核线程建立，函数为kernel_thread

4.4 进程终结

释放资源

• 进程终结时，内核必须释放它所占有的资源，并通知父进程
• 结束能够是正常，异常，还能够注册终止清理函数，详见另外一篇文章：关于unix进程和文件的文章序列
• 最终结束会调用do_exit（kenel/exit.c），完成的工做包括：
  • 将task_struct的标志成员设置为PF_EXITING
  • 若是进程会计功能开启，会调用acct_process输出统计信息
  • 调用_exit_mm函数放弃进程占用的mm_struct，若是没有被共享就完全释放
  • 调用sem_exit。若是排队等待IPC信号，则离开队列
  • 调用__exit_files:递减文件描述符；__exit_fs:递减文件系统数据；exit_namespace：名字空间引用计数；exit_sighand：信号处理函数引用计数，若是某个降为0，则可释放
  • task_struct的exit_code设置退出代码
  • 调用exit_notify向进程发送信号，父进程修改成其余线程或init进程，进程状态设置为TASK_ZOMBLE（僵死，不被调度）
  • 最后，调用schedule切换到其余进程
• 调用完do_exit，与进程相关的全部资源都被释放了，它所占有的资源只剩报错thread_info的内核栈和保存task_struct的那一小片slab，存在的惟一目的就是向父进程提供信息。

删除进程描述符

• 调用do_exit以后，线程僵死，可是还保留文件描述符
• 父进程获取到子进程的信息后，子进程的task_sturct结构才被释放
• wait函数调用系统函数wait4实现，将挂起调用它的进程，直到其中一个子进程退出，函数返回子进程的pid
• 当最终须要释放进程描述符时，release_task会被调用，执行如下工做：
  • 调用free_uid减小该进程拥有者的进程使用计数
  • 调用unhash_process从pidhash上删除该进程，同时从task_list删除该进程
  • 若是进程正在被ptrace跟踪，将跟踪父进程重置
  • 最后，调用put_task_struct释放内核栈和thread_info结构所占的页，并释放task_struct所占的slab高速缓存
  • 这时资源和描述符就所有被释放掉了

孤儿进程的处理

• 父进程若是在子进程以前退出，必须找到新的父亲，不然永远僵死
• 寻找父亲的函数在do_exit中调用的notify_present函数，内部调用forget_original_parent，该函数实现具体寻找过程
• 该函数设置父亲为线程组内的其余进程，没有就用init进程

三. 进程调度

1. 概述

• 调度程序是内核组成部分，它负责选择下一个要运行的进程
• 调度程序负责给可运行进程分配处理器时间资源
• 多任务系统可分为：抢占式任务（linux等现代操做系统的方式）和非抢占式任务
• 分配给每一个进程的执行时间叫作时间片

2. 调度策略

2.1 cpu密集型和IO密集型

• cpu密集型：大部分时间执行代码
• IO密集型：大部分时间提交io和等待io，常常可运行，但运行时间极短
• 从系统响应速度考虑，linux调度策略更倾向于优先调度IO密集型进程

2.2 进程优先级

• 调度算法中最基本的一类：基于优先级调度，根据进程的价值和其对处理器时间的需求分级的思想
• 调度程序老是选择时间片未用完且优先级最高的进程运行
• linux实现了一种基于动态优先级的调度算法。一开始设置基本优先级，而后根据须要动态加，减优先级：若是一个进程IO等待时间多余运行时间，它属于IO密集型，会提升优先级；相反，若是进程时间片一下就别耗尽，属于cpu密集型，会下降优先级
• linux提供两组独立的优先级范围：
  • nice值：-20～19，默认为0。标准优先级范围。值越大，优先级越低，时间片越短。task_struct的static_prio字段表示
  • 实时优先级：0～99

2.3 时间片

• 代表进程在被抢占以前能持续运行的时间
• 调度策略必须规定默认时间片。若是过长，交互式的响应表现欠佳；若是太短，会明显增大进程切换带来的处理器耗时
• 不少系统默认时间片很短：20ms
• linux提供动态调整优先级和时间片长度的机制，使得调度性能稳定且强健
• 进程不必定要一次用完时间片，可分屡次使用，尽量长时间保证可运行

2.4 进程抢占

• 当一个进程处于TASK_RUNNING状态，内核会检查它的优先级是否高于正在运行的进程，知足的话调度程序被唤醒从新选择进程运行
• 当一个进程的时间片为0，它会被抢占，调度程序能够选择新的进程执行

3. 调度算法

3.1 概述

• linux调度程序定义与kernel/sched.c
• 2.5版本内核重写调度算法，和之前版本区别很大，实现如下目标
  • 充分实现O（1）调度，无论多少进程或什么输入，每一个算法能在恒定时间内完成
  • 每一个处理器拥有本身的锁和本身的可执行队列
  • 尽可能将同一组任务分配给同一个cpu连续执行，减小在cpu间移动进程
  • 增强交互性能，即便系统负载，也保证系统响应
  • 保证公平。消除饥饿线程，减小大量时间片进程

3.2 可执行队列

• 可执行队列数据结构为kernel/sched.c文件下的runqueue
• 表示给定处理器上的可执行进程链表，每一个处理器一个

  

• 可执行队列是调度程序核心的数据结构，提供不少宏获取该指针
  • cpu_rq（processor）：返回给定处理器可执行队列指针
  • this_rq：当前处理器可执行队列指针
  • task_rq：给定任务所在队列指针
• 对队列进行操做时，须要锁住队列，加锁函数
  • task_rq_lock
  • task_rq_unlock
  • this_rq_lock
  • this_rq_unlock
  • double_rq_lock
  • double_rq_unlock

3.3 优先级数组

• 每一个可执行队列都有两个优先级数组，一个活跃的和一个过时的
• 数据结构为kernel/sched.c文件下的prio_array
• 能提供O(1)级算法复杂度的数据结构
• 优先级数组使可运行处理器的每一种优先级都包含一个相应的队列，该队列包含该优先级上可执行进程链表
• 优先级数组还拥有一个优先级位图，帮助高效查询最高优先级可执行进程

  

• MAX_PRIO：系统拥有的优先级个数，默认140
• BITMAP_SISE：优先级位图数组大小，unsigned long为32位，要表示140个优先级，须要5个长整形，总共160位
• 每一个优先级数组都要包含一个位图成员。开始时，全部位图为0，当某个优先级进程开始执行，相应位图变为1，查找最高优先级就变为查找位图为1的第一个值，查找时间恒定。函数为sched_find_first_bit
• 要查找给定优先级任务，并轮询时，只须要遍历某个优先级链表便可
• nr_active表示优先级数组内可执行进程数目

3.4 从新计算时间片

• 当全部线程时间片用完时，老版本linux采用循环遍历计算的方式从新计算时间片
• 新版本调度程序经过维护两个优先级数组：活动数组和过时数组，过时时间耗尽的线程放入过时数组，异步计算过时数组的时间片。最后只须要交换两个数组便可

3.5 计算优先级和时间片

动态计算优先级

• 静态优先级由用户指定后就不可更改，即前面介绍的nice值
• 动态优先级根据静态优先级和进程交互性函数关系计算而来
• effective_prio函数返回一个进程的动态优先级：该函数以nice值为基数，再根据交互程度加上奖惩值（-5～5）
• 交换程度判断：计算进程执行时间和休眠时间。task_struct的sleep_avg变量，默认为10ms，休眠时增长该值（休眠时长），运行时减小该值

动态计算时间片

• 进程建立时，父子进程平分时间片。防止建立多个进程以抢占更多cpu时间
• 任务时间片用完时，根据任务的动态优先级计算时间片。函数为task_timeslice。时间值根据优先级值按比例缩放。最高200ms，最低10ms，默认为100ms
• 若是一个交互性很强的进程（TASK_INTER_ACTIVE宏），时间片用完后，会被再次放入活动数组而不是过时数组。避免出现须要交互却由于没有等到两个数组交换而执行不了。实现代码：scheduler_tick函数

3.6 睡眠和唤醒

• 处于休眠的线程进入等待队列，里面保存全部因等待某些事件发生的进程组成的简单链表
• 等待队列的数据结构为wake_queue_head_t
• 等待队列的建立：DECLEAR_WAITQUEUE或init_waitqueue_head
• 加入等待队列：add_wait_queue
• 与等待队列相关的事件发生时，队列的进程会被唤醒，使用wake_up函数

3.7 负载平衡程序

• 负载平衡程序针对多处理器系统中可执行程序负载不均衡的状况
• 函数为kernel/sched.c中的load_balance函数
• 调用时机：可执行队列为空时，定时调用（系统空闲时每隔1ms调用，其余状况每隔200ms调用）。单处理器不须要此函数。
• 负载平衡调用时须要锁定当前队列，而且屏蔽中断
• load_balance操做步骤：
  • 调用find_busiest_queue，找到最繁忙的队列。该队列进程数最多。若是没有超过当前队列25%的队列，直接结束返回
  • 从繁忙队列中选择一个优先级数组用来抽取进程，最好是过时数组
  • 寻址含有优先级最高（值最小）的链表，把高优先级的进程分散开
  • 找到链表中没有在执行，且可移动，且不在高速缓存中的进程，靠用pull_task将进程抽取到当前队列
  • 只要队列不平衡就执行以上步骤。最后释放锁。

4. 抢占和上下文切换

4.1 概述

• 上下文切换是从一个进程切换到另外一个进程。
• 上下文切换定义在kernel/sched.c中的context_switch函数，该函数完成两项基本工做
  • 调用定义在include/asm/menu_context.h中的switch_mm，负责把虚拟内存从上一个进程映射切换到新进程中
  • 调用定义在include/asm/system.h中的switch_to，负责从上一个进程的处理器状态切换到新进程的处理器状态。包括保存，恢复栈信息和寄存器信息
• 内核提供need_resched标志代表是否须要从新调度。某个进程用尽时间片时，schedular_tick会设置该标志；当一个高优先级进程进入可执行状态时，try_to_wake_up也会设置该标志
• 每一个进程都包含need_resched标志

4.2 用户抢占

• 用户抢占：内核返回用户空间时，若是need_reshed被设置，致使调用schedule，会选择一个更合适的进程执行的状况
• 用户抢占在如下状况时发生：
  • 从系统调用返回用户空间
  • 从中断处理程序返回用户空间

4.3 内核抢占

• 大部分Unix其余变体和大部分操做系统，不支持内核抢占，内核代码须要一直执行直到完成
• 2.6版本内核中，添加了内核抢占。只要从新调度是安全的，就能够内核抢占
• 只要没有持有锁，从新调度就是安全的，能够内核抢占
• 持有锁使用thread_info中的preempt_count计数器表示，使用锁时数值加一，释放锁时数值减一
• 内核抢占在如下状况时发生：
  • 从中断处理程序返回内核空间时
  • 当内核代码再一次具备可抢占性时
  • 内核中的任务显示调用schedule
  • 内核中的任务阻塞

5. 与调度相关的系统调用

• sched_setscheduler：设置task_struct的policy和rt_priority值
• sched_setaffinity：设置task_struct的cpus_allowed这个位掩码标志
• sched_yield：将进程从活动队列移动到过时队列，以让出执行时间

四. 系统调用

1. 概述

• 系统调用提供内核和应用程序交互的接口

  

• 系统调用内部，函数声明中要添加asmlinkage，通知编译期仅从栈中提取函数参数
• 系统调用在内核中均以sys_做为前缀
• linux中每一个系统调用都和一个独一无二的系统调用号关联
• 内核记录系统调用表全部已注册过的系统调用列表，存储在sys_call——table中，以体系结构有关
• linux内核设计优化简洁，上下文切换时间极快，操做系统执行效率高

2. 系统调用处理程序

• 用户程序不能直接调用内核函数，以防止内核空间安全失控。而是经过中断通知内核，让内核表明程序去执行
• 触发软中断前，将调用号装入eax寄存器

  

• 参数传递：在x86系统上，ebx、ecx、edx、esi、edi按照顺序存放前五个参数。返回值经过eax寄存器返回
• 内核空间和用户空间数据拷贝函数：copy_to_user，copy_from_user

3. 系统调用上下文

• current指针指向引起当前调用的进程
• 执行系统调用时处于进程上下文
• 进程上下文中，内核能够休眠（调用阻塞或schedule）并能够被抢占

4. 系统调用的实现

• linux不提倡多用途的系统调用，每一个系统调用都应该有明确的用途
• 接口应该尽可能简洁，参数少。力求稳定不作改动
• 尽可能为未来作考虑，尽可能通用，不要作限制。“提供机制而不是策略”
• 编写完后要注册到内核，成为真正可用的系统调用
  • 在系统调用最好加入一个表项。大部分位于entry.s文件中。全部支持系统调用的硬件体系都要作
  • 定义系统调用号到include/asm/unist.h文件中
  • 函数放入kernel文件下某个位置，使之编译进内核映像（不能被编译称模块）
• 用户空间如何访问注册的系统调用
  • 一般状况下，用户经过包含标准头文件，并和底层系统调用具体的c实现连接，就可使用系统调用
  • 自定义系统调用在标志头文件中不存在，能够经过linux提供的宏来调用：_syscalln,n表明须要传递的参数。该宏有2+2n个参数，第一个表明返回值类型，第二个表明函数名称，后续的是n个参数类型和参数名称
  • 好比：open函数的系统调用，系统调用号为_NR_open,定义在<asm/unistd.h>中，内部被_syscall3宏实现，调用open时，内部把宏直接放入应用程序代码中

五. 中断和中断处理程序

1. 中断

• 中断用于解决计算机处理器与硬件设备处理速度不匹配的问题，硬件处理好任务后主动发送信号给处理器
• 中断本质是电信号，由硬件设备产生，送入中断处理器的输入引脚上。再由中断控制器向处理器发送信号。处理器收到信号就中断工做去处理中断
• 每一个中断都有惟一都数字标识，称为中断请求（IRQ）线。好比：IRQ0是时钟中断，IRQ1是键盘中断

2. 中断处理程序

• 响应特定中断时，会执行的函数为中断处理程序或中断服务例程
• 中断处理程序是设备驱动程序的一部分，设备驱动程序是用于对设备进行管理的内核代码
• 与内核函数的区别：中断处理程序是被内核调用来响应中断的，运行与中断上下文中
• 中断处理程序必须能快速执行，同时，咱们要靠它完成大量的其余工做。这两个目的是矛盾的。
• 为了解决上述矛盾，将中断处理程序切分为两个半部
  • 上半部：接收到请求就当即执行，但执行少部分工做。中断应答和硬件复位
  • 下半部：中断处理程序返回时当即执行

3. 注册中断处理程序

• irq：要分配的中断号
• handler：实际中断处理程序。接受三个参数，返回irqreturn_t类型参数
• irqflags：能够为0，或如下标识的位掩码
  • SA_INTERRUPT：代表是快速中断程序。主要用于时钟中断程序
  • SA_SAMPLE_RANDOM
  • SA_SHIRQ：共享中断线
• devname：中断相关设备的Ascii文本名称，如键盘中段为“keyboard”
• dev_id：用于共享中断线
• 该函数可能会休眠，不能在中断上下文或不容许阻塞的代码中调用

4. 中断处理机制

• 设备产生中断，把电信号发送给中断控制器
• 中断控制器把信号发给处理器
• 处理器中断程序，跳到内存中预约义的位置执行。就是中断程序入口点
• 内核调用do_IRQ，对中断进行应答
• 相关函数位于arch/i386/kernel/entry.s，arch/i386/kernel/irq.c

5 中断控制

• linux提供一组接口用于操做机器上的中断状态，提供可以禁止中断系统或屏蔽中断线的功能
• 相关代码在<asm/system.h>, <asm/irq.h>中
• 中断控制的根源是提供同步，经过禁止中断，确保中断程序不会抢占当前代码，也能够禁止内核抢占
• 禁止和激活当前处理器中断：local_irq_disable，local_irq_enable
• 禁止（屏蔽）指定中断线： disable_irq，disable_irq_nosync，enable_irq，synchronize_irq
• 获取中断系统状态：asm/system.h中的irqs_disable
• 判断是否处于中断上下文中：asm/hardirq.h中的in_interrupt

六. 内核同步

1. 基本概念

• 临界区：访问和操做共享数据的代码段
• 竞争条件：多个执行线程处于同一个临界区
• 同步：避免并发和防止竞争条件
• 为何须要同步：用户程序会被调度程序抢占和从新调度
• 形成并发的缘由有：
  • 中断
  • 内核抢占
  • 睡眠及用户空间的同步
  • 多处理器
• 同步问题的解决：加锁
• 什么数据须要加锁
  • 内核全局变量
  • 共享数据
• 死锁；全部线程都在等待对方释放锁，任何线程都没法继续进行

2. 内核同步方法

2.1 原子操做

• 原子操做保证指令以原子方式执行
• 原子操做一般是内联函数，经过内嵌汇编指令完成
• 原子操做比其余同步方法给系统的开销小
• linux内核提供对整数和单独对位进行的原子操做
• 整数原子操做相关函数为asm/atomic.h文件中
• 位原子操做相关函数为asm/bitops.h

2.2 自旋锁

• 自旋锁（spin lock）最多只能被一个可执行线程持有。若是锁未被占用，线程马上能够获得。若是被占用，会一直循环等待锁可用。
• 自旋锁可用于防止多个线程同时进入临界区
• 自旋时特别浪费cpu，因此不该该被长时间持有
• 接口定义在<linux/spinlock.h>,具体与体系结构相关的实如今<asm/spinlock.h>
• linux中自旋锁不可用递归
• 自旋锁的使用

  spinlock_t mr_lock = SPIN_LOCK_UNLOCKED;
  //普通请求锁
  spin_lock(&mr_lock);
  //禁止中断请求锁
  spin_lock_irqsave(&mr_lock);
  //确保中断是激活的状况可用的方法
  spin_lock_irq(&mr_lock)
  /**临界区**/
  spin_unlock_irq(&mr_lock)
  spin_unlock_irqrestore(&mr_lock);
  spin_unlock(&mr_lock)
  复制代码

• 自旋锁能够用在中断处理程序中（信号量不行，会致使休眠）,在使用锁以前，要禁止本地中断，不然会致使死锁

2.3 读写自旋锁

• 锁用途能够明确分为读锁和写锁。
• 一个或多个读任务能够并发的持有读者锁
• 用于写的锁只能被一个写任务持有，且此时不能并发读
• 读写锁使用

  rwlock_t mr_rwlock = RW_LOCK_UNLOCKED;
  read_lock(&mr_rwlock);
  /**只读临界区**/
  read_unlock(&mr_rwlock)
  
  write_lock(&mr_rwlock)
  /**读写临界区**/
  write_unlock(&mr_rwlock)
  复制代码

• 不能把读锁升级为写锁，会致使死锁

2.4 信号量

• 信号量是一种睡眠锁
• 同一时刻容许任意数量的锁持有者
• 信号量数量为1时，称为二值信号量或互斥信号量
• 若是一个任务试图获取被占用的信号量，信号量会将其推入等待队列，让其睡眠。当持有信号量的进程释放后，等待的任务被唤醒，得到信号量
• 信号量的特色
  • 适合锁会被长时间持有的状况
  • 锁被短期持有，睡眠耗时可能比所有时间还长
  • 会睡眠，不能在中断中调用
  • 占有信号量时不能占用自旋锁。自旋锁不容许休眠
• 信号量支持两个原子操做P和V，荷兰语的探查和增长
• 信号量相关文件：<asm/semaphore.h>
• 使用信号量

  //声明信号量
  static DECLARE_SEMAPHORE_GENERIC(name, count);
  //声明互斥量
  static DECLARE_MUTET(name);
  
  //以指针方式初始化信号量
  sema_init(sem, count);
  //以指针方式初始化互斥量
  init_MUTET(sem);
  
  //试图得到信号量
  down_interruptible(&name)
  //释放信号量
  up(&name)
  复制代码

2.5 读写信号量

• 与读写锁同样
• 相关文件：<linux/rwsem.h>

2.6 彻底变量

• 提供代替信号量的简单解决方法
• 相关文件：<linux/completion>

2.7 Seq锁

• 提供一种简单的机制，用于读写共享数据
• 内部实现主要一个序列计数器
• 锁的初始化为0，写数据时，会获得锁，且序列值增长。读数据以前和以后，序列号被读取，若是相同则没有被打断，若是为偶数则没有写操做发生

2.8 屏障

• 屏障（barriers）能够确保指令顺序执行，禁止指令重排序
• 重排序是由于现代处理器为了优化其传送管道，打乱了分派和提交指令的顺序
• rmb方法提供“读”内存屏障，rmb前面的载入操做不会排在rmb以后，反之亦然
• wmb方法提供“写”内存屏障，wmb前面的存储操做不会排在wmb以后。
• mb方法提供了“读写”屏障

七. 内存管理

1. 内核对内存的管理

1.1 页

• 内核把物理页做为内存管理的基本单元。
• 内存管理单元：MMU，管理内存，并把虚拟地址转换为物理地址的硬件
• 页大小跟体系结构不一样而不一样，大多数32为体系支持4KB的页，64位体系支持8KB的页
• 物理页的数据结构位于<linux/mm.h>中的struct page。page与物理页相关，而不是虚拟页

  sturct page{
     unsigned long                flags; // 页的状态，是否脏，是否被锁定。可表示32种状态。定义与<linux/page-flags.h>
     atomic_t                     count; // 页的引用计数，被使用了多少次。为0时，新的分配就可使用它 
     struct list_head list;
     struct address_space *mapping; //指向与该页有关的address_space对象
     unsigned long                index; 
     struct list_head lru;
     union{
         struct pte_chain *chain;
         pte_addr_t   direct;
     }pte;
     unsigned long                private;
     void                         *virtual; //页虚拟地址，虚拟内存地址
  }
  复制代码

1.2 区

• 因为硬件限制，有些页位于内存中特定的物理地址上，不能用于特定的任务，因此把也划分为不一样的区（zones）。
• 区对有类似特性的页进行分组。区的划分没有任何物理意义，仅仅是为了管理页采起的逻辑分组
• linux使用三种区：
  • ZONE_DMA：能执行DMA（直接内存访问）的区
  • ZONE_NORMAL：能正常映射的区
  • ZONE_HIGHEM：不能永久映射到内核地址空间的“高端内存”
• 区的数据结构位于<linux/mmzone.h>的struct zone

2. 页相关接口

• 内核提供了一种请求内存的底层机制，提供了访问接口，接口都以页为端午分配内存，定义与<linx/gfp.h>中

  // 分配2^order个连续的物理页，并返回指针
  struct page* alloc_pages(unsigned int gfp_mask, unsigned int order) // 将页转换为逻辑地址,页是连续的，其余页紧随其后 unsigned long __get_free_pages(unsigned int gfp_mask, unsigned int order) // 只获取一页，高端地址分配须要使用此函数 struct page* alloc_page(unsigned int gfp_mask) unsigned long get_free_page(unsigned int gfp_mask) //获取填充内容为0的页 unsigned long get_zeroed_page(unsigned int gfp_mask) //释放页 void __free_pages(struct page *page, unsigned int order) void free_pages(unsigned long addr, unsigned int order) void free_page(unsigned int order) // 与用户空间的malloc函数相似，最通用的接口。提供用于得到以字节为单位的一块内核内存 // 定义与<linux/slab.h>中 void *kmalloc(size_t siez, int flags) // kmalloc相反函数，释放空间 void kfree(const void *ptr) // 确保分配的页在物理地址上是连续的 // 定义与<linux/vmalloc.h> void* vmalloc(unsigned long size) //释放空间 void vfree(void *addr) 复制代码

• gfp_mask标志，在<linx/gfp.h>中，分为三类：行为修饰符，区修饰符和类型
  • 行为修饰符：内核如何分配所需的内存
  • 区修饰符：从哪儿分配内存
  • 类型：组合了行为修饰符和区修饰符

3. slab

• slab提供通用数据结构缓存层的角色，slab会给每一个处理器维持一个对象告诉缓存（空闲链表）
• 适用于须要建立和销毁很大的数据结构
• slab层把不一样的对象划分为所谓告诉缓存组，每一个告诉缓存都存放不一样类型的对象（每种对象类型对应一个高速缓存）
• 每一个slab处于三种状态之一：慢，部分或空
• 多个salb组成一个高速缓存，各类数据结构：
  • slab的：struct slab
  • 高速缓存：kmem_cache_s
  • 满链表：slabs_full
  • 部分链表：slabs_partial
  • 空链表：slabs_empty

4. 高端内存的映射

• 高端内存的页不能永久映射到内核地址空间中，因此某种标志得到的页不可能有逻辑地址
• x86系统上，高端内存中的页被映射到3GB-4GB的逻辑地址
• 映射相关接口：

  //映射一个给定的page结构到内核地址空间：
  void kmap(sturct page *page) //解除映射关系 void kunmap(struct page* page) //临时映射 void *kmap_atomic(sturct page *page, enum km_type type) 复制代码

八. 虚拟文件系统

1. 基本概念

• 虚拟文件系统：VFS，提供文件系统接口。经过VFS，能够利用标准的unix文件系统调用堆不一样介质的不一样文件进行操做
• linux支持至关多的文件系统（超过50种）：
  • 本地文件系统： ext2, ext3
  • 网络文件系统：NFS，Coda
• VFS中有四个主要的对象类型
  • 超级快对象，表明一个已安装文件系统
  • 索引节点对象，表明一个文件
  • 目录项对象，表明一个目录项
  • 文件对象，表明由进程打开的文件

2. 超级块对象

• 各类文件系统都必须实现超级块，该对象用于存储特定文件系统的信息，一般对应于存放在磁盘特定扇区中的文件系统控制块
• 超级块数据结构定义与<linux/fs.h>中的super_block。
• 超级块中的s_op指向超级快的操做函数表，由super_operation结构体表示。文件系统对超级块操做时，会找到相应的操做方法
• 也就是不一样的文件系统的信息，经过往super_operation中注册本身的针对文件系统操做的方法，提供给VFS使用
• 超级快相关代码位于<fs/super.c>中

3. 索引节点对象

• 索引节点对象包含了内核在操做文件或目录时须要的所有信息
• 索引节点对象数据结构位于<linux/fs.h>中的struct inode
• 表明了文件系统中的一个文件（包括普通文件，管道等等）
• 索引节点中的inode_operations项也很是重要，定义了操做索引节点对象的全部方法

4. 目录项对象

• 目录项包括执行目录相关的操做，好比路径名查找等
• 目录项数据结构位于<linux/dcache.h>中的struct dentry
• 目录项状态包括：被使用，未被使用和负状态
• 目录项还包括目录项缓存，包括：
  • 被使用的目录项链表
  • 最近被使用的双向链表
  • 哈希表和相应的哈希函数用来快速将给定路径解析为相关目录项对象
• 目录项操做定义在dentry_operation结构体中，位于<linux/dcache.h>

5. 文件对象

• 文件对象定义与<linux/fs.h>中的struct file结构体
• 文件操做由file_operations结构体表示
• 具体的文件系统定义不一样的实现

6. 其余数据结构

• 与文件系统相关的数据结构：struct file_system_type，描述特定文件系统类型，如ext3或XFS
• 安装文件系统的实例：vfsmount，<linux/mount.h>
• 进程描述符的files指向的数据，包含进程相关的打开的文件及文件描述符的等信息：struct files_struct，<linux/file.h>
• 进程描述符的fs指向的数据，包含文件系统和进程信息：struct fs_struct, <linx/fs_struct.h>
• 进程描述符的namespace指向的数据，包含命名空间信息：struct namespace, <linx/namespace.h>

九. 块IO层

1. 基本概念

• 基本设备类型包括：块设备，字符设备。区别在因而否能够被随机访问
• 块设备中最小的可寻址单元是扇区，扇区大小通常是2的整数倍，最多见的大小是512字节
• 物理磁盘按扇区寻址，文件系统按块进行访问，块是较高层次的抽象
• 块包含一个或多个扇区，但大小不超过一页
• 块调入内存时，须要先加载到缓冲区，每一个缓冲区与一个块对应
• 每一个缓冲区有一个描述符，用buffer_head结构表示，称为缓冲区头。在文件<linux/buffer_head.h>中。包括缓冲区状态，使用计数，逻辑块号，物理页，块大小等信息

2. bio

• 目前内核中块IO操做基本容器由bio结构表示，位于<linux/bio.h>

  

3. io调度程序

十. 进程地址空间

1. 基本概念

• 每一个进程都有惟一的地址空间，彼此之间互不干扰
• 进程只能访问有效范围内的内存地址
• 内存区域包含各类内存对象，包括：
  • 代码段：可执行文件代码的内存映射
  • 数据段：已初始化全局变量的内存映射
  • BSS段：未初始化全局变量
  • 其余

2. 内存描述符

• 内核使用内存描述符表示进程的地址空间
• 内存描述符数据结构位于<linux/sched.h>中的mm_struct
• 内部的mmap和mm_rb两个数据结构表示的内容同样，此处作了冗余。前者为链表，便于高效遍历全部；后者为红黑树，便于高效搜索
• 锁都有的mm_struct都经过自身的mmlist连接在一个双向链表中，首元素的init进程，init_mm描述符。操做链表时，要用mmlist_lock加锁，锁位于<kernel/fork.c>
• 进程描述符中的mm字段存放内存描述符
• 分配内存描述符：copy_mm，内部调用allocate_mm宏从mm_cachep slab缓存分配
• 内核线程没有进程地址空间，mm字段为空

3. 内存区域

• 内存区域由vm_area_struct表示，定义在<linux/mm.h>中，也称虚拟内存区域
• vm_area_struct描述了指定地址空间内连续空间上的一个独立内存范围
• vma包括不少标志位，标志了所含页面的行为和信息
  • VM_READ：页面读权限
  • VM_WRITE：页面写权限
  • VM_EXEC：页面可执行权限
• vm_area_struct结构体的vm_ops指向与指定内存区域相关的操做函数表，由vm_operations_struct表示

十一. 页高速缓存和页回写

1. 基本概念

• 页高速缓存是linux实现的一种磁盘缓存，主要用来减小对磁盘的io操做
• 经过把磁盘中的数据缓存到物理内存中，把对磁盘的访问变为对物理内存的访问
• 磁盘高速缓存的意义：
  • 加快访问速度，内存速度大于磁盘
  • 临时局部原理：数据一旦被访问，颇有可能在短时间内再次被访问
• 执行io操做前，内核会检查数据是否已经在页高速缓存中，若是在就能够立马返回

2. 页高速缓存数据结构

• 页高速缓存使用address_space结构体描述页高速缓存中的页面，定义与<linux/fs.h>中
• 内部的a_ops指向地址空间对象中的操做函数表，由address_space_operations结构体表示
• 检查页是否在高速缓存中操做必须高效，每一个address_struct提供的基树（radix tree），page_tree的二叉树，记录了文件偏移量。以达到快速检索的目的。基树代码在<lib/radix-tree.c>

3. 页回写

• pdflush后台例程负责将内存的脏页写回磁盘，写的时机包括
  • 空闲内存低于某个值，以释放内存。阀值可配置
  • 脏页驻留时间超过特定值
  • 周期性回写，防止系统异常数据丢失
• pdflush代码在<mm/pdflush.c>中。回写机制代码在<mm/page-writeback.c>,<fs/fs-writeback.c>

十二. 其余

定时器和时间管理

• 周期性时间由系统定时器驱动，是一种可编程硬件芯片，能以固定频率产生中断（定时器中断）
• 实际时间：定义在<kernel/time.c>中。struct timespec xtime; timespec数据结构定义在文件<linux/time.h>中
• 定时器：定义在<linux/timer.h>中，由结构time_list