Zrozumienie makra container_of w jądrze Linuksa

Kiedy przeglądałem jądro Linuksa, znalazłem container_ofmakro, które jest zdefiniowane w następujący sposób:

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

Rozumiem, co robi container_of, ale nie rozumiem ostatniego zdania, czyli

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

Jeśli użyjemy makra w następujący sposób:

container_of(dev, struct wifi_device, dev);

Odpowiednia część ostatniego zdania brzmiałaby:

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

co wygląda na nic nie robienie. Czy ktoś mógłby tutaj wypełnić tę pustkę?

Twój przykład użycia container_of(dev, struct wifi_device, dev);może być nieco mylący, ponieważ mieszasz tam dwie przestrzenie nazw.

Podczas gdy pierwsza devw twoim przykładzie odnosi się do nazwy wskaźnika, druga devodnosi się do nazwy elementu członkowskiego struktury.

Najprawdopodobniej to zamieszanie wywołuje cały ten ból głowy. W rzeczywistości memberparametr w Twojej ofercie odnosi się do nazwy nadanej temu elementowi w strukturze kontenera.

Biorąc na przykład ten pojemnik:

struct container {
  int some_other_data;
  int this_data;
}

I wskaźnik int *my_ptrdo this_dataczłonka, do którego użyjesz makra, aby uzyskać wskaźnik struct container *my_container, używając:

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

Uwzględnienie przesunięcia this_datado początku struktury jest niezbędne do uzyskania prawidłowego położenia wskaźnika.

W efekcie wystarczy odjąć przesunięcie członka this_dataod wskaźnika, my_ptraby uzyskać prawidłowe położenie.

To jest dokładnie to, co robi ostatni wiersz makra.

Ostatnie rzucone zdanie:

(type *)(...)

wskaźnik do danego type. Wskaźnik jest obliczany jako przesunięcie od podanego wskaźnika dev:

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

Korzystając z cointainer_ofmakra, chcesz pobrać strukturę zawierającą wskaźnik danego pola. Na przykład:

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);

Masz wskaźnik, który wskazuje środek struktury (i wiesz, że jest to wskaźnik do pola two[ nazwa pola w strukturze ]), ale chcesz pobrać całą strukturę ( numbers). Więc obliczasz przesunięcie pola twow strukturze:

offsetof(type,member)

i odejmij to przesunięcie od podanego wskaźnika. Rezultatem jest wskaźnik do początku struktury. Na koniec rzutujesz ten wskaźnik na typ struktury, aby mieć prawidłową zmienną.

Jest to wykorzystanie rozszerzenia gcc, wyrażeń instrukcji . Jeśli widzisz makro jako coś zwracającego wartość, ostatnia linia wyglądałaby tak:

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

Zobacz linkowaną stronę, aby uzyskać wyjaśnienie instrukcji złożonych. Oto przykład :

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

Wynik jest

b 25

makro conatainer_of () w jądrze Linuksa -

Jeśli chodzi o zarządzanie kilkoma strukturami danych w kodzie, prawie zawsze będziesz musiał osadzić jedną strukturę w innej i odzyskać je w dowolnym momencie bez zadawania pytań o przesunięcia lub granice pamięci. Powiedzmy, że masz osobę struct, jak zdefiniowano tutaj:

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

Mając tylko wskaźnik na wiek lub wynagrodzenie, możesz pobrać całą strukturę opakowującą (zawierającą) ten wskaźnik. Jak sama nazwa wskazuje, makro container_of służy do wyszukiwania kontenera danego pola struktury. Makro jest zdefiniowane w include / linux / kernel.h i wygląda następująco:

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

Nie bój się wskazówek; po prostu zobacz je w następujący sposób:

container_of(pointer, container_type, container_field); 

Oto elementy poprzedniego fragmentu kodu:

• pointer: To jest wskaźnik do pola w strukturze
• typ_kontenera: jest to typ zawijania struktury (zawierającej) wskaźnik
• container_field: jest to nazwa pola, na które wskaźnik wskazuje wewnątrz struktury

Rozważmy następujący kontener:

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

Rozważmy teraz jedno z jego wystąpień, wraz ze wskaźnikiem do członka wieku:

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

Wraz ze wskaźnikiem do elementu członkowskiego imienia (age_ptr) możesz użyć makra container_of, aby uzyskać wskaźnik do całej struktury (kontenera), który otacza ten element członkowski, używając następującego polecenia:

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

container_of bierze pod uwagę przesunięcie wieku na początku struktury, aby uzyskać poprawną lokalizację wskaźnika. Jeśli odejmiesz przesunięcie wieku pola od wskaźnika age_ptr, otrzymasz poprawną lokalizację. Oto, co robi ostatnia linia makra:

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

Odnosząc to do prawdziwego przykładu, daje to:

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); 

Makro container_of jest używane głównie w ogólnych kontenerach jądra.

To wszystko o makrze container_of w jądrze.

Trochę rzeczywisty kontekst mówi jaśniej, poniżej użyj czerwono-czarnego drzewa jako przykładu , co rozumiem container_of.

jak Documentation/rbtree.txtstwierdza, w kodzie jądra Linuksa, rb_node nie zawiera raczej wprowadzania danych

Węzły danych w drzewie rbtree są strukturami zawierającymi element struktury rb_node.

struct vm_area_struct(w pliku include/linux/mm_types.h:284) jest taką strukturą,

w tym samym pliku znajduje się makro rb_entryzdefiniowane jako

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

oczywiście rb_entryjest taki sam jak container_of.

w mm/mmap.c:299definicji funkcji wewnętrznej browse_rbzastosowano 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 */

Teraz jest jasne, w container_of(ptr, type, member),

• type jest strukturą kontenera struct vm_area_struct
• memberto nazwa członka typeinstancji, w tym vm_rbprzypadku typu rb_node,
• ptrJest to wskaźnik wskazujący membero typeprzykład tutaj rb_node *nd.

co container_ofto jest, jak w tym przykładzie,

• podany adres obj.member(tutaj obj.vm_rb), zwróć adres obj.
• ponieważ struktura jest blokiem ciągłej pamięci, adres obj.vm_rbminus offset between the struct and memberbędzie adresem kontenera.

include/linux/kernel.h:858 -- Definicja container_of

include/linux/rbtree.h:51 -- Definicja rb_entry

mm/mmap.c:299 -- użycie rb_entry

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

Documentation/rbtree.txt: - Dokumentacja czerwono-czarnego drzewa

include/linux/rbtree.h:36 -- Definicja struct rb_node

PS

Powyższe pliki są w aktualnej wersji deweloperskiej tj 4.13.0-rc7.

file:koznacza k-tą linię w file.

Bardzo przydatny link do zrozumienia makra container_of w jądrze Linuksa. https://linux-concepts.blogspot.com/2018/01/understanding-containerof-macro-in.html

Najprostsza implementacja makra Container _of jest poniżej. Zmniejsza ona wszelkie skomplikowane sprawdzanie typu i prac

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

ptr poda adres członka i po prostu odejmie różnicę przesunięcia, a otrzymasz adres początkowy.

Przykładowe użycie

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;
}