1
进程内存布局:
2
  ┌───────────────────┐ 高地址
3
  │     内核空间       │ 3G~4G (32位系统)
4
  ├───────────────────┤
5
  │     栈(Stack) ↓   │ 局部变量、函数调用
6
  │        ...        │
7
  │     堆(Heap) ↑    │ malloc/free
8
  ├───────────────────┤
9
  │     BSS段         │ 未初始化的全局/静态变量(自动清零)
10
  │     数据段(Data)  │ 已初始化的全局/静态变量
11
  │     代码段(Text)  │ 程序指令(只读)
12
  └───────────────────┘ 低地址
13

14
多线程共享:
15
  ┌──────────────────────────────┐
8 collapsed lines
16
  │  进程地址空间(共享):          │
17
  │  代码段 / 数据段 / 堆 / 文件 │
18
  │  ┌─────┐ ┌─────┐ ┌─────┐   │
19
  │  │线程1│ │线程2│ │线程3│   │  ← 每个线程独立的:
20
  │  │ 栈  │ │ 栈  │ │ 栈  │   │    栈、寄存器、errno、TLS
21
  │  │ PC  │ │ PC  │ │ PC  │   │
22
  │  └─────┘ └─────┘ └─────┘   │
23
  └──────────────────────────────┘

1
┌──────────────────────────────────────────────────────────┐
2
│                    IPC 方式选择                            │
3
├──────────┬──────────┬───────┬─────────┬─────────────────┤
4
│ 方式     │ 速度     │ 方向  │ 适用    │ 特点             │
5
├──────────┼──────────┼───────┼─────────┼─────────────────┤
6
│ 管道pipe │ 中       │ 单向  │ 父子进程│ 简单,4KB缓冲    │
7
│ FIFO     │ 中       │ 单向  │ 任意进程│ 有名管道,文件系统│
8
│ 信号signal│ 快      │ 异步  │ 任意进程│ 只传信号号,不传数据│
9
│ 消息队列 │ 中       │ 双向  │ 任意进程│ 有格式,内核维护  │
10
│ 共享内存 │ ★最快   │ 双向  │ 任意进程│ 需同步机制(信号量)│
11
│ 信号量sem│ —       │ 同步  │ 任意进程│ 不传数据,只做同步│
12
│ Socket   │ 慢       │ 双向  │ 可跨网络│ 最通用,TCP/UDP  │
13
│ mmap     │ 快       │ 双向  │ 任意进程│ 文件映射到内存   │
14
└──────────┴──────────┴───────┴─────────┴─────────────────┘
15

5 collapsed lines
16
嵌入式中最常考:
17
  进程间大数据传输 → 共享内存 + 信号量同步
18
  父子进程通信 → 管道(pipe)
19
  网络通信 → Socket
20
  简单通知 → 信号(signal)

1
-rwxr-xr-- 1 user group 1234 Jan 1 file.txt
2
│└┬┘└┬┘└┬┘
3
│ │   │   └── 其他用户: r-- (只读)
4
│ │   └────── 组用户:   r-x (读+执行)
5
│ └────────── 属主:     rwx (读+写+执行)
6
└──────────── 文件类型: - 普通, d 目录, l 链接
7

8
权限数字表示: r=4, w=2, x=1
9
  chmod 755 file  →  rwxr-xr-x (属主全权限, 其他读+执行)
10
  chmod 644 file  →  rw-r--r-- (属主读写, 其他只读)

1
# 变量
2
CC = gcc
3
CFLAGS = -Wall -g
4
SRCS = $(wildcard src/*.c)
5
OBJS = $(SRCS:.c=.o)
6

7
# 目标: 依赖
8
#     命令(必须Tab开头)
9
app: $(OBJS)
10
$(CC) $(CFLAGS) -o $@ $^
11

12
# 模式规则
13
%.o: %.c
14
$(CC) $(CFLAGS) -c -o $@ $<
15

9 collapsed lines
16
# 伪目标
17
.PHONY: clean
18
clean:
19
rm -f $(OBJS) app
20

21
# 自动变量:
22
# $@ = 目标名
23
# $< = 第一个依赖
24
# $^ = 所有依赖

1
#!/bin/bash
2
# 变量
3
NAME="embedded"
4
echo "Hello $NAME"    # 双引号内变量展开
5
echo 'Hello $NAME'    # 单引号内原样输出
6

7
# 条件判断
8
if [ -f /etc/passwd ]; then
9
    echo "File exists"
10
elif [ -d /tmp ]; then
11
    echo "Dir exists"
12
fi
13

14
# 循环
15
for i in 1 2 3; do
16 collapsed lines
16
    echo "num: $i"
17
done
18

19
# while循环读文件
20
while read line; do
21
    echo "$line"
22
done < file.txt
23

24
# 函数
25
check_process() {
26
    if ps aux | grep -q "$1"; then
27
        return 0
28
    fi
29
    return 1
30
}
31
check_process "myapp" && echo "Running"

1
#include <fcntl.h>
2
#include <unistd.h>
3

4
// 打开文件
5
int fd = open("/tmp/test.txt", O_RDWR | O_CREAT | O_TRUNC, 0644);
6
if (fd < 0) {
7
    perror("open");
8
    return -1;
9
}
10

11
// 写入
12
const char *msg = "Hello\n";
13
ssize_t n = write(fd, msg, strlen(msg));
14

15
// 定位
8 collapsed lines
16
lseek(fd, 0, SEEK_SET);  // 回到文件开头
17

18
// 读取
19
char buf[64];
20
n = read(fd, buf, sizeof(buf) - 1);
21
buf[n] = '\0';
22

23
close(fd);

1
// 标准IO的缓冲模式
2
setvbuf(fp, NULL, _IOFBF, 4096);  // 全缓冲(文件)
3
setvbuf(fp, NULL, _IOLBF, 0);     // 行缓冲(终端stdout)
4
setvbuf(fp, NULL, _IONBF, 0);     // 无缓冲(stderr)

1
#include <unistd.h>
2
#include <fcntl.h>
3

4
// 输出重定向到文件(printf输出到文件)
5
int fd = open("output.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
6
int old_stdout = dup(STDOUT_FILENO);   // 备份stdout
7
dup2(fd, STDOUT_FILENO);               // 将fd复制到1号(stdout)
8
close(fd);
9

10
printf("This goes to file\n");        // 输出到output.txt
11

12
// 恢复stdout
13
dup2(old_stdout, STDOUT_FILENO);
14
close(old_stdout);
15
printf("Back to terminal\n");

1
// fcntl: 设置非阻塞
2
int flags = fcntl(fd, F_GETFL);
3
fcntl(fd, F_SETFL, flags | O_NONBLOCK);
4

5
// ioctl: 设置串口波特率
6
struct termios tio;
7
tcgetattr(fd, &tio);
8
cfsetispeed(&tio, B115200);
9
cfsetospeed(&tio, B115200);
10
tcsetattr(fd, TCSANOW, &tio);

1
#include <sys/mman.h>
2
#include <fcntl.h>
3

4
int fd = open("data.bin", O_RDWR);
5
struct stat st;
6
fstat(fd, &st);
7

8
// 映射整个文件到内存
9
char *addr = mmap(NULL, st.st_size, PROT_READ | PROT_WRITE,
10
                  MAP_SHARED, fd, 0);
11
if (addr == MAP_FAILED) {
12
    perror("mmap");
13
    return -1;
14
}
15

6 collapsed lines
16
// 直接通过指针操作文件内容
17
addr[0] = 'A';  // 修改会同步到文件(MAP_SHARED)
18

19
// 解除映射
20
munmap(addr, st.st_size);
21
close(fd);

1
// epoll基本使用(嵌入式网络编程首选)
2
#include <sys/epoll.h>
3

4
int epfd = epoll_create1(0);
5

6
struct epoll_event ev;
7
ev.events = EPOLLIN;
8
ev.data.fd = listen_fd;
9
epoll_ctl(epfd, EPOLL_CTL_ADD, listen_fd, &ev);
10

11
struct epoll_event events[64];
12
while (1) {
13
    int n = epoll_wait(epfd, events, 64, -1);
14
    for (int i = 0; i < n; i++) {
15
        if (events[i].data.fd == listen_fd) {
11 collapsed lines
16
            // 新连接
17
            int client = accept(listen_fd, NULL, NULL);
18
            ev.events = EPOLLIN;
19
            ev.data.fd = client;
20
            epoll_ctl(epfd, EPOLL_CTL_ADD, client, &ev);
21
        } else {
22
            // 数据可读
23
            handle_client(events[i].data.fd);
24
        }
25
    }
26
}

1
#include <fcntl.h>
2

3
int fd = open("shared.dat", O_RDWR);
4

5
// 方法1: flock(整个文件锁)
6
flock(fd, LOCK_EX);   // 加排他锁(阻塞等)
7
// ... 操作文件 ...
8
flock(fd, LOCK_UN);   // 解锁
9

10
// 方法2: fcntl(可锁文件区域)
11
struct flock fl;
12
fl.l_type = F_WRLCK;     // 写锁
13
fl.l_whence = SEEK_SET;
14
fl.l_start = 0;          // 从文件开始
15
fl.l_len = 100;          // 锁前100字节
4 collapsed lines
16
fcntl(fd, F_SETLKW, &fl);  // 加锁(W=阻塞等待)
17
// ... 操作 ...
18
fl.l_type = F_UNLCK;
19
fcntl(fd, F_SETLK, &fl);   // 解锁

1
// 关键系统调用示例(见各函数注释)
2
#include <sys/inotify.h>
3

4
int ifd = inotify_init();
5
int wd = inotify_add_watch(ifd, "/etc/myapp.conf",
6
                           IN_MODIFY | IN_DELETE);
7

8
char buf[4096];
9
while (1) {
10
    int len = read(ifd, buf, sizeof(buf));
11
    struct inotify_event *event;
12
    for (char *ptr = buf; ptr < buf + len;
13
         ptr += sizeof(*event) + event->len) {
14
        event = (struct inotify_event *)ptr;
15
        if (event->mask & IN_MODIFY)
3 collapsed lines
16
            reload_config();
17
    }
18
}

1
// 方法1: mmap分段映射
2
#define MAP_SIZE (4*1024*1024)  // 每次映射4MB
3
off_t offset = 0;
4
while (offset < file_size) {
5
    size_t len = MIN(MAP_SIZE, file_size - offset);
6
    char *addr = mmap(NULL, len, PROT_READ, MAP_SHARED, fd, offset);
7
    process_chunk(addr, len);
8
    munmap(addr, len);
9
    offset += len;
10
}
11

12
// 方法2: sendfile零拷贝传输
13
#include <sys/sendfile.h>
14
off_t off = 0;
15
sendfile(out_fd, in_fd, &off, file_size);

1
#include <aio.h>
2

3
struct aiocb aio;
4
memset(&aio, 0, sizeof(aio));
5
aio.aio_fildes = fd;
6
aio.aio_buf = buffer;
7
aio.aio_nbytes = 4096;
8
aio.aio_offset = 0;
9

10
// 提交异步读
11
aio_read(&aio);
12

13
// 检查是否完成
14
while (aio_error(&aio) == EINPROGRESS) {
15
    // 做其他事情
5 collapsed lines
16
    do_other_work();
17
}
18

19
// 获取结果
20
ssize_t ret = aio_return(&aio);

1
#include <dirent.h>
2

3
void list_files(const char *path) {
4
    DIR *dir = opendir(path);
5
    if (!dir) { perror("opendir"); return; }
6

7
    struct dirent *entry;
8
    while ((entry = readdir(dir)) != NULL) {
9
        if (entry->d_name[0] == '.') continue;  // 跳过.和..
10

11
        if (entry->d_type == DT_DIR)
12
            printf("[DIR]  %s\n", entry->d_name);
13
        else
14
            printf("[FILE] %s\n", entry->d_name);
15
    }
2 collapsed lines
16
    closedir(dir);
17
}

1
#include <sys/stat.h>
2

3
struct stat st;
4
if (stat("/tmp/test.txt", &st) == 0) {
5
    printf("Size: %ld\n", st.st_size);
6
    printf("Mode: %o\n", st.st_mode & 0777);
7
    printf("UID: %d\n", st.st_uid);
8
    printf("Modified: %s", ctime(&st.st_mtime));
9

10
    // 判断文件类型
11
    if (S_ISREG(st.st_mode)) printf("Regular file\n");
12
    if (S_ISDIR(st.st_mode)) printf("Directory\n");
13
    if (S_ISLNK(st.st_mode)) printf("Symlink\n");
14
}
15

2 collapsed lines
16
// stat vs lstat: lstat不跟随符号链接
17
// stat vs fstat: fstat用fd而不是路径

1
// 关键系统调用示例(见各函数注释)
2
#include <sys/vfs.h>
3

4
struct statfs sfs;
5
if (statfs("/", &sfs) == 0) {
6
    unsigned long total = sfs.f_blocks * sfs.f_bsize;
7
    unsigned long free = sfs.f_bfree * sfs.f_bsize;
8
    unsigned long avail = sfs.f_bavail * sfs.f_bsize;
9
    printf("Total: %lu MB\n", total / 1024 / 1024);
10
    printf("Free:  %lu MB\n", free / 1024 / 1024);
11
    printf("Avail: %lu MB\n", avail / 1024 / 1024);
12
}

1
// 方法1: tmpfile(自动删除)
2
FILE *fp = tmpfile();  // 关闭时自动删除
3
fprintf(fp, "temp data");
4
rewind(fp);
5

6
// 方法2: mkstemp(需要手动删除)
7
char template[] = "/tmp/myapp_XXXXXX";
8
int fd = mkstemp(template);  // XXXXXX被替换为唯一字符串
9
write(fd, "data", 4);
10
close(fd);
11
unlink(template);  // 删除临时文件

1
#include <unistd.h>
2
#include <sys/wait.h>
3

4
int main() {
5
    pid_t pid = fork();
6

7
    if (pid < 0) {
8
        perror("fork");
9
        exit(1);
10
    } else if (pid == 0) {
11
        // 子进程
12
        printf("Child PID: %d\n", getpid());
13
        execl("/bin/ls", "ls", "-la", NULL);
14
        exit(1);  // exec失败才到这
15
    } else {
8 collapsed lines
16
        // 父进程
17
        int status;
18
        waitpid(pid, &status, 0);
19
        if (WIFEXITED(status))
20
            printf("Child exited with %d\n", WEXITSTATUS(status));
21
    }
22
    return 0;
23
}

1
// wait: 等待任意子进程
2
int status;
3
pid_t child = wait(&status);
4

5
// waitpid: 等待指定子进程, 支持非阻塞
6
pid_t child = waitpid(pid, &status, WNOHANG);
7
// WNOHANG: 如果子进程没结束立即返回0
8

9
// 解析退出状态
10
if (WIFEXITED(status))      // 正常退出
11
    printf("Exit code: %d\n", WEXITSTATUS(status));
12
if (WIFSIGNALED(status))    // 被信号杀死
13
    printf("Killed by signal: %d\n", WTERMSIG(status));
14
if (WIFSTOPPED(status))     // 被暂停
15
    printf("Stopped by signal: %d\n", WSTOPSIG(status));

1
#include <unistd.h>
2
#include <sys/stat.h>
3

4
void daemonize(void) {
5
    // 1. fork，父进程退出
6
    pid_t pid = fork();
7
    if (pid > 0) exit(0);
8
    if (pid < 0) exit(1);
9

10
    // 2. 创建新会话(脱离终端)
11
    setsid();
12

13
    // 3. 再次fork(防止重新关联终端)
14
    pid = fork();
15
    if (pid > 0) exit(0);
17 collapsed lines
16
    if (pid < 0) exit(1);
17

18
    // 4. 修改工作目录
19
    chdir("/");
20

21
    // 5. 重设文件权限掩码
22
    umask(0);
23

24
    // 6. 关闭所有文件描述符
25
    for (int i = 0; i < sysconf(_SC_OPEN_MAX); i++)
26
        close(i);
27

28
    // 7. 重定向stdin/stdout/stderr到/dev/null
29
    open("/dev/null", O_RDWR);  // stdin  -> fd 0
30
    dup(0);                     // stdout -> fd 1
31
    dup(0);                     // stderr -> fd 2
32
}

1
终端 tty ─── 会话(Session)
2
              │
3
              ├── 前台进程组(接收键盘输入和信号)
4
              │   ├── shell
5
              │   └── shell启动的前台命令
6
              │
7
              └── 后台进程组(&启动的)
8
                  ├── bg_proc1
9
                  └── bg_proc2
10

11
API:
12
  getpgrp()    - 获取进程组ID
13
  setpgid()    - 设置进程组
14
  getsid()     - 获取会话ID
15
  setsid()     - 创建新会话(daemon关键步骤)
1 collapsed line
16
  tcsetpgrp()  - 设置前台进程组

1
// execl - 参数列表
2
execl("/bin/echo", "echo", "hello", "world", NULL);
3

4
// execv - 参数数组
5
char *args[] = {"echo", "hello", "world", NULL};
6
execv("/bin/echo", args);
7

8
// execvp - 自动搜索PATH
9
execlp("echo", "echo", "hello", NULL);
10

11
// execve - 指定环境变量
12
char *envp[] = {"PATH=/bin", "HOME=/tmp", NULL};
13
execve("/bin/echo", args, envp);

1
// system() - 执行命令等待结束
2
int ret = system("ls -la /tmp");
3
// ret = 子进程的exit status
4

5
// popen() - 执行命令并读取输出
6
FILE *fp = popen("ifconfig eth0", "r");
7
char buf[1024];
8
while (fgets(buf, sizeof(buf), fp)) {
9
    printf("%s", buf);
10
}
11
pclose(fp);
12

13
// 注意: system/popen有安全风险(命令注入)
14
// 嵌入式产品中应避免拼接用户输入到命令

1
int pipefd[2];
2
pipe(pipefd);  // pipefd[0]读, pipefd[1]写
3

4
pid_t pid = fork();
5
if (pid == 0) {
6
    // 子进程：写数据
7
    close(pipefd[0]);
8
    const char *msg = "Hello from child";
9
    write(pipefd[1], msg, strlen(msg));
10
    close(pipefd[1]);
11
    exit(0);
12
} else {
13
    // 父进程：读数据
14
    close(pipefd[1]);
15
    char buf[256];
6 collapsed lines
16
    int n = read(pipefd[0], buf, sizeof(buf) - 1);
17
    buf[n] = '\0';
18
    printf("Parent got: %s\n", buf);
19
    close(pipefd[0]);
20
    wait(NULL);
21
}

1
#include <sys/stat.h>
2

3
// 创建FIFO
4
mkfifo("/tmp/myfifo", 0666);
5

6
// 写者进程
7
int fd = open("/tmp/myfifo", O_WRONLY);
8
write(fd, "data", 4);
9
close(fd);
10

11
// 读者进程(另一个程序)
12
int fd = open("/tmp/myfifo", O_RDONLY);
13
char buf[256];
14
int n = read(fd, buf, sizeof(buf));
15
close(fd);
1 collapsed line
16
unlink("/tmp/myfifo");  // 用完删除

1
#include <sys/mman.h>
2
#include <fcntl.h>
3

4
// 创建共享内存对象
5
int shm_fd = shm_open("/my_shm", O_CREAT | O_RDWR, 0666);
6
ftruncate(shm_fd, 4096);
7

8
// 映射到进程空间
9
char *addr = mmap(NULL, 4096, PROT_READ | PROT_WRITE,
10
                  MAP_SHARED, shm_fd, 0);
11

12
// 写入数据
13
sprintf(addr, "Hello shared memory");
14

15
// 另一个进程读取
7 collapsed lines
16
int shm_fd2 = shm_open("/my_shm", O_RDONLY, 0);
17
char *addr2 = mmap(NULL, 4096, PROT_READ, MAP_SHARED, shm_fd2, 0);
18
printf("Got: %s\n", addr2);
19

20
// 清理
21
munmap(addr, 4096);
22
shm_unlink("/my_shm");

1
#include <mqueue.h>
2

3
// 创建消息队列
4
struct mq_attr attr = { .mq_maxmsg = 10, .mq_msgsize = 256 };
5
mqd_t mq = mq_open("/my_mq", O_CREAT | O_RDWR, 0666, &attr);
6

7
// 发送消息(优先级=1)
8
mq_send(mq, "Hello", 5, 1);
9

10
// 接收消息
11
char buf[256];
12
unsigned int prio;
13
ssize_t n = mq_receive(mq, buf, sizeof(buf), &prio);
14
printf("Received: %.*s (prio=%u)\n", (int)n, buf, prio);
15

3 collapsed lines
16
// 清理
17
mq_close(mq);
18
mq_unlink("/my_mq");

1
#include <signal.h>
2

3
volatile sig_atomic_t running = 1;  // volatile: 防止编译器优化
4

5
void sighandler(int sig) {
6
    if (sig == SIGINT || sig == SIGTERM)
7
        running = 0;
8
}
9

10
int main() {
11
    // 推荐使用sigaction(比signal更可靠)
12
    struct sigaction sa;
13
    sa.sa_handler = sighandler;
14
    sigemptyset(&sa.sa_mask);
15
    sa.sa_flags = 0;
13 collapsed lines
16
    sigaction(SIGINT, &sa, NULL);  // 注册信号处理
17
    sigaction(SIGTERM, &sa, NULL);  // 注册信号处理
18

19
    // 忽略SIGPIPE(网络编程必须)
20
    signal(SIGPIPE, SIG_IGN);  // 注册信号处理
21

22
    while (running) {
23
        do_work();
24
        usleep(100000);
25
    }
26
    printf("Graceful shutdown\n");
27
    return 0;
28
}

1
#include <semaphore.h>
2

3
// 无名信号量(线程间)
4
sem_t sem;
5
sem_init(&sem, 0, 1);  // 0=线程间, 初始值1(互斥)
6
sem_wait(&sem);  // P操作
7
// 临界区
8
sem_post(&sem);  // V操作
9
sem_destroy(&sem);
10

11
// 有名信号量(进程间)
12
sem_t *sem = sem_open("/my_sem", O_CREAT, 0666, 1);
13
sem_wait(sem);
14
// 临界区
15
sem_post(sem);
2 collapsed lines
16
sem_close(sem);
17
sem_unlink("/my_sem");

1
// 预fork模式(避免每次连接都fork)
2
#define WORKER_NUM 4
3

4
int listen_fd = socket_bindlisten(8080);
5

6
for (int i = 0; i < WORKER_NUM; i++) {
7
    if (fork() == 0) {
8
        // 子进程循环accept
9
        while (1) {
10
            int client_fd = accept(listen_fd, NULL, NULL);
11
            handle_request(client_fd);
12
            close(client_fd);
13
        }
14
        exit(0);
15
    }
3 collapsed lines
16
}
17
// 父进程等待子进程
18
while (wait(NULL) > 0);