alloc_skb()

 

sock_alloc_send_pskb() --> alloc_skb()     alloc_skb()用于分配缓冲区的函数。由于"数据缓冲区"和"缓冲区的描述结构"(sk_buff结构)是两种不同的实体，这就意味着，在分配一个缓冲区时，需要分配两块内存(一个是缓冲区，一个是缓冲区的描述结构sk_buff)。 /usr/src/linux-2.6.19/include/linux/skbuff.h static inline struct sk_buff *alloc_skb(unsigned int size,                                         gfp_t    priority) {     return __alloc_skb(size, priority, 0); }     __alloc_skb()调用kmem_cache_alloc()从缓存中获取一个sk_buff结构，并调用 kmalloc_track_caller 分配缓冲区 /usr/src/linux-2.6.19/net/core/skbuff.c struct sk_buff * __alloc_skb (unsigned int size, gfp_t gfp_mask,                 int fclone) {     kmem_cache_t           *cache;     struct skb_shared_info *shinfo;     struct sk_buff         *skb;     u8                     *data;     cache = fclone ? skbuff_fclone_cache : skbuff_head_cache;     skb = kmem_cache_alloc(cache, gfp_mask & ~__GFP_DMA);     if (!skb)         goto out;     size = SKB_DATA_ALIGN(size);     data = kmalloc_track_caller(size + sizeof(struct skb_shared_info),             gfp_mask);     if (!data)         goto nodata;     memset(skb, 0, offsetof(struct sk_buff, truesize));     skb->truesize = size + sizeof(struct sk_buff);     atomic_set(&skb->users, 1);     skb->head = data;     skb->data = data;     skb->tail = data;     skb->end = data + size;     shinfo = skb_shinfo(skb);     atomic_set(&shinfo->dataref, 1);     shinfo->nr_frags = 0;     shinfo->gso_size = 0;     shinfo->gso_segs = 0;     shinfo->gso_type = 0;     shinfo->ip6_frag_id = 0;     shinfo->frag_list = NULL;     if (fclone) {         struct sk_buff *child = skb + 1;         atomic_t *fclone_ref = (atomic_t *) (child + 1);         skb->fclone = SKB_FCLONE_ORIG;         atomic_set(fclone_ref, 1);            child->fclone = SKB_FCLONE_UNAVAILABLE;     } out:     return skb; nodata:     kmem_cache_free(cache, skb);     skb = NULL;     goto out; }     alloc_skb(size, gpf_mask) allocates memory for a socket buffer structure and the corresponding packet memory. In this case, size specifies the size of the packet data space, where this space will be increased (aligned) to the next 16-bit address     In the creation of a new socket buffer, no immediate attempt is made to allocate the memory with kmalloc() for the sk_buff structure; rather, an attempt is made to reuse previously consumed sk_buff structures. Note that requesting memory in the kernel's storage management is very expensive and that, because structures of the same type always require the same size, an attempt is first made to reuse an sk_buff structure no longer required. There are two different structures that manage consumed socket buffer structures:     First, each CPU manages a so-called skb_head_cache that stores packets no longer needed. This is a simple socket buffer queue, from which alloc_skb() takes socket buffers.     Second, there is a central stack for consumed sk_buff structures (skbuff_head_cache).     If there are no more sk_buff structures available for the current CPU, then kmem_cache_alloc() is used to try obtaining a packet from the central socket-buffer cache (skbuff_head_cache). If this attempt fails, then kmalloc() is eventually used. gfp_mask contains flags required to reserve memory.     Using these two caches can be justified by the fact that many packets are created and released in a system (i.e., the memory of sk_buff structures is frequently released), only to be required again shortly afterwards. The two socket buffer caches were introduced to avoid this expensive releasing and reallocating of memory space by the storage management (similarly to first-level and second-level caches for CPU memory access). This means that the time required to release and reserve sk_buff structures can be shortened. When kmem_cache_alloc() is used to reserve an sk_buff structure, the function skb_header_init() is called to initialize the structure. It will be described further below.     Naturally, for the sk_buff structure, a socket buffer requires memory for the packet data. Because the size of a packet is usually different from and clearly bigger than that of an sk_buff structure, a method like the socket-buffer cache does not provide any benefit. The packet data space is reserved in the usual way (i.e., by use of kmalloc()).     The pointers head, data, tail, and end are set once memory has been reserved for the packet data. The counters user and datarefp (number of references to these socket buffer structure) are set to one. The data space for packets begins to grow from the top (data) (i.e., at that point, the socket buffer has no headroom and has tailroom of size bytes).