OS Basics on Yuanye Ma's Blog

x86汇编从实模式到保护模式实验

yuanye.ma@qq.com (Yuanye Ma) — Wed, 15 Jan 2020 16:01:23 +0800

x86汇编从实模式到保护模式实验

实验一

实验环境：MacOS High Sierra

安装nasm

nasm是一个开源的汇编语言编译器，可以将汇编代码编程成x86平台可以执行的二进制代码

# 安装homebrew
ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)" < /dev/null 2> /dev/null
# 安装nasm
brewinstall nasm

Vim 编辑器–用于编辑代码

xxd 命令可以以二进制或者十六进制的形式查看二进制文件，配合vim可以当做十六进制查看器使用。

1
2
3

vim test.bin
# 输入 :%!xxd 可以十六进制形式查看
# xxd -r 可以写二进制文件

写入代码，并编译

1
2
3

vim test.asm
# 粘贴写入代码
nasm -f bin -o test.bin test.asm # 编译生成二进制文件

创建虚拟机镜像，并启动虚拟机查看实验结果

1
2
3

# 创建软盘镜像
dd if=./test.bin of=os.img count=1 bs=1440k
# bs：一个块多少个字节 count：多少个块 软盘大小1.44MB

打开virtualbox->创建虚拟机->操作系统类型：Other->Other unknow -> 不要硬盘。

设置虚拟机->存储->注册->选中上边创建的os.img。开启虚拟机。引导设置为软盘

此外可以通过以下方式将img转换为vdi的硬盘

qemu-img convert -f raw -O vpc ./test.img ./test.vdi
# 此时需要将虚拟机的引导方式修改为硬盘启动
# 也可以通过以下命令转换，但是磁盘文件太小是会出错
VBoxManage convertdd test.img os.vdi # convertdd指将raw硬盘转换为vdi硬盘

![image-20200114204303405](/Users/kevin/Library/Application Support/typora-user-images/image-20200114204303405.png)

创建一个虚拟硬盘，并写入MBR

1
2
3

dd if=./test.bin of=./os.img bs=512 count=1
dd if=/dev/zero of=./os.img seek=1 bs=512 count=2000000 # 创建了一个大小为1G的硬盘，seek是跳过多少块再开始写
VBoxManage convertdd os.img os.vdi

然后将此硬盘镜像设置为虚拟机的启动硬盘，可以得到和上边实验相同的结果。

Bochs

bochs是一个开源的x86模拟器，可以单步调试，可以查看CPU的寄存器值。各个版本的下载链接

# 下载Bochs代码
wget https://sourceforge.net/projects/bochs/files/bochs/2.6.11/bochs-2.6.11.tar.gz/download
# 解压并进入代码目录
tar -zxvf ./download && cd ./bochs-2.6.11
# 配置编译环境
brew install sdl # 依赖项
chmod u+x ./configure
./configure --enable-ne2000 \
 --enable-all-optimizations \
 --enable-cpu-level=6 \
 --enable-x86-64 \
 --enable-vmx=2 \
 --enable-pci \
 --enable-usb \
 --enable-usb-ohci \
 --enable-e1000 \
 --enable-debugger \
 --enable-disasm \
 --disable-debugger-gui \
 --with-sdl \
 --prefix=$HOME/opt/bochs
# 编译安装
# 报错 eth_socket.cc:98:10: fatal error: 'linux/types.h' file not found

参考1 参考2

bochs在macos上编译的时候遇到fatal error: 'linux/types.h' file not found错误，暂时不知道怎么解决。

代码解释

;代码清单5-1

mov ax,0xb800 ;指向文本模式的显示缓冲区
mov es,ax

;以下显示字符串"Label offset:"

mov byte [es:0x00],'L'
mov byte [es:0x01],0x07 ;黑底白字
mov byte [es:0x02],'a'
mov byte [es:0x03],0x07
mov byte [es:0x04],'b'
mov byte [es:0x05],0x07
mov byte [es:0x06],'e'
mov byte [es:0x07],0x07
mov byte [es:0x08],'l'
mov byte [es:0x09],0x07
mov byte [es:0x0a],' '
mov byte [es:0x0b],0x07
mov byte [es:0x0c],"o"
mov byte [es:0x0d],0x07
mov byte [es:0x0e],'f'
mov byte [es:0x0f],0x07
mov byte [es:0x10],'f'
mov byte [es:0x11],0x07
mov byte [es:0x12],'s'
mov byte [es:0x13],0x07
mov byte [es:0x14],'e'
mov byte [es:0x15],0x07
mov byte [es:0x16],'t'
mov byte [es:0x17],0x07
mov byte [es:0x18],':'
mov byte [es:0x19],0x07

mov ax,number ;取得标号number的偏移地址
mov bx,10 ; 除数

;设置数据段的基地址
mov cx,cs
mov ds,cx

;求个位上的数字
mov dx,0 ; 被除数是DX:AX 32位
div bx ; 除数是BX 16位， 商在AX，余数在DX
mov [0x7c00+number+0x00],dl ; dl中保存的是余数的低8位 ;保存个位上的数字

;求十位上的数字
xor dx,dx ; 清空dx寄存器的值
div bx
mov [0x7c00+number+0x01],dl ;保存十位上的数字

;求百位上的数字
xor dx,dx
div bx
mov [0x7c00+number+0x02],dl ;保存百位上的数字

;求千位上的数字
xor dx,dx
div bx
mov [0x7c00+number+0x03],dl ;保存千位上的数字

;求万位上的数字
xor dx,dx
div bx
mov [0x7c00+number+0x04],dl ;保存万位上的数字

;以下用十进制显示标号的偏移地址

mov al,[0x7c00+number+0x04]
add al,0x30 ; 要显示数字的ASCII
mov [es:0x1a],al
mov byte [es:0x1b],0x04

mov al,[0x7c00+number+0x03]
add al,0x30
mov [es:0x1c],al
mov byte [es:0x1d],0x04 ; 黑底红字，无闪烁，无加亮

mov al,[0x7c00+number+0x02]
add al,0x30
mov [es:0x1e],al
mov byte [es:0x1f],0x04 ; 设置显示模式

mov al,[0x7c00+number+0x01]
add al,0x30
mov [es:0x20],al
mov byte [es:0x21],0x04

mov al,[0x7c00+number+0x00]
add al,0x30
mov [es:0x22],al
mov byte [es:0x23],0x04

mov byte [es:0x24],'D'
mov byte [es:0x25],0x07

;无限循环
infi:
jmp near infi

number db 0,0,0,0,0
times 203 db 0 ; 重复定义203个0
db 0x55,0xaa

div指令：

被除数是32位时存储在（DX:AX）除数是16位的跟在div指令后，商存在AX，余数在DX中

被除数是16位时存储在 AX中，除数是8位的跟在div指令后，商在AL,余数在AH中

DB是伪指令，即没有对应的机器码，只是给编译器用的。DB表示声明一个字节数据，此外还有DW(两个字),DD（双字）,DQ（四字）

;代码清单6-1

jmp near start
mytext db 'L',0x07,'a',0x07,'b',0x07,'e',0x07,'l',0x07,' ',0x07,'o',0x07,\
'f',0x07,'f',0x07,'s',0x07,'e',0x07,'t',0x07,':',0x07
number db 0,0,0,0,0

start:
 mov ax,0x7c0
 mov ds,ax ;设置数据段基地址

 mov ax,0xb800
 mov es,ax ;设置附加段基地址

 cld ; 清除DF位，DF=0表示movsw为正方向， std指令设置DF=1 传送方向为从高地址到低地址

 mov si,mytext ; movsw的源（source）
 mov di,0 ; movsw的目的（dist）
 mov cx,(number-mytext)/2 ; (numbner-mytext)/2是需要movsw的次数，cx是计数寄存器cx==0时rep结束 13
 rep movsw ; 重复movsw，每次mov一个word及两个字节 起始DS:SI 目的ES:DI


 mov ax,number ;得到标号所代表的偏移地址

 ;计算各个数位
 mov bx,ax
 mov cx,5
 mov si,10 ; 除数
digit:
 xor dx,dx ; 清空dx寄存器的值
 div si
 mov [bx],dl ; 保存数位，保存位置为number
 inc bx ; bx值增加1
 loop digit ; cx != 0 就跳转回digit标签处

 ;显示各个数位
 mov bx,number
 mov si,4 ; 显示位数
show:
 mov al,[bx+si]
 add al,0x30
 mov ah,0x04
 mov [es:di],ax

 add di,2
 dec si ; si 自减1
 jns show ; SF=0则跳转 SF（Sign Flag）如果前边dec执行后最高位为0则SF=0,否则置1


 mov word [es:di],0x0744 ; 0x07 表示黑底白字 0x44是字母'D'
 jmp near $ ; 死循环

 times 510-($-$$) db 0 ; 一个块512B，减去55aa还有510个块, $代表行首地址，$$代表当前段的起始地址
 db 0x55,0xaa ; MBR分区标记

movsw指令

movsw和movsb指令执行时，原始数据串的地址由DS:SI指定，要传送的目的地址为ES:DI，传送次数为CX，movsb每次传送一个字节，movsw每次传送两个字节。

正向传送时，没传送一个字节（movsb）或者一个字（movsw）SI和DI加1或者2；

反向传送时，没传送一个字节（movsb）或者一个字（movsw）SI和DI减1或者2；

传送方向由标志寄存器（FLAGS）的DF位指定，0为正，1为负。cls清零DF位，std将DF位置1.

单纯的movsw或者movsb指令只能执行1此，需要加上rep前缀，只要CX不为0就一直执行movsw或者movsb。

X86汇编

yuanye.ma@qq.com (Yuanye Ma) — Fri, 05 Jul 2019 16:01:23 +0800

X86汇编

在网上无意间看到“编程达人”的一个讲汇编的视频，觉得讲的挺好的，刚好我也一直没学明白这个东西，然后就花了半天时间看完了，看到头昏脑涨就记住了下边这些东西。

通用寄存器

32位	16位	8位
EAX	AX	AL
EBX	BX	BL
ECX	CX	CL
EDX	DX	DL
ESP	SP	AH
EBP	BP	CH
ESI	SI	DH
EDI	DI	BH

mov eax, 1

使用内存

1.把立即数写入内存

`1`	`mov byte ptr ds:[0018FFF0], 1 # 将立即数1 写入内存地址[0018FFF0]中，写入长度为一个字节`

2.把寄存器的值写入内存

`1`	`mov DWORD ptr ds:[0018FFF0], eax # 将立即数1 写入内存地址[0018FFF0]中，写入长度为一个字节`

3.把内存中的值写入寄存器

`1`	`mov EAX, BWORD PTR DS:[0018FFF0]`

4.内存到内存需要特殊的指令
后边会有

内存地址的五种表示形式

形式一： [立即数]

形式二： [reg] reg代表八个通用寄存器中的任何一个

`1`	`mov dword ptr ds:[eax], 12345678 # 其中eax中保存内存的地址`

形式三：[reg+立即数]

`1`	`mov dword ptr ds:[eax+4], 12345678 # 其中eax+4中保存内存的地址`

形式四：[reg+reg*{1,2,4,8}]

1
2
3

mov eax, 13ffc4
mov ecx, 2
mov dword ptr ds:[eax+ecx*4]

形式五：[reg+reg*{1,2,4,8}+立即数]

存储模式

大端模式：数据高位在低地址，数据低位在高地址

小端模式：数据低位在低地址

0x1A2C3E4F的小端模式

地址	数字
0x00	4F
0x01	3E
0x02	2C
0x03	1A

80x86一般都是小端模式

汇编指令

基础指令

1.mov

格式	解释
mov r/m8, r8	r代表通用寄存器，8代表是8位的
mov r/m16, r16	m代表内存
mov r/m32, r32
mov r8, r/m8
mov r16, r/m16
mov r32, r/m32
mov r8, imm8	imm8 代表8位立即数
mov r16, imm16
mov r32, imm32

2.ADD

格式	解释
ADD r/m8, imm8	中间那个表示目的地址
ADD r/m32, r32
ADD r32, r/m32

3.SUB和add指令类似

4.AND

5.OR

6.XOR

7.NOT

连续复制数据指令

8.MOVS 移动数据，内存-内存

指令	简写
MOVS BYTE PTR ES:[EDI], BYTE PTR DS:[ESI]	MOVSB
MOVS WORD PTR ES:[EDI], WORD PTR DS:[ESI]	MOVSW
MOVS DWORD PTR ES:[EDI], DWORD PTR DS:[ESI]	MOVSD

EDI：存储一个地址，目标地址 ESI：存储的是一个地址，源数据的地址

EDI和ESI内的地址会根据EFI的第十位DF的值改变，0 ：自增， 1：自减。

9.STOS：将AL/AX/EAX的值存储到[EDI]指定的内存单元

格式	解释	简写
STOS BYTE PTR ES:[EDI]	将AL中的内容写到[EDI]指向的内存空间，EDI内的地址+1/-1(由DF位确定)	STOSB
STOS WORD PTR ES:[EDI]		STOSW
STOS DWORD PTR ES:[EDI]		STOSD

10.REP : 按照计数寄存器（ECX）中指定的次数重复执行字符串指令

MOV ECX, 10
REP MOVS DWORD PTR ES:[EDI], DWORD PTR DS:[ESI] #或者 REP MOVSD

堆栈操作

ESP寄存器存储栈顶指针，从大地址逐渐减小，向低地址生长。

11.push : 向堆栈中压入数据，并修改esp的值。

格式	同义
PUSH r32
PUSH r16
PUSH m32	PUSH DWORD PTR DS:[18FFA4]
PUSH m16
PUSH imm8/imm16/imm32

12.pop：

格式	同义
POP r32
POP r16
POP m32
POP m16

修改EIP的指令

EIP寄存器里边存储的是CPU下一时刻应该执行的指令。

13.jmp ：寄存器/立即数/内存地址
14.call : 先push下一行地址，然后jmp，
15.ret ： ADD ESP, 4; MOV EIP, [ESP-4];

函数

函数调用

jmp 来执行函数

call 来调用函数

ret 返回call调用的函数

参数传递

寄存器传参：ecx,edx存储参数，eax存储返回值。

堆栈传参：先将参数压入堆栈，然后call调用函数，eax存储返回值。

push 1
push 2
call 41840d
add esp, 8 #外平栈

41840d:
mov eax, dword ptr ds:[esp+8]
mov eax, dword ptr ds:[esp+4]
ret # ret 8 内平栈

堆栈平衡：

如果要返回父程序，则当我们在堆栈中进行堆栈操作的时候，一定要保证在RET指令前，ESP指向的是我们压入栈中的地址。
如果通过堆栈传递参数，那么在函数执行完毕后，要平衡参数导致的堆栈变化。

ESP寻址

调用函数的时候要保存现场，函数返回前要恢复现场。

EBP寻址

EBP寄存器保存的是栈底的地址。

PUSH 1
PUSH 2
CALL 4183EE

4183EE:
# 保存
PUSH EBP
MOV EBP, ESP

# 执行函数
MOV EAX, DWORD PTR SS:[EBP+8]
ADD EAX, DWORD PTR SS:[EBP+C]

# 准备返回
MOV ESP, EBP
POP EBP

# 返回
ret 8

JCC指令

标志寄存器EFL

31-12	11	10	9	8	7	6	5	4	3	2	1	0
	OF	DF	IF	TF	SF	ZF	0	AF	0	PF	1	CF
	溢出	方向	中断使能	单步	符号	零	0	辅助进位	0	奇偶	1	进位

CF (Carry flag)：若算术操作产生的结果在最高有效位发生进位或者借位将其置1，反之清零。
PF（parity flag）: 如果结果的最低有效字节（最低位的一个字节）包含偶数个1，则置1，否则清零。
AF (Auxiliary Carry Flag):如果算术操作在结果的第三位发生进位或者借位则将该标志置1，主要应用于BCD运算。
ZF (Zero Flag): 如果运算的结果为0，则设置为1，否则清零，经常和cmp或者test等指令一起使用

mov eax, 100
mov ecx, 100
cmp eax, ecx # cmp指令相当于SUB指令，但是相减的结果不保存到第一个操作数中

test eax, eax # test指令相当于AND指令，但是与的结果并不保存在第一个操作数中

SF (Sign Flag): 该标志被设置为有符号整数的最高有效位，0为正，反之为负
OF (Overflow flag) ：溢出标志用于反映有符号数加减运算所得出结果是否溢出。

如果是无符号数运算，是否溢出看CF位；

有符号数看OF
DF （Direction Flag）：这个方向标志控制串指令（MOVS, CMPS, SCAS, LODS以及STOS）。设置DF标志使得串指令自动递减，清除该标志则使得串指令自动递增。STD和CLD指令分别用于设置以及清除DF标志。

指令	意义	标志位
JE, JZ	结果为零则跳转（相等时跳转）	ZF=1
JNE, JNZ	结果不为零则跳转（不相等时跳转）	ZF=0
JS	结果为负则跳转	SF=1
…	…	…

清华大学-汇编语言程序设计

基础知识

各类指令集初步

数制与整数表示

浮点数表示

X86汇编（AT&T风格）

AT&T风格的汇编

movl source, dist

其中mov后边的l表示操作的字长， AT&T先原地址后目标地址

80x86计算机组成与保护模式

80386有三种工作模式：

1
2
3

- 实模式：操作相当于一个可进行32位快速运算的8086
- 保护模式：是80x86设计目标全部达到的工作模式，通过对程序使用的存储区采用分段、分页的存储管理机制，以达到分级使用、互不干扰的保护目的。能为每个任务提供一台虚拟处理器，使每个任务单独执行，快速切换。
- 虚拟8086模式：保护模式下同时模拟多个8086处理器

X86指令系统与寻址方式

间接寻址 （R）: Mem[Reg[R]] 表示寄存器R指定内存的地址，例：movl (%ecx), %eax
基址+偏移量 寻址 D(R) : Mem[Reg[R]+D] 寄存器R指定内存起始地址，常数D给出偏移量，例，movl 8(%ebp), %edx表示把%ebp中取出一个数加上8作为内存的地址。
变址寻址 D(Rb, Ri, S) : Mem[Reg[Rb] + S* Reg[Ri] +D], 常量D给出地址偏移量，基址寄存器Rb是8个通用寄存器之一，索引寄存器Ri，S是比例因子，取值为1，2，4，8。

leal src, dist 指令将src表示的地址计算出来并传递给dist。比如：leal (%edx, %edx, 2), %edx

C与x86汇编

x86汇编语言程序格式与基本编程

AT&T和Intel汇编格式主要区别

在Intel格式中大多使用大写字母，而AT&T格式中都使用小写字母
在AT&T格式中，寄存器名上要加上“%”作为前缀，而Intel格式则不带前缀。
在AT&T格式中，指令的源操作数在前，目标在后，恰好和Intel格式完全相反。
在AT&T格式中，访问内存指令的操作数大小由操作码后缀来决定。用作操作码后缀的字母有b(表示8位)，w(表示16位), l(32位)。而在Intel格式中，则是在表示内存单元的操作数前面加上“BYTE PTR” , “WORD PTR”, “DWORD PTR"来表示的。
AT&T中的立即数要加上”$“作为前缀，Intel格式不带前缀。
AT&T格式中，绝对转移或者调用指令jump/call的操作数，要加上”*“作为前缀。Intel格式不用。
间接寻址的一般格式：Intel格式：SECTION:[BASE + INDEX*SCALE+DISP];AT&T格式：section:disp(base, index, scale)
远程的转移指令和子程序调用指令的操作码名称，在AT&T中为"ljmp"和"lcall”，而在Intel格式中为“JMP FAR”和"CALL FAR"。

linux内核中的汇编语言规则

哈工大李治军操作系统

linux内核中使用了三种汇编

as86汇编：能产生16位代码的Intel 8086汇编。主要构成了bootsect, setup代码。
GNU as汇编：能产生32位代码的AT&T系统V语法。主要构成保护模式代码。
GNU内嵌汇编：进程调度代码。

GDT LDT IDT TSS

yuanye.ma@qq.com (Yuanye Ma) — Mon, 15 Apr 2019 16:01:23 +0800

GDT LDT IDT TSS

和一个段有关的信息需要8个字节来描述，所以称之为段描述符（Segment Descriptor），每个段都需要一个描述符。为了存放这些描述符，需要在内存中开辟出一段空间。在这段空间中，所有的描述符都是挨在一起的，集中存放的，这就构成了描述符表。

i386中，除了段描述符，还有一种描述符叫做“门描述符”，描述控制转移的入口点，也就是异常控制中断的入口点，通过这种门可以实现特权级的转变和任务的切换。

GDT & GDTR

GDT : Global Descriptor Table , 全局描述符表，用来存放全局的段描述符。

GDTR ： Global Descriptor Table Register，用来保存全局描述符表（GDT）的起始地址。

整个系统中，全局描述符表GDT只有一张(一个处理器对应一个GDT)，GDT可以被放在内存的任何位置，但CPU必须知道GDT的入口，也就是基地址放在哪里，Intel的设计者门提供了一个寄存器GDTR用来存放GDT的入口地址，程序员将GDT设定在内存中某个位置之后，可以通过LGDT指令将GDT的入口地址装入此寄存器，从此以后，CPU就根据此寄存器中的内容作为GDT的入口来访问GDT了。GDTR中存放的是GDT在内存中的基地址和其表长界限。

全局描述符表线性基地址：保存的是全局描述符表在内存中的起始线性地址；
16位的全局描述符表边界：在数值上等于表的大小（总字节数）减一，16位决定了表最大65536字节（64KB），又因为每个描述符占8个字节，所以最多能有8192个描述符；

**段选择子（Selector）**由GDTR访问全局描述符表是通过“段选择子”（实模式下的段寄存器）来完成的。段选择子是一个16位的寄存器（同实模式下的段寄存器相同）。

描述符索引：指示段描述符在GDT中的下标；
TI ：描述符表指示器（Table Indicator）0表示此描述符在GDT中，1表示此描述符在LDT中；
RPL：请求特权级，表示给出当前选择子的那个程序的特权级；

G ：粒度（Granularity）位，解释段界限的含义，0表示段界限以字节为单位；1表示段界限以4KB为单位；
S ：类型（Descriptor Type）位，0表示是一个系统段；1表示是一个代码段或者数据段；
DPL : 表示描述符的特权级( Descriptor Privilege Level)。对应CPU的0,1,2,3特权级，数字越小特权级越高；
P ：段存在（Segment Present）位，描述此段是否在内存中，在为1，不在为0；
D/B：默认的操作数大小，如果代码段的D位为0，那么处理器在这个段上执行时，将使用16位指令指针寄存器IP来取指令，否则用32位的取指令；对于栈段，此位为B位，用于在进行隐式的栈操作时，是使用SP寄存器还是ESP寄存器，如果该位为0，使用SP,否则使用ESP；
L： 64位代码段标志，保留给64位系统使用，否则填0；
TYPE段共4位，用于指示描述符的子类型，X表示是否可执行。E表示数据段的扩展方向，E=0表示向上扩展，也就是向高地址方向扩展，即普通数据段；E=1表示向下扩展，即栈段；W=0表示不可写入；C=0表示非依从代码段，这样的代码段可以从与它特权级相同的代码段调用；C=1表示允许从低特权级的程序转移到该段执行。

LDT & LDTR

为了有效地在任务之间实施隔离，处理器建议每个任务都应该具有自己的描述符表，称之为局部描述符表LDT（Local Descriptor Table），并且将属于自己的段放在LDT中。

局部描述符表可以有若干张，每个任务可以有一张。我们可以这样理解GDT和LDT：GDT为一级描述符表，LDT为二级描述符表。

为了追踪和访问这些LDT，处理器使用了局部描述符表寄存器LDTR。在一个多任务系统中，会有很多任务在轮流执行，正在执行的那个任务，称为当前任务（Current Task）,因为LDTR只有一个，所以，它只指向当前任务的LDT。每当发生任务切换时，LDTR的内容会被更新。

IDT & IDTR

中断描述符表（Interrupt Descriptor Table, IDT）保存的是和中断过程有关的描述符，包括中断门、陷阱门和任务门，整个系统中只有一个IDT。

中断描述符表寄存器（Interrupt Descriptor Table Register,IDTR）保存着中断描述符表在内存中的线性基地址和界限。

中断描述符表的每一行是一个门描述符。

门描述符：中断门(Interrupt Gate)，陷阱门（Trap Gate）任务门(Task Gate)和调用门(Interrupt Gate)，其中中断门和陷阱门必须存放在IDT中，任务门和调用门可以存储在GDT\LDT和IDT中。除了任务门外其他三种门的结构基本相同，中断门，陷阱门，调用门结构如下图所示。任务门结构在下一小节TSS&TR后边有贴图。

中断i发生 ->确定与中断或异常关联的向量i-> 通过查询IDT的第i项目 -> 得到中断描述符（门）-> 得到段选择符 -> 查询GDT - >得到段描述符 -> 得到段的基地址 -> 段基地址加上中断描述符中的偏移地址 -> 得到中断服务程序的入口地址。过程中或检查特权级，如果特权级发生了变化还会发生栈切换。

中断门和陷阱门的唯一区别在于，通过中断门进入中断服务程序时CPU会自动关闭中断，也就是将CPU中的EFLAGS寄存器的IF标志位清成0，即防止中断嵌套。而通过陷阱门进入服务程序时则维持IF标志位不变。

TSS & TR

任务状态段(Task State Segment : TSS）是一个专门用来保存任务运行现场的数据结构，其中包括CPU中所有与具体进程有关的寄存器的内容（包含页面目录指针CR3），还包括了三个堆栈指针。中断发生时，CPU在中断向量表中找到相应的表项。如果找到的表项是一个任务门，并且通过了优先级别的检查，CPU就会将当前任务的运行现场保存相应的TSS中，并将任务门所指向的TSS作为当前任务，将其内容装入CPU中各个寄存器，从而完成一次任务的切换。

任务寄存器TR用来指向当前任务的TSS。 TR寄存器在处理器中也是只有一个，当任务切换发生时，TR寄存器的内容会跟着指向新的任务的TSS。这个过程是这样的：首先，处理器将当前任务的现场信息保存到由TR寄存器指向的TSS, 然后，再使TR寄存器指向新的TSS，并从新任务的TSS中恢复现场。

进入中断服务函数，或者发生任务切换时，栈也要发生切换，TSS中除了保存有常规的寄存器内容外，还有三个额外的堆栈指针（SS和ESP），这三个额外的堆栈指针分别用于当CPU在目标代码段中的运行级别为0,1,2时的栈。图中的SS0 ESP0 SS1 ESP1等就对应不同级别下的栈。

DPL & CPL & RPL

DPL : Descriptor Privilege Level, 存放在段描述符中，用于表示段的特权级;

CPL : Current Privilege Level, 代表当前执行程序的特权级;

RPL : Request Privilege Level, 请求特权级，存放在段选择子中.

每个段描述符中都有一个DPL位段，即描述项优先级别位段。当CPU通过中断门找到一个代码段描述符，并进而转入相应的服务程序时，就把这个代码段描述项装入CPU中，而描述项的DPL就变成CPU的当前运行级别，即CPL。

而中断门也有一个DPL，当通过int指令进入一个中断服务程序时，在指令中给出一个中断向量，CPU先根据该中断向量找到中断门，将中断门的DPL和当前CPU的CPL进行对比，CPL必须小于等于DPL才能通过该中断门。穿过门后再对比CPU的CPL和段描述符的DPL。

GNU C 内联汇编

yuanye.ma@qq.com (Yuanye Ma) — Mon, 15 Apr 2019 16:01:23 +0800

GNU C 内联汇编

内核代码中有很多内联汇编，为了更好的读懂内核，上网搜罗了一些内联汇编的文章在这里，方便自己随时查阅。这篇文章比较有价值，特别是后半段引用的中国科大BBS站的一些邮件列表，“对《gcc中的内嵌汇编语言》一文的补充说明”中的一些例子描述的很好，能够帮助更好的理解内联汇编。这里摘抄一些。

参考二参考三

基本形式

__asm__ __volatile__(
 "xorps %%xmm0,%%xmm1\n\t"
 "1:\n\t"
 "movdqa %%xmm0,%%xmm1\n\t"
 "pcmpgtd (%1),%%xmm1\n\t"
 "andps %%xmm1,%%xmm0\n\t"
 "andnps (%1),%%xmm1\n\t"
 "orps %%xmm1,%%xmm0\n\t"
 "addq $16,%1\n\t"
 "subq $4,%2\n\t"
 "jnz 1b\n\t"
 "movdqu %%xmm0,(%3)\n\t"
 "movl (%3),%%eax\n\t"
 "cmpl 4(%3),%%eax\n\t"
 "cmovll 4(%3),%%eax\n\t"
 "cmpl 8(%3),%%eax\n\t"
 "cmovll 8(%3),%%eax\n\t"
 "cmpl 12(%3),%%eax\n\t"
 "cmovll 12(%3),%%eax\n\t"
 "movl %%eax,%0\n\t"
 :"=m"(mx) //输出部分
 :"r"(a),"r"((long long)N),"r"(tmp) //输入部分
 :"eax"); //clobber

GNU C 内联汇编以关键字__asm__开头，表示后边部分为汇编代码; __volatile__表示告诉编译器，不要优化后边的代码，严禁将后边的汇编语句和其他语句进行重组优化。

寄存器使用%%开头；
立即数使用$开头；
%0 %1 %2用来引用输入输出部分的内容；

内联汇编一共分为四部分： instruction \ output operand\ input operand \ clobber不同部分之间以冒号分割。

instruction : 是汇编指令，每条指令最好以"\n\t"结尾；
output operand : 是输出部分。每个输出部分使用 , （逗号）分隔. “=“作为修饰符, “m"是约束符，表示存放位置, ()里面表示对应C程序变量。例如: 。
input operand ：是输入部分。和输出部分规则一样。例如：。
clobber : 这个部分是告诉gcc在这条指令里面我们会修改什么值.

操作数限定字符

操作数限定字符串中利用规定的限定字符来描述相应的操作数，一些常用的限定字符有：（还有一些没有涉及的限定字符，参见gcc.info）

“m”:操作数是内存变量。
“o”:操作数是内存变量，但它的寻址方式必须是“偏移量”类型的，也就是基址寻址或者基址加变址寻址。
“V”:操作数是内存变量，其寻址方式非“偏移量”类型。
" “:操作数是内存变量，其地址自动增量。
“r”:操作数是通用寄存器。
“i”:操作数是立即操作数。（其值可在汇编时确定）
“n”:操作数是立即操作数。有些系统不支持除字(双字节)以外的立即操作数，这些操作数要用"n"而不是"i"来描述。
“g”:操作数可以是立即数，内存变量或者寄存器，只要寄存器属于通用寄存器。
“X”:操作数允许是任何类型。
“0”,“1”,…,“9”:操作数与某个指定的操作数匹配。也就是说，该操作数就是指定的那个操作数。例如，如果用"0"来描述”%1"操作数，那么”%1"引用的其实就是”%0"操作数。
“p”:操作数是一个合法的内存地址（指针）。
“=":操作数在指令中是只写的（输出操作数）。
“+":操作数在指令中是读-写类型的（输入-输出操作数）。
“a”:寄存器EAX。
“b”:寄存器EBX。
“c”:寄存器ECX。
“c”:寄存器ECX。
“d”:寄存器EDX。
“q”:寄存器"a”,“b”,“c"或者"d”。-
“A”:寄存器"a"或者"d”。
“f”:浮点数寄存器。
“t”:第一个浮点数寄存器。
“u”:第二个浮点数寄存器。
“D”:寄存器di。
“S”:寄存器si。
“I”:0-31之间的立即数。（用于32位的移位指令）
“J”:0-63之间的立即数。（用于64位的移位指令）
“N”:0-255之间的立即数。(用于"out"指令）
“G”:标准的80387浮点常数。

gcc 对内嵌汇编语言的处理方式

gcc在编译内嵌汇编语言时,采取的步骤如下

变量输入: 根据限定符的内容将输入操作数放入合适的寄存器,如果限定符指定为立即数(“1i”)或内存变量(“m”),则该步被省略,如果限定符没有具体指定输入操作数的类型(如常用的"g”),gcc会视需要决定是否将该操作数输入到某个寄存器.这样每个占位符都与某个寄存器,内存变量,或立即数形成了一一对应的关系.这就是对第二个冒号后内容的解释.如::"a"(foo),"i"(100),"m"(bar)表示%0对应eax寄存器,%1对应100,%2对应内存变量bar.
生成代码: 然后根据这种一一对应的关系(还应包括输出操作符),用这些寄存器,内存变量,或立即数来取代汇编代码中的占位符(则有点像宏操作),注意,则一步骤并不检查由这种取代操作所生成的汇编代码是否合法,例如,如果有这样一条指令asm("movl %0,%1"::"m"(foo),"m"(bar));如果你用gcc -c -S选项编译该源文件,那么在生成的汇编文件中,你将会看到生成了movl foo,bar这样一条指令,这显然是错误的.这个错误在稍后的编译检查中会被发现.
变量输出: 按照输出限定符的指定将寄存器的内容输出到某个内存变量中,如果输出操作数的限定符指定为内存变量(“m”),则该步骤被省略.这就是对第一个冒号后内容的解释, 如:asm("mov %0,%1":"=m"(foo),"=a"(bar):);编译后为
```
 #APP
movl foo,eax
#NO_APP
movl eax,bar
```

该语句虽然有点怪怪的,但它很好的体现了gcc的运作方式.　

x86平台Linux中断机制

yuanye.ma@qq.com (Yuanye Ma) — Mon, 15 Apr 2019 16:01:23 +0800

x86平台Linux中断机制

[toc]

基础知识

NMI不能被IF禁止，其中断向量号由系统固定分配。

外部中断一般可分为非屏蔽中断和可屏蔽中断。对于非屏蔽中断，cpu直接在对应的中断向量表中取得中断入口地址，执行中断处理程序。而对于可屏蔽中断，一般是用8259A等中断管理器来管理。cpu从中断管理器中得到一个中断请求时，会去检查一下中断允许标志IF，若IF为1则取出中断类型码，从中断向量表中取得中断入口地址，执行中断处理程序。若IF为0，cpu将不响应外部提出的中断请求。

IRQ : Interrupt ReQuest

PIC : Programmable Interrupt Controller 可编程中断控制器

向量：每个中断和异常，由0-255之间的数来标识，Intel把这个无符号的整数叫做向量（vector）

PIC的作用：

监视IRQ线，检查产生的信号。
如果有引发信号出现在IRQ线上：

a. 把接收到的引发信号转换成对应的向量。
b. 把这个向量存放在中断控制器的一个I/O端口，从而允许CPU通过数据总线读取此向量。
c. 把引发信号发送到处理器的INTR引脚，即产生一个中断。
d. 等待，直到CPU通过把这个中断信号写进可编程中断控制器的一个I/O端口来确认，这种情况发生时，清INTR线。
返回第1步。

IRQ线从0开始编号，因此IRQn关联的Intel的缺省向量是n+32(CPU保留了一部分向量来处理异常)。可以通过向中断控制器端口发布合适的指令，修改IRQ和向量之间的映射，以及有选择的禁止或者激活相应的IRQ，此禁止只是告诉PIC暂时不向CPU发布此IRQ中断，而一旦此IRQ被再次激活，PIC又会发送此IRQ给CPU 。可屏蔽中断的全局屏蔽或者非屏蔽，由CPU的eflags寄存器的IF标志位决定，cli和sti指令分别清楚和设置该标志。

传统的PIC由两片8259A外部芯片级联组成，只能作为单处理器的PIC。在SMP体系结构中，中断需要传递给系统中的每个CPU，为此Intel从Pentiun III开始引入I/O高级可编程控制器（I/O Advanded Programmable Interrupt Controller, I/O APIC）用以代替老式的8259A PIC。

多APIC结构：APIC总线把“前端”I/O APIC连接到本地APIC。来自设备的IRQ线连接到I/O APIC，相对于本地APIC来说，I/O APIC起路由作用。 I/O APIC中的中断重定向表将每个外部IRQ信号转换为一条消息，然后，通过APIC总线发送给一个或多个CPU的本地APIC单元。多APIC系统还允许CPU产生处理器间中断（interprocessor interrupt, 简称IPI）。

目前大部分单处理器系统都包含一个I/O APIC芯片，可以用以下两种方式进行配置：

作为一种标准的8259A方式的外部PIC连接到CPU。本地APIC被禁止，LINT0和LINT1本地IRQ线分别配置为INTR和NMI引脚。
作为一种标准的I/O APIC。本地APIC被激活，且所有的外部中断都通过I/O APIC接收。

中断请求队列

由于硬件的限制，很多外部设备不得不共享中断线，例如，一些PC配置可以把同一条中断线分配给网卡和图形卡。由此看来，让每个中断源都必须占用一条中断线是不现实的。所以，仅仅中断描述符表并不能提供中断产生的所有信息，内核必须对中断线给出进一步的描述。在Linux设计中，专门为每个中断请求IRQ设置了一个队列，这就是我们所说的中断请求队列。

关于I/O APIC的一些更详细的资料

PIC 、APIC(IOAPIC LAPIC)

1. IO APIC

Linux kernel version : linux 2.6.30.4

基本数据结构

由于通用中断门是让多个中断源共享的，而且允许这种公用的结构在系统运行的过程中动态地变化，所以IDT的初始化阶段只是为每个中断向量，也即每个表项准备一个“中断请求队列”，从而形成一个中断请求队列的数组，这就是数组irq_desc[]。

每个队列头部中除了action用来维持一个由中断服务程序描述项目构成的单链队列外，还有个指针handler指向另一个数据结构，即hw_interrupt_type数据结构，此结构主要是一些函数指针，用于该队列，或者该共用“中断通道”的控制，并不对具体的中断源服务。具体的函数取决于所用的中断控制器(比如 i8259A)。其中，函数指针enable和disable用于开启和关闭其所属的通道，ack用于对中断控制器的相应，而end则用于每次中断服务返回的前夕，这些函数都是在init_IRQ()函数中调用init_ISA_irqs()设置好的。 [这两段摘自《Linux内核源代码情景分析》3.3小节]

irq_desc_t

每个中断向量都有自己的irq_desc_t描述符，所有这些描述符组织在一起形成了irq_desc数组。

根据前一段书中的描述，irq_desc数组应该就是作者所说的中断请求队列数组，数组中的每一项即每一个struct irq_desc结构都描述一个“中断请求队列”，struct irqaction即中断服务程序构成的队列，队列中每一项都对应一个中断服务程序。hw_interrupt_type在较新版本的内核中被struct irq_chip取代，指代此中断通道的操作函数。

/*include/linux/irq.h*/
/**
 * struct irq_desc - interrupt descriptor
 * @irq: interrupt number for this descriptor
 * @timer_rand_state: pointer to timer rand state struct
 * @kstat_irqs: irq stats per cpu
 * @irq_2_iommu: iommu with this irq
 * @handle_irq: highlevel irq-events handler [if NULL, __do_IRQ()]
 * @chip: low level interrupt hardware access
 * @msi_desc: MSI descriptor
 * @handler_data: per-IRQ data for the irq_chip methods
 * @chip_data: platform-specific per-chip private data for the chip
 * methods, to allow shared chip implementations
 * @action: the irq action chain
 * @status: status information
 * @depth: disable-depth, for nested irq_disable() calls
 * @wake_depth: enable depth, for multiple set_irq_wake() callers
 * @irq_count: stats field to detect stalled irqs
 * @last_unhandled: aging timer for unhandled count
 * @irqs_unhandled: stats field for spurious unhandled interrupts
 * @lock: locking for SMP
 * @affinity: IRQ affinity on SMP
 * @cpu: cpu index useful for balancing
 * @pending_mask: pending rebalanced interrupts
 * @threads_active: number of irqaction threads currently running
 * @wait_for_threads: wait queue for sync_irq to wait for threaded handlers
 * @dir: /proc/irq/ procfs entry
 * @name: flow handler name for /proc/interrupts output
 */
struct irq_desc {
 unsigned int irq;
 struct timer_rand_state *timer_rand_state;
 unsigned int *kstat_irqs;
#ifdef CONFIG_INTR_REMAP
 struct irq_2_iommu *irq_2_iommu;
#endif
 irq_flow_handler_t handle_irq;
 struct irq_chip *chip; /*指向描述PIC对象的描述符*/
 struct msi_desc *msi_desc;
 void *handler_data;
 void *chip_data; /* 指向PIC对象方法所使用的的数据 */
 struct irqaction *action; /* IRQ action list */
 unsigned int status; /* IRQ status */

 unsigned int depth; /* nested irq disables */
 unsigned int wake_depth; /* nested wake enables */
 unsigned int irq_count; /* For detecting broken IRQs */
 unsigned long last_unhandled; /* Aging timer for unhandled count */
 unsigned int irqs_unhandled;
 spinlock_t lock;
#ifdef CONFIG_SMP
 cpumask_var_t affinity;
 unsigned int cpu;
#ifdef CONFIG_GENERIC_PENDING_IRQ
 cpumask_var_t pending_mask;
#endif
#endif
 atomic_t threads_active;
 wait_queue_head_t wait_for_threads;
#ifdef CONFIG_PROC_FS
 struct proc_dir_entry *dir;
#endif
 const char *name;
} ____cacheline_internodealigned_in_smp;

extern struct irq_desc irq_desc[NR_IRQS];

/* include/linux/cache.h */
#if !defined(____cacheline_internodealigned_in_smp)
#if defined(CONFIG_SMP)
#define ____cacheline_internodealigned_in_smp \
 __attribute__((__aligned__(1 << (INTERNODE_CACHE_SHIFT))))
#else
#define ____cacheline_internodealigned_in_smp
#endif
#endif

/* struct irq_desc的status字段，描述IRQ线的一组状态 */
/* */
struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned_in_smp = {
 [0 ... NR_IRQS-1] = {
 .status = IRQ_DISABLED,
 .chip = &no_irq_chip,
 .handle_irq = handle_bad_irq,
 .depth = 1,
 .lock = __SPIN_LOCK_UNLOCKED(irq_desc->lock),
 }
};

irq_desc_t描述的depth字段和IRQ_DISABLED标志表示IRQ线是否被禁用。每次调用disable_irq()或者disale_irq_nosync()函数，depth字段的值增加，如果depth等于0，函数禁用IRQ线并设置它的IRQ_DISABLED标志相反，每当调用enable_irq()函数，depth字段的值减少，如果depth变为0，函数激活IRQ线并清除IRQ_DISABLED标志。

irq_chip

Linux支持多种PIC，为了以统一的方式处理所有这样的设备，Linux用了一个PIC对象，由PIC名字和七个PIC标准方法组成。定义PIC对象的数据结构叫做hw_interrupt_type（也叫作hw_irq_controller），后来被irq_chip取代，并添加了很多新的底层硬件操作函数。

/*include/linux/irq.h*/
/**
 * struct irq_chip - hardware interrupt chip descriptor
 *
 * @name: name for /proc/interrupts
 * @startup: start up the interrupt (defaults to ->enable if NULL)
 * @shutdown: shut down the interrupt (defaults to ->disable if NULL)
 * @enable: enable the interrupt (defaults to chip->unmask if NULL)
 * @disable: disable the interrupt (defaults to chip->mask if NULL)
 * @ack: start of a new interrupt
 * @mask: mask an interrupt source
 * @mask_ack: ack and mask an interrupt source
 * @unmask: unmask an interrupt source
 * @eoi: end of interrupt - chip level
 * @end: end of interrupt - flow level
 * @set_affinity: set the CPU affinity on SMP machines
 * @retrigger: resend an IRQ to the CPU
 * @set_type: set the flow type (IRQ_TYPE_LEVEL/etc.) of an IRQ
 * @set_wake: enable/disable power-management wake-on of an IRQ
 *
 * @release: release function solely used by UML
 * @typename: obsoleted by name, kept as migration helper
 */
struct irq_chip {
 const char *name;
 unsigned int (*startup)(unsigned int irq);
 void (*shutdown)(unsigned int irq);
 void (*enable)(unsigned int irq);
 void (*disable)(unsigned int irq);

 void (*ack)(unsigned int irq);
 void (*mask)(unsigned int irq);
 void (*mask_ack)(unsigned int irq);
 void (*unmask)(unsigned int irq);
 void (*eoi)(unsigned int irq);

 void (*end)(unsigned int irq);
 void (*set_affinity)(unsigned int irq,
 const struct cpumask *dest);
 int (*retrigger)(unsigned int irq);
 int (*set_type)(unsigned int irq, unsigned int flow_type);
 int (*set_wake)(unsigned int irq, unsigned int on);

 /* Currently used only by UML, might disappear one day.*/
#ifdef CONFIG_IRQ_RELEASE_METHOD
 void (*release)(unsigned int irq, void *dev_id);
#endif
 /*
 * For compatibility, ->typename is copied into ->name.
 * Will disappear.
 */
 const char *typename;
};

irqaction

多个设备能共享一个单独的IRQ，因此，内核要维护多个irqaction描述符，其中的每个描述符涉及一个特定的硬件设备和一个特定的中断。

/* include/linux/interrupt.h */
/**
 * struct irqaction - per interrupt action descriptor
 * @handler: interrupt handler function
 * @flags: flags (see IRQF_* above)
 * @mask: no comment as it is useless and about to be removed
 * @name: name of the device
 * @dev_id: cookie to identify the device
 * @next: pointer to the next irqaction for shared interrupts
 * @irq: interrupt number
 * @dir: pointer to the proc/irq/NN/name entry
 * @thread_fn: interupt handler function for threaded interrupts
 * @thread: thread pointer for threaded interrupts
 * @thread_flags: flags related to @thread
 */
struct irqaction {
 irq_handler_t handler; /* 指向一个I/O设备的中断服务例程 */
 unsigned long flags; /* 描述IRQ和I/O设备之间的关系 */
 cpumask_t mask;
 const char *name; /* I/O设备名，/proc/interrupts文件中显示 */
 void *dev_id; /* I/O设备的私有字段，标识设备本身(设备号)或者其驱动程序 */
 struct irqaction *next; /* 指向irqaction描述符链表的下一个元素，链表中的元素指向共享同一个IRQ的硬件设备 */
 int irq; /* IRQ线 */
 struct proc_dir_entry *dir; /* 指向IRQn相关的/proc/irq/n目录的描述符 */
 irq_handler_t thread_fn;
 struct task_struct *thread;
 unsigned long thread_flags;
};
/* 中断服务函数类型 */
typedef irqreturn_t (*irq_handler_t)(int, void *);

中断初始化

x86平台中断初始化共分为以下几步：

中断描述符表的初步初始化
中断描述符表的最终初始化
trap_init()
early_irq_init()
init_IRQ()

`IDT`初步初始化

声明256个门描述符的IDT表空间

/* arch/x86/kernel/head_32.S */
idt_descr:
 .word IDT_ENTRIES*8-1 # idt contains 256 entries
 .long idt_table
/*
 这里相当于声明了一个结构体idt_descr，包含两个元素，一个数字和idt_table的地址
 arch/x86/include/asm/desc.h:35:extern gate_desc idt_table[];声明idt_table是一个外部变量，即head_32.S中的idt_descr中的idt_table.
 idt_table表的内容被_set_gate() -> write_idt_entry()填充。
*/

#define write_idt_entry(dt, entry, g) \
 native_write_idt_entry(dt, entry, g)
static inline void native_write_idt_entry(gate_desc *idt, int entry,
 const gate_desc *gate)
{
 memcpy(&idt[entry], gate, sizeof(*gate));
}
/*
 _set_gate()函数被set_xxxintr_gate()调用，用以设置中断门，陷阱门等。
 函数被set_xxxintr_gate()函数主要在
 start_kernel()
 ->trap_init()
 ->init_IQR()
 被调用
*/

设置IDTR

is386: movl $2,%ecx # set MP
2: movl %cr0,%eax
 andl $0x80000011,%eax # Save PG,PE,ET
 orl %ecx,%eax
 movl %eax,%cr0

 call check_x87
 lgdt early_gdt_descr
 lidt idt_descr
 ljmp $(__KERNEL_CS),$1f
1: movl $(__KERNEL_DS),%eax # reload all the segment registers
 movl %eax,%ss # after changing gdt.

初始化256个门描述符

/*
 * setup_idt
 *
 * sets up a idt with 256 entries pointing to
 * ignore_int, interrupt gates. It doesn't actually load
 * idt - that can be done only after paging has been enabled
 * and the kernel moved to PAGE_OFFSET. Interrupts
 * are enabled elsewhere, when we can be relatively
 * sure everything is ok.
 *
 * Warning: %esi is live across this function.
 */
setup_idt:
 lea ignore_int,%edx
 movl $(__KERNEL_CS << 16),%eax
 movw %dx,%ax /* selector = 0x0010 = cs */
 movw $0x8E00,%dx /* interrupt gate - dpl=0, present */

 lea idt_table,%edi
 mov $256,%ecx
rp_sidt:
 movl %eax,(%edi)
 movl %edx,4(%edi)
 addl $8,%edi
 dec %ecx
 jne rp_sidt

lea指令： load effective address 功能是取偏移地址。

mov是将数据从源传到目的

lea是将源的地址传到目的

例如：

movl 18(%eax), %ebx #是将内存中（%eax+18）的内容传入%ebx中；

leal 18(%eax), %ebx #是将（18+（%eax中的值））即地址，传入%ebx;

代码中，lea idt_table, %edi #即将idt_table表的地址传到%edi中。

`IDT`最终初始化

异常：由函数trap_init()实现，被系统初始化入口函数start_kernel()调用；
中断：由函数init_IRQ()实现，被系统初始化入口函数start_kernel()调用；

`trap_init()`

此函数在x86平台linux系统调用章节已经分析过。

`early_irq_init()`

该函数用于初始化数组irq_desc[]；

/*
 init/main.c->start_kernel()->early_irq_init()
 early_irq_init()定义在kernel/irq/handle.c中，且针对不同的controller有不同的实现。
*/
/*
 * Linux has a controller-independent interrupt architecture.
 * Every controller has a 'controller-template', that is used
 * by the main code to do the right thing. Each driver-visible
 * interrupt source is transparently wired to the appropriate
 * controller. Thus drivers need not be aware of the
 * interrupt-controller.
 *
 * The code is designed to be easily extended with new/different
 * interrupt controllers, without having to do assembly magic or
 * having to touch the generic code.
 *
 * Controller mappings for all interrupt sources:
 */

int nr_irqs = NR_IRQS;
EXPORT_SYMBOL_GPL(nr_irqs);

#ifdef CONFIG_SPARSE_IRQ /*CONFIG_SPARSE_IRQ=y支持稀有的中断号*/
/* 暂时不看 */
#else
struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned_in_smp = {
 [0 ... NR_IRQS-1] = {
 .status = IRQ_DISABLED,
 .chip = &no_irq_chip,
 .handle_irq = handle_bad_irq,
 .depth = 1,
 .lock = __SPIN_LOCK_UNLOCKED(irq_desc->lock),
 }
};
static unsigned int kstat_irqs_all[NR_IRQS][NR_CPUS];
int __init early_irq_init(void)
{
 struct irq_desc *desc;
 int count;
 int i;

 init_irq_default_affinity();

 printk(KERN_INFO "NR_IRQS:%d\n", NR_IRQS);

 desc = irq_desc;
 count = ARRAY_SIZE(irq_desc);

 for (i = 0; i < count; i++) {
 desc[i].irq = i;
 init_alloc_desc_masks(&desc[i], 0, true);
 desc[i].kstat_irqs = kstat_irqs_all[i];
 }
 return arch_early_irq_init();
}

struct irq_desc *irq_to_desc(unsigned int irq)
{
 return (irq < NR_IRQS) ? irq_desc + irq : NULL;
}
struct irq_desc *irq_to_desc_alloc_cpu(unsigned int irq, int cpu)
{
 return irq_to_desc(irq);
}
#endif /* !CONFIG_SPARSE_IRQ */

`init_IRQ()`

init/main.c->start_kernel()->init_IRQ()

/* early_irq_init()函数调用完紧接着就是init_IQR()函数 */
/*arch/x86/kernel/paravirt.c*/
void init_IRQ(void)
{
 pv_irq_ops.init_IRQ();
}

/*pv_irq_ops的定义在arch/x86/kernel/paravirt.c*/
struct pv_irq_ops pv_irq_ops = {
 .init_IRQ = native_init_IRQ,
 .save_fl = __PV_IS_CALLEE_SAVE(native_save_fl),
 .restore_fl = __PV_IS_CALLEE_SAVE(native_restore_fl),
 .irq_disable = __PV_IS_CALLEE_SAVE(native_irq_disable),
 .irq_enable = __PV_IS_CALLEE_SAVE(native_irq_enable),
 .safe_halt = native_safe_halt,
 .halt = native_halt,
#ifdef CONFIG_X86_64
 .adjust_exception_frame = paravirt_nop,
#endif
};

/* 这里的调用关系搞不清楚是通过paravirt.c中的init_IRQ还是直接调用的irqinit_32.c中的init_IRQ然后再调用的native_init_IRQ, 通过irqinit_32.c中的注释：Overridden in paravirt.c 推断应该是直接调用的irqinit_32.c中的代码*/

/*arch/x86/kernel/irqinit_32.c*/
/* Overridden in paravirt.c */
void init_IRQ(void) __attribute__((weak, alias("native_init_IRQ")));

void __init native_init_IRQ(void)
{
 int i;

 /* Execute any quirks before the call gates are initialised: */
 x86_quirk_pre_intr_init();

 /*
 * Cover the whole vector space, no vector can escape
 * us. (some of these will be overridden and become
 * 'special' SMP interrupts)
 */
 for (i = FIRST_EXTERNAL_VECTOR; i < NR_VECTORS; i++) {
 /* SYSCALL_VECTOR was reserved in trap_init. */
 if (i != SYSCALL_VECTOR)
 set_intr_gate(i, interrupt[i-FIRST_EXTERNAL_VECTOR]);
 }
 /*略*/
}

_attribute_((weak, alias(“native_init_IRQ”)));

weak 和 alias 分别是GNU扩展的两个属性。

weak 使得所修饰的符号在目标文件中作为 weak symbol 而不是 global symbol。用 nm 命令查看编译生成的目标文件可用看到所修饰的符号是一个 weak symbol，它前面的标记是 W。给函数加上weak属性时，即使函数没定义，函数被调用也可以编译成功。若两个或两个以上全局符号（函数或变量名）名字一样，而其中之一声明为weak symbol（弱符号），则这些全局符号不会引发重定义错误。链接器会忽略弱符号，去使用普通的全局符号来解析所有对这些符号的引用，但当普通的全局符号不可用时，链接器会使用弱符号。当有函数或变量名可能被用户覆盖时，该函数或变量名可以声明为一个弱符号。

而 alias 为所修饰的符号定义一个别名，前边代码中init_IRQ是native_init_IRQ的一个别名，所定义的别名和原符号名必须在同一个编译单元中定义，如native_init_IRQ和init_IRQ在同一个.c文件中，否则会编译出错。

参考

其中x86_quirk_pre_intr_init函数定义在arch/x86/kernel/setup.c中，主要调用了init_ISA_irqs函数完成中断控制器8259A的初始化。

/**
 * x86_quirk_pre_intr_init - initialisation prior to setting up interrupt vectors
 *
 * Description:
 * Perform any necessary interrupt initialisation prior to setting up
 * the "ordinary" interrupt call gates. For legacy reasons, the ISA
 * interrupts should be initialised here if the machine emulates a PC
 * in any way.
 **/
void __init x86_quirk_pre_intr_init(void)
{
 if (x86_quirks->arch_pre_intr_init) {
 if (x86_quirks->arch_pre_intr_init())
 return;
 }
 init_ISA_irqs();
}
/* init_ISA_irqs函数定义在arch/x86/kernel/irqinit_32.c中 */
void __init init_ISA_irqs(void)
{
 int i;

#ifdef CONFIG_X86_LOCAL_APIC
 init_bsp_APIC();
#endif
 init_8259A(0); // 完成8259A中断控制器的初始化

 /*
 * 16 old-style INTA-cycle interrupts:
 */
 for (i = 0; i < NR_IRQS_LEGACY; i++) {
 struct irq_desc *desc = irq_to_desc(i);

 desc->status = IRQ_DISABLED;
 desc->action = NULL;
 desc->depth = 1;

 set_irq_chip_and_handler_name(i, &i8259A_chip,
 handle_level_irq, "XT");
 }
 /* for循环中初始化了16个 irq_desc_t描述符，*/
}
/* 其中 */
struct irq_chip i8259A_chip = {
 .name = "XT-PIC",
 .mask = disable_8259A_irq,
 .disable = disable_8259A_irq,
 .unmask = enable_8259A_irq,
 .mask_ack = mask_and_ack_8259A,
};
handle_level_irq() 定义在 /kernel/irq/chip.c


/* /kernel/irq/chip.c" */

void
set_irq_chip_and_handler_name(unsigned int irq, struct irq_chip *chip,
 irq_flow_handler_t handle, const char *name)
{
 set_irq_chip(irq, chip); /* 设置chip */
 __set_irq_handler(irq, handle, 0, name);
 /* 设置handle
 desc->handle_irq = handle;
 desc->name = name;
 */
}

/* /kernel/irq/chip.c */
/**
 * set_irq_chip - set the irq chip for an irq
 * @irq: irq number
 * @chip: pointer to irq chip description structure
 */
int set_irq_chip(unsigned int irq, struct irq_chip *chip)
{
 struct irq_desc *desc = irq_to_desc(irq);
 unsigned long flags;

 if (!desc) {
 WARN(1, KERN_ERR "Trying to install chip for IRQ%d\n", irq);
 return -EINVAL;
 }

 if (!chip)
 chip = &no_irq_chip;

 spin_lock_irqsave(&desc->lock, flags);
 irq_chip_set_defaults(chip);
 desc->chip = chip;
 spin_unlock_irqrestore(&desc->lock, flags);

 return 0;
}

之后循环调用set_intr_gate函数，完成中断门的初始化。循环中的几个宏定义如下。

/*arch/x86/include/asm/irq_vectors.h*/
/*
 * IDT vectors usable for external interrupt sources start
 * at 0x20:
 */
#define FIRST_EXTERNAL_VECTOR 0x20

#define NR_VECTORS 256

# define SYSCALL_VECTOR 0x80

即初始化IDT从0x20开始的256个中断门，并跳过0x80。set_intr_gate函数定义在arch/x86/include/asm/desc.h中，定义如下。

/*
 * This needs to use 'idt_table' rather than 'idt', and
 * thus use the _nonmapped_ version of the IDT, as the
 * Pentium F0 0F bugfix can have resulted in the mapped
 * IDT being write-protected.
 */
static inline void set_intr_gate(unsigned int n, void *addr)
{
 BUG_ON((unsigned)n > 0xFF);
 _set_gate(n, GATE_INTERRUPT, addr, 0, 0, __KERNEL_CS);
}
/*
 其中 GATE_INTERRUPT定义如下
 arch/x86/include/asm/desc_defs.h"
 enum {
 GATE_INTERRUPT = 0xE,
 GATE_TRAP = 0xF,
 GATE_CALL = 0xC,
 GATE_TASK = 0x5,
 };
*/

简单总结native_init_IRQ函数主要完成两个工作，

初始化中断控制器；
- 初始化struct desc主要是chip成员和handle_irq成员。
将interrupt[]数组中的中断服务程序地址写进了IDT中。

interrupt[]的定义

参考的第二项：中断之中断向量表IDT的初始化，有对这段代码的注释以及解释。

/*arch/x86/kernel/entry_32.S*/
/*
 * Build the entry stubs and pointer table with some assembler magic.
 * We pack 7 stubs into a single 32-byte chunk, which will fit in a
 * single cache line on all modern x86 implementations.
 */
.section .init.rodata,"a"
ENTRY(interrupt)
.text
 .p2align 5
 .p2align CONFIG_X86_L1_CACHE_SHIFT
ENTRY(irq_entries_start)
 RING0_INT_FRAME
vector=FIRST_EXTERNAL_VECTOR
.rept (NR_VECTORS-FIRST_EXTERNAL_VECTOR+6)/7
 .balign 32
 .rept 7
 .if vector < NR_VECTORS
 .if vector <> FIRST_EXTERNAL_VECTOR
 CFI_ADJUST_CFA_OFFSET -4
 .endif
1: pushl $(~vector+0x80) /* Note: always in signed byte range */
 CFI_ADJUST_CFA_OFFSET 4
 .if ((vector-FIRST_EXTERNAL_VECTOR)%7) <> 6
 jmp 2f
 .endif
 .previous
 .long 1b
 .text
vector=vector+1
 .endif
 .endr
2: jmp common_interrupt
.endr
END(irq_entries_start)

.previous
END(interrupt)
.previous

主要包含两行代码pushl $(~vector+0x80) 和jmp common_interrupt,即把中断号减去256的结果保存到栈中，然后调用通用中断处理程序。之所以要减去256，是因为内核用负数表示所有的中断，正数表示系统调用。

.rept语法

.rept count Repeat the sequence of lines between the .rept directive and the next .endr directive count times. For example, assembling .rept 3 .long 0 .endr is equivalent to assembling .long 0 .long 0 .long 0

参考

.IF、.ELSE、.ELSEIF 和 .ENDIF 伪指令使得程序员易于对多分支逻辑进行编码。它们让汇编器在后台生成 CMP 和条件跳转指令，这些指令显示在输出列表文件中。语法如下所示：

.IF conditionl statements [.ELSEIF condition2 statements ] [.ELSE statements ] .ENDIF

方括号表示 .ELSEIF 和 .ELSE 是可选的，而 .IF 和 .ENDIF 则是必需的。condition（条件）是布尔表达式，

参考

数组中每个元素的初始值是标号1的地址。因此访问数组中的元素时，都会跳到标号1处，执行相应的指令。也就是，在除了0~19号和0x80号中断外，其余的所有中断在进入其自己的中断服务程序之前，必须是先条转执行common_interrupt的.

common_interrupt的定义


/*
 * the CPU automatically disables interrupts when executing an IRQ vector,
 * so IRQ-flags tracing has to follow that:
 */
 .p2align CONFIG_X86_L1_CACHE_SHIFT
common_interrupt:
 addl $-0x80,(%esp) /* Adjust vector into the [-256,-1] range */
 SAVE_ALL
 TRACE_IRQS_OFF
 movl %esp,%eax
 call do_IRQ
 jmp ret_from_intr
ENDPROC(common_interrupt)
 CFI_ENDPROC

保存寄存器的值以后，栈顶的地址被存放到eax寄存器，然后中断处理程序调用do_IRQ()函数，执行do_IRQ()的ret指令时，控制跳转到ret_from_intr()。

do_IRQ函数

/* arch/x86/kernel/irq.c */
/*
 * do_IRQ handles all normal device IRQ's (the special
 * SMP cross-CPU interrupts have their own specific
 * handlers).
 */
unsigned int __irq_entry do_IRQ(struct pt_regs *regs)
{
 struct pt_regs *old_regs = set_irq_regs(regs);

 /* high bit used in ret_from_ code */
 unsigned vector = ~regs->orig_ax; // 取得对应的中断向量
 unsigned irq;

 exit_idle();
 irq_enter();

 irq = __get_cpu_var(vector_irq)[vector];

 if (!handle_irq(irq, regs)) { //调用中断处理句柄，对8259，就是handle_level_irq
#ifdef CONFIG_X86_64
 if (!disable_apic)
 ack_APIC_irq();
#endif
 if (printk_ratelimit())
 printk(KERN_EMERG "%s: %d.%d No irq handler for vector (irq %d)\n",
 __func__, smp_processor_id(), vector, irq);
 }
 irq_exit();

 set_irq_regs(old_regs);
 return 1;
}

handle_irq

搜索发现此函数在arch/x86/kernel/irq_32.c"中定义

bool handle_irq(unsigned irq, struct pt_regs *regs)
{
 struct irq_desc *desc;
 int overflow;

 overflow = check_stack_overflow();

 desc = irq_to_desc(irq);
 if (unlikely(!desc))
 return false;

 if (!execute_on_irq_stack(overflow, desc, irq)) {
 if (unlikely(overflow))
 print_stack_overflow();
 desc->handle_irq(irq, desc);
 /* 在这里调用了之前注册的handler_irq函数
 init_ISA_irqs()
 -> set_irq_chip_and_handler_name(i, &i8259A_chip,
 handle_level_irq, "XT");
 -> __set_irq_handler(irq, handle, 0, name);
 -> desc->handle_irq = handle;
 即handle_level_irq
 -> handle_IRQ_event(irq, action);
 -> do {
 ret = action->handler(irq, action->dev_id);
 action = action->next;
 } while (action);
 */
 }

 return true;
}

注册中断

在Linux内核申请中断的函数是request_irq(),函数原型定义在include/linux/interrupt.h中，

request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
 const char *name, void *dev);
/*
 irq : 要申请的硬件中断号；
 handler : 中断服务函数指针；
 flags: 中断处理的属性，
 若设置了IRQF_DISABLED则表示是快速中断，快速中断在处理过程中会屏蔽其他中断。
 若设置了IRQD_SHARED则表示多个设备共享此中断。
 若设置了IRQF_SAMPLE_RANDOM则表示对系统产生随机数有作用。
 IRQF_TRIGGER_* 其中*可以是中断触发方式，定义在include/linux/interrupt.h中。
 name : 中断名字，/proc/interrupts文件系统中显示；
 dev : 中断共享时可以用到，一般设置为这个设备的设备结构体或者NULL

 返回值：
 0 : 成功 ；
 -INVAL : 表示中断号无效或处理函数指针为NULL ；
 -EBUSY : 表示中断已经被占用且不能共享。
*/

关于request_irq()的最后一个参数dev

中断发生时，内核并不判断是共享中断线上的哪个设备产生了中断，它会循环执行所有该中断线上注册的所有中断服务函数（irqaction->handler函数）。因此irqaction->handler函数需要自己判断具体的中断源。很多资料都建议将设备结构指针作为此参数的值，当中断发生时，迅速根据硬件寄存器中的信息比照传入的dev参数判断是否是本设备发出的中断。而且free_irq()函数也需要据此判断从共享中断线上移除哪一个irqaction

代码流程


/*include/linux/interrupt.h*/
static inline int __must_check
request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
 const char *name, void *dev)
{
 return request_threaded_irq(irq, handler, NULL, flags, name, dev);
}

extern void exit_irq_thread(void);
#else

extern int __must_check
request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
 const char *name, void *dev);

主要调用了request_threaded_irq()函数，此函数定义在kernel/irq/manage.c中，


/**
 * request_threaded_irq - allocate an interrupt line
 * @irq: Interrupt line to allocate
 * @handler: Function to be called when the IRQ occurs.
 * Primary handler for threaded interrupts
 * @thread_fn: Function called from the irq handler thread
 * If NULL, no irq thread is created
 * @irqflags: Interrupt type flags
 * @devname: An ascii name for the claiming device
 * @dev_id: A cookie passed back to the handler function
 *
 * This call allocates interrupt resources and enables the
 * interrupt line and IRQ handling. From the point this
 * call is made your handler function may be invoked. Since
 * your handler function must clear any interrupt the board
 * raises, you must take care both to initialise your hardware
 * and to set up the interrupt handler in the right order.
 *
 * If you want to set up a threaded irq handler for your device
 * then you need to supply @handler and @thread_fn. @handler ist
 * still called in hard interrupt context and has to check
 * whether the interrupt originates from the device. If yes it
 * needs to disable the interrupt on the device and return
 * IRQ_THREAD_WAKE which will wake up the handler thread and run
 * @thread_fn. This split handler design is necessary to support
 * shared interrupts.
 *
 * Dev_id must be globally unique. Normally the address of the
 * device data structure is used as the cookie. Since the handler
 * receives this value it makes sense to use it.
 *
 * If your interrupt is shared you must pass a non NULL dev_id
 * as this is required when freeing the interrupt.
 *
 * Flags:
 *
 * IRQF_SHARED Interrupt is shared
 * IRQF_DISABLED Disable local interrupts while processing
 * IRQF_SAMPLE_RANDOM The interrupt can be used for entropy
 * IRQF_TRIGGER_* Specify active edge(s) or level
 *
 */

int request_threaded_irq(unsigned int irq, irq_handler_t handler,
 irq_handler_t thread_fn, unsigned long irqflags,
 const char *devname, void *dev_id)
{
 struct irqaction *action;
 struct irq_desc *desc;
 int retval;

 /*
 * handle_IRQ_event() always ignores IRQF_DISABLED except for
 * the _first_ irqaction (sigh). That can cause oopsing, but
 * the behavior is classified as "will not fix" so we need to
 * start nudging drivers away from using that idiom.
 */
 if ((irqflags & (IRQF_SHARED|IRQF_DISABLED)) ==
 (IRQF_SHARED|IRQF_DISABLED)) {
 pr_warning(
 "IRQ %d/%s: IRQF_DISABLED is not guaranteed on shared IRQs\n",
 irq, devname);
 }

 /*省略一些状态检查的代码*/

 desc = irq_to_desc(irq);
 if (!desc)
 return -EINVAL;
 action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
 if (!action)
 return -ENOMEM;

 action->handler = handler; /* 注册中断服务函数 */
 action->thread_fn = thread_fn;
 action->flags = irqflags;
 action->name = devname;
 action->dev_id = dev_id;

 retval = __setup_irq(irq, desc, action);
 if (retval)
 kfree(action);
 /* 省略一部分 */
 return retval;
}
EXPORT_SYMBOL(request_threaded_irq);

首先从irq拿到struct desc，然后初始化了struct desc结构的action结构，最后调用了__setup_irq()函数。

__setup_irq()函数还调用了内核线程的创建kthread_create()等等，暂时不做分析。

中断处理流程

注册流程：

系统初始化时 : 调用init_IRQ()，此函数间接调用init_ISA_irq()函数，初始化PIC以及struct irq_desc数组，填充了struct irq_desc元素的handler_irq和chip结构。之后调用set_intr_gate()将interrupts数组设置到系统的IDT中。
在内核代码中调用request_irq()函数，将中断服务程序注册到irqaction结构中，调用__setup_irq()函数。

中断发生时：先去IDT表中找到相应的中断门描述符，根据中断门描述符找到GDTR中相应的代码段，再根据中断门描述符中代码偏移，到相应代码段中找到中断服务程序入口，即common_interrupt，此函数先保存现场，然后将中断号压入栈，调用do_IRQ()函数，此函数调用desc->handle_irq即handle_level_irq，又调用了handle_IRQ_event()，此函数中循环调用action->handler()，间接调用到request_irq()函数注册的回调函数。

小结

本文主要基于x86平台对应linux 2.6.30.4版本的内核源码，对linux中断的初始化过程进行简单分析。还有一些东西没有弄懂，留待以后分析。

__setup_irq()函数；
中断发生时代码执行到action->handler()的过程；
free_irq()的执行流程；
从中断中返回；
软中断及tasklet；
一些其他细节；

参考

x86体系结构下Linux-2.6.26的中断处理

中断之中断向量表IDT的初始化

x86平台linux系统调用分析

yuanye.ma@qq.com (Yuanye Ma) — Mon, 15 Apr 2019 16:01:23 +0800

x86平台linux系统调用分析

[toc]

kernel version : linux 2.6.30.4

x86 系统调用整体流程

用户空间调用libc库的syscall函数，此函数内嵌汇编，汇编代码先将系统调用号写入eax寄存器，其他参数写入ebx ecx edx esi edi五个寄存器，若参数总个数超过五个，则应该用一个单独的寄存器存放指向所有这些参数在用户空间地址的指针。然后调用int 0x80指令陷入内核。

CPU从IDTR中得到IDT（中断向量表）地址，并根据中断号(0x80)找到IDT下标为0x80的元素，即门描述符，检查CPL=3, 门描述符DPL=0，不相符，发生栈切换。

CPU根据寄存器TR的内容找到当前TSS,并根据目标代码段的DPL，从TSS结构中取出新的堆栈指针（SS和ESP），并装入其堆栈段寄存器SS和堆栈指针ESP中，达到更换堆栈的目的。这种情况下CPU不但要将EFLAGS、返回地址以及出错代码压入堆栈，还要先将原来的堆栈指针也压入新堆栈中。

栈切换完成后，CPU从陷阱门描述符中找到中断服务程序所在内存段的段选择子和地址偏移，根据段选择子去GDT或者LDT中找到对应的段描述符，装入CS段选择寄存器，找到段基地址，并加上地址偏移后找到中断服务程序入口地址，跳转过去运行。

中断向量表IDT的初始化

基于linux 2.6.30.4

/* "arch/x86/kernel/traps.c" */
void __init trap_init(void)
{
 set_intr_gate(0, &divide_error);
 set_intr_gate_ist(1, &debug, DEBUG_STACK);
 set_intr_gate_ist(2, &nmi, NMI_STACK);
 /* int3 can be called from all */
 set_system_intr_gate_ist(3, &int3, DEBUG_STACK);
 /* int4 can be called from all */
 set_system_intr_gate(4, &overflow);
 set_intr_gate(5, &bounds);
 set_intr_gate(6, &invalid_op);
 set_intr_gate(7, &device_not_available);

 set_task_gate(8, GDT_ENTRY_DOUBLEFAULT_TSS);
 set_intr_gate(9, &coprocessor_segment_overrun);
 set_intr_gate(10, &invalid_TSS);
 set_intr_gate(11, &segment_not_present);
 set_intr_gate_ist(12, &stack_segment, STACKFAULT_STACK);
 set_intr_gate(13, &general_protection);
 set_intr_gate(14, &page_fault);
 set_intr_gate(15, &spurious_interrupt_bug);
 set_intr_gate(16, &coprocessor_error);
 set_intr_gate(17, &alignment_check);

 set_system_trap_gate(SYSCALL_VECTOR, &system_call);
 /*
 SYSCALL_VECTOR
 arch/x86/include/asm/irq_vectors.h:36:# define SYSCALL_VECTOR 0x80
 asmlinkage int system_call(void);
 */

 cpu_init();
}

程序中首先设置中断向量表的头19个陷阱门，这些中断向量表都是CPU保留用于异常处理的。

set_intr_gate() 等函数都调用了_set_gate()函数设置门描述符，本文重点分析系统调用相关的内容，即 set_system_trap_gate()函数。

/*"arch/x86/include/asm/desc.h" */

/*
 set_system_trap_gate(SYSCALL_VECTOR, &system_call);
 参数
 n = SYSCALL_VECTOR = 0x80;
 addr = &system_call
*/
static inline void set_system_trap_gate(unsigned int n, void *addr)
{
 BUG_ON((unsigned)n > 0xFF);
 _set_gate(n, GATE_TRAP, addr, 0x3, 0, __KERNEL_CS);
}

_set_gate()函数完成设置门描述符的工作。

/*
 _set_gate(n, GATE_TRAP, addr, 0x3, 0, __KERNEL_CS);
 "arch/x86/include/asm/desc_defs.h"
 enum {
 GATE_INTERRUPT = 0xE,
 GATE_TRAP = 0xF,
 GATE_CALL = 0xC,
 GATE_TASK = 0x5,
 };
 arch/x86/include/asm/segment.h
 #define __KERNEL_CS (GDT_ENTRY_KERNEL_CS * 8)
 #define GDT_ENTRY_KERNEL_CS 2
*/

static inline void _set_gate(int gate, unsigned type, void *addr,
 unsigned dpl, unsigned ist, unsigned seg)
{
 /*
 参数如下：
 gate = n = SYSCALL_VECTOR = 0x80;
 type = GATE_TRAP = 0xF;
 addr = &system_call;
 dpl = 0x3;
 ist = 0;
 seg = __KERNEL_CS = 2*8;
 */
 gate_desc s;
 pack_gate(&s, type, (unsigned long)addr, dpl, ist, seg);
 /*
 * does not need to be atomic because it is only done once at
 * setup time
 */
 write_idt_entry(idt_table, gate, &s);
}

先看看第一行gate_desc s;，主要分配了门描述符的结构。

/*gate_desc 结构 "arch/x86/include/asm/desc_defs.h" */
typedef struct desc_struct gate_desc;
struct desc_struct {
 union {
 struct {
 unsigned int a; // 4字节
 unsigned int b; // 4字节
 };
 struct {
 u16 limit0; // 2字节 位移的低16位
 u16 base0; // 2字节 段选择码
 unsigned base1: 8, type: 4, s: 1, dpl: 2, p: 1; // 2字节
 unsigned limit: 4, avl: 1, l: 1, d: 1, g: 1, base2: 8; //2字节
 };
 };
} __attribute__((packed));

attribute ((packed)) 的作用就是告诉编译器取消结构在编译过程中的优化对齐,按照实际占用字节数进行对齐，是GCC特有的语法。这个功能是跟操作系统没关系，跟编译器有关，gcc编译器不是紧凑模式的，在windows下，用vc的编译器也不是紧凑的，用tc的编译器就是紧凑的。

例如：

在TC下：struct my{ char ch; int a;} sizeof(int)=2;sizeof(my)=3;（紧凑模式）
在GCC下：struct my{ char ch; int a;} sizeof(int)=4;sizeof(my)=8;（非紧凑模式）
在GCC下：struct my{ char ch; int a;}attrubte ((packed)) sizeof(int)=4;sizeof(my)=5

struct desc_struct包含一个联合体，可以用其中任何一种类型，后边可以看到pack_gate()函数使用联合体中的第一种，即struct {unsigned int a; unsigned int b};。

/*
参数
 gate = n = SYSCALL_VECTOR = 0x80;
 type = GATE_TRAP = 0xF;
 addr = &system_call;
 dpl = 0x3;
 ist = 0;
 seg = __KERNEL_CS = 2*8;
*/
static inline void pack_gate(gate_desc *gate, unsigned char type,
 unsigned long base, unsigned dpl, unsigned flags,
 unsigned short seg)
{
 gate->a = (seg << 16) | (base & 0xffff);
 gate->b = (base & 0xffff0000) |
 (((0x80 | type | (dpl << 5)) & 0xff) << 8);
}

pack_gate()此函数包装一个陷阱门描述符。gate->a在低地址。

/*
gate->a = (seg << 16) | (base & 0xffff);
gate->a = ((2*8)<<16 | (&system_call & 0xffff);
(&system_call & 0xffff) : 中断服务函数地址段内偏移的低16位
((2*8)<<16 : 段选择码，即中断服务函数所在代码段选择子在GTD或者LDT中的下标。
gate->b = (base & 0xffff0000) | (((0x80 | type | (dpl << 5)) & 0xff) << 8);
gate->b = (&system_call & 0xffff0000) | (((0x80 | 0xF | (0x3 << 5)) & 0xff) << 8)
解析
0x80 : 1000 0000
0xf : 0000 1111
0x3 : 0000 0011
0xff : 1111 1111
0x80 | 0xF = 0x8f : 1000 1111
0x3 << 5 = 0110 0000
(0x80 | 0xF | (0x3 << 5)) = 1110 1111
((0x80 | 0xF | (0x3 << 5)) & 0xff) = 1110 1111
(((0x80 | 0xF | (0x3 << 5)) & 0xff) << 8) = 1110 1111 0000 0000
对应到门描述符
(&system_call & 0xffff0000) : 中断服务函数地址段内偏移的高16位
P ： 1 ： 内存段在内存中
DPL ： 11 ：DPL = 3
0 ： 永远为0
D ： 1 表示32位
111 ： 类型码 ： 陷阱门
*/

#define write_idt_entry(dt, entry, g) \
 native_write_idt_entry(dt, entry, g)

/*
参数
 idt = idt_table;
 entry = gate = n = SYSCALL_VECTOR = 0x80;;
 gate = &s；
其中
 gate_desc idt_table[256]
 __attribute__((__section__(".data.idt"))) = { { { { 0, 0 } } }, };

 typedef struct desc_struct gate_desc;
*/
static inline void native_write_idt_entry(gate_desc *idt, int entry,
 const gate_desc *gate)
{
 memcpy(&idt[entry], gate, sizeof(*gate));
}

native_write_idt_entry()此函数将pack_gate()函数封装的陷阱门描述符拷贝进idt的0x80位置。

系统调用的中断服务程序分析

/*arch/x86/kernel/entry_32.S*/

 # system call handler stub
ENTRY(system_call)
 RING0_INT_FRAME # can't unwind into user space anyway
 pushl %eax # save orig_eax
 CFI_ADJUST_CFA_OFFSET 4
 SAVE_ALL
 GET_THREAD_INFO(%ebp) # system call tracing in operation / emulation
 testl $_TIF_WORK_SYSCALL_ENTRY,TI_flags(%ebp)
 jnz syscall_trace_entry
 cmpl $(nr_syscalls), %eax
 jae syscall_badsys
syscall_call:
 call *sys_call_table(,%eax,4)
 movl %eax,PT_EAX(%esp) # store the return value
syscall_exit:
 LOCKDEP_SYS_EXIT
 DISABLE_INTERRUPTS(CLBR_ANY) # make sure we don't miss an interrupt
 # setting need_resched or sigpending
 # between sampling and the iret
 TRACE_IRQS_OFF
 movl TI_flags(%ebp), %ecx
 testl $_TIF_ALLWORK_MASK, %ecx # current->work
 jne syscall_exit_work

先将%eax（系统调用号）压入栈，然后调用SAVE_ALL保存中断现场，检查系统调用号，跳转到相应的而系统调用函数去执行call *sys_call_table(,%eax,4)，sys_call_table定义如下，是一个函数指针列表。

/*arch/x86/kernel/syscall_table_32.S*/
ENTRY(sys_call_table)
 .long sys_restart_syscall /* 0 - old "setup()" system call, used for restarting */
 .long sys_exit
 .long ptregs_fork
 .long sys_read
 .long sys_write
 .long sys_open /* 5 */
 .long sys_close
 .long sys_waitpid
 .long sys_creat
 .long sys_link
 .long sys_unlink /* 10 */
 .long ptregs_execve
 .long sys_chdir
 .long sys_time
 /* 略 */

关于SAVE_ALL

.macro SAVE_ALL
 cld
 PUSH_GS
 pushl %fs
 CFI_ADJUST_CFA_OFFSET 4 # 这些宏暂时不知道干啥的
 /*CFI_REL_OFFSET fs, 0;*/
 pushl %es
 CFI_ADJUST_CFA_OFFSET 4
 /*CFI_REL_OFFSET es, 0;*/
 pushl %ds
 CFI_ADJUST_CFA_OFFSET 4
 /*CFI_REL_OFFSET ds, 0;*/
 pushl %eax
 CFI_ADJUST_CFA_OFFSET 4
 CFI_REL_OFFSET eax, 0
 pushl %ebp
 CFI_ADJUST_CFA_OFFSET 4
 CFI_REL_OFFSET ebp, 0
 pushl %edi
 CFI_ADJUST_CFA_OFFSET 4
 CFI_REL_OFFSET edi, 0
 pushl %esi
 CFI_ADJUST_CFA_OFFSET 4
 CFI_REL_OFFSET esi, 0
 pushl %edx
 CFI_ADJUST_CFA_OFFSET 4
 CFI_REL_OFFSET edx, 0
 pushl %ecx
 CFI_ADJUST_CFA_OFFSET 4
 CFI_REL_OFFSET ecx,
 pushl %ebx
 CFI_ADJUST_CFA_OFFSET 4
 CFI_REL_OFFSET ebx, 0
 movl $(__USER_DS), %edx
 movl %edx, %ds
 movl %edx, %es
 movl $(__KERNEL_PERCPU), %edx
 movl %edx, %fs
 SET_KERNEL_GS %edx
.endm

穿插一些宏暂时不知道干什么的，先不管。主要看一下寄存器的压栈顺序：%es %ds %eax %ebp %edi %esi %edx %ecx %ebx

系统调用的定义

/* include/linux/syscalls.h */
#define SYSCALL_DEFINE0(sname) \
 static const struct syscall_metadata __used \
 __attribute__((__aligned__(4))) \
 __attribute__((section("__syscalls_metadata"))) \
 __syscall_meta_##sname = { \
 .name = "sys_"#sname, \
 .nb_args = 0, \
 }; \
 asmlinkage long sys_##sname(void)

#else
#define SYSCALL_DEFINE0(name) asmlinkage long sys_##name(void)
#endif
#define SYSCALL_DEFINE1(name, ...) SYSCALL_DEFINEx(1, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE2(name, ...) SYSCALL_DEFINEx(2, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE3(name, ...) SYSCALL_DEFINEx(3, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE4(name, ...) SYSCALL_DEFINEx(4, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE5(name, ...) SYSCALL_DEFINEx(5, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE6(name, ...) SYSCALL_DEFINEx(6, _##name, __VA_ARGS__)

/* 其中 SYSCALL_DEFINEx*/
#ifdef CONFIG_FTRACE_SYSCALLS /*ftrace是内核提供的一种调试工具*/
#define SYSCALL_DEFINEx(x, sname, ...) \
 static const char *types_##sname[] = { \
 __SC_STR_TDECL##x(__VA_ARGS__) \
 }; \
 static const char *args_##sname[] = { \
 __SC_STR_ADECL##x(__VA_ARGS__) \
 }; \
 SYSCALL_METADATA(sname, x); \
 __SYSCALL_DEFINEx(x, sname, __VA_ARGS__)
#else
#define SYSCALL_DEFINEx(x, sname, ...) \
 __SYSCALL_DEFINEx(x, sname, __VA_ARGS__)
#endif

#ifdef CONFIG_HAVE_SYSCALL_WRAPPERS

#define SYSCALL_DEFINE(name) static inline long SYSC_##name

#define __SYSCALL_DEFINEx(x, name, ...) \
 asmlinkage long sys##name(__SC_DECL##x(__VA_ARGS__)); \
 static inline long SYSC##name(__SC_DECL##x(__VA_ARGS__)); \
 asmlinkage long SyS##name(__SC_LONG##x(__VA_ARGS__)) \
 { \
 __SC_TEST##x(__VA_ARGS__); \
 return (long) SYSC##name(__SC_CAST##x(__VA_ARGS__)); \
 } \
 SYSCALL_ALIAS(sys##name, SyS##name); \
 static inline long SYSC##name(__SC_DECL##x(__VA_ARGS__))

#else /* CONFIG_HAVE_SYSCALL_WRAPPERS */

#define SYSCALL_DEFINE(name) asmlinkage long sys_##name
#define __SYSCALL_DEFINEx(x, name, ...) \
 asmlinkage long sys##name(__SC_DECL##x(__VA_ARGS__))

#endif /* CONFIG_HAVE_SYSCALL_WRAPPERS */

/* 后边是所有系统调用的函数声明 */
asmlinkage long sys_time(time_t __user *tloc);

系统调用的定义分布在内核源代码多个源文件中find . -type f -name "*.c" | xargs grep SYSCALL_DEFINE | wc -l

系统调用号

每个系统调用xxx都对应着一个系统调用号__NR_xxx。当应用程序调用某系统调用时，寄存器eax中保存该系统调用对应的系统调用号。系统调用号定义于如下头文件中：

include/linux/unistd.h
+- arch/x86/include/asm/unistd.h
 +- arch/x86/include/asm/unistd_32.h
 | +- ...
 | +- #define __NR_process_vm_writev 348
 | +- #define NR_syscalls 349
 +- arch/x86/include/asm/unistd_64.h
 +- ...
 +- #define __NR_process_vm_writev 311
 +- __SYSCALL(__NR_process_vm_writev, sys_process_vm_writev)

在应用程序中仅需包含头文件#include <unistd.h>即可。

#ifndef _LINUX_UNISTD_H_
#define _LINUX_UNISTD_H_

/*
 * Include machine specific syscall numbers
 */
#include <asm/unistd.h>

#endif /* _LINUX_UNISTD_H_ */

对于x86而言，asm/unistd.h即为arch/x86/include/asm/unistd.h:

#ifdef __KERNEL__
# ifdef CONFIG_X86_32
# include "unistd_32.h"
# else
# include "unistd_64.h"
# endif
#else
# ifdef __i386__
# include "unistd_32.h"
# else
# include "unistd_64.h"
# endif
#endif

对于x86 32-bit而言，unistd_32.h即为arch/x86/include/asm/unistd_32.h:
#define __NR_restart_syscall 0
#define __NR_exit 1
#define __NR_fork 2
#define __NR_read 3
#define __NR_write 4
#define __NR_open 5
#define __NR_close 6
...
#define __NR_process_vm_readv 347
#define __NR_process_vm_writev 348

#ifdef __KERNEL__
#define NR_syscalls 349
#endif

系统调用的返回值

如果系统调用执行失败，系统调用并不直接返回错误码，而是将错误码保存到全局变量errno中，因而可根据errno的值来确定错误类型。错误码定义于如下头文件中：

include/linux/errno.h // 错误码512-530
-> arch/x86/include/asm/errno.h // 仅包含asm-generic/errno.h，未新增错误码
 -> include/asm-generic/errno.h // 错误码35-133
 -> include/asm-generic/errno-base.h // 错误码1-34

也可以执行 man errno查询到。

新增系统调用

通过修改内核代码

确定新增的系统调用号
1. 修改arch/x86/include/asm/unistd_32.h，为新增的系统调用定义的系统调用号#define _NR_testsyscall 350
2. 修改arch/x86/kernel/syscall_table_32.S，将新增的系统调用加入到系统调用表，即数组sys_call_table中写入：long sys_testsyscall /* 350 */
编写新增的系统调用编写一个系统调用意味着要给内核增加一个函数，将该函数写入文件kernel/sys.c中，代码如下：
1 2 3 4 5

SYSCALL_DEFINE0(testsyscall) { console_print("hello world\n"); return 0; }
使用新增的系统调用因为C库中没有新增的系统调用的程序段，必须自己建立其代码，如下：
1 2 3 4 5 6

#inculde <syscalls.h> SYSCALL_DEFINE0(testsyscall) void main() { tsetsyscall(); }

通过编写插入内核模块

编写系统调用内核模块

 #inculde <linux/kernel.h>
 #inculde <linux/module.h>
 #inculde <linux/modversions.h>
 #inculde <linux/sched.h>
 #inculde <asm/uaccess.h>

 #define _NR_testsyscall 350

 extern void *sys_call_table[];

 asmlinkage long testsyscall()
 {
 printf("hello world\n");
 return 0;
 }

 int syscall_test_init()
 {
 sys_call_table[_NR_tsetsyscall] = testsyscall;
 printf("system call testsyscall() loaded success\n");
 return 0;
 }
 module_init(syscall_test_init);

 void syscall_test_exit()
 {
 }
 module_exit(syscall_test_exit)

编写使用新增的系统调用的代码
编译内核模块并插入内核模块

从用户空间直接访问系统调用

方式一：通过C库函数，C库函数封装了所有的系统调用。

方式二：2.6.18版本之前的内核可以使用_syscall宏。但是自2.6.19版本开始，_syscall宏被废除，我们需要使用syscall函数，通过指定系统调用号和一组参数来调用系统调用。

#include <unistd.h> 
#include <sys/syscall.h> 
#include <sys/types.h> 
#define __NR_gettid 224
int main(int argc, char *argv[])
{
 pid_t tid;

 tid = syscall(__NR_gettid); //括号内参数直接写224也可以
 /*也可以写成tid = syscall(SYS_gettid);*/
}

参考

注： syscall()函数是glibc中的一个用户空间函数，可以通过man syscall命令查看，函数声明在/usr/include/unistd.h中，对应系统调用号在/usr/include/asm-generic/unistd.h中声明。

OS Basics on Yuanye Ma's Blog

x86汇编从实模式到保护模式实验

x86汇编从实模式到保护模式实验

实验一

安装nasm

写入代码，并编译

创建虚拟机镜像，并启动虚拟机查看实验结果

创建一个虚拟硬盘，并写入MBR

Bochs

代码解释

X86汇编

X86汇编

通用寄存器

使用内存

存储模式

汇编指令

基础指令

连续复制数据指令

堆栈操作

修改EIP的指令

函数

函数调用

参数传递

ESP寻址

EBP寻址

JCC指令

清华大学-汇编语言程序设计

基础知识

X86汇编（AT&T风格）

80x86计算机组成与保护模式

X86指令系统与寻址方式

AT&T和Intel汇编格式主要区别

linux内核中的汇编语言规则

哈工大李治军操作系统

linux内核中使用了三种汇编

GDT LDT IDT TSS

GDT LDT IDT TSS

GDT & GDTR

LDT & LDTR

IDT & IDTR

TSS & TR

DPL & CPL & RPL

GNU C 内联汇编

GNU C 内联汇编

基本形式

操作数限定字符

gcc 对内嵌汇编语言的处理方式

x86平台Linux中断机制

x86平台Linux中断机制

基础知识

关于I/O APIC的一些更详细的资料

基本数据结构

irq_desc_t

irq_chip

irqaction

中断初始化

IDT初步初始化

IDT最终初始化

trap_init()

early_irq_init()

init_IRQ()

interrupt[]的定义

common_interrupt的定义

do_IRQ函数

handle_irq

注册中断

中断处理流程

小结

参考

x86平台linux系统调用分析

x86平台linux系统调用分析

x86 系统调用整体流程

中断向量表IDT的初始化

系统调用的中断服务程序分析

系统调用的定义

系统调用号

系统调用的返回值

新增系统调用

通过修改内核代码

通过编写插入内核模块

`IDT`初步初始化

`IDT`最终初始化

`trap_init()`

`early_irq_init()`

`init_IRQ()`