Introduction to container of() function in Linux kernel programming

Preface

In Linux kernel programming, you will often see a macro function container_of(ptr, type, member), but when you trace through the source code, ordinary people like us will despair (what is all this? Functions can be defined like this??? Why is there 0??? Oh, forget it, let's just give up...). This is where the kernel masters are so powerful. Just two lines of code can make us doubt our lives. Everything requires a process, so take it slow.

In fact, the principle is very simple: given the address ptr of the member member of the structure type, find the starting address of the structure type.

The starting address of type = ptr - size (here it needs to be converted to char * because it is in bytes).

At this point, the function has been explained. Isn’t it simple? ? ? Actually, it is not. There is no mention of how to calculate the size here, and this is what makes us dizzy.

Well, let's start with the container of function prototype:

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

Next is the offserof function prototype:

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

How about it, isn’t it cool? Okay, let's start unveiling:

1. Use of 0 pointer (I gave it my own name, I don’t know if there is any problem)

Let the facts speak for themselves:

#include <stdio.h>
 
struct test
{
	char i ;
	int j;
	char k;
};
 
int main()
{
	struct test temp;
	printf("&temp = %p\n",&temp);   
	printf("&temp.k = %p\n",&temp.k);
	printf("&((struct test *)0)->k = %d\n",((int)&((struct test *)0)->k));
 
}

Compile and run, and you can get the following results:

&temp = 0xbf9815b4
&temp.k = 0xbf9815bc
&((struct test *)0)->k = 8

You see what I mean, the custom structure has three variables: i, j, and k. Because of the byte alignment requirement, the size of the structure is 4bytes * 3 = 12 bytes. The function of &((struct test *)0)->k is to find the number of bytes from k to the starting address of the structure temp (that is, our size). Here 0 is forced to be converted to struct test * type, and its role is to serve as a pointer to the starting address of the structure, and the role of & ((struct test *) 0) -> k is to calculate the number of bytes from k to the starting pointer. . . In fact, it is to find the relative address. The starting address is 0, so the value of &k is the size (Note: because an integer is required when printing, there is a forced conversion to int), so we can find the size we need. Well, I have accidentally finished explaining the functionality of the offsetof() function:

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

It looks better this time, right? (I still don’t understand why it is like this at the bottom level... I just know that it works this way), so the function of offsetof() is to find the size we dream of and return it in the form of size_t (size_t: unsigned integer).

2. Rigorousness of Kernel Programming

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

Here we only look at the second line:

const typeof( ((type *)0)->member ) *__mptr = (ptr);  

What is its function? Actually, it doesn’t have much effect (please don’t criticize me, let me finish what I’m saying), but in terms of form, _mptr = ptr, so why do we need to define the same variable? ? ? In fact, this is the awesomeness of kernel developers: if there is a problem with the parameters input by the developer when using it: ptr and member types do not match, there will be a warning during compilation, but if the line break is removed, there will be no warning, and this warning is exactly necessary (to prevent errors without knowing where the error is). . . This is rigorous, right?

typeof( ((type *)0)->member )

Its function is to obtain the type of member and nothing more. This is basically the end

3. Conclusion

The implementation of the container_of(ptr, type, member) function consists of two parts:

1. Determine whether ptr and member are of the same type

2. Calculate the size, the starting address of the structure = (type *)((char *)ptr - size) (Note: forced conversion to the structure pointer)

Now we know that the function of container_of() is to find the first address of a structure variable through the address of a member in the structure variable.

container_of(ptr,type,member), where ptr, type, and member represent pointer, type, and member respectively.

This is the end of this article about the linux kernel programming container of() function. For more related linux container of() function content, please search 123WORDPRESS.COM's previous articles or continue to browse the following related articles. I hope everyone will support 123WORDPRESS.COM in the future!