网络链路层加密实现02-skb相关操作函数

void __init skb_init(void)
{
    skbuff_head_cache = kmem_cache_create("skbuff_head_cache",
                          sizeof(struct sk_buff),
                          0,
                          SLAB_HWCACHE_ALIGN|SLAB_PANIC,
                          NULL);
    skbuff_fclone_cache = kmem_cache_create("skbuff_fclone_cache",
                        sizeof(struct sk_buff_fclones),
                        0,
                        SLAB_HWCACHE_ALIGN|SLAB_PANIC,
                        NULL);
}


//struct sk_buff_fclones结构体如下：
/* Layout of fast clones : [skb1][skb2][fclone_ref] */
struct sk_buff_fclones {
    struct sk_buff  skb1;
    struct sk_buff  skb2;
    atomic_t    fclone_ref;
};

static inline struct sk_buff *alloc_skb(unsigned int size, gfp_t priority)
{
  //size - 待分配skb的线性存储区的长度
//priority – 分配内存的方式
//0 – 预测是否会被克隆，用于确定是从哪个高速缓存中分配
//NUMA_NO_NODE – 当支持NUMA时用于确定何种区域中分配SKB
    return __alloc_skb(size, priority, 0, NUMA_NO_NODE);
}

/* legacy helper around netdev_alloc_skb() */
static inline struct sk_buff *dev_alloc_skb(unsigned int length)
{
    return netdev_alloc_skb(NULL, length);
}
*/
static inline struct sk_buff *netdev_alloc_skb(struct net_device *dev,
                           unsigned int length)
{
  //因为在中断函数中被调用，所以要求原子操作GFP_ATOMIC
    return __netdev_alloc_skb(dev, length, GFP_ATOMIC);
}

#define dev_kfree_skb(a)    consume_skb(a)
/**
 *  consume_skb - free an skbuff
 *  @skb: buffer to free
 *
 *  Drop a ref to the buffer and free it if the usage count has hit zero
 *  Functions identically to kfree_skb, but kfree_skb assumes that the frame
 *  is being dropped after a failure and notes that
 */
void consume_skb(struct sk_buff *skb)
{
    if (unlikely(!skb))
        return;
    if (likely(atomic_read(&skb->users) == 1))
        smp_rmb();
    else if (likely(!atomic_dec_and_test(&skb->users)))
        return;
    trace_consume_skb(skb);
    __kfree_skb(skb);
}

/** *  skb_reserve - adjust headroom
 *  @skb: buffer to alter
 *  @len: bytes to move
 *
 *  Increase the headroom of an empty &sk_buff by reducing the tail
 *  room. This is only allowed for an empty buffer.
 */
static inline void skb_reserve(struct sk_buff *skb, int len)
{
    skb->data += len;
    skb->tail += len;
}

/**
 *  skb_push - add data to the start of a buffer
 *  @skb: buffer to use
 *  @len: amount of data to add
 *  
 *  This function extends the used data area of the buffer at the buffer
 *  start. If this would exceed the total buffer headroom the kernel will
 *  panic. A pointer to the first byte of the extra data is returned.
 */
unsigned char *skb_push(struct sk_buff *skb, unsigned int len)
{
    skb->data -= len;
    skb->len  += len;
    if (unlikely(skb->data<skb->head))
        skb_under_panic(skb, len, __builtin_return_address(0));
    return skb->data;
}

/**
 *  skb_pull - remove data from the start of a buffer
 *  @skb: buffer to use
 *  @len: amount of data to remove
 *  
 *  This function removes data from the start of a buffer, returning
 *  the memory to the headroom. A pointer to the next data in the buffer
 *  is returned. Once the data has been pulled future pushes will overwrite
 *  the old data.
 */
unsigned char *skb_pull(struct sk_buff *skb, unsigned int len)
{
    return skb_pull_inline(skb, len);
}

static inline int skb_add_data(struct sk_buff *skb,
                   struct iov_iter *from, int copy)
{
    const int off = skb->len;


    if (skb->ip_summed == CHECKSUM_NONE) {
        __wsum csum = 0; 
        if (csum_and_copy_from_iter(skb_put(skb, copy), copy,
                        &csum, from) == copy) {
            skb->csum = csum_block_add(skb->csum, csum, off);
            return 0;
        }
    } else if (copy_from_iter(skb_put(skb, copy), copy, from) == copy)
        return 0;


    __skb_trim(skb, off);
    return -EFAULT;
}




struct kvec {
    void *iov_base; /* and that should *never* hold a userland pointer */
    size_t iov_len;
};  
        
enum {  
    ITER_IOVEC = 0,
    ITER_KVEC = 2,
    ITER_BVEC = 4, 
};      
    
struct iov_iter {
    int type;
    size_t iov_offset;
    size_t count;
    union {
        const struct iovec *iov;
        const struct kvec *kvec;
        const struct bio_vec *bvec;
    };
    unsigned long nr_segs;
};   

/**
 *  skb_trim - remove end from a buffer
 *  @skb: buffer to alter
 *  @len: new length
 *
 *  Cut the length of a buffer down by removing data from the tail. If
 *  the buffer is already under the length specified it is not modified.
 *  The skb must be linear.
 */
void skb_trim(struct sk_buff *skb, unsigned int len) 
{
    if (skb->len > len) 
        __skb_trim(skb, len);
}
static inline int pskb_trim(struct sk_buff *skb, unsigned int len)
{
    return (len < skb->len) ? __pskb_trim(skb, len) : 0;
}