最新资讯

大家好呀，我是残念，希望在你看完之后，能对你有所帮助，有什么不足请指正！共同学习交流哦！
本文由：残念ing原创CSDN首发，如需要转载请通知
个人主页：残念ing-CSDN博客，欢迎各位→点赞👍 + 收藏⭐️ + 留言📝
📣系列专栏：[残念ing 的【Linux】系列专栏——CSDN博客]

生活中的一些信号

结论：
你怎么能识别信号呢？识别信号是内置的，进程识别信号，是内核程序员写的内置特性。
• 信号产⽣之后，你知道怎么处理吗？知道。如果信号没有产⽣，你知道怎么处理信号吗？
知道。所以，信号的处理⽅法，在信号产⽣之前，已经准备好了。
比特就业课• 处理信号，⽴即处理吗？我可能正在做优先级更⾼的事情，不会⽴即处理？什么时候？合
适的时候。
• 信号到来 -> 信号保存 -> 信号处理
• 怎么进⾏信号处理啊？a.默认b.忽略c.⾃定义，后续都叫做信号捕捉。

技术应用角度的信号

当我们正常在shell下启动一个进程（前台），当我们按下ctrl+c时，这个进程就会被终止。

原理：

然而其实，本质是向前台进程发送 SIGINT 即 2 号信号，我们可以通过以下系统调用函数来证明一下。

参数说明：
signum：信号编号[后⾯解释，只需要知道是数字即可]
handler：函数指针，表⽰更改信号的处理动作，当收到对应的信号，就回调执⾏handler⽅法

注意：signal函数仅仅是设置了特定信号的捕捉⾏为处理⽅式，并不是直接调⽤处理动作。如果后续特定信号没有产⽣，设置的捕捉函数永远也不会被调⽤！！
Ctrl-C 产⽣的信号只能发给前台进程。⼀个命令后⾯加个&可以放到后台运⾏,这样
Shell不必等待进程结束就可以接受新的命令,启动新的进程。
Shell可以同时运⾏⼀个前台进程和任意多个后台进程,只有前台进程才能接到像 Ctrl-C这种控制键产⽣的信号。
前台进程在运⾏过程中⽤⼾随时可能按下 Ctrl-C ⽽产⽣⼀个信号,也就是说该进程的⽤户空间代码执⾏到任何地⽅都有可能收到 SIGINT 信号⽽终⽌,所以信号相对于进程的控制流程来说是异步(Asynchronous)的。

信号

是一种用户、OS、其他进程、向目标进程发送异步（突然）事件的一种方式。

思考：
你是怎么知道信号的？识别信号其实是内置的，进程认识信号是程序员内置的特性。
信号的处理方法，在信号产生之前，就已经准备好了。
信号是在合适的时候处理的。

查看信号（kill -l）

每个信号都有⼀个编号和⼀个宏定义名称,这些宏定义可以在signal.h中找到,例如其中有定义。

补充：编号34以上的都是实时信号。

信号的产生

基本认识

Ctrl+C（SIGNT）可以发送终止信号，让进程终止
Ctrl+（SIGAUIT）可以发送终止信号并且生成core dump文件，用于事后调试
Ctrl+Z（SIGTSTP）可以发送停止信号，将当前前台进程挂起到后天

补充：可执行程序 & //后台进程，不能通过Ctrl+c（信号）终止
nohup 可执行程序 & //将结果放入nuhup.out 文件中
fg 1 +ctrl-c 将这1号任务重新移到前台，+关闭这个任务。

产生信号的方式：

1 键盘产生

当键盘被按下，计算机CPU识别到键盘有动作，唤醒操作系统，让操作系统去读取键盘上的行为，将行为解释为信号（比特位由0置1），然后操作系统会将该信号给到该进程，该进程会在合适的时候对信号进行处理。

2系统指令

kill -9 当前进程的pid

3 系统调用

kill

kill 命令是调⽤ kill 函数实现的。 kill 函数可以给⼀个指定的进程发送指定的信号
kill（pid_t pid, int sig）

raise

raise 函数可以给当前进程发送指定的信号(⾃⼰给⾃⼰发信号)。
int raise(int sig);

NAME
raise - send a signal to the caller
SYNOPSIS
#include 
int raise(int sig);
RETURN VALUE
raise() returns 0 on success, and nonzero for failure.

#include 
#include 
#include 
#include 
#include 
using namespace std;
int main(int argc, char *argv[])
{

    ::signal(2,SIG_IGN);//SIG_IGN:信号忽略,本身就是一种信号捕捉的方法，动作是忽略
    ::signal(2,SIG_DFL);//SIG_DFL:默认执行
    int cnt = 5;
    while (1)
    {
        cout << "hahahaahahha" << endl;
        if (cnt == 0)
            raise(9);//当cnt=0时就给进程发送9号信号
        cnt--;
        /* code */
    }
  }
  

abort

abort 函数使当前进程接收到信号⽽异常终⽌。

NAME
abort - cause abnormal process termination
SYNOPSIS
#include 
void abort(void);
RETURN VALUE
The abort() function never returns.
// 就像exit函数⼀样,abort函数总是会成功的,所以没有返回值

#include 
#include 
#include 
#include 
#include 
using namespace std;
int main(int argc, char *argv[])
{

    ::signal(2,SIG_IGN);//SIG_IGN:信号忽略,本身就是一种信号捕捉的方法，动作是忽略
    ::signal(2,SIG_DFL);//SIG_DFL:默认执行
     int cnt = 5;
    while (1)
    {
        cout << "hahahaahahha" << endl;
        if (cnt == 0)
            abort(); // 6号信号
        cnt--;
        /* code */
    }
}

xxx@VM-24-4-ubuntu:~/112/lesson4$ ./signal 
hahahaahahha
hahahaahahha
hahahaahahha
hahahaahahha
hahahaahahha
hahahaahahha
Aborted (core dumped)

软件条件

SIGPIPE 是⼀种由软件条件产⽣的信号
调⽤ alarm 函数可以设定⼀个闹钟,也就是告诉内核在 seconds 秒之后给当前进程发SIGALRM 信号，该信号的默认处理动作是终⽌当前进程。

NAME
alarm - set an alarm clock for delivery of a signal

SYNOPSIS
#include 

unsigned int alarm(unsigned int seconds);

RETURN VALUE
alarm() returns the number of seconds remaining until any previously
scheduled alarm was due to be delivered, or zero if there was no previ‐
ously scheduled alarm.

alarm的返回值：当闹钟还没有响，那就放回当时还剩下的时间，如果响了就返回0，要取消闹钟，就设置一个alarm参数为0的闹钟就可以了，返回值为取消闹钟的剩余时间。

结论：
• 闹钟会响⼀次，默认终⽌进程
• 有IO效率低

什么是软件条件

在操作系统中，信号的软件条件指的是由软件内部状态或特定软件操作触发的信号产⽣机制。这些条件包括但不限于定时器超时（如alarm函数设定的时间到达）、软件异常（如向已关闭的管道写数据产⽣的SIGPIPE信号）等。当这些软件条件满⾜时，操作系统会向相关进程发送相应的信号，以通知进程进⾏相应的处理。简⽽⾔之，软件条件是因操作系统内部或外部软件操作⽽触发的信号产⽣。

什么是系统闹钟

系统闹钟，其实本质是OS必须⾃⾝具有定时功能，并能让⽤⼾设置这种定时功能，才可能实现闹钟这样的技术。
定时闹钟也要被管理的：先描述，再组织。
在内核中的定时闹钟是以数据结构来的

struct timer_list {
struct list_head entry;
unsigned long expires;//定时器超时时间
void (*function)(unsigned long);
unsigned long data;
struct tvec_t_base_s *base;
};

操作系统管理定时器，采⽤的是时间轮的做法，但是我们为了简单理解，可以把它在组织成为"堆结构"。

异常条件

硬件异常被硬件以某种⽅式被硬件检测到并通知内核,然后内核向当前进程发送适当的信号 （11：野指针 8：语法错误）进程执行了除以0的指令,CPU的运算单元会产生异常,内核将这个异常解释为SIGFPE信号发送给进程。再比如当前进程访问了非法内存址,MMU会产生异常,内核将这个异常解释SIGSEGV信号发送给进程。

c/c++中，常见的异常，进程崩溃了，OS给目标进程发送对应错误的信号，进而导致该进程退出，这些错误在系统层面上，是被当成信号被处理的。

OS是怎么知道我们的进程内部出错了？

OS系统要知道CPU(硬件)内部是否出错，是谁导致的出错，并且通过信号杀掉它。
代码实现

#include 
比特就业课#include <signal.h>
void handler(int sig)
{
	printf("catch a sig : %d
", sig);
} /
/ v1
int main()
{
//signal(SIGFPE, handler); // 8) SIGFPE
	sleep(1);
	int a = 10;
	a/=0;
	while(1);
	return 0;
}
xxx@localhost code_test]$ ./sig
xxxb@localhost code_test]$ ./sig
catch a sig : 8
catch a sig : 8
catch a sig : 8

野指针

代码实现

[hb@localhost code_test]$ cat sig.c
#include 
#include 
void handler(int sig)
{
	printf("catch a sig : %d
", sig);
} 
int main()
{
//signal(SIGSEGV, handler);
	sleep(1);
	int *p = NULL;
	*p = 100;
	while(1);
	return 0;
} 
xxx@localhost code_test]$ ./sig
xxx@localhost code_test]$ ./sig
catch a sig : 11
catch a sig : 11
catch a sig : 11

总结：
发现⼀直有8号信号产⽣被我们捕获，这是为什么呢？上⾯我们只提到CPU运算异常后，如何处理后续的流程，实际上OS会检查应⽤程序的异常情况，其实在CPU中有⼀些控制和状态寄存器，主要⽤于控制处理器的操作，通常由操作系统代码使⽤。状态寄存器可以简单理解为⼀个位图，对应着⼀些状态标记位、溢出标记位。OS会检测是否存在异常状态，有异常存在就会调⽤对应的异常处理⽅法。
除零异常后，我们并没有清理内存，关闭进程打开的⽂件，切换进程等操作，所以CPU中还保留上下⽂数据以及寄存器内容，除零异常会⼀直存在，就有了我们看到的⼀直发出异常信号的现象。访问⾮法内存其实也是如此。

进程退出(core dump)

进程退出有两种做法：Term（正常退出）和core（可以调试）：在当前目录下形成.core文件，进程崩溃的时候，将进程在内存中的部分信息保存起来，方便后续调试（云服务器一般是关闭core功能的，因为怕当错误次数过多时，会将内存占满，导致后续无法正常使用）。

ulimit -a //查看
ulimit -c 大小 //打开core服务并且给.core文件分配大小
gdb 调试下直接执行，core-file core //直接找到出错信息（事后调试）
调试的前提是要有Debag信息。-g

#include 
#include 
#include 
#include 
#include 
#include 
int main()
{
	if (fork() == 0)
	{
	sleep(1);
	int a = 10;
	a /= 0;
	exit(0);
} 
	int status = 0;
	waitpid(-1, &status, 0);
	printf("exit signal: %d, core dump: %d
", status&0x7F, (status>>7)&1);
	return 0;
} 
$ man 7 signal
SIGABRT P1990 Core Abort signal from abort(3)
	SIGALRM P1990 Term Timer signal from alarm(2)
	SIGBUS P2001 Core Bus error (bad memory access)
	SIGCHLD P1990 Ign Child stopped or terminated
	SIGCLD - Ign A synonym for SIGCHLD
	SIGCONT P1990 Cont Continue if stopped
	SIGEMT - Term Emulator trap
	SIGFPE P1990 Core Floating-point exception
	SIGHUP P1990 Term Hangup detected on controlling terminal
	or death of controlling process
	SIGILL P1990 Core Illegal Instruction
	SIGINFO - A synonym for SIGPWR
	SIGINT P1990 Term Interrupt from keyboard
	SIGIO - Term I/O now possible (4.2BSD)
	SIGIOT - Core IOT trap. A synonym for SIGABRT
	SIGKILL P1990 Term Kill signal
	SIGLOST - Term File lock lost (unused)
	SIGPIPE P1990 Term Broken pipe: write to pipe with no
	readers; see pipe(7)
	SIGPOLL P2001 Term Pollable event (Sys V).
$ ulimit -a
core file size (blocks, -c) 0
data seg size (kbytes, -d) unlimited
scheduling priority (-e) 0
file size (blocks, -f) unlimited
pending signals (-i) 7643
max locked memory (kbytes, -l) 65536
max memory size (kbytes, -m) unlimited
open files (-n) 65535
pipe size (512 bytes, -p) 8
POSIX message queues (bytes, -q) 819200
real-time priority (-r) 0
stack size (kbytes, -s) 8192
cpu time (seconds, -t) unlimited
max user processes (-u) 7643
virtual memory (kbytes, -v) unlimited
file locks (-x) unlimited

总结：

1. 不管产生的信号是多少种，最终都是由操作系统来发送的,因为OS是进程的管理者
2. 信号的处理是在合适的时候处理的

信号的保存

信号如果不是被立即处理的，那么信号是否需要被暂时被进程记录下来呢？记录在哪里合适呢？答案是：是的要被记录下来，这也就是信号的保存。

补充知识（必须知道，要不然看后面会很懵的）：

1. 实际执⾏信号的处理动作称为信号递达(Delivery)
2. 信号从产⽣到递达之间的状态,称为信号未决(Pending)。
3. 进程可以选择阻塞(Block)某个信号。—阻塞特定信号，信号产生了也一定要把信号进行pending（保存）如果该信号是阻塞的，那么信号将永远不递达，除非我们解除阻塞。
4. 被阻塞的信号产⽣时将保持在未决状态,直到进程解除对此信号的阻塞,才执⾏递达的动作。

注意,阻塞和忽略是不同的,只要信号被阻塞就不会递达,⽽忽略是在递达之后可选的⼀种处理动作。

信号在内核中的表示

信号在内核中的表示示意图

1. 每个信号都有两个标志位分别表⽰阻塞(block)和未决(pending),还有⼀个函数指针表示处理动作。信号产⽣时,内核在进程控制块中设置该信号的未决标志,直到信号递达才清除该标志。在上图的例⼦中,SIGHUP信号未阻塞也未产生过,当它递达时执行默认处理动作。
2. SIGINT信号产生过,但正在被阻塞,所以暂时不能递达。虽然它的处理动作是忽略,但在没有解除阻塞之前不能忽略这个信号,因为进程仍有机会改变处理动作之后再解除阻塞。
3. SIGQUIT信号未产生过,⼀旦产生SIGQUIT信号将被阻塞,它的处理动作是用户自定义函数sighandler

总结：
block表：存储的方式是以位图来的，其中含义：比特为的位置是信号编号、1：收到对应的信号、0：没有收到对应的信号
pending表：存储数据的方式也是用位图，其中含义：比特位的位置是信号编号、1：阻塞（屏蔽）特点的信号，0：不阻塞（屏蔽）特定的信号。
handler表：存储对应信号要执行的行为。以函数指针数组的形式，信号编号就是函数指针数组的下标。

思考：如果在进程还没有解除对某信号的阻塞之前这种信号又产生了多次，将如何处理呢？
POSIX.1是允许系统递送该信号⼀次或多次。Linux是这样实现的:常规信号在递达之前产生多次只计⼀次,而实时信号在递达之前产生多次可以依次放在⼀个队列里。

// 内核结构 2.6.18
struct task_struct {
...
	/* signal handlers */
	struct sighand_struct *sighand;
	sigset_t blocked
	struct sigpending pending;
	...
} 
struct sighand_struct {
	atomic_t count;
	struct k_sigaction action[_NSIG]; // #define _NSIG 64
	spinlock_t siglock;
};
struct __new_sigaction {
	__sighandler_t sa_handler;
	unsigned long sa_flags;
	void (*sa_restorer)(void); /* Not used by Linux/SPARC */
	__new_sigset_t sa_mask;
};
struct k_sigaction {
	struct __new_sigaction sa;
	void __user *ka_restorer;
};
/* Type of a signal handler. */
typedef void (*__sighandler_t)(int);

struct sigpending {
	struct list_head list;
	sigset_t signal;
};

sigset_t

从上图来看,每个信号只有⼀个bit的未决标志,非0即1,不管记录该信号产⽣了多少次,阻塞标志也是这样表示的。因此,未决和阻塞标志可以用相同的数据类型sigset_t来存储,sigset_t称为信号集，这个类型可以表示每个信号的“有效”或“⽆效”状态,在阻塞信号集中“有效”和“⽆效”的含义是该信号是否被阻塞,而在未决信号集中“有效”和“⽆效”的含义是该信号是否处于未决状态。
阻塞信号集也叫做当前进程的信号屏蔽字（signal mask） 这⾥的“屏蔽”应该理解为阻塞⽽不是忽略。

信号集操作函数

sigset_t类型对于每种信号⽤⼀个bit表⽰“有效”或“无效”状态,⾄于这个类型内部如何存储这些bit则依赖于系统实现,从使⽤者的⻆度是不必关⼼的,使用者只能调⽤以下函数来操作sigset_t变量,而不应该对它的内部数据做任何解释。

#include 
int sigemptyset(sigset_t *set);
//函数sigemptyset初始化set所指向的信号集,
//使其中所有信号的对应bit清零,表⽰该信号集
//不包含任何有效信号。成功返回0,出错返回-1

int sigfillset(sigset_t *set);
//函数sigfillset初始化set所指向的信号集,
//使其中所有信号的对应bit置位,表⽰该信号集
//的有效信号包括系统⽀持的所有信号。成功返回//0,出错返回-1
int sigaddset(sigset_t *set, int signo);//信号集中添加除某种有效信号，成功返回0,出错返回-1
int sigdelset(sigset_t *set, int signo);//信号集中删除除某种有效信号，成功返回0,出错返回-1
int sigismember(const sigset_t *set, int signo);//⼀个布尔函数,⽤于判断⼀个信号集的有效信号中是否包含某种信号,若包含则返回1,不包含则返回0,出错返回-1

sigprocmask

调⽤函数 sigprocmask 可以读取或更改进程的信号屏蔽字(pending阻塞信号集)。
#include int sigprocmask(int how, const sigset_t *set, sigset_t *oset); 返回值:若成功则为0,若出错则为-1

如果oset是非空指针,则读取进程的当前信号屏蔽字通过oset参数传出。如果set是⾮空指针,则更改进程的信号屏蔽字,参数how指⽰如何更改。如果oset和set都是非空指针,则先将原来的信号屏蔽字备份到oset⾥,然后根据set和how参数更改信号屏蔽字。假设当前的信号屏蔽字为mask,下表说明了how参数的可选值。

补充：
如果调⽤sigprocmask解除了对当前若⼲个未决信号的阻塞,则在sigprocmask返回前,⾄少将其中⼀个信号递达

sigpending

#include 
int sigpending(sigset_t *set);
读取当前进程的未决信号集,通过set参数传出。
调⽤成功则返回0,出错则返回-1

运用一下所学的知识：

#include 
#include 
#include 
#include 
#include 
using namespace std;


void prinprint(const sigset_t panding)
{
    cout<<"pid: "<<getpid()<<endl;
    for(int set=31;set>0;set--)
    {
        if(sigismember(&panding,set))
        {
            cout<<1;
        }
        else{
            cout<<0;
        }
    }
    cout<<endl;
}

void no_handl(int sig)
{
    cout<<"处理完成"<<endl;
}

int main()
{
    signal(2,SIG_IGN);
    //signal(2,no_handl);

    //1 对2号信号进行屏蔽
    //在栈上开辟空间
    sigset_t block,oblock;
    sigemptyset(&block);
    sigemptyset(&oblock);
    //1.1 添加2号信号
    //我们把2号信号的屏蔽只是在用户栈上设置了block的位图结构
    //并没有设置进入内核中
    sigaddset(&block,2);
    //将其设置到内核
    sigprocmask(SIG_SETMASK,&block,&oblock);


    int cut=0;
    while (1)
    {
        
        sigset_t panding;

        sigpending(&panding);

        prinprint(panding);
        sleep(1);
        /* code */

        if(cut==10)
        {
            cout<<"解除对2号信号的屏蔽"<<endl;
            sigprocmask(SIG_SETMASK,&oblock,&block);
        }
        cut++;
    }
    

    return 0;
}

程序运⾏时,每秒钟把各信号的未决状态打印⼀遍,由于我们阻塞了SIGINT信号,按Ctrl-C将会使SIGINT信号处于未决状态,按Ctrl-仍然可以终⽌程序,因为SIGQUIT信号没有阻塞。

信号捕捉

信号捕捉的流程

如果信号的处理动作是用户自定义函数,在信号递达时就调⽤这个函数,这称为捕捉信号。

由于信号处理函数的代码是在用户空间的,处理过程比较复杂。举个例子就是

1. 用户程序注册了 SIGQUIT 信号的处理函数 sighandler
2. 当前正在执⾏ main 函数,这时发⽣中断或异常切换到内核态
3. 在中断处理完毕后要返回用户态的 main 函数之前检查到有信号 SIGQUIT 递达
4. 内核决定返回⽤⼾态后不是恢复main函数的上下⽂继续执⾏,而是执行sighandler函数,sighandler 和main函数使用不同的堆栈空间,它们之间不存在调⽤和被调用的关系,是两个独⽴的控制流程。
5. sighandler 函数返回后⾃动执⾏特殊的系统调⽤ sigreturn 再次进⼊内核态。
6. 如果没有新的信号要递达,这次再返回用户态就是恢复 main 函数的上下文继续执行了
   

sigaction

#include 
int sigaction(int signo, const struct sigaction *act, struct sigaction *oact);

• sigaction函数可以读取和修改与指定信号相关联的处理动作。调⽤成功则返回0,出错则返回-1。signo是指定信号的编号。若act指针⾮空,则根据act修改该信号的处理动作。若oact指针⾮空,则通过oact传出该信号原来的处理动作。act和oact指向sigaction结构体:
• 将sa_handler赋值为常数SIG_IGN传给sigaction表⽰忽略信号,赋值为常数SIG_DFL表⽰执⾏系统默认动作,赋值为⼀个函数指针表⽰⽤⾃定义函数捕捉信号,或者说向内核注册了⼀个信号处理函数,该函数返回值为void,可以带⼀个int参数,通过参数可以得知当前信号的编号,这样就可以⽤同⼀个函数处理多种信号。显然,这也是⼀个回调函数,不是被main函数调⽤,⽽是被系统所调⽤。

当某个信号的处理函数被调⽤时,内核⾃动将当前信号加⼊进程的信号屏蔽字,当信号处理函数返回时⾃动恢复原来的信号屏蔽字,这样就保证了在处理某个信号时,如果这种信号再次产⽣,那么它会被阻塞到当前处理结束为⽌。如果在调⽤信号处理函数时,除了当前信号被⾃动屏蔽之外,还希望⾃动屏蔽另外⼀些信号,则⽤sa_mask字段说明这些需要额外屏蔽的信号,当信号处理函数返回时⾃动恢复原来的信号屏字。sa_flags字段包含⼀些选项,本章的代码都把sa_flags设为0,sa_sigaction是实时信号的处理函数,本章不详细解释这两个字段,有兴趣可以在了解⼀下。

操作系统是怎么样运行的

硬件中断

1. 中断向量表就是操作系统的⼀部分，启动就加载到内存中了
2. 通过外部硬件中断，操作系统就不需要对外设进⾏任何周期性的检测或者轮询
3. 由外部设备触发的，中断系统运⾏流程，叫做硬件中断

// Linux内核0.11源码
void trap_init(void)
{
    int i;
    set_trap_gate(0, &divide_error); // 设置除操作出错的中断向量值。以下雷同。
    set_trap_gate(1, &debug);
    set_trap_gate(2, &nmi);
    set_system_gate(3, &int3); /* int3-5 can be called from all */
    set_system_gate(4, &overflow);
    set_system_gate(5, &bounds);
    set_trap_gate(6, &invalid_op);
    set_trap_gate(7, &device_not_available);
    set_trap_gate(8, &double_fault);
    set_trap_gate(9, &coprocessor_segment_overrun);
    set_trap_gate(10, &invalid_TSS);
    set_trap_gate(11, &segment_not_present);
    set_trap_gate(12, &stack_segment);
    set_trap_gate(13, &general_protection);
    set_trap_gate(14, &page_fault);
    set_trap_gate(15, &reserved);
    set_trap_gate(16, &coprocessor_error);
    // 下⾯将int17-48 的陷阱⻔先均设置为reserved，以后每个硬件初始化时会重新设置⾃⼰的陷阱⻔。
    for (i = 17; i < 48; i++)
        set_trap_gate(i, &reserved);
    set_trap_gate(45, &irq13);              // 设置协处理器的陷阱⻔。
    outb_p(inb_p(0x21) & 0xfb, 0x21);       // 允许主8259A 芯⽚的IRQ2 中断请求。
    outb(inb_p(0xA1) & 0xdf, 0xA1);         // 允许从8259A 芯⽚的IRQ13 中断请求。
    set_trap_gate(39, &parallel_interrupt); // 设置并⾏⼝的陷阱⻔。
}
void rs_init(void)
{
    set_intr_gate(0x24, rs1_interrupt); // 设置串⾏⼝1 的中断⻔向量(硬件IRQ4 信号)。
    set_intr_gate(0x23, rs2_interrupt); // 设置串⾏⼝2 的中断⻔向量(硬件IRQ3 信号)。
    init(tty_table[1].read_q.data);     // 初始化串⾏⼝1(.data 是端⼝号)。
    init(tty_table[2].read_q.data);     // 初始化串⾏⼝2。
    outb(inb_p(0x21) & 0xE7, 0x21);     // 允许主8259A 芯⽚的IRQ3，IRQ4 中断信号请求。
}

时钟中断

// Linux 内核0.11
// main.c
sched_init(); // 调度程序初始化(加载了任务0 的tr, ldtr) （kernel/sched.c）
// 调度程序的初始化⼦程序。
void sched_init(void)
{
    ... set_intr_gate(0x20, &timer_interrupt);
    // 修改中断控制器屏蔽码，允许时钟中断。
    outb(inb_p(0x21) & ~0x01, 0x21);
    // 设置系统调⽤中断⻔。
    set_system_gate(0x80, &system_call);
    ...
}
// system_call.s _timer_interrupt : ...; // do_timer(CPL)执⾏任务切换、计时等⼯作，在kernel/shched.c,305 ⾏实现。
call _do_timer; // 'do_timer(long CPL)' does everything from
// 调度⼊⼝
void do_timer(long cpl)
{
    ... schedule();
}
v
    oid
    schedule(void)
{
    ... switch_to(next); // 切换到任务号为next 的任务，并运⾏之。
}

死循环

如果是上面那样的话，操作系统不就可以躺平了吗？对，操作系统自己不做任何事情，需要什么功能，就向中断向量表⾥⾯添加⽅法即可.操作系统的本质：就是⼀个死循环！

void main(void) /* 这⾥确实是void，并没错。 */
{               /* 在startup 程序(head.s)中就是这样假设的。 */
    ...
        /*
         * 注意!! 对于任何其它的任务，'pause()'将意味着我们必须等待收到⼀个信号才会返
         * 回就绪运⾏态，但任务0（task0）是唯⼀的意外情况（参⻅'schedule()'），因为任
         * 务0 在任何空闲时间⾥都会被激活（当没有其它任务在运⾏时），
         * 因此对于任务0'pause()'仅意味着我们返回来查看是否有其它任务可以运⾏，如果没
         * 有的话我们就回到这⾥，⼀直循环执⾏'pause()'。
         */
        for (;;)
            pause();
} // end main

这样，操作系统，就可以在硬件时钟的推动下，⾃动调度了。

软中断

之前的都是硬件中断，需要硬件设备触发。其实也可以因为软件原因，也触发中断。
为了让操作系统⽀持进⾏系统调⽤，CPU也设计了对应的汇编指令(int或者syscall),可以让CPU内部触发中断逻辑。

用户是通过寄存器把系统调用号给操作系统的
操作系统是通过寄存器或用户传入的缓冲区地址
系统调用的过程，其实就是先int0x80、syscall陷入内核，本质就是触发软中断，CUP就会自动执行系统调用的处理方法，而这个方法会根据系统调用号，自动查找表，执行对应的方法。
系统调用的本质就是：数组下标

// sys.h
// 系统调⽤函数指针表。⽤于系统调⽤中断处理程序(int 0x80)，作为跳转表。
extern int sys_setup();     // 系统启动初始化设置函数。 (kernel/blk_drv/hd.c,71)
extern int sys_exit();      // 程序退出。 (kernel/exit.c, 137)
extern int sys_fork();      // 创建进程。 (kernel/system_call.s, 208)
extern int sys_read();      // 读⽂件。 (fs/read_write.c, 55)
extern int sys_write();     // 写⽂件。 (fs/read_write.c, 83)
extern int sys_open();      // 打开⽂件。 (fs/open.c, 138)
extern int sys_close();     // 关闭⽂件。 (fs/open.c, 192)
extern int sys_waitpid();   // 等待进程终⽌。 (kernel/exit.c, 142)
extern int sys_creat();     // 创建⽂件。 (fs/open.c, 187)
extern int sys_link();      // 创建⼀个⽂件的硬连接。 (fs/namei.c, 721)
extern int sys_unlink();    // 删除⼀个⽂件名(或删除⽂件)。 (fs/namei.c, 663)
extern int sys_execve();    // 执⾏程序。 (kernel/system_call.s, 200)
extern int sys_chdir();     // 更改当前⽬录。 (fs/open.c, 75)
extern int sys_time();      // 取当前时间。 (kernel/sys.c, 102)
extern int sys_mknod();     // 建⽴块/字符特殊⽂件。 (fs/namei.c, 412)
extern int sys_chmod();     // 修改⽂件属性。 (fs/open.c, 105)
extern int sys_chown();     // 修改⽂件宿主和所属组。 (fs/open.c, 121)
extern int sys_break();     // (-kernel/sys.c, 21)
extern int sys_stat();      // 使⽤路径名取⽂件的状态信息。 (fs/stat.c, 36)
extern int sys_lseek();     // 重新定位读/写⽂件偏移。 (fs/read_write.c, 25)
extern int sys_getpid();    // 取进程id。 (kernel/sched.c, 348)
extern int sys_mount();     // 安装⽂件系统。 (fs/super.c, 200)
extern int sys_umount();    // 卸载⽂件系统。 (fs/super.c, 167)
extern int sys_setuid();    // 设置进程⽤⼾id。 (kernel/sys.c, 143)
extern int sys_getuid();    // 取进程⽤⼾id。 (kernel/sched.c, 358)
extern int sys_stime();     // 设置系统时间⽇期。 (-kernel/sys.c, 148)
extern int sys_ptrace();    // 程序调试。 (-kernel/sys.c, 26)
extern int sys_alarm();     // 设置报警。 (kernel/sched.c, 338)
extern int sys_fstat();     // 使⽤⽂件句柄取⽂件的状态信息。(fs/stat.c, 47)
extern int sys_pause();     // 暂停进程运⾏。 (kernel/sched.c, 144)
extern int sys_utime();     // 改变⽂件的访问和修改时间。 (fs/open.c, 24)
extern int sys_stty();      // 修改终端⾏设置。 (-kernel/sys.c, 31)
extern int sys_gtty();      // 取终端⾏设置信息。 (-kernel/sys.c, 36)
extern int sys_access();    // 检查⽤⼾对⼀个⽂件的访问权限。(fs/open.c, 47)
extern int sys_nice();      // 设置进程执⾏优先权。 (kernel/sched.c, 378)
extern int sys_ftime();     // 取⽇期和时间。 (-kernel/sys.c,16)
extern int sys_sync();      // 同步⾼速缓冲与设备中数据。 (fs/buffer.c, 44)
extern int sys_kill();      // 终⽌⼀个进程。 (kernel/exit.c, 60)
extern int sys_rename();    // 更改⽂件名。 (-kernel/sys.c, 41)
extern int sys_mkdir();     // 创建⽬录。 (fs/namei.c, 463)
extern int sys_rmdir();     // 删除⽬录。 (fs/namei.c, 587)
extern int sys_dup();       // 复制⽂件句柄。 (fs/fcntl.c, 42)
extern int sys_pipe();      // 创建管道。 (fs/pipe.c, 71)
extern int sys_times();     // 取运⾏时间。 (kernel/sys.c, 156)
extern int sys_prof();      // 程序执⾏时间区域。 (-kernel/sys.c, 46)
extern int sys_brk();       // 修改数据段⻓度。 (kernel/sys.c, 168)
extern int sys_setgid();    // 设置进程组id。 (kernel/sys.c, 72)
extern int sys_getgid();    // 取进程组id。 (kernel/sched.c, 368)
extern int sys_signal();    // 信号处理。 (kernel/signal.c, 48)
extern int sys_geteuid();   // 取进程有效⽤⼾id。 (kenrl/sched.c, 363)
extern int sys_getegid();   // 取进程有效组id。 (kenrl/sched.c, 373)
extern int sys_acct();      // 进程记帐。 (-kernel/sys.c, 77)
extern int sys_phys();      // (-kernel/sys.c, 82)
extern int sys_lock();      // (-kernel/sys.c, 87)
extern int sys_ioctl();     // 设备控制。 (fs/ioctl.c, 30)
extern int sys_fcntl();     // ⽂件句柄操作。 (fs/fcntl.c, 47)
extern int sys_mpx();       // (-kernel/sys.c, 92)
extern int sys_setpgid();   // 设置进程组id。 (kernel/sys.c, 181)
extern int sys_ulimit();    // (-kernel/sys.c, 97)
extern int sys_uname();     // 显⽰系统信息。 (kernel/sys.c, 216)
extern int sys_umask();     // 取默认⽂件创建属性码。 (kernel/sys.c, 230)
extern int sys_chroot();    // 改变根系统。 (fs/open.c, 90)
extern int sys_ustat();     // 取⽂件系统信息。 (fs/open.c, 19)
extern int sys_dup2();      // 复制⽂件句柄。 (fs/fcntl.c, 36)
extern int sys_getppid();   // 取⽗进程id。 (kernel/sched.c, 353)
extern int sys_getpgrp();   // 取进程组id，等于getpgid(0)。(kernel/sys.c, 201)
extern int sys_setsid();    // 在新会话中运⾏程序。 (kernel/sys.c, 206)
extern int sys_sigaction(); // 改变信号处理过程。 (kernel/signal.c, 63)
extern int sys_sgetmask();  // 取信号屏蔽码。 (kernel/signal.c, 15)
extern int sys_ssetmask();  // 设置信号屏蔽码。 (kernel/signal.c, 20)
extern int sys_setreuid();  // 设置真实与/或有效⽤⼾id。 (kernel/sys.c,118)
extern int sys_setregid();  // 设置真实与/或有效组id。 (kernel/sys.c, 51)
// 系统调⽤函数指针表。⽤于系统调⽤中断处理程序(int 0x80)，作为跳转表。
fn_ptr sys_call_table[] = {sys_setup, sys_exit, sys_fork, sys_read,
                           sys_write, sys_open, sys_close, sys_waitpid, sys_creat, sys_link,
                           sys_unlink, sys_execve, sys_chdir, sys_time, sys_mknod, sys_chmod,
                           sys_chown, sys_break, sys_stat, sys_lseek, sys_getpid, sys_mount,
                           sys_umount, sys_setuid, sys_getuid, sys_stime, sys_ptrace, sys_alarm,
                           sys_fstat, sys_pause, sys_utime, sys_stty, sys_gtty, sys_access,
                           sys_nice, sys_ftime, sys_sync, sys_kill, sys_rename, sys_mkdir,
                           sys_rmdir, sys_dup, sys_pipe, sys_times, sys_prof, sys_brk, sys_setgid,
                           sys_getgid, sys_signal, sys_geteuid, sys_getegid, sys_acct, sys_phys,
                           sys_lock, sys_ioctl, sys_fcntl, sys_mpx, sys_setpgid, sys_ulimit,
                           sys_uname, sys_umask, sys_chroot, sys_ustat, sys_dup2, sys_getppid,
                           sys_getpgrp, sys_setsid, sys_sigaction, sys_sgetmask, sys_ssetmask,
                           sys_setreuid, sys_setregid};
// 调度程序的初始化⼦程序。
void sched_init(void)
{
    ...
        // 设置系统调⽤中断⻔。
        set_system_gate(0x80, &system_call);
}
_
    system_call : cmp eax,
                  nr_system_calls - 1; // 调⽤号如果超出范围的话就在eax 中置-1 并退出。
ja bad_sys_call
    push ds; // 保存原段寄存器值。
push es
    push fs
        push edx;                         // ebx,ecx,edx 中放着系统调⽤相应的C 语⾔函数的调⽤参数。
push ecx;                                 // push %ebx,%ecx,%edx as parameters
push ebx;                                 // to the system call
mov edx, 10h;                             // set up ds,es to kernel space
mov ds, dx;                               // ds,es 指向内核数据段(全局描述符表中数据段描述符)。
mov es, dx mov edx, 17h;                  // fs points to local data space
mov fs, dx;                               // fs 指向局部数据段(局部描述符表中数据段描述符)。
;                                         // 下⾯这句操作数的含义是：调⽤地址 = _sys_call_table + %eax * 4。参⻅列表后的说明。
;                                         // 对应的C 程序中的sys_call_table 在include/linux/sys.h 中，其中定义了⼀个包括72 个
;                                         // 系统调⽤C 处理函数的地址数组表。
call[_sys_call_table + eax * 4] push eax; // 把系统调⽤号⼊栈。
mov eax, _current;                        // 取当前任务（进程）数据结构地址??eax。
;                                         // 下⾯97-100 ⾏查看当前任务的运⾏状态。如果不在就绪状态(state 不等于0)就去执⾏调度程
序。;                                     // 如果该任务在就绪状态但counter[??]值等于0，则也去执⾏调度程序。
cmp dword ptr[state + eax], 0;            // state
jne reschedule
    cmp dword ptr[counter + eax],
    0;         // counter
je reschedule; // 以下这段代码执⾏从系统调⽤C 函数返回后，对信号量进⾏识别处理。
ret_from_sys_call:

int 0x80 或者 syscall 从哪里来呢？
Linux的gnu C标准库，给我们把⼏乎所有的系统调⽤全部封装了。

缺页中断？内存碎⽚处理？除零野指针错误？

缺⻚中断？内存碎⽚处理？除零野指针错误？这些问题，全部都会被转换成为CPU内部的软中断，然后⾛中断处理例程，完成所有处理。有的是进⾏申请内存，填充⻚表，进⾏映射的。有的是⽤来处理内存碎⽚的，有的是⽤来给⽬标进⾏发送信号，杀掉进程等等

总结：

1. 操作系统就是躺在中断处理例程上的代码块！
2. CPU内部的软中断，⽐如int0x80或者syscall，我们叫做陷阱
3. CPU内部的软中断，⽐如除零/野指针等，我们叫做异常

如何理解内核态和用户态

我们调用的任何函数（库，系统调用），但是在我们自己进程的地址空间中进行调用的，都是通过将系统调用号和下一条指令（代码）的地址+要传的参数存进寄存器中（EXA），然后OS通过拿到系统调用号在对应的表中拿到对应的函数，进行执行，然后执行完毕后，将返回值等一系列参数放回到寄存器中，拿到这些参数后，然后弹栈，继续调用下一条指令。

操作系统无论怎么切换进程，都能找到同一个操作系统，换句话说就是操作系统在系统调用方法的执行，是在进程的地址空间执行的。

不管是通过哪一个进程的地址空间进入内核，都是通过软中断进入操作的。

用户进入内核态的几种情况：
1 当有时钟中断（外设中断）时，当前进程会立即停止
2 当CUP内部出现异常时，就会触发软中断，操作系统自动执行处理软中断的方法。
3 陷阱（int0x80）

结论：

1. 操作系统⽆论怎么切换进程，都能找到同⼀个操作系统！换句话说操作系统系统调⽤⽅法的执行，是在进程的地址空间中执行的！
2. 关于特权级别，涉及到段，段描述符，段选择⼦，DPL，CPL，RPL等概念，而现在芯⽚为了保证兼容性，已经⾮常复杂了，进⽽导致OS也必须得照顾它的复杂性
3. ⽤⼾态就是执行用户[0,3]GB时所处的状态
4. 内核态就是执行内核[3,4]GB时所处的状态
5. 区分就是按照CPU内的CPL决定，CPL的全称是Current Privilege Level，即当前特权级别。
6. ⼀般执⾏ int 0x80 或者 syscall 软中断，CPL会在校验之后⾃动变更(怎么校验看学⽣反映)

补充：CS段寄存器：
CPL 0表示内核 3表示用户

可重入函数

执行情况：main函数调⽤insert函数向⼀个链表head中插⼊节点node1,插⼊操作分为两步,刚做完第⼀步的时候,因为硬件中断使进程切换到内核,再次回⽤⼾态之前检查到有信号待处理,于是切换到sighandler函数,sighandler也调⽤insert函数向同⼀个链表head中插⼊节点node2,插⼊操作的两步都做完之后从sighandler返回内核态,再次回到⽤⼾态就从main函数调⽤的insert函数中继续往下执⾏,先前做第⼀步之后被打断,现在继续做完第⼆步。结果是,main函数和sighandler先后向链表中插⼊两个节点,⽽最后只有⼀个节点真正插⼊链表中了。

insert函数被不同的控制流程调⽤,有可能在第⼀次调⽤还没返回时就再次进⼊该函数,这称为重⼊,insert函数访问⼀个全局链表,有可能因为重⼊⽽造成错乱,像这样的函数称为不可重⼊函数,反之,如果⼀个函数只访问⾃⼰的局部变量或参数,则称为可重⼊(Reentrant)函数

简单点就是：一个函数被两个以上的执行流同时进入了——重入
结果：出问题了=该函数是不可重入函数
没有出问题=该函数是可重入函数

如果⼀个函数符合以下条件之⼀则是不可重⼊的:

1. 调⽤了malloc或free,因为malloc也是⽤全局链表来管理堆的。
2. 调⽤了标准I/O库函数。标准I/O库的很多实现都以不可重⼊的⽅式使⽤全局数据结构。

Volatile

[hb@localhost code_test]$ cat sig.c
#include 
#include 
int flag = 0;
void handler(int sig)
{
	printf("chage flag 0 to 1
");
	flag = 1;
} 
int main()
{
	signal(2, handler);
	while(!flag);
	printf("process quit normal
");
	return 0;
} 
//标准情况下，键⼊ CTRL-C ,2号信号被捕捉，执⾏⾃定义动作，修改 flag＝1 ，
//while条件不满⾜,退出循环，进程退出
xxx@localhost code_test]$ cat Makefile
sig:sig.c
gcc -o sig sig.c #-O2
.PHONY:clean
clean:
rm -f sig
xxx@localhost code_test]$ ./sig
^Cchage flag 0 to 1
process quit normal

[hb@localhost code_test]$ cat sig.c
#include 
#include 
int flag = 0;
void handler(int sig)
{
printf("chage flag 0 to 1
");
flag = 1;
} 
int main()
{
	signal(2, handler);
	while(!flag);
	printf("process quit normal
");
	return 0;
} 
xxx@localhost code_test]$ cat Makefile
sig:sig.c
gcc -o sig sig.c -O2
.PHONY:clean
clean:
rm -f sig
xxx@localhost code_test]$ ./sig
^Cchage flag 0 to 1
^Cchage flag 0 to 1
^Cchage flag 0 to 1

优化情况下，键⼊ CTRL-C ，2号信号被捕捉，执⾏⾃定义动作，修改 flag＝1 ，但是while条件依旧满⾜,进程继续运⾏！但是很明显flag肯定已经被修改了，但是为何循环依旧执⾏？很明显，while 循环检查的flag，并不是内存中最新的flag，这就存在了数据⼆异性的问题。 while 检测的flag其实已经因为优化，被放在了CPU寄存器当中。如何解决呢？很明显需要volatile。

当加了volatile后

[hb@localhost code_test]$ cat sig.c
#include 
#include 

volatile int flag = 0;
void handler(int sig)
{
	printf("chage flag 0 to 1
");
	flag = 1;
} 
int main()
{
	signal(2, handler);
	while(!flag);
	printf("process quit normal
");
	return 0;
} 
xxx@localhost code_test]$ cat Makefile
sig:sig.c
gcc -o sig sig.c -O2
.PHONY:clean
clean:
rm -f sig
xxx@localhost code_test]$ ./sig
^Cchage flag 0 to 1
process quit normal

volatile 作⽤：保持内存的可⻅性，告知编译器，被该关键字修饰的变量，不允许被优化，对该
变量的任何操作，都必须在真实的内存中进⾏操作

SIGCHLD信号

当子进程被创建后，父进程就要用wait和waitpid函数清理子进程，⽗进程可以阻塞等待⼦进程结束,也可以⾮阻塞地查询是否有⼦进程结束等待清理(也就是轮询的⽅式)。

采⽤第⼀种⽅式,⽗进程阻塞了就不能处理⾃⼰的⼯作了;
采⽤第⼆种⽅式,⽗进程在处理⾃⼰的⼯作的同时还要记得时不时地轮询⼀下,程序实现复杂。

其实,⼦进程在终⽌时会给⽗进程发SIGCHLD信号,该信号的默认处理动作是忽略,⽗进程可以⾃定义SIGCHLD信号的处理函数,这样⽗进程只需专⼼处理⾃⼰的⼯作,不必关⼼⼦进程了,⼦进程终⽌时会通知⽗进程,⽗进程在信号处理函数中调⽤wait清理⼦进程即可。

事实上,由于UNIX的历史原因,要想不产⽣僵⼫进程还有另外⼀种办法:⽗进程调⽤sigaction将SIGCHLD的处理动作置为SIG_IGN,这样fork出来的⼦进程在终⽌时会⾃动清理掉,不会产⽣僵⼫进程,也不会通知⽗进程。系统默认的忽略动作和用户⽤sigaction函数⾃定义的忽略通常是没有区别的,但这是⼀个特例。此⽅法对于Linux可⽤,但不保证在其它UNIX系统上都可⽤。
编写程序验证这样做不会产⽣僵⼫进程。

#include 
#include 
#include 
#include 
#include 
void handler(int sig)
{
    while (1)
    {
        pid_t id = waitpid(-1, NULL, WNOHANG);//交给WNOHANG
        if (id > 0)
        {
            std::cout << "关闭" << getpid() << std::endl;
        }
        else if (id == 0)
        {
            std::cout << "暂时关闭" << std::endl;
            break;
        }
        else
        {
            std::cout << "全部关闭" << std::endl;
            break;
        }
        /* code */
    }
}

int main()
{
    signal(SIGCHLD, handler);
    //signal(SIGCHLD, SIG_IGN);//另一种方法

    //当10个甚至更多个子进程一起来时
    for (int i = 0; i < 10; i++)
    {
        if (fork() == 0)
        {
            sleep(3);
            exit(1);
        }
    }

    while (1)
    {
        sleep(3);
        /* code */
    }

    return 0;
}