正点原子lwIP学习笔记——网络数据包管理

最新推荐文章于 2024-05-01 23:05:42 发布
最新推荐文章于 2024-05-01 23:05:42 发布
阅读量159 收藏
点赞数
分类专栏： linux学习 文章标签： 学习 笔记 stm32 网络协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xhj12138/article/details/132891824
版权

1.lwIP网络数据包简介

TCP/IP是一种数据通信机制，因此，协议栈的实现本质上就是对数据包进行处理，为了实现高效的效率，lwIP数据包管理要提供一种高效处理的机制。协议栈各层能对数据包进行灵活的处理，同时减少数据在各层间传递时的时间与空间开销，这是提高协议栈工作效率的关键点。在lwIP中它称之为pbuf。
数据传输示意图
用户的数据，经过申请pbuf，拷贝到pbuf结构的内存堆中，在应用层，数据的前面加上应用层首部，在传输层加上传输层首部，最后在网络层加上网络层首部。

pbuf用于lwIP各层间数据传递，避免各层拷贝数据！

lwIP与标准TCP/IP协议栈区别

lwIP与标准TCP/IP比较
lwIP是一种模糊分层的TCP/IP协议，大大提高数据传输效率！

2.lwIP网络数据包结构

pbuf.h中的关键结构体
这是定义在pbuf.h中的关键结构体pbuf。

通过指针next，构建出了一个数据包的单向链表；payload指向的是现在这个结构体所存储的数据区域；tot_len是所有的数据长度，包括当前pbuf和后续所有pbuf；而len就是指当前pbuf的长度；type_internal有四种类型；ref代表当前pbuf被引用的次数。

pbuf典型结构
右边展示的pbuf_layer就是用来首部地址偏移，用来对应相应的结构体。

3.lwIP网络数据包类型

四种网络数据包类型
PBUF_RAM采用内存堆，长度不定，一般都是用在传输数据；PBUF_POOL采用内存池，固定大小的内存块，所以分配速度快（一般1500字节，就是分配3个PBUF_POOL的内存池），一般用在中断服务中；PBUF_ROM和PBUF_REF都是内存池形式，而且只有pbuf没有数据区域，数据都是直接指向了内存区（PBUF_ROM指向ROM中，PBUF_REF指向RAM中）。

网络数据包的四种结构示意图
左边第一幅对应PBUF_RAM；中间两幅对应PBUF_POOL；最后一幅对应PBUF_ROM和PBUF_REF。

其中PBUF_RAM和PBUF_POOL相对更为常用。

4.lwIP网络数据包函数

lwIP网络数据包常用函数
更多的函数，都可以在pbuf.c和.h中找到。

pbuf_alloc()

pbuf_alloc的REF/ROM示意图
如果是PBUF_REF或者是PBUF_ROM，就会如上图所示，创建一个结构体指针p，然后会进入pbuf_alloc_reference；该函数中，会申请一个pbuf结构体大小的内存；然后调用pbuf_init_alloced_pbuf进行初始化，初始化可以如上图所示。

pbuf_alloc的PBUF_POOL示意图
如果是PBUF_POOL，会定义q和last两个pbuf结构体指针，q和last都初始化为NULL，rem_len（剩余长度）初始化为1500（用户指定需要构建的长度）；然后q会经过内存申请，qlen则是去rem_len和当前可申请的数据大小（PBUF_POOL_BUFSIZE_ALIGNED - LWIP_MEM_ALIGN_SIZE(offset)）取小值，然后同样经过pbuf_init_alloced_pbuf初始化q中的pbuf结构体；然后会把offset清零，就是说之后的pbuf都没有offset了，只有第一个链表的元素有offset；经过if判断并判断rem_len的大小，只要还有剩余就会回去循环继续执行上述操作，直到完成3个内存块的初始化。

pbuf_alloc的PBUF_RAM示意图
首先会计算payload_len和alloc_len，如果是传输数据，那么LWIP_MEM_ALIGN_SIZE(offset)就是54，计算得到payload_len=1554，alloc_len=1570；然后进入判断payload和alloc的长度是否<length（54），如果其中一个满足（或语句）就return NULL；pbuf的结构体p进入内存申请内存堆，然后调用pbuf_init_alloced_pbuf；该函数完成p的初始化。

该函数源码如下：

static void
pbuf_init_alloced_pbuf(struct pbuf *p, void *payload, u16_t tot_len, u16_t len, pbuf_type type, u8_t flags)
{
  p->next = NULL;
  p->payload = payload;
  p->tot_len = tot_len;
  p->len = len;
  p->type_internal = (u8_t)type;
  p->flags = flags;
  p->ref = 1;
  p->if_idx = NETIF_NO_INDEX;
}

struct pbuf *
pbuf_alloc(pbuf_layer layer, u16_t length, pbuf_type type)
{
  struct pbuf *p;
  u16_t offset = (u16_t)layer;
  LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_alloc(length=%"U16_F")\n", length));

  switch (type) {
    case PBUF_REF: /* fall through */
    case PBUF_ROM:
      p = pbuf_alloc_reference(NULL, length, type);
      break;
    case PBUF_POOL: {
      struct pbuf *q, *last;
      u16_t rem_len; /* remaining length */
      p = NULL;
      last = NULL;
      rem_len = length;
      do {
        u16_t qlen;
        q = (struct pbuf *)memp_malloc(MEMP_PBUF_POOL);
        if (q == NULL) {
          PBUF_POOL_IS_EMPTY();
          /* free chain so far allocated */
          if (p) {
            pbuf_free(p);
          }
          /* bail out unsuccessfully */
          return NULL;
        }
        qlen = LWIP_MIN(rem_len, (u16_t)(PBUF_POOL_BUFSIZE_ALIGNED - LWIP_MEM_ALIGN_SIZE(offset)));
        pbuf_init_alloced_pbuf(q, LWIP_MEM_ALIGN((void *)((u8_t *)q + SIZEOF_STRUCT_PBUF + offset)),
                               rem_len, qlen, type, 0);
        LWIP_ASSERT("pbuf_alloc: pbuf q->payload properly aligned",
                    ((mem_ptr_t)q->payload % MEM_ALIGNMENT) == 0);
        LWIP_ASSERT("PBUF_POOL_BUFSIZE must be bigger than MEM_ALIGNMENT",
                    (PBUF_POOL_BUFSIZE_ALIGNED - LWIP_MEM_ALIGN_SIZE(offset)) > 0 );
        if (p == NULL) {
          /* allocated head of pbuf chain (into p) */
          p = q;
        } else {
          /* make previous pbuf point to this pbuf */
          last->next = q;
        }
        last = q;
        rem_len = (u16_t)(rem_len - qlen);
        offset = 0;
      } while (rem_len > 0);
      break;
    }
    case PBUF_RAM: {
      mem_size_t payload_len = (mem_size_t)(LWIP_MEM_ALIGN_SIZE(offset) + LWIP_MEM_ALIGN_SIZE(length));
      mem_size_t alloc_len = (mem_size_t)(LWIP_MEM_ALIGN_SIZE(SIZEOF_STRUCT_PBUF) + payload_len);

      /* bug #50040: Check for integer overflow when calculating alloc_len */
      if ((payload_len < LWIP_MEM_ALIGN_SIZE(length)) ||
          (alloc_len < LWIP_MEM_ALIGN_SIZE(length))) {
        return NULL;
      }

      /* If pbuf is to be allocated in RAM, allocate memory for it. */
      p = (struct pbuf *)mem_malloc(alloc_len);
      if (p == NULL) {
        return NULL;
      }
      pbuf_init_alloced_pbuf(p, LWIP_MEM_ALIGN((void *)((u8_t *)p + SIZEOF_STRUCT_PBUF + offset)),
                             length, length, type, 0);
      LWIP_ASSERT("pbuf_alloc: pbuf->payload properly aligned",
                  ((mem_ptr_t)p->payload % MEM_ALIGNMENT) == 0);
      break;
    }
    default:
      LWIP_ASSERT("pbuf_alloc: erroneous type", 0);
      return NULL;
  }
  LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_alloc(length=%"U16_F") == %p\n", length, (void *)p));
  return p;
}

pbuf_free()

进入判断p是否为空，不为空证明还没有释放；进入while语句，每一次都–ref（引用次数）；然后类似链表删除，调用相应的pbuf类型的内存释放（内存堆或者内存池），直到p全部被释放。源码如下：

u8_t
pbuf_free(struct pbuf *p)
{
  u8_t alloc_src;
  struct pbuf *q;
  u8_t count;

  if (p == NULL) {
    LWIP_ASSERT("p != NULL", p != NULL);
    /* if assertions are disabled, proceed with debug output */
    LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
                ("pbuf_free(p == NULL) was called.\n"));
    return 0;
  }
  LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_free(%p)\n", (void *)p));

  PERF_START;

  count = 0;
  /* de-allocate all consecutive pbufs from the head of the chain that
   * obtain a zero reference count after decrementing*/
  while (p != NULL) {
    LWIP_PBUF_REF_T ref;
    SYS_ARCH_DECL_PROTECT(old_level);
    /* Since decrementing ref cannot be guaranteed to be a single machine operation
     * we must protect it. We put the new ref into a local variable to prevent
     * further protection. */
    SYS_ARCH_PROTECT(old_level);
    /* all pbufs in a chain are referenced at least once */
    LWIP_ASSERT("pbuf_free: p->ref > 0", p->ref > 0);
    /* decrease reference count (number of pointers to pbuf) */
    ref = --(p->ref);
    SYS_ARCH_UNPROTECT(old_level);
    /* this pbuf is no longer referenced to? */
    if (ref == 0) {
      /* remember next pbuf in chain for next iteration */
      q = p->next;
      LWIP_DEBUGF( PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_free: deallocating %p\n", (void *)p));
      alloc_src = pbuf_get_allocsrc(p);
#if LWIP_SUPPORT_CUSTOM_PBUF
      /* is this a custom pbuf? */
      if ((p->flags & PBUF_FLAG_IS_CUSTOM) != 0) {
        struct pbuf_custom *pc = (struct pbuf_custom *)p;
        LWIP_ASSERT("pc->custom_free_function != NULL", pc->custom_free_function != NULL);
        pc->custom_free_function(p);
      } else
#endif /* LWIP_SUPPORT_CUSTOM_PBUF */
      {
        /* is this a pbuf from the pool? */
        if (alloc_src == PBUF_TYPE_ALLOC_SRC_MASK_STD_MEMP_PBUF_POOL) {
          memp_free(MEMP_PBUF_POOL, p);
          /* is this a ROM or RAM referencing pbuf? */
        } else if (alloc_src == PBUF_TYPE_ALLOC_SRC_MASK_STD_MEMP_PBUF) {
          memp_free(MEMP_PBUF, p);
          /* type == PBUF_RAM */
        } else if (alloc_src == PBUF_TYPE_ALLOC_SRC_MASK_STD_HEAP) {
          mem_free(p);
        } else {
          /* @todo: support freeing other types */
          LWIP_ASSERT("invalid pbuf type", 0);
        }
      }
      count++;
      /* proceed to next pbuf */
      p = q;
      /* p->ref > 0, this pbuf is still referenced to */
      /* (and so the remaining pbufs in chain as well) */
    } else {
      LWIP_DEBUGF( PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_free: %p has ref %"U16_F", ending here.\n", (void *)p, (u16_t)ref));
      /* stop walking through the chain */
      p = NULL;
    }
  }
  PERF_STOP("pbuf_free");
  /* return number of de-allocated pbufs */
  return count;
}

pbuf_header()

这个就要看你使用的是什么类型，然后会根据类型来决定payload_len的大小，进行相应的payload指针指向数据区前的首部字段。

总结

这一章主要讲述了lwIP中重要的pbuf缓冲，具体有哪些数据构成，为之后的学习奠定基础，确定了pbuf除了所需传输的数据，还有哪些变量需要添加，如何申请对应的pbuf内存大小，以及对应的内存堆和内存池。

努力自学的小夏
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
正点原子阿波罗V2 Lwip例程与手册
03-15
【正点原子阿波罗V2 Lwip例程与手册】是一份专注于STM32F429微控制器上LwIP网络协议栈应用的综合资料，旨在帮助开发者理解和实践LwIP在嵌入式系统中的实际运用。LwIP（Lightweight IP）是一个轻量级的TCP/IP协议栈，...
正点原子阿波罗F429+STM32CubeMX+LAN8720+LWIP+Freetos:带操作系统实现网络热插拔
12-31
在本文中，我们将深入探讨如何使用正点原子阿波罗F429微控制器，结合STM32CubeMX配置工具、LAN8720以太网接口芯片、LWIP轻型网络协议栈以及FreetOS实时操作系统，来实现网络连接的热插拔功能。这些技术在现代嵌入式...
TCP/IP协议栈之LwIP-pbuf
孙兴兴的博客
01-04 4272
一、介绍 lwIP - A Lightweight TCP/IP stack The focus of the lwIP TCP/IP implementation is to reduce resource usage while still having a full scale TCP. This makes lwIP suitable for use in embedded systems with tens of kilobytes of free RAM and room for around
LwIP系列--数据包处理和PBUF结构详解
coderma的博客
01-31 4393
LwIP pbuf详解
LWIP中“pbuf_free: p-＞ref ＞ 0“ failed 问题分析
mianba_98的博客
05-01 780
但如果删除某个pbuf链表的首节点时，链表中第二个节点的pbuf中ref字段不为0，则表示该节点还在其他地方被引用，那么第二个节点不与第一个节点存储同一个数据包，那么就不会删除第二个节点。(4)：获取当前pbuf的类型，根据不一样的类型进行不一样的释放操作，如果是从内存池中申请的pbuf，则调用memp_free()函数进行释放，如PBUF_POOL、PBUF_ROM和PBUF_REF类型的pbuf，如果是从内存堆中申请的，就调用mem_free()函数进行释放内存，如PBUF_RAM类型的pbuf。
Lwip pbuf分析
自由的天空
04-18 5562
在BSD中用mbuf结构体来管理网络上来的各种数据包，同样lwip中也有一个类似的结构体pbuf用来管理数据包。Pbuf结构体定义如下： structpbuf{ structpbuf *next; ...
lwip协议栈源码分析之pbuf
杀手的博客
12-13 5056
文章目录一，数据在tcp/ip层中的传递二，认识pbuf结构体二，创建一个pbuf三，释放pbuf四，给pbuf链表减肥五，移动payload六，小结 lwip使用pbuf对数据进行发送与接收，灵活的pbuf结构体使得数据在不同网络层之间传输时可以减少内存的开销，内存复制所占用的时间，一切都是为了节约内存，增加数据在不同层之间传递的速度。 一，数据在tcp/ip层中的传递 数据如何从tcp层一层层传递到最底层的物理层并发送出去呢？ 应用层需要发送的数据传递到tcp层时，tcp层给数据添加首部数据，tcp
LwIP从入门到放弃之（三）---数据包管理
rgxiwei的博客
03-12 994
LwIP从入门到放弃之—数据包管理（三） 我一开始看LwIP协议栈的时候，发现pbuf这个数据类型出现的非常频繁，我就感觉这个数据类型肯定不一般。现在终于知道，pbuf是描述和管理数据包的结构，在整个协议栈中是非常重要的部分。其实，协议栈的本质就是各层对数据包的处理。在数据链路层，判断数据包的类型、提取数据包的数据字段、记录物理地址信息；IP层根据数据包中的IP地址进行数据存储、转发；TCP使用数据包中的信息更新TCP状态机，并向应用层提交程序等等。上述所有操作过程都与数据包操作密切相关。 数据包结构
LwIP之pbuf
wjjontheway的专栏
06-14 1545
pbuf的结构 |            next       |            指向链表上的下一个pbuf       |         payload    |            指向pbuf管理的数据的起始地址，可以是紧跟在pbuf后的RAM，也可以是ROM上的某个地址，取决于pbuf是什么类型 |             len        |
LwIP编程指南LwIP协议详解lwip学习笔记IP+LWIP移植实现等相关资料12个合集.zip
最新发布
05-19
LwIP编程指南LwIP协议详解lwip学习笔记IP+LWIP移植实现等相关资料12个合集： IP+LWIP移植实现.pdf Lwip.doc LWIP中文.pdf LwIP协议栈源码详解.pdf LwIP协议栈的设计与实现_中文译稿.pdf LwIP协议详解.pdf lwip学习...
正点原子例程，lwip+stm32f407
09-08
标题中的“正点原子例程，lwip+stm32f407”是指一个基于STM32F407微控制器的嵌入式开发项目，其中整合了lwIP网络协议栈。STM32F407是意法半导体公司（STMicroelectronics）生产的一款高性能ARM Cortex-M4内核的微...
lwip学习资料及部分源码 - 正点原子
05-15
通过这套正点原子提供的学习资料，无论是初学者还是有经验的开发者，都能从中受益，提升自己在lwIP和嵌入式网络开发领域的技能。记得在学习过程中结合实际操作，理论与实践相结合，才能更好地理解和掌握lwIP的强大...
p-＞ref ＞ 0
qq_44819943的博客
11-11 2572
配置： 单片机：stm32h743VIT6 有线网卡：lan8720 操作系统：r-thread 协议栈：lwip bug： pbuf_free: p->ref > 0 Assertion: 747 in …\components\net\lwip-2.0.2\src\core\pbuf.c, thread tcpip 问题描述： 当调试的时候，中途断点的停顿时间超20s，就会触发以上bug。 参考资料： lwip应用开发指南 问题定位+解决方法： **问题定位：**pbuf_free函数释放p
lwip之数据包管理
coder
01-05 1865
数据包结构 /***************************************************************************************************************** struct pbuf {     struct pbuf *next;    // 指向下一个pbuf结构     void *payload  
11.物联网lwip，网卡原理
m0_61659911的博客
08-30 1388
pbuf层--》选此类型是对不同报文的区分，比如PBUF_TRANSPORT传输层数据，PBUF_IP网络层数据，PBUF_LINK链路层数据，PBUF_RAW_TX物理层数据。//消息邮箱(freeRTOS是通过消息队列实现)，任务与任务间消息通信，网卡收到数据，网络分层解析，我们的任务怎么知道呢，就是通过消息邮箱进行传输。底层网卡的数据接口，当接收到网卡数据后，会通过此函数，封装为pbuf提供上层使用。这可以是来自应用程序的指针，底层网卡的数据输出，实际的数据输出，是通过pbuf进行封装管理的。
lwip---（二）数据包pbuf
陈言陈语的小陈
01-08 805
  总结一下，LWIP中常用到的内存分配策略有两种，一种是内存堆分配，一种是内存池分配。前者可以说能随心所欲的分配我们需要的合理大小的内存块，缺点是当经过多次的分配释放后，内存堆中间会出现很多碎片，使得需要分配较大内存块时分配失败；后者分配速度快，就是简单的链表操作，因为各种类型的POOL是我们事先建立好的，但是采用POOL会有些情况下会浪费掉一定的内存空间。在LWIP中，将这两种分配策略混合使用，达到了很好的内存使用效率。   下面我们将来看看LWIP中是怎样合理利用这两种分配策略的。这就顺利的过渡到了这
pbuf类型和应用
优先级4.0
05-23 740
下面的讨论仅限于RAW API。 按存储方式分类 1. PBUF_RAM 从一般性的Heap中分配。可用空间大小受MEM_SIZE宏控制。可看作一般意义上的动态内存。 用途： a) 将应用层中的待发送数据复制下来（当使用拷贝发送时） b) 构造请求类的数据包（ARP，DHCP，DNS，etc） c) 当发送零拷贝数据时，需要额外的pbuf用于下层协议的协议头 2. PBUF_POOL 驱动使用这种类型的PBUF接收网卡数据包。其数量和大小受PBUF_POOL_SIZE和PBUF_POOL_BUFS
Lwip-网络数据包
Garrix的博客
10-25 1907
LwIP数据包管理提供一种高效处理的机制。协议栈各层能对数据包进行灵活的处理，同时减少数据在各层间传递时的时间与空间开销，这是提高协议栈工作效率的关键点。什么是数据包？数据包的种类可谓是五花八门，就比如网卡上的接收到的数据，它可以是一个一千多字节的数据包，也可以是几十个字节的ARP数据包，还有用户的数据，这些数据可能存在RAM、ROM上，重点是这些数据大小不一，可以是几个字节，也看是上千个字节，并且LwIP各层在数据处理的时候极力避免进行数据的拷贝，所以就对数据进行统一的管理，使得处理效率更加高效。
lwip——select
09-14
`lwip_select()` 是 Lightweight IP（LwIP）网络堆栈中的一个函数，它用于在一组文件描述符中选择就绪的套接字。 在LwIP中，套接字是通过文件描述符（fd）来表示的，`lwip_select()` 函数可以通过监视一组文件描述符，找出其中哪些套接字已经准备好进行读取、写

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值