1 /*

     2  *	Definitions for the 'struct sk_buff' memory handlers.

     3  *

     4  *	Authors:

     5  *		Alan Cox, <gw4pts@gw4pts.ampr.org>

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

     7  *

     8  *	This program is free software; you can redistribute it and/or

     9  *	modify it under the terms of the GNU General Public License

    10  *	as published by the Free Software Foundation; either version

    11  *	2 of the License, or (at your option) any later version.

    12  */

    13 

    14 #ifndef _LINUX_SKBUFF_H

    15 #define _LINUX_SKBUFF_H

    16 

    17 #include <linux/kernel.h>

    18 #include <linux/compiler.h>

    19 #include <linux/time.h>

    20 #include <linux/cache.h>

    21 

    22 #include <asm/atomic.h>

    23 #include <asm/types.h>

    24 #include <linux/spinlock.h>

    25 #include <linux/net.h>

    26 #include <linux/textsearch.h>

    27 #include <net/checksum.h>

    28 #include <linux/rcupdate.h>

    29 #include <linux/dmaengine.h>

    30 #include <linux/hrtimer.h>

    31 

    32 #define HAVE_ALLOC_SKB		/* For the drivers to know */

    33 #define HAVE_ALIGNABLE_SKB	/* Ditto 8)		   */

    34 

    35 /* Don't change this without changing skb_csum_unnecessary! */

    36 #define CHECKSUM_NONE 0

    37 #define CHECKSUM_UNNECESSARY 1

    38 #define CHECKSUM_COMPLETE 2

    39 #define CHECKSUM_PARTIAL 3

    40 

    41 #define SKB_DATA_ALIGN(X)	(((X) + (SMP_CACHE_BYTES - 1)) & \

    42 				 ~(SMP_CACHE_BYTES - 1))

    43 #define SKB_WITH_OVERHEAD(X)	\

    44 	((X) - SKB_DATA_ALIGN(sizeof(struct skb_shared_info)))

    45 #define SKB_MAX_ORDER(X, ORDER) \

    46 	SKB_WITH_OVERHEAD((PAGE_SIZE << (ORDER)) - (X))

    47 #define SKB_MAX_HEAD(X)		(SKB_MAX_ORDER((X), 0))

    48 #define SKB_MAX_ALLOC		(SKB_MAX_ORDER(0, 2))

    49 

    50 /* A. Checksumming of received packets by device.

    51  *

    52  *	NONE: device failed to checksum this packet.

    53  *		skb->csum is undefined.

    54  *

    55  *	UNNECESSARY: device parsed packet and wouldbe verified checksum.

    56  *		skb->csum is undefined.

    57  *	      It is bad option, but, unfortunately, many of vendors do this.

    58  *	      Apparently with secret goal to sell you new device, when you

    59  *	      will add new protocol to your host. F.e. IPv6. 8)

    60  *

    61  *	COMPLETE: the most generic way. Device supplied checksum of _all_

    62  *	    the packet as seen by netif_rx in skb->csum.

    63  *	    NOTE: Even if device supports only some protocols, but

    64  *	    is able to produce some skb->csum, it MUST use COMPLETE,

    65  *	    not UNNECESSARY.

    66  *

    67  *	PARTIAL: identical to the case for output below.  This may occur

    68  *	    on a packet received directly from another Linux OS, e.g.,

    69  *	    a virtualised Linux kernel on the same host.  The packet can

    70  *	    be treated in the same way as UNNECESSARY except that on

    71  *	    output (i.e., forwarding) the checksum must be filled in

    72  *	    by the OS or the hardware.

    73  *

    74  * B. Checksumming on output.

    75  *

    76  *	NONE: skb is checksummed by protocol or csum is not required.

    77  *

    78  *	PARTIAL: device is required to csum packet as seen by hard_start_xmit

    79  *	from skb->csum_start to the end and to record the checksum

    80  *	at skb->csum_start + skb->csum_offset.

    81  *

    82  *	Device must show its capabilities in dev->features, set

    83  *	at device setup time.

    84  *	NETIF_F_HW_CSUM	- it is clever device, it is able to checksum

    85  *			  everything.

    86  *	NETIF_F_NO_CSUM - loopback or reliable single hop media.

    87  *	NETIF_F_IP_CSUM - device is dumb. It is able to csum only

    88  *			  TCP/UDP over IPv4. Sigh. Vendors like this

    89  *			  way by an unknown reason. Though, see comment above

    90  *			  about CHECKSUM_UNNECESSARY. 8)

    91  *	NETIF_F_IPV6_CSUM about as dumb as the last one but does IPv6 instead.

    92  *

    93  *	Any questions? No questions, good. 		--ANK

    94  */

    95 

    96 struct net_device;

    97 struct scatterlist;

    98 struct pipe_inode_info;

    99 

   100 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)

   101 struct nf_conntrack {

   102 	atomic_t use;

   103 };

   104 #endif

   105 

   106 #ifdef CONFIG_BRIDGE_NETFILTER

   107 struct nf_bridge_info {

   108 	atomic_t use;

   109 	struct net_device *physindev;

   110 	struct net_device *physoutdev;

   111 	unsigned int mask;

   112 	unsigned long data[32 / sizeof(unsigned long)];

   113 };

   114 #endif

   115 

   116 struct sk_buff_head {

   117 	/* These two members must be first. */

   118 	struct sk_buff	*next;

   119 	struct sk_buff	*prev;

   120 

   121 	__u32		qlen;

   122 	spinlock_t	lock;

   123 };

   124 

   125 struct sk_buff;

   126 

   127 /* To allow 64K frame to be packed as single skb without frag_list */

   128 #define MAX_SKB_FRAGS (65536/PAGE_SIZE + 2)

   129 

   130 typedef struct skb_frag_struct skb_frag_t;

   131 

   132 struct skb_frag_struct {

   133 	struct page *page;

   134 	__u32 page_offset;

   135 	__u32 size;

   136 };

   137 

   138 /* This data is invariant across clones and lives at

   139  * the end of the header data, ie. at skb->end.

   140  */

   141 struct skb_shared_info {

   142 	atomic_t	dataref;

   143 	unsigned short	nr_frags;

   144 	unsigned short	gso_size;

   145 	/* Warning: this field is not always filled in (UFO)! */

   146 	unsigned short	gso_segs;

   147 	unsigned short  gso_type;

   148 	__be32          ip6_frag_id;

   149 #ifdef CONFIG_HAS_DMA

   150 	unsigned int	num_dma_maps;

   151 #endif

   152 	struct sk_buff	*frag_list;

   153 	skb_frag_t	frags[MAX_SKB_FRAGS];

   154 #ifdef CONFIG_HAS_DMA

   155 	dma_addr_t	dma_maps[MAX_SKB_FRAGS + 1];

   156 #endif

   157 };

   158 

   159 /* We divide dataref into two halves.  The higher 16 bits hold references

   160  * to the payload part of skb->data.  The lower 16 bits hold references to

   161  * the entire skb->data.  A clone of a headerless skb holds the length of

   162  * the header in skb->hdr_len.

   163  *

   164  * All users must obey the rule that the skb->data reference count must be

   165  * greater than or equal to the payload reference count.

   166  *

   167  * Holding a reference to the payload part means that the user does not

   168  * care about modifications to the header part of skb->data.

   169  */

   170 #define SKB_DATAREF_SHIFT 16

   171 #define SKB_DATAREF_MASK ((1 << SKB_DATAREF_SHIFT) - 1)

   172 

   173 

   174 enum {

   175 	SKB_FCLONE_UNAVAILABLE,

   176 	SKB_FCLONE_ORIG,

   177 	SKB_FCLONE_CLONE,

   178 };

   179 

   180 enum {

   181 	SKB_GSO_TCPV4 = 1 << 0,

   182 	SKB_GSO_UDP = 1 << 1,

   183 

   184 	/* This indicates the skb is from an untrusted source. */

   185 	SKB_GSO_DODGY = 1 << 2,

   186 

   187 	/* This indicates the tcp segment has CWR set. */

   188 	SKB_GSO_TCP_ECN = 1 << 3,

   189 

   190 	SKB_GSO_TCPV6 = 1 << 4,

   191 };

   192 

   193 #if BITS_PER_LONG > 32

   194 #define NET_SKBUFF_DATA_USES_OFFSET 1

   195 #endif

   196 

   197 #ifdef NET_SKBUFF_DATA_USES_OFFSET

   198 typedef unsigned int sk_buff_data_t;

   199 #else

   200 typedef unsigned char *sk_buff_data_t;

   201 #endif

   202 

   203 /** 

   204  *	struct sk_buff - socket buffer

   205  *	@next: Next buffer in list

   206  *	@prev: Previous buffer in list

   207  *	@sk: Socket we are owned by

   208  *	@tstamp: Time we arrived

   209  *	@dev: Device we arrived on/are leaving by

   210  *	@transport_header: Transport layer header

   211  *	@network_header: Network layer header

   212  *	@mac_header: Link layer header

   213  *	@dst: destination entry

   214  *	@sp: the security path, used for xfrm

   215  *	@cb: Control buffer. Free for use by every layer. Put private vars here

   216  *	@len: Length of actual data

   217  *	@data_len: Data length

   218  *	@mac_len: Length of link layer header

   219  *	@hdr_len: writable header length of cloned skb

   220  *	@csum: Checksum (must include start/offset pair)

   221  *	@csum_start: Offset from skb->head where checksumming should start

   222  *	@csum_offset: Offset from csum_start where checksum should be stored

   223  *	@local_df: allow local fragmentation

   224  *	@cloned: Head may be cloned (check refcnt to be sure)

   225  *	@nohdr: Payload reference only, must not modify header

   226  *	@pkt_type: Packet class

   227  *	@fclone: skbuff clone status

   228  *	@ip_summed: Driver fed us an IP checksum

   229  *	@priority: Packet queueing priority

   230  *	@users: User count - see {datagram,tcp}.c

   231  *	@protocol: Packet protocol from driver

   232  *	@truesize: Buffer size 

   233  *	@head: Head of buffer

   234  *	@data: Data head pointer

   235  *	@tail: Tail pointer

   236  *	@end: End pointer

   237  *	@destructor: Destruct function

   238  *	@mark: Generic packet mark

   239  *	@nfct: Associated connection, if any

   240  *	@ipvs_property: skbuff is owned by ipvs

   241  *	@peeked: this packet has been seen already, so stats have been

   242  *		done for it, don't do them again

   243  *	@nf_trace: netfilter packet trace flag

   244  *	@nfctinfo: Relationship of this skb to the connection

   245  *	@nfct_reasm: netfilter conntrack re-assembly pointer

   246  *	@nf_bridge: Saved data about a bridged frame - see br_netfilter.c

   247  *	@iif: ifindex of device we arrived on

   248  *	@queue_mapping: Queue mapping for multiqueue devices

   249  *	@tc_index: Traffic control index

   250  *	@tc_verd: traffic control verdict

   251  *	@ndisc_nodetype: router type (from link layer)

   252  *	@do_not_encrypt: set to prevent encryption of this frame

   253  *	@dma_cookie: a cookie to one of several possible DMA operations

   254  *		done by skb DMA functions

   255  *	@secmark: security marking

   256  *	@vlan_tci: vlan tag control information

   257  */

   258 

   259 struct sk_buff {

   260 	/* These two members must be first. */

   261 	struct sk_buff		*next;

   262 	struct sk_buff		*prev;

   263 

   264 	struct sock		*sk;

   265 	ktime_t			tstamp;

   266 	struct net_device	*dev;

   267 

   268 	union {

   269 		struct  dst_entry	*dst;

   270 		struct  rtable		*rtable;

   271 	};

   272 	struct	sec_path	*sp;

   273 

   274 	/*

   275 	 * This is the control buffer. It is free to use for every

   276 	 * layer. Please put your private variables there. If you

   277 	 * want to keep them across layers you have to do a skb_clone()

   278 	 * first. This is owned by whoever has the skb queued ATM.

   279 	 */

   280 	char			cb[48];

   281 

   282 	unsigned int		len,

   283 				data_len;

   284 	__u16			mac_len,

   285 				hdr_len;

   286 	union {

   287 		__wsum		csum;

   288 		struct {

   289 			__u16	csum_start;

   290 			__u16	csum_offset;

   291 		};

   292 	};

   293 	__u32			priority;

   294 	__u8			local_df:1,

   295 				cloned:1,

   296 				ip_summed:2,

   297 				nohdr:1,

   298 				nfctinfo:3;

   299 	__u8			pkt_type:3,

   300 				fclone:2,

   301 				ipvs_property:1,

   302 				peeked:1,

   303 				nf_trace:1;

   304 	__be16			protocol;

   305 

   306 	void			(*destructor)(struct sk_buff *skb);

   307 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)

   308 	struct nf_conntrack	*nfct;

   309 	struct sk_buff		*nfct_reasm;

   310 #endif

   311 #ifdef CONFIG_BRIDGE_NETFILTER

   312 	struct nf_bridge_info	*nf_bridge;

   313 #endif

   314 

   315 	int			iif;

   316 	__u16			queue_mapping;

   317 #ifdef CONFIG_NET_SCHED

   318 	__u16			tc_index;	/* traffic control index */

   319 #ifdef CONFIG_NET_CLS_ACT

   320 	__u16			tc_verd;	/* traffic control verdict */

   321 #endif

   322 #endif

   323 #ifdef CONFIG_IPV6_NDISC_NODETYPE

   324 	__u8			ndisc_nodetype:2;

   325 #endif

   326 #if defined(CONFIG_MAC80211) || defined(CONFIG_MAC80211_MODULE)

   327 	__u8			do_not_encrypt:1;

   328 #endif

   329 	/* 0/13/14 bit hole */

   330 

   331 #ifdef CONFIG_NET_DMA

   332 	dma_cookie_t		dma_cookie;

   333 #endif

   334 #ifdef CONFIG_NETWORK_SECMARK

   335 	__u32			secmark;

   336 #endif

   337 

   338 	__u32			mark;

   339 

   340 	__u16			vlan_tci;

   341 

   342 	sk_buff_data_t		transport_header;

   343 	sk_buff_data_t		network_header;

   344 	sk_buff_data_t		mac_header;

   345 	/* These elements must be at the end, see alloc_skb() for details.  */

   346 	sk_buff_data_t		tail;

   347 	sk_buff_data_t		end;

   348 	unsigned char		*head,

   349 				*data;

   350 	unsigned int		truesize;

   351 	atomic_t		users;

   352 };

   353 

   354 #ifdef __KERNEL__

   355 /*

   356  *	Handling routines are only of interest to the kernel

   357  */

   358 #include <linux/slab.h>

   359 

   360 #include <asm/system.h>

   361 

   362 #ifdef CONFIG_HAS_DMA

   363 #include <linux/dma-mapping.h>

   364 extern int skb_dma_map(struct device *dev, struct sk_buff *skb,

   365 		       enum dma_data_direction dir);

   366 extern void skb_dma_unmap(struct device *dev, struct sk_buff *skb,

   367 			  enum dma_data_direction dir);

   368 #endif

   369 

   370 extern void kfree_skb(struct sk_buff *skb);

   371 extern void	       __kfree_skb(struct sk_buff *skb);

   372 extern struct sk_buff *__alloc_skb(unsigned int size,

   373 				   gfp_t priority, int fclone, int node);

   374 static inline struct sk_buff *alloc_skb(unsigned int size,

   375 					gfp_t priority)

   376 {

   377 	return __alloc_skb(size, priority, 0, -1);

   378 }

   379 

   380 static inline struct sk_buff *alloc_skb_fclone(unsigned int size,

   381 					       gfp_t priority)

   382 {

   383 	return __alloc_skb(size, priority, 1, -1);

   384 }

   385 

   386 extern int skb_recycle_check(struct sk_buff *skb, int skb_size);

   387 

   388 extern struct sk_buff *skb_morph(struct sk_buff *dst, struct sk_buff *src);

   389 extern struct sk_buff *skb_clone(struct sk_buff *skb,

   390 				 gfp_t priority);

   391 extern struct sk_buff *skb_copy(const struct sk_buff *skb,

   392 				gfp_t priority);

   393 extern struct sk_buff *pskb_copy(struct sk_buff *skb,

   394 				 gfp_t gfp_mask);

   395 extern int	       pskb_expand_head(struct sk_buff *skb,

   396 					int nhead, int ntail,

   397 					gfp_t gfp_mask);

   398 extern struct sk_buff *skb_realloc_headroom(struct sk_buff *skb,

   399 					    unsigned int headroom);

   400 extern struct sk_buff *skb_copy_expand(const struct sk_buff *skb,

   401 				       int newheadroom, int newtailroom,

   402 				       gfp_t priority);

   403 extern int	       skb_to_sgvec(struct sk_buff *skb,

   404 				    struct scatterlist *sg, int offset,

   405 				    int len);

   406 extern int	       skb_cow_data(struct sk_buff *skb, int tailbits,

   407 				    struct sk_buff **trailer);

   408 extern int	       skb_pad(struct sk_buff *skb, int pad);

   409 #define dev_kfree_skb(a)	kfree_skb(a)

   410 extern void	      skb_over_panic(struct sk_buff *skb, int len,

   411 				     void *here);

   412 extern void	      skb_under_panic(struct sk_buff *skb, int len,

   413 				      void *here);

   414 extern void	      skb_truesize_bug(struct sk_buff *skb);

   415 

   416 static inline void skb_truesize_check(struct sk_buff *skb)

   417 {

   418 	int len = sizeof(struct sk_buff) + skb->len;

   419 

   420 	if (unlikely((int)skb->truesize < len))

   421 		skb_truesize_bug(skb);

   422 }

   423 

   424 extern int skb_append_datato_frags(struct sock *sk, struct sk_buff *skb,

   425 			int getfrag(void *from, char *to, int offset,

   426 			int len,int odd, struct sk_buff *skb),

   427 			void *from, int length);

   428 

   429 struct skb_seq_state

   430 {

   431 	__u32		lower_offset;

   432 	__u32		upper_offset;

   433 	__u32		frag_idx;

   434 	__u32		stepped_offset;

   435 	struct sk_buff	*root_skb;

   436 	struct sk_buff	*cur_skb;

   437 	__u8		*frag_data;

   438 };

   439 

   440 extern void	      skb_prepare_seq_read(struct sk_buff *skb,

   441 					   unsigned int from, unsigned int to,

   442 					   struct skb_seq_state *st);

   443 extern unsigned int   skb_seq_read(unsigned int consumed, const u8 **data,

   444 				   struct skb_seq_state *st);

   445 extern void	      skb_abort_seq_read(struct skb_seq_state *st);

   446 

   447 extern unsigned int   skb_find_text(struct sk_buff *skb, unsigned int from,

   448 				    unsigned int to, struct ts_config *config,

   449 				    struct ts_state *state);

   450 

   451 #ifdef NET_SKBUFF_DATA_USES_OFFSET

   452 static inline unsigned char *skb_end_pointer(const struct sk_buff *skb)

   453 {

   454 	return skb->head + skb->end;

   455 }

   456 #else

   457 static inline unsigned char *skb_end_pointer(const struct sk_buff *skb)

   458 {

   459 	return skb->end;

   460 }

   461 #endif

   462 

   463 /* Internal */

   464 #define skb_shinfo(SKB)	((struct skb_shared_info *)(skb_end_pointer(SKB)))

   465 

   466 /**

   467  *	skb_queue_empty - check if a queue is empty

   468  *	@list: queue head

   469  *

   470  *	Returns true if the queue is empty, false otherwise.

   471  */

   472 static inline int skb_queue_empty(const struct sk_buff_head *list)

   473 {

   474 	return list->next == (struct sk_buff *)list;

   475 }

   476 

   477 /**

   478  *	skb_queue_is_last - check if skb is the last entry in the queue

   479  *	@list: queue head

   480  *	@skb: buffer

   481  *

   482  *	Returns true if @skb is the last buffer on the list.

   483  */

   484 static inline bool skb_queue_is_last(const struct sk_buff_head *list,

   485 				     const struct sk_buff *skb)

   486 {

   487 	return (skb->next == (struct sk_buff *) list);

   488 }

   489 

   490 /**

   491  *	skb_queue_next - return the next packet in the queue

   492  *	@list: queue head

   493  *	@skb: current buffer

   494  *

   495  *	Return the next packet in @list after @skb.  It is only valid to

   496  *	call this if skb_queue_is_last() evaluates to false.

   497  */

   498 static inline struct sk_buff *skb_queue_next(const struct sk_buff_head *list,

   499 					     const struct sk_buff *skb)

   500 {

   501 	/* This BUG_ON may seem severe, but if we just return then we

   502 	 * are going to dereference garbage.

   503 	 */

   504 	BUG_ON(skb_queue_is_last(list, skb));

   505 	return skb->next;

   506 }

   507 

   508 /**

   509  *	skb_get - reference buffer

   510  *	@skb: buffer to reference

   511  *

   512  *	Makes another reference to a socket buffer and returns a pointer

   513  *	to the buffer.

   514  */

   515 static inline struct sk_buff *skb_get(struct sk_buff *skb)

   516 {

   517 	atomic_inc(&skb->users);

   518 	return skb;

   519 }

   520 

   521 /*

   522  * If users == 1, we are the only owner and are can avoid redundant

   523  * atomic change.

   524  */

   525 

   526 /**

   527  *	skb_cloned - is the buffer a clone

   528  *	@skb: buffer to check

   529  *

   530  *	Returns true if the buffer was generated with skb_clone() and is

   531  *	one of multiple shared copies of the buffer. Cloned buffers are

   532  *	shared data so must not be written to under normal circumstances.

   533  */

   534 static inline int skb_cloned(const struct sk_buff *skb)

   535 {

   536 	return skb->cloned &&

   537 	       (atomic_read(&skb_shinfo(skb)->dataref) & SKB_DATAREF_MASK) != 1;

   538 }

   539 

   540 /**

   541  *	skb_header_cloned - is the header a clone

   542  *	@skb: buffer to check

   543  *

   544  *	Returns true if modifying the header part of the buffer requires

   545  *	the data to be copied.

   546  */

   547 static inline int skb_header_cloned(const struct sk_buff *skb)

   548 {

   549 	int dataref;

   550 

   551 	if (!skb->cloned)

   552 		return 0;

   553 

   554 	dataref = atomic_read(&skb_shinfo(skb)->dataref);

   555 	dataref = (dataref & SKB_DATAREF_MASK) - (dataref >> SKB_DATAREF_SHIFT);

   556 	return dataref != 1;

   557 }

   558 

   559 /**

   560  *	skb_header_release - release reference to header

   561  *	@skb: buffer to operate on

   562  *

   563  *	Drop a reference to the header part of the buffer.  This is done

   564  *	by acquiring a payload reference.  You must not read from the header

   565  *	part of skb->data after this.

   566  */

   567 static inline void skb_header_release(struct sk_buff *skb)

   568 {

   569 	BUG_ON(skb->nohdr);

   570 	skb->nohdr = 1;

   571 	atomic_add(1 << SKB_DATAREF_SHIFT, &skb_shinfo(skb)->dataref);

   572 }

   573 

   574 /**

   575  *	skb_shared - is the buffer shared

   576  *	@skb: buffer to check

   577  *

   578  *	Returns true if more than one person has a reference to this

   579  *	buffer.

   580  */

   581 static inline int skb_shared(const struct sk_buff *skb)

   582 {

   583 	return atomic_read(&skb->users) != 1;

   584 }

   585 

   586 /**

   587  *	skb_share_check - check if buffer is shared and if so clone it

   588  *	@skb: buffer to check

   589  *	@pri: priority for memory allocation

   590  *

   591  *	If the buffer is shared the buffer is cloned and the old copy

   592  *	drops a reference. A new clone with a single reference is returned.

   593  *	If the buffer is not shared the original buffer is returned. When

   594  *	being called from interrupt status or with spinlocks held pri must

   595  *	be GFP_ATOMIC.

   596  *

   597  *	NULL is returned on a memory allocation failure.

   598  */

   599 static inline struct sk_buff *skb_share_check(struct sk_buff *skb,

   600 					      gfp_t pri)

   601 {

   602 	might_sleep_if(pri & __GFP_WAIT);

   603 	if (skb_shared(skb)) {

   604 		struct sk_buff *nskb = skb_clone(skb, pri);

   605 		kfree_skb(skb);

   606 		skb = nskb;

   607 	}

   608 	return skb;

   609 }

   610 

   611 /*

   612  *	Copy shared buffers into a new sk_buff. We effectively do COW on

   613  *	packets to handle cases where we have a local reader and forward

   614  *	and a couple of other messy ones. The normal one is tcpdumping

   615  *	a packet thats being forwarded.

   616  */

   617 

   618 /**

   619  *	skb_unshare - make a copy of a shared buffer

   620  *	@skb: buffer to check

   621  *	@pri: priority for memory allocation

   622  *

   623  *	If the socket buffer is a clone then this function creates a new

   624  *	copy of the data, drops a reference count on the old copy and returns

   625  *	the new copy with the reference count at 1. If the buffer is not a clone

   626  *	the original buffer is returned. When called with a spinlock held or

   627  *	from interrupt state @pri must be %GFP_ATOMIC

   628  *

   629  *	%NULL is returned on a memory allocation failure.

   630  */

   631 static inline struct sk_buff *skb_unshare(struct sk_buff *skb,

   632 					  gfp_t pri)

   633 {

   634 	might_sleep_if(pri & __GFP_WAIT);

   635 	if (skb_cloned(skb)) {

   636 		struct sk_buff *nskb = skb_copy(skb, pri);

   637 		kfree_skb(skb);	/* Free our shared copy */

   638 		skb = nskb;

   639 	}

   640 	return skb;

   641 }

   642 

   643 /**

   644  *	skb_peek

   645  *	@list_: list to peek at

   646  *

   647  *	Peek an &sk_buff. Unlike most other operations you _MUST_

   648  *	be careful with this one. A peek leaves the buffer on the

   649  *	list and someone else may run off with it. You must hold

   650  *	the appropriate locks or have a private queue to do this.

   651  *

   652  *	Returns %NULL for an empty list or a pointer to the head element.

   653  *	The reference count is not incremented and the reference is therefore

   654  *	volatile. Use with caution.

   655  */

   656 static inline struct sk_buff *skb_peek(struct sk_buff_head *list_)

   657 {

   658 	struct sk_buff *list = ((struct sk_buff *)list_)->next;

   659 	if (list == (struct sk_buff *)list_)

   660 		list = NULL;

   661 	return list;

   662 }

   663 

   664 /**

   665  *	skb_peek_tail

   666  *	@list_: list to peek at

   667  *

   668  *	Peek an &sk_buff. Unlike most other operations you _MUST_

   669  *	be careful with this one. A peek leaves the buffer on the

   670  *	list and someone else may run off with it. You must hold

   671  *	the appropriate locks or have a private queue to do this.

   672  *

   673  *	Returns %NULL for an empty list or a pointer to the tail element.

   674  *	The reference count is not incremented and the reference is therefore

   675  *	volatile. Use with caution.

   676  */

   677 static inline struct sk_buff *skb_peek_tail(struct sk_buff_head *list_)

   678 {

   679 	struct sk_buff *list = ((struct sk_buff *)list_)->prev;

   680 	if (list == (struct sk_buff *)list_)

   681 		list = NULL;

   682 	return list;

   683 }

   684 

   685 /**

   686  *	skb_queue_len	- get queue length

   687  *	@list_: list to measure

   688  *

   689  *	Return the length of an &sk_buff queue.

   690  */

   691 static inline __u32 skb_queue_len(const struct sk_buff_head *list_)

   692 {

   693 	return list_->qlen;

   694 }

   695 

   696 /**

   697  *	__skb_queue_head_init - initialize non-spinlock portions of sk_buff_head

   698  *	@list: queue to initialize

   699  *

   700  *	This initializes only the list and queue length aspects of

   701  *	an sk_buff_head object.  This allows to initialize the list

   702  *	aspects of an sk_buff_head without reinitializing things like

   703  *	the spinlock.  It can also be used for on-stack sk_buff_head

   704  *	objects where the spinlock is known to not be used.

   705  */

   706 static inline void __skb_queue_head_init(struct sk_buff_head *list)

   707 {

   708 	list->prev = list->next = (struct sk_buff *)list;

   709 	list->qlen = 0;

   710 }

   711 

   712 /*

   713  * This function creates a split out lock class for each invocation;

   714  * this is needed for now since a whole lot of users of the skb-queue

   715  * infrastructure in drivers have different locking usage (in hardirq)

   716  * than the networking core (in softirq only). In the long run either the

   717  * network layer or drivers should need annotation to consolidate the

   718  * main types of usage into 3 classes.

   719  */

   720 static inline void skb_queue_head_init(struct sk_buff_head *list)

   721 {

   722 	spin_lock_init(&list->lock);

   723 	__skb_queue_head_init(list);

   724 }

   725 

   726 static inline void skb_queue_head_init_class(struct sk_buff_head *list,

   727 		struct lock_class_key *class)

   728 {

   729 	skb_queue_head_init(list);

   730 	lockdep_set_class(&list->lock, class);

   731 }

   732 

   733 /*

   734  *	Insert an sk_buff on a list.

   735  *

   736  *	The "__skb_xxxx()" functions are the non-atomic ones that

   737  *	can only be called with interrupts disabled.

   738  */

   739 extern void        skb_insert(struct sk_buff *old, struct sk_buff *newsk, struct sk_buff_head *list);

   740 static inline void __skb_insert(struct sk_buff *newsk,

   741 				struct sk_buff *prev, struct sk_buff *next,

   742 				struct sk_buff_head *list)

   743 {

   744 	newsk->next = next;

   745 	newsk->prev = prev;

   746 	next->prev  = prev->next = newsk;

   747 	list->qlen++;

   748 }

   749 

   750 static inline void __skb_queue_splice(const struct sk_buff_head *list,

   751 				      struct sk_buff *prev,

   752 				      struct sk_buff *next)

   753 {

   754 	struct sk_buff *first = list->next;

   755 	struct sk_buff *last = list->prev;

   756 

   757 	first->prev = prev;

   758 	prev->next = first;

   759 

   760 	last->next = next;

   761 	next->prev = last;

   762 }

   763 

   764 /**

   765  *	skb_queue_splice - join two skb lists, this is designed for stacks

   766  *	@list: the new list to add

   767  *	@head: the place to add it in the first list

   768  */

   769 static inline void skb_queue_splice(const struct sk_buff_head *list,

   770 				    struct sk_buff_head *head)

   771 {

   772 	if (!skb_queue_empty(list)) {

   773 		__skb_queue_splice(list, (struct sk_buff *) head, head->next);

   774 		head->qlen += list->qlen;

   775 	}

   776 }

   777 

   778 /**

   779  *	skb_queue_splice - join two skb lists and reinitialise the emptied list

   780  *	@list: the new list to add

   781  *	@head: the place to add it in the first list

   782  *

   783  *	The list at @list is reinitialised

   784  */

   785 static inline void skb_queue_splice_init(struct sk_buff_head *list,

   786 					 struct sk_buff_head *head)

   787 {

   788 	if (!skb_queue_empty(list)) {

   789 		__skb_queue_splice(list, (struct sk_buff *) head, head->next);

   790 		head->qlen += list->qlen;

   791 		__skb_queue_head_init(list);

   792 	}

   793 }

   794 

   795 /**

   796  *	skb_queue_splice_tail - join two skb lists, each list being a queue

   797  *	@list: the new list to add

   798  *	@head: the place to add it in the first list

   799  */

   800 static inline void skb_queue_splice_tail(const struct sk_buff_head *list,

   801 					 struct sk_buff_head *head)

   802 {

   803 	if (!skb_queue_empty(list)) {

   804 		__skb_queue_splice(list, head->prev, (struct sk_buff *) head);

   805 		head->qlen += list->qlen;

   806 	}

   807 }

   808 

   809 /**

   810  *	skb_queue_splice_tail - join two skb lists and reinitialise the emptied list

   811  *	@list: the new list to add

   812  *	@head: the place to add it in the first list

   813  *

   814  *	Each of the lists is a queue.

   815  *	The list at @list is reinitialised

   816  */

   817 static inline void skb_queue_splice_tail_init(struct sk_buff_head *list,

   818 					      struct sk_buff_head *head)

   819 {

   820 	if (!skb_queue_empty(list)) {

   821 		__skb_queue_splice(list, head->prev, (struct sk_buff *) head);

   822 		head->qlen += list->qlen;

   823 		__skb_queue_head_init(list);

   824 	}

   825 }

   826 

   827 /**

   828  *	__skb_queue_after - queue a buffer at the list head

   829  *	@list: list to use

   830  *	@prev: place after this buffer

   831  *	@newsk: buffer to queue

   832  *

   833  *	Queue a buffer int the middle of a list. This function takes no locks

   834  *	and you must therefore hold required locks before calling it.

   835  *

   836  *	A buffer cannot be placed on two lists at the same time.

   837  */

   838 static inline void __skb_queue_after(struct sk_buff_head *list,

   839 				     struct sk_buff *prev,

   840 				     struct sk_buff *newsk)

   841 {

   842 	__skb_insert(newsk, prev, prev->next, list);

   843 }

   844 

   845 extern void skb_append(struct sk_buff *old, struct sk_buff *newsk,

   846 		       struct sk_buff_head *list);

   847 

   848 static inline void __skb_queue_before(struct sk_buff_head *list,

   849 				      struct sk_buff *next,

   850 				      struct sk_buff *newsk)

   851 {

   852 	__skb_insert(newsk, next->prev, next, list);

   853 }

   854 

   855 /**

   856  *	__skb_queue_head - queue a buffer at the list head

   857  *	@list: list to use

   858  *	@newsk: buffer to queue

   859  *

   860  *	Queue a buffer at the start of a list. This function takes no locks

   861  *	and you must therefore hold required locks before calling it.

   862  *

   863  *	A buffer cannot be placed on two lists at the same time.

   864  */

   865 extern void skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk);

   866 static inline void __skb_queue_head(struct sk_buff_head *list,

   867 				    struct sk_buff *newsk)

   868 {

   869 	__skb_queue_after(list, (struct sk_buff *)list, newsk);

   870 }

   871 

   872 /**

   873  *	__skb_queue_tail - queue a buffer at the list tail

   874  *	@list: list to use

   875  *	@newsk: buffer to queue

   876  *

   877  *	Queue a buffer at the end of a list. This function takes no locks

   878  *	and you must therefore hold required locks before calling it.

   879  *

   880  *	A buffer cannot be placed on two lists at the same time.

   881  */

   882 extern void skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk);

   883 static inline void __skb_queue_tail(struct sk_buff_head *list,

   884 				   struct sk_buff *newsk)

   885 {

   886 	__skb_queue_before(list, (struct sk_buff *)list, newsk);

   887 }

   888 

   889 /*

   890  * remove sk_buff from list. _Must_ be called atomically, and with

   891  * the list known..

   892  */

   893 extern void	   skb_unlink(struct sk_buff *skb, struct sk_buff_head *list);

   894 static inline void __skb_unlink(struct sk_buff *skb, struct sk_buff_head *list)

   895 {

   896 	struct sk_buff *next, *prev;

   897 

   898 	list->qlen--;

   899 	next	   = skb->next;

   900 	prev	   = skb->prev;

   901 	skb->next  = skb->prev = NULL;

   902 	next->prev = prev;

   903 	prev->next = next;

   904 }

   905 

   906 /**

   907  *	__skb_dequeue - remove from the head of the queue

   908  *	@list: list to dequeue from

   909  *

   910  *	Remove the head of the list. This function does not take any locks

   911  *	so must be used with appropriate locks held only. The head item is

   912  *	returned or %NULL if the list is empty.

   913  */

   914 extern struct sk_buff *skb_dequeue(struct sk_buff_head *list);

   915 static inline struct sk_buff *__skb_dequeue(struct sk_buff_head *list)

   916 {

   917 	struct sk_buff *skb = skb_peek(list);

   918 	if (skb)

   919 		__skb_unlink(skb, list);

   920 	return skb;

   921 }

   922 

   923 /**

   924  *	__skb_dequeue_tail - remove from the tail of the queue

   925  *	@list: list to dequeue from

   926  *

   927  *	Remove the tail of the list. This function does not take any locks

   928  *	so must be used with appropriate locks held only. The tail item is

   929  *	returned or %NULL if the list is empty.

   930  */

   931 extern struct sk_buff *skb_dequeue_tail(struct sk_buff_head *list);

   932 static inline struct sk_buff *__skb_dequeue_tail(struct sk_buff_head *list)

   933 {

   934 	struct sk_buff *skb = skb_peek_tail(list);

   935 	if (skb)

   936 		__skb_unlink(skb, list);

   937 	return skb;

   938 }

   939 

   940 

   941 static inline int skb_is_nonlinear(const struct sk_buff *skb)

   942 {

   943 	return skb->data_len;

   944 }

   945 

   946 static inline unsigned int skb_headlen(const struct sk_buff *skb)

   947 {

   948 	return skb->len - skb->data_len;

   949 }

   950 

   951 static inline int skb_pagelen(const struct sk_buff *skb)

   952 {

   953 	int i, len = 0;

   954 

   955 	for (i = (int)skb_shinfo(skb)->nr_frags - 1; i >= 0; i--)

   956 		len += skb_shinfo(skb)->frags[i].size;

   957 	return len + skb_headlen(skb);

   958 }

   959 

   960 static inline void skb_fill_page_desc(struct sk_buff *skb, int i,

   961 				      struct page *page, int off, int size)

   962 {

   963 	skb_frag_t *frag = &skb_shinfo(skb)->frags[i];

   964 

   965 	frag->page		  = page;

   966 	frag->page_offset	  = off;

   967 	frag->size		  = size;

   968 	skb_shinfo(skb)->nr_frags = i + 1;

   969 }

   970 

   971 extern void skb_add_rx_frag(struct sk_buff *skb, int i, struct page *page,

   972 			    int off, int size);

   973 

   974 #define SKB_PAGE_ASSERT(skb) 	BUG_ON(skb_shinfo(skb)->nr_frags)

   975 #define SKB_FRAG_ASSERT(skb) 	BUG_ON(skb_shinfo(skb)->frag_list)

   976 #define SKB_LINEAR_ASSERT(skb)  BUG_ON(skb_is_nonlinear(skb))

   977 

   978 #ifdef NET_SKBUFF_DATA_USES_OFFSET

   979 static inline unsigned char *skb_tail_pointer(const struct sk_buff *skb)

   980 {

   981 	return skb->head + skb->tail;

   982 }

   983 

   984 static inline void skb_reset_tail_pointer(struct sk_buff *skb)

   985 {

   986 	skb->tail = skb->data - skb->head;

   987 }

   988 

   989 static inline void skb_set_tail_pointer(struct sk_buff *skb, const int offset)

   990 {

   991 	skb_reset_tail_pointer(skb);

   992 	skb->tail += offset;

   993 }

   994 #else /* NET_SKBUFF_DATA_USES_OFFSET */

   995 static inline unsigned char *skb_tail_pointer(const struct sk_buff *skb)

   996 {

   997 	return skb->tail;

   998 }

   999 

  1000 static inline void skb_reset_tail_pointer(struct sk_buff *skb)

  1001 {

  1002 	skb->tail = skb->data;

  1003 }

  1004 

  1005 static inline void skb_set_tail_pointer(struct sk_buff *skb, const int offset)

  1006 {

  1007 	skb->tail = skb->data + offset;

  1008 }

  1009 

  1010 #endif /* NET_SKBUFF_DATA_USES_OFFSET */

  1011 

  1012 /*

  1013  *	Add data to an sk_buff

  1014  */

  1015 extern unsigned char *skb_put(struct sk_buff *skb, unsigned int len);

  1016 static inline unsigned char *__skb_put(struct sk_buff *skb, unsigned int len)

  1017 {

  1018 	unsigned char *tmp = skb_tail_pointer(skb);

  1019 	SKB_LINEAR_ASSERT(skb);

  1020 	skb->tail += len;

  1021 	skb->len  += len;

  1022 	return tmp;

  1023 }

  1024 

  1025 extern unsigned char *skb_push(struct sk_buff *skb, unsigned int len);

  1026 static inline unsigned char *__skb_push(struct sk_buff *skb, unsigned int len)

  1027 {

  1028 	skb->data -= len;

  1029 	skb->len  += len;

  1030 	return skb->data;

  1031 }

  1032 

  1033 extern unsigned char *skb_pull(struct sk_buff *skb, unsigned int len);

  1034 static inline unsigned char *__skb_pull(struct sk_buff *skb, unsigned int len)

  1035 {

  1036 	skb->len -= len;

  1037 	BUG_ON(skb->len < skb->data_len);

  1038 	return skb->data += len;

  1039 }

  1040 

  1041 extern unsigned char *__pskb_pull_tail(struct sk_buff *skb, int delta);

  1042 

  1043 static inline unsigned char *__pskb_pull(struct sk_buff *skb, unsigned int len)

  1044 {

  1045 	if (len > skb_headlen(skb) &&

  1046 	    !__pskb_pull_tail(skb, len - skb_headlen(skb)))

  1047 		return NULL;

  1048 	skb->len -= len;

  1049 	return skb->data += len;

  1050 }

  1051 

  1052 static inline unsigned char *pskb_pull(struct sk_buff *skb, unsigned int len)

  1053 {

  1054 	return unlikely(len > skb->len) ? NULL : __pskb_pull(skb, len);

  1055 }

  1056 

  1057 static inline int pskb_may_pull(struct sk_buff *skb, unsigned int len)

  1058 {

  1059 	if (likely(len <= skb_headlen(skb)))

  1060 		return 1;

  1061 	if (unlikely(len > skb->len))

  1062 		return 0;

  1063 	return __pskb_pull_tail(skb, len - skb_headlen(skb)) != NULL;

  1064 }

  1065 

  1066 /**

  1067  *	skb_headroom - bytes at buffer head

  1068  *	@skb: buffer to check

  1069  *

  1070  *	Return the number of bytes of free space at the head of an &sk_buff.

  1071  */

  1072 static inline unsigned int skb_headroom(const struct sk_buff *skb)

  1073 {

  1074 	return skb->data - skb->head;

  1075 }

  1076 

  1077 /**

  1078  *	skb_tailroom - bytes at buffer end

  1079  *	@skb: buffer to check

  1080  *

  1081  *	Return the number of bytes of free space at the tail of an sk_buff

  1082  */

  1083 static inline int skb_tailroom(const struct sk_buff *skb)

  1084 {

  1085 	return skb_is_nonlinear(skb) ? 0 : skb->end - skb->tail;

  1086 }

  1087 

  1088 /**

  1089  *	skb_reserve - adjust headroom

  1090  *	@skb: buffer to alter

  1091  *	@len: bytes to move

  1092  *

  1093  *	Increase the headroom of an empty &sk_buff by reducing the tail

  1094  *	room. This is only allowed for an empty buffer.

  1095  */

  1096 static inline void skb_reserve(struct sk_buff *skb, int len)

  1097 {

  1098 	skb->data += len;

  1099 	skb->tail += len;

  1100 }

  1101 

  1102 #ifdef NET_SKBUFF_DATA_USES_OFFSET

  1103 static inline unsigned char *skb_transport_header(const struct sk_buff *skb)

  1104 {

  1105 	return skb->head + skb->transport_header;

  1106 }

  1107 

  1108 static inline void skb_reset_transport_header(struct sk_buff *skb)

  1109 {

  1110 	skb->transport_header = skb->data - skb->head;

  1111 }

  1112 

  1113 static inline void skb_set_transport_header(struct sk_buff *skb,

  1114 					    const int offset)

  1115 {

  1116 	skb_reset_transport_header(skb);

  1117 	skb->transport_header += offset;

  1118 }

  1119 

  1120 static inline unsigned char *skb_network_header(const struct sk_buff *skb)

  1121 {

  1122 	return skb->head + skb->network_header;

  1123 }

  1124 

  1125 static inline void skb_reset_network_header(struct sk_buff *skb)

  1126 {

  1127 	skb->network_header = skb->data - skb->head;

  1128 }

  1129 

  1130 static inline void skb_set_network_header(struct sk_buff *skb, const int offset)

  1131 {

  1132 	skb_reset_network_header(skb);

  1133 	skb->network_header += offset;

  1134 }

  1135