1
虚拟地址 → MMU查页表 → 物理地址
2

3
进程A:                     物理内存:
4
  0x0000 ┌────────┐        ┌────────┐ 0x0000
5
  代码段 │ Page 0 │──┐     │ 空闲   │
6
         ├────────┤  │     ├────────┤
7
  数据段 │ Page 1 │──┼──→  │ A-Page0│ 0x1000
8
         ├────────┤  │     ├────────┤
9
  堆     │ Page 2 │  └──→  │ A-Page1│ 0x2000
10
         ├────────┤        ├────────┤
11
         │  ...   │        │ B-Page0│ 0x3000  ← 进程B的
12
  栈     │ Page N │        ├────────┤
13
  0xFFFF └────────┘        │ A-Page2│ 0x4000
14
                           └────────┘
15

12 collapsed lines
16
Page Fault(缺页中断):
17
  访问的页不在物理内存 → 触发中断 → OS从磁盘加载到内存 → 更新页表 → 重新执行
18

19
页面置换算法:
20
  ┌──────┬──────────────────┬───────────┐
21
  │ 算法  │ 原理              │ 性能       │
22
  ├──────┼──────────────────┼───────────┤
23
  │ FIFO │ 先进先出          │ 差(Belady)│
24
  │ LRU  │ 最近最少使用★    │ 优(但贵)  │
25
  │ Clock│ LRU近似(二次机会)│ 好(实用)  │
26
  │ OPT  │ 未来最久不用      │ 最优(理论)│
27
  └──────┴──────────────────┴───────────┘

1
        创建(fork)
2
           │
3
           ▼
4
      ┌──────────┐   调度     ┌──────────┐
5
      │  就绪态   │──────────→│  运行态   │
6
      │  Ready   │←──────────│ Running  │
7
      └────┬─────┘   时间片到  └────┬─────┘
8
           │                        │
9
           │                   I/O请求/等信号
10
           │          I/O完成      │
11
           │←───────────────┐      │
12
           │                │      ▼
13
           │           ┌────┴─────┐
14
           │           │  阻塞态   │
15
           │           │ Blocked  │
9 collapsed lines
16
           │           └──────────┘
17
           │
18
      exit()/被杀                               // 进程退出
19
           │
20
           ▼
21
      ┌──────────┐
22
      │  僵尸态   │──→ 父进程wait()回收 → 销毁                           // 等待子进程结束
23
      │  Zombie  │
24
      └──────────┘

1
// 用户态调用write系统调用的底层过程(Linux x86_64)：
2
// 1. 用户态: write(fd, buf, len)
3
// 2. glibc将系统调用号放入rax, 参数放入rdi/rsi/rdx
4
// 3. 执行syscall指令 → CPU切换到内核态
5
// 4. 内核执行sys_write()
6
// 5. 执行sysret → 返回用户态

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

4
int main() {
5
    int x = 100;
6
    pid_t pid = fork();  // 创建子进程
7

8
    if (pid < 0) {
9
        perror("fork failed");
10
    } else if (pid == 0) {
11
        // 子进程：fork返回0
12
        x = 200;
13
        printf("Child: pid=%d, x=%d\n", getpid(), x);
14
    } else {
15
        // 父进程：fork返回子进程PID
4 collapsed lines
16
        printf("Parent: pid=%d, child=%d, x=%d\n", getpid(), pid, x);
17
    }
18
    return 0;
19
}

1
fork()后:
2
父进程页表 ──→ [物理页A](只读标记)
3
子进程页表 ──→ [物理页A](只读标记)  ← 共享同一物理页
4

5
子进程写入时(触发Page Fault):
6
父进程页表 ──→ [物理页A](恢复可写)
7
子进程页表 ──→ [物理页B](新分配，拷贝A内容) ← 才真正复制

1
pid_t pid = fork();
2
if (pid == 0) {
3
    // 子进程: 用exec替换为新程序
4
    execl("/usr/bin/app", "app", "--config", "test.cfg", NULL);
5
    perror("exec failed");  // 只有exec失败才会执行到这里
6
    exit(1);
7
} else {
8
    // 父进程: 等待子进程结束
9
    waitpid(pid, &status, 0);
10
}

1
// fork + exec 典型用法(shell执行命令)
2
pid_t pid = fork();
3
if (pid == 0) {
4
    // 子进程中执行新程序
5
    execl("/bin/ls", "ls", "-l", NULL);
6
    // exec成功后下面的代码不会执行
7
    perror("exec failed");
8
    exit(1);
9
}
10
// 父进程等待子进程结束
11
waitpid(pid, NULL, 0);

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

4
pid_t pid = fork();
5
if (pid == 0) {
6
    close(pipefd[0]);  // 子进程关闭读端
7
    write(pipefd[1], "hello", 5);
8
    close(pipefd[1]);
9
} else {
10
    close(pipefd[1]);  // 父进程关闭写端
11
    char buf[64];
12
    int n = read(pipefd[0], buf, sizeof(buf));
13
    buf[n] = '\0';
14
    printf("Received: %s\n", buf);
15
    close(pipefd[0]);
1 collapsed line
16
}

1
#include <sys/shm.h>
2

3
// 进程A：创建并写入
4
int shmid = shmget(IPC_PRIVATE, 4096, IPC_CREAT | 0666);
5
char *addr = (char *)shmat(shmid, NULL, 0);
6
strcpy(addr, "Hello from A");
7
shmdt(addr);
8

9
// 进程B：连接并读取
10
char *addr = (char *)shmat(shmid, NULL, 0);
11
printf("Got: %s\n", addr);
12
shmdt(addr);
13
shmctl(shmid, IPC_RMID, NULL);  // 用完释放

1
#include <signal.h>
2

3
void handler(int sig) {
4
    printf("Caught signal %d\n", sig);
5
}
6

7
int main() {
8
    signal(SIGINT, handler);   // 捕获Ctrl+C
9
    signal(SIGCHLD, SIG_IGN);  // 忽略子进程退出(避免僵尸)
10
    while (1) pause();
11
    return 0;
12
}

1
进程A:  持有锁1 → 请求锁2 → 等待...
2
进程B:  持有锁2 → 请求锁1 → 等待...

1
// 方法1：固定加锁顺序(最常用)
2
// 规则: 永远先锁mutex_a(地址小的), 再锁mutex_b
3
pthread_mutex_lock(&mutex_a);
4
pthread_mutex_lock(&mutex_b);
5
// ... 临界区 ...
6
pthread_mutex_unlock(&mutex_b);
7
pthread_mutex_unlock(&mutex_a);
8

9
// 方法2：trylock + 回退
10
if (pthread_mutex_trylock(&mutex_a) == 0) {
11
    if (pthread_mutex_trylock(&mutex_b) == 0) {
12
        // 拿到两把锁
13
        // ...
14
        pthread_mutex_unlock(&mutex_b);
15
    }
10 collapsed lines
16
    pthread_mutex_unlock(&mutex_a);
17
}
18

19
// 方法3：超时锁
20
struct timespec ts;
21
clock_gettime(CLOCK_REALTIME, &ts);
22
ts.tv_sec += 1;  // 1秒超时
23
if (pthread_mutex_timedlock(&mutex, &ts) == ETIMEDOUT) {
24
    // 超时处理
25
}

1
// 生产者-消费者模型(mutex + cond)
2
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
3
pthread_cond_t not_empty = PTHREAD_COND_INITIALIZER;
4
int buffer = 0;
5

6
void *producer(void *arg) {
7
    pthread_mutex_lock(&lock);
8
    buffer = 42;
9
    pthread_cond_signal(&not_empty);  // 通知消费者
10
    pthread_mutex_unlock(&lock);
11
    return NULL;
12
}
13

14
void *consumer(void *arg) {
15
    pthread_mutex_lock(&lock);
6 collapsed lines
16
    while (buffer == 0)
17
        pthread_cond_wait(&not_empty, &lock);  // 等待+释放锁(原子)
18
    printf("Got: %d\n", buffer);
19
    pthread_mutex_unlock(&lock);
20
    return NULL;
21
}

1
核心数据结构: 红黑树(按vruntime排序)
2

3
        vruntime(虚拟运行时间)
4
              │
5
  ┌───────────┼───────────┐
6
  │           │           │
7
进程A(5ms)  进程B(3ms)  进程C(7ms)  ← 每次选vruntime最小的运行
8

9
vruntime增长速度 = 实际运行时间 × (NICE_0_LOAD / 该进程权重)
10
- 权重大(nice值小) → vruntime增长慢 → 获得更多CPU时间
11
- 权重小(nice值大) → vruntime增长快 → 获得更少CPU时间

1
#include <sched.h>
2

3
// 设置实时调度策略
4
struct sched_param param;
5
param.sched_priority = 80;  // 实时优先级1~99
6
sched_setscheduler(0, SCHED_FIFO, &param);  // 当前进程设为FIFO

1
缺页处理流程:
2
1. CPU访问虚拟地址VA → MMU查页表 → 页表项标记"不在内存"
3
2. 触发Page Fault异常 → 进入内核缺页处理程序
4
3. 内核检查该VA是否合法(是否在进程的VMA中)
5
   → 不合法: SIGSEGV(段错误)
6
   → 合法: 继续处理
7
4. 在物理内存中找空闲页
8
   → 无空闲: 页面置换算法选一页换出到磁盘(swap)
9
5. 从磁盘/文件读入数据到物理页
10
6. 更新页表项(物理地址 + 在内存标记)
11
7. 重新执行触发缺页的指令

1
Clock算法(Linux实际使用的近似LRU):
2
  页面组成环形链表，每页有"访问位"
3
  指针扫描:
4
    访问位=1 → 清零, 继续扫描(给第二次机会)
5
    访问位=0 → 选中换出

1
分配策略(glibc实现):
2
  size < 128KB → brk() 扩展堆顶
3
  size >= 128KB → mmap() 分配独立内存区域
4

5
brk方式:
6
  低地址         堆顶(brk)
7
    │ 已分配区域 │ ↑ 向上增长
8

9
mmap方式:
10
  在进程地址空间中间区域映射一段匿名内存
11
  释放时直接munmap归还OS

1
// 封装malloc/free，记录分配信息
2
#define MY_MALLOC(size) my_malloc(size, __FILE__, __LINE__)
3
#define MY_FREE(ptr)    my_free(ptr, __FILE__, __LINE__)
4

5
typedef struct {  // 结构体定义
6
    void *ptr;
7
    size_t size;
8
    const char *file;
9
    int line;
10
} AllocInfo;
11

12
static AllocInfo alloc_table[1024];
13
static int alloc_count = 0;
14

15
void *my_malloc(size_t size, const char *file, int line) {
29 collapsed lines
16
    void *ptr = malloc(size);  // 动态分配内存
17
    if (ptr) {
18
        alloc_table[alloc_count].ptr = ptr;
19
        alloc_table[alloc_count].size = size;
20
        alloc_table[alloc_count].file = file;
21
        alloc_table[alloc_count].line = line;
22
        alloc_count++;
23
    }
24
    return ptr;
25
}
26

27
void my_free(void *ptr, const char *file, int line) {
28
    for (int i = 0; i < alloc_count; i++) {
29
        if (alloc_table[i].ptr == ptr) {
30
            alloc_table[i] = alloc_table[--alloc_count];
31
            break;
32
        }
33
    }
34
    free(ptr);  // 释放内存(建议之后置NULL)
35
}
36

37
// 程序结束时检查未释放的
38
void check_leak(void) {
39
    for (int i = 0; i < alloc_count; i++) {
40
        printf("LEAK: %p (%zu bytes) at %s:%d\n",
41
               alloc_table[i].ptr, alloc_table[i].size,
42
               alloc_table[i].file, alloc_table[i].line);
43
    }
44
}

1
// 简易定长内存池实现
2
#define BLOCK_SIZE 64
3
#define POOL_SIZE  32
4

5
typedef struct MemPool {
6
    uint8_t pool[BLOCK_SIZE * POOL_SIZE];
7
    uint8_t used[POOL_SIZE];  // 0=空闲, 1=已分配
8
} MemPool;
9

10
void pool_init(MemPool *mp) {
11
    memset(mp->used, 0, sizeof(mp->used));
12
}
13

14
void *pool_alloc(MemPool *mp) {
15
    for (int i = 0; i < POOL_SIZE; i++) {
13 collapsed lines
16
        if (!mp->used[i]) {
17
            mp->used[i] = 1;
18
            return &mp->pool[i * BLOCK_SIZE];
19
        }
20
    }
21
    return NULL;  // 池满
22
}
23

24
void pool_free(MemPool *mp, void *ptr) {
25
    int idx = ((uint8_t *)ptr - mp->pool) / BLOCK_SIZE;
26
    if (idx >= 0 && idx < POOL_SIZE)
27
        mp->used[idx] = 0;
28
}

1
#include <sys/mman.h>
2

3
// 1. 文件映射(零拷贝读文件)
4
int fd = open("data.bin", O_RDONLY);
5
struct stat st;
6
fstat(fd, &st);
7
char *addr = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
8
// 直接通过addr访问文件内容，无需read系统调用
9
printf("First byte: 0x%02x\n", addr[0]);
10
munmap(addr, st.st_size);
11
close(fd);
12

13
// 2. 匿名映射(大块内存分配)
14
void *ptr = mmap(NULL, 1024*1024, PROT_READ|PROT_WRITE,
15
                 MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
6 collapsed lines
16
// 等价于malloc大块内存
17
munmap(ptr, 1024*1024);
18

19
// 3. 进程间共享内存
20
void *shared = mmap(NULL, 4096, PROT_READ|PROT_WRITE,
21
                    MAP_SHARED|MAP_ANONYMOUS, -1, 0);

1
用户态:     open() / read() / write()
2
              │
3
内核VFS:    struct file_operations {
4
              .open = xxx_open,
5
              .read = xxx_read,
6
              .write = xxx_write,
7
            };
8
              │
9
具体FS:    ext4_read() / fat_read() / nfs_read()

1
进程PCB:
2
  files_struct → fd_table[]:
3
    fd[0] → stdin的file结构体
4
    fd[1] → stdout的file结构体
5
    fd[2] → stderr的file结构体
6
    fd[3] → 用户open()返回的file结构体
7

8
open("test.txt")的内核过程:
9
1. 路径解析(namei): 逐级查找目录项 → 找到inode
10
2. 创建struct file，填入inode指针、f_pos=0、f_op=文件操作集
11
3. 在进程fd_table[]中找到最小空闲位置(如3)
12
4. fd_table[3] = 新file结构体指针
13
5. 返回3给用户态

1
// epoll典型使用(Linux嵌入式常用)
2
int epfd = epoll_create1(0);
3
struct epoll_event ev;
4
ev.events = EPOLLIN | EPOLLET;  // 边沿触发
5
ev.data.fd = sockfd;
6
epoll_ctl(epfd, EPOLL_CTL_ADD, sockfd, &ev);
7

8
struct epoll_event events[MAX_EVENTS];
9
int n = epoll_wait(epfd, events, MAX_EVENTS, timeout_ms);
10
for (int i = 0; i < n; i++) {
11
    if (events[i].events & EPOLLIN) {
12
        // 处理可读事件
13
    }
14
}

1
// ET模式必须循环读到EAGAIN
2
while (1) {
3
    int n = read(fd, buf, sizeof(buf));
4
    if (n < 0) {
5
        if (errno == EAGAIN) break;  // 数据读完
6
        perror("read");
7
        break;
8
    }
9
    if (n == 0) break;  // 对端关闭
10
    process(buf, n);
11
}

1
传统文件发送(4次拷贝):
2
  磁盘 →(DMA)→ 内核缓冲 →(CPU)→ 用户缓冲 →(CPU)→ Socket缓冲 →(DMA)→ 网卡
3

4
sendfile零拷贝(2次拷贝):
5
  磁盘 →(DMA)→ 内核缓冲 →(DMA)→ 网卡   (不经过用户态!)
6

7
mmap + write(3次拷贝):
8
  磁盘 →(DMA)→ 内核缓冲(映射到用户空间) →(CPU)→ Socket缓冲 →(DMA)→ 网卡

1
传统文件系统写入:
2
  1. 写数据块 → 2. 更新inode → 3. 更新bitmap
3
  (任一步掉电都导致不一致)
4

5
日志文件系统:
6
  1. 写日志(Journal): 记录"将要进行的操作"
7
  2. 执行实际写操作
8
  3. 标记日志完成(commit)
9

10
  掉电恢复: 检查日志 → 未commit则丢弃 → 已commit则重放

1
// 信号量结构
2
typedef struct {
3
    int value;           // 资源计数
4
    struct list_head wait_list;  // 等待队列
5
} Semaphore;
6

7
// P操作(等待/申请) - 也叫wait/down
8
void sem_wait(Semaphore *sem) {
9
    sem->value--;
10
    if (sem->value < 0) {
11
        // 加入等待队列，阻塞当前进程
12
        add_to_wait_list(current);
13
        schedule();  // 让出CPU
14
    }
15
}
9 collapsed lines
16

17
// V操作(释放/signal) - 也叫post/up
18
void sem_post(Semaphore *sem) {
19
    sem->value++;
20
    if (sem->value <= 0) {
21
        // 唤醒等待队列中的一个进程
22
        wakeup(wait_list.first);
23
    }
24
}

1
#include <pthread.h>
2
#include <semaphore.h>
3

4
#define BUF_SIZE 10
5
int buffer[BUF_SIZE];
6
int in = 0, out = 0;
7

8
sem_t empty;  // 空位计数(初始=BUF_SIZE)
9
sem_t full;   // 数据计数(初始=0)
10
pthread_mutex_t mutex;
11

12
void *producer(void *arg) {
13
    while (1) {
14
        int item = produce_item();
15
        sem_wait(&empty);         // 等待空位
19 collapsed lines
16
        pthread_mutex_lock(&mutex);
17
        buffer[in] = item;
18
        in = (in + 1) % BUF_SIZE;
19
        pthread_mutex_unlock(&mutex);
20
        sem_post(&full);          // 增加数据计数
21
    }
22
}
23

24
void *consumer(void *arg) {
25
    while (1) {
26
        sem_wait(&full);          // 等待数据
27
        pthread_mutex_lock(&mutex);
28
        int item = buffer[out];
29
        out = (out + 1) % BUF_SIZE;
30
        pthread_mutex_unlock(&mutex);
31
        sem_post(&empty);         // 增加空位
32
        consume_item(item);
33
    }
34
}

1
pthread_rwlock_t rwlock;
2
pthread_rwlock_init(&rwlock, NULL);
3

4
// 读者(可并发)
5
pthread_rwlock_rdlock(&rwlock);
6
// ... 读操作 ...
7
pthread_rwlock_unlock(&rwlock);
8

9
// 写者(独占)
10
pthread_rwlock_wrlock(&rwlock);
11
// ... 写操作 ...
12
pthread_rwlock_unlock(&rwlock);

1
// Linux内核自旋锁使用
2
spinlock_t my_lock;
3
spin_lock_init(&my_lock);
4

5
// 进程上下文
6
spin_lock(&my_lock);
7
// 临界区(绝对不能睡眠!)
8
spin_unlock(&my_lock);
9

10
// 中断上下文(需要关中断)
11
unsigned long flags;
12
spin_lock_irqsave(&my_lock, flags);
13
// 临界区
14
spin_unlock_irqrestore(&my_lock, flags);

1
原理:
2
  [读者] 直接读指针指向的数据(无锁，极快)
3
  [写者] 分三步:
4
    1. Copy: 复制旧数据到新副本
5
    2. Update: 修改新副本
6
    3. 替换指针(原子操作，让读者看到新数据)
7
    4. 等待所有旧读者退出(grace period)
8
    5. 释放旧数据
9

10
优势: 读操作零开销(无锁、无原子操作、无内存屏障)
11
代价: 写操作开销大(需要复制+等待)
12
适用: 读极多写极少(如路由表、模块列表)

1
// 问题场景(双核)
2
// CPU0:                  CPU1:
3
flag = 1;                while (!flag);
4
data = 42;               use(data);  // 可能读到旧值！
5

6
// 因为CPU0的store可能被重排: data=42可能在flag=1之前对CPU1可见
7

8
// 解决:
9
// CPU0:
10
data = 42;
11
wmb();   // 写屏障：data=42一定先于flag=1对外可见
12
flag = 1;
13

14
// CPU1:
15
while (!flag);
2 collapsed lines
16
rmb();   // 读屏障：确保读data在读flag之后
17
use(data);

1
// 场景1：中断与主循环共享变量
2
volatile int flag = 0;
3

4
void ISR(void) {
5
    flag = 1;  // 中断中修改
6
}
7

8
int main(void) {
9
    while (!flag);  // 如果没有volatile，编译器可能优化为死循环
10
    // (编译器认为flag在循环中没有修改，优化成if(!flag) while(1);)
11
    do_something();
12
}
13

14
// 场景2：硬件寄存器
15
#define UART_DR  (*(volatile uint32_t *)0x40001000)
1 collapsed line
16
// 每次读UART_DR都必须从硬件地址读取，不能用缓存值

1
// Linux内核原子操作
2
atomic_t counter = ATOMIC_INIT(0);
3

4
atomic_set(&counter, 5);
5
atomic_inc(&counter);      // counter++（原子）
6
atomic_dec(&counter);      // counter--（原子）
7
int val = atomic_read(&counter);
8

9
// 用户态GCC内建原子操作
10
int val = 0;
11
__atomic_add_fetch(&val, 1, __ATOMIC_SEQ_CST);  // val++
12
__atomic_sub_fetch(&val, 1, __ATOMIC_SEQ_CST);  // val--
13

14
// CAS(Compare-And-Swap)
15
int expected = 0;
3 collapsed lines
16
int desired = 1;
17
__atomic_compare_exchange_n(&val, &expected, desired,
18
                            0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);

1
#include <setjmp.h>
2
#include <stdio.h>
3

4
jmp_buf env;
5

6
void dangerous_func(void) {
7
    printf("About to fail...\n");
8
    longjmp(env, 1);  // 跳回setjmp处，返回值为1
9
    printf("Never reached\n");
10
}
11

12
int main(void) {
13
    if (setjmp(env) == 0) {
14
        // 正常执行路径(setjmp首次返回0)
15
        dangerous_func();
6 collapsed lines
16
    } else {
17
        // 异常处理路径(longjmp触发setjmp返回非0)
18
        printf("Error caught!\n");
19
    }
20
    return 0;
21
}

1
// STM32 IWDG配置
2
IWDG->KR = 0x5555;  // 使能写入
3
IWDG->PR = 4;       // 预分频
4
IWDG->RLR = 625;    // 超时500ms
5
IWDG->KR = 0xCCCC;  // 启动看门狗
6

7
// 喂狗(必须周期调用)
8
void feed_watchdog(void) {
9
    IWDG->KR = 0xAAAA;
10
}

1
/* Linux内核模块的加载和卸载？ - 示例实现 */
2
#include <linux/module.h>
3
#include <linux/init.h>
4

5
static int __init my_init(void) {
6
    printk(KERN_INFO "Module loaded\n");
7
    return 0;
8
}
9

10
static void __exit my_exit(void) {
11
    printk(KERN_INFO "Module unloaded\n");
12
}
13

14
module_init(my_init);
15
module_exit(my_exit);
1 collapsed line
16
MODULE_LICENSE("GPL");

1
// copy_to_user / copy_from_user (驱动中常用)
2
static ssize_t my_read(struct file *filp, char __user *buf,
3
                       size_t count, loff_t *pos) {
4
    char kbuf[] = "hello";
5
    if (copy_to_user(buf, kbuf, sizeof(kbuf)))
6
        return -EFAULT;
7
    return sizeof(kbuf);
8
}

1
OOM触发条件: 物理内存+Swap全部用完，无法分配新页
2

3
选择策略(oom_score):
4
  - 内存使用越大，分数越高(越容易被杀)
5
  - 运行时间越短，分数越高
6
  - root进程分数降低
7

8
调整OOM优先级:
9
  echo -1000 > /proc/<pid>/oom_score_adj  # 永远不杀(-1000)
10
  echo 1000 > /proc/<pid>/oom_score_adj   # 优先杀(1000)

1
上电复位
2
  │
3
  ▼
4
BootROM(芯片固化代码)
5
  │ 加载Bootloader
6
  ▼
7
U-Boot(Bootloader)
8
  │ 初始化DDR、加载内核镜像、传递设备树
9
  ▼
10
Linux Kernel
11
  │ 解压→初始化→挂载rootfs→启动init进程
12
  ▼
13
Init进程(systemd/busybox init)
14
  │ 读配置→启动服务→启动shell/应用
15
  ▼
1 collapsed line
16
用户应用程序运行

1
// 设备树基本语法(.dts)
2
/ {
3
    model = "My Board";
4
    compatible = "vendor,board";
5

6
    memory@80000000 {
7
        device_type = "memory";
8
        reg = <0x80000000 0x20000000>;  // 起始地址 大小
9
    };
10

11
    uart0: serial@44e09000 {
12
        compatible = "ti,am335x-uart";
13
        reg = <0x44e09000 0x2000>;
14
        interrupts = <72>;
15
        clock-frequency = <48000000>;
3 collapsed lines
16
        status = "okay";
17
    };
18
};

1
#include <linux/kthread.h>
2

3
static struct task_struct *my_thread;
4

5
static int thread_func(void *data) {
6
    while (!kthread_should_stop()) {
7
        printk("Working...\n");
8
        msleep(1000);
9
    }
10
    return 0;
11
}
12

13
// 创建并启动
14
my_thread = kthread_run(thread_func, NULL, "my_kthread");
15

2 collapsed lines
16
// 停止
17
kthread_stop(my_thread);