1. 引言:为什么需要 ttm_resource?
在上一篇文章中,我们分析了 TTM 的核心设计目标:
- 统一管理异构内存域(VRAM、GTT、SYSTEM)
- 显存动态调度与超配(eviction 机制)
- GPU 虚拟地址与页表管理
那么问题来了:如何统一描述这三种完全不同的内存的分配结果?
- VRAM:GPU 芯片上的高速显存,需要用 Buddy 分配器管理物理块
- GTT:GPU 可访问的系统内存,需要管理 GPU 侧的虚拟地址空间
- SYSTEM:纯系统内存,由页分配器管理,GPU 通过 DMA 访问
这三种内存的分配方式、地址空间、访问特性都完全不同,但 TTM 必须提供统一的接口来管理它们。这就是ttm_resource的职责,从该视角让我们认识下ttm_resource:
- ttm_resource 是什么?—— 物理内存占用的凭证/描述符
- 它解决什么问题?—— 统一描述不同类型内存的分配结果
- 它如何与其他结构体协作?—— 作为 BO 与物理内存之间的桥梁
核心结论:
ttm_resource 是 TTM 对"任何类型的物理内存/地址空间分配结果"的统一抽象。
只要 BO 占用了某类内存/地址空间(不管是 VRAM、GTT、还是 SYSTEM),就必须有 ttm_resource 来描述这个"占用事实"。
2. ttm_resource 核心结构体详解
2.1 结构体定义剖析
/**
* struct ttm_resource
* Structure indicating the placement and space resources used by a
* buffer object.
*/
struct ttm_resource {
unsigned long start; // 起始地址/偏移
size_t size; // 资源大小
uint32_t mem_type; // 内存类型(VRAM/GTT/SYSTEM)
uint32_t placement; // 放置标志
struct ttm_bus_placement bus; // CPU 端总线映射信息
struct ttm_buffer_object *bo; // 反向指针指向所属 BO
struct ttm_lru_item lru; // LRU 链表节点
struct dmem_cgroup_pool_state *css; // cgroup 资源记账
};
2.2 字段详细解析
| start | unsigned long | 资源起始位置 | VRAM: 物理偏移(相对于显存基址)GTT: GTT 地址空间偏移SYSTEM: 无意义(通常为 0) |
| size | size_t | 资源大小(字节) | 实际分配的物理内存/地址空间大小 |
| mem_type | uint32_t | 内存域类型 | TTM_PL_VRAM (0)TTM_PL_TT (1,即 GTT)TTM_PL_SYSTEM (2) |
| placement | uint32_t | 放置标志位 | 标记访问属性:- TTM_PL_FLAG_WC (Write-Combine)- TTM_PL_FLAG_UNCACHED- TTM_PL_FLAG_CACHED |
| bus | struct ttm_bus_placement | CPU 端映射信息 | CPU mmap 时使用:- addr: 映射的虚拟地址- offset: 物理地址- is_iomem: 是否为 IO 内存- caching: 缓存属性 |
| bo | struct ttm_buffer_object * | 反向引用 | 指向拥有这个资源的 BO注意: 弱引用,由 ttm_device::lru_lock 保护 |
| lru | struct ttm_lru_item | LRU 节点 | 用于 eviction 时的 LRU 算法挂载到 ttm_resource_manager::lru 链表 |
| css | struct dmem_cgroup_pool_state * | cgroup 资源记账 | 用于内存控制组(cgroup)资源统计 |
2.3 辅助结构:ttm_bus_placement
/**
* struct ttm_bus_placement
*
* @addr: mapped virtual address
* @offset: physical addr
* @is_iomem: is this io memory ?
* @caching: See enum ttm_caching
*
* Structure indicating the bus placement of an object.
*/
struct ttm_bus_placement {
void *addr; // CPU 端映射的虚拟地址
phys_addr_t offset; // 物理地址偏移
bool is_iomem; // 是否为 IO 内存(VRAM 为 true)
enum ttm_caching caching; // 缓存属性
};
使用场景:
- CPU 通过 mmap 访问 BO 时,根据 bus 信息建立页表映射
- VRAM:is_iomem=true,通过 IO 地址映射访问
- GTT/SYSTEM:is_iomem=false,直接访问系统内存
3. ttm_resource 的生命周期
3.1 创建流程
用户分配 BO
↓
ttm_bo_init_reserved() / ttm_bo_validate()
↓
ttm_bo_mem_space() ← 选择合适的内存域
↓
ttm_resource_alloc() ← 分配 resource
↓
man->func->alloc() ← 调用具体管理器的分配函数
↓
├─ VRAM: ttm_buddy_man_alloc() → 返回 ttm_buddy_resource
├─ GTT: ttm_range_man_alloc() → 返回 ttm_range_mgr_node
└─ SYSTEM: ttm_sys_man_alloc() → 返回基础 ttm_resource
↓
bo->resource = 新分配的 resource
关键函数:
/**
* ttm_resource_alloc – 分配 TTM 资源
* @bo: 要分配资源的 buffer object
* @place: 放置要求(内存域、对齐、标志等)
* @res: 输出参数,返回分配的 resource
*
* 返回: 0 表示成功,-ENOSPC 表示空间不足,负数表示其他错误
*/
int ttm_resource_alloc(struct ttm_buffer_object *bo,
const struct ttm_place *place,
struct ttm_resource **res);
3.2 使用阶段
场景 1:BO 迁移时查询当前位置
struct ttm_resource *old_mem = bo->resource;
if (old_mem->mem_type == TTM_PL_VRAM) {
// 当前在 VRAM,需要迁移到 GTT
}
场景 2:CPU mmap 访问
// DRM mmap 处理函数中
struct ttm_resource *mem = bo->resource;
if (mem->bus.is_iomem) {
// VRAM,使用 IO 地址映射
vma->vm_pgoff += mem->bus.offset >> PAGE_SHIFT;
} else {
// GTT/SYSTEM,直接映射系统内存
}
场景 3:GPU 访问时填充页表
// GPU 页表更新(驱动特定代码)
struct ttm_resource *mem = bo->resource;
uint64_t gpu_addr = mem->start; // GPU 侧的起始地址
if (mem->mem_type == TTM_PL_VRAM) {
// 填充 GPU 页表,指向 VRAM 物理地址
update_gpu_page_table(gpu_addr, vram_phys_addr);
} else if (mem->mem_type == TTM_PL_TT) {
// 填充 GPU 页表,指向 GTT 映射的系统内存
update_gpu_page_table(gpu_addr, gtt_dma_addr);
}
3.3 销毁流程
BO 释放或迁移
↓
ttm_resource_free() ← 释放旧的 resource
↓
man->func->free() ← 调用管理器的释放函数
↓
├─ VRAM: ttm_buddy_man_free() → 归还 buddy 内存块
├─ GTT: ttm_range_man_free() → 释放 drm_mm 节点
└─ SYSTEM: ttm_sys_man_free() → 简单释放结构体
↓
bo->resource = NULL (或指向新的 resource)
关键函数:
/**
* ttm_resource_free – 释放 TTM 资源
* @bo: 拥有该资源的 buffer object
* @res: 要释放的 resource 指针的指针
*/
void ttm_resource_free(struct ttm_buffer_object *bo,
struct ttm_resource **res);
4. 不同内存域的 ttm_resource 实现
4.1 VRAM 场景:ttm_buddy_resource
定义(位于 ttm_buddy_manager.c):
/**
* struct ttm_buddy_resource – TTM Buddy 管理器的资源描述
* @base: 基础 ttm_resource
* @blocks: Buddy 分配的内存块链表
* @flags: 内存属性标志(如 TOPDOWN、CONTIGUOUS 等)
*/
struct ttm_buddy_resource {
struct ttm_resource base; // 继承自 ttm_resource
struct list_head blocks; // buddy 分配的内存块链表
unsigned long flags; // 内存属性标志
};
特点:
- 使用 Buddy 分配器管理 VRAM 物理内存
- blocks 链表记录分配的一个或多个物理内存块
- base.start 通常是首个 block 的物理偏移
- 支持连续分配(CONTIGUOUS)和从高地址分配(TOPDOWN)
分配流程:
ttm_buddy_man_alloc()
↓
ttm_buddy_alloc() ← Buddy 分配器核心算法
↓
分配一个或多个 buddy block
↓
将 block 链接到 ttm_buddy_resource::blocks
↓
设置 base.start = 首个 block 的偏移
4.2 GTT 场景:ttm_range_mgr_node
定义(位于 ttm_range_manager.c):
/**
* struct ttm_range_mgr_node – GTT 地址空间分配节点
* @base: 基础 ttm_resource
* @mm_nodes: 地址区间节点数组(支持碎片化分配)
*/
struct ttm_range_mgr_node {
struct ttm_resource base; // 继承自 ttm_resource
struct drm_mm_node mm_nodes[]; // 地址区间节点(柔性数组)
};
特点:
- 使用 drm_mm 管理 GTT 地址空间(类似于 vmalloc 的地址分配)
- mm_nodes 可能包含多个节点(当 GTT 空间碎片化时)
- base.start 是首个 mm_nodes 的起始偏移
- GTT 是 GPU 侧的虚拟地址空间,实际物理页由 ttm_tt 管理
分配流程:
ttm_range_man_alloc()
↓
drm_mm_insert_node_generic() ← 在 GTT 地址空间中找空闲区域
↓
分配 ttm_range_mgr_node(可能包含多个 mm_nodes)
↓
设置 base.start = mm_nodes[0].start
关键理解:
GTT 分配的是 GPU 地址空间,不是物理内存!
物理页的分配和映射由 ttm_tt 负责,GTT 只是提供 GPU 侧的虚拟地址。
4.3 SYSTEM 场景:纯 ttm_resource
定义:
// 不需要继承,直接使用基础的 ttm_resource
特点:
- 不需要地址空间分配(系统内存由 ttm_tt 的页池分配)
- ttm_resource 仅作为占位符,记录:
- mem_type = TTM_PL_SYSTEM
- size = BO 大小
- start 无实际意义(通常为 0)
- 物理页管理完全由 ttm_tt 负责
分配流程:
ttm_sys_man_alloc()
↓
简单分配一个 ttm_resource 结构体
↓
设置 mem_type = TTM_PL_SYSTEM
设置 size = bo->base.size
设置 start = 0
4.4 对比总结表
| VRAM | ttm_buddy_resource | Buddy 分配器 | VRAM 物理偏移 | blocks 链表 | Buddy 内存块 |
| GTT | ttm_range_mgr_node | drm_mm 区间管理 | GTT 虚拟偏移 | mm_nodes 数组 | 由 ttm_tt 管理 |
| SYSTEM | ttm_resource | 页池分配 | 无意义(0) | 无 | 由 ttm_tt 管理 |
记忆口诀:
- VRAM 用 Buddy,物理块成链
- GTT 用区间,虚拟地址段
- SYSTEM 占位符,页表另外管
5. ttm_resource 与其他结构体的交互
5.1 与 ttm_buffer_object 的关系
/**
* struct ttm_buffer_object – TTM 缓冲区对象
*/
struct ttm_buffer_object {
struct drm_gem_object base; // 继承自 GEM
struct ttm_resource *resource; // 当前分配的物理资源 ★
struct ttm_tt *ttm; // 页表对象(GTT/SYSTEM 场景)
struct ttm_device *bdev; // 所属设备
// … 其他字段
};
关系说明:
- BO 通过 resource 指针获取当前的物理位置和地址
- BO 迁移时,resource 指针会被替换为新的 resource
- resource 与 ttm 协同工作(见 5.3)
典型操作:
// 查询 BO 当前位置
uint32_t mem_type = bo->resource->mem_type;
if (mem_type == TTM_PL_VRAM) {
printk("BO in VRAM at offset 0x%lx\\n", bo->resource->start);
}
// BO 迁移
struct ttm_resource *new_res;
ttm_resource_alloc(bo, &place_gtt, &new_res); // 分配 GTT
ttm_bo_move_buffer(bo, new_res); // 迁移数据
ttm_resource_free(bo, &bo->resource); // 释放旧 VRAM
bo->resource = new_res; // 更新指针
5.2 与 ttm_resource_manager 的关系
/**
* struct ttm_resource_manager – TTM 资源管理器
*/
struct ttm_resource_manager {
bool use_type; // 是否启用该类型
bool use_tt; // 是否需要 ttm_tt
struct ttm_device *bdev; // 所属设备
uint64_t size; // 管理的总容量
const struct ttm_resource_manager_func *func; // 操作函数表 ★
spinlock_t move_lock; // 移动锁
struct dma_fence *move; // 移动 fence
struct list_head lru[TTM_MAX_BO_PRIORITY]; // LRU 链表(4 个优先级)★
uint64_t usage; // 当前使用量
// …
};
关系说明:
- 管理器负责创建和销毁特定类型的 ttm_resource
- ttm_resource::lru 挂载到管理器的 lru 链表(按优先级)
- 通过 func 函数表调用具体的分配/释放实现
操作函数表:
struct ttm_resource_manager_func {
int (*alloc)(struct ttm_resource_manager *man,
struct ttm_buffer_object *bo,
const struct ttm_place *place,
struct ttm_resource **res); // 分配资源 ★
void (*free)(struct ttm_resource_manager *man,
struct ttm_resource *res); // 释放资源 ★
bool (*intersects)(struct ttm_resource_manager *man,
struct ttm_resource *res,
const struct ttm_place *place,
size_t size); // 判断是否相交
bool (*compatible)(struct ttm_resource_manager *man,
struct ttm_resource *res,
const struct ttm_place *place,
size_t size); // 判断是否兼容
void (*debug)(struct ttm_resource_manager *man,
struct drm_printer *printer); // 调试信息
};
调用流程:
ttm_resource_alloc(bo, place, &res)
↓
获取对应的 resource_manager (根据 place->mem_type)
↓
man->func->alloc(man, bo, place, &res) ← 调用具体实现
↓
├─ VRAM: ttm_buddy_man_alloc()
├─ GTT: ttm_range_man_alloc()
└─ SYSTEM: ttm_sys_man_alloc()
↓
将 res->lru 加入 man->lru[priority] 链表
5.3 与 ttm_tt 的协作(GTT/SYSTEM 场景)
/**
* struct ttm_tt – TTM 页表对象
*/
struct ttm_tt {
struct page **pages; // 物理页数组 ★
dma_addr_t *dma_address; // DMA 地址数组 ★
uint32_t page_flags; // 页标志
uint32_t num_pages; // 页数量
struct sg_table *sg; // scatter-gather 表
// …
};
协作关系:
- ttm_resource:描述 GPU 地址空间的分配(GTT 虚拟地址范围)
- ttm_tt:管理具体的物理页和 DMA 映射
场景 1:GTT 内存分配
1. ttm_resource_alloc() 分配 GTT 地址空间
→ 返回 ttm_range_mgr_node (base.start = GTT 偏移)
2. ttm_tt_create() 创建页表对象
→ 分配 ttm_tt 结构体
3. ttm_tt_populate() 分配物理页
→ 从页池分配 pages[]
4. ttm_tt_map() 建立 DMA 映射
→ 填充 dma_address[]
5. 驱动填充 GTT 页表
→ 将 GTT 地址映射到 dma_address[]
场景 2:CPU 访问 GTT 内存
// CPU mmap 处理
struct ttm_resource *mem = bo->resource; // GTT resource
struct ttm_tt *tt = bo->ttm; // 页表对象
if (mem->mem_type == TTM_PL_TT) {
// 通过 ttm_tt->pages[] 建立 CPU 页表映射
for (i = 0; i < tt->num_pages; i++) {
vm_insert_page(vma, addr, tt->pages[i]);
addr += PAGE_SIZE;
}
}
关系图:
[ttm_buffer_object]
├─> resource ────> [ttm_resource (ttm_range_mgr_node)]
│ ├─> mem_type: TTM_PL_TT
│ ├─> start: 0x10000 (GTT 偏移)
│ ├─> size: 4MB
│ └─> lru ──> [ttm_resource_manager::lru]
│
└─> ttm ─────────> [ttm_tt]
├─> pages[]: [页0, 页1, …, 页1023]
└─> dma_address[]: [DMA0, DMA1, …, DMA1023]
↓
GPU GTT 页表
GTT[0x10000] -> DMA0
GTT[0x10001] -> DMA1
…
核心理解:
- ttm_resource 是"地址空间分配凭证"(GPU 侧虚拟地址)
- ttm_tt 是"物理页管理器"(实际的物理内存)
- 两者配合完成 GPU 的虚拟地址到物理地址的映射
6. 核心操作接口
6.1 分配接口
/**
* ttm_resource_alloc – 分配 TTM 资源
* @bo: 要分配资源的 buffer object
* @place: 放置要求(内存域、对齐、标志等)
* @res: 输出参数,返回分配的 resource
*
* 根据 place 的要求,从对应的资源管理器分配资源。
* place 包含:
* – mem_type: 内存域类型(VRAM/GTT/SYSTEM)
* – fpfn/lpfn: 物理页帧范围(First/Last Page Frame Number)
* – flags: 放置标志(WC/UC/CACHED 等)
*
* 返回: 0 表示成功,-ENOSPC 表示空间不足,负数表示其他错误
*/
int ttm_resource_alloc(struct ttm_buffer_object *bo,
const struct ttm_place *place,
struct ttm_resource **res);
使用示例:
struct ttm_place place = {
.fpfn = 0,
.lpfn = 0, // 0 表示无限制
.mem_type = TTM_PL_VRAM,
.flags = TTM_PL_FLAG_TOPDOWN | TTM_PL_FLAG_CONTIGUOUS,
};
struct ttm_resource *res;
int ret = ttm_resource_alloc(bo, &place, &res);
if (ret == 0) {
printk("分配成功: VRAM 偏移 0x%lx, 大小 %zu\\n",
res->start, res->size);
}
6.2 释放接口
/**
* ttm_resource_free – 释放 TTM 资源
* @bo: 拥有该资源的 buffer object
* @res: 要释放的 resource 指针的指针
*
* 释放资源并将指针置为 NULL。
*/
void ttm_resource_free(struct ttm_buffer_object *bo,
struct ttm_resource **res);
使用示例:
struct ttm_resource *res = bo->resource;
if (res) {
ttm_resource_free(bo, &bo->resource); // 释放并置 NULL
// bo->resource 现在为 NULL
}
6.3 兼容性判断
/**
* ttm_resource_compatible – 判断资源是否与放置要求兼容
* @res: 要检查的资源
* @place: 放置要求
* @size: 所需大小
*
* 用于判断是否可以复用现有资源,避免不必要的迁移。
*
* 返回: true 表示兼容,false 表示需要重新分配
*/
bool ttm_resource_compatible(struct ttm_resource *res,
const struct ttm_place *place,
size_t size);
使用场景:
// BO validation 时检查是否需要迁移
if (bo->resource &&
ttm_resource_compatible(bo->resource, &new_place, bo->base.size)) {
// 当前位置兼容,无需迁移
return 0;
}
// 需要迁移到新位置
ttm_bo_move_buffer(bo, &new_place);
6.4 交集判断(用于 Eviction)
/**
* ttm_resource_intersects – 判断资源是否与放置要求相交
* @res: 要检查的资源
* @place: 放置要求
* @size: 所需大小
*
* 用于 eviction 时判断是否应该驱逐某个 BO。
* 例如:新 BO 需要 VRAM 0x1000-0x2000,检查现有 BO 是否占用该区域。
*
* 返回: true 表示相交(应该驱逐),false 表示不相交
*/
bool ttm_resource_intersects(struct ttm_resource *res,
const struct ttm_place *place,
size_t size);
6.5 CPU 映射准备
/**
* ttm_resource_ioremap – 为 CPU 访问准备 IO 映射
* @bdev: TTM 设备
* @mem: 要映射的资源
* @virtual: 输出参数,返回虚拟地址
*
* 主要用于 VRAM 的 CPU 访问,建立 ioremap 映射。
*
* 返回: 0 表示成功,负数表示错误
*/
int ttm_resource_ioremap(struct ttm_device *bdev,
struct ttm_resource *mem,
void **virtual);
6.6 LRU 管理
/**
* ttm_resource_add_bulk_move – 将资源加入批量移动
* @res: 要加入的资源
* @bulk: 批量移动对象
*
* 用于优化批量 BO 的 LRU 位置更新。
*/
void ttm_resource_add_bulk_move(struct ttm_resource *res,
struct ttm_lru_bulk_move *bulk);
/**
* ttm_lru_item_to_res – 将 LRU 节点转换为 resource
* @item: LRU 节点
*
* 从 LRU 链表遍历时使用。
*/
static inline struct ttm_resource *
ttm_lru_item_to_res(struct ttm_lru_item *item)
{
return container_of(item, struct ttm_resource, lru);
}
7. 实际案例分析
案例 1:VRAM 到 GTT 的迁移
场景:应用分配了过多显存,触发 eviction,需要将不活跃的 BO 从 VRAM 迁移到 GTT。
完整流程:
// 1. 当前 BO 的 resource 指向 VRAM
struct ttm_buffer_object *bo = ...;
struct ttm_resource *old_vram_res = bo->resource;
printk("旧位置: VRAM 偏移 0x%lx\\n", old_vram_res->start);
// 旧位置: VRAM 偏移 0x80000000
// 2. 触发 eviction,选择 GTT 作为目标
struct ttm_place place_gtt = {
.mem_type = TTM_PL_TT,
.flags = TTM_PL_FLAG_CACHED,
};
// 3. 在 GTT 域分配新的 resource
struct ttm_resource *new_gtt_res;
int ret = ttm_resource_alloc(bo, &place_gtt, &new_gtt_res);
if (ret) {
printk("GTT 分配失败: %d\\n", ret);
return ret;
}
printk("新位置: GTT 偏移 0x%lx\\n", new_gtt_res->start);
// 新位置: GTT 偏移 0x10000
// 4. 如果需要,分配 ttm_tt(GTT 需要页表)
if (!bo->ttm) {
ret = ttm_tt_create(bo, true); // true = 需要 CPU 访问
if (ret) {
ttm_resource_free(bo, &new_gtt_res);
return ret;
}
ret = ttm_tt_populate(bo->bdev, bo->ttm, &ctx);
if (ret) {
ttm_resource_free(bo, &new_gtt_res);
return ret;
}
}
// 5. 数据拷贝:VRAM → 临时缓冲区 → GTT
struct ttm_operation_ctx ctx = { .interruptible = true };
ret = ttm_bo_move_memcpy(bo, &ctx, new_gtt_res);
if (ret) {
ttm_resource_free(bo, &new_gtt_res);
return ret;
}
// 内部流程:
// a) 从 VRAM 读取数据到系统内存临时缓冲区
// b) 将数据写入 bo->ttm->pages[]
// c) 更新 GPU 页表,将 GTT 地址映射到 pages[]
// 6. 释放旧的 VRAM resource
ttm_resource_free(bo, &old_vram_res);
// 7. 更新 BO 的 resource 指针
bo->resource = new_gtt_res;
printk("迁移完成: VRAM → GTT\\n");
关键点:
- VRAM resource 不需要 ttm_tt(直接访问显存)
- GTT resource 必须有 ttm_tt(管理系统内存页)
- 数据迁移完成后才能释放旧 resource
案例 2:CPU mmap 访问不同类型的内存
场景:用户空间通过 mmap 访问 BO,驱动需要根据 BO 的 resource 类型建立不同的映射。
// DRM mmap 处理函数(简化版)
static vm_fault_t ttm_bo_vm_fault(struct vm_fault *vmf)
{
struct vm_area_struct *vma = vmf->vma;
struct ttm_buffer_object *bo = vma->vm_private_data;
struct ttm_resource *mem = bo->resource;
unsigned long page_offset;
struct page *page;
if (!mem) {
return VM_FAULT_SIGBUS;
}
page_offset = vmf->pgoff – drm_vma_node_start(&bo->base.vma_node);
switch (mem->mem_type) {
case TTM_PL_VRAM:
// VRAM:使用 IO 映射
if (!mem->bus.is_iomem) {
// 首次访问,建立 IO 映射
ret = ttm_bo_ioremap(bo, 0, bo->base.size, &mem->bus);
if (ret)
return VM_FAULT_SIGBUS;
}
// 使用 vm_insert_pfn_prot 映射 IO 内存
pfn = (mem->bus.offset >> PAGE_SHIFT) + page_offset;
// 设置缓存属性(Write-Combine)
pgprot_t prot = pgprot_writecombine(vma->vm_page_prot);
ret = vm_insert_pfn_prot(vma, vmf->address, pfn, prot);
break;
case TTM_PL_TT:
// GTT:通过 ttm_tt 访问系统内存页
if (!bo->ttm) {
return VM_FAULT_SIGBUS;
}
// 获取对应的物理页
page = bo->ttm->pages[page_offset];
// 使用 vm_insert_page 映射系统内存页
ret = vm_insert_page(vma, vmf->address, page);
break;
case TTM_PL_SYSTEM:
// SYSTEM:直接访问系统内存
page = bo->ttm->pages[page_offset];
ret = vm_insert_page(vma, vmf->address, page);
break;
default:
return VM_FAULT_SIGBUS;
}
return ret ? VM_FAULT_SIGBUS : VM_FAULT_NOPAGE;
}
关键点:
- VRAM:通过 mem->bus.offset + vm_insert_pfn_prot 映射 IO 内存
- GTT/SYSTEM:通过 bo->ttm->pages[] + vm_insert_page 映射系统内存页
- 缓存属性:VRAM 通常使用 WC(Write-Combine),GTT 可能使用 Cached
案例 3:GPU 命令提交时的地址翻译
场景:GPU 需要访问 BO,驱动需要根据 resource 类型填充不同的 GPU 页表。
// GPU 命令提交时更新页表(AMD 驱动简化版)
static int amdgpu_vm_bo_update_mapping(struct amdgpu_device *adev,
struct amdgpu_bo *bo,
struct ttm_resource *mem,
uint64_t va_start,
uint64_t va_size)
{
struct amdgpu_vm *vm = ...;
uint64_t pte_flags = 0;
uint64_t *ptes;
int i, num_ptes;
num_ptes = va_size >> PAGE_SHIFT;
switch (mem->mem_type) {
case TTM_PL_VRAM:
// VRAM:直接映射到 VRAM 物理地址
uint64_t vram_base = adev->gmc.vram_start;
uint64_t phys_addr = vram_base + mem->start;
// 设置 PTE 标志:Valid, Read, Write, VRAM
pte_flags = AMDGPU_PTE_VALID |
AMDGPU_PTE_READABLE |
AMDGPU_PTE_WRITEABLE |
AMDGPU_PTE_VRAM;
// 填充 GPU 页表
for (i = 0; i < num_ptes; i++) {
uint64_t pte = (phys_addr + (i << PAGE_SHIFT)) | pte_flags;
amdgpu_vm_write_pte(vm, va_start + (i << PAGE_SHIFT), pte);
}
break;
case TTM_PL_TT:
// GTT:映射到系统内存 DMA 地址
struct ttm_tt *tt = bo->tbo.ttm;
if (!tt || !tt->dma_address) {
return –EINVAL;
}
// 设置 PTE 标志:Valid, Read, Write, System
pte_flags = AMDGPU_PTE_VALID |
AMDGPU_PTE_READABLE |
AMDGPU_PTE_WRITEABLE |
AMDGPU_PTE_SYSTEM;
// 使用 DMA 地址填充 GPU 页表
for (i = 0; i < num_ptes; i++) {
uint64_t pte = tt->dma_address[i] | pte_flags;
amdgpu_vm_write_pte(vm, va_start + (i << PAGE_SHIFT), pte);
}
break;
case TTM_PL_SYSTEM:
// SYSTEM:与 GTT 类似,但可能需要建立临时 GART 映射
// (部分老旧 GPU 需要通过 GART 访问系统内存)
return amdgpu_gart_map_system_memory(adev, bo, va_start);
default:
return –EINVAL;
}
// 刷新 TLB
amdgpu_vm_flush_tlb(vm);
return 0;
}
关键点:
- VRAM:GPU 页表直接指向 vram_base + mem->start
- GTT:GPU 页表指向 ttm_tt->dma_address[](系统内存的 DMA 地址)
- 页表标志:不同内存类型使用不同的 PTE 标志
8. 常见问题解答
Q1:为什么 GTT 需要 ttm_resource,而不是只用 ttm_tt?
回答:
GTT(Graphics Translation Table)是 GPU 侧的 虚拟地址空间,而 ttm_tt 管理的是 物理页。两者职责完全不同:
-
ttm_resource(具体是 ttm_range_mgr_node):
- 负责在 GTT 地址空间中分配一段连续的虚拟地址范围
- 记录分配到的 GTT 偏移(start)和大小(size)
- 解决"GPU 用什么虚拟地址访问这块内存"的问题
-
ttm_tt:
- 负责分配实际的系统内存物理页(pages[])
- 建立 DMA 映射(dma_address[])
- 解决"这块内存实际在哪些物理页上"的问题
类比理解:
GTT 就像 CPU 的虚拟地址空间(vmalloc 区域)
ttm_resource 就像 vmalloc 返回的虚拟地址范围
ttm_tt 就像实际分配的物理页
实际工作流程:
1. ttm_resource_alloc() 在 GTT 空间分配虚拟地址:0x10000-0x11000
2. ttm_tt_populate() 分配 1024 个物理页
3. ttm_tt_map() 建立 DMA 映射,得到 DMA 地址
4. 驱动填充 GPU 页表:GTT[0x10000] → DMA 地址[0]
GTT[0x10001] → DMA 地址[1]
…
结论:两者缺一不可,ttm_resource 管地址空间,ttm_tt 管物理页。
Q2:SYSTEM 内存的 ttm_resource 有什么用?start 为什么没有意义?
回答:
SYSTEM 类型的 ttm_resource 虽然 start 字段无实际意义,但其他字段仍然非常重要:
仍然有用的字段:
- mem_type:标识这是 SYSTEM 内存(TTM_PL_SYSTEM)
- size:记录 BO 的大小,用于资源统计
- lru:参与 LRU eviction 算法(SYSTEM 内存也可能被驱逐)
- bo:反向引用,方便从 resource 找到 BO
- css:cgroup 资源记账
为什么 start 无意义?
- SYSTEM 内存不需要分配 GPU 地址空间(没有像 GTT 那样的虚拟地址)
- 物理页由 ttm_tt 的页池直接分配,不是连续的物理地址
- GPU 访问 SYSTEM 内存通常需要建立临时的 GART 映射或直接通过 PCIe DMA
统一接口的好处:
// 统一的 eviction 逻辑,不需要区分内存类型
struct ttm_resource *res = bo->resource;
if (res->lru.link.next != &res->lru.link) { // 在 LRU 链表中
list_del_init(&res->lru.link); // 从 LRU 移除
}
ttm_resource_free(bo, &bo->resource); // 统一释放接口
结论:ttm_resource 提供了统一的管理接口,即使 SYSTEM 内存不需要地址分配,仍然需要这个"占位符"。
Q3:为什么需要继承 ttm_resource(如 ttm_buddy_resource)?
回答:
不同内存域的管理方式差异巨大,需要额外的私有数据:
VRAM(ttm_buddy_resource):
struct ttm_buddy_resource {
struct ttm_resource base; // 公共字段
struct list_head blocks; // Buddy 分配的内存块链表 ★
unsigned long flags; // 分配标志(CONTIGUOUS/TOPDOWN)★
};
- 需要记录 Buddy 分配的多个内存块
- 需要记录分配时的特殊要求(连续分配、从高地址分配等)
GTT(ttm_range_mgr_node):
struct ttm_range_mgr_node {
struct ttm_resource base; // 公共字段
struct drm_mm_node mm_nodes[]; // 地址区间节点(可能多个)★
};
- 需要记录 drm_mm 分配的地址区间(可能不连续)
- 柔性数组支持多段分配
继承的优势:
类型转换示例:
// 统一接口操作
struct ttm_resource *res = bo->resource;
// 根据类型转换为具体类型
if (res->mem_type == TTM_PL_VRAM) {
struct ttm_buddy_resource *bres;
bres = container_of(res, struct ttm_buddy_resource, base);
// 访问 VRAM 特有字段
list_for_each_entry(block, &bres->blocks, link) {
printk("Block: offset 0x%llx, size %zu\\n",
block->offset, block->size);
}
}
结论:继承实现了面向对象的多态,既保证了统一接口,又满足了不同内存域的特殊需求。
Q4:ttm_resource::bo 为什么是弱引用?
回答:
弱引用的含义:
- 不增加 BO 的引用计数
- 不阻止 BO 被释放
- 使用时必须持有 ttm_device::lru_lock
原因 1:避免循环引用
ttm_buffer_object
├─> resource (强引用) ──> ttm_resource
└─── 如果 resource->bo 是强引用,形成循环 ──┘
- 如果是强引用,BO 和 resource 互相持有,导致内存泄漏
原因 2:LRU 遍历的需要
// Eviction 时遍历 LRU 链表
spin_lock(&bdev->lru_lock);
list_for_each_entry(res, &man->lru[priority], lru.link) {
struct ttm_buffer_object *bo = res->bo; // 弱引用访问 ★
if (bo && ttm_bo_evict_swapout_allowable(bo, ctx)) {
// 驱逐这个 BO
ttm_bo_evict(bo);
break;
}
}
spin_unlock(&bdev->lru_lock);
- eviction 时需要从 resource 找到 BO
- 但不希望 resource 阻止 BO 被释放
使用规则:
// 正确:持有锁访问
spin_lock(&bdev->lru_lock);
struct ttm_buffer_object *bo = res->bo;
if (bo) {
// 使用 bo
}
spin_unlock(&bdev->lru_lock);
// 错误:不持有锁访问
struct ttm_buffer_object *bo = res->bo; // 可能已被释放!
bo->resource = NULL; // 崩溃!
结论:弱引用避免了循环引用,但访问时必须持有锁保护。
Q5:如何判断一个 BO 是否可以驱逐(evict)?
回答:
eviction 判断涉及多个维度:
1. LRU 位置(最重要)
// BO 的 resource 在 LRU 链表中的位置决定了驱逐优先级
// 链表头部 = 最近使用,链表尾部 = 最久未使用
list_for_each_entry_reverse(res, &man->lru[priority], lru.link) {
// 从尾部开始遍历,优先驱逐最久未使用的 BO
}
2. Pin 状态
if (bo->pin_count > 0) {
// BO 被 pin 住(如正在被 GPU 使用),不能驱逐
continue;
}
3. 优先级
// LRU 按优先级分为 4 个链表
enum ttm_bo_priority {
TTM_BO_PRIORITY_SYSTEM = 0, // 系统使用,优先保留
TTM_BO_PRIORITY_KERNEL = 1, // 内核使用
TTM_BO_PRIORITY_NORMAL = 2, // 普通优先级
TTM_BO_PRIORITY_EVICT = 3, // 可驱逐,最低优先级
};
// 驱逐时从低优先级(EVICT)开始
for (priority = TTM_MAX_BO_PRIORITY – 1; priority >= 0; priority—) {
list_for_each_entry(res, &man->lru[priority], lru.link) {
// …
}
}
4. 兼容性检查
// 检查是否与新分配需求相交
if (!man->func->intersects(man, res, place, size)) {
// 不相交,驱逐它也不会释放我们需要的空间
continue;
}
5. 资源量检查
// 检查是否已经释放了足够的空间
if (man->size – man->usage >= size) {
// 已经有足够的空闲空间
break;
}
完整的 eviction 流程:
int ttm_bo_mem_space(struct ttm_buffer_object *bo,
struct ttm_placement *placement,
struct ttm_resource **mem,
struct ttm_operation_ctx *ctx)
{
// 1. 尝试直接分配
for (i = 0; i < placement->num_placement; i++) {
ret = ttm_resource_alloc(bo, &placement->placement[i], mem);
if (ret == 0)
return 0; // 分配成功
}
// 2. 分配失败,触发 eviction
for (i = 0; i < placement->num_placement; i++) {
struct ttm_place *place = &placement->placement[i];
struct ttm_resource_manager *man = ttm_manager_type(bdev, place->mem_type);
// 遍历 LRU,从低优先级开始
for (priority = TTM_MAX_BO_PRIORITY – 1; priority >= 0; priority—) {
list_for_each_entry_safe(res, tmp, &man->lru[priority], lru.link) {
struct ttm_buffer_object *evict_bo = res->bo;
// 检查是否可以驱逐
if (!evict_bo ||
evict_bo->pin_count > 0 ||
!man->func->intersects(man, res, place, bo->base.size)) {
continue;
}
// 驱逐这个 BO
ret = ttm_bo_evict(evict_bo, ctx);
if (ret)
continue;
// 再次尝试分配
ret = ttm_resource_alloc(bo, place, mem);
if (ret == 0)
return 0; // 分配成功
}
}
}
return –ENOSPC; // 驱逐后仍然失败
}
结论:eviction 综合考虑 LRU、pin 状态、优先级、空间需求等多个因素。
9. 总结
核心要点
定位:ttm_resource 是"物理内存/地址空间占用凭证",统一描述所有内存域的分配结果
多态设计:通过继承实现不同内存域的特化
- VRAM → ttm_buddy_resource(Buddy 分配器)
- GTT → ttm_range_mgr_node(地址区间管理)
- SYSTEM → 基础 ttm_resource(仅作占位符)
协同工作:
- 与 ttm_buffer_object:通过 bo->resource 关联
- 与 ttm_resource_manager:通过 man->func 函数表操作
- 与 ttm_tt:GTT/SYSTEM 场景下协同管理地址空间和物理页
生命周期:分配 → 使用 → 迁移 → 释放
- 分配:ttm_resource_alloc() → man->func->alloc()
- 释放:ttm_resource_free() → man->func->free()
关键字段:
- start:地址/偏移(VRAM/GTT 有意义,SYSTEM 无意义)
- mem_type:内存域类型(VRAM/GTT/SYSTEM)
- size:资源大小
- lru:参与 eviction 算法
- bus:CPU mmap 映射信息
本文深入剖析了 ttm_resource 这个核心组件:
- 是什么:物理内存分配结果的统一抽象
- 怎么做:通过继承支持不同内存域的特化
- 如何用:分配、释放、兼容性判断、LRU 管理
- 与谁协作:BO、资源管理器、页表对象
打油诗一首:
ttm_resource 是凭证,地址空间占用证
VRAM 用 Buddy 块成链,GTT 用区间虚拟段
SYSTEM 占位符无 start,页表另交 ttm_tt 管
BO 迁移换 resource,GPU 页表看 start 填
弱引用避免循环依赖,LRU 驱逐按优先级算
10. 下一篇预告
可以看出,ttm_resource是被ttm_resoure_manager的分配和管理的,下一节我们具体分析manager的实现。
《TTM 资源管理器实现:ttm_resource_manager 深度剖析》
- ttm_resource_manager 的设计与实现
- 三种管理器的具体实现:
- ttm_buddy_manager(VRAM Buddy 分配器)
- ttm_range_manager(GTT 地址区间管理)
- ttm_sys_manager(SYSTEM 页池分配)
- 资源管理器的操作函数表(ttm_resource_manager_func)
