In-depth analysis of the Linux kernel macro container_of

1. As mentioned above

I saw this macro when I was reading Linux driver code several years ago. I searched on Baidu for a long time and knew how to use it, but I still had only a vague understanding of the implementation process and principles.

The container_of macro is used very many times in the Linux kernel code. For students who like Linux programming, understanding its implementation method will be of great help in reading kernel code and writing kernel drivers in the future. Of course, I am not saying that you can do whatever you want after understanding this. The kernel is profound and extensive. You should learn from the macro first and then the micro. Don't think that you can become a fat man in one bite. This article mainly analyzes the implementation principle of this function, and I hope it will be helpful to everyone in your learning process.

android7.1/kernel/drivers/input
kernel/drivers/input$ grep -rn container_of ./|wc -l
710
android7.1/kernel/drivers/input$

Use grep -rn container_of ./|wc -l to count the number of times container_of appears in the kernel/drivers/input/ directory. There are 710 uses in total.

2. The role of container_of

The function of container_of is to get the address of the structure through the address of the structure member variable. Suppose your name is Li Guangming, and you have a younger brother named XXX. The police uncle found that your brother XXX did a bad thing, but the police uncle did not know your brother's name, so he arrested you for interrogation, but you were very stubborn and refused to tell him. The police uncle got your name and checked your family's household registration book, and then your brother was found out. It turned out that your brother XXX's name was Li Xiaoming. This method of solving a case is called following the clues.

Kernel function calls often pass in the address of a structure member, and then the function wants to use other member variables in the structure, which leads to this problem. I think this is also a way to implement object-oriented programming in C.

For example, this code

static void sensor_suspend(struct early_suspend *h)          
{                          
  struct sensor_private_data *sensor =               
      container_of(h, struct sensor_private_data, early_suspend);  
  if (sensor->ops->suspend)                     
    sensor->ops->suspend(sensor->client);             
}

early_suspend is a member of sensor_private_data. The address of the sensor_private_data structure variable is obtained through the address of this member, thereby calling the member variable client inside. This method is very elegant. Here I used a more elegant word, "elegant".

Let me briefly explain here that the h passed in must have been defined somewhere else and the operating system has allocated memory space for it. The allocation of space for h means that its father also has memory. Otherwise, you would be stupid if you follow the clues and find a NULL.

3. How to use container_of

Container_of needs to pass in three parameters. The first parameter is a pointer, the second parameter is the structure type, and the third parameter is the member in the structure corresponding to the second parameter.

container_of(ptr, type, member)

• ptr: represents the address of member in the structure
• type: indicates the structure type struct sensor_private_data
• member: indicates that the member early_suspend type in the structure must contain this member, you can't mess around with it
• Returns the first address of the structure

4. Analysis of knowledge points used in container_of

4.1. The role of ({})

({}) First, let’s talk about this expression. Many people may understand it and may have seen it in many places, but they may not pay attention to it. This expression returns the value of the last expression. For example, if x=({a;b;c;d;}), the final value of x should be d.

Code example:

#include <stdio.h>
void main(void)
{
  int a=({1;2;4;})+10;
  printf("%d\n",a);//a=14
}

4.2. typeof gets the type of variable

We rarely see this. This keyword is an extension of the C language keyword and returns the type of the variable. For details, see the introduction in GCC
https://gcc.gnu.org/onlinedocs/gcc/Typeof.html

++Another way to refer to the type of an expression is with typeof. The syntax of using of this keyword looks like sizeof, but the construct acts semantically like a type name defined with typedef.++

Code example:

void main(void)
{
  int a = 6;
  typeof(a) b =9;
  printf("%d %d\n",a,b);
}

4.3. The role of (struct st*)0

I think everyone has used a ruler. For example, if I want to use a ruler to measure the length of a book, we first need to find the 0 scale position of the ruler, and then use this 0 scale position to align the edge of the book, and then align it. Check the ruler scale on the other side of the book to know the length of the book.

Now we need to measure the length of a structure. We can also use a ruler to measure it. We just need to find the position of the 0 scale. Similarly, even if we don't know the position of the 0 scale, we can still calculate the length of the structure by subtracting the first and last scales.

But what is a ruler in C? You may think of sizeof, but unfortunately, this does not meet our needs, so we have (struct st *), which is really perfect as a ruler.

struct st{
  int a;
  int b;
}*p_st,n_st;
void main(void)
{
  printf("%p\n",&((struct st*)0)->b);
}

The above code

(struct st*)0

This means putting this structure on the 0 scale and starting measuring. Then where do we measure to?

&((struct st*)0)->b)

This is reflected when measuring to the position b. So the output above should be 4.

After reading the above explanation, you should know that the following two codes have the same functions.

typeof ((struct st*)0)->b) c; // Take the type of b to declare c
int c;

In fact, it is not just for 0, it is also valid for other numbers. For example, in the following code, the compiler cares about the type, not the number.

printf("%p\n",&((struct st*)4)->b -4 );

I wrote this article a few days ago, but I didn’t want to post it directly because I felt that I had never found a particularly good way to prove this core point. After reading the above, you should have some idea about this kind of measurement. If you are now required to set the first address of an array to 0, what should you do?

Think about it for a moment, assuming there is a delay of a few minutes.

The code is as follows:

struct A {
  short array[100];
};
int main(int argc, char *argv[])
{
  int i = 10;
  A* a = (A*)0;
  printf("%p %d %d\n",a,sizeof(short), &a->array[20]);
  getchar();
  return 1;
}
// Output 00000000 2 40

Is there any way to put the address of the array directly at position 0 without using ==struct A *==? I haven't found any better solution yet. If you have any good suggestions, please leave me a message.

4.4、offsetof(TYPE, MEMBER)

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

If you don't understand size_t, you can search it on Baidu. It is an unsigned integer. The length is different in 32-bit and 64-bit, so offsetof is used to get the offset length of the structure.

4.5. Function of const int* p

There is also a small knowledge point in the above macro definition

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

The above code can be shortened to

const int * __mptr

What does this indicate? This indicates that the integer data pointed to by __mptr is a const (constant).

This involves two other pieces of knowledge

int * const __mptr; // means that the value of __mptr cannot be changed // and const int * const __mptr; // means that __mptr cannot be changed and the content it points to cannot be changed

5. Analysis of container_of

After reading the above knowledge points, the container_of macro becomes very clear. I put the parsing part in the code comments below.

#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE*)0)->MEMBER)
#define container_of(ptr, type, member) ({ \
    const typeof( ((type *)0)->member ) *__mptr = (const typeof( ((type *)0)->member ) *)(ptr); \
    (type *)( (char *)__mptr - offsetof(type,member) );})
//-----dividing line struct st{
  int a;
  int b;
}*pt;
//Use this as an example container_of(&pt->a,struct st,a)
 const typeof( ((struct st *)0)->a ) *__mptr = (const typeof( ((struct st *)0)->a ) *)(&pt->a);
const int *__mptr = (int *)(&pt->a);//After parsing the first sentence, it actually gets the address of a.
(type *)( (char *)__mptr - offsetof(type,member) );
//This becomes (struct st *)( (char *)__mptr - ((unsigned int) &((struct st*)0)->a));
//This sentence means that the address of a minus the offset address length of a to the structure is the address position of the structure.

6. Example code

After the above explanation, you should at least have a feel for this macro. Write a code to test it and integrate yourself with the code. Only in this way can you achieve the state of unity of man and code.

The code is as follows:

#include <stdio.h>
#include<stddef.h>
#include<stdlib.h>
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE*)0)->MEMBER)
/*ptr member pointer* type structure such as struct Stu
* member member variable, corresponding to the pointer* */
#define container_of(ptr, type, member) ({ \
    const typeof( ((type *)0)->member ) *__mptr = (const typeof( ((type *)0)->member ) *)(ptr); \
    (type *)( (char *)__mptr - offsetof(type,member) );})
typedef struct Stu{
    int age;
    char name[10];
    int id;
    unsigned long phone_num;
}*p_stu,str_stu;
void print_all(void *p_str)
{
  p_stu m1p_stu = NULL;
  m1p_stu = container_of(p_str,struct Stu,age);
  printf("age:%d\n",m1p_stu->age);
  printf("name:%s\n",m1p_stu->name);
  printf("id:%d\n",m1p_stu->id);
  printf("phone_num:%d\n",m1p_stu->phone_num);
}
void main(void)
{
  p_stu m_stu = (p_stu)malloc(sizeof(str_stu));
  m_stu->age = 25;
  m_stu->id = 1;
  m_stu->name[0]='w';
  m_stu->name[1]='e';
  m_stu->name[2]='i';
  m_stu->name[3]='q';
  m_stu->name[4]='i';
  m_stu->name[5]='f';
  m_stu->name[6]='a';
  m_stu->name[7]='\0';
  m_stu->phone_num=13267;
  /* Pass the structure member pointer in */
  print_all(&m_stu->age);
  printf("main end\n");
  if(m_stu!=NULL)
    free(m_stu);
}

7. Program Output

age:25
name:weiqifa
id:1
phone_num:13267
main end

Summarize

The above is the full content of this article. I hope that the content of this article will have certain reference learning value for your study or work. Thank you for your support of 123WORDPRESS.COM. If you want to learn more about this, please check out the following links