Linux内核中的container_of宏详解

// 示例：内核链表节点结构
struct list_head {
    struct list_head *next, *prev;
};

// 业务数据结构
struct my_struct {
    int data;
    struct list_head list;  // 嵌入的链表节点
};

#define container_of(ptr, type, member) ({              \
    const typeof(((type *)0)->member) *__mptr = (ptr);  \
    (type *)((char *)__mptr - offsetof(type, member)); })

#define container_of(ptr, type, member) \
    ((type *)((char *)(ptr) - offsetof(type, member)))

参数说明表格：
┌─────────┬─────────────────────────────────────────┐
│ 参数    │ 说明                                    │
├─────────┼─────────────────────────────────────────┤
│ ptr     │ 结构体成员的指针                        │
│ type    │ 包含该成员的结构体类型                  │
│ member  │ 成员在结构体中的名称                    │
└─────────┴─────────────────────────────────────────┘

内存布局示意图：
┌─────────────────────────────────────────────┐
│            struct container                 │
│  ┌──────────────────────────────────────┐  │
│  │ 成员1                                │  │
│  ├──────────────────────────────────────┤  │
│  │ 成员2                                │  │
│  ├──────────────────────────────────────┤  │
│  │ ...                                  │  │
│  ├──────────────────────────────────────┤  │
│  │ member (我们已知它的地址: ptr)       │←─┘ 已知点
│  │                                      │
│  ├──────────────────────────────────────┤
│  │ 其他成员...                          │
│  └──────────────────────────────────────┘
└─────────────────────────────────────────────┘
↑
container_of计算出的结构体起始地址

// offsetof宏计算成员在结构体中的偏移
#define offsetof(TYPE, MEMBER) ((size_t)&((TYPE *)0)->MEMBER)

struct example {
    int a;      // 偏移量：0
    char b;     // 偏移量：4（假设int为4字节）
    double c;   // 偏移量：8（考虑内存对齐）
};

// offsetof(struct example, c) = 8

计算公式：
结构体地址 = 成员地址 - 成员偏移量
           ↓
container = ptr - offsetof(type, member)

// 实际数据结构
struct person {
    int age;
    char name[20];
    struct list_head node;  // 链表节点
};

// 假设我们知道node的地址
struct list_head *node_ptr = &some_person.node;

// 使用container_of
struct person *person_ptr = container_of(node_ptr, struct person, node);

// 展开计算过程：
// 1. offsetof(struct person, node) = 
//    (age:4字节 + name:20字节) = 24字节（假设对齐）
// 2. 结构体地址 = node_ptr - 24

内存地址可视化：
地址       内容                        说明
0x1000     [age]                      person结构体开始
0x1004     [name[0..19]]              name字段
0x1018     [node.next]                ← node成员开始
0x1020     [node.prev]                我们已知这里的地址：ptr=0x1018
          
计算过程：
ptr = 0x1018 (node的地址)
offset = 0x18 (24字节，node在person中的偏移)
person地址 = 0x1018 - 0x18 = 0x1000 ✓

#include <stdio.h>
#include <stddef.h>

// 简化版offsetof和container_of
#define offsetof(TYPE, MEMBER) ((size_t)&((TYPE *)0)->MEMBER)
#define container_of(ptr, type, member) \
    ((type *)((char *)(ptr) - offsetof(type, member)))

// 链表节点
struct list_head {
    struct list_head *next;
};

// 业务数据
struct task {
    int pid;
    int priority;
    struct list_head list;  // 嵌入的链表节点
};

int main() {
    // 创建一些任务
    struct task task1 = {.pid = 100, .priority = 1};
    struct task task2 = {.pid = 101, .priority = 2};
    
    // 链接它们（简化版）
    task1.list.next = &task2.list;
    
    // 遍历链表：从list_head获取完整的task结构
    struct list_head *current = &task1.list;
    
    while (current != NULL) {
        // 关键步骤：通过list_head找到包含它的task
        struct task *task_ptr = container_of(current, struct task, list);
        
        printf("Found task: pid=%d, priority=%d\n", 
               task_ptr->pid, task_ptr->priority);
        
        current = current->next;
    }
    
    return 0;
}

// Linux内核中的真实示例（简化）
struct inode {
    // ... 各种字段 ...
    struct hlist_node i_hash;  // 哈希链表节点
};

// 在哈希表中查找inode
struct hlist_node *node = ...;  // 从哈希表获取的节点

// 通过节点找到inode
struct inode *inode = container_of(node, struct inode, i_hash);

// 内核中的实际实现包含类型检查
#define container_of(ptr, type, member) ({              \
    void *__mptr = (void *)(ptr);                       \
    BUILD_BUG_ON(!__same_type(*(ptr), ((type *)0)->member) && \
                 !__same_type(*(ptr), void));           \
    ((type *)(__mptr - offsetof(type, member))); })

内存对齐示例：
struct aligned_example {
    char a;      // 地址：0
    // 填充3字节（假设int需要4字节对齐）
    int b;       // 地址：4
    short c;     // 地址：8
};

offsetof(struct aligned_example, c) = 8
而不是 1 + 4 = 5

struct inner {
    int data;
};

struct outer {
    char tag;
    struct inner embed;
    float value;
};

struct inner *inner_ptr = &some_outer.embed;
struct outer *outer_ptr = container_of(inner_ptr, struct outer, embed);

struct complex_struct {
    int id;
    struct list_head hash_node;   // 用于哈希表
    struct list_head lru_node;    // 用于LRU缓存
    struct list_head free_node;   // 用于空闲列表
};
// 同一个结构体可以同时存在于多个链表中