Linux Kernel on Yuanye Ma's Blog

如何获取跨系统调用的函数调用栈

yuanye.ma@qq.com (Yuanye Ma) — Wed, 10 Dec 2025 10:50:18 +0800

在进行功能调试或者问题定位时，经常需要找一下哪里触发的系统调用，并跟踪一下系统调用过程。

一种方法是使用simpleperf ：

simpleperf record -g -o <path_to_perf.data> -- <path_to_exe_with_debuginfo>
python3 <path-to-ndk>/android-ndk-r27c/simpleperf/gecko_profile_generator.py \
 -i <path_to_perf.data> \
 --symfs <path_to_symbols> \
 --kallsyms <path_to_System.map> | gzip > <path_to_perf.json.gz>

浏览器打开https://profiler.firefox.com/将生成的add_client.perf.json.gz拖进去，就可以查看调用树、火焰图、栈图等进一步分析函数调用关系。

参考另一篇文章尝试通过一个demo分析binder的执行流程的使用simpleperf抓取通讯双方的函数调用栈小节

或者使用基于eBPF的工具比如stackplz 参考：https://github.com/SeeFlowerX/stackplz

这两种方式在尝试定位某些问题时比较受限，比如kernel启动早期时。因此本文尝试一种更加直接的方式：直接在目标位置打印函数调用栈。

获取用户态和内核态的函数调用栈

首先确保 CONFIG_STACKTRACE CONFIG_KALLSYMS和CONFIG_USER_STACKTRACE_SUPPORT内核宏打开

可以通过 zcat /proc/config.gz | grep -E "STACKTRACE|KALLSYMS" 确认。

在代码中插入以下代码：

#if IS_ENABLED(CONFIG_STACKTRACE)
#include <linux/stacktrace.h>
#define STACK_ENTRIES 64

/*
 * 打印当前进程的
 * 1) 内核调用栈（符号名）
 * 2) 用户空间调用栈（原始 PC 地址）
 */
static void dump_all_stacks(void)
{
 int i;
 unsigned int nr;
 unsigned long entries[STACK_ENTRIES];

 /* 基本进程信息 */
 pr_info("pid=%d comm=%s\n",
 current->pid, current->comm);

 memset(entries, 0, sizeof(entries));
 nr = stack_trace_save(entries, ARRAY_SIZE(entries), 0);

 pr_info("kernel backtrace:\n");
 for (i = 0; i < nr; i++) {
 /* %pS 依赖 CONFIG_KALLSYMS，可以打印出符号名 */
 pr_info(" [k%02d] %pS\n", i, (void *)entries[i]);
 }

#if IS_ENABLED(CONFIG_USER_STACKTRACE_SUPPORT)
 /* -------- 用户空间调用栈 -------- */
 memset(entries, 0, sizeof(entries));

 /*
 * 注意：save_stack_trace_user() 只能对 current 生效，
 * 会保存从用户态进入内核时的那一组返回地址。
 */
 nr = stack_trace_save_user(entries, ARRAY_SIZE(entries));

 pr_info("user backtrace (raw user PCs):\n");
 for (i = 0; i < nr; i++) {
 /*
 * 这些是用户虚拟地址，需要 offline 用 addr2line 等工具
 * 结合 /proc/<pid>/maps 的映射基址还原成具体函数名/行号。
 */
 pr_info(" [u%02d] 0x%016lx\n", i, entries[i]);
 }
#else
 pr_info("user stack trace not supported "
 "(CONFIG_USER_STACKTRACE_SUPPORT is disabled)\n");
#endif /* CONFIG_USER_STACKTRACE_SUPPORT */
}
#else
static inline void dump_all_stacks(void) {}
#endif /* CONFIG_STACKTRACE */

可以在目标位置插入调用dump_all_stacks()。抓内核日志。

解析用户态调用栈

准备了一个python脚本来解析用户态的堆栈，该脚本会计算堆栈中地址相对于符号文件的偏移，并用addr2line尝试解析符号。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
binder_user_stack_resolver.py

用法示例：

1) 先把内核日志导出来：
 adb shell dmesg | grep binder_open > binder.log

2) 把 /proc/<pid>/maps 导出来：
 adb shell cat /proc/1234/maps > maps_1234.txt

3) 在宿主机上执行（假设已提取 system 映像到 /path/to/symbols）：

 python3 binder_user_stack_resolver.py \
 --pid 1234 \
 --log binder.log \
 --maps maps_1234.txt \
 --sym-root /path/to/symbols \
 --addr2line aarch64-linux-android-addr2line

说明：
- sym-root 目录下应当能找到类似 /system/bin/surfaceflinger 这样的路径
 （例如解包 system.img 后的根目录）
- addr2line 可以是 aarch64-linux-android-addr2line 或 llvm-addr2line 等
"""

import argparse
import os
import re
import subprocess
import sys
from typing import List, Tuple, Dict, Optional


class MapEntry:
 def __init__(self, start: int, end: int, offset: int, path: str):
 self.start = start
 self.end = end
 self.offset = offset
 self.path = path

 def contains(self, addr: int) -> bool:
 return self.start <= addr < self.end

 def file_offset(self, addr: int) -> int:
 """
 计算 addr 在 ELF 文件内的偏移：
 file_off = (addr - start_vma) + file_offset_column
 """
 return (addr - self.start) + self.offset


def parse_maps(maps_path: str) -> List[MapEntry]:
 entries: List[MapEntry] = []
 with open(maps_path, "r", encoding="utf-8", errors="ignore") as f:
 for line in f:
 line = line.strip()
 if not line:
 continue
 # 形如：
 # start-end perms offset dev inode pathname
 # 0000007f8a100000-0000007f8a200000 r-xp 00000000 08:01 123456 /system/bin/surfaceflinger
 parts = line.split()
 if len(parts) < 5:
 continue

 addr_range = parts[0]
 perms = parts[1]
 offset_str = parts[2]
 path = parts[5] if len(parts) >= 6 else ""

 # 只关心可执行映射
 if "x" not in perms:
 continue

 try:
 start_str, end_str = addr_range.split("-")
 start = int(start_str, 16)
 end = int(end_str, 16)
 offset = int(offset_str, 16)
 except ValueError:
 continue

 if not path or path == "[vdso]" or path.startswith('['):
 continue

 entries.append(MapEntry(start, end, offset, path))
 return entries


def find_mapping(maps: List[MapEntry], addr: int) -> Optional[MapEntry]:
 for m in maps:
 if m.contains(addr):
 return m
 return None


def resolve_addr(addr: int, maps: List[MapEntry], sym_root: str, addr2line_bin: str) -> str:
 m = find_mapping(maps, addr)
 if not m:
 return f"0x{addr:016x} <no mapping>"

 file_off = m.file_offset(addr)

 # 把 /system/bin/surfaceflinger 这种路径映射到 sym_root/system/bin/surfaceflinger
 rel_path = m.path.lstrip("/") # 去掉开头的 '/'
 elf_path = os.path.join(sym_root, rel_path)

 if not os.path.exists(elf_path):
 return f"0x{addr:016x} {m.path}+0x{file_off:x} (ELF not found: {elf_path})"

 cmd = [addr2line_bin, "-C", "-f", "-e", elf_path, f"0x{file_off:x}"]
 try:
 out = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
 decoded = out.decode("utf-8", errors="ignore").strip().splitlines()
 if len(decoded) >= 2:
 func = decoded[0]
 loc = decoded[1]
 return f"0x{addr:016x} {m.path}+0x{file_off:x} => {func} @ {loc}"
 elif decoded:
 return f"0x{addr:016x} {m.path}+0x{file_off:x} => {decoded[0]}"
 else:
 return f"0x{addr:016x} {m.path}+0x{file_off:x} (no addr2line output)"
 except subprocess.CalledProcessError as e:
 return f"0x{addr:016x} {m.path}+0x{file_off:x} (addr2line error: {e})"


def parse_log_for_pid(log_path: str, pid: int) -> List[int]:
 """
 从 binder log 中抽取指定 pid 的 [uXX] 行的地址
 """
 addrs: List[int] = []
 current_pid: Optional[int] = None
 in_user_bt = False

 pid_line_re = re.compile(r"binder_open:\s+pid=(\d+)\s+comm=")
 user_bt_re = re.compile(r"binder_open:\s+user backtrace")
 addr_re = re.compile(r"\[u\d+\]\s+0x([0-9a-fA-F]+)")

 with open(log_path, "r", encoding="utf-8", errors="ignore") as f:
 for line in f:
 line = line.rstrip("\n")

 m = pid_line_re.search(line)
 if m:
 current_pid = int(m.group(1))
 in_user_bt = False
 continue

 if current_pid == pid and user_bt_re.search(line):
 in_user_bt = True
 continue

 if in_user_bt and current_pid == pid:
 m2 = addr_re.search(line)
 if m2:
 addr_str = m2.group(1)
 addr = int(addr_str, 16)
 addrs.append(addr)
 else:
 # 遇到不是 [uXX] 的行，认为本次 user backtrace 结束
 if line.strip() == "" or line.startswith("binder_open:"):
 in_user_bt = False

 return addrs


def main():
 parser = argparse.ArgumentParser(description="Resolve SurfaceFlinger binder_open user stacks")
 parser.add_argument("--pid", type=int, required=True, help="surfaceflinger 的 pid")
 parser.add_argument("--log", required=True, help="包含 binder_open 打印的 log 文件")
 parser.add_argument("--maps", required=True, help="/proc/<pid>/maps 导出的文件路径")
 parser.add_argument("--sym-root", required=True, help="带符号 system/so/root 的根目录")
 parser.add_argument("--addr2line", default="addr2line",
 help="addr2line 可执行文件名（默认: addr2line，可改为 aarch64-linux-android-addr2line）")

 args = parser.parse_args()

 maps = parse_maps(args.maps)
 if not maps:
 print("ERROR: no executable mappings parsed from maps file", file=sys.stderr)
 sys.exit(1)

 addrs = parse_log_for_pid(args.log, args.pid)
 if not addrs:
 print(f"ERROR: no user backtrace addresses found in log for pid={args.pid}", file=sys.stderr)
 sys.exit(1)

 print(f"# binder_open user stack for pid={args.pid}")
 for addr in addrs:
 resolved = resolve_addr(addr, maps, args.sym_root, args.addr2line)
 print(resolved)


if __name__ == "__main__":
 main()

解析示例

原理分析

1. 发生系统调用时保存现场

以用户空间执行 open("/dev/binder") 的系统调用为例，指令是： svc #0

CPU 硬件做的事情:

当 EL0 执行 svc #imm：
CPU 切换异常级：EL0 → EL1；
用户 PSTATE 保存到 SPSR_EL1
用户 PC（svc 下一条指令地址）保存到 ELR_EL1
使用异常向量表中 EL0 同步异常的入口地址（VBAR_EL1 指向的一张表）：
跳转到 el0_sync（或类似名字）的入口
切换栈指针：
使用 SP_EL1 作为栈指针（这时已经是内核栈）
SP_EL0 保留的是用户态栈，暂时不会动

注意：此时 x0–x30 里的值仍然是用户态的寄存器值，CPU 没帮你保存到内存，必须靠内核汇编自己存。

arch/arm64/kernel/head.S
__HEAD
 primary_entry
 __primary_switched
 adr_l x8, vectors // load VBAR_EL1 with virtual
 msr vbar_el1, x8 // vector table address

将vectors填入vbar_el1寄存器中，其中vectors是一个全局标记：

 arch/arm64/kernel/entry.S
 /*
 * Exception vectors.
 */
 .pushsection &#34;.entry.text&#34;, &#34;ax&#34;

 .align 11
 SYM_CODE_START(vectors)
 kernel_ventry 0, t, 64, sync // Synchronous 64-bit EL0
 SYM_CODE_END(vectors)

vectors处通过kernel_ventry定义了多个入口:

 .macro kernel_ventry, el:req, ht:req, regsize:req, label:req
 .align 7
 sub sp, sp, #PT_REGS_SIZE
 b el\el\ht\()_\regsize\()_\label

先预留PT_REGS_SIZE大小的栈空间，然后跳转到el0t_64_sync处执行

 SYM_CODE_START_LOCAL(el\el\ht\()_\regsize\()_\label)
 kernel_entry \el, \regsize
 mov x0, sp
 bl el\el\ht\()_\regsize\()_\label\()_handler
 .if \el == 0
 b ret_to_user
 .else
 b ret_to_kernel
 .endif
 SYM_CODE_END(el\el\ht\()_\regsize\()_\label)
 .endm

kernel_entry \el, \regsize宏处保存寄存器信息到内核栈中

 .macro kernel_entry, el, regsize = 64
 stp x0, x1, [sp, #16 * 0]
 stp x2, x3, [sp, #16 * 1]
 stp x4, x5, [sp, #16 * 2]
 stp x6, x7, [sp, #16 * 3]
 stp x8, x9, [sp, #16 * 4]
 stp x10, x11, [sp, #16 * 5]
 stp x12, x13, [sp, #16 * 6]
 stp x14, x15, [sp, #16 * 7]
 stp x16, x17, [sp, #16 * 8]
 stp x18, x19, [sp, #16 * 9]
 stp x20, x21, [sp, #16 * 10]
 stp x22, x23, [sp, #16 * 11]
 stp x24, x25, [sp, #16 * 12]
 stp x26, x27, [sp, #16 * 13]
 stp x28, x29, [sp, #16 * 14]

 .if \el == 0
 clear_gp_regs
 mrs x21, sp_el0
 ldr_this_cpu tsk, __entry_task, x20
 msr sp_el0, tsk
 .else
 add x21, sp, #PT_REGS_SIZE
 get_current_task tsk
 .endif /* \el == 0 */
 mrs x22, elr_el1
 mrs x23, spsr_el1
 stp lr, x21, [sp, #S_LR]

 /*
 * For exceptions from EL0, create a final frame record.
 * For exceptions from EL1, create a synthetic frame record so the
 * interrupted code shows up in the backtrace.
 */
 .if \el == 0
 stp xzr, xzr, [sp, #S_STACKFRAME] // pt_regs 区域里写一个终止 frame record（FP、LR = 0），方便 unwinder 知道到头了。
 .else
 stp x29, x22, [sp, #S_STACKFRAME]
 .endif
 add x29, sp, #S_STACKFRAME

之后栈布局如下

低地址
+-------------------------+
| struct thread_info | <-- 与 task_struct 关联
+-------------------------+
| |
| 内核栈空间 | <-- 内核函数调用使用的栈
| |
| ... (正常内核栈帧) |
| |
+-------------------------+ <-- THREAD_SIZE 对齐的栈顶
| struct pt_regs | <-- 从用户态陷入时压入的寄存器快照
+-------------------------+
高地址

2. stack_trace的实现

#ifdef CONFIG_USER_STACKTRACE_SUPPORT
/**
 * stack_trace_save_user - Save a user space stack trace into a storage array
 * @store: Pointer to storage array
 * @size: Size of the storage array
 *
 * Return: Number of trace entries stored.
 */
unsigned int stack_trace_save_user(unsigned long *store, unsigned int size)
{
 stack_trace_consume_fn consume_entry = stack_trace_consume_entry;//函数指针
 struct stacktrace_cookie c = {
 .store = store,
 .size = size,
 };

 /* Trace user stack if not a kernel thread */
 if (current->flags & PF_KTHREAD)
 return 0;

 arch_stack_walk_user(consume_entry, &c, task_pt_regs(current));

 return c.len;
}
#endif

arch_stack_walk_user是一个架构相关的函数，定义在arch/arm64/kernel/stacktrace.c中：

void arch_stack_walk_user(stack_trace_consume_fn consume_entry, void *cookie,
 const struct pt_regs *regs)
{
 if (!consume_entry(cookie, regs->pc))
 return;

 if (!compat_user_mode(regs)) {
 /* AARCH64 mode */
 struct frame_tail __user *tail;

 tail = (struct frame_tail __user *)regs->regs[29];
 while (tail && !((unsigned long)tail & 0x7))
 tail = unwind_user_frame(tail, cookie, consume_entry);
 } else {
 /* ...... */
 }
}

task_pt_regs(current)

1
2

#define task_pt_regs(p) \
 ((struct pt_regs *)(THREAD_SIZE + task_stack_page(p)) - 1)

/*
 * When accessing the stack of a non-current task that might exit, use
 * try_get_task_stack() instead. task_stack_page will return a pointer
 * that could get freed out from under you.
 */
static __always_inline void *task_stack_page(const struct task_struct *task)
{
 return task->stack;
}

其中THREAD_SIZE 是内核栈的大小，task_stack_page拿到的是栈的地址。因此task_pt_regs(current)拿到的就是当前进程内核栈上保存的中断线程，然后 arch_stack_walk_user从中找到x29寄存器，并依次去找lr指针和fp指针，就可以抓到用户态的调用栈。

在本地复现syzbot Bugs

yuanye.ma@qq.com (Yuanye Ma) — Mon, 28 Jul 2025 10:50:18 +0800

在本地复现syzbot Bugs

本文按照以下文章内容，尝试复现一个syzbot报告的bug。

https://www.linkedin.com/pulse/proof-execution-reproducing-syzbot-bugs-local-kernel-moon-hee-lee-081bc/?trackingId=ueW806vHTCSaYeZf%2Bgzfrg%3D%3D

Step One: Choose a syzbot Report with an Upstream Fix

挑选满足以下三个条件的bug report：

有可复现的c reproducer;
有配套的bzImage, vmlinux, 和disk.raw ；
已经被修复，patch已经被合入上游分支；

https://syzkaller.appspot.com/upstream上罗列了好几千的bugs，但是本文从那些被修复的入手，选择 Fiexed 标签，查看那些已确认、已解决并已关闭的 Bug。为了尽可能贴近当前主线，点一下 Reported 使得列表按报告日期升序排列，优先显示最近的 Bug。

以下边这个为例子： https://syzkaller.appspot.com/bug?extid=3f89ec3d1d0842e95d50

该问题相关的config文件以及测试信息已经在syzbot的报告邮件中，此外该问提的讨论过程在邮件列表中：https://lore.kernel.org/all/686d5a9f.050a0220.1ffab7.0017.GAE@google.com/T/

并且修复patch已经合入上游分支：https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=4c4ca3c46167518f8534ed70f6e3b4bf86c4d158

Step Two: Set Up the Local Workspace

mkdir -p ~/syz/usbnet_status_start
cd ~/syz/usbnet_status_start

# C reproducer
wget -O repro.c https://syzkaller.appspot.com/x/repro.c?x=14c9abd4580000

# Kernel config
wget -O .config https://syzkaller.appspot.com/x/.config?x=28729dff5d03ad1

# Optional: syzkaller binary reproducer
wget -O repro.syz https://syzkaller.appspot.com/x/repro.syz?x=11680a8c580000

# bzImage
wget https://storage.googleapis.com/syzbot-assets/4b24078bc227/bzImage-d1b07cc0.xz

# vmlinux (used for debugging and symbol resolution)
wget https://storage.googleapis.com/syzbot-assets/934d59614ed5/vmlinux-d1b07cc0.xz

# Disk image
wget https://storage.googleapis.com/syzbot-assets/3eab0cb43ae2/disk-d1b07cc0.raw.xz

# 解压
xz -d ./bzImage-d1b07cc0.xz ./disk-d1b07cc0.raw.xz ./vmlinux-d1b07cc0.xz

# 最终的工作空间目录结构如下
tree -a
.
├── bzImage-d1b07cc0
├── .config
├── disk-d1b07cc0.raw
├── repro.c
├── repro.syz
└── vmlinux-d1b07cc0

1 directory, 6 files

Step Three: Boot the syzbot Kernel in QEMU

sudo apt install qemu-system-x86

qemu-system-x86_64 \
 -m 2048 \
 -smp 2 \
 -machine q35,accel=kvm \
 -cpu host \
 -kernel bzImage-d1b07cc0 \
 -append "root=/dev/sda1 console=ttyS0" \
 -drive file=disk-d1b07cc0.raw,format=raw \
 -nographic \
 -enable-kvm \
 -netdev user,id=net0,hostfwd=tcp::10022-:22 \
 -device e1000,netdev=net0

参数	解释
qemu-system-x86_64	启动一个x86_64的模拟器
-m 2048	分配2GB内存
-smp 2	分配2个CPU核心
-machine q35,accel=kvm	使用 Q35芯片组（较新的 Intel 芯片组，支持 PCIe 设备等现代硬件）accel=kvm：启用 KVM（内核虚拟化模块）加速，依赖主机支持 VT-x/AMD-V
-cpu host	使用主机的 CPU 配置（即暴露主机 CPU 的全部指令集特性给虚拟机），比如 AVX、SSE 等。
-kernel bzImage-b56bbaf8	指定一个已编译好的 Linux 内核镜像文件
-append “root=/dev/sda1 console=ttyS0”	给内核传递启动参数：root=/dev/sda1：告诉内核，根文件系统位于 /dev/sda1，也就是第一个硬盘的第一个分区。console=ttyS0：将控制台绑定到串口 ttyS0，这是为了搭配 -nographic 让你可以通过终端看到内核输出。
-drive file=disk-b56bbaf8.raw,format=raw	挂载一个原始格式（raw）的虚拟硬盘文件，默认.raw 磁盘镜像是可写的。也就是说，虚拟机内部所做的任何修改在重启后都会被保留。如果希望每次测试都从干净的状态开始，可以通过在 -drive 参数中添加`snapshot=on` 来启用快照模式，这会让虚拟机运行在一个临时的覆盖层（overlay）上，所有更改在关机后都会被丢弃。使用这个选项可以确保每次测试运行都是干净、可复现的。
-nographic	不使用图形界面，所有输入输出都通过终端（命令行）进行
-enable-kvm	启用 KVM硬件虚拟化加速（和 -machine accel=kvm 作用类似，通常两者一起写以防兼容性问题）。
-netdev user,id=net0,hostfwd=tcp::10022-:22	使用 QEMU 的用户模式网络（user mode networking）。id=net0 给该网络接口一个 ID 名称。hostfwd=tcp::10022-:22 实现端口转发：把主机的 10022端口映射到虚拟机的 22端口，即虚拟机的SSH服务。
-device e1000,netdev=net0	使用 e1000 模拟一个 Intel E1000 网卡（兼容性较好）。把它连接到上面定义的 net0 网络设备。

由于我本身就是在一个虚拟机中运行ubuntu，因此硬件加速相关的参数都不能用：

qemu-system-x86_64 \
 -m 2048 \
 -smp 2 \
 -machine q35 \
 -cpu qemu64 \
 -kernel bzImage-d1b07cc0 \
 -append "root=/dev/sda1 console=ttyS0" \
 -drive file=disk-d1b07cc0.raw,format=raw,snapshot=on \
 -nographic \
 -netdev user,id=net0,hostfwd=tcp::10022-:22 \
 -device e1000,netdev=net0

启动成功，登录用户名：root 无密码

Step Four: Run the Reproducer in the Original Image

Syzkaller 的报告通常会提供两种类型的复现程序（reproducer）：

一个 C 源码文件（repro.c）
一个二进制格式的程序（repro.syz），用于在 syz-execprog 下运行。

如果两者都提供了，建议优先使用 C 版本，因为它通常更容易阅读、运行和调试。

使用复现器

编译 syz-execprog 和 syz-executor

git clone https://github.com/google/syzkaller.git
cd syzkaller
sudo apt install golang-go
make TARGETOS=linux TARGETARCH=amd64

将复现程序拷贝进qemu模拟器

cp bin/linux_amd64/syz-execprog ~/syz/usbnet_status_start/assets/
cp bin/linux_amd64/syz-executor ~/syz/usbnet_status_start/assets/

scp -P 10022 \
 -o UserKnownHostsFile=/dev/null \
 -o StrictHostKeyChecking=no \
 ~/syz/usbnet_status_start/assets/syz-execprog \
 ~/syz/usbnet_status_start/assets/syz-executor \
 ~/syz/usbnet_status_start/assets/repro \
 ~/syz/usbnet_status_start/assets/repro.syz \
 root@127.0.0.1:/root/

使用复现器复现问题：

`1`	`./syz-execprog -enable=all -repeat=0 -procs=6 ./repro.syz`

这将调用与 syzkaller 构造的完全相同的系统调用序列。如果内核漏洞仍然存在，那么崩溃或相应的警告信息应该会出现在控制台上。这说明复现程序仍然有效，并且测试环境配置是正确的。

编译复现程序

另外，也可以直接运行编译后的 C 程序：

1
2

gcc -static -O2 -o repro repro.c
./repro

这种方式避开了 syzkaller 的运行时环境，通常在调试时更加简单。

由于我本地的ubuntu虚拟机是aarch64架构的，编译x86_64的目标程序需要交叉编译

1
2

sudo apt update
sudo apt install gcc-x86-64-linux-gnu g++-x86-64-linux-gnu

随便写个c程序试试

#include <stdio.h>
int main() {
 printf("Hello from x86_64!\n");
 return 0;
}

编译一下试试

x86_64-linux-gnu-gcc -static hello.c -o hello_x86_64

file hello_x86_64
hello_x86_64: ELF 64-bit LSB executable, x86-64, version 1 (GNU/Linux), statically linked, BuildID[sha1]=829d19ddb1083607e695354fb0d8b47792aa80b6, for GNU/Linux 3.2.0, not stripped

# 也可以用clang编译
sudo apt install clang
clang --target=x86_64-linux-gnu hello.c -o hello_x86_64

看起来没问题，用qemu-user模式运行一下试试

1
2

sudo apt install qemu-user
qemu-x86_64 ./hello_x86_64

测试没问题，用交叉编译的方式编译repro.c

x86_64-linux-gnu-gcc -static -O2 -o repro repro.c
# 将编译产物拷贝到模拟器中
scp -P 10022 \
 -o UserKnownHostsFile=/dev/null \
 -o StrictHostKeyChecking=no \
 ~/syz/usbnet_status_start/repro \
 root@127.0.0.1:/root/

Step Five: Build the Matching Kernel Locally

# syzbot报告问题的邮件中：git tree: https://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb.git usb-testing
git clone https://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb.git usb-testing
cd usb-testing
# syzbot报告问题的邮件中 HEAD commit: d1b07cc0868f arm64: dts: s32g: Add USB device tree informa..
git checkout d1b07cc0868f

# 先安装编译内核必要的依赖
sudo apt install libelf-dev libdw-dev

cp ~/syz/usbnet_status_start/.config .
make ARCH=x86_64 CROSS_COMPILE=x86_64-linux-gnu- olddefconfig
make ARCH=x86_64 CROSS_COMPILE=x86_64-linux-gnu- -j$(nproc)

# 编译报错的时候也可以用以下命令保存更多的编译日志方便排错
make V=1 ARCH=x86_64 CROSS_COMPILE=x86_64-linux-gnu- -j$(nproc) 2>&1 | tee build.log

Step Six: Run the Reproducer on the Locally Built Kernel

qemu-system-x86_64 \
 -m 2048 \
 -smp 2 \
 -machine q35 \
 -cpu qemu64 \
 -kernel ~/usb-testing/arch/x86_64/boot/bzImage \
 -append "root=/dev/sda1 console=ttyS0" \
 -drive file=disk-d1b07cc0.raw,format=raw,snapshot=on \
 -nographic \
 -netdev user,id=net0,hostfwd=tcp::10022-:22 \
 -device e1000,netdev=net0

拷贝编译后的复现程序repro

scp -P 10022
 -o UserKnownHostsFile=/dev/null
 -o StrictHostKeyChecking=no
 ~/syz/usbnet_status_start/repro
 root@127.0.0.1:/root/

使用复现器

拷贝复现器

scp -P 10022 \
 -o UserKnownHostsFile=/dev/null \
 -o StrictHostKeyChecking=no \
 ~/syz/usbnet_status_start//assets/syz-execprog \
 ~/syz/usbnet_status_start/assets/syz-executor \
 ~/syz/usbnet_status_start/assets/repro.syz \
 root@127.0.0.1:/root/

执行复现器

ssh -p 10022 \
 -o UserKnownHostsFile=/dev/null \
 -o StrictHostKeyChecking=no \
 root@127.0.0.1 \
 './syz-execprog -enable=all -repeat=0 -procs=6 ./repro.syz'

Step Seven: Apply the Patch and Rebuild

尝试下载并应用以下patch

# 下载patch
wget -O patch.diff https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/patch/\?id\=4c4ca3c46167518f8534ed70f6e3b4bf86c4d158

# 应用patch
cd ~/usb-testing
git am ~/syz/usbnet_status_start/patch.diff

# 编译内核
cp ~/syz/usbnet_status_start/.config .
make ARCH=x86_64 CROSS_COMPILE=x86_64-linux-gnu- olddefconfig
make V=1 ARCH=x86_64 CROSS_COMPILE=x86_64-linux-gnu- -j$(nproc) 2>&1 | tee build.log

# 启动模拟器
qemu-system-x86_64 \
 -m 2048 \
 -smp 2 \
 -machine q35 \
 -cpu qemu64 \
 -kernel ~/usb-testing/arch/x86_64/boot/bzImage \
 -append "root=/dev/sda1 console=ttyS0" \
 -drive file=disk-d1b07cc0.raw,format=raw,snapshot=on \
 -nographic \
 -netdev user,id=net0,hostfwd=tcp::10022-:22 \
 -device e1000,netdev=net0

# 拷贝复现程序 
scp -P 10022 \
 -o UserKnownHostsFile=/dev/null \
 -o StrictHostKeyChecking=no \
 ~/syz/usbnet_status_start/repro \
 root@127.0.0.1:/root/

# 执行复现程序 
./repro

不会再出现内核崩溃日志：

总结

本文主要根据Moon Hee Lee的Proof by Execution: Reproducing syzbot Bugs in a Local Kernel尝试复现syzbot发现的bug，并应用上游patch解决对应的问题。熟悉整个流程，为以后跟进上游bugfix做基础准备。

第一次尝试向Linux Kernel提交Patch

yuanye.ma@qq.com (Yuanye Ma) — Sun, 22 Jun 2025 10:50:18 +0800

第一次提交内核patch尝试

虽然很早就对linux kernel的开发流程比较熟悉了，但是一直没有尝试过向内核社区贡献 patch , 最近看到一个内核开发者写的A Kernel Developer`s Notes专栏文章，介绍了自己对内核理解、跟踪学习内核 patch 流程，以及复现内核 bug 、提交 patch 的流程等等，写的很好，很有可操作性。因此也想跟着学习一番。
本文是阅读以下文章后的尝试： https://www.linkedin.com/pulse/fixing-one-line-learning-whole-process-moon-hee-lee-uu0cc/?trackingId=wxTo5KYjT5KhL8zO9ZXqIw%3D%3D

准备内核

sudo apt install git

git clone git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
cd linux/

sudo apt install make llvm lld clang flex bison libssl-dev # 编译的时候缺什么就装什么

make O=llvm-build LLVM=1 defconfig
make O=llvm-build LLVM=1 -j$(nproc)

准备patch

make htmldocs
# 会提醒缺少依赖，全部安装一下
sudo apt-get install imagemagick graphviz dvipng python3-venv gcc latexmk librsvg2-bin texlive-lang-chinese texlive-xetex python3-sphinx
# 会发现有很多报错，也可以研究一下，fix掉，提patch

sudo apt install codespell
find Documentation/ -path Documentation/translations -prune -o -name '*.rst' -print | xargs codespell
# 会发现有很多报错，可以尝试找几个简单的尝试修复一下 

git commit -s
git format-patch -1
scripts/checkpatch.pl ./0001-docs-f2fs-fix-typos-in-f2fs.rst.patch

生成gmail的应用专用密码

Google账号→ 安全性 → 您的账号登录选项 → 两部验证 → 应用专用密码 → 输入应用名字后点创建 → 保存好密码后点完成

设置git-email的smtp服务

sudo apt install git-email
vim ~/.gitconfig

[user]
 email = xxxx@gmail.com
 name = xxxx
[core]
 editor = vim
[sendemail]
 smtpserver = smtp.gmail.com
 smtpserverport = 587
 smtpencryption = tls
 smtpuser = xxxx@gmail.com
 smtpPass = passwd

端口号在https://support.google.com/mail/answer/7104828?hl=zh-Hans&sjid=11981818515342586304-NC

发送patch

1
2

# 查找收件人
./scripts/get_maintainer.pl xxxxx.patch

这么多收件人，哪些应该是 --to 哪些应该是 --cc ？看看 ChatGPT 怎么说：

# 发送patch 
git send-email \
--to=jaegeuk@kernel.org \
--to=chao@kernel.org \
--to=linux-f2fs-devel@lists.sourceforge.net \
--cc=corbet@lwn.net \
--cc=linux-doc@vger.kernel.org \
--cc=linux-kernel@vger.kernel.org \
0001-docs-f2fs-fix-typos-in-f2fs.rst.patch

记得 --cc=xxxx@gmail.com 抄送自己的邮箱

Kernel Mail List : https://lore.kernel.org/all/20250618225546.104949-1-yuanye.ma20@gmail.com/T/#t

patch被接受

过了两天，收到了 patch 被接受的邮件：

https://lore.kernel.org/all/877c14dfa5.fsf@trenco.lwn.net/

patch 被合入上游仓库

patch先被合入了next tree : https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git/commit/?id=0242b8b0cc89599b3e4162add672179ce2dd4131 还需要等待patch进入上游仓库。

总结

整个过程并不复杂，重要的是要去做，只有做了才知道哪里理解的不到位，才能进一步去改进。

此外，patch 的 commitmsg 很重要，patch 并不只是提交代码，更重要的是和社区的其他开发者们交流/协作，因此要认真对待，不仅要写清楚“改了什么”，更要说明“为什么改”，以及“怎么发现的”。

补丁不仅仅是一个改动，它是一份贡献 —— 而它必须是自洽、独立成立的。这也包括说明问题是如何被发现的，以及为什么这个修复是合理的。尤其是对于新贡献者来说，这比 diff 的大小更重要。这不仅仅是“提交补丁”，更是在帮助他人理解这个改动为什么正确。
一个合格的 commit message 不只是描述“改了什么”，更要说明“为什么改”，以及“怎么发现的”。

linux kernel slab系统

yuanye.ma@qq.com (Yuanye Ma) — Sun, 01 Nov 2020 16:01:23 +0800

linux kernel slab系统

基于linux kernel v2.6.30.4

基本原理

以字节为单位的内存管理 SLAB 为了提高内核中一些十分频繁进行分配释放的“对象”的分配效率， SLAB 的做法是：每次释放掉某个对象之后，不是立即将其返回给伙伴系统，而是存放在一个叫 array_cache 的结构中，下次要分配的时候就可以直接从这里分配，从而加快了速度。

slab系统的内存区域主要分为专用和通用，专用指的是用于存放数据结构的，通用主要指kmalloc用于通用目的而分配的内存。

概念以及数据结构

`struct kmem_cache`

“高速缓存” 其实是一个管理slab的结构

/*
 * DEBUG - 1 for kmem_cache_create() to honour; SLAB_RED_ZONE & SLAB_POISON.
 * 0 for faster, smaller code (especially in the critical paths).
 *
 * STATS - 1 to collect stats for /proc/slabinfo.
 * 0 for faster, smaller code (especially in the critical paths).
 *
 * FORCED_DEBUG - 1 enables SLAB_RED_ZONE and SLAB_POISON (if possible)
 */

/*
 * struct kmem_cache
 *
 * manages a cache.
 */

struct kmem_cache {
/* 1) per-cpu data, touched during every alloc/free */
 struct array_cache *array[NR_CPUS];
/* 2) Cache tunables. Protected by cache_chain_mutex */
 unsigned int batchcount;
 unsigned int limit;
 unsigned int shared;

 unsigned int buffer_size;
 u32 reciprocal_buffer_size;
/* 3) touched by every alloc & free from the backend */

 unsigned int flags; /* constant flags */
 unsigned int num; /* # of objs per slab */

/* 4) cache_grow/shrink */
 /* order of pgs per slab (2^n) */
 unsigned int gfporder;

 /* force GFP flags, e.g. GFP_DMA */
 gfp_t gfpflags;

 size_t colour; /* cache colouring range */
 unsigned int colour_off; /* colour offset */
 struct kmem_cache *slabp_cache;
 unsigned int slab_size;
 unsigned int dflags; /* dynamic flags */

 /* constructor func */
 void (*ctor)(void *obj);

/* 5) cache creation/removal */
 const char *name;
 struct list_head next;

/* 6) statistics */
#if STATS
 unsigned long num_active;
 unsigned long num_allocations;
 unsigned long high_mark;
 unsigned long grown;
 unsigned long reaped;
 unsigned long errors;
 unsigned long max_freeable;
 unsigned long node_allocs;
 unsigned long node_frees;
 unsigned long node_overflow;
 atomic_t allochit;
 atomic_t allocmiss;
 atomic_t freehit;
 atomic_t freemiss;
#endif
#if DEBUG
 /*
 * If debugging is enabled, then the allocator can add additional
 * fields and/or padding to every object. buffer_size contains the total
 * object size including these internal fields, the following two
 * variables contain the offset to the user object and its size.
 */
 int obj_offset;
 int obj_size;
#endif
 /*
 * We put nodelists[] at the end of kmem_cache, because we want to size
 * this array to nr_node_ids slots instead of MAX_NUMNODES
 * (see kmem_cache_init())
 * We still use [MAX_NUMNODES] and not [1] or [0] because cache_cache
 * is statically defined, so we reserve the max number of nodes.
 */
 struct kmem_list3 *nodelists[MAX_NUMNODES];
 /*
 * Do not add fields after nodelists[]
 */
};

本地CPU空闲对象链表

struct kmem_cache中定义了一个 struct array_cache结构体指针数组，即成员struct array_cache *array[NR_CPUS];，数组的元素个数对应了系统的CPU数。和伙伴系统的每CPU页框高速缓存类似，该结构用来描述每个CPU的本地高速缓存，在每个array_cache的末端，都用一个指针数组记录了slab中的空闲对象。分配对象的时候采用LIFO方式，也就是将该数组中的最后一个索引对应的对象分配出去。实际上，每次分配内存都是直接与本地CPU高速缓存进行交互，只有当其空闲内存不足时，才会从kmem_list3中的slab中取一些加入到本地高速缓存中。

本地CPU空闲对象链表，存在的意义：

每个CPU都有它自己的硬件缓存（L1 L2 Cache），当此CPU上释放对象时，这个对象很可能还在CPU Cache中，所以内核为每个CPU维护这样一个链表，当需要新的对象时，会优先尝试从当前CPU的“pre-cpu”缓存中空闲对象列表获取相应大小的对象。

减少所的竞争，假设多个CPU同时申请一个大小的slab，这时如果没有"pre-cpu"缓存空闲对象链表，就会导致分配的流程互斥，需要上锁，这就导致分配效率低下。而如果分配对象时从各自的CPU缓存中分配就不会出现竞争问题。

/*
 * struct array_cache
 *
 * Purpose:
 * - LIFO ordering, to hand out cache-warm objects from _alloc
 * - reduce the number of linked list operations
 * - reduce spinlock operations
 *
 * The limit is stored in the per-cpu structure to reduce the data cache
 * footprint.
 *
 */
struct array_cache {
 unsigned int avail; /* 可用对象数目 */
 unsigned int limit; /* 可拥有的最大对象数目，和kmem_cache中一样 */
 unsigned int batchcount; /* 同kmem_cache，要转移进本地高速缓存或从本地高速缓存中转移出去的对象的个数 */
 unsigned int touched; /* 是否在收缩后被访问过 */
 spinlock_t lock;
 void *entry[]; /*
 * Must have this definition in here for the proper
 * alignment of array_cache. Also simplifies accessing
 * the entries.
 */
 /* entry是一个伪数组，初始没有任何数据项，之后会增加并保存释放的对象指针 */
};

这个本地CPU空闲对象链表在初始化完成后是一个空的链表，只有释放对象时才会将对象加入这个链表。链表中对象的个数受limit字段限制，其最大值就是limit。链表中对象个数超过这个值时，会将batchcount个对象返回到所有CPU共享的空闲对象链表（也是这样一个结构）中。

array_cache中的entry数组保存的是指向空闲对象的首地址的指针，此链表是在kmem_cache结构中的，即每一种类型的kmem_cache都有它自己的本地CPU空闲对象链表。

所有CPU共享的空闲对象链表

原理和本地CPU空闲对象列表是一样的，唯一的区别就是所有CPU都可以从这个链表中获取对象。所有CPU共享的空闲对象链表不是一直都有，而是根据kmem_cache的shared字段确定，如果shared为1，则此kmem_cache中存在此链表，否则不存在。

一个常规的对象申请流程：系统首先会从本地CPU空闲对象链表中尝试获取一个对象用于分配；如果失败，则尝试从所有CPU共享的空闲对象列表中尝试获取；如果还是失败，就会从SLAB中分配一个；这时如果还失败kmem_cache会尝试从页框分配器中获取一组连续页框，建立一个新的slab，然后将从新的slab中获取一个对象。

对象释放流程也类似：首先将对象释放到本地CPU空闲对象链表，如果本地CPU空闲对象链表中的对象过多（大于limit），kmem_cache会将本地CPU空闲对象链表中的batchcount个对象移动到所有CPU共享的空闲对象链表中，如果所有CPU共享的空闲对象链表中的对象数量也超过了limit，kmem_cache会把所有CPU共享的空闲对象链表中的batchcount个对象移回他们自己所属的SLAB中，这是如果SLAB中空闲对象也太多了，kmem_cache会整理出一些空闲的slab，将这些slab占用的页框释放回页框分配器中。

`struct kmem_list3`

每个内存结点都有自己的kmem_list3，每个CPU都有array_cache。

/*
 * The slab lists for all objects.
 */
struct kmem_list3 {
 struct list_head slabs_partial; /* partial list first, better asm code */
 struct list_head slabs_full;
 struct list_head slabs_free;
 unsigned long free_objects;
 unsigned int free_limit;
 unsigned int colour_next; /* Per-node cache coloring */
 spinlock_t list_lock;
 struct array_cache *shared; /* shared per node */
 struct array_cache **alien; /* on other nodes */
 unsigned long next_reap; /* updated without locking */
 int free_touched; /* updated without locking */
};

`sturct slab`

负责管理从buddy系统分配的一个或多个物理页框，slab主要包含两大部分，管理性数据和obj对象，其中管理性数据包括struct slab和kmem_bufctl_t。

slab有两种形式的结构：管理数据外挂或者内嵌。如果obj较小，那么struct slab和kmem_bufctl_t可以和obj分配在同一个物理页中，称为内嵌。

/*
 * kmem_bufctl_t:
 *
 * Bufctl's are used for linking objs within a slab
 * linked offsets.
 *
 * This implementation relies on "struct page" for locating the cache &
 * slab an object belongs to.
 * This allows the bufctl structure to be small (one int), but limits
 * the number of objects a slab (not a cache) can contain when off-slab
 * bufctls are used. The limit is the size of the largest general cache
 * that does not use off-slab slabs.
 * For 32bit archs with 4 kB pages, is this 56.
 * This is not serious, as it is only for large objects, when it is unwise
 * to have too many per slab.
 * Note: This limit can be raised by introducing a general cache whose size
 * is less than 512 (PAGE_SIZE<<3), but greater than 256.
 */

typedef unsigned int kmem_bufctl_t;
#define BUFCTL_END (((kmem_bufctl_t)(~0U))-0)
#define BUFCTL_FREE (((kmem_bufctl_t)(~0U))-1)
#define BUFCTL_ACTIVE (((kmem_bufctl_t)(~0U))-2)
#define SLAB_LIMIT (((kmem_bufctl_t)(~0U))-3)

/*
 * struct slab
 *
 * Manages the objs in a slab. Placed either at the beginning of mem allocated
 * for a slab, or allocated from an general cache.
 * Slabs are chained into three list: fully used, partial, fully free slabs.
 */
struct slab {
 struct list_head list;
 unsigned long colouroff;
 void *s_mem; /* including colour offset 指向第一个对象的地址 */
 unsigned int inuse; /* num of objs active in slab */
 kmem_bufctl_t free;
 unsigned short nodeid;
};

在每个 slab 中，起始处是为着色预留的区间，接下来是 struct slab 结构，该结构就是用于管理 slab 的数据，紧接着就是一个 kmem_bufctl数组，该数组是由 kmem_bufctl_t 类型的成员组成的数组。接下来是对象区，这就是用于分配的对象。在 kmem_bufctl 数组中，每个成员按顺序与每个对象进行绑定，用于表示该对象的下一个对象的索引，并且最后一个对象的值为 BUFCTL_END, 这样将 slab 中的所有对象通过一个单链表进行维护。通过上面的分析，kmem_bufctl_t 数据结构构造的数据用于指向当前对象指向的下一个对象的索引.

在 SLAB 分配器中，struct slab 可以位于 slab 内部，也可以位于 slab 外部，但不论位于 slab 内部或外部，其成员的含义都是一致的。colouroff 成员用于指明该 slab 着色总长度，其包含了着色、struct slab 以及 kmem_bufctl array 的总长度，这样可用对象加载到 CACHE 之后就会被插入到不同的 CACHE 行; s_mem 用于指向 slab 中对象的起始地址; inuse 成员用于指定 slab 中可用对象的数量; free 成员用于指向 slab 当前可用对象在 kmem_bufctl 的索引; nodeid 成员用于指向该 slab 位于哪个 NODE; list 成员用于将 slab 加入到 struct kmem_cache 的 kmem_list3 中三个链表中的其中一个链表。

object

每个slab只负责管理一种类型的“对象”，将该大小进行内存对齐后的大小就是该“对象”的大小，依此大小对slab进行划分，从而实现细粒度的内存管理

结构之间的关系

cache_chain的定义：static struct list_head cache_chain;是一个struct kmem_cache的链表，将所有struct kemem_cache连接起来。

cache_cache是第一个kemem_cache_struct结构，通过struct kmem_list3结构维护的三个struct slab链表构成了内核的第一个slab系统，用于存储slab系统所有的struct kmem_cache_struct结构。

struct slab结构可以通过参数选择1.存储在自己slab管理的页面上，2.存储到cache_cache中?

struct kmem_list3结构存在哪里？

参考资料

Linux内存管理之slab分配器分析(一)

Linux内存管理之SLAB原理浅析

linux内存源码分析 - SLAB分配器概述

kmem_cache_init

此函数在init/main.c中被start_kernel()函数调用，其定义在mm/slab.c中定义。先看看源码中的注释：引导程序很棘手，因为需要从尚不存在的caches中分配几个objects。

/*
 * Initialisation. Called after the page allocator have been initialised and
 * before smp_init().
 */
void __init kmem_cache_init(void)
{

 /* Bootstrap is tricky, because several objects are allocated
 * from caches that do not exist yet:
 * 1) initialize the cache_cache cache: it contains the struct
 * kmem_cache structures of all caches, except cache_cache itself:
 * cache_cache is statically allocated.
 * Initially an __init data area is used for the head array and the
 * kmem_list3 structures, it's replaced with a kmalloc allocated
 * array at the end of the bootstrap.
 * 2) Create the first kmalloc cache.
 * The struct kmem_cache for the new cache is allocated normally.
 * An __init data area is used for the head array.
 * 3) Create the remaining kmalloc caches, with minimally sized
 * head arrays.
 * 4) Replace the __init data head arrays for cache_cache and the first
 * kmalloc cache with kmalloc allocated arrays.
 * 5) Replace the __init data for kmem_list3 for cache_cache and
 * the other cache's with kmalloc allocated memory.
 * 6) Resize the head arrays of the kmalloc caches to their final sizes.
 */
}

从注释可以看出，kmem_cache_init()函数主要完成六项工作：

初始化cache_cache高速缓存：静态分配cache_cache结构，它用于保存所有高速缓存的struct kmem_cache描述结构体。初始化一个__init数据区域，用于保存head array和kmem_list3结构体，在引导程序末尾将其替换为kmalloc分配的数组。
创建第一个kmalloc用的cache:
创建剩余的kmalloc缓存，并使用最小大小的头数组。
将cache_cache的__init数据头数组和第一个kmalloc缓存替换为kmalloc分配的数组。
将kmem_list3的__init数据替换为cache_cache，将其他缓存替换为kmalloc分配的内存。
将kmalloc缓存的头数组调整为最终大小。

(1)构建好了kmem_cache实例cache_cache(静态分配)，且构建好了kmem_cache的slab分配器,并由initkmem_list3[0]组织, 相应的array为initarray_cache；
(2)构建好了kmem_cache实例（管理arraycache_init），且构建好了arraycache_init的slab分配器,并由initkmem_list3[1]组织,相应的array为initarray_generic；
(3)构建好了kmem_cache实例（管理kmem_list3）,此时还未构建好kmem_list3的slab分配器，但是一旦申请sizeof(kmem_list3)空间，将构建kmem_list3分配器,并由initkmem_list[2]组织,其array将通过kmalloc进行申请；
(4)为malloc_sizes的相应数组元素构建kmem_cache实例，并分配kmem_list3,用于组织slab链表，分配arraycache_init用于组织每CPU的同一个kmem_cache下的slab分配;
(5)替换kmem_cache、malloc_sizes[INDEX_AC].cs_cachep下的arraycache_init实例；
(6)替换kmem_cache、malloc_sizes[INDEX_AC].cs_cachep、malloc_sizes[INDEX_L3].cs_cachep下的kmem_list3实例;
(7)g_cpucachep_up = EARLY;

在slab初始化好之前，无法通过kmalloc分配初始化过程中必要的一些对象，只能使用静态的全局变量，待slab初始化后期，再使用kmalloc动态分配的对象替换全局变量

初始化前的准备工作

静态全局变量

/*
 * bootstrap: The caches do not work without cpuarrays anymore, but the
 * cpuarrays are allocated from the generic caches...
 */
#define BOOT_CPUCACHE_ENTRIES 1
struct arraycache_init {
 struct array_cache cache;
 void *entries[BOOT_CPUCACHE_ENTRIES];
};

static struct arraycache_init initarray_cache __initdata =
 { {0, BOOT_CPUCACHE_ENTRIES, 1, 0} };
static struct arraycache_init initarray_generic =
 { {0, BOOT_CPUCACHE_ENTRIES, 1, 0} };

即
struct arraycache_init initarray_generic = initarray_cache.cache =
struct array_cache {
 unsigned int avail = 0; /* 可用对象数目 */
 unsigned int limit = BOOT_CPUCACHE_ENTRIES; /* 可拥有的最大对象数目，和kmem_cache中一样 */
 unsigned int batchcount = 1; /* 同kmem_cache，要转移进本地高速缓存或从本地高速缓存中转移出去的对象的个数 */
 unsigned int touched = 0; /* 是否在收缩后被访问过 */
};

slab系统三个最重要的结构体，kmem_cache arary_cache 以及 kmem_list3，初始化slab系统，其实就是初始化这三个结构体，在slab系统初始化的初期，slab系统还没建立起来，只能通过静态全局变量初始化这三个结构体，用以搭建一个初始化阶段用的临时slab系统，等slab系统建立起来后，再将这三个结构体加入到slab系统管理的内存中。

void __init kmem_cache_init(void)
{
 /*
 如前所述，先借用全局变量initkmem_list3表示的slab三链 ，每个内存节点对应一组slab三链。
 initkmem_list3是个slab三链数组，包含所有内存节点的slab三链。
 对于每个内存节点，包含三个三链：
 struct kmem_cache的slab三链、
 struct arraycache_init的slab 三链、
 struct kmem_list3的slab三链
 这里循环初始化所有内存节点的所有slab三链
 */
 for (i = 0; i < NUM_INIT_LISTS; i++) { /* 每个内存结点都有kmem_list3 */
 /*初始化所有node的所有slab中的三个链表*/
 kmem_list3_init(&initkmem_list3[i]); /* 1 2 */
 /* 这里初始化所有内存节点的struct kmem_cache的slab三链为空。*/
 if (i < MAX_NUMNODES)
 cache_cache.nodelists[i] = NULL;
 }
 set_up_list3s(&cache_cache, CACHE_CACHE); /* 3 4 */
 /*
 * Fragmentation resistance on low memory - only use bigger
 * page orders on machines with more than 32MB of memory.
 */
 if (num_physpages > (32 << 20) >> PAGE_SHIFT)
 slab_break_gfp_order = BREAK_GFP_ORDER_HI;

主要两个函数起作用：kmem_list3_init()和set_up_list3s;

/* 1.关于全局变量initkmem_list3的定义，以及宏NUM_INIT_LISTS的定义 */
/*
 * Need this for bootstrapping a per node allocator.
 */
#define NUM_INIT_LISTS (3 * MAX_NUMNODES)
struct kmem_list3 __initdata initkmem_list3[NUM_INIT_LISTS];

/* include/linux/numa.h */
#ifdef CONFIG_NODES_SHIFT
#define NODES_SHIFT CONFIG_NODES_SHIFT
#else
#define NODES_SHIFT 0
#endif

#define MAX_NUMNODES (1 << NODES_SHIFT)
/*
 总结 ： 一个UMA系统中只有一个Node，而在NUMA中则可以存在多个Node。它由CONFIG_NODES_SHIFT配置选项决定，它是CONFIG_NUMA的子选项，所以只有配置了CONFIG_NUMA，该选项才起作用。
 UMA情况下，NODES_SHIFT被定义为0，MAX_NUMNODES也即为1。
*/

/* 2. kmem_list3_init()所做的初始化 */
static void kmem_list3_init(struct kmem_list3 *parent)
{
 INIT_LIST_HEAD(&parent->slabs_full);
 INIT_LIST_HEAD(&parent->slabs_partial);
 INIT_LIST_HEAD(&parent->slabs_free);
 parent->shared = NULL;
 parent->alien = NULL;
 parent->colour_next = 0;
 spin_lock_init(&parent->list_lock);
 parent->free_objects = 0;
 parent->free_touched = 0;
}

/* 3. 全局变量cache_cache的初始化 */
/* internal cache of cache description objs */
static struct kmem_cache cache_cache = {
 .batchcount = 1,
 .limit = BOOT_CPUCACHE_ENTRIES,
 .shared = 1, /* 所有CPU共享的空闲对象链表 */
 .buffer_size = sizeof(struct kmem_cache), /* kmem_cache中对象的大小 */
 .name = "kmem_cache", /* kmem_cache的名字 */
};
/* 4. set_up_list3s(&cache_cache, CACHE_CACHE); */
#define CACHE_CACHE 0
/*
 * For setting up all the kmem_list3s for cache whose buffer_size is same as
 * size of kmem_list3.
 */
static void __init set_up_list3s(struct kmem_cache *cachep, int index)
{
 int node;

 for_each_online_node(node) {
 cachep->nodelists[node] = &initkmem_list3[index + node];
 cachep->nodelists[node]->next_reap = jiffies +
 REAPTIMEOUT_LIST3 +
 ((unsigned long)cachep) % REAPTIMEOUT_LIST3;
 }
}
/*
 设置struct kmem_cache的slab三链指向initkmem_list3中的一组slab三链，
 CACHE_CACHE为cache在内核cache链表中的索引，
 struct kmem_cache对应的cache是内核中创建的第一个cache
 ，故CACHE_CACHE为0
*/

/* 5.
 全局变量slab_break_gfp_order为每个slab最多占用几个页面 ，用来抑制碎片。
 如大小为3360的对象，如果其slab只占一个页面，碎片为736，slab占用两个页面，则碎片大小也翻倍。
 只有当对象很大以至于slab中连一个对象都放不下时才可以超过这个值。
 有两个可能的取值 ：
 当可用内存大于32MB时，BREAK_GFP_ORDER_HI为1 ，即每个slab最多占用2个页面 ，只有当对象大小大于8192时 ，才可以突破slab_break_gfp_order的限制。
 小于等于32MB时BREAK_GFP_ORDER_LO为0。
*/

1）初始化`cache_chain`

node = numa_node_id();
/* 1) create the cache_cache */
INIT_LIST_HEAD(&cache_chain);
list_add(&cache_cache.next, &cache_chain);
cache_cache.colour_off = cache_line_size();
cache_cache.array[smp_processor_id()] = &initarray_cache.cache;
cache_cache.nodelists[node] = &initkmem_list3[CACHE_CACHE + node];

/*
 * struct kmem_cache size depends on nr_node_ids, which
 * can be less than MAX_NUMNODES.
 */
cache_cache.buffer_size = offsetof(struct kmem_cache, nodelists) + nr_node_ids * sizeof(struct kmem_list3 *);
/*offsetof会生成一个类型为 size_t 的整型常量，它是一个结构成员相对于结构开头的字节偏移量*/

cache_cache.buffer_size = ALIGN(cache_cache.buffer_size, cache_line_size());
cache_cache.reciprocal_buffer_size = reciprocal_value(cache_cache.buffer_size);

for (order = 0; order < MAX_ORDER; order++) {
 /*计算每个slab中对象的数目。*/
 cache_estimate(order, cache_cache.buffer_size,
 cache_line_size(), 0, &left_over, &cache_cache.num);
 if (cache_cache.num)
 break;
}
BUG_ON(!cache_cache.num);
cache_cache.gfporder = order;
cache_cache.colour = left_over / cache_cache.colour_off;
cache_cache.slab_size = ALIGN(cache_cache.num * sizeof(kmem_bufctl_t) +
 sizeof(struct slab), cache_line_size());

2）&3）创建`kmalloc`用的高速缓存

/* 2+3) create the kmalloc caches */
sizes = malloc_sizes; /* 1 */
names = cache_names;

/* begin of 2 */
/*
 * Initialize the caches that provide memory for the array cache and the
 * kmem_list3 structures first. Without this, further allocations will
 * bug.
 */
sizes[INDEX_AC].cs_cachep = kmem_cache_create(names[INDEX_AC].name,
 sizes[INDEX_AC].cs_size,
 ARCH_KMALLOC_MINALIGN,
 ARCH_KMALLOC_FLAGS|SLAB_PANIC,
 NULL);

if (INDEX_AC != INDEX_L3) {
 sizes[INDEX_L3].cs_cachep =
 kmem_cache_create(names[INDEX_L3].name,
 sizes[INDEX_L3].cs_size,
 ARCH_KMALLOC_MINALIGN,
 ARCH_KMALLOC_FLAGS|SLAB_PANIC,
 NULL);
}
/* end of 2 */
slab_early_init = 0;

/* begin of 3 */
while (sizes->cs_size != ULONG_MAX) { /* ULONG_MAX = (~0UL)即最大值 */
 /*
 * For performance, all the general caches are L1 aligned.
 * This should be particularly beneficial on SMP boxes, as it
 * eliminates "false sharing".
 * Note for systems short on memory removing the alignment will
 * allow tighter packing of the smaller caches.
 */
 if (!sizes->cs_cachep) {
 sizes->cs_cachep = kmem_cache_create(names->name,
 sizes->cs_size,
 ARCH_KMALLOC_MINALIGN,
 ARCH_KMALLOC_FLAGS|SLAB_PANIC,
 NULL);
#ifdef CONFIG_ZONE_DMA
 sizes->cs_dmacachep = kmem_cache_create(names->name_dma,
 sizes->cs_size,
 ARCH_KMALLOC_MINALIGN,
 ARCH_KMALLOC_FLAGS|SLAB_CACHE_DMA|
 SLAB_PANIC,
 NULL);
#endif
 sizes++;
 names++;
 }
/* end of 3 */

分步骤看看

/* 1. */
struct cache_sizes *sizes;
struct cache_names *names;

sizes = malloc_sizes;
names = cache_names;

/* 先看看这两个变量的类型 */
/* Size description struct for general caches. */
struct cache_sizes {
 size_t cs_size;
 struct kmem_cache *cs_cachep;
#ifdef CONFIG_ZONE_DMA
 struct kmem_cache *cs_dmacachep;
#endif
};
/* Must match cache_sizes above. Out of line to keep cache footprint low. */
struct cache_names {
 char *name;
 char *name_dma;
};

/* 然后看看全局变量malloc_sizes和cache_names的定义 */
/*
 * These are the default caches for kmalloc. Custom caches can have other sizes.
 */
#define ULONG_MAX (~0UL)
struct cache_sizes malloc_sizes[] = {
#define CACHE(x) { .cs_size = (x) },
#include <linux/kmalloc_sizes.h>
 CACHE(ULONG_MAX)
#undef CACHE
};
EXPORT_SYMBOL(malloc_sizes);

static struct cache_names __initdata cache_names[] = {
#define CACHE(x) { .name = "size-" #x, .name_dma = "size-" #x "(DMA)" },
#include <linux/kmalloc_sizes.h>
 {NULL,}
#undef CACHE
};

/* 其中include/linux/kmalloc_sizes.h的内容如下 */
#if (PAGE_SIZE == 4096)
 CACHE(32)
#endif
 CACHE(64)
#if L1_CACHE_BYTES < 64
 CACHE(96)
#endif
 CACHE(128)
#if L1_CACHE_BYTES < 128
 CACHE(192)
#endif
 CACHE(256)
 CACHE(512)
 CACHE(1024)
 CACHE(2048)
 CACHE(4096)
 CACHE(8192)
 CACHE(16384)
 CACHE(32768)
 CACHE(65536)
 CACHE(131072)
#if KMALLOC_MAX_SIZE >= 262144
 CACHE(262144)
#endif
#if KMALLOC_MAX_SIZE >= 524288
 CACHE(524288)
#endif
#if KMALLOC_MAX_SIZE >= 1048576
 CACHE(1048576)
#endif
#if KMALLOC_MAX_SIZE >= 2097152
 CACHE(2097152)
#endif
#if KMALLOC_MAX_SIZE >= 4194304
 CACHE(4194304)
#endif
#if KMALLOC_MAX_SIZE >= 8388608
 CACHE(8388608)
#endif
#if KMALLOC_MAX_SIZE >= 16777216
 CACHE(16777216)
#endif
#if KMALLOC_MAX_SIZE >= 33554432
 CACHE(33554432)
#endif
/*
展开后的定义如下
struct cache_sizes malloc_sizes[] = {
 { .cs_size = (32) },
 { .cs_size = (64) },
 { .cs_size = (128) },
 { .cs_size = (256) },
 { .cs_size = (512) },
 ...
 { .cs_size = (~0UL) },
};

static struct cache_names __initdata cache_names[] = {
 {.name = "size-32", .name_dma = "size-32(DMA)"},
 {.name = "size-64", .name_dma = "size-64(DMA)"},
 {.name = "size-128", .name_dma = "size-128(DMA)"},
 {.name = "size-256", .name_dma = "size-256(DMA)"},
 .....
 {NULL,}
};
 即，定义了struct cache_sizes malloc_sizes[]和struct cache_names cache_names[]。
 并将这两个数组的地址赋值给了sizes和namas两个变量。
*/

/* 2 创建专用的高速缓存*/
#define INDEX_AC index_of(sizeof(struct arraycache_init))
#define INDEX_L3 index_of(sizeof(struct kmem_list3))
/*
 INDEX_AC就是与sizeof(struct arraycache_init :28==>0)适配的kmalloc可分配缓存的索引.
 INDEX_L3就是与sizeof(struct kmem_list3 :56==>1)适配的kmalloc可分配缓存的索引.
*/
其中
/*
 * bootstrap: The caches do not work without cpuarrays anymore, but the
 * cpuarrays are allocated from the generic caches...
 */
#define BOOT_CPUCACHE_ENTRIES 1
struct arraycache_init {
 struct array_cache cache;
 void *entries[BOOT_CPUCACHE_ENTRIES];
};

/*
 即2这里创建了两个调用kmem_cache_create()函数创建了两个高速缓存。
 即struct array_cache和struct kmem_list3所用的general cache。
 INDEX_AC是计算local cache所用的struct arraycache_init对象在kmalloc size中的索引
 ，即属于哪一级别大小的general cache，创建此大小级别的cache为local cache所用。
*/

/* 3 这里是一个循环，循环调用kmem_cache_create()函数，创建剩下的给kmalloc用的高速缓存 */
while (sizes->cs_size != ULONG_MAX) { /* ULONG_MAX = (~0UL)即最大值 */
 sizes->cs_cachep = kmem_cache_create(names->name, sizes->cs_size, ...);
 sizes->cs_dmacachep = kmem_cache_create(names->name_dma, sizes->cs_size, ...);
 sizes++;
 names++;
}

4）用`kmalloc`对象替换静态分配的全局高速缓存变量

/* 4) Replace the bootstrap head arrays */
/*
 用kmalloc对象替换静态分配的全局变量。
 到目前为止一共使用了两个全局local cache，
 一个是cache_cache的local cache指向initarray_cache.cache;
 另一个是malloc_sizes[INDEX_AC].cs_cachep的local cache指向initarray_generic.cache,参见setup_cpu_cache函数。
*/

{
 struct array_cache *ptr;

 ptr = kmalloc(sizeof(struct arraycache_init), GFP_KERNEL);
 /* 第2)和第3)步已经初始化了kmalloc用的高速缓存，这里可以使用kmalloc函数进行内存分配了 */

 local_irq_disable();
 BUG_ON(cpu_cache_get(&cache_cache) != &initarray_cache.cache);
 memcpy(ptr, cpu_cache_get(&cache_cache),
 sizeof(struct arraycache_init));
 /*
 * Do not assume that spinlocks can be initialized via memcpy:
 */
 spin_lock_init(&ptr->lock);

 cache_cache.array[smp_processor_id()] = ptr;
 local_irq_enable();

 ptr = kmalloc(sizeof(struct arraycache_init), GFP_KERNEL);

 local_irq_disable();
 BUG_ON(cpu_cache_get(malloc_sizes[INDEX_AC].cs_cachep)
 != &initarray_generic.cache);
 memcpy(ptr, cpu_cache_get(malloc_sizes[INDEX_AC].cs_cachep),
 sizeof(struct arraycache_init));
 /*
 * Do not assume that spinlocks can be initialized via memcpy:
 */
 spin_lock_init(&ptr->lock);

 malloc_sizes[INDEX_AC].cs_cachep->array[smp_processor_id()] = ptr;
 local_irq_enable();
}

其中cpu_cache_get()定义如下。

static inline struct array_cache *cpu_cache_get(struct kmem_cache *cachep)
{
 return cachep->array[smp_processor_id()];
}

smp_processor_id()函数用户获得当前的CPU ID的定义，详细定义暂时不展开。

5）用`kmalloc`的空间替换静态分配的slab三链

/* 5) Replace the bootstrap kmem_list3's */
/*
* 与第4步类似，用kmalloc的空间替换静态分配的slab三链
*/
{
 int nid;

 for_each_online_node(nid) {
 /* 复制struct kmem_cache的slab三链 */
 init_list(&cache_cache, &initkmem_list3[CACHE_CACHE + nid], nid);
 /* 复制struct arraycache_init的slab三链 */
 init_list(malloc_sizes[INDEX_AC].cs_cachep,
 &initkmem_list3[SIZE_AC + nid], nid);
 /* 复制struct kmem_list3的slab三链 */
 if (INDEX_AC != INDEX_L3) {
 init_list(malloc_sizes[INDEX_L3].cs_cachep,
 &initkmem_list3[SIZE_L3 + nid], nid);
 }
 }
}

/* 其中 init_list()函数的定义如下 */
/*
 * swap the static kmem_list3 with kmalloced memory
 */
static void init_list(struct kmem_cache *cachep, struct kmem_list3 *list, int nodeid)
{
 struct kmem_list3 *ptr;

 ptr = kmalloc_node(sizeof(struct kmem_list3), GFP_KERNEL, nodeid); /* 1 */
 BUG_ON(!ptr);

 local_irq_disable();
 memcpy(ptr, list, sizeof(struct kmem_list3));
 /*
 * Do not assume that spinlocks can be initialized via memcpy:
 */
 spin_lock_init(&ptr->list_lock);

 MAKE_ALL_LISTS(cachep, ptr, nodeid); /* 2 */
 cachep->nodelists[nodeid] = ptr;
 local_irq_enable();
}
/* 1 */
/**
 * kmalloc_node - allocate memory from a specific node
 * @size: how many bytes of memory are required.
 * @flags: the type of memory to allocate (see kcalloc).
 * @node: node to allocate from.
 *
 * kmalloc() for non-local nodes, used to allocate from a specific node
 * if available. Equivalent to kmalloc() in the non-NUMA single-node
 * case.
 */
static inline void *kmalloc_node(size_t size, gfp_t flags, int node)
{
 return kmalloc(size, flags);
}
/* 2 */
#define MAKE_ALL_LISTS(cachep, ptr, nodeid) \
 do { \
 MAKE_LIST((cachep), (&(ptr)->slabs_full), slabs_full, nodeid); \
 MAKE_LIST((cachep), (&(ptr)->slabs_partial), slabs_partial, nodeid); \
 MAKE_LIST((cachep), (&(ptr)->slabs_free), slabs_free, nodeid); \
 } while (0)

#define MAKE_LIST(cachep, listp, slab, nodeid) \
 do { \
 INIT_LIST_HEAD(listp); \
 list_splice(&(cachep->nodelists[nodeid]->slab), listp); \
 } while (0)

list_splice - join two lists, this is designed for stacks

6） `enable_cpucache`

/* 6) resize the head arrays to their final sizes */
{
 struct kmem_cache *cachep;
 mutex_lock(&cache_chain_mutex);
 list_for_each_entry(cachep, &cache_chain, next)
 if (enable_cpucache(cachep))
 BUG();
 mutex_unlock(&cache_chain_mutex);
}
/* enable_cpucache()函数 在分析kmem_cache_create函数的 “初始化本地以及共享的高速缓存”小结分析 */

收尾工作

 /* Annotate slab for lockdep -- annotate the malloc caches */
 init_lock_keys();


 /* Done! */
 g_cpucache_up = FULL;

 /*
 * Register a cpu startup notifier callback that initializes
 * cpu_cache_get for all new cpus
 */
 register_cpu_notifier(&cpucache_notifier);

 /*
 * The reap timers are started later, with a module init call: That part
 * of the kernel is not yet operational.
 */
}

/* init_lock_keys()函数的定义 */
#ifdef CONFIG_LOCKDEP

/*
 * Slab sometimes uses the kmalloc slabs to store the slab headers
 * for other slabs "off slab".
 * The locking for this is tricky in that it nests within the locks
 * of all other slabs in a few places; to deal with this special
 * locking we put on-slab caches into a separate lock-class.
 *
 * We set lock class for alien array caches which are up during init.
 * The lock annotation will be lost if all cpus of a node goes down and
 * then comes back up during hotplug
 */
static struct lock_class_key on_slab_l3_key;
static struct lock_class_key on_slab_alc_key;

static inline void init_lock_keys(void)
{
 int q;
 struct cache_sizes *s = malloc_sizes;

 while (s->cs_size != ULONG_MAX) {
 for_each_node(q) {
 struct array_cache **alc;
 int r;
 struct kmem_list3 *l3 = s->cs_cachep->nodelists[q];
 if (!l3 || OFF_SLAB(s->cs_cachep))
 continue;
 lockdep_set_class(&l3->list_lock, &on_slab_l3_key);
 alc = l3->alien;
 /*
 * FIXME: This check for BAD_ALIEN_MAGIC
 * should go away when common slab code is taught to
 * work even without alien caches.
 * Currently, non NUMA code returns BAD_ALIEN_MAGIC
 * for alloc_alien_cache,
 */
 if (!alc || (unsigned long)alc == BAD_ALIEN_MAGIC)
 continue;
 for_each_node(r) {
 if (alc[r])
 lockdep_set_class(&alc[r]->lock,
 &on_slab_alc_key);
 }
 }
 s++;
 }
}
#else
static inline void init_lock_keys(void)
{
}
#endif

关于`kmem_cache`的初始化阶段

由于 SLAB 分配器的初始化是一个 “鸡和蛋” 的问题，因此 SLAB 分配器将初始化分作几个阶段，通过g_cpucache_up 进行描述，g_cpucache_up 可以取值:

/*
 * chicken and egg problem: delay the per-cpu array allocation
 * until the general caches are up.
 */
static enum {
 NONE,
 PARTIAL_AC,
 PARTIAL_L3,
 FULL
} g_cpucache_up;

NONE 阶段 SLAB 分配器只能分配 struct kmem_cache 对应的高速缓存，且功能不是很完整;
PARTIAL_AC 阶段 SLAB 分配器已经增加了 struct array_cache 对应的高速缓存，因此高速函数可以为本地高速缓存分配内存了;
PARTIAL_L3 阶段，SLAB 分配器增加了 struct kmem_list3 的缓存，因此该阶段 kmalloc 等函数已经可以使用;
~~EARLY 阶段，SLAB 分配器已经将分配器相关的所有数据都使用 SLAB 分配器分配内存，不再使用静态数据~~;
FULL阶段 SLAB 分配器已经可以像一个正常的分配器为内核提供接口进行内存分配和回收.

~~因此 SLAB 如果处于 EARLY 及其之后都表示 SLAB 已经准备好，可以开始使用了.~~

总结

kmem_cache_init()函数主要，

初始化全局链表cache_chain
创建全局静态变量cache_cache , 将静态创建的变量initarray_cache.array赋值给cache_cache.array;将静态创建的kmem_list3按照内存结点编号赋值给cache_cache.nodelists[nodeid];
创建通用内存分配用的kmem_cache ：size-32等；
将初始化cache_cache时用的struct arraycache_init类型的initarray_cache.array以及struct kmem_list3结构放入通用内存（kmalloc分配）的kmem_cache中。

参考资料

Linux内存管理之slab分配器分析(二初始化 kmem_cache_init)

Linux内存管理之slab机制（初始化）

内存管理初始化（五）kmem_cache_init 初始化slab分配器(上)

kmem_cache_create

SLAB 分配器使用 struct kmem_cache 表示一个高速缓存，其包含了高速缓存的基础信息，其中也包含了高速缓存的本地缓存、共享缓存，以及 slab 链表等。高速缓存的创建过程就是用于填充和创建高速缓存所需的数据。

这函数主要创建一个kmem_cache，但是并不实际分配内存，创建好kmem_cache后调用kmem_cache_alloc()请求分配对象的时候才调用cache_grow()函数向伙伴系统申请内存页框。

函数参数说明

/**
 * kmem_cache_create - Create a cache.
 * @name: A string which is used in /proc/slabinfo to identify this cache.
 * @size: The size of objects to be created in this cache.
 * @align: The required alignment for the objects.
 * @flags: SLAB flags
 * @ctor: A constructor for the objects.
 *
 * Returns a ptr to the cache on success, NULL on failure.
 * Cannot be called within a int, but can be interrupted.
 * The @ctor is run when new pages are allocated by the cache.
 *
 * @name must be valid until the cache is destroyed. This implies that
 * the module calling this has to destroy the cache before getting unloaded.
 * Note that kmem_cache_name() is not guaranteed to return the same pointer,
 * therefore applications must manage it themselves.
 *
 * The flags are
 *
 * %SLAB_POISON - Poison the slab with a known test pattern (a5a5a5a5)
 * to catch references to uninitialised memory.
 *
 * %SLAB_RED_ZONE - Insert `Red' zones around the allocated memory to check
 * for buffer overruns.
 *
 * %SLAB_HWCACHE_ALIGN - Align the objects in this cache to a hardware
 * cacheline. This can be beneficial if you're counting cycles as closely
 * as davem.
 */

name : kmem_cache的名字；
size: kmem_cache中对象的大小；
align ：对象所需的对齐方式
flags : SLAB flags
- SLAB_POISON
- SLAB_RED_ZONE
- SLAB_HWCACHE_ALIGN
ctor : 一个构造函数，当向kmem_cache中添加新的物理页时被调用。

检查参数以及运行环境

struct kmem_cache *
kmem_cache_create (const char *name, size_t size, size_t align,
 unsigned long flags, void (*ctor)(void *))
{
 size_t left_over, slab_size, ralign;
 struct kmem_cache *cachep = NULL, *pc;

 /*
 * Sanity checks... these are all serious usage bugs.
 */
 if (!name || in_interrupt() || (size < BYTES_PER_WORD) ||
 size > KMALLOC_MAX_SIZE) {
 printk(KERN_ERR "%s: Early error in slab %s\n", __func__,
 name);
 BUG();
 }

这一段代码主要判断传入的参数或者CPU运行的环境是否满足。如果1.调用函数时参数中给的name为空; 2. 此时CPU在执行中断服务程序（in_interrupt()此函数通过thread_info的一下信息去判断，以后分析进程管理的时候再分析; 3. 要创建的kmem_cache的size比一个字的字节数还少或比kmalloc所允许分配的最大的内存还大，就报oops错。

BYTES_PER_WORD和KMALLOC_MAX_SIZE的定义如下：

#define BYTES_PER_WORD sizeof(void *)
/*
 * The largest kmalloc size supported by the slab allocators is
 * 32 megabyte (2^25) or the maximum allocatable page order if that is
 * less than 32 MB.
 *
 * WARNING: Its not easy to increase this value since the allocators have
 * to do various tricks to work around compiler limitations in order to
 * ensure proper constant folding.
 */
#define KMALLOC_SHIFT_HIGH ((MAX_ORDER + PAGE_SHIFT - 1) <= 25 ? \
 (MAX_ORDER + PAGE_SHIFT - 1) : 25)

#define KMALLOC_MAX_SIZE (1UL << KMALLOC_SHIFT_HIGH)

继续分析kmem_cache_create()函数的流程。


 /*
 * We use cache_chain_mutex to ensure a consistent view of
 * cpu_online_mask as well. Please see cpuup_callback
 */
 get_online_cpus(); /* 如果此时系统支持CPU热插拔，那么此函数获得可用的CPU，否则什么都不干 */
 mutex_lock(&cache_chain_mutex);

 /* 遍历所有的高速缓存 */
 list_for_each_entry(pc, &cache_chain, next) {
 char tmp;
 int res;

 /*
 * This happens when the module gets unloaded and doesn't
 * destroy its slab cache and no-one else reuses the vmalloc
 * area of the module. Print a warning.
 */
 res = probe_kernel_address(pc->name, tmp);
 if (res) {
 printk(KERN_ERR
 "SLAB: cache with size %d has lost its name\n",
 pc->buffer_size);
 continue;
 }

 if (!strcmp(pc->name, name)) { /* 如果发现已经存在相同名字的高速缓存就dump_stack()并报oops */
 printk(KERN_ERR
 "kmem_cache_create: duplicate cache %s\n", name);
 dump_stack();
 goto oops;
 }
 }

#if DEBUG
 WARN_ON(strchr(name, ' ')); /* It confuses parsers */
#if FORCED_DEBUG
 /*
 * Enable redzoning and last user accounting, except for caches with
 * large objects, if the increased size would increase the object size
 * above the next power of two: caches with object sizes just above a
 * power of two have a significant amount of internal fragmentation.
 */
 if (size < 4096 || fls(size - 1) == fls(size-1 + REDZONE_ALIGN +
 2 * sizeof(unsigned long long)))
 flags |= SLAB_RED_ZONE | SLAB_STORE_USER;
 if (!(flags & SLAB_DESTROY_BY_RCU))
 flags |= SLAB_POISON;
#endif
 if (flags & SLAB_DESTROY_BY_RCU)
 BUG_ON(flags & SLAB_POISON);
#endif
 /*
 * Always checks flags, a caller might be expecting debug support which
 * isn't available.
 */
 BUG_ON(flags & ~CREATE_MASK);

计算对齐

根据高速缓存创建时提供的标志进行对齐相关的操作，最终会将对齐的结果存储在 align 变量里.

 /*
 * Check that size is in terms of words. This is needed to avoid
 * unaligned accesses for some archs when redzoning is used, and makes
 * sure any on-slab bufctl's are also correctly aligned.
 */
 if (size & (BYTES_PER_WORD - 1)) {
 size += (BYTES_PER_WORD - 1);
 size &= ~(BYTES_PER_WORD - 1);
 }

 /* calculate the final buffer alignment: */

 /* 1) arch recommendation: can be overridden for debug */
 if (flags & SLAB_HWCACHE_ALIGN) {
 /*
 * Default alignment: as specified by the arch code. Except if
 * an object is really small, then squeeze multiple objects into
 * one cacheline.
 */
 ralign = cache_line_size();
 while (size <= ralign / 2)
 ralign /= 2;
 } else {
 ralign = BYTES_PER_WORD;
 }

 /*
 * Redzoning and user store require word alignment or possibly larger.
 * Note this will be overridden by architecture or caller mandated
 * alignment if either is greater than BYTES_PER_WORD.
 */
 if (flags & SLAB_STORE_USER)
 ralign = BYTES_PER_WORD;

 if (flags & SLAB_RED_ZONE) {
 ralign = REDZONE_ALIGN;
 /* If redzoning, ensure that the second redzone is suitably
 * aligned, by adjusting the object size accordingly. */
 size += REDZONE_ALIGN - 1;
 size &= ~(REDZONE_ALIGN - 1);
 }

 /* 2) arch mandated alignment */
 if (ralign < ARCH_SLAB_MINALIGN) {
 ralign = ARCH_SLAB_MINALIGN;
 }
 /* 3) caller mandated alignment */
 if (ralign < align) {
 ralign = align;
 }
 /* disable debug if necessary */
 if (ralign > __alignof__(unsigned long long))
 flags &= ~(SLAB_RED_ZONE | SLAB_STORE_USER);
 /*
 * 4) Store it.
 */
 align = ralign;

分配`kmem_cache`描述符

 /* Get cache's description obj. */
 cachep = kmem_cache_zalloc(&cache_cache, GFP_KERNEL);
 if (!cachep)
 goto oops;

#if DEBUG
 cachep->obj_size = size;

 /*
 * Both debugging options require word-alignment which is calculated
 * into align above.
 */
 if (flags & SLAB_RED_ZONE) {
 /* add space for red zone words */
 cachep->obj_offset += sizeof(unsigned long long);
 size += 2 * sizeof(unsigned long long);
 }
 if (flags & SLAB_STORE_USER) {
 /* user store requires one word storage behind the end of
 * the real object. But if the second red zone needs to be
 * aligned to 64 bits, we must allow that much space.
 */
 if (flags & SLAB_RED_ZONE)
 size += REDZONE_ALIGN;
 else
 size += BYTES_PER_WORD;
 }
#if FORCED_DEBUG && defined(CONFIG_DEBUG_PAGEALLOC)
 if (size >= malloc_sizes[INDEX_L3 + 1].cs_size
 && cachep->obj_size > cache_line_size() && size < PAGE_SIZE) {
 cachep->obj_offset += PAGE_SIZE - size;
 size = PAGE_SIZE;
 }
#endif
#endif

判断slab管理数据是放在slab内部还是外部

判断依据是kmem_cache中对象的大小，即传递给kmem_cache_create()函数的size参数。


 /*
 * Determine if the slab management is 'on' or 'off' slab.
 * (bootstrapping cannot cope with offslab caches so don't do
 * it too early on.)
 */
 if ((size >= (PAGE_SIZE >> 3)) && !slab_early_init)
 /*
 * Size is large, assume best to place the slab management obj
 * off-slab (should allow better packing of objs).
 */
 flags |= CFLGS_OFF_SLAB;

这个if判断 slab 默认的管理数据是位于 slab 内部还是外部，判断的条件之一是 slab_early_init 是否为零（kmem_cache_init()函数）在2+3）步骤时赋值为0），这也说明了 SLAB 初始化完毕之前， slab 的管理数据默认只能待在 slab 内部。

函数判断如果 slab 管理数据位于 slab 外部，必须满足这几个条件: 其一高速缓存对象的长度不小于 “PAGE_SIZE » 3”, 其二 SLAB 分配器已经过了基础初始化阶段，只有同时满足上面条件，那么 slab 的管理数据才能位于 slab 外部. 如果条件都满足了，那么函数将 CFLAGS_OFF_SLAB 标志添加到 flags 参数里面. （在后来版本的内核中还加入了第三个条件： flags 标志不能包含 SLAB_NOLEAKTRACE.）

计算slab的容量

 size = ALIGN(size, align); /* 获得高速缓存对象对齐之后的长度 */

 left_over = calculate_slab_order(cachep, size, align, flags); /* 计算出高速缓存每个 slab 维护缓存对象的数量， */

 if (!cachep->num) {
 printk(KERN_ERR
 "kmem_cache_create: couldn't create cache %s.\n", name);
 kmem_cache_free(&cache_cache, cachep);
 cachep = NULL;
 goto oops;
 }
 slab_size = ALIGN(cachep->num * sizeof(kmem_bufctl_t)
 + sizeof(struct slab), align); /* 计算除了 slab 管理数据的长度，并存储在 slab_size 变量中. */

首先，获得高速缓存对象对齐之后的长度，然后，调用 calculate_slab_order() 函数计算出高速缓存每个 slab 维护缓存对象的数量，然后，计算每个 slab 占用物理页的数量，并计算出每个 slab 剩余的内存数量. 函数在 2306 行计算除了 slab 管理数据的长度，并存储在 slab_size 变量中.

最终确定slab管理数据的存储位置

 /*
 * If the slab has been placed off-slab, and we have enough space then
 * move it on-slab. This is at the expense of any extra colouring.
 */
 if (flags & CFLGS_OFF_SLAB && left_over >= slab_size) {
 flags &= ~CFLGS_OFF_SLAB;
 left_over -= slab_size;
 }

 if (flags & CFLGS_OFF_SLAB) {
 /* really off slab. No need for manual alignment */
 slab_size =
 cachep->num * sizeof(kmem_bufctl_t) + sizeof(struct slab);
 }

检测 slab 的管理数据是否位于 slab 外面，同时也检测 slab 剩余的内存是否比 slab 管理数据大。

如果高速缓存的 flags 参数包含了 CFLAGS_OFF_SLAB 标志，即表示想让 slab 管理数据位于 slab 外部，当如果此时 slab 管理数据的长度小于等于 slab 剩余的内存，那么 SLAB 分配器不会让该高速缓存的 slab 管理数据位于 slab 外部，因此将 CFLAGS_OFF_SLAB 标志从 flags 中移除，并将 slab 中剩余的内存减去了 slab 管理数据的长度.

函数接着检测 slab 管理数据是否位于 slab 外部，如果此时 slab 管理数据位于 slab 外部，那么 SLAB 分配器需要独立计算 slab 管理数据占用的内存数量，从上图可以看出 slab 管理数据包括了 struct slab 以及 kmem_bufctl 数组，kmem_bufctl 数组的长度与 slab 中位于缓存对象数量有关.

计算slab着色

 cachep->colour_off = cache_line_size();
 /* Offset must be a multiple of the alignment. */
 if (cachep->colour_off < align)
 cachep->colour_off = align;
/*2337*/cachep->colour = left_over / cachep->colour_off;
 cachep->slab_size = slab_size;
 cachep->flags = flags;
 cachep->gfpflags = 0;
 if (CONFIG_ZONE_DMA_FLAG && (flags & SLAB_CACHE_DMA))
 cachep->gfpflags |= GFP_DMA;
 cachep->buffer_size = size;
 cachep->reciprocal_buffer_size = reciprocal_value(size);

调用cache_line_size() 计算出当前 cache line 的长度，以此作为高速缓存着色的长度，存储在高速缓存的 colour_off 成员里，如果 cache line 的长度小于之前计算出来的对齐长度，那么函数还是将高速缓存的着色长度设置为 align。

函数在 2337 行将之前获得的 slab 剩余的内存除以着色长度，以此获得高速缓存着色范围，并存储在高速缓存的 colour 成员里.

接着在 2338 行将 slab 管理数据的长度存储在高速缓存的 slab_size 成员里，

2339 行将高速缓存的创建标志存在在 flags 成员里，

并在 2341 行到 2342 行计算高速缓存从 Buddy 分配器中获得物理页的标志.

2343 行将缓存对象的长度存储在高速缓存的 buffer_size 成员里.

初始化slab构造函数

 if (flags & CFLGS_OFF_SLAB) {
 cachep->slabp_cache = kmem_find_general_cachep(slab_size, 0u);
 /*
 * This is a possibility for one of the malloc_sizes caches.
 * But since we go off slab only for object size greater than
 * PAGE_SIZE/8, and malloc_sizes gets created in ascending order,
 * this should not happen at all.
 * But leave a BUG_ON for some lucky dude.
 */
 BUG_ON(ZERO_OR_NULL_PTR(cachep->slabp_cache));
 }
 cachep->ctor = ctor; /* 设置了高速缓存的构造函数 */
 cachep->name = name; /* 设置了高速缓存的名字*/

检测 slab 管理数据是否位于 slab 外部，如果位于，那么函数调用kmem_find_general_cachep() 函数根据 slab 管理数据的长度，从 SLAB 中获得一个合适的通用高速缓存，并使用高速缓存的 slabp_cache 指向该通用高速缓存.

之后函数设置了高速缓存的构造函数和高速缓存的名字.

初始化本地以及共享的高速缓存


 if (setup_cpu_cache(cachep)) {
 __kmem_cache_destroy(cachep);
 cachep = NULL;
 goto oops;
 }

 /* cache setup completed, link it into the list */
 list_add(&cachep->next, &cache_chain);

调用setup_cpu_cache() 函数用于设置高速缓存的本地高速缓存、共享高速缓存以及 slab 链表. 如果设置失败，那么函数调用 __kmem_cache_destroy() 函数摧毁该高速缓存，并将高速缓存指针 cachep 设置为 NULL, 最后跳转到 oops. 如果分配成功，那么将高速缓存插入到系统高速缓存链表 cache_chain 里.

setup_cpu_cache()

在每个高速缓存中，SLAB 分配器为加速高速缓存的分配速度，为每个 CPU 创建了一个本地高速缓存，其使用一个缓存栈维护一定数量的可用缓存对象.

由于 SLAB 分配器的初始化分作多个阶段，每个阶段都涉及到为高速缓存创建本地高速缓存。

SLAB 分配器使用 g_cpucache_up 变量来标示 SLAB 分配器的初始化进度。

SLAB 分配器初始化的第一阶段，这个阶段struct kmem_list3 和struct cache_array 对应的高速缓存还没有创建，因此为该阶段的高速缓存分配本地缓存只能使用静态变量initarray_generic对应的本地高速缓存，由于这个阶段只有一个 CPU 在运行，因此函数在首先设置了本地高速缓存.

然后调用set_up_list3s()函数设置这个阶段的kmem_list3 链表. 如果此时INDEX_AC 的值与INDEX_L3的值相等，那么函数将 SLAB 初始化进度设置为 PARTIAL_L3; 反之设置为 PARTIAL_AC。通过源码分析可以知道，此时 INDEX_AC 与 INDEX_L3不相等，因此将 SLAB 分配器初始化进度设置为 PARTIAL_AC.

SLAB 分配器初始化进度达到第二阶段之后，首先为高速缓存分配本地高速缓存, 此时 kmalloc() 函数已经可以使用，2047 行到 2048 行，函数调用kmalloc()函数为高速缓存分配内存，此时系统还是只有一个 CPU，由于此时 SLAB 分配器初始化进度是 PARTIAL_AC，因此函数在 2051 行将 SLAB 分配器初始化进度设置为 PARTIAL_L3;

当 SLAB 分配器初始化进入第三阶段，此时系统中多个 CPU 已经可以使用，因此函数在 2055 行遍历所有的在线 CPU，并调用 kmalloc_node() 函数为每个 CPU 分配本地高速缓存，并调用 kmem_list3_init()函数初始化高速缓存的kmem_list3链表. 对于 SLAB 分配器初始化进度前三个阶段，SLAB 分配器将这些阶段的本地缓存维护的缓存对象控制在 BOOT_CPUCACHE_ENTRIES 个.

函数 2068 行到 2073 行初始化了基础的成员.

SLAB 分配器初始化进度到第四阶段，即 g_cpucache_up 等于 FULL, 那么函数在 2026 行调用 enable_cpucache() 函数初始化高速缓存的本地高速缓存、共享高速缓存，以及kmem_list3 slab 链表.

setup_cpu_cache()函数用于为高速缓存设置本地高速缓存. 参数 cachep 指向高速缓存。


static int __init_refok setup_cpu_cache(struct kmem_cache *cachep)
{
 if (g_cpucache_up == FULL)
 return enable_cpucache(cachep); /* 2026 行 */

 if (g_cpucache_up == NONE) { /* slab分配器处于初始化第一阶段 */
 /*
 * Note: the first kmem_cache_create must create the cache
 * that's used by kmalloc(24), otherwise the creation of
 * further caches will BUG().
 */
 cachep->array[smp_processor_id()] = &initarray_generic.cache; /*设置了本地高速缓存*/

 /*
 * If the cache that's used by kmalloc(sizeof(kmem_list3)) is
 * the first cache, then we need to set up all its list3s,
 * otherwise the creation of further caches will BUG().
 */
 set_up_list3s(cachep, SIZE_AC); /* 设置初始化阶段的kmem_list3链表 */
 if (INDEX_AC == INDEX_L3)
 g_cpucache_up = PARTIAL_L3;
 else
 g_cpucache_up = PARTIAL_AC;
 } else { /*第二阶段*/
/*2047*/ cachep->array[smp_processor_id()] =
 kmalloc(sizeof(struct arraycache_init), GFP_KERNEL);

 if (g_cpucache_up == PARTIAL_AC) {
 set_up_list3s(cachep, SIZE_L3);
 g_cpucache_up = PARTIAL_L3; /*2051 */
 } else { /*第三阶段*/
 int node;
 for_each_online_node(node) {
 cachep->nodelists[node] =
 kmalloc_node(sizeof(struct kmem_list3),
 GFP_KERNEL, node);
 BUG_ON(!cachep->nodelists[node]);
 kmem_list3_init(cachep->nodelists[node]);
 }
 }
 }
 cachep->nodelists[numa_node_id()]->next_reap =
 jiffies + REAPTIMEOUT_LIST3 +
 ((unsigned long)cachep) % REAPTIMEOUT_LIST3;
 /*初始化了基础的成员*/
 cpu_cache_get(cachep)->avail = 0; /*2068*/
 cpu_cache_get(cachep)->limit = BOOT_CPUCACHE_ENTRIES;
 cpu_cache_get(cachep)->batchcount = 1;
 cpu_cache_get(cachep)->touched = 0;
 cachep->batchcount = 1;
 cachep->limit = BOOT_CPUCACHE_ENTRIES;
 return 0;
}

enable_cpucache()

enable_cpucache() 函数用于计算一个高速缓存的本地缓存维护缓存对象的数量，以及高速缓存对应的共享高速缓存维护缓存对象的数量，并为高速缓存分配本地缓存和 kmem_list3 链表, 最后更新本地缓存.

/* Called with cache_chain_mutex held always */
static int enable_cpucache(struct kmem_cache *cachep)
{
 int err;
 int limit, shared;

 /*
 * The head array serves three purposes:
 * - create a LIFO ordering, i.e. return objects that are cache-warm
 * - reduce the number of spinlock operations.
 * - reduce the number of linked list operations on the slab and
 * bufctl chains: array operations are cheaper.
 * The numbers are guessed, we should auto-tune as described by
 * Bonwick.
 */
 if (cachep->buffer_size > 131072) /* 3971 */
 limit = 1;
 else if (cachep->buffer_size > PAGE_SIZE)
 limit = 8;
 else if (cachep->buffer_size > 1024)
 limit = 24;
 else if (cachep->buffer_size > 256)
 limit = 54;
 else
 limit = 120; /* 3980 */

 /*
 * CPU bound tasks (e.g. network routing) can exhibit cpu bound
 * allocation behaviour: Most allocs on one cpu, most free operations
 * on another cpu. For these cases, an efficient object passing between
 * cpus is necessary. This is provided by a shared array. The array
 * replaces Bonwick's magazine layer.
 * On uniprocessor, it's functionally equivalent (but less efficient)
 * to a larger limit. Thus disabled by default.
 */
 shared = 0; /* 3991 */
 if (cachep->buffer_size <= PAGE_SIZE && num_possible_cpus() > 1)
 shared = 8;

#if DEBUG
 /*
 * With debugging enabled, large batchcount lead to excessively long
 * periods with disabled local interrupts. Limit the batchcount
 */
 if (limit > 32)
 limit = 32;
#endif
 err = do_tune_cpucache(cachep, limit, (limit + 1) / 2, shared); /* 4003 */
 if (err)
 printk(KERN_ERR "enable_cpucache failed for %s, error %d.\n",
 cachep->name, -err);
 return err;
}

SLAB 分配器为加快高速缓存的分配速度，为每个 CPU 创建了一个本地高速缓存，其使用一个缓存栈维护一定数量的可用缓存对象，每个 CPU 都可以快速从缓存栈上分配可用的缓存对象.

SLAB 分配器还为高速缓存创建了一个共享高速缓存，所有 CPU 都可以从共享高速缓存中获得可用的缓存对象。

SLAB 分配器使用 kmem_list3 链表为高速缓存在指定 NODE 上维护了 3 类链表，以此管理指定的 slab。

enable_cpucache() 函数就是用于为一个高速缓存规划本地高速缓存和共享高速缓存中维护缓存对象的数量，以及创建并更新本地缓存，最后为高速缓存创建 kmem_list3 链表。

函数 3971 行到 3980 行用于计算一个高速缓存对应的本地高速缓存维护可用缓存对象的数量，从代码逻辑可以推断高速缓存对象越大，本地高速缓存能够维护可用缓存对象数量越少。

3991 行到 3993 行，如果高速缓存对象的大小不大于 PAGE_SIZE, 且 num_possible_cpus() 数量大于 1，即 CPU 数量大于 1，那么将共享高速缓存维护的缓存对象设置为 8.

最后函数在 4003 行处调用 do_tune_cpucache() 函数为高速缓存创建了本地高速缓存和共享高速缓存，以及 kmem_list3 链表.

do_tune_cpucache()

do_tune_cpucache() 函数用于为缓存分配本地缓存、共享缓存和 l3 链表.

参数 cachep 指向缓存，limit 用于指明本地缓存最大缓存对象的数量。

shared 参数用于指明共享缓存中缓存对象的数量;

函数 3920 行调用 kzalloc() 函数为 struct ccupdate_struct 分配新的内存。

3924 行到 3933 行，函数调用 for_each_online_cpu() 函数遍历所有的 CPU，并基于 struct ccupdate_struct 结构为 CPU 分配本地缓存结构 struct cache_array, 通过 alloc_arraycache()函数进行分配.

函数 3936 行调用 on_each_cpu() 函数与 do_ccupdate_local() 函数更新当前高速缓存的本地缓存.

接着函数设置了高速缓存的 batchcount, limit 以及 shared 成员.

函数 3943 行到 3951 行遍历所有在线的 CPU，如果发生了 CPU 热插拔事件之后，离线的 CPU 没有释放本地缓存，那么函数并检测高速缓存对应的本地缓存是否存在，如果存在，那么释放本地缓存. 函数最后释放 new 变量，并调用 alloc_kmemlist() 函数为高速缓存分配kmem_list3链表数据.

static int do_tune_cpucache(struct kmem_cache *cachep, int limit,
 int batchcount, int shared)
{
 struct ccupdate_struct *new;
 int i;

 new = kzalloc(sizeof(*new), GFP_KERNEL); /* 3920 */
 if (!new)
 return -ENOMEM;

 for_each_online_cpu(i) { /* 3924 */
 new->new[i] = alloc_arraycache(cpu_to_node(i), limit,
 batchcount);
 if (!new->new[i]) {
 for (i--; i >= 0; i--)
 kfree(new->new[i]);
 kfree(new);
 return -ENOMEM;
 }
 } /* 3933 */
 new->cachep = cachep;

 on_each_cpu(do_ccupdate_local, (void *)new, 1); /* 3936 */

 check_irq_on();
 cachep->batchcount = batchcount;
 cachep->limit = limit;
 cachep->shared = shared;

 for_each_online_cpu(i) { /* 3943 */
 struct array_cache *ccold = new->new[i];
 if (!ccold)
 continue;
 spin_lock_irq(&cachep->nodelists[cpu_to_node(i)]->list_lock);
 free_block(cachep, ccold->entry, ccold->avail, cpu_to_node(i));
 spin_unlock_irq(&cachep->nodelists[cpu_to_node(i)]->list_lock);
 kfree(ccold);
 } /* 3951 */
 kfree(new);
 return alloc_kmemlist(cachep);
}

alloc_arraycache()

alloc_kmemlist()

struct ccupdate_struct

oops的处理流程

oops:
 if (!cachep && (flags & SLAB_PANIC))
 panic("kmem_cache_create(): failed to create slab `%s'\n",
 name);
 mutex_unlock(&cache_chain_mutex);
 put_online_cpus();
 return cachep;
}
EXPORT_SYMBOL(kmem_cache_create);

oops的处理流程：首先判断高速缓存是否已经成功分配了，如果没有成功分配且flags 中包含了SLAB_PANIC标志，那么调用 panic() 函数. 否则，函数解除 cache_chain_mutex 互斥锁，并调用 put_online_cpus() 函数。函数最后返回指向高速缓存的指针 cachep，并将该函数通过 EXPORT_SYMBOL() 导出给内核其他部分使用.

kmem_cache_alloc

kmem_cache_alloc()函数用于从缓存对象中分配一个可用的缓存对象. 参数 cachep 指向缓存对象; 参数flags用于指明分配物理内存标志。


/**
 * kmem_cache_alloc - Allocate an object
 * @cachep: The cache to allocate from.
 * @flags: See kmalloc().
 *
 * Allocate an object from this cache. The flags are only relevant
 * if the cache has no available objects.
 */
void *kmem_cache_alloc(struct kmem_cache *cachep, gfp_t flags)
{
 void *ret = __cache_alloc(cachep, flags, __builtin_return_address(0));

 trace_kmem_cache_alloc(_RET_IP_, ret,
 obj_size(cachep), cachep->buffer_size, flags);

 return ret;
}
EXPORT_SYMBOL(kmem_cache_alloc);

__cache_alloc()定义如下

static __always_inline void *
__cache_alloc(struct kmem_cache *cachep, gfp_t flags, void *caller)
{
 unsigned long save_flags;
 void *objp;

 lockdep_trace_alloc(flags);

 if (slab_should_failslab(cachep, flags))
 return NULL;

 cache_alloc_debugcheck_before(cachep, flags);
 local_irq_save(save_flags);
 objp = __do_cache_alloc(cachep, flags); /* 分配可用的缓存对象 */
 local_irq_restore(save_flags);
 objp = cache_alloc_debugcheck_after(cachep, flags, objp, caller);
 prefetchw(objp); /* 将可用缓存对象预加载到 CACHE */

 if (unlikely((flags & __GFP_ZERO) && objp)) /* 如果检测到 flags 参数中包含了 __GFP_ZERO 标志， */
 memset(objp, 0, obj_size(cachep)); /* 调用 memset() 函数将缓存对象指向的内存清零. */

 return objp; /* 最后返回缓存对象. */
}

__cache_alloc() 函数用于从缓存对象中分配可用的缓存对象. 参数 cachep 指向缓存对象; 参数 flags 指向物理内存分配标志; 参数 caller 用于指向申请者.

UMA平台

static __always_inline void *
__do_cache_alloc(struct kmem_cache *cachep, gfp_t flags)
{
 return ____cache_alloc(cachep, flags);
}

____cache_alloc()函数

static inline void *____cache_alloc(struct kmem_cache *cachep, gfp_t flags)
{
 void *objp;
 struct array_cache *ac;

 check_irq_off();

 ac = cpu_cache_get(cachep); /* 获得缓存对应的缓存栈 */
 if (likely(ac->avail)) { /* 检测缓存栈的栈顶, 以此判断缓存栈里是否有可用的缓存对象，如果栈顶不为零，即 avail 成员不为 0 */
 STATS_INC_ALLOCHIT(cachep);
 ac->touched = 1;
 objp = ac->entry[--ac->avail]; /* 从缓存栈上获得可用的缓存对象, 并更新缓存栈的栈顶*/
 } else { /* 如果栈顶为 0，那么表示缓存栈上没有可用的缓存对象 */
 STATS_INC_ALLOCMISS(cachep);
 objp = cache_alloc_refill(cachep, flags); /*调用 cache_alloc_refill() 函数将一定数量的可用缓存对象添加到缓存栈上，并再次使用 ac 变量指向缓存栈. */
 }
 return objp;
}

在 SLAB 分配器里，为了加速缓存对象的分配，SLAB 分配器为缓存对象针对每个 CPU 构建了一个缓存栈，CPU 可以快速从缓存栈上获得可用的缓存对象。其实现原理如上图，缓存对象使用 struct kmem_cache 进行维护，其成员 array 是一个 struct cache_array 数组，数组中的每个成员对应一个缓存栈，因此 struct cache_array 维护着一个缓存栈.

cpu_cache_get()

static inline struct array_cache *cpu_cache_get(struct kmem_cache *cachep)
{
 return cachep->array[smp_processor_id()];
}

cache_alloc_refill()

每当 SLAB 分配缓存对象的时候，如果发现缓存栈上没有可用的缓存对象时候，

那么 SLAB 分配器就会检测缓存对象的 slabs_partial 上是否有可用的 slab，

如果有，那么 SLAB 从 slabs_partial 的 slab 上获取 batchcount 数量的缓存对象到缓存栈里;

如果 slabs_partial 上没有可用的 slab，那么 SLAB 分配器检测 slabs_free 上时候有可用的 slab，

如果有，那么就从对应的 slab 上获得 batchcount 数量的缓存对象到缓存栈上;

如果此时 slabs_free 上也找不到 slab，

那么 SLAB 分配器需要为缓存对象扩充新的 slab，那么 SLAB 分配器从 Buddy 分配指定数量的物理内存，并将这些内存组织成新的 slab，并插入到 slabs_free 链表上，并重新执行之前的查找过程.

重新查找的过程中，slabs_free 链表上有可用的 slab，那么缓存栈获得 batchcount 数量的缓存对象之后，将 slab 从 slabs_free 上移除并插入到 slabs_partial 链表上。

static void *cache_alloc_refill(struct kmem_cache *cachep, gfp_t flags)
{
 int batchcount;
 struct kmem_list3 *l3;
 struct array_cache *ac;
 int node;

retry:
 check_irq_off();
 node = numa_node_id();
 ac = cpu_cache_get(cachep); /* 获得缓存对象对应的缓存栈，通过 ac 进行指定 */

 batchcount = ac->batchcount;
 if (!ac->touched && batchcount > BATCHREFILL_LIMIT) {
 /*
 * If there was little recent activity on this cache, then
 * perform only a partial refill. Otherwise we could generate
 * refill bouncing.
 */
 batchcount = BATCHREFILL_LIMIT;
 }
 l3 = cachep->nodelists[node]; /* 获得缓存对象的 kmem_list3 链表，通过l3进行指定 */

 BUG_ON(ac->avail > 0 || !l3);
 spin_lock(&l3->list_lock);

 /* See if we can refill from the shared array */
 if (l3->shared && transfer_objects(ac, l3->shared, batchcount))
 goto alloc_done;

 while (batchcount > 0) { /* 检测缓存栈的 batchount 是否大于 0，以此确认缓存栈是否在使用，如果小于 1，那么缓存栈不再使用*/
 struct list_head *entry;
 struct slab *slabp;
 /* Get slab alloc is to come from. */
 entry = l3->slabs_partial.next;
 if (entry == &l3->slabs_partial) {
 l3->free_touched = 1;
 entry = l3->slabs_free.next;
 if (entry == &l3->slabs_free) /* 如果最终slabs_free上都没有找到可用的 slab */
 goto must_grow; /*那么函数跳转到 must_grow分配新的 slab*/
 }
 /* 找到从 slabs_partial/slabs_free 里找到一个可用的 slab */
 slabp = list_entry(entry, struct slab, list);
 check_slabp(cachep, slabp);
 check_spinlock_acquired(cachep);

 /*
 * The slab was either on partial or free list so
 * there must be at least one object available for
 * allocation.
 */
 BUG_ON(slabp->inuse >= cachep->num);

 /*
 while 循环，只要确认缓存对象正在使用的缓存对象数量小于缓存对象总数，并且 batchcount 不为0，
 那么进入循环，在循环中，函数不断从 slab 中将可用缓存对象加入到缓存栈里，并更新缓存栈的栈顶
 */
 while (slabp->inuse < cachep->num && batchcount--) {
 STATS_INC_ALLOCED(cachep);
 STATS_INC_ACTIVE(cachep);
 STATS_SET_HIGH(cachep);

 ac->entry[ac->avail++] = slab_get_obj(cachep, slabp,
 node);
 }
 check_slabp(cachep, slabp);
 /*
 将 slab 从原先的链表中移除，
 如果此时slab 中没有可用的缓存对象，那么将 slab 插到slabs_full 链表中，
 如果此时 slab 中还有部分可用缓存对象，那么将 slab 插入到 slabs_partial 链表中.
 */
 /* move slabp to correct slabp list: */
 list_del(&slabp->list);
 if (slabp->free == BUFCTL_END)
 list_add(&slabp->list, &l3->slabs_full);
 else
 list_add(&slabp->list, &l3->slabs_partial);
 }

must_grow:
 l3->free_objects -= ac->avail;
alloc_done:
 spin_unlock(&l3->list_lock);

 if (unlikely(!ac->avail)) {
 int x;
 x = cache_grow(cachep, flags | GFP_THISNODE, node, NULL); /* 调用 cache_grow() 函数进行分配 新的 slab */

 /* cache_grow can reenable interrupts, then ac could change. */
 ac = cpu_cache_get(cachep);
 if (!x && ac->avail == 0) /* no objects in sight? abort */
 return NULL;
 /* 函数再次检测缓存栈是否等于 0，如果为真，那么函数重新从缓存栈上分配新的可用缓存栈 */
 if (!ac->avail) /* objects refilled by interrupt? */
 goto retry;
 }
 ac->touched = 1; /*当缓存栈被访问，那么缓存栈 的 touch 标记为 1*/
 return ac->entry[--ac->avail]; /* 从缓存栈中返回一个可用缓存对象.*/
}

cache_grow()

cache_grow() 函数用于扩充缓存对象的 slab。cachep 参数指向缓存对象; flags 参数用于从 Buddy 分配器中分配内存的标志; nodeid 参数用于指明 NODE 信息; objp 用于指向 slab.

SLAB 分配器在为缓存对象分配新的 slab 时，首先从 Buddy 分配器中分配指定数量的物理页，然后将这些物理内存进行组织，将其转换成 slab，转换之后在将 slab 对应的物理页与缓存对象和 slab 进行绑定，最后初始化 slab 的 kmem_bufctl 数组。新的 slab 创建完毕之后，将其插入缓存对象的 slabs_free 链表。

/*
 * Grow (by 1) the number of slabs within a cache. This is called by
 * kmem_cache_alloc() when there are no active objs left in a cache.
 */
static int cache_grow(struct kmem_cache *cachep,
 gfp_t flags, int nodeid, void *objp)
{
 struct slab *slabp;
 size_t offset;
 gfp_t local_flags;
 struct kmem_list3 *l3;

 /*
 * Be lazy and only check for valid flags here, keeping it out of the
 * critical path in kmem_cache_alloc().
 */
 /* 对分配物理内存的标志进行检查，以此确认分配的物理页是否可以回收或者不可以回收 */
 BUG_ON(flags & GFP_SLAB_BUG_MASK);
 local_flags = flags & (GFP_CONSTRAINT_MASK|GFP_RECLAIM_MASK);

 /* Take the l3 list lock to change the colour_next on this node */
 check_irq_off();
 l3 = cachep->nodelists[nodeid]; /* 获得缓存对象在指定 NODE 的 kmem_list3 数据结构*/
 spin_lock(&l3->list_lock);

 /* Get colour for the slab, and cal the next value. */
 offset = l3->colour_next; /* 获得了当前着色信息 */
 l3->colour_next++;
 /* 更新缓存对象的下一个着色信息 */
 if (l3->colour_next >= cachep->colour)
 l3->colour_next = 0; /* 如果下一个着色信息超过了缓存支持的着色范围，那么将下一个着色信息设置为 0 */
 spin_unlock(&l3->list_lock);

 offset *= cachep->colour_off; /* 计算着色预留的内存长度 */

 if (local_flags & __GFP_WAIT)
 local_irq_enable();

 /*
 * The test for missing atomic flag is performed here, rather than
 * the more obvious place, simply to reduce the critical path length
 * in kmem_cache_alloc(). If a caller is seriously mis-behaving they
 * will eventually be caught here (where it matters).
 */
 kmem_flagcheck(cachep, flags);

 /*
 * Get mem for the objs. Attempt to allocate a physical page from
 * 'nodeid'.
 */
 if (!objp)
 objp = kmem_getpages(cachep, local_flags, nodeid); /* 从 Buddy 分配器中分配指定数量的物理内存，并获得物理内存对应的虚拟地址，存储中objp 变量里 */
 if (!objp)
 goto failed;

 /* Get slab management. */
 /*
 把新分配的内存组织成一个 slab,
 无论 slab 采用 外部管理数据还是内部管理数据，函数都返回了 slab 管理数据对应的 struct slab 指针
 */
 slabp = alloc_slabmgmt(cachep, objp, offset,
 local_flags & ~GFP_CONSTRAINT_MASK, nodeid);
 if (!slabp)
 goto opps1;

 slab_map_pages(cachep, slabp, objp); /* 将从 Buddy 分配器分配的物理页 与缓存对象和 slab 进行绑定 */

 cache_init_objs(cachep, slabp); /* 初始化 slab 的 kmem_bufctl 数组 */

 if (local_flags & __GFP_WAIT)
 local_irq_disable();
 check_irq_off();
 spin_lock(&l3->list_lock);

 /* Make slab active. */
 /*
 将 slab 加入到缓存对象的 slabs_free 链表里，
 并添加缓存对象的 kmem_list3 的 free_objects 可用对象数量.
 */
 list_add_tail(&slabp->list, &(l3->slabs_free));
 STATS_INC_GROWN(cachep);
 l3->free_objects += cachep->num;
 spin_unlock(&l3->list_lock);
 return 1;
opps1:
 kmem_freepages(cachep, objp);
failed:
 if (local_flags & __GFP_WAIT)
 local_irq_disable();
 return 0;
}

kmem_getpages()

从 Buddy 分配器中分配指定数量的物理内存，并获得物理内存对应的虚拟地址，存储中objp 变量里。

/*
 * Interface to system's page allocator. No need to hold the cache-lock.
 *
 * If we requested dmaable memory, we will get it. Even if we
 * did not request dmaable memory, we might get it, but that
 * would be relatively rare and ignorable.
 */
static void *kmem_getpages(struct kmem_cache *cachep, gfp_t flags, int nodeid)
{
 struct page *page;
 int nr_pages;
 int i;

#ifndef CONFIG_MMU
 /*
 * Nommu uses slab's for process anonymous memory allocations, and thus
 * requires __GFP_COMP to properly refcount higher order allocations
 */
 flags |= __GFP_COMP;
#endif

 flags |= cachep->gfpflags;
 if (cachep->flags & SLAB_RECLAIM_ACCOUNT)
 flags |= __GFP_RECLAIMABLE;

 page = alloc_pages_node(nodeid, flags, cachep->gfporder);
 if (!page)
 return NULL;

 nr_pages = (1 << cachep->gfporder);
 if (cachep->flags & SLAB_RECLAIM_ACCOUNT)
 add_zone_page_state(page_zone(page),
 NR_SLAB_RECLAIMABLE, nr_pages);
 else
 add_zone_page_state(page_zone(page),
 NR_SLAB_UNRECLAIMABLE, nr_pages);
 for (i = 0; i < nr_pages; i++)
 __SetPageSlab(page + i);
 return page_address(page);
}

alloc_slabmgmt()

把新分配的内存组织成一个 slab, 无论 slab 采用外部管理数据还是内部管理数据，函数都返回了 slab 管理数据对应的 struct slab 指针。

/*
 * Get the memory for a slab management obj.
 * For a slab cache when the slab descriptor is off-slab, slab descriptors
 * always come from malloc_sizes caches. The slab descriptor cannot
 * come from the same cache which is getting created because,
 * when we are searching for an appropriate cache for these
 * descriptors in kmem_cache_create, we search through the malloc_sizes array.
 * If we are creating a malloc_sizes cache here it would not be visible to
 * kmem_find_general_cachep till the initialization is complete.
 * Hence we cannot have slabp_cache same as the original cache.
 */
static struct slab *alloc_slabmgmt(struct kmem_cache *cachep, void *objp,
 int colour_off, gfp_t local_flags,
 int nodeid)
{
 struct slab *slabp;

 if (OFF_SLAB(cachep)) {
 /* Slab management obj is off-slab. */
 slabp = kmem_cache_alloc_node(cachep->slabp_cache,
 local_flags, nodeid);
 if (!slabp)
 return NULL;
 } else {
 slabp = objp + colour_off;
 colour_off += cachep->slab_size;
 }
 slabp->inuse = 0;
 slabp->colouroff = colour_off;
 slabp->s_mem = objp + colour_off;
 slabp->nodeid = nodeid;
 slabp->free = 0;
 return slabp;
}

slab_map_pages()

将从 Buddy 分配器分配的物理页与缓存对象和 slab 进行绑定。

/*
 * Grow (by 1) the number of slabs within a cache. This is called by
 * kmem_cache_alloc() when there are no active objs left in a cache.
 */
static int cache_grow(struct kmem_cache *cachep,
 gfp_t flags, int nodeid, void *objp)
{
 struct slab *slabp;
 size_t offset;
 gfp_t local_flags;
 struct kmem_list3 *l3;

 /*
 * Be lazy and only check for valid flags here, keeping it out of the
 * critical path in kmem_cache_alloc().
 */
 BUG_ON(flags & GFP_SLAB_BUG_MASK);
 local_flags = flags & (GFP_CONSTRAINT_MASK|GFP_RECLAIM_MASK);

 /* Take the l3 list lock to change the colour_next on this node */
 check_irq_off();
 l3 = cachep->nodelists[nodeid];
 spin_lock(&l3->list_lock);

 /* Get colour for the slab, and cal the next value. */
 offset = l3->colour_next;
 l3->colour_next++;
 if (l3->colour_next >= cachep->colour)
 l3->colour_next = 0;
 spin_unlock(&l3->list_lock);

 offset *= cachep->colour_off;

 if (local_flags & __GFP_WAIT)
 local_irq_enable();

 /*
 * The test for missing atomic flag is performed here, rather than
 * the more obvious place, simply to reduce the critical path length
 * in kmem_cache_alloc(). If a caller is seriously mis-behaving they
 * will eventually be caught here (where it matters).
 */
 kmem_flagcheck(cachep, flags);

 /*
 * Get mem for the objs. Attempt to allocate a physical page from
 * 'nodeid'.
 */
 if (!objp)
 objp = kmem_getpages(cachep, local_flags, nodeid);
 if (!objp)
 goto failed;

 /* Get slab management. */
 slabp = alloc_slabmgmt(cachep, objp, offset,
 local_flags & ~GFP_CONSTRAINT_MASK, nodeid);
 if (!slabp)
 goto opps1;

 slab_map_pages(cachep, slabp, objp);

 cache_init_objs(cachep, slabp);

 if (local_flags & __GFP_WAIT)
 local_irq_disable();
 check_irq_off();
 spin_lock(&l3->list_lock);

 /* Make slab active. */
 list_add_tail(&slabp->list, &(l3->slabs_free));
 STATS_INC_GROWN(cachep);
 l3->free_objects += cachep->num;
 spin_unlock(&l3->list_lock);
 return 1;
opps1:
 kmem_freepages(cachep, objp);
failed:
 if (local_flags & __GFP_WAIT)
 local_irq_disable();
 return 0;
}

cache_init_objs()

初始化 slab 的 kmem_bufctl 数组。

static void cache_init_objs(struct kmem_cache *cachep,
 struct slab *slabp)
{
 int i;

 for (i = 0; i < cachep->num; i++) {
 void *objp = index_to_obj(cachep, slabp, i);
#if DEBUG
 /* need to poison the objs? */
 if (cachep->flags & SLAB_POISON)
 poison_obj(cachep, objp, POISON_FREE);
 if (cachep->flags & SLAB_STORE_USER)
 *dbg_userword(cachep, objp) = NULL;

 if (cachep->flags & SLAB_RED_ZONE) {
 *dbg_redzone1(cachep, objp) = RED_INACTIVE;
 *dbg_redzone2(cachep, objp) = RED_INACTIVE;
 }
 /*
 * Constructors are not allowed to allocate memory from the same
 * cache which they are a constructor for. Otherwise, deadlock.
 * They must also be threaded.
 */
 if (cachep->ctor && !(cachep->flags & SLAB_POISON))
 cachep->ctor(objp + obj_offset(cachep));

 if (cachep->flags & SLAB_RED_ZONE) {
 if (*dbg_redzone2(cachep, objp) != RED_INACTIVE)
 slab_error(cachep, "constructor overwrote the"
 " end of an object");
 if (*dbg_redzone1(cachep, objp) != RED_INACTIVE)
 slab_error(cachep, "constructor overwrote the"
 " start of an object");
 }
 if ((cachep->buffer_size % PAGE_SIZE) == 0 &&
 OFF_SLAB(cachep) && cachep->flags & SLAB_POISON)
 kernel_map_pages(virt_to_page(objp),
 cachep->buffer_size / PAGE_SIZE, 0);
#else
 if (cachep->ctor)
 cachep->ctor(objp);
#endif
 slab_bufctl(slabp)[i] = i + 1;
 }
 slab_bufctl(slabp)[i - 1] = BUFCTL_END;
}

kmem_cache_free


/**
 * kmem_cache_free - Deallocate an object
 * @cachep: The cache the allocation was from.
 * @objp: The previously allocated object.
 *
 * Free an object which was previously allocated from this
 * cache.
 */
void kmem_cache_free(struct kmem_cache *cachep, void *objp)
{
 unsigned long flags;

 local_irq_save(flags);
 debug_check_no_locks_freed(objp, obj_size(cachep));
 if (!(cachep->flags & SLAB_DEBUG_OBJECTS))
 debug_check_no_obj_freed(objp, obj_size(cachep));
 __cache_free(cachep, objp);
 local_irq_restore(flags);

 trace_kmem_cache_free(_RET_IP_, objp);
}
EXPORT_SYMBOL(kmem_cache_free);

kmem_cache_destroy


/**
 * kmem_cache_destroy - delete a cache
 * @cachep: the cache to destroy
 *
 * Remove a &struct kmem_cache object from the slab cache.
 *
 * It is expected this function will be called by a module when it is
 * unloaded. This will remove the cache completely, and avoid a duplicate
 * cache being allocated each time a module is loaded and unloaded, if the
 * module doesn't have persistent in-kernel storage across loads and unloads.
 *
 * The cache must be empty before calling this function.
 *
 * The caller must guarantee that noone will allocate memory from the cache
 * during the kmem_cache_destroy().
 */

void kmem_cache_destroy(struct kmem_cache *cachep)
{
 BUG_ON(!cachep || in_interrupt());

 /* Find the cache in the chain of caches. */
 get_online_cpus();
 mutex_lock(&cache_chain_mutex);
 /*
 * the chain is never empty, cache_cache is never destroyed
 */
 list_del(&cachep->next);
 if (__cache_shrink(cachep)) {
 slab_error(cachep, "Can't free all objects");
 list_add(&cachep->next, &cache_chain);
 mutex_unlock(&cache_chain_mutex);
 put_online_cpus();
 return;
 }

 if (unlikely(cachep->flags & SLAB_DESTROY_BY_RCU))
 rcu_barrier();

 __kmem_cache_destroy(cachep);
 mutex_unlock(&cache_chain_mutex);
 put_online_cpus();
}
EXPORT_SYMBOL(kmem_cache_destroy);

通用内存对象管理举例： zalloc/kmalloc和kfree

 malloc_sizes 数组

专用内存对象管理举例： task_struct

参考资料

SLAB Allocator

Linux 内核临时页表初始化

yuanye.ma@qq.com (Yuanye Ma) — Sat, 31 Oct 2020 16:01:23 +0800

Linux 内核临时页表初始化

基于 linux 2.6.30.4分析x86平台相关代码

64位系统： 使用四级分页或三级分页，跟硬件有关。
未开启PAE(物理地址扩展)的32位系统： 只使用二级分页，页上级目录和页中间目录里的值全为0。
开启PAE的32位系统： 使用三级分页，这种情况下被排除在外的是页上级目录，也就是页上级目录中所有值都为0。

表项

实际上页全局目录、页上级目录、页中间目录、页表都是保存在一个一个页框中，我们知道常规情况下页框大小为4K(特殊情况有2MB、1GB)，也就是页框的布局都是以4K倍数的地址进行排列的，要寻址一个页框，只需要20位地址就足够了。这些目录和页表中保存的都是表项，页全局目录保存的是页全局目录项，页中间目录保存的是页中间目录项，在32位系统中这些项都是32位(20位是所指页框的基地址，12位是标志位)的，在开启PAE后会变成64位，这些项保存着很多标志，我们罗列几个重要的：

Present标志：为1，所指的页在内存中，为0，不在。
所指的页框基地址：占20位。
Accessed标志：每当分页单元对相应页框进行寻址时设置。
Dirty标志：只用于页表项，每次对一个页框进行写操作时设置。
Read/Write标志：读写权限标志。
User/Supervisor标志：所指的页的特权级(进程能否访问)。
Page size标志：为1表示指的是2MB或4MB的页框。也就是页表是2MB或者4MB。

　　在这些里面，最重要的或许就是所指页框基地址了，一个页中间目录项保存的页框基地址就是对应的页表的基地址，而页表项中保存的页框基地址，就是页(用于保存数据)的地址。而Present标志是用于判断是否发生缺页异常处理的标志。由于这些标志加上所指的页框基地址一共32位，一个4K的页框就能够保存1024个表项。

物理地址扩展(PAE)

　　这个技术是用于X86_32位体系下的，因为32位线性地址最多能表示4GB大小的空间，而PAE技术将物理地址线扩大到36条，也就是CPU能够寻址64GB大小的物理内存。但是物理地址线扩大到36条，但是线性地址还是使用32位，这时候没办法用32位的线性地址去表示64GB大小的物理内存。实际上PAE做的就是让内核有多个“主内核页全局目录”，第一个主内核页全局目录寻址0~~4GB的地址，第二个寻址5~~8GB的地址，所以当寻址不同区域的地址时，只需要将不同的“主内核页全局目录”基地址存入cr3中。这些多个主内核页全局目录被称为页目录指针表(PDPT)。

　　开启PAE后，32位系统寻址方式将大大改变：

二级分页会变成三级分页
表项的大小也由原来的32位变成了64位(原来是12位标志+20位页框基地址，变成12位标志+24位页框基地址)。
页框大小将可选择4K或者2MB，通过修改表项中的Page size标志即可指定所指页框大小。
线性地址表示也变成如下：
- 当把线性地址映射为4KB的页时（页目录项中的PS标志清零），32位线性地址按以下方式解释：
  - cr3 : 指向一个PDPT；
  - 位31-30 ：指向PDPT中4项中的一个；
  - 位29-21 ：指向页目录中512个项中的一个；
  - 位20-12 ：指向页表中512个项中的一个；
  - 位 11 - 0： 4KB页中的偏移量；
- 当把线性地址映射为2MB的页（页目录项中的PS标志置1）时，32位线性地址按下列方式解释：
  - cr3 : 指向一个PDPT；
  - 位31-30 ：指向PDPT中4项中的一个；
  - 位29-21 ：指向页目录中512个项中的一个；
  - 位 20 - 0： 2MB页中的偏移量；

临时内核页表的构造

x86系统刚刚启动的时候，运行在实模式下，这个时候线性地址就是物理地址。为了进入32位保护模式，首先就要启用分页。这就要求我们构建一个页表：这张页表把线性地址映射转换为物理地址。

为了解决构造页表时鸡生蛋蛋生鸡的问题，Linux使用了一个临时的内核页表。它只有两个页表项（这里指用来索引页框的最后一级页表）。在不启用PAE(Page Addression Extension) 和 PSE (Page Size Extension)的情况下，一个页表可以指向 2^10 = 1024个内存页，一个内存页 4k ，所以两个页表允许索引8M的内存。

`swapper_pg_dir`

顶层的页目录 (page directory) 使用全局变量 swapper_pg_dir定义。

/* 在 arch/x86/include/asm/pgtable_32.h 中声明为外部全局变量 */
extern pgd_t swapper_pg_dir[1024];

/* 其中pgd_t的定义如下 */
typedef struct { pgdval_t pgd; } pgd_t;
typedef unsigned long pgdval_t;
/* 即，swapper_pg_dir 是unsigned long类型的数组，数组大小为1024 */


/* 在 arch/x86/kernel/head_32.S 中定义此变量 */
/*
 * BSS section
 */
.section ".bss.page_aligned","wa"
 .align PAGE_SIZE_asm
#ifdef CONFIG_X86_PAE
swapper_pg_pmd:
 .fill 1024*KPMDS,4,0
#else
ENTRY(swapper_pg_dir)
 .fill 1024,4,0
#endif
swapper_pg_fixmap:
 .fill 1024,4,0
ENTRY(empty_zero_page)
 .fill 4096,1,0

.fill 1024, 4, 0 表示用0填充1024个 4 byte 长度的内存（一个页目录项 page table entry 的大小是32bits 即 4Byte）。

pg0

ULK3 P74 原文：临时页全局目录放在 swapper_pg_dir地址处，临时页表在pg0地址处，紧接在内核bss段之后。在linux 2.6.30.4中没有找到pg0变量。在分析代码时发现，应该是替换为了变量 __brk_base

/* __brk_base 定义在 arch/x86/kernel/vmlinux_32.lds.S 中*/
 .bss : AT(ADDR(.bss) - LOAD_OFFSET) {
 __init_end = .;
 __bss_start = .; /* BSS */
 *(.bss.page_aligned)
 *(.bss)
 . = ALIGN(4);
 __bss_stop = .;
 }

 .brk : AT(ADDR(.brk) - LOAD_OFFSET) {
 . = ALIGN(PAGE_SIZE);
 __brk_base = . ;
 . += 64 * 1024 ; /* 64k alignment slop space */
 *(.brk_reservation) /* areas brk users have reserved */
 __brk_limit = . ;
 }
 _end = . ;

初始化过程

/*
 * Initialize page tables. This creates a PDE and a set of page
 * tables, which are located immediately beyond __brk_base. The variable
 * _brk_end is set up to point to the first "safe" location.
 * Mappings are created both at virtual address 0 (identity mapping)
 * and PAGE_OFFSET for up to _end.
 *
 * Note that the stack is not yet set up!
 */
default_entry:
#ifdef CONFIG_X86_PAE

 /* 暂时不看 */

#else /* Not PAE */

page_pde_offset = (__PAGE_OFFSET >> 20);
 /* 其中 __PAGE_OFFSET = 0xC000 0000 所以 page_pde_offset = 0xC00 */

 movl $pa(__brk_base), %edi
 movl $pa(swapper_pg_dir), %edx
 /*
 /* Physical address */
 #define pa(X) ((X) - __PAGE_OFFSET)
 */
 movl $PTE_IDENT_ATTR, %eax
10:
 leal PDE_IDENT_ATTR(%edi),%ecx /* Create PDE entry */
 movl %ecx,(%edx) /* Store identity PDE entry */
 movl %ecx,page_pde_offset(%edx) /* Store kernel PDE entry */
 addl $4,%edx
 movl $1024, %ecx
11:
 stosl
 addl $0x1000,%eax
 loop 11b
 /*
 * End condition: we must map up to the end + MAPPING_BEYOND_END.
 */
 movl $pa(_end) + MAPPING_BEYOND_END + PTE_IDENT_ATTR, %ebp
 cmpl %ebp,%eax
 jb 10b
 addl $__PAGE_OFFSET, %edi
 movl %edi, pa(_brk_end)
 shrl $12, %eax
 movl %eax, pa(max_pfn_mapped)

 /* Do early initialization of the fixmap area */
 movl $pa(swapper_pg_fixmap)+PDE_IDENT_ATTR,%eax
 movl %eax,pa(swapper_pg_dir+0xffc)
#endif
 jmp 3f

stosl 指令：相当于将eax中的值保存到 ES:EDI 所指向的地址中，若设置了EFLAGS中的方向位，则EDI自减4否则自增4。

loop 指令 : 借助ECX寄存器作为计数实现循环，每轮循环先将ECX减一，再判断ECX的值，循环直到ECX为0时止。

leal 指令：load effective address 功能是取偏移地址

mov 是将数据从源传到目的； lea是将源目的地址传到目的

例如

movl 18(%eax), %ebx # 将内存中 %eax+18内存处的内容，传递到 %ebx中；

leal 18(%eax), %ebx # 将（18+%eax中内容）的值，传入%ebx;


/* PTE_IDENT_ATTR和PDE_IDENT_ATTR 定义在arch/x86/include/asm/pgtable_types.h中 */
/*
 * early identity mapping pte attrib macros.
 */
#ifdef CONFIG_X86_64
#define __PAGE_KERNEL_IDENT_LARGE_EXEC __PAGE_KERNEL_LARGE_EXEC
#else
/*
 * For PDE_IDENT_ATTR include USER bit. As the PDE and PTE protection
 * bits are combined, this will alow user to access the high address mapped
 * VDSO in the presence of CONFIG_COMPAT_VDSO
 */
#define PTE_IDENT_ATTR 0x003 /* PRESENT+RW */
#define PDE_IDENT_ATTR 0x067 /* PRESENT+RW+USER+DIRTY+ACCESSED */
#define PGD_IDENT_ATTR 0x001 /* PRESENT (no other attributes) */
#endif

分步骤来看

初始化变量

page_pde_offset = (__PAGE_OFFSET >> 20);
 /* 其中 __PAGE_OFFSET = 0xC000 0000 所以 page_pde_offset = 0xC00 */

 movl $pa(__brk_base), %edi # 将pg0的物理地址存储到 %edi寄存器中
 movl $pa(swapper_pg_dir), %edx # 将页全局目录swapper_pg_dir的地址存到寄存器%edx中
 movl $PTE_IDENT_ATTR, %eax # 存储PTE的属性 PRESENT+RW 到%eax中

设置页全局目录

10:
 leal PDE_IDENT_ATTR(%edi),%ecx /* Create PDE entry */
 movl %ecx,(%edx) /* Store identity PDE entry */
 movl %ecx,page_pde_offset(%edx) /* Store kernel PDE entry */
 addl $4,%edx
 movl $1024, %ecx

pde ： page directory entry 页目录表

先将pg0的物理地址+PDE_IDENT_ATTR -> %ecx；即将页表的地址加上页表的属性写入到%ECX;
%ecx -> swapper_pg_dir的物理地址；即将页表的地址写入到页目录中；
%ecx -> swapper_pg_dir的物理地址+page_pde_offset；将页表地址写入到内核页表所在位置；
4+%edx ; 即将指针往后移动四个字节，指向第二个页目录项，为初始化第二个页表做准备；
最后将1024写入%ecx，作为初始化页表时的循环变量。

初始化页表

```c
11:
stosl ;将%eax的内容(0+PRESENT+RW)复制到 %es:%edi ，即pg0第一个表项处，并%edi+4 ;
addl $0x1000,%eax ; %eax+0x1000, 即 %eax+4K,
loop 11b ; %ecx-=1, 若%ecx!=0, 跳转到标号11处，继续执行，即循环1024次。
```

初始化剩下的页表

 /*
 * End condition: we must map up to the end + MAPPING_BEYOND_END.
 */
 movl $pa(_end) + MAPPING_BEYOND_END + PTE_IDENT_ATTR, %ebp
 cmpl %ebp,%eax
 jb 10b

其中 _end在前边连接器脚本中定义，MAPPING_BEYOND_END定义如下，PTE_IDENT_ATTR为页表的属性。

/*
 * This is how much memory in addition to the memory covered up to
 * and including _end we need mapped initially.
 * We need:
 * (KERNEL_IMAGE_SIZE/4096) / 1024 pages (worst case, non PAE)
 * (KERNEL_IMAGE_SIZE/4096) / 512 + 4 pages (worst case for PAE)
 *
 * Modulo rounding, each megabyte assigned here requires a kilobyte of
 * memory, which is currently unreclaimed.
 *
 * This should be a multiple of a page.
 *
 * KERNEL_IMAGE_SIZE should be greater than pa(_end)
 * and small than max_low_pfn, otherwise will waste some page table entries
 */

#if PTRS_PER_PMD > 1
#define PAGE_TABLE_SIZE(pages) (((pages) / PTRS_PER_PMD) + PTRS_PER_PGD)
#else
#define PAGE_TABLE_SIZE(pages) ((pages) / PTRS_PER_PGD)
#endif

/* Enough space to fit pagetables for the low memory linear map */
MAPPING_BEYOND_END = \
 PAGE_TABLE_SIZE(((1<<32) - __PAGE_OFFSET) >> PAGE_SHIFT) << PAGE_SHIFT

启用分页

初始化过程的最后执行了 jmp 3f , 标号3处执行PAE相关的判断和操作，最后跳转到了标号6处执行。

6:

/*
 * Enable paging
 */
 movl $pa(swapper_pg_dir),%eax
 movl %eax,%cr3 /* set the page table pointer.. */
 movl %cr0,%eax
 orl $X86_CR0_PG,%eax
 movl %eax,%cr0 /* ..and set paging (PG) bit */
 ljmp $__BOOT_CS,$1f /* Clear prefetch and normalize %eip */
1:
 /* Set up the stack pointer */
 lss stack_start,%esp

参考

linux内存源码分析 - 页表的初始化

Linux 内核内存管理

yuanye.ma@qq.com (Yuanye Ma) — Fri, 30 Oct 2020 16:01:23 +0800

Linux 内核内存管理

[toc]

越整理发现知识越多，分页机制、伙伴算法、slab等任何一块单独拿出来都有很多东西，因此本文先粗略的统揽全貌，有时间再针对每个部分，逐个深入，单独分析梳理成文章。

内存寻址的基本框架

Linux内核的映射机制分三层：页面目录：PGD, 中间目录：PMD，页表PT。PT的表项称为PTE (Page Table Entry). PGD PMD以及PT三者都是数组。三者的关系如图所示。

CPU给出的线性地址在逻辑上可以分为4个位段，各占若干位。分别用作在页面目录表PGD中的下标志，页中间目录表PMD中的下标，页表PT中的下标，以及物理页内的地址偏移。线性地址映射为物理地址的大致过程如下。

CPU发出线性地址；
用1中线性地址的最高位段中的值，在PGD中找到相应的表项，该表项的内容指向PMD的地址；
用1中线性地址的第二个位段中的值，在PMD中找到相应的表项，该表项的内容指向PT的地址；
用1中线性地址的第三个位段中的值，在PT中找到相应的表项，该表项是PTE,即存储物理页面的地址。
在4中找到的物理页中，以1中线性地址的最后一个位段的内容作为地址偏移量，找到对应的物理地址。

i386的MMU只支持两级页表，对于Pentium Pro开始Intel引入了物理地址扩充功能PAE，允许将32位的地址线扩展为36位，并在硬件上支持了三层映射。两层映射、三层映射甚至64位机器的四层映射，原理都是相似的，力图简单，先搞懂两层映射。

arch/x86/include/asm/pgtable_32_types.h中的宏CONFIG_X86_PAE在内核配置的过程中(arch/x86/Kconfig中)生成，决定是否开启PAE。

/* arch/x86/include/asm/pgtable_32_types.h */
/*
 * The Linux x86 paging architecture is 'compile-time dual-mode', it
 * implements both the traditional 2-level x86 page tables and the
 * newer 3-level PAE-mode page tables.
 */
#ifdef CONFIG_X86_PAE
# include <asm/pgtable-3level_types.h>
# define PMD_SIZE (1UL << PMD_SHIFT)
# define PMD_MASK (~(PMD_SIZE - 1))
#else
# include <asm/pgtable-2level_types.h>
#endif

不开启PAE时即包含<asm/pgtable-2level_types.h>头文件，即采用两级页表。

/* arch/x86/include/asm/pgtable-2level_types.h */
/*
 * traditional i386 two-level paging structure:
 */
#define PGDIR_SHIFT 22 /* 表示线性地址中PGD下标位段在线性地址中的起始位置，即从bit22开始到bit31共10位 */
#define PTRS_PER_PGD 1024 /* 代表每个PGD表中指针个数 */

/* arch/x86/include/asm/pgtable_32_types.h */
#define PGDIR_SIZE (1UL << PGDIR_SHIFT) /* 表示PGD中每一个表代表1x2^22的地址空间 */

默认状态下，32位的地址空间分为 0x00000000 - 0xBFFFFFFF 3G的用户态空间，和0xC0000000 - 0xFFFFFFFF 1G的内核态空间。下边的配置项决定内核空间的开始位置，默认是从0xC0000000开始的1G空间。

/* arch/x86/Kconfig */
config PAGE_OFFSET
 hex
 default 0xB0000000 if VMSPLIT_3G_OPT
 default 0x80000000 if VMSPLIT_2G
 default 0x78000000 if VMSPLIT_2G_OPT
 default 0x40000000 if VMSPLIT_1G
 default 0xC0000000
 depends on X86_32

关于PAGE_OFFSET宏的定义如下过程。

/* arch/x86/include/asm/page_types.h */
#define PAGE_OFFSET ((unsigned long)__PAGE_OFFSET)

/* 其中__PAGE_OFFSET定义在 arch/x86/include/asm/page_32_types.h*/
/*
 * This handles the memory map.
 *
 * A __PAGE_OFFSET of 0xC0000000 means that the kernel has
 * a virtual address space of one gigabyte, which limits the
 * amount of physical memory you can use to about 950MB.
 *
 * If you want more physical memory than this then see the CONFIG_HIGHMEM4G
 * and CONFIG_HIGHMEM64G options in the kernel configuration.
 */
#define __PAGE_OFFSET _AC(CONFIG_PAGE_OFFSET, UL)

/* CONFIG_PAGE_OFFSET 由前边arch/x86/Kconfig中的配置项PAGE_OFFSET决定 */

由此原理内核定义了一套用于内核空间中简单的地址转换方式。

/* arch/x86/include/asm/page.h */
#define __pa(x) __phys_addr((unsigned long)(x))
#define __va(x) ((void *)((unsigned long)(x)+PAGE_OFFSET))

/*arch/x86/include/asm/page_32.h*/
#define __phys_addr_nodebug(x) ((x) - PAGE_OFFSET)
#define __phys_addr(x) __phys_addr_nodebug(x)

地址映射全过程

假设hello-world程序编译链接加载完的程序入口地址是0x08048568，CPU要执行此程序，首先此地址经过MMU得到对应的物理地址，将CS:EIP的地址指向该物理地址，之后CPU就可以运行此程序的代码。

首先看一下段式映射机制，即得到物理地址后CPU怎么执行。

段式映射机制

/* arch/x86/include/asm/processor.h */
extern void start_thread(struct pt_regs *regs, unsigned long new_ip,
 unsigned long new_sp);
/* /arch/x86/kernel/process_32.c */
void
start_thread(struct pt_regs *regs, unsigned long new_ip, unsigned long new_sp)
{
 set_user_gs(regs, 0);
 regs->fs = 0;
 set_fs(USER_DS);
 regs->ds = __USER_DS;
 regs->es = __USER_DS;
 regs->ss = __USER_DS;
 regs->cs = __USER_CS;
 regs->ip = new_ip;
 regs->sp = new_sp;
 /*
 * Free the old FP and other extended state
 */
 free_thread_xstate(current);
}
EXPORT_SYMBOL_GPL(start_thread);

/* /arch/x86/include/asm/segment.h */
#define __KERNEL_CS (GDT_ENTRY_KERNEL_CS * 8)
 /*(12+0)*8=96 : 60H : 0000 0000 0110 0000*/
#define __KERNEL_DS (GDT_ENTRY_KERNEL_DS * 8)
 /*(12+1)*8=104 : 68H : 0000 0000 0110 1000*/
#define __USER_DS (GDT_ENTRY_DEFAULT_USER_DS* 8 + 3)
 /* 15*8+3=123 : 7BH : 0000 0000 0111 1011*/
#define __USER_CS (GDT_ENTRY_DEFAULT_USER_CS* 8 + 3)
 /* 14*8+3=115 : 73H : 0000 0000 0111 0011*/


#define GDT_ENTRY_KERNEL_BASE 12
#define GDT_ENTRY_KERNEL_CS (GDT_ENTRY_KERNEL_BASE + 0)
#define GDT_ENTRY_KERNEL_DS (GDT_ENTRY_KERNEL_BASE + 1)

#define GDT_ENTRY_DEFAULT_USER_CS 14
#define GDT_ENTRY_DEFAULT_USER_DS 15

对应到段寄存器格式定义可得下边的表，即四个段全在GDT中。

	index	RPL
__KERNEL_CS	12	0
__KERNEL_DS	13	0
__USER_DS	15	3
__USER_CS	14	3

内核GDT表的映像在arch/x86/include/asm/segment.h的注释可以看出来。

/*
 * The layout of the per-CPU GDT under Linux:
 *
 * 0 - null
 * 1 - reserved
 * 2 - reserved
 * 3 - reserved
 *
 * 4 - unused <==== new cacheline
 * 5 - unused
 *
 * ------- start of TLS (Thread-Local Storage) segments:
 *

 * 6 - TLS segment #1 [ glibc's TLS segment ]
 * 7 - TLS segment #2 [ Wine's %fs Win32 segment ]
 * 8 - TLS segment #3
 * 9 - reserved
 * 10 - reserved
 * 11 - reserved
 *
 * ------- start of kernel segments:
 *
 * 12 - kernel code segment <==== new cacheline
 * 13 - kernel data segment
 * 14 - default user CS
 * 15 - default user DS
 * 16 - TSS
 * 17 - LDT
 * 18 - PNPBIOS support (16->32 gate)
 * 19 - PNPBIOS support
 * 20 - PNPBIOS support
 * 21 - PNPBIOS support
 * 22 - PNPBIOS support
 * 23 - APM BIOS support
 * 24 - APM BIOS support
 * 25 - APM BIOS support
 *
 * 26 - ESPFIX small SS
 * 27 - per-cpu [ offset to per-cpu data area ]
 * 28 - stack_canary-20 [ for stack protector ]
 * 29 - unused
 * 30 - unused
 * 31 - TSS for double fault handler
 */
/* Constructor for a conventional segment GDT (or LDT) entry */
/* This is a macro so it can be used in initializers */
#define GDT_ENTRY(flags, base, limit) \
 ((((base) & 0xff000000ULL) << (56-24)) | \
 (((flags) & 0x0000f0ffULL) << 40) | \
 (((limit) & 0x000f0000ULL) << (48-16)) | \
 (((base) & 0x00ffffffULL) << 16) | \
 (((limit) & 0x0000ffffULL)))

关于gdt的建立过程，在内核的初始化阶段完成，搜索内核代码发现在arch/x86/kernel/cpu/common.c定义。

DEFINE_PER_CPU_PAGE_ALIGNED(struct gdt_page, gdt_page) = { .gdt = {
 /* 省略其他 */
 [GDT_ENTRY_KERNEL_CS] = { { { 0x0000ffff, 0x00cf9a00 } } },
 [GDT_ENTRY_KERNEL_DS] = { { { 0x0000ffff, 0x00cf9200 } } },
 [GDT_ENTRY_DEFAULT_USER_CS] = { { { 0x0000ffff, 0x00cffa00 } } },
 [GDT_ENTRY_DEFAULT_USER_DS] = { { { 0x0000ffff, 0x00cff200 } } },
 /*省略其他*/
} };
EXPORT_PER_CPU_SYMBOL_GPL(gdt_page);
/*
 GDT_ENTRY_KERNEL_CS = 12
 GDT_ENTRY_KERNEL_DS = 13
 GDT_ENTRY_DEFAULT_USER_CS = 14
 GDT_ENTRY_DEFAULT_USER_DS = 15
 这里还有一点需要注意
 { 0x0000ffff, 0x00cf9a00 }在内存中应该是0x00cf9a000000ffff
*/

/*include/linux/percpu-defs.h" */
#define DEFINE_PER_CPU_PAGE_ALIGNED(type, name) \
 DEFINE_PER_CPU_SECTION(type, name, ".page_aligned")

/*include/linux/percpu-defs.h */
#define DEFINE_PER_CPU_SECTION(type, name, section) \
 __attribute__((__section__(PER_CPU_BASE_SECTION section))) \
 PER_CPU_ATTRIBUTES PER_CPU_DEF_ATTRIBUTES \
 __typeof__(type) per_cpu__##name

参照gdt表项定义可以得出以下结论

	B31-B24		L19-L16		B23-B16	B15-B0	L15-L0
__KERNEL_CS	0x00	0xC	0xF	0x9A	0x00	0x0000	0xFFFF
__KERNEL_DS	0x00	0xC	0xF	0x92	0xFF	0x00CF	0xFFFF
__USER_CS	0x00	0xC	0xF	0xFA	0xFF	0x00CF	0xFFFF
__USER_DS	0x00	0xC	0xF	0xF2	0xFF	0x00CF	0xFFFF

即

B0-B15, B16-B24 全是0，段的基地址是0；
L0-L15， L16-L19 全是1，段的上限是0xFFFFF;
G位都是1，段长单位都为4KB；
D/B位都为1，对四个段访问的指令都是32位的；
P位都为1，四个段都在内存中；
bit40-bit46字段有区别
- __KERNEL_CS ： DPL = 0； S = 1代码或数据段；101 代码段，可读；未被访问过；
- __KERNEL_DS ： DPL = 0； S = 1代码或数据段；001 数据段，可读，可写；未被访问过；
- __USER_CS ： DPL = 3； S = 1代码或数据段；101 代码段，可读；未被访问过；
- __USER_DS ： DPL = 3； S = 1代码或数据段；001 数据段，可读，可写；未被访问过；

小结

分段机制中，所有进程公用一个GDT，主要分了四个段：内核代码段、内核数据段、用户代码段、用户数据段，所有进程共享这四个段。这四个段的映射整个内存空间。

页式映射机制

分页机制主要完成虚拟地址（线性地址）到物理地址的映射。

分页机制中，每个进程都有其自己的页目录PGD，指向这个目录的指针保存在每个进程的mm_struct结构中，每当调度一个进程进入运行时，内核都据此设置CR3寄存器，MMU的硬件又从CR3中取得PGD的地址。

CPU给出线性地址0x08048568，写成二进制形式0000 1000 0000 0100 1000 0101 0110 1000。

查PGD： 0000 1000 00十进制为32，以32位为下标，在PGD中找到相应表项，取此表项的高20位后边补12个0组成PT的地址。
查PT : 00 0100 1000 十进制为72，以72位下标，在PT中找到相应的表项，取此表项的高20位后边补12个0，组成页表的地址。
查页表：线性地址中省下的12位 0101 0110 1000为地址偏移，上一步查到的页表地址加上此偏移，得到线性地址0x08048568相应的物理地址。

此过程中共访存了3次，第一次取PGD[32]，第二次取PT[72]，第三次取PT[72]+0101 0110 1000得到物理地址。

时间优化：快表 TLB;

空间优化：多级页表。

内核启动过程和启动完成后gdt有所不同，以下为内核启动时gdt的初始化函数调用过程。

参考这篇文章

arch/x86/boot/main.c -> main()
 -> arch/x86/boot/pm.c : go_to_protected_mode()
 -> arch/x86/boot/pm.c : setup_gdt();
static void setup_gdt(void)
{
 /* There are machines which are known to not boot with the GDT
 being 8-byte unaligned. Intel recommends 16 byte alignment. */
 static const u64 boot_gdt[] __attribute__((aligned(16))) = {
 /* CS: code, read/execute, 4 GB, base 0 */
 [GDT_ENTRY_BOOT_CS] = GDT_ENTRY(0xc09b, 0, 0xfffff),
 /* DS: data, read/write, 4 GB, base 0 */
 [GDT_ENTRY_BOOT_DS] = GDT_ENTRY(0xc093, 0, 0xfffff),
 /* TSS: 32-bit tss, 104 bytes, base 4096 */
 /* We only have a TSS here to keep Intel VT happy;
 we don't actually use it for anything. */
 [GDT_ENTRY_BOOT_TSS] = GDT_ENTRY(0x0089, 4096, 103),
 };
 /* Xen HVM incorrectly stores a pointer to the gdt_ptr, instead
 of the gdt_ptr contents. Thus, make it static so it will
 stay in memory, at least long enough that we switch to the
 proper kernel GDT. */
 static struct gdt_ptr gdt;

 gdt.len = sizeof(boot_gdt)-1;
 gdt.ptr = (u32)&boot_gdt + (ds() << 4);

 asm volatile("lgdtl %0" : : "m" (gdt));
}

#define GDT_ENTRY_BOOT_CS 2
#define GDT_ENTRY_BOOT_DS (GDT_ENTRY_BOOT_CS + 1)

几个重要的数据结构

系统中的每个物理页面都有一个page结构，系统在初始化时根据系统中物理内存的大小建立起一个page结构数组，作为物理页面的“仓库”，里面每个page数据结构都代表系统中一个物理页面。

“仓库”中的物理页面被划分为ZONE_DMA 、 ZONE_NORMAL和ZONE_HIGHMEM区，其中ZONE_HIGHMEM用于物理地址超过1G的存储空间，在64位系统中该区为空。一个管理区用一个zone_struct结构表示。

对于NUMA结构，管理区不再是最高层级的存储管理机构，而是在每个存储节点中都至少有两个管理区，而且前述page结构数组，也不再是全局性的，而是从属于具体的节点。 pg_data_t结构保存节点信息。

pgd_t / pmd_t / pte_t

/* arch/x86/include/asm/pgtable_types.h" */
typedef struct { pgdval_t pgd; } pgd_t;
#if PAGETABLE_LEVELS > 2
typedef struct { pmdval_t pmd; } pmd_t; /* 这里为了简单只看 */
#esle
typedef struct { pud_t pud; } pmd_t; //include/asm-generic/pgtable-nopmd.h
#endif


/* arch/x86/include/asm/pgtable-2level_types.h */

typedef unsigned long pteval_t;
typedef unsigned long pmdval_t;
typedef unsigned long pudval_t;
typedef unsigned long pgdval_t;
typedef unsigned long pgprotval_t;

typedef union {
 pteval_t pte;
 pteval_t pte_low;
} pte_t;

页面目录PGD 中间目录PMD 页表PT 分别是由表项pgd_t pmd_t pte_t组成的数组。

1
2

/* arch/x86/include/asm/pgtable_types.h */
typedef struct pgprot { pgprotval_t pgprot; } pgprot_t; //页面保护的结构

`struct page`

内核中有一个全局量mem_map（定义在mm/memory.c的70行struct page *mem_map;）是一个指针，指向一个page数据结构的数组，每个page代表着一个物理页面，整个数组就代表着系统中的全部物理页面。系统在初始化时根据物理内存的大小建立mem_map。

/* include/linux/mm_types.h +40 */
/*
 * Each physical page in the system has a struct page associated with
 * it to keep track of whatever it is we are using the page for at the
 * moment. Note that we have no way to track which tasks are using
 * a page, though if it is a pagecache page, rmap structures can tell us
 * who is mapping it.
 */
struct page {
 unsigned long flags; /* Atomic flags, some possibly
 * updated asynchronously */
 atomic_t _count; /* Usage count, see below. */
 union {
 atomic_t _mapcount; /* Count of ptes mapped in mms,
 * to show when page is mapped
 * & limit reverse map searches.
 */
 struct { /* SLUB */
 u16 inuse;
 u16 objects;
 };
 };
 union {
 struct {
 unsigned long private; /* Mapping-private opaque data:
 * usually used for buffer_heads
 * if PagePrivate set; used for
 * swp_entry_t if PageSwapCache;
 * indicates order in the buddy
 * system if PG_buddy is set.
 */
 struct address_space *mapping; /* If low bit clear, points to
 * inode address_space, or NULL.
 * If page mapped as anonymous
 * memory, low bit is set, and
 * it points to anon_vma object:
 * see PAGE_MAPPING_ANON below.
 */
 };
#if USE_SPLIT_PTLOCKS
 spinlock_t ptl;
#endif
 struct kmem_cache *slab; /* SLUB: Pointer to slab */
 struct page *first_page; /* Compound tail pages */
 };
 union {
 pgoff_t index; /* Our offset within mapping. */
 void *freelist; /* SLUB: freelist req. slab lock */
 };
 struct list_head lru; /* Pageout list, eg. active_list
 * protected by zone->lru_lock !
 */
 /*
 * On machines where all RAM is mapped into kernel address space,
 * we can simply calculate the virtual address. On machines with
 * highmem some memory is mapped into kernel virtual memory
 * dynamically, so we need a place to store that address.
 * Note that this field could be 16 bits on x86 ... ;)
 *
 * Architectures with slow multiplication can define
 * WANT_PAGE_VIRTUAL in asm/page.h
 */
#if defined(WANT_PAGE_VIRTUAL)
 void *virtual; /* Kernel virtual address (NULL if
 not kmapped, ie. highmem) */
#endif /* WANT_PAGE_VIRTUAL */
#ifdef CONFIG_WANT_PAGE_DEBUG_FLAGS
 unsigned long debug_flags; /* Use atomic bitops on this */
#endif
};

如果把物理内存看做一个物理页面的“数组”，高20位就是数组的下标，也就是物理页面的序号，用这个下标，可以在上述page结构数组中找到代表目标物理页面的数据结构，实现如下边代码。

/* arch/x86/include/asm/pgtable.h */
#define pte_page(pte) pfn_to_page(pte_pfn(pte))
130 static inline unsigned long pte_pfn(pte_t pte)
131 {
132 return (pte_val(pte) & PTE_PFN_MASK) >> PAGE_SHIFT;
 /*
 176 /* PTE_PFN_MASK extracts the PFN from a (pte|pmd|pud|pgd)val_t */
 177 #define PTE_PFN_MASK ((pteval_t)PHYSICAL_PAGE_MASK)

 */
133 }
/*include/asm-generic/memory_model.h*/
70 #define pfn_to_page __pfn_to_page
30 #define __pfn_to_page(pfn) (mem_map + ((pfn) - ARCH_PFN_OFFSET))

 8 #ifndef ARCH_PFN_OFFSET
 9 #define ARCH_PFN_OFFSET (0UL)
 10 #endif

/*
即
 pte_page(pte) 展开为 (mem_map + ((pte) - 0))
 其中pte = (pte_val(pte) & PTE_PFN_MASK) >> PAGE_SHIFT
*/

`struct zone`

关于zone的划分，内核中的注释应该能够帮助理解。

enum zone_type {
#ifdef CONFIG_ZONE_DMA
 /*
 * ZONE_DMA is used when there are devices that are not able
 * to do DMA to all of addressable memory (ZONE_NORMAL). Then we
 * carve out the portion of memory that is needed for these devices.
 * The range is arch specific.
 *
 * Some examples
 *
 * Architecture Limit
 * ---------------------------
 * parisc, ia64, sparc <4G
 * s390 <2G
 * arm Various
 * alpha Unlimited or 0-16MB.
 *
 * i386, x86_64 and multiple other arches
 * <16M.
 */
 ZONE_DMA,
#endif
#ifdef CONFIG_ZONE_DMA32
 /*
 * x86_64 needs two ZONE_DMAs because it supports devices that are
 * only able to do DMA to the lower 16M but also 32 bit devices that
 * can only do DMA areas below 4G.
 */
 ZONE_DMA32,
#endif
 /*
 * Normal addressable memory is in ZONE_NORMAL. DMA operations can be
 * performed on pages in ZONE_NORMAL if the DMA devices support
 * transfers to all addressable memory.
 */
 ZONE_NORMAL,
#ifdef CONFIG_HIGHMEM
 /*
 * A memory area that is only addressable by the kernel through
 * mapping portions into its own address space. This is for example
 * used by i386 to allow the kernel to address the memory beyond
 * 900MB. The kernel will set up special mappings (page
 * table entries on i386) for each page that the kernel needs to
 * access.
 */
 ZONE_HIGHMEM,
#endif
 ZONE_MOVABLE,
 __MAX_NR_ZONES
};

zone结构

/* "include/linux/mmzone.h" */


struct zone {
 /* Fields commonly accessed by the page allocator */
 unsigned long pages_min, pages_low, pages_high;
 /*
 * We don't know if the memory that we're going to allocate will be freeable
 * or/and it will be released eventually, so to avoid totally wasting several
 * GB of ram we must reserve some of the lower zone memory (otherwise we risk
 * to run OOM on the lower zones despite there's tons of freeable ram
 * on the higher zones). This array is recalculated at runtime if the
 * sysctl_lowmem_reserve_ratio sysctl changes.
 */
 unsigned long lowmem_reserve[MAX_NR_ZONES];

#ifdef CONFIG_NUMA
 int node;
 /*
 * zone reclaim becomes active if more unmapped pages exist.
 */
 unsigned long min_unmapped_pages;
 unsigned long min_slab_pages;
 struct per_cpu_pageset *pageset[NR_CPUS];
#else
 struct per_cpu_pageset pageset[NR_CPUS];
 /*
 * free areas of different sizes
 */
 spinlock_t lock;
#ifdef CONFIG_MEMORY_HOTPLUG
 /* see spanned/present_pages for more description */
 seqlock_t span_seqlock;
#endif
 struct free_area free_area[MAX_ORDER]; /* "空闲区间"队列 */

 /* 省略一些元素 */

 /*
 * Discontig memory support fields.
 */
 struct pglist_data *zone_pgdat; /* 属于哪个NUMA节点 */
 /* zone_start_pfn == zone_start_paddr >> PAGE_SHIFT */
 unsigned long zone_start_pfn; /* 在page结构数组中的起始页面号 */

 /*
 * zone_start_pfn, spanned_pages and present_pages are all
 * protected by span_seqlock. It is a seqlock because it has
 * to be read outside of zone->lock, and it is done in the main
 * allocator path. But, it is written quite infrequently.
 *
 * The lock is declared along with zone->lock because it is
 * frequently read in proximity to zone->lock. It's good to
 * give them a chance of being in the same cacheline.
 */
 unsigned long spanned_pages; /* total size, including holes */
 unsigned long present_pages; /* amount of memory (excluding holes) */

 /*
 * rarely used fields:
 */
 const char *name;
} ____cacheline_internodealigned_in_smp;

`pg_data_t` 或者 `struct pglist_data`

此结构表示每个NUMA节点的存储信息。

/* include/linux/mmzone.h */

/*
 * The pg_data_t structure is used in machines with CONFIG_DISCONTIGMEM
 * (mostly NUMA machines?) to denote a higher-level memory zone than the
 * zone denotes.
 *
 * On NUMA machines, each NUMA node would have a pg_data_t to describe
 * it's memory layout.
 *
 * Memory statistics and page replacement data structures are maintained on a
 * per-zone basis.
 */
typedef struct pglist_data {
 struct zone node_zones[MAX_NR_ZONES]; /* 节点内的 zone，数组 */
 struct zonelist node_zonelists[MAX_ZONELISTS]; /* 分配策略数组 */
 int nr_zones;
#ifdef CONFIG_FLAT_NODE_MEM_MAP /* means !SPARSEMEM */
 struct page *node_mem_map; /* 指向具体节点内的page数组 */
#ifdef CONFIG_CGROUP_MEM_RES_CTLR
 struct page_cgroup *node_page_cgroup;
#endif
#endif
 struct bootmem_data *bdata;
#ifdef CONFIG_MEMORY_HOTPLUG
 /*
 * Must be held any time you expect node_start_pfn, node_present_pages
 * or node_spanned_pages stay constant. Holding this will also
 * guarantee that any pfn_valid() stays that way.
 *
 * Nests above zone->lock and zone->size_seqlock.
 */
 spinlock_t node_size_lock;
#endif
 unsigned long node_start_pfn;
 unsigned long node_present_pages; /* total number of physical pages */
 unsigned long node_spanned_pages; /* total size of physical page
 range, including holes */

 int node_id;
 wait_queue_head_t kswapd_wait;
 struct task_struct *kswapd;
 int kswapd_max_order;
} pg_data_t;

每个zonelist规定了一种分配策略，当当前节点中的物理页面不够时，按zonelist中的顺序，从公共存储或者其他cpu的存储中分配页面。

/*
 * One allocation request operates on a zonelist. A zonelist
 * is a list of zones, the first one is the 'goal' of the
 * allocation, the other zones are fallback zones, in decreasing
 * priority.
 *
 * If zlcache_ptr is not NULL, then it is just the address of zlcache,
 * as explained above. If zlcache_ptr is NULL, there is no zlcache.
 * *
 * To speed the reading of the zonelist, the zonerefs contain the zone index
 * of the entry being read. Helper functions to access information given
 * a struct zoneref are
 *
 * zonelist_zone() - Return the struct zone * for an entry in _zonerefs
 * zonelist_zone_idx() - Return the index of the zone for an entry
 * zonelist_node_idx() - Return the index of the node for an entry
 */
struct zonelist {
 struct zonelist_cache *zlcache_ptr; // NULL or &zlcache
 struct zoneref _zonerefs[MAX_ZONES_PER_ZONELIST + 1];
#ifdef CONFIG_NUMA
 struct zonelist_cache zlcache; // optional ...
#endif
};


/* 其中 */
/*
 * This struct contains information about a zone in a zonelist. It is stored
 * here to avoid dereferences into large structures and lookups of tables
 */
struct zoneref {
 struct zone *zone; /* Pointer to actual zone */
 int zone_idx; /* zone_idx(zoneref->zone) */
};

之前的几个结构都是用于物理空间管理的，下面是虚拟空间管理的。

虚拟空间的管理是以进程为基础的，每个进程都有各自的虚拟内存空间，所有进程的内核空间是共享的。

`struct vm_area_struct`

一个进程所需要使用的虚拟空间中的各个部位未必连续，通常形成若干离散的虚存区间，对虚存区间的抽象就是数据结构struct vm_area_struct.

/* include/linux/mm_types.h */
/*
 * This struct defines a memory VMM memory area. There is one of these
 * per VM-area/task. A VM area is any part of the process virtual memory
 * space that has a special rule for the page-fault handlers (ie a shared
 * library, the executable area etc).
 */
struct vm_area_struct {
 struct mm_struct * vm_mm; /* The address space we belong to. */
 unsigned long vm_start; /* Our start address within vm_mm. */
 unsigned long vm_end; /* The first byte after our end address
 within vm_mm. */

 /* linked list of VM areas per task, sorted by address */
 struct vm_area_struct *vm_next;

 pgprot_t vm_page_prot; /* Access permissions of this VMA. */
 unsigned long vm_flags; /* Flags, see mm.h. */

 struct rb_node vm_rb;

 /*
 * For areas with an address space and backing store,
 * linkage into the address_space->i_mmap prio tree, or
 * linkage to the list of like vmas hanging off its node, or
 * linkage of vma in the address_space->i_mmap_nonlinear list.
 */
 union {
 struct {
 struct list_head list;
 void *parent; /* aligns with prio_tree_node parent */
 struct vm_area_struct *head;
 } vm_set;

 struct raw_prio_tree_node prio_tree_node;
 } shared;

 /*
 * A file's MAP_PRIVATE vma can be in both i_mmap tree and anon_vma
 * list, after a COW of one of the file pages. A MAP_SHARED vma
 * can only be in the i_mmap tree. An anonymous MAP_PRIVATE, stack
 * or brk vma (with NULL file) can only be in an anon_vma list.
 */
 struct list_head anon_vma_node; /* Serialized by anon_vma->lock */
 struct anon_vma *anon_vma; /* Serialized by page_table_lock */

 /* Function pointers to deal with this struct. */
 struct vm_operations_struct * vm_ops;

 /* Information about our backing store: */
 unsigned long vm_pgoff; /* Offset (within vm_file) in PAGE_SIZE
 units, *not* PAGE_CACHE_SIZE */
 struct file * vm_file; /* File we map to (can be NULL). */
 void * vm_private_data; /* was vm_pte (shared mem) */
 unsigned long vm_truncate_count;/* truncate_count or restart_addr */
#ifndef CONFIG_MMU
 struct vm_region *vm_region; /* NOMMU mapping region */
#endif
#ifdef CONFIG_NUMA
 struct mempolicy *vm_policy; /* NUMA policy for the VMA */
#endif
};

vm_mm : 指向一个mm_struct结构，是比vm_area_struct更高层次的结构，隶属于task_struct。
vm_start和vm_end : 决定了虚存区间，前闭后开即start在区间内，end不包含在区间内；
vm_next : 隶属于同一个进程的所有区间的结构链表指针；
vm_page_prot 和vm_flags : 表示同一个区间所有页面相同的访问权限以及其他一些属性；
vm_rb : 红黑树节点，当区间数量较大时只通过vm_next链式搜索速度太慢，加速搜索；
vm_ops : 指向一个vm_operations_struct指针，此结构中保存了一些函数指针，用于操作此区间，比如打开，关闭，建立映射以及处理缺页异常等操作。
在两种情况下虚存页面（或区间）会和磁盘文件发生联系，mapping vm_file等几个结构保存这种联系。
- swap，内存页面不够分配时，将一些久未使用的页面交换到磁盘上去；
- 通过mmap()将一个磁盘文件映射到进程的用户空间。

/*
 * These are the virtual MM functions - opening of an area, closing and
 * unmapping it (needed to keep files on disk up-to-date etc), pointer
 * to the functions called when a no-page or a wp-page exception occurs.
 */
struct vm_operations_struct {
 void (*open)(struct vm_area_struct * area);
 void (*close)(struct vm_area_struct * area);
 int (*fault)(struct vm_area_struct *vma, struct vm_fault *vmf);

 /* notification that a previously read-only page is about to become
 * writable, if an error is returned it will cause a SIGBUS */
 int (*page_mkwrite)(struct vm_area_struct *vma, struct vm_fault *vmf);

 /* called by access_process_vm when get_user_pages() fails, typically
 * for use by special VMAs that can switch between memory and hardware
 */
 int (*access)(struct vm_area_struct *vma, unsigned long addr,
 void *buf, int len, int write);
#ifdef CONFIG_NUMA
 /*
 * set_policy() op must add a reference to any non-NULL @new mempolicy
 * to hold the policy upon return. Caller should pass NULL @new to
 * remove a policy and fall back to surrounding context--i.e. do not
 * install a MPOL_DEFAULT policy, nor the task or system default
 * mempolicy.
 */
 int (*set_policy)(struct vm_area_struct *vma, struct mempolicy *new);
 /*
 * get_policy() op must add reference [mpol_get()] to any policy at
 * (vma,addr) marked as MPOL_SHARED. The shared policy infrastructure
 * in mm/mempolicy.c will do this automatically.
 * get_policy() must NOT add a ref if the policy at (vma,addr) is not
 * marked as MPOL_SHARED. vma policies are protected by the mmap_sem.
 * If no [shared/vma] mempolicy exists at the addr, get_policy() op
 * must return NULL--i.e., do not "fallback" to task or system default
 * policy.
 */
 struct mempolicy *(*get_policy)(struct vm_area_struct *vma,
 unsigned long addr);
 int (*migrate)(struct vm_area_struct *vma, const nodemask_t *from,
 const nodemask_t *to, unsigned long flags);
#endif
};

`struct mm_struct`

每个进程只有一个mm_struct结构，mm_struct是进程整个用户空间的抽象。

/* "include/linux/mm_types.h" */
struct mm_struct {
 struct vm_area_struct * mmap; /* list of VMAs */
 struct rb_root mm_rb;
 struct vm_area_struct * mmap_cache; /* last find_vma result */
 unsigned long (*get_unmapped_area) (struct file *filp,
 unsigned long addr, unsigned long len,
 unsigned long pgoff, unsigned long flags);
 void (*unmap_area) (struct mm_struct *mm, unsigned long addr);
 unsigned long mmap_base; /* base of mmap area */
 unsigned long task_size; /* size of task vm space */
 unsigned long cached_hole_size; /* if non-zero, the largest hole below free_area_cache */
 unsigned long free_area_cache; /* first hole of size cached_hole_size or larger */
 pgd_t * pgd;
 atomic_t mm_users; /* How many users with user space? */
 atomic_t mm_count; /* How many references to "struct mm_struct" (users count as 1) */
 int map_count; /* number of VMAs */
 struct rw_semaphore mmap_sem;
 spinlock_t page_table_lock; /* Protects page tables and some counters */

 struct list_head mmlist; /* List of maybe swapped mm's. These are globally strung
 * together off init_mm.mmlist, and are protected
 * by mmlist_lock
 */

 /* Special counters, in some configurations protected by the
 * page_table_lock, in other configurations by being atomic.
 */
 mm_counter_t _file_rss;
 mm_counter_t _anon_rss;

 unsigned long hiwater_rss; /* High-watermark of RSS usage */
 unsigned long hiwater_vm; /* High-water virtual memory usage */

 unsigned long total_vm, locked_vm, shared_vm, exec_vm;
 unsigned long stack_vm, reserved_vm, def_flags, nr_ptes;
 unsigned long start_code, end_code, start_data, end_data;
 unsigned long start_brk, brk, start_stack;
 unsigned long arg_start, arg_end, env_start, env_end;

 unsigned long saved_auxv[AT_VECTOR_SIZE]; /* for /proc/PID/auxv */

 cpumask_t cpu_vm_mask;

 /* Architecture-specific MM context */
 mm_context_t context;

 /* Swap token stuff */
 /*
 * Last value of global fault stamp as seen by this process.
 * In other words, this value gives an indication of how long
 * it has been since this task got the token.
 * Look at mm/thrash.c
 */
 unsigned int faultstamp;
 unsigned int token_priority;
 unsigned int last_interval;

 unsigned long flags; /* Must use atomic bitops to access the bits */

 struct core_state *core_state; /* coredumping support */

 /* aio bits */
 spinlock_t ioctx_lock;
 struct hlist_head ioctx_list;

#ifdef CONFIG_MM_OWNER
 /*
 * "owner" points to a task that is regarded as the canonical
 * user/owner of this mm. All of the following must be true in
 * order for it to be changed:
 *
 * current == mm->owner
 * current->mm != mm
 * new_owner->mm == mm
 * new_owner->alloc_lock is held
 */
 struct task_struct *owner;
#endif

#ifdef CONFIG_PROC_FS
 /* store ref to file /proc/<pid>/exe symlink points to */
 struct file *exe_file;
 unsigned long num_exe_file_vmas;
#endif
#ifdef CONFIG_MMU_NOTIFIER
 struct mmu_notifier_mm *mmu_notifier_mm;
#endif
};

* mmap ：用来建立一个虚存区间vm_area_struct的单链线性队列；
mm_rb : 用来建立vm_area_struct的红黑树结构；
* mmap_cache : 用来指向最近一次用到的vm_area_struct结构；
* pgd : 指向该进程的页表目录，当内核调度一个进程进入运行时，就将这个地址转换成物理地址，并写入CR3寄存器；
map_count : 说明此进程有多少个vm_area_struct结构；
mm_users和mm_count : atomic_t（原子）类型，一个进程只能有一个mm_struct，但是一个mm_struct可能同时为多个进程服务，此两个变量用以计数。
mmap_sem和page_table_lock : 用于此结构的信号量和用于页表的锁，用于进程间的互斥和并发；
start_code, end_code, start_data, end_data : 进程的代码段、数据段，此外还有堆栈段等的起点和终点。

内存管理基本框架

管理区分配器接收动态内存分配与释放的请求，在请求分配的情况下，该部分搜索一个能满足所请求的一组连续的页框的内存管理区。在每个管理区内，页框被伙伴算法系统处理。每CPU页框高速缓存包含一些预先分配，它们被用于满足本地CPU发出的单一内存请求。

伙伴系统

网上超了一段算法的简单描述如下。

为了便于页面的维护，将多个页面组成内存块，每个内存块都有 2 的方幂个页，方幂的指数被称为阶 order。order相同的内存块被组织到一个空闲链表中。伙伴系统基于2的方幂来申请释放内存页。当申请内存页时，伙伴系统首先检查与申请大小相同的内存块链表中，检看是否有空闲页，如果有就将其分配出去，并将其从链表中删除，否则就检查上一级，即大小为申请大小的2倍的内存块空闲链表，如果该链表有空闲内存，就将其分配出去，同时将剩余的一部分（即未分配出去的一半）加入到下一级空闲链表中；如果这一级仍没有空闲内存；就检查它的上一级，依次类推，直到分配成功或者彻底失败，在成功时还要按照伙伴系统的要求，将未分配的内存块进行划分并加入到相应的空闲内存块链表在释放内存页时，会检查其伙伴是否也是空闲的，如果是就将它和它的伙伴合并为更大的空闲内存块，该检查会递归进行，直到发现伙伴正在被使用或者已经合并成了最大的内存块。

在linux中可以通过命令cat /proc/buddyinfo查看系统中伙伴系统使用情况。

此处以DMA区域进行分析，第二列值为4，表示当前系统中DMA区域，可用的连续两页的内存大小为4*2*PAGE_SIZE；第三列值为21，表示当前系统中DMA区域，可用的连续四页的内存大小为21*2^2*PAGE_SIZE。

/* include/mm/mmzone.h */
/* Free memory management - zoned buddy allocator. */
#ifndef CONFIG_FORCE_MAX_ZONEORDER
#define MAX_ORDER 11
#else
#define MAX_ORDER CONFIG_FORCE_MAX_ZONEORDER
#endif
#define MAX_ORDER_NR_PAGES (1 << (MAX_ORDER - 1))

struct zone {
 /* 略 */
 struct free_area free_area[MAX_ORDER];
 /* 略 */
}；
#define MIGRATE_UNMOVABLE 0
#define MIGRATE_RECLAIMABLE 1
#define MIGRATE_MOVABLE 2
#define MIGRATE_RESERVE 3
#define MIGRATE_ISOLATE 4 /* can't allocate from here */
#define MIGRATE_TYPES 5

struct free_area {
 struct list_head free_list[MIGRATE_TYPES];
 unsigned long nr_free;
};

nr_free:其中nr_free表示内存页块的数目，对于0阶的表示以1页为单位计算，对于1阶的以2页为单位计算，n阶的以2的n次方为单位计算。
free_list:用于将具有该大小的内存页块连接起来。由于内存页块表示的是连续的物理页，因而对于加入到链表中的每个内存页块来说，只需要将内存页块中的第一个页加入该链表即可。因此这些链表连接的是每个内存页块中第一个内存页，使用了struct page中的struct list_head lru成员。free_list数组元素的每一个对应一种属性的类型，可用于不同的目地，但是它们的大小和组织方式相同。

每个struct zone都有11(MAX_ORDER)个struct free_area结构，每一个free_area包含5(MIGRATE_TYPES)个链表，其中每一个链表中的内存页面按照其自身是否可以释放或者迁移被归为一类，于是凡是请求“不可迁移”页面的分配请求全部在free_list[MIGRATE_UNMOVABLE]这条链表上分配。

/* include/linux/mm_types.h */
struct page{
 /* 略 */
 struct list_head lru;
 /* 略 */
};

参考

Linux /proc/buddyinfo理解

linux 2.6.36的free_area结构

linux内核对伙伴系统的改进–migrate_type

linux内核内存管理学习之二（物理内存管理–伙伴系统）

slab系统

伙伴算法系统采用页框作为基本内存区，这适合于对大块内存的请求，但是如何处理小内存的请求，比如说几十或者几百个字节？linux kernel采用slab系统进行高效的小内存管理。

make menuconfig后输入/搜索slab后回车，会看到下图的路径。

此外还有

SLAB是基础，是最早从Sun OS那引进的；
SLUB是在Slab上进行的改进，在大型机上表现出色，据说还被IA-64作为默认；
SLOB是针对小型系统设计的，主要是嵌入式。

slab分配器把对象分组放进高速缓存，每个高速缓存都是同种类型对象的“储备”。例如，当一个文件被打开时，存放相应“打开文件”对象所需的内存区是从一个叫做filp的slab分配器的高速缓存中得到的。

`1`	`cat /proc/slabinfo #查看系统中slab使用情况`

也可以使用slabtop命令查看slab系统使用情况。

OBJS — The total number of objects (memory blocks), including those in use (allocated), and some spares not in use.
ACTIVE — The number of objects (memory blocks) that are in use (allocated).
USE — Percentage of total objects that are active. ((ACTIVE/OBJS)(100))
OBJ SIZE — The size of the objects.
SLABS — The total number of slabs.
OBJ/SLAB — The number of objects that fit into a slab.
CACHE SIZE — The cache size of the slab.
NAME — The name of the slab.

包含高速缓存的主内存区域被划分为多个slab，每个slab由一个或多个连续的页框组成，这些页框中既包含已经分配的对象，也包含空闲的对象。

每个高速缓存都是由struct kmem_cache类型的数据结构来描述的。

/* mm/slab.c */
/*
 * struct kmem_cache
 *
 * manages a cache.
 */

struct kmem_cache {
/* 1) per-cpu data, touched during every alloc/free */
 struct array_cache *array[NR_CPUS];
/* 2) Cache tunables. Protected by cache_chain_mutex */
 unsigned int batchcount;
 unsigned int limit;
 unsigned int shared;

 unsigned int buffer_size;
 u32 reciprocal_buffer_size;
/* 3) touched by every alloc & free from the backend */

 unsigned int flags; /* constant flags */
 unsigned int num; /* # of objs per slab */

/* 4) cache_grow/shrink */
 /* order of pgs per slab (2^n) */
 unsigned int gfporder;

 /* force GFP flags, e.g. GFP_DMA */
 gfp_t gfpflags; /* 分配页框时传递给伙伴系统函数的一组标志 */

 size_t colour; /* cache colouring range */
 unsigned int colour_off; /* colour offset */
 struct kmem_cache *slabp_cache;
 unsigned int slab_size; /* 单个slab的大小 */
 unsigned int dflags; /* dynamic flags */

 /* constructor func */
 void (*ctor)(void *obj);

/* 5) cache creation/removal */
 const char *name; /* 存放高速缓存的名字 */
 struct list_head next; /* 高速缓存描述符双向链表使用的指针 */

/* 6) statistics */
#if STATS
 unsigned long num_active;
 unsigned long num_allocations;
 unsigned long high_mark;
 unsigned long grown;
 unsigned long reaped;
 unsigned long errors;
 unsigned long max_freeable;
 unsigned long node_allocs;
 unsigned long node_frees;
 unsigned long node_overflow;
 atomic_t allochit;
 atomic_t allocmiss;
#endif
#if DEBUG
 /*
 * If debugging is enabled, then the allocator can add additional
 * fields and/or padding to every object. buffer_size contains the total
 * object size including these internal fields, the following two
 * variables contain the offset to the user object and its size.
 */
 int obj_offset;
 int obj_size;
#endif
 /*
 * We put nodelists[] at the end of kmem_cache, because we want to size
 * this array to nr_node_ids slots instead of MAX_NUMNODES
 * (see kmem_cache_init())
 * We still use [MAX_NUMNODES] and not [1] or [0] because cache_cache
 * is statically defined, so we reserve the max number of nodes.
 */
 struct kmem_list3 *nodelists[MAX_NUMNODES];
 /*
 * Do not add fields after nodelists[]
 */
};

第一个元素是 struct array_cache，其定义如下

 struct array_cache {
 unsigned int avail; /* 可用对象数目 */
 unsigned int limit; /* 可拥有的最大对象数目，和kmem_cache中一样 */
 unsigned int batchcount; /* 同kmem_cache，要转移进本地高速缓存或从本地高速缓存中转移出去的对象的个数 */
 unsigned int touched; /* 是否在收缩后被访问过 */
 spinlock_t lock;
 void *entry[]; /*
 * Must have this definition in here for the proper
 * alignment of array_cache. Also simplifies accessing
 * the entries.
 */
 /* entry是一个伪数组，初始没有任何数据项，之后会增加并保存释放的对象指针 */
};

其中kmem_list3结构主要保存了三个slab结构链表，是slab系统的核心，其定义如下

/* mm/slab.c */
/*
 * The slab lists for all objects.
 */
struct kmem_list3 {
 struct list_head slabs_partial; /* partial list first, better asm code */
 struct list_head slabs_full; /* 不包含空闲对象的slab描述符双向循环链表 */
 struct list_head slabs_free; /* 只包含空闲对象的slab描述符双向循环链表 */
 unsigned long free_objects; /* 高速缓存中空闲对象的个数 */
 unsigned int free_limit;
 unsigned int colour_next; /* Per-node cache coloring */
 spinlock_t list_lock;
 struct array_cache *shared; /* shared per node */
 struct array_cache **alien; /* on other nodes */
 unsigned long next_reap; /* updated without locking */
 int free_touched; /* updated without locking */
};

slab描述符

/* mm/slab.c */
/*
 * struct slab
 *
 * Manages the objs in a slab. Placed either at the beginning of mem allocated
 * for a slab, or allocated from an general cache.
 * Slabs are chained into three list: fully used, partial, fully free slabs.
 */
struct slab {
 struct list_head list; /* slab描述符的三个双向循环链表中的一个 */
 unsigned long colouroff;/* slab中第一个对象的偏移 */
 void *s_mem; /* including colour offset slab中第一个对象的地址 */
 unsigned int inuse; /* num of objs active in slab 正在使用的非空闲slab的对象个数*/
 kmem_bufctl_t free; /* slab中下一个空闲对象的下标 */
 unsigned short nodeid;
};

slab分配器的接口

新建一个高速缓存

/**
 * kmem_cache_create - Create a cache.
 * @name: A string which is used in /proc/slabinfo to identify this cache.
 * @size: The size of objects to be created in this cache.
 * @align: The required alignment for the objects.
 * @flags: SLAB flags
 * @ctor: A constructor for the objects.
 *
 * Returns a ptr to the cache on success, NULL on failure.
 * Cannot be called within a int, but can be interrupted.
 * The @ctor is run when new pages are allocated by the cache.
 *
 * @name must be valid until the cache is destroyed. This implies that
 * the module calling this has to destroy the cache before getting unloaded.
 * Note that kmem_cache_name() is not guaranteed to return the same pointer,
 * therefore applications must manage it themselves.
 *
 * The flags are
 *
 * %SLAB_POISON - Poison the slab with a known test pattern (a5a5a5a5)
 * to catch references to uninitialised memory.
 *
 * %SLAB_RED_ZONE - Insert `Red' zones around the allocated memory to check
 * for buffer overruns.
 *
 * %SLAB_HWCACHE_ALIGN - Align the objects in this cache to a hardware
 * cacheline. This can be beneficial if you're counting cycles as closely
 * as davem.
 */
struct kmem_cache *
kmem_cache_create (const char *name, size_t size, size_t align,
 unsigned long flags, void (*ctor)(void *));

销毁一个高速缓存

/**
 * kmem_cache_destroy - delete a cache
 * @cachep: the cache to destroy
 *
 * Remove a &struct kmem_cache object from the slab cache.
 *
 * It is expected this function will be called by a module when it is
 * unloaded. This will remove the cache completely, and avoid a duplicate
 * cache being allocated each time a module is loaded and unloaded, if the
 * module doesn't have persistent in-kernel storage across loads and unloads.
 *
 * The cache must be empty before calling this function.
 *
 * The caller must guarantee that noone will allocate memory from the cache
 * during the kmem_cache_destroy().
 */
void kmem_cache_destroy(struct kmem_cache *cachep);

从缓存中分配对象

/**
 * kmem_cache_alloc - Allocate an object
 * @cachep: The cache to allocate from.
 * @flags: See kmalloc().
 *
 * Allocate an object from this cache. The flags are only relevant
 * if the cache has no available objects.
 */
void *kmem_cache_alloc(struct kmem_cache *cachep, gfp_t flags);

释放对象回高速缓存

/**
 * kmem_cache_free - Deallocate an object
 * @cachep: The cache the allocation was from.
 * @objp: The previously allocated object.
 *
 * Free an object which was previously allocated from this
 * cache.
 */
void kmem_cache_free(struct kmem_cache *cachep, void *objp);

一个示例

/* 1. 定义一个全局变量存放指向task_struct高速缓存的指针 */
struct kmem_cache *task_struct_cachep;

/* 2. 内核初始化期间，在kernel/fork.c中的fork_init()中会创建高速缓存 */
/* create a slab on which task_structs can be allocated */
task_struct_cachep = kmem_cache_create("task_struct", sizeof(struct task_struct), ARCH_MIN_TASKALIGN, SLAB_PANIC, NULL);

/* 3. 从task_struct_cachep中分配对象
 do_fork() ->
 copy_process() ->
 dup_task_struct() ->
 struct task_struct *tsk;
 tsk = alloc_task_struct();
其中alloc_task_struct() 定义为
*/
#ifndef __HAVE_ARCH_TASK_STRUCT_ALLOCATOR
# define alloc_task_struct() kmem_cache_alloc(task_struct_cachep, GFP_KERNEL)
# define free_task_struct(tsk) kmem_cache_free(task_struct_cachep, (tsk))
static struct kmem_cache *task_struct_cachep;
#endif
/* 即 */
struct task_struct *tsk;
tsk = kmem_cache_alloc(task_struct_cachep, GFP_KERNEL);

slab系统申请页框

当slab分配器创建新的slab时，它依靠分区页框分配器来获得一组连续的空闲页框（一般是从伙伴系统获得）。一般调用kmem_gerpages()函数实现。

给高速缓存分配slab

只有当已发出一个分配新对象的请求，且高速缓存不包含任何空闲对象时，才给高速缓存分配slab。

slab分配器通过调用cache_grow()函数给高速缓存分配一个新的slab。cache_grow()调用kmem_getpages()获得一组页框来存放一个单独的slab，然后调用alloc_slabmgmt()函数获得一个新的slab描述符。接着调用cache_init_objs()函数，它将构造方法应用到新的slab包含的所有对象上，最后调用list_add_tail()来讲新得到的slab描述符*slabp，添加到高速缓存描述符*cachep的全空slab链表的末端，并更新告诉缓存中的空闲对象计数器。

/* mm/slab.c" */
/*
 * Grow (by 1) the number of slabs within a cache. This is called by
 * kmem_cache_alloc() when there are no active objs left in a cache.
 */
static int cache_grow(struct kmem_cache *cachep,
 gfp_t flags, int nodeid, void *objp)
{
 struct slab *slabp;
 size_t offset;
 gfp_t local_flags;
 struct kmem_list3 *l3;

 /*
 * Be lazy and only check for valid flags here, keeping it out of the
 * critical path in kmem_cache_alloc().
 */
 BUG_ON(flags & GFP_SLAB_BUG_MASK);
 local_flags = flags & (GFP_CONSTRAINT_MASK|GFP_RECLAIM_MASK);

 /* Take the l3 list lock to change the colour_next on this node */
 check_irq_off();
 l3 = cachep->nodelists[nodeid];
 spin_lock(&l3->list_lock);

 /* Get colour for the slab, and cal the next value. */
 offset = l3->colour_next;
 l3->colour_next++;
 if (l3->colour_next >= cachep->colour)
 l3->colour_next = 0;
 spin_unlock(&l3->list_lock);

 offset *= cachep->colour_off;

 if (local_flags & __GFP_WAIT)
 local_irq_enable();

 /*
 * The test for missing atomic flag is performed here, rather than
 * the more obvious place, simply to reduce the critical path length
 * in kmem_cache_alloc(). If a caller is seriously mis-behaving they
 * will eventually be caught here (where it matters).
 */
 kmem_flagcheck(cachep, flags);

 /*
 * Get mem for the objs. Attempt to allocate a physical page from
 * 'nodeid'.
 */
 if (!objp)
 objp = kmem_getpages(cachep, local_flags, nodeid);
 if (!objp)
 goto failed;

 /* Get slab management. */
 slabp = alloc_slabmgmt(cachep, objp, offset,
 local_flags & ~GFP_CONSTRAINT_MASK, nodeid);
 if (!slabp)
 goto opps1;
 slab_map_pages(cachep, slabp, objp);

 cache_init_objs(cachep, slabp);

 if (local_flags & __GFP_WAIT)
 local_irq_disable();
 check_irq_off();
 spin_lock(&l3->list_lock);

 /* Make slab active. */
 list_add_tail(&slabp->list, &(l3->slabs_free));
 STATS_INC_GROWN(cachep);
 l3->free_objects += cachep->num;
 spin_unlock(&l3->list_lock);
 return 1;
opps1:
 kmem_freepages(cachep, objp);
failed:
 if (local_flags & __GFP_WAIT)
 local_irq_disable();
 return 0;
}

/*
简单总结cache_grow()的流程
static int cache_grow(struct kmem_cache *cachep,
 gfp_t flags, int nodeid, void *objp)
{
 objp = kmem_getpages(cachep, local_flags, nodeid); //获得页框

 slabp = alloc_slabmgmt(cachep, objp, offset,
 local_flags & ~GFP_CONSTRAINT_MASK, nodeid); //获得一个新的slab描述符
 cache_init_objs(cachep, slabp); // 初始化slab
 list_add_tail(&slabp->list, &(l3->slabs_free)); //将新分配的slab加入到空闲链表
 l3->free_objects += cachep->num; //更新空闲slab计数器
}
*/

关于高端内存

全文参考

大佬的blog

ULK3

LKD3

Linux内核源代码情景分析

Linux设备驱动开发--中断用法

yuanye.ma@qq.com (Yuanye Ma) — Sat, 17 Oct 2020 16:01:23 +0800

[TOC]

1. `linux`中`file` `cdev` `inode`之间的关系；

struct file对象：描述进程中打开文件的信息，包括文件名、读写标志、文件的当前偏移指针等。

#include <linux/fs.h>
struct file {
 /*
 * fu_list becomes invalid after file_free is called and queued via
 * fu_rcuhead for RCU freeing
 */
 union {
 struct list_head fu_list;
 struct rcu_head fu_rcuhead;
 } f_u;
 struct path f_path;
 /* 略 */
 const struct file_operations *f_op; // 文件操作接口
 spinlock_t f_lock; /* f_ep_links, f_flags, no IRQ */
 /* 略 */
 loff_t f_pos; // 文件偏移
 struct fown_struct f_owner;
 const struct cred *f_cred;
 struct file_ra_state f_ra;

 /* 略 */
 void *private_data; // 万能指针，可以用来存储私有的数据地址
 /* 略 */
};

struct cdev对象：描述一个字符设备对象，任何一个字符设备驱动都应该有此对象；

#include <linux/cdev.h>
struct cdev {
 struct kobject kobj;
 struct module *owner;
 const struct file_operations *ops;
 struct list_head list;
 dev_t dev; // 设备号
 unsigned int count;
};

struct inode对象：描述文件系统中某个文件的信息；

#include <linux/fs.h>
struct inode {
 /* RCU path lookup touches following: */
 umode_t i_mode;
 uid_t i_uid;
 gid_t i_gid;
 /* 省略众多暂时无关的成员 */
 const struct file_operations *i_fop; /* former ->i_op->default_file_ops */
 struct file_lock *i_flock;
 struct address_space *i_mapping;
 struct address_space i_data;
#ifdef CONFIG_QUOTA
 struct dquot *i_dquot[MAXQUOTAS];
#endif
 struct list_head i_devices;
 union {
 struct pipe_inode_info *i_pipe;
 struct block_device *i_bdev;
 struct cdev *i_cdev;
 };
 /* 略 */
};

字符设备通过register_chrdev(设备号, fops)将cdev结构体挂接在内核中cdev的链表上。

用户空间mknod的时候，会在/dev/下创建设备文件，该文件在内存中对应一个inode对象，mknod的设备号赋给inode.

用户空间open()的时候，通过inode中的i_cdev找到对应的cdev，将cdev->ops赋值给struct file的f_op，执行f_op->open()；

/* 通过inode获得主次设备号*/
int minor = iminot(const struct inode * inode);
int major = imajor(const struct inode * inode);
/* 通过filp找到inode */
struct inode * node = filp->f_path.dentry->d_inode;

2. 注册字符设备的方式

/*1.两种方式申请设备号*/
/* 1.1 静态申请设备号--仅仅得到设备号，注册设备*/
dev_t devno = MKDEV(260, 0);
register_chrdev_region(devno, 1, “key_new_drv”);
int register_chrdev_region(dev_t from, unsigned count, const char * name);
 // 参数一： 设备号
 // 参数二： 设备的个数
 // 参数三： 描述字符串 --- /proc/devices
 // 返回值： 0 成功， -1 失败
/* 1.2 动态分配设备号*/
int alloc_chrdev_region(dev_t * dev, unsigned baseminor, unsigned count, const char * name);
 // 参数一： 保存主设备号的变量地址
 // 参数二： 次设备号的起始地址
 // 参数三： 设备的个数
 // 参数四： 描述字符串 --- /proc/devices
 // 返回值： 0 成功， -1 失败

/*2.动态分配一个cdev结构对象*/
cdev_alloc(void);
/*3.初始化cdev对象*/
cdev_init(struct cdev * cdev, const struct file_operations * fops);
/*4.将当前的cdev注册到系统中*/
cdev_add(struct cdev * p, dev_t dev, unsigned count);
 // 参数二：设备号
 // 参数三：设备的个数，一般都填1


/*
 以上1、2、3、4步骤等同于用
 int register_chrdev(unsigned int major, const char *name,
 const struct file_operations *fops)
 此函数内部会创建并初始化cdev对象， 当第一个参数为0时，自动分配设备号。
*/

cdev_del();
unregister_chrdev();
unregister_chrdev_region

3. 申请中断

// 注册中断的处理方法
static inline int __must_check
request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
 const char *name, void *dev)
 //参数一： 中断号， IRQ_EINT(x) x为外部中断号 arch/../mach/irqs.h中有枚举
 //参数二： 中断处理函数 typedef irqreturn_t (*irq_handler_t)(int, void *);
 //参数三： 中断的触发方式，include/linux/interrupt.h文件中定义
 #define IRQF_TRIGGER_NONE 0x00000000
 #define IRQF_TRIGGER_RISING 0x00000001
 #define IRQF_TRIGGER_FALLING 0x00000002
 #define IRQF_TRIGGER_HIGH 0x00000004
 #define IRQF_TRIGGER_LOW 0x00000008
 #define IRQF_TRIGGER_MASK (IRQF_TRIGGER_HIGH | IRQF_TRIGGER_LOW | \
 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING)
 #define IRQF_TRIGGER_PROBE 0x00000010
 //参数四： /proc/interrupts中显示的字符串
 //参数五： 传递给中断处理函数的参数
 //返回值：

// irq_handler_t的原型
typedef irqreturn_t (*irq_handler_t)(int, void *);
//返回值如下
/**
 * enum irqreturn
 * @IRQ_NONE interrupt was not from this device
 * @IRQ_HANDLED interrupt was handled by this device
 * @IRQ_WAKE_THREAD handler requests to wake the handler thread
 */
enum irqreturn {
 IRQ_NONE = (0 << 0),
 IRQ_HANDLED = (1 << 0), //正常处理结束
 IRQ_WAKE_THREAD = (1 << 1),
};

typedef enum irqreturn irqreturn_t;

//释放中断
void free_irq(unsigned int irq, void * dev_id)
 //参数一: 中断号
 //参数二： 和request_irq()函数的最后一个参数保持一致

4. 文件io模型实现之阻塞和非阻塞

实现阻塞

/*实现阻塞的步骤*/
/* 1 将当前进程状态设置为TASK_INTERRUPTIBLE : 可以被信号唤醒 */
set_current_state(TASK_INTERRUPTIBLE);
/* 2 将当前进程加入到一个等待队列 */
add_wait_queue(wait_queue_head_t * q, wait_queue_t * wait)；
/* 3 让出调度权 */
schedule();

/* 以上三个函数等同于wait_event_interruptible */
wait_event_interruptible(struct wait_queue_head_t wq, int condition);
 //参数一： 等待队列头
 //参数二： 条件，如果为假，就休眠，否则继续执行

/* 资源可达的时候需要唤醒进程 */
wake_up_interruptible(x)

/* 定义一个等待队列头 */
struct wait_queue_head_t wq_head;
/* 初始化等待队列 */
init_waitqueue_head(wq_head);

实现非阻塞

//在应用程序中设定非阻塞模式
int fd = open("/dev/key0", O_RDWR|O_NOBLOCK);
 // 有数据就得到数据，没有数据就得到一个出错码 -EAGAIN

//在驱动xxx_read中要区分是阻塞还是非阻塞
if ( (filp->f_flags & O_NONBLOCK) && 没有数据) //非阻塞且没有数据，就返回出错码
{
 return -EAGAIN;
}

5. 按键驱动

v1版本

实现按键触发中断

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/interrupt.h>
#include <linux/cdev.h>

#define IR_GPIO GPIOH(8)


#define USE_STATIC_MAJOR 1
#define KEY_MAJOR 260

struct s5pv210_key {
 dev_t devno;
 int dev_major;
 int irqno;
 struct cdev *cdev;
 struct class *cls;
 struct device *dev;
};
struct s5pv210_key *key_dev;

static int key_drv_open(struct inode *inode, struct file *filp)
{
 return 0;
}


static int key_drv_close(struct inode *inode, struct file *filp)
{
 printk("-------^_^ %s-------\n", __FUNCTION__);
 return 0;
}

struct file_operations key_fops = {
 .open = key_drv_open,
 .release = key_drv_close,
};

irqreturn_t key_irq_svc(int irqno, void *dev_id)
{
 printk(" --------- ^-^ ---------%s \n", __FUNCTION__);
 return IRQ_HANDLED;
}


static int __init key_drv_init(void)
{
 int ret;
 key_dev = kzalloc(sizeof(struct s5pv210_key), GFP_KERNEL);
 if (key_dev == NULL) {
 printk(KERN_ERR"kzalloc error\n");
 return -ENOMEM;
 }
 #ifdef USE_STATIC_MAJOR
 key_dev->devno = MKDEV(KEY_MAJOR, 32);
 ret = register_chrdev_region(key_dev->devno, 1, "key"); /*申请设备号*/
 if (ret < 0) {
 printk(KERN_ERR"register chrdev failed\n");
 goto err_free;
 }
 #else
 ret = alloc_chrdev_region(&key_dev->devno, 32, 1, "key");
 if (ret != 0) {
 /* 出错 */
 printk(KERN_ERR"register chrdev failed\n");
 goto err_free;
 }
 #endif

 key_dev->cdev = cdev_alloc(); /*动态分配一个struct cdev对象*/
 cdev_init(key_dev->cdev, &key_fops); /*初始化cdev的fops*/
 cdev_add(key_dev->cdev, key_dev->devno, 1); /*将cdev注册到系统中*/

 /* 自动创建设备节点 */
 key_dev->cls = class_create(THIS_MODULE, "key_cls");
 if (IS_ERR(key_dev->cls)) {
 printk(KERN_ERR"class create error\n");
 ret = PTR_ERR(key_dev->cls);
 goto err_unregister;
 }

 key_dev->dev = device_create(key_dev->cls, NULL, MKDEV(key_dev->dev_major, 0), NULL, "key%d", 0);
 if (IS_ERR(key_dev->dev)) {
 printk(KERN_ERR"device create error\n");
 ret = PTR_ERR(key_dev->dev);
 goto err_class_destory;
 }

 /* 初始化硬件 */
 // 中断号获取 IRQ_EINT(x); irqs.h
 //key_dev->irqno = IRQ_EINT(1);
 key_dev->irqno = gpio_to_irq(IR_GPIO);
 ret = request_irq(key_dev->irqno, key_irq_svc, IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, "KEY", NULL);
 if (ret != 0) {
 printk(KERN_ERR"request irq error\n");
 ret = -EBUSY;
 goto err_device_destory;
 }

err_device_destory:
 device_destroy(key_dev->cls, key_dev->devno);
err_class_destory:
 class_destroy(key_dev->cls);
err_unregister:
 cdev_del(key_dev->cdev);
 unregister_chrdev_region(key_dev->devno, 1);
err_free:
 kfree(key_dev);
 return ret;
}

static void __exit key_drv_exit(void)
{
 class_destroy(key_dev->cls);
 cdev_del(key_dev->cdev);
 unregister_chrdev_region(key_dev->devno, 1);
 kfree(key_dev);
}
module_init(key_drv_init);
module_exit(key_drv_exit);

MODULE_LICENSE("GPL");

基于linux操作系统下s5pv210板子的按键中断实验

NanoPi—M1(H3)———基于该平台的一个内核中的按键中断程序开发历程

v2版本

识别按键

#include <linux/input.h> // KEY_DOWN
//设计一个按键数据包
struct key_event {
 int code; //按键的名字 --- 例如：下键、回车键
 int value; //按键的状态 --- 按下和抬起 1/0
};

struct s5pv210_key {
 dev_t devno;
 int dev_major;
 int irqno;
 struct cdev *cdev;
 struct class *cls;
 struct device *dev;
 struct key_event evnet;
};
struct s5pv210_key *key_dev;


irqreturn_t key_irq_svc(int irqno, void *dev_id)
{
 printk(" --------- ^-^ ---------%s \n", __FUNCTION__);
 int value = gpio_get_value(S5PV210_GPH0(1));

 if (value) {
 /* 抬起 */
 printk(" key up \n");
 key_dev->evnet.code = KEY_DOWN; //#include <linux/input.h>
 key_dev->event.value = 0;
 } else {
 printk(" key down \n");
 key_dev->evnet.code = KEY_DOWN;
 key_dev->event.value = 1;
 }
 return IRQ_HANDLED;
}
ssize_t key_drv_read(struct file (filp, char __user *buf, size_t count, loff_t *fpos)
{
 int ret = copy_to_user(buf, &key_dev->event, count);
 if (ret > 0){
 printk("copy_to_user error\n");
 return -EFAULT;
 }
 memset(&key_dev->event, 0, sizeof(struct key_event));
 return count;
}

应用程序

#include <linux/input.h> // KEY_DOWN grep -nHr "KEY_DOWN" /usr/include/
int fd = open("/dev/key0", O_RDWR);
if (fd < 0) {
 perror("open");
 exit(1);
}
while(1) {
 ret = read(fd, &event, sizeof(struct key_event));
 if (ret < 0) {
 perror("open");
 exit(1);
 }
 if (event.code == KEY_DOWN) {
 if (event.value) {
 printf("KEY DOWN : UP");
 } else {
 printf("KEY DOWN : DOWN");
 }
 }

}

v3版本

v2版本的应用程序在运行时不停的读取按键状态，非常耗费CPU资源。考虑使用阻塞方式将读不到内容时将进程挂起。

在按键中断程序中使用阻塞方式。

#include <linux/sched.h> //
#include <linux/wait.h>
struct s5pv210_key {
 dev_t devno;
 int dev_major;
 int irqno;
 struct cdev *cdev;
 struct class *cls;
 struct device *dev;
 struct key_event evnet;
 struct wait_queue_head_t wq_head;
 int have_data; // 一个标志，表示是否有数据，在open函数中将此标志置为0
};
struct s5pv210_key *key_dev;
/*在key_drv_init函数中初始化等待队列*/
static int __init key_drv_init(void)
{
 init_waitqueue_head(key_dev->wq_head);
}

/*在read函数中如果读不到数据就将进程休眠*/
ssize_t key_drv_read(struct file (filp, char __user *buf, size_t count, loff_t *fpos)
{
 int ret = 0；
 /*判断是否有资源*/
 wait_event_interruptible(key_dev->wq_head, key_dev->have_data);
 /**/
 ret = copy_to_user(buf, &key_dev->event, count);
 if (ret > 0){
 printk("copy_to_user error\n");
 return -EFAULT;
 }
 /* 清空缓冲区 为下一次读取操作做准备 */
 memset(&key_dev->event, 0, sizeof(struct key_event));
 /* 同时也要清空标志 */
 key_dev->have_data = 0;
 return count;
}

/* 在中断服务函数中唤醒挂起的进程 */
irqreturn_t key_irq_svc(int irqno, void *dev_id)
{
 printk(" --------- ^-^ ---------%s \n", __FUNCTION__);
 int value = gpio_get_value(S5PV210_GPH0(1));

 if (value) {
 /* 抬起 */
 printk(" key up \n");
 key_dev->evnet.code = KEY_DOWN; //#include <linux/input.h>
 key_dev->event.value = 0;
 } else {
 printk(" key down \n");
 key_dev->evnet.code = KEY_DOWN;
 key_dev->event.value = 1;
 }
 /* 此时有数据可以读写了 */
 key_dev->have_data = 1;
 /* 唤醒等待队列 */
 wake_up_interruptible(&key_dev->wq_head);
 return IRQ_HANDLED;
}

再看看驱动中区分是否阻塞需要注意的地方

/* 在本例中 */
ssize_t key_drv_read(struct file (filp, char __user *buf, size_t count, loff_t *fpos)
{
 int ret = 0;
 /* 区分阻塞还是非阻塞 */
 if ((filp->f_flags & O_NONBLOCK) && !key_dev->have_data) {
 return -EAGAIN;
 }

 /*判断是否有资源*/
 wait_event_interruptible(key_dev->wq_head, key_dev->have_data);
 /**/
 ret = copy_to_user(buf, &key_dev->event, count);
 if (ret > 0){
 printk("copy_to_user error\n");
 return -EFAULT;
 }
 /* 清空缓冲区 为下一次读取操作做准备 */
 memset(&key_dev->event, 0, sizeof(struct key_event));
 /* 同时也要清空标志 */
 key_dev->have_data = 0;
 return count;
}

手头只有NanoPi M1的板子，试验暂时还没做，加入TODO。

Linux设备驱动基础

yuanye.ma@qq.com (Yuanye Ma) — Sat, 10 Oct 2020 16:01:23 +0800

1.2 设备驱动基础

驱动基本结构

// hello_drv.c
#include <linux/init.h>
#include <linux/module.h>

static int __init hello_drv_init(void)
{
 printk(KERN_ERR"-----------from hello.ko : %s %s---------\n", __FILE__, __FUNCTION__);
 return 0;
}

static void __exit hello_drv_exit(void)
{
 printk("-----------from hello.ko : %s %s---------\n", __FILE__, __FUNCTION__);
}

module_init(hello_drv_init);
module_exit(hello_drv_exit);
MODULE_LICENSE("GPL");

基本Makefile结构

# 内核源码路径
KERNEL_DIR =
# 驱动源码所在目录
CUR_DIR = $(shell pwd)

# 指定编译哪些源文件
obj-m = hello_drv.o

all :
 make -C $(KERNEL_DIR) M=$(CUR_DIR) modules
clean ：
 make -C $(KERNEL_DIR) M=$(CUR_DIR) clean

运行/装载驱动模块

1
2
3

inmod hello_drv.ko #插入内核模块
rmmod hello_drv #移除内核模块
lsmod #查看当前已经插入的内核模块

其他特性

模块传参

1
2

// $insmod hello.ko number=250 name="ruhua"
module_param(参数名， 参数类型， 权限) //例： module_param(number, int, 666)

模块符号导出
1. EXPORT_SYMBOL(符号名)
2. 装载的时候先装载被调用的模块

一个真正的设备驱动需要一些元素

设备号

register_chrdev(unsigned int major, const char * name , const struct file_operations * fops);
/*
* 参数1 --- 指定一个主设备号，填0表示由系统自动分配
* 参数2 --- 字符串， 描述设备驱动信息，自定义
* 参数3 --- 文件操作对象
* 如果参数1为0，则返回值是一个int型的主设备号，否则返回负数为错误号， generic
*/
unregister_chrdev(unsigned int major, const char * name) //--- 释放已经注册的主设备号

设备文件

手动创建: 每次重启都得手动创建

mknod /dev/hello c 254 0

自动创建

#include <linux/device.h>
struct class * class_create(THIS_MODULE, “led_cls”)
 /*
 * 参数一： THIS_MODULE
 * 参数二 ： 字符串，表示类的名字
 * 返回值 struct class 指针类型
 */
struct device * device_create(struct class * cls, struct device * parent, dev_t devt, void * drvdata, const char * fmt, ...)
 /*
 * 参数一： class_create()返回的指针
 * 参数二： 该设备的父类
 * 参数三： 设备号， 包含主设备号和次设备号，MKDEV(major, minor)
 * 参数四： 私有数据指针，可以为NULL
 * 参数五： 设备节点名字
 * 返回值： struct device *
 */
void device_destory(struct device * dev, dev_t devt);
void class_destory(struct class * cls);

设备的操作方法

/*
 * NOTE:
 * all file operations except setlease can be called without
 * the big kernel lock held in all filesystems.
 */
struct file_operations {
 struct module *owner;
 loff_t (*llseek) (struct file *, loff_t, int);
 ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
 ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);

 unsigned int (*poll) (struct file *, struct poll_table_struct *);
 long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
 int (*mmap) (struct file *, struct vm_area_struct *);
 int (*open) (struct inode *, struct file *);
 int (*flush) (struct file *, fl_owner_t id);
 int (*release) (struct inode *, struct file *);
 /*省略其他不常用的*/
};
/*
 * 设备操作命令如何定义： 由程序员定义，一定是一个整数
* 1. 直接用整数 --- 有可能会和系统中已经有的命令冲突
 * #define LED_ALL_ON 0x2222
 * 2. 用内核提供的接口来定义
 #include <asm/ioctl.h>
 _IO(type, nr) //参数一 ：魔幻数---字符，参数二：唯一的数字
 __IOW(type, nr, size)
 __IOR(type, nr, size)
 __IOWR(type, nr, size)
 */
/* 原型如下 */
#define _IO(type,nr) _IOC(_IOC_NONE,(type),(nr),0)
#define _IOR(type,nr,size) _IOC(_IOC_READ,(type),(nr),sizeof(size))
#define _IOW(type,nr,size) _IOC(_IOC_WRITE,(type),(nr),sizeof(size))
#define _IOWR(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),sizeof(size))
 /* ------------------ 例 ----------------*/
#define LED_NUM_ON _IOW('L', 0x3456, int)
#define LED_NUM_OFF _IOW('L', 0x3457, int)
#define LED_ALL_ON _IOW('L', 0x3458)

xxx_ioctl(int fd, int cmd, unsigned long args)
{
 int num = args;
 switch(cmd)
 {
 case LED_NUM_ON：
 xxx
 break;
 case LED_NUM_OFF：
 xxx
 break;
 case LED_ALL_ON:
 xxx
 break;
 }
}

内存映射与映射

#include <linux/slab.h>
/**
 * kzalloc - allocate memory. The memory is set to zero.
 * @size: how many bytes of memory are required.
 * @flags: the type of memory to allocate (see kmalloc).
 */
static inline void *kzalloc(size_t size, gfp_t flags)
 //flags: GFP_KERNEL 如果当前暂时没有内存，会尝试等待（阻塞）
kfree()

#include <asm/io.h>
#define ioremap(cookie, size) __uc32_ioremap(cookie, size)
 /*
 * 参数一：物理地址
 * 参数二：映射的长度
 * 返回值：映射之后的虚拟地址
 */
/* ------------------ 例 ----------------*/
gpc0_conf = ioremap(0xE020060, 8);
gpc0_data = gpc0_conf+1;
 //配置输出
*gpc0_conf &= ~(0xff<<12); //清零
*gpc0_cong |= (0x11<<12); //置1
//亮灯
*gpc0_data |= 0x3<<3;
//灭灯
*gpc0_data &= ~(0x3<<3);

数据在内核空间和用户空间拷贝的方法

1
2
3

#include <asm/uaccess.h> 
unsigned long copy_from_user(void * to, void __user * from, unsigned long n);
unsigned long copy_to_user(void __user * to, const void * from, unsigned long n);

vim ctags cscope

yuanye.ma@qq.com (Yuanye Ma) — Thu, 08 Oct 2020 16:01:23 +0800

vim ctags cscope

ctags or cscope

为什么要同时用ctags和cscope

ctags启用了两个功能：允许您从函数调用跳转到其定义，以及omni完成。

第一个功能意味着当您调用方法时，按cscope_gen.sh或g]将跳转到定义或实现该方法的位置。

第二个功能意味着当您键入foo.或foo->时，如果foo是结构，则将显示具有字段完成的弹出菜单。

cscope也有第一个功能 - 使用cscope_gen.sh 。但是，cscope还增加了跳转到调用函数的任何地方的能力。

因此，就跳转代码库而言，ctags只会引导您前往实现函数的位置，而cscope也可以向您显示调用函数的位置。

ctags更容易设置，运行速度更快，如果你只关心单向跳跃，它会显示更少的线条。您只需运行cscope_gen.sh和g]即可。它还可以实现全方位的完整。

Cscope非常适合更大，未知的代码库。设置很痛苦，因为cscope需要一个包含要解析的文件名列表的文件。同样在vim中，默认情况下没有设置键绑定 - 您需要手动运行cscope_gen.sh。

安装

1
2

sudo apt-get install ctags
sudo apt-get install cscope

ctags

生成tags

$ cd linux/
$ ctags -R ./
# 在当前目录生成了tags文件
kevin→ $ ls -lh tags
-rw-rw-r-- 1 kevin kevin 392M 10月 8 20:50 tags

将tags添加到vimrc中

1
2
3

$ vim ~/.vimrc
# 写入以下内容
set tag = /home/kevin/linux/tags

简单使用
- 光标停留在符号上按ctrl+]自动跳转到定义处， ctrl+t跳转回调用处。
- vim -t start_kernel 会自动打开打开并跳转。
- vim中输入tselect tag会列出tag的表单，输入数字选择跳转到哪一处

HOW TO USE WITH VI

Vi will, by default, expect a tag file by the name “tags” in the current directory. Once the tag file is built, the following commands exercise the tag indexing feature:

vi −t tag Start vi and position the cursor at the file and line where “tag” is defined. :ta tag Find a tag.
Ctrl-] Find the tag under the cursor. Ctrl-T Return to previous location before jump to tag (not widely implemented).

cscope

配置cscope

在vim中输入:help cscope-suggestions可以查看帮助

$ vim ~/.vimrc
# 写入以下内容
if has("cscope")
 set csprg=/usr/bin/cscope "指定用来执行 cscope 的命令
 set csto=0
 set cst "使用|:cstag|(:cs find g)，而不是缺省的:tag
 set nocsverb "不显示添加数据库是否成功
 " add any database in current directory
 if filereadable("cscope.out")
 cs add cscope.out "添加cscope数据库
 " else add database pointed to by environment
 elseif $CSCOPE_DB != ""
 cs add $CSCOPE_DB
 endif
 set csverb "显示添加成功与否
endif

生成符号数据库

$ cd linux
$ make cscope
#使用下面的命令生成代码的符号索引文件：
$ cscope -Rbkq
#这个命令会生成三个文件：cscope.out, cscope.in.out, cscope.po.out。

#其中cscope.out是基本的符号索引，后两个文件是使用"-q"选项生成的，可以加快cscope的索引速度。上面命令的参数含义如下：
# -R: 在生成索引文件时，搜索子目录树中的代码
# -b: 只生成索引文件，不进入cscope的界面
# -d: 只调出cscope gui界面，不跟新cscope.out
# -k: 在生成索引文件时，不搜索/usr/include目录
# -q: 生成cscope.in.out和cscope.po.out文件，加快cscope的索引速度
# -i: 如果保存文件列表的文件名不是cscope.files时，需要加此选项告诉cscope到哪儿去找源文件列表。可以使用"-"，表示由标准输入获得文件列表。
# -I dir: 在-I选项指出的目录中查找头文件
# -u: 扫描所有文件，重新生成交叉索引文件
# -C: 在搜索时忽略大小写
# -P path: 在以相对路径表示的文件前加上的path，这样，你不用切换到你数据库文件所在的目录也可以使用它了。 

#在缺省情况下，cscope在生成数据库后就会进入它自己的查询界面，一般不用这个界面，所以使用了"-b"选项。如果已经进入了这个界面，按CTRL-D退出。

cscope的，命令格式如下：

cscope 命令:
add ：添加一个新的数据库 (用法： add file|dir [pre-path] [flags])
find ：查询一个模式 (用法： find a|c|d|e|f|g|i|s|t name)
 a: Find assignments to this symbol
 c: Find functions calling this function
 d: Find functions called by this function
 e: Find this egrep pattern
 f: Find this file
 g: Find this definition
 i: Find files #including this file
 s: Find this C symbol
 t: Find this text string
help ：显示此信息 (用法： help)
kill ：结束一个连接 (用法： kill #)
reset：重置所有连接 (用法： reset)
show ：显示连接 (用法： show)

说一下里边的键map映射

如： nmap <C-\>s :cs find s <C-R>=expand("<cword>")<CR><CR>
nmap 表示在vim的普通模式下，即相对于：编辑模块和可视模式，以下是几种模式
 :map 普通，可视模式及操作符等待模式
 :vmap 可视模式
 :omap 操作符等待模式
 :map! 插入和命令行模式
 :imap 插入模式
 :cmap 命令行模式
<C-\>表示：Ctrl+\
s表示输入(即按：s)s
: 表示输入':'
“cs find s"表示输入"cs find s"也即是要输入的命令
<C-R>=expand("cword")总体是为了得到：光标下的变量或函数。\
cword 表示：cursor word, 类似的还有：cfile表示光标所在处的文件名
将下面的内容添加到~/.vimrc中, 并重启vim:
nmap <C-_>s :cs find s <C-R>=expand("<cword>")<CR><CR>
nmap <C-_>g :cs find g <C-R>=expand("<cword>")<CR><CR>
nmap <C-_>c :cs find c <C-R>=expand("<cword>")<CR><CR>
nmap <C-_>t :cs find t <C-R>=expand("<cword>")<CR><CR>
nmap <C-_>e :cs find e <C-R>=expand("<cword>")<CR><CR>
nmap <C-_>f :cs find f <C-R>=expand("<cfile>")<CR><CR>
nmap <C-_>i :cs find i ^<C-R>=expand("<cfile>")<CR>$<CR>
nmap <C-_>d :cs find d <C-R>=expand("<cword>")<CR><CR>
当光标停在某个你要查找的词上时, 按下<C-_>g, 就是查找该对象的定义, 其他的同理.

搭建阅读内核环境的一些补充

本节内容摘自《ARM Linux源码剖析》

下载解压内核

安装ctages 和 cscope

1
2

$ sudo apt update
$ sudo apt install ctags cscope

生成标签

ctags程序通过程序代码生成标签，用以生成函数、变量、类成员、宏等的索引，以管理数据库。

使用ctags生成标签的命令是ctags -R。内核源码树中提供了用于生成各种架构ctags标签的脚本./scripts/tags.sh, 使用命令 make tags ARCH=arm可以生成arm架构的内核源码标签。
1 2 3 4 5 6

$ ls ./scripts/tags.sh ./scripts/tags.sh $ make tags ARCH=arm GEN tags $ ls -lah tags -rw-rw-r-- 1 kevin kevin 89M Nov 14 16:36 ./tags # 生成的89MB的tags文件

tags文件结构

tart_kernel include/linux/start_kernel.h /^extern asmlinkage void __init start_kernel(void);$/;" p
start_kernel init/main.c /^asmlinkage void __init start_kernel(void)$/;" f

tags_name<TAB>file_name<TAB>ex_cmd;<TAB>extension_fields
# tags_name 符号名 
# file_name 符号所在的文件名 
# ex_cmd 在文件中查找符号时，使用vim的ex模式，在此模式中搜索范式的正则表达式
# extension_field 符号类型 f=普通C函数， c=类， d=已定义的值

生成cscope数据库

ctags只能进行单方向的搜索，无法搜索调用的函数；无法输出调用该函数的函数；无法输出该函数调用的函数。cscope与ctags十分相似，但是补充了ctags的不足。

$ make cscope ARCH=arm
 GEN cscope
$ ls cscope* -lh
-rw-rw-r-- 1 kevin kevin 449K Nov 14 16:39 cscope.files
-rw-rw-r-- 1 kevin kevin 178M Nov 14 16:39 cscope.out
-rw-rw-r-- 1 kevin kevin 34M Nov 14 16:39 cscope.out.in
-rw-rw-r-- 1 kevin kevin 258M Nov 14 16:39 cscope.out.po
# 生成的四个文件
# cscope.files 含有要分析的代码文件列表的文件
# cscope.out 针对函数位置、函数调用、宏、变量、预处理符号的符号交叉引用文件，是实际的数据库
# cscope.out.in 用-q选项生成数据库时生成的文件，用于提高符号搜索速度的反向索引
# cscope.out.po 用-q选项生成数据库时生成的文件，作用同cscope.in

vim下插件配置

Source Explorer : 当光标停留在变量名或者函数名时，会显示此变量或者函数所在的文件列表；

NERDTree : 显示源码目录树；

Tag List : 显示文件中的符号列表；

vim的插件可以到vim官网下载，点击左侧"Scripts" -> “Browse all"在下方出现的搜索窗口中依次搜索需要的插件并下载。

$ mkdir -p ~/.vim/plugin
$ mv srcexpl.vim ~/.vim/plugin/
$ mv NERD_tree.zip ~/.vim/ && unzip NERD_tree.zip
$ mv taglist_45.zip ~/.vim/ && unzip taglist_45.zip

配置vim插件

$ vim ~/.vimrc


"------------------------------------------------"
"ctags database path"
"------------------------------------------------"
set tags=xxxxxx/tags "ctags DB位置"

"------------------------------------------------"
"cscope database path"
"------------------------------------------------"
set csprg=/usr/bin/cscope "cscope可执行程序的路径"
set csto=0 "cscope DS search first"
set cst "cscope D tag DB search"
set nocsverb "verbose off"
cs add /home/xxxx/cscope.out /home/code/linux-2.6.30.4
set csverb

"------------------------------------------------"
"Tag List"
"------------------------------------------------"
filetype on
nmap <F7> :TlistToggle<CR>
let Tlist_Ctags_Cmd = "/usr/bin/ctags"
let Tlist_Inc_Winwidth = 0 "window width change off"
let Tlist_Exit_OnlyWindow = 0 "tag/file完成选择时taglist window close = off"
let Tlist_Auto_Open = 0
let Tlist_Use_Right_Window = 1


"------------------------------------------------"
"Source Explore"
"------------------------------------------------"
nmap <F8> :SrcExplToggle<CR>
nmap <C-H> <C-W>h "向左侧窗口移动"
nmap <C-J> <C-W>j "向下侧窗口移动"
nmap <C-K> <C-W>k "向上侧窗口移动"
nmap <C-L> <C-W>l "向右侧窗口移动"

let g:SrcExpl_winHeight = 8 "指定SrcExpl Windows高度"
let g:SrcExpl_refreshTime = 100 "100ms"
let g:SrcExpl_jumpKey = "<Enter>" "按Enter跳转到相应的defineition"
let g:SrcExpl_gobackKey = "<SPACE>" "back"
let g:SrcExpl_isUpdateTags = 0 "tag file update = off"


"------------------------------------------------"
"NERD Tree"
"------------------------------------------------"
let NERDTreeWinPos = "left"
nmap <F2> :NERDTreeToggle<CR>

打开vim，按F2在左侧出现NERDTree源码目录树，选择./init/main.c。按Enter打开源码文件，按F8 F9打开TagList和Source Explorer窗口。

将光标移动到右侧的TagList窗口后，进入vim的ex模式(按Esc)后，输入:/start_kernel， TagList窗口会自动跳转到start_kernel符号处，再按Enter，则代码文件窗口会显示定义start_kernel的位置。

在代码窗口移动光标到函数或者变量名上时，在下方的Source Explorer窗口会显示定义相应符号的文件目录。将光标移动到下方Source Explorer窗口,上下选择要浏览的文件，按Enter上方代码浏览窗口会显示相应的文件内容，按SPACE会回退。

常用ctags命令

命令	说明
ctrl+]	移动到定义函数的位置
ctrl+t	回退到跳转前的位置

cscope命令格式: cs find <querytype> <name>

querytype	说明
0 or s	查找c符号
1 or g	查找定义（definition）
2 or d	查找被该函数调用（called）的函数
3 or c	查找调用该函数的（calling）函数
4 or t	查找文本字符串(text string)
6 or e	查找egrep范式
7 or f	查找文件
8 or i	查找用#include包含该文件的文件

：hellp cscope可以查看更详细的指令用法。

参考文献

cscope官网
 Cscope的使用（领略Vim + Cscope的强大魅力）
ctags
Ubuntu下查看Linux内核源码(vim+ctags) vim插件ctags的安装和使用 [VIM使用(二) 浏览内核源代码 ](https://www.cnblogs.com/linux-sir/p/4675919.html) 定义cscope快捷键

platform总线驱动

yuanye.ma@qq.com (Yuanye Ma) — Tue, 06 Oct 2020 16:01:23 +0800

Linux内核 platform总线驱动

platform总线驱动

在linux2.6以后的设备驱动模型中，需要关心总线、设备和驱动三个实体，总线将设备和驱动绑定。在系统中每注册一个设备时，总线会寻找与之匹配的驱动；相反的，在系统每注册一个驱动的时候，总线会寻找与之匹配的设备，而匹配绑定工作由总线完成。

platform总线是linux系统中的一种虚拟总线，相应的设备称为platform_device对应的驱动称为platfor_driver。

platform_device

#include <linux/platform_device.h>
struct platform_device {
 const char * name;
 int id;
 struct device dev; // 在linux设备驱动模型文章中有所介绍，是linux中所有设备对象的抽象
 u32 num_resources; // 设备对应的资源数量
 struct resource * resource; // 设备资源数组

 const struct platform_device_id *id_entry; //用于和platform_driver匹配

 /* MFD cell pointer */
 struct mfd_cell *mfd_cell;

 /* arch specific additions */
 struct pdev_archdata archdata;
};

int platform_device_register(struct platform_device *); //此函数调用platform_device_add(pdev)完成向platform总线注册设备
void platform_device_unregister(struct platform_device *); //此函数调用platform_device_del(pdev)完成从platform总线中删除设备
int platform_add_devices(struct platform_device **, int); //循环调用platform_device_register函数，批量注册platform_device


//函数定义在 drivers/base/platform.c中

/**
 * platform_device_register - add a platform-level device
 * @pdev: platform device we're adding
 */
int platform_device_register(struct platform_device *pdev)
{
 device_initialize(&pdev->dev);
 return platform_device_add(pdev);
}
EXPORT_SYMBOL_GPL(platform_device_register);


/**
 * platform_device_unregister - unregister a platform-level device
 * @pdev: platform device we're unregistering
 *
 * Unregistration is done in 2 steps. First we release all resources
 * and remove it from the subsystem, then we drop reference count by
 * calling platform_device_put().
 */
void platform_device_unregister(struct platform_device *pdev)
{
 platform_device_del(pdev);
 platform_device_put(pdev);
}
EXPORT_SYMBOL_GPL(platform_device_unregister);

/**
 * platform_add_devices - add a numbers of platform devices
 * @devs: array of platform devices to add
 * @num: number of platform devices in array
 */
int platform_add_devices(struct platform_device **devs, int num)
{
 int i, ret = 0;

 for (i = 0; i < num; i++) {
 ret = platform_device_register(devs[i]);
 if (ret) {
 while (--i >= 0)
 platform_device_unregister(devs[i]);
 break;
 }
 }

 return ret;
}
EXPORT_SYMBOL_GPL(platform_add_devices);

在板文件中，platform_device通常被组织成一个数组，通过在板级初始化时调用platform_add_devices()函数统一注册，例如mach-smdkv210.c的smdkv210_machine_init()函数调用platform_add_devices(smdkv210_devices, ARRAY_SIZE(smdkv210_devices));就是采用这种统一注册多个设备的方法。

platform_driver

#include <linux/platform_device.h>
struct platform_driver {
 int (*probe)(struct platform_device *);
 int (*remove)(struct platform_device *);
 void (*shutdown)(struct platform_device *);
 int (*suspend)(struct platform_device *, pm_message_t state);
 int (*resume)(struct platform_device *);
 struct device_driver driver; // 在linux设备驱动模型文章中有所介绍，是linux中所有驱动对象的抽象
 const struct platform_device_id *id_table;
};

// 操作方法如下
int platform_driver_register(struct platform_driver *drv); //初始化platform_driver结构，并向系统中注册struct driver
void platform_driver_unregister(struct platform_driver *drv); //从系统中删除struct driver

// drivers/base/platform.c中定义
/*
 * platform_driver_register - register a driver for platform-level devices
 * @drv: platform driver structure
 */
int platform_driver_register(struct platform_driver *drv)
{
 drv->driver.bus = &platform_bus_type;
 if (drv->probe)
 drv->driver.probe = platform_drv_probe;
 if (drv->remove)
 drv->driver.remove = platform_drv_remove;
 if (drv->shutdown)
 drv->driver.shutdown = platform_drv_shutdown;

 return driver_register(&drv->driver);
}
/**
 * platform_driver_unregister - unregister a driver for platform-level devices
 * @drv: platform driver structure
 */
void platform_driver_unregister(struct platform_driver *drv)
{
 driver_unregister(&drv->driver);
}

platform的bus_type定义

系统为platform总线定义了一个bus_type的实例，在drivers/base/platform.c中描述。

// drivers/base/platform.c
struct device platform_bus = {
 .init_name = "platform",
};

struct bus_type platform_bus_type = {
 .name = "platform",
 .dev_attrs = platform_dev_attrs,
 .match = platform_match,
 .uevent = platform_uevent,
 .pm = &platform_dev_pm_ops,
};


int __init platform_bus_init(void)
{
 int error;

 early_platform_cleanup();

 error = device_register(&platform_bus);
 /*
 注册了一个struct device对象作为，其他platform_device的parent
 比如在platform_device_add(pdev)函数中
 pdev->dev.parent = &platform_bus
 */
 if (error)
 return error;
 error = bus_register(&platform_bus_type);
 /*
 注册总线
 在platform_device_add(pdev)函数中pdev->dev.bus = &platform_bus_type
 */
 if (error)
 device_unregister(&platform_bus);
 return error;
}

其中match()方法完成platform_device和platform_driver之间是如何进行匹配的。

static int platform_match(struct device *dev, struct device_driver *drv)
{
 struct platform_device *pdev = to_platform_device(dev);
 struct platform_driver *pdrv = to_platform_driver(drv);

 /* Attempt an OF style match first */
 if (of_driver_match_device(dev, drv)) //设备树匹配方式
 return 1;

 /* Then try to match against the id table */
 if (pdrv->id_table)
 return platform_match_id(pdrv->id_table, pdev) != NULL;

 /* fall-back to driver name match */
 return (strcmp(pdev->name, drv->name) == 0);
}

//其中
#define to_platform_driver(drv) (container_of((drv), struct platform_driver, driver))
#define to_platform_device(x) container_of((x), struct platform_device, dev)

static const struct platform_device_id *platform_match_id(
 const struct platform_device_id *id,
 struct platform_device *pdev)
{
 while (id->name[0]) {
 if (strcmp(pdev->name, id->name) == 0) {
 pdev->id_entry = id;
 return id;
 }
 id++;
 }
 return NULL;
}

struct platform_device_id {
 char name[PLATFORM_NAME_SIZE];
 kernel_ulong_t driver_data
 __attribute__((aligned(sizeof(kernel_ulong_t))));
};

下边是一个platform_device和platform_driver匹配的实例。

// arch/arm/mach-smdkv210.c
static struct resource s3c_i2c_resource[] = {
 [0] = {
 .start = S3C_PA_IIC,
 .end = S3C_PA_IIC + SZ_4K - 1,
 .flags = IORESOURCE_MEM,
 },
 [1] = {
 .start = IRQ_IIC,
 .end = IRQ_IIC,
 .flags = IORESOURCE_IRQ,
 },
};

struct platform_device s3c_device_i2c0 = {
 .name = "s3c2410-i2c",
 .id = 0,
 .num_resources = ARRAY_SIZE(s3c_i2c_resource),
 .resource = s3c_i2c_resource,
};

// drivers/i2c/busses/i2c-s3c2410.c中关于platform_driver的定义

/* device driver for platform bus bits */
static struct platform_device_id s3c24xx_driver_ids[] = {
 {
 .name = "s3c2410-i2c",
 .driver_data = TYPE_S3C2410,
 }, {
 .name = "s3c2440-i2c",
 .driver_data = TYPE_S3C2440,
 }, { }, // platform_device_id是一个数组,最后以空元素结尾
};

MODULE_DEVICE_TABLE(platform, s3c24xx_driver_ids);
static struct platform_driver s3c24xx_i2c_driver = {
 .probe = s3c24xx_i2c_probe,
 .remove = s3c24xx_i2c_remove,
 .id_table = s3c24xx_driver_ids, // 用于和platform_device中的name字段匹配
 .driver = {
 .owner = THIS_MODULE,
 .name = "s3c-i2c",
 .pm = S3C24XX_DEV_PM_OPS,
 },
};

关于资源

#include <linux/ioport.h>
struct resource {
 resource_size_t start;
 resource_size_t end;
 const char *name;
 unsigned long flags; // IORESOURCE_IO IORESOURCE_MEM IORESOURCE_IRQ等 在include /linux/ioport.h中有描述
 struct resource *parent, *sibling, *child;
};

#include <linux/platform_device.h>
/**
 * platform_get_resource - get a resource for a device
 * @dev: platform device
 * @type: resource type
 * @num: resource index
 */
struct resource *platform_get_resource(struct platform_device *, unsigned int, unsigned int);

/**
 * platform_get_irq - get an IRQ for a device
 * @dev: platform device
 * @num: IRQ number index
 */
int platform_get_irq(struct platform_device *, unsigned int);

定义资源以及获取资源的实例

// arch/arm/mach-at91/board-sam9261ek.c
static struct resource dm9000_resource[] = {
 [0] = {
 .start = AT91_CHIPSELECT_2,
 .end = AT91_CHIPSELECT_2 + 3,
 .flags = IORESOURCE_MEM
 },
 [1] = {
 .start = AT91_CHIPSELECT_2 + 0x44,
 .end = AT91_CHIPSELECT_2 + 0xFF,
 .flags = IORESOURCE_MEM
 },
 [2] = {
 .start = AT91_PIN_PC11,
 .end = AT91_PIN_PC11,
 .flags = IORESOURCE_IRQ
 | IORESOURCE_IRQ_LOWEDGE | IORESOURCE_IRQ_HIGHEDGE,
 }
};

// 获取资源实例
res_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
port->membase = ioremap(res_mem, ALTERA_JTAGUART_SIZE);

res_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
request_irq(res_irq, ....)

platform_match()什么时候被谁调用？

参考文献：platform_driver_register()–如何match之后调用probe

platform_driver_register
 |
 driver_register
 |
 bus_add_driver
 |
 driver_attach(drv)
 int driver_attach(struct device_driver *drv)
 {
 return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
 }
 |
 __driver_attach
 |
 driver_match_device(drv, dev)
 static inline int driver_match_device(struct device_driver *drv,struct device *dev)
 {
 return drv->bus->match ? drv->bus->match(dev, drv) : 1;
 }
 |
 driver_probe_device
 |
 really_probe
 |
 if (dev->bus->probe) {
 ret = dev->bus->probe(dev);
 } else if (drv->probe) {
 ret = drv->probe(dev);
 }

总结：

bus_for_each_dev遍历总线drv->bus上的每个设备，并对每一个设备执行__driver_attach()函数;
__driver_attach()函数又调用driver_match_device()函数匹配pdev和pdrv, 而driver_match_device()函数会调用总线的match函数，对于platform总线来说match函数即platform_match();
匹配成功后首先看总线有没有probe函数，若有则调用，否则调用驱动自己的probe函数, 而总线没有probe函数

I2C子系统代码跟读

yuanye.ma@qq.com (Yuanye Ma) — Mon, 05 Oct 2020 16:01:23 +0800

Linux内核 I2C子系统代码跟读

听了这个课程感觉讲的很好，很有必要自己跟读一遍Kernel中I2C的代码，以加深对Kernel中I2C子系统的理解。

设备注册

// mach-smdkv210.c
static struct i2c_board_info smdkv210_i2c_devs0[] __initdata = {
 { I2C_BOARD_INFO("24c08", 0x50), },
 { I2C_BOARD_INFO("wm8580", 0x1b), },
};
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) //求数组中元素个数
#define I2C_BOARD_INFO(dev_type, dev_addr) .type = dev_type, .addr = (dev_addr)

smdkv210_machine_init
 |
 i2c_register_board_info(0, smdkv210_i2c_devs0,ARRAY_SIZE(smdkv210_i2c_devs0));
 |
 int i2c_register_board_info(int busnum,struct i2c_board_info const *info, unsigned len)
 {
 for (status = 0; len; len--, info++) {
 struct i2c_devinfo *devinfo;
 /*
 struct i2c_devinfo {
 struct list_head list;
 int busnum;
 struct i2c_board_info board_info;
 };
 */
 devinfo = kzalloc(sizeof(*devinfo), GFP_KERNEL);
 devinfo->busnum = busnum;
 devinfo->board_info = *info;
 list_add_tail(&devinfo->list, &__i2c_board_list);
 }
 }
 /*
 总结： i2c_register_board_info()函数构造了一个链表__i2c_board_list，并将i2c的board_info加入此链表，并加入了控制器编号。
 */
 i2c_register_board_info(1, smdkv210_i2c_devs1,ARRAY_SIZE(smdkv210_i2c_devs1));
 i2c_register_board_info(2, smdkv210_i2c_devs2,ARRAY_SIZE(smdkv210_i2c_devs2));
 platform_add_devices(smdkv210_devices, ARRAY_SIZE(smdkv210_devices));
 /*
 static struct platform_device *smdkv210_devices[] __initdata = {
 &s3c_device_i2c0,
 &s3c_device_i2c1,
 &s3c_device_i2c2,
 };
 struct platform_device s3c_device_i2c0 = {
 .name = "s3c2410-i2c",
 .id = 0,
 .num_resources = ARRAY_SIZE(s3c_i2c_resource),
 .resource = s3c_i2c_resource,
 };
 static struct resource s3c_i2c_resource[] = {
 [0] = {
 .start = S3C_PA_IIC5, // #define S3C_PA_IIC5 EXYNOS4_PA_IIC(5)
 .end = S3C_PA_IIC5 + SZ_4K - 1,
 .flags = IORESOURCE_MEM,
 },
 [1] = {
 .start = IRQ_IIC5,
 .end = IRQ_IIC5,
 .flags = IORESOURCE_IRQ,
 },
 };
 */
 |
 int platform_add_devices(struct platform_device **devs, int num)
 for (i = 0; i < num; i++)
 ret = platform_device_register(devs[i]);
 |
 platform_device_add() //此函数定义在drivers/base/platform.c中
 |
 pdev->dev.bus = &platform_bus_type;
 |
 struct bus_type platform_bus_type = {
 .name = "platform",
 .match = platform_match,
 };
 device_add(&pdev->dev); //此函数定义在drivers/base/core.c

 /*
 总结：
 此函数向platform平台中批量注册platform_device, i2c控制器也抽象为platform_device，并包含寄存器地址信息。
 */

向platform中注册设备属于另外一篇文章，此处不再深究。

i2c总线核心驱动层

//i2c-core.c (drivers/i2c/i2c-core.c)
postcore_initcall(i2c_init);
module_exit(i2c_exit);


static int __init i2c_init(void)
 |
 bus_register(&i2c_bus_type); // 构建了i2c总线，并定义了匹配的方法
 /*
 struct bus_type i2c_bus_type = {
 .name = "i2c",
 .match = i2c_device_match,
 .probe = i2c_device_probe,
 .remove = i2c_device_remove,
 };
 */
 |
 i2c_add_driver(&dummy_driver); //只增加了一个设备


static void __exit i2c_exit(void)
{
 i2c_del_driver(&dummy_driver);
 bus_unregister(&i2c_bus_type);
}

i2c adapter层

// i2c-s3c2410.c (drivers/i2c/busses/i2c-s3c2410.c)

i2c_adap_s3c_init()
 |
 platform_driver_register(&s3c24xx_i2c_driver) // 向platform总线注册了platform_driver
 static struct platform_driver s3c24xx_i2c_driver = {
 .probe = s3c24xx_i2c_probe,
 .id_table = s3c24xx_driver_ids,
 .driver = {
 .name = "s3c-i2c",
 },
 };
 /*
 其中
 static struct platform_device_id s3c24xx_driver_ids[] = {
 {
 .name = "s3c2410-i2c",
 .driver_data = TYPE_S3C2410,
 }, {
 .name = "s3c2440-i2c",
 .driver_data = TYPE_S3C2440,
 }, { },
 };
 */
 // platform_driver注册进platform总线后会调用platform的match函数，匹配成功后会调用platform_driver的probe函数，匹配的过程这里暂时不分析，先看probe函数的内容。

s3c24xx_i2c_probe(struct platform_device *pdev)
 |
 struct s3c24xx_i2c *i2c;
 struct s3c2410_platform_i2c *pdata;
 struct resource *res;
 pdata = pdev->dev.platform_data; // 获取到平台自定义数据

 i2c = kzalloc(sizeof(struct s3c24xx_i2c), GFP_KERNEL); // 分配一个adapter
 /*
 struct s3c24xx_i2c {
 struct i2c_msg *msg;
 unsigned int irq;
 void __iomem *regs;
 struct device *dev;
 struct resource *ioarea;
 struct i2c_adapter adap;
 };

 struct i2c_adapter {
 struct module *owner;
 const struct i2c_algorithm *algo;
 void *algo_data;
 struct device dev;
 int nr;
 char name[48];
 }
 */
 /* 初始化adapter */
 strlcpy(i2c->adap.name, "s3c2410-i2c", sizeof(i2c->adap.name));
 i2c->adap.owner = THIS_MODULE;
 i2c->adap.algo = &s3c24xx_i2c_algorithm;
 i2c->dev = &pdev->dev;

 /* 获得内存资源 */
 platform_get_resource(pdev, IORESOURCE_MEM, 0);
 i2c->regs = ioremap(res->start, resource_size(res));

 i2c->adap.algo_data = i2c;
 i2c->adap.dev.parent = &pdev->dev;

 s3c24xx_i2c_init(i2c); // 硬件初始化

 /* 获得中断资源 */
 i2c->irq = platform_get_irq(pdev, 0);
 request_irq(i2c->irq, s3c24xx_i2c_irq, IRQF_DISABLED, dev_name(&pdev->dev), i2c);

 i2c->adap.nr = pdata->bus_num;
 i2c_add_numbered_adapter(&i2c->adap); // i2c-core.c
 static int i2c_register_adapter(struct i2c_adapter *adap)
 |
 i2c_register_adapter(adap);
 |
 dev_set_name(&adap->dev, "i2c-%d", adap->nr); // 设备名字 i2c-控制器序号
 adap->dev.bus = &i2c_bus_type;
 adap->dev.type = &i2c_adapter_type;
 res = device_register(&adap->dev);
 i2c_scan_static_board_info(adap);
 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
 struct i2c_devinfo *devinfo;
 |
 list_for_each_entry(devinfo, &__i2c_board_list, list) {
 if (devinfo->busnum == adapter->nr
 && !i2c_new_device(adapter, &devinfo->board_info))
 }
 |
 struct i2c_client * i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
 |
 struct i2c_client *client;
 /*
 struct i2c_client {
 unsigned short flags; //传输方向
 unsigned short addr; //设备地址
 char name[I2C_NAME_SIZE];
 struct i2c_adapter *adapter; //与之对应的适配器
 struct i2c_driver *driver; //父类
 struct device dev; //父类
 };

 struct i2c_driver {
 //Standard driver model interfaces
 int (*probe)(struct i2c_client *, const struct i2c_device_id *);
 int (*remove)(struct i2c_client *);
 struct device_driver driver;
 const struct i2c_device_id *id_table;
 };
 */
 client = kzalloc(sizeof *client, GFP_KERNEL);
 client->adapter = adap;
 client->dev.platform_data = info->platform_data;
 client->flags = info->flags;
 client->addr = info->addr;
 client->irq = info->irq;
 strlcpy(client->name, info->type, sizeof(client->name));
 client->dev.parent = &client->adapter->dev;
 client->dev.bus = &i2c_bus_type;
 client->dev.type = &i2c_client_type;
 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap), client->addr); // 0-0x50 0号控制器上的地址为0x50的从设备
 device_register(&client->dev);
 /*
 总结:
 adapter在注册的时候,会遍历__i2c_board_list链表
 如果adapter的编号和链表中节点的号码一致,就会构建i2c client并注册client
 i2c client中成员的值来自于board_info
 */

 platform_set_drvdata(pdev, i2c);

设备驱动层

自己需要写的驱动代码


const struct file_operations at24_fops = {
 .read = at24_e2prom_read,
 .write = at24_e2prom_write,
 .open = at24_e2prom_open,
 .release = at24_e2prom_close,
};

int at24_drv_probe(struct i2c_client * client, const struct i2c_device_id * id)
{
 /*
 申请设备号
 创建设备文件
 硬件初始化
 实现fops
 */
 at24_dev = kzalloc(sizeof(struct i2c_e2prom), GFP_KERNEL);
 at24_dev->major = register_chrdev(0, "at24_drv", &at24_fops);

 at24_dev->cls = class_create(THIS_MODULE, "at24_cls");
 at24_dev->dev = device_create(at24_dev->cls, NULL, \
 MKDEV(at24_dev->major, 0), NULL, "at24_e2prom" );
 /* 硬件初始化 e2prom上电就可以工作了，不需要初始化,其他设备初始化就是指定寄存器地址，写入指定值。
 i2c系统中为从设备传输数据的方法
 int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
 int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
 这两个函数都调用
 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
 */
 // 记录当前的client, 总线中匹配成功后发送过来的
 at24_dev->client = client;

 return 0;
}

const struct i2c_device_id at24_id_table[] = {
 {"at24c02", 0x2222},
 {"at24c04", 0x3333},
 {"at24c08", 0x4444},
};

struct i2c_driver at24_drv = {
 .probe = at24_drv_probe,
 .remove = at24_drv_remove,
 .driver = {
 .name = "at24_e2prom_drv", //不会用于比对， /sys/bus/i2c/drivers/at24_e2prom_drv
 },
 .id_table = at24_id_table,
};

static int __init at24_drv_init(void)
{
 // 注册一个i2c driver
 return i2c_add_driver(&at24_drv);
}

static void __exit at24_drv_exit(void)
{
 i2c_del_driver(&at24_drv);
}

module_init(at24_drv_init);
module_exit(at24_drv_exit);

总结

mach-smdkv210.c中的smdkv210_machine_init() 会在内核初始化时调用

smdkv210_machine_init()中

 a. 调用i2c_register_board_info()函数，初始化了一个保存有从设备名字和地址的链表__i2c_board_list；
b. 调用platform_add_devices()函数，将SOC的I2C控制器抽象为的 包含寄存器以及中断等硬件资源的platform_device 注册进了platform总线;

i2c-core.c中调用i2c_init()函数，注册了I2C总线的实现（包括总线上设备和驱动的匹配方法match()等）(即bus_register(&i2c_bus_type))
i2c-s3c2410.c 中i2c_adap_s3c_init()函数调用platform_driver_register(&s3c24xx_i2c_driver)函数向platform总线注册了一个platform_driver对象；
4中注册platform_driver的操作会调用platform的match()方法，此方法按照所注册的platform_driver(即s3c24xx_i2c_driver)的id_table字段和platform_device(比如mach-smdkv210.c中的s3c_device_i2c0)的name字段进行匹配，如果匹配就调用相应platform_driver的probe()方法。

i2c-s3c2410.c 中s3c24xx_i2c_probe()方法

 a. 分配并初始化了对象struct s3c24xx_i2c， 此对象包含一个 struct i2c_adapter对象，以及I2C控制器需要的硬件资源；
b. 然后调用i2c-core.c中的i2c_register_adapter()函数，主要根据__i2c_board_list中的从设备信息创建client并和adapter相关联。

驱动编写

at24_drv.c中是自己写的驱动代码，按照一般内核模块写法，自己构造i2c_driver对象，该对象包含probe()方法，该方法在总结3 i2c_init()函数中定义的i2c_bus_type对象的match()方法中匹配i2c_device和i2c_driver成功时被调用。

probe()方法完成设备号注册，fops对象定义，以及硬件初始化操作。

关于数据流

client->adapter->i2c_algorithm->master_xfer(client->adapter, msgs, num)

struct i2c_algorithm {
 int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,int num);
};

struct i2c_msg {
 __u16 addr; /* slave address */
 __u16 flags;
#define I2C_M_TEN 0x0010 /* this is a ten bit chip address */
#define I2C_M_RD 0x0001 /* read data, from slave to master */
#define I2C_M_NOSTART 0x4000 /* if I2C_FUNC_PROTOCOL_MANGLING */
#define I2C_M_REV_DIR_ADDR 0x2000 /* if I2C_FUNC_PROTOCOL_MANGLING */
#define I2C_M_IGNORE_NAK 0x1000 /* if I2C_FUNC_PROTOCOL_MANGLING */
#define I2C_M_NO_RD_ACK 0x0800 /* if I2C_FUNC_PROTOCOL_MANGLING */
#define I2C_M_RECV_LEN 0x0400 /* length will be first received byte */
 __u16 len; /* msg length */
 __u8 *buf; /* pointer to msg data */
};

I2C读写驱动例子

int at24_drv_probe(struct i2c_client * client, const struct i2c_device_id * id)
{
 /*将i2c_bus的match()方法匹配成功时，会将相应的client传递过来，此处保存到全局的设备对象中*/
 at24_dev->client = client;
}

// 全局的设备对象
struct i2c_e2prom{
 int dev_major;
 struct class *cls;
 struct device *dev;
 struct i2c_client *client;//记录当前匹配的client
};

struct i2c_e2prom *at24_dev;


//编写一个类似i2c_master_recv/i2c_master_send
int at24_i2c_read(struct i2c_client *client, char *buf, int size)
{
 int ret;
 struct i2c_adapter *adapter = client->adapter;

 struct i2c_msg msg;
 msg.addr = client->addr;
 msg.flags = I2C_M_RD;
 msg.len = size;
 msg.buf = buf;
 // 参数1---适配器
 //参数2--消息包
 // 参数3--消息的个数
 ret = i2c_transfer(adapter, &msg, 1);
 return ret==1?size:ret;
}

int at24_i2c_write(struct i2c_client *client, char *buf, int size)
{

 int ret;
 struct i2c_adapter *adapter = client->adapter;

 struct i2c_msg msg;
 msg.addr = client->addr;
 msg.flags = 0;
 msg.len = size;
 msg.buf = buf;

 ret = i2c_transfer(adapter, &msg, 1);

 return ret==1?size:ret;

}

int at24_i2c_write(struct i2c_client *client, char *buf, int size)
{

 int ret;
 struct i2c_adapter *adapter = client->adapter;

 struct i2c_msg msg;
 msg.addr = client->addr;
 msg.flags = 0;
 msg.len = size;
 msg.buf = buf;

 ret = i2c_transfer(adapter, &msg, 1);

 return ret==1?size:ret;

}

int at24_e2prom_drv_open (struct inode *inode, struct file *filp)
{

 return 0;
}

ssize_t at24_e2prom_drv_read(struct file *filp, char __user *buf, size_t count, loff_t *fpos)
{
 int ret;

 if(count < 0 || count > 256)
 return -EINVAL;

 char *tmp = kzalloc(count, GFP_KERNEL);

 // 1, 从硬件中获取数据
 ret = at24_i2c_read(at24_dev->client, tmp, count);
 if(ret < 0)
 {
 printk("at24_i2c_read error\n");
 goto err_free;
 }

 // 2 ,将数据给用户
 ret = copy_to_user(buf, tmp, count);
 if(ret > 0)
 {
 printk("copy_to_user error\n");
 goto err_free;
 }
err_free:
 kfree(tmp);
 return ret;
}

ssize_t at24_e2prom_drv_write(struct file *filp, const char __user *buf, size_t count, loff_t *fpos)
{
 printk("-----------%s-----------\n", __FUNCTION__);
 int ret;

 if(count < 0 || count > 256)
 return -EINVAL;

 char *tmp = kzalloc(count, GFP_KERNEL);

 // 1, 从用户空间将数据获取到
 ret = copy_from_user(tmp, buf, count);
 if(ret > 0)
 {
 printk("copy_from_user error\n");
 goto err_free;
 }
 // 2, 将数据写入硬件中去
 ret = at24_i2c_write(at24_dev->client, tmp, count);
 if(ret < 0)
 {
 printk("at24_i2c_write error\n");
 goto err_free;
 }
err_free:
 kfree(tmp);
 return ret;
}

Linux Kernel on Yuanye Ma's Blog

如何获取跨系统调用的函数调用栈

获取用户态和内核态的函数调用栈

解析用户态调用栈

原理分析

1. 发生系统调用时保存现场

2. stack_trace的实现

在本地复现syzbot Bugs

在本地复现syzbot Bugs

Step One: Choose a syzbot Report with an Upstream Fix

Step Two: Set Up the Local Workspace

Step Three: Boot the syzbot Kernel in QEMU

Step Four: Run the Reproducer in the Original Image

使用复现器

编译复现程序

Step Five: Build the Matching Kernel Locally

Step Six: Run the Reproducer on the Locally Built Kernel

拷贝编译后的复现程序repro

使用复现器

Step Seven: Apply the Patch and Rebuild

总结

第一次尝试向Linux Kernel提交Patch

第一次提交内核patch尝试

准备内核

准备patch

生成gmail的应用专用密码

设置git-email的smtp服务

发送patch

patch被接受

patch 被合入上游仓库

总结

linux kernel slab系统

linux kernel slab系统

基本原理

概念以及数据结构

struct kmem_cache

本地CPU空闲对象链表

所有CPU共享的空闲对象链表

struct kmem_list3

sturct slab

object

结构之间的关系

参考资料

kmem_cache_init

初始化前的准备工作

1） 初始化cache_chain

2）&3） 创建kmalloc用的高速缓存

4） 用kmalloc对象替换静态分配的全局高速缓存变量

5） 用kmalloc的空间替换静态分配的slab三链

6） enable_cpucache

收尾工作

关于kmem_cache的初始化阶段

总结

参考资料

kmem_cache_create

函数参数说明

检查参数以及运行环境

计算对齐

分配kmem_cache描述符

判断slab管理数据是放在slab内部还是外部

计算slab的容量

最终确定slab管理数据的存储位置

计算slab着色

初始化slab构造函数

初始化本地以及共享的高速缓存

setup_cpu_cache()

enable_cpucache()

do_tune_cpucache()

oops的处理流程

kmem_cache_alloc

cpu_cache_get()

cache_alloc_refill()

cache_grow()

kmem_getpages()

alloc_slabmgmt()

slab_map_pages()

cache_init_objs()

kmem_cache_free

kmem_cache_destroy

通用内存对象管理举例 ： zalloc/kmalloc和kfree

`struct kmem_cache`

`struct kmem_list3`

`sturct slab`

1）初始化`cache_chain`

2）&3）创建`kmalloc`用的高速缓存

4）用`kmalloc`对象替换静态分配的全局高速缓存变量

5）用`kmalloc`的空间替换静态分配的slab三链

6） `enable_cpucache`

关于`kmem_cache`的初始化阶段

分配`kmem_cache`描述符

通用内存对象管理举例： zalloc/kmalloc和kfree

`swapper_pg_dir`

`struct page`

`struct zone`

`pg_data_t` 或者 `struct pglist_data`

`struct vm_area_struct`

`struct mm_struct`

1. `linux`中`file` `cdev` `inode`之间的关系；