blob: cf2cb50f77d1fe5f19e9894b78f4532789054ce7 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include <linux/net.h>
Thomas Graf3fc7e8a2005-06-23 21:00:17 -070026#include <linux/textsearch.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <net/checksum.h>
Al Viroa80958f2006-12-04 20:41:19 +000028#include <linux/rcupdate.h>
Chris Leech97fc2f02006-05-23 17:55:33 -070029#include <linux/dmaengine.h>
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -070030#include <linux/hrtimer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
32#define HAVE_ALLOC_SKB /* For the drivers to know */
33#define HAVE_ALIGNABLE_SKB /* Ditto 8) */
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
Herbert Xu60476372007-04-09 11:59:39 -070035/* Don't change this without changing skb_csum_unnecessary! */
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#define CHECKSUM_NONE 0
Herbert Xu60476372007-04-09 11:59:39 -070037#define CHECKSUM_UNNECESSARY 1
38#define CHECKSUM_COMPLETE 2
39#define CHECKSUM_PARTIAL 3
Linus Torvalds1da177e2005-04-16 15:20:36 -070040
41#define SKB_DATA_ALIGN(X) (((X) + (SMP_CACHE_BYTES - 1)) & \
42 ~(SMP_CACHE_BYTES - 1))
David S. Millerfc910a22007-03-25 20:27:59 -070043#define SKB_WITH_OVERHEAD(X) \
Herbert Xudeea84b2007-10-21 16:27:46 -070044 ((X) - SKB_DATA_ALIGN(sizeof(struct skb_shared_info)))
David S. Millerfc910a22007-03-25 20:27:59 -070045#define SKB_MAX_ORDER(X, ORDER) \
46 SKB_WITH_OVERHEAD((PAGE_SIZE << (ORDER)) - (X))
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#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 *
Patrick McHardy84fa7932006-08-29 16:44:56 -070061 * COMPLETE: the most generic way. Device supplied checksum of _all_
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 * the packet as seen by netif_rx in skb->csum.
63 * NOTE: Even if device supports only some protocols, but
Patrick McHardy84fa7932006-08-29 16:44:56 -070064 * is able to produce some skb->csum, it MUST use COMPLETE,
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 * not UNNECESSARY.
66 *
Herbert Xuc6c6e3e2007-07-10 22:41:55 -070067 * 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 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 * B. Checksumming on output.
75 *
76 * NONE: skb is checksummed by protocol or csum is not required.
77 *
Patrick McHardy84fa7932006-08-29 16:44:56 -070078 * PARTIAL: device is required to csum packet as seen by hard_start_xmit
Herbert Xuc6c6e3e2007-07-10 22:41:55 -070079 * from skb->csum_start to the end and to record the checksum
80 * at skb->csum_start + skb->csum_offset.
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 *
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)
Herbert Xuc6c6e3e2007-07-10 22:41:55 -070091 * NETIF_F_IPV6_CSUM about as dumb as the last one but does IPv6 instead.
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 *
93 * Any questions? No questions, good. --ANK
94 */
95
Linus Torvalds1da177e2005-04-16 15:20:36 -070096struct net_device;
David Howells716ea3a2007-04-02 20:19:53 -070097struct scatterlist;
Jens Axboe9c55e012007-11-06 23:30:13 -080098struct pipe_inode_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -0700100#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101struct nf_conntrack {
102 atomic_t use;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103};
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -0700104#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105
106#ifdef CONFIG_BRIDGE_NETFILTER
107struct nf_bridge_info {
108 atomic_t use;
109 struct net_device *physindev;
110 struct net_device *physoutdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 unsigned int mask;
112 unsigned long data[32 / sizeof(unsigned long)];
113};
114#endif
115
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116struct 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
125struct 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
130typedef struct skb_frag_struct skb_frag_t;
131
132struct skb_frag_struct {
133 struct page *page;
David S. Millera309bb02007-07-30 18:47:03 -0700134 __u32 page_offset;
135 __u32 size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136};
137
138/* This data is invariant across clones and lives at
139 * the end of the header data, ie. at skb->end.
140 */
141struct skb_shared_info {
142 atomic_t dataref;
Benjamin LaHaise4947d3e2006-01-03 14:06:50 -0800143 unsigned short nr_frags;
Herbert Xu79671682006-06-22 02:40:14 -0700144 unsigned short gso_size;
145 /* Warning: this field is not always filled in (UFO)! */
146 unsigned short gso_segs;
147 unsigned short gso_type;
Al Viroae08e1f2006-11-08 00:27:11 -0800148 __be32 ip6_frag_id;
David S. Miller271bff72008-09-11 04:48:58 -0700149#ifdef CONFIG_HAS_DMA
150 unsigned int num_dma_maps;
151#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 struct sk_buff *frag_list;
153 skb_frag_t frags[MAX_SKB_FRAGS];
David S. Miller271bff72008-09-11 04:48:58 -0700154#ifdef CONFIG_HAS_DMA
155 dma_addr_t dma_maps[MAX_SKB_FRAGS + 1];
156#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157};
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
Patrick McHardy334a8132007-06-25 04:35:20 -0700161 * the entire skb->data. A clone of a headerless skb holds the length of
162 * the header in skb->hdr_len.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 *
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
David S. Millerd179cd12005-08-17 14:57:30 -0700173
174enum {
175 SKB_FCLONE_UNAVAILABLE,
176 SKB_FCLONE_ORIG,
177 SKB_FCLONE_CLONE,
178};
179
Herbert Xu79671682006-06-22 02:40:14 -0700180enum {
181 SKB_GSO_TCPV4 = 1 << 0,
Herbert Xuf83ef8c2006-06-30 13:37:03 -0700182 SKB_GSO_UDP = 1 << 1,
Herbert Xu576a30e2006-06-27 13:22:38 -0700183
184 /* This indicates the skb is from an untrusted source. */
185 SKB_GSO_DODGY = 1 << 2,
Michael Chanb0da85372006-06-29 12:30:00 -0700186
187 /* This indicates the tcp segment has CWR set. */
Herbert Xuf83ef8c2006-06-30 13:37:03 -0700188 SKB_GSO_TCP_ECN = 1 << 3,
189
190 SKB_GSO_TCPV6 = 1 << 4,
Herbert Xu79671682006-06-22 02:40:14 -0700191};
192
Arnaldo Carvalho de Melo2e07fa92007-04-10 21:22:35 -0700193#if BITS_PER_LONG > 32
194#define NET_SKBUFF_DATA_USES_OFFSET 1
195#endif
196
197#ifdef NET_SKBUFF_DATA_USES_OFFSET
198typedef unsigned int sk_buff_data_t;
199#else
200typedef unsigned char *sk_buff_data_t;
201#endif
202
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203/**
204 * struct sk_buff - socket buffer
205 * @next: Next buffer in list
206 * @prev: Previous buffer in list
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 * @sk: Socket we are owned by
Herbert Xu325ed822005-10-03 13:57:23 -0700208 * @tstamp: Time we arrived
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 * @dev: Device we arrived on/are leaving by
Randy Dunlapbe521782007-05-03 03:16:20 -0700210 * @transport_header: Transport layer header
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -0700211 * @network_header: Network layer header
212 * @mac_header: Link layer header
Martin Waitz67be2dd2005-05-01 08:59:26 -0700213 * @dst: destination entry
214 * @sp: the security path, used for xfrm
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 * @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
Patrick McHardy334a8132007-06-25 04:35:20 -0700219 * @hdr_len: writable header length of cloned skb
Herbert Xu663ead32007-04-09 11:59:07 -0700220 * @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
Martin Waitz67be2dd2005-05-01 08:59:26 -0700223 * @local_df: allow local fragmentation
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 * @cloned: Head may be cloned (check refcnt to be sure)
225 * @nohdr: Payload reference only, must not modify header
226 * @pkt_type: Packet class
Randy Dunlapc83c2482005-10-18 22:07:41 -0700227 * @fclone: skbuff clone status
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 * @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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 * @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
Thomas Graf82e91ff2006-11-09 15:19:14 -0800238 * @mark: Generic packet mark
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 * @nfct: Associated connection, if any
Randy Dunlapc83c2482005-10-18 22:07:41 -0700240 * @ipvs_property: skbuff is owned by ipvs
Randy Dunlap31729362008-02-18 20:52:13 -0800241 * @peeked: this packet has been seen already, so stats have been
242 * done for it, don't do them again
Jozsef Kadlecsikba9dda32007-07-07 22:21:23 -0700243 * @nf_trace: netfilter packet trace flag
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 * @nfctinfo: Relationship of this skb to the connection
Randy Dunlap461ddf32005-11-20 21:25:15 -0800245 * @nfct_reasm: netfilter conntrack re-assembly pointer
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 * @nf_bridge: Saved data about a bridged frame - see br_netfilter.c
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -0700247 * @iif: ifindex of device we arrived on
248 * @queue_mapping: Queue mapping for multiqueue devices
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 * @tc_index: Traffic control index
250 * @tc_verd: traffic control verdict
Randy Dunlap553a5672008-04-20 10:51:01 -0700251 * @ndisc_nodetype: router type (from link layer)
Randy Dunlap4a7b61d2008-07-31 20:52:08 -0700252 * @do_not_encrypt: set to prevent encryption of this frame
Sujith8b30b1f2008-10-24 09:55:27 +0530253 * @requeue: set to indicate that the wireless core should attempt
254 * a software retry on this frame if we failed to
255 * receive an ACK for it
Randy Dunlapf4b8ea72006-06-22 16:00:11 -0700256 * @dma_cookie: a cookie to one of several possible DMA operations
257 * done by skb DMA functions
James Morris984bc162006-06-09 00:29:17 -0700258 * @secmark: security marking
Patrick McHardy6aa895b2008-07-14 22:49:06 -0700259 * @vlan_tci: vlan tag control information
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 */
261
262struct sk_buff {
263 /* These two members must be first. */
264 struct sk_buff *next;
265 struct sk_buff *prev;
266
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 struct sock *sk;
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -0700268 ktime_t tstamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 struct net_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270
Eric Dumazetee6b9672008-03-05 18:30:47 -0800271 union {
272 struct dst_entry *dst;
273 struct rtable *rtable;
274 };
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -0700275#ifdef CONFIG_XFRM
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 struct sec_path *sp;
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -0700277#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 /*
279 * This is the control buffer. It is free to use for every
280 * layer. Please put your private variables there. If you
281 * want to keep them across layers you have to do a skb_clone()
282 * first. This is owned by whoever has the skb queued ATM.
283 */
Patrick McHardy3e3850e2006-01-06 23:04:54 -0800284 char cb[48];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285
286 unsigned int len,
Patrick McHardy334a8132007-06-25 04:35:20 -0700287 data_len;
288 __u16 mac_len,
289 hdr_len;
Al Viroff1dcad2006-11-20 18:07:29 -0800290 union {
291 __wsum csum;
Herbert Xu663ead32007-04-09 11:59:07 -0700292 struct {
293 __u16 csum_start;
294 __u16 csum_offset;
295 };
Al Viroff1dcad2006-11-20 18:07:29 -0800296 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 __u32 priority;
Thomas Graf1cbb3382005-07-05 14:13:41 -0700298 __u8 local_df:1,
299 cloned:1,
300 ip_summed:2,
Harald Welte6869c4d2005-08-09 19:24:19 -0700301 nohdr:1,
302 nfctinfo:3;
David S. Millerd179cd12005-08-17 14:57:30 -0700303 __u8 pkt_type:3,
Patrick McHardyb84f4cc2005-11-20 21:19:21 -0800304 fclone:2,
Jozsef Kadlecsikba9dda32007-07-07 22:21:23 -0700305 ipvs_property:1,
Herbert Xua59322b2007-12-05 01:53:40 -0800306 peeked:1,
Jozsef Kadlecsikba9dda32007-07-07 22:21:23 -0700307 nf_trace:1;
Alexey Dobriyana0d3bea2005-08-11 16:05:50 -0700308 __be16 protocol;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309
310 void (*destructor)(struct sk_buff *skb);
Yasuyuki Kozakai9fb9cbb2005-11-09 16:38:16 -0800311#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -0700312 struct nf_conntrack *nfct;
Yasuyuki Kozakai9fb9cbb2005-11-09 16:38:16 -0800313 struct sk_buff *nfct_reasm;
314#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315#ifdef CONFIG_BRIDGE_NETFILTER
316 struct nf_bridge_info *nf_bridge;
317#endif
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -0700318
319 int iif;
320 __u16 queue_mapping;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321#ifdef CONFIG_NET_SCHED
Patrick McHardyb6b99eb2005-08-09 19:33:51 -0700322 __u16 tc_index; /* traffic control index */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323#ifdef CONFIG_NET_CLS_ACT
Patrick McHardyb6b99eb2005-08-09 19:33:51 -0700324 __u16 tc_verd; /* traffic control verdict */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326#endif
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -0400327#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -0400328 __u8 ndisc_nodetype:2;
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -0400329#endif
Johannes Bergd0f09802008-07-29 11:32:07 +0200330#if defined(CONFIG_MAC80211) || defined(CONFIG_MAC80211_MODULE)
331 __u8 do_not_encrypt:1;
Sujith8b30b1f2008-10-24 09:55:27 +0530332 __u8 requeue:1;
Johannes Bergd0f09802008-07-29 11:32:07 +0200333#endif
334 /* 0/13/14 bit hole */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -0700335
Chris Leech97fc2f02006-05-23 17:55:33 -0700336#ifdef CONFIG_NET_DMA
337 dma_cookie_t dma_cookie;
338#endif
James Morris984bc162006-06-09 00:29:17 -0700339#ifdef CONFIG_NETWORK_SECMARK
340 __u32 secmark;
341#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342
Thomas Graf82e91ff2006-11-09 15:19:14 -0800343 __u32 mark;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
Patrick McHardy6aa895b2008-07-14 22:49:06 -0700345 __u16 vlan_tci;
346
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700347 sk_buff_data_t transport_header;
348 sk_buff_data_t network_header;
349 sk_buff_data_t mac_header;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 /* These elements must be at the end, see alloc_skb() for details. */
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700351 sk_buff_data_t tail;
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -0700352 sk_buff_data_t end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 unsigned char *head,
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -0700354 *data;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700355 unsigned int truesize;
356 atomic_t users;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357};
358
359#ifdef __KERNEL__
360/*
361 * Handling routines are only of interest to the kernel
362 */
363#include <linux/slab.h>
364
365#include <asm/system.h>
366
David S. Millera40c24a2008-09-11 04:51:14 -0700367#ifdef CONFIG_HAS_DMA
368#include <linux/dma-mapping.h>
369extern int skb_dma_map(struct device *dev, struct sk_buff *skb,
370 enum dma_data_direction dir);
371extern void skb_dma_unmap(struct device *dev, struct sk_buff *skb,
372 enum dma_data_direction dir);
373#endif
374
Jörn Engel231d06a2006-03-20 21:28:35 -0800375extern void kfree_skb(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376extern void __kfree_skb(struct sk_buff *skb);
David S. Millerd179cd12005-08-17 14:57:30 -0700377extern struct sk_buff *__alloc_skb(unsigned int size,
Christoph Hellwigb30973f2006-12-06 20:32:36 -0800378 gfp_t priority, int fclone, int node);
David S. Millerd179cd12005-08-17 14:57:30 -0700379static inline struct sk_buff *alloc_skb(unsigned int size,
Al Virodd0fc662005-10-07 07:46:04 +0100380 gfp_t priority)
David S. Millerd179cd12005-08-17 14:57:30 -0700381{
Christoph Hellwigb30973f2006-12-06 20:32:36 -0800382 return __alloc_skb(size, priority, 0, -1);
David S. Millerd179cd12005-08-17 14:57:30 -0700383}
384
385static inline struct sk_buff *alloc_skb_fclone(unsigned int size,
Al Virodd0fc662005-10-07 07:46:04 +0100386 gfp_t priority)
David S. Millerd179cd12005-08-17 14:57:30 -0700387{
Christoph Hellwigb30973f2006-12-06 20:32:36 -0800388 return __alloc_skb(size, priority, 1, -1);
David S. Millerd179cd12005-08-17 14:57:30 -0700389}
390
Lennert Buytenhek04a4bb52008-10-01 02:33:12 -0700391extern int skb_recycle_check(struct sk_buff *skb, int skb_size);
392
Herbert Xue0053ec2007-10-14 00:37:52 -0700393extern struct sk_buff *skb_morph(struct sk_buff *dst, struct sk_buff *src);
Victor Fusco86a76ca2005-07-08 14:57:47 -0700394extern struct sk_buff *skb_clone(struct sk_buff *skb,
Al Virodd0fc662005-10-07 07:46:04 +0100395 gfp_t priority);
Victor Fusco86a76ca2005-07-08 14:57:47 -0700396extern struct sk_buff *skb_copy(const struct sk_buff *skb,
Al Virodd0fc662005-10-07 07:46:04 +0100397 gfp_t priority);
Victor Fusco86a76ca2005-07-08 14:57:47 -0700398extern struct sk_buff *pskb_copy(struct sk_buff *skb,
Al Virodd0fc662005-10-07 07:46:04 +0100399 gfp_t gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400extern int pskb_expand_head(struct sk_buff *skb,
Victor Fusco86a76ca2005-07-08 14:57:47 -0700401 int nhead, int ntail,
Al Virodd0fc662005-10-07 07:46:04 +0100402 gfp_t gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403extern struct sk_buff *skb_realloc_headroom(struct sk_buff *skb,
404 unsigned int headroom);
405extern struct sk_buff *skb_copy_expand(const struct sk_buff *skb,
406 int newheadroom, int newtailroom,
Al Virodd0fc662005-10-07 07:46:04 +0100407 gfp_t priority);
David Howells716ea3a2007-04-02 20:19:53 -0700408extern int skb_to_sgvec(struct sk_buff *skb,
409 struct scatterlist *sg, int offset,
410 int len);
411extern int skb_cow_data(struct sk_buff *skb, int tailbits,
412 struct sk_buff **trailer);
Herbert Xu5b057c62006-06-23 02:06:41 -0700413extern int skb_pad(struct sk_buff *skb, int pad);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414#define dev_kfree_skb(a) kfree_skb(a)
415extern void skb_over_panic(struct sk_buff *skb, int len,
416 void *here);
417extern void skb_under_panic(struct sk_buff *skb, int len,
418 void *here);
David S. Millerdc6de332006-04-20 00:10:50 -0700419extern void skb_truesize_bug(struct sk_buff *skb);
420
421static inline void skb_truesize_check(struct sk_buff *skb)
422{
Chuck Lever78608ba2007-11-10 21:53:30 -0800423 int len = sizeof(struct sk_buff) + skb->len;
424
425 if (unlikely((int)skb->truesize < len))
David S. Millerdc6de332006-04-20 00:10:50 -0700426 skb_truesize_bug(skb);
427}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428
Ananda Rajue89e9cf2005-10-18 15:46:41 -0700429extern int skb_append_datato_frags(struct sock *sk, struct sk_buff *skb,
430 int getfrag(void *from, char *to, int offset,
431 int len,int odd, struct sk_buff *skb),
432 void *from, int length);
433
Thomas Graf677e90e2005-06-23 20:59:51 -0700434struct skb_seq_state
435{
436 __u32 lower_offset;
437 __u32 upper_offset;
438 __u32 frag_idx;
439 __u32 stepped_offset;
440 struct sk_buff *root_skb;
441 struct sk_buff *cur_skb;
442 __u8 *frag_data;
443};
444
445extern void skb_prepare_seq_read(struct sk_buff *skb,
446 unsigned int from, unsigned int to,
447 struct skb_seq_state *st);
448extern unsigned int skb_seq_read(unsigned int consumed, const u8 **data,
449 struct skb_seq_state *st);
450extern void skb_abort_seq_read(struct skb_seq_state *st);
451
Thomas Graf3fc7e8a2005-06-23 21:00:17 -0700452extern unsigned int skb_find_text(struct sk_buff *skb, unsigned int from,
453 unsigned int to, struct ts_config *config,
454 struct ts_state *state);
455
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -0700456#ifdef NET_SKBUFF_DATA_USES_OFFSET
457static inline unsigned char *skb_end_pointer(const struct sk_buff *skb)
458{
459 return skb->head + skb->end;
460}
461#else
462static inline unsigned char *skb_end_pointer(const struct sk_buff *skb)
463{
464 return skb->end;
465}
466#endif
467
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468/* Internal */
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -0700469#define skb_shinfo(SKB) ((struct skb_shared_info *)(skb_end_pointer(SKB)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470
471/**
472 * skb_queue_empty - check if a queue is empty
473 * @list: queue head
474 *
475 * Returns true if the queue is empty, false otherwise.
476 */
477static inline int skb_queue_empty(const struct sk_buff_head *list)
478{
479 return list->next == (struct sk_buff *)list;
480}
481
482/**
David S. Millerfc7ebb22008-09-23 00:34:07 -0700483 * skb_queue_is_last - check if skb is the last entry in the queue
484 * @list: queue head
485 * @skb: buffer
486 *
487 * Returns true if @skb is the last buffer on the list.
488 */
489static inline bool skb_queue_is_last(const struct sk_buff_head *list,
490 const struct sk_buff *skb)
491{
492 return (skb->next == (struct sk_buff *) list);
493}
494
495/**
Ilpo Järvinen832d11c2008-11-24 21:20:15 -0800496 * skb_queue_is_first - check if skb is the first entry in the queue
497 * @list: queue head
498 * @skb: buffer
499 *
500 * Returns true if @skb is the first buffer on the list.
501 */
502static inline bool skb_queue_is_first(const struct sk_buff_head *list,
503 const struct sk_buff *skb)
504{
505 return (skb->prev == (struct sk_buff *) list);
506}
507
508/**
David S. Miller249c8b42008-09-23 00:44:42 -0700509 * skb_queue_next - return the next packet in the queue
510 * @list: queue head
511 * @skb: current buffer
512 *
513 * Return the next packet in @list after @skb. It is only valid to
514 * call this if skb_queue_is_last() evaluates to false.
515 */
516static inline struct sk_buff *skb_queue_next(const struct sk_buff_head *list,
517 const struct sk_buff *skb)
518{
519 /* This BUG_ON may seem severe, but if we just return then we
520 * are going to dereference garbage.
521 */
522 BUG_ON(skb_queue_is_last(list, skb));
523 return skb->next;
524}
525
526/**
Ilpo Järvinen832d11c2008-11-24 21:20:15 -0800527 * skb_queue_prev - return the prev packet in the queue
528 * @list: queue head
529 * @skb: current buffer
530 *
531 * Return the prev packet in @list before @skb. It is only valid to
532 * call this if skb_queue_is_first() evaluates to false.
533 */
534static inline struct sk_buff *skb_queue_prev(const struct sk_buff_head *list,
535 const struct sk_buff *skb)
536{
537 /* This BUG_ON may seem severe, but if we just return then we
538 * are going to dereference garbage.
539 */
540 BUG_ON(skb_queue_is_first(list, skb));
541 return skb->prev;
542}
543
544/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 * skb_get - reference buffer
546 * @skb: buffer to reference
547 *
548 * Makes another reference to a socket buffer and returns a pointer
549 * to the buffer.
550 */
551static inline struct sk_buff *skb_get(struct sk_buff *skb)
552{
553 atomic_inc(&skb->users);
554 return skb;
555}
556
557/*
558 * If users == 1, we are the only owner and are can avoid redundant
559 * atomic change.
560 */
561
562/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 * skb_cloned - is the buffer a clone
564 * @skb: buffer to check
565 *
566 * Returns true if the buffer was generated with skb_clone() and is
567 * one of multiple shared copies of the buffer. Cloned buffers are
568 * shared data so must not be written to under normal circumstances.
569 */
570static inline int skb_cloned(const struct sk_buff *skb)
571{
572 return skb->cloned &&
573 (atomic_read(&skb_shinfo(skb)->dataref) & SKB_DATAREF_MASK) != 1;
574}
575
576/**
577 * skb_header_cloned - is the header a clone
578 * @skb: buffer to check
579 *
580 * Returns true if modifying the header part of the buffer requires
581 * the data to be copied.
582 */
583static inline int skb_header_cloned(const struct sk_buff *skb)
584{
585 int dataref;
586
587 if (!skb->cloned)
588 return 0;
589
590 dataref = atomic_read(&skb_shinfo(skb)->dataref);
591 dataref = (dataref & SKB_DATAREF_MASK) - (dataref >> SKB_DATAREF_SHIFT);
592 return dataref != 1;
593}
594
595/**
596 * skb_header_release - release reference to header
597 * @skb: buffer to operate on
598 *
599 * Drop a reference to the header part of the buffer. This is done
600 * by acquiring a payload reference. You must not read from the header
601 * part of skb->data after this.
602 */
603static inline void skb_header_release(struct sk_buff *skb)
604{
605 BUG_ON(skb->nohdr);
606 skb->nohdr = 1;
607 atomic_add(1 << SKB_DATAREF_SHIFT, &skb_shinfo(skb)->dataref);
608}
609
610/**
611 * skb_shared - is the buffer shared
612 * @skb: buffer to check
613 *
614 * Returns true if more than one person has a reference to this
615 * buffer.
616 */
617static inline int skb_shared(const struct sk_buff *skb)
618{
619 return atomic_read(&skb->users) != 1;
620}
621
622/**
623 * skb_share_check - check if buffer is shared and if so clone it
624 * @skb: buffer to check
625 * @pri: priority for memory allocation
626 *
627 * If the buffer is shared the buffer is cloned and the old copy
628 * drops a reference. A new clone with a single reference is returned.
629 * If the buffer is not shared the original buffer is returned. When
630 * being called from interrupt status or with spinlocks held pri must
631 * be GFP_ATOMIC.
632 *
633 * NULL is returned on a memory allocation failure.
634 */
Victor Fusco86a76ca2005-07-08 14:57:47 -0700635static inline struct sk_buff *skb_share_check(struct sk_buff *skb,
Al Virodd0fc662005-10-07 07:46:04 +0100636 gfp_t pri)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637{
638 might_sleep_if(pri & __GFP_WAIT);
639 if (skb_shared(skb)) {
640 struct sk_buff *nskb = skb_clone(skb, pri);
641 kfree_skb(skb);
642 skb = nskb;
643 }
644 return skb;
645}
646
647/*
648 * Copy shared buffers into a new sk_buff. We effectively do COW on
649 * packets to handle cases where we have a local reader and forward
650 * and a couple of other messy ones. The normal one is tcpdumping
651 * a packet thats being forwarded.
652 */
653
654/**
655 * skb_unshare - make a copy of a shared buffer
656 * @skb: buffer to check
657 * @pri: priority for memory allocation
658 *
659 * If the socket buffer is a clone then this function creates a new
660 * copy of the data, drops a reference count on the old copy and returns
661 * the new copy with the reference count at 1. If the buffer is not a clone
662 * the original buffer is returned. When called with a spinlock held or
663 * from interrupt state @pri must be %GFP_ATOMIC
664 *
665 * %NULL is returned on a memory allocation failure.
666 */
Victor Fuscoe2bf5212005-07-18 13:36:38 -0700667static inline struct sk_buff *skb_unshare(struct sk_buff *skb,
Al Virodd0fc662005-10-07 07:46:04 +0100668 gfp_t pri)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669{
670 might_sleep_if(pri & __GFP_WAIT);
671 if (skb_cloned(skb)) {
672 struct sk_buff *nskb = skb_copy(skb, pri);
673 kfree_skb(skb); /* Free our shared copy */
674 skb = nskb;
675 }
676 return skb;
677}
678
679/**
680 * skb_peek
681 * @list_: list to peek at
682 *
683 * Peek an &sk_buff. Unlike most other operations you _MUST_
684 * be careful with this one. A peek leaves the buffer on the
685 * list and someone else may run off with it. You must hold
686 * the appropriate locks or have a private queue to do this.
687 *
688 * Returns %NULL for an empty list or a pointer to the head element.
689 * The reference count is not incremented and the reference is therefore
690 * volatile. Use with caution.
691 */
692static inline struct sk_buff *skb_peek(struct sk_buff_head *list_)
693{
694 struct sk_buff *list = ((struct sk_buff *)list_)->next;
695 if (list == (struct sk_buff *)list_)
696 list = NULL;
697 return list;
698}
699
700/**
701 * skb_peek_tail
702 * @list_: list to peek at
703 *
704 * Peek an &sk_buff. Unlike most other operations you _MUST_
705 * be careful with this one. A peek leaves the buffer on the
706 * list and someone else may run off with it. You must hold
707 * the appropriate locks or have a private queue to do this.
708 *
709 * Returns %NULL for an empty list or a pointer to the tail element.
710 * The reference count is not incremented and the reference is therefore
711 * volatile. Use with caution.
712 */
713static inline struct sk_buff *skb_peek_tail(struct sk_buff_head *list_)
714{
715 struct sk_buff *list = ((struct sk_buff *)list_)->prev;
716 if (list == (struct sk_buff *)list_)
717 list = NULL;
718 return list;
719}
720
721/**
722 * skb_queue_len - get queue length
723 * @list_: list to measure
724 *
725 * Return the length of an &sk_buff queue.
726 */
727static inline __u32 skb_queue_len(const struct sk_buff_head *list_)
728{
729 return list_->qlen;
730}
731
David S. Miller67fed452008-09-21 22:36:24 -0700732/**
733 * __skb_queue_head_init - initialize non-spinlock portions of sk_buff_head
734 * @list: queue to initialize
735 *
736 * This initializes only the list and queue length aspects of
737 * an sk_buff_head object. This allows to initialize the list
738 * aspects of an sk_buff_head without reinitializing things like
739 * the spinlock. It can also be used for on-stack sk_buff_head
740 * objects where the spinlock is known to not be used.
741 */
742static inline void __skb_queue_head_init(struct sk_buff_head *list)
743{
744 list->prev = list->next = (struct sk_buff *)list;
745 list->qlen = 0;
746}
747
Arjan van de Ven76f10ad2006-08-02 14:06:55 -0700748/*
749 * This function creates a split out lock class for each invocation;
750 * this is needed for now since a whole lot of users of the skb-queue
751 * infrastructure in drivers have different locking usage (in hardirq)
752 * than the networking core (in softirq only). In the long run either the
753 * network layer or drivers should need annotation to consolidate the
754 * main types of usage into 3 classes.
755 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756static inline void skb_queue_head_init(struct sk_buff_head *list)
757{
758 spin_lock_init(&list->lock);
David S. Miller67fed452008-09-21 22:36:24 -0700759 __skb_queue_head_init(list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760}
761
Pavel Emelianovc2ecba72007-04-17 12:45:31 -0700762static inline void skb_queue_head_init_class(struct sk_buff_head *list,
763 struct lock_class_key *class)
764{
765 skb_queue_head_init(list);
766 lockdep_set_class(&list->lock, class);
767}
768
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769/*
Gerrit Renkerbf299272008-04-14 00:04:51 -0700770 * Insert an sk_buff on a list.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 *
772 * The "__skb_xxxx()" functions are the non-atomic ones that
773 * can only be called with interrupts disabled.
774 */
Gerrit Renkerbf299272008-04-14 00:04:51 -0700775extern void skb_insert(struct sk_buff *old, struct sk_buff *newsk, struct sk_buff_head *list);
776static inline void __skb_insert(struct sk_buff *newsk,
777 struct sk_buff *prev, struct sk_buff *next,
778 struct sk_buff_head *list)
779{
780 newsk->next = next;
781 newsk->prev = prev;
782 next->prev = prev->next = newsk;
783 list->qlen++;
784}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785
David S. Miller67fed452008-09-21 22:36:24 -0700786static inline void __skb_queue_splice(const struct sk_buff_head *list,
787 struct sk_buff *prev,
788 struct sk_buff *next)
789{
790 struct sk_buff *first = list->next;
791 struct sk_buff *last = list->prev;
792
793 first->prev = prev;
794 prev->next = first;
795
796 last->next = next;
797 next->prev = last;
798}
799
800/**
801 * skb_queue_splice - join two skb lists, this is designed for stacks
802 * @list: the new list to add
803 * @head: the place to add it in the first list
804 */
805static inline void skb_queue_splice(const struct sk_buff_head *list,
806 struct sk_buff_head *head)
807{
808 if (!skb_queue_empty(list)) {
809 __skb_queue_splice(list, (struct sk_buff *) head, head->next);
David S. Miller1d4a31d2008-09-22 21:57:21 -0700810 head->qlen += list->qlen;
David S. Miller67fed452008-09-21 22:36:24 -0700811 }
812}
813
814/**
815 * skb_queue_splice - join two skb lists and reinitialise the emptied list
816 * @list: the new list to add
817 * @head: the place to add it in the first list
818 *
819 * The list at @list is reinitialised
820 */
821static inline void skb_queue_splice_init(struct sk_buff_head *list,
822 struct sk_buff_head *head)
823{
824 if (!skb_queue_empty(list)) {
825 __skb_queue_splice(list, (struct sk_buff *) head, head->next);
David S. Miller1d4a31d2008-09-22 21:57:21 -0700826 head->qlen += list->qlen;
David S. Miller67fed452008-09-21 22:36:24 -0700827 __skb_queue_head_init(list);
828 }
829}
830
831/**
832 * skb_queue_splice_tail - join two skb lists, each list being a queue
833 * @list: the new list to add
834 * @head: the place to add it in the first list
835 */
836static inline void skb_queue_splice_tail(const struct sk_buff_head *list,
837 struct sk_buff_head *head)
838{
839 if (!skb_queue_empty(list)) {
840 __skb_queue_splice(list, head->prev, (struct sk_buff *) head);
David S. Miller1d4a31d2008-09-22 21:57:21 -0700841 head->qlen += list->qlen;
David S. Miller67fed452008-09-21 22:36:24 -0700842 }
843}
844
845/**
846 * skb_queue_splice_tail - join two skb lists and reinitialise the emptied list
847 * @list: the new list to add
848 * @head: the place to add it in the first list
849 *
850 * Each of the lists is a queue.
851 * The list at @list is reinitialised
852 */
853static inline void skb_queue_splice_tail_init(struct sk_buff_head *list,
854 struct sk_buff_head *head)
855{
856 if (!skb_queue_empty(list)) {
857 __skb_queue_splice(list, head->prev, (struct sk_buff *) head);
David S. Miller1d4a31d2008-09-22 21:57:21 -0700858 head->qlen += list->qlen;
David S. Miller67fed452008-09-21 22:36:24 -0700859 __skb_queue_head_init(list);
860 }
861}
862
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863/**
Stephen Hemminger300ce172005-10-30 13:47:34 -0800864 * __skb_queue_after - queue a buffer at the list head
865 * @list: list to use
866 * @prev: place after this buffer
867 * @newsk: buffer to queue
868 *
869 * Queue a buffer int the middle of a list. This function takes no locks
870 * and you must therefore hold required locks before calling it.
871 *
872 * A buffer cannot be placed on two lists at the same time.
873 */
874static inline void __skb_queue_after(struct sk_buff_head *list,
875 struct sk_buff *prev,
876 struct sk_buff *newsk)
877{
Gerrit Renkerbf299272008-04-14 00:04:51 -0700878 __skb_insert(newsk, prev, prev->next, list);
Stephen Hemminger300ce172005-10-30 13:47:34 -0800879}
880
Gerrit Renker7de6c032008-04-14 00:05:09 -0700881extern void skb_append(struct sk_buff *old, struct sk_buff *newsk,
882 struct sk_buff_head *list);
883
Gerrit Renkerf5572852008-04-14 00:05:28 -0700884static inline void __skb_queue_before(struct sk_buff_head *list,
885 struct sk_buff *next,
886 struct sk_buff *newsk)
887{
888 __skb_insert(newsk, next->prev, next, list);
889}
890
Stephen Hemminger300ce172005-10-30 13:47:34 -0800891/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 * __skb_queue_head - queue a buffer at the list head
893 * @list: list to use
894 * @newsk: buffer to queue
895 *
896 * Queue a buffer at the start of a list. This function takes no locks
897 * and you must therefore hold required locks before calling it.
898 *
899 * A buffer cannot be placed on two lists at the same time.
900 */
901extern void skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk);
902static inline void __skb_queue_head(struct sk_buff_head *list,
903 struct sk_buff *newsk)
904{
Stephen Hemminger300ce172005-10-30 13:47:34 -0800905 __skb_queue_after(list, (struct sk_buff *)list, newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906}
907
908/**
909 * __skb_queue_tail - queue a buffer at the list tail
910 * @list: list to use
911 * @newsk: buffer to queue
912 *
913 * Queue a buffer at the end of a list. This function takes no locks
914 * and you must therefore hold required locks before calling it.
915 *
916 * A buffer cannot be placed on two lists at the same time.
917 */
918extern void skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk);
919static inline void __skb_queue_tail(struct sk_buff_head *list,
920 struct sk_buff *newsk)
921{
Gerrit Renkerf5572852008-04-14 00:05:28 -0700922 __skb_queue_before(list, (struct sk_buff *)list, newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923}
924
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 * remove sk_buff from list. _Must_ be called atomically, and with
927 * the list known..
928 */
David S. Miller8728b832005-08-09 19:25:21 -0700929extern void skb_unlink(struct sk_buff *skb, struct sk_buff_head *list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930static inline void __skb_unlink(struct sk_buff *skb, struct sk_buff_head *list)
931{
932 struct sk_buff *next, *prev;
933
934 list->qlen--;
935 next = skb->next;
936 prev = skb->prev;
937 skb->next = skb->prev = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 next->prev = prev;
939 prev->next = next;
940}
941
Gerrit Renkerf525c062008-04-14 00:04:12 -0700942/**
943 * __skb_dequeue - remove from the head of the queue
944 * @list: list to dequeue from
945 *
946 * Remove the head of the list. This function does not take any locks
947 * so must be used with appropriate locks held only. The head item is
948 * returned or %NULL if the list is empty.
949 */
950extern struct sk_buff *skb_dequeue(struct sk_buff_head *list);
951static inline struct sk_buff *__skb_dequeue(struct sk_buff_head *list)
952{
953 struct sk_buff *skb = skb_peek(list);
954 if (skb)
955 __skb_unlink(skb, list);
956 return skb;
957}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958
959/**
960 * __skb_dequeue_tail - remove from the tail of the queue
961 * @list: list to dequeue from
962 *
963 * Remove the tail of the list. This function does not take any locks
964 * so must be used with appropriate locks held only. The tail item is
965 * returned or %NULL if the list is empty.
966 */
967extern struct sk_buff *skb_dequeue_tail(struct sk_buff_head *list);
968static inline struct sk_buff *__skb_dequeue_tail(struct sk_buff_head *list)
969{
970 struct sk_buff *skb = skb_peek_tail(list);
971 if (skb)
972 __skb_unlink(skb, list);
973 return skb;
974}
975
976
977static inline int skb_is_nonlinear(const struct sk_buff *skb)
978{
979 return skb->data_len;
980}
981
982static inline unsigned int skb_headlen(const struct sk_buff *skb)
983{
984 return skb->len - skb->data_len;
985}
986
987static inline int skb_pagelen(const struct sk_buff *skb)
988{
989 int i, len = 0;
990
991 for (i = (int)skb_shinfo(skb)->nr_frags - 1; i >= 0; i--)
992 len += skb_shinfo(skb)->frags[i].size;
993 return len + skb_headlen(skb);
994}
995
996static inline void skb_fill_page_desc(struct sk_buff *skb, int i,
997 struct page *page, int off, int size)
998{
999 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
1000
1001 frag->page = page;
1002 frag->page_offset = off;
1003 frag->size = size;
1004 skb_shinfo(skb)->nr_frags = i + 1;
1005}
1006
Peter Zijlstra654bed12008-10-07 14:22:33 -07001007extern void skb_add_rx_frag(struct sk_buff *skb, int i, struct page *page,
1008 int off, int size);
1009
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010#define SKB_PAGE_ASSERT(skb) BUG_ON(skb_shinfo(skb)->nr_frags)
1011#define SKB_FRAG_ASSERT(skb) BUG_ON(skb_shinfo(skb)->frag_list)
1012#define SKB_LINEAR_ASSERT(skb) BUG_ON(skb_is_nonlinear(skb))
1013
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001014#ifdef NET_SKBUFF_DATA_USES_OFFSET
1015static inline unsigned char *skb_tail_pointer(const struct sk_buff *skb)
1016{
1017 return skb->head + skb->tail;
1018}
1019
1020static inline void skb_reset_tail_pointer(struct sk_buff *skb)
1021{
1022 skb->tail = skb->data - skb->head;
1023}
1024
1025static inline void skb_set_tail_pointer(struct sk_buff *skb, const int offset)
1026{
1027 skb_reset_tail_pointer(skb);
1028 skb->tail += offset;
1029}
1030#else /* NET_SKBUFF_DATA_USES_OFFSET */
1031static inline unsigned char *skb_tail_pointer(const struct sk_buff *skb)
1032{
1033 return skb->tail;
1034}
1035
1036static inline void skb_reset_tail_pointer(struct sk_buff *skb)
1037{
1038 skb->tail = skb->data;
1039}
1040
1041static inline void skb_set_tail_pointer(struct sk_buff *skb, const int offset)
1042{
1043 skb->tail = skb->data + offset;
1044}
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -07001045
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001046#endif /* NET_SKBUFF_DATA_USES_OFFSET */
1047
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048/*
1049 * Add data to an sk_buff
1050 */
Ilpo Järvinen0dde3e12008-03-27 17:43:41 -07001051extern unsigned char *skb_put(struct sk_buff *skb, unsigned int len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052static inline unsigned char *__skb_put(struct sk_buff *skb, unsigned int len)
1053{
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001054 unsigned char *tmp = skb_tail_pointer(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 SKB_LINEAR_ASSERT(skb);
1056 skb->tail += len;
1057 skb->len += len;
1058 return tmp;
1059}
1060
Ilpo Järvinenc2aa2702008-03-27 17:52:40 -07001061extern unsigned char *skb_push(struct sk_buff *skb, unsigned int len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062static inline unsigned char *__skb_push(struct sk_buff *skb, unsigned int len)
1063{
1064 skb->data -= len;
1065 skb->len += len;
1066 return skb->data;
1067}
1068
Ilpo Järvinen6be8ac22008-03-27 17:47:24 -07001069extern unsigned char *skb_pull(struct sk_buff *skb, unsigned int len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070static inline unsigned char *__skb_pull(struct sk_buff *skb, unsigned int len)
1071{
1072 skb->len -= len;
1073 BUG_ON(skb->len < skb->data_len);
1074 return skb->data += len;
1075}
1076
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077extern unsigned char *__pskb_pull_tail(struct sk_buff *skb, int delta);
1078
1079static inline unsigned char *__pskb_pull(struct sk_buff *skb, unsigned int len)
1080{
1081 if (len > skb_headlen(skb) &&
Gerrit Renker987c4022008-08-11 18:17:17 -07001082 !__pskb_pull_tail(skb, len - skb_headlen(skb)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 return NULL;
1084 skb->len -= len;
1085 return skb->data += len;
1086}
1087
1088static inline unsigned char *pskb_pull(struct sk_buff *skb, unsigned int len)
1089{
1090 return unlikely(len > skb->len) ? NULL : __pskb_pull(skb, len);
1091}
1092
1093static inline int pskb_may_pull(struct sk_buff *skb, unsigned int len)
1094{
1095 if (likely(len <= skb_headlen(skb)))
1096 return 1;
1097 if (unlikely(len > skb->len))
1098 return 0;
Gerrit Renker987c4022008-08-11 18:17:17 -07001099 return __pskb_pull_tail(skb, len - skb_headlen(skb)) != NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100}
1101
1102/**
1103 * skb_headroom - bytes at buffer head
1104 * @skb: buffer to check
1105 *
1106 * Return the number of bytes of free space at the head of an &sk_buff.
1107 */
Chuck Leverc2636b42007-10-23 21:07:32 -07001108static inline unsigned int skb_headroom(const struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109{
1110 return skb->data - skb->head;
1111}
1112
1113/**
1114 * skb_tailroom - bytes at buffer end
1115 * @skb: buffer to check
1116 *
1117 * Return the number of bytes of free space at the tail of an sk_buff
1118 */
1119static inline int skb_tailroom(const struct sk_buff *skb)
1120{
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -07001121 return skb_is_nonlinear(skb) ? 0 : skb->end - skb->tail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122}
1123
1124/**
1125 * skb_reserve - adjust headroom
1126 * @skb: buffer to alter
1127 * @len: bytes to move
1128 *
1129 * Increase the headroom of an empty &sk_buff by reducing the tail
1130 * room. This is only allowed for an empty buffer.
1131 */
David S. Miller82431262006-01-17 02:54:21 -08001132static inline void skb_reserve(struct sk_buff *skb, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133{
1134 skb->data += len;
1135 skb->tail += len;
1136}
1137
Arnaldo Carvalho de Melo2e07fa92007-04-10 21:22:35 -07001138#ifdef NET_SKBUFF_DATA_USES_OFFSET
1139static inline unsigned char *skb_transport_header(const struct sk_buff *skb)
1140{
1141 return skb->head + skb->transport_header;
1142}
1143
1144static inline void skb_reset_transport_header(struct sk_buff *skb)
1145{
1146 skb->transport_header = skb->data - skb->head;
1147}
1148
1149static inline void skb_set_transport_header(struct sk_buff *skb,
1150 const int offset)
1151{
1152 skb_reset_transport_header(skb);
1153 skb->transport_header += offset;
1154}
1155
1156static inline unsigned char *skb_network_header(const struct sk_buff *skb)
1157{
1158 return skb->head + skb->network_header;
1159}
1160
1161static inline void skb_reset_network_header(struct sk_buff *skb)
1162{
1163 skb->network_header = skb->data - skb->head;
1164}
1165
1166static inline void skb_set_network_header(struct sk_buff *skb, const int offset)
1167{
1168 skb_reset_network_header(skb);
1169 skb->network_header += offset;
1170}
1171
1172static inline unsigned char *skb_mac_header(const struct sk_buff *skb)
1173{
1174 return skb->head + skb->mac_header;
1175}
1176
1177static inline int skb_mac_header_was_set(const struct sk_buff *skb)
1178{
1179 return skb->mac_header != ~0U;
1180}
1181
1182static inline void skb_reset_mac_header(struct sk_buff *skb)
1183{
1184 skb->mac_header = skb->data - skb->head;
1185}
1186
1187static inline void skb_set_mac_header(struct sk_buff *skb, const int offset)
1188{
1189 skb_reset_mac_header(skb);
1190 skb->mac_header += offset;
1191}
1192
1193#else /* NET_SKBUFF_DATA_USES_OFFSET */
1194
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001195static inline unsigned char *skb_transport_header(const struct sk_buff *skb)
1196{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001197 return skb->transport_header;
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001198}
1199
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03001200static inline void skb_reset_transport_header(struct sk_buff *skb)
1201{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001202 skb->transport_header = skb->data;
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03001203}
1204
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -03001205static inline void skb_set_transport_header(struct sk_buff *skb,
1206 const int offset)
1207{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001208 skb->transport_header = skb->data + offset;
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -03001209}
1210
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -07001211static inline unsigned char *skb_network_header(const struct sk_buff *skb)
1212{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001213 return skb->network_header;
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -07001214}
1215
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07001216static inline void skb_reset_network_header(struct sk_buff *skb)
1217{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001218 skb->network_header = skb->data;
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07001219}
1220
Arnaldo Carvalho de Meloc14d2452007-03-11 22:39:41 -03001221static inline void skb_set_network_header(struct sk_buff *skb, const int offset)
1222{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001223 skb->network_header = skb->data + offset;
Arnaldo Carvalho de Meloc14d2452007-03-11 22:39:41 -03001224}
1225
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001226static inline unsigned char *skb_mac_header(const struct sk_buff *skb)
1227{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001228 return skb->mac_header;
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001229}
1230
1231static inline int skb_mac_header_was_set(const struct sk_buff *skb)
1232{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001233 return skb->mac_header != NULL;
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001234}
1235
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -07001236static inline void skb_reset_mac_header(struct sk_buff *skb)
1237{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001238 skb->mac_header = skb->data;
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -07001239}
1240
Arnaldo Carvalho de Melo48d49d0c2007-03-10 12:30:58 -03001241static inline void skb_set_mac_header(struct sk_buff *skb, const int offset)
1242{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001243 skb->mac_header = skb->data + offset;
Arnaldo Carvalho de Melo48d49d0c2007-03-10 12:30:58 -03001244}
Arnaldo Carvalho de Melo2e07fa92007-04-10 21:22:35 -07001245#endif /* NET_SKBUFF_DATA_USES_OFFSET */
1246
1247static inline int skb_transport_offset(const struct sk_buff *skb)
1248{
1249 return skb_transport_header(skb) - skb->data;
1250}
1251
1252static inline u32 skb_network_header_len(const struct sk_buff *skb)
1253{
1254 return skb->transport_header - skb->network_header;
1255}
1256
1257static inline int skb_network_offset(const struct sk_buff *skb)
1258{
1259 return skb_network_header(skb) - skb->data;
1260}
Arnaldo Carvalho de Melo48d49d0c2007-03-10 12:30:58 -03001261
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262/*
1263 * CPUs often take a performance hit when accessing unaligned memory
1264 * locations. The actual performance hit varies, it can be small if the
1265 * hardware handles it or large if we have to take an exception and fix it
1266 * in software.
1267 *
1268 * Since an ethernet header is 14 bytes network drivers often end up with
1269 * the IP header at an unaligned offset. The IP header can be aligned by
1270 * shifting the start of the packet by 2 bytes. Drivers should do this
1271 * with:
1272 *
1273 * skb_reserve(NET_IP_ALIGN);
1274 *
1275 * The downside to this alignment of the IP header is that the DMA is now
1276 * unaligned. On some architectures the cost of an unaligned DMA is high
1277 * and this cost outweighs the gains made by aligning the IP header.
1278 *
1279 * Since this trade off varies between architectures, we allow NET_IP_ALIGN
1280 * to be overridden.
1281 */
1282#ifndef NET_IP_ALIGN
1283#define NET_IP_ALIGN 2
1284#endif
1285
Anton Blanchard025be812006-03-31 02:27:06 -08001286/*
1287 * The networking layer reserves some headroom in skb data (via
1288 * dev_alloc_skb). This is used to avoid having to reallocate skb data when
1289 * the header has to grow. In the default case, if the header has to grow
1290 * 16 bytes or less we avoid the reallocation.
1291 *
1292 * Unfortunately this headroom changes the DMA alignment of the resulting
1293 * network packet. As for NET_IP_ALIGN, this unaligned DMA is expensive
1294 * on some architectures. An architecture can override this value,
1295 * perhaps setting it to a cacheline in size (since that will maintain
1296 * cacheline alignment of the DMA). It must be a power of 2.
1297 *
1298 * Various parts of the networking layer expect at least 16 bytes of
1299 * headroom, you should not reduce this.
1300 */
1301#ifndef NET_SKB_PAD
1302#define NET_SKB_PAD 16
1303#endif
1304
Herbert Xu3cc0e872006-06-09 16:13:38 -07001305extern int ___pskb_trim(struct sk_buff *skb, unsigned int len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306
1307static inline void __skb_trim(struct sk_buff *skb, unsigned int len)
1308{
Herbert Xu3cc0e872006-06-09 16:13:38 -07001309 if (unlikely(skb->data_len)) {
1310 WARN_ON(1);
1311 return;
1312 }
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001313 skb->len = len;
1314 skb_set_tail_pointer(skb, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315}
1316
Ilpo Järvinen419ae742008-03-27 17:54:01 -07001317extern void skb_trim(struct sk_buff *skb, unsigned int len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318
1319static inline int __pskb_trim(struct sk_buff *skb, unsigned int len)
1320{
Herbert Xu3cc0e872006-06-09 16:13:38 -07001321 if (skb->data_len)
1322 return ___pskb_trim(skb, len);
1323 __skb_trim(skb, len);
1324 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325}
1326
1327static inline int pskb_trim(struct sk_buff *skb, unsigned int len)
1328{
1329 return (len < skb->len) ? __pskb_trim(skb, len) : 0;
1330}
1331
1332/**
Herbert Xue9fa4f72006-08-13 20:12:58 -07001333 * pskb_trim_unique - remove end from a paged unique (not cloned) buffer
1334 * @skb: buffer to alter
1335 * @len: new length
1336 *
1337 * This is identical to pskb_trim except that the caller knows that
1338 * the skb is not cloned so we should never get an error due to out-
1339 * of-memory.
1340 */
1341static inline void pskb_trim_unique(struct sk_buff *skb, unsigned int len)
1342{
1343 int err = pskb_trim(skb, len);
1344 BUG_ON(err);
1345}
1346
1347/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348 * skb_orphan - orphan a buffer
1349 * @skb: buffer to orphan
1350 *
1351 * If a buffer currently has an owner then we call the owner's
1352 * destructor function and make the @skb unowned. The buffer continues
1353 * to exist but is no longer charged to its former owner.
1354 */
1355static inline void skb_orphan(struct sk_buff *skb)
1356{
1357 if (skb->destructor)
1358 skb->destructor(skb);
1359 skb->destructor = NULL;
1360 skb->sk = NULL;
1361}
1362
1363/**
1364 * __skb_queue_purge - empty a list
1365 * @list: list to empty
1366 *
1367 * Delete all buffers on an &sk_buff list. Each buffer is removed from
1368 * the list and one reference dropped. This function does not take the
1369 * list lock and the caller must hold the relevant locks to use it.
1370 */
1371extern void skb_queue_purge(struct sk_buff_head *list);
1372static inline void __skb_queue_purge(struct sk_buff_head *list)
1373{
1374 struct sk_buff *skb;
1375 while ((skb = __skb_dequeue(list)) != NULL)
1376 kfree_skb(skb);
1377}
1378
1379/**
Christoph Hellwigb4e54de2006-07-24 15:31:14 -07001380 * __dev_alloc_skb - allocate an skbuff for receiving
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 * @length: length to allocate
1382 * @gfp_mask: get_free_pages mask, passed to alloc_skb
1383 *
1384 * Allocate a new &sk_buff and assign it a usage count of one. The
1385 * buffer has unspecified headroom built in. Users should allocate
1386 * the headroom they think they need without accounting for the
1387 * built in space. The built in space is used for optimisations.
1388 *
Christoph Hellwig766ea8c2006-08-07 15:49:53 -07001389 * %NULL is returned if there is no free memory.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391static inline struct sk_buff *__dev_alloc_skb(unsigned int length,
Al Virodd0fc662005-10-07 07:46:04 +01001392 gfp_t gfp_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393{
Anton Blanchard025be812006-03-31 02:27:06 -08001394 struct sk_buff *skb = alloc_skb(length + NET_SKB_PAD, gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395 if (likely(skb))
Anton Blanchard025be812006-03-31 02:27:06 -08001396 skb_reserve(skb, NET_SKB_PAD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 return skb;
1398}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399
Ilpo Järvinenf58518e2008-03-27 17:51:31 -07001400extern struct sk_buff *dev_alloc_skb(unsigned int length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401
Christoph Hellwig8af27452006-07-31 22:35:23 -07001402extern struct sk_buff *__netdev_alloc_skb(struct net_device *dev,
1403 unsigned int length, gfp_t gfp_mask);
1404
1405/**
1406 * netdev_alloc_skb - allocate an skbuff for rx on a specific device
1407 * @dev: network device to receive on
1408 * @length: length to allocate
1409 *
1410 * Allocate a new &sk_buff and assign it a usage count of one. The
1411 * buffer has unspecified headroom built in. Users should allocate
1412 * the headroom they think they need without accounting for the
1413 * built in space. The built in space is used for optimisations.
1414 *
1415 * %NULL is returned if there is no free memory. Although this function
1416 * allocates memory it can be called from an interrupt.
1417 */
1418static inline struct sk_buff *netdev_alloc_skb(struct net_device *dev,
1419 unsigned int length)
1420{
1421 return __netdev_alloc_skb(dev, length, GFP_ATOMIC);
1422}
1423
Peter Zijlstra654bed12008-10-07 14:22:33 -07001424extern struct page *__netdev_alloc_page(struct net_device *dev, gfp_t gfp_mask);
1425
1426/**
1427 * netdev_alloc_page - allocate a page for ps-rx on a specific device
1428 * @dev: network device to receive on
1429 *
1430 * Allocate a new page node local to the specified device.
1431 *
1432 * %NULL is returned if there is no free memory.
1433 */
1434static inline struct page *netdev_alloc_page(struct net_device *dev)
1435{
1436 return __netdev_alloc_page(dev, GFP_ATOMIC);
1437}
1438
1439static inline void netdev_free_page(struct net_device *dev, struct page *page)
1440{
1441 __free_page(page);
1442}
1443
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444/**
Patrick McHardy334a8132007-06-25 04:35:20 -07001445 * skb_clone_writable - is the header of a clone writable
1446 * @skb: buffer to check
1447 * @len: length up to which to write
1448 *
1449 * Returns true if modifying the header part of the cloned buffer
1450 * does not requires the data to be copied.
1451 */
Chuck Leverc2636b42007-10-23 21:07:32 -07001452static inline int skb_clone_writable(struct sk_buff *skb, unsigned int len)
Patrick McHardy334a8132007-06-25 04:35:20 -07001453{
1454 return !skb_header_cloned(skb) &&
1455 skb_headroom(skb) + len <= skb->hdr_len;
1456}
1457
Herbert Xud9cc2042007-09-16 16:21:16 -07001458static inline int __skb_cow(struct sk_buff *skb, unsigned int headroom,
1459 int cloned)
1460{
1461 int delta = 0;
1462
1463 if (headroom < NET_SKB_PAD)
1464 headroom = NET_SKB_PAD;
1465 if (headroom > skb_headroom(skb))
1466 delta = headroom - skb_headroom(skb);
1467
1468 if (delta || cloned)
1469 return pskb_expand_head(skb, ALIGN(delta, NET_SKB_PAD), 0,
1470 GFP_ATOMIC);
1471 return 0;
1472}
1473
Patrick McHardy334a8132007-06-25 04:35:20 -07001474/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475 * skb_cow - copy header of skb when it is required
1476 * @skb: buffer to cow
1477 * @headroom: needed headroom
1478 *
1479 * If the skb passed lacks sufficient headroom or its data part
1480 * is shared, data is reallocated. If reallocation fails, an error
1481 * is returned and original skb is not changed.
1482 *
1483 * The result is skb with writable area skb->head...skb->tail
1484 * and at least @headroom of space at head.
1485 */
1486static inline int skb_cow(struct sk_buff *skb, unsigned int headroom)
1487{
Herbert Xud9cc2042007-09-16 16:21:16 -07001488 return __skb_cow(skb, headroom, skb_cloned(skb));
1489}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490
Herbert Xud9cc2042007-09-16 16:21:16 -07001491/**
1492 * skb_cow_head - skb_cow but only making the head writable
1493 * @skb: buffer to cow
1494 * @headroom: needed headroom
1495 *
1496 * This function is identical to skb_cow except that we replace the
1497 * skb_cloned check by skb_header_cloned. It should be used when
1498 * you only need to push on some header and do not need to modify
1499 * the data.
1500 */
1501static inline int skb_cow_head(struct sk_buff *skb, unsigned int headroom)
1502{
1503 return __skb_cow(skb, headroom, skb_header_cloned(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504}
1505
1506/**
1507 * skb_padto - pad an skbuff up to a minimal size
1508 * @skb: buffer to pad
1509 * @len: minimal length
1510 *
1511 * Pads up a buffer to ensure the trailing bytes exist and are
1512 * blanked. If the buffer already contains sufficient data it
Herbert Xu5b057c62006-06-23 02:06:41 -07001513 * is untouched. Otherwise it is extended. Returns zero on
1514 * success. The skb is freed on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515 */
1516
Herbert Xu5b057c62006-06-23 02:06:41 -07001517static inline int skb_padto(struct sk_buff *skb, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518{
1519 unsigned int size = skb->len;
1520 if (likely(size >= len))
Herbert Xu5b057c62006-06-23 02:06:41 -07001521 return 0;
Gerrit Renker987c4022008-08-11 18:17:17 -07001522 return skb_pad(skb, len - size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523}
1524
1525static inline int skb_add_data(struct sk_buff *skb,
1526 char __user *from, int copy)
1527{
1528 const int off = skb->len;
1529
1530 if (skb->ip_summed == CHECKSUM_NONE) {
1531 int err = 0;
Al Viro50842052006-11-14 21:36:34 -08001532 __wsum csum = csum_and_copy_from_user(from, skb_put(skb, copy),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533 copy, 0, &err);
1534 if (!err) {
1535 skb->csum = csum_block_add(skb->csum, csum, off);
1536 return 0;
1537 }
1538 } else if (!copy_from_user(skb_put(skb, copy), from, copy))
1539 return 0;
1540
1541 __skb_trim(skb, off);
1542 return -EFAULT;
1543}
1544
1545static inline int skb_can_coalesce(struct sk_buff *skb, int i,
1546 struct page *page, int off)
1547{
1548 if (i) {
1549 struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i - 1];
1550
1551 return page == frag->page &&
1552 off == frag->page_offset + frag->size;
1553 }
1554 return 0;
1555}
1556
Herbert Xu364c6ba2006-06-09 16:10:40 -07001557static inline int __skb_linearize(struct sk_buff *skb)
1558{
1559 return __pskb_pull_tail(skb, skb->data_len) ? 0 : -ENOMEM;
1560}
1561
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562/**
1563 * skb_linearize - convert paged skb to linear one
1564 * @skb: buffer to linarize
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 *
1566 * If there is no free memory -ENOMEM is returned, otherwise zero
1567 * is returned and the old skb data released.
1568 */
Herbert Xu364c6ba2006-06-09 16:10:40 -07001569static inline int skb_linearize(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570{
Herbert Xu364c6ba2006-06-09 16:10:40 -07001571 return skb_is_nonlinear(skb) ? __skb_linearize(skb) : 0;
1572}
1573
1574/**
1575 * skb_linearize_cow - make sure skb is linear and writable
1576 * @skb: buffer to process
1577 *
1578 * If there is no free memory -ENOMEM is returned, otherwise zero
1579 * is returned and the old skb data released.
1580 */
1581static inline int skb_linearize_cow(struct sk_buff *skb)
1582{
1583 return skb_is_nonlinear(skb) || skb_cloned(skb) ?
1584 __skb_linearize(skb) : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585}
1586
1587/**
1588 * skb_postpull_rcsum - update checksum for received skb after pull
1589 * @skb: buffer to update
1590 * @start: start of data before pull
1591 * @len: length of data pulled
1592 *
1593 * After doing a pull on a received packet, you need to call this to
Patrick McHardy84fa7932006-08-29 16:44:56 -07001594 * update the CHECKSUM_COMPLETE checksum, or set ip_summed to
1595 * CHECKSUM_NONE so that it can be recomputed from scratch.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596 */
1597
1598static inline void skb_postpull_rcsum(struct sk_buff *skb,
Herbert Xucbb042f2006-03-20 22:43:56 -08001599 const void *start, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600{
Patrick McHardy84fa7932006-08-29 16:44:56 -07001601 if (skb->ip_summed == CHECKSUM_COMPLETE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602 skb->csum = csum_sub(skb->csum, csum_partial(start, len, 0));
1603}
1604
Herbert Xucbb042f2006-03-20 22:43:56 -08001605unsigned char *skb_pull_rcsum(struct sk_buff *skb, unsigned int len);
1606
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607/**
1608 * pskb_trim_rcsum - trim received skb and update checksum
1609 * @skb: buffer to trim
1610 * @len: new length
1611 *
1612 * This is exactly the same as pskb_trim except that it ensures the
1613 * checksum of received packets are still valid after the operation.
1614 */
1615
1616static inline int pskb_trim_rcsum(struct sk_buff *skb, unsigned int len)
1617{
Stephen Hemminger0e4e4222005-09-08 12:32:03 -07001618 if (likely(len >= skb->len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619 return 0;
Patrick McHardy84fa7932006-08-29 16:44:56 -07001620 if (skb->ip_summed == CHECKSUM_COMPLETE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621 skb->ip_summed = CHECKSUM_NONE;
1622 return __pskb_trim(skb, len);
1623}
1624
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625#define skb_queue_walk(queue, skb) \
1626 for (skb = (queue)->next; \
1627 prefetch(skb->next), (skb != (struct sk_buff *)(queue)); \
1628 skb = skb->next)
1629
James Chapman46f89142007-04-30 00:07:31 -07001630#define skb_queue_walk_safe(queue, skb, tmp) \
1631 for (skb = (queue)->next, tmp = skb->next; \
1632 skb != (struct sk_buff *)(queue); \
1633 skb = tmp, tmp = skb->next)
1634
David S. Miller1164f522008-09-23 00:49:44 -07001635#define skb_queue_walk_from(queue, skb) \
1636 for (; prefetch(skb->next), (skb != (struct sk_buff *)(queue)); \
1637 skb = skb->next)
1638
1639#define skb_queue_walk_from_safe(queue, skb, tmp) \
1640 for (tmp = skb->next; \
1641 skb != (struct sk_buff *)(queue); \
1642 skb = tmp, tmp = skb->next)
1643
Stephen Hemminger300ce172005-10-30 13:47:34 -08001644#define skb_queue_reverse_walk(queue, skb) \
1645 for (skb = (queue)->prev; \
1646 prefetch(skb->prev), (skb != (struct sk_buff *)(queue)); \
1647 skb = skb->prev)
1648
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649
Herbert Xua59322b2007-12-05 01:53:40 -08001650extern struct sk_buff *__skb_recv_datagram(struct sock *sk, unsigned flags,
1651 int *peeked, int *err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652extern struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags,
1653 int noblock, int *err);
1654extern unsigned int datagram_poll(struct file *file, struct socket *sock,
1655 struct poll_table_struct *wait);
1656extern int skb_copy_datagram_iovec(const struct sk_buff *from,
1657 int offset, struct iovec *to,
1658 int size);
Herbert Xufb286bb2005-11-10 13:01:24 -08001659extern int skb_copy_and_csum_datagram_iovec(struct sk_buff *skb,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660 int hlen,
1661 struct iovec *iov);
Rusty Russelldb543c12008-08-15 15:13:53 -07001662extern int skb_copy_datagram_from_iovec(struct sk_buff *skb,
1663 int offset,
1664 struct iovec *from,
1665 int len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666extern void skb_free_datagram(struct sock *sk, struct sk_buff *skb);
Herbert Xu27ab2562007-12-05 01:51:58 -08001667extern int skb_kill_datagram(struct sock *sk, struct sk_buff *skb,
Herbert Xu3305b802005-12-13 23:16:37 -08001668 unsigned int flags);
Al Viro2bbbc862006-11-14 21:37:14 -08001669extern __wsum skb_checksum(const struct sk_buff *skb, int offset,
1670 int len, __wsum csum);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671extern int skb_copy_bits(const struct sk_buff *skb, int offset,
1672 void *to, int len);
Stephen Hemminger0c6fcc82007-04-20 16:40:01 -07001673extern int skb_store_bits(struct sk_buff *skb, int offset,
1674 const void *from, int len);
Al Viro81d77662006-11-14 21:37:33 -08001675extern __wsum skb_copy_and_csum_bits(const struct sk_buff *skb,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 int offset, u8 *to, int len,
Al Viro81d77662006-11-14 21:37:33 -08001677 __wsum csum);
Jens Axboe9c55e012007-11-06 23:30:13 -08001678extern int skb_splice_bits(struct sk_buff *skb,
1679 unsigned int offset,
1680 struct pipe_inode_info *pipe,
1681 unsigned int len,
1682 unsigned int flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683extern void skb_copy_and_csum_dev(const struct sk_buff *skb, u8 *to);
1684extern void skb_split(struct sk_buff *skb,
1685 struct sk_buff *skb1, const u32 len);
Ilpo Järvinen832d11c2008-11-24 21:20:15 -08001686extern int skb_shift(struct sk_buff *tgt, struct sk_buff *skb,
1687 int shiftlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688
Herbert Xu576a30e2006-06-27 13:22:38 -07001689extern struct sk_buff *skb_segment(struct sk_buff *skb, int features);
Herbert Xu71d93b32008-12-15 23:42:33 -08001690extern int skb_gro_receive(struct sk_buff **head,
1691 struct sk_buff *skb);
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03001692
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693static inline void *skb_header_pointer(const struct sk_buff *skb, int offset,
1694 int len, void *buffer)
1695{
1696 int hlen = skb_headlen(skb);
1697
Patrick McHardy55820ee2005-07-05 14:08:10 -07001698 if (hlen - offset >= len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 return skb->data + offset;
1700
1701 if (skb_copy_bits(skb, offset, buffer, len) < 0)
1702 return NULL;
1703
1704 return buffer;
1705}
1706
Arnaldo Carvalho de Melod626f622007-03-27 18:55:52 -03001707static inline void skb_copy_from_linear_data(const struct sk_buff *skb,
1708 void *to,
1709 const unsigned int len)
1710{
1711 memcpy(to, skb->data, len);
1712}
1713
1714static inline void skb_copy_from_linear_data_offset(const struct sk_buff *skb,
1715 const int offset, void *to,
1716 const unsigned int len)
1717{
1718 memcpy(to, skb->data + offset, len);
1719}
1720
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03001721static inline void skb_copy_to_linear_data(struct sk_buff *skb,
1722 const void *from,
1723 const unsigned int len)
1724{
1725 memcpy(skb->data, from, len);
1726}
1727
1728static inline void skb_copy_to_linear_data_offset(struct sk_buff *skb,
1729 const int offset,
1730 const void *from,
1731 const unsigned int len)
1732{
1733 memcpy(skb->data + offset, from, len);
1734}
1735
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736extern void skb_init(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001738/**
1739 * skb_get_timestamp - get timestamp from a skb
1740 * @skb: skb to get stamp from
1741 * @stamp: pointer to struct timeval to store stamp in
1742 *
1743 * Timestamps are stored in the skb as offsets to a base timestamp.
1744 * This function converts the offset back to a struct timeval and stores
1745 * it in stamp.
1746 */
Stephen Hemmingerf2c38392005-09-06 15:48:03 -07001747static inline void skb_get_timestamp(const struct sk_buff *skb, struct timeval *stamp)
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001748{
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07001749 *stamp = ktime_to_timeval(skb->tstamp);
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001750}
1751
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07001752static inline void __net_timestamp(struct sk_buff *skb)
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001753{
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07001754 skb->tstamp = ktime_get_real();
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001755}
1756
Stephen Hemminger164891a2007-04-23 22:26:16 -07001757static inline ktime_t net_timedelta(ktime_t t)
1758{
1759 return ktime_sub(ktime_get_real(), t);
1760}
1761
Ilpo Järvinenb9ce2042007-06-15 15:08:43 -07001762static inline ktime_t net_invalid_timestamp(void)
1763{
1764 return ktime_set(0, 0);
1765}
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001766
Herbert Xu759e5d02007-03-25 20:10:56 -07001767extern __sum16 __skb_checksum_complete_head(struct sk_buff *skb, int len);
Al Virob51655b2006-11-14 21:40:42 -08001768extern __sum16 __skb_checksum_complete(struct sk_buff *skb);
Herbert Xufb286bb2005-11-10 13:01:24 -08001769
Herbert Xu60476372007-04-09 11:59:39 -07001770static inline int skb_csum_unnecessary(const struct sk_buff *skb)
1771{
1772 return skb->ip_summed & CHECKSUM_UNNECESSARY;
1773}
1774
Herbert Xufb286bb2005-11-10 13:01:24 -08001775/**
1776 * skb_checksum_complete - Calculate checksum of an entire packet
1777 * @skb: packet to process
1778 *
1779 * This function calculates the checksum over the entire packet plus
1780 * the value of skb->csum. The latter can be used to supply the
1781 * checksum of a pseudo header as used by TCP/UDP. It returns the
1782 * checksum.
1783 *
1784 * For protocols that contain complete checksums such as ICMP/TCP/UDP,
1785 * this function can be used to verify that checksum on received
1786 * packets. In that case the function should return zero if the
1787 * checksum is correct. In particular, this function will return zero
1788 * if skb->ip_summed is CHECKSUM_UNNECESSARY which indicates that the
1789 * hardware has already verified the correctness of the checksum.
1790 */
Al Viro4381ca32007-07-15 21:00:11 +01001791static inline __sum16 skb_checksum_complete(struct sk_buff *skb)
Herbert Xufb286bb2005-11-10 13:01:24 -08001792{
Herbert Xu60476372007-04-09 11:59:39 -07001793 return skb_csum_unnecessary(skb) ?
1794 0 : __skb_checksum_complete(skb);
Herbert Xufb286bb2005-11-10 13:01:24 -08001795}
1796
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -07001797#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
Yasuyuki Kozakaide6e05c2007-03-23 11:17:27 -07001798extern void nf_conntrack_destroy(struct nf_conntrack *nfct);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799static inline void nf_conntrack_put(struct nf_conntrack *nfct)
1800{
1801 if (nfct && atomic_dec_and_test(&nfct->use))
Yasuyuki Kozakaide6e05c2007-03-23 11:17:27 -07001802 nf_conntrack_destroy(nfct);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803}
1804static inline void nf_conntrack_get(struct nf_conntrack *nfct)
1805{
1806 if (nfct)
1807 atomic_inc(&nfct->use);
1808}
Yasuyuki Kozakai9fb9cbb2005-11-09 16:38:16 -08001809static inline void nf_conntrack_get_reasm(struct sk_buff *skb)
1810{
1811 if (skb)
1812 atomic_inc(&skb->users);
1813}
1814static inline void nf_conntrack_put_reasm(struct sk_buff *skb)
1815{
1816 if (skb)
1817 kfree_skb(skb);
1818}
1819#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820#ifdef CONFIG_BRIDGE_NETFILTER
1821static inline void nf_bridge_put(struct nf_bridge_info *nf_bridge)
1822{
1823 if (nf_bridge && atomic_dec_and_test(&nf_bridge->use))
1824 kfree(nf_bridge);
1825}
1826static inline void nf_bridge_get(struct nf_bridge_info *nf_bridge)
1827{
1828 if (nf_bridge)
1829 atomic_inc(&nf_bridge->use);
1830}
1831#endif /* CONFIG_BRIDGE_NETFILTER */
Patrick McHardya193a4a2006-03-20 19:23:05 -08001832static inline void nf_reset(struct sk_buff *skb)
1833{
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -07001834#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
Patrick McHardya193a4a2006-03-20 19:23:05 -08001835 nf_conntrack_put(skb->nfct);
1836 skb->nfct = NULL;
Patrick McHardya193a4a2006-03-20 19:23:05 -08001837 nf_conntrack_put_reasm(skb->nfct_reasm);
1838 skb->nfct_reasm = NULL;
1839#endif
1840#ifdef CONFIG_BRIDGE_NETFILTER
1841 nf_bridge_put(skb->nf_bridge);
1842 skb->nf_bridge = NULL;
1843#endif
1844}
1845
Yasuyuki Kozakaiedda5532007-03-14 16:43:37 -07001846/* Note: This doesn't put any conntrack and bridge info in dst. */
1847static inline void __nf_copy(struct sk_buff *dst, const struct sk_buff *src)
1848{
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -07001849#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
Yasuyuki Kozakaiedda5532007-03-14 16:43:37 -07001850 dst->nfct = src->nfct;
1851 nf_conntrack_get(src->nfct);
1852 dst->nfctinfo = src->nfctinfo;
Yasuyuki Kozakaiedda5532007-03-14 16:43:37 -07001853 dst->nfct_reasm = src->nfct_reasm;
1854 nf_conntrack_get_reasm(src->nfct_reasm);
1855#endif
1856#ifdef CONFIG_BRIDGE_NETFILTER
1857 dst->nf_bridge = src->nf_bridge;
1858 nf_bridge_get(src->nf_bridge);
1859#endif
1860}
1861
Yasuyuki Kozakaie7ac05f2007-03-14 16:44:01 -07001862static inline void nf_copy(struct sk_buff *dst, const struct sk_buff *src)
1863{
Yasuyuki Kozakaie7ac05f2007-03-14 16:44:01 -07001864#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -07001865 nf_conntrack_put(dst->nfct);
Yasuyuki Kozakaie7ac05f2007-03-14 16:44:01 -07001866 nf_conntrack_put_reasm(dst->nfct_reasm);
1867#endif
1868#ifdef CONFIG_BRIDGE_NETFILTER
1869 nf_bridge_put(dst->nf_bridge);
1870#endif
1871 __nf_copy(dst, src);
1872}
1873
James Morris984bc162006-06-09 00:29:17 -07001874#ifdef CONFIG_NETWORK_SECMARK
1875static inline void skb_copy_secmark(struct sk_buff *to, const struct sk_buff *from)
1876{
1877 to->secmark = from->secmark;
1878}
1879
1880static inline void skb_init_secmark(struct sk_buff *skb)
1881{
1882 skb->secmark = 0;
1883}
1884#else
1885static inline void skb_copy_secmark(struct sk_buff *to, const struct sk_buff *from)
1886{ }
1887
1888static inline void skb_init_secmark(struct sk_buff *skb)
1889{ }
1890#endif
1891
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001892static inline void skb_set_queue_mapping(struct sk_buff *skb, u16 queue_mapping)
1893{
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001894 skb->queue_mapping = queue_mapping;
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001895}
1896
Pavel Emelyanov4e3ab472007-10-21 17:01:29 -07001897static inline u16 skb_get_queue_mapping(struct sk_buff *skb)
1898{
Pavel Emelyanov4e3ab472007-10-21 17:01:29 -07001899 return skb->queue_mapping;
Pavel Emelyanov4e3ab472007-10-21 17:01:29 -07001900}
1901
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001902static inline void skb_copy_queue_mapping(struct sk_buff *to, const struct sk_buff *from)
1903{
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001904 to->queue_mapping = from->queue_mapping;
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001905}
1906
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -07001907#ifdef CONFIG_XFRM
1908static inline struct sec_path *skb_sec_path(struct sk_buff *skb)
1909{
1910 return skb->sp;
1911}
1912#else
1913static inline struct sec_path *skb_sec_path(struct sk_buff *skb)
1914{
1915 return NULL;
1916}
1917#endif
1918
Herbert Xu89114af2006-07-08 13:34:32 -07001919static inline int skb_is_gso(const struct sk_buff *skb)
1920{
1921 return skb_shinfo(skb)->gso_size;
1922}
1923
Brice Goglineabd7e32007-10-13 12:33:32 +02001924static inline int skb_is_gso_v6(const struct sk_buff *skb)
1925{
1926 return skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6;
1927}
1928
Ben Hutchings4497b072008-06-19 16:22:28 -07001929extern void __skb_warn_lro_forwarding(const struct sk_buff *skb);
1930
1931static inline bool skb_warn_if_lro(const struct sk_buff *skb)
1932{
1933 /* LRO sets gso_size but not gso_type, whereas if GSO is really
1934 * wanted then gso_type will be set. */
1935 struct skb_shared_info *shinfo = skb_shinfo(skb);
1936 if (shinfo->gso_size != 0 && unlikely(shinfo->gso_type == 0)) {
1937 __skb_warn_lro_forwarding(skb);
1938 return true;
1939 }
1940 return false;
1941}
1942
Herbert Xu35fc92a2007-03-26 23:22:20 -07001943static inline void skb_forward_csum(struct sk_buff *skb)
1944{
1945 /* Unfortunately we don't support this one. Any brave souls? */
1946 if (skb->ip_summed == CHECKSUM_COMPLETE)
1947 skb->ip_summed = CHECKSUM_NONE;
1948}
1949
Rusty Russellf35d9d82008-02-04 23:49:54 -05001950bool skb_partial_csum_set(struct sk_buff *skb, u16 start, u16 off);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951#endif /* __KERNEL__ */
1952#endif /* _LINUX_SKBUFF_H */