[Linux] Linux 系统编程之文件系统与进程管理（示例代码）

Linux 系统编程之文件系统与进程管理

一、Linux的文件系统与进程管理

1.1. Linux 文件系统的基本结构

Linux 文件系统采用树形结构，根目录为 /，所有文件和目录都从根目录开始展开。主要目录及其功能如下：

• /bin：存放系统启动和运行所需的基本命令，如 ls, cp, mv 等。
• /etc：存放系统配置文件，如网络配置、用户账户信息等。
• /home：普通用户的主目录，每个用户在此目录下有一个以用户名命名的子目录。
• /var：存放经常变化的文件，如日志文件 (/var/log)、邮件队列等。
• /tmp：临时文件目录，所有用户均可在此创建临时文件。
• /dev：设备文件目录，系统通过此目录访问硬件设备。
• /proc：虚拟文件系统，提供系统内核和进程的实时信息。

文件系统还支持多种文件类型，包括普通文件、目录、符号链接、设备文件等。文件权限管理通过 chmod、chown 等命令实现，确保系统安全。

1.2. 进程的基本概念与生命周期

进程是操作系统进行资源分配和调度的基本单位。每个进程都有一个唯一的进程 ID (PID)，并包含以下主要状态：

1. 创建 (Created)：进程通过 fork() 系统调用创建，新进程复制父进程的地址空间。
2. 就绪 (Ready)：进程等待 CPU 调度执行。
3. 运行 (Running)：进程正在 CPU 上执行。
4. 阻塞 (Blocked)：进程等待某些事件（如 I/O 操作）完成。
5. 终止 (Terminated)：进程执行完毕或被强制终止。

进程的生命周期可以通过 ps, top, htop 等命令监控。进程间通信 (IPC) 机制包括管道、消息队列、共享内存等，用于协调多个进程的工作。

1.3. 文件与进程的关系

文件与进程在 Linux 系统中密切相关，主要体现在以下几个方面：

1. 文件描述符：每个进程打开文件时，系统会分配一个文件描述符 (File Descriptor)，用于标识该文件。标准输入、输出和错误分别对应文件描述符 0、1 和 2。
2. 文件操作：进程通过系统调用（如 open, read, write, close）访问文件。例如，一个文本编辑器进程会打开文件进行读写操作。
3. 进程间共享文件：多个进程可以同时打开同一个文件，通过文件锁机制（如 flock）避免冲突。
4. 文件系统与进程管理：文件系统为进程提供存储空间，而进程通过文件系统访问数据。例如，一个 Web 服务器进程会读取配置文件 (/etc/httpd/conf/httpd.conf) 并根据配置提供服务。

理解文件系统与进程管理的关系，有助于更好地进行系统优化和故障排查。例如，通过 lsof 命令可以查看哪些进程打开了特定文件，帮助定位资源占用问题。

二、文件操作技术

2.1.文件描述符与文件指针

• 文件描述符：在Unix/Linux系统中，每个打开的文件都会被分配一个非负整数作为唯一标识，称为文件描述符（File Descriptor）。标准输入、输出和错误分别对应文件描述符0、1和2。
• 文件指针：在C语言等高级编程语言中，通常使用FILE结构体指针（如FILE*）来操作文件。文件指针内部会关联到一个文件描述符，但提供了更高级的缓冲和格式化I/O功能。

2.2.文件读写操作

• 顺序读写：

  • 通过fread/fwrite（C语言标准库函数）按顺序读取或写入文件内容
    • fread从文件流中读取数据到缓冲区
    • fwrite将缓冲区数据写入文件流
    • 适用于连续存取数据的场景，如批量处理配置文件
  • 通过read/write（系统调用）进行底层文件操作
    • 直接调用操作系统提供的文件读写接口
    • 效率较高但需要自行处理缓冲等细节

• 随机访问：

  • 使用fseek（C语言）或lseek（系统调用）移动文件指针
    • 可以精确跳转到文件的任意字节位置
    • 支持从文件开头（SEEK_SET）、当前位置（SEEK_CUR）或末尾（SEEK_END）开始定位
  • 典型应用场景：
    • 数据库索引查询
    • 多媒体文件的部分读取
    • 大型文件的快速定位修改

• 示例：

  • 日志文件追加操作的标准流程：
    1. 使用fopen以追加模式(“a”)打开文件
    2. 自动定位到文件末尾
    3. 调用fwrite写入新日志条目
    4. 完成后fclose关闭文件
  • 代码示例（C语言）：

    FILE *log = fopen("app.log", "a");
    if(log) {
        fwrite(log_entry, sizeof(char), strlen(log_entry), log);
        fclose(log);
    }
    

2.3.文件权限与属性管理

2.3.1.权限设置

在Linux系统中，文件权限是保护文件安全的重要机制。每个文件都有三组权限：所有者（Owner）、所属组（Group）和其他用户（Others）。每组权限包含读（r）、写（w）和执行（x）三种操作。通过chmod命令可以修改文件的权限，具体方式包括：

1. 符号模式：使用u（所有者）、g（所属组）、o（其他用户）和a（所有用户）结合+、-、=来设置权限。例如：

   chmod u+rwx,g+rx,o+r file.txt
   

   表示给所有者添加读、写、执行权限，给所属组添加读、执行权限，给其他用户添加读权限。

2. 数字模式：使用三位八进制数表示权限，每位分别对应所有者、所属组和其他用户。例如：

   chmod 754 file.txt
   

   表示所有者拥有rwx权限（7），所属组拥有r-x权限（5），其他用户拥有r--权限（4）。

此外，还可以通过系统调用（如fchmod）在程序中动态修改文件权限。

2.3.2.属性查看

文件的元数据包括文件大小、创建时间、修改时间、访问时间、inode号等信息。通过stat命令可以查看这些信息，例如：

stat file.txt

输出示例：

  File: file.txt
  Size: 1024       Blocks: 8          IO Block: 4096   regular file
Device: 803h/2051d Inode: 123456      Links: 1
Access: (0754/-rwxr-xr--)  Uid: ( 1000/  user)   Gid: ( 1000/  group)
Access: 2023-10-01 12:34:56.000000000 +0800
Modify: 2023-10-01 12:34:56.000000000 +0800
Change: 2023-10-01 12:34:56.000000000 +0800

fstat是stat的系统调用版本，适用于在程序中获取文件元数据。

2.3.3.所有权

文件的所有权包括所有者和所属组。通过chown命令可以修改文件的所有者和所属组，例如：

chown user:group file.txt

表示将file.txt的所有者改为user，所属组改为group。如果只想修改所有者或所属组，可以单独指定：

chown user file.txt  # 仅修改所有者
chown :group file.txt  # 仅修改所属组

在系统管理中，chown常用于将文件权限转移给特定用户或组，以确保文件访问的安全性。

2.4.文件系统调用

文件系统调用是操作系统为用户程序提供的与文件系统交互的接口，允许程序对文件进行创建、读取、写入、删除等操作。以下是常见的文件系统调用及其详细说明：

2.4.1. open

• 功能：打开或创建文件。
• 参数：
  • 路径：指定文件的路径，可以是绝对路径或相对路径。
  • 打开模式：指定文件的打开方式，常见的模式包括：
    • O_RDONLY：只读模式。
    • O_WRONLY：只写模式。
    • O_RDWR：读写模式。
    • O_CREAT：如果文件不存在则创建文件。
    • O_TRUNC：如果文件存在且为写模式，则清空文件内容。
    • O_APPEND：在文件末尾追加数据。
  • 权限：当使用O_CREAT模式时，需指定文件的权限，通常以八进制表示，如0644表示文件所有者可读写，其他用户只读。
• 返回值：成功时返回文件描述符（一个非负整数），失败时返回-1。
• 示例：

  int fd = open("/path/to/file", O_RDWR | O_CREAT, 0644);
  if (fd == -1) {
      perror("open");
  }
  

2.4.2. read

• 功能：从文件中读取数据。
• 参数：
  • 文件描述符：由open调用返回的文件描述符。
  • 缓冲区：用于存储读取数据的缓冲区。
  • 字节数：指定要读取的字节数。
• 返回值：成功时返回实际读取的字节数，失败时返回-1。如果到达文件末尾，返回0。
• 示例：

  char buffer[1024];
  ssize_t bytes_read = read(fd, buffer, sizeof(buffer));
  if (bytes_read == -1) {
      perror("read");
  }
  

2.4.3. write

• 功能：向文件中写入数据。
• 参数：
  • 文件描述符：由open调用返回的文件描述符。
  • 缓冲区：包含要写入数据的缓冲区。
  • 字节数：指定要写入的字节数。
• 返回值：成功时返回实际写入的字节数，失败时返回-1。
• 示例：

  const char *data = "Hello, World!";
  ssize_t bytes_written = write(fd, data, strlen(data));
  if (bytes_written == -1) {
      perror("write");
  }
  

2.4.4. close

• 功能：关闭文件描述符，释放系统资源。
• 参数：
  • 文件描述符：由open调用返回的文件描述符。
• 返回值：成功时返回0，失败时返回-1。
• 示例：

  if (close(fd) == -1) {
      perror("close");
  }
  

2.4.5.其他调用

• creat：

  • 功能：创建文件，相当于open调用中指定O_CREAT | O_WRONLY | O_TRUNC模式。
  • 参数：文件路径和权限。
  • 示例：

    int fd = creat("/path/to/newfile", 0644);
    if (fd == -1) {
        perror("creat");
    }
    

• unlink：

  • 功能：删除文件。
  • 参数：文件路径。
  • 示例：

    if (unlink("/path/to/file") == -1) {
        perror("unlink");
    }
    

• fcntl：

  • 功能：控制文件属性，如设置文件描述符的标志、获取文件状态等。
  • 参数：文件描述符、命令和可选参数。
  • 示例：

    int flags = fcntl(fd, F_GETFL);
    if (flags == -1) {
        perror("fcntl");
    }
    

2.4.6 文件锁

文件锁：使用fcntl调用实现文件锁，防止多个进程同时修改同一文件。

• 实现方式：通过fcntl系统调用设置F_SETLK或F_SETLKW命令，配合struct flock结构体指定锁类型（读锁F_RDLCK/写锁F_WRLCK）和锁定范围（文件起始偏移l_start、锁定长度l_len）。
• 典型场景：
  • 日志文件追加：多个进程通过写锁（F_WRLCK）互斥写入
  • 配置文件读取：多个进程通过读锁（F_RDLCK）共享读取，阻止写入进程
• 注意事项：
  1. 锁是进程级别的，线程间不独立生效
  2. 锁不会自动继承，子进程需重新获取
  3. 建议使用F_SETLKW（阻塞等待）而非F_SETLK（立即返回）避免轮询
• 示例代码片段：

  struct flock fl = {
      .l_type = F_WRLCK,
      .l_whence = SEEK_SET,
      .l_start = 0,
      .l_len = 0  // 锁整个文件
  };
  fcntl(fd, F_SETLKW, &fl);  // 阻塞式获取锁
  

• 替代方案：对于多线程应用，可考虑pthread_mutex；对于分布式系统，需使用分布式锁如Redis/ZooKeeper实现。

三、进程管理技术

3.1.进程创建与终止（fork, exec, wait）

进程创建是操作系统中最基础的功能之一。在Unix/Linux系统中，主要通过以下系统调用来实现：

1. fork()：创建一个与父进程几乎完全相同的子进程，包括代码段、数据段和堆栈段等。子进程获得父进程内存空间的副本，二者在fork()返回处开始执行。fork()的特殊之处在于它"一次调用，两次返回"：父进程中返回子进程PID，子进程中返回0。

2. exec系列函数：包括execl(), execv(), execle()等，用于将当前进程映像替换为一个新的程序。例如：

   execl("/bin/ls", "ls", "-l", NULL);
   

3. wait()/waitpid()：允许父进程等待子进程终止并获取其退出状态。典型使用场景：

   pid_t pid = fork();
   if (pid == 0) {
       // 子进程代码
       exit(0);
   } else {
       wait(NULL); // 父进程等待
   }
   

3.2.进程间通信（IPC）机制

进程间通信是多个进程协作的关键技术，主要方式包括：

1. 管道(Pipe)：半双工通信方式，常用于父子进程间通信。创建示例：

   int fd[2];
   pipe(fd); // fd[0]读端，fd[1]写端
   

2. 命名管道(FIFO)：通过文件系统中的特殊文件实现，不相关进程也可通信。

3. 消息队列：内核维护的消息链表，允许进程以消息形式交换数据。

4. 共享内存：最高效的IPC方式，多个进程映射同一物理内存区域。使用步骤：

   • shmget()创建共享内存段
   • shmat()附加到进程地址空间
   • 读写操作
   • shmdt()分离

5. 信号量：用于进程间同步，防止资源竞争。

6. 套接字(Socket)：支持不同主机上的进程通信。

3.3.信号处理与进程控制

信号是进程间异步通信机制，常见信号及其处理：

1. 信号类型：

   • SIGINT(2)：终端中断(Ctrl+C)
   • SIGKILL(9)：强制终止
   • SIGTERM(15)：请求终止
   • SIGSEGV(11)：段错误

2. 信号处理：

   • signal()：设置信号处理函数

   void handler(int sig) { /*...*/ }
   signal(SIGINT, handler);
   

   • sigaction()：更强大的信号处理接口

3. 进程控制：

   • kill()：向指定进程发送信号
   • raise()：向自身发送信号
   • alarm()：设置定时器信号

3.4.进程调度与优先级管理

操作系统通过调度算法决定CPU使用权的分配：

1. 调度策略：

   • 先来先服务(FCFS)
   • 短作业优先(SJF)
   • 时间片轮转(Round Robin)
   • 多级反馈队列

2. Linux优先级：

   • 静态优先级(100-139，值越小优先级越高)
   • 动态优先级调整
   • 使用nice值改变优先级(-20到19)

3. 相关系统调用：

   • nice()：调整进程优先级
   • getpriority()/setpriority()：获取/设置优先级
   • sched_setscheduler()：设置调度策略

4. 实时进程调度：

   • SCHED_FIFO：先进先出
   • SCHED_RR：轮转调度
   • 优先级高于普通进程

四、文件与进程的交互

4.1.文件锁机制

文件锁（File Locking）是操作系统提供的一种同步机制，用于协调多个进程对同一文件的并发访问，避免数据竞争和损坏。常见的文件锁类型包括：

1. 劝告锁（Advisory Lock）：需要进程主动检查并遵守锁约定，如flock()和fcntl()实现的锁
2. 强制锁（Mandatory Lock）：由内核强制执行的锁，违规访问会被直接阻止
3. 共享锁（Read Lock）：允许多个进程同时读取文件
4. 排他锁（Write Lock）：只允许单个进程写入文件

典型应用场景：数据库系统通过文件锁保证事务隔离性，如MySQL的MyISAM存储引擎使用表级文件锁。

4.2.进程间共享文件

进程可通过以下方式共享文件资源：

1. 文件描述符传递：通过UNIX域套接字发送文件描述符（sendmsg/recvmsg系统调用）
2. 内存映射文件：mmap()将文件映射到多个进程的地址空间，如Oracle数据库使用共享内存文件
3. 硬链接共享：多个进程通过不同路径访问同一inode
4. 继承打开文件：子进程通过fork()继承父进程已打开的文件描述符

特别注意：NFS等网络文件系统需要特殊处理共享锁和缓存一致性。

4.3.文件描述符的继承与复制

文件描述符管理机制：

1. 继承机制：fork()创建子进程时，子进程获得父进程所有打开文件描述符的副本
   • 示例：Apache通过fork创建worker进程继承监听套接字
2. 复制方法：
   • dup()/dup2()：创建新的描述符指向同一文件表项
   • open()同一文件：新建独立文件表项但指向相同inode
3. close-on-exec标志：通过fcntl设置FD_CLOEXEC，避免exec时泄露描述符

4.4.文件与进程的资源管理

操作系统通过以下机制管理文件资源：

1. 描述符表限额：ulimit -n控制进程最大打开文件数（默认通常1024）
2. 系统级限制：/proc/sys/fs/file-max定义系统总文件句柄数
3. 泄漏检测工具：
   • lsof查看进程打开文件
   • /proc//fd目录查看具体描述符
4. 自动清理机制：
   • 进程退出时内核自动关闭所有文件描述符
   • 孤儿进程持有的文件仍会计入系统资源

典型问题：文件描述符泄漏会导致"Too many open files"错误，常见于长期运行的服务器程序。

五、高级主题

5.1. 内存映射文件（mmap）

内存映射文件是一种将文件直接映射到进程地址空间的技术，允许程序像访问内存一样访问文件内容。相比传统的读写操作，mmap具有以下优势：

• 避免了数据在用户空间和内核空间的多次拷贝
• 可以随机访问大文件而不需要全部加载到内存
• 多个进程可以共享同一个映射，实现进程间通信

典型应用场景：

• 大型数据库系统
• 高性能日志处理
• 图像/视频处理

示例代码（Linux）：

int fd = open("large_file.dat", O_RDONLY);
void* addr = mmap(NULL, file_size, PROT_READ, MAP_PRIVATE, fd, 0);
// 现在可以直接通过addr指针访问文件内容

5.2. 异步 I/O 操作

异步I/O是一种高效的I/O处理方式，它允许程序在发起I/O操作后立即继续执行其他任务，而不需要阻塞等待I/O操作完成。这种非阻塞的特性使得程序可以充分利用CPU资源，在处理I/O密集型任务时表现出色。

具体工作流程如下：

1. 应用程序调用异步I/O接口发起请求
2. 操作系统接管I/O操作
3. 程序立即获得控制权继续执行其他代码
4. 当I/O操作完成时，系统通过回调函数或轮询机制通知程序

常见的实现方式包括：

1. POSIX AIO（Linux标准异步I/O接口）

   • 提供aio_read/aio_write等系统调用
   • 通过信号或回调通知完成
   • 典型应用场景：数据库系统、文件服务器

2. IOCP（Windows的I/O完成端口）

   • 基于事件驱动的完成通知机制
   • 提供高效的多线程I/O处理能力
   • 常用于高性能服务器开发

3. 现代高性能方案

   • libuv：跨平台异步I/O库，Node.js的基础
   • io_uring：Linux 5.1引入的高性能接口
     • 支持真正的异步文件I/O
     • 减少了系统调用次数
     • 典型应用：NGINX、Redis等高性能服务

这些技术在现代软件开发中广泛应用，特别是在需要处理大量并发连接的服务器程序、数据库系统和网络应用中。通过合理使用异步I/O，开发者可以构建出响应迅速、吞吐量高的应用程序。

5.3. 文件系统监控（inotify）

inotify是Linux内核提供的高效文件系统事件监控机制，它通过内核空间的事件队列实现实时监控，避免了传统轮询方式带来的性能开销。该机制可以精确监测以下事件类型：

1. 文件操作事件：

   • 文件创建(IN_CREATE)
   • 文件删除(IN_DELETE)
   • 文件打开(IN_OPEN)
   • 文件关闭(IN_CLOSE_WRITE/IN_CLOSE_NOWRITE)

2. 文件修改事件：

   • 内容修改(IN_MODIFY)
   • 截断操作(IN_TRUNCATE)

3. 属性变更事件：

   • 元数据修改(IN_ATTRIB)
   • 权限变更(IN_ACCESS)
   • 所有者变更(IN_OWNER)

4. 移动操作事件：

   • 文件移入监控目录(IN_MOVED_TO)
   • 文件移出监控目录(IN_MOVED_FROM)
   • 重命名(IN_MOVE_SELF)

典型应用场景包括：

• 文件同步工具(如rsync)
• 开发环境的热重载
• 日志文件实时监控
• 自动化构建系统

完整实现步骤详解：

1. 初始化inotify实例：

int fd = inotify_init();
if (fd < 0) {
    perror("inotify_init failed");
    exit(EXIT_FAILURE);
}

2. 添加监控项(watch)：

int wd = inotify_add_watch(fd, "/path/to/directory",
    IN_CREATE | IN_DELETE | IN_MODIFY | IN_MOVED_FROM | IN_MOVED_TO);
if (wd < 0) {
    perror("inotify_add_watch failed");
    close(fd);
    exit(EXIT_FAILURE);
}

3. 通过事件队列读取变更：

char buffer[1024] __attribute__ ((aligned(4)));
ssize_t length = read(fd, buffer, sizeof(buffer));
if (length < 0) {
    perror("read error");
    close(fd);
    exit(EXIT_FAILURE);
}

4. 处理相应事件：

struct inotify_event *event;
for (char *ptr = buffer; ptr < buffer + length; 
     ptr += sizeof(struct inotify_event) + event->len) {
    event = (struct inotify_event *)ptr;
    
    if (event->mask & IN_CREATE) {
        printf("File %s created\n", event->name);
    }
    if (event->mask & IN_DELETE) {
        printf("File %s deleted\n", event->name);
    }
    // 处理其他事件类型...
}

注意事项：

• 监控目录需要具有读权限
• 大量监控项可能导致内核队列溢出
• 符号链接不会被自动跟踪
• 对于递归监控需要自行实现目录遍历

5.4. 多线程与文件操作

在多线程环境下操作文件需要特别注意以下几个关键问题，这些问题的处理不当可能导致数据损坏或程序异常：

1. 文件描述符共享问题：

   • 当多个线程共享同一个文件描述符时，一个线程的文件操作（如seek）会影响其他线程
   • 示例：线程A调用了lseek(fd, 100, SEEK_SET)后，线程B的读写操作将从新位置开始
   • 在Linux系统中，文件描述符在内核层是共享的，所有操作共享同一个文件偏移量

2. 读写竞争条件：

   • 多个线程同时写入文件可能导致数据交错
   • 读线程可能读取到不完整的数据
   • 典型案例：日志系统中多个线程同时写入日志文件

3. 原子性保证：

   • 需要确保文件操作的原子性，特别是在追加写入等场景
   • 单个write操作通常是原子的，但多个操作组合需要额外保护

解决方案的详细实现：

1. 使用文件锁机制：

   • fcntl锁（建议锁）：

     struct flock fl;
     fl.l_type = F_WRLCK;  // 写锁
     fl.l_whence = SEEK_SET;
     fl.l_start = 0;
     fl.l_len = 0;  // 锁定整个文件
     fcntl(fd, F_SETLKW, &fl);  // 阻塞获取锁
     

   • flock锁（BSD风格）：

     flock(fd, LOCK_EX);  // 互斥锁
     

   • 注意点：锁的范围可以是整个文件或文件区域，锁类型分共享锁和互斥锁

2. 线程局部存储(TLS)方案：

   • 每个线程维护自己的文件描述符
   • POSIX线程实现示例：

     __thread int tls_fd;  // GCC线程局部变量
     void thread_func() {
         tls_fd = open("file", O_RDWR);
         // 使用tls_fd进行操作
     }
     

   • 优势：完全避免锁竞争
   • 限制：可能增加系统资源占用

3. 无锁设计方案：

   • 每个线程使用独立文件（如按线程ID命名）

     char filename[256];
     snprintf(filename, sizeof(filename), "file_%lu", pthread_self());
     int fd = open(filename, O_CREAT|O_RDWR, 0644);
     

   • 适用于日志收集等场景
   • 后续需要合并处理多个文件

实际应用场景建议：

• 高频小文件写入：优先考虑无锁设计
• 必须共享文件时：根据性能需求选择细粒度锁或整体锁
• 关键数据操作：建议结合锁机制和fsync确保数据持久化

在Windows平台上的注意事项：

• 使用LockFileEx替代flock
• 注意HANDLE的继承属性设置
• 考虑使用内存映射文件(Memory-mapped File)作为替代方案

---

研究学习不易，点赞易。
工作生活不易，收藏易，点收藏不迷茫 ：）

---