问题

本机环境：
OS: Arch Linux x86_64
声卡：C-Media_R__Audio

这几天面试，发现电脑能正常输入音频数据（麦克风），但是无法接收音频数据（扬声器）。
具体问题是：

1. pavucontrol 命令打开的界面，输出设备中只有一个 HDMI 的输出（笔记本外接显示器）。
2. alsamixer 进入后按 F6 查看有 HDA NVidia 和 C-Media(R) Audio 两个声卡，且重新选择后 pavucontrol 依旧只有一个 HDMI 的输出。电脑无法进行音量输出。
3. 排除硬件故障，在 Windows 中能正常工作。

解决方案

安装 pulseaudio 以及 pulseaudio-alsa，或者安装 pipewire-pulse、pipewire-alsa、wireplumber。二选一，都装会有冲突。我本机是使用的 pulseaudio。

使用 aplay -l 命令查看自己有几个声卡，这一步输出后续会用到：

1
2
3
4
5
6
7
8
9
10
11

➜  ~ aplay -l
**** List of PLAYBACK Hardware Devices ****
card 0: NVidia [HDA NVidia], device 3: HDMI 0 [27M1C5500V]
  Subdevices: 1/1
  Subdevice #0: subdevice #0
card 0: NVidia [HDA NVidia], device 7: HDMI 1 [HDMI 1]
  Subdevices: 1/1
  Subdevice #0: subdevice #0
card 1: Audio [C-Media(R) Audio], device 0: USB Audio [USB Audio]
  Subdevices: 1/1
  Subdevice #0: subdevice #0

修改前先列出系统中所有可用的音频输出设备（sinks）。

1
2
3

pactl list short sinks
# 此时没有 C-Media Audio 的输出设备
# 1	alsa_output.pci-0000_01_00.1.hdmi-stereo        module-alsa-card.c      s16le 2ch 44100Hz       IDLE

之后重新加载相关模块后再查看可用音频输出设备

1
2
3
4
5

pactl unload-module module-udev-detect
pactl load-module module-udev-detect
pactl list short sinks
1       alsa_output.hw_1_0      module-alsa-sink.c      s16le 2ch 44100Hz       IDLE
2       alsa_output.pci-0000_01_00.1.hdmi-stereo        module-alsa-card.c      s16le 2ch 44100Hz       IDLE

此时在 pavucontrol 中应该也能查看到网卡设备，选择输出就行，问题基本上就解决了，应该是模块加载顺序可能有问题，导致某些设备没有被正常检测到，重新加载一下就好了。唯一的问题是每次开机都要重新加载模块，这比较麻烦，此时就需要修改相关配置文件：

1
2
3
4
5
6
7

sudo vim /etc/pulse/default.pa

# 如果有，将这一行前面的注释去除
load-module module-udev-detect

# 最后在该文件末尾添加（1,0 含义是前面 aplay -l 输出的信息， card "1", device "0", PCI设备管理相关的，知道怎么改自己的就够了）
load-module module-alsa-sink device=hw:1,0

重启查看是否能检测到扬声器。

环境配置

DPDK 系统要求：

Kernel version >= 4.14
GCC（版本 5.0+）或 Clang（版本 3.6+）
Python 3.6 或更高版本
Meson (version 0.53.2+) and ninja
pyelftools （版本 0.22+）

笔者环境：

内核版本： 6.6.32-1-lts
发行版： ArchLinux
gcc 版本 14.1.1 20240522
Python 3.12.3
Meson 1.4.1
pyelftools 0.31-2

环境配置

1. 检查当前内核是否支持

1
2
3
4
5
6
7
8
9
10

# 查看当前内核是否支持
zgrep -E "HUGETLBFS|PROC_PAGE_MONITOR" /proc/config.gz
CONFIG_PROC_PAGE_MONITOR=y
CONFIG_HUGETLBFS=y
# 查看高精度事件定时器
zgrep -E "HPET" /proc/config.gz     
CONFIG_HPET_TIMER=y
CONFIG_HPET_EMULATE_RTC=y
CONFIG_HPET=y
# CONFIG_HPET_MMAP is not set

如果不支持 HUGETLBFS 或者 PROC_PAGE_MONITOR，重编内核。

2. 安装上述环境

1
2

sudo pacman -S gcc clang pkgconf python meson ninja python-pyelftools numactl
sudo pacman -S libarchive libelf

3. 配置大页

最简单的配置，只使用 2MB 的大页，没有配置 1GB 的，如果有需要可以官网查教程。

非 root 用户使用 sudo vim 操作下面文件填写自己认为适合的数值，不太离谱都行。

1

echo 1024 > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages

HugePages_Total 不为 0 就代表成功。

1
2
3
4
5
6
7
8
9
10

➜  ~ cat /proc/meminfo | grep Huge
AnonHugePages:   3670016 kB
ShmemHugePages:        0 kB
FileHugePages:    190464 kB
HugePages_Total:    1024
HugePages_Free:     1024
HugePages_Rsvd:        0
HugePages_Surp:        0
Hugepagesize:       2048 kB
Hugetlb:         2097152 kB

编译安装

下载一个自己喜欢的 DPDK 版本，懒得话就：

1

git clone http://dpdk.org/git/dpdk --depth=1

进入项目主目录:

1
2
3
4

meson setup build
cd build
ninja
sudo meson install

编译安装完成后，查看路径 /usr/local/lib/pkgconfig 有无和libdpdk.pc，没有的话全局找一下该文件路径，并且在 ~/.zshrc 添加 export PKG_CONFIG_PATH=/path/to/，我本机设置 export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig，完成后进行下面命令：

1

sudo ldconfig

Hello World

简单运行一下：

1
2
3
4

cd examples/helloworld
make
cd build
sudo ./helloworld

Output:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

➜  build git:(main) sudo ./helloworld
EAL: Detected CPU lcores: 16
EAL: Detected NUMA nodes: 1
EAL: Detected shared linkage of DPDK
EAL: Multi-process socket /var/run/dpdk/rte/mp_socket
EAL: Selected IOVA mode 'VA'
TELEMETRY: No legacy callbacks, legacy socket not created
hello from core 1
hello from core 2
hello from core 3
hello from core 4
hello from core 5
hello from core 6
hello from core 7
hello from core 8
hello from core 9
hello from core 10
hello from core 11
hello from core 12
hello from core 13
hello from core 14
hello from core 15
hello from core 0

前言

该文章仅用于个人阅读笔记使用，如有错误，敬请指正。

什么是 DPDK？

什么是 DPDK? 对于用户来说，它可能是一个性能出色的包数据处理加速软件库；对于开发者来说，它可能是一个实践包处理新想法的创新工场；对于性能调优者来说，它可能又是一个绝佳的成果分享平台。当下火热的网络功能虚拟化，则将 DPDK 放在一个重要的基石位置。

DPDK 最初的动机很简单，就是证明 IA 多核处理器能够支撑高性能数据包处理。随着早期目标的达成和更多通用处理器体系的加入，DPDK 逐渐成为通用多核处理器高性能数据包处理的业界标杆。

IA 不适合进行数据包处理吗？

Linux 系统为例，内核栈处理数据包流程：

1. 数据包到达网卡。
2. 网卡通过 DMA 将数据包复制到内存中的接收缓冲区。
3. 网卡发送中断信号通知 CPU 有新的数据包到达。
4. 中断处理程序被触发，处理该中断。
5. 驱动程序将数据包从网卡的接收缓冲区移到内核的网络栈中，并将其放入适当的队列中。
6. 内核网络栈对数据包进行处理（例如，协议栈处理，IP、TCP/UDP 等）。
7. 根据数据包的目的地，内核决定下一步操作：
   • 如果数据包需要在内核态进行处理，则直接在内核态处理。
   • 如果数据包需要由用户态应用程序处理，则内核将数据包放入相应的套接字缓冲区中。
8. 用户态应用程序通过系统调用读取数据包，数据从内核态（CPU）复制到用户态的缓冲区中，然后进行处理。

在网络带宽向万兆发展时，大量的中断操作会严重降低处理性能。当然 Linux 操作系统对此也提出了 NAPI 机制，NAPI 是 Linux 上采用的一种提高网络处理效率的技术，它的核心概念就是不采用中断的方式读取数据，而代之以首先采用中断唤醒数据接收的服务程序，然后 POLL 的方法来轮询数据。以此来减少中断；问题是数据还需要做一次 CPU copy，复制操作也是很大的性能开销。对此也有处理方案，就是 Netmap，使用共享数据包池减少这次 CPU copy；还有问题：Linux 是分时操作系统，需要进行进 / 线程进行对应的调度操作，那么它们的上下文切换以及 cache miss 和 cache write back 也会对极致的网络性能带来影响。

DPDK 预取

在 DPDK 运行的时候，会使用 mmap () 系统调用把大页映射到用户态的虚拟地址空间，然后就可以正常使用了。

DDIO

DDIO 技术之前是如何进行处理网络数据的：当一个网络报文送到服务器的网卡时，网卡通过外部总线 (比如 PCI 总线) 把数据和报文描述符送到内存。接着，CPU 从内存读取数据到 Cache 进而到寄存器。进行处理之后，再写回到 Cache, 并最终送到内存中。最后，网卡读取内存数据，经过外部总线送到网卡内部，最终通过网络接口发送出去。

DDIO 技术是如何改进的呢？这种技术使外部网卡和 CPU 通过 LLCCache 直接交换数据，绕过了内存这个相对慢速的部件。这样，就增加了 CPU 处理网络报文的速度 (减少了 CPU 和网卡等待内存的时间), 减小了网络报文在服务器端的处理延迟。

1. 下载 linux 源码，v6.10-rc2
2. 在项目根目录下执行 make menuconfig

配置

Kernel hacking —>
Compile-time checks and compiler options —>
Debug information (Generate DWARF Version 5 debuginfo) —>
(X) Generate DWARF Version 5 debuginfo

[*] Provide GDB scripts for kernel debugging 

make -j8

busybox 1.36.1

1
2
3

code scripts/kconfig/lxdialog/Makefile
# always		:= $(hostprogs-y) dochecklxdialog

1
2

make menuconfig

[*] Build static binary (no shared libs)

前言

本文是阅读 kernel 文档中关于 Slab 分配器的文档所写的笔记。

slab 分配器背后的基本思想：让常用对象的缓存保持在初始化状态供给内核使用。

slab 分配器的三个主要目标

1. 分配小内存块有助于消除由伙伴系统引起的内部碎片。slab 内部维护了两组小内存缓冲区的缓存，范围从 32 字节到 131072（2 的 17 次方）字节。
2. 缓存常用的对象，使系统不会浪费时间分配、初始化和销毁对象。当创建一个新的 slab 时，将很多对象进行打包并且进行初始化；当对象被释放，它保持其初始化状态，以便于下一次的对象分配。
3. 通过将对象与 L1 与 L2 缓存对齐，更好利用硬件缓存。这是 slab 的最本质的任务，如果一个对象打包进 slab 后还有剩余空间，slab 就将其进行着色，使其与 CPU L1 缓存对齐。

主体

slabs_full 的所有对象都在使用中。 slabs_partial 中有空闲对象，因此是分配对象的主要候选者。 slabs_free 没有分配的对象，是 slab 销毁的主要候选者。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// The slab lists for all objects.
struct kmem_cache_node {
	spinlock_t list_lock;

#ifdef CONFIG_SLAB
	struct list_head slabs_partial;	/* partial list first, better asm code */
	struct list_head slabs_full;
	struct list_head slabs_free;
	unsigned long total_slabs;	/* length of all slab lists */
	unsigned long free_slabs;	/* length of free slab list only */
	unsigned long free_objects;
	unsigned int free_limit;
	unsigned int colour_next;	/* Per-node cache coloring */
	struct array_cache *shared;	/* shared per node */
	struct alien_cache **alien;	/* on other nodes */
	unsigned long next_reap;	/* updated without locking */
	int free_touched;		/* updated without locking */
#endif

#ifdef CONFIG_SLUB
	unsigned long nr_partial;
	struct list_head partial;
#ifdef CONFIG_SLUB_DEBUG
	atomic_long_t nr_slabs;
	atomic_long_t total_objects;
	struct list_head full;
#endif
#endif

};

写一个简单的包过滤防火墙涉及到使用 netfilter 框架，netfilter 是 Linux 内核中的一个子系统，用于处理和过滤网络数据包。我们可以使用 iptables 来设置规则，但如果我们想要自己编写代码，则需要编写一个内核模块或使用 libnetfilter_queue 来处理用户空间的包过滤。这里我们使用 libnetfilter_queue 库来编写一个简单的包过滤防火墙。

环境设置

首先，确保你已经安装了必要的库和开发包。可以使用以下命令安装它们：

1

sudo apt-get install libnetfilter-queue-dev

防火墙代码

下面是一个简单的 C 代码示例，使用 libnetfilter_queue 来过滤数据包。这个防火墙只允许 ICMP（如 ping）和 TCP 数据包通过，拒绝其他类型的数据包。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <netinet/ip.h>
#include <linux/netfilter.h>        /* for NF_ACCEPT */
#include <libnetfilter_queue/libnetfilter_queue.h>

/* Callback function to process packets */
static int cb(struct nfq_q_handle *qh, struct nfgenmsg *nfmsg,
              struct nfq_data *nfa, void *data)
{
    struct nfqnl_msg_packet_hdr *ph;
    unsigned char *payload;
    int id = 0;

    ph = nfq_get_msg_packet_hdr(nfa);
    if (ph) {
        id = ntohl(ph->packet_id);
    }

    int ret = nfq_get_payload(nfa, &payload);
    if (ret >= 0) {
        struct iphdr *ip_header = (struct iphdr *)payload;
        if (ip_header->protocol == IPPROTO_ICMP || ip_header->protocol == IPPROTO_TCP) {
            // Allow ICMP and TCP packets
            return nfq_set_verdict(qh, id, NF_ACCEPT, 0, NULL);
        }
    }

    // Drop all other packets
    return nfq_set_verdict(qh, id, NF_DROP, 0, NULL);
}

int main(int argc, char **argv)
{
    struct nfq_handle *h;
    struct nfq_q_handle *qh;
    struct nfnl_handle *nh;
    int fd;
    int rv;
    char buf[4096] __attribute__ ((aligned));

    printf("Opening library handle\n");
    h = nfq_open();
    if (!h) {
        fprintf(stderr, "Error during nfq_open()\n");
        exit(1);
    }

    printf("Unbinding existing nf_queue handler for AF_INET (if any)\n");
    if (nfq_unbind_pf(h, AF_INET) < 0) {
        fprintf(stderr, "Error during nfq_unbind_pf()\n");
        exit(1);
    }

    printf("Binding nfnetlink_queue as nf_queue handler for AF_INET\n");
    if (nfq_bind_pf(h, AF_INET) < 0) {
        fprintf(stderr, "Error during nfq_bind_pf()\n");
        exit(1);
    }

    printf("Binding this socket to queue '0'\n");
    qh = nfq_create_queue(h,  0, &cb, NULL);
    if (!qh) {
        fprintf(stderr, "Error during nfq_create_queue()\n");
        exit(1);
    }

    printf("Setting copy_packet mode\n");
    if (nfq_set_mode(qh, NFQNL_COPY_PACKET, 0xffff) < 0) {
        fprintf(stderr, "Can't set packet_copy mode\n");
        exit(1);
    }

    fd = nfq_fd(h);

    while ((rv = recv(fd, buf, sizeof(buf), 0)) && rv >= 0) {
        nfq_handle_packet(h, buf, rv);
    }

    printf("Unbinding from queue 0\n");
    nfq_destroy_queue(qh);

    printf("Closing library handle\n");
    nfq_close(h);

    exit(0);
}

编译代码

将上述代码保存为 firewall.c，然后编译它：

1

gcc -o firewall firewall.c -lnetfilter_queue

设置 iptables 规则

为了让 iptables 将数据包传递到 NFQUEUE，使用以下命令：

1
2

sudo iptables -I INPUT -j NFQUEUE --queue-num 0
sudo iptables -I OUTPUT -j NFQUEUE --queue-num 0

运行防火墙

运行编译后的防火墙程序：

1

sudo ./firewall

测试防火墙

1. 允许 ICMP 包（如 ping）：

   打开一个终端，运行 ping 命令：

   1	ping 8.8.8.8

   你应该看到 ping 包被允许通过。

2. 允许 TCP 包：

   打开一个终端，运行 curl 命令：

   1	curl http://example.com

   你应该看到 curl 请求被允许通过。

3. 拒绝其他包：

   所有其他类型的数据包将被拒绝。

清理

完成测试后，清理 iptables 规则：

1
2

sudo iptables -D INPUT -j NFQUEUE --queue-num 0
sudo iptables -D OUTPUT -j NFQUEUE --queue-num 0

这就是一个简单的包过滤防火墙的实现，利用 libnetfilter_queue 来处理和过滤数据包。你可以根据需要进一步扩展和修改此代码以实现更复杂的防火墙功能。

要测试 iptables 防火墙规则，确认其是否正确拒绝和允许指定的服务，可以进行以下步骤：

1. 检查允许的服务

允许的服务包括：

• 本地回环接口流量
• 已建立和相关的连接
• SSH (端口 22)
• ICMP (ping)
• HTTP (端口 80) 和 HTTPS (端口 443)

测试 SSH 连接

在本地或远程系统上，尝试通过 SSH 连接到配置了防火墙的机器：

1

ssh user@your_server_ip

应能够成功连接。

测试 HTTP 和 HTTPS

在本地或远程系统上，使用 curl 或浏览器访问 HTTP 和 HTTPS 服务：

1
2

curl http://your_server_ip
curl https://your_server_ip

应返回相应的网页内容或响应头。

测试 ICMP (ping)

在本地或远程系统上，尝试 ping 配置了防火墙的机器：

1

ping your_server_ip

应接收到来自目标机器的响应。

2. 检查拒绝的服务

未特别允许的服务应被拒绝。

测试其他端口

尝试访问未允许的端口（例如，端口 23），应该被拒绝：

1

telnet your_server_ip 23

或使用 nc (netcat)：

1

nc -zv your_server_ip 23

应显示连接被拒绝或超时。

3. 使用日志检查拒绝的服务

防火墙脚本包含日志记录规则，可以通过系统日志检查被拒绝的连接：

1

sudo tail -f /var/log/syslog

或在某些系统上：

1

sudo journalctl -f

尝试连接未允许的服务，并在日志中查看记录的 IPTABLES-DROP 消息。

总结

以下是一个完整的测试步骤：

1. 测试允许的服务：

   • SSH 连接：

     1	ssh user@your_server_ip
   • HTTP 和 HTTPS 访问：

     1 2	curl http://your_server_ip curl https://your_server_ip
   • ICMP (ping)：

     1	ping your_server_ip

2. 测试拒绝的服务：

   • 其他端口访问：

     1 2	telnet your_server_ip 23 nc -zv your_server_ip 23

3. 查看系统日志：

   • 检查日志以确认拒绝的服务被记录：

     1	sudo tail -f /var/log/syslog
     或

     1	sudo journalctl -f

通过这些测试，你可以确认防火墙规则是否正确应用，并确保只允许指定的服务。

中断种类

1. 外部中断

外部中断又可以细分为可屏蔽中断和不可屏蔽中断。

2. 内部中断

内部中断可以分为软中断和异常。
软中断是由软件主动发起的中断，并不是发生了某种错误。
发起软中断的指令：

• int 8位立即数。常用于系统调用，可表示 256 种中断。
• int3。调试断点指令，中断向量号是 3。我们常用的 gdb 或者 bochs 调试实际上就是使用到了这个指令。运行 gdb 的进程 fork 一个子进程用来运行被调试的程序，调试器打断点的本质是：将对应断点的地址的第一个字节备份并更改为 0xcc，这样程序运行到断点处就会触发中断处理程序，运行中断处理程序之前要将当前的寄存器等数据压栈保存，查看寄存器或者变量实际上是从栈中获取的。
• into。中断溢出指令，中断向量号是 4。在 eflags 寄存器的 OF 位为 1 的前提下触发中断。
• bound。数组索引越界检查指令，中断向量号是 5。指令格式 bound 16/32位 内存/寄存器，如果数据访问越界，则触发该中断。
• ud2。未定义指令，中断向量号是 6。表示该指令 CPU 无法识别。

除了第一个是软中断外，其余是软中断，也可以认为是异常。因为它们既具备软中断的 “主动” 行为，又具备异常的 “错误” 结果。

异常可以分为三类：

1. Fault（故障）。比如缺页中断，这类异常交给对应的异常处理程序很大概率会被修复，甚至对操作系统有益处。
2. Trap (陷阱)。比如调试时候的 int3，掉入了 CPU 设下的陷阱，很形象。
3. Abort (终止)。这是最严重的异常，意味着不可修复，操作系统为了正常运行，会直接将其从进程表中删除。通常是硬件出错或者内核某些数据结构出错。

中断描述符表

中断描述符表 (Interrupt Descriptor Table,IDT) 是保护模式下用于存储中断处理程序入口的表。由于操作系统是中断驱动的，实模式下存储中断的是中断向量表。

中断向量表和中断描述符表的区别？

• 中断描述符表地址不限制，在哪里都可以。
• 中断描述符表中的每个描述符用 8 字节描述。

中断处理过程以及保护

一个完整的中断包含 CPU 内部的 CPU 外部和 CPU 内部两个部分以及特权级的检查。

CPU 外：外部设备的中断由中断代理芯片接收，处理后将该中断的中断向量号发送到 CPU。
CPU 内：CPU 执行该中断向量号对应的中断处理程序。

这里只讨论 CPU 内部的过程：

1. 处理器根据中断向量号定位中断门描述符。

2. 处理器进行特权级检查。当前的特权级 CPL 必须在门描述符 DPL 和门中代码段描述符 DPL 之间（防止用户主动调用只为内核服务的例程）。

   1. 如果是由软中断 int n、int3 和 into 引发的中断，这些是用户进程中主动发起的中断，由用户代码控制，处理器要检查当前特权级 CPL 和门描述符 DPL, 这是检查进门的特权下限，如果 CPL 权限大于等于 DPL, 即数值上 CPL≤门描述符 DPL, 特权级 “门槛” 检查通过，进入下一步的 “门框” 检查。否则，处理器抛出异常。
   2. 这一步检查特权级的上限 (门框): 处理器要检查当前特权级 CPL 和门描述符中所记录的选择子对应的目标代码段 DPL, 如果 CPL 权限小于目标代码段 DPL, 即数值上 CPL > 目标代码段 DPL, 检查通过。否则 CPL 若大于等于目标代码段 DPL, 处理器将引发异常，也就是说，除了用返回指令从高特权级返回，特权转移只能发生在由低向高。
   3. 若中断是由外部设备和异常引起的，只直接检查 CPL 和目标代码段的 DPL, 和上面的步骤 2 是一样的，要求 CPL 权限小于目标代码段 DPL, 即数值上 CPL > 目标代码段 DPL, 否则处理器引发异常。

3. 执行中断处理程序。

由于 IDT 中会有中断门，陷阱门，任务门。中断发生时候会将 NT 位和 TF 位置为 0。

NT 位和 TF 位：
当 NT 标志被设置为 1 时，表示允许任务嵌套。设置为 0 表示进入了中断处理程序。这里还有个作用，iret 指令既可以从新任务返回到旧任务，也可以从中断返回，这里 NT 标志就是区分到底是哪种返回。
当 TF 标志被设置为 1 时，会启用单步调试模式。设置为 0 也很容易想到，中断程序怎么会让你单步调试捏。

如果执行的是中断门时，会将 IF 位设置为 0, 避免中断嵌套，如果是陷阱门或者任务门则不会设置 IF 位为 0，允许 CPU 响应更高级别的中断。当然也可以在中断处理程序中将 IF 位置为 1, 这样就可以处理优先级更高的中断。eflags 寄存器有些位可以通过和栈配合来更改位，但是这有内存操作，效率低下且不是原子操作，所以专门给 IF 位提供了控制指令：sti 开中断和 cli 关中断。IF 位 (中断允许位) 只能限制外部设备的中断，对那些影响系统正常运行的中断都无效，如异常 exception, 软中断，如 int n 等，不可屏蔽中断 NMI 都不受 IF 限制。

中断发生时候的压栈

布拉布拉….

可编程中断控制器 8259A

最理想的方式是每个外设准备一个引脚接收中断，但是这明显不现实，成本高收益低。这时候一个中间层代理就显得智慧，这里使用的是 Intel 8259A 芯片。传统的 PIC (就是可编程中断控制器 Programmable Interrupt Controller 的简称) 是两片 8259A 风格的芯片级联的方式连接在一起。每个芯片可以处理 8 个不同的 IRQ（中断请求）输入线，因为从 PIC 的 INT 输出线到主 PIC 的 IRQ2 引脚，因此可用的 IRQ 引脚只有 16 - 1 个。这种情况仅仅在系统只有一个 CPU 的情况下，将主芯片的输出引脚连接 CPU 的 INTR 引脚，但是系统有多个 CPU 就不适用了，引入了 ACPI 的新组件来代替老式的 8259A 芯片，这里只学习 8259A 芯片的原理和操作方式，不涉及多处理器的情况。
8259A 可以管理和控制可屏蔽中断，它可以屏蔽外设中断，判断中断优先级，向 CPU 提供中断向量号，这些功能都是可编程的。 外接设备通过主板线路和 8259A 芯片连接在一起。下面是个人计算机中芯片级联方式：

内部结构

• INT: 芯片挑选出来优先级最高的中断请求，发信号给 CPU。
• INTA: INT Acknowledge, 中断响应信号。用于接收 CPU 的 INTA 接口的中断响应信号。
• IMR (Interrupt Mask Register): 中断屏蔽寄存器，8 位，用来屏蔽某个外设的中断信号。
• IRR (Interrupt Request Register): 中断请求寄存器，8 位，用来存储等待处理的中断。
• PR (Priority Resolver): 优先仲裁器，找出优先级最高的中断。
• ISR (In-Service Register): 中断服务寄存器，8 位，存储正在处理的中断。

工作流程

1. 外设发出一个中断信号，通过主板线路将信号传递给芯片的某个 IRQ 接口。
2. 8259A 首先检查 IMR 寄存器是否屏蔽了该 IRQ 接口的中断信号，如果为 1 则表示屏蔽，直接忽略。否则将其送入 IRR 寄存器，将其对应位置为 1。
3. PR 寄存器找出优先级最高的中断（这里优先级判断很简单，IRQ 接口接口号越低，优先级越大）。
4. 芯片在控制电路中通过 INT 接口向 CPU 发送 INTR 信号，信号传入 CPU 的 INTR 接口后，CPU 就知道有新的中断到来，执行完手里的指令就向自己的 INTA 接口向 8259A 回复一个中断响应信号，表示 CPU 准备就绪。
5. 8259A 受到信号后，将刚才选出来的优先级最高的中断在 ISR 中置为 1, 同时将 IRR 中置为 0。
6. CPU 再次发送 INTA 信号，为了获取中断对应的中断向量号。
7. 如果 8259A 的 EOI（End of Interrupt）被设置为手动模式，中断处理程序必须有向 8259A 发送 EOI 的代码，芯片受到 EOI 后会自动将 ISR 对应中断位置为 0。

需要注意的是：并不是进入了 ISR 后的中断就高枕无忧了，它还是有可能被后者换下来的。比如，在 8259A 发送中断向量号给 CPU 之前，这时候又来了新的中断，如果它的来源 IRQ 接口号比 ISR 中的低，也就是优先级更高，原来 ISR 中准备上 CPU 处理的旧中断，其对应的 BIT 就得清 0, 同时将它所在的 IRR 中的相应 BIT 恢复为 1, 随后在 ISR 中将此优先级更高的新中断对应的 BIT 置 1, 然后将此新中断的中断向量号发给 CPU。

实际操作

说了那么多，我们最终目的很简单：

1. 构建 IDT
2. 提供中断向量号

8259A 内部有两组寄存器：初始化命令寄存器组 (ICW1 ~ ICW4)，操作命令寄存器组 (OCW1 ~ OCW3)。因此我们的操作也分为初始化和操作两部分。

初始化

注意：ICW1 ~ ICW4 的初始是有严格顺序的。必须依次写入 ICW1、ICW2、ICW3、ICW4。因为其中某些设置是由关联，依赖的。

ICW1

用来初始化 8259A 的连接方式和中断信号的触发方式。连接方式是指用单片工作，还是用多片级联工作，触发方式是指中断请求信号是电平触发，还是边沿触发。

IC4：表示是否写入 ICW4, 该位为 1 表示需要在后面写入 ICW4, 为 0 则不需要。x86 必须设置为 1。
SNGL：该位为 1, 表示是单片，为 0 则表示级联。
ADI：用来设置 8259A 的调用时间间隔，x86 不需要设置。
LTIM：表示中断检测方式，为 0 表示边沿触发，为 1 表示电平触发。
第四位恒定为 1。
第 5~7 位专用于 8085 处理器，x86 不需要，设置为 0。

ICW2

用来设置起始中断向量号。需要写入主片的 0x21 端口和从片的 0xA1 端口。
我们只需要写高五位的 T3~T7，所以任意数字都是 8 的倍数，这个数字便是设定的起始中断向量号。第三位可以表示 8 个中断向量号，这是根据 8259A 芯片自行导入，这样就能表示任意一个 IQR 接口实际分配的中断向量号。

ICW3

在级联的前提下才能使用，用来设置主从片用哪个 IRQ 接口互联。需要写入主片的 0x21 端口和从片的 0xA1 端口。
对于主片，哪个 IRQ 接口用于连接从片，就将其设置为 1（可以设置多个从片），设置为 0 表示是外接设备。
对于从片，只需要在从片上指定主片用于连接自己的 IRQ 接口。这样中断发生后，主片会发送与从片做级联的 IRQ 接口号，所有从片用自己的 ICW3 的低 3 位和它对比，若一致则认为是发给自己的。高五位没用到，设置为 0。

ICW4

SFNM 表示特殊全嵌套模式 (Special Fully Nested Mode) , 若 SFNM 为 0, 则表示全嵌套模式，若 SFNM 为 1, 则表示特殊全嵌套模式。
BUF 表示本 8259A 芯片是否工作在缓冲模式。BUF 为 0, 则工作非缓冲模式，BUF 为 1, 则工作在缓冲模式。
当多个 8259A 级联时，如果工作在缓冲模式下，M/S 用来规定本 8259A 是主片，还是从片。若 M/S 为 1 , 则表示则表示是主片，若 M/S 为 0, 则表示是从片。若工作在非缓冲模式 (BUF 为 0) 下，M/S 无效。
AEOI 表示自动结束中断 (Auto End Of Interrupt) ,8259A 在收到中断结束信号时才能继续处理下一个中断，此项用来设置是否要让 8259A 自动把中断结束。若 AEOI 为 0, 则表示非自动，即手动结束中断，咱们可以在中断处理程序中或主函数中手动向 8259A 的主、从片发送 EOI 信号。这种 “操作” 类命令，通过下面要介绍的 OCW 进行。若 AEOI 为 1, 则表示自动结束中断。
μPM 表示微处理器类型 (microprocessor) , 此项是为了兼容老处理器。若 μPM 为 0, 则表示 8080 或 8085 处理器，若 μPM 为 1, 则表示 x86 处理器。

OCW

OCW1

需要写入主片的 0x21 端口和从片的 0xA1 端口。
OCW1 用来屏蔽连接在 8259A 上的外部设备的中断信号，还记得上面说的 IMR (Interrupt Mask Register) 吗？实际上就是将 OCW1 的数据填入该寄存器中。为 1 表示该位被屏蔽。

OCW2

OCW2 要写入到主片的 0x20 及从片的 0xA0 端口。
OCW2 用来设置中断结束方式和优先级模式。

SL：Specific Level, 表示是否指定优先等级。等级是用低 3 位来指定的。此处的 SL 只是开启低 3 位的开关，所以 SL 也表示低 3 位的 L2~L0 是否有效。SL 为 1 表示有效，SL 为 0 表示无效。

OCW2 其中的一个作用就是发 EOI 信号结束中断。如果使 SL 为 1, 可以用 OCW2 的低 3 位 (L2L0) 来指定位于 ISR 寄存器中的哪一个中断被终止，也就是结束来自哪个 IRQ 接口的中断信号。如果 SL 位为 0,L2L0 便不起作用了，8259A 会自动将正在处理的中断结束，也就是把 ISR 寄存器中优先级最高的位清 0。

R：用来设置优先级控制方式。为 0，则 IRQ 接口号越低，优先级越高。
R 为 1: 设置为循环优先级方式。

1. SL 为 0，初始优先级次序为 IR0>IR1>IR2>IR3>IR4>IR5>IR6>IR7。
2. SL 为 1, 通过 L2 L1 指定最低优先级是哪个 IRQ 接口。
   举个例子，在 R 和 SL 都等于 1 的情况下，若想指定 IR5 为最低的优先级，需要将 L2L0 置为 101。
   这样，新的初始优先级循环是：IR6>IR7>IR0>IR1>IR2>IR3>IR4>IR5。什么是循环优先级方式？当前 IR6 为最高级别中断请求，处理完成后，IR6 将变成最低级别，IR7 变成最高级别，这一组循环之后的优先级变成了：IR7>IR0>IR1>IR2>IR3>IR4>IR5>IR6。

EOI：End Of Interrupt, 为中断结束命令位。令 EOI 为 1, 则会令 ISR 寄存器中的相应位清 0, 也就是
将当前处理的中断清掉，表示处理结束。向 8259A 主动发送 EOI 是手工结束中断的做法，所以，使用此
命令有个前提，就是 ICW4 中的 AEOI 位为 0, 非自动结束中断时才用。

只有 EOI 位为 1 时候，表示发送中断结束。

OCW3 用于设定特殊的屏蔽方式以及查询方式。

编写中断处理程序

中断向量 019 为处理器内部固定的异常类型，2031 是 Intel 保留的，所以咱们可用的中断向量号最低是 32, 将来咱们在设置 8259A 的时候，会把 IR0 的中断向量号设置为 32。

前言

• 实验环境：Archlinux + Bochs x86 Emulator 2.7
• 编译器: nasm

— 以下均是我的个人笔记，如有错误，敬请指正.—

哎！当时懒得记笔记，到头来还是得重新回头翻书看，这次顺带把笔记做上。

CHS 和 LBA

早期的时候计算机是通过 CHS 寻址模式来定位区块的，但是弊端也很明显，区块必须将指定硬盘的柱面（Cylinder）/ 磁头 (Head)/ 扇区（Sector）三个参数来定位一个唯一的扇区地址，这套逻辑只有在硬盘操作内部有用，其他设备想要访问的话需要额外知道这些细节数据，太麻烦了，于是 LBA 应运而生。LBA 十分单纯，从 0 开始定位区块，第一个区块的 LBA=0，第二个区块的 LBA=1，以此类推，LBA 取代了 CHS，这样就能以一种相对而言更方便的方式来进行硬盘 IO。但是 LBA 只是在 CHS 上进行了抽象，实际上的硬件控制器还是需要 CHS 来进行寻址的，但是我们现在使用 LBA 给传入的是 0 1 2 3 之类的数字，硬件控制器又该如何通过 LBA 转换成正确的 CHS 呢？

1
2

CONFIGURE_ARGS="--enable-gdb-stub"
CONFIGURE_ARGS="--enable-debugger --enable-readline"

先改.conf.linux，里面的

1

CONFIGURE_ARGS="--enable-gdb-stub"

再使用：

1

sh .conf.linux 

然后在 Makefile 里面操作:

我是在 vscode 中，Ctrl+F，将所有的 bochs 更改成 bochs_gdb，接着将 bochs_gdb.h 更改为 bochs.h,wxbochs_gdb.rc 更改为 wxbochs.rc，后面这个应该没影响，是和 win 有关系的，但是保险起见还是改了吧，然后进行 make -j16 && sudo make install。