一、数据包管理 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。
|