Linux 编程接口（Linux Programming Interface）详解

#include <unistd.h>  // 包含 write() 声明
 
int main() {
    const char* msg = "Hello, Linux System Call!\n";
    // 系统调用：向标准输出（文件描述符 1）写入数据
    ssize_t bytes_written = write(1, msg, 25);  // 25 是字符串长度（含换行符）
    if (bytes_written == -1) {
        // 错误处理（实际开发中需用 perror 打印具体错误）
        return 1;
    }
    return 0;
}

gcc syscall_demo.c -o syscall_demo && ./syscall_demo
# 输出：Hello, Linux System Call!

// 标准库 API：带缓冲，易用性高
#include <stdio.h>
int main() {
    printf("Hello, glibc!\n");  // 内部调用 write()，但通过缓冲区优化
    return 0;
}
 
// 直接系统调用：无缓冲，需手动处理细节
#include <unistd.h>
int main() {
    const char* msg = "Hello, syscall!\n";
    write(1, msg, 16);  // 需手动指定长度，无格式化
    return 0;
}

// 打开文件，返回 FD（失败返回 -1）
int open(const char* pathname, int flags, mode_t mode);
// 读文件（返回读取字节数，0 表示 EOF，-1 表示错误）
ssize_t read(int fd, void* buf, size_t count);
// 写文件（返回写入字节数，-1 表示错误）
ssize_t write(int fd, const void* buf, size_t count);
// 关闭 FD（失败返回 -1）
int close(int fd);

off_t lseek(int fd, off_t offset, int whence);

#include <stdio.h>
#include <fcntl.h>   // open()
#include <unistd.h>  // read(), write(), close()
#include <stdlib.h>  // exit()
 
int main() {
    // 1. 创建并打开文件（若不存在则创建，权限 0644，读写模式）
    int fd = open("demo.txt", O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd == -1) {
        perror("open failed");  // 打印错误信息（依赖 errno）
        exit(1);
    }
 
    // 2. 写入数据
    const char* content = "Linux 文件 I/O 示例\n";
    ssize_t written = write(fd, content, 20);  // 字符串长度为 20
    if (written == -1) {
        perror("write failed");
        close(fd);  // 错误时需释放资源
        exit(1);
    }
    close(fd);  // 写完关闭文件
 
    // 3. 重新打开文件读取内容
    fd = open("demo.txt", O_RDONLY);
    if (fd == -1) {
        perror("open failed");
        exit(1);
    }
 
    char buf[1024];
    ssize_t read_bytes = read(fd, buf, sizeof(buf)-1);  // 留 1 字节给 '\0'
    if (read_bytes == -1) {
        perror("read failed");
        close(fd);
        exit(1);
    }
    buf[read_bytes] = '\0';  // 手动添加字符串结束符
    printf("读取内容：%s", buf);
 
    close(fd);  // 关闭文件
    return 0;
}

gcc file_io_demo.c -o file_io_demo && ./file_io_demo
# 输出：读取内容：Linux 文件 I/O 示例

pid_t fork(void);  // 返回值：父进程中为子进程 PID，子进程中为 0，失败返回 -1

// 最常用的 exec 函数：从 PATH 中查找程序，参数列表可变
int execlp(const char* file, const char* arg, ...);

pid_t wait(int* status);  // 等待任意子进程退出
pid_t waitpid(pid_t pid, int* status, int options);  // 等待指定子进程

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>  // waitpid()
#include <stdlib.h>
 
int main() {
    pid_t pid = fork();
    if (pid == -1) {
        perror("fork failed");
        exit(1);
    }
 
    if (pid == 0) {  // 子进程
        printf("子进程 PID: %d\n", getpid());
        // 替换为 ls -l 命令
        execlp("ls", "ls", "-l", NULL);  // 参数列表以 NULL 结束
        // 若 execlp 失败，才会执行以下代码
        perror("execlp failed");
        exit(1);
    } else {  // 父进程
        printf("父进程 PID: %d，等待子进程...\n", getpid());
        int status;
        // 等待 PID 为 pid 的子进程，阻塞模式
        waitpid(pid, &status, 0);
        if (WIFEXITED(status)) {  // 判断子进程是否正常退出
            printf("子进程退出，退出码: %d\n", WEXITSTATUS(status));
        }
    }
    return 0;
}

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

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>
 
int main() {
    int pipefd[2];
    if (pipe(pipefd) == -1) {  // 创建管道
        perror("pipe failed");
        return 1;
    }
 
    pid_t pid = fork();
    if (pid == -1) {
        perror("fork failed");
        return 1;
    }
 
    if (pid == 0) {  // 子进程：读管道
        close(pipefd[1]);  // 关闭写端（仅读）
        char buf[1024];
        ssize_t n = read(pipefd[0], buf, sizeof(buf)-1);
        if (n > 0) {
            buf[n] = '\0';
            printf("子进程收到：%s\n", buf);
        }
        close(pipefd[0]);
        return 0;
    } else {  // 父进程：写管道
        close(pipefd[0]);  // 关闭读端（仅写）
        const char* msg = "Hello from parent!";
        write(pipefd[1], msg, strlen(msg));
        close(pipefd[1]);  // 关闭写端，子进程 read 会返回 0（EOF）
        wait(NULL);  // 等待子进程
        return 0;
    }
}

mkfifo /tmp/myfifo  # 命令行创建

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <string.h>
#include <unistd.h>
 
// 信号量操作：P 操作（等待）
void sem_p(int semid) {
    struct sembuf sb = {0, -1, 0};  // sem_num=0, sem_op=-1（P操作）
    semop(semid, &sb, 1);
}
 
// 信号量操作：V 操作（释放）
void sem_v(int semid) {
    struct sembuf sb = {0, 1, 0};  // sem_op=1（V操作）
    semop(semid, &sb, 1);
}
 
int main() {
    key_t key = ftok(".", 'a');  // 生成唯一键值（基于当前目录和字符 'a'）
 
    // 1. 创建共享内存（大小 1024 字节，权限 0666）
    int shmid = shmget(key, 1024, IPC_CREAT | 0666);
    if (shmid == -1) { perror("shmget"); return 1; }
 
    // 2. 创建信号量（1 个信号量，初始值 1，权限 0666）
    int semid = semget(key, 1, IPC_CREAT | 0666);
    if (semid == -1) { perror("semget"); return 1; }
    semctl(semid, 0, SETVAL, 1);  // 初始化信号量值为 1（互斥锁）
 
    pid_t pid = fork();
    if (pid == 0) {  // 子进程：写入共享内存
        char* shm = shmat(shmid, NULL, 0);  // 映射共享内存
        sem_p(semid);  // P操作：获取锁
        strcpy(shm, "Hello from shared memory!");
        sem_v(semid);  // V操作：释放锁
        shmdt(shm);    // 解除映射
        return 0;
    } else {  // 父进程：读取共享内存
        wait(NULL);
        char* shm = shmat(shmid, NULL, 0);
        sem_p(semid);
        printf("共享内存内容：%s\n", shm);
        sem_v(semid);
        shmdt(shm);
 
        // 清理资源
        shmctl(shmid, IPC_RMID, NULL);  // 删除共享内存
        semctl(semid, 0, IPC_RMID);     // 删除信号量
    }
    return 0;
}

int socket(int domain, int type, int protocol);

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>  // sockaddr_in
 
#define PORT 8080
#define BUFFER_SIZE 1024
 
int main() {
    // 1. 创建 TCP 套接字
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }
 
    // 2. 绑定端口和 IP
    struct sockaddr_in address;
    int addrlen = sizeof(address);
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;  // 绑定所有网卡 IP
    address.sin_port = htons(PORT);        // 端口转换为网络字节序（大端）
 
    if (bind(server_fd, (struct sockaddr*)&address, sizeof(address)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }
 
    // 3. 监听连接（最大等待队列长度 3）
    if (listen(server_fd, 3) < 0) {
        perror("listen failed");
        exit(EXIT_FAILURE);
    }
    printf("服务器启动，监听端口 %d...\n", PORT);
 
    // 4. 接收客户端连接并处理
    while (1) {
        int new_socket;
        // 阻塞等待客户端连接，返回新的通信套接字
        if ((new_socket = accept(server_fd, (struct sockaddr*)&address, (socklen_t*)&addrlen)) < 0) {
            perror("accept failed");
            continue;
        }
 
        // 读取客户端数据并回显
        char buffer[BUFFER_SIZE] = {0};
        ssize_t valread = read(new_socket, buffer, BUFFER_SIZE);
        printf("收到客户端数据：%s\n", buffer);
        write(new_socket, buffer, strlen(buffer));  // 回显数据
        close(new_socket);  // 关闭连接
    }
 
    return 0;
}

nc localhost 8080  # 输入任意字符串，服务器会回显

struct sigaction {
    void (*sa_handler)(int);  // 信号处理函数
    sigset_t sa_mask;         // 处理期间屏蔽的信号集
    int sa_flags;             // 标志（如 SA_RESTART 自动重启被中断的系统调用）
};
 
int sigaction(int signum, const struct sigaction* act, struct sigaction* oldact);

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
 
// 信号处理函数
void handle_sigint(int signum) {
    printf("\n收到 SIGINT 信号（Ctrl+C），正在优雅退出...\n");
    // 此处可添加资源清理逻辑（如关闭文件、释放内存）
    exit(0);
}
 
int main() {
    struct sigaction sa;
    sa.sa_handler = handle_sigint;  // 绑定处理函数
    sigemptyset(&sa.sa_mask);       // 不屏蔽其他信号
    sa.sa_flags = 0;
 
    // 注册 SIGINT 信号处理
    if (sigaction(SIGINT, &sa, NULL) == -1) {
        perror("sigaction failed");
        return 1;
    }
 
    printf("程序运行中，按 Ctrl+C 测试信号处理...\n");
    while (1) {
        sleep(1);  // 模拟程序运行
    }
    return 0;
}

void* malloc(size_t size);  // 分配 size 字节内存，返回首地址（失败返回 NULL）
void free(void* ptr);       // 释放 ptr 指向的内存

#include <stdio.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
 
int main() {
    int fd = open("large_file.txt", O_RDONLY);
    if (fd == -1) { perror("open"); return 1; }
 
    // 获取文件大小
    struct stat st;
    fstat(fd, &st);
    off_t file_size = st.st_size;
 
    // 映射文件到内存（只读，私有映射）
    char* addr = mmap(NULL, file_size, PROT_READ, MAP_PRIVATE, fd, 0);
    if (addr == MAP_FAILED) { perror("mmap"); return 1; }
 
    // 直接访问内存即可读取文件内容（无需 read()）
    printf("文件前 100 字节：%.100s\n", addr);
 
    // 解除映射并关闭文件
    munmap(addr, file_size);
    close(fd);
    return 0;
}