offsetof，container_of

offsetof  和 container_of  是 linux 内核中定义的宏。

offsetof: 计算结构体的成员相对于结构体的地址的偏移量。

container_of: 根据结构体成员的地址得到这个结构体的地址。结构体可以看作这个成员的容器，所以 container of，一个成员的容器。

offset 和 container_of 两个宏在内核中的定义如下，可以看到 container_of 中还使用了 offsetof。

#define offsetof(TYPE, MEMBER)	((size_t)&((TYPE *)0)->MEMBER)

/**
 * container_of - cast a member of a structure out to the containing structure
 * @ptr:	the pointer to the member.
 * @type:	the type of the container struct this is embedded in.
 * @member:	the name of the member within the struct.
 *
 */
#define container_of(ptr, type, member) ({				\
	void *__mptr = (void *)(ptr);					\
	BUILD_BUG_ON_MSG(!__same_type(*(ptr), ((type *)0)->member) &&	\
			 !__same_type(*(ptr), void),			\
			 "pointer type mismatch in container_of()");	\
	((type *)(__mptr - offsetof(type, member))); })

如下图所示，两个结构体：struct Member 和 struct Container。struct Container 中有一个 struct Member 类型的成员 member。那么可以使用 offset 宏计算成员 member 相对于 struct Cotainer 的偏移量，也可以通过 member 的地址获取到结构体 struct Container 的地址。

struct Member {

   int member;

}

struct Container {

    int a;

    char b;

    struct Member member;

    long c;

};

如下是 offsetof 和 container_of 使用的示例代码。

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#define offsetof(TYPE, MEMBER) ((size_t) & ((TYPE *)0)->MEMBER)
#define container_of(ptr, type, member) ({                              \
        void *__mptr = (void *)(ptr);                                   \
        ((type *)(__mptr - offsetof(type, member))); })

struct Member {
   int member;
};

struct Container {
    int a;
    char b;
    struct Member member;
    long c;
};

int main() {
  struct Container container;
  printf("offsetof member: %d\n", offsetof(struct Container, member));
  printf("container addr: %p, member addr: %p, container of member: %p\n", \
                  &container, &(container.member), container_of(&(container.member), struct Container, member));
  return 0;
}

从内核的 offset 定义中可以看出来，其中使用了 0，将 0 作为地址强制转换成了结构体类型的地址。0 地址能这么用吗 ？

读写 0 地址的时候，程序会崩溃，segmentfault，如下代码所示：

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main() {
  int *p = 0x0;
  // int a = *p; // 从 0x0 中读
  *p = 10; // 向 0x0 中写
  return 0;
}

那为什么在 offset 中使用 0 地址就不会崩溃呢 ？offset 的实现，并没有操作 0 地址，没有读，也没有写。

为了验证 0 地址是不是被访问，我们对上边两个代码进行简化，只保留必要的代码。然后编译，编译之后使用反汇编查看对应的汇编指令，来确定是不是访问了 0 地址。为了反汇编显示的信息更加全面，编译的时候带上 -g 选项。

// offset.c
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#define offsetof(TYPE, MEMBER) ((size_t) & ((TYPE *)0)->MEMBER)

struct Member {
   int member;
};

struct Container {
    int a;
    char b;
    struct Member member;
    long c;
};

int main() {
  struct Container container;
  int a = offsetof(struct Container, member);
  return 0;
}


// offsetof.c
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main() {
  int *p = 0x0;
  int a = *p; // 从 0x0 中读
  return 0;
}

上边两个文件编译之后的目标文件分别是 access 和 offset，然后使用 objdump 对目标文件进行反汇编。

objdump -d -S -l access

objdump -d -S -l offset

-d: 反汇编

-S: 显示源码

-l: 显示行号

offset:

offset:

 可以看到，针对 offset 这个宏，编译器直接计算出来了偏移 0x8，并没有访问 0 地址。