linux内核原理－共享内存，信号

1.共享内存
(1). 定义
在Linux中，进程间通信（IPC）有多种方式，其中共享内存（Shared Memory）是一种非常高效的方式。它允许两个或多个进程共享同一块物理内存区域，从而可以快速地传递大量数据。

共享内存的基本概念
共享内存允许两个或多个进程共享一个给定的存储区。因为数据不需要在不同的进程之间复制，所以这是一种最快的一种IPC方式。通常是通过使用某种同步手段（如信号量）来同步对共享内存的访问。

共享内存的基本步骤：
a. 创建共享内存对象：使用shmget函数来创建一个新的共享内存对象或获取一个已存在的共享内存对象。

#include <sys/ipc.h>  
#include <sys/shm.h>  
int shmget(key_t key, size_t size, int shmflg);

key：用于唯一标识共享内存对象的键。
size：共享内存对象的大小（以字节为单位）。
shmflg：创建标志和权限标志的组合。

b. 连接共享内存对象：使用shmat函数将共享内存对象连接到进程的地址空间。

void *shmat(int shmid, const void *shmaddr, int shmflg);

shmid：共享内存对象的标识符。
shmaddr：指定共享内存对象在进程地址空间中的连接地址。如果为NULL，则由系统选择地址。
shmflg：标志位，通常设置为0。

c. 使用共享内存：一旦共享内存对象被连接到进程的地址空间，进程就可以像操作普通内存一样操作这块共享内存。

d. 断开共享内存连接：当进程不再需要访问共享内存时，应使用shmdt函数断开连接。

int shmdt(const void *shmaddr);

shmaddr：指向共享内存对象在进程地址空间中的指针。

e. 删除共享内存对象：当不再需要共享内存对象时，可以使用shmctl函数删除它。

int shmctl(int shmid, int cmd, struct shmid_ds *buf);

shmid：共享内存对象的标识符。
cmd：要执行的命令（如IPC_RMID来删除共享内存对象）。
buf：指向shmid_ds结构的指针，用于获取或设置共享内存对象的属性。

注意事项：
e.1. 同步问题：多个进程访问共享内存时，需要确保同步访问，以避免数据不一致或冲突。这通常通过信号量（semaphore）、互斥锁（mutex）或其他同步机制来实现。
e.2. 权限问题：创建共享内存对象时，需要设置适当的权限，以确保只有授权的进程可以访问它。
e.3. 内存管理：虽然共享内存允许进程之间共享数据，但每个进程仍然需要负责自己地址空间中的内存管理，如避免内存泄漏等。

(2). 实例
服务端实例

#pragma once
#include<iostream>
#include<string>
#include<unistd.h>
#include<cstdio>
#include<sys/shm.h>
#include<sys/ipc.h>
#include<sys/types.h>
#include<cassert>
#include<cstring>
#include<sys/stat.h>
#include<fcntl.h>
#include <pthread.h> 
struct shared_memory {  
    int nIndex;
    int nArr[1000];
    pthread_mutex_t lock;  
    bool bReady;
};

using namespace std;
#define PATHNAME "/home/xubenhao"  
#define PROJ_ID 0x666  
int main()
{
    key_t key = ftok(PATHNAME, 0);
    printf("key_%d,errno_%d\n", key, errno);
    int shmid = shmget(key, sizeof(struct shared_memory), IPC_CREAT | IPC_EXCL | 0666);
    if(shmid == -1) {
        printf("shmget err %d\n", shmid);
        return 0;
    }

    printf("shmid_%d\n", shmid);
    struct shared_memory *shared_ptr = (struct shared_memory *) shmat(shmid, NULL, 0);  
    if (shared_ptr == (void *) -1) {  
        printf("shmat err\n");  
        return 0;
    }  

    printf("shared_ptr_%x\n", shared_ptr);
    printf("ready now_%d\n", shared_ptr->bReady);
    // 初始化
    if (pthread_mutex_init(&shared_ptr->lock, NULL) != 0) {  
        printf("mutext init err\n");
        return 0;  
    }  
    
    shared_ptr->nIndex = 0;
    for(int i = 0; i < 1000; i++){
        shared_ptr->nArr[i] = 0;
    }
    shared_ptr->bReady = true;
    printf("ready,wait stop\n");
    while(true){
        char c = getchar();
        if(c == 'q'){
            break;
        }
    }
    
    // 退出前打印一次
    printf("count_%d\n", shared_ptr->nIndex);
    for(int i = 0; i < shared_ptr->nIndex; i++){
        printf("%d ", shared_ptr->nArr[i]);
    }
    printf("\n");
    int n1 = shmdt(shared_ptr);
    printf("shmdt %d\n", n1);
    int n2 = shmctl(shmid,IPC_RMID,nullptr);
    printf("shmctl %d\n", n2);
    return 0;
}

客户端实例

#pragma once
#include<iostream>
#include<string>
#include<unistd.h>
#include<cstdio>
#include<sys/shm.h>
#include<sys/ipc.h>
#include<sys/types.h>
#include<cassert>
#include<cstring>
#include<sys/stat.h>
#include<fcntl.h>
#include <pthread.h> // 引入互斥锁相关的头文件
struct shared_memory {  
    int nIndex;
    int nArr[1000];
    pthread_mutex_t lock; // 互斥锁  
    bool bReady;
};

using namespace std;
#define PATHNAME "/home/xubenhao"  
#define PROJ_ID 0  
int main() {
    key_t k = ftok(PATHNAME, PROJ_ID);
    printf("key_%0x,errno_%d\n", k, errno);
    // 获取共享内存
    int shmid = shmget(k, sizeof(struct shared_memory), 0);
    if(shmid < 0)
    {
        printf("shmget err %d\n", shmid);
        return 0;
    }

    printf("shmget %d\n");
    struct shared_memory *shared_ptr = (struct shared_memory *) shmat(shmid, NULL, 0);  
    if (shared_ptr == (void *) -1) {  
        printf("shmat err %d\n", shared_ptr);
        return 0;
    }  

    while(shared_ptr->bReady == false){
    }

    pthread_mutex_lock(&shared_ptr->lock);  
    for(int i = 0; i < 100; i++){
        shared_ptr->nArr[shared_ptr->nIndex] = shared_ptr->nIndex;
        shared_ptr->nIndex++;
    }
    pthread_mutex_unlock(&shared_ptr->lock);

    int n = shmdt(shared_ptr);
    printf("shmdt %d\n", n);
    return 0;
}

(3). 原理
shmget共享内存原理主要涉及到以下几个关键步骤和概念：
a. shmget函数
此函数用于在系统中创建一片共享内存空间，并返回这片共享内存的标识（ID）。这个函数的一个重要参数是shm_key，它能唯一地标识一片物理内存。如果两个进程想要通过共享内存进行通信，它们必须映射到同一片物理内存。因此，第一个进程使用某个key创建共享内存空间后，第二个进程使用相同的key调用shmget时，它不会创建新的共享内存，而是直接获取前一个进程创建的共享内存。
b. 共享内存空间映射
一旦共享内存空间被创建，shmat调用可以将这片共享内存空间映射到进程的虚拟内存空间，并返回对应的虚拟地址。这样，进程就可以像访问普通内存一样访问共享内存。
c. IPC共享内存与内核tmpfs文件系统
IPC（进程间通信）共享内存实际上利用了内核的tmpfs文件系统。tmpfs是一个基于内存的文件系统，它允许将文件直接存储在RAM中，从而提供快速的I/O性能。由于tmpfs文件系统直接建立在物理内存上，因此共享内存的实现得以高效且快速地进行。
总的来说，shmget共享内存原理是通过在内核中创建和管理共享内存空间，并利用tmpfs文件系统实现高效的内存访问，从而实现进程间的数据共享和通信。这种机制使得多个进程可以访问和修改同一片内存区域，从而简化了进程间的通信和数据共享过程。本质上是利用文件对象共享映射实现多进程访问同一后备存储区域．

2.信号
(1). 信号的阻塞与屏蔽
在Linux系统中，信号的阻塞和忽略是处理信号时的两种不同策略。

信号阻塞意味着操作系统在信号被进程解除阻塞之前不会将信号传递出去。每个进程都有一个信号掩码，这是一个“位图”，用来描述哪些信号传送来将被阻塞。如果位图中某位标识为1，表示该位对应的信号被暂时屏蔽，即被阻塞。当信号处于阻塞状态时，信号只是暂时被阻止传递，不会影响进程的行为。进程可以使用各种系统调用来对其信号掩码添加和移除信号，从而控制哪些信号被阻塞。

与信号阻塞不同，当进程忽略一个信号时，信号仍然会被传递出去，但进程将信号丢弃，即不对其进行任何处理。这意味着信号已经到达了进程，但进程选择不响应它。

在Linux中，有多种信号和信号处理方式。标准信号用于内核向进程通知事件，而实时信号则可以在稍后被传递给某进程，进程也会采取某措施来响应信号。在信号产生和到达期间，信号处于pending（等待）状态。通过阻塞或忽略信号，进程可以更加灵活地控制其行为和响应方式。

总的来说，Linux信号的阻塞和忽略是两种不同的信号处理策略，它们允许进程根据具体需求来控制对信号的响应方式。

需要注意的是，即使信号被阻塞，它们仍然会保留在系统中，等待进程解除阻塞后进行处理。因此，即使进程在一段时间内没有解除对某个信号的阻塞，这个信号也不会丢失或被忽略。只有当进程显式地忽略了某个信号时，该信号才会被丢弃，不会触发任何处理程序。

(2). 信号处理与多线程
a. 通过kill向一个多线程的进程发信号，信号处理会在那个线程的上下文中执行
在Linux中，当一个信号被发送到多线程进程时，信号处理函数（如果已设置）将在进程的一个线程上下文中执行。但是，这个线程上下文并不是预先确定的，也不是由信号的发送者选择的。确切地说，操作系统会选择一个线程来执行信号处理函数。

通常情况下，操作系统会选择任意一个没有阻塞该信号的线程来执行信号处理函数。这意味着，如果有多个线程没有阻塞该信号，那么操作系统可能会选择其中任何一个线程。具体选择哪个线程通常是由操作系统的调度策略和当前的系统状态决定的。

重要的是要理解，信号处理函数是在进程上下文中执行的，而不是在特定的线程上下文中。这意味着信号处理函数可以访问进程的全局变量和共享资源，但是它不会获得任何特定线程的局部变量或栈状态。

由于信号处理函数的执行是异步的，它可能打断正在执行的线程，包括持有重要锁或资源的线程。因此，在编写信号处理函数时，需要格外小心，确保它不会破坏进程的状态或导致数据不一致。特别是，在信号处理函数中访问或修改共享资源时，必须使用适当的同步机制来避免竞态条件。

总结来说，通过kill向一个多线程进程发送信号时，信号处理函数会在进程的一个线程上下文中执行，但具体是哪个线程是不确定的，由操作系统决定。因此，在编写信号处理逻辑时，需要确保它是线程安全的，并且能够处理潜在的并发问题。

b. 信号处理的进程与线程
在Linux中，每个进程有一个进程控制块（PCB），其中包含了关于该进程的信息，包括其信号掩码和信号处理函数。当一个信号被发送给进程时，操作系统会根据该进程的信号掩码来确定是否应该传递该信号。如果信号没有被阻塞，那么操作系统会查找该进程的PCB中的信号处理函数，并调用该函数来处理信号。

对于多线程进程，虽然每个线程有其自己的线程控制块（TCB），但是它们共享同一个进程控制块。这意味着它们共享相同的信号掩码和信号处理函数。因此，当一个信号到达进程时，无论是发送给整个进程还是特定的线程，信号处理函数只会被执行一次，而不是在每个线程中分别执行。

此外，线程可以拥有自己独立的信号掩码，这意味着它们可以选择性地阻塞或解除阻塞某些信号。因此，尽管信号在概念上是发送给整个进程的，但实际上每个线程都可以根据自己的信号掩码来决定是否响应某个信号。

(3). 信号处理程序编写原则
在信号处理程序中，有一些操作是安全的，而有一些操作则是不安全的，甚至可能导致未定义的行为或程序崩溃。下面是一些建议：
可以执行的操作：
a. 设置全局变量的值：这通常是安全的，只要这些变量不涉及到多线程间的同步问题
b. 记录日志：将信号到达的信息记录到日志文件中通常是安全的。
c. 调用sigaction来更改信号处理函数：可以在信号处理程序中更改信号的处理方式，但这需要小心，以避免产生递归信号。
d. 调用raise或kill发送信号给其他进程或线程：只要确保不会发送会导致递归的信号。
e. 执行一些快速且简单的清理工作：例如，关闭文件描述符或释放某些资源。

不可以执行的操作：
a. 调用大多数库函数：许多库函数都不是异步信号安全的（AS-unsafe）。这意味着在信号处理程序中调用它们可能会导致未定义的行为。这包括大多数I/O函数（如printf、fread、fwrite等）、内存分配函数（如malloc、free）、以及许多其他常见的库函数。
b. 修改全局数据结构：如果这些数据结构可能被其他线程访问或修改，那么在信号处理程序中修改它们可能会导致数据不一致或竞态条件。
c. 长时间运行的操作：信号处理程序的执行应该尽可能快，以避免阻塞其他信号或导致其他问题。
d. 调用不是异步信号安全的系统调用：一些系统调用在信号处理程序中是不安全的。在编写信号处理代码时，应该查阅相关文档以确定哪些系统调用是安全的。
e. 创建或销毁线程：在信号处理程序中创建或销毁线程通常是不安全的，因为这涉及到复杂的线程管理和同步问题。
f. 访问非线程局部存储：访问非线程局部存储（TLS）中的数据在信号处理程序中通常是不可靠的，因为信号处理函数可能在一个与原始线程不同的线程上下文中执行。

总的来说，信号处理程序的编写应该非常小心，并且应该尽可能简单和快速。在信号处理程序中执行的操作应该被限制在最小的范围内，并且应该避免任何可能导致未定义行为或程序崩溃的操作。最好的做法是将信号处理函数限制为设置标志或记录日志，然后在主程序的安全上下文中处理这些标志或日志。

以为何不建议在信号处理中执行malloc为例，深入分析．
假设某线程正在执行malloc，此时先是遭遇中断，又在中断返回引发信号处理．信号处理中也执行了malloc，这就可能引发单线程下死锁．malloc内部是通过一个全局锁来保持互斥的．