blob: 881fe80f01d004f63e6ffc7dd51237a13f83e02a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Definitions for the 'struct sk_buff' memory handlers.
3 *
4 * Authors:
5 * Alan Cox, <gw4pts@gw4pts.ampr.org>
6 * Florian La Roche, <rzsfl@rz.uni-sb.de>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
12 */
13
14#ifndef _LINUX_SKBUFF_H
15#define _LINUX_SKBUFF_H
16
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/kernel.h>
18#include <linux/compiler.h>
19#include <linux/time.h>
20#include <linux/cache.h>
21
22#include <asm/atomic.h>
23#include <asm/types.h>
24#include <linux/spinlock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include <linux/net.h>
Thomas Graf3fc7e8a2005-06-23 21:00:17 -070026#include <linux/textsearch.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <net/checksum.h>
Al Viroa80958f2006-12-04 20:41:19 +000028#include <linux/rcupdate.h>
Chris Leech97fc2f02006-05-23 17:55:33 -070029#include <linux/dmaengine.h>
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -070030#include <linux/hrtimer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
32#define HAVE_ALLOC_SKB /* For the drivers to know */
33#define HAVE_ALIGNABLE_SKB /* Ditto 8) */
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
Herbert Xu60476372007-04-09 11:59:39 -070035/* Don't change this without changing skb_csum_unnecessary! */
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#define CHECKSUM_NONE 0
Herbert Xu60476372007-04-09 11:59:39 -070037#define CHECKSUM_UNNECESSARY 1
38#define CHECKSUM_COMPLETE 2
39#define CHECKSUM_PARTIAL 3
Linus Torvalds1da177e2005-04-16 15:20:36 -070040
41#define SKB_DATA_ALIGN(X) (((X) + (SMP_CACHE_BYTES - 1)) & \
42 ~(SMP_CACHE_BYTES - 1))
David S. Millerfc910a22007-03-25 20:27:59 -070043#define SKB_WITH_OVERHEAD(X) \
44 (((X) - sizeof(struct skb_shared_info)) & \
45 ~(SMP_CACHE_BYTES - 1))
46#define SKB_MAX_ORDER(X, ORDER) \
47 SKB_WITH_OVERHEAD((PAGE_SIZE << (ORDER)) - (X))
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#define SKB_MAX_HEAD(X) (SKB_MAX_ORDER((X), 0))
49#define SKB_MAX_ALLOC (SKB_MAX_ORDER(0, 2))
50
51/* A. Checksumming of received packets by device.
52 *
53 * NONE: device failed to checksum this packet.
54 * skb->csum is undefined.
55 *
56 * UNNECESSARY: device parsed packet and wouldbe verified checksum.
57 * skb->csum is undefined.
58 * It is bad option, but, unfortunately, many of vendors do this.
59 * Apparently with secret goal to sell you new device, when you
60 * will add new protocol to your host. F.e. IPv6. 8)
61 *
Patrick McHardy84fa7932006-08-29 16:44:56 -070062 * COMPLETE: the most generic way. Device supplied checksum of _all_
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 * the packet as seen by netif_rx in skb->csum.
64 * NOTE: Even if device supports only some protocols, but
Patrick McHardy84fa7932006-08-29 16:44:56 -070065 * is able to produce some skb->csum, it MUST use COMPLETE,
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 * not UNNECESSARY.
67 *
68 * B. Checksumming on output.
69 *
70 * NONE: skb is checksummed by protocol or csum is not required.
71 *
Patrick McHardy84fa7932006-08-29 16:44:56 -070072 * PARTIAL: device is required to csum packet as seen by hard_start_xmit
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -070073 * from skb->transport_header to the end and to record the checksum
74 * at skb->transport_header + skb->csum.
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 *
76 * Device must show its capabilities in dev->features, set
77 * at device setup time.
78 * NETIF_F_HW_CSUM - it is clever device, it is able to checksum
79 * everything.
80 * NETIF_F_NO_CSUM - loopback or reliable single hop media.
81 * NETIF_F_IP_CSUM - device is dumb. It is able to csum only
82 * TCP/UDP over IPv4. Sigh. Vendors like this
83 * way by an unknown reason. Though, see comment above
84 * about CHECKSUM_UNNECESSARY. 8)
85 *
86 * Any questions? No questions, good. --ANK
87 */
88
Linus Torvalds1da177e2005-04-16 15:20:36 -070089struct net_device;
David Howells716ea3a2007-04-02 20:19:53 -070090struct scatterlist;
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -070092#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
Linus Torvalds1da177e2005-04-16 15:20:36 -070093struct nf_conntrack {
94 atomic_t use;
Linus Torvalds1da177e2005-04-16 15:20:36 -070095};
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -070096#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
98#ifdef CONFIG_BRIDGE_NETFILTER
99struct nf_bridge_info {
100 atomic_t use;
101 struct net_device *physindev;
102 struct net_device *physoutdev;
103#if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
104 struct net_device *netoutdev;
105#endif
106 unsigned int mask;
107 unsigned long data[32 / sizeof(unsigned long)];
108};
109#endif
110
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111struct sk_buff_head {
112 /* These two members must be first. */
113 struct sk_buff *next;
114 struct sk_buff *prev;
115
116 __u32 qlen;
117 spinlock_t lock;
118};
119
120struct sk_buff;
121
122/* To allow 64K frame to be packed as single skb without frag_list */
123#define MAX_SKB_FRAGS (65536/PAGE_SIZE + 2)
124
125typedef struct skb_frag_struct skb_frag_t;
126
127struct skb_frag_struct {
128 struct page *page;
129 __u16 page_offset;
130 __u16 size;
131};
132
133/* This data is invariant across clones and lives at
134 * the end of the header data, ie. at skb->end.
135 */
136struct skb_shared_info {
137 atomic_t dataref;
Benjamin LaHaise4947d3e2006-01-03 14:06:50 -0800138 unsigned short nr_frags;
Herbert Xu79671682006-06-22 02:40:14 -0700139 unsigned short gso_size;
140 /* Warning: this field is not always filled in (UFO)! */
141 unsigned short gso_segs;
142 unsigned short gso_type;
Al Viroae08e1f2006-11-08 00:27:11 -0800143 __be32 ip6_frag_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 struct sk_buff *frag_list;
145 skb_frag_t frags[MAX_SKB_FRAGS];
146};
147
148/* We divide dataref into two halves. The higher 16 bits hold references
149 * to the payload part of skb->data. The lower 16 bits hold references to
Patrick McHardy334a8132007-06-25 04:35:20 -0700150 * the entire skb->data. A clone of a headerless skb holds the length of
151 * the header in skb->hdr_len.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 *
153 * All users must obey the rule that the skb->data reference count must be
154 * greater than or equal to the payload reference count.
155 *
156 * Holding a reference to the payload part means that the user does not
157 * care about modifications to the header part of skb->data.
158 */
159#define SKB_DATAREF_SHIFT 16
160#define SKB_DATAREF_MASK ((1 << SKB_DATAREF_SHIFT) - 1)
161
David S. Millerd179cd12005-08-17 14:57:30 -0700162
163enum {
164 SKB_FCLONE_UNAVAILABLE,
165 SKB_FCLONE_ORIG,
166 SKB_FCLONE_CLONE,
167};
168
Herbert Xu79671682006-06-22 02:40:14 -0700169enum {
170 SKB_GSO_TCPV4 = 1 << 0,
Herbert Xuf83ef8c2006-06-30 13:37:03 -0700171 SKB_GSO_UDP = 1 << 1,
Herbert Xu576a30e2006-06-27 13:22:38 -0700172
173 /* This indicates the skb is from an untrusted source. */
174 SKB_GSO_DODGY = 1 << 2,
Michael Chanb0da85372006-06-29 12:30:00 -0700175
176 /* This indicates the tcp segment has CWR set. */
Herbert Xuf83ef8c2006-06-30 13:37:03 -0700177 SKB_GSO_TCP_ECN = 1 << 3,
178
179 SKB_GSO_TCPV6 = 1 << 4,
Herbert Xu79671682006-06-22 02:40:14 -0700180};
181
Arnaldo Carvalho de Melo2e07fa92007-04-10 21:22:35 -0700182#if BITS_PER_LONG > 32
183#define NET_SKBUFF_DATA_USES_OFFSET 1
184#endif
185
186#ifdef NET_SKBUFF_DATA_USES_OFFSET
187typedef unsigned int sk_buff_data_t;
188#else
189typedef unsigned char *sk_buff_data_t;
190#endif
191
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192/**
193 * struct sk_buff - socket buffer
194 * @next: Next buffer in list
195 * @prev: Previous buffer in list
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 * @sk: Socket we are owned by
Herbert Xu325ed822005-10-03 13:57:23 -0700197 * @tstamp: Time we arrived
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 * @dev: Device we arrived on/are leaving by
Patrick McHardyc01003c2007-03-29 11:46:52 -0700199 * @iif: ifindex of device we arrived on
Randy Dunlapbe52178b2007-05-03 03:16:20 -0700200 * @transport_header: Transport layer header
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -0700201 * @network_header: Network layer header
202 * @mac_header: Link layer header
Martin Waitz67be2dd2005-05-01 08:59:26 -0700203 * @dst: destination entry
204 * @sp: the security path, used for xfrm
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 * @cb: Control buffer. Free for use by every layer. Put private vars here
206 * @len: Length of actual data
207 * @data_len: Data length
208 * @mac_len: Length of link layer header
Patrick McHardy334a8132007-06-25 04:35:20 -0700209 * @hdr_len: writable header length of cloned skb
Herbert Xu663ead32007-04-09 11:59:07 -0700210 * @csum: Checksum (must include start/offset pair)
211 * @csum_start: Offset from skb->head where checksumming should start
212 * @csum_offset: Offset from csum_start where checksum should be stored
Martin Waitz67be2dd2005-05-01 08:59:26 -0700213 * @local_df: allow local fragmentation
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 * @cloned: Head may be cloned (check refcnt to be sure)
215 * @nohdr: Payload reference only, must not modify header
216 * @pkt_type: Packet class
Randy Dunlapc83c2482005-10-18 22:07:41 -0700217 * @fclone: skbuff clone status
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 * @ip_summed: Driver fed us an IP checksum
219 * @priority: Packet queueing priority
220 * @users: User count - see {datagram,tcp}.c
221 * @protocol: Packet protocol from driver
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 * @truesize: Buffer size
223 * @head: Head of buffer
224 * @data: Data head pointer
225 * @tail: Tail pointer
226 * @end: End pointer
227 * @destructor: Destruct function
Thomas Graf82e91ff2006-11-09 15:19:14 -0800228 * @mark: Generic packet mark
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 * @nfct: Associated connection, if any
Randy Dunlapc83c2482005-10-18 22:07:41 -0700230 * @ipvs_property: skbuff is owned by ipvs
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 * @nfctinfo: Relationship of this skb to the connection
Randy Dunlap461ddf32005-11-20 21:25:15 -0800232 * @nfct_reasm: netfilter conntrack re-assembly pointer
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 * @nf_bridge: Saved data about a bridged frame - see br_netfilter.c
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 * @tc_index: Traffic control index
235 * @tc_verd: traffic control verdict
Randy Dunlapf4b8ea72006-06-22 16:00:11 -0700236 * @dma_cookie: a cookie to one of several possible DMA operations
237 * done by skb DMA functions
James Morris984bc162006-06-09 00:29:17 -0700238 * @secmark: security marking
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 */
240
241struct sk_buff {
242 /* These two members must be first. */
243 struct sk_buff *next;
244 struct sk_buff *prev;
245
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 struct sock *sk;
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -0700247 ktime_t tstamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 struct net_device *dev;
Patrick McHardyc01003c2007-03-29 11:46:52 -0700249 int iif;
250 /* 4 byte hole on 64 bit*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 struct dst_entry *dst;
253 struct sec_path *sp;
254
255 /*
256 * This is the control buffer. It is free to use for every
257 * layer. Please put your private variables there. If you
258 * want to keep them across layers you have to do a skb_clone()
259 * first. This is owned by whoever has the skb queued ATM.
260 */
Patrick McHardy3e3850e2006-01-06 23:04:54 -0800261 char cb[48];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262
263 unsigned int len,
Patrick McHardy334a8132007-06-25 04:35:20 -0700264 data_len;
265 __u16 mac_len,
266 hdr_len;
Al Viroff1dcad2006-11-20 18:07:29 -0800267 union {
268 __wsum csum;
Herbert Xu663ead32007-04-09 11:59:07 -0700269 struct {
270 __u16 csum_start;
271 __u16 csum_offset;
272 };
Al Viroff1dcad2006-11-20 18:07:29 -0800273 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 __u32 priority;
Thomas Graf1cbb3382005-07-05 14:13:41 -0700275 __u8 local_df:1,
276 cloned:1,
277 ip_summed:2,
Harald Welte6869c4d2005-08-09 19:24:19 -0700278 nohdr:1,
279 nfctinfo:3;
David S. Millerd179cd12005-08-17 14:57:30 -0700280 __u8 pkt_type:3,
Patrick McHardyb84f4cc2005-11-20 21:19:21 -0800281 fclone:2,
282 ipvs_property:1;
Alexey Dobriyana0d3bea2005-08-11 16:05:50 -0700283 __be16 protocol;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284
285 void (*destructor)(struct sk_buff *skb);
Yasuyuki Kozakai9fb9cbb2005-11-09 16:38:16 -0800286#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -0700287 struct nf_conntrack *nfct;
Yasuyuki Kozakai9fb9cbb2005-11-09 16:38:16 -0800288 struct sk_buff *nfct_reasm;
289#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290#ifdef CONFIG_BRIDGE_NETFILTER
291 struct nf_bridge_info *nf_bridge;
292#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293#ifdef CONFIG_NET_SCHED
Patrick McHardyb6b99eb2005-08-09 19:33:51 -0700294 __u16 tc_index; /* traffic control index */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295#ifdef CONFIG_NET_CLS_ACT
Patrick McHardyb6b99eb2005-08-09 19:33:51 -0700296 __u16 tc_verd; /* traffic control verdict */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298#endif
Chris Leech97fc2f02006-05-23 17:55:33 -0700299#ifdef CONFIG_NET_DMA
300 dma_cookie_t dma_cookie;
301#endif
James Morris984bc162006-06-09 00:29:17 -0700302#ifdef CONFIG_NETWORK_SECMARK
303 __u32 secmark;
304#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305
Thomas Graf82e91ff2006-11-09 15:19:14 -0800306 __u32 mark;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700308 sk_buff_data_t transport_header;
309 sk_buff_data_t network_header;
310 sk_buff_data_t mac_header;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 /* These elements must be at the end, see alloc_skb() for details. */
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700312 sk_buff_data_t tail;
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -0700313 sk_buff_data_t end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 unsigned char *head,
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -0700315 *data;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700316 unsigned int truesize;
317 atomic_t users;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318};
319
320#ifdef __KERNEL__
321/*
322 * Handling routines are only of interest to the kernel
323 */
324#include <linux/slab.h>
325
326#include <asm/system.h>
327
Jörn Engel231d06a2006-03-20 21:28:35 -0800328extern void kfree_skb(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329extern void __kfree_skb(struct sk_buff *skb);
David S. Millerd179cd12005-08-17 14:57:30 -0700330extern struct sk_buff *__alloc_skb(unsigned int size,
Christoph Hellwigb30973f2006-12-06 20:32:36 -0800331 gfp_t priority, int fclone, int node);
David S. Millerd179cd12005-08-17 14:57:30 -0700332static inline struct sk_buff *alloc_skb(unsigned int size,
Al Virodd0fc662005-10-07 07:46:04 +0100333 gfp_t priority)
David S. Millerd179cd12005-08-17 14:57:30 -0700334{
Christoph Hellwigb30973f2006-12-06 20:32:36 -0800335 return __alloc_skb(size, priority, 0, -1);
David S. Millerd179cd12005-08-17 14:57:30 -0700336}
337
338static inline struct sk_buff *alloc_skb_fclone(unsigned int size,
Al Virodd0fc662005-10-07 07:46:04 +0100339 gfp_t priority)
David S. Millerd179cd12005-08-17 14:57:30 -0700340{
Christoph Hellwigb30973f2006-12-06 20:32:36 -0800341 return __alloc_skb(size, priority, 1, -1);
David S. Millerd179cd12005-08-17 14:57:30 -0700342}
343
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344extern void kfree_skbmem(struct sk_buff *skb);
Victor Fusco86a76ca2005-07-08 14:57:47 -0700345extern struct sk_buff *skb_clone(struct sk_buff *skb,
Al Virodd0fc662005-10-07 07:46:04 +0100346 gfp_t priority);
Victor Fusco86a76ca2005-07-08 14:57:47 -0700347extern struct sk_buff *skb_copy(const struct sk_buff *skb,
Al Virodd0fc662005-10-07 07:46:04 +0100348 gfp_t priority);
Victor Fusco86a76ca2005-07-08 14:57:47 -0700349extern struct sk_buff *pskb_copy(struct sk_buff *skb,
Al Virodd0fc662005-10-07 07:46:04 +0100350 gfp_t gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351extern int pskb_expand_head(struct sk_buff *skb,
Victor Fusco86a76ca2005-07-08 14:57:47 -0700352 int nhead, int ntail,
Al Virodd0fc662005-10-07 07:46:04 +0100353 gfp_t gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354extern struct sk_buff *skb_realloc_headroom(struct sk_buff *skb,
355 unsigned int headroom);
356extern struct sk_buff *skb_copy_expand(const struct sk_buff *skb,
357 int newheadroom, int newtailroom,
Al Virodd0fc662005-10-07 07:46:04 +0100358 gfp_t priority);
David Howells716ea3a2007-04-02 20:19:53 -0700359extern int skb_to_sgvec(struct sk_buff *skb,
360 struct scatterlist *sg, int offset,
361 int len);
362extern int skb_cow_data(struct sk_buff *skb, int tailbits,
363 struct sk_buff **trailer);
Herbert Xu5b057c62006-06-23 02:06:41 -0700364extern int skb_pad(struct sk_buff *skb, int pad);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365#define dev_kfree_skb(a) kfree_skb(a)
366extern void skb_over_panic(struct sk_buff *skb, int len,
367 void *here);
368extern void skb_under_panic(struct sk_buff *skb, int len,
369 void *here);
David S. Millerdc6de332006-04-20 00:10:50 -0700370extern void skb_truesize_bug(struct sk_buff *skb);
371
372static inline void skb_truesize_check(struct sk_buff *skb)
373{
374 if (unlikely((int)skb->truesize < sizeof(struct sk_buff) + skb->len))
375 skb_truesize_bug(skb);
376}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377
Ananda Rajue89e9cf2005-10-18 15:46:41 -0700378extern int skb_append_datato_frags(struct sock *sk, struct sk_buff *skb,
379 int getfrag(void *from, char *to, int offset,
380 int len,int odd, struct sk_buff *skb),
381 void *from, int length);
382
Thomas Graf677e90e2005-06-23 20:59:51 -0700383struct skb_seq_state
384{
385 __u32 lower_offset;
386 __u32 upper_offset;
387 __u32 frag_idx;
388 __u32 stepped_offset;
389 struct sk_buff *root_skb;
390 struct sk_buff *cur_skb;
391 __u8 *frag_data;
392};
393
394extern void skb_prepare_seq_read(struct sk_buff *skb,
395 unsigned int from, unsigned int to,
396 struct skb_seq_state *st);
397extern unsigned int skb_seq_read(unsigned int consumed, const u8 **data,
398 struct skb_seq_state *st);
399extern void skb_abort_seq_read(struct skb_seq_state *st);
400
Thomas Graf3fc7e8a2005-06-23 21:00:17 -0700401extern unsigned int skb_find_text(struct sk_buff *skb, unsigned int from,
402 unsigned int to, struct ts_config *config,
403 struct ts_state *state);
404
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -0700405#ifdef NET_SKBUFF_DATA_USES_OFFSET
406static inline unsigned char *skb_end_pointer(const struct sk_buff *skb)
407{
408 return skb->head + skb->end;
409}
410#else
411static inline unsigned char *skb_end_pointer(const struct sk_buff *skb)
412{
413 return skb->end;
414}
415#endif
416
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417/* Internal */
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -0700418#define skb_shinfo(SKB) ((struct skb_shared_info *)(skb_end_pointer(SKB)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419
420/**
421 * skb_queue_empty - check if a queue is empty
422 * @list: queue head
423 *
424 * Returns true if the queue is empty, false otherwise.
425 */
426static inline int skb_queue_empty(const struct sk_buff_head *list)
427{
428 return list->next == (struct sk_buff *)list;
429}
430
431/**
432 * skb_get - reference buffer
433 * @skb: buffer to reference
434 *
435 * Makes another reference to a socket buffer and returns a pointer
436 * to the buffer.
437 */
438static inline struct sk_buff *skb_get(struct sk_buff *skb)
439{
440 atomic_inc(&skb->users);
441 return skb;
442}
443
444/*
445 * If users == 1, we are the only owner and are can avoid redundant
446 * atomic change.
447 */
448
449/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 * skb_cloned - is the buffer a clone
451 * @skb: buffer to check
452 *
453 * Returns true if the buffer was generated with skb_clone() and is
454 * one of multiple shared copies of the buffer. Cloned buffers are
455 * shared data so must not be written to under normal circumstances.
456 */
457static inline int skb_cloned(const struct sk_buff *skb)
458{
459 return skb->cloned &&
460 (atomic_read(&skb_shinfo(skb)->dataref) & SKB_DATAREF_MASK) != 1;
461}
462
463/**
464 * skb_header_cloned - is the header a clone
465 * @skb: buffer to check
466 *
467 * Returns true if modifying the header part of the buffer requires
468 * the data to be copied.
469 */
470static inline int skb_header_cloned(const struct sk_buff *skb)
471{
472 int dataref;
473
474 if (!skb->cloned)
475 return 0;
476
477 dataref = atomic_read(&skb_shinfo(skb)->dataref);
478 dataref = (dataref & SKB_DATAREF_MASK) - (dataref >> SKB_DATAREF_SHIFT);
479 return dataref != 1;
480}
481
482/**
483 * skb_header_release - release reference to header
484 * @skb: buffer to operate on
485 *
486 * Drop a reference to the header part of the buffer. This is done
487 * by acquiring a payload reference. You must not read from the header
488 * part of skb->data after this.
489 */
490static inline void skb_header_release(struct sk_buff *skb)
491{
492 BUG_ON(skb->nohdr);
493 skb->nohdr = 1;
494 atomic_add(1 << SKB_DATAREF_SHIFT, &skb_shinfo(skb)->dataref);
495}
496
497/**
498 * skb_shared - is the buffer shared
499 * @skb: buffer to check
500 *
501 * Returns true if more than one person has a reference to this
502 * buffer.
503 */
504static inline int skb_shared(const struct sk_buff *skb)
505{
506 return atomic_read(&skb->users) != 1;
507}
508
509/**
510 * skb_share_check - check if buffer is shared and if so clone it
511 * @skb: buffer to check
512 * @pri: priority for memory allocation
513 *
514 * If the buffer is shared the buffer is cloned and the old copy
515 * drops a reference. A new clone with a single reference is returned.
516 * If the buffer is not shared the original buffer is returned. When
517 * being called from interrupt status or with spinlocks held pri must
518 * be GFP_ATOMIC.
519 *
520 * NULL is returned on a memory allocation failure.
521 */
Victor Fusco86a76ca2005-07-08 14:57:47 -0700522static inline struct sk_buff *skb_share_check(struct sk_buff *skb,
Al Virodd0fc662005-10-07 07:46:04 +0100523 gfp_t pri)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524{
525 might_sleep_if(pri & __GFP_WAIT);
526 if (skb_shared(skb)) {
527 struct sk_buff *nskb = skb_clone(skb, pri);
528 kfree_skb(skb);
529 skb = nskb;
530 }
531 return skb;
532}
533
534/*
535 * Copy shared buffers into a new sk_buff. We effectively do COW on
536 * packets to handle cases where we have a local reader and forward
537 * and a couple of other messy ones. The normal one is tcpdumping
538 * a packet thats being forwarded.
539 */
540
541/**
542 * skb_unshare - make a copy of a shared buffer
543 * @skb: buffer to check
544 * @pri: priority for memory allocation
545 *
546 * If the socket buffer is a clone then this function creates a new
547 * copy of the data, drops a reference count on the old copy and returns
548 * the new copy with the reference count at 1. If the buffer is not a clone
549 * the original buffer is returned. When called with a spinlock held or
550 * from interrupt state @pri must be %GFP_ATOMIC
551 *
552 * %NULL is returned on a memory allocation failure.
553 */
Victor Fuscoe2bf5212005-07-18 13:36:38 -0700554static inline struct sk_buff *skb_unshare(struct sk_buff *skb,
Al Virodd0fc662005-10-07 07:46:04 +0100555 gfp_t pri)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556{
557 might_sleep_if(pri & __GFP_WAIT);
558 if (skb_cloned(skb)) {
559 struct sk_buff *nskb = skb_copy(skb, pri);
560 kfree_skb(skb); /* Free our shared copy */
561 skb = nskb;
562 }
563 return skb;
564}
565
566/**
567 * skb_peek
568 * @list_: list to peek at
569 *
570 * Peek an &sk_buff. Unlike most other operations you _MUST_
571 * be careful with this one. A peek leaves the buffer on the
572 * list and someone else may run off with it. You must hold
573 * the appropriate locks or have a private queue to do this.
574 *
575 * Returns %NULL for an empty list or a pointer to the head element.
576 * The reference count is not incremented and the reference is therefore
577 * volatile. Use with caution.
578 */
579static inline struct sk_buff *skb_peek(struct sk_buff_head *list_)
580{
581 struct sk_buff *list = ((struct sk_buff *)list_)->next;
582 if (list == (struct sk_buff *)list_)
583 list = NULL;
584 return list;
585}
586
587/**
588 * skb_peek_tail
589 * @list_: list to peek at
590 *
591 * Peek an &sk_buff. Unlike most other operations you _MUST_
592 * be careful with this one. A peek leaves the buffer on the
593 * list and someone else may run off with it. You must hold
594 * the appropriate locks or have a private queue to do this.
595 *
596 * Returns %NULL for an empty list or a pointer to the tail element.
597 * The reference count is not incremented and the reference is therefore
598 * volatile. Use with caution.
599 */
600static inline struct sk_buff *skb_peek_tail(struct sk_buff_head *list_)
601{
602 struct sk_buff *list = ((struct sk_buff *)list_)->prev;
603 if (list == (struct sk_buff *)list_)
604 list = NULL;
605 return list;
606}
607
608/**
609 * skb_queue_len - get queue length
610 * @list_: list to measure
611 *
612 * Return the length of an &sk_buff queue.
613 */
614static inline __u32 skb_queue_len(const struct sk_buff_head *list_)
615{
616 return list_->qlen;
617}
618
Arjan van de Ven76f10ad2006-08-02 14:06:55 -0700619/*
620 * This function creates a split out lock class for each invocation;
621 * this is needed for now since a whole lot of users of the skb-queue
622 * infrastructure in drivers have different locking usage (in hardirq)
623 * than the networking core (in softirq only). In the long run either the
624 * network layer or drivers should need annotation to consolidate the
625 * main types of usage into 3 classes.
626 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627static inline void skb_queue_head_init(struct sk_buff_head *list)
628{
629 spin_lock_init(&list->lock);
630 list->prev = list->next = (struct sk_buff *)list;
631 list->qlen = 0;
632}
633
Pavel Emelianovc2ecba72007-04-17 12:45:31 -0700634static inline void skb_queue_head_init_class(struct sk_buff_head *list,
635 struct lock_class_key *class)
636{
637 skb_queue_head_init(list);
638 lockdep_set_class(&list->lock, class);
639}
640
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641/*
642 * Insert an sk_buff at the start of a list.
643 *
644 * The "__skb_xxxx()" functions are the non-atomic ones that
645 * can only be called with interrupts disabled.
646 */
647
648/**
Stephen Hemminger300ce172005-10-30 13:47:34 -0800649 * __skb_queue_after - queue a buffer at the list head
650 * @list: list to use
651 * @prev: place after this buffer
652 * @newsk: buffer to queue
653 *
654 * Queue a buffer int the middle of a list. This function takes no locks
655 * and you must therefore hold required locks before calling it.
656 *
657 * A buffer cannot be placed on two lists at the same time.
658 */
659static inline void __skb_queue_after(struct sk_buff_head *list,
660 struct sk_buff *prev,
661 struct sk_buff *newsk)
662{
663 struct sk_buff *next;
664 list->qlen++;
665
666 next = prev->next;
667 newsk->next = next;
668 newsk->prev = prev;
669 next->prev = prev->next = newsk;
670}
671
672/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 * __skb_queue_head - queue a buffer at the list head
674 * @list: list to use
675 * @newsk: buffer to queue
676 *
677 * Queue a buffer at the start of a list. This function takes no locks
678 * and you must therefore hold required locks before calling it.
679 *
680 * A buffer cannot be placed on two lists at the same time.
681 */
682extern void skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk);
683static inline void __skb_queue_head(struct sk_buff_head *list,
684 struct sk_buff *newsk)
685{
Stephen Hemminger300ce172005-10-30 13:47:34 -0800686 __skb_queue_after(list, (struct sk_buff *)list, newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687}
688
689/**
690 * __skb_queue_tail - queue a buffer at the list tail
691 * @list: list to use
692 * @newsk: buffer to queue
693 *
694 * Queue a buffer at the end of a list. This function takes no locks
695 * and you must therefore hold required locks before calling it.
696 *
697 * A buffer cannot be placed on two lists at the same time.
698 */
699extern void skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk);
700static inline void __skb_queue_tail(struct sk_buff_head *list,
701 struct sk_buff *newsk)
702{
703 struct sk_buff *prev, *next;
704
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 list->qlen++;
706 next = (struct sk_buff *)list;
707 prev = next->prev;
708 newsk->next = next;
709 newsk->prev = prev;
710 next->prev = prev->next = newsk;
711}
712
713
714/**
715 * __skb_dequeue - remove from the head of the queue
716 * @list: list to dequeue from
717 *
718 * Remove the head of the list. This function does not take any locks
719 * so must be used with appropriate locks held only. The head item is
720 * returned or %NULL if the list is empty.
721 */
722extern struct sk_buff *skb_dequeue(struct sk_buff_head *list);
723static inline struct sk_buff *__skb_dequeue(struct sk_buff_head *list)
724{
725 struct sk_buff *next, *prev, *result;
726
727 prev = (struct sk_buff *) list;
728 next = prev->next;
729 result = NULL;
730 if (next != prev) {
731 result = next;
732 next = next->next;
733 list->qlen--;
734 next->prev = prev;
735 prev->next = next;
736 result->next = result->prev = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 }
738 return result;
739}
740
741
742/*
743 * Insert a packet on a list.
744 */
David S. Miller8728b832005-08-09 19:25:21 -0700745extern void skb_insert(struct sk_buff *old, struct sk_buff *newsk, struct sk_buff_head *list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746static inline void __skb_insert(struct sk_buff *newsk,
747 struct sk_buff *prev, struct sk_buff *next,
748 struct sk_buff_head *list)
749{
750 newsk->next = next;
751 newsk->prev = prev;
752 next->prev = prev->next = newsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 list->qlen++;
754}
755
756/*
757 * Place a packet after a given packet in a list.
758 */
David S. Miller8728b832005-08-09 19:25:21 -0700759extern void skb_append(struct sk_buff *old, struct sk_buff *newsk, struct sk_buff_head *list);
760static inline void __skb_append(struct sk_buff *old, struct sk_buff *newsk, struct sk_buff_head *list)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761{
David S. Miller8728b832005-08-09 19:25:21 -0700762 __skb_insert(newsk, old, old->next, list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763}
764
765/*
766 * remove sk_buff from list. _Must_ be called atomically, and with
767 * the list known..
768 */
David S. Miller8728b832005-08-09 19:25:21 -0700769extern void skb_unlink(struct sk_buff *skb, struct sk_buff_head *list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770static inline void __skb_unlink(struct sk_buff *skb, struct sk_buff_head *list)
771{
772 struct sk_buff *next, *prev;
773
774 list->qlen--;
775 next = skb->next;
776 prev = skb->prev;
777 skb->next = skb->prev = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 next->prev = prev;
779 prev->next = next;
780}
781
782
783/* XXX: more streamlined implementation */
784
785/**
786 * __skb_dequeue_tail - remove from the tail of the queue
787 * @list: list to dequeue from
788 *
789 * Remove the tail of the list. This function does not take any locks
790 * so must be used with appropriate locks held only. The tail item is
791 * returned or %NULL if the list is empty.
792 */
793extern struct sk_buff *skb_dequeue_tail(struct sk_buff_head *list);
794static inline struct sk_buff *__skb_dequeue_tail(struct sk_buff_head *list)
795{
796 struct sk_buff *skb = skb_peek_tail(list);
797 if (skb)
798 __skb_unlink(skb, list);
799 return skb;
800}
801
802
803static inline int skb_is_nonlinear(const struct sk_buff *skb)
804{
805 return skb->data_len;
806}
807
808static inline unsigned int skb_headlen(const struct sk_buff *skb)
809{
810 return skb->len - skb->data_len;
811}
812
813static inline int skb_pagelen(const struct sk_buff *skb)
814{
815 int i, len = 0;
816
817 for (i = (int)skb_shinfo(skb)->nr_frags - 1; i >= 0; i--)
818 len += skb_shinfo(skb)->frags[i].size;
819 return len + skb_headlen(skb);
820}
821
822static inline void skb_fill_page_desc(struct sk_buff *skb, int i,
823 struct page *page, int off, int size)
824{
825 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
826
827 frag->page = page;
828 frag->page_offset = off;
829 frag->size = size;
830 skb_shinfo(skb)->nr_frags = i + 1;
831}
832
833#define SKB_PAGE_ASSERT(skb) BUG_ON(skb_shinfo(skb)->nr_frags)
834#define SKB_FRAG_ASSERT(skb) BUG_ON(skb_shinfo(skb)->frag_list)
835#define SKB_LINEAR_ASSERT(skb) BUG_ON(skb_is_nonlinear(skb))
836
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700837#ifdef NET_SKBUFF_DATA_USES_OFFSET
838static inline unsigned char *skb_tail_pointer(const struct sk_buff *skb)
839{
840 return skb->head + skb->tail;
841}
842
843static inline void skb_reset_tail_pointer(struct sk_buff *skb)
844{
845 skb->tail = skb->data - skb->head;
846}
847
848static inline void skb_set_tail_pointer(struct sk_buff *skb, const int offset)
849{
850 skb_reset_tail_pointer(skb);
851 skb->tail += offset;
852}
853#else /* NET_SKBUFF_DATA_USES_OFFSET */
854static inline unsigned char *skb_tail_pointer(const struct sk_buff *skb)
855{
856 return skb->tail;
857}
858
859static inline void skb_reset_tail_pointer(struct sk_buff *skb)
860{
861 skb->tail = skb->data;
862}
863
864static inline void skb_set_tail_pointer(struct sk_buff *skb, const int offset)
865{
866 skb->tail = skb->data + offset;
867}
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -0700868
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700869#endif /* NET_SKBUFF_DATA_USES_OFFSET */
870
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871/*
872 * Add data to an sk_buff
873 */
874static inline unsigned char *__skb_put(struct sk_buff *skb, unsigned int len)
875{
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700876 unsigned char *tmp = skb_tail_pointer(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 SKB_LINEAR_ASSERT(skb);
878 skb->tail += len;
879 skb->len += len;
880 return tmp;
881}
882
883/**
884 * skb_put - add data to a buffer
885 * @skb: buffer to use
886 * @len: amount of data to add
887 *
888 * This function extends the used data area of the buffer. If this would
889 * exceed the total buffer size the kernel will panic. A pointer to the
890 * first byte of the extra data is returned.
891 */
892static inline unsigned char *skb_put(struct sk_buff *skb, unsigned int len)
893{
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700894 unsigned char *tmp = skb_tail_pointer(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 SKB_LINEAR_ASSERT(skb);
896 skb->tail += len;
897 skb->len += len;
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -0700898 if (unlikely(skb->tail > skb->end))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899 skb_over_panic(skb, len, current_text_addr());
900 return tmp;
901}
902
903static inline unsigned char *__skb_push(struct sk_buff *skb, unsigned int len)
904{
905 skb->data -= len;
906 skb->len += len;
907 return skb->data;
908}
909
910/**
911 * skb_push - add data to the start of a buffer
912 * @skb: buffer to use
913 * @len: amount of data to add
914 *
915 * This function extends the used data area of the buffer at the buffer
916 * start. If this would exceed the total buffer headroom the kernel will
917 * panic. A pointer to the first byte of the extra data is returned.
918 */
919static inline unsigned char *skb_push(struct sk_buff *skb, unsigned int len)
920{
921 skb->data -= len;
922 skb->len += len;
923 if (unlikely(skb->data<skb->head))
924 skb_under_panic(skb, len, current_text_addr());
925 return skb->data;
926}
927
928static inline unsigned char *__skb_pull(struct sk_buff *skb, unsigned int len)
929{
930 skb->len -= len;
931 BUG_ON(skb->len < skb->data_len);
932 return skb->data += len;
933}
934
935/**
936 * skb_pull - remove data from the start of a buffer
937 * @skb: buffer to use
938 * @len: amount of data to remove
939 *
940 * This function removes data from the start of a buffer, returning
941 * the memory to the headroom. A pointer to the next data in the buffer
942 * is returned. Once the data has been pulled future pushes will overwrite
943 * the old data.
944 */
945static inline unsigned char *skb_pull(struct sk_buff *skb, unsigned int len)
946{
947 return unlikely(len > skb->len) ? NULL : __skb_pull(skb, len);
948}
949
950extern unsigned char *__pskb_pull_tail(struct sk_buff *skb, int delta);
951
952static inline unsigned char *__pskb_pull(struct sk_buff *skb, unsigned int len)
953{
954 if (len > skb_headlen(skb) &&
955 !__pskb_pull_tail(skb, len-skb_headlen(skb)))
956 return NULL;
957 skb->len -= len;
958 return skb->data += len;
959}
960
961static inline unsigned char *pskb_pull(struct sk_buff *skb, unsigned int len)
962{
963 return unlikely(len > skb->len) ? NULL : __pskb_pull(skb, len);
964}
965
966static inline int pskb_may_pull(struct sk_buff *skb, unsigned int len)
967{
968 if (likely(len <= skb_headlen(skb)))
969 return 1;
970 if (unlikely(len > skb->len))
971 return 0;
972 return __pskb_pull_tail(skb, len-skb_headlen(skb)) != NULL;
973}
974
975/**
976 * skb_headroom - bytes at buffer head
977 * @skb: buffer to check
978 *
979 * Return the number of bytes of free space at the head of an &sk_buff.
980 */
981static inline int skb_headroom(const struct sk_buff *skb)
982{
983 return skb->data - skb->head;
984}
985
986/**
987 * skb_tailroom - bytes at buffer end
988 * @skb: buffer to check
989 *
990 * Return the number of bytes of free space at the tail of an sk_buff
991 */
992static inline int skb_tailroom(const struct sk_buff *skb)
993{
Arnaldo Carvalho de Melo4305b542007-04-19 20:43:29 -0700994 return skb_is_nonlinear(skb) ? 0 : skb->end - skb->tail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995}
996
997/**
998 * skb_reserve - adjust headroom
999 * @skb: buffer to alter
1000 * @len: bytes to move
1001 *
1002 * Increase the headroom of an empty &sk_buff by reducing the tail
1003 * room. This is only allowed for an empty buffer.
1004 */
David S. Miller8243126c2006-01-17 02:54:21 -08001005static inline void skb_reserve(struct sk_buff *skb, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006{
1007 skb->data += len;
1008 skb->tail += len;
1009}
1010
Arnaldo Carvalho de Melo2e07fa92007-04-10 21:22:35 -07001011#ifdef NET_SKBUFF_DATA_USES_OFFSET
1012static inline unsigned char *skb_transport_header(const struct sk_buff *skb)
1013{
1014 return skb->head + skb->transport_header;
1015}
1016
1017static inline void skb_reset_transport_header(struct sk_buff *skb)
1018{
1019 skb->transport_header = skb->data - skb->head;
1020}
1021
1022static inline void skb_set_transport_header(struct sk_buff *skb,
1023 const int offset)
1024{
1025 skb_reset_transport_header(skb);
1026 skb->transport_header += offset;
1027}
1028
1029static inline unsigned char *skb_network_header(const struct sk_buff *skb)
1030{
1031 return skb->head + skb->network_header;
1032}
1033
1034static inline void skb_reset_network_header(struct sk_buff *skb)
1035{
1036 skb->network_header = skb->data - skb->head;
1037}
1038
1039static inline void skb_set_network_header(struct sk_buff *skb, const int offset)
1040{
1041 skb_reset_network_header(skb);
1042 skb->network_header += offset;
1043}
1044
1045static inline unsigned char *skb_mac_header(const struct sk_buff *skb)
1046{
1047 return skb->head + skb->mac_header;
1048}
1049
1050static inline int skb_mac_header_was_set(const struct sk_buff *skb)
1051{
1052 return skb->mac_header != ~0U;
1053}
1054
1055static inline void skb_reset_mac_header(struct sk_buff *skb)
1056{
1057 skb->mac_header = skb->data - skb->head;
1058}
1059
1060static inline void skb_set_mac_header(struct sk_buff *skb, const int offset)
1061{
1062 skb_reset_mac_header(skb);
1063 skb->mac_header += offset;
1064}
1065
1066#else /* NET_SKBUFF_DATA_USES_OFFSET */
1067
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001068static inline unsigned char *skb_transport_header(const struct sk_buff *skb)
1069{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001070 return skb->transport_header;
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001071}
1072
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03001073static inline void skb_reset_transport_header(struct sk_buff *skb)
1074{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001075 skb->transport_header = skb->data;
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03001076}
1077
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -03001078static inline void skb_set_transport_header(struct sk_buff *skb,
1079 const int offset)
1080{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001081 skb->transport_header = skb->data + offset;
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -03001082}
1083
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -07001084static inline unsigned char *skb_network_header(const struct sk_buff *skb)
1085{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001086 return skb->network_header;
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -07001087}
1088
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07001089static inline void skb_reset_network_header(struct sk_buff *skb)
1090{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001091 skb->network_header = skb->data;
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07001092}
1093
Arnaldo Carvalho de Meloc14d2452007-03-11 22:39:41 -03001094static inline void skb_set_network_header(struct sk_buff *skb, const int offset)
1095{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001096 skb->network_header = skb->data + offset;
Arnaldo Carvalho de Meloc14d2452007-03-11 22:39:41 -03001097}
1098
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001099static inline unsigned char *skb_mac_header(const struct sk_buff *skb)
1100{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001101 return skb->mac_header;
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001102}
1103
1104static inline int skb_mac_header_was_set(const struct sk_buff *skb)
1105{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001106 return skb->mac_header != NULL;
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001107}
1108
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -07001109static inline void skb_reset_mac_header(struct sk_buff *skb)
1110{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001111 skb->mac_header = skb->data;
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -07001112}
1113
Arnaldo Carvalho de Melo48d49d0c2007-03-10 12:30:58 -03001114static inline void skb_set_mac_header(struct sk_buff *skb, const int offset)
1115{
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001116 skb->mac_header = skb->data + offset;
Arnaldo Carvalho de Melo48d49d0c2007-03-10 12:30:58 -03001117}
Arnaldo Carvalho de Melo2e07fa92007-04-10 21:22:35 -07001118#endif /* NET_SKBUFF_DATA_USES_OFFSET */
1119
1120static inline int skb_transport_offset(const struct sk_buff *skb)
1121{
1122 return skb_transport_header(skb) - skb->data;
1123}
1124
1125static inline u32 skb_network_header_len(const struct sk_buff *skb)
1126{
1127 return skb->transport_header - skb->network_header;
1128}
1129
1130static inline int skb_network_offset(const struct sk_buff *skb)
1131{
1132 return skb_network_header(skb) - skb->data;
1133}
Arnaldo Carvalho de Melo48d49d0c2007-03-10 12:30:58 -03001134
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135/*
1136 * CPUs often take a performance hit when accessing unaligned memory
1137 * locations. The actual performance hit varies, it can be small if the
1138 * hardware handles it or large if we have to take an exception and fix it
1139 * in software.
1140 *
1141 * Since an ethernet header is 14 bytes network drivers often end up with
1142 * the IP header at an unaligned offset. The IP header can be aligned by
1143 * shifting the start of the packet by 2 bytes. Drivers should do this
1144 * with:
1145 *
1146 * skb_reserve(NET_IP_ALIGN);
1147 *
1148 * The downside to this alignment of the IP header is that the DMA is now
1149 * unaligned. On some architectures the cost of an unaligned DMA is high
1150 * and this cost outweighs the gains made by aligning the IP header.
1151 *
1152 * Since this trade off varies between architectures, we allow NET_IP_ALIGN
1153 * to be overridden.
1154 */
1155#ifndef NET_IP_ALIGN
1156#define NET_IP_ALIGN 2
1157#endif
1158
Anton Blanchard025be812006-03-31 02:27:06 -08001159/*
1160 * The networking layer reserves some headroom in skb data (via
1161 * dev_alloc_skb). This is used to avoid having to reallocate skb data when
1162 * the header has to grow. In the default case, if the header has to grow
1163 * 16 bytes or less we avoid the reallocation.
1164 *
1165 * Unfortunately this headroom changes the DMA alignment of the resulting
1166 * network packet. As for NET_IP_ALIGN, this unaligned DMA is expensive
1167 * on some architectures. An architecture can override this value,
1168 * perhaps setting it to a cacheline in size (since that will maintain
1169 * cacheline alignment of the DMA). It must be a power of 2.
1170 *
1171 * Various parts of the networking layer expect at least 16 bytes of
1172 * headroom, you should not reduce this.
1173 */
1174#ifndef NET_SKB_PAD
1175#define NET_SKB_PAD 16
1176#endif
1177
Herbert Xu3cc0e872006-06-09 16:13:38 -07001178extern int ___pskb_trim(struct sk_buff *skb, unsigned int len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179
1180static inline void __skb_trim(struct sk_buff *skb, unsigned int len)
1181{
Herbert Xu3cc0e872006-06-09 16:13:38 -07001182 if (unlikely(skb->data_len)) {
1183 WARN_ON(1);
1184 return;
1185 }
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001186 skb->len = len;
1187 skb_set_tail_pointer(skb, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188}
1189
1190/**
1191 * skb_trim - remove end from a buffer
1192 * @skb: buffer to alter
1193 * @len: new length
1194 *
1195 * Cut the length of a buffer down by removing data from the tail. If
1196 * the buffer is already under the length specified it is not modified.
Herbert Xu3cc0e872006-06-09 16:13:38 -07001197 * The skb must be linear.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198 */
1199static inline void skb_trim(struct sk_buff *skb, unsigned int len)
1200{
1201 if (skb->len > len)
1202 __skb_trim(skb, len);
1203}
1204
1205
1206static inline int __pskb_trim(struct sk_buff *skb, unsigned int len)
1207{
Herbert Xu3cc0e872006-06-09 16:13:38 -07001208 if (skb->data_len)
1209 return ___pskb_trim(skb, len);
1210 __skb_trim(skb, len);
1211 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212}
1213
1214static inline int pskb_trim(struct sk_buff *skb, unsigned int len)
1215{
1216 return (len < skb->len) ? __pskb_trim(skb, len) : 0;
1217}
1218
1219/**
Herbert Xue9fa4f72006-08-13 20:12:58 -07001220 * pskb_trim_unique - remove end from a paged unique (not cloned) buffer
1221 * @skb: buffer to alter
1222 * @len: new length
1223 *
1224 * This is identical to pskb_trim except that the caller knows that
1225 * the skb is not cloned so we should never get an error due to out-
1226 * of-memory.
1227 */
1228static inline void pskb_trim_unique(struct sk_buff *skb, unsigned int len)
1229{
1230 int err = pskb_trim(skb, len);
1231 BUG_ON(err);
1232}
1233
1234/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235 * skb_orphan - orphan a buffer
1236 * @skb: buffer to orphan
1237 *
1238 * If a buffer currently has an owner then we call the owner's
1239 * destructor function and make the @skb unowned. The buffer continues
1240 * to exist but is no longer charged to its former owner.
1241 */
1242static inline void skb_orphan(struct sk_buff *skb)
1243{
1244 if (skb->destructor)
1245 skb->destructor(skb);
1246 skb->destructor = NULL;
1247 skb->sk = NULL;
1248}
1249
1250/**
1251 * __skb_queue_purge - empty a list
1252 * @list: list to empty
1253 *
1254 * Delete all buffers on an &sk_buff list. Each buffer is removed from
1255 * the list and one reference dropped. This function does not take the
1256 * list lock and the caller must hold the relevant locks to use it.
1257 */
1258extern void skb_queue_purge(struct sk_buff_head *list);
1259static inline void __skb_queue_purge(struct sk_buff_head *list)
1260{
1261 struct sk_buff *skb;
1262 while ((skb = __skb_dequeue(list)) != NULL)
1263 kfree_skb(skb);
1264}
1265
1266/**
Christoph Hellwigb4e54de2006-07-24 15:31:14 -07001267 * __dev_alloc_skb - allocate an skbuff for receiving
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 * @length: length to allocate
1269 * @gfp_mask: get_free_pages mask, passed to alloc_skb
1270 *
1271 * Allocate a new &sk_buff and assign it a usage count of one. The
1272 * buffer has unspecified headroom built in. Users should allocate
1273 * the headroom they think they need without accounting for the
1274 * built in space. The built in space is used for optimisations.
1275 *
Christoph Hellwig766ea8c2006-08-07 15:49:53 -07001276 * %NULL is returned if there is no free memory.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278static inline struct sk_buff *__dev_alloc_skb(unsigned int length,
Al Virodd0fc662005-10-07 07:46:04 +01001279 gfp_t gfp_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280{
Anton Blanchard025be812006-03-31 02:27:06 -08001281 struct sk_buff *skb = alloc_skb(length + NET_SKB_PAD, gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 if (likely(skb))
Anton Blanchard025be812006-03-31 02:27:06 -08001283 skb_reserve(skb, NET_SKB_PAD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 return skb;
1285}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286
1287/**
Christoph Hellwigb4e54de2006-07-24 15:31:14 -07001288 * dev_alloc_skb - allocate an skbuff for receiving
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 * @length: length to allocate
1290 *
1291 * Allocate a new &sk_buff and assign it a usage count of one. The
1292 * buffer has unspecified headroom built in. Users should allocate
1293 * the headroom they think they need without accounting for the
1294 * built in space. The built in space is used for optimisations.
1295 *
Christoph Hellwig766ea8c2006-08-07 15:49:53 -07001296 * %NULL is returned if there is no free memory. Although this function
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297 * allocates memory it can be called from an interrupt.
1298 */
1299static inline struct sk_buff *dev_alloc_skb(unsigned int length)
1300{
1301 return __dev_alloc_skb(length, GFP_ATOMIC);
1302}
1303
Christoph Hellwig8af27452006-07-31 22:35:23 -07001304extern struct sk_buff *__netdev_alloc_skb(struct net_device *dev,
1305 unsigned int length, gfp_t gfp_mask);
1306
1307/**
1308 * netdev_alloc_skb - allocate an skbuff for rx on a specific device
1309 * @dev: network device to receive on
1310 * @length: length to allocate
1311 *
1312 * Allocate a new &sk_buff and assign it a usage count of one. The
1313 * buffer has unspecified headroom built in. Users should allocate
1314 * the headroom they think they need without accounting for the
1315 * built in space. The built in space is used for optimisations.
1316 *
1317 * %NULL is returned if there is no free memory. Although this function
1318 * allocates memory it can be called from an interrupt.
1319 */
1320static inline struct sk_buff *netdev_alloc_skb(struct net_device *dev,
1321 unsigned int length)
1322{
1323 return __netdev_alloc_skb(dev, length, GFP_ATOMIC);
1324}
1325
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326/**
Patrick McHardy334a8132007-06-25 04:35:20 -07001327 * skb_clone_writable - is the header of a clone writable
1328 * @skb: buffer to check
1329 * @len: length up to which to write
1330 *
1331 * Returns true if modifying the header part of the cloned buffer
1332 * does not requires the data to be copied.
1333 */
1334static inline int skb_clone_writable(struct sk_buff *skb, int len)
1335{
1336 return !skb_header_cloned(skb) &&
1337 skb_headroom(skb) + len <= skb->hdr_len;
1338}
1339
1340/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 * skb_cow - copy header of skb when it is required
1342 * @skb: buffer to cow
1343 * @headroom: needed headroom
1344 *
1345 * If the skb passed lacks sufficient headroom or its data part
1346 * is shared, data is reallocated. If reallocation fails, an error
1347 * is returned and original skb is not changed.
1348 *
1349 * The result is skb with writable area skb->head...skb->tail
1350 * and at least @headroom of space at head.
1351 */
1352static inline int skb_cow(struct sk_buff *skb, unsigned int headroom)
1353{
Anton Blanchard025be812006-03-31 02:27:06 -08001354 int delta = (headroom > NET_SKB_PAD ? headroom : NET_SKB_PAD) -
1355 skb_headroom(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356
1357 if (delta < 0)
1358 delta = 0;
1359
1360 if (delta || skb_cloned(skb))
Anton Blanchard025be812006-03-31 02:27:06 -08001361 return pskb_expand_head(skb, (delta + (NET_SKB_PAD-1)) &
1362 ~(NET_SKB_PAD-1), 0, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 return 0;
1364}
1365
1366/**
1367 * skb_padto - pad an skbuff up to a minimal size
1368 * @skb: buffer to pad
1369 * @len: minimal length
1370 *
1371 * Pads up a buffer to ensure the trailing bytes exist and are
1372 * blanked. If the buffer already contains sufficient data it
Herbert Xu5b057c62006-06-23 02:06:41 -07001373 * is untouched. Otherwise it is extended. Returns zero on
1374 * success. The skb is freed on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375 */
1376
Herbert Xu5b057c62006-06-23 02:06:41 -07001377static inline int skb_padto(struct sk_buff *skb, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378{
1379 unsigned int size = skb->len;
1380 if (likely(size >= len))
Herbert Xu5b057c62006-06-23 02:06:41 -07001381 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 return skb_pad(skb, len-size);
1383}
1384
1385static inline int skb_add_data(struct sk_buff *skb,
1386 char __user *from, int copy)
1387{
1388 const int off = skb->len;
1389
1390 if (skb->ip_summed == CHECKSUM_NONE) {
1391 int err = 0;
Al Viro50842052006-11-14 21:36:34 -08001392 __wsum csum = csum_and_copy_from_user(from, skb_put(skb, copy),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393 copy, 0, &err);
1394 if (!err) {
1395 skb->csum = csum_block_add(skb->csum, csum, off);
1396 return 0;
1397 }
1398 } else if (!copy_from_user(skb_put(skb, copy), from, copy))
1399 return 0;
1400
1401 __skb_trim(skb, off);
1402 return -EFAULT;
1403}
1404
1405static inline int skb_can_coalesce(struct sk_buff *skb, int i,
1406 struct page *page, int off)
1407{
1408 if (i) {
1409 struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i - 1];
1410
1411 return page == frag->page &&
1412 off == frag->page_offset + frag->size;
1413 }
1414 return 0;
1415}
1416
Herbert Xu364c6ba2006-06-09 16:10:40 -07001417static inline int __skb_linearize(struct sk_buff *skb)
1418{
1419 return __pskb_pull_tail(skb, skb->data_len) ? 0 : -ENOMEM;
1420}
1421
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422/**
1423 * skb_linearize - convert paged skb to linear one
1424 * @skb: buffer to linarize
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425 *
1426 * If there is no free memory -ENOMEM is returned, otherwise zero
1427 * is returned and the old skb data released.
1428 */
Herbert Xu364c6ba2006-06-09 16:10:40 -07001429static inline int skb_linearize(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430{
Herbert Xu364c6ba2006-06-09 16:10:40 -07001431 return skb_is_nonlinear(skb) ? __skb_linearize(skb) : 0;
1432}
1433
1434/**
1435 * skb_linearize_cow - make sure skb is linear and writable
1436 * @skb: buffer to process
1437 *
1438 * If there is no free memory -ENOMEM is returned, otherwise zero
1439 * is returned and the old skb data released.
1440 */
1441static inline int skb_linearize_cow(struct sk_buff *skb)
1442{
1443 return skb_is_nonlinear(skb) || skb_cloned(skb) ?
1444 __skb_linearize(skb) : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445}
1446
1447/**
1448 * skb_postpull_rcsum - update checksum for received skb after pull
1449 * @skb: buffer to update
1450 * @start: start of data before pull
1451 * @len: length of data pulled
1452 *
1453 * After doing a pull on a received packet, you need to call this to
Patrick McHardy84fa7932006-08-29 16:44:56 -07001454 * update the CHECKSUM_COMPLETE checksum, or set ip_summed to
1455 * CHECKSUM_NONE so that it can be recomputed from scratch.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 */
1457
1458static inline void skb_postpull_rcsum(struct sk_buff *skb,
Herbert Xucbb042f2006-03-20 22:43:56 -08001459 const void *start, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460{
Patrick McHardy84fa7932006-08-29 16:44:56 -07001461 if (skb->ip_summed == CHECKSUM_COMPLETE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462 skb->csum = csum_sub(skb->csum, csum_partial(start, len, 0));
1463}
1464
Herbert Xucbb042f2006-03-20 22:43:56 -08001465unsigned char *skb_pull_rcsum(struct sk_buff *skb, unsigned int len);
1466
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467/**
1468 * pskb_trim_rcsum - trim received skb and update checksum
1469 * @skb: buffer to trim
1470 * @len: new length
1471 *
1472 * This is exactly the same as pskb_trim except that it ensures the
1473 * checksum of received packets are still valid after the operation.
1474 */
1475
1476static inline int pskb_trim_rcsum(struct sk_buff *skb, unsigned int len)
1477{
Stephen Hemminger0e4e4222005-09-08 12:32:03 -07001478 if (likely(len >= skb->len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 return 0;
Patrick McHardy84fa7932006-08-29 16:44:56 -07001480 if (skb->ip_summed == CHECKSUM_COMPLETE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481 skb->ip_summed = CHECKSUM_NONE;
1482 return __pskb_trim(skb, len);
1483}
1484
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485#define skb_queue_walk(queue, skb) \
1486 for (skb = (queue)->next; \
1487 prefetch(skb->next), (skb != (struct sk_buff *)(queue)); \
1488 skb = skb->next)
1489
James Chapman46f89142007-04-30 00:07:31 -07001490#define skb_queue_walk_safe(queue, skb, tmp) \
1491 for (skb = (queue)->next, tmp = skb->next; \
1492 skb != (struct sk_buff *)(queue); \
1493 skb = tmp, tmp = skb->next)
1494
Stephen Hemminger300ce172005-10-30 13:47:34 -08001495#define skb_queue_reverse_walk(queue, skb) \
1496 for (skb = (queue)->prev; \
1497 prefetch(skb->prev), (skb != (struct sk_buff *)(queue)); \
1498 skb = skb->prev)
1499
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500
1501extern struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags,
1502 int noblock, int *err);
1503extern unsigned int datagram_poll(struct file *file, struct socket *sock,
1504 struct poll_table_struct *wait);
1505extern int skb_copy_datagram_iovec(const struct sk_buff *from,
1506 int offset, struct iovec *to,
1507 int size);
Herbert Xufb286bb2005-11-10 13:01:24 -08001508extern int skb_copy_and_csum_datagram_iovec(struct sk_buff *skb,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509 int hlen,
1510 struct iovec *iov);
1511extern void skb_free_datagram(struct sock *sk, struct sk_buff *skb);
Herbert Xu3305b802005-12-13 23:16:37 -08001512extern void skb_kill_datagram(struct sock *sk, struct sk_buff *skb,
1513 unsigned int flags);
Al Viro2bbbc862006-11-14 21:37:14 -08001514extern __wsum skb_checksum(const struct sk_buff *skb, int offset,
1515 int len, __wsum csum);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516extern int skb_copy_bits(const struct sk_buff *skb, int offset,
1517 void *to, int len);
Stephen Hemminger0c6fcc82007-04-20 16:40:01 -07001518extern int skb_store_bits(struct sk_buff *skb, int offset,
1519 const void *from, int len);
Al Viro81d77662006-11-14 21:37:33 -08001520extern __wsum skb_copy_and_csum_bits(const struct sk_buff *skb,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521 int offset, u8 *to, int len,
Al Viro81d77662006-11-14 21:37:33 -08001522 __wsum csum);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523extern void skb_copy_and_csum_dev(const struct sk_buff *skb, u8 *to);
1524extern void skb_split(struct sk_buff *skb,
1525 struct sk_buff *skb1, const u32 len);
1526
Herbert Xu576a30e2006-06-27 13:22:38 -07001527extern struct sk_buff *skb_segment(struct sk_buff *skb, int features);
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03001528
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529static inline void *skb_header_pointer(const struct sk_buff *skb, int offset,
1530 int len, void *buffer)
1531{
1532 int hlen = skb_headlen(skb);
1533
Patrick McHardy55820ee2005-07-05 14:08:10 -07001534 if (hlen - offset >= len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535 return skb->data + offset;
1536
1537 if (skb_copy_bits(skb, offset, buffer, len) < 0)
1538 return NULL;
1539
1540 return buffer;
1541}
1542
Arnaldo Carvalho de Melod626f622007-03-27 18:55:52 -03001543static inline void skb_copy_from_linear_data(const struct sk_buff *skb,
1544 void *to,
1545 const unsigned int len)
1546{
1547 memcpy(to, skb->data, len);
1548}
1549
1550static inline void skb_copy_from_linear_data_offset(const struct sk_buff *skb,
1551 const int offset, void *to,
1552 const unsigned int len)
1553{
1554 memcpy(to, skb->data + offset, len);
1555}
1556
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03001557static inline void skb_copy_to_linear_data(struct sk_buff *skb,
1558 const void *from,
1559 const unsigned int len)
1560{
1561 memcpy(skb->data, from, len);
1562}
1563
1564static inline void skb_copy_to_linear_data_offset(struct sk_buff *skb,
1565 const int offset,
1566 const void *from,
1567 const unsigned int len)
1568{
1569 memcpy(skb->data + offset, from, len);
1570}
1571
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572extern void skb_init(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001574/**
1575 * skb_get_timestamp - get timestamp from a skb
1576 * @skb: skb to get stamp from
1577 * @stamp: pointer to struct timeval to store stamp in
1578 *
1579 * Timestamps are stored in the skb as offsets to a base timestamp.
1580 * This function converts the offset back to a struct timeval and stores
1581 * it in stamp.
1582 */
Stephen Hemmingerf2c38392005-09-06 15:48:03 -07001583static inline void skb_get_timestamp(const struct sk_buff *skb, struct timeval *stamp)
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001584{
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07001585 *stamp = ktime_to_timeval(skb->tstamp);
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001586}
1587
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07001588static inline void __net_timestamp(struct sk_buff *skb)
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001589{
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07001590 skb->tstamp = ktime_get_real();
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001591}
1592
Stephen Hemminger164891a2007-04-23 22:26:16 -07001593static inline ktime_t net_timedelta(ktime_t t)
1594{
1595 return ktime_sub(ktime_get_real(), t);
1596}
1597
Ilpo Järvinenb9ce2042007-06-15 15:08:43 -07001598static inline ktime_t net_invalid_timestamp(void)
1599{
1600 return ktime_set(0, 0);
1601}
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001602
Herbert Xu759e5d02007-03-25 20:10:56 -07001603extern __sum16 __skb_checksum_complete_head(struct sk_buff *skb, int len);
Al Virob51655b2006-11-14 21:40:42 -08001604extern __sum16 __skb_checksum_complete(struct sk_buff *skb);
Herbert Xufb286bb2005-11-10 13:01:24 -08001605
Herbert Xu60476372007-04-09 11:59:39 -07001606static inline int skb_csum_unnecessary(const struct sk_buff *skb)
1607{
1608 return skb->ip_summed & CHECKSUM_UNNECESSARY;
1609}
1610
Herbert Xufb286bb2005-11-10 13:01:24 -08001611/**
1612 * skb_checksum_complete - Calculate checksum of an entire packet
1613 * @skb: packet to process
1614 *
1615 * This function calculates the checksum over the entire packet plus
1616 * the value of skb->csum. The latter can be used to supply the
1617 * checksum of a pseudo header as used by TCP/UDP. It returns the
1618 * checksum.
1619 *
1620 * For protocols that contain complete checksums such as ICMP/TCP/UDP,
1621 * this function can be used to verify that checksum on received
1622 * packets. In that case the function should return zero if the
1623 * checksum is correct. In particular, this function will return zero
1624 * if skb->ip_summed is CHECKSUM_UNNECESSARY which indicates that the
1625 * hardware has already verified the correctness of the checksum.
1626 */
1627static inline unsigned int skb_checksum_complete(struct sk_buff *skb)
1628{
Herbert Xu60476372007-04-09 11:59:39 -07001629 return skb_csum_unnecessary(skb) ?
1630 0 : __skb_checksum_complete(skb);
Herbert Xufb286bb2005-11-10 13:01:24 -08001631}
1632
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -07001633#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
Yasuyuki Kozakaide6e05c2007-03-23 11:17:27 -07001634extern void nf_conntrack_destroy(struct nf_conntrack *nfct);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635static inline void nf_conntrack_put(struct nf_conntrack *nfct)
1636{
1637 if (nfct && atomic_dec_and_test(&nfct->use))
Yasuyuki Kozakaide6e05c2007-03-23 11:17:27 -07001638 nf_conntrack_destroy(nfct);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639}
1640static inline void nf_conntrack_get(struct nf_conntrack *nfct)
1641{
1642 if (nfct)
1643 atomic_inc(&nfct->use);
1644}
Yasuyuki Kozakai9fb9cbb2005-11-09 16:38:16 -08001645static inline void nf_conntrack_get_reasm(struct sk_buff *skb)
1646{
1647 if (skb)
1648 atomic_inc(&skb->users);
1649}
1650static inline void nf_conntrack_put_reasm(struct sk_buff *skb)
1651{
1652 if (skb)
1653 kfree_skb(skb);
1654}
1655#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656#ifdef CONFIG_BRIDGE_NETFILTER
1657static inline void nf_bridge_put(struct nf_bridge_info *nf_bridge)
1658{
1659 if (nf_bridge && atomic_dec_and_test(&nf_bridge->use))
1660 kfree(nf_bridge);
1661}
1662static inline void nf_bridge_get(struct nf_bridge_info *nf_bridge)
1663{
1664 if (nf_bridge)
1665 atomic_inc(&nf_bridge->use);
1666}
1667#endif /* CONFIG_BRIDGE_NETFILTER */
Patrick McHardya193a4a2006-03-20 19:23:05 -08001668static inline void nf_reset(struct sk_buff *skb)
1669{
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -07001670#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
Patrick McHardya193a4a2006-03-20 19:23:05 -08001671 nf_conntrack_put(skb->nfct);
1672 skb->nfct = NULL;
Patrick McHardya193a4a2006-03-20 19:23:05 -08001673 nf_conntrack_put_reasm(skb->nfct_reasm);
1674 skb->nfct_reasm = NULL;
1675#endif
1676#ifdef CONFIG_BRIDGE_NETFILTER
1677 nf_bridge_put(skb->nf_bridge);
1678 skb->nf_bridge = NULL;
1679#endif
1680}
1681
Yasuyuki Kozakaiedda5532007-03-14 16:43:37 -07001682/* Note: This doesn't put any conntrack and bridge info in dst. */
1683static inline void __nf_copy(struct sk_buff *dst, const struct sk_buff *src)
1684{
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -07001685#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
Yasuyuki Kozakaiedda5532007-03-14 16:43:37 -07001686 dst->nfct = src->nfct;
1687 nf_conntrack_get(src->nfct);
1688 dst->nfctinfo = src->nfctinfo;
Yasuyuki Kozakaiedda5532007-03-14 16:43:37 -07001689 dst->nfct_reasm = src->nfct_reasm;
1690 nf_conntrack_get_reasm(src->nfct_reasm);
1691#endif
1692#ifdef CONFIG_BRIDGE_NETFILTER
1693 dst->nf_bridge = src->nf_bridge;
1694 nf_bridge_get(src->nf_bridge);
1695#endif
1696}
1697
Yasuyuki Kozakaie7ac05f2007-03-14 16:44:01 -07001698static inline void nf_copy(struct sk_buff *dst, const struct sk_buff *src)
1699{
Yasuyuki Kozakaie7ac05f2007-03-14 16:44:01 -07001700#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
Yasuyuki Kozakai5f79e0f2007-03-23 11:17:07 -07001701 nf_conntrack_put(dst->nfct);
Yasuyuki Kozakaie7ac05f2007-03-14 16:44:01 -07001702 nf_conntrack_put_reasm(dst->nfct_reasm);
1703#endif
1704#ifdef CONFIG_BRIDGE_NETFILTER
1705 nf_bridge_put(dst->nf_bridge);
1706#endif
1707 __nf_copy(dst, src);
1708}
1709
James Morris984bc162006-06-09 00:29:17 -07001710#ifdef CONFIG_NETWORK_SECMARK
1711static inline void skb_copy_secmark(struct sk_buff *to, const struct sk_buff *from)
1712{
1713 to->secmark = from->secmark;
1714}
1715
1716static inline void skb_init_secmark(struct sk_buff *skb)
1717{
1718 skb->secmark = 0;
1719}
1720#else
1721static inline void skb_copy_secmark(struct sk_buff *to, const struct sk_buff *from)
1722{ }
1723
1724static inline void skb_init_secmark(struct sk_buff *skb)
1725{ }
1726#endif
1727
Herbert Xu89114af2006-07-08 13:34:32 -07001728static inline int skb_is_gso(const struct sk_buff *skb)
1729{
1730 return skb_shinfo(skb)->gso_size;
1731}
1732
Herbert Xu35fc92a2007-03-26 23:22:20 -07001733static inline void skb_forward_csum(struct sk_buff *skb)
1734{
1735 /* Unfortunately we don't support this one. Any brave souls? */
1736 if (skb->ip_summed == CHECKSUM_COMPLETE)
1737 skb->ip_summed = CHECKSUM_NONE;
1738}
1739
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740#endif /* __KERNEL__ */
1741#endif /* _LINUX_SKBUFF_H */