下面来讲解一下文件锁有关的API，它是进程级别的锁。
1. **`fcntl()`**：控制文件描述符的属性。



   ```c
   #include <fcntl.h>

   int fcntl(int fd, int cmd, ... /* arg */ );
   ```

   - `fd`：文件描述符。
   - `cmd`：控制命令，可以是以下之一：
     - `F_SETLK`：设置锁（非阻塞）
     - `F_SETLKW`：设置锁（阻塞）
     - `F_GETLK`：获取锁信息
   - `arg`：命令的附加参数，可以是一个 `struct flock` 结构。

   返回值：
   - 成功时返回执行命令的结果（根据命令不同）。
   - 失败时返回 -1，并设置 `errno`。

2. **`struct flock`**：文件锁信息结构。

   ```c
   struct flock {
       short l_type;    // 锁的类型：F_RDLCK、F_WRLCK、F_UNLCK
       short l_whence;  // 偏移量起点：SEEK_SET、SEEK_CUR、SEEK_END
       off_t l_start;   // 锁的起始偏移量
       off_t l_len;     // 锁的长度，0 表示锁住整个文件
       pid_t l_pid;     // 持有锁的进程ID（F_GETLK 命令返回）
   };
   ```

   - `l_type`：锁的类型，可以是 `F_RDLCK`（读锁）、`F_WRLCK`（写锁）、`F_UNLCK`（解锁）。
   - `l_whence`：偏移量起点，如 `SEEK_SET`、`SEEK_CUR`、`SEEK_END`。
   - `l_start`：锁的起始偏移量。
   - `l_len`：锁的长度，0 表示锁住整个文件。
   - `l_pid`：持有锁的进程ID，`F_GETLK` 命令返回时会填充。

3. **文件锁类型**：
   - **读锁（F_RDLCK）**：允许其他进程获取读锁，但阻止其他进程获取写锁。
   - **写锁（F_WRLCK）**：阻止其他进程获取读锁和写锁。
   - **解锁（F_UNLCK）**：释放文件上的锁。

以下是演示：

进程1 - 写入数据：

```c
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    int fd = open("file_lock_example.txt", O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);
    if (fd == -1) {
        perror("打开文件失败");
        exit(1);
    }

    struct flock lock;
    lock.l_type = F_WRLCK;  // 写锁
    lock.l_whence = SEEK_SET;
    lock.l_start = 0;
    lock.l_len = 0;  // 锁住整个文件

    printf("进程1 尝试获取写锁...\n");
    if (fcntl(fd, F_SETLKW, &lock) == -1) {
        perror("获取写锁失败");
        exit(1);
    }

    printf("进程1 获取写锁成功，写入数据...\n");
    sleep(30);  // 模拟写入数据的耗时操作

    lock.l_type = F_UNLCK;  // 解锁
    if (fcntl(fd, F_SETLKW, &lock) == -1) {
        perror("解锁失败");
        exit(1);
    }

    close(fd);

    return 0;
}
```

进程2 - 读取数据：

```c
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    int fd = open("file_lock_example.txt", O_RDONLY);
    if (fd == -1) {
        perror("打开文件失败");
        exit(1);
    }

    struct flock lock;
    lock.l_type = F_RDLCK;  // 读锁
    lock.l_whence = SEEK_SET;
    lock.l_start = 0;
    lock.l_len = 0;  // 锁住整个文件

    printf("进程2 尝试获取读锁...\n");
    if (fcntl(fd, F_SETLKW, &lock) == -1) {
        perror("获取读锁失败");
        exit(1);
    }

    printf("进程2 获取读锁成功，读取数据...\n");
    sleep(2);  // 模拟读取数据的耗时操作

    lock.l_type = F_UNLCK;  // 解锁
    if (fcntl(fd, F_SETLKW, &lock) == -1) {
        perror("解锁失败");
        exit(1);
    }

    close(fd);

    return 0;
}
```

当某个进程获取一个文件的写锁，这个文件就会被锁死，其他进程无法获取他的锁，包括写锁读锁，所以上面进程2会阻塞

![image.png](/static/img/82a0dd03c0404fbadfea23aa32c448bb.image.webp)

你也可以用信号量来进行模拟文件锁操作，还有共享内存等，锁就是一个与各自状态无关联且双方都能够访问的变量。

file lock

写个简单的c程序
```c
#include <stdio.h>

int add(int a, int b) {
    int result = a + b;
    return result;
}





int main() {
    int x = 5;
    int y = 7;
    int sum = add(x, y);
    printf("Sum: %d\n", sum);
    return 0;
}

```
接下来用gcc把它编译成汇编代码
```bash
gcc -S -o add.s add.c
```
查看汇编代码`cat add.s`，这是一段`x86_64`汇编。
```
        .file	"add.c"           // 源文件名

        .text                   // 文本段开始
        .globl	add             // 声明全局可见函数 add
        .type	add, @function   // 声明 add 为函数类型
add:                    // add 函数标签
.LFB0:                  // 函数基本块标签
        .cfi_startproc          // 开始定义过程
        endbr64                 // 启用分支目标地址检查
        pushq	%rbp            // 将 %rbp 寄存器值压入栈
        .cfi_def_cfa_offset 16  // 定义栈偏移量
        .cfi_offset 6, -16     // 定义 %rbp 的偏移
        movq	%rsp, %rbp      // 将栈指针保存到 %rbp
        .cfi_def_cfa_register 6 // 定义 %rbp 为栈指针
        movl	%edi, -20(%rbp) // 将 %edi 寄存器值存储到偏移 -20(%rbp) 的位置
        movl	%esi, -24(%rbp) // 将 %esi 寄存器值存储到偏移 -24(%rbp) 的位置
        movl	-20(%rbp), %edx // 将偏移 -20(%rbp) 处的值加载到 %edx 寄存器
        movl	-24(%rbp), %eax // 将偏移 -24(%rbp) 处的值加载到 %eax 寄存器
        addl	%edx, %eax      // 将 %edx 和 %eax 寄存器值相加，结果存入 %eax
        movl	%eax, -4(%rbp)  // 将 %eax 寄存器值存储到偏移 -4(%rbp) 的位置
        movl	-4(%rbp), %eax  // 将偏移 -4(%rbp) 处的值加载到 %eax 寄存器
        popq	%rbp            // 弹出栈中的 %rbp 寄存器值
        .cfi_def_cfa 7, 8      // 定义新的栈顶
        ret                     // 函数返回指令
        .cfi_endproc            // 结束定义过程
.LFE0:                  // 函数结束标签
        .size	add, .-add         // 计算函数大小
        .section	.rodata         // 数据段开始
.LC0:                    // 字符串常量标签
        .string	"Sum: %d\n"      // 定义字符串常量
        .text                   // 文本段
        .globl	main             // 声明全局可见函数 main
        .type	main, @function   // 声明 main 为函数类型
main:                   // main 函数标签
.LFB1:                  // 函数基本块标签
        .cfi_startproc          // 开始定义过程
        endbr64                 // 启用分支目标地址检查
        pushq	%rbp            // 将 %rbp 寄存器值压入栈
        .cfi_def_cfa_offset 16  // 定义栈偏移量
        .cfi_offset 6, -16     // 定义 %rbp 的偏移
        movq	%rsp, %rbp      // 将栈指针保存到 %rbp
        subq	$16, %rsp       // 减少栈指针
        movl	$5, -12(%rbp)   // 将 5 存储到偏移 -12(%rbp) 的位置
        movl	$7, -8(%rbp)    // 将 7 存储到偏移 -8(%rbp) 的位置
        movl	-8(%rbp), %edx  // 将偏移 -8(%rbp) 处的值加载到 %edx 寄存器
        movl	-12(%rbp), %eax // 将偏移 -12(%rbp) 处的值加载到 %eax 寄存器
        movl	%edx, %esi      // 将 %edx 寄存器值存入 %esi
        movl	%eax, %edi      // 将 %eax 寄存器值存入 %edi
        call	add             // 调用 add 函数
        movl	%eax, -4(%rbp)  // 将 %eax 寄存器值存储到偏移 -4(%rbp) 的位置
        movl	-4(%rbp), %eax  // 将偏移 -4(%rbp) 处的值加载到 %eax 寄存器
        movl	%eax, %esi      // 将 %eax 寄存器值存入 %esi
        leaq	.LC0(%rip), %rax // 将字符串常量地址存入 %rax
        movq	%rax, %rdi      // 将 %rax 寄存器值存入 %rdi
        movl	$0, %eax        // 将 0 存入 %eax 寄存器
        call	printf@PLT     // 调用 printf 函数
        movl	$0, %eax        // 将 0 存入 %eax 寄存器
        leave                   // 离开函数
        .cfi_def_cfa 7, 8      // 定义新的栈顶
        .ret                    // 函数返回
        .cfi_endproc            // 结束定义过程
.LFE1:                  // 函数结束标签
        .size	main, .-main       // 计算函数大小
        .ident	"GCC: (Ubuntu 11.2.0-19ubuntu1) 11.2.0" // 标识信息
        .section	.note.GNU-stack,"",@progbits  // 标志堆栈是否可执行
        .section	.note.gnu.property,"a"  // GNU属性
        .align 8                    // 对齐
        .long	1f - 0f              // 跳转偏移
        .long	4f - 1f              // 跳转偏移
        .long	5                     // 版本信息
0:                           // 标志 0
        .string	"GNU"                 // "GNU" 字符串
1:                           // 标志 1
        .align 8                      // 对齐
        .long	0xc0000002             // 属性值
        .long	3f - 2f                // 跳转偏移
2:                           // 标志 2
        .long	0x3                    // 属性值
3:                           // 标志 3
        .align 8                      // 对齐
4:                           // 标志 4

```

总结一下，当调用一个函数时，需要为该函数的局部变量、参数、返回地址等信息分配内存空间。这些信息存储在函数栈帧中，函数栈帧是在栈上动态分配的，用于函数调用和返回。

1. `pushq %rbp`：将当前函数的栈帧指针 `%rbp` 压入栈中，保存上一个函数的栈帧指针，以便后续恢复。
2. `movq %rsp, %rbp`：将当前栈指针 `%rsp` 的值存储到 `%rbp`，创建新的栈帧，将 `%rbp` 指向当前函数的栈帧。
3. `subq $16, %rsp`：分配 16 字节的栈空间，用于存储函数的局部变量。
4. 将函数的参数存储到栈帧中，例如 `movl $5, -12(%rbp)` 和 `movl $7, -8(%rbp)`。
5. `call add`：调用函数 `add`，将控制流跳转到 `add` 函数，同时将当前函数的返回地址存储在栈帧中。
6. `movl %eax, -4(%rbp)`：将 `add` 函数的返回值存储在栈帧中，以备后续使用。
7. `movl -4(%rbp), %eax`：将存储在栈帧中的返回值加载到 `%eax` 寄存器中。
8. `popq %rbp`：从栈中弹出之前保存的栈帧指针 `%rbp`，恢复到上一个函数的栈帧。
9. `ret`：从栈帧中加载返回地址，将控制流恢复到调用函数的位置。


![image.png](/static/img/56a328e0eb2756e1ed734a1f4b4181f1.image.webp)

一时间看不懂上面的？来对比一下，多写几个函数


![image.png](/static/img/97de442ab9846a5a829fc16920e47705.image.webp)
上面的`add`和`subl`就是加减指令，图中被框起来的就是寄存器取参数压栈，因为参数是局部变量。看好了，上面的返回值都被保存到了%eax这个寄存器。


![image.png](/static/img/bfa997acb11c98e318518e1478be54fc.image.webp)
在main这里,每次调用完一个函数就把%eax里的返回值存到变量里。对上了不是。基本符合上图。

汇编c语言

在Linux系统中，进程的标识符（PID）是用来唯一标识正在运行的进程的数字。在这些PID中，有一些特殊的PID值，分别是0、1和2。它们有特殊的含义，表示了系统中的一些重要进程。

1. **PID 0 - 调度进程（swapper）**：
   PID 0 是内核中的一个特殊进程，通常被称为“调度进程”或“swapper”。在早期的Unix系统中，调度进程用于在运行的进程之间切换，并将CPU时间片分配给不同的进程。在现代Linux系统中，PID 0不再表示一个实际运行的进程，而是用来标识系统初始化的内核线程。

2. **PID 1 - init进程**：
   PID 1 是系统中的第一个真实进程，通常是`init`进程。`init`进程是Linux系统中的第一个用户空间进程，它是所有其他进程的父进程，因此被称为“祖先进程”。`init`进程负责启动和管理系统的各种服务和进程。然而，在现代Linux发行版中，`init`进程通常由更先进的init系统（如SysV init、Upstart、systemd等）代替。

3. **PID 2 - kthreadd进程**：
   PID 2 是内核线程`kthreadd`的PID。`kthreadd`是Linux内核中的一个线程，负责创建和管理内核线程，这些线程用于执行不同的内核任务。`kthreadd`是内核的一部分，它帮助管理其他内核线程的创建和终止。



总结：
PID 0、1和2是Linux系统中的特殊PID，具有特殊的含义。PID 0是调度进程，用于系统初始化。PID 1是init进程或其等效的init系统，是用户空间的第一个进程，负责启动和管理其他进程。PID 2是kthreadd进程，负责管理内核线程。这些特殊PID在Linux系统的运行中发挥着重要的作用。



当涉及与进程相关的系统调用时，Linux提供了多种功能，以便管理、控制和与进程交互。以下是一些常见的与进程相关的系统调用列表：

1. **创建与执行进程**：
   - `fork()`: 创建一个新进程，称为子进程，它是调用进程的复制。
   - `execve()`: 在当前进程的上下文中执行一个新程序。

2. **进程等待和终止**：
   - `waitpid()`: 等待一个特定的子进程终止，并获取其退出状态。
   - `wait()`: 等待任何子进程终止，并获取其退出状态。
   - `exit()`: 终止当前进程，返回退出状态给父进程。

3. **进程间通信**：
   - `pipe()`: 创建一个管道，用于在父子进程或进程间进行双向通信。
   - `shmget()`, `shmat()`, `shmdt()`: 创建共享内存区域，允许进程在共享内存中交换数据。
   - `msgget()`, `msgsnd()`, `msgrcv()`, `msgctl()`: 创建消息队列，允许进程通过消息进行通信。
   - `semget()`, `semop()`, `semctl()`: 创建和操作信号量，用于进程间同步和互斥。

4. **进程状态查询和控制**：
   - `getpid()`: 获取当前进程的ID。
   - `getppid()`: 获取父进程的ID。
   - `getpgrp()`, `setpgid()`: 获取或设置进程组ID。
   - `nice()`: 调整进程的优先级。

5. **进程调度与优先级**：
   - `sched_yield()`: 放弃CPU，允许其他具有相同优先级的进程运行。
   - `nice()`: 调整进程的优先级。

6. **进程信号**：
   - `kill()`: 向指定进程发送信号。
   - `signal()`, `sigaction()`: 设置信号处理程序。

7. **进程时间和资源**：
   - `times()`: 获取进程和子进程的累计CPU时间。
   - `getrusage()`: 获取进程或子进程的资源使用情况。

这只是一部分与进程相关的系统调用列表，还有其他更多的系统调用可以用于进程管理和控制。每个系统调用都有其特定的用途和参数

> 
> (1)inin进程会调用prepare_namespace()函数去挂载根文件系统，根文件系统的存储位置由bootcmdline指定(例如：root=/dev/mmcblk0p2)；
> 
> (2)挂载上根文件系统后，去查找应用层的初始化函数，应用层的初始化函数也是通过bootcmdline指定(例如：init=/linuxrc)；
> 
> (3)init进程调用run_init_process()函数去执行应用层的初始化函数，然后init进程就从内核态转变成用户态；
> 
> (4)打开控制台"/dev/console"，此时得到文件描述符(因为是打开的第一个文件，文件描述符是0)，然后将文件描述符赋值两遍，得到文件描述符0、1、2，也就是标准输出、标准输入、标准出错。
> 
> (5)init进程构建了交互界面，启动了login进程、命令行进程、shell进程

-------------------------------------------------------------------------------
> 
> (1)init进程是通过kernel_thread()函数创建，刚开始是内核线程，当执行应用层的初始化函数后就变成用户态的线程，并且这个过程是不可逆的，
> init进程将一直是用户态线程；
> 
> (2)init进程是其他用户态线程的祖宗进程，其他用户态线程都是init进程直接\间接创建；
原文链接：https://blog.csdn.net/weixin_42031299/article/details/122444282



> 当系统中所有的进程起来后，0号进程也就蜕化为idle进程，当一个core上没有任务可运行时就会去运行idle进程。一旦运行idle进程则此core就可以进入低功耗模式了，在ARM上就是WFI。
> 
> 我们本节重点关注是0号进程是如何启动的。在linux内核中为0号进程专门定义了一个静态的task_struct的结构，称为init_task。

-------------------------------------------------------------------------------------------------------------------------------------------------------------

> linux启动的第一个进程是0号进程，是静态创建的
> 
> 在0号进程启动后会接连创建两个进程，分别是1号进程和2和进程。
> 
> 1号进程最终会去调用可init可执行文件，init进程最终会去创建所有的应用进程。
> 
> 2号进程会在内核中负责创建所有的内核线程
> 
> 所以说0号进程是1号和2号进程的父进程；1号进程是所有用户态进程的父进程；2号进程是所有内核线程的父进程。

原文链接：https://cloud.tencent.com/developer/article/1603977

0,1,2进程

今天执行`strace`的时候发现，不管哪个进程最后都会调用`exit_group`,就打算总结一下进程退出相关的系统调用。
，查阅资料后发现有以下。

![image.png](/static/img/402013280d37a8d687eb5968a11fb483.image.webp)
**1. `exit()`：**
- `exit()` 是标准 C 库中的函数，用于终止当前进程。
- 函数原型：`void exit(int status);`
- 调用 `exit()` 函数将终止当前进程，并将退出状态 `status` 返回给父进程。
- `exit()` 函数将执行一系列清理操作，包括关闭文件描述符、刷新缓冲区以及执行通过 `atexit()` 注册的终止处理程序。
- 可以使用 `EXIT_SUCCESS` 和 `EXIT_FAILURE` 宏来表示进程的成功或失败状态。



**2. `_exit()`：**
- `_exit()` 是一个系统调用，用于立即终止当前进程，不执行清理操作。
- 函数原型：`void _exit(int status);`
- 调用 `_exit()` 函数将立即终止当前进程，并将退出状态 `status` 返回给父进程。
- `_exit()` 不会执行清理操作，包括不会关闭文件描述符、不会刷新缓冲区，也不会执行终止处理程序。

**3. `atexit()`：**
- `atexit()` 函数用于注册在进程终止时自动执行的终止处理程序。
- 函数原型：`int atexit(void (*function)(void));`
- 通过调用 `atexit()` 函数并传递一个函数指针，可以注册一个终止处理程序。
- 注册的终止处理程序将在进程正常终止时被调用，执行一些清理操作。
- 可以多次调用 `atexit()` 来注册多个终止处理程序，它们将按照注册的相反顺序执行。

**4. `exit_group()`：**
   
- `exit_group()` 是 Linux 特定的系统调用，用于终止整个进程组中的所有进程，包括当前进程。
- 函数原型：`void exit_group(int status);`
- 调用 `exit_group()` 将立即终止当前进程组中的所有进程，包括当前进程。
- `exit_group()` 不执行清理操作，也不返回到调用进程，因为它会终止整个进程组。

这些 API 提供了不同的方式来控制进程的退出和清理操作。

接下来演示一下网上找到的的示例程序

1. 示例程序：使用 `exit()` 终止进程

```c
#include <stdio.h>
#include <stdlib.h>

int main() {
    printf("This is the main process.\n");
    
    // 调用 exit() 终止当前进程
    exit(EXIT_SUCCESS);
    
    // 下面的代码不会被执行
    printf("This line will not be printed.\n");
    
    return 0;
}
```

当程序执行到 `exit()` 时，当前进程将被终止。因此，`printf()` 函数后面的代码将不会被执行。

1. 示例程序：使用 `_exit()` 终止进程

```c
#include <stdio.h>
#include <unistd.h>

int main() {
    printf("This is the main process.\n");
    
    // 调用 _exit() 终止当前进程
    _exit(EXIT_SUCCESS);
    
    // 下面的代码不会被执行
    printf("This line will not be printed.\n");
    
    return 0;
}
```

当程序执行到 `_exit()` 时，当前进程将被立即终止。与 `exit()` 不同，`_exit()` 不执行清理操作，直接退出。

1. 示例程序：使用 `atexit()` 注册终止处理程序

```c
#include <stdio.h>
#include <stdlib.h>

void cleanup() {
    printf("Executing cleanup...\n");
    // 执行一些清理操作
}

int main() {
    printf("This is the main process.\n");
    
    // 注册终止处理程序
    atexit(cleanup);
    
    // 调用 exit() 终止当前进程
    exit(EXIT_SUCCESS);
    
    // 下面的代码不会被执行
    printf("This line will not be printed.\n");
    
    return 0;
}
```

`cleanup()` 函数作为终止处理程序被注册。当进程正常终止时，注册的终止处理程序将被调用，执行一些清理操作。

1. 示例程序：使用 `exit_group()` 终止进程组中的所有进程

```c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main() {
    printf("This is the main process. PID: %d\n", getpid());
    
    // 创建一个子进程
    pid_t child_pid = fork();

    if (child_pid == 0) {
        // 子进程
        printf("This is the child process. PID: %d\n", getpid());
        
        // 子进程调用 exit_group() 终止整个进程组
        exit_group(EXIT_SUCCESS);
    } else if (child_pid > 0) {
        // 父进程
        printf("This is the parent process. PID: %d\n", getpid());
        
        // 等待子进程终止
        int status;
        wait(&status);
        
        if (WIFEXITED(status)) {
            printf("Child process terminated with exit status: %d\n", WEXITSTATUS(status));
        }
    } else {
        // fork() 失败
        perror("fork");
        exit(EXIT_FAILURE);
    }
    
    // 下面的代码不会被执行
    printf("This line will not be printed.\n");
    
    return 0;
}
```

在这个示例中，主进程创建了一个子进程，并等待子进程终止。子进程调用了 `exit_group()` 终止整个进程组。当子进程终止后，父进程会检查子进程的退出状态并打印出来。

进程组是进程的集合，通常是由父进程创建，父进程创建子进程并将其加入到自己这个进程组，进程组的PGID就等于父进程自己的PID,子进程初始的PGID也等于父进程的PID,除非子进程创建会话成为另一个会话的领导者，子进程的PGID会变成自己的PID,还有通过`setpgid`手动加入到其他进程组。

所以，`exit_group`会杀死和这个程序有关的所有进程。s

进程退出相关system call

```go
go env -w GOPROXY=https://goproxy.io,direct

```