blob: 7cdfb4d52847e6f733df1538f48fc73508e3d13e [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>
Vegard Nossumfe55f6d2008-08-30 12:16:35 +020018#include <linux/kmemcheck.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/compiler.h>
20#include <linux/time.h>
21#include <linux/cache.h>
22
23#include <asm/atomic.h>
24#include <asm/types.h>
25#include <linux/spinlock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/net.h>
Thomas Graf3fc7e8a2005-06-23 21:00:17 -070027#include <linux/textsearch.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <net/checksum.h>
Al Viroa80958f2006-12-04 20:41:19 +000029#include <linux/rcupdate.h>
Chris Leech97fc2f02006-05-23 17:55:33 -070030#include <linux/dmaengine.h>
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -070031#include <linux/hrtimer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
Herbert Xu60476372007-04-09 11:59:39 -070033/* Don't change this without changing skb_csum_unnecessary! */
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#define CHECKSUM_NONE 0
Herbert Xu60476372007-04-09 11:59:39 -070035#define CHECKSUM_UNNECESSARY 1
36#define CHECKSUM_COMPLETE 2
37#define CHECKSUM_PARTIAL 3
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
39#define SKB_DATA_ALIGN(X) (((X) + (SMP_CACHE_BYTES - 1)) & \
40 ~(SMP_CACHE_BYTES - 1))
David S. Millerfc910a22007-03-25 20:27:59 -070041#define SKB_WITH_OVERHEAD(X) \
Herbert Xudeea84b2007-10-21 16:27:46 -070042 ((X) - SKB_DATA_ALIGN(sizeof(struct skb_shared_info)))
David S. Millerfc910a22007-03-25 20:27:59 -070043#define SKB_MAX_ORDER(X, ORDER) \
44 SKB_WITH_OVERHEAD((PAGE_SIZE << (ORDER)) - (X))
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#define SKB_MAX_HEAD(X) (SKB_MAX_ORDER((X), 0))
46#define SKB_MAX_ALLOC (SKB_MAX_ORDER(0, 2))
47
48/* A. Checksumming of received packets by device.
49 *
50 * NONE: device failed to checksum this packet.
51 * skb->csum is undefined.
52 *
53 * UNNECESSARY: device parsed packet and wouldbe verified checksum.
54 * skb->csum is undefined.
55 * It is bad option, but, unfortunately, many of vendors do this.
56 * Apparently with secret goal to sell you new device, when you
57 * will add new protocol to your host. F.e. IPv6. 8)
58 *
Patrick McHardy84fa7932006-08-29 16:44:56 -070059 * COMPLETE: the most generic way. Device supplied checksum of _all_
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 * the packet as seen by netif_rx in skb->csum.
61 * NOTE: Even if device supports only some protocols, but
Patrick McHardy84fa7932006-08-29 16:44:56 -070062 * is able to produce some skb->csum, it MUST use COMPLETE,
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 * not UNNECESSARY.
64 *
Herbert Xuc6c6e3e2007-07-10 22:41:55 -070065 * PARTIAL: identical to the case for output below. This may occur
66 * on a packet received directly from another Linux OS, e.g.,
67 * a virtualised Linux kernel on the same host. The packet can
68 * be treated in the same way as UNNECESSARY except that on
69 * output (i.e., forwarding) the checksum must be filled in
70 * by the OS or the hardware.
71 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 * B. Checksumming on output.
73 *
74 * NONE: skb is checksummed by protocol or csum is not required.
75 *
Patrick McHardy84fa7932006-08-29 16:44:56 -070076 * PARTIAL: device is required to csum packet as seen by hard_start_xmit
Herbert Xuc6c6e3e2007-07-10 22:41:55 -070077 * from skb->csum_start to the end and to record the checksum
78 * at skb->csum_start + skb->csum_offset.
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 *
80 * Device must show its capabilities in dev->features, set
81 * at device setup time.
82 * NETIF_F_HW_CSUM - it is clever device, it is able to checksum
83 * everything.
84 * NETIF_F_NO_CSUM - loopback or reliable single hop media.
85 * NETIF_F_IP_CSUM - device is dumb. It is able to csum only
86 * TCP/UDP over IPv4. Sigh. Vendors like this
87 * way by an unknown reason. Though, see comment above
88 * about CHECKSUM_UNNECESSARY. 8)
Herbert Xuc6c6e3e2007-07-10 22:41:55 -070089 * NETIF_F_IPV6_CSUM about as dumb as the last one but does IPv6 instead.
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 *
91 * Any questions? No questions, good. --ANK
92 */
93
Linus Torvalds1da177e2005-04-16 15:20:36 -070094struct net_device;
David Howells716ea3a2007-04-02 20:19:53 -070095struct scatterlist;
Jens Axboe9c55e012007-11-06 23:30:13 -080096struct pipe_inode_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -070098#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
Linus Torvalds1da177e2005-04-16 15:20:36 -070099struct nf_conntrack {
100 atomic_t use;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101};
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -0700102#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103
104#ifdef CONFIG_BRIDGE_NETFILTER
105struct nf_bridge_info {
106 atomic_t use;
107 struct net_device *physindev;
108 struct net_device *physoutdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 unsigned int mask;
110 unsigned long data[32 / sizeof(unsigned long)];
111};
112#endif
113
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114struct sk_buff_head {
115 /* These two members must be first. */
116 struct sk_buff *next;
117 struct sk_buff *prev;
118
119 __u32 qlen;
120 spinlock_t lock;
121};
122
123struct sk_buff;
124
125/* To allow 64K frame to be packed as single skb without frag_list */
126#define MAX_SKB_FRAGS (65536/PAGE_SIZE + 2)
127
128typedef struct skb_frag_struct skb_frag_t;
129
130struct skb_frag_struct {
131 struct page *page;
David S. Millera309bb02007-07-30 18:47:03 -0700132 __u32 page_offset;
133 __u32 size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134};
135
Patrick Ohlyac45f602009-02-12 05:03:37 +0000136#define HAVE_HW_TIME_STAMP
137
138/**
Randy Dunlapd3a21be2009-03-02 03:15:58 -0800139 * struct skb_shared_hwtstamps - hardware time stamps
Patrick Ohlyac45f602009-02-12 05:03:37 +0000140 * @hwtstamp: hardware time stamp transformed into duration
141 * since arbitrary point in time
142 * @syststamp: hwtstamp transformed to system time base
143 *
144 * Software time stamps generated by ktime_get_real() are stored in
145 * skb->tstamp. The relation between the different kinds of time
146 * stamps is as follows:
147 *
148 * syststamp and tstamp can be compared against each other in
149 * arbitrary combinations. The accuracy of a
150 * syststamp/tstamp/"syststamp from other device" comparison is
151 * limited by the accuracy of the transformation into system time
152 * base. This depends on the device driver and its underlying
153 * hardware.
154 *
155 * hwtstamps can only be compared against other hwtstamps from
156 * the same device.
157 *
158 * This structure is attached to packets as part of the
159 * &skb_shared_info. Use skb_hwtstamps() to get a pointer.
160 */
161struct skb_shared_hwtstamps {
162 ktime_t hwtstamp;
163 ktime_t syststamp;
164};
165
166/**
Randy Dunlapd3a21be2009-03-02 03:15:58 -0800167 * struct skb_shared_tx - instructions for time stamping of outgoing packets
Patrick Ohlyac45f602009-02-12 05:03:37 +0000168 * @hardware: generate hardware time stamp
169 * @software: generate software time stamp
170 * @in_progress: device driver is going to provide
171 * hardware time stamp
Randy Dunlap4b21cd42009-03-28 23:38:40 -0700172 * @flags: all shared_tx flags
Patrick Ohlyac45f602009-02-12 05:03:37 +0000173 *
174 * These flags are attached to packets as part of the
175 * &skb_shared_info. Use skb_tx() to get a pointer.
176 */
177union skb_shared_tx {
178 struct {
179 __u8 hardware:1,
180 software:1,
181 in_progress:1;
182 };
183 __u8 flags;
184};
185
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186/* This data is invariant across clones and lives at
187 * the end of the header data, ie. at skb->end.
188 */
189struct skb_shared_info {
Benjamin LaHaise4947d3e2006-01-03 14:06:50 -0800190 unsigned short nr_frags;
Herbert Xu79671682006-06-22 02:40:14 -0700191 unsigned short gso_size;
192 /* Warning: this field is not always filled in (UFO)! */
193 unsigned short gso_segs;
194 unsigned short gso_type;
Al Viroae08e1f2006-11-08 00:27:11 -0800195 __be32 ip6_frag_id;
Patrick Ohlyac45f602009-02-12 05:03:37 +0000196 union skb_shared_tx tx_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 struct sk_buff *frag_list;
Patrick Ohlyac45f602009-02-12 05:03:37 +0000198 struct skb_shared_hwtstamps hwtstamps;
Eric Dumazetec7d2f22010-05-05 01:07:37 -0700199
200 /*
201 * Warning : all fields before dataref are cleared in __alloc_skb()
202 */
203 atomic_t dataref;
204
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 skb_frag_t frags[MAX_SKB_FRAGS];
Johann Baudy69e3c752009-05-18 22:11:22 -0700206 /* Intermediate layers must ensure that destructor_arg
207 * remains valid until skb destructor */
208 void * destructor_arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209};
210
211/* We divide dataref into two halves. The higher 16 bits hold references
212 * to the payload part of skb->data. The lower 16 bits hold references to
Patrick McHardy334a8132007-06-25 04:35:20 -0700213 * the entire skb->data. A clone of a headerless skb holds the length of
214 * the header in skb->hdr_len.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 *
216 * All users must obey the rule that the skb->data reference count must be
217 * greater than or equal to the payload reference count.
218 *
219 * Holding a reference to the payload part means that the user does not
220 * care about modifications to the header part of skb->data.
221 */
222#define SKB_DATAREF_SHIFT 16
223#define SKB_DATAREF_MASK ((1 << SKB_DATAREF_SHIFT) - 1)
224
David S. Millerd179cd12005-08-17 14:57:30 -0700225
226enum {
227 SKB_FCLONE_UNAVAILABLE,
228 SKB_FCLONE_ORIG,
229 SKB_FCLONE_CLONE,
230};
231
Herbert Xu79671682006-06-22 02:40:14 -0700232enum {
233 SKB_GSO_TCPV4 = 1 << 0,
Herbert Xuf83ef8c2006-06-30 13:37:03 -0700234 SKB_GSO_UDP = 1 << 1,
Herbert Xu576a30e2006-06-27 13:22:38 -0700235
236 /* This indicates the skb is from an untrusted source. */
237 SKB_GSO_DODGY = 1 << 2,
Michael Chanb0da85372006-06-29 12:30:00 -0700238
239 /* This indicates the tcp segment has CWR set. */
Herbert Xuf83ef8c2006-06-30 13:37:03 -0700240 SKB_GSO_TCP_ECN = 1 << 3,
241
242 SKB_GSO_TCPV6 = 1 << 4,
Chris Leech01d5b2f2009-02-27 14:06:49 -0800243
244 SKB_GSO_FCOE = 1 << 5,
Herbert Xu79671682006-06-22 02:40:14 -0700245};
246
Arnaldo Carvalho de Melo2e07fa92007-04-10 21:22:35 -0700247#if BITS_PER_LONG > 32
248#define NET_SKBUFF_DATA_USES_OFFSET 1
249#endif
250
251#ifdef NET_SKBUFF_DATA_USES_OFFSET
252typedef unsigned int sk_buff_data_t;
253#else
254typedef unsigned char *sk_buff_data_t;
255#endif
256
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257/**
258 * struct sk_buff - socket buffer
259 * @next: Next buffer in list
260 * @prev: Previous buffer in list
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 * @sk: Socket we are owned by
Herbert Xu325ed822005-10-03 13:57:23 -0700262 * @tstamp: Time we arrived
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 * @dev: Device we arrived on/are leaving by
Randy Dunlapbe52178b2007-05-03 03:16:20 -0700264 * @transport_header: Transport layer header
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -0700265 * @network_header: Network layer header
266 * @mac_header: Link layer header
Eric Dumazet7fee2262010-05-11 23:19:48 +0000267 * @_skb_refdst: destination entry (with norefcount bit)
Martin Waitz67be2dd2005-05-01 08:59:26 -0700268 * @sp: the security path, used for xfrm
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 * @cb: Control buffer. Free for use by every layer. Put private vars here
270 * @len: Length of actual data
271 * @data_len: Data length
272 * @mac_len: Length of link layer header
Patrick McHardy334a8132007-06-25 04:35:20 -0700273 * @hdr_len: writable header length of cloned skb
Herbert Xu663ead32007-04-09 11:59:07 -0700274 * @csum: Checksum (must include start/offset pair)
275 * @csum_start: Offset from skb->head where checksumming should start
276 * @csum_offset: Offset from csum_start where checksum should be stored
Martin Waitz67be2dd2005-05-01 08:59:26 -0700277 * @local_df: allow local fragmentation
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 * @cloned: Head may be cloned (check refcnt to be sure)
279 * @nohdr: Payload reference only, must not modify header
280 * @pkt_type: Packet class
Randy Dunlapc83c2482005-10-18 22:07:41 -0700281 * @fclone: skbuff clone status
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 * @ip_summed: Driver fed us an IP checksum
283 * @priority: Packet queueing priority
284 * @users: User count - see {datagram,tcp}.c
285 * @protocol: Packet protocol from driver
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 * @truesize: Buffer size
287 * @head: Head of buffer
288 * @data: Data head pointer
289 * @tail: Tail pointer
290 * @end: End pointer
291 * @destructor: Destruct function
Thomas Graf82e91ff2006-11-09 15:19:14 -0800292 * @mark: Generic packet mark
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 * @nfct: Associated connection, if any
Randy Dunlapc83c2482005-10-18 22:07:41 -0700294 * @ipvs_property: skbuff is owned by ipvs
Randy Dunlap31729362008-02-18 20:52:13 -0800295 * @peeked: this packet has been seen already, so stats have been
296 * done for it, don't do them again
Jozsef Kadlecsikba9dda32007-07-07 22:21:23 -0700297 * @nf_trace: netfilter packet trace flag
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 * @nfctinfo: Relationship of this skb to the connection
Randy Dunlap461ddf32005-11-20 21:25:15 -0800299 * @nfct_reasm: netfilter conntrack re-assembly pointer
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 * @nf_bridge: Saved data about a bridged frame - see br_netfilter.c
Eric Dumazet8964be42009-11-20 15:35:04 -0800301 * @skb_iif: ifindex of device we arrived on
Tom Herbert0a9627f2010-03-16 08:03:29 +0000302 * @rxhash: the packet hash computed on receive
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -0700303 * @queue_mapping: Queue mapping for multiqueue devices
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 * @tc_index: Traffic control index
305 * @tc_verd: traffic control verdict
Randy Dunlap553a5672008-04-20 10:51:01 -0700306 * @ndisc_nodetype: router type (from link layer)
Randy Dunlapf4b8ea72006-06-22 16:00:11 -0700307 * @dma_cookie: a cookie to one of several possible DMA operations
308 * done by skb DMA functions
James Morris984bc162006-06-09 00:29:17 -0700309 * @secmark: security marking
Patrick McHardy6aa895b02008-07-14 22:49:06 -0700310 * @vlan_tci: vlan tag control information
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 */
312
313struct sk_buff {
314 /* These two members must be first. */
315 struct sk_buff *next;
316 struct sk_buff *prev;
317
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -0700318 ktime_t tstamp;
Felix Fietkauda3f5cf2010-02-23 11:45:51 +0000319
320 struct sock *sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 struct net_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 /*
324 * This is the control buffer. It is free to use for every
325 * layer. Please put your private variables there. If you
326 * want to keep them across layers you have to do a skb_clone()
327 * first. This is owned by whoever has the skb queued ATM.
328 */
Felix Fietkauda3f5cf2010-02-23 11:45:51 +0000329 char cb[48] __aligned(8);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330
Eric Dumazet7fee2262010-05-11 23:19:48 +0000331 unsigned long _skb_refdst;
Felix Fietkauda3f5cf2010-02-23 11:45:51 +0000332#ifdef CONFIG_XFRM
333 struct sec_path *sp;
334#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 unsigned int len,
Patrick McHardy334a8132007-06-25 04:35:20 -0700336 data_len;
337 __u16 mac_len,
338 hdr_len;
Al Viroff1dcad2006-11-20 18:07:29 -0800339 union {
340 __wsum csum;
Herbert Xu663ead32007-04-09 11:59:07 -0700341 struct {
342 __u16 csum_start;
343 __u16 csum_offset;
344 };
Al Viroff1dcad2006-11-20 18:07:29 -0800345 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 __u32 priority;
Vegard Nossumfe55f6d2008-08-30 12:16:35 +0200347 kmemcheck_bitfield_begin(flags1);
Thomas Graf1cbb3382005-07-05 14:13:41 -0700348 __u8 local_df:1,
349 cloned:1,
350 ip_summed:2,
Harald Welte6869c4d2005-08-09 19:24:19 -0700351 nohdr:1,
352 nfctinfo:3;
David S. Millerd179cd12005-08-17 14:57:30 -0700353 __u8 pkt_type:3,
Patrick McHardyb84f4cc2005-11-20 21:19:21 -0800354 fclone:2,
Jozsef Kadlecsikba9dda32007-07-07 22:21:23 -0700355 ipvs_property:1,
Herbert Xua59322b2007-12-05 01:53:40 -0800356 peeked:1,
Jozsef Kadlecsikba9dda32007-07-07 22:21:23 -0700357 nf_trace:1;
Vegard Nossumfe55f6d2008-08-30 12:16:35 +0200358 kmemcheck_bitfield_end(flags1);
Eric Dumazet4ab408d2010-03-01 03:09:26 +0000359 __be16 protocol;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360
361 void (*destructor)(struct sk_buff *skb);
Yasuyuki Kozakai9fb9cbb2005-11-09 16:38:16 -0800362#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -0700363 struct nf_conntrack *nfct;
Yasuyuki Kozakai9fb9cbb2005-11-09 16:38:16 -0800364 struct sk_buff *nfct_reasm;
365#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366#ifdef CONFIG_BRIDGE_NETFILTER
367 struct nf_bridge_info *nf_bridge;
368#endif
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -0700369
Eric Dumazet8964be42009-11-20 15:35:04 -0800370 int skb_iif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371#ifdef CONFIG_NET_SCHED
Patrick McHardyb6b99eb2005-08-09 19:33:51 -0700372 __u16 tc_index; /* traffic control index */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373#ifdef CONFIG_NET_CLS_ACT
Patrick McHardyb6b99eb2005-08-09 19:33:51 -0700374 __u16 tc_verd; /* traffic control verdict */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376#endif
Vegard Nossumfe55f6d2008-08-30 12:16:35 +0200377
Tom Herbert0a9627f2010-03-16 08:03:29 +0000378 __u32 rxhash;
379
Vegard Nossumfe55f6d2008-08-30 12:16:35 +0200380 kmemcheck_bitfield_begin(flags2);
Eric Dumazet14d18a82009-10-29 00:10:37 +0000381 __u16 queue_mapping:16;
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -0400382#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -0400383 __u8 ndisc_nodetype:2;
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -0400384#endif
Vegard Nossumfe55f6d2008-08-30 12:16:35 +0200385 kmemcheck_bitfield_end(flags2);
386
Johannes Berg72bce622009-06-17 17:45:28 +0200387 /* 0/14 bit hole */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -0700388
Chris Leech97fc2f02006-05-23 17:55:33 -0700389#ifdef CONFIG_NET_DMA
390 dma_cookie_t dma_cookie;
391#endif
James Morris984bc162006-06-09 00:29:17 -0700392#ifdef CONFIG_NETWORK_SECMARK
393 __u32 secmark;
394#endif
Neil Horman3b885782009-10-12 13:26:31 -0700395 union {
396 __u32 mark;
397 __u32 dropcount;
398 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399
Patrick McHardy6aa895b02008-07-14 22:49:06 -0700400 __u16 vlan_tci;
401
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700402 sk_buff_data_t transport_header;
403 sk_buff_data_t network_header;
404 sk_buff_data_t mac_header;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 /* These elements must be at the end, see alloc_skb() for details. */
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700406 sk_buff_data_t tail;
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -0700407 sk_buff_data_t end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 unsigned char *head,
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -0700409 *data;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700410 unsigned int truesize;
411 atomic_t users;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412};
413
414#ifdef __KERNEL__
415/*
416 * Handling routines are only of interest to the kernel
417 */
418#include <linux/slab.h>
419
420#include <asm/system.h>
421
Eric Dumazet7fee2262010-05-11 23:19:48 +0000422/*
423 * skb might have a dst pointer attached, refcounted or not.
424 * _skb_refdst low order bit is set if refcount was _not_ taken
425 */
426#define SKB_DST_NOREF 1UL
427#define SKB_DST_PTRMASK ~(SKB_DST_NOREF)
428
429/**
430 * skb_dst - returns skb dst_entry
431 * @skb: buffer
432 *
433 * Returns skb dst_entry, regardless of reference taken or not.
434 */
Eric Dumazetadf30902009-06-02 05:19:30 +0000435static inline struct dst_entry *skb_dst(const struct sk_buff *skb)
436{
Eric Dumazet7fee2262010-05-11 23:19:48 +0000437 /* If refdst was not refcounted, check we still are in a
438 * rcu_read_lock section
439 */
440 WARN_ON((skb->_skb_refdst & SKB_DST_NOREF) &&
441 !rcu_read_lock_held() &&
442 !rcu_read_lock_bh_held());
443 return (struct dst_entry *)(skb->_skb_refdst & SKB_DST_PTRMASK);
Eric Dumazetadf30902009-06-02 05:19:30 +0000444}
445
Eric Dumazet7fee2262010-05-11 23:19:48 +0000446/**
447 * skb_dst_set - sets skb dst
448 * @skb: buffer
449 * @dst: dst entry
450 *
451 * Sets skb dst, assuming a reference was taken on dst and should
452 * be released by skb_dst_drop()
453 */
Eric Dumazetadf30902009-06-02 05:19:30 +0000454static inline void skb_dst_set(struct sk_buff *skb, struct dst_entry *dst)
455{
Eric Dumazet7fee2262010-05-11 23:19:48 +0000456 skb->_skb_refdst = (unsigned long)dst;
457}
458
459/**
460 * skb_dst_set_noref - sets skb dst, without a reference
461 * @skb: buffer
462 * @dst: dst entry
463 *
464 * Sets skb dst, assuming a reference was not taken on dst
465 * skb_dst_drop() should not dst_release() this dst
466 */
467static inline void skb_dst_set_noref(struct sk_buff *skb, struct dst_entry *dst)
468{
469 WARN_ON(!rcu_read_lock_held() && !rcu_read_lock_bh_held());
470 skb->_skb_refdst = (unsigned long)dst | SKB_DST_NOREF;
471}
472
473/**
474 * skb_dst_is_noref - Test if skb dst isnt refcounted
475 * @skb: buffer
476 */
477static inline bool skb_dst_is_noref(const struct sk_buff *skb)
478{
479 return (skb->_skb_refdst & SKB_DST_NOREF) && skb_dst(skb);
Eric Dumazetadf30902009-06-02 05:19:30 +0000480}
481
Eric Dumazet511c3f92009-06-02 05:14:27 +0000482static inline struct rtable *skb_rtable(const struct sk_buff *skb)
483{
Eric Dumazetadf30902009-06-02 05:19:30 +0000484 return (struct rtable *)skb_dst(skb);
Eric Dumazet511c3f92009-06-02 05:14:27 +0000485}
486
Jörn Engel231d06a2006-03-20 21:28:35 -0800487extern void kfree_skb(struct sk_buff *skb);
Neil Hormanead2ceb2009-03-11 09:49:55 +0000488extern void consume_skb(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489extern void __kfree_skb(struct sk_buff *skb);
David S. Millerd179cd12005-08-17 14:57:30 -0700490extern struct sk_buff *__alloc_skb(unsigned int size,
Christoph Hellwigb30973f2006-12-06 20:32:36 -0800491 gfp_t priority, int fclone, int node);
David S. Millerd179cd12005-08-17 14:57:30 -0700492static inline struct sk_buff *alloc_skb(unsigned int size,
Al Virodd0fc662005-10-07 07:46:04 +0100493 gfp_t priority)
David S. Millerd179cd12005-08-17 14:57:30 -0700494{
Christoph Hellwigb30973f2006-12-06 20:32:36 -0800495 return __alloc_skb(size, priority, 0, -1);
David S. Millerd179cd12005-08-17 14:57:30 -0700496}
497
498static inline struct sk_buff *alloc_skb_fclone(unsigned int size,
Al Virodd0fc662005-10-07 07:46:04 +0100499 gfp_t priority)
David S. Millerd179cd12005-08-17 14:57:30 -0700500{
Christoph Hellwigb30973f2006-12-06 20:32:36 -0800501 return __alloc_skb(size, priority, 1, -1);
David S. Millerd179cd12005-08-17 14:57:30 -0700502}
503
Lennert Buytenhek04a4bb52008-10-01 02:33:12 -0700504extern int skb_recycle_check(struct sk_buff *skb, int skb_size);
505
Herbert Xue0053ec2007-10-14 00:37:52 -0700506extern struct sk_buff *skb_morph(struct sk_buff *dst, struct sk_buff *src);
Victor Fusco86a76ca2005-07-08 14:57:47 -0700507extern struct sk_buff *skb_clone(struct sk_buff *skb,
Al Virodd0fc662005-10-07 07:46:04 +0100508 gfp_t priority);
Victor Fusco86a76ca2005-07-08 14:57:47 -0700509extern struct sk_buff *skb_copy(const struct sk_buff *skb,
Al Virodd0fc662005-10-07 07:46:04 +0100510 gfp_t priority);
Victor Fusco86a76ca2005-07-08 14:57:47 -0700511extern struct sk_buff *pskb_copy(struct sk_buff *skb,
Al Virodd0fc662005-10-07 07:46:04 +0100512 gfp_t gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513extern int pskb_expand_head(struct sk_buff *skb,
Victor Fusco86a76ca2005-07-08 14:57:47 -0700514 int nhead, int ntail,
Al Virodd0fc662005-10-07 07:46:04 +0100515 gfp_t gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516extern struct sk_buff *skb_realloc_headroom(struct sk_buff *skb,
517 unsigned int headroom);
518extern struct sk_buff *skb_copy_expand(const struct sk_buff *skb,
519 int newheadroom, int newtailroom,
Al Virodd0fc662005-10-07 07:46:04 +0100520 gfp_t priority);
David Howells716ea3a2007-04-02 20:19:53 -0700521extern int skb_to_sgvec(struct sk_buff *skb,
522 struct scatterlist *sg, int offset,
523 int len);
524extern int skb_cow_data(struct sk_buff *skb, int tailbits,
525 struct sk_buff **trailer);
Herbert Xu5b057c62006-06-23 02:06:41 -0700526extern int skb_pad(struct sk_buff *skb, int pad);
Neil Hormanead2ceb2009-03-11 09:49:55 +0000527#define dev_kfree_skb(a) consume_skb(a)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528
Ananda Rajue89e9cf2005-10-18 15:46:41 -0700529extern int skb_append_datato_frags(struct sock *sk, struct sk_buff *skb,
530 int getfrag(void *from, char *to, int offset,
531 int len,int odd, struct sk_buff *skb),
532 void *from, int length);
533
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800534struct skb_seq_state {
Thomas Graf677e90e2005-06-23 20:59:51 -0700535 __u32 lower_offset;
536 __u32 upper_offset;
537 __u32 frag_idx;
538 __u32 stepped_offset;
539 struct sk_buff *root_skb;
540 struct sk_buff *cur_skb;
541 __u8 *frag_data;
542};
543
544extern void skb_prepare_seq_read(struct sk_buff *skb,
545 unsigned int from, unsigned int to,
546 struct skb_seq_state *st);
547extern unsigned int skb_seq_read(unsigned int consumed, const u8 **data,
548 struct skb_seq_state *st);
549extern void skb_abort_seq_read(struct skb_seq_state *st);
550
Thomas Graf3fc7e8a2005-06-23 21:00:17 -0700551extern unsigned int skb_find_text(struct sk_buff *skb, unsigned int from,
552 unsigned int to, struct ts_config *config,
553 struct ts_state *state);
554
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -0700555#ifdef NET_SKBUFF_DATA_USES_OFFSET
556static inline unsigned char *skb_end_pointer(const struct sk_buff *skb)
557{
558 return skb->head + skb->end;
559}
560#else
561static inline unsigned char *skb_end_pointer(const struct sk_buff *skb)
562{
563 return skb->end;
564}
565#endif
566
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567/* Internal */
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -0700568#define skb_shinfo(SKB) ((struct skb_shared_info *)(skb_end_pointer(SKB)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
Patrick Ohlyac45f602009-02-12 05:03:37 +0000570static inline struct skb_shared_hwtstamps *skb_hwtstamps(struct sk_buff *skb)
571{
572 return &skb_shinfo(skb)->hwtstamps;
573}
574
575static inline union skb_shared_tx *skb_tx(struct sk_buff *skb)
576{
577 return &skb_shinfo(skb)->tx_flags;
578}
579
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580/**
581 * skb_queue_empty - check if a queue is empty
582 * @list: queue head
583 *
584 * Returns true if the queue is empty, false otherwise.
585 */
586static inline int skb_queue_empty(const struct sk_buff_head *list)
587{
588 return list->next == (struct sk_buff *)list;
589}
590
591/**
David S. Millerfc7ebb22008-09-23 00:34:07 -0700592 * skb_queue_is_last - check if skb is the last entry in the queue
593 * @list: queue head
594 * @skb: buffer
595 *
596 * Returns true if @skb is the last buffer on the list.
597 */
598static inline bool skb_queue_is_last(const struct sk_buff_head *list,
599 const struct sk_buff *skb)
600{
601 return (skb->next == (struct sk_buff *) list);
602}
603
604/**
Ilpo Järvinen832d11c2008-11-24 21:20:15 -0800605 * skb_queue_is_first - check if skb is the first entry in the queue
606 * @list: queue head
607 * @skb: buffer
608 *
609 * Returns true if @skb is the first buffer on the list.
610 */
611static inline bool skb_queue_is_first(const struct sk_buff_head *list,
612 const struct sk_buff *skb)
613{
614 return (skb->prev == (struct sk_buff *) list);
615}
616
617/**
David S. Miller249c8b42008-09-23 00:44:42 -0700618 * skb_queue_next - return the next packet in the queue
619 * @list: queue head
620 * @skb: current buffer
621 *
622 * Return the next packet in @list after @skb. It is only valid to
623 * call this if skb_queue_is_last() evaluates to false.
624 */
625static inline struct sk_buff *skb_queue_next(const struct sk_buff_head *list,
626 const struct sk_buff *skb)
627{
628 /* This BUG_ON may seem severe, but if we just return then we
629 * are going to dereference garbage.
630 */
631 BUG_ON(skb_queue_is_last(list, skb));
632 return skb->next;
633}
634
635/**
Ilpo Järvinen832d11c2008-11-24 21:20:15 -0800636 * skb_queue_prev - return the prev packet in the queue
637 * @list: queue head
638 * @skb: current buffer
639 *
640 * Return the prev packet in @list before @skb. It is only valid to
641 * call this if skb_queue_is_first() evaluates to false.
642 */
643static inline struct sk_buff *skb_queue_prev(const struct sk_buff_head *list,
644 const struct sk_buff *skb)
645{
646 /* This BUG_ON may seem severe, but if we just return then we
647 * are going to dereference garbage.
648 */
649 BUG_ON(skb_queue_is_first(list, skb));
650 return skb->prev;
651}
652
653/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 * skb_get - reference buffer
655 * @skb: buffer to reference
656 *
657 * Makes another reference to a socket buffer and returns a pointer
658 * to the buffer.
659 */
660static inline struct sk_buff *skb_get(struct sk_buff *skb)
661{
662 atomic_inc(&skb->users);
663 return skb;
664}
665
666/*
667 * If users == 1, we are the only owner and are can avoid redundant
668 * atomic change.
669 */
670
671/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 * skb_cloned - is the buffer a clone
673 * @skb: buffer to check
674 *
675 * Returns true if the buffer was generated with skb_clone() and is
676 * one of multiple shared copies of the buffer. Cloned buffers are
677 * shared data so must not be written to under normal circumstances.
678 */
679static inline int skb_cloned(const struct sk_buff *skb)
680{
681 return skb->cloned &&
682 (atomic_read(&skb_shinfo(skb)->dataref) & SKB_DATAREF_MASK) != 1;
683}
684
685/**
686 * skb_header_cloned - is the header a clone
687 * @skb: buffer to check
688 *
689 * Returns true if modifying the header part of the buffer requires
690 * the data to be copied.
691 */
692static inline int skb_header_cloned(const struct sk_buff *skb)
693{
694 int dataref;
695
696 if (!skb->cloned)
697 return 0;
698
699 dataref = atomic_read(&skb_shinfo(skb)->dataref);
700 dataref = (dataref & SKB_DATAREF_MASK) - (dataref >> SKB_DATAREF_SHIFT);
701 return dataref != 1;
702}
703
704/**
705 * skb_header_release - release reference to header
706 * @skb: buffer to operate on
707 *
708 * Drop a reference to the header part of the buffer. This is done
709 * by acquiring a payload reference. You must not read from the header
710 * part of skb->data after this.
711 */
712static inline void skb_header_release(struct sk_buff *skb)
713{
714 BUG_ON(skb->nohdr);
715 skb->nohdr = 1;
716 atomic_add(1 << SKB_DATAREF_SHIFT, &skb_shinfo(skb)->dataref);
717}
718
719/**
720 * skb_shared - is the buffer shared
721 * @skb: buffer to check
722 *
723 * Returns true if more than one person has a reference to this
724 * buffer.
725 */
726static inline int skb_shared(const struct sk_buff *skb)
727{
728 return atomic_read(&skb->users) != 1;
729}
730
731/**
732 * skb_share_check - check if buffer is shared and if so clone it
733 * @skb: buffer to check
734 * @pri: priority for memory allocation
735 *
736 * If the buffer is shared the buffer is cloned and the old copy
737 * drops a reference. A new clone with a single reference is returned.
738 * If the buffer is not shared the original buffer is returned. When
739 * being called from interrupt status or with spinlocks held pri must
740 * be GFP_ATOMIC.
741 *
742 * NULL is returned on a memory allocation failure.
743 */
Victor Fusco86a76ca2005-07-08 14:57:47 -0700744static inline struct sk_buff *skb_share_check(struct sk_buff *skb,
Al Virodd0fc662005-10-07 07:46:04 +0100745 gfp_t pri)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746{
747 might_sleep_if(pri & __GFP_WAIT);
748 if (skb_shared(skb)) {
749 struct sk_buff *nskb = skb_clone(skb, pri);
750 kfree_skb(skb);
751 skb = nskb;
752 }
753 return skb;
754}
755
756/*
757 * Copy shared buffers into a new sk_buff. We effectively do COW on
758 * packets to handle cases where we have a local reader and forward
759 * and a couple of other messy ones. The normal one is tcpdumping
760 * a packet thats being forwarded.
761 */
762
763/**
764 * skb_unshare - make a copy of a shared buffer
765 * @skb: buffer to check
766 * @pri: priority for memory allocation
767 *
768 * If the socket buffer is a clone then this function creates a new
769 * copy of the data, drops a reference count on the old copy and returns
770 * the new copy with the reference count at 1. If the buffer is not a clone
771 * the original buffer is returned. When called with a spinlock held or
772 * from interrupt state @pri must be %GFP_ATOMIC
773 *
774 * %NULL is returned on a memory allocation failure.
775 */
Victor Fuscoe2bf5212005-07-18 13:36:38 -0700776static inline struct sk_buff *skb_unshare(struct sk_buff *skb,
Al Virodd0fc662005-10-07 07:46:04 +0100777 gfp_t pri)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778{
779 might_sleep_if(pri & __GFP_WAIT);
780 if (skb_cloned(skb)) {
781 struct sk_buff *nskb = skb_copy(skb, pri);
782 kfree_skb(skb); /* Free our shared copy */
783 skb = nskb;
784 }
785 return skb;
786}
787
788/**
Ben Hutchings1a5778a2010-02-14 22:35:47 -0800789 * skb_peek - peek at the head of an &sk_buff_head
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 * @list_: list to peek at
791 *
792 * Peek an &sk_buff. Unlike most other operations you _MUST_
793 * be careful with this one. A peek leaves the buffer on the
794 * list and someone else may run off with it. You must hold
795 * the appropriate locks or have a private queue to do this.
796 *
797 * Returns %NULL for an empty list or a pointer to the head element.
798 * The reference count is not incremented and the reference is therefore
799 * volatile. Use with caution.
800 */
801static inline struct sk_buff *skb_peek(struct sk_buff_head *list_)
802{
803 struct sk_buff *list = ((struct sk_buff *)list_)->next;
804 if (list == (struct sk_buff *)list_)
805 list = NULL;
806 return list;
807}
808
809/**
Ben Hutchings1a5778a2010-02-14 22:35:47 -0800810 * skb_peek_tail - peek at the tail of an &sk_buff_head
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 * @list_: list to peek at
812 *
813 * Peek an &sk_buff. Unlike most other operations you _MUST_
814 * be careful with this one. A peek leaves the buffer on the
815 * list and someone else may run off with it. You must hold
816 * the appropriate locks or have a private queue to do this.
817 *
818 * Returns %NULL for an empty list or a pointer to the tail element.
819 * The reference count is not incremented and the reference is therefore
820 * volatile. Use with caution.
821 */
822static inline struct sk_buff *skb_peek_tail(struct sk_buff_head *list_)
823{
824 struct sk_buff *list = ((struct sk_buff *)list_)->prev;
825 if (list == (struct sk_buff *)list_)
826 list = NULL;
827 return list;
828}
829
830/**
831 * skb_queue_len - get queue length
832 * @list_: list to measure
833 *
834 * Return the length of an &sk_buff queue.
835 */
836static inline __u32 skb_queue_len(const struct sk_buff_head *list_)
837{
838 return list_->qlen;
839}
840
David S. Miller67fed452008-09-21 22:36:24 -0700841/**
842 * __skb_queue_head_init - initialize non-spinlock portions of sk_buff_head
843 * @list: queue to initialize
844 *
845 * This initializes only the list and queue length aspects of
846 * an sk_buff_head object. This allows to initialize the list
847 * aspects of an sk_buff_head without reinitializing things like
848 * the spinlock. It can also be used for on-stack sk_buff_head
849 * objects where the spinlock is known to not be used.
850 */
851static inline void __skb_queue_head_init(struct sk_buff_head *list)
852{
853 list->prev = list->next = (struct sk_buff *)list;
854 list->qlen = 0;
855}
856
Arjan van de Ven76f10ad2006-08-02 14:06:55 -0700857/*
858 * This function creates a split out lock class for each invocation;
859 * this is needed for now since a whole lot of users of the skb-queue
860 * infrastructure in drivers have different locking usage (in hardirq)
861 * than the networking core (in softirq only). In the long run either the
862 * network layer or drivers should need annotation to consolidate the
863 * main types of usage into 3 classes.
864 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865static inline void skb_queue_head_init(struct sk_buff_head *list)
866{
867 spin_lock_init(&list->lock);
David S. Miller67fed452008-09-21 22:36:24 -0700868 __skb_queue_head_init(list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869}
870
Pavel Emelianovc2ecba72007-04-17 12:45:31 -0700871static inline void skb_queue_head_init_class(struct sk_buff_head *list,
872 struct lock_class_key *class)
873{
874 skb_queue_head_init(list);
875 lockdep_set_class(&list->lock, class);
876}
877
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878/*
Gerrit Renkerbf299272008-04-14 00:04:51 -0700879 * Insert an sk_buff on a list.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 *
881 * The "__skb_xxxx()" functions are the non-atomic ones that
882 * can only be called with interrupts disabled.
883 */
Gerrit Renkerbf299272008-04-14 00:04:51 -0700884extern void skb_insert(struct sk_buff *old, struct sk_buff *newsk, struct sk_buff_head *list);
885static inline void __skb_insert(struct sk_buff *newsk,
886 struct sk_buff *prev, struct sk_buff *next,
887 struct sk_buff_head *list)
888{
889 newsk->next = next;
890 newsk->prev = prev;
891 next->prev = prev->next = newsk;
892 list->qlen++;
893}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894
David S. Miller67fed452008-09-21 22:36:24 -0700895static inline void __skb_queue_splice(const struct sk_buff_head *list,
896 struct sk_buff *prev,
897 struct sk_buff *next)
898{
899 struct sk_buff *first = list->next;
900 struct sk_buff *last = list->prev;
901
902 first->prev = prev;
903 prev->next = first;
904
905 last->next = next;
906 next->prev = last;
907}
908
909/**
910 * skb_queue_splice - join two skb lists, this is designed for stacks
911 * @list: the new list to add
912 * @head: the place to add it in the first list
913 */
914static inline void skb_queue_splice(const struct sk_buff_head *list,
915 struct sk_buff_head *head)
916{
917 if (!skb_queue_empty(list)) {
918 __skb_queue_splice(list, (struct sk_buff *) head, head->next);
David S. Miller1d4a31d2008-09-22 21:57:21 -0700919 head->qlen += list->qlen;
David S. Miller67fed452008-09-21 22:36:24 -0700920 }
921}
922
923/**
924 * skb_queue_splice - join two skb lists and reinitialise the emptied list
925 * @list: the new list to add
926 * @head: the place to add it in the first list
927 *
928 * The list at @list is reinitialised
929 */
930static inline void skb_queue_splice_init(struct sk_buff_head *list,
931 struct sk_buff_head *head)
932{
933 if (!skb_queue_empty(list)) {
934 __skb_queue_splice(list, (struct sk_buff *) head, head->next);
David S. Miller1d4a31d2008-09-22 21:57:21 -0700935 head->qlen += list->qlen;
David S. Miller67fed452008-09-21 22:36:24 -0700936 __skb_queue_head_init(list);
937 }
938}
939
940/**
941 * skb_queue_splice_tail - join two skb lists, each list being a queue
942 * @list: the new list to add
943 * @head: the place to add it in the first list
944 */
945static inline void skb_queue_splice_tail(const struct sk_buff_head *list,
946 struct sk_buff_head *head)
947{
948 if (!skb_queue_empty(list)) {
949 __skb_queue_splice(list, head->prev, (struct sk_buff *) head);
David S. Miller1d4a31d2008-09-22 21:57:21 -0700950 head->qlen += list->qlen;
David S. Miller67fed452008-09-21 22:36:24 -0700951 }
952}
953
954/**
955 * skb_queue_splice_tail - join two skb lists and reinitialise the emptied list
956 * @list: the new list to add
957 * @head: the place to add it in the first list
958 *
959 * Each of the lists is a queue.
960 * The list at @list is reinitialised
961 */
962static inline void skb_queue_splice_tail_init(struct sk_buff_head *list,
963 struct sk_buff_head *head)
964{
965 if (!skb_queue_empty(list)) {
966 __skb_queue_splice(list, head->prev, (struct sk_buff *) head);
David S. Miller1d4a31d2008-09-22 21:57:21 -0700967 head->qlen += list->qlen;
David S. Miller67fed452008-09-21 22:36:24 -0700968 __skb_queue_head_init(list);
969 }
970}
971
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972/**
Stephen Hemminger300ce172005-10-30 13:47:34 -0800973 * __skb_queue_after - queue a buffer at the list head
974 * @list: list to use
975 * @prev: place after this buffer
976 * @newsk: buffer to queue
977 *
978 * Queue a buffer int the middle of a list. This function takes no locks
979 * and you must therefore hold required locks before calling it.
980 *
981 * A buffer cannot be placed on two lists at the same time.
982 */
983static inline void __skb_queue_after(struct sk_buff_head *list,
984 struct sk_buff *prev,
985 struct sk_buff *newsk)
986{
Gerrit Renkerbf299272008-04-14 00:04:51 -0700987 __skb_insert(newsk, prev, prev->next, list);
Stephen Hemminger300ce172005-10-30 13:47:34 -0800988}
989
Gerrit Renker7de6c032008-04-14 00:05:09 -0700990extern void skb_append(struct sk_buff *old, struct sk_buff *newsk,
991 struct sk_buff_head *list);
992
Gerrit Renkerf5572852008-04-14 00:05:28 -0700993static inline void __skb_queue_before(struct sk_buff_head *list,
994 struct sk_buff *next,
995 struct sk_buff *newsk)
996{
997 __skb_insert(newsk, next->prev, next, list);
998}
999
Stephen Hemminger300ce172005-10-30 13:47:34 -08001000/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 * __skb_queue_head - queue a buffer at the list head
1002 * @list: list to use
1003 * @newsk: buffer to queue
1004 *
1005 * Queue a buffer at the start of a list. This function takes no locks
1006 * and you must therefore hold required locks before calling it.
1007 *
1008 * A buffer cannot be placed on two lists at the same time.
1009 */
1010extern void skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk);
1011static inline void __skb_queue_head(struct sk_buff_head *list,
1012 struct sk_buff *newsk)
1013{
Stephen Hemminger300ce172005-10-30 13:47:34 -08001014 __skb_queue_after(list, (struct sk_buff *)list, newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015}
1016
1017/**
1018 * __skb_queue_tail - queue a buffer at the list tail
1019 * @list: list to use
1020 * @newsk: buffer to queue
1021 *
1022 * Queue a buffer at the end of a list. This function takes no locks
1023 * and you must therefore hold required locks before calling it.
1024 *
1025 * A buffer cannot be placed on two lists at the same time.
1026 */
1027extern void skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk);
1028static inline void __skb_queue_tail(struct sk_buff_head *list,
1029 struct sk_buff *newsk)
1030{
Gerrit Renkerf5572852008-04-14 00:05:28 -07001031 __skb_queue_before(list, (struct sk_buff *)list, newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032}
1033
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 * remove sk_buff from list. _Must_ be called atomically, and with
1036 * the list known..
1037 */
David S. Miller8728b832005-08-09 19:25:21 -07001038extern void skb_unlink(struct sk_buff *skb, struct sk_buff_head *list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039static inline void __skb_unlink(struct sk_buff *skb, struct sk_buff_head *list)
1040{
1041 struct sk_buff *next, *prev;
1042
1043 list->qlen--;
1044 next = skb->next;
1045 prev = skb->prev;
1046 skb->next = skb->prev = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047 next->prev = prev;
1048 prev->next = next;
1049}
1050
Gerrit Renkerf525c062008-04-14 00:04:12 -07001051/**
1052 * __skb_dequeue - remove from the head of the queue
1053 * @list: list to dequeue from
1054 *
1055 * Remove the head of the list. This function does not take any locks
1056 * so must be used with appropriate locks held only. The head item is
1057 * returned or %NULL if the list is empty.
1058 */
1059extern struct sk_buff *skb_dequeue(struct sk_buff_head *list);
1060static inline struct sk_buff *__skb_dequeue(struct sk_buff_head *list)
1061{
1062 struct sk_buff *skb = skb_peek(list);
1063 if (skb)
1064 __skb_unlink(skb, list);
1065 return skb;
1066}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067
1068/**
1069 * __skb_dequeue_tail - remove from the tail of the queue
1070 * @list: list to dequeue from
1071 *
1072 * Remove the tail of the list. This function does not take any locks
1073 * so must be used with appropriate locks held only. The tail item is
1074 * returned or %NULL if the list is empty.
1075 */
1076extern struct sk_buff *skb_dequeue_tail(struct sk_buff_head *list);
1077static inline struct sk_buff *__skb_dequeue_tail(struct sk_buff_head *list)
1078{
1079 struct sk_buff *skb = skb_peek_tail(list);
1080 if (skb)
1081 __skb_unlink(skb, list);
1082 return skb;
1083}
1084
1085
1086static inline int skb_is_nonlinear(const struct sk_buff *skb)
1087{
1088 return skb->data_len;
1089}
1090
1091static inline unsigned int skb_headlen(const struct sk_buff *skb)
1092{
1093 return skb->len - skb->data_len;
1094}
1095
1096static inline int skb_pagelen(const struct sk_buff *skb)
1097{
1098 int i, len = 0;
1099
1100 for (i = (int)skb_shinfo(skb)->nr_frags - 1; i >= 0; i--)
1101 len += skb_shinfo(skb)->frags[i].size;
1102 return len + skb_headlen(skb);
1103}
1104
1105static inline void skb_fill_page_desc(struct sk_buff *skb, int i,
1106 struct page *page, int off, int size)
1107{
1108 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
1109
1110 frag->page = page;
1111 frag->page_offset = off;
1112 frag->size = size;
1113 skb_shinfo(skb)->nr_frags = i + 1;
1114}
1115
Peter Zijlstra654bed12008-10-07 14:22:33 -07001116extern void skb_add_rx_frag(struct sk_buff *skb, int i, struct page *page,
1117 int off, int size);
1118
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119#define SKB_PAGE_ASSERT(skb) BUG_ON(skb_shinfo(skb)->nr_frags)
David S. Milleree039872009-06-09 00:17:13 -07001120#define SKB_FRAG_ASSERT(skb) BUG_ON(skb_has_frags(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121#define SKB_LINEAR_ASSERT(skb) BUG_ON(skb_is_nonlinear(skb))
1122
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001123#ifdef NET_SKBUFF_DATA_USES_OFFSET
1124static inline unsigned char *skb_tail_pointer(const struct sk_buff *skb)
1125{
1126 return skb->head + skb->tail;
1127}
1128
1129static inline void skb_reset_tail_pointer(struct sk_buff *skb)
1130{
1131 skb->tail = skb->data - skb->head;
1132}
1133
1134static inline void skb_set_tail_pointer(struct sk_buff *skb, const int offset)
1135{
1136 skb_reset_tail_pointer(skb);
1137 skb->tail += offset;
1138}
1139#else /* NET_SKBUFF_DATA_USES_OFFSET */
1140static inline unsigned char *skb_tail_pointer(const struct sk_buff *skb)
1141{
1142 return skb->tail;
1143}
1144
1145static inline void skb_reset_tail_pointer(struct sk_buff *skb)
1146{
1147 skb->tail = skb->data;
1148}
1149
1150static inline void skb_set_tail_pointer(struct sk_buff *skb, const int offset)
1151{
1152 skb->tail = skb->data + offset;
1153}
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -07001154
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001155#endif /* NET_SKBUFF_DATA_USES_OFFSET */
1156
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157/*
1158 * Add data to an sk_buff
1159 */
Ilpo Järvinen0dde3e12008-03-27 17:43:41 -07001160extern unsigned char *skb_put(struct sk_buff *skb, unsigned int len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161static inline unsigned char *__skb_put(struct sk_buff *skb, unsigned int len)
1162{
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001163 unsigned char *tmp = skb_tail_pointer(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164 SKB_LINEAR_ASSERT(skb);
1165 skb->tail += len;
1166 skb->len += len;
1167 return tmp;
1168}
1169
Ilpo Järvinenc2aa2702008-03-27 17:52:40 -07001170extern unsigned char *skb_push(struct sk_buff *skb, unsigned int len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171static inline unsigned char *__skb_push(struct sk_buff *skb, unsigned int len)
1172{
1173 skb->data -= len;
1174 skb->len += len;
1175 return skb->data;
1176}
1177
Ilpo Järvinen6be8ac22008-03-27 17:47:24 -07001178extern unsigned char *skb_pull(struct sk_buff *skb, unsigned int len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179static inline unsigned char *__skb_pull(struct sk_buff *skb, unsigned int len)
1180{
1181 skb->len -= len;
1182 BUG_ON(skb->len < skb->data_len);
1183 return skb->data += len;
1184}
1185
David S. Miller47d29642010-05-02 02:21:44 -07001186static inline unsigned char *skb_pull_inline(struct sk_buff *skb, unsigned int len)
1187{
1188 return unlikely(len > skb->len) ? NULL : __skb_pull(skb, len);
1189}
1190
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191extern unsigned char *__pskb_pull_tail(struct sk_buff *skb, int delta);
1192
1193static inline unsigned char *__pskb_pull(struct sk_buff *skb, unsigned int len)
1194{
1195 if (len > skb_headlen(skb) &&
Gerrit Renker987c4022008-08-11 18:17:17 -07001196 !__pskb_pull_tail(skb, len - skb_headlen(skb)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 return NULL;
1198 skb->len -= len;
1199 return skb->data += len;
1200}
1201
1202static inline unsigned char *pskb_pull(struct sk_buff *skb, unsigned int len)
1203{
1204 return unlikely(len > skb->len) ? NULL : __pskb_pull(skb, len);
1205}
1206
1207static inline int pskb_may_pull(struct sk_buff *skb, unsigned int len)
1208{
1209 if (likely(len <= skb_headlen(skb)))
1210 return 1;
1211 if (unlikely(len > skb->len))
1212 return 0;
Gerrit Renker987c4022008-08-11 18:17:17 -07001213 return __pskb_pull_tail(skb, len - skb_headlen(skb)) != NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214}
1215
1216/**
1217 * skb_headroom - bytes at buffer head
1218 * @skb: buffer to check
1219 *
1220 * Return the number of bytes of free space at the head of an &sk_buff.
1221 */
Chuck Leverc2636b42007-10-23 21:07:32 -07001222static inline unsigned int skb_headroom(const struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223{
1224 return skb->data - skb->head;
1225}
1226
1227/**
1228 * skb_tailroom - bytes at buffer end
1229 * @skb: buffer to check
1230 *
1231 * Return the number of bytes of free space at the tail of an sk_buff
1232 */
1233static inline int skb_tailroom(const struct sk_buff *skb)
1234{
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -07001235 return skb_is_nonlinear(skb) ? 0 : skb->end - skb->tail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236}
1237
1238/**
1239 * skb_reserve - adjust headroom
1240 * @skb: buffer to alter
1241 * @len: bytes to move
1242 *
1243 * Increase the headroom of an empty &sk_buff by reducing the tail
1244 * room. This is only allowed for an empty buffer.
1245 */
David S. Miller8243126c2006-01-17 02:54:21 -08001246static inline void skb_reserve(struct sk_buff *skb, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247{
1248 skb->data += len;
1249 skb->tail += len;
1250}
1251
Arnaldo Carvalho de Melo2e07fa92007-04-10 21:22:35 -07001252#ifdef NET_SKBUFF_DATA_USES_OFFSET
1253static inline unsigned char *skb_transport_header(const struct sk_buff *skb)
1254{
1255 return skb->head + skb->transport_header;
1256}
1257
1258static inline void skb_reset_transport_header(struct sk_buff *skb)
1259{
1260 skb->transport_header = skb->data - skb->head;
1261}
1262
1263static inline void skb_set_transport_header(struct sk_buff *skb,
1264 const int offset)
1265{
1266 skb_reset_transport_header(skb);
1267 skb->transport_header += offset;
1268}
1269
1270static inline unsigned char *skb_network_header(const struct sk_buff *skb)
1271{
1272 return skb->head + skb->network_header;
1273}
1274
1275static inline void skb_reset_network_header(struct sk_buff *skb)
1276{
1277 skb->network_header = skb->data - skb->head;
1278}
1279
1280static inline void skb_set_network_header(struct sk_buff *skb, const int offset)
1281{
1282 skb_reset_network_header(skb);
1283 skb->network_header += offset;
1284}
1285
1286static inline unsigned char *skb_mac_header(const struct sk_buff *skb)
1287{
1288 return skb->head + skb->mac_header;
1289}
1290
1291static inline int skb_mac_header_was_set(const struct sk_buff *skb)
1292{
1293 return skb->mac_header != ~0U;
1294}
1295
1296static inline void skb_reset_mac_header(struct sk_buff *skb)
1297{
1298 skb->mac_header = skb->data - skb->head;
1299}
1300
1301static inline void skb_set_mac_header(struct sk_buff *skb, const int offset)
1302{
1303 skb_reset_mac_header(skb);
1304 skb->mac_header += offset;
1305}
1306
1307#else /* NET_SKBUFF_DATA_USES_OFFSET */
1308
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001309static inline unsigned char *skb_transport_header(const struct sk_buff *skb)
1310{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001311 return skb->transport_header;
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001312}
1313
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03001314static inline void skb_reset_transport_header(struct sk_buff *skb)
1315{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001316 skb->transport_header = skb->data;
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03001317}
1318
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -03001319static inline void skb_set_transport_header(struct sk_buff *skb,
1320 const int offset)
1321{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001322 skb->transport_header = skb->data + offset;
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -03001323}
1324
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -07001325static inline unsigned char *skb_network_header(const struct sk_buff *skb)
1326{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001327 return skb->network_header;
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -07001328}
1329
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07001330static inline void skb_reset_network_header(struct sk_buff *skb)
1331{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001332 skb->network_header = skb->data;
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07001333}
1334
Arnaldo Carvalho de Meloc14d2452007-03-11 22:39:41 -03001335static inline void skb_set_network_header(struct sk_buff *skb, const int offset)
1336{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001337 skb->network_header = skb->data + offset;
Arnaldo Carvalho de Meloc14d2452007-03-11 22:39:41 -03001338}
1339
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001340static inline unsigned char *skb_mac_header(const struct sk_buff *skb)
1341{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001342 return skb->mac_header;
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001343}
1344
1345static inline int skb_mac_header_was_set(const struct sk_buff *skb)
1346{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001347 return skb->mac_header != NULL;
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001348}
1349
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -07001350static inline void skb_reset_mac_header(struct sk_buff *skb)
1351{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001352 skb->mac_header = skb->data;
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -07001353}
1354
Arnaldo Carvalho de Melo48d49d0c2007-03-10 12:30:58 -03001355static inline void skb_set_mac_header(struct sk_buff *skb, const int offset)
1356{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001357 skb->mac_header = skb->data + offset;
Arnaldo Carvalho de Melo48d49d0c2007-03-10 12:30:58 -03001358}
Arnaldo Carvalho de Melo2e07fa92007-04-10 21:22:35 -07001359#endif /* NET_SKBUFF_DATA_USES_OFFSET */
1360
1361static inline int skb_transport_offset(const struct sk_buff *skb)
1362{
1363 return skb_transport_header(skb) - skb->data;
1364}
1365
1366static inline u32 skb_network_header_len(const struct sk_buff *skb)
1367{
1368 return skb->transport_header - skb->network_header;
1369}
1370
1371static inline int skb_network_offset(const struct sk_buff *skb)
1372{
1373 return skb_network_header(skb) - skb->data;
1374}
Arnaldo Carvalho de Melo48d49d0c2007-03-10 12:30:58 -03001375
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376/*
1377 * CPUs often take a performance hit when accessing unaligned memory
1378 * locations. The actual performance hit varies, it can be small if the
1379 * hardware handles it or large if we have to take an exception and fix it
1380 * in software.
1381 *
1382 * Since an ethernet header is 14 bytes network drivers often end up with
1383 * the IP header at an unaligned offset. The IP header can be aligned by
1384 * shifting the start of the packet by 2 bytes. Drivers should do this
1385 * with:
1386 *
Tobias Klauser8660c122009-07-13 22:48:16 +00001387 * skb_reserve(skb, NET_IP_ALIGN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 *
1389 * The downside to this alignment of the IP header is that the DMA is now
1390 * unaligned. On some architectures the cost of an unaligned DMA is high
1391 * and this cost outweighs the gains made by aligning the IP header.
Tobias Klauser8660c122009-07-13 22:48:16 +00001392 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393 * Since this trade off varies between architectures, we allow NET_IP_ALIGN
1394 * to be overridden.
1395 */
1396#ifndef NET_IP_ALIGN
1397#define NET_IP_ALIGN 2
1398#endif
1399
Anton Blanchard025be812006-03-31 02:27:06 -08001400/*
1401 * The networking layer reserves some headroom in skb data (via
1402 * dev_alloc_skb). This is used to avoid having to reallocate skb data when
1403 * the header has to grow. In the default case, if the header has to grow
David S. Millerd6301d32009-02-08 19:24:13 -08001404 * 32 bytes or less we avoid the reallocation.
Anton Blanchard025be812006-03-31 02:27:06 -08001405 *
1406 * Unfortunately this headroom changes the DMA alignment of the resulting
1407 * network packet. As for NET_IP_ALIGN, this unaligned DMA is expensive
1408 * on some architectures. An architecture can override this value,
1409 * perhaps setting it to a cacheline in size (since that will maintain
1410 * cacheline alignment of the DMA). It must be a power of 2.
1411 *
David S. Millerd6301d32009-02-08 19:24:13 -08001412 * Various parts of the networking layer expect at least 32 bytes of
Anton Blanchard025be812006-03-31 02:27:06 -08001413 * headroom, you should not reduce this.
Eric Dumazet18e8c132010-05-06 21:58:51 -07001414 * With RPS, we raised NET_SKB_PAD to 64 so that get_rps_cpus() fetches span
1415 * a 64 bytes aligned block to fit modern (>= 64 bytes) cache line sizes
1416 * NET_IP_ALIGN(2) + ethernet_header(14) + IP_header(20/40) + ports(8)
Anton Blanchard025be812006-03-31 02:27:06 -08001417 */
1418#ifndef NET_SKB_PAD
Eric Dumazet18e8c132010-05-06 21:58:51 -07001419#define NET_SKB_PAD 64
Anton Blanchard025be812006-03-31 02:27:06 -08001420#endif
1421
Herbert Xu3cc0e872006-06-09 16:13:38 -07001422extern int ___pskb_trim(struct sk_buff *skb, unsigned int len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423
1424static inline void __skb_trim(struct sk_buff *skb, unsigned int len)
1425{
Herbert Xu3cc0e872006-06-09 16:13:38 -07001426 if (unlikely(skb->data_len)) {
1427 WARN_ON(1);
1428 return;
1429 }
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001430 skb->len = len;
1431 skb_set_tail_pointer(skb, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432}
1433
Ilpo Järvinen419ae742008-03-27 17:54:01 -07001434extern void skb_trim(struct sk_buff *skb, unsigned int len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435
1436static inline int __pskb_trim(struct sk_buff *skb, unsigned int len)
1437{
Herbert Xu3cc0e872006-06-09 16:13:38 -07001438 if (skb->data_len)
1439 return ___pskb_trim(skb, len);
1440 __skb_trim(skb, len);
1441 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442}
1443
1444static inline int pskb_trim(struct sk_buff *skb, unsigned int len)
1445{
1446 return (len < skb->len) ? __pskb_trim(skb, len) : 0;
1447}
1448
1449/**
Herbert Xue9fa4f72006-08-13 20:12:58 -07001450 * pskb_trim_unique - remove end from a paged unique (not cloned) buffer
1451 * @skb: buffer to alter
1452 * @len: new length
1453 *
1454 * This is identical to pskb_trim except that the caller knows that
1455 * the skb is not cloned so we should never get an error due to out-
1456 * of-memory.
1457 */
1458static inline void pskb_trim_unique(struct sk_buff *skb, unsigned int len)
1459{
1460 int err = pskb_trim(skb, len);
1461 BUG_ON(err);
1462}
1463
1464/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465 * skb_orphan - orphan a buffer
1466 * @skb: buffer to orphan
1467 *
1468 * If a buffer currently has an owner then we call the owner's
1469 * destructor function and make the @skb unowned. The buffer continues
1470 * to exist but is no longer charged to its former owner.
1471 */
1472static inline void skb_orphan(struct sk_buff *skb)
1473{
1474 if (skb->destructor)
1475 skb->destructor(skb);
1476 skb->destructor = NULL;
1477 skb->sk = NULL;
1478}
1479
1480/**
1481 * __skb_queue_purge - empty a list
1482 * @list: list to empty
1483 *
1484 * Delete all buffers on an &sk_buff list. Each buffer is removed from
1485 * the list and one reference dropped. This function does not take the
1486 * list lock and the caller must hold the relevant locks to use it.
1487 */
1488extern void skb_queue_purge(struct sk_buff_head *list);
1489static inline void __skb_queue_purge(struct sk_buff_head *list)
1490{
1491 struct sk_buff *skb;
1492 while ((skb = __skb_dequeue(list)) != NULL)
1493 kfree_skb(skb);
1494}
1495
1496/**
Christoph Hellwigb4e54de2006-07-24 15:31:14 -07001497 * __dev_alloc_skb - allocate an skbuff for receiving
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498 * @length: length to allocate
1499 * @gfp_mask: get_free_pages mask, passed to alloc_skb
1500 *
1501 * Allocate a new &sk_buff and assign it a usage count of one. The
1502 * buffer has unspecified headroom built in. Users should allocate
1503 * the headroom they think they need without accounting for the
1504 * built in space. The built in space is used for optimisations.
1505 *
Christoph Hellwig766ea8c2006-08-07 15:49:53 -07001506 * %NULL is returned if there is no free memory.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508static inline struct sk_buff *__dev_alloc_skb(unsigned int length,
Al Virodd0fc662005-10-07 07:46:04 +01001509 gfp_t gfp_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510{
Anton Blanchard025be812006-03-31 02:27:06 -08001511 struct sk_buff *skb = alloc_skb(length + NET_SKB_PAD, gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512 if (likely(skb))
Anton Blanchard025be812006-03-31 02:27:06 -08001513 skb_reserve(skb, NET_SKB_PAD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514 return skb;
1515}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516
Ilpo Järvinenf58518e2008-03-27 17:51:31 -07001517extern struct sk_buff *dev_alloc_skb(unsigned int length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518
Christoph Hellwig8af27452006-07-31 22:35:23 -07001519extern struct sk_buff *__netdev_alloc_skb(struct net_device *dev,
1520 unsigned int length, gfp_t gfp_mask);
1521
1522/**
1523 * netdev_alloc_skb - allocate an skbuff for rx on a specific device
1524 * @dev: network device to receive on
1525 * @length: length to allocate
1526 *
1527 * Allocate a new &sk_buff and assign it a usage count of one. The
1528 * buffer has unspecified headroom built in. Users should allocate
1529 * the headroom they think they need without accounting for the
1530 * built in space. The built in space is used for optimisations.
1531 *
1532 * %NULL is returned if there is no free memory. Although this function
1533 * allocates memory it can be called from an interrupt.
1534 */
1535static inline struct sk_buff *netdev_alloc_skb(struct net_device *dev,
1536 unsigned int length)
1537{
1538 return __netdev_alloc_skb(dev, length, GFP_ATOMIC);
1539}
1540
Eric Dumazet61321bb2009-10-07 17:11:23 +00001541static inline struct sk_buff *netdev_alloc_skb_ip_align(struct net_device *dev,
1542 unsigned int length)
1543{
1544 struct sk_buff *skb = netdev_alloc_skb(dev, length + NET_IP_ALIGN);
1545
1546 if (NET_IP_ALIGN && skb)
1547 skb_reserve(skb, NET_IP_ALIGN);
1548 return skb;
1549}
1550
Peter Zijlstra654bed12008-10-07 14:22:33 -07001551extern struct page *__netdev_alloc_page(struct net_device *dev, gfp_t gfp_mask);
1552
1553/**
1554 * netdev_alloc_page - allocate a page for ps-rx on a specific device
1555 * @dev: network device to receive on
1556 *
1557 * Allocate a new page node local to the specified device.
1558 *
1559 * %NULL is returned if there is no free memory.
1560 */
1561static inline struct page *netdev_alloc_page(struct net_device *dev)
1562{
1563 return __netdev_alloc_page(dev, GFP_ATOMIC);
1564}
1565
1566static inline void netdev_free_page(struct net_device *dev, struct page *page)
1567{
1568 __free_page(page);
1569}
1570
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571/**
Patrick McHardy334a8132007-06-25 04:35:20 -07001572 * skb_clone_writable - is the header of a clone writable
1573 * @skb: buffer to check
1574 * @len: length up to which to write
1575 *
1576 * Returns true if modifying the header part of the cloned buffer
1577 * does not requires the data to be copied.
1578 */
Chuck Leverc2636b42007-10-23 21:07:32 -07001579static inline int skb_clone_writable(struct sk_buff *skb, unsigned int len)
Patrick McHardy334a8132007-06-25 04:35:20 -07001580{
1581 return !skb_header_cloned(skb) &&
1582 skb_headroom(skb) + len <= skb->hdr_len;
1583}
1584
Herbert Xud9cc2042007-09-16 16:21:16 -07001585static inline int __skb_cow(struct sk_buff *skb, unsigned int headroom,
1586 int cloned)
1587{
1588 int delta = 0;
1589
1590 if (headroom < NET_SKB_PAD)
1591 headroom = NET_SKB_PAD;
1592 if (headroom > skb_headroom(skb))
1593 delta = headroom - skb_headroom(skb);
1594
1595 if (delta || cloned)
1596 return pskb_expand_head(skb, ALIGN(delta, NET_SKB_PAD), 0,
1597 GFP_ATOMIC);
1598 return 0;
1599}
1600
Patrick McHardy334a8132007-06-25 04:35:20 -07001601/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602 * skb_cow - copy header of skb when it is required
1603 * @skb: buffer to cow
1604 * @headroom: needed headroom
1605 *
1606 * If the skb passed lacks sufficient headroom or its data part
1607 * is shared, data is reallocated. If reallocation fails, an error
1608 * is returned and original skb is not changed.
1609 *
1610 * The result is skb with writable area skb->head...skb->tail
1611 * and at least @headroom of space at head.
1612 */
1613static inline int skb_cow(struct sk_buff *skb, unsigned int headroom)
1614{
Herbert Xud9cc2042007-09-16 16:21:16 -07001615 return __skb_cow(skb, headroom, skb_cloned(skb));
1616}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617
Herbert Xud9cc2042007-09-16 16:21:16 -07001618/**
1619 * skb_cow_head - skb_cow but only making the head writable
1620 * @skb: buffer to cow
1621 * @headroom: needed headroom
1622 *
1623 * This function is identical to skb_cow except that we replace the
1624 * skb_cloned check by skb_header_cloned. It should be used when
1625 * you only need to push on some header and do not need to modify
1626 * the data.
1627 */
1628static inline int skb_cow_head(struct sk_buff *skb, unsigned int headroom)
1629{
1630 return __skb_cow(skb, headroom, skb_header_cloned(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631}
1632
1633/**
1634 * skb_padto - pad an skbuff up to a minimal size
1635 * @skb: buffer to pad
1636 * @len: minimal length
1637 *
1638 * Pads up a buffer to ensure the trailing bytes exist and are
1639 * blanked. If the buffer already contains sufficient data it
Herbert Xu5b057c62006-06-23 02:06:41 -07001640 * is untouched. Otherwise it is extended. Returns zero on
1641 * success. The skb is freed on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 */
1643
Herbert Xu5b057c62006-06-23 02:06:41 -07001644static inline int skb_padto(struct sk_buff *skb, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645{
1646 unsigned int size = skb->len;
1647 if (likely(size >= len))
Herbert Xu5b057c62006-06-23 02:06:41 -07001648 return 0;
Gerrit Renker987c4022008-08-11 18:17:17 -07001649 return skb_pad(skb, len - size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650}
1651
1652static inline int skb_add_data(struct sk_buff *skb,
1653 char __user *from, int copy)
1654{
1655 const int off = skb->len;
1656
1657 if (skb->ip_summed == CHECKSUM_NONE) {
1658 int err = 0;
Al Viro50842052006-11-14 21:36:34 -08001659 __wsum csum = csum_and_copy_from_user(from, skb_put(skb, copy),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660 copy, 0, &err);
1661 if (!err) {
1662 skb->csum = csum_block_add(skb->csum, csum, off);
1663 return 0;
1664 }
1665 } else if (!copy_from_user(skb_put(skb, copy), from, copy))
1666 return 0;
1667
1668 __skb_trim(skb, off);
1669 return -EFAULT;
1670}
1671
1672static inline int skb_can_coalesce(struct sk_buff *skb, int i,
1673 struct page *page, int off)
1674{
1675 if (i) {
1676 struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i - 1];
1677
1678 return page == frag->page &&
1679 off == frag->page_offset + frag->size;
1680 }
1681 return 0;
1682}
1683
Herbert Xu364c6ba2006-06-09 16:10:40 -07001684static inline int __skb_linearize(struct sk_buff *skb)
1685{
1686 return __pskb_pull_tail(skb, skb->data_len) ? 0 : -ENOMEM;
1687}
1688
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689/**
1690 * skb_linearize - convert paged skb to linear one
1691 * @skb: buffer to linarize
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 *
1693 * If there is no free memory -ENOMEM is returned, otherwise zero
1694 * is returned and the old skb data released.
1695 */
Herbert Xu364c6ba2006-06-09 16:10:40 -07001696static inline int skb_linearize(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697{
Herbert Xu364c6ba2006-06-09 16:10:40 -07001698 return skb_is_nonlinear(skb) ? __skb_linearize(skb) : 0;
1699}
1700
1701/**
1702 * skb_linearize_cow - make sure skb is linear and writable
1703 * @skb: buffer to process
1704 *
1705 * If there is no free memory -ENOMEM is returned, otherwise zero
1706 * is returned and the old skb data released.
1707 */
1708static inline int skb_linearize_cow(struct sk_buff *skb)
1709{
1710 return skb_is_nonlinear(skb) || skb_cloned(skb) ?
1711 __skb_linearize(skb) : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712}
1713
1714/**
1715 * skb_postpull_rcsum - update checksum for received skb after pull
1716 * @skb: buffer to update
1717 * @start: start of data before pull
1718 * @len: length of data pulled
1719 *
1720 * After doing a pull on a received packet, you need to call this to
Patrick McHardy84fa7932006-08-29 16:44:56 -07001721 * update the CHECKSUM_COMPLETE checksum, or set ip_summed to
1722 * CHECKSUM_NONE so that it can be recomputed from scratch.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723 */
1724
1725static inline void skb_postpull_rcsum(struct sk_buff *skb,
Herbert Xucbb042f2006-03-20 22:43:56 -08001726 const void *start, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727{
Patrick McHardy84fa7932006-08-29 16:44:56 -07001728 if (skb->ip_summed == CHECKSUM_COMPLETE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 skb->csum = csum_sub(skb->csum, csum_partial(start, len, 0));
1730}
1731
Herbert Xucbb042f2006-03-20 22:43:56 -08001732unsigned char *skb_pull_rcsum(struct sk_buff *skb, unsigned int len);
1733
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734/**
1735 * pskb_trim_rcsum - trim received skb and update checksum
1736 * @skb: buffer to trim
1737 * @len: new length
1738 *
1739 * This is exactly the same as pskb_trim except that it ensures the
1740 * checksum of received packets are still valid after the operation.
1741 */
1742
1743static inline int pskb_trim_rcsum(struct sk_buff *skb, unsigned int len)
1744{
Stephen Hemminger0e4e4222005-09-08 12:32:03 -07001745 if (likely(len >= skb->len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746 return 0;
Patrick McHardy84fa7932006-08-29 16:44:56 -07001747 if (skb->ip_summed == CHECKSUM_COMPLETE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748 skb->ip_summed = CHECKSUM_NONE;
1749 return __pskb_trim(skb, len);
1750}
1751
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752#define skb_queue_walk(queue, skb) \
1753 for (skb = (queue)->next; \
1754 prefetch(skb->next), (skb != (struct sk_buff *)(queue)); \
1755 skb = skb->next)
1756
James Chapman46f89142007-04-30 00:07:31 -07001757#define skb_queue_walk_safe(queue, skb, tmp) \
1758 for (skb = (queue)->next, tmp = skb->next; \
1759 skb != (struct sk_buff *)(queue); \
1760 skb = tmp, tmp = skb->next)
1761
David S. Miller1164f522008-09-23 00:49:44 -07001762#define skb_queue_walk_from(queue, skb) \
1763 for (; prefetch(skb->next), (skb != (struct sk_buff *)(queue)); \
1764 skb = skb->next)
1765
1766#define skb_queue_walk_from_safe(queue, skb, tmp) \
1767 for (tmp = skb->next; \
1768 skb != (struct sk_buff *)(queue); \
1769 skb = tmp, tmp = skb->next)
1770
Stephen Hemminger300ce172005-10-30 13:47:34 -08001771#define skb_queue_reverse_walk(queue, skb) \
1772 for (skb = (queue)->prev; \
1773 prefetch(skb->prev), (skb != (struct sk_buff *)(queue)); \
1774 skb = skb->prev)
1775
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776
David S. Milleree039872009-06-09 00:17:13 -07001777static inline bool skb_has_frags(const struct sk_buff *skb)
1778{
1779 return skb_shinfo(skb)->frag_list != NULL;
1780}
1781
1782static inline void skb_frag_list_init(struct sk_buff *skb)
1783{
1784 skb_shinfo(skb)->frag_list = NULL;
1785}
1786
1787static inline void skb_frag_add_head(struct sk_buff *skb, struct sk_buff *frag)
1788{
1789 frag->next = skb_shinfo(skb)->frag_list;
1790 skb_shinfo(skb)->frag_list = frag;
1791}
1792
1793#define skb_walk_frags(skb, iter) \
1794 for (iter = skb_shinfo(skb)->frag_list; iter; iter = iter->next)
1795
Herbert Xua59322b2007-12-05 01:53:40 -08001796extern struct sk_buff *__skb_recv_datagram(struct sock *sk, unsigned flags,
1797 int *peeked, int *err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798extern struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags,
1799 int noblock, int *err);
1800extern unsigned int datagram_poll(struct file *file, struct socket *sock,
1801 struct poll_table_struct *wait);
1802extern int skb_copy_datagram_iovec(const struct sk_buff *from,
1803 int offset, struct iovec *to,
1804 int size);
Herbert Xufb286bb2005-11-10 13:01:24 -08001805extern int skb_copy_and_csum_datagram_iovec(struct sk_buff *skb,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806 int hlen,
1807 struct iovec *iov);
Rusty Russelldb543c12008-08-15 15:13:53 -07001808extern int skb_copy_datagram_from_iovec(struct sk_buff *skb,
1809 int offset,
Michael S. Tsirkin6f26c9a2009-04-20 01:26:11 +00001810 const struct iovec *from,
1811 int from_offset,
Rusty Russelldb543c12008-08-15 15:13:53 -07001812 int len);
Michael S. Tsirkin0a1ec072009-04-20 01:25:46 +00001813extern int skb_copy_datagram_const_iovec(const struct sk_buff *from,
1814 int offset,
1815 const struct iovec *to,
1816 int to_offset,
1817 int size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818extern void skb_free_datagram(struct sock *sk, struct sk_buff *skb);
Eric Dumazet9d410c72009-10-30 05:03:53 +00001819extern void skb_free_datagram_locked(struct sock *sk,
1820 struct sk_buff *skb);
Herbert Xu27ab2562007-12-05 01:51:58 -08001821extern int skb_kill_datagram(struct sock *sk, struct sk_buff *skb,
Herbert Xu3305b802005-12-13 23:16:37 -08001822 unsigned int flags);
Al Viro2bbbc862006-11-14 21:37:14 -08001823extern __wsum skb_checksum(const struct sk_buff *skb, int offset,
1824 int len, __wsum csum);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825extern int skb_copy_bits(const struct sk_buff *skb, int offset,
1826 void *to, int len);
Stephen Hemminger0c6fcc82007-04-20 16:40:01 -07001827extern int skb_store_bits(struct sk_buff *skb, int offset,
1828 const void *from, int len);
Al Viro81d77662006-11-14 21:37:33 -08001829extern __wsum skb_copy_and_csum_bits(const struct sk_buff *skb,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830 int offset, u8 *to, int len,
Al Viro81d77662006-11-14 21:37:33 -08001831 __wsum csum);
Jens Axboe9c55e012007-11-06 23:30:13 -08001832extern int skb_splice_bits(struct sk_buff *skb,
1833 unsigned int offset,
1834 struct pipe_inode_info *pipe,
1835 unsigned int len,
1836 unsigned int flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837extern void skb_copy_and_csum_dev(const struct sk_buff *skb, u8 *to);
1838extern void skb_split(struct sk_buff *skb,
1839 struct sk_buff *skb1, const u32 len);
Ilpo Järvinen832d11c2008-11-24 21:20:15 -08001840extern int skb_shift(struct sk_buff *tgt, struct sk_buff *skb,
1841 int shiftlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842
Herbert Xu576a30e2006-06-27 13:22:38 -07001843extern struct sk_buff *skb_segment(struct sk_buff *skb, int features);
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03001844
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845static inline void *skb_header_pointer(const struct sk_buff *skb, int offset,
1846 int len, void *buffer)
1847{
1848 int hlen = skb_headlen(skb);
1849
Patrick McHardy55820ee2005-07-05 14:08:10 -07001850 if (hlen - offset >= len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851 return skb->data + offset;
1852
1853 if (skb_copy_bits(skb, offset, buffer, len) < 0)
1854 return NULL;
1855
1856 return buffer;
1857}
1858
Arnaldo Carvalho de Melod626f622007-03-27 18:55:52 -03001859static inline void skb_copy_from_linear_data(const struct sk_buff *skb,
1860 void *to,
1861 const unsigned int len)
1862{
1863 memcpy(to, skb->data, len);
1864}
1865
1866static inline void skb_copy_from_linear_data_offset(const struct sk_buff *skb,
1867 const int offset, void *to,
1868 const unsigned int len)
1869{
1870 memcpy(to, skb->data + offset, len);
1871}
1872
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03001873static inline void skb_copy_to_linear_data(struct sk_buff *skb,
1874 const void *from,
1875 const unsigned int len)
1876{
1877 memcpy(skb->data, from, len);
1878}
1879
1880static inline void skb_copy_to_linear_data_offset(struct sk_buff *skb,
1881 const int offset,
1882 const void *from,
1883 const unsigned int len)
1884{
1885 memcpy(skb->data + offset, from, len);
1886}
1887
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888extern void skb_init(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889
Patrick Ohlyac45f602009-02-12 05:03:37 +00001890static inline ktime_t skb_get_ktime(const struct sk_buff *skb)
1891{
1892 return skb->tstamp;
1893}
1894
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001895/**
1896 * skb_get_timestamp - get timestamp from a skb
1897 * @skb: skb to get stamp from
1898 * @stamp: pointer to struct timeval to store stamp in
1899 *
1900 * Timestamps are stored in the skb as offsets to a base timestamp.
1901 * This function converts the offset back to a struct timeval and stores
1902 * it in stamp.
1903 */
Patrick Ohlyac45f602009-02-12 05:03:37 +00001904static inline void skb_get_timestamp(const struct sk_buff *skb,
1905 struct timeval *stamp)
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001906{
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07001907 *stamp = ktime_to_timeval(skb->tstamp);
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001908}
1909
Patrick Ohlyac45f602009-02-12 05:03:37 +00001910static inline void skb_get_timestampns(const struct sk_buff *skb,
1911 struct timespec *stamp)
1912{
1913 *stamp = ktime_to_timespec(skb->tstamp);
1914}
1915
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07001916static inline void __net_timestamp(struct sk_buff *skb)
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001917{
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07001918 skb->tstamp = ktime_get_real();
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001919}
1920
Stephen Hemminger164891a2007-04-23 22:26:16 -07001921static inline ktime_t net_timedelta(ktime_t t)
1922{
1923 return ktime_sub(ktime_get_real(), t);
1924}
1925
Ilpo Järvinenb9ce2042007-06-15 15:08:43 -07001926static inline ktime_t net_invalid_timestamp(void)
1927{
1928 return ktime_set(0, 0);
1929}
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001930
Patrick Ohlyac45f602009-02-12 05:03:37 +00001931/**
1932 * skb_tstamp_tx - queue clone of skb with send time stamps
1933 * @orig_skb: the original outgoing packet
1934 * @hwtstamps: hardware time stamps, may be NULL if not available
1935 *
1936 * If the skb has a socket associated, then this function clones the
1937 * skb (thus sharing the actual data and optional structures), stores
1938 * the optional hardware time stamping information (if non NULL) or
1939 * generates a software time stamp (otherwise), then queues the clone
1940 * to the error queue of the socket. Errors are silently ignored.
1941 */
1942extern void skb_tstamp_tx(struct sk_buff *orig_skb,
1943 struct skb_shared_hwtstamps *hwtstamps);
1944
Herbert Xu759e5d02007-03-25 20:10:56 -07001945extern __sum16 __skb_checksum_complete_head(struct sk_buff *skb, int len);
Al Virob51655b2006-11-14 21:40:42 -08001946extern __sum16 __skb_checksum_complete(struct sk_buff *skb);
Herbert Xufb286bb2005-11-10 13:01:24 -08001947
Herbert Xu60476372007-04-09 11:59:39 -07001948static inline int skb_csum_unnecessary(const struct sk_buff *skb)
1949{
1950 return skb->ip_summed & CHECKSUM_UNNECESSARY;
1951}
1952
Herbert Xufb286bb2005-11-10 13:01:24 -08001953/**
1954 * skb_checksum_complete - Calculate checksum of an entire packet
1955 * @skb: packet to process
1956 *
1957 * This function calculates the checksum over the entire packet plus
1958 * the value of skb->csum. The latter can be used to supply the
1959 * checksum of a pseudo header as used by TCP/UDP. It returns the
1960 * checksum.
1961 *
1962 * For protocols that contain complete checksums such as ICMP/TCP/UDP,
1963 * this function can be used to verify that checksum on received
1964 * packets. In that case the function should return zero if the
1965 * checksum is correct. In particular, this function will return zero
1966 * if skb->ip_summed is CHECKSUM_UNNECESSARY which indicates that the
1967 * hardware has already verified the correctness of the checksum.
1968 */
Al Viro4381ca32007-07-15 21:00:11 +01001969static inline __sum16 skb_checksum_complete(struct sk_buff *skb)
Herbert Xufb286bb2005-11-10 13:01:24 -08001970{
Herbert Xu60476372007-04-09 11:59:39 -07001971 return skb_csum_unnecessary(skb) ?
1972 0 : __skb_checksum_complete(skb);
Herbert Xufb286bb2005-11-10 13:01:24 -08001973}
1974
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -07001975#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
Yasuyuki Kozakaide6e05c2007-03-23 11:17:27 -07001976extern void nf_conntrack_destroy(struct nf_conntrack *nfct);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977static inline void nf_conntrack_put(struct nf_conntrack *nfct)
1978{
1979 if (nfct && atomic_dec_and_test(&nfct->use))
Yasuyuki Kozakaide6e05c2007-03-23 11:17:27 -07001980 nf_conntrack_destroy(nfct);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981}
1982static inline void nf_conntrack_get(struct nf_conntrack *nfct)
1983{
1984 if (nfct)
1985 atomic_inc(&nfct->use);
1986}
Yasuyuki Kozakai9fb9cbb2005-11-09 16:38:16 -08001987static inline void nf_conntrack_get_reasm(struct sk_buff *skb)
1988{
1989 if (skb)
1990 atomic_inc(&skb->users);
1991}
1992static inline void nf_conntrack_put_reasm(struct sk_buff *skb)
1993{
1994 if (skb)
1995 kfree_skb(skb);
1996}
1997#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998#ifdef CONFIG_BRIDGE_NETFILTER
1999static inline void nf_bridge_put(struct nf_bridge_info *nf_bridge)
2000{
2001 if (nf_bridge && atomic_dec_and_test(&nf_bridge->use))
2002 kfree(nf_bridge);
2003}
2004static inline void nf_bridge_get(struct nf_bridge_info *nf_bridge)
2005{
2006 if (nf_bridge)
2007 atomic_inc(&nf_bridge->use);
2008}
2009#endif /* CONFIG_BRIDGE_NETFILTER */
Patrick McHardya193a4a2006-03-20 19:23:05 -08002010static inline void nf_reset(struct sk_buff *skb)
2011{
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -07002012#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
Patrick McHardya193a4a2006-03-20 19:23:05 -08002013 nf_conntrack_put(skb->nfct);
2014 skb->nfct = NULL;
Patrick McHardya193a4a2006-03-20 19:23:05 -08002015 nf_conntrack_put_reasm(skb->nfct_reasm);
2016 skb->nfct_reasm = NULL;
2017#endif
2018#ifdef CONFIG_BRIDGE_NETFILTER
2019 nf_bridge_put(skb->nf_bridge);
2020 skb->nf_bridge = NULL;
2021#endif
2022}
2023
Yasuyuki Kozakaiedda5532007-03-14 16:43:37 -07002024/* Note: This doesn't put any conntrack and bridge info in dst. */
2025static inline void __nf_copy(struct sk_buff *dst, const struct sk_buff *src)
2026{
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -07002027#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
Yasuyuki Kozakaiedda5532007-03-14 16:43:37 -07002028 dst->nfct = src->nfct;
2029 nf_conntrack_get(src->nfct);
2030 dst->nfctinfo = src->nfctinfo;
Yasuyuki Kozakaiedda5532007-03-14 16:43:37 -07002031 dst->nfct_reasm = src->nfct_reasm;
2032 nf_conntrack_get_reasm(src->nfct_reasm);
2033#endif
2034#ifdef CONFIG_BRIDGE_NETFILTER
2035 dst->nf_bridge = src->nf_bridge;
2036 nf_bridge_get(src->nf_bridge);
2037#endif
2038}
2039
Yasuyuki Kozakaie7ac05f2007-03-14 16:44:01 -07002040static inline void nf_copy(struct sk_buff *dst, const struct sk_buff *src)
2041{
Yasuyuki Kozakaie7ac05f2007-03-14 16:44:01 -07002042#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -07002043 nf_conntrack_put(dst->nfct);
Yasuyuki Kozakaie7ac05f2007-03-14 16:44:01 -07002044 nf_conntrack_put_reasm(dst->nfct_reasm);
2045#endif
2046#ifdef CONFIG_BRIDGE_NETFILTER
2047 nf_bridge_put(dst->nf_bridge);
2048#endif
2049 __nf_copy(dst, src);
2050}
2051
James Morris984bc162006-06-09 00:29:17 -07002052#ifdef CONFIG_NETWORK_SECMARK
2053static inline void skb_copy_secmark(struct sk_buff *to, const struct sk_buff *from)
2054{
2055 to->secmark = from->secmark;
2056}
2057
2058static inline void skb_init_secmark(struct sk_buff *skb)
2059{
2060 skb->secmark = 0;
2061}
2062#else
2063static inline void skb_copy_secmark(struct sk_buff *to, const struct sk_buff *from)
2064{ }
2065
2066static inline void skb_init_secmark(struct sk_buff *skb)
2067{ }
2068#endif
2069
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002070static inline void skb_set_queue_mapping(struct sk_buff *skb, u16 queue_mapping)
2071{
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002072 skb->queue_mapping = queue_mapping;
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002073}
2074
Stephen Hemminger92477442009-03-21 13:39:26 -07002075static inline u16 skb_get_queue_mapping(const struct sk_buff *skb)
Pavel Emelyanov4e3ab472007-10-21 17:01:29 -07002076{
Pavel Emelyanov4e3ab472007-10-21 17:01:29 -07002077 return skb->queue_mapping;
Pavel Emelyanov4e3ab472007-10-21 17:01:29 -07002078}
2079
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002080static inline void skb_copy_queue_mapping(struct sk_buff *to, const struct sk_buff *from)
2081{
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002082 to->queue_mapping = from->queue_mapping;
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002083}
2084
David S. Millerd5a9e242009-01-27 16:22:11 -08002085static inline void skb_record_rx_queue(struct sk_buff *skb, u16 rx_queue)
2086{
2087 skb->queue_mapping = rx_queue + 1;
2088}
2089
Stephen Hemminger92477442009-03-21 13:39:26 -07002090static inline u16 skb_get_rx_queue(const struct sk_buff *skb)
David S. Millerd5a9e242009-01-27 16:22:11 -08002091{
2092 return skb->queue_mapping - 1;
2093}
2094
Stephen Hemminger92477442009-03-21 13:39:26 -07002095static inline bool skb_rx_queue_recorded(const struct sk_buff *skb)
David S. Millerd5a9e242009-01-27 16:22:11 -08002096{
2097 return (skb->queue_mapping != 0);
2098}
2099
Stephen Hemminger92477442009-03-21 13:39:26 -07002100extern u16 skb_tx_hash(const struct net_device *dev,
2101 const struct sk_buff *skb);
2102
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -07002103#ifdef CONFIG_XFRM
2104static inline struct sec_path *skb_sec_path(struct sk_buff *skb)
2105{
2106 return skb->sp;
2107}
2108#else
2109static inline struct sec_path *skb_sec_path(struct sk_buff *skb)
2110{
2111 return NULL;
2112}
2113#endif
2114
Herbert Xu89114af2006-07-08 13:34:32 -07002115static inline int skb_is_gso(const struct sk_buff *skb)
2116{
2117 return skb_shinfo(skb)->gso_size;
2118}
2119
Brice Goglineabd7e32007-10-13 12:33:32 +02002120static inline int skb_is_gso_v6(const struct sk_buff *skb)
2121{
2122 return skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6;
2123}
2124
Ben Hutchings4497b072008-06-19 16:22:28 -07002125extern void __skb_warn_lro_forwarding(const struct sk_buff *skb);
2126
2127static inline bool skb_warn_if_lro(const struct sk_buff *skb)
2128{
2129 /* LRO sets gso_size but not gso_type, whereas if GSO is really
2130 * wanted then gso_type will be set. */
2131 struct skb_shared_info *shinfo = skb_shinfo(skb);
2132 if (shinfo->gso_size != 0 && unlikely(shinfo->gso_type == 0)) {
2133 __skb_warn_lro_forwarding(skb);
2134 return true;
2135 }
2136 return false;
2137}
2138
Herbert Xu35fc92a2007-03-26 23:22:20 -07002139static inline void skb_forward_csum(struct sk_buff *skb)
2140{
2141 /* Unfortunately we don't support this one. Any brave souls? */
2142 if (skb->ip_summed == CHECKSUM_COMPLETE)
2143 skb->ip_summed = CHECKSUM_NONE;
2144}
2145
Rusty Russellf35d9d82008-02-04 23:49:54 -05002146bool skb_partial_csum_set(struct sk_buff *skb, u16 start, u16 off);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002147#endif /* __KERNEL__ */
2148#endif /* _LINUX_SKBUFF_H */