5. Linux服务器程序规范

1.进程 PID

进程的PID（Process ID）是操作系统中用于唯一标识一个进程的整数值。每个进程在创建时，操作系统都会分配一个唯一的PID，用来区分不同的进程。

PID的特点

1.唯一性：

在操作系统运行的某一时刻，每个进程的PID都是唯一的。不同进程不会共享同一个PID。即使一个进程终止后，该PID可以被回收并分配给新创建的进程，但在同一时刻不会有两个进程拥有相同的PID。

2.进程生命周期：

PID 的生命周期与进程的生命周期相对应。当一个进程被创建时，操作系统为它分配一个PID；当进程终止时，该PID被释放，并可能被分配给后续的新进程。

3.系统管理和调试：

PID 在进程管理和调试中起着重要作用。系统管理员和开发者可以通过PID来监视、控制和调试进程。例如，使用 ps 命令可以查看系统中所有进程的PID，以及它们的状态、资源使用等信息。使用 kill 命令可以通过PID来终止指定的进程。

PID的分配

PID 是由操作系统内核管理和分配的，通常是一个非负整数。PID 通常从一个最小值（通常是1）开始，逐渐递增。当系统运行的进程数达到最大PID值时，PID 会回绕到最小值并重新开始分配。

特殊的PID

  • PID 1：在大多数类UNIX操作系统中，PID 1 通常分配给初始化进程（init 或 systemd），这是系统启动时创建的第一个进程。init 是所有其他进程的祖先，它负责启动系统的其余部分，并在系统运行期间维持各种系统服务。
  • PID 0：PID 0 通常被保留给调度进程或空闲进程，这个进程在大多数情况下不会被普通用户或程序直接操作。

2.日志

Linux系统日志

Linux提供一个守护进程（后台进程）来处理系统日志：rsyslogd。rsyslogd 守护进程既能接收用户进程输出的日志，又能接收内核日志。

syslog 函数

应用程序使用syslog函数和守护进程rsyslog通信。第一个参数是用来设置优先级的

1
2
#include <syslog.h>
void syslog(int priority, const char* message, ...);

openlog用来改变syslog的默认输出方式，进一步结构化日志内容。

1
2
#include <syslog.h>
void openlog(const char* ident, int logopt, int facility);

setlogmask 用于设置日志掩码，使得日志级别大于日志掩码的信息被系统忽略。用于在程序发布之后将程序的调试信息关闭。

1
2
#include <syslog.h>
int setlogmask(int maskpri);

closelog函数用于关闭日志功能：

1
2
#include <syslog.h>
void closelog();

linux内核的环状缓存是什么

  1. 环状缓存（环形缓冲区）基本概念
    • 在 Linux 内核中，环状缓存（环形缓冲区，Ring Buffer）是一种用于数据存储和传输的数据结构。它的名字来源于其形状，数据存储在一个环形的空间中，就像一个首尾相接的环。想象一个圆形的轨道，数据在这个轨道上按顺序存放。
    • 它有一个固定的大小，由一个数组来实现。有两个指针，一个用于指示数据写入的位置（通常称为写指针），另一个用于指示数据读取的位置（通常称为读指针）。当数据写入环形缓冲区时，写指针会向前移动；当从缓冲区读取数据时，读指针会向前移动。
  2. 工作原理
    • 写入数据：当有新的数据要写入环形缓冲区时，首先检查缓冲区是否有足够的空间。如果有空间，就将数据写入写指针指向的位置，然后写指针向前移动（如果到达缓冲区的末尾，就会回到开头，因为是环形结构）。例如，假设环形缓冲区大小为 10 个单元，写指针当前位置为 3，当写入一个数据单元后，数据被放入第 3 个单元，写指针移动到 4。
    • 读取数据：当要从缓冲区读取数据时，检查是否有数据可读（即读指针和写指针的位置关系表明有数据存在）。如果有数据，就读取读指针指向的位置的数据，然后读指针向前移动。例如，读指针在位置 2，写指针在位置 5，那么就可以读取位置 2、3、4 的数据，读取完后读指针移动到 5。
  3. 在内核中的应用场景
    • 驱动程序中的数据传输：在设备驱动程序中，环形缓冲区常用于在设备和内核之间传输数据。例如，在一个网络设备驱动程序中，网卡接收的数据可以先放入环形缓冲区，然后内核再从缓冲区中读取这些数据进行处理。这样可以缓冲设备快速产生的数据，避免数据丢失，因为如果内核暂时无法处理新的数据，只要环形缓冲区还有空间，数据就可以继续存放。
    • 进程间通信（IPC）：环形缓冲区也可用于某些形式的进程间通信。例如，两个进程可以共享一个环形缓冲区，一个进程负责写入数据，另一个进程负责读取数据，实现简单高效的数据共享。这种方式比一些传统的 IPC 方法在某些场景下更高效，特别是对于连续的、大量的数据传输。
  4. 优势
    • 高效的数据处理：由于其环形结构，只要缓冲区没有被填满，就可以持续写入数据，不需要频繁地分配和释放内存。而且可以实现数据的连续处理，避免了像普通线性缓冲区那样，当缓冲区满了就需要等待数据被全部读取后才能继续写入的情况。
    • 数据的缓存和同步：环形缓冲区可以缓存一定量的数据，使得数据的生产者（如设备）和数据的消费者（如内核处理程序）能够在不同的速度下工作。生产者可以快速地将数据放入缓冲区，消费者可以按照自己的节奏从缓冲区中读取数据，起到了一定的数据同步作用。

3.用户信息

UID、EUID、GID、EGID

在操作系统中，尤其是类 UNIX 系统中，用户和组的标识符用于控制对系统资源的访问权限。以下是对 UID（User ID）、EUID（Effective User ID）、GID（Group ID）和 EGID（Effective Group ID）的解释：

1. UID（User ID）

UID 是用于唯一标识系统中每个用户的整数值。当用户在系统中创建时，系统会为该用户分配一个唯一的 UID。UID 用于控制用户对系统资源的访问权限。

  • UID 0：通常保留给 root 用户（超级用户），它拥有系统的所有权限，能够执行任何操作。
  • 普通用户的 UID：通常从 1000 或 500 开始（取决于操作系统的配置），用于普通用户。

2. EUID（Effective User ID）

EUID 是用于实际控制用户对文件和系统资源访问权限的用户标识符。使得运行程序的用户拥有该程序的有效用户权限。它可能与 UID 相同，但在某些情况下可以不同。例如，通过 setuid 程序，普通用户可以临时获得文件所有者的权限。EUID 通常用于判断用户是否有权执行某些操作。

  • 典型用法：当一个用户执行 setuid 程序时，该程序的 EUID 会被设置为程序文件的所有者的 UID，而不是当前用户的 UID，从而赋予执行该程序的用户临时的更高权限。

3. GID（Group ID）

GID 是用于标识系统中每个用户组的整数值。与 UID 类似，GID 用于控制用户组对系统资源的访问权限。每个用户在系统中都有一个与之关联的主组（primary group），该组由 GID 表示。

  • GID 0：通常属于 root 组，具有最高权限。
  • 普通用户的 GID：通常与其主组的 GID 相同。

4. EGID（Effective Group ID）

EGID 是用于实际控制用户对文件和系统资源访问权限的组标识符。类似于 EUID，EGID 可以通过 setgid 程序来修改，以便临时提升执行程序的用户的组权限。

  • 典型用法：如果一个文件设置了 setgid 位，那么当任何用户执行该文件时，该进程的 EGID 将被设置为文件所属组的 GID，从而赋予该用户临时的组权限。

总结

  • UID：标识用户身份，决定用户本身的所有权限。
  • EUID：用于实际判断用户的权限，可能与 UID 不同。
  • GID：标识用户所属的组，决定用户组的权限。
  • EGID：用于实际判断用户的组权限，可能与 GID 不同。

在权限管理中，UID 和 GID 决定了用户和组的基本身份和权限，而 EUID 和 EGID 决定了用户在特定情境下（如执行带有 setuid 或 setgid 标志的程序时）所拥有的实际权限。这些标识符是 UNIX 权限模型的重要组成部分，用于确保系统资源的安全访问和管理。

有效用户为 root 的进程称为特权进程（privileged processes）

下边一组函数可以获取和设置当前进程的UID、EUID、GID、EGID：

1
2
3
4
5
6
7
8
9
10
11
#include <sys/types.h>
#include <unistd.h>
uid_t getuid();		//获取真实用户ID
uid_t geteuid();	//获取有效用户ID
gid_t getgid();		//获取真实组ID
gid_t getegid();	//获取有效组ID
 
int setuid(uid_t uid);		//设置真实用户ID
int seteuid(uid_t uid);		//设置有效用户ID
int setgid(gid_t gid);		//设置真实组ID
int setegid(gid_t gid);		//设置有效组ID

4.测试 UID 和 EUID 的区别

新建一个 test_uid.cpp 文件，并写入下面的代码：

1
2
3
4
5
6
7
8
9
10
#include <unistd.h> // <unistd.h>（Unix Standard Definitions）头文件提供对POSIX操作系统API的访问，主要用于提供对POSIX操作系统API的函数原型、符号常量等。
#include <stdio.h>  // <stdio.h>（Standard Input Output Header）头文件提供了进行输入和输出操作的函数。
 
int main(){
    uid_t uid = getuid();
    uid_t euid = geteuid();
    
    printf("userid :%d , euid: %d \n", uid, euid);
    return 0;
}

编译该文件：

1
gcc test_uid.cpp -o test_uid

运行可执行文件：

1
./test_uid

img

修改目标文件的所有者为 root：

1
sudo chown root:root test_uid

设置目标文件的 set-user-id 标志：

1
sudo chmod +s test_uid

重新执行该文件（无需再次编译）：

img

修改后，进程的用户 ID 是启动程序的用户 ID：1000，而有效用户 ID 是文件所有者的 ID：0（这里为 root 账户）。

5.进程间关系

进程组

Linux下的每一个进程都隶属于一个进程组，因此他们除了 PID 信息外，还有进程组ID：PGID。

获取指定进程的 PGID：

1
2
#include <unistd.h>
pid_t getpgid(pid_t pid);

设置 PGID：

1
int setpgid(pid_t pid, pid_t pgid);

每个进程组都有一个首领进程，其 PGID 和 PID 相同。一个进程只能设置自己或其子进程的 PGID。

pid==pgid，那么该进程就被设置为进程组的首领

pid==0，设置当前进程的PGID为pgid

pgid==0，设置pid为目标PGID

1.子进程调用exec系列函数以后，父进程不可以设置子进程pgid

2.一旦子进程成为进程组首领，它就脱离了父进程的进程组。此后，子进程及其后续创建的子进程（如果有）将属于新的进程组，而父进程和其他未重新设置进程组的子进程仍然属于原来的父进程进程组。

会话

一些有关联的进程组将形成一个会话（session）。

创建一个会话：

1
2
#include <unistd.h>
pid_t setsid(void);

注意，该函数不能由进程组的首领进程调用，否则会出错。对于非组首领的进程来说，调用该函数会生成一个新的会话，并且：

  • 调用进程成为会话的首领，此时进程是新会话的唯一成员
  • 新建一个进程组，其 PGID 就是调用该函数的进程PID，调用进程成为首领
  • 调用进程甩开终端（若有）。

新的会话不会有控制终端（controlling terminal）。如果调用进程原本有控制终端，那么它会被与控制终端分离。

Linux并没有提供会话ID（SID）的概念，但 Linux 系统认为会话ID等同于会话首领所在进程组的 PGID，并提供如下函数来读取 SID：

1
2
#include <unistd.h>
pid_t getsid(pid_t pid);

使用 setsid() 创建一个新的会话和进程组：

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
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
 
int main() {
    pid_t pid;
 
    // 创建一个子进程
    pid = fork();
    printf("Child Process ID: %d\n", pid);
 
    if (pid < 0) {
        perror("fork failed");
        exit(EXIT_FAILURE);
    } else if (pid > 0) {
        // 父进程退出，使子进程成为孤儿进程
        exit(EXIT_SUCCESS);
    }
 
    // 子进程开始执行，创建新的会话
    pid_t sid = setsid();
    if (sid < 0) {
        perror("setsid failed");
        exit(EXIT_FAILURE);
    }
 
    // 此时，进程已经成为新的会话和进程组的首领
    printf("New session ID: %d\n", sid);
 
    // 继续执行其他代码...
 
    return 0;
}

编译运行：

1
2
gcc create_sid.cpp -o create_sid
./create_sid

img

fork() 是一个在 UNIX 和类 [UNIX 操作系统](https://so.csdn.net/so/search?q=UNIX 操作系统&spm=1001.2101.3001.7020)中用于创建新进程的系统调用。调用 fork() 后，操作系统会创建一个新的进程（称为子进程），这个子进程是调用进程（父进程）的副本，除了一些特定的区别外，子进程几乎完全继承了父进程的上下文。

create_sid.cpp 的执行逻辑：

  1. 在调用 fork() 之前，只有一个进程在运行，这个进程是你的程序的父进程。当 fork() 被调用时，操作系统会复制当前进程的全部内容，从而创建一个几乎完全相同的子进程。
  2. fork() 成功时，父进程会收到子进程的 PID，而子进程会收到 0。此时，printf("Child Process ID: %d\n", pid); 会在父进程和子进程中都执行，打印不同的 PID 值。
  3. 在代码中，父进程收到这个返回值后，执行 exit(EXIT_SUCCESS);，表示父进程正常退出。
  4. 父进程退出后，子进程就成为了一个孤儿进程（因为它的父进程不再存在），但操作系统会将孤儿进程重新分配给 init 或 systemd 进程来管理。
  5. 子进程在父进程退出后继续运行，并调用 setsid() 来创建一个新的会话。
  6. 调用 setsid() 后，子进程将成为新会话的会话首领（session leader），并创建一个新的进程组，其中该子进程是进程组的组首领（group leader）。

用ps命令查看进程关系

用 ps 命令可以查看进程、进程组和会话之间的关系：

1
ps -o pid,ppid,pgid,sid,comm | less

img

我们在 bash 下执行 ps 和 less 命令，所以 ps 和 less 的父进程是 bash：bash 的 PID 为 264971，而 ps 和 less 的 PPID 也为 264971。

这三条命令创建了一个会话：SID = 264971，两个进程组：PGID = 264971, 266761。

bash 既是会话首领，也是进程组 264971 的首领。

进程组 266761 的首领是 ps。

| less: 这是一个分页工具，允许你逐页查看命令输出的内容。使用 less 可以方便地查看长输出内容而不会直接在终端上滚动过去。

image-20241212112243402

6.系统资源限制

Linux上运行的程序会受到资源限制的影响。如物理设备限制：CPU数量，内存数量；系统策略限制：CPU时间；具体实现限制：文件名的最大长度等。

Linux 系统资源限制可以通过如下一对函数读取和设置：

resource：指定资源限制类型

1
2
3
4
#include <sys/resource.h>
//成功返回0，失败返回-1并设置errno
int getrlimit(int resurce, struct rlimit *rlim);
int setrlimit(int resurce, const struct rlimit *rlim);

rlimit 结构体：

1
2
3
4
5
struct rlimit {
	//rlim_t 描述资源级别
	rlim_t rlim_ur;		//软限制
	rlim_t rlim_max;	//硬限制
}

一般用户只能减少硬限制，root用户可以增加

软：最好不要超过的限制

硬：软的上限

7.改变工作目录和根目录

工作目录和根目录概念

在操作系统中，尤其是 UNIX 和类 UNIX 系统中，工作目录和根目录是两个非常重要的概念，它们与文件系统的组织和进程的操作密切相关。

工作目录（Working Directory）

工作目录，有时也称为当前目录，是指一个进程当前所在的目录。所有相对路径的文件操作（如打开文件、读取文件等）都是相对于工作目录进行的。

  • 特性:

    • 每个进程都有一个工作目录。进程可以通过系统调用 chdir() 或命令 cd 来改变其工作目录。
    • 当你在终端中打开一个 shell 时，通常 shell 的工作目录最初是用户的主目录（如 /home/username）。
    • 在编写程序时，如果使用相对路径（如 ./file.txt），系统会从当前工作目录开始查找文件。

  • 查看和更改:

    • 使用 pwd 命令可以查看当前工作目录。
    • 使用 cd 命令可以更改当前工作目录。例如，cd /var/log 会将工作目录更改为 /var/log。

示例:

img

根目录（Root Directory）

根目录是文件系统的最顶层目录，用 / 表示。在 UNIX 和类 UNIX 系统中，根目录是文件系统的起点，所有文件和目录都位于根目录之下。

  • 特性:

    • 根目录是文件系统层级结构的起点，没有父目录。
    • 所有其他目录（如 /home、/etc、/usr）都是从根目录派生出来的。
    • 在系统启动时，操作系统会挂载根文件系统，根目录是整个文件系统的基础。

  • 根目录与工作目录的区别:

    • 根目录是文件系统的最顶层，是绝对路径的起点。
    • 工作目录是进程当前正在操作的目录，可以在文件系统的任何位置。

示例:

1
2
cd /
ls

在这个示例中，使用 cd / 切换到根目录，并使用 ls 列出了根目录下的文件和子目录。

img

总结

  • 工作目录是当前进程正在操作的目录，所有相对路径的操作都是基于工作目录。
  • 根目录是文件系统的最顶层目录，用 / 表示，是绝对路径的起点。

有些服务器程序还需要改变工作目录和根目录，比如web服务器的逻辑根目录不是文件系统的根目录/，而是站点的根目录，对于 Linux 上的 Web 服务来说，该目录一般是/var/www/。

获取进程当前工作目录，改变进程工作目录的函数分别是：

1
2
3
#include <unistd.h>
char* getcwd(char* buf, size_t size);//超过大小返回null
int chdir(const char* path);//成功0 失败 -1

buf存储当前工作目录的绝对路径名，大小由size指定

path指定要更换到的目录

改变进程根目录的函数：

1
2
3
4
#include <unistd.h>
 
//成功返回0，失败返回-1并设置errno
int chroot(const char* path);

只有特权进程才能改变根目录。

8.服务器程序后台化

1.守护进程代码

下面代码实现了如何让一个进程以守护进程的方式运行：

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
bool daemonize() {
    // 创建子进程，关闭父进程，这样子进程就不是进程组首进程，就可以调用setsid了
    pid_t pid = fork();
    if (pid < 0) {
        return false;
    } else if (pid > 0) {
        exit(0);
    }
 
    /* 设置文件权限掩码。当进程创建新文件（使用open()系统调用），文件的权限将是mode & 0777 */
    umask(0);
 
    // 创建新会话，本进程将成为进程组的首领
    pid_t sid = setsid();
    if (sid < 0) {
        return false;
    }
 
    // 切换工作目录，防止当前工作目录所在文件系统不能卸载
    if ((chdir("/")) < 0) {
        return false;
    }
 
    // 关闭所有文件描述符
    close(STDIN_FILENO);
    close(STDOUT_FILENO);
    close(STDERR_FILENO);
    
    // 此处省略了关闭其他已打开的文件描述符的代码
 
    // 将标准输入、标准输出、标准错误重定向到/dev/null文件
    open("/dev/null", O_RDONLY);
    open("/dev/null", O_RDWR);
    open("/dev/null", O_RDWR);
    
    return true;
}

Linux 提供了完成同样功能的库函数：

1
2
#include <unistd.h>
int daemon(int nochdir, int noclose);

这个 daemonize() 函数执行了创建守护进程的标准步骤：

  1. 通过 fork() 创建一个子进程，并让父进程退出。
  2. 通过 setsid() 创建一个新的会话，脱离控制终端，并成为会话首领。
  3. 设置文件权限掩码和切换工作目录。
  4. 关闭标准文件描述符并将它们重定向到 /dev/null。

如果所有步骤成功，则返回 true 表示守护进程创建成功。否则返回 false。这段代码展示了将一个普通进程转化为守护进程的标准方法，是在后台运行长时间任务的基础方法之一。

接下来对上面代码进行解释：

2.代码解释

创建子进程并关闭父进程

1
2
3
4
5
6
pid_t pid = fork();
if (pid < 0) {
    return false;
} else if (pid > 0) {
    exit(0);
}

fork() 创建一个子进程。如果 fork() 失败（返回值为负），则返回 false 表示守护进程创建失败。

如果 fork() 成功，父进程收到子进程的 PID 并退出 (exit(0))，子进程继续执行。

这样做的目的是让子进程成为孤儿进程，由 init 或 systemd 进程接管，从而保证守护进程在父进程结束后仍然继续运行。

设置文件权限掩码

umask(0) 清除文件模式创建掩码，确保进程创建的文件权限不受父进程的文件权限掩码影响。这样，进程创建的文件将具有最大的权限（取决于创建文件时指定的权限）。

创建新会话

1
2
3
4
pid_t sid = setsid();
if (sid < 0) {
    return false;
}

setsid() 创建一个新的会话，使当前进程成为会话的首领，并与原来的控制终端分离。该进程成为新会话的会话首领和进程组的首领，并且没有控制终端。

切换工作目录

1
2
3
if ((chdir("/")) < 0) {
    return false;
}

chdir("/") 将工作目录切换到根目录 /。这样做的目的是避免当前工作目录所在的文件系统不能卸载。

关闭所有文件描述符

1
2
3
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);

关闭标准输入（STDIN_FILENO）、标准输出（STDOUT_FILENO）和标准错误（STDERR_FILENO）的文件描述符，以避免守护进程不小心使用这些文件描述符。

重定向标准输入、输出和错误

1
2
3
open("/dev/null", O_RDONLY);
open("/dev/null", O_RDWR);
open("/dev/null", O_RDWR);

将标准输入重定向到 /dev/null，并将标准输出和标准错误也重定向到 /dev/null。/dev/null 是一个特殊的文件，读取它会返回 EOF，写入它的数据将被丢弃。这样可以确保守护进程不向任何终端输出信息，也不会从任何终端读取输入。

3.重点：更好理解的守护进程版本

守护进程创建步骤：

  1. fork子进程，让父进程终止。
  2. 子进程调用 setsid() 创建新会话
  3. 改变工作目录位置 chdir()， 防止目录被卸载。
  4. 通常根据需要，重设umask文件权限掩码，影响新文件的创建权限。
  5. 关闭/重定向 文件描述符
  6. 守护进程 业务逻辑。while（）
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
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <pthread.h>
#include <sys/stat.h>


int main(void)
{
        pid_t pid;
        int fd;

        pid = fork();
        if(pid>0)
                exit(0);         //1. 退出父线程

        pid = setsid();  //2. 子进程创建会话
        if(pid==-1)
        {
                perror("setsid error");
                exit(1);
        }

        //3. 改变文件目录
        chdir("/home/hui/test");

        //4. 设置权限掩码
        umask(0022);

        //5. 关闭/重定向 文件描述符

        close(STDIN_FILENO); //关闭文件描述符 0;
        fd = open("/dev/null",O_RDWR); //此时fd=0(open使用可用的最小的，因为0刚>刚关闭了)
        dup2(fd,STDOUT_FILENO);
        dup2(fd,STDERR_FILENO);

        //6. 守护进程逻辑
        while(1)
        {
                printf("哈哈哈 我是被守护的进程\n");
                sleep(5);
        }

        return 0;
}