一、数据包管理 TCP/IP 是一种数据通信机制，因此，协议栈的实现本质上就是对数据包进行处理。 链路层、IP层和TCP层都需要对数据包进解析，并获取响应的数据，数据包在TCP/IP协议栈中是非常重要的部分，数据包管理需要提供一种高效的机制，使协议栈各层能对数据包进行灵活的处理，同时减少数据在各层间传递时的时间与空间开销，这是提高协议栈工作效率的关键点。 在 LwIP 中的描述和管理数据包的结构叫做 pbuf，本文主要分析数据包管理结构pbuf和所有的数据包相关操作函数。 1.1、数据包结构pbuf在 LwIP 中，数据包管理机制采用数据结构pbuf来描述协议栈中使用的数据包，文件 pbuf.h和 pbuf.c 中实现了协议栈数据包管理相关的所有数据结构和函数。结构 pbuf 的定义如下： ---------pbuf.h--------------------------------------------------------------------- struct pbuf { /** next pbuf insingly linked pbuf chain */ struct pbuf*next; //构成pbuf 链表时指向下一个 pbuf 结构 /** pointer tothe actual data in the buffer */ void *payload; //数据指针，指向该 pbuf 所记录的数据区域 /** * total lengthof this buffer and all next buffers in chain * belonging tothe same packet. * * For non-queuepacket chains this is the invariant: * p->tot_len== p->len + (p->next? p->next->tot_len: 0) */ u16_t tot_len; //当前 pbuf 及其后续所有 pbuf 中包含的数据总长度 /** length ofthis buffer */ u16_t len; //当前 pbuf 的数据的长度 /** pbuf_type asu8_t instead of enum to save space */ u8_t type; //当前 pbuf 的类型 /** misc flags */ u8_t flags; //状态位，未用到 /** * the referencecount always equals the number of pointers * that refer tothis pbuf. This can be pointers from an application, * the stackitself, or pbuf->next pointers from a chain. */ u16_t ref; //指向该pbuf 的指针数，即该 pbuf 被引用的次数 }; pbuf结构体采用链表的数据结构，新的pbuf数据可直接插入到原pbuf的next字段，下面对pbuf结构体的程序进行解析： 1、 next指针是指向下一个pbuf结构，因实际发送/接收的数据包可能很大，但每个pbuf可管理的数据空间有限，所以存在多个pbuf才能描述完一个数据包的情况，采用pbuf链表的数据结构可保证多个pbuf之间存在关联，只需要知道第一个pbuf的地址即可遍历出所有的pbuf； 2、 payload是数据指针，指向pbuf管理的数据起始地址，也就是指向了pbuf结构中ref变量后的地址； 3、 len表示当前pbuf中有效数据的字节数； 4、 tot_len表示当前pbuf和其后所有pbuf的有效数据和，即表示当前pbuf的有效数据长度+pbuf链表下一个pbuf的有效数据长度+…+最后一个pbuf的有效数据长度； 5、 type表示pbuf的类型，pbuf的类型有四种，后面会讲述四种类型的特点； 6、 ref表示该pbuf被应用的次数，初始化pbuf时，该值为1，当其他指针指向该pbuf时，ref的值自增。 1.2、pbuf的类型 pbuf有4类：PBUF_RAM、PBUF_ROM、PBUF_REF、PBUF_POOL系统中使用了一个专门的枚举类型 pbuf_type 来描述它们： typedef enum { PBUF_RAM, /* pbufdata is stored in RAM */ PBUF_ROM, /* pbufdata is stored in ROM */ PBUF_REF, /* pbufcomes from the pbuf pool */ PBUF_POOL /* pbufpayload refers to RAM */ } pbuf_type; PBUF_RAM 类型的 pbuf 空间是通过内存堆分配得到的。这种类型的 pbuf 在协议栈中是使用得最多的，协议栈的待发送数据和应用程序的待发送数据一般都采用这个形式。申请 PBUF_RAM类型 pbuf 时，协议栈会在内存堆中分配相应空间。 下面来看看源代码是怎样申请PBUF_RAM 型的，具体流程参考后面的函数讲解。 p = (struct pbuf*)mem_malloc(LWIP_MEM_ALIGN_SIZE(SIZEOF_STRUCT_PBUF+ offset) + LWIP_MEM_ALIGN_SIZE(length)); 分配成功的 PBUF_RAM 类型 pbuf 如图 1 所示。 file:///C:/temp/msohtmlclip1/01/clip_image001.png 从图1中可看出 pbuf 结构和相应数据在一片连续的内存区域中，注意 payload 并没有指向整个数据区的起始处，而是间隔了一定区域。这段区域就是上面的 offset，它通常用来存储数据包的各种首部字段，如 TCP 报文首部、IP 首部、以太网帧首部等。 PBUF_POOL 类型和 PBUF_RAM 类型的 pbuf 有很大的相似之处，但它的空间是通过内存池分配得到的。这种类型的 pbuf 可以在极短的时间内得到分配（得益于内存池的优点），在网卡接收数据包时，我们就使用了这种方式包装数据。在申请 PBUF_POOL 类型 pbuf 时，协议栈会在内存池 MEMP_PBUF_POOL 中选择一个或多个POOL，以满足用户空间大小的申请。源代码是通过下面一条语句来完成 POOL 申请的，其中 p 是pbuf 型指针。 p = memp_malloc(MEMP_PBUF_POOL); 通常，用户发送的数据可能很长，所以系统会多次调用上面的语句，为用户分配多个 POOL，并把它们按照 pbuf 链表的形式组织在一起，以保证用户的空间请求要求。分配成功的 PBUF_POOL 类型 pbuf 示意如图 72所示。 file:///C:/temp/msohtmlclip1/01/clip_image002.png PBUF_ROM 和 PBUF_REF 类型的 pbuf 基本相同，它们的申请都是在内存池中分配一个相应的 pbuf结构（即 MEMP_PBUF 类型的 POOL），而不申请数据区的空间 在发送某些静态数据时，可以采用这两种类型的 pbuf，这将大大节省协议栈的内存空间。下面来看看源代码是怎样申请 PBUF_ROM 和PBUF_REF 类型的，其中 p 是 pbuf 型指针。 file:///C:/temp/msohtmlclip1/01/clip_image003.png 对于同一个数据包，他可能使用上述任意的pbuf类型描述，也可能是多个不同类型pbuf连在一起保存一个数据包的数据，如下图两种类型的pbuf组成的pbuf链表情况： file:///C:/temp/msohtmlclip1/01/clip_image004.png 二、数据包相关函数解析2.1、数据包申请函数 数据包申请函数有两个重要的参数，一是数据包 pbuf 类型，另一个是该数据包是在协议栈中哪一层被申请的，分配函数会根据这个层次的不同，在 pbuf 数据区域前为相应的协议预留出首部空间，这就是前面所说的 offset 值了。总的来说，LwIP 定义了四个层次，当数据包申请时，所处的层次不同，会导致预留空间的 offset值不同。层次的定义是通过一个枚举类型 pbuf_layer 来实现的，如下代码所示： #define PBUF_TRANSPORT_HLEN 20 //TCP 报文首部长度 #define PBUF_IP_HLEN 20 //IP 数据报首部长度 typedef enum
{ PBUF_TRANSPORT, //传输层 PBUF_IP, //网络层 PBUF_LINK, //链路层 PBUF_RAW //原始层，不预留任何空间 } pbuf_layer; PBUF_TRANSPORT_HLEN和 PBUF_IP_HLEN，前者是典型的 TCP 报文首部长度，而后者是典型的不带任何选项字段的 IP 首部长度 //参数 layer，指定该pbuf 数据所处的层次，分配函数根据该值在 pbuf 数据//区预留出首部空间；length 表示需要申请的数据区长度，type 指出需要申请//的pbuf 类型 structpbuf * pbuf_alloc(pbuf_layer layer, u16_t length, pbuf_type type) { struct pbuf *p, *q, *r; //定义了几个局部pbuf指针，在链表封装时使用 u16_t offset; //标记首部预留的空间长度，即pbuf头到payload 指向的地址间的空间 s32_t rem_len; //还需要申请的数据空间长度 LWIP_DEBUGF(PBUF_DEBUG |LWIP_DBG_TRACE, ("pbuf_alloc(length=%"U16_F")\n", length));//打印信息 /* determine header offset */ switch (layer) { //根据层次的不同，计算预留长度 case PBUF_TRANSPORT: //在传输层，预留出TCP首部大小 /* add room for transport (often TCP) layerheader */ offset = PBUF_LINK_HLEN+ PBUF_IP_HLEN + PBUF_TRANSPORT_HLEN;//计算首部大小 break; case PBUF_IP: //在网络层或传输层，预留出IP首部的大小 /* add room for IP layer header*/ offset = PBUF_LINK_HLEN +PBUF_IP_HLEN; //计算IP首部大小 break; case PBUF_LINK: //在链路层或以上层，需要留出链路层首部大小 /* add room for link layerheader */ offset = PBUF_LINK_HLEN; //以太网头部大小，即14字节 break; case PBUF_RAW: //为原始层，不预留空间（常用于数据包接收） offset = 0; break; default: LWIP_ASSERT("pbuf_alloc:bad pbuf layer", 0); return NULL; } switch (type) { case PBUF_POOL: //PBUF_POOL类型，可能需分配多个POOL /* allocate head of pbuf chaininto p */ p = (struct pbuf*)memp_malloc(MEMP_PBUF_POOL); //分配第一个POOL LWIP_DEBUGF(PBUF_DEBUG |LWIP_DBG_TRACE, ("pbuf_alloc: allocated pbuf %p\n", (void *)p)); //打印信息 if (p == NULL) { //说明POOL没有多余空间申请 PBUF_POOL_IS_EMPTY(); return NULL; } p->type = type; //初始化pbuf的type和next字段 p->next = NULL; /* make the payload pointerpoint 'offset' bytes into pbuf data memory */ p->payload = LWIP_MEM_ALIGN((void*)((u8_t *)p + (SIZEOF_STRUCT_PBUF + offset))); //初始化payload，指向数据段的起始地址，预留头部空间offset LWIP_ASSERT("pbuf_alloc:pbuf p->payload properly aligned", ((mem_ptr_t)p->payload % MEM_ALIGNMENT) == 0); //打印信息 /* the total length of the pbufchain is the requested size */ p->tot_len = length; //初始化总长度字段 /* set the length of the firstpbuf in the chain */ p->len = LWIP_MIN(length,PBUF_POOL_BUFSIZE_ALIGNED - LWIP_MEM_ALIGN_SIZE(offset));//设置len字段，若当前POOL能放下所有数据，则len的值为length，否则len为实际数据区的长度 LWIP_ASSERT("checkp->payload + p->len does not overflow pbuf", ((u8_t*)p->payload + p->len <= (u8_t*)p +SIZEOF_STRUCT_PBUF + PBUF_POOL_BUFSIZE_ALIGNED)); LWIP_ASSERT("PBUF_POOL_BUFSIZE must be bigger thanMEM_ALIGNMENT", (PBUF_POOL_BUFSIZE_ALIGNED -LWIP_MEM_ALIGN_SIZE(offset)) > 0 ); /* set reference count (neededhere in case we fail) */ p->ref = 1; //ref设置为1 /* now allocate the tail of thepbuf chain */ /* remember first pbuf forlinkage in next iteration */ r = p; //检测已经分配的POOL是否能满足用户长度要求，不能则继续分配 /* remaining length to beallocated */ rem_len = length - p->len; //计算还需要申请的长度 /* any remaining pbufs to beallocated? */ while (rem_len > 0) { //遍历分配剩余的长度空间 q = (struct pbuf*)memp_malloc(MEMP_PBUF_POOL); if (q == NULL) { //若分配失败，则释放链表p上的所有POOL PBUF_POOL_IS_EMPTY(); //标记POOL已经分配完 /* free chain so farallocated */ pbuf_free(p); //释放p /* bail out unsuccesfully */ return NULL; } //分配成功后初始化q的所有字段，并接q连接到p上 q->type = type; q->flags = 0; q->next = NULL; /* make previous pbuf point tothis pbuf */ r->next = q; //q连接大p的尾部 /* set total length of thispbuf and next in chain */ LWIP_ASSERT("rem_len <max_u16_t", rem_len < 0xffff); q->tot_len =(u16_t)rem_len; /* this pbuf length is poolsize, unless smaller sized tail */ q->len =LWIP_MIN((u16_t)rem_len, PBUF_POOL_BUFSIZE_ALIGNED); q->payload = (void *)((u8_t*)q + SIZEOF_STRUCT_PBUF); LWIP_ASSERT("pbuf_alloc:pbuf q->payload properly aligned", ((mem_ptr_t)q->payload % MEM_ALIGNMENT) == 0); LWIP_ASSERT("checkp->payload + p->len does not overflow pbuf", ((u8_t*)p->payload + p->len <= (u8_t*)p +SIZEOF_STRUCT_PBUF + PBUF_POOL_BUFSIZE_ALIGNED)); q->ref = 1; /* calculate remaining lengthto be allocated */ rem_len -= q->len; //更新还需要申请的长度 /* remember this pbuf forlinkage in next iteration */ r = q; //r指向链表p的最后一个pbuf，即为q } break; //PBUF_POOL类型的pbuf申请完成 case PBUF_RAM: //直接在内存堆中申请 /* If pbuf is to be allocated inRAM, allocate memory for it. */ p = (structpbuf*)mem_malloc(LWIP_MEM_ALIGN_SIZE(SIZEOF_STRUCT_PBUF + offset) +LWIP_MEM_ALIGN_SIZE(length)); if (p == NULL) { //申请失败，不需要释放 return NULL; } /* Set up internalstructure of the pbuf. */ //申请成功后，初始化pbuf的各个字段 p->payload =LWIP_MEM_ALIGN((void *)((u8_t *)p + SIZEOF_STRUCT_PBUF + offset)); p->len = p->tot_len =length; p->next = NULL; p->type = type; LWIP_ASSERT("pbuf_alloc:pbuf->payload properly aligned", ((mem_ptr_t)p->payload% MEM_ALIGNMENT) == 0); break; //pbuf申请完毕 /* pbuf references existing(non-volatile static constant) ROM payload? */ case PBUF_ROM: //PBUF_ROM和PBUF_REF类型的pbuf，只分配pbuf结构 /* pbuf references existing(externally allocated) RAM payload? */ case PBUF_REF: //不分配数据的空间，也不分配预留的首部空间 /* only allocate memory for thepbuf structure */ p = (struct pbuf*)memp_malloc(MEMP_PBUF); if (p == NULL) { //分配失败后，直接返回 LWIP_DEBUGF(PBUF_DEBUG |LWIP_DBG_LEVEL_SERIOUS, ("pbuf_alloc:Could not allocate MEMP_PBUF for PBUF_%s.\n", (type == PBUF_ROM)? "ROM" : "REF")); return NULL; } /* caller must set this fieldproperly, afterwards */ //分配成功后初始化p，payload需要根据实际数据位置来设置 p->payload = NULL; p->len = p->tot_len =length; p->next = NULL; p->type = type; break; //pbuf分配完毕 default: LWIP_ASSERT("pbuf_alloc:erroneous type", 0); return NULL; } /* set reference count */ //到这一步，说明pbuf申请成功，设置剩余的字段，并返回pbuf指针 p->ref = 1; /* set flags */ p->flags = 0; LWIP_DEBUGF(PBUF_DEBUG |LWIP_DBG_TRACE, ("pbuf_alloc(length=%"U16_F") == %p\n",length, (void *)p)); return p; } 在这个函数中，申请一个 PBUF_POOL 类型的 pbuf比较麻烦，可能存在需要申请多次的情况。 p =pbuf_alloc(PBUF_TRANSPORT, optlen, PBUF_POOL) 这个语句申请了一个 PBUF_POOL 类型的 pbuf，且其申请的协议层为 PBUF_RAW，所以pbuf_alloc 函数不会在数据区前预留出任何首部空间；通过使用 p>payload，就可以实现对 pbuf 中数据区的读取或写入操作了。 在 TCP 层要申请一个数据包时，常常调用下面的语句： p =pbuf_alloc(PBUF_TRANSPORT, optlen, PBUF_RAM) 它告诉数据包分配函数，使用 PBUF_RAM 类型的 pbuf，且数据区前应该预留一部分的首部空间，由于这里是 PBUF_TRANSPORT 层，所以预留空间将有 54 字节，即 TCP 首部长度PBUF_TRANSPORT_HLEN（20 字节）、IP 数据包首部长度 PBUF_IP_HLEN（20 字节）以及以太网帧首部长度（14 字节）。当数据包往下层递交，各层协议就可以直接操作这些预留空间中的数据，以实现数据包首部的填写，这样就避免了数据的拷贝。 2.2、数据包释放函数 假如现在我们的 pbuf 链表由 A，B，C 三个 pbuf 结构连接起来，结构为 A>B>C，利用 pbuf_free(A)函数来删除 pbuf 结构，下面用 ABC 的几组不同 ref值来看看删除结果： （1）1>2>3 函数执行后变为 ...1>3，节点 BC 仍在；
（2）3>3>3 函数执行后变为 2>3>3，节点 ABC 仍在；
（3）1>1>2 函数执行后变为......1，节点 C 仍在；
（4）2>1>1 函数执行后变为 1>1>1，节点 ABC 仍在；
（5）1>1>1 函数执行后变为.......，节点全部被删除。
假如在上面的第（4）种情况下，错误的调用数据包释放函数，如 pbuf_free(B)，这会导致严重的错误。 //函数的返回值为成功删除的 pbuf 个数 u8_t pbuf_free(structpbuf *p) { u16_t type; struct pbuf *q; //定义一个pbuf的指针 u8_t count; if (p == NULL) { //若pbuf为0，直接返回 LWIP_ASSERT("p != NULL", p !=NULL); /* if assertions are disabled, proceed withdebug output */ LWIP_DEBUGF(PBUF_DEBUG |LWIP_DBG_LEVEL_SERIOUS, ("pbuf_free(p == NULL) wascalled.\n")); return 0; } LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_free(%p)\n",(void *)p)); PERF_START; LWIP_ASSERT("pbuf_free: sane type", p->type == PBUF_RAM || p->type ==PBUF_ROM || p->type == PBUF_REF || p->type ==PBUF_POOL); count = 0; //记录值清0 /* de-allocate all consecutive pbufs from thehead of the chain that * obtain a zero reference count afterdecrementing*/ while (p != NULL) { //直到pbuf释放完毕 u16_t ref; SYS_ARCH_DECL_PROTECT(old_level); //申请临界区保护变量 /* Since decrementing ref cannot beguaranteed to be a single machine operation * we must protect it. We put the new refinto a local variable to prevent * further protection. */ SYS_ARCH_PROTECT(old_level); //进入临界区 /* all pbufs in a chain are referenced atleast once */ LWIP_ASSERT("pbuf_free: p->ref >0", p->ref > 0); /* decrease reference count (number ofpointers to pbuf) */ ref = --(p->ref); //该pbuf引用次数减1，并记录 SYS_ARCH_UNPROTECT(old_level); //退出临界保护区 /* this pbuf is no longer referenced to? */ if (ref == 0) { //若pbuf被引用的次数为0，则删除该pbuf /* remember next pbuf in chain for nextiteration */ q = p->next; //q记录链表中的下一个pbuf LWIP_DEBUGF( PBUF_DEBUG | LWIP_DBG_TRACE,("pbuf_free: deallocating %p\n", (void *)p)); type = p->type; //判断要删除的pbuf类型 #ifLWIP_SUPPORT_CUSTOM_PBUF /* is this a custom pbuf? */ if ((p->flags& PBUF_FLAG_IS_CUSTOM) != 0) { //调用用户自己的函数申请的pbuf structpbuf_custom *pc = (struct pbuf_custom*)p; LWIP_ASSERT("pc->custom_free_function!= NULL", pc->custom_free_function != NULL); pc->custom_free_function(p); //调用用户自己的释放函数，释放pbuf } else #endif /*LWIP_SUPPORT_CUSTOM_PBUF */ { /* is this a pbuf from the pool? */ if (type == PBUF_POOL) { //不同类型调用不同的内存管理删除函数 memp_free(MEMP_PBUF_POOL, p); /* is this a ROM or RAM referencingpbuf? */ } else if (type == PBUF_ROM || type ==PBUF_REF) { memp_free(MEMP_PBUF, p); /* type == PBUF_RAM */ } else { mem_free(p); } } count++; //删除记录值加1 /* proceed to next pbuf */ p = q; //处理下一个pbuf } else { LWIP_DEBUGF( PBUF_DEBUG | LWIP_DBG_TRACE,("pbuf_free: %p has ref %"U16_F", ending here.\n", (void*)p, ref)); /* stop walking through the chain */ p = NULL; //p设置为NULL，程序退出while } } PERF_STOP("pbuf_free"); /* return number of de-allocated pbufs */ return count; //返回成功删除的pbuf个数 } 当可以删除某个pbuf结构时，函数pbuf_free首先检查这个 pbuf是属于四个类型中的哪种，根据类型的不同， 调用不同的内存释放函数进行删除。 5、其他数据包操作函数 pbuf_realloc 函数在相应 pbuf（链表）尾部释放一定的空间，将数据包 pbuf 中的数据长度减少为某个长度值。对于 PBUF_RAM 类型的 pbuf，函数将调用内存堆管理中介绍到的 mem_realloc 函数，释放这些多余的空间；对于其他三种类型的 pbuf，该函数只是修改 pbuf 中的长度字段值，并不释放对应的内存池空间。 pbuf_header 函数用于调整 pbuf 的 payload 指针（向前或向后移动一定的字节数），在前面也说到过了，在 pbuf 的数据区前可能会预留一些协议首部空间，而 pbuf 被创建时，payload 指针是指向数据区的，为了实现对这些预留空间的操作，可以调用函数 pbuf_header 使 payload 指针指向数据区前的首部字段，这就为各层对数据包首部的操作提供了方便。当然，进行这个操作的时候，len和 tot_len 字段值也会随之更新。 pbuf_take 函数用于向 pbuf 的数据区域拷贝数据；pbuf_copy 函数用于将一个任何类型的 pbuf中的数据拷贝到一个 PBUF_RAM 类型的 pbuf 中。pbuf_chain 函数用于连接两个 pbuf（链表）为一个 pbuf 链表；pbuf_ref 函数用于将 pbuf 中的 ref 值加 1。
| 
楼主
标题置顶
标题高亮
;){kind=link}