[开发工具] 嵌入式开发中100%会用的几个宏

[复制链接]
2836|16
 楼主| LEDyyds 发表于 2022-7-25 13:52 | 显示全部楼层 |阅读模式
链表宏linux内核鸿蒙内核rtos和一些开源代码中用的非常多。链表宏是双向链表的经典实现方式,总代码不超过50行,相当精炼。在一些开源框架中,它的数据结构,就是以链表宏为基础进行搭建(如shttpd,一个开源的轻量级、嵌入式服务器框架)。本篇文章将对llist.h文件中的链表宏进行逐个讲解。
 楼主| LEDyyds 发表于 2022-7-25 13:53 | 显示全部楼层
1 源码(llist.h)
llist.h文件的全部源码如下:
  1. #ifndef LLIST_HEADER_INCLUDED
  2. #define LLIST_HEADER_INCLUDED

  3. /*
  4. * Linked list macros.
  5. */
  6. struct llhead {
  7. struct llhead *prev;
  8. struct llhead *next;
  9. };

  10. #define LL_INIT(N) ((N)->next = (N)->prev = (N))

  11. #define LL_HEAD(H) struct llhead H = { &H, &H }

  12. #define LL_ENTRY(P,T,N) ((T *)((char *)(P) - offsetof(T, N)))

  13. #define LL_ADD(H, N)       \
  14. do {        \
  15.   ((H)->next)->prev = (N);    \
  16.   (N)->next = ((H)->next);    \
  17.   (N)->prev = (H);     \
  18.   (H)->next = (N);     \
  19. } while (0)

  20. #define LL_TAIL(H, N)       \
  21. do {        \
  22.   ((H)->prev)->next = (N);    \
  23.   (N)->prev = ((H)->prev);    \
  24.   (N)->next = (H);     \
  25.   (H)->prev = (N);     \
  26. } while (0)

  27. #define LL_DEL(N)       \
  28. do {        \
  29.   ((N)->next)->prev = ((N)->prev);   \
  30.   ((N)->prev)->next = ((N)->next);   \
  31.   LL_INIT(N);      \
  32. } while (0)

  33. #define LL_EMPTY(N) ((N)->next == (N))

  34. #define LL_FOREACH(H,N) for (N = (H)->next; N != (H); N = (N)->next)

  35. #define LL_FOREACH_SAFE(H,N,T)      \
  36. for (N = (H)->next, T = (N)->next; N != (H);   \
  37.    N = (T), T = (N)->next)

  38. #endif /* LLIST_HEADER_INCLUDED */
 楼主| LEDyyds 发表于 2022-7-25 13:54 | 显示全部楼层
2 注解
在llist.h中,所用到的链表是双向链表,其节点结构定义如下。在此节点结构中,其只包含了两个指针域,一个指向直接前驱,一个指向直接后继,没有定义数据域。
  1. struct llhead {
  2. struct llhead *prev;
  3. struct llhead *next;
  4. };
 楼主| LEDyyds 发表于 2022-7-25 13:54 | 显示全部楼层
2.1 LL_INIT(N)
宏LL_INIT的定义如下,其作用是将所传入指针N的两个指针域(N)->next和(N)->prev都指向N。目的是完成单个节点的初始化工作,如下图示意了该过程。
9150962de300a2a0f3.png
  1. #define LL_INIT(N) ((N)->next = (N)->prev = (N))

 楼主| LEDyyds 发表于 2022-7-25 13:55 | 显示全部楼层
2.2 LL_HEAD(H)
宏LL_HEAD的定义如下,直接将宏LL_HEAD展开,其意图很明显是定义一个新链表H(H表示为传入宏的参数名),并且将H的两个指针域,都初始化为H地址本身,如下图示意了该过程。
8919162de302f6f415.png
  1. #define LL_HEAD(H) struct llhead H = { &H, &H }

 楼主| LEDyyds 发表于 2022-7-25 13:56 | 显示全部楼层
2.3 LL_ENTRY(P,T,N)
宏LL_ENTRY的定义如下,其依赖于宏offsetof。下面先对宏offsetof进行详细描述,其功能描述为:
C语言的offsetof()宏,是定义在stddef.h。用于求出一个struct或union数据类型的给定成员的size_t类型的字节偏移值(相对于struct或union数据类型的开头)。offsetof()宏有两个参数,分别是结构名与结构内的成员名。——维基百科
  1. #define LL_ENTRY(P,T,N) ((T *)((char *)(P) - offsetof(T, N)))

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

为了更好的理解宏offsetof,下面按照宏的定义来进行拆解说明。

((TYPE *)0):取整数零并将其强转换为指向TYPE的指针。
((TYPE *)0)->MEMBER):引用指向结构成员MEMBER。
&((TYPE *)0)->MEMBER):取出MEMBER的地址。
((size_t) &((TYPE *)0)->MEMBER):将结果转换为适当的数据类型。
由于该结构体是以0地址开头,所以最后该宏返回的结果就是该成员相对于结构体开头的偏移量。有了对宏offsetof的理解,再来看宏LL_ENTRY就比较好理解了。宏LL_ENTRY的功能是,根据结构体变量(T)中的域成员变量(N)的指针(P)来获取指向整个结构体变量的指针,下面来做拆解说明:

offsetof(T, N):计算成员N相对于其结构体T开头的偏移量。
((char *)(P):将指针P强转为字符指针类型,保证其做+/-运算时是以字节为单位。
(char *)(P) - offsetof(T, N)):P为成员N的指针,减去偏移量,指针到了结构体开头位置。
((T *)((char *)(P)- offsetof(T, N))):将指针强转,得到了整个结构体指针。
宏LL_ENTRY的作用和linux中的宏container_of作用基本一样,该宏定义如下:
  1. #define container_of(ptr, type, member) ({          \
  2.      const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
  3.      (type *)( (char *)__mptr - offsetof(type,member) );})
 楼主| LEDyyds 发表于 2022-7-25 13:57 | 显示全部楼层
2.4 LL_ADD(H, N)
宏LL_ADD的定义如下,其作用是向双向链表H的头部添加节点N。根据LL_ADD定义的语句顺序,对照着图片分析,会更加清晰。如下图,上面这张图片展示了添加节点N之前的结构,下图展示了添加节点N之后的结构。
3819562de3091a87d5.png
6429962de30976a831.png
  1. #define LL_ADD(H, N)       \
  2. do {        \
  3.   ((H)->next)->prev = (N);    \
  4.   (N)->next = ((H)->next);    \
  5.   (N)->prev = (H);     \
  6.   (H)->next = (N);     \
  7. } while (0)
 楼主| LEDyyds 发表于 2022-7-25 13:58 | 显示全部楼层
2.5 LL_TAIL(H, N)
宏LL_TAIL的定义如下,其作用是将节点N添加到双向链表H的尾部。宏LL_TAIL的定义如下,其作用是向双向链表H的头部添加节点N。根据LL_TAIL定义的语句顺序,对照着图片分析,会更加清晰。如下图,上面这张图片展示了添加节点N之前的结构,下图展示了添加节点N之后的结构,可以和LL_ADD的结果进行对照。
8972162de30e11506a.png
2634162de30e624a6e.png
  1. #define LL_TAIL(H, N)       \
  2. do {        \
  3.   ((H)->prev)->next = (N);    \
  4.   (N)->prev = ((H)->prev);    \
  5.   (N)->next = (H);     \
  6.   (H)->prev = (N);     \
  7. } while (0)
 楼主| LEDyyds 发表于 2022-7-25 14:00 | 显示全部楼层
2.6 LL_DEL(N)
宏LL_DEL的定义如下,其作用是将节点N从双向链表中删除,并且节点N回到初始状态(其指针仅指向自身,不再指向其它地方)。
  1. #define LL_DEL(N)       \
  2. do {        \
  3.   ((N)->next)->prev = ((N)->prev);   \
  4.   ((N)->prev)->next = ((N)->next);   \
  5.   LL_INIT(N);      \
  6. } while (0)
 楼主| LEDyyds 发表于 2022-7-25 14:00 | 显示全部楼层
2.7 LL_EMPTY(N)
宏LL_EMPTY的定义如下,其作用是判断链表N是否为空链表,返回布尔值false/true。如果节点的直接后继next指向其自身,就认为其为空节点。
  1. #define LL_EMPTY(N) ((N)->next == (N))
 楼主| LEDyyds 发表于 2022-7-25 14:01 | 显示全部楼层
2.8 LL_FOREACH(H,N)
宏LL_FOREACH的定义如下,其作用是在双向链表H中,循环遍历出节点。
  1. #define LL_FOREACH(H,N) for (N = (H)->next; N != (H); N = (N)->next)

 楼主| LEDyyds 发表于 2022-7-25 14:02 | 显示全部楼层
2.9 LL_FOREACH_SAFE(H,N,T)
宏LL_FOREACH_SAFE的定义如下,其作用是在双向链表H中,循环遍历出节点N,因为其有提前存储N的下一个节点T。即使N节点被清理掉,也不影响其下一个节点的遍历,所以该宏一般用来做循环清除双向链表中节点的操作,而宏LL_FOREACH仅用来遍历双向链表。
  1. #define LL_FOREACH_SAFE(H,N,T)      \
  2. for (N = (H)->next, T = (N)->next; N != (H);   \
  3.    N = (T), T = (N)->next)
 楼主| LEDyyds 发表于 2022-7-25 14:07 | 显示全部楼层
3 使用案例
有人可能会有疑惑,这个双向链表定义如此简单,只有前驱和后继两个指针,甚至连数据域都没有,那实际该如何使用呢?这个可能就是这组双向链表宏的精妙之处。其在使用过程中并不需要数据域,而是通过指针将结构体串联成双向链表,并且通过该指针借助 LL_ENTRY宏 能还原出该结构体指针,从而达到操作具体结构体的目的。

如下例子虽然不是完整能跑的程序,但是足够说明双向链表宏的关键用法。程序源码如下,现对照代码,描述双向链表宏的大致使用步骤:
  • 定义一个结构体,结构体中必须包含struct llhead link;双向链表节点,这是后续能通过遍历双向链表节点,还原出该结构体指针的关键;
  • 通过LL_HEAD(listeners);,创建一个双向链表的头为listeners;
  • 在具体逻辑中,肯定有地方通过LL_TAIL(&listeners, &l->link);或者LL_ADD(H, N),向双向链表的头listeners添加节点;
  • 在需要操作1.所定义的结构体时,通过LL_FOREACH(&listeners, lp)遍历出节点指针;
  • 这是最精华的一步,通过4.遍历出来的节点,传入宏LL_ENTRY(lp, struct listener, link);中,还原出节点所在的结构体指针,根据逻辑的需要对结构体进行具体相应的操作;
  • 通过宏LL_FOREACH_SAFE来遍历双向链表,LL_DEL来删除遍历出来的节点,达到清空链表的作用。
    1. struct llhead {
    2. struct llhead *prev;
    3. struct llhead *next;
    4. };

    5. struct listener {
    6. struct llhead link;
    7. struct shttpd_ctx *ctx;  /* Context that socket belongs */
    8. int  sock;  /* Listening socket  */
    9. int  is_ssl;  /* Should be SSL-ed  */
    10. };

    11. static LL_HEAD(listeners); /* List of listening sockets */

    12. struct listener *l;
    13. LL_TAIL(&listeners, &l->link);

    14. struct llhead *lp;
    15. LL_FOREACH(&listeners, lp) {
    16. l = LL_ENTRY(lp, struct listener, link);
    17. FD_SET(l->sock, &read_set);
    18. if (l->sock > max_fd)
    19.   max_fd = l->sock;
    20. DBG(("FD_SET(%d) (listening)", l->sock));
    21. }

    22. struct llhead  *lp, *tmp;
    23. LL_FOREACH_SAFE(&listeners, lp, tmp) {
    24. l = LL_ENTRY(lp, struct listener, link);
    25. (void) closesocket(l->sock);
    26. LL_DEL(&l->link);
    27. free(l);
    28. }

 楼主| LEDyyds 发表于 2022-7-25 14:08 | 显示全部楼层
4 总结
LL_ENTRY(P,T,N)宏是这一组宏的核心,其在具体使用中的功能可以概括为,通过传入链表节点P,还原出节点所在结构体的指针,进而能对结构体进行相应操作;
这一组双向链表宏其实形成的是一个循环双向链表;
这些宏最初是极客写出的,后来在Linux内核中被推广使用。
麻花油条 发表于 2022-7-25 14:51 来自手机 | 显示全部楼层
感谢分享,学习学习
您需要登录后才可以回帖 登录 | 注册

本版积分规则

122

主题

867

帖子

1

粉丝
快速回复 在线客服 返回列表 返回顶部