Розуміння макросу container_of у ядрі Linux

Коли я переглядав ядро ​​Linux, я знайшов container_ofмакрос, який визначається наступним чином:

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

Я розумію, що робить container_of, але що я не розумію, це останнє речення, яке є

(type *)( (char *)__mptr - offsetof(type,member) );})

Якщо ми використовуємо макрос наступним чином:

container_of(dev, struct wifi_device, dev);

Відповідною частиною останнього речення буде:

(struct wifi_device *)( (char *)__mptr - offset(struct wifi_device, dev);

що виглядає як нічого не робити. Хтось міг заповнити порожнечу тут?

Ваш приклад використання container_of(dev, struct wifi_device, dev);може трохи ввести в оману, оскільки ви змішуєте там два простори імен.

У той час як перший devу вашому прикладі посилається на ім'я вказівника, другий dev- на ім'я елемента структури.

Швидше за все це змішування провокує весь головний біль. Насправді memberпараметр у вашій пропозиції посилається на ім'я, дане цьому члену в структурі контейнера.

Взявши цей контейнер, наприклад:

struct container {
  int some_other_data;
  int this_data;
}

І вказівник int *my_ptrна this_dataчлен, до якого ви б використали макрос, щоб отримати вказівник struct container *my_container, використовуючи:

struct container *my_container;
my_container = container_of(my_ptr, struct container, this_data);

Врахування зміщення this_dataдо початку структури має важливе значення для отримання правильного розташування вказівника.

Фактично вам просто потрібно відняти зміщення елемента this_dataвід вашого вказівника, my_ptrщоб отримати правильне розташування.

Це саме те, що робить останній рядок макросу.

Останнє речення:

(type *)(...)

вказівник на задану type. Покажчик обчислюється як зміщення від заданого покажчика dev:

( (char *)__mptr - offsetof(type,member) )

Коли ви використовуєте cointainer_ofмакрос, ви хочете отримати структуру, що містить вказівник на дане поле. Наприклад:

struct numbers {
    int one;
    int two;
    int three;
} n;

int *ptr = &n.two;
struct numbers *n_ptr;
n_ptr = container_of(ptr, struct numbers, two);

У вас є вказівник, який вказує на середину структури (і ви знаєте, що це вказівник на поле two[ ім’я поля в структурі ]), але ви хочете отримати всю структуру ( numbers). Отже, ви обчислюєте зміщення поданої twoв структурі:

offsetof(type,member)

і відніміть це зміщення від заданого покажчика. Результат - вказівник на початок структури. Нарешті, ви призначаєте цей покажчик до типу структури, щоб мати дійсну змінну.

Це використання розширення gcc, вирази операторів . Якщо ви бачите макрос як щось, що повертає значення, то останній рядок буде таким:

return (struct wifi_device *)( (char *)__mptr - offset(struct wifi_device, dev);

Див. Посилання на сторінку для пояснення складених тверджень. Ось приклад:

int main(int argc, char**argv)
{
    int b;
    b = 5;
    b = ({int a; 
            a = b*b; 
            a;});
    printf("b %d\n", b); 
}

Вихідний результат

b 25

макрос conatainer_of () у ядрі Linux -

Коли справа доходить до управління кількома структурами даних у коді, вам майже завжди потрібно буде вбудовувати одну структуру в іншу та отримувати їх у будь-який момент, не задаючи питань про зміщення пам’яті чи межі. Скажімо, у вас є структура людини, як визначено тут:

 struct person { 
     int age; 
     int salary;
     char *name; 
 } p;

Маючи лише вказівник на вік або зарплату, ви можете отримати всю структуру, яка обертає (містить) цей вказівник. Як випливає з назви, макрос container_of використовується для пошуку контейнера заданого поля структури. Макрос визначений у include / linux / kernel.h і виглядає так:

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

Не бійтеся покажчиків; просто перегляньте їх наступним чином:

container_of(pointer, container_type, container_field); 

Ось елементи попереднього фрагмента коду:

• покажчик: це вказівник на поле в структурі
• container_type: Це тип обтікання структури (що містить) покажчик
• container_field: Це ім'я поля, на яке вказує вказівник всередині структури

Давайте розглянемо наступний контейнер:

struct person { 
    int age; 
    int salary; 
    char *name; 
}; 

Тепер давайте розглянемо один із його випадків, разом із вказівником на віковий член:

struct person somebody; 
[...] 
int *age_ptr = &somebody.age; 

Поряд з покажчиком на ім'я члена (age_ptr), ви можете використовувати макрос container_of, щоб отримати вказівник на всю структуру (контейнер), яка обертає цього члена, використовуючи наступне:

struct person *the_person; 
the_person = container_of(age_ptr, struct person, age); 

container_of враховує зміщення віку на початку структури, щоб отримати правильне розташування вказівника. Якщо відняти зміщення віку поля від покажчика age_ptr, ви отримаєте правильне розташування. Ось що робить останній рядок макросу:

(type *)( (char *)__mptr - offsetof(type,member) ); 

Застосовуючи це до реального прикладу, можна отримати наступне:

struct family { 
    struct person *father; 
    struct person *mother; 
    int number_of_sons; 
    int family_id; 
} f; 

/*   
 * Fill and initialise f somewhere   */      [...]

 /* 
  * pointer to a field of the structure 
  * (could be any (non-pointer) member in the structure) 
  */ 
   int *fam_id_ptr = &f.family_id; 
   struct family *fam_ptr; 

   /* now let us retrieve back its family */ 
   fam_ptr = container_of(fam_id_ptr, struct family, family_id); 

Макрос container_of в основному використовується в загальних контейнерах ядра.

Це все про макрос container_of в ядрі.

Трохи реальний контекст говорить ясніше, нижче використовуйте червоно-чорне дерево як приклад , який я розуміюcontainer_of .

як Documentation/rbtree.txtзазначено, в коді ядра Linux це, швидше, не rb_node, що містить введення даних

Вузли даних у дереві rbtree - це структури, що містять член struct rb_node.

struct vm_area_struct (у файлі include/linux/mm_types.h:284 ) - це така структура,

у тому ж файлі є макрос, rb_entryякий визначається як

#define rb_entry(ptr, type, member) container_of(ptr, type, member)

ясно, rb_entryце те саме, що container_of.

у mm/mmap.c:299внутрішньому визначенні функції browse_rbвикористовується rb_entry:

static int browse_rb(struct mm_struct *mm)
{
    /* two line code not matter */
    struct rb_node *nd, *pn = NULL; /*nd, first arg, i.e. ptr. */
    unsigned long prev = 0, pend = 0;

    for (nd = rb_first(root); nd; nd = rb_next(nd)) {
        struct vm_area_struct *vma;
        vma = rb_entry(nd, struct vm_area_struct, vm_rb);   
        /* -- usage of rb_entry (equivalent to container_of) */
        /* more code not matter here */

тепер зрозуміло, в container_of(ptr, type, member),

• type є структурою контейнера, тут struct vm_area_struct
• memberце ім'я члена typeекземпляра, тут vm_rb, який має тип rb_node,
• ptrтут - вказівник, що вказує memberна typeекземпляр rb_node *nd.

що container_ofробити, як у цьому прикладі,

• вказану адресу obj.member(тут obj.vm_rb), поверніть адресу obj.
• оскільки структура - це блок суміжної пам'яті, адреса obj.vm_rbмінуса offset between the struct and memberбуде адресою контейнера.

include/linux/kernel.h:858 - визначення container_of

include/linux/rbtree.h:51 - визначення rb_entry

mm/mmap.c:299 - використання rb_entry

include/linux/mm_types.h:284 - struct vm_area_struct

Documentation/rbtree.txt: - Документація червоно-чорного дерева

include/linux/rbtree.h:36 - визначення struct rb_node

PS

Наведені вище файли знаходяться в поточній версії для розробки, тобто 4.13.0-rc7.

file:kсередній k-й рядок в file.

Дуже корисне посилання для розуміння макросу container_of у ядрі Linux. https://linux-concepts.blogspot.com/2018/01/understanding-containerof-macro-in.html

Найпростіша реалізація контейнера _ макросу нижче, це зменшує всі складні перевірки типу та роботи

#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
#define container_of(ptr, type, member) ((type *)((char *)(ptr) - offsetof(type, member))) 

ptr дасть адресу учасника і просто зменшить різницю зміщення, і ви отримаєте стартову адресу.

Приклад використання

struct sample {
    int mem1;
    char mem2;
    int mem3;
};
int main(void)
{

struct sample sample1;

printf("Address of Structure sample1 (Normal Method) = %p\n", &sample1);
printf("Address of Structure sample1 (container_of Method) = %p\n", 
                        container_of(&sample1.mem3, struct sample, mem3));

return 0;
}