Lec 2 用 C 语言编程 Xv6

本讲导览

• C 语言：一门”高级汇编“
• 数据表示
• 内存安全问题
• 指针： 带类型的整数
• 声明、定义 与 static
• 字符串、常用库函数、结构体和位操作
• GDB： 调试内核的手法
• 内存抽象的层次：从总线到堆栈
• 自测清单

本讲定位：用 C 语言编程 Xv6、用 GDB + QEMU 调试。本讲打牢两个工具基础——把 C 当作"高级汇编"来理解内存与指针，并掌握调试内核所需的 GDB 手法；最后从硬件总线一路抽象到栈与堆，建立"内存到底是什么"的层次图景。

0. 本讲脉络

C 作为"高级汇编" ──► 数据表示(端序/范围) ──► 内存三区(栈/堆/静态) ──► 指针(带类型的整数)
        │
        ▼
   GDB 调试内核（断点/单步/查寄存器查内存/TUI）
        │
        ▼
   内存抽象的层次：硬件总线 → 地址空间 → 栈与堆

1. C 语言：一门"高级汇编"

按地址从低到高：

大端序 (big-endian)：0x12, 0x34, 0x56, 0x78（高位字节在低地址）。

小端序 (little-endian)：0x78, 0x56, 0x34, 0x12（低位字节在低地址）。

RISC-V 是小端序。

2.2 三类内存区域

3. 内存安全问题

C 把内存管理交给程序员，于是有一类典型 bug：

• 释放后使用 (use-after-free)：释放后仍访问该内存。
• 重复释放 (double-free)：对同一块释放两次。
• 使用未初始化内存：读到的是残留垃圾值。
• 缓冲区溢出 (buffer overflow)：写越过数组末尾（Lec 22 砸栈攻击的根源）。
• 内存泄漏 (memory leak)：分配后从不释放。
• 类型混淆 (type confusion)：用错误的类型解释同一段字节。

4. 指针：带类型的整数

声明语法（从右向左读）：

int *a;          // 指向 int 的指针
float *b;        // 指向 float 的指针
int **c;         // 指向"int 指针"的指针
char (*d)(int);  // 指向函数 (int -> char) 的指针
char (**e)(int); // 指向"函数指针"的指针
void *f;         // 指向无类型内存的指针
int ******value; // 指针可任意嵌套

4.1 数组与部分初始化

int my_array[6] = {1};
// my_array[0] = 1，其余元素全部被零初始化
// [0] = 1, [3] = 0, [5] = 0

4.2 指针运算会按类型大小缩放

• array[n] 等价于 *(array + n)；&array[n] 等价于 array + n。
• 关键：把整数加到指针上时，整数会隐式乘以所指类型的大小。

int my_array[4];   // 设 &my_array[0] = 0x2FB0
// &my_array[3] == 0x2FBC，比起点大 12 = 3 × sizeof(int)
(long)(my_array + 3) == (long)my_array + 3 * sizeof(int);

int values[5] = {10, 20, 30, 40, 50};
printf("%d\n", 4[values]);  // 打印 50

4.3 指针 ↔ 整数的强制转换

int x[4] = {1, 2, 3, 4};
int *x_ptr   = &x[0];
long x_addr  = (long)x_ptr;          // 指针 → 整数
int *x2_ptr  = (int *)(x_addr + 4);  // 整数(+4 字节) → 指针，指向 &x[1]
int x2_value = x2_ptr[1];            // x2_ptr[1] = x[2] = 3
// x2_value == 3

4.4 void 与指针大小

• void 表示"没有数据类型"，主要用于函数返回值/参数；不能定义 void 变量。
• 可以定义 void *，但不能解引用、不能做指针算术（不知道步长）。
• 指针大小依平台而定；本课的 RISC-V 是 64 位指针，与 long 同宽。

int x[5];                  // 设 x 位于 0x...7f00
printf("%p\n", x);    // 0x...7f00  —— 数组退化为首元素指针
printf("%p\n", x+1);  // 0x...7f04  —— +1 个 int = +4 字节
printf("%p\n", &x);   // 0x...7f00  —— 地址值相同，但类型是 int(*)[5]
printf("%p\n", &x+1); // 0x...7f14  —— +1 个"整个数组" = +20 字节(0x14)

5. 声明、定义与 static

int add_cumulative_numbers(int increase) {
    static int total_sum = 0;   // 启动时初始化为 0，之后跨调用累加
    total_sum += increase;
    return total_sum;
}

my_int |=  1 << N;            // 置第 N 位
my_int &= ~(1 << N);          // 清第 N 位
if (my_int & MASK)            // MASK 中有任一位被置
if ((my_int & MASK) == MASK)  // MASK 中所有位都被置
if (my_int && !(my_int & (my_int - 1)))  // 判断是否 2 的幂

四个递进的想法：

1. 地址空间可以有空洞：能访问的地址称"已映射 (mapped)"，访问不到的"未映射 (unmapped)"；地址空间通常远大于物理 RAM。
2. 地址带权限：读（R，可 load）/ 写（W，可 store）/ 执行（X，可作为代码）。无权限访问会触发异常——这是隔离与安全的基石。
3. 统一 RAM 与设备：把 I/O 设备寄存器也放进地址空间（内存映射 I/O），用 load/store 即可操作设备。"代码和数据同为内存"即冯·诺依曼架构 (von Neumann)。（注：x86 早期把 I/O 放在独立地址空间。）映射粒度通常是一个页 (page, 4KB) 而非一字节。
4. 虚拟内存 + 缓存一致性：让每个进程拥有独立地址空间；让多 CPU 共享同一地址空间（Lec 5 展开）。

8.3 编译器 / 库层：栈与堆

地址空间仍太底层——"数据放数组哪个位置"这个内存分配 (memory allocation) 问题，有两种基本答案：

9. 自测清单

• C 相对 Python 的 5 点差异？"静态类型"中类型绑定到变量还是值？
• 0x12345678 在小端/大端下的字节序列？RISC-V 是哪种？
• 栈/堆/静态三区的分配方式与默认初始化各是什么？
• 6 类内存安全 bug 分别是什么？
• 为什么 (int)p+1 与 (int)(p+1) 结果不同？x+1 与 &x+1 差多少字节？
• static 局部变量的生命周期与初始化行为？
• memcpy 与 memmove 的区别？为何优先 memmove？
• 地址空间的 4 个递进想法（空洞/权限/统一 I/O/虚拟内存）。
• 何时该用堆而非栈？列出至少 5 个内存管理陷阱。