blob: 50db9b04a552d5ecca29af92ffa794f80e73483a [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
Arun Sharma60063492011-07-26 16:09:06 -070023#include <linux/atomic.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#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>
Ian Campbell131ea662011-08-19 06:25:00 +000032#include <linux/dma-mapping.h>
Michał Mirosławc8f44af2011-11-15 15:29:55 +000033#include <linux/netdev_features.h>
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
Eric Dumazet87fb4b72011-10-13 07:28:54 +000050/* return minimum truesize of one skb containing X bytes of data */
51#define SKB_TRUESIZE(X) ((X) + \
52 SKB_DATA_ALIGN(sizeof(struct sk_buff)) + \
53 SKB_DATA_ALIGN(sizeof(struct skb_shared_info)))
54
Linus Torvalds1da177e2005-04-16 15:20:36 -070055/* A. Checksumming of received packets by device.
56 *
57 * NONE: device failed to checksum this packet.
58 * skb->csum is undefined.
59 *
60 * UNNECESSARY: device parsed packet and wouldbe verified checksum.
61 * skb->csum is undefined.
62 * It is bad option, but, unfortunately, many of vendors do this.
63 * Apparently with secret goal to sell you new device, when you
64 * will add new protocol to your host. F.e. IPv6. 8)
65 *
Patrick McHardy84fa7932006-08-29 16:44:56 -070066 * COMPLETE: the most generic way. Device supplied checksum of _all_
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 * the packet as seen by netif_rx in skb->csum.
68 * NOTE: Even if device supports only some protocols, but
Patrick McHardy84fa7932006-08-29 16:44:56 -070069 * is able to produce some skb->csum, it MUST use COMPLETE,
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 * not UNNECESSARY.
71 *
Herbert Xuc6c6e3e2007-07-10 22:41:55 -070072 * PARTIAL: identical to the case for output below. This may occur
73 * on a packet received directly from another Linux OS, e.g.,
74 * a virtualised Linux kernel on the same host. The packet can
75 * be treated in the same way as UNNECESSARY except that on
76 * output (i.e., forwarding) the checksum must be filled in
77 * by the OS or the hardware.
78 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 * B. Checksumming on output.
80 *
81 * NONE: skb is checksummed by protocol or csum is not required.
82 *
Patrick McHardy84fa7932006-08-29 16:44:56 -070083 * PARTIAL: device is required to csum packet as seen by hard_start_xmit
Herbert Xuc6c6e3e2007-07-10 22:41:55 -070084 * from skb->csum_start to the end and to record the checksum
85 * at skb->csum_start + skb->csum_offset.
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 *
87 * Device must show its capabilities in dev->features, set
88 * at device setup time.
89 * NETIF_F_HW_CSUM - it is clever device, it is able to checksum
90 * everything.
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 * NETIF_F_IP_CSUM - device is dumb. It is able to csum only
92 * TCP/UDP over IPv4. Sigh. Vendors like this
93 * way by an unknown reason. Though, see comment above
94 * about CHECKSUM_UNNECESSARY. 8)
Herbert Xuc6c6e3e2007-07-10 22:41:55 -070095 * NETIF_F_IPV6_CSUM about as dumb as the last one but does IPv6 instead.
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 *
97 * Any questions? No questions, good. --ANK
98 */
99
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100struct net_device;
David Howells716ea3a2007-04-02 20:19:53 -0700101struct scatterlist;
Jens Axboe9c55e012007-11-06 23:30:13 -0800102struct pipe_inode_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -0700104#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105struct nf_conntrack {
106 atomic_t use;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107};
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -0700108#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
110#ifdef CONFIG_BRIDGE_NETFILTER
111struct nf_bridge_info {
112 atomic_t use;
113 struct net_device *physindev;
114 struct net_device *physoutdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 unsigned int mask;
116 unsigned long data[32 / sizeof(unsigned long)];
117};
118#endif
119
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120struct sk_buff_head {
121 /* These two members must be first. */
122 struct sk_buff *next;
123 struct sk_buff *prev;
124
125 __u32 qlen;
126 spinlock_t lock;
127};
128
129struct sk_buff;
130
Ian Campbell9d4dde52011-12-22 23:39:14 +0000131/* To allow 64K frame to be packed as single skb without frag_list we
132 * require 64K/PAGE_SIZE pages plus 1 additional page to allow for
133 * buffers which do not start on a page boundary.
134 *
135 * Since GRO uses frags we allocate at least 16 regardless of page
136 * size.
Anton Blancharda715dea2011-03-27 14:57:26 +0000137 */
Ian Campbell9d4dde52011-12-22 23:39:14 +0000138#if (65536/PAGE_SIZE + 1) < 16
David S. Millereec00952011-03-29 23:34:08 -0700139#define MAX_SKB_FRAGS 16UL
Anton Blancharda715dea2011-03-27 14:57:26 +0000140#else
Ian Campbell9d4dde52011-12-22 23:39:14 +0000141#define MAX_SKB_FRAGS (65536/PAGE_SIZE + 1)
Anton Blancharda715dea2011-03-27 14:57:26 +0000142#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143
144typedef struct skb_frag_struct skb_frag_t;
145
146struct skb_frag_struct {
Ian Campbella8605c62011-10-19 23:01:49 +0000147 struct {
148 struct page *p;
149 } page;
Eric Dumazetcb4dfe52010-09-23 05:06:54 +0000150#if (BITS_PER_LONG > 32) || (PAGE_SIZE >= 65536)
David S. Millera309bb02007-07-30 18:47:03 -0700151 __u32 page_offset;
152 __u32 size;
Eric Dumazetcb4dfe52010-09-23 05:06:54 +0000153#else
154 __u16 page_offset;
155 __u16 size;
156#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157};
158
Eric Dumazet9e903e02011-10-18 21:00:24 +0000159static inline unsigned int skb_frag_size(const skb_frag_t *frag)
160{
161 return frag->size;
162}
163
164static inline void skb_frag_size_set(skb_frag_t *frag, unsigned int size)
165{
166 frag->size = size;
167}
168
169static inline void skb_frag_size_add(skb_frag_t *frag, int delta)
170{
171 frag->size += delta;
172}
173
174static inline void skb_frag_size_sub(skb_frag_t *frag, int delta)
175{
176 frag->size -= delta;
177}
178
Patrick Ohlyac45f602009-02-12 05:03:37 +0000179#define HAVE_HW_TIME_STAMP
180
181/**
Randy Dunlapd3a21be2009-03-02 03:15:58 -0800182 * struct skb_shared_hwtstamps - hardware time stamps
Patrick Ohlyac45f602009-02-12 05:03:37 +0000183 * @hwtstamp: hardware time stamp transformed into duration
184 * since arbitrary point in time
185 * @syststamp: hwtstamp transformed to system time base
186 *
187 * Software time stamps generated by ktime_get_real() are stored in
188 * skb->tstamp. The relation between the different kinds of time
189 * stamps is as follows:
190 *
191 * syststamp and tstamp can be compared against each other in
192 * arbitrary combinations. The accuracy of a
193 * syststamp/tstamp/"syststamp from other device" comparison is
194 * limited by the accuracy of the transformation into system time
195 * base. This depends on the device driver and its underlying
196 * hardware.
197 *
198 * hwtstamps can only be compared against other hwtstamps from
199 * the same device.
200 *
201 * This structure is attached to packets as part of the
202 * &skb_shared_info. Use skb_hwtstamps() to get a pointer.
203 */
204struct skb_shared_hwtstamps {
205 ktime_t hwtstamp;
206 ktime_t syststamp;
207};
208
Oliver Hartkopp2244d072010-08-17 08:59:14 +0000209/* Definitions for tx_flags in struct skb_shared_info */
210enum {
211 /* generate hardware time stamp */
212 SKBTX_HW_TSTAMP = 1 << 0,
213
214 /* generate software time stamp */
215 SKBTX_SW_TSTAMP = 1 << 1,
216
217 /* device driver is going to provide hardware time stamp */
218 SKBTX_IN_PROGRESS = 1 << 2,
219
220 /* ensure the originating sk reference is available on driver level */
221 SKBTX_DRV_NEEDS_SK_REF = 1 << 3,
Shirley Maa6686f22011-07-06 12:22:12 +0000222
223 /* device driver supports TX zero-copy buffers */
224 SKBTX_DEV_ZEROCOPY = 1 << 4,
Johannes Berg6e3e9392011-11-09 10:15:42 +0100225
226 /* generate wifi status information (where possible) */
227 SKBTX_WIFI_STATUS = 1 << 5,
Shirley Maa6686f22011-07-06 12:22:12 +0000228};
229
230/*
231 * The callback notifies userspace to release buffers when skb DMA is done in
232 * lower device, the skb last reference should be 0 when calling this.
233 * The desc is used to track userspace buffer index.
234 */
235struct ubuf_info {
236 void (*callback)(void *);
237 void *arg;
238 unsigned long desc;
Patrick Ohlyac45f602009-02-12 05:03:37 +0000239};
240
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241/* This data is invariant across clones and lives at
242 * the end of the header data, ie. at skb->end.
243 */
244struct skb_shared_info {
Ian Campbell9f42f122012-01-05 07:13:39 +0000245 unsigned char nr_frags;
246 __u8 tx_flags;
Herbert Xu79671682006-06-22 02:40:14 -0700247 unsigned short gso_size;
248 /* Warning: this field is not always filled in (UFO)! */
249 unsigned short gso_segs;
250 unsigned short gso_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 struct sk_buff *frag_list;
Patrick Ohlyac45f602009-02-12 05:03:37 +0000252 struct skb_shared_hwtstamps hwtstamps;
Ian Campbell9f42f122012-01-05 07:13:39 +0000253 __be32 ip6_frag_id;
Eric Dumazetec7d2f22010-05-05 01:07:37 -0700254
255 /*
256 * Warning : all fields before dataref are cleared in __alloc_skb()
257 */
258 atomic_t dataref;
259
Johann Baudy69e3c752009-05-18 22:11:22 -0700260 /* Intermediate layers must ensure that destructor_arg
261 * remains valid until skb destructor */
262 void * destructor_arg;
Shirley Maa6686f22011-07-06 12:22:12 +0000263
Eric Dumazetfed66382010-07-22 19:09:08 +0000264 /* must be last field, see pskb_expand_head() */
265 skb_frag_t frags[MAX_SKB_FRAGS];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266};
267
268/* We divide dataref into two halves. The higher 16 bits hold references
269 * to the payload part of skb->data. The lower 16 bits hold references to
Patrick McHardy334a8132007-06-25 04:35:20 -0700270 * the entire skb->data. A clone of a headerless skb holds the length of
271 * the header in skb->hdr_len.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 *
273 * All users must obey the rule that the skb->data reference count must be
274 * greater than or equal to the payload reference count.
275 *
276 * Holding a reference to the payload part means that the user does not
277 * care about modifications to the header part of skb->data.
278 */
279#define SKB_DATAREF_SHIFT 16
280#define SKB_DATAREF_MASK ((1 << SKB_DATAREF_SHIFT) - 1)
281
David S. Millerd179cd12005-08-17 14:57:30 -0700282
283enum {
284 SKB_FCLONE_UNAVAILABLE,
285 SKB_FCLONE_ORIG,
286 SKB_FCLONE_CLONE,
287};
288
Herbert Xu79671682006-06-22 02:40:14 -0700289enum {
290 SKB_GSO_TCPV4 = 1 << 0,
Herbert Xuf83ef8c2006-06-30 13:37:03 -0700291 SKB_GSO_UDP = 1 << 1,
Herbert Xu576a30e2006-06-27 13:22:38 -0700292
293 /* This indicates the skb is from an untrusted source. */
294 SKB_GSO_DODGY = 1 << 2,
Michael Chanb0da85372006-06-29 12:30:00 -0700295
296 /* This indicates the tcp segment has CWR set. */
Herbert Xuf83ef8c2006-06-30 13:37:03 -0700297 SKB_GSO_TCP_ECN = 1 << 3,
298
299 SKB_GSO_TCPV6 = 1 << 4,
Chris Leech01d5b2f2009-02-27 14:06:49 -0800300
301 SKB_GSO_FCOE = 1 << 5,
Herbert Xu79671682006-06-22 02:40:14 -0700302};
303
Arnaldo Carvalho de Melo2e07fa92007-04-10 21:22:35 -0700304#if BITS_PER_LONG > 32
305#define NET_SKBUFF_DATA_USES_OFFSET 1
306#endif
307
308#ifdef NET_SKBUFF_DATA_USES_OFFSET
309typedef unsigned int sk_buff_data_t;
310#else
311typedef unsigned char *sk_buff_data_t;
312#endif
313
KOVACS Krisztian2fc72c72011-01-12 20:25:08 +0100314#if defined(CONFIG_NF_DEFRAG_IPV4) || defined(CONFIG_NF_DEFRAG_IPV4_MODULE) || \
315 defined(CONFIG_NF_DEFRAG_IPV6) || defined(CONFIG_NF_DEFRAG_IPV6_MODULE)
316#define NET_SKBUFF_NF_DEFRAG_NEEDED 1
317#endif
318
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319/**
320 * struct sk_buff - socket buffer
321 * @next: Next buffer in list
322 * @prev: Previous buffer in list
Herbert Xu325ed822005-10-03 13:57:23 -0700323 * @tstamp: Time we arrived
Daniel Balutad84e0bd2011-07-10 07:04:04 -0700324 * @sk: Socket we are owned by
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 * @dev: Device we arrived on/are leaving by
Daniel Balutad84e0bd2011-07-10 07:04:04 -0700326 * @cb: Control buffer. Free for use by every layer. Put private vars here
Eric Dumazet7fee2262010-05-11 23:19:48 +0000327 * @_skb_refdst: destination entry (with norefcount bit)
Martin Waitz67be2dd2005-05-01 08:59:26 -0700328 * @sp: the security path, used for xfrm
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 * @len: Length of actual data
330 * @data_len: Data length
331 * @mac_len: Length of link layer header
Patrick McHardy334a8132007-06-25 04:35:20 -0700332 * @hdr_len: writable header length of cloned skb
Herbert Xu663ead32007-04-09 11:59:07 -0700333 * @csum: Checksum (must include start/offset pair)
334 * @csum_start: Offset from skb->head where checksumming should start
335 * @csum_offset: Offset from csum_start where checksum should be stored
Daniel Balutad84e0bd2011-07-10 07:04:04 -0700336 * @priority: Packet queueing priority
Martin Waitz67be2dd2005-05-01 08:59:26 -0700337 * @local_df: allow local fragmentation
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 * @cloned: Head may be cloned (check refcnt to be sure)
Daniel Balutad84e0bd2011-07-10 07:04:04 -0700339 * @ip_summed: Driver fed us an IP checksum
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 * @nohdr: Payload reference only, must not modify header
Daniel Balutad84e0bd2011-07-10 07:04:04 -0700341 * @nfctinfo: Relationship of this skb to the connection
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 * @pkt_type: Packet class
Randy Dunlapc83c2482005-10-18 22:07:41 -0700343 * @fclone: skbuff clone status
Randy Dunlapc83c2482005-10-18 22:07:41 -0700344 * @ipvs_property: skbuff is owned by ipvs
Randy Dunlap31729362008-02-18 20:52:13 -0800345 * @peeked: this packet has been seen already, so stats have been
346 * done for it, don't do them again
Jozsef Kadlecsikba9dda32007-07-07 22:21:23 -0700347 * @nf_trace: netfilter packet trace flag
Daniel Balutad84e0bd2011-07-10 07:04:04 -0700348 * @protocol: Packet protocol from driver
349 * @destructor: Destruct function
350 * @nfct: Associated connection, if any
Randy Dunlap461ddf32005-11-20 21:25:15 -0800351 * @nfct_reasm: netfilter conntrack re-assembly pointer
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 * @nf_bridge: Saved data about a bridged frame - see br_netfilter.c
Eric Dumazet8964be42009-11-20 15:35:04 -0800353 * @skb_iif: ifindex of device we arrived on
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 * @tc_index: Traffic control index
355 * @tc_verd: traffic control verdict
Daniel Balutad84e0bd2011-07-10 07:04:04 -0700356 * @rxhash: the packet hash computed on receive
357 * @queue_mapping: Queue mapping for multiqueue devices
Randy Dunlap553a5672008-04-20 10:51:01 -0700358 * @ndisc_nodetype: router type (from link layer)
Daniel Balutad84e0bd2011-07-10 07:04:04 -0700359 * @ooo_okay: allow the mapping of a socket to a queue to be changed
Changli Gao4ca24622011-08-19 07:26:44 -0700360 * @l4_rxhash: indicate rxhash is a canonical 4-tuple hash over transport
361 * ports.
Johannes Berg6e3e9392011-11-09 10:15:42 +0100362 * @wifi_acked_valid: wifi_acked was set
363 * @wifi_acked: whether frame was acked on wifi or not
Randy Dunlapf4b8ea72006-06-22 16:00:11 -0700364 * @dma_cookie: a cookie to one of several possible DMA operations
365 * done by skb DMA functions
James Morris984bc162006-06-09 00:29:17 -0700366 * @secmark: security marking
Daniel Balutad84e0bd2011-07-10 07:04:04 -0700367 * @mark: Generic packet mark
368 * @dropcount: total number of sk_receive_queue overflows
Patrick McHardy6aa895b2008-07-14 22:49:06 -0700369 * @vlan_tci: vlan tag control information
Daniel Balutad84e0bd2011-07-10 07:04:04 -0700370 * @transport_header: Transport layer header
371 * @network_header: Network layer header
372 * @mac_header: Link layer header
373 * @tail: Tail pointer
374 * @end: End pointer
375 * @head: Head of buffer
376 * @data: Data head pointer
377 * @truesize: Buffer size
378 * @users: User count - see {datagram,tcp}.c
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 */
380
381struct sk_buff {
382 /* These two members must be first. */
383 struct sk_buff *next;
384 struct sk_buff *prev;
385
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -0700386 ktime_t tstamp;
Felix Fietkauda3f5cf2010-02-23 11:45:51 +0000387
388 struct sock *sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 struct net_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 /*
392 * This is the control buffer. It is free to use for every
393 * layer. Please put your private variables there. If you
394 * want to keep them across layers you have to do a skb_clone()
395 * first. This is owned by whoever has the skb queued ATM.
396 */
Felix Fietkauda3f5cf2010-02-23 11:45:51 +0000397 char cb[48] __aligned(8);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398
Eric Dumazet7fee2262010-05-11 23:19:48 +0000399 unsigned long _skb_refdst;
Felix Fietkauda3f5cf2010-02-23 11:45:51 +0000400#ifdef CONFIG_XFRM
401 struct sec_path *sp;
402#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 unsigned int len,
Patrick McHardy334a8132007-06-25 04:35:20 -0700404 data_len;
405 __u16 mac_len,
406 hdr_len;
Al Viroff1dcad2006-11-20 18:07:29 -0800407 union {
408 __wsum csum;
Herbert Xu663ead32007-04-09 11:59:07 -0700409 struct {
410 __u16 csum_start;
411 __u16 csum_offset;
412 };
Al Viroff1dcad2006-11-20 18:07:29 -0800413 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 __u32 priority;
Vegard Nossumfe55f6d2008-08-30 12:16:35 +0200415 kmemcheck_bitfield_begin(flags1);
Thomas Graf1cbb3382005-07-05 14:13:41 -0700416 __u8 local_df:1,
417 cloned:1,
418 ip_summed:2,
Harald Welte6869c4d2005-08-09 19:24:19 -0700419 nohdr:1,
420 nfctinfo:3;
David S. Millerd179cd12005-08-17 14:57:30 -0700421 __u8 pkt_type:3,
Patrick McHardyb84f4cc2005-11-20 21:19:21 -0800422 fclone:2,
Jozsef Kadlecsikba9dda32007-07-07 22:21:23 -0700423 ipvs_property:1,
Herbert Xua59322b2007-12-05 01:53:40 -0800424 peeked:1,
Jozsef Kadlecsikba9dda32007-07-07 22:21:23 -0700425 nf_trace:1;
Vegard Nossumfe55f6d2008-08-30 12:16:35 +0200426 kmemcheck_bitfield_end(flags1);
Eric Dumazet4ab408d2010-03-01 03:09:26 +0000427 __be16 protocol;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428
429 void (*destructor)(struct sk_buff *skb);
Yasuyuki Kozakai9fb9cbb2005-11-09 16:38:16 -0800430#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -0700431 struct nf_conntrack *nfct;
KOVACS Krisztian2fc72c72011-01-12 20:25:08 +0100432#endif
433#ifdef NET_SKBUFF_NF_DEFRAG_NEEDED
Yasuyuki Kozakai9fb9cbb2005-11-09 16:38:16 -0800434 struct sk_buff *nfct_reasm;
435#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436#ifdef CONFIG_BRIDGE_NETFILTER
437 struct nf_bridge_info *nf_bridge;
438#endif
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -0700439
Eric Dumazet8964be42009-11-20 15:35:04 -0800440 int skb_iif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441#ifdef CONFIG_NET_SCHED
Patrick McHardyb6b99eb2005-08-09 19:33:51 -0700442 __u16 tc_index; /* traffic control index */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443#ifdef CONFIG_NET_CLS_ACT
Patrick McHardyb6b99eb2005-08-09 19:33:51 -0700444 __u16 tc_verd; /* traffic control verdict */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446#endif
Vegard Nossumfe55f6d2008-08-30 12:16:35 +0200447
Tom Herbert0a9627f2010-03-16 08:03:29 +0000448 __u32 rxhash;
449
Eric Dumazet0a148422011-04-20 09:27:32 +0000450 __u16 queue_mapping;
Vegard Nossumfe55f6d2008-08-30 12:16:35 +0200451 kmemcheck_bitfield_begin(flags2);
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -0400452#ifdef CONFIG_IPV6_NDISC_NODETYPE
Jiri Pirko8a4eb572011-03-12 03:14:39 +0000453 __u8 ndisc_nodetype:2;
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -0400454#endif
Tom Herbert3853b582010-11-21 13:17:29 +0000455 __u8 ooo_okay:1;
Tom Herbertbdeab992011-08-14 19:45:55 +0000456 __u8 l4_rxhash:1;
Johannes Berg6e3e9392011-11-09 10:15:42 +0100457 __u8 wifi_acked_valid:1;
458 __u8 wifi_acked:1;
459 /* 10/12 bit hole (depending on ndisc_nodetype presence) */
Vegard Nossumfe55f6d2008-08-30 12:16:35 +0200460 kmemcheck_bitfield_end(flags2);
461
Chris Leech97fc2f02006-05-23 17:55:33 -0700462#ifdef CONFIG_NET_DMA
463 dma_cookie_t dma_cookie;
464#endif
James Morris984bc162006-06-09 00:29:17 -0700465#ifdef CONFIG_NETWORK_SECMARK
466 __u32 secmark;
467#endif
Neil Horman3b885782009-10-12 13:26:31 -0700468 union {
469 __u32 mark;
470 __u32 dropcount;
471 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
Patrick McHardy6aa895b2008-07-14 22:49:06 -0700473 __u16 vlan_tci;
474
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700475 sk_buff_data_t transport_header;
476 sk_buff_data_t network_header;
477 sk_buff_data_t mac_header;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 /* These elements must be at the end, see alloc_skb() for details. */
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700479 sk_buff_data_t tail;
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -0700480 sk_buff_data_t end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 unsigned char *head,
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -0700482 *data;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700483 unsigned int truesize;
484 atomic_t users;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485};
486
487#ifdef __KERNEL__
488/*
489 * Handling routines are only of interest to the kernel
490 */
491#include <linux/slab.h>
492
493#include <asm/system.h>
494
Eric Dumazet7fee2262010-05-11 23:19:48 +0000495/*
496 * skb might have a dst pointer attached, refcounted or not.
497 * _skb_refdst low order bit is set if refcount was _not_ taken
498 */
499#define SKB_DST_NOREF 1UL
500#define SKB_DST_PTRMASK ~(SKB_DST_NOREF)
501
502/**
503 * skb_dst - returns skb dst_entry
504 * @skb: buffer
505 *
506 * Returns skb dst_entry, regardless of reference taken or not.
507 */
Eric Dumazetadf30902009-06-02 05:19:30 +0000508static inline struct dst_entry *skb_dst(const struct sk_buff *skb)
509{
Eric Dumazet7fee2262010-05-11 23:19:48 +0000510 /* If refdst was not refcounted, check we still are in a
511 * rcu_read_lock section
512 */
513 WARN_ON((skb->_skb_refdst & SKB_DST_NOREF) &&
514 !rcu_read_lock_held() &&
515 !rcu_read_lock_bh_held());
516 return (struct dst_entry *)(skb->_skb_refdst & SKB_DST_PTRMASK);
Eric Dumazetadf30902009-06-02 05:19:30 +0000517}
518
Eric Dumazet7fee2262010-05-11 23:19:48 +0000519/**
520 * skb_dst_set - sets skb dst
521 * @skb: buffer
522 * @dst: dst entry
523 *
524 * Sets skb dst, assuming a reference was taken on dst and should
525 * be released by skb_dst_drop()
526 */
Eric Dumazetadf30902009-06-02 05:19:30 +0000527static inline void skb_dst_set(struct sk_buff *skb, struct dst_entry *dst)
528{
Eric Dumazet7fee2262010-05-11 23:19:48 +0000529 skb->_skb_refdst = (unsigned long)dst;
530}
531
Eric Dumazet27b75c92010-10-15 05:44:11 +0000532extern void skb_dst_set_noref(struct sk_buff *skb, struct dst_entry *dst);
Eric Dumazet7fee2262010-05-11 23:19:48 +0000533
534/**
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300535 * skb_dst_is_noref - Test if skb dst isn't refcounted
Eric Dumazet7fee2262010-05-11 23:19:48 +0000536 * @skb: buffer
537 */
538static inline bool skb_dst_is_noref(const struct sk_buff *skb)
539{
540 return (skb->_skb_refdst & SKB_DST_NOREF) && skb_dst(skb);
Eric Dumazetadf30902009-06-02 05:19:30 +0000541}
542
Eric Dumazet511c3f92009-06-02 05:14:27 +0000543static inline struct rtable *skb_rtable(const struct sk_buff *skb)
544{
Eric Dumazetadf30902009-06-02 05:19:30 +0000545 return (struct rtable *)skb_dst(skb);
Eric Dumazet511c3f92009-06-02 05:14:27 +0000546}
547
Jörn Engel231d06a2006-03-20 21:28:35 -0800548extern void kfree_skb(struct sk_buff *skb);
Neil Hormanead2ceb2009-03-11 09:49:55 +0000549extern void consume_skb(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550extern void __kfree_skb(struct sk_buff *skb);
David S. Millerd179cd12005-08-17 14:57:30 -0700551extern struct sk_buff *__alloc_skb(unsigned int size,
Christoph Hellwigb30973f2006-12-06 20:32:36 -0800552 gfp_t priority, int fclone, int node);
Eric Dumazetb2b5ce92011-11-14 06:03:34 +0000553extern struct sk_buff *build_skb(void *data);
David S. Millerd179cd12005-08-17 14:57:30 -0700554static inline struct sk_buff *alloc_skb(unsigned int size,
Al Virodd0fc662005-10-07 07:46:04 +0100555 gfp_t priority)
David S. Millerd179cd12005-08-17 14:57:30 -0700556{
Eric Dumazet564824b2010-10-11 19:05:25 +0000557 return __alloc_skb(size, priority, 0, NUMA_NO_NODE);
David S. Millerd179cd12005-08-17 14:57:30 -0700558}
559
560static inline struct sk_buff *alloc_skb_fclone(unsigned int size,
Al Virodd0fc662005-10-07 07:46:04 +0100561 gfp_t priority)
David S. Millerd179cd12005-08-17 14:57:30 -0700562{
Eric Dumazet564824b2010-10-11 19:05:25 +0000563 return __alloc_skb(size, priority, 1, NUMA_NO_NODE);
David S. Millerd179cd12005-08-17 14:57:30 -0700564}
565
Andy Fleming3d153a72011-10-13 04:33:54 +0000566extern void skb_recycle(struct sk_buff *skb);
Changli Gao5b0daa32010-05-29 00:12:13 -0700567extern bool skb_recycle_check(struct sk_buff *skb, int skb_size);
Lennert Buytenhek04a4bb52008-10-01 02:33:12 -0700568
Herbert Xue0053ec2007-10-14 00:37:52 -0700569extern struct sk_buff *skb_morph(struct sk_buff *dst, struct sk_buff *src);
Michael S. Tsirkin48c83012011-08-31 08:03:29 +0000570extern int skb_copy_ubufs(struct sk_buff *skb, gfp_t gfp_mask);
Victor Fusco86a76ca2005-07-08 14:57:47 -0700571extern struct sk_buff *skb_clone(struct sk_buff *skb,
Al Virodd0fc662005-10-07 07:46:04 +0100572 gfp_t priority);
Victor Fusco86a76ca2005-07-08 14:57:47 -0700573extern struct sk_buff *skb_copy(const struct sk_buff *skb,
Al Virodd0fc662005-10-07 07:46:04 +0100574 gfp_t priority);
Eric Dumazet117632e2011-12-03 21:39:53 +0000575extern struct sk_buff *__pskb_copy(struct sk_buff *skb,
576 int headroom, gfp_t gfp_mask);
577
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578extern int pskb_expand_head(struct sk_buff *skb,
Victor Fusco86a76ca2005-07-08 14:57:47 -0700579 int nhead, int ntail,
Al Virodd0fc662005-10-07 07:46:04 +0100580 gfp_t gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581extern struct sk_buff *skb_realloc_headroom(struct sk_buff *skb,
582 unsigned int headroom);
583extern struct sk_buff *skb_copy_expand(const struct sk_buff *skb,
584 int newheadroom, int newtailroom,
Al Virodd0fc662005-10-07 07:46:04 +0100585 gfp_t priority);
David Howells716ea3a2007-04-02 20:19:53 -0700586extern int skb_to_sgvec(struct sk_buff *skb,
587 struct scatterlist *sg, int offset,
588 int len);
589extern int skb_cow_data(struct sk_buff *skb, int tailbits,
590 struct sk_buff **trailer);
Herbert Xu5b057c62006-06-23 02:06:41 -0700591extern int skb_pad(struct sk_buff *skb, int pad);
Neil Hormanead2ceb2009-03-11 09:49:55 +0000592#define dev_kfree_skb(a) consume_skb(a)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593
Ananda Rajue89e9cf2005-10-18 15:46:41 -0700594extern int skb_append_datato_frags(struct sock *sk, struct sk_buff *skb,
595 int getfrag(void *from, char *to, int offset,
596 int len,int odd, struct sk_buff *skb),
597 void *from, int length);
598
Eric Dumazetd94d9fe2009-11-04 09:50:58 -0800599struct skb_seq_state {
Thomas Graf677e90e2005-06-23 20:59:51 -0700600 __u32 lower_offset;
601 __u32 upper_offset;
602 __u32 frag_idx;
603 __u32 stepped_offset;
604 struct sk_buff *root_skb;
605 struct sk_buff *cur_skb;
606 __u8 *frag_data;
607};
608
609extern void skb_prepare_seq_read(struct sk_buff *skb,
610 unsigned int from, unsigned int to,
611 struct skb_seq_state *st);
612extern unsigned int skb_seq_read(unsigned int consumed, const u8 **data,
613 struct skb_seq_state *st);
614extern void skb_abort_seq_read(struct skb_seq_state *st);
615
Thomas Graf3fc7e8a2005-06-23 21:00:17 -0700616extern unsigned int skb_find_text(struct sk_buff *skb, unsigned int from,
617 unsigned int to, struct ts_config *config,
618 struct ts_state *state);
619
Tom Herbertbdeab992011-08-14 19:45:55 +0000620extern void __skb_get_rxhash(struct sk_buff *skb);
Krishna Kumarbfb564e2010-08-04 06:15:52 +0000621static inline __u32 skb_get_rxhash(struct sk_buff *skb)
622{
623 if (!skb->rxhash)
Tom Herbertbdeab992011-08-14 19:45:55 +0000624 __skb_get_rxhash(skb);
Krishna Kumarbfb564e2010-08-04 06:15:52 +0000625
626 return skb->rxhash;
627}
628
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -0700629#ifdef NET_SKBUFF_DATA_USES_OFFSET
630static inline unsigned char *skb_end_pointer(const struct sk_buff *skb)
631{
632 return skb->head + skb->end;
633}
634#else
635static inline unsigned char *skb_end_pointer(const struct sk_buff *skb)
636{
637 return skb->end;
638}
639#endif
640
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641/* Internal */
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -0700642#define skb_shinfo(SKB) ((struct skb_shared_info *)(skb_end_pointer(SKB)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643
Patrick Ohlyac45f602009-02-12 05:03:37 +0000644static inline struct skb_shared_hwtstamps *skb_hwtstamps(struct sk_buff *skb)
645{
646 return &skb_shinfo(skb)->hwtstamps;
647}
648
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649/**
650 * skb_queue_empty - check if a queue is empty
651 * @list: queue head
652 *
653 * Returns true if the queue is empty, false otherwise.
654 */
655static inline int skb_queue_empty(const struct sk_buff_head *list)
656{
657 return list->next == (struct sk_buff *)list;
658}
659
660/**
David S. Millerfc7ebb22008-09-23 00:34:07 -0700661 * skb_queue_is_last - check if skb is the last entry in the queue
662 * @list: queue head
663 * @skb: buffer
664 *
665 * Returns true if @skb is the last buffer on the list.
666 */
667static inline bool skb_queue_is_last(const struct sk_buff_head *list,
668 const struct sk_buff *skb)
669{
Eric Dumazeta02cec22010-09-22 20:43:57 +0000670 return skb->next == (struct sk_buff *)list;
David S. Millerfc7ebb22008-09-23 00:34:07 -0700671}
672
673/**
Ilpo Järvinen832d11c2008-11-24 21:20:15 -0800674 * skb_queue_is_first - check if skb is the first entry in the queue
675 * @list: queue head
676 * @skb: buffer
677 *
678 * Returns true if @skb is the first buffer on the list.
679 */
680static inline bool skb_queue_is_first(const struct sk_buff_head *list,
681 const struct sk_buff *skb)
682{
Eric Dumazeta02cec22010-09-22 20:43:57 +0000683 return skb->prev == (struct sk_buff *)list;
Ilpo Järvinen832d11c2008-11-24 21:20:15 -0800684}
685
686/**
David S. Miller249c8b42008-09-23 00:44:42 -0700687 * skb_queue_next - return the next packet in the queue
688 * @list: queue head
689 * @skb: current buffer
690 *
691 * Return the next packet in @list after @skb. It is only valid to
692 * call this if skb_queue_is_last() evaluates to false.
693 */
694static inline struct sk_buff *skb_queue_next(const struct sk_buff_head *list,
695 const struct sk_buff *skb)
696{
697 /* This BUG_ON may seem severe, but if we just return then we
698 * are going to dereference garbage.
699 */
700 BUG_ON(skb_queue_is_last(list, skb));
701 return skb->next;
702}
703
704/**
Ilpo Järvinen832d11c2008-11-24 21:20:15 -0800705 * skb_queue_prev - return the prev packet in the queue
706 * @list: queue head
707 * @skb: current buffer
708 *
709 * Return the prev packet in @list before @skb. It is only valid to
710 * call this if skb_queue_is_first() evaluates to false.
711 */
712static inline struct sk_buff *skb_queue_prev(const struct sk_buff_head *list,
713 const struct sk_buff *skb)
714{
715 /* This BUG_ON may seem severe, but if we just return then we
716 * are going to dereference garbage.
717 */
718 BUG_ON(skb_queue_is_first(list, skb));
719 return skb->prev;
720}
721
722/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 * skb_get - reference buffer
724 * @skb: buffer to reference
725 *
726 * Makes another reference to a socket buffer and returns a pointer
727 * to the buffer.
728 */
729static inline struct sk_buff *skb_get(struct sk_buff *skb)
730{
731 atomic_inc(&skb->users);
732 return skb;
733}
734
735/*
736 * If users == 1, we are the only owner and are can avoid redundant
737 * atomic change.
738 */
739
740/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 * skb_cloned - is the buffer a clone
742 * @skb: buffer to check
743 *
744 * Returns true if the buffer was generated with skb_clone() and is
745 * one of multiple shared copies of the buffer. Cloned buffers are
746 * shared data so must not be written to under normal circumstances.
747 */
748static inline int skb_cloned(const struct sk_buff *skb)
749{
750 return skb->cloned &&
751 (atomic_read(&skb_shinfo(skb)->dataref) & SKB_DATAREF_MASK) != 1;
752}
753
754/**
755 * skb_header_cloned - is the header a clone
756 * @skb: buffer to check
757 *
758 * Returns true if modifying the header part of the buffer requires
759 * the data to be copied.
760 */
761static inline int skb_header_cloned(const struct sk_buff *skb)
762{
763 int dataref;
764
765 if (!skb->cloned)
766 return 0;
767
768 dataref = atomic_read(&skb_shinfo(skb)->dataref);
769 dataref = (dataref & SKB_DATAREF_MASK) - (dataref >> SKB_DATAREF_SHIFT);
770 return dataref != 1;
771}
772
773/**
774 * skb_header_release - release reference to header
775 * @skb: buffer to operate on
776 *
777 * Drop a reference to the header part of the buffer. This is done
778 * by acquiring a payload reference. You must not read from the header
779 * part of skb->data after this.
780 */
781static inline void skb_header_release(struct sk_buff *skb)
782{
783 BUG_ON(skb->nohdr);
784 skb->nohdr = 1;
785 atomic_add(1 << SKB_DATAREF_SHIFT, &skb_shinfo(skb)->dataref);
786}
787
788/**
789 * skb_shared - is the buffer shared
790 * @skb: buffer to check
791 *
792 * Returns true if more than one person has a reference to this
793 * buffer.
794 */
795static inline int skb_shared(const struct sk_buff *skb)
796{
797 return atomic_read(&skb->users) != 1;
798}
799
800/**
801 * skb_share_check - check if buffer is shared and if so clone it
802 * @skb: buffer to check
803 * @pri: priority for memory allocation
804 *
805 * If the buffer is shared the buffer is cloned and the old copy
806 * drops a reference. A new clone with a single reference is returned.
807 * If the buffer is not shared the original buffer is returned. When
808 * being called from interrupt status or with spinlocks held pri must
809 * be GFP_ATOMIC.
810 *
811 * NULL is returned on a memory allocation failure.
812 */
Victor Fusco86a76ca2005-07-08 14:57:47 -0700813static inline struct sk_buff *skb_share_check(struct sk_buff *skb,
Al Virodd0fc662005-10-07 07:46:04 +0100814 gfp_t pri)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815{
816 might_sleep_if(pri & __GFP_WAIT);
817 if (skb_shared(skb)) {
818 struct sk_buff *nskb = skb_clone(skb, pri);
819 kfree_skb(skb);
820 skb = nskb;
821 }
822 return skb;
823}
824
825/*
826 * Copy shared buffers into a new sk_buff. We effectively do COW on
827 * packets to handle cases where we have a local reader and forward
828 * and a couple of other messy ones. The normal one is tcpdumping
829 * a packet thats being forwarded.
830 */
831
832/**
833 * skb_unshare - make a copy of a shared buffer
834 * @skb: buffer to check
835 * @pri: priority for memory allocation
836 *
837 * If the socket buffer is a clone then this function creates a new
838 * copy of the data, drops a reference count on the old copy and returns
839 * the new copy with the reference count at 1. If the buffer is not a clone
840 * the original buffer is returned. When called with a spinlock held or
841 * from interrupt state @pri must be %GFP_ATOMIC
842 *
843 * %NULL is returned on a memory allocation failure.
844 */
Victor Fuscoe2bf5212005-07-18 13:36:38 -0700845static inline struct sk_buff *skb_unshare(struct sk_buff *skb,
Al Virodd0fc662005-10-07 07:46:04 +0100846 gfp_t pri)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847{
848 might_sleep_if(pri & __GFP_WAIT);
849 if (skb_cloned(skb)) {
850 struct sk_buff *nskb = skb_copy(skb, pri);
851 kfree_skb(skb); /* Free our shared copy */
852 skb = nskb;
853 }
854 return skb;
855}
856
857/**
Ben Hutchings1a5778a2010-02-14 22:35:47 -0800858 * skb_peek - peek at the head of an &sk_buff_head
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 * @list_: list to peek at
860 *
861 * Peek an &sk_buff. Unlike most other operations you _MUST_
862 * be careful with this one. A peek leaves the buffer on the
863 * list and someone else may run off with it. You must hold
864 * the appropriate locks or have a private queue to do this.
865 *
866 * Returns %NULL for an empty list or a pointer to the head element.
867 * The reference count is not incremented and the reference is therefore
868 * volatile. Use with caution.
869 */
Eric Dumazet05bdd2f2011-10-20 17:45:43 -0400870static inline struct sk_buff *skb_peek(const struct sk_buff_head *list_)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871{
Eric Dumazet05bdd2f2011-10-20 17:45:43 -0400872 struct sk_buff *list = ((const struct sk_buff *)list_)->next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 if (list == (struct sk_buff *)list_)
874 list = NULL;
875 return list;
876}
877
878/**
Ben Hutchings1a5778a2010-02-14 22:35:47 -0800879 * skb_peek_tail - peek at the tail of an &sk_buff_head
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 * @list_: list to peek at
881 *
882 * Peek an &sk_buff. Unlike most other operations you _MUST_
883 * be careful with this one. A peek leaves the buffer on the
884 * list and someone else may run off with it. You must hold
885 * the appropriate locks or have a private queue to do this.
886 *
887 * Returns %NULL for an empty list or a pointer to the tail element.
888 * The reference count is not incremented and the reference is therefore
889 * volatile. Use with caution.
890 */
Eric Dumazet05bdd2f2011-10-20 17:45:43 -0400891static inline struct sk_buff *skb_peek_tail(const struct sk_buff_head *list_)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892{
Eric Dumazet05bdd2f2011-10-20 17:45:43 -0400893 struct sk_buff *list = ((const struct sk_buff *)list_)->prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 if (list == (struct sk_buff *)list_)
895 list = NULL;
896 return list;
897}
898
899/**
900 * skb_queue_len - get queue length
901 * @list_: list to measure
902 *
903 * Return the length of an &sk_buff queue.
904 */
905static inline __u32 skb_queue_len(const struct sk_buff_head *list_)
906{
907 return list_->qlen;
908}
909
David S. Miller67fed452008-09-21 22:36:24 -0700910/**
911 * __skb_queue_head_init - initialize non-spinlock portions of sk_buff_head
912 * @list: queue to initialize
913 *
914 * This initializes only the list and queue length aspects of
915 * an sk_buff_head object. This allows to initialize the list
916 * aspects of an sk_buff_head without reinitializing things like
917 * the spinlock. It can also be used for on-stack sk_buff_head
918 * objects where the spinlock is known to not be used.
919 */
920static inline void __skb_queue_head_init(struct sk_buff_head *list)
921{
922 list->prev = list->next = (struct sk_buff *)list;
923 list->qlen = 0;
924}
925
Arjan van de Ven76f10ad2006-08-02 14:06:55 -0700926/*
927 * This function creates a split out lock class for each invocation;
928 * this is needed for now since a whole lot of users of the skb-queue
929 * infrastructure in drivers have different locking usage (in hardirq)
930 * than the networking core (in softirq only). In the long run either the
931 * network layer or drivers should need annotation to consolidate the
932 * main types of usage into 3 classes.
933 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934static inline void skb_queue_head_init(struct sk_buff_head *list)
935{
936 spin_lock_init(&list->lock);
David S. Miller67fed452008-09-21 22:36:24 -0700937 __skb_queue_head_init(list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938}
939
Pavel Emelianovc2ecba72007-04-17 12:45:31 -0700940static inline void skb_queue_head_init_class(struct sk_buff_head *list,
941 struct lock_class_key *class)
942{
943 skb_queue_head_init(list);
944 lockdep_set_class(&list->lock, class);
945}
946
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947/*
Gerrit Renkerbf299272008-04-14 00:04:51 -0700948 * Insert an sk_buff on a list.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 *
950 * The "__skb_xxxx()" functions are the non-atomic ones that
951 * can only be called with interrupts disabled.
952 */
Gerrit Renkerbf299272008-04-14 00:04:51 -0700953extern void skb_insert(struct sk_buff *old, struct sk_buff *newsk, struct sk_buff_head *list);
954static inline void __skb_insert(struct sk_buff *newsk,
955 struct sk_buff *prev, struct sk_buff *next,
956 struct sk_buff_head *list)
957{
958 newsk->next = next;
959 newsk->prev = prev;
960 next->prev = prev->next = newsk;
961 list->qlen++;
962}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963
David S. Miller67fed452008-09-21 22:36:24 -0700964static inline void __skb_queue_splice(const struct sk_buff_head *list,
965 struct sk_buff *prev,
966 struct sk_buff *next)
967{
968 struct sk_buff *first = list->next;
969 struct sk_buff *last = list->prev;
970
971 first->prev = prev;
972 prev->next = first;
973
974 last->next = next;
975 next->prev = last;
976}
977
978/**
979 * skb_queue_splice - join two skb lists, this is designed for stacks
980 * @list: the new list to add
981 * @head: the place to add it in the first list
982 */
983static inline void skb_queue_splice(const struct sk_buff_head *list,
984 struct sk_buff_head *head)
985{
986 if (!skb_queue_empty(list)) {
987 __skb_queue_splice(list, (struct sk_buff *) head, head->next);
David S. Miller1d4a31d2008-09-22 21:57:21 -0700988 head->qlen += list->qlen;
David S. Miller67fed452008-09-21 22:36:24 -0700989 }
990}
991
992/**
993 * skb_queue_splice - join two skb lists and reinitialise the emptied list
994 * @list: the new list to add
995 * @head: the place to add it in the first list
996 *
997 * The list at @list is reinitialised
998 */
999static inline void skb_queue_splice_init(struct sk_buff_head *list,
1000 struct sk_buff_head *head)
1001{
1002 if (!skb_queue_empty(list)) {
1003 __skb_queue_splice(list, (struct sk_buff *) head, head->next);
David S. Miller1d4a31d2008-09-22 21:57:21 -07001004 head->qlen += list->qlen;
David S. Miller67fed452008-09-21 22:36:24 -07001005 __skb_queue_head_init(list);
1006 }
1007}
1008
1009/**
1010 * skb_queue_splice_tail - join two skb lists, each list being a queue
1011 * @list: the new list to add
1012 * @head: the place to add it in the first list
1013 */
1014static inline void skb_queue_splice_tail(const struct sk_buff_head *list,
1015 struct sk_buff_head *head)
1016{
1017 if (!skb_queue_empty(list)) {
1018 __skb_queue_splice(list, head->prev, (struct sk_buff *) head);
David S. Miller1d4a31d2008-09-22 21:57:21 -07001019 head->qlen += list->qlen;
David S. Miller67fed452008-09-21 22:36:24 -07001020 }
1021}
1022
1023/**
1024 * skb_queue_splice_tail - join two skb lists and reinitialise the emptied list
1025 * @list: the new list to add
1026 * @head: the place to add it in the first list
1027 *
1028 * Each of the lists is a queue.
1029 * The list at @list is reinitialised
1030 */
1031static inline void skb_queue_splice_tail_init(struct sk_buff_head *list,
1032 struct sk_buff_head *head)
1033{
1034 if (!skb_queue_empty(list)) {
1035 __skb_queue_splice(list, head->prev, (struct sk_buff *) head);
David S. Miller1d4a31d2008-09-22 21:57:21 -07001036 head->qlen += list->qlen;
David S. Miller67fed452008-09-21 22:36:24 -07001037 __skb_queue_head_init(list);
1038 }
1039}
1040
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041/**
Stephen Hemminger300ce172005-10-30 13:47:34 -08001042 * __skb_queue_after - queue a buffer at the list head
1043 * @list: list to use
1044 * @prev: place after this buffer
1045 * @newsk: buffer to queue
1046 *
1047 * Queue a buffer int the middle of a list. This function takes no locks
1048 * and you must therefore hold required locks before calling it.
1049 *
1050 * A buffer cannot be placed on two lists at the same time.
1051 */
1052static inline void __skb_queue_after(struct sk_buff_head *list,
1053 struct sk_buff *prev,
1054 struct sk_buff *newsk)
1055{
Gerrit Renkerbf299272008-04-14 00:04:51 -07001056 __skb_insert(newsk, prev, prev->next, list);
Stephen Hemminger300ce172005-10-30 13:47:34 -08001057}
1058
Gerrit Renker7de6c032008-04-14 00:05:09 -07001059extern void skb_append(struct sk_buff *old, struct sk_buff *newsk,
1060 struct sk_buff_head *list);
1061
Gerrit Renkerf5572852008-04-14 00:05:28 -07001062static inline void __skb_queue_before(struct sk_buff_head *list,
1063 struct sk_buff *next,
1064 struct sk_buff *newsk)
1065{
1066 __skb_insert(newsk, next->prev, next, list);
1067}
1068
Stephen Hemminger300ce172005-10-30 13:47:34 -08001069/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 * __skb_queue_head - queue a buffer at the list head
1071 * @list: list to use
1072 * @newsk: buffer to queue
1073 *
1074 * Queue a buffer at the start of a list. This function takes no locks
1075 * and you must therefore hold required locks before calling it.
1076 *
1077 * A buffer cannot be placed on two lists at the same time.
1078 */
1079extern void skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk);
1080static inline void __skb_queue_head(struct sk_buff_head *list,
1081 struct sk_buff *newsk)
1082{
Stephen Hemminger300ce172005-10-30 13:47:34 -08001083 __skb_queue_after(list, (struct sk_buff *)list, newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084}
1085
1086/**
1087 * __skb_queue_tail - queue a buffer at the list tail
1088 * @list: list to use
1089 * @newsk: buffer to queue
1090 *
1091 * Queue a buffer at the end of a list. This function takes no locks
1092 * and you must therefore hold required locks before calling it.
1093 *
1094 * A buffer cannot be placed on two lists at the same time.
1095 */
1096extern void skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk);
1097static inline void __skb_queue_tail(struct sk_buff_head *list,
1098 struct sk_buff *newsk)
1099{
Gerrit Renkerf5572852008-04-14 00:05:28 -07001100 __skb_queue_before(list, (struct sk_buff *)list, newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101}
1102
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 * remove sk_buff from list. _Must_ be called atomically, and with
1105 * the list known..
1106 */
David S. Miller8728b832005-08-09 19:25:21 -07001107extern void skb_unlink(struct sk_buff *skb, struct sk_buff_head *list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108static inline void __skb_unlink(struct sk_buff *skb, struct sk_buff_head *list)
1109{
1110 struct sk_buff *next, *prev;
1111
1112 list->qlen--;
1113 next = skb->next;
1114 prev = skb->prev;
1115 skb->next = skb->prev = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 next->prev = prev;
1117 prev->next = next;
1118}
1119
Gerrit Renkerf525c062008-04-14 00:04:12 -07001120/**
1121 * __skb_dequeue - remove from the head of the queue
1122 * @list: list to dequeue from
1123 *
1124 * Remove the head of the list. This function does not take any locks
1125 * so must be used with appropriate locks held only. The head item is
1126 * returned or %NULL if the list is empty.
1127 */
1128extern struct sk_buff *skb_dequeue(struct sk_buff_head *list);
1129static inline struct sk_buff *__skb_dequeue(struct sk_buff_head *list)
1130{
1131 struct sk_buff *skb = skb_peek(list);
1132 if (skb)
1133 __skb_unlink(skb, list);
1134 return skb;
1135}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136
1137/**
1138 * __skb_dequeue_tail - remove from the tail of the queue
1139 * @list: list to dequeue from
1140 *
1141 * Remove the tail of the list. This function does not take any locks
1142 * so must be used with appropriate locks held only. The tail item is
1143 * returned or %NULL if the list is empty.
1144 */
1145extern struct sk_buff *skb_dequeue_tail(struct sk_buff_head *list);
1146static inline struct sk_buff *__skb_dequeue_tail(struct sk_buff_head *list)
1147{
1148 struct sk_buff *skb = skb_peek_tail(list);
1149 if (skb)
1150 __skb_unlink(skb, list);
1151 return skb;
1152}
1153
1154
1155static inline int skb_is_nonlinear(const struct sk_buff *skb)
1156{
1157 return skb->data_len;
1158}
1159
1160static inline unsigned int skb_headlen(const struct sk_buff *skb)
1161{
1162 return skb->len - skb->data_len;
1163}
1164
1165static inline int skb_pagelen(const struct sk_buff *skb)
1166{
1167 int i, len = 0;
1168
1169 for (i = (int)skb_shinfo(skb)->nr_frags - 1; i >= 0; i--)
Eric Dumazet9e903e02011-10-18 21:00:24 +00001170 len += skb_frag_size(&skb_shinfo(skb)->frags[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 return len + skb_headlen(skb);
1172}
1173
Ian Campbell131ea662011-08-19 06:25:00 +00001174/**
1175 * __skb_fill_page_desc - initialise a paged fragment in an skb
1176 * @skb: buffer containing fragment to be initialised
1177 * @i: paged fragment index to initialise
1178 * @page: the page to use for this fragment
1179 * @off: the offset to the data with @page
1180 * @size: the length of the data
1181 *
1182 * Initialises the @i'th fragment of @skb to point to &size bytes at
1183 * offset @off within @page.
1184 *
1185 * Does not take any additional reference on the fragment.
1186 */
1187static inline void __skb_fill_page_desc(struct sk_buff *skb, int i,
1188 struct page *page, int off, int size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189{
1190 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
1191
Ian Campbella8605c62011-10-19 23:01:49 +00001192 frag->page.p = page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 frag->page_offset = off;
Eric Dumazet9e903e02011-10-18 21:00:24 +00001194 skb_frag_size_set(frag, size);
Ian Campbell131ea662011-08-19 06:25:00 +00001195}
1196
1197/**
1198 * skb_fill_page_desc - initialise a paged fragment in an skb
1199 * @skb: buffer containing fragment to be initialised
1200 * @i: paged fragment index to initialise
1201 * @page: the page to use for this fragment
1202 * @off: the offset to the data with @page
1203 * @size: the length of the data
1204 *
1205 * As per __skb_fill_page_desc() -- initialises the @i'th fragment of
1206 * @skb to point to &size bytes at offset @off within @page. In
1207 * addition updates @skb such that @i is the last fragment.
1208 *
1209 * Does not take any additional reference on the fragment.
1210 */
1211static inline void skb_fill_page_desc(struct sk_buff *skb, int i,
1212 struct page *page, int off, int size)
1213{
1214 __skb_fill_page_desc(skb, i, page, off, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 skb_shinfo(skb)->nr_frags = i + 1;
1216}
1217
Peter Zijlstra654bed12008-10-07 14:22:33 -07001218extern void skb_add_rx_frag(struct sk_buff *skb, int i, struct page *page,
1219 int off, int size);
1220
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221#define SKB_PAGE_ASSERT(skb) BUG_ON(skb_shinfo(skb)->nr_frags)
David S. Miller21dc3302010-08-23 00:13:46 -07001222#define SKB_FRAG_ASSERT(skb) BUG_ON(skb_has_frag_list(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223#define SKB_LINEAR_ASSERT(skb) BUG_ON(skb_is_nonlinear(skb))
1224
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001225#ifdef NET_SKBUFF_DATA_USES_OFFSET
1226static inline unsigned char *skb_tail_pointer(const struct sk_buff *skb)
1227{
1228 return skb->head + skb->tail;
1229}
1230
1231static inline void skb_reset_tail_pointer(struct sk_buff *skb)
1232{
1233 skb->tail = skb->data - skb->head;
1234}
1235
1236static inline void skb_set_tail_pointer(struct sk_buff *skb, const int offset)
1237{
1238 skb_reset_tail_pointer(skb);
1239 skb->tail += offset;
1240}
1241#else /* NET_SKBUFF_DATA_USES_OFFSET */
1242static inline unsigned char *skb_tail_pointer(const struct sk_buff *skb)
1243{
1244 return skb->tail;
1245}
1246
1247static inline void skb_reset_tail_pointer(struct sk_buff *skb)
1248{
1249 skb->tail = skb->data;
1250}
1251
1252static inline void skb_set_tail_pointer(struct sk_buff *skb, const int offset)
1253{
1254 skb->tail = skb->data + offset;
1255}
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -07001256
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001257#endif /* NET_SKBUFF_DATA_USES_OFFSET */
1258
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259/*
1260 * Add data to an sk_buff
1261 */
Ilpo Järvinen0dde3e12008-03-27 17:43:41 -07001262extern unsigned char *skb_put(struct sk_buff *skb, unsigned int len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263static inline unsigned char *__skb_put(struct sk_buff *skb, unsigned int len)
1264{
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001265 unsigned char *tmp = skb_tail_pointer(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 SKB_LINEAR_ASSERT(skb);
1267 skb->tail += len;
1268 skb->len += len;
1269 return tmp;
1270}
1271
Ilpo Järvinenc2aa2702008-03-27 17:52:40 -07001272extern unsigned char *skb_push(struct sk_buff *skb, unsigned int len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273static inline unsigned char *__skb_push(struct sk_buff *skb, unsigned int len)
1274{
1275 skb->data -= len;
1276 skb->len += len;
1277 return skb->data;
1278}
1279
Ilpo Järvinen6be8ac22008-03-27 17:47:24 -07001280extern unsigned char *skb_pull(struct sk_buff *skb, unsigned int len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281static inline unsigned char *__skb_pull(struct sk_buff *skb, unsigned int len)
1282{
1283 skb->len -= len;
1284 BUG_ON(skb->len < skb->data_len);
1285 return skb->data += len;
1286}
1287
David S. Miller47d29642010-05-02 02:21:44 -07001288static inline unsigned char *skb_pull_inline(struct sk_buff *skb, unsigned int len)
1289{
1290 return unlikely(len > skb->len) ? NULL : __skb_pull(skb, len);
1291}
1292
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293extern unsigned char *__pskb_pull_tail(struct sk_buff *skb, int delta);
1294
1295static inline unsigned char *__pskb_pull(struct sk_buff *skb, unsigned int len)
1296{
1297 if (len > skb_headlen(skb) &&
Gerrit Renker987c4022008-08-11 18:17:17 -07001298 !__pskb_pull_tail(skb, len - skb_headlen(skb)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 return NULL;
1300 skb->len -= len;
1301 return skb->data += len;
1302}
1303
1304static inline unsigned char *pskb_pull(struct sk_buff *skb, unsigned int len)
1305{
1306 return unlikely(len > skb->len) ? NULL : __pskb_pull(skb, len);
1307}
1308
1309static inline int pskb_may_pull(struct sk_buff *skb, unsigned int len)
1310{
1311 if (likely(len <= skb_headlen(skb)))
1312 return 1;
1313 if (unlikely(len > skb->len))
1314 return 0;
Gerrit Renker987c4022008-08-11 18:17:17 -07001315 return __pskb_pull_tail(skb, len - skb_headlen(skb)) != NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316}
1317
1318/**
1319 * skb_headroom - bytes at buffer head
1320 * @skb: buffer to check
1321 *
1322 * Return the number of bytes of free space at the head of an &sk_buff.
1323 */
Chuck Leverc2636b42007-10-23 21:07:32 -07001324static inline unsigned int skb_headroom(const struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325{
1326 return skb->data - skb->head;
1327}
1328
1329/**
1330 * skb_tailroom - bytes at buffer end
1331 * @skb: buffer to check
1332 *
1333 * Return the number of bytes of free space at the tail of an sk_buff
1334 */
1335static inline int skb_tailroom(const struct sk_buff *skb)
1336{
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -07001337 return skb_is_nonlinear(skb) ? 0 : skb->end - skb->tail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338}
1339
1340/**
1341 * skb_reserve - adjust headroom
1342 * @skb: buffer to alter
1343 * @len: bytes to move
1344 *
1345 * Increase the headroom of an empty &sk_buff by reducing the tail
1346 * room. This is only allowed for an empty buffer.
1347 */
David S. Miller82431262006-01-17 02:54:21 -08001348static inline void skb_reserve(struct sk_buff *skb, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349{
1350 skb->data += len;
1351 skb->tail += len;
1352}
1353
Jiri Pirko0b5c9db2011-06-10 06:56:58 +00001354static inline void skb_reset_mac_len(struct sk_buff *skb)
1355{
1356 skb->mac_len = skb->network_header - skb->mac_header;
1357}
1358
Arnaldo Carvalho de Melo2e07fa92007-04-10 21:22:35 -07001359#ifdef NET_SKBUFF_DATA_USES_OFFSET
1360static inline unsigned char *skb_transport_header(const struct sk_buff *skb)
1361{
1362 return skb->head + skb->transport_header;
1363}
1364
1365static inline void skb_reset_transport_header(struct sk_buff *skb)
1366{
1367 skb->transport_header = skb->data - skb->head;
1368}
1369
1370static inline void skb_set_transport_header(struct sk_buff *skb,
1371 const int offset)
1372{
1373 skb_reset_transport_header(skb);
1374 skb->transport_header += offset;
1375}
1376
1377static inline unsigned char *skb_network_header(const struct sk_buff *skb)
1378{
1379 return skb->head + skb->network_header;
1380}
1381
1382static inline void skb_reset_network_header(struct sk_buff *skb)
1383{
1384 skb->network_header = skb->data - skb->head;
1385}
1386
1387static inline void skb_set_network_header(struct sk_buff *skb, const int offset)
1388{
1389 skb_reset_network_header(skb);
1390 skb->network_header += offset;
1391}
1392
1393static inline unsigned char *skb_mac_header(const struct sk_buff *skb)
1394{
1395 return skb->head + skb->mac_header;
1396}
1397
1398static inline int skb_mac_header_was_set(const struct sk_buff *skb)
1399{
1400 return skb->mac_header != ~0U;
1401}
1402
1403static inline void skb_reset_mac_header(struct sk_buff *skb)
1404{
1405 skb->mac_header = skb->data - skb->head;
1406}
1407
1408static inline void skb_set_mac_header(struct sk_buff *skb, const int offset)
1409{
1410 skb_reset_mac_header(skb);
1411 skb->mac_header += offset;
1412}
1413
1414#else /* NET_SKBUFF_DATA_USES_OFFSET */
1415
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001416static inline unsigned char *skb_transport_header(const struct sk_buff *skb)
1417{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001418 return skb->transport_header;
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001419}
1420
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03001421static inline void skb_reset_transport_header(struct sk_buff *skb)
1422{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001423 skb->transport_header = skb->data;
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03001424}
1425
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -03001426static inline void skb_set_transport_header(struct sk_buff *skb,
1427 const int offset)
1428{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001429 skb->transport_header = skb->data + offset;
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -03001430}
1431
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -07001432static inline unsigned char *skb_network_header(const struct sk_buff *skb)
1433{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001434 return skb->network_header;
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -07001435}
1436
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07001437static inline void skb_reset_network_header(struct sk_buff *skb)
1438{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001439 skb->network_header = skb->data;
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07001440}
1441
Arnaldo Carvalho de Meloc14d2452007-03-11 22:39:41 -03001442static inline void skb_set_network_header(struct sk_buff *skb, const int offset)
1443{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001444 skb->network_header = skb->data + offset;
Arnaldo Carvalho de Meloc14d2452007-03-11 22:39:41 -03001445}
1446
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001447static inline unsigned char *skb_mac_header(const struct sk_buff *skb)
1448{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001449 return skb->mac_header;
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001450}
1451
1452static inline int skb_mac_header_was_set(const struct sk_buff *skb)
1453{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001454 return skb->mac_header != NULL;
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001455}
1456
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -07001457static inline void skb_reset_mac_header(struct sk_buff *skb)
1458{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001459 skb->mac_header = skb->data;
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -07001460}
1461
Arnaldo Carvalho de Melo48d49d0c2007-03-10 12:30:58 -03001462static inline void skb_set_mac_header(struct sk_buff *skb, const int offset)
1463{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001464 skb->mac_header = skb->data + offset;
Arnaldo Carvalho de Melo48d49d0c2007-03-10 12:30:58 -03001465}
Arnaldo Carvalho de Melo2e07fa92007-04-10 21:22:35 -07001466#endif /* NET_SKBUFF_DATA_USES_OFFSET */
1467
Michał Mirosław04fb4512010-12-14 15:24:08 +00001468static inline int skb_checksum_start_offset(const struct sk_buff *skb)
1469{
1470 return skb->csum_start - skb_headroom(skb);
1471}
1472
Arnaldo Carvalho de Melo2e07fa92007-04-10 21:22:35 -07001473static inline int skb_transport_offset(const struct sk_buff *skb)
1474{
1475 return skb_transport_header(skb) - skb->data;
1476}
1477
1478static inline u32 skb_network_header_len(const struct sk_buff *skb)
1479{
1480 return skb->transport_header - skb->network_header;
1481}
1482
1483static inline int skb_network_offset(const struct sk_buff *skb)
1484{
1485 return skb_network_header(skb) - skb->data;
1486}
Arnaldo Carvalho de Melo48d49d0c2007-03-10 12:30:58 -03001487
Changli Gaof9599ce2010-08-04 04:43:44 +00001488static inline int pskb_network_may_pull(struct sk_buff *skb, unsigned int len)
1489{
1490 return pskb_may_pull(skb, skb_network_offset(skb) + len);
1491}
1492
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493/*
1494 * CPUs often take a performance hit when accessing unaligned memory
1495 * locations. The actual performance hit varies, it can be small if the
1496 * hardware handles it or large if we have to take an exception and fix it
1497 * in software.
1498 *
1499 * Since an ethernet header is 14 bytes network drivers often end up with
1500 * the IP header at an unaligned offset. The IP header can be aligned by
1501 * shifting the start of the packet by 2 bytes. Drivers should do this
1502 * with:
1503 *
Tobias Klauser8660c122009-07-13 22:48:16 +00001504 * skb_reserve(skb, NET_IP_ALIGN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505 *
1506 * The downside to this alignment of the IP header is that the DMA is now
1507 * unaligned. On some architectures the cost of an unaligned DMA is high
1508 * and this cost outweighs the gains made by aligning the IP header.
Tobias Klauser8660c122009-07-13 22:48:16 +00001509 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510 * Since this trade off varies between architectures, we allow NET_IP_ALIGN
1511 * to be overridden.
1512 */
1513#ifndef NET_IP_ALIGN
1514#define NET_IP_ALIGN 2
1515#endif
1516
Anton Blanchard025be812006-03-31 02:27:06 -08001517/*
1518 * The networking layer reserves some headroom in skb data (via
1519 * dev_alloc_skb). This is used to avoid having to reallocate skb data when
1520 * the header has to grow. In the default case, if the header has to grow
David S. Millerd6301d32009-02-08 19:24:13 -08001521 * 32 bytes or less we avoid the reallocation.
Anton Blanchard025be812006-03-31 02:27:06 -08001522 *
1523 * Unfortunately this headroom changes the DMA alignment of the resulting
1524 * network packet. As for NET_IP_ALIGN, this unaligned DMA is expensive
1525 * on some architectures. An architecture can override this value,
1526 * perhaps setting it to a cacheline in size (since that will maintain
1527 * cacheline alignment of the DMA). It must be a power of 2.
1528 *
David S. Millerd6301d32009-02-08 19:24:13 -08001529 * Various parts of the networking layer expect at least 32 bytes of
Anton Blanchard025be812006-03-31 02:27:06 -08001530 * headroom, you should not reduce this.
Eric Dumazet5933dd22010-06-15 18:16:43 -07001531 *
1532 * Using max(32, L1_CACHE_BYTES) makes sense (especially with RPS)
1533 * to reduce average number of cache lines per packet.
1534 * get_rps_cpus() for example only access one 64 bytes aligned block :
Eric Dumazet18e8c132010-05-06 21:58:51 -07001535 * NET_IP_ALIGN(2) + ethernet_header(14) + IP_header(20/40) + ports(8)
Anton Blanchard025be812006-03-31 02:27:06 -08001536 */
1537#ifndef NET_SKB_PAD
Eric Dumazet5933dd22010-06-15 18:16:43 -07001538#define NET_SKB_PAD max(32, L1_CACHE_BYTES)
Anton Blanchard025be812006-03-31 02:27:06 -08001539#endif
1540
Herbert Xu3cc0e872006-06-09 16:13:38 -07001541extern int ___pskb_trim(struct sk_buff *skb, unsigned int len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542
1543static inline void __skb_trim(struct sk_buff *skb, unsigned int len)
1544{
Emmanuel Grumbachc4264f22011-05-21 19:46:09 +00001545 if (unlikely(skb_is_nonlinear(skb))) {
Herbert Xu3cc0e872006-06-09 16:13:38 -07001546 WARN_ON(1);
1547 return;
1548 }
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001549 skb->len = len;
1550 skb_set_tail_pointer(skb, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551}
1552
Ilpo Järvinen419ae742008-03-27 17:54:01 -07001553extern void skb_trim(struct sk_buff *skb, unsigned int len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554
1555static inline int __pskb_trim(struct sk_buff *skb, unsigned int len)
1556{
Herbert Xu3cc0e872006-06-09 16:13:38 -07001557 if (skb->data_len)
1558 return ___pskb_trim(skb, len);
1559 __skb_trim(skb, len);
1560 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561}
1562
1563static inline int pskb_trim(struct sk_buff *skb, unsigned int len)
1564{
1565 return (len < skb->len) ? __pskb_trim(skb, len) : 0;
1566}
1567
1568/**
Herbert Xue9fa4f72006-08-13 20:12:58 -07001569 * pskb_trim_unique - remove end from a paged unique (not cloned) buffer
1570 * @skb: buffer to alter
1571 * @len: new length
1572 *
1573 * This is identical to pskb_trim except that the caller knows that
1574 * the skb is not cloned so we should never get an error due to out-
1575 * of-memory.
1576 */
1577static inline void pskb_trim_unique(struct sk_buff *skb, unsigned int len)
1578{
1579 int err = pskb_trim(skb, len);
1580 BUG_ON(err);
1581}
1582
1583/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 * skb_orphan - orphan a buffer
1585 * @skb: buffer to orphan
1586 *
1587 * If a buffer currently has an owner then we call the owner's
1588 * destructor function and make the @skb unowned. The buffer continues
1589 * to exist but is no longer charged to its former owner.
1590 */
1591static inline void skb_orphan(struct sk_buff *skb)
1592{
1593 if (skb->destructor)
1594 skb->destructor(skb);
1595 skb->destructor = NULL;
1596 skb->sk = NULL;
1597}
1598
1599/**
1600 * __skb_queue_purge - empty a list
1601 * @list: list to empty
1602 *
1603 * Delete all buffers on an &sk_buff list. Each buffer is removed from
1604 * the list and one reference dropped. This function does not take the
1605 * list lock and the caller must hold the relevant locks to use it.
1606 */
1607extern void skb_queue_purge(struct sk_buff_head *list);
1608static inline void __skb_queue_purge(struct sk_buff_head *list)
1609{
1610 struct sk_buff *skb;
1611 while ((skb = __skb_dequeue(list)) != NULL)
1612 kfree_skb(skb);
1613}
1614
1615/**
Christoph Hellwigb4e54de2006-07-24 15:31:14 -07001616 * __dev_alloc_skb - allocate an skbuff for receiving
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 * @length: length to allocate
1618 * @gfp_mask: get_free_pages mask, passed to alloc_skb
1619 *
1620 * Allocate a new &sk_buff and assign it a usage count of one. The
1621 * buffer has unspecified headroom built in. Users should allocate
1622 * the headroom they think they need without accounting for the
1623 * built in space. The built in space is used for optimisations.
1624 *
Christoph Hellwig766ea8c2006-08-07 15:49:53 -07001625 * %NULL is returned if there is no free memory.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627static inline struct sk_buff *__dev_alloc_skb(unsigned int length,
Al Virodd0fc662005-10-07 07:46:04 +01001628 gfp_t gfp_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629{
Anton Blanchard025be812006-03-31 02:27:06 -08001630 struct sk_buff *skb = alloc_skb(length + NET_SKB_PAD, gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 if (likely(skb))
Anton Blanchard025be812006-03-31 02:27:06 -08001632 skb_reserve(skb, NET_SKB_PAD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 return skb;
1634}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635
Ilpo Järvinenf58518e2008-03-27 17:51:31 -07001636extern struct sk_buff *dev_alloc_skb(unsigned int length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637
Christoph Hellwig8af27452006-07-31 22:35:23 -07001638extern struct sk_buff *__netdev_alloc_skb(struct net_device *dev,
1639 unsigned int length, gfp_t gfp_mask);
1640
1641/**
1642 * netdev_alloc_skb - allocate an skbuff for rx on a specific device
1643 * @dev: network device to receive on
1644 * @length: length to allocate
1645 *
1646 * Allocate a new &sk_buff and assign it a usage count of one. The
1647 * buffer has unspecified headroom built in. Users should allocate
1648 * the headroom they think they need without accounting for the
1649 * built in space. The built in space is used for optimisations.
1650 *
1651 * %NULL is returned if there is no free memory. Although this function
1652 * allocates memory it can be called from an interrupt.
1653 */
1654static inline struct sk_buff *netdev_alloc_skb(struct net_device *dev,
1655 unsigned int length)
1656{
1657 return __netdev_alloc_skb(dev, length, GFP_ATOMIC);
1658}
1659
Eric Dumazet4915a0d2011-07-11 20:08:34 -07001660static inline struct sk_buff *__netdev_alloc_skb_ip_align(struct net_device *dev,
1661 unsigned int length, gfp_t gfp)
Eric Dumazet61321bb2009-10-07 17:11:23 +00001662{
Eric Dumazet4915a0d2011-07-11 20:08:34 -07001663 struct sk_buff *skb = __netdev_alloc_skb(dev, length + NET_IP_ALIGN, gfp);
Eric Dumazet61321bb2009-10-07 17:11:23 +00001664
1665 if (NET_IP_ALIGN && skb)
1666 skb_reserve(skb, NET_IP_ALIGN);
1667 return skb;
1668}
1669
Eric Dumazet4915a0d2011-07-11 20:08:34 -07001670static inline struct sk_buff *netdev_alloc_skb_ip_align(struct net_device *dev,
1671 unsigned int length)
1672{
1673 return __netdev_alloc_skb_ip_align(dev, length, GFP_ATOMIC);
1674}
1675
Eric Dumazet564824b2010-10-11 19:05:25 +00001676/**
Ian Campbell131ea662011-08-19 06:25:00 +00001677 * skb_frag_page - retrieve the page refered to by a paged fragment
1678 * @frag: the paged fragment
1679 *
1680 * Returns the &struct page associated with @frag.
1681 */
1682static inline struct page *skb_frag_page(const skb_frag_t *frag)
1683{
Ian Campbella8605c62011-10-19 23:01:49 +00001684 return frag->page.p;
Ian Campbell131ea662011-08-19 06:25:00 +00001685}
1686
1687/**
1688 * __skb_frag_ref - take an addition reference on a paged fragment.
1689 * @frag: the paged fragment
1690 *
1691 * Takes an additional reference on the paged fragment @frag.
1692 */
1693static inline void __skb_frag_ref(skb_frag_t *frag)
1694{
1695 get_page(skb_frag_page(frag));
1696}
1697
1698/**
1699 * skb_frag_ref - take an addition reference on a paged fragment of an skb.
1700 * @skb: the buffer
1701 * @f: the fragment offset.
1702 *
1703 * Takes an additional reference on the @f'th paged fragment of @skb.
1704 */
1705static inline void skb_frag_ref(struct sk_buff *skb, int f)
1706{
1707 __skb_frag_ref(&skb_shinfo(skb)->frags[f]);
1708}
1709
1710/**
1711 * __skb_frag_unref - release a reference on a paged fragment.
1712 * @frag: the paged fragment
1713 *
1714 * Releases a reference on the paged fragment @frag.
1715 */
1716static inline void __skb_frag_unref(skb_frag_t *frag)
1717{
1718 put_page(skb_frag_page(frag));
1719}
1720
1721/**
1722 * skb_frag_unref - release a reference on a paged fragment of an skb.
1723 * @skb: the buffer
1724 * @f: the fragment offset
1725 *
1726 * Releases a reference on the @f'th paged fragment of @skb.
1727 */
1728static inline void skb_frag_unref(struct sk_buff *skb, int f)
1729{
1730 __skb_frag_unref(&skb_shinfo(skb)->frags[f]);
1731}
1732
1733/**
1734 * skb_frag_address - gets the address of the data contained in a paged fragment
1735 * @frag: the paged fragment buffer
1736 *
1737 * Returns the address of the data within @frag. The page must already
1738 * be mapped.
1739 */
1740static inline void *skb_frag_address(const skb_frag_t *frag)
1741{
1742 return page_address(skb_frag_page(frag)) + frag->page_offset;
1743}
1744
1745/**
1746 * skb_frag_address_safe - gets the address of the data contained in a paged fragment
1747 * @frag: the paged fragment buffer
1748 *
1749 * Returns the address of the data within @frag. Checks that the page
1750 * is mapped and returns %NULL otherwise.
1751 */
1752static inline void *skb_frag_address_safe(const skb_frag_t *frag)
1753{
1754 void *ptr = page_address(skb_frag_page(frag));
1755 if (unlikely(!ptr))
1756 return NULL;
1757
1758 return ptr + frag->page_offset;
1759}
1760
1761/**
1762 * __skb_frag_set_page - sets the page contained in a paged fragment
1763 * @frag: the paged fragment
1764 * @page: the page to set
1765 *
1766 * Sets the fragment @frag to contain @page.
1767 */
1768static inline void __skb_frag_set_page(skb_frag_t *frag, struct page *page)
1769{
Ian Campbella8605c62011-10-19 23:01:49 +00001770 frag->page.p = page;
Ian Campbell131ea662011-08-19 06:25:00 +00001771}
1772
1773/**
1774 * skb_frag_set_page - sets the page contained in a paged fragment of an skb
1775 * @skb: the buffer
1776 * @f: the fragment offset
1777 * @page: the page to set
1778 *
1779 * Sets the @f'th fragment of @skb to contain @page.
1780 */
1781static inline void skb_frag_set_page(struct sk_buff *skb, int f,
1782 struct page *page)
1783{
1784 __skb_frag_set_page(&skb_shinfo(skb)->frags[f], page);
1785}
1786
1787/**
1788 * skb_frag_dma_map - maps a paged fragment via the DMA API
Marcos Paulo de Souzaf83347d2011-10-31 15:11:45 +00001789 * @dev: the device to map the fragment to
Ian Campbell131ea662011-08-19 06:25:00 +00001790 * @frag: the paged fragment to map
1791 * @offset: the offset within the fragment (starting at the
1792 * fragment's own offset)
1793 * @size: the number of bytes to map
Marcos Paulo de Souzaf83347d2011-10-31 15:11:45 +00001794 * @dir: the direction of the mapping (%PCI_DMA_*)
Ian Campbell131ea662011-08-19 06:25:00 +00001795 *
1796 * Maps the page associated with @frag to @device.
1797 */
1798static inline dma_addr_t skb_frag_dma_map(struct device *dev,
1799 const skb_frag_t *frag,
1800 size_t offset, size_t size,
1801 enum dma_data_direction dir)
1802{
1803 return dma_map_page(dev, skb_frag_page(frag),
1804 frag->page_offset + offset, size, dir);
1805}
1806
Eric Dumazet117632e2011-12-03 21:39:53 +00001807static inline struct sk_buff *pskb_copy(struct sk_buff *skb,
1808 gfp_t gfp_mask)
1809{
1810 return __pskb_copy(skb, skb_headroom(skb), gfp_mask);
1811}
1812
Ian Campbell131ea662011-08-19 06:25:00 +00001813/**
Patrick McHardy334a8132007-06-25 04:35:20 -07001814 * skb_clone_writable - is the header of a clone writable
1815 * @skb: buffer to check
1816 * @len: length up to which to write
1817 *
1818 * Returns true if modifying the header part of the cloned buffer
1819 * does not requires the data to be copied.
1820 */
Eric Dumazet05bdd2f2011-10-20 17:45:43 -04001821static inline int skb_clone_writable(const struct sk_buff *skb, unsigned int len)
Patrick McHardy334a8132007-06-25 04:35:20 -07001822{
1823 return !skb_header_cloned(skb) &&
1824 skb_headroom(skb) + len <= skb->hdr_len;
1825}
1826
Herbert Xud9cc2042007-09-16 16:21:16 -07001827static inline int __skb_cow(struct sk_buff *skb, unsigned int headroom,
1828 int cloned)
1829{
1830 int delta = 0;
1831
1832 if (headroom < NET_SKB_PAD)
1833 headroom = NET_SKB_PAD;
1834 if (headroom > skb_headroom(skb))
1835 delta = headroom - skb_headroom(skb);
1836
1837 if (delta || cloned)
1838 return pskb_expand_head(skb, ALIGN(delta, NET_SKB_PAD), 0,
1839 GFP_ATOMIC);
1840 return 0;
1841}
1842
Patrick McHardy334a8132007-06-25 04:35:20 -07001843/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844 * skb_cow - copy header of skb when it is required
1845 * @skb: buffer to cow
1846 * @headroom: needed headroom
1847 *
1848 * If the skb passed lacks sufficient headroom or its data part
1849 * is shared, data is reallocated. If reallocation fails, an error
1850 * is returned and original skb is not changed.
1851 *
1852 * The result is skb with writable area skb->head...skb->tail
1853 * and at least @headroom of space at head.
1854 */
1855static inline int skb_cow(struct sk_buff *skb, unsigned int headroom)
1856{
Herbert Xud9cc2042007-09-16 16:21:16 -07001857 return __skb_cow(skb, headroom, skb_cloned(skb));
1858}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859
Herbert Xud9cc2042007-09-16 16:21:16 -07001860/**
1861 * skb_cow_head - skb_cow but only making the head writable
1862 * @skb: buffer to cow
1863 * @headroom: needed headroom
1864 *
1865 * This function is identical to skb_cow except that we replace the
1866 * skb_cloned check by skb_header_cloned. It should be used when
1867 * you only need to push on some header and do not need to modify
1868 * the data.
1869 */
1870static inline int skb_cow_head(struct sk_buff *skb, unsigned int headroom)
1871{
1872 return __skb_cow(skb, headroom, skb_header_cloned(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873}
1874
1875/**
1876 * skb_padto - pad an skbuff up to a minimal size
1877 * @skb: buffer to pad
1878 * @len: minimal length
1879 *
1880 * Pads up a buffer to ensure the trailing bytes exist and are
1881 * blanked. If the buffer already contains sufficient data it
Herbert Xu5b057c62006-06-23 02:06:41 -07001882 * is untouched. Otherwise it is extended. Returns zero on
1883 * success. The skb is freed on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884 */
1885
Herbert Xu5b057c62006-06-23 02:06:41 -07001886static inline int skb_padto(struct sk_buff *skb, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887{
1888 unsigned int size = skb->len;
1889 if (likely(size >= len))
Herbert Xu5b057c62006-06-23 02:06:41 -07001890 return 0;
Gerrit Renker987c4022008-08-11 18:17:17 -07001891 return skb_pad(skb, len - size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892}
1893
1894static inline int skb_add_data(struct sk_buff *skb,
1895 char __user *from, int copy)
1896{
1897 const int off = skb->len;
1898
1899 if (skb->ip_summed == CHECKSUM_NONE) {
1900 int err = 0;
Al Viro50842052006-11-14 21:36:34 -08001901 __wsum csum = csum_and_copy_from_user(from, skb_put(skb, copy),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 copy, 0, &err);
1903 if (!err) {
1904 skb->csum = csum_block_add(skb->csum, csum, off);
1905 return 0;
1906 }
1907 } else if (!copy_from_user(skb_put(skb, copy), from, copy))
1908 return 0;
1909
1910 __skb_trim(skb, off);
1911 return -EFAULT;
1912}
1913
1914static inline int skb_can_coalesce(struct sk_buff *skb, int i,
Ian Campbellea2ab692011-08-22 23:44:58 +00001915 const struct page *page, int off)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916{
1917 if (i) {
Eric Dumazet9e903e02011-10-18 21:00:24 +00001918 const struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i - 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919
Ian Campbellea2ab692011-08-22 23:44:58 +00001920 return page == skb_frag_page(frag) &&
Eric Dumazet9e903e02011-10-18 21:00:24 +00001921 off == frag->page_offset + skb_frag_size(frag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922 }
1923 return 0;
1924}
1925
Herbert Xu364c6ba2006-06-09 16:10:40 -07001926static inline int __skb_linearize(struct sk_buff *skb)
1927{
1928 return __pskb_pull_tail(skb, skb->data_len) ? 0 : -ENOMEM;
1929}
1930
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931/**
1932 * skb_linearize - convert paged skb to linear one
1933 * @skb: buffer to linarize
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934 *
1935 * If there is no free memory -ENOMEM is returned, otherwise zero
1936 * is returned and the old skb data released.
1937 */
Herbert Xu364c6ba2006-06-09 16:10:40 -07001938static inline int skb_linearize(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939{
Herbert Xu364c6ba2006-06-09 16:10:40 -07001940 return skb_is_nonlinear(skb) ? __skb_linearize(skb) : 0;
1941}
1942
1943/**
1944 * skb_linearize_cow - make sure skb is linear and writable
1945 * @skb: buffer to process
1946 *
1947 * If there is no free memory -ENOMEM is returned, otherwise zero
1948 * is returned and the old skb data released.
1949 */
1950static inline int skb_linearize_cow(struct sk_buff *skb)
1951{
1952 return skb_is_nonlinear(skb) || skb_cloned(skb) ?
1953 __skb_linearize(skb) : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954}
1955
1956/**
1957 * skb_postpull_rcsum - update checksum for received skb after pull
1958 * @skb: buffer to update
1959 * @start: start of data before pull
1960 * @len: length of data pulled
1961 *
1962 * After doing a pull on a received packet, you need to call this to
Patrick McHardy84fa7932006-08-29 16:44:56 -07001963 * update the CHECKSUM_COMPLETE checksum, or set ip_summed to
1964 * CHECKSUM_NONE so that it can be recomputed from scratch.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965 */
1966
1967static inline void skb_postpull_rcsum(struct sk_buff *skb,
Herbert Xucbb042f2006-03-20 22:43:56 -08001968 const void *start, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969{
Patrick McHardy84fa7932006-08-29 16:44:56 -07001970 if (skb->ip_summed == CHECKSUM_COMPLETE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971 skb->csum = csum_sub(skb->csum, csum_partial(start, len, 0));
1972}
1973
Herbert Xucbb042f2006-03-20 22:43:56 -08001974unsigned char *skb_pull_rcsum(struct sk_buff *skb, unsigned int len);
1975
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976/**
1977 * pskb_trim_rcsum - trim received skb and update checksum
1978 * @skb: buffer to trim
1979 * @len: new length
1980 *
1981 * This is exactly the same as pskb_trim except that it ensures the
1982 * checksum of received packets are still valid after the operation.
1983 */
1984
1985static inline int pskb_trim_rcsum(struct sk_buff *skb, unsigned int len)
1986{
Stephen Hemminger0e4e4222005-09-08 12:32:03 -07001987 if (likely(len >= skb->len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988 return 0;
Patrick McHardy84fa7932006-08-29 16:44:56 -07001989 if (skb->ip_summed == CHECKSUM_COMPLETE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990 skb->ip_summed = CHECKSUM_NONE;
1991 return __pskb_trim(skb, len);
1992}
1993
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994#define skb_queue_walk(queue, skb) \
1995 for (skb = (queue)->next; \
Linus Torvaldsa1e48912011-05-22 16:51:43 -07001996 skb != (struct sk_buff *)(queue); \
Linus Torvalds1da177e2005-04-16 15:20:36 -07001997 skb = skb->next)
1998
James Chapman46f89142007-04-30 00:07:31 -07001999#define skb_queue_walk_safe(queue, skb, tmp) \
2000 for (skb = (queue)->next, tmp = skb->next; \
2001 skb != (struct sk_buff *)(queue); \
2002 skb = tmp, tmp = skb->next)
2003
David S. Miller1164f522008-09-23 00:49:44 -07002004#define skb_queue_walk_from(queue, skb) \
Linus Torvaldsa1e48912011-05-22 16:51:43 -07002005 for (; skb != (struct sk_buff *)(queue); \
David S. Miller1164f522008-09-23 00:49:44 -07002006 skb = skb->next)
2007
2008#define skb_queue_walk_from_safe(queue, skb, tmp) \
2009 for (tmp = skb->next; \
2010 skb != (struct sk_buff *)(queue); \
2011 skb = tmp, tmp = skb->next)
2012
Stephen Hemminger300ce172005-10-30 13:47:34 -08002013#define skb_queue_reverse_walk(queue, skb) \
2014 for (skb = (queue)->prev; \
Linus Torvaldsa1e48912011-05-22 16:51:43 -07002015 skb != (struct sk_buff *)(queue); \
Stephen Hemminger300ce172005-10-30 13:47:34 -08002016 skb = skb->prev)
2017
David S. Miller686a2952011-01-20 22:47:32 -08002018#define skb_queue_reverse_walk_safe(queue, skb, tmp) \
2019 for (skb = (queue)->prev, tmp = skb->prev; \
2020 skb != (struct sk_buff *)(queue); \
2021 skb = tmp, tmp = skb->prev)
2022
2023#define skb_queue_reverse_walk_from_safe(queue, skb, tmp) \
2024 for (tmp = skb->prev; \
2025 skb != (struct sk_buff *)(queue); \
2026 skb = tmp, tmp = skb->prev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027
David S. Miller21dc3302010-08-23 00:13:46 -07002028static inline bool skb_has_frag_list(const struct sk_buff *skb)
David S. Milleree039872009-06-09 00:17:13 -07002029{
2030 return skb_shinfo(skb)->frag_list != NULL;
2031}
2032
2033static inline void skb_frag_list_init(struct sk_buff *skb)
2034{
2035 skb_shinfo(skb)->frag_list = NULL;
2036}
2037
2038static inline void skb_frag_add_head(struct sk_buff *skb, struct sk_buff *frag)
2039{
2040 frag->next = skb_shinfo(skb)->frag_list;
2041 skb_shinfo(skb)->frag_list = frag;
2042}
2043
2044#define skb_walk_frags(skb, iter) \
2045 for (iter = skb_shinfo(skb)->frag_list; iter; iter = iter->next)
2046
Herbert Xua59322b2007-12-05 01:53:40 -08002047extern struct sk_buff *__skb_recv_datagram(struct sock *sk, unsigned flags,
2048 int *peeked, int *err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049extern struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags,
2050 int noblock, int *err);
2051extern unsigned int datagram_poll(struct file *file, struct socket *sock,
2052 struct poll_table_struct *wait);
2053extern int skb_copy_datagram_iovec(const struct sk_buff *from,
2054 int offset, struct iovec *to,
2055 int size);
Herbert Xufb286bb2005-11-10 13:01:24 -08002056extern int skb_copy_and_csum_datagram_iovec(struct sk_buff *skb,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002057 int hlen,
2058 struct iovec *iov);
Rusty Russelldb543c12008-08-15 15:13:53 -07002059extern int skb_copy_datagram_from_iovec(struct sk_buff *skb,
2060 int offset,
Michael S. Tsirkin6f26c9a2009-04-20 01:26:11 +00002061 const struct iovec *from,
2062 int from_offset,
Rusty Russelldb543c12008-08-15 15:13:53 -07002063 int len);
Michael S. Tsirkin0a1ec072009-04-20 01:25:46 +00002064extern int skb_copy_datagram_const_iovec(const struct sk_buff *from,
2065 int offset,
2066 const struct iovec *to,
2067 int to_offset,
2068 int size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002069extern void skb_free_datagram(struct sock *sk, struct sk_buff *skb);
Eric Dumazet9d410c72009-10-30 05:03:53 +00002070extern void skb_free_datagram_locked(struct sock *sk,
2071 struct sk_buff *skb);
Herbert Xu27ab2562007-12-05 01:51:58 -08002072extern int skb_kill_datagram(struct sock *sk, struct sk_buff *skb,
Herbert Xu3305b802005-12-13 23:16:37 -08002073 unsigned int flags);
Al Viro2bbbc862006-11-14 21:37:14 -08002074extern __wsum skb_checksum(const struct sk_buff *skb, int offset,
2075 int len, __wsum csum);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076extern int skb_copy_bits(const struct sk_buff *skb, int offset,
2077 void *to, int len);
Stephen Hemminger0c6fcc82007-04-20 16:40:01 -07002078extern int skb_store_bits(struct sk_buff *skb, int offset,
2079 const void *from, int len);
Al Viro81d77662006-11-14 21:37:33 -08002080extern __wsum skb_copy_and_csum_bits(const struct sk_buff *skb,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081 int offset, u8 *to, int len,
Al Viro81d77662006-11-14 21:37:33 -08002082 __wsum csum);
Jens Axboe9c55e012007-11-06 23:30:13 -08002083extern int skb_splice_bits(struct sk_buff *skb,
2084 unsigned int offset,
2085 struct pipe_inode_info *pipe,
2086 unsigned int len,
2087 unsigned int flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088extern void skb_copy_and_csum_dev(const struct sk_buff *skb, u8 *to);
2089extern void skb_split(struct sk_buff *skb,
2090 struct sk_buff *skb1, const u32 len);
Ilpo Järvinen832d11c2008-11-24 21:20:15 -08002091extern int skb_shift(struct sk_buff *tgt, struct sk_buff *skb,
2092 int shiftlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093
Michał Mirosławc8f44af2011-11-15 15:29:55 +00002094extern struct sk_buff *skb_segment(struct sk_buff *skb,
2095 netdev_features_t features);
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03002096
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097static inline void *skb_header_pointer(const struct sk_buff *skb, int offset,
2098 int len, void *buffer)
2099{
2100 int hlen = skb_headlen(skb);
2101
Patrick McHardy55820ee2005-07-05 14:08:10 -07002102 if (hlen - offset >= len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103 return skb->data + offset;
2104
2105 if (skb_copy_bits(skb, offset, buffer, len) < 0)
2106 return NULL;
2107
2108 return buffer;
2109}
2110
Arnaldo Carvalho de Melod626f622007-03-27 18:55:52 -03002111static inline void skb_copy_from_linear_data(const struct sk_buff *skb,
2112 void *to,
2113 const unsigned int len)
2114{
2115 memcpy(to, skb->data, len);
2116}
2117
2118static inline void skb_copy_from_linear_data_offset(const struct sk_buff *skb,
2119 const int offset, void *to,
2120 const unsigned int len)
2121{
2122 memcpy(to, skb->data + offset, len);
2123}
2124
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03002125static inline void skb_copy_to_linear_data(struct sk_buff *skb,
2126 const void *from,
2127 const unsigned int len)
2128{
2129 memcpy(skb->data, from, len);
2130}
2131
2132static inline void skb_copy_to_linear_data_offset(struct sk_buff *skb,
2133 const int offset,
2134 const void *from,
2135 const unsigned int len)
2136{
2137 memcpy(skb->data + offset, from, len);
2138}
2139
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140extern void skb_init(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002141
Patrick Ohlyac45f602009-02-12 05:03:37 +00002142static inline ktime_t skb_get_ktime(const struct sk_buff *skb)
2143{
2144 return skb->tstamp;
2145}
2146
Patrick McHardya61bbcf2005-08-14 17:24:31 -07002147/**
2148 * skb_get_timestamp - get timestamp from a skb
2149 * @skb: skb to get stamp from
2150 * @stamp: pointer to struct timeval to store stamp in
2151 *
2152 * Timestamps are stored in the skb as offsets to a base timestamp.
2153 * This function converts the offset back to a struct timeval and stores
2154 * it in stamp.
2155 */
Patrick Ohlyac45f602009-02-12 05:03:37 +00002156static inline void skb_get_timestamp(const struct sk_buff *skb,
2157 struct timeval *stamp)
Patrick McHardya61bbcf2005-08-14 17:24:31 -07002158{
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07002159 *stamp = ktime_to_timeval(skb->tstamp);
Patrick McHardya61bbcf2005-08-14 17:24:31 -07002160}
2161
Patrick Ohlyac45f602009-02-12 05:03:37 +00002162static inline void skb_get_timestampns(const struct sk_buff *skb,
2163 struct timespec *stamp)
2164{
2165 *stamp = ktime_to_timespec(skb->tstamp);
2166}
2167
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07002168static inline void __net_timestamp(struct sk_buff *skb)
Patrick McHardya61bbcf2005-08-14 17:24:31 -07002169{
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07002170 skb->tstamp = ktime_get_real();
Patrick McHardya61bbcf2005-08-14 17:24:31 -07002171}
2172
Stephen Hemminger164891a2007-04-23 22:26:16 -07002173static inline ktime_t net_timedelta(ktime_t t)
2174{
2175 return ktime_sub(ktime_get_real(), t);
2176}
2177
Ilpo Järvinenb9ce2042007-06-15 15:08:43 -07002178static inline ktime_t net_invalid_timestamp(void)
2179{
2180 return ktime_set(0, 0);
2181}
Patrick McHardya61bbcf2005-08-14 17:24:31 -07002182
Richard Cochranc1f19b52010-07-17 08:49:36 +00002183extern void skb_timestamping_init(void);
2184
2185#ifdef CONFIG_NETWORK_PHY_TIMESTAMPING
2186
2187extern void skb_clone_tx_timestamp(struct sk_buff *skb);
2188extern bool skb_defer_rx_timestamp(struct sk_buff *skb);
2189
2190#else /* CONFIG_NETWORK_PHY_TIMESTAMPING */
2191
2192static inline void skb_clone_tx_timestamp(struct sk_buff *skb)
2193{
2194}
2195
2196static inline bool skb_defer_rx_timestamp(struct sk_buff *skb)
2197{
2198 return false;
2199}
2200
2201#endif /* !CONFIG_NETWORK_PHY_TIMESTAMPING */
2202
2203/**
2204 * skb_complete_tx_timestamp() - deliver cloned skb with tx timestamps
2205 *
Richard Cochranda92b192011-10-21 00:49:15 +00002206 * PHY drivers may accept clones of transmitted packets for
2207 * timestamping via their phy_driver.txtstamp method. These drivers
2208 * must call this function to return the skb back to the stack, with
2209 * or without a timestamp.
2210 *
Richard Cochranc1f19b52010-07-17 08:49:36 +00002211 * @skb: clone of the the original outgoing packet
Richard Cochranda92b192011-10-21 00:49:15 +00002212 * @hwtstamps: hardware time stamps, may be NULL if not available
Richard Cochranc1f19b52010-07-17 08:49:36 +00002213 *
2214 */
2215void skb_complete_tx_timestamp(struct sk_buff *skb,
2216 struct skb_shared_hwtstamps *hwtstamps);
2217
Patrick Ohlyac45f602009-02-12 05:03:37 +00002218/**
2219 * skb_tstamp_tx - queue clone of skb with send time stamps
2220 * @orig_skb: the original outgoing packet
2221 * @hwtstamps: hardware time stamps, may be NULL if not available
2222 *
2223 * If the skb has a socket associated, then this function clones the
2224 * skb (thus sharing the actual data and optional structures), stores
2225 * the optional hardware time stamping information (if non NULL) or
2226 * generates a software time stamp (otherwise), then queues the clone
2227 * to the error queue of the socket. Errors are silently ignored.
2228 */
2229extern void skb_tstamp_tx(struct sk_buff *orig_skb,
2230 struct skb_shared_hwtstamps *hwtstamps);
2231
Richard Cochran4507a712010-07-17 08:48:28 +00002232static inline void sw_tx_timestamp(struct sk_buff *skb)
2233{
Oliver Hartkopp2244d072010-08-17 08:59:14 +00002234 if (skb_shinfo(skb)->tx_flags & SKBTX_SW_TSTAMP &&
2235 !(skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS))
Richard Cochran4507a712010-07-17 08:48:28 +00002236 skb_tstamp_tx(skb, NULL);
2237}
2238
2239/**
2240 * skb_tx_timestamp() - Driver hook for transmit timestamping
2241 *
2242 * Ethernet MAC Drivers should call this function in their hard_xmit()
Richard Cochran4ff75b72011-06-19 03:31:39 +00002243 * function immediately before giving the sk_buff to the MAC hardware.
Richard Cochran4507a712010-07-17 08:48:28 +00002244 *
2245 * @skb: A socket buffer.
2246 */
2247static inline void skb_tx_timestamp(struct sk_buff *skb)
2248{
Richard Cochranc1f19b52010-07-17 08:49:36 +00002249 skb_clone_tx_timestamp(skb);
Richard Cochran4507a712010-07-17 08:48:28 +00002250 sw_tx_timestamp(skb);
2251}
2252
Johannes Berg6e3e9392011-11-09 10:15:42 +01002253/**
2254 * skb_complete_wifi_ack - deliver skb with wifi status
2255 *
2256 * @skb: the original outgoing packet
2257 * @acked: ack status
2258 *
2259 */
2260void skb_complete_wifi_ack(struct sk_buff *skb, bool acked);
2261
Herbert Xu759e5d02007-03-25 20:10:56 -07002262extern __sum16 __skb_checksum_complete_head(struct sk_buff *skb, int len);
Al Virob51655b2006-11-14 21:40:42 -08002263extern __sum16 __skb_checksum_complete(struct sk_buff *skb);
Herbert Xufb286bb2005-11-10 13:01:24 -08002264
Herbert Xu60476372007-04-09 11:59:39 -07002265static inline int skb_csum_unnecessary(const struct sk_buff *skb)
2266{
2267 return skb->ip_summed & CHECKSUM_UNNECESSARY;
2268}
2269
Herbert Xufb286bb2005-11-10 13:01:24 -08002270/**
2271 * skb_checksum_complete - Calculate checksum of an entire packet
2272 * @skb: packet to process
2273 *
2274 * This function calculates the checksum over the entire packet plus
2275 * the value of skb->csum. The latter can be used to supply the
2276 * checksum of a pseudo header as used by TCP/UDP. It returns the
2277 * checksum.
2278 *
2279 * For protocols that contain complete checksums such as ICMP/TCP/UDP,
2280 * this function can be used to verify that checksum on received
2281 * packets. In that case the function should return zero if the
2282 * checksum is correct. In particular, this function will return zero
2283 * if skb->ip_summed is CHECKSUM_UNNECESSARY which indicates that the
2284 * hardware has already verified the correctness of the checksum.
2285 */
Al Viro4381ca32007-07-15 21:00:11 +01002286static inline __sum16 skb_checksum_complete(struct sk_buff *skb)
Herbert Xufb286bb2005-11-10 13:01:24 -08002287{
Herbert Xu60476372007-04-09 11:59:39 -07002288 return skb_csum_unnecessary(skb) ?
2289 0 : __skb_checksum_complete(skb);
Herbert Xufb286bb2005-11-10 13:01:24 -08002290}
2291
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -07002292#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
Yasuyuki Kozakaide6e05c2007-03-23 11:17:27 -07002293extern void nf_conntrack_destroy(struct nf_conntrack *nfct);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294static inline void nf_conntrack_put(struct nf_conntrack *nfct)
2295{
2296 if (nfct && atomic_dec_and_test(&nfct->use))
Yasuyuki Kozakaide6e05c2007-03-23 11:17:27 -07002297 nf_conntrack_destroy(nfct);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002298}
2299static inline void nf_conntrack_get(struct nf_conntrack *nfct)
2300{
2301 if (nfct)
2302 atomic_inc(&nfct->use);
2303}
KOVACS Krisztian2fc72c72011-01-12 20:25:08 +01002304#endif
2305#ifdef NET_SKBUFF_NF_DEFRAG_NEEDED
Yasuyuki Kozakai9fb9cbb2005-11-09 16:38:16 -08002306static inline void nf_conntrack_get_reasm(struct sk_buff *skb)
2307{
2308 if (skb)
2309 atomic_inc(&skb->users);
2310}
2311static inline void nf_conntrack_put_reasm(struct sk_buff *skb)
2312{
2313 if (skb)
2314 kfree_skb(skb);
2315}
2316#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002317#ifdef CONFIG_BRIDGE_NETFILTER
2318static inline void nf_bridge_put(struct nf_bridge_info *nf_bridge)
2319{
2320 if (nf_bridge && atomic_dec_and_test(&nf_bridge->use))
2321 kfree(nf_bridge);
2322}
2323static inline void nf_bridge_get(struct nf_bridge_info *nf_bridge)
2324{
2325 if (nf_bridge)
2326 atomic_inc(&nf_bridge->use);
2327}
2328#endif /* CONFIG_BRIDGE_NETFILTER */
Patrick McHardya193a4a2006-03-20 19:23:05 -08002329static inline void nf_reset(struct sk_buff *skb)
2330{
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -07002331#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
Patrick McHardya193a4a2006-03-20 19:23:05 -08002332 nf_conntrack_put(skb->nfct);
2333 skb->nfct = NULL;
KOVACS Krisztian2fc72c72011-01-12 20:25:08 +01002334#endif
2335#ifdef NET_SKBUFF_NF_DEFRAG_NEEDED
Patrick McHardya193a4a2006-03-20 19:23:05 -08002336 nf_conntrack_put_reasm(skb->nfct_reasm);
2337 skb->nfct_reasm = NULL;
2338#endif
2339#ifdef CONFIG_BRIDGE_NETFILTER
2340 nf_bridge_put(skb->nf_bridge);
2341 skb->nf_bridge = NULL;
2342#endif
2343}
2344
Yasuyuki Kozakaiedda5532007-03-14 16:43:37 -07002345/* Note: This doesn't put any conntrack and bridge info in dst. */
2346static inline void __nf_copy(struct sk_buff *dst, const struct sk_buff *src)
2347{
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -07002348#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
Yasuyuki Kozakaiedda5532007-03-14 16:43:37 -07002349 dst->nfct = src->nfct;
2350 nf_conntrack_get(src->nfct);
2351 dst->nfctinfo = src->nfctinfo;
KOVACS Krisztian2fc72c72011-01-12 20:25:08 +01002352#endif
2353#ifdef NET_SKBUFF_NF_DEFRAG_NEEDED
Yasuyuki Kozakaiedda5532007-03-14 16:43:37 -07002354 dst->nfct_reasm = src->nfct_reasm;
2355 nf_conntrack_get_reasm(src->nfct_reasm);
2356#endif
2357#ifdef CONFIG_BRIDGE_NETFILTER
2358 dst->nf_bridge = src->nf_bridge;
2359 nf_bridge_get(src->nf_bridge);
2360#endif
2361}
2362
Yasuyuki Kozakaie7ac05f2007-03-14 16:44:01 -07002363static inline void nf_copy(struct sk_buff *dst, const struct sk_buff *src)
2364{
Yasuyuki Kozakaie7ac05f2007-03-14 16:44:01 -07002365#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -07002366 nf_conntrack_put(dst->nfct);
KOVACS Krisztian2fc72c72011-01-12 20:25:08 +01002367#endif
2368#ifdef NET_SKBUFF_NF_DEFRAG_NEEDED
Yasuyuki Kozakaie7ac05f2007-03-14 16:44:01 -07002369 nf_conntrack_put_reasm(dst->nfct_reasm);
2370#endif
2371#ifdef CONFIG_BRIDGE_NETFILTER
2372 nf_bridge_put(dst->nf_bridge);
2373#endif
2374 __nf_copy(dst, src);
2375}
2376
James Morris984bc162006-06-09 00:29:17 -07002377#ifdef CONFIG_NETWORK_SECMARK
2378static inline void skb_copy_secmark(struct sk_buff *to, const struct sk_buff *from)
2379{
2380 to->secmark = from->secmark;
2381}
2382
2383static inline void skb_init_secmark(struct sk_buff *skb)
2384{
2385 skb->secmark = 0;
2386}
2387#else
2388static inline void skb_copy_secmark(struct sk_buff *to, const struct sk_buff *from)
2389{ }
2390
2391static inline void skb_init_secmark(struct sk_buff *skb)
2392{ }
2393#endif
2394
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002395static inline void skb_set_queue_mapping(struct sk_buff *skb, u16 queue_mapping)
2396{
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002397 skb->queue_mapping = queue_mapping;
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002398}
2399
Stephen Hemminger92477442009-03-21 13:39:26 -07002400static inline u16 skb_get_queue_mapping(const struct sk_buff *skb)
Pavel Emelyanov4e3ab472007-10-21 17:01:29 -07002401{
Pavel Emelyanov4e3ab472007-10-21 17:01:29 -07002402 return skb->queue_mapping;
Pavel Emelyanov4e3ab472007-10-21 17:01:29 -07002403}
2404
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002405static inline void skb_copy_queue_mapping(struct sk_buff *to, const struct sk_buff *from)
2406{
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002407 to->queue_mapping = from->queue_mapping;
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07002408}
2409
David S. Millerd5a9e242009-01-27 16:22:11 -08002410static inline void skb_record_rx_queue(struct sk_buff *skb, u16 rx_queue)
2411{
2412 skb->queue_mapping = rx_queue + 1;
2413}
2414
Stephen Hemminger92477442009-03-21 13:39:26 -07002415static inline u16 skb_get_rx_queue(const struct sk_buff *skb)
David S. Millerd5a9e242009-01-27 16:22:11 -08002416{
2417 return skb->queue_mapping - 1;
2418}
2419
Stephen Hemminger92477442009-03-21 13:39:26 -07002420static inline bool skb_rx_queue_recorded(const struct sk_buff *skb)
David S. Millerd5a9e242009-01-27 16:22:11 -08002421{
Eric Dumazeta02cec22010-09-22 20:43:57 +00002422 return skb->queue_mapping != 0;
David S. Millerd5a9e242009-01-27 16:22:11 -08002423}
2424
Vladislav Zolotarova3d22a62010-12-13 06:27:10 +00002425extern u16 __skb_tx_hash(const struct net_device *dev,
2426 const struct sk_buff *skb,
2427 unsigned int num_tx_queues);
Stephen Hemminger92477442009-03-21 13:39:26 -07002428
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -07002429#ifdef CONFIG_XFRM
2430static inline struct sec_path *skb_sec_path(struct sk_buff *skb)
2431{
2432 return skb->sp;
2433}
2434#else
2435static inline struct sec_path *skb_sec_path(struct sk_buff *skb)
2436{
2437 return NULL;
2438}
2439#endif
2440
Herbert Xu89114af2006-07-08 13:34:32 -07002441static inline int skb_is_gso(const struct sk_buff *skb)
2442{
2443 return skb_shinfo(skb)->gso_size;
2444}
2445
Brice Goglineabd7e32007-10-13 12:33:32 +02002446static inline int skb_is_gso_v6(const struct sk_buff *skb)
2447{
2448 return skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6;
2449}
2450
Ben Hutchings4497b072008-06-19 16:22:28 -07002451extern void __skb_warn_lro_forwarding(const struct sk_buff *skb);
2452
2453static inline bool skb_warn_if_lro(const struct sk_buff *skb)
2454{
2455 /* LRO sets gso_size but not gso_type, whereas if GSO is really
2456 * wanted then gso_type will be set. */
Eric Dumazet05bdd2f2011-10-20 17:45:43 -04002457 const struct skb_shared_info *shinfo = skb_shinfo(skb);
2458
Alexander Duyckb78462e2010-06-02 12:24:37 +00002459 if (skb_is_nonlinear(skb) && shinfo->gso_size != 0 &&
2460 unlikely(shinfo->gso_type == 0)) {
Ben Hutchings4497b072008-06-19 16:22:28 -07002461 __skb_warn_lro_forwarding(skb);
2462 return true;
2463 }
2464 return false;
2465}
2466
Herbert Xu35fc92a2007-03-26 23:22:20 -07002467static inline void skb_forward_csum(struct sk_buff *skb)
2468{
2469 /* Unfortunately we don't support this one. Any brave souls? */
2470 if (skb->ip_summed == CHECKSUM_COMPLETE)
2471 skb->ip_summed = CHECKSUM_NONE;
2472}
2473
Eric Dumazetbc8acf22010-09-02 13:07:41 -07002474/**
2475 * skb_checksum_none_assert - make sure skb ip_summed is CHECKSUM_NONE
2476 * @skb: skb to check
2477 *
2478 * fresh skbs have their ip_summed set to CHECKSUM_NONE.
2479 * Instead of forcing ip_summed to CHECKSUM_NONE, we can
2480 * use this helper, to document places where we make this assertion.
2481 */
Eric Dumazet05bdd2f2011-10-20 17:45:43 -04002482static inline void skb_checksum_none_assert(const struct sk_buff *skb)
Eric Dumazetbc8acf22010-09-02 13:07:41 -07002483{
2484#ifdef DEBUG
2485 BUG_ON(skb->ip_summed != CHECKSUM_NONE);
2486#endif
2487}
2488
Rusty Russellf35d9d82008-02-04 23:49:54 -05002489bool skb_partial_csum_set(struct sk_buff *skb, u16 start, u16 off);
Shirley Maa6686f22011-07-06 12:22:12 +00002490
Eric Dumazet05bdd2f2011-10-20 17:45:43 -04002491static inline bool skb_is_recycleable(const struct sk_buff *skb, int skb_size)
Andy Fleming3d153a72011-10-13 04:33:54 +00002492{
2493 if (irqs_disabled())
2494 return false;
2495
2496 if (skb_shinfo(skb)->tx_flags & SKBTX_DEV_ZEROCOPY)
2497 return false;
2498
2499 if (skb_is_nonlinear(skb) || skb->fclone != SKB_FCLONE_UNAVAILABLE)
2500 return false;
2501
2502 skb_size = SKB_DATA_ALIGN(skb_size + NET_SKB_PAD);
2503 if (skb_end_pointer(skb) - skb->head < skb_size)
2504 return false;
2505
2506 if (skb_shared(skb) || skb_cloned(skb))
2507 return false;
2508
2509 return true;
2510}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002511#endif /* __KERNEL__ */
2512#endif /* _LINUX_SKBUFF_H */