linux内核的设计与实现

① linux内核探索

对待知识领域，我们总喜欢去下一个定义。操作系统是我们每天工作都要使用的东西，由于现代商业操作系统的复杂性和没有统一的标准，若对一个操作系统下定义并不能精确的描述操作系统所属领域。根据经验我们可以认为操作系统就是在整个应用系统中负责最基本功能和系统管理的那部分。包括内核、设备驱动程序、启动引导程序、命令行Shell或者GUI界面、基本文件管理工具和系统工具。

严格的来讲linux只是操作系统内核本身，广义上的linux则常用来指基于linux内二的完整的操作系统，它包括GUI组件和其它许多工具。

GUI其实只是操作系统的表象，内核才是操作系统内在的核心。系统的其它部分必须依靠内核所提供的服务，像管理硬件设备、分配系统资源等，内核有时候被称为管理者或者操作系统核心。

通常一个内核由负责响应中断的中断服务程序，负责进程调度的CPU调度程序，负责管理进程地址空间的内存管理程序以及网络、进程间通信等系统服务共同组成的。

内核在有安全机制的操作系统中不同于普通程序，一般处于系统态(内核态)，拥有受保护的内存空间和访问硬件设备的所有权限。这种系统状态和被保护起来的内存空间，统称为 内核空间 。

与内核空间相对的，用户所执行的应用程序在用户空间执行。用户态的应用程序只能访问允许它们使用的系统资源，并且只使用某些特定的系统功能，不能直接访问硬件，也不能访问内核划分给其它应用程序的内存空间。

应用程序通过系统调用来和内核通信，当一个应用程序发起系统调用时，内核便代其执行。在这种情况下应用程序通过系统调用在内核空间运行，而内核被称为运行在进程上下文中。应用程序通过系统调用进入内核空间时应用完成其工作的基本方式。

操作系统内核可分为两大阵营：单内核和微内核。

单内核是一种较为简单的设计，通常以单个静态二进制文件存储在磁盘中，整体上作为一个单独的大过程，所有的内核服务都在这样的一个大内核地址空间上运行。内核服务都处于内核态，并身处同一内核地址空间，之间可以几乎无性能损耗的相互通信。

单内核具有简单和高性能等特点。

微内核根据功能被分割成多个独立的过程，每个过程都叫做一个服务器。所有的服务器都运行在各自的地址空间上（大部分处于用户空间），只有强烈请求特权服务的服务器才运行在特权模式下。

微内核服务器之间不能直接调用函数通信，而是通过 消息传递 通信。系统采用进程间通信(IPC)机制，服务之间各自独立，通过IPC互换消息，有效的避免了服务之间的失败传染。

IPC机制的开销远高于函数调用，而且在运行时还会牵扯到内核空间和用户空间上下文切换，所以消息传递需要一些开销。所以在内核的实际实现上大部分微内核的操作系统也会让大部分的服务放置与内核中，这样就可以直接调用函数，消除消息传递的开销。

windows NT和Mach(Mac OS X)都是典型的微内核，不过在实际实现上，其所有服务都运行在内核空间。

linux是一个单内核，不过linux汲取了微内核的精华，并拥有模块化设计、抢占式内核、支持内核线程以及动态装载内核模块等特性。

linux内核在设计时充分参考了已有的很多UNIX的内核实现，并且有一些创新方案。linux内核和传统的UNIX系统之间存在一些显着的差异：

本文的写作和学习中参考了以下资料
1.《Linux Kenel Development ~ Thrid Edition 》

② 学习linux内核设计与实现需要哪些基础，看不懂啊！好迷茫。

最早接触inux是看了《linux操作系统实用教程》，98~99年的光景，学习了简单的操作和内核编译，那时候开始注意并学习内核。看的第一本是《Unix环境高级编程》，看了一部分没看完，开始对
if(!(p=fork()))
{
…………
}
else
{
……
}
结构恨意很疑惑，这和一般的应用程序逻辑相背，因此想搞明白内核在干什么，怎么干的。开始买了《操作系统设计与实现》，上下册，下册全是minix操作系统内核代码。它和linux完全不同的，一个是微内核，一个单内核。即便看懂了minix,linux也要从头看起，反之亦然。因此后来没钻进去。我看的第一本Linux内核书是李善平老师的《linux操作系统实验教程》，当时市面上关于内核的书很少，这本是讲2.0.35版的好像，似懂非懂。就开始边看边读源代码，间或看点操作系统原理的书，有不懂得在论坛上提问，这样慢慢琢磨，就有点懂了。现在比当时好多了，很多内核的书，各方面剖析得很详尽。不过要学懂，还是要：1、有好奇心和兴趣 2、看书、读代码，这样能够比较懂。要进一步提高的话还要学会修改内核。有以下书籍可以参考：
1、《linux内核完全剖析》0.11版内核
2、《深入理解linux内核》(1、2、3版) ，3个版本分别对应2.2、2.4、2.6版的内核。
3、《linux内核源代码情景分析》2.4.0版内核
4、《linux内核设计与实现》
5、《linux设备驱动程序》

③ linux内核同步问题

Linux内核设计与实现 十、内核同步方法

手把手教Linux驱动5-自旋锁、信号量、互斥体概述

== 基础概念： ==

并发 ：多个执行单元同时进行或多个执行单元微观串行执行，宏观并行执行

竞态 ：并发的执行单元对共享资源（硬件资源和软件上的全局变量）的访问而导致的竟态状态。

临界资源 ：多个进程访问的资源

临界区 ：多个进程访问的代码段

== 并发场合： ==

1、单CPU之间进程间的并发 :时间片轮转，调度进程。 A进程访问打印机，时间片用完，OS调度B进程访问打印机。

2、单cpu上进程和中断之间并发 ：CPU必须停止当前进程的执行中断;

3、多cpu之间

4、单CPU上中断之间的并发

== 使用偏向： ==

==信号量用于进程之间的同步，进程在信号量保护的临界区代码里面是可以睡眠的（需要进行进程调度），这是与自旋锁最大的区别。==

信号量又称为信号灯，它是用来协调不同进程间的数据对象的，而最主要的应用是共享内存方式的进程间通信。本质上，信号量是一个计数器，它用来记录对某个资源（如共享内存）的存取状况。它负责协调各个进程，以保证他们能够正确、合理的使用公共资源。它和spin lock最大的不同之处就是：无法获取信号量的进程可以睡眠，因此会导致系统调度。

1、==用于进程与进程之间的同步==

2、==允许多个进程进入临界区代码执行，临界区代码允许睡眠；==

3、信号量本质是==基于调度器的==，在UP和SMP下没有区别；进程获取不到信号量将陷入休眠，并让出CPU；

4、不支持进程和中断之间的同步

5、==进程调度也是会消耗系统资源的，如果一个int型共享变量就需要使用信号量，将极大的浪费系统资源==

6、信号量可以用于多个线程，用于资源的计数（有多种状态）

==信号量加锁以及解锁过程：==

sema_init(&sp->dead_sem, 0); / 初始化 /

down(&sema);

临界区代码

up(&sema);

==信号量定义：==

==信号量初始化：==

==dowm函数实现：==

==up函数实现：==

信号量一般可以用来标记可用资源的个数。

举2个生活中的例子：

==dowm函数实现原理解析：==

（1）down

判断sem->count是否 > 0，大于0则说明系统资源够用，分配一个给该进程，否则进入__down(sem);

（2）__down

调用__down_common(sem, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);其中TASK_UNINTERRUPTIBLE=2代表进入睡眠，且不可以打断；MAX_SCHEDULE_TIMEOUT休眠最长LONG_MAX时间；

（3）list_add_tail(&waiter.list, &sem->wait_list);

把当前进程加入到sem->wait_list中；

（3）先解锁后加锁;

进入__down_common前已经加锁了，先把解锁，调用schele_timeout(timeout)，当waiter.up=1后跳出for循环；退出函数之前再加锁；

Linux内核ARM构架中原子变量的底层实现研究

rk3288 原子操作和原子位操作

原子变量适用于只共享一个int型变量；

1、原子操作是指不被打断的操作，即它是最小的执行单位。

2、最简单的原子操作就是一条条的汇编指令(不包括一些伪指令，伪指令会被汇编器解释成多条汇编指令)

==常见函数：==

==以atomic_inc为例介绍实现过程==

在Linux内核文件archarmincludeasmatomic.h中。 执行atomic_read、atomic_set这些操作都只需要一条汇编指令，所以它们本身就是不可打断的。 需要特别研究的是atomic_inc、atomic_dec这类读出、修改、写回的函数。

所以atomic_add的原型是下面这个宏：

atomic_add等效于：

result（%0） tmp（%1） (v->counter)（%2） (&v->counter)（%3） i（%4）

注意：根据内联汇编的语法，result、tmp、&v->counter对应的数据都放在了寄存器中操作。如果出现上下文切换，切换机制会做寄存器上下文保护。

（1）ldrex %0, [%3]

意思是将&v->counter指向的数据放入result中，并且（分别在Local monitor和Global monitor中）设置独占标志。

（2）add %0, %0, %4

result = result + i

（3）strex %1, %0, [%3]

意思是将result保存到&v->counter指向的内存中， 此时 Exclusive monitors会发挥作用，将保存是否成功的标志放入tmp中。

（4） teq %1, #0

测试strex是否成功（tmp == 0 ？？）

（5）bne 1b

如果发现strex失败，从（1）再次执行。

Spinlock 是内核中提供的一种比较常见的锁机制，==自旋锁是“原地等待”的方式解决资源冲突的==，即，一个线程获取了一个自旋锁后，另外一个线程期望获取该自旋锁，获取不到，只能够原地“打转”（忙等待）。由于自旋锁的这个忙等待的特性，注定了它使用场景上的限制 —— 自旋锁不应该被长时间的持有（消耗 CPU 资源），一般应用在==中断上下文==。

1、spinlock是一种死等机制

2、信号量可以允许多个执行单元进入，spinlock不行，一次只能允许一个执行单元获取锁，并且进入临界区，其他执行单元都是在门口不断的死等

3、由于不休眠，因此spinlock可以应用在中断上下文中；

4、由于spinlock死等的特性，因此临界区执行代码尽可能的短；

==spinlock加锁以及解锁过程：==

spin_lock(&devices_lock);

临界区代码

spin_unlock(&devices_lock);

==spinlock初始化==

==进程和进程之间同步==

==本地软中断之间同步==

==本地硬中断之间同步==

==本地硬中断之间同步并且保存本地中断状态==

==尝试获取锁==

== arch_spinlock_t结构体定义如下： ==

== arch_spin_lock的实现如下： ==

lockval（%0） newval（%1） tmp（%2） &lock->slock（%3） 1 << TICKET_SHIFT（%4）

（1）ldrex %0, [%3]

把lock->slock的值赋值给lockval；并且（分别在Local monitor和Global monitor中）设置独占标志。

（2）add %1, %0, %4

newval =lockval +（1<<16）; 相当于next+1；

（3）strex %2, %1, [%3]

newval =lockval +（1<<16）; 相当于next+1；

意思是将newval保存到 &lock->slock指向的内存中， 此时 Exclusive monitors会发挥作用，将保存是否成功的标志放入tmp中。

（4） teq %2, #0

测试strex是否成功

（5）bne 1b

如果发现strex失败，从（1）再次执行。

通过上面的分析，可知关键在于strex的操作是否成功的判断上。而这个就归功于ARM的Exclusive monitors和ldrex/strex指令的机制。

（6）while (lockval.tickets.next != lockval.tickets.owner)

如何lockval.tickets的next和owner是否相等。相同则跳出while循环，否则在循环内等待判断；

* （7）wfe()和smp_mb() 最终调用#define barrier() asm volatile ("": : :"memory") *

阻止编译器重排，保证编译程序时在优化屏障之前的指令不会在优化屏障之后执行。

== arch_spin_unlock的实现如下： ==

退出锁时：tickets.owner++

== 出现死锁的情况： ==

1、拥有自旋锁的进程A在内核态阻塞了，内核调度B进程，碰巧B进程也要获得自旋锁，此时B只能自旋转。 而此时抢占已经关闭，（单核）不会调度A进程了，B永远自旋，产生死锁。

2、进程A拥有自旋锁，中断到来，CPU执行中断函数，中断处理函数，中断处理函数需要获得自旋锁，访问共享资源，此时无法获得锁，只能自旋，产生死锁。

== 如何避免死锁： ==

1、如果中断处理函数中也要获得自旋锁，那么驱动程序需要在拥有自旋锁时禁止中断；

2、自旋锁必须在可能的最短时间内拥有

3、避免某个获得锁的函数调用其他同样试图获取这个锁的函数，否则代码就会死锁；不论是信号量还是自旋锁，都不允许锁拥有者第二次获得这个锁，如果试图这么做，系统将挂起；

4、锁的顺序规则（a) 按同样的顺序获得锁；b) 如果必须获得一个局部锁和一个属于内核更中心位置的锁，则应该首先获取自己的局部锁 ;c) 如果我们拥有信号量和自旋锁的组合，则必须首先获得信号量；在拥有自旋锁时调用down(可导致休眠)是个严重的错误的；）

== rw（read/write）spinlock： ==

加锁逻辑：

1、假设临界区内没有任何的thread，这个时候任何的读线程和写线程都可以键入

2、假设临界区内有一个读线程，这时候信赖的read线程可以任意进入，但是写线程不能进入；

3、假设临界区有一个写线程，这时候任何的读、写线程都不可以进入；

4、假设临界区内有一个或者多个读线程，写线程不可以进入临界区，但是写线程也无法阻止后续的读线程继续进去，要等到临界区所有的读线程都结束了，才可以进入，可见：==rw（read/write）spinlock更加有利于读线程；==

== seqlock（顺序锁）： ==

加锁逻辑：

1、假设临界区内没有任何的thread，这个时候任何的读线程和写线程都可以键入

2、假设临界区内没有写线程的情况下，read线程可以任意进入；

3、假设临界区有一个写线程，这时候任何的读、写线程都不可以进入；

4、假设临界区内只有read线程的情况下，写线程可以理解执行，不会等待，可见：==seqlock（顺序锁）更加有利于写线程；==

读写速度 ： CPU > 一级缓存 > 二级缓存 > 内存 ，因此某一个CPU0的lock修改了，其他的CPU的lock就会失效；那么其他CPU就会依次去L1 L2和主存中读取lock值，一旦其他CPU去读取了主存，就存在系统性能降低的风险；

mutex用于互斥操作。

互斥体只能用于一个线程，资源只有两种状态（占用或者空闲）

1、mutex的语义相对于信号量要简单轻便一些，在锁争用激烈的测试场景下，mutex比信号量执行速度更快，可扩展

性更好，

2、另外mutex数据结构的定义比信号量小;、

3、同一时刻只有一个线程可以持有mutex

4、不允许递归地加锁和解锁

5、当进程持有mutex时，进程不可以退出。

• mutex必须使用官方API来初始化。

• mutex可以睡眠，所以不允许在中断处理程序或者中断下半部中使用，例如tasklet、定时器等

==常见操作：==

struct mutex mutex_1;

mutex_init(&mutex_1);

mutex_lock(&mutex_1)

临界区代码；

mutex_unlock(&mutex_1)

==常见函数：==

=

④ Linux内核设计与实现的内容简介

《Linux内核设计与实现(原书第3版)》主要内容包括：进程管理、进程调度、时间管理和定时器、系统调用接口、内存寻址、内存管理和页缓存、VFS、内核同步以及调试技术等。同时《Linux内核设计与实现(原书第3版)》也涵盖了Linux 2.6内核中颇具特色的内容，包括CFS调度程序、抢占式内核、块I/O层以及I/O调度程序等。《Linux内核设计与实现(原书第3版)》采用理论与实践相结合的路线，能够带领读者快速走进Linux内核世界，真正开发内核代码。《Linux内核设计与实现(原书第3版)》适合作为高等院校操作系统课程的教材或参考书，也可供相关技术人员参考。
如果你是一名linux内核爱好者，本书的内容可以帮助你大显身手。如果你是一名普通程序员，本书的内容将会拓宽你的编程思路。如果你初次接触linux内核，本书则可以帮助你对内核各个核心子系统有一个整体把握。
本版新增内容
·增加一章专门描述内核数据结构
·详细描述中断处理程序
·扩充虚拟内存和内存分配的内容
·调试linux内核的技巧
·内核同步和锁机制的深度描述
·提交内核补丁以及参与linux内核社区的建设性建议