关于lwip中pbuf_alloc()内存申请函数

落日映苍穹つ 2022-08-27 13:49 219阅读 0赞

[关于lwip中pbuf\_alloc()内存申请函数][lwip_pbuf_alloc] *2012-04-18 14:47:42*

分类： LINUX

[http://blog.chinaunix.net/uid-26611973-id-3180999.html][lwip_pbuf_alloc]

**1. PBUF\_RAM一次性分配size大小的连续内存**  
**2. RBUF\_ROM只需要分配小小的管理pbuf的控制管理内存**  
**3. PBUF\_ROOL分配一个链表,链表上每个元素所管理的内存最大不超过PBUF\_POOL\_BUFSIZE,它更像linux**  
 **中的kmem\_alloc内存高速缓存机制,所以它也更适合在网卡驱动irq中断中为刚刚到来的网络数据包申请存储空间**  
/\*-----------------------------------------------------------------------------------\*/  
/\* pbuf\_alloc():  
\*  
\* Allocates a pbuf at protocol layer l. The actual memory allocated  
\* for the pbuf is determined by the layer at which the pbuf is  
\* allocated and the requested size (from the size parameter). The  
\* flag parameter decides how and where the pbuf should be allocated  
\* as follows:  
\*  
\* \* PBUF\_RAM: buffer memory for pbuf is allocated as one large  
\* chunk. This includes protocol headers as well.  
\* \* RBUF\_ROM: no buffer memory is allocated for the pbuf, even for  
\* protocol headers. Additional headers must be prepended  
\* by allocating another pbuf and chain in to the front of  
\* the ROM pbuf.  
\* \* PBUF\_ROOL: the pbuf is allocated as a pbuf chain, with pbufs from  
\* the pbuf pool that is allocated during pbuf\_init().  
\*/  
/\*-----------------------------------------------------------------------------------\*/  
struct pbuf \*  
pbuf\_alloc(pbuf\_layer l, u16\_t size, pbuf\_flag flag)  
\{  
struct pbuf \*p, \*q, \*r;  
u16\_t offset;  
s32\_t rsize;  
  
offset = 0;  
switch(l) \{  
case PBUF\_TRANSPORT: // 如果为传输层申请pbuf,那么有效数据的偏移位置为PBUF\_TRANSPORT\_HLEN\[luther.gliethttp\]  
offset += PBUF\_TRANSPORT\_HLEN;  
/\* FALLTHROUGH \*/  
case PBUF\_IP: // 如果为ip层申请pbuf,那么有效数据的偏移位置为PBUF\_IP\_HLEN+PBUF\_LINK\_HLEN  
offset += PBUF\_IP\_HLEN;  
offset += PBUF\_LINK\_HLEN;  
/\* FALLTHROUGH \*/  
case PBUF\_LINK: // 如果是链路层申请pbuf内存,那么数据偏移位置就是0  
break;  
case PBUF\_RAW:  
break;  
default:  
ASSERT("pbuf\_alloc: bad pbuf layer", 0);  
return NULL;  
\}  
  
switch(flag) \{  
case PBUF\_POOL:  
/\* Allocate head of pbuf chain into p. \*/  
p = pbuf\_pool\_alloc(); // 为PBUF\_POOL类型,那么需要多申请pbuf的head控制头部所需内存\[luther.gliethttp\]  
if(p == NULL) \{  
\#ifdef PBUF\_STATS  
\++stats.pbuf.err;  
\#endif /\* PBUF\_STATS \*/  
return NULL;  
\}  
p->next = NULL;  
  
/\* Set the payload pointer so that it points offset bytes into  
pbuf data memory. \*/  
p->payload = MEM\_ALIGN((void \*)((u8\_t \*)p + (sizeof(struct pbuf) + offset))); // 以offset为基准,登记有效数据存储的起始偏移位置到p->payload\[luther.gliethttp\]  
  
/\* The total length of the pbuf is the requested size. \*/  
p->tot\_len = size; // pbuf链表上有效数据总大小  
  
/\* Set the length of the first pbuf is the chain. \*/  
// pbuf链表上每个元素所能存储的最大数据为PBUF\_POOL\_BUFSIZE,如果超过该值,那么就会  
// 使用链表方式,链接其很多个pbuf,直到申请的size数据全部能够正常存储为止\[luther.gliethttp\]  
p->len = size > PBUF\_POOL\_BUFSIZE - offset? PBUF\_POOL\_BUFSIZE - offset: size;  
  
p->flags = PBUF\_FLAG\_POOL;  
  
/\* Allocate the tail of the pbuf chain. \*/  
r = p;  
rsize = size - p->len; // 第1个pbuf所能存储数据大小为p->len,这里计算还需要多少存储空间存储剩下的数据.  
while(rsize > 0) \{ // 构成数据缓存链表,每个链表元素所能存储的最大数据量为PBUF\_POOL\_BUFSIZE个字节\[luther.gliethttp\]  
q = pbuf\_pool\_alloc();  
if(q == NULL) \{  
DEBUGF(PBUF\_DEBUG, ("pbuf\_alloc: Out of pbufs in pool,\\n"));  
\#ifdef PBUF\_STATS  
\++stats.pbuf.err;  
\#endif /\* PBUF\_STATS \*/  
pbuf\_pool\_free(p);  
return NULL;  
\}  
q->next = NULL;  
r->next = q;  
q->len = rsize > PBUF\_POOL\_BUFSIZE? PBUF\_POOL\_BUFSIZE: rsize;  
q->flags = PBUF\_FLAG\_POOL;  
q->payload = (void \*)((u8\_t \*)q + sizeof(struct pbuf));  
r = q;  
q->ref = 1;  
q = q->next;  
rsize -= PBUF\_POOL\_BUFSIZE;  
\}  
r->next = NULL;  
  
ASSERT("pbuf\_alloc: pbuf->payload properly aligned",  
((u32\_t)p->payload % MEM\_ALIGNMENT) == 0);  
break;  
case PBUF\_RAM:  
/\* If pbuf is to be allocated in RAM, allocate memory for it. \*/  
// PBUF\_RAM类型内存,那么一次性申请size大小的连续内存  
p = mem\_malloc(MEM\_ALIGN\_SIZE(sizeof(struct pbuf) + size + offset));  
if(p == NULL) \{  
return NULL;  
\}  
/\* Set up internal structure of the pbuf. \*/  
p->payload = MEM\_ALIGN((void \*)((u8\_t \*)p + sizeof(struct pbuf) + offset));  
p->len = p->tot\_len = size;  
p->next = NULL;  
p->flags = PBUF\_FLAG\_RAM;  
  
ASSERT("pbuf\_alloc: pbuf->payload properly aligned",  
((u32\_t)p->payload % MEM\_ALIGNMENT) == 0);  
break;  
case PBUF\_ROM:  
/\* If the pbuf should point to ROM, we only need to allocate  
memory for the pbuf structure. \*/  
// PBUF\_ROM类型内存,那么只需要申请pbufs头部控制结构体所需内存即可\[luther.gliethttp\]  
p = memp\_mallocp(MEMP\_PBUF);  
if(p == NULL) \{  
return NULL;  
\}  
p->payload = NULL;  
p->len = p->tot\_len = size;  
p->next = NULL;  
p->flags = PBUF\_FLAG\_ROM;  
break;  
default:  
ASSERT("pbuf\_alloc: erroneous flag", 0);  
return NULL;  
\}  
p->ref = 1;  
return p;  
\}

[lwip_pbuf_alloc]: http://blog.chinaunix.net/uid-26611973-id-3180999.html