/*
   *	Routines having to do with the 'struct sk_buff' memory handlers.
   *

   *	Authors:	Alan Cox <alan@lxorguk.ukuu.org.uk>

   *			Florian La Roche <rzsfl@rz.uni-sb.de>
   *

   *	Fixes:
   *		Alan Cox	:	Fixed the worst of the load
   *					balancer bugs.
   *		Dave Platt	:	Interrupt stacking fix.
   *	Richard Kooijman	:	Timestamp fixes.
   *		Alan Cox	:	Changed buffer format.
   *		Alan Cox	:	destructor hook for AF_UNIX etc.
   *		Linus Torvalds	:	Better skb_clone.
   *		Alan Cox	:	Added skb_copy.
   *		Alan Cox	:	Added all the changed routines Linus
   *					only put in the headers
   *		Ray VanTassle	:	Fixed --skb->lock in free
   *		Alan Cox	:	skb_copy copy arp field
   *		Andi Kleen	:	slabified it.
   *		Robert Olsson	:	Removed skb_head_pool
   *
   *	NOTE:
   *		The __skb_ routines should be called with interrupts
   *	disabled, or you better be *real* sure that the operation is atomic
   *	with respect to whatever list is being frobbed (e.g. via lock_sock()
   *	or via disabling bottom half handlers, etc).
   *
   *	This program is free software; you can redistribute it and/or
   *	modify it under the terms of the GNU General Public License
   *	as published by the Free Software Foundation; either version
   *	2 of the License, or (at your option) any later version.
   */
  
  /*
   *	The functions in this file will not compile correctly with gcc 2.4.x
   */

  #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

  #include <linux/module.h>
  #include <linux/types.h>
  #include <linux/kernel.h>

  #include <linux/mm.h>
  #include <linux/interrupt.h>
  #include <linux/in.h>
  #include <linux/inet.h>
  #include <linux/slab.h>

  #include <linux/tcp.h>
  #include <linux/udp.h>

  #include <linux/sctp.h>

  #include <linux/netdevice.h>
  #ifdef CONFIG_NET_CLS_ACT
  #include <net/pkt_sched.h>
  #endif
  #include <linux/string.h>
  #include <linux/skbuff.h>

  #include <linux/splice.h>

  #include <linux/cache.h>
  #include <linux/rtnetlink.h>
  #include <linux/init.h>

  #include <linux/scatterlist.h>

  #include <linux/errqueue.h>

  #include <linux/prefetch.h>

  #include <linux/if_vlan.h>

  
  #include <net/protocol.h>
  #include <net/dst.h>
  #include <net/sock.h>
  #include <net/checksum.h>

  #include <net/ip6_checksum.h>

  #include <net/xfrm.h>

  #include <linux/uaccess.h>

  #include <trace/events/skb.h>

  #include <linux/highmem.h>

  #include <linux/capability.h>
  #include <linux/user_namespace.h>

  struct kmem_cache *skbuff_head_cache __read_mostly;

  static struct kmem_cache *skbuff_fclone_cache __read_mostly;

  int sysctl_max_skb_frags __read_mostly = MAX_SKB_FRAGS;
  EXPORT_SYMBOL(sysctl_max_skb_frags);

  /**

   *	skb_panic - private function for out-of-line support
   *	@skb:	buffer
   *	@sz:	size
   *	@addr:	address

   *	@msg:	skb_over_panic or skb_under_panic

   *

   *	Out-of-line support for skb_put() and skb_push().
   *	Called via the wrapper skb_over_panic() or skb_under_panic().
   *	Keep out of line to prevent kernel bloat.
   *	__builtin_return_address is not used because it is not always reliable.

   */

  static void skb_panic(struct sk_buff *skb, unsigned int sz, void *addr,

  		      const char msg[])

  {

  	pr_emerg("%s: text:%p len:%d put:%d head:%p data:%p tail:%#lx end:%#lx dev:%s
  ",

  		 msg, addr, skb->len, sz, skb->head, skb->data,

  		 (unsigned long)skb->tail, (unsigned long)skb->end,
  		 skb->dev ? skb->dev->name : "<NULL>");

  	BUG();
  }

  static void skb_over_panic(struct sk_buff *skb, unsigned int sz, void *addr)

  {

  	skb_panic(skb, sz, addr, __func__);

  }

  static void skb_under_panic(struct sk_buff *skb, unsigned int sz, void *addr)
  {
  	skb_panic(skb, sz, addr, __func__);
  }

  
  /*
   * kmalloc_reserve is a wrapper around kmalloc_node_track_caller that tells
   * the caller if emergency pfmemalloc reserves are being used. If it is and
   * the socket is later found to be SOCK_MEMALLOC then PFMEMALLOC reserves
   * may be used. Otherwise, the packet data may be discarded until enough
   * memory is free
   */
  #define kmalloc_reserve(size, gfp, node, pfmemalloc) \
  	 __kmalloc_reserve(size, gfp, node, _RET_IP_, pfmemalloc)

  
  static void *__kmalloc_reserve(size_t size, gfp_t flags, int node,
  			       unsigned long ip, bool *pfmemalloc)

  {
  	void *obj;
  	bool ret_pfmemalloc = false;
  
  	/*
  	 * Try a regular allocation, when that fails and we're not entitled
  	 * to the reserves, fail.
  	 */
  	obj = kmalloc_node_track_caller(size,
  					flags | __GFP_NOMEMALLOC | __GFP_NOWARN,
  					node);
  	if (obj || !(gfp_pfmemalloc_allowed(flags)))
  		goto out;
  
  	/* Try again but now we are using pfmemalloc reserves */
  	ret_pfmemalloc = true;
  	obj = kmalloc_node_track_caller(size, flags, node);
  
  out:
  	if (pfmemalloc)
  		*pfmemalloc = ret_pfmemalloc;
  
  	return obj;
  }

  /* 	Allocate a new skbuff. We do this ourselves so we can fill in a few
   *	'private' fields and also do memory statistics to find all the
   *	[BEEP] leaks.
   *
   */
  
  /**

   *	__alloc_skb	-	allocate a network buffer

   *	@size: size to allocate
   *	@gfp_mask: allocation mask

   *	@flags: If SKB_ALLOC_FCLONE is set, allocate from fclone cache
   *		instead of head cache and allocate a cloned (child) skb.
   *		If SKB_ALLOC_RX is set, __GFP_MEMALLOC will be used for
   *		allocations in case the data is required for writeback

   *	@node: numa node to allocate memory on

   *
   *	Allocate a new &sk_buff. The returned buffer has no headroom and a

   *	tail room of at least size bytes. The object has a reference count
   *	of one. The return is the buffer. On a failure the return is %NULL.

   *
   *	Buffers may only be allocated from interrupts using a @gfp_mask of
   *	%GFP_ATOMIC.
   */

  struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask,

  			    int flags, int node)

  {

  	struct kmem_cache *cache;

  	struct skb_shared_info *shinfo;

  	struct sk_buff *skb;
  	u8 *data;

  	bool pfmemalloc;

  	cache = (flags & SKB_ALLOC_FCLONE)
  		? skbuff_fclone_cache : skbuff_head_cache;
  
  	if (sk_memalloc_socks() && (flags & SKB_ALLOC_RX))
  		gfp_mask |= __GFP_MEMALLOC;

  	/* Get the HEAD */

  	skb = kmem_cache_alloc_node(cache, gfp_mask & ~__GFP_DMA, node);

  	if (!skb)
  		goto out;

  	prefetchw(skb);

  	/* We do our best to align skb_shared_info on a separate cache
  	 * line. It usually works because kmalloc(X > SMP_CACHE_BYTES) gives
  	 * aligned memory blocks, unless SLUB/SLAB debug is enabled.
  	 * Both skb->head and skb_shared_info are cache line aligned.
  	 */

  	size = SKB_DATA_ALIGN(size);

  	size += SKB_DATA_ALIGN(sizeof(struct skb_shared_info));

  	data = kmalloc_reserve(size, gfp_mask, node, &pfmemalloc);

  	if (!data)
  		goto nodata;

  	/* kmalloc(size) might give us more room than requested.
  	 * Put skb_shared_info exactly at the end of allocated zone,
  	 * to allow max possible filling before reallocation.
  	 */
  	size = SKB_WITH_OVERHEAD(ksize(data));

  	prefetchw(data + size);

  	/*

  	 * Only clear those fields we need to clear, not those that we will
  	 * actually initialise below. Hence, don't put any more fields after
  	 * the tail pointer in struct sk_buff!

  	 */
  	memset(skb, 0, offsetof(struct sk_buff, tail));

  	/* Account for allocated memory : skb + skb->head */
  	skb->truesize = SKB_TRUESIZE(size);

  	skb->pfmemalloc = pfmemalloc;

  	refcount_set(&skb->users, 1);

  	skb->head = data;
  	skb->data = data;

  	skb_reset_tail_pointer(skb);

  	skb->end = skb->tail + size;

  	skb->mac_header = (typeof(skb->mac_header))~0U;
  	skb->transport_header = (typeof(skb->transport_header))~0U;

  	/* make sure we initialize shinfo sequentially */
  	shinfo = skb_shinfo(skb);

  	memset(shinfo, 0, offsetof(struct skb_shared_info, dataref));

  	atomic_set(&shinfo->dataref, 1);

  	if (flags & SKB_ALLOC_FCLONE) {

  		struct sk_buff_fclones *fclones;

  		fclones = container_of(skb, struct sk_buff_fclones, skb1);

  		skb->fclone = SKB_FCLONE_ORIG;

  		refcount_set(&fclones->fclone_ref, 1);

  		fclones->skb2.fclone = SKB_FCLONE_CLONE;

  	}

  out:
  	return skb;
  nodata:

  	kmem_cache_free(cache, skb);

  	skb = NULL;
  	goto out;

  }

  EXPORT_SYMBOL(__alloc_skb);

  /**

   * __build_skb - build a network buffer

   * @data: data buffer provided by caller

   * @frag_size: size of data, or 0 if head was kmalloced

   *
   * Allocate a new &sk_buff. Caller provides space holding head and

   * skb_shared_info. @data must have been allocated by kmalloc() only if

   * @frag_size is 0, otherwise data should come from the page allocator
   *  or vmalloc()

   * The return is the new skb buffer.
   * On a failure the return is %NULL, and @data is not freed.
   * Notes :
   *  Before IO, driver allocates only data buffer where NIC put incoming frame
   *  Driver should add room at head (NET_SKB_PAD) and
   *  MUST add room at tail (SKB_DATA_ALIGN(skb_shared_info))
   *  After IO, driver calls build_skb(), to allocate sk_buff and populate it
   *  before giving packet to stack.
   *  RX rings only contains data buffers, not full skbs.
   */

  struct sk_buff *__build_skb(void *data, unsigned int frag_size)

  {
  	struct skb_shared_info *shinfo;
  	struct sk_buff *skb;

  	unsigned int size = frag_size ? : ksize(data);

  
  	skb = kmem_cache_alloc(skbuff_head_cache, GFP_ATOMIC);
  	if (!skb)
  		return NULL;

  	size -= SKB_DATA_ALIGN(sizeof(struct skb_shared_info));

  
  	memset(skb, 0, offsetof(struct sk_buff, tail));
  	skb->truesize = SKB_TRUESIZE(size);

  	refcount_set(&skb->users, 1);

  	skb->head = data;
  	skb->data = data;
  	skb_reset_tail_pointer(skb);
  	skb->end = skb->tail + size;

  	skb->mac_header = (typeof(skb->mac_header))~0U;
  	skb->transport_header = (typeof(skb->transport_header))~0U;

  
  	/* make sure we initialize shinfo sequentially */
  	shinfo = skb_shinfo(skb);
  	memset(shinfo, 0, offsetof(struct skb_shared_info, dataref));
  	atomic_set(&shinfo->dataref, 1);

  
  	return skb;
  }

  
  /* build_skb() is wrapper over __build_skb(), that specifically
   * takes care of skb->head and skb->pfmemalloc
   * This means that if @frag_size is not zero, then @data must be backed
   * by a page fragment, not kmalloc() or vmalloc()
   */
  struct sk_buff *build_skb(void *data, unsigned int frag_size)
  {
  	struct sk_buff *skb = __build_skb(data, frag_size);
  
  	if (skb && frag_size) {
  		skb->head_frag = 1;

  		if (page_is_pfmemalloc(virt_to_head_page(data)))

  			skb->pfmemalloc = 1;
  	}
  	return skb;
  }

  EXPORT_SYMBOL(build_skb);

  #define NAPI_SKB_CACHE_SIZE	64
  
  struct napi_alloc_cache {
  	struct page_frag_cache page;

  	unsigned int skb_count;

  	void *skb_cache[NAPI_SKB_CACHE_SIZE];
  };

  static DEFINE_PER_CPU(struct page_frag_cache, netdev_alloc_cache);

  static DEFINE_PER_CPU(struct napi_alloc_cache, napi_alloc_cache);

  
  static void *__netdev_alloc_frag(unsigned int fragsz, gfp_t gfp_mask)
  {

  	struct page_frag_cache *nc;

  	unsigned long flags;
  	void *data;
  
  	local_irq_save(flags);

  	nc = this_cpu_ptr(&netdev_alloc_cache);

  	data = page_frag_alloc(nc, fragsz, gfp_mask);

  	local_irq_restore(flags);
  	return data;
  }

  
  /**
   * netdev_alloc_frag - allocate a page fragment
   * @fragsz: fragment size
   *
   * Allocates a frag from a page for receive buffer.
   * Uses GFP_ATOMIC allocations.
   */
  void *netdev_alloc_frag(unsigned int fragsz)
  {
  	return __netdev_alloc_frag(fragsz, GFP_ATOMIC | __GFP_COLD);
  }

  EXPORT_SYMBOL(netdev_alloc_frag);

  static void *__napi_alloc_frag(unsigned int fragsz, gfp_t gfp_mask)
  {

  	struct napi_alloc_cache *nc = this_cpu_ptr(&napi_alloc_cache);

  	return page_frag_alloc(&nc->page, fragsz, gfp_mask);

  }
  
  void *napi_alloc_frag(unsigned int fragsz)
  {
  	return __napi_alloc_frag(fragsz, GFP_ATOMIC | __GFP_COLD);
  }
  EXPORT_SYMBOL(napi_alloc_frag);

  /**

   *	__netdev_alloc_skb - allocate an skbuff for rx on a specific device
   *	@dev: network device to receive on

   *	@len: length to allocate

   *	@gfp_mask: get_free_pages mask, passed to alloc_skb
   *
   *	Allocate a new &sk_buff and assign it a usage count of one. The
   *	buffer has NET_SKB_PAD headroom built in. Users should allocate
   *	the headroom they think they need without accounting for the
   *	built in space. The built in space is used for optimisations.
   *
   *	%NULL is returned if there is no free memory.
   */

  struct sk_buff *__netdev_alloc_skb(struct net_device *dev, unsigned int len,
  				   gfp_t gfp_mask)

  {

  	struct page_frag_cache *nc;

  	unsigned long flags;

  	struct sk_buff *skb;

  	bool pfmemalloc;
  	void *data;
  
  	len += NET_SKB_PAD;

  	if ((len > SKB_WITH_OVERHEAD(PAGE_SIZE)) ||

  	    (gfp_mask & (__GFP_DIRECT_RECLAIM | GFP_DMA))) {

  		skb = __alloc_skb(len, gfp_mask, SKB_ALLOC_RX, NUMA_NO_NODE);
  		if (!skb)
  			goto skb_fail;
  		goto skb_success;
  	}

  	len += SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
  	len = SKB_DATA_ALIGN(len);
  
  	if (sk_memalloc_socks())
  		gfp_mask |= __GFP_MEMALLOC;
  
  	local_irq_save(flags);
  
  	nc = this_cpu_ptr(&netdev_alloc_cache);

  	data = page_frag_alloc(nc, len, gfp_mask);

  	pfmemalloc = nc->pfmemalloc;
  
  	local_irq_restore(flags);
  
  	if (unlikely(!data))
  		return NULL;
  
  	skb = __build_skb(data, len);
  	if (unlikely(!skb)) {

  		skb_free_frag(data);

  		return NULL;

  	}

  	/* use OR instead of assignment to avoid clearing of bits in mask */
  	if (pfmemalloc)
  		skb->pfmemalloc = 1;
  	skb->head_frag = 1;

  skb_success:

  	skb_reserve(skb, NET_SKB_PAD);
  	skb->dev = dev;

  skb_fail:

  	return skb;
  }

  EXPORT_SYMBOL(__netdev_alloc_skb);

  /**
   *	__napi_alloc_skb - allocate skbuff for rx in a specific NAPI instance
   *	@napi: napi instance this buffer was allocated for

   *	@len: length to allocate

   *	@gfp_mask: get_free_pages mask, passed to alloc_skb and alloc_pages
   *
   *	Allocate a new sk_buff for use in NAPI receive.  This buffer will
   *	attempt to allocate the head from a special reserved region used
   *	only for NAPI Rx allocation.  By doing this we can save several
   *	CPU cycles by avoiding having to disable and re-enable IRQs.
   *
   *	%NULL is returned if there is no free memory.
   */

  struct sk_buff *__napi_alloc_skb(struct napi_struct *napi, unsigned int len,
  				 gfp_t gfp_mask)

  {

  	struct napi_alloc_cache *nc = this_cpu_ptr(&napi_alloc_cache);

  	struct sk_buff *skb;

  	void *data;
  
  	len += NET_SKB_PAD + NET_IP_ALIGN;

  	if ((len > SKB_WITH_OVERHEAD(PAGE_SIZE)) ||

  	    (gfp_mask & (__GFP_DIRECT_RECLAIM | GFP_DMA))) {

  		skb = __alloc_skb(len, gfp_mask, SKB_ALLOC_RX, NUMA_NO_NODE);
  		if (!skb)
  			goto skb_fail;
  		goto skb_success;
  	}

  
  	len += SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
  	len = SKB_DATA_ALIGN(len);
  
  	if (sk_memalloc_socks())
  		gfp_mask |= __GFP_MEMALLOC;

  	data = page_frag_alloc(&nc->page, len, gfp_mask);

  	if (unlikely(!data))
  		return NULL;
  
  	skb = __build_skb(data, len);
  	if (unlikely(!skb)) {

  		skb_free_frag(data);

  		return NULL;

  	}

  	/* use OR instead of assignment to avoid clearing of bits in mask */

  	if (nc->page.pfmemalloc)

  		skb->pfmemalloc = 1;
  	skb->head_frag = 1;

  skb_success:

  	skb_reserve(skb, NET_SKB_PAD + NET_IP_ALIGN);
  	skb->dev = napi->dev;

  skb_fail:

  	return skb;
  }
  EXPORT_SYMBOL(__napi_alloc_skb);

  void skb_add_rx_frag(struct sk_buff *skb, int i, struct page *page, int off,

  		     int size, unsigned int truesize)

  {
  	skb_fill_page_desc(skb, i, page, off, size);
  	skb->len += size;
  	skb->data_len += size;

  	skb->truesize += truesize;

  }
  EXPORT_SYMBOL(skb_add_rx_frag);

  void skb_coalesce_rx_frag(struct sk_buff *skb, int i, int size,
  			  unsigned int truesize)
  {
  	skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
  
  	skb_frag_size_add(frag, size);
  	skb->len += size;
  	skb->data_len += size;
  	skb->truesize += truesize;
  }
  EXPORT_SYMBOL(skb_coalesce_rx_frag);

  static void skb_drop_list(struct sk_buff **listp)

  {

  	kfree_skb_list(*listp);

  	*listp = NULL;

  }

  static inline void skb_drop_fraglist(struct sk_buff *skb)
  {
  	skb_drop_list(&skb_shinfo(skb)->frag_list);
  }

  static void skb_clone_fraglist(struct sk_buff *skb)
  {
  	struct sk_buff *list;

  	skb_walk_frags(skb, list)

  		skb_get(list);
  }

  static void skb_free_head(struct sk_buff *skb)
  {

  	unsigned char *head = skb->head;

  	if (skb->head_frag)

  		skb_free_frag(head);

  	else

  		kfree(head);

  }

  static void skb_release_data(struct sk_buff *skb)

  {

  	struct skb_shared_info *shinfo = skb_shinfo(skb);
  	int i;

  	if (skb->cloned &&
  	    atomic_sub_return(skb->nohdr ? (1 << SKB_DATAREF_SHIFT) + 1 : 1,
  			      &shinfo->dataref))
  		return;

  	for (i = 0; i < shinfo->nr_frags; i++)
  		__skb_frag_unref(&shinfo->frags[i]);

  	if (shinfo->frag_list)
  		kfree_skb_list(shinfo->frag_list);

  	skb_zcopy_clear(skb, true);

  	skb_free_head(skb);

  }
  
  /*
   *	Free an skbuff by memory without cleaning the state.
   */

  static void kfree_skbmem(struct sk_buff *skb)

  {

  	struct sk_buff_fclones *fclones;

  	switch (skb->fclone) {
  	case SKB_FCLONE_UNAVAILABLE:
  		kmem_cache_free(skbuff_head_cache, skb);

  		return;

  
  	case SKB_FCLONE_ORIG:

  		fclones = container_of(skb, struct sk_buff_fclones, skb1);

  		/* We usually free the clone (TX completion) before original skb
  		 * This test would have no chance to be true for the clone,
  		 * while here, branch prediction will be good.

  		 */

  		if (refcount_read(&fclones->fclone_ref) == 1)

  			goto fastpath;
  		break;

  	default: /* SKB_FCLONE_CLONE */
  		fclones = container_of(skb, struct sk_buff_fclones, skb2);

  		break;

  	}

  	if (!refcount_dec_and_test(&fclones->fclone_ref))

  		return;
  fastpath:
  	kmem_cache_free(skbuff_fclone_cache, fclones);

  }

  void skb_release_head_state(struct sk_buff *skb)

  {

  	skb_dst_drop(skb);

  	secpath_reset(skb);

  	if (skb->destructor) {
  		WARN_ON(in_irq());

  		skb->destructor(skb);
  	}

  #if IS_ENABLED(CONFIG_NF_CONNTRACK)

  	nf_conntrack_put(skb_nfct(skb));

  #endif

  #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)

  	nf_bridge_put(skb->nf_bridge);
  #endif

  }
  
  /* Free everything but the sk_buff shell. */
  static void skb_release_all(struct sk_buff *skb)
  {
  	skb_release_head_state(skb);

  	if (likely(skb->head))
  		skb_release_data(skb);

  }
  
  /**
   *	__kfree_skb - private function
   *	@skb: buffer
   *
   *	Free an sk_buff. Release anything attached to the buffer.
   *	Clean the state. This is an internal helper function. Users should
   *	always call kfree_skb
   */

  void __kfree_skb(struct sk_buff *skb)
  {
  	skb_release_all(skb);

  	kfree_skbmem(skb);
  }

  EXPORT_SYMBOL(__kfree_skb);

  
  /**

   *	kfree_skb - free an sk_buff
   *	@skb: buffer to free
   *
   *	Drop a reference to the buffer and free it if the usage count has
   *	hit zero.
   */
  void kfree_skb(struct sk_buff *skb)
  {

  	if (!skb_unref(skb))

  		return;

  	trace_kfree_skb(skb, __builtin_return_address(0));

  	__kfree_skb(skb);
  }

  EXPORT_SYMBOL(kfree_skb);

  void kfree_skb_list(struct sk_buff *segs)
  {
  	while (segs) {
  		struct sk_buff *next = segs->next;
  
  		kfree_skb(segs);
  		segs = next;
  	}
  }
  EXPORT_SYMBOL(kfree_skb_list);

  /**

   *	skb_tx_error - report an sk_buff xmit error
   *	@skb: buffer that triggered an error
   *
   *	Report xmit error if a device callback is tracking this skb.
   *	skb must be freed afterwards.
   */
  void skb_tx_error(struct sk_buff *skb)
  {

  	skb_zcopy_clear(skb, true);

  }
  EXPORT_SYMBOL(skb_tx_error);
  
  /**

   *	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 (!skb_unref(skb))

  		return;

  	trace_consume_skb(skb);

  	__kfree_skb(skb);
  }
  EXPORT_SYMBOL(consume_skb);

  /**
   *	consume_stateless_skb - free an skbuff, assuming it is stateless
   *	@skb: buffer to free
   *

   *	Alike consume_skb(), but this variant assumes that this is the last
   *	skb reference and all the head states have been already dropped

   */

  void __consume_stateless_skb(struct sk_buff *skb)

  {

  	trace_consume_skb(skb);

  	skb_release_data(skb);

  	kfree_skbmem(skb);
  }

  void __kfree_skb_flush(void)
  {
  	struct napi_alloc_cache *nc = this_cpu_ptr(&napi_alloc_cache);
  
  	/* flush skb_cache if containing objects */
  	if (nc->skb_count) {
  		kmem_cache_free_bulk(skbuff_head_cache, nc->skb_count,
  				     nc->skb_cache);
  		nc->skb_count = 0;
  	}
  }

  static inline void _kfree_skb_defer(struct sk_buff *skb)

  {
  	struct napi_alloc_cache *nc = this_cpu_ptr(&napi_alloc_cache);
  
  	/* drop skb->head and call any destructors for packet */
  	skb_release_all(skb);
  
  	/* record skb to CPU local list */
  	nc->skb_cache[nc->skb_count++] = skb;
  
  #ifdef CONFIG_SLUB
  	/* SLUB writes into objects when freeing */
  	prefetchw(skb);
  #endif
  
  	/* flush skb_cache if it is filled */
  	if (unlikely(nc->skb_count == NAPI_SKB_CACHE_SIZE)) {
  		kmem_cache_free_bulk(skbuff_head_cache, NAPI_SKB_CACHE_SIZE,
  				     nc->skb_cache);
  		nc->skb_count = 0;
  	}
  }

  void __kfree_skb_defer(struct sk_buff *skb)
  {
  	_kfree_skb_defer(skb);
  }

  
  void napi_consume_skb(struct sk_buff *skb, int budget)
  {
  	if (unlikely(!skb))
  		return;

  	/* Zero budget indicate non-NAPI context called us, like netpoll */

  	if (unlikely(!budget)) {

  		dev_consume_skb_any(skb);

  		return;
  	}

  	if (!skb_unref(skb))

  		return;

  	/* if reaching here SKB is ready to free */
  	trace_consume_skb(skb);
  
  	/* if SKB is a clone, don't handle this case */

  	if (skb->fclone != SKB_FCLONE_UNAVAILABLE) {

  		__kfree_skb(skb);
  		return;
  	}

  	_kfree_skb_defer(skb);

  }
  EXPORT_SYMBOL(napi_consume_skb);

  /* Make sure a field is enclosed inside headers_start/headers_end section */
  #define CHECK_SKB_FIELD(field) \
  	BUILD_BUG_ON(offsetof(struct sk_buff, field) <		\
  		     offsetof(struct sk_buff, headers_start));	\
  	BUILD_BUG_ON(offsetof(struct sk_buff, field) >		\
  		     offsetof(struct sk_buff, headers_end));	\

  static void __copy_skb_header(struct sk_buff *new, const struct sk_buff *old)
  {
  	new->tstamp		= old->tstamp;

  	/* We do not copy old->sk */

  	new->dev		= old->dev;

  	memcpy(new->cb, old->cb, sizeof(old->cb));

  	skb_dst_copy(new, old);

  #ifdef CONFIG_XFRM

  	new->sp			= secpath_get(old->sp);
  #endif

  	__nf_copy(new, old, false);
  
  	/* Note : this field could be in headers_start/headers_end section
  	 * It is not yet because we do not want to have a 16 bit hole
  	 */
  	new->queue_mapping = old->queue_mapping;
  
  	memcpy(&new->headers_start, &old->headers_start,
  	       offsetof(struct sk_buff, headers_end) -
  	       offsetof(struct sk_buff, headers_start));
  	CHECK_SKB_FIELD(protocol);
  	CHECK_SKB_FIELD(csum);
  	CHECK_SKB_FIELD(hash);
  	CHECK_SKB_FIELD(priority);
  	CHECK_SKB_FIELD(skb_iif);
  	CHECK_SKB_FIELD(vlan_proto);
  	CHECK_SKB_FIELD(vlan_tci);
  	CHECK_SKB_FIELD(transport_header);
  	CHECK_SKB_FIELD(network_header);
  	CHECK_SKB_FIELD(mac_header);
  	CHECK_SKB_FIELD(inner_protocol);
  	CHECK_SKB_FIELD(inner_transport_header);
  	CHECK_SKB_FIELD(inner_network_header);
  	CHECK_SKB_FIELD(inner_mac_header);
  	CHECK_SKB_FIELD(mark);
  #ifdef CONFIG_NETWORK_SECMARK
  	CHECK_SKB_FIELD(secmark);
  #endif
  #ifdef CONFIG_NET_RX_BUSY_POLL
  	CHECK_SKB_FIELD(napi_id);

  #endif

  #ifdef CONFIG_XPS
  	CHECK_SKB_FIELD(sender_cpu);
  #endif

  #ifdef CONFIG_NET_SCHED

  	CHECK_SKB_FIELD(tc_index);

  #endif

  }

  /*
   * You should not add any new code to this function.  Add it to
   * __copy_skb_header above instead.
   */

  static struct sk_buff *__skb_clone(struct sk_buff *n, struct sk_buff *skb)

  {

  #define C(x) n->x = skb->x
  
  	n->next = n->prev = NULL;

  	n->sk = NULL;

  	__copy_skb_header(n, skb);

  	C(len);
  	C(data_len);

  	C(mac_len);

  	n->hdr_len = skb->nohdr ? skb_headroom(skb) : skb->hdr_len;

  	n->cloned = 1;

  	n->nohdr = 0;

  	n->peeked = 0;

  	C(pfmemalloc);

  	n->destructor = NULL;

  	C(tail);
  	C(end);

  	C(head);

  	C(head_frag);

  	C(data);
  	C(truesize);

  	refcount_set(&n->users, 1);

  
  	atomic_inc(&(skb_shinfo(skb)->dataref));
  	skb->cloned = 1;
  
  	return n;

  #undef C
  }
  
  /**
   *	skb_morph	-	morph one skb into another
   *	@dst: the skb to receive the contents
   *	@src: the skb to supply the contents
   *
   *	This is identical to skb_clone except that the target skb is
   *	supplied by the user.
   *
   *	The target skb is returned upon exit.
   */
  struct sk_buff *skb_morph(struct sk_buff *dst, struct sk_buff *src)
  {

  	skb_release_all(dst);

  	return __skb_clone(dst, src);
  }
  EXPORT_SYMBOL_GPL(skb_morph);

  static int mm_account_pinned_pages(struct mmpin *mmp, size_t size)
  {
  	unsigned long max_pg, num_pg, new_pg, old_pg;
  	struct user_struct *user;
  
  	if (capable(CAP_IPC_LOCK) || !size)
  		return 0;
  
  	num_pg = (size >> PAGE_SHIFT) + 2;	/* worst case */
  	max_pg = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
  	user = mmp->user ? : current_user();
  
  	do {
  		old_pg = atomic_long_read(&user->locked_vm);
  		new_pg = old_pg + num_pg;
  		if (new_pg > max_pg)
  			return -ENOBUFS;
  	} while (atomic_long_cmpxchg(&user->locked_vm, old_pg, new_pg) !=
  		 old_pg);
  
  	if (!mmp->user) {
  		mmp->user = get_uid(user);
  		mmp->num_pg = num_pg;
  	} else {
  		mmp->num_pg += num_pg;
  	}
  
  	return 0;
  }
  
  static void mm_unaccount_pinned_pages(struct mmpin *mmp)
  {
  	if (mmp->user) {
  		atomic_long_sub(mmp->num_pg, &mmp->user->locked_vm);
  		free_uid(mmp->user);
  	}
  }

  struct ubuf_info *sock_zerocopy_alloc(struct sock *sk, size_t size)
  {
  	struct ubuf_info *uarg;
  	struct sk_buff *skb;
  
  	WARN_ON_ONCE(!in_task());
  
  	skb = sock_omalloc(sk, 0, GFP_KERNEL);
  	if (!skb)
  		return NULL;
  
  	BUILD_BUG_ON(sizeof(*uarg) > sizeof(skb->cb));
  	uarg = (void *)skb->cb;

  	uarg->mmp.user = NULL;
  
  	if (mm_account_pinned_pages(&uarg->mmp, size)) {
  		kfree_skb(skb);
  		return NULL;
  	}

  
  	uarg->callback = sock_zerocopy_callback;

  	uarg->id = ((u32)atomic_inc_return(&sk->sk_zckey)) - 1;
  	uarg->len = 1;
  	uarg->bytelen = size;

  	uarg->zerocopy = 1;

  	refcount_set(&uarg->refcnt, 1);

  	sock_hold(sk);
  
  	return uarg;
  }
  EXPORT_SYMBOL_GPL(sock_zerocopy_alloc);
  
  static inline struct sk_buff *skb_from_uarg(struct ubuf_info *uarg)
  {
  	return container_of((void *)uarg, struct sk_buff, cb);
  }

  struct ubuf_info *sock_zerocopy_realloc(struct sock *sk, size_t size,
  					struct ubuf_info *uarg)
  {
  	if (uarg) {
  		const u32 byte_limit = 1 << 19;		/* limit to a few TSO */
  		u32 bytelen, next;
  
  		/* realloc only when socket is locked (TCP, UDP cork),
  		 * so uarg->len and sk_zckey access is serialized
  		 */
  		if (!sock_owned_by_user(sk)) {
  			WARN_ON_ONCE(1);
  			return NULL;
  		}
  
  		bytelen = uarg->bytelen + size;
  		if (uarg->len == USHRT_MAX - 1 || bytelen > byte_limit) {
  			/* TCP can create new skb to attach new uarg */
  			if (sk->sk_type == SOCK_STREAM)
  				goto new_alloc;
  			return NULL;
  		}
  
  		next = (u32)atomic_read(&sk->sk_zckey);
  		if ((u32)(uarg->id + uarg->len) == next) {

  			if (mm_account_pinned_pages(&uarg->mmp, size))
  				return NULL;

  			uarg->len++;
  			uarg->bytelen = bytelen;
  			atomic_set(&sk->sk_zckey, ++next);

  			sock_zerocopy_get(uarg);

  			return uarg;
  		}
  	}
  
  new_alloc:
  	return sock_zerocopy_alloc(sk, size);
  }
  EXPORT_SYMBOL_GPL(sock_zerocopy_realloc);
  
  static bool skb_zerocopy_notify_extend(struct sk_buff *skb, u32 lo, u16 len)
  {
  	struct sock_exterr_skb *serr = SKB_EXT_ERR(skb);
  	u32 old_lo, old_hi;
  	u64 sum_len;
  
  	old_lo = serr->ee.ee_info;
  	old_hi = serr->ee.ee_data;
  	sum_len = old_hi - old_lo + 1ULL + len;
  
  	if (sum_len >= (1ULL << 32))
  		return false;
  
  	if (lo != old_hi + 1)
  		return false;
  
  	serr->ee.ee_data += len;
  	return true;
  }

  void sock_zerocopy_callback(struct ubuf_info *uarg, bool success)
  {

  	struct sk_buff *tail, *skb = skb_from_uarg(uarg);

  	struct sock_exterr_skb *serr;
  	struct sock *sk = skb->sk;

  	struct sk_buff_head *q;
  	unsigned long flags;
  	u32 lo, hi;
  	u16 len;

  	mm_unaccount_pinned_pages(&uarg->mmp);

  	/* if !len, there was only 1 call, and it was aborted
  	 * so do not queue a completion notification
  	 */
  	if (!uarg->len || sock_flag(sk, SOCK_DEAD))

  		goto release;

  	len = uarg->len;
  	lo = uarg->id;
  	hi = uarg->id + len - 1;

  	serr = SKB_EXT_ERR(skb);
  	memset(serr, 0, sizeof(*serr));
  	serr->ee.ee_errno = 0;
  	serr->ee.ee_origin = SO_EE_ORIGIN_ZEROCOPY;

  	serr->ee.ee_data = hi;
  	serr->ee.ee_info = lo;

  	if (!success)
  		serr->ee.ee_code |= SO_EE_CODE_ZEROCOPY_COPIED;

  	q = &sk->sk_error_queue;
  	spin_lock_irqsave(&q->lock, flags);
  	tail = skb_peek_tail(q);
  	if (!tail || SKB_EXT_ERR(tail)->ee.ee_origin != SO_EE_ORIGIN_ZEROCOPY ||
  	    !skb_zerocopy_notify_extend(tail, lo, len)) {
  		__skb_queue_tail(q, skb);
  		skb = NULL;
  	}
  	spin_unlock_irqrestore(&q->lock, flags);

  
  	sk->sk_error_report(sk);
  
  release:
  	consume_skb(skb);
  	sock_put(sk);
  }
  EXPORT_SYMBOL_GPL(sock_zerocopy_callback);
  
  void sock_zerocopy_put(struct ubuf_info *uarg)
  {

  	if (uarg && refcount_dec_and_test(&uarg->refcnt)) {

  		if (uarg->callback)
  			uarg->callback(uarg, uarg->zerocopy);
  		else
  			consume_skb(skb_from_uarg(uarg));
  	}
  }
  EXPORT_SYMBOL_GPL(sock_zerocopy_put);
  
  void sock_zerocopy_put_abort(struct ubuf_info *uarg)
  {
  	if (uarg) {
  		struct sock *sk = skb_from_uarg(uarg)->sk;
  
  		atomic_dec(&sk->sk_zckey);

  		uarg->len--;

  		sock_zerocopy_put(uarg);
  	}
  }
  EXPORT_SYMBOL_GPL(sock_zerocopy_put_abort);
  
  extern int __zerocopy_sg_from_iter(struct sock *sk, struct sk_buff *skb,
  				   struct iov_iter *from, size_t length);
  
  int skb_zerocopy_iter_stream(struct sock *sk, struct sk_buff *skb,
  			     struct msghdr *msg, int len,
  			     struct ubuf_info *uarg)
  {

  	struct ubuf_info *orig_uarg = skb_zcopy(skb);

  	struct iov_iter orig_iter = msg->msg_iter;
  	int err, orig_len = skb->len;

  	/* An skb can only point to one uarg. This edge case happens when
  	 * TCP appends to an skb, but zerocopy_realloc triggered a new alloc.
  	 */
  	if (orig_uarg && uarg != orig_uarg)
  		return -EEXIST;

  	err = __zerocopy_sg_from_iter(sk, skb, &msg->msg_iter, len);
  	if (err == -EFAULT || (err == -EMSGSIZE && skb->len == orig_len)) {

  		struct sock *save_sk = skb->sk;

  		/* Streams do not free skb on error. Reset to prev state. */
  		msg->msg_iter = orig_iter;

  		skb->sk = sk;

  		___pskb_trim(skb, orig_len);

  		skb->sk = save_sk;

  		return err;
  	}
  
  	skb_zcopy_set(skb, uarg);
  	return skb->len - orig_len;
  }
  EXPORT_SYMBOL_GPL(skb_zerocopy_iter_stream);

  static int skb_zerocopy_clone(struct sk_buff *nskb, struct sk_buff *orig,

  			      gfp_t gfp_mask)
  {
  	if (skb_zcopy(orig)) {
  		if (skb_zcopy(nskb)) {
  			/* !gfp_mask callers are verified to !skb_zcopy(nskb) */
  			if (!gfp_mask) {
  				WARN_ON_ONCE(1);
  				return -ENOMEM;
  			}
  			if (skb_uarg(nskb) == skb_uarg(orig))
  				return 0;
  			if (skb_copy_ubufs(nskb, GFP_ATOMIC))
  				return -EIO;
  		}
  		skb_zcopy_set(nskb, skb_uarg(orig));
  	}
  	return 0;
  }

  /**
   *	skb_copy_ubufs	-	copy userspace skb frags buffers to kernel

   *	@skb: the skb to modify
   *	@gfp_mask: allocation priority
   *
   *	This must be called on SKBTX_DEV_ZEROCOPY skb.
   *	It will copy all frags into kernel and drop the reference
   *	to userspace pages.
   *
   *	If this function is called from an interrupt gfp_mask() must be
   *	%GFP_ATOMIC.
   *
   *	Returns 0 on success or a negative error code on failure
   *	to allocate kernel memory to copy to.
   */
  int skb_copy_ubufs(struct sk_buff *skb, gfp_t gfp_mask)

  {

  	int num_frags = skb_shinfo(skb)->nr_frags;
  	struct page *page, *head = NULL;

  	int i, new_frags;
  	u32 d_off;

  	if (skb_shared(skb) || skb_unclone(skb, gfp_mask))
  		return -EINVAL;

  	if (!num_frags)
  		goto release;

  	new_frags = (__skb_pagelen(skb) + PAGE_SIZE - 1) >> PAGE_SHIFT;
  	for (i = 0; i < new_frags; i++) {

  		page = alloc_page(gfp_mask);

  		if (!page) {
  			while (head) {

  				struct page *next = (struct page *)page_private(head);

  				put_page(head);
  				head = next;
  			}
  			return -ENOMEM;
  		}

  		set_page_private(page, (unsigned long)head);
  		head = page;
  	}
  
  	page = head;
  	d_off = 0;
  	for (i = 0; i < num_frags; i++) {
  		skb_frag_t *f = &skb_shinfo(skb)->frags[i];
  		u32 p_off, p_len, copied;
  		struct page *p;
  		u8 *vaddr;

  
  		skb_frag_foreach_page(f, f->page_offset, skb_frag_size(f),
  				      p, p_off, p_len, copied) {

  			u32 copy, done = 0;

  			vaddr = kmap_atomic(p);

  
  			while (done < p_len) {
  				if (d_off == PAGE_SIZE) {
  					d_off = 0;
  					page = (struct page *)page_private(page);
  				}
  				copy = min_t(u32, PAGE_SIZE - d_off, p_len - done);
  				memcpy(page_address(page) + d_off,
  				       vaddr + p_off + done, copy);
  				done += copy;
  				d_off += copy;
  			}

  			kunmap_atomic(vaddr);
  		}

  	}
  
  	/* skb frags release userspace buffers */

  	for (i = 0; i < num_frags; i++)

  		skb_frag_unref(skb, i);

  	/* skb frags point to kernel buffers */

  	for (i = 0; i < new_frags - 1; i++) {
  		__skb_fill_page_desc(skb, i, head, 0, PAGE_SIZE);

  		head = (struct page *)page_private(head);

  	}

  	__skb_fill_page_desc(skb, new_frags - 1, head, 0, d_off);
  	skb_shinfo(skb)->nr_frags = new_frags;

  release:

  	skb_zcopy_clear(skb, false);

  	return 0;
  }

  EXPORT_SYMBOL_GPL(skb_copy_ubufs);

  /**
   *	skb_clone	-	duplicate an sk_buff
   *	@skb: buffer to clone
   *	@gfp_mask: allocation priority
   *
   *	Duplicate an &sk_buff. The new one is not owned by a socket. Both
   *	copies share the same packet data but not structure. The new
   *	buffer has a reference count of 1. If the allocation fails the
   *	function returns %NULL otherwise the new buffer is returned.
   *
   *	If this function is called from an interrupt gfp_mask() must be
   *	%GFP_ATOMIC.
   */
  
  struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t gfp_mask)
  {

  	struct sk_buff_fclones *fclones = container_of(skb,
  						       struct sk_buff_fclones,
  						       skb1);

  	struct sk_buff *n;

  	if (skb_orphan_frags(skb, gfp_mask))
  		return NULL;

  	if (skb->fclone == SKB_FCLONE_ORIG &&

  	    refcount_read(&fclones->fclone_ref) == 1) {

  		n = &fclones->skb2;

  		refcount_set(&fclones->fclone_ref, 2);

  	} else {

  		if (skb_pfmemalloc(skb))
  			gfp_mask |= __GFP_MEMALLOC;

  		n = kmem_cache_alloc(skbuff_head_cache, gfp_mask);
  		if (!n)
  			return NULL;

  		n->fclone = SKB_FCLONE_UNAVAILABLE;
  	}
  
  	return __skb_clone(n, skb);

  }

  EXPORT_SYMBOL(skb_clone);

  static void skb_headers_offset_update(struct sk_buff *skb, int off)
  {

  	/* Only adjust this if it actually is csum_start rather than csum */
  	if (skb->ip_summed == CHECKSUM_PARTIAL)
  		skb->csum_start += off;

  	/* {transport,network,mac}_header and tail are relative to skb->head */
  	skb->transport_header += off;
  	skb->network_header   += off;
  	if (skb_mac_header_was_set(skb))
  		skb->mac_header += off;
  	skb->inner_transport_header += off;
  	skb->inner_network_header += off;

  	skb->inner_mac_header += off;

  }

  static void copy_skb_header(struct sk_buff *new, const struct sk_buff *old)
  {

  	__copy_skb_header(new, old);

  	skb_shinfo(new)->gso_size = skb_shinfo(old)->gso_size;
  	skb_shinfo(new)->gso_segs = skb_shinfo(old)->gso_segs;
  	skb_shinfo(new)->gso_type = skb_shinfo(old)->gso_type;

  }

  static inline int skb_alloc_rx_flag(const struct sk_buff *skb)
  {
  	if (skb_pfmemalloc(skb))
  		return SKB_ALLOC_RX;
  	return 0;
  }

  /**
   *	skb_copy	-	create private copy of an sk_buff
   *	@skb: buffer to copy
   *	@gfp_mask: allocation priority
   *
   *	Make a copy of both an &sk_buff and its data. This is used when the
   *	caller wishes to modify the data and needs a private copy of the
   *	data to alter. Returns %NULL on failure or the pointer to the buffer
   *	on success. The returned buffer has a reference count of 1.
   *
   *	As by-product this function converts non-linear &sk_buff to linear
   *	one, so that &sk_buff becomes completely private and caller is allowed
   *	to modify all the data of returned buffer. This means that this
   *	function is not recommended for use in circumstances when only
   *	header is going to be modified. Use pskb_copy() instead.
   */

  struct sk_buff *skb_copy(const struct sk_buff *skb, gfp_t gfp_mask)

  {

  	int headerlen = skb_headroom(skb);

  	unsigned int size = skb_end_offset(skb) + skb->data_len;

  	struct sk_buff *n = __alloc_skb(size, gfp_mask,
  					skb_alloc_rx_flag(skb), NUMA_NO_NODE);

  	if (!n)
  		return NULL;
  
  	/* Set the data pointer */
  	skb_reserve(n, headerlen);
  	/* Set the tail pointer and length */
  	skb_put(n, skb->len);

  
  	if (skb_copy_bits(skb, -headerlen, n->head, headerlen + skb->len))
  		BUG();
  
  	copy_skb_header(n, skb);
  	return n;
  }

  EXPORT_SYMBOL(skb_copy);

  
  /**

   *	__pskb_copy_fclone	-  create copy of an sk_buff with private head.

   *	@skb: buffer to copy

   *	@headroom: headroom of new skb

   *	@gfp_mask: allocation priority

   *	@fclone: if true allocate the copy of the skb from the fclone
   *	cache instead of the head cache; it is recommended to set this
   *	to true for the cases where the copy will likely be cloned

   *
   *	Make a copy of both an &sk_buff and part of its data, located
   *	in header. Fragmented data remain shared. This is used when
   *	the caller wishes to modify only header of &sk_buff and needs
   *	private copy of the header to alter. Returns %NULL on failure
   *	or the pointer to the buffer on success.
   *	The returned buffer has a reference count of 1.
   */

  struct sk_buff *__pskb_copy_fclone(struct sk_buff *skb, int headroom,
  				   gfp_t gfp_mask, bool fclone)

  {

  	unsigned int size = skb_headlen(skb) + headroom;

  	int flags = skb_alloc_rx_flag(skb) | (fclone ? SKB_ALLOC_FCLONE : 0);
  	struct sk_buff *n = __alloc_skb(size, gfp_mask, flags, NUMA_NO_NODE);

  	if (!n)
  		goto out;
  
  	/* Set the data pointer */

  	skb_reserve(n, headroom);

  	/* Set the tail pointer and length */
  	skb_put(n, skb_headlen(skb));
  	/* Copy the bytes */

  	skb_copy_from_linear_data(skb, n->data, n->len);

  	n->truesize += skb->data_len;

  	n->data_len  = skb->data_len;
  	n->len	     = skb->len;
  
  	if (skb_shinfo(skb)->nr_frags) {
  		int i;

  		if (skb_orphan_frags(skb, gfp_mask) ||
  		    skb_zerocopy_clone(n, skb, gfp_mask)) {

  			kfree_skb(n);
  			n = NULL;
  			goto out;

  		}

  		for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
  			skb_shinfo(n)->frags[i] = skb_shinfo(skb)->frags[i];

  			skb_frag_ref(skb, i);

  		}
  		skb_shinfo(n)->nr_frags = i;
  	}

  	if (skb_has_frag_list(skb)) {

  		skb_shinfo(n)->frag_list = skb_shinfo(skb)->frag_list;
  		skb_clone_fraglist(n);
  	}
  
  	copy_skb_header(n, skb);
  out:
  	return n;
  }

  EXPORT_SYMBOL(__pskb_copy_fclone);

  
  /**
   *	pskb_expand_head - reallocate header of &sk_buff
   *	@skb: buffer to reallocate
   *	@nhead: room to add at head
   *	@ntail: room to add at tail
   *	@gfp_mask: allocation priority
   *

   *	Expands (or creates identical copy, if @nhead and @ntail are zero)
   *	header of @skb. &sk_buff itself is not changed. &sk_buff MUST have

   *	reference count of 1. Returns zero in the case of success or error,
   *	if expansion failed. In the last case, &sk_buff is not changed.
   *
   *	All the pointers pointing into skb header may change and must be
   *	reloaded after call to this function.
   */

  int pskb_expand_head(struct sk_buff *skb, int nhead, int ntail,

  		     gfp_t gfp_mask)

  {

  	int i, osize = skb_end_offset(skb);
  	int size = osize + nhead + ntail;

  	long off;

  	u8 *data;

  	BUG_ON(nhead < 0);

  	if (skb_shared(skb))
  		BUG();
  
  	size = SKB_DATA_ALIGN(size);

  	if (skb_pfmemalloc(skb))
  		gfp_mask |= __GFP_MEMALLOC;
  	data = kmalloc_reserve(size + SKB_DATA_ALIGN(sizeof(struct skb_shared_info)),
  			       gfp_mask, NUMA_NO_NODE, NULL);

  	if (!data)
  		goto nodata;

  	size = SKB_WITH_OVERHEAD(ksize(data));

  
  	/* Copy only real data... and, alas, header. This should be

  	 * optimized for the cases when header is void.
  	 */
  	memcpy(data + nhead, skb->head, skb_tail_pointer(skb) - skb->head);
  
  	memcpy((struct skb_shared_info *)(data + size),
  	       skb_shinfo(skb),

  	       offsetof(struct skb_shared_info, frags[skb_shinfo(skb)->nr_frags]));

  	/*
  	 * if shinfo is shared we must drop the old head gracefully, but if it
  	 * is not we can just drop the old head and let the existing refcount
  	 * be since all we did is relocate the values
  	 */
  	if (skb_cloned(skb)) {

  		if (skb_orphan_frags(skb, gfp_mask))
  			goto nofrags;

  		if (skb_zcopy(skb))

  			refcount_inc(&skb_uarg(skb)->refcnt);

  		for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)

  			skb_frag_ref(skb, i);

  		if (skb_has_frag_list(skb))
  			skb_clone_fraglist(skb);

  		skb_release_data(skb);

  	} else {
  		skb_free_head(skb);

  	}

  	off = (data + nhead) - skb->head;
  
  	skb->head     = data;

  	skb->head_frag = 0;

  	skb->data    += off;

  #ifdef NET_SKBUFF_DATA_USES_OFFSET
  	skb->end      = size;

  	off           = nhead;

  #else
  	skb->end      = skb->head + size;

  #endif

  	skb->tail	      += off;

  	skb_headers_offset_update(skb, nhead);

  	skb->cloned   = 0;

  	skb->hdr_len  = 0;

  	skb->nohdr    = 0;
  	atomic_set(&skb_shinfo(skb)->dataref, 1);

  
  	/* It is not generally safe to change skb->truesize.
  	 * For the moment, we really care of rx path, or
  	 * when skb is orphaned (not attached to a socket).
  	 */
  	if (!skb->sk || skb->destructor == sock_edemux)
  		skb->truesize += size - osize;

  	return 0;

  nofrags:
  	kfree(data);

  nodata:
  	return -ENOMEM;
  }

  EXPORT_SYMBOL(pskb_expand_head);

  
  /* Make private copy of skb with writable head and some headroom */
  
  struct sk_buff *skb_realloc_headroom(struct sk_buff *skb, unsigned int headroom)
  {
  	struct sk_buff *skb2;
  	int delta = headroom - skb_headroom(skb);
  
  	if (delta <= 0)
  		skb2 = pskb_copy(skb, GFP_ATOMIC);
  	else {
  		skb2 = skb_clone(skb, GFP_ATOMIC);
  		if (skb2 && pskb_expand_head(skb2, SKB_DATA_ALIGN(delta), 0,
  					     GFP_ATOMIC)) {
  			kfree_skb(skb2);
  			skb2 = NULL;
  		}
  	}
  	return skb2;
  }

  EXPORT_SYMBOL(skb_realloc_headroom);

  
  /**
   *	skb_copy_expand	-	copy and expand sk_buff
   *	@skb: buffer to copy
   *	@newheadroom: new free bytes at head
   *	@newtailroom: new free bytes at tail
   *	@gfp_mask: allocation priority
   *
   *	Make a copy of both an &sk_buff and its data and while doing so
   *	allocate additional space.
   *
   *	This is used when the caller wishes to modify the data and needs a
   *	private copy of the data to alter as well as more space for new fields.
   *	Returns %NULL on failure or the pointer to the buffer
   *	on success. The returned buffer has a reference count of 1.
   *
   *	You must pass %GFP_ATOMIC as the allocation priority if this function
   *	is called from an interrupt.

   */
  struct sk_buff *skb_copy_expand(const struct sk_buff *skb,

  				int newheadroom, int newtailroom,

  				gfp_t gfp_mask)

  {
  	/*
  	 *	Allocate the copy buffer
  	 */

  	struct sk_buff *n = __alloc_skb(newheadroom + skb->len + newtailroom,
  					gfp_mask, skb_alloc_rx_flag(skb),
  					NUMA_NO_NODE);

  	int oldheadroom = skb_headroom(skb);

  	int head_copy_len, head_copy_off;
  
  	if (!n)
  		return NULL;
  
  	skb_reserve(n, newheadroom);
  
  	/* Set the tail pointer and length */
  	skb_put(n, skb->len);

  	head_copy_len = oldheadroom;

  	head_copy_off = 0;
  	if (newheadroom <= head_copy_len)
  		head_copy_len = newheadroom;
  	else
  		head_copy_off = newheadroom - head_copy_len;
  
  	/* Copy the linear header and data. */
  	if (skb_copy_bits(skb, -head_copy_len, n->head + head_copy_off,
  			  skb->len + head_copy_len))
  		BUG();
  
  	copy_skb_header(n, skb);

  	skb_headers_offset_update(n, newheadroom - oldheadroom);

  	return n;
  }

  EXPORT_SYMBOL(skb_copy_expand);

  
  /**

   *	__skb_pad		-	zero pad the tail of an skb

   *	@skb: buffer to pad
   *	@pad: space to pad

   *	@free_on_error: free buffer on error

   *
   *	Ensure that a buffer is followed by a padding area that is zero
   *	filled. Used by network drivers which may DMA or transfer data
   *	beyond the buffer end onto the wire.
   *

   *	May return error in out of memory cases. The skb is freed on error
   *	if @free_on_error is true.

   */

  int __skb_pad(struct sk_buff *skb, int pad, bool free_on_error)

  {

  	int err;
  	int ntail;

  	/* If the skbuff is non linear tailroom is always zero.. */

  	if (!skb_cloned(skb) && skb_tailroom(skb) >= pad) {

  		memset(skb->data+skb->len, 0, pad);

  		return 0;

  	}

  	ntail = skb->data_len + pad - (skb->end - skb->tail);

  	if (likely(skb_cloned(skb) || ntail > 0)) {
  		err = pskb_expand_head(skb, 0, ntail, GFP_ATOMIC);
  		if (unlikely(err))
  			goto free_skb;
  	}
  
  	/* FIXME: The use of this function with non-linear skb's really needs
  	 * to be audited.
  	 */
  	err = skb_linearize(skb);
  	if (unlikely(err))
  		goto free_skb;
  
  	memset(skb->data + skb->len, 0, pad);
  	return 0;
  
  free_skb:

  	if (free_on_error)
  		kfree_skb(skb);

  	return err;

  }

  EXPORT_SYMBOL(__skb_pad);

  /**

   *	pskb_put - add data to the tail of a potentially fragmented buffer
   *	@skb: start of the buffer to use
   *	@tail: tail fragment of the buffer to use
   *	@len: amount of data to add
   *
   *	This function extends the used data area of the potentially
   *	fragmented buffer. @tail must be the last fragment of @skb -- or
   *	@skb itself. If this would exceed the total buffer size the kernel
   *	will panic. A pointer to the first byte of the extra data is
   *	returned.
   */

  void *pskb_put(struct sk_buff *skb, struct sk_buff *tail, int len)

  {
  	if (tail != skb) {
  		skb->data_len += len;
  		skb->len += len;
  	}
  	return skb_put(tail, len);
  }
  EXPORT_SYMBOL_GPL(pskb_put);
  
  /**

   *	skb_put - add data to a buffer
   *	@skb: buffer to use
   *	@len: amount of data to add
   *
   *	This function extends the used data area of the buffer. If this would
   *	exceed the total buffer size the kernel will panic. A pointer to the
   *	first byte of the extra data is returned.
   */

  void *skb_put(struct sk_buff *skb, unsigned int len)

  {

  	void *tmp = skb_tail_pointer(skb);

  	SKB_LINEAR_ASSERT(skb);
  	skb->tail += len;
  	skb->len  += len;
  	if (unlikely(skb->tail > skb->end))
  		skb_over_panic(skb, len, __builtin_return_address(0));
  	return tmp;
  }
  EXPORT_SYMBOL(skb_put);

  /**

   *	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.
   */

  void *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;
  }
  EXPORT_SYMBOL(skb_push);
  
  /**

   *	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.
   */

  void *skb_pull(struct sk_buff *skb, unsigned int len)

  {

  	return skb_pull_inline(skb, len);

  }
  EXPORT_SYMBOL(skb_pull);

  /**
   *	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);
  }
  EXPORT_SYMBOL(skb_trim);

  /* Trims skb to length len. It can change skb pointers.

   */

  int ___pskb_trim(struct sk_buff *skb, unsigned int len)

  {

  	struct sk_buff **fragp;
  	struct sk_buff *frag;

  	int offset = skb_headlen(skb);
  	int nfrags = skb_shinfo(skb)->nr_frags;
  	int i;

  	int err;
  
  	if (skb_cloned(skb) &&
  	    unlikely((err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC))))
  		return err;

  	i = 0;
  	if (offset >= len)
  		goto drop_pages;
  
  	for (; i < nfrags; i++) {

  		int end = offset + skb_frag_size(&skb_shinfo(skb)->frags[i]);

  
  		if (end < len) {
  			offset = end;
  			continue;
  		}

  		skb_frag_size_set(&skb_shinfo(skb)->frags[i++], len - offset);

  drop_pages:

  		skb_shinfo(skb)->nr_frags = i;
  
  		for (; i < nfrags; i++)

  			skb_frag_unref(skb, i);

  		if (skb_has_frag_list(skb))

  			skb_drop_fraglist(skb);

  		goto done;

  	}
  
  	for (fragp = &skb_shinfo(skb)->frag_list; (frag = *fragp);
  	     fragp = &frag->next) {
  		int end = offset + frag->len;
  
  		if (skb_shared(frag)) {
  			struct sk_buff *nfrag;
  
  			nfrag = skb_clone(frag, GFP_ATOMIC);
  			if (unlikely(!nfrag))
  				return -ENOMEM;
  
  			nfrag->next = frag->next;

  			consume_skb(frag);

  			frag = nfrag;
  			*fragp = frag;

  		}

  
  		if (end < len) {
  			offset = end;
  			continue;
  		}
  
  		if (end > len &&
  		    unlikely((err = pskb_trim(frag, len - offset))))
  			return err;
  
  		if (frag->next)
  			skb_drop_list(&frag->next);
  		break;

  	}

  done:

  	if (len > skb_headlen(skb)) {

  		skb->data_len -= skb->len - len;
  		skb->len       = len;
  	} else {

  		skb->len       = len;
  		skb->data_len  = 0;

  		skb_set_tail_pointer(skb, len);

  	}

  	if (!skb->sk || skb->destructor == sock_edemux)
  		skb_condense(skb);

  	return 0;
  }

  EXPORT_SYMBOL(___pskb_trim);

  /* Note : use pskb_trim_rcsum() instead of calling this directly
   */
  int pskb_trim_rcsum_slow(struct sk_buff *skb, unsigned int len)
  {
  	if (skb->ip_summed == CHECKSUM_COMPLETE) {
  		int delta = skb->len - len;
  
  		skb->csum = csum_sub(skb->csum,
  				     skb_checksum(skb, len, delta, 0));
  	}
  	return __pskb_trim(skb, len);
  }
  EXPORT_SYMBOL(pskb_trim_rcsum_slow);

  /**
   *	__pskb_pull_tail - advance tail of skb header
   *	@skb: buffer to reallocate
   *	@delta: number of bytes to advance tail
   *
   *	The function makes a sense only on a fragmented &sk_buff,
   *	it expands header moving its tail forward and copying necessary
   *	data from fragmented part.
   *
   *	&sk_buff MUST have reference count of 1.
   *
   *	Returns %NULL (and &sk_buff does not change) if pull failed
   *	or value of new tail of skb in the case of success.
   *
   *	All the pointers pointing into skb header may change and must be
   *	reloaded after call to this function.
   */
  
  /* Moves tail of skb head forward, copying data from fragmented part,
   * when it is necessary.
   * 1. It may fail due to malloc failure.
   * 2. It may change skb pointers.
   *
   * It is pretty complicated. Luckily, it is called only in exceptional cases.
   */

  void *__pskb_pull_tail(struct sk_buff *skb, int delta)

  {
  	/* If skb has not enough free space at tail, get new one
  	 * plus 128 bytes for future expansions. If we have enough
  	 * room at tail, reallocate without expansion only if skb is cloned.
  	 */

  	int i, k, eat = (skb->tail + delta) - skb->end;

  
  	if (eat > 0 || skb_cloned(skb)) {
  		if (pskb_expand_head(skb, 0, eat > 0 ? eat + 128 : 0,
  				     GFP_ATOMIC))
  			return NULL;
  	}

  	if (skb_copy_bits(skb, skb_headlen(skb), skb_tail_pointer(skb), delta))

  		BUG();
  
  	/* Optimization: no fragments, no reasons to preestimate
  	 * size of pulled pages. Superb.
  	 */

  	if (!skb_has_frag_list(skb))

  		goto pull_pages;
  
  	/* Estimate size of pulled pages. */
  	eat = delta;
  	for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {

  		int size = skb_frag_size(&skb_shinfo(skb)->frags[i]);
  
  		if (size >= eat)

  			goto pull_pages;