skbuff.h 42 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528
  1. /*
  2. * Definitions for the 'struct sk_buff' memory handlers.
  3. *
  4. * Authors:
  5. * Alan Cox, <gw4pts@gw4pts.ampr.org>
  6. * Florian La Roche, <rzsfl@rz.uni-sb.de>
  7. *
  8. * This program is free software; you can redistribute it and/or
  9. * modify it under the terms of the GNU General Public License
  10. * as published by the Free Software Foundation; either version
  11. * 2 of the License, or (at your option) any later version.
  12. */
  13. #ifndef _LINUX_SKBUFF_H
  14. #define _LINUX_SKBUFF_H
  15. #include <linux/kernel.h>
  16. #include <linux/compiler.h>
  17. #include <linux/time.h>
  18. #include <linux/cache.h>
  19. #include <asm/atomic.h>
  20. #include <asm/types.h>
  21. #include <linux/spinlock.h>
  22. #include <linux/net.h>
  23. #include <linux/textsearch.h>
  24. #include <net/checksum.h>
  25. #include <linux/rcupdate.h>
  26. #include <linux/dmaengine.h>
  27. #include <linux/hrtimer.h>
  28. #define HAVE_ALLOC_SKB /* For the drivers to know */
  29. #define HAVE_ALIGNABLE_SKB /* Ditto 8) */
  30. #define CHECKSUM_NONE 0
  31. #define CHECKSUM_PARTIAL 1
  32. #define CHECKSUM_UNNECESSARY 2
  33. #define CHECKSUM_COMPLETE 3
  34. #define SKB_DATA_ALIGN(X) (((X) + (SMP_CACHE_BYTES - 1)) & \
  35. ~(SMP_CACHE_BYTES - 1))
  36. #define SKB_WITH_OVERHEAD(X) \
  37. (((X) - sizeof(struct skb_shared_info)) & \
  38. ~(SMP_CACHE_BYTES - 1))
  39. #define SKB_MAX_ORDER(X, ORDER) \
  40. SKB_WITH_OVERHEAD((PAGE_SIZE << (ORDER)) - (X))
  41. #define SKB_MAX_HEAD(X) (SKB_MAX_ORDER((X), 0))
  42. #define SKB_MAX_ALLOC (SKB_MAX_ORDER(0, 2))
  43. /* A. Checksumming of received packets by device.
  44. *
  45. * NONE: device failed to checksum this packet.
  46. * skb->csum is undefined.
  47. *
  48. * UNNECESSARY: device parsed packet and wouldbe verified checksum.
  49. * skb->csum is undefined.
  50. * It is bad option, but, unfortunately, many of vendors do this.
  51. * Apparently with secret goal to sell you new device, when you
  52. * will add new protocol to your host. F.e. IPv6. 8)
  53. *
  54. * COMPLETE: the most generic way. Device supplied checksum of _all_
  55. * the packet as seen by netif_rx in skb->csum.
  56. * NOTE: Even if device supports only some protocols, but
  57. * is able to produce some skb->csum, it MUST use COMPLETE,
  58. * not UNNECESSARY.
  59. *
  60. * B. Checksumming on output.
  61. *
  62. * NONE: skb is checksummed by protocol or csum is not required.
  63. *
  64. * PARTIAL: device is required to csum packet as seen by hard_start_xmit
  65. * from skb->h.raw to the end and to record the checksum
  66. * at skb->h.raw+skb->csum.
  67. *
  68. * Device must show its capabilities in dev->features, set
  69. * at device setup time.
  70. * NETIF_F_HW_CSUM - it is clever device, it is able to checksum
  71. * everything.
  72. * NETIF_F_NO_CSUM - loopback or reliable single hop media.
  73. * NETIF_F_IP_CSUM - device is dumb. It is able to csum only
  74. * TCP/UDP over IPv4. Sigh. Vendors like this
  75. * way by an unknown reason. Though, see comment above
  76. * about CHECKSUM_UNNECESSARY. 8)
  77. *
  78. * Any questions? No questions, good. --ANK
  79. */
  80. struct net_device;
  81. #ifdef CONFIG_NETFILTER
  82. struct nf_conntrack {
  83. atomic_t use;
  84. void (*destroy)(struct nf_conntrack *);
  85. };
  86. #ifdef CONFIG_BRIDGE_NETFILTER
  87. struct nf_bridge_info {
  88. atomic_t use;
  89. struct net_device *physindev;
  90. struct net_device *physoutdev;
  91. #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
  92. struct net_device *netoutdev;
  93. #endif
  94. unsigned int mask;
  95. unsigned long data[32 / sizeof(unsigned long)];
  96. };
  97. #endif
  98. #endif
  99. struct sk_buff_head {
  100. /* These two members must be first. */
  101. struct sk_buff *next;
  102. struct sk_buff *prev;
  103. __u32 qlen;
  104. spinlock_t lock;
  105. };
  106. struct sk_buff;
  107. /* To allow 64K frame to be packed as single skb without frag_list */
  108. #define MAX_SKB_FRAGS (65536/PAGE_SIZE + 2)
  109. typedef struct skb_frag_struct skb_frag_t;
  110. struct skb_frag_struct {
  111. struct page *page;
  112. __u16 page_offset;
  113. __u16 size;
  114. };
  115. /* This data is invariant across clones and lives at
  116. * the end of the header data, ie. at skb->end.
  117. */
  118. struct skb_shared_info {
  119. atomic_t dataref;
  120. unsigned short nr_frags;
  121. unsigned short gso_size;
  122. /* Warning: this field is not always filled in (UFO)! */
  123. unsigned short gso_segs;
  124. unsigned short gso_type;
  125. __be32 ip6_frag_id;
  126. struct sk_buff *frag_list;
  127. skb_frag_t frags[MAX_SKB_FRAGS];
  128. };
  129. /* We divide dataref into two halves. The higher 16 bits hold references
  130. * to the payload part of skb->data. The lower 16 bits hold references to
  131. * the entire skb->data. It is up to the users of the skb to agree on
  132. * where the payload starts.
  133. *
  134. * All users must obey the rule that the skb->data reference count must be
  135. * greater than or equal to the payload reference count.
  136. *
  137. * Holding a reference to the payload part means that the user does not
  138. * care about modifications to the header part of skb->data.
  139. */
  140. #define SKB_DATAREF_SHIFT 16
  141. #define SKB_DATAREF_MASK ((1 << SKB_DATAREF_SHIFT) - 1)
  142. enum {
  143. SKB_FCLONE_UNAVAILABLE,
  144. SKB_FCLONE_ORIG,
  145. SKB_FCLONE_CLONE,
  146. };
  147. enum {
  148. SKB_GSO_TCPV4 = 1 << 0,
  149. SKB_GSO_UDP = 1 << 1,
  150. /* This indicates the skb is from an untrusted source. */
  151. SKB_GSO_DODGY = 1 << 2,
  152. /* This indicates the tcp segment has CWR set. */
  153. SKB_GSO_TCP_ECN = 1 << 3,
  154. SKB_GSO_TCPV6 = 1 << 4,
  155. };
  156. /**
  157. * struct sk_buff - socket buffer
  158. * @next: Next buffer in list
  159. * @prev: Previous buffer in list
  160. * @sk: Socket we are owned by
  161. * @tstamp: Time we arrived
  162. * @dev: Device we arrived on/are leaving by
  163. * @iif: ifindex of device we arrived on
  164. * @h: Transport layer header
  165. * @nh: Network layer header
  166. * @mac: Link layer header
  167. * @dst: destination entry
  168. * @sp: the security path, used for xfrm
  169. * @cb: Control buffer. Free for use by every layer. Put private vars here
  170. * @len: Length of actual data
  171. * @data_len: Data length
  172. * @mac_len: Length of link layer header
  173. * @csum: Checksum
  174. * @local_df: allow local fragmentation
  175. * @cloned: Head may be cloned (check refcnt to be sure)
  176. * @nohdr: Payload reference only, must not modify header
  177. * @pkt_type: Packet class
  178. * @fclone: skbuff clone status
  179. * @ip_summed: Driver fed us an IP checksum
  180. * @priority: Packet queueing priority
  181. * @users: User count - see {datagram,tcp}.c
  182. * @protocol: Packet protocol from driver
  183. * @truesize: Buffer size
  184. * @head: Head of buffer
  185. * @data: Data head pointer
  186. * @tail: Tail pointer
  187. * @end: End pointer
  188. * @destructor: Destruct function
  189. * @mark: Generic packet mark
  190. * @nfct: Associated connection, if any
  191. * @ipvs_property: skbuff is owned by ipvs
  192. * @nfctinfo: Relationship of this skb to the connection
  193. * @nfct_reasm: netfilter conntrack re-assembly pointer
  194. * @nf_bridge: Saved data about a bridged frame - see br_netfilter.c
  195. * @tc_index: Traffic control index
  196. * @tc_verd: traffic control verdict
  197. * @dma_cookie: a cookie to one of several possible DMA operations
  198. * done by skb DMA functions
  199. * @secmark: security marking
  200. */
  201. struct sk_buff {
  202. /* These two members must be first. */
  203. struct sk_buff *next;
  204. struct sk_buff *prev;
  205. struct sock *sk;
  206. ktime_t tstamp;
  207. struct net_device *dev;
  208. int iif;
  209. /* 4 byte hole on 64 bit*/
  210. union {
  211. struct tcphdr *th;
  212. struct icmphdr *icmph;
  213. struct iphdr *ipiph;
  214. struct ipv6hdr *ipv6h;
  215. unsigned char *raw;
  216. } h;
  217. union {
  218. unsigned char *raw;
  219. } nh;
  220. union {
  221. unsigned char *raw;
  222. } mac;
  223. struct dst_entry *dst;
  224. struct sec_path *sp;
  225. /*
  226. * This is the control buffer. It is free to use for every
  227. * layer. Please put your private variables there. If you
  228. * want to keep them across layers you have to do a skb_clone()
  229. * first. This is owned by whoever has the skb queued ATM.
  230. */
  231. char cb[48];
  232. unsigned int len,
  233. data_len,
  234. mac_len;
  235. union {
  236. __wsum csum;
  237. __u32 csum_offset;
  238. };
  239. __u32 priority;
  240. __u8 local_df:1,
  241. cloned:1,
  242. ip_summed:2,
  243. nohdr:1,
  244. nfctinfo:3;
  245. __u8 pkt_type:3,
  246. fclone:2,
  247. ipvs_property:1;
  248. __be16 protocol;
  249. void (*destructor)(struct sk_buff *skb);
  250. #ifdef CONFIG_NETFILTER
  251. struct nf_conntrack *nfct;
  252. #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
  253. struct sk_buff *nfct_reasm;
  254. #endif
  255. #ifdef CONFIG_BRIDGE_NETFILTER
  256. struct nf_bridge_info *nf_bridge;
  257. #endif
  258. #endif /* CONFIG_NETFILTER */
  259. #ifdef CONFIG_NET_SCHED
  260. __u16 tc_index; /* traffic control index */
  261. #ifdef CONFIG_NET_CLS_ACT
  262. __u16 tc_verd; /* traffic control verdict */
  263. #endif
  264. #endif
  265. #ifdef CONFIG_NET_DMA
  266. dma_cookie_t dma_cookie;
  267. #endif
  268. #ifdef CONFIG_NETWORK_SECMARK
  269. __u32 secmark;
  270. #endif
  271. __u32 mark;
  272. /* These elements must be at the end, see alloc_skb() for details. */
  273. unsigned int truesize;
  274. atomic_t users;
  275. unsigned char *head,
  276. *data,
  277. *tail,
  278. *end;
  279. };
  280. #ifdef __KERNEL__
  281. /*
  282. * Handling routines are only of interest to the kernel
  283. */
  284. #include <linux/slab.h>
  285. #include <asm/system.h>
  286. extern void kfree_skb(struct sk_buff *skb);
  287. extern void __kfree_skb(struct sk_buff *skb);
  288. extern struct sk_buff *__alloc_skb(unsigned int size,
  289. gfp_t priority, int fclone, int node);
  290. static inline struct sk_buff *alloc_skb(unsigned int size,
  291. gfp_t priority)
  292. {
  293. return __alloc_skb(size, priority, 0, -1);
  294. }
  295. static inline struct sk_buff *alloc_skb_fclone(unsigned int size,
  296. gfp_t priority)
  297. {
  298. return __alloc_skb(size, priority, 1, -1);
  299. }
  300. extern void kfree_skbmem(struct sk_buff *skb);
  301. extern struct sk_buff *skb_clone(struct sk_buff *skb,
  302. gfp_t priority);
  303. extern struct sk_buff *skb_copy(const struct sk_buff *skb,
  304. gfp_t priority);
  305. extern struct sk_buff *pskb_copy(struct sk_buff *skb,
  306. gfp_t gfp_mask);
  307. extern int pskb_expand_head(struct sk_buff *skb,
  308. int nhead, int ntail,
  309. gfp_t gfp_mask);
  310. extern struct sk_buff *skb_realloc_headroom(struct sk_buff *skb,
  311. unsigned int headroom);
  312. extern struct sk_buff *skb_copy_expand(const struct sk_buff *skb,
  313. int newheadroom, int newtailroom,
  314. gfp_t priority);
  315. extern int skb_pad(struct sk_buff *skb, int pad);
  316. #define dev_kfree_skb(a) kfree_skb(a)
  317. extern void skb_over_panic(struct sk_buff *skb, int len,
  318. void *here);
  319. extern void skb_under_panic(struct sk_buff *skb, int len,
  320. void *here);
  321. extern void skb_truesize_bug(struct sk_buff *skb);
  322. static inline void skb_truesize_check(struct sk_buff *skb)
  323. {
  324. if (unlikely((int)skb->truesize < sizeof(struct sk_buff) + skb->len))
  325. skb_truesize_bug(skb);
  326. }
  327. extern int skb_append_datato_frags(struct sock *sk, struct sk_buff *skb,
  328. int getfrag(void *from, char *to, int offset,
  329. int len,int odd, struct sk_buff *skb),
  330. void *from, int length);
  331. struct skb_seq_state
  332. {
  333. __u32 lower_offset;
  334. __u32 upper_offset;
  335. __u32 frag_idx;
  336. __u32 stepped_offset;
  337. struct sk_buff *root_skb;
  338. struct sk_buff *cur_skb;
  339. __u8 *frag_data;
  340. };
  341. extern void skb_prepare_seq_read(struct sk_buff *skb,
  342. unsigned int from, unsigned int to,
  343. struct skb_seq_state *st);
  344. extern unsigned int skb_seq_read(unsigned int consumed, const u8 **data,
  345. struct skb_seq_state *st);
  346. extern void skb_abort_seq_read(struct skb_seq_state *st);
  347. extern unsigned int skb_find_text(struct sk_buff *skb, unsigned int from,
  348. unsigned int to, struct ts_config *config,
  349. struct ts_state *state);
  350. /* Internal */
  351. #define skb_shinfo(SKB) ((struct skb_shared_info *)((SKB)->end))
  352. /**
  353. * skb_queue_empty - check if a queue is empty
  354. * @list: queue head
  355. *
  356. * Returns true if the queue is empty, false otherwise.
  357. */
  358. static inline int skb_queue_empty(const struct sk_buff_head *list)
  359. {
  360. return list->next == (struct sk_buff *)list;
  361. }
  362. /**
  363. * skb_get - reference buffer
  364. * @skb: buffer to reference
  365. *
  366. * Makes another reference to a socket buffer and returns a pointer
  367. * to the buffer.
  368. */
  369. static inline struct sk_buff *skb_get(struct sk_buff *skb)
  370. {
  371. atomic_inc(&skb->users);
  372. return skb;
  373. }
  374. /*
  375. * If users == 1, we are the only owner and are can avoid redundant
  376. * atomic change.
  377. */
  378. /**
  379. * skb_cloned - is the buffer a clone
  380. * @skb: buffer to check
  381. *
  382. * Returns true if the buffer was generated with skb_clone() and is
  383. * one of multiple shared copies of the buffer. Cloned buffers are
  384. * shared data so must not be written to under normal circumstances.
  385. */
  386. static inline int skb_cloned(const struct sk_buff *skb)
  387. {
  388. return skb->cloned &&
  389. (atomic_read(&skb_shinfo(skb)->dataref) & SKB_DATAREF_MASK) != 1;
  390. }
  391. /**
  392. * skb_header_cloned - is the header a clone
  393. * @skb: buffer to check
  394. *
  395. * Returns true if modifying the header part of the buffer requires
  396. * the data to be copied.
  397. */
  398. static inline int skb_header_cloned(const struct sk_buff *skb)
  399. {
  400. int dataref;
  401. if (!skb->cloned)
  402. return 0;
  403. dataref = atomic_read(&skb_shinfo(skb)->dataref);
  404. dataref = (dataref & SKB_DATAREF_MASK) - (dataref >> SKB_DATAREF_SHIFT);
  405. return dataref != 1;
  406. }
  407. /**
  408. * skb_header_release - release reference to header
  409. * @skb: buffer to operate on
  410. *
  411. * Drop a reference to the header part of the buffer. This is done
  412. * by acquiring a payload reference. You must not read from the header
  413. * part of skb->data after this.
  414. */
  415. static inline void skb_header_release(struct sk_buff *skb)
  416. {
  417. BUG_ON(skb->nohdr);
  418. skb->nohdr = 1;
  419. atomic_add(1 << SKB_DATAREF_SHIFT, &skb_shinfo(skb)->dataref);
  420. }
  421. /**
  422. * skb_shared - is the buffer shared
  423. * @skb: buffer to check
  424. *
  425. * Returns true if more than one person has a reference to this
  426. * buffer.
  427. */
  428. static inline int skb_shared(const struct sk_buff *skb)
  429. {
  430. return atomic_read(&skb->users) != 1;
  431. }
  432. /**
  433. * skb_share_check - check if buffer is shared and if so clone it
  434. * @skb: buffer to check
  435. * @pri: priority for memory allocation
  436. *
  437. * If the buffer is shared the buffer is cloned and the old copy
  438. * drops a reference. A new clone with a single reference is returned.
  439. * If the buffer is not shared the original buffer is returned. When
  440. * being called from interrupt status or with spinlocks held pri must
  441. * be GFP_ATOMIC.
  442. *
  443. * NULL is returned on a memory allocation failure.
  444. */
  445. static inline struct sk_buff *skb_share_check(struct sk_buff *skb,
  446. gfp_t pri)
  447. {
  448. might_sleep_if(pri & __GFP_WAIT);
  449. if (skb_shared(skb)) {
  450. struct sk_buff *nskb = skb_clone(skb, pri);
  451. kfree_skb(skb);
  452. skb = nskb;
  453. }
  454. return skb;
  455. }
  456. /*
  457. * Copy shared buffers into a new sk_buff. We effectively do COW on
  458. * packets to handle cases where we have a local reader and forward
  459. * and a couple of other messy ones. The normal one is tcpdumping
  460. * a packet thats being forwarded.
  461. */
  462. /**
  463. * skb_unshare - make a copy of a shared buffer
  464. * @skb: buffer to check
  465. * @pri: priority for memory allocation
  466. *
  467. * If the socket buffer is a clone then this function creates a new
  468. * copy of the data, drops a reference count on the old copy and returns
  469. * the new copy with the reference count at 1. If the buffer is not a clone
  470. * the original buffer is returned. When called with a spinlock held or
  471. * from interrupt state @pri must be %GFP_ATOMIC
  472. *
  473. * %NULL is returned on a memory allocation failure.
  474. */
  475. static inline struct sk_buff *skb_unshare(struct sk_buff *skb,
  476. gfp_t pri)
  477. {
  478. might_sleep_if(pri & __GFP_WAIT);
  479. if (skb_cloned(skb)) {
  480. struct sk_buff *nskb = skb_copy(skb, pri);
  481. kfree_skb(skb); /* Free our shared copy */
  482. skb = nskb;
  483. }
  484. return skb;
  485. }
  486. /**
  487. * skb_peek
  488. * @list_: list to peek at
  489. *
  490. * Peek an &sk_buff. Unlike most other operations you _MUST_
  491. * be careful with this one. A peek leaves the buffer on the
  492. * list and someone else may run off with it. You must hold
  493. * the appropriate locks or have a private queue to do this.
  494. *
  495. * Returns %NULL for an empty list or a pointer to the head element.
  496. * The reference count is not incremented and the reference is therefore
  497. * volatile. Use with caution.
  498. */
  499. static inline struct sk_buff *skb_peek(struct sk_buff_head *list_)
  500. {
  501. struct sk_buff *list = ((struct sk_buff *)list_)->next;
  502. if (list == (struct sk_buff *)list_)
  503. list = NULL;
  504. return list;
  505. }
  506. /**
  507. * skb_peek_tail
  508. * @list_: list to peek at
  509. *
  510. * Peek an &sk_buff. Unlike most other operations you _MUST_
  511. * be careful with this one. A peek leaves the buffer on the
  512. * list and someone else may run off with it. You must hold
  513. * the appropriate locks or have a private queue to do this.
  514. *
  515. * Returns %NULL for an empty list or a pointer to the tail element.
  516. * The reference count is not incremented and the reference is therefore
  517. * volatile. Use with caution.
  518. */
  519. static inline struct sk_buff *skb_peek_tail(struct sk_buff_head *list_)
  520. {
  521. struct sk_buff *list = ((struct sk_buff *)list_)->prev;
  522. if (list == (struct sk_buff *)list_)
  523. list = NULL;
  524. return list;
  525. }
  526. /**
  527. * skb_queue_len - get queue length
  528. * @list_: list to measure
  529. *
  530. * Return the length of an &sk_buff queue.
  531. */
  532. static inline __u32 skb_queue_len(const struct sk_buff_head *list_)
  533. {
  534. return list_->qlen;
  535. }
  536. /*
  537. * This function creates a split out lock class for each invocation;
  538. * this is needed for now since a whole lot of users of the skb-queue
  539. * infrastructure in drivers have different locking usage (in hardirq)
  540. * than the networking core (in softirq only). In the long run either the
  541. * network layer or drivers should need annotation to consolidate the
  542. * main types of usage into 3 classes.
  543. */
  544. static inline void skb_queue_head_init(struct sk_buff_head *list)
  545. {
  546. spin_lock_init(&list->lock);
  547. list->prev = list->next = (struct sk_buff *)list;
  548. list->qlen = 0;
  549. }
  550. static inline void skb_queue_head_init_class(struct sk_buff_head *list,
  551. struct lock_class_key *class)
  552. {
  553. skb_queue_head_init(list);
  554. lockdep_set_class(&list->lock, class);
  555. }
  556. /*
  557. * Insert an sk_buff at the start of a list.
  558. *
  559. * The "__skb_xxxx()" functions are the non-atomic ones that
  560. * can only be called with interrupts disabled.
  561. */
  562. /**
  563. * __skb_queue_after - queue a buffer at the list head
  564. * @list: list to use
  565. * @prev: place after this buffer
  566. * @newsk: buffer to queue
  567. *
  568. * Queue a buffer int the middle of a list. This function takes no locks
  569. * and you must therefore hold required locks before calling it.
  570. *
  571. * A buffer cannot be placed on two lists at the same time.
  572. */
  573. static inline void __skb_queue_after(struct sk_buff_head *list,
  574. struct sk_buff *prev,
  575. struct sk_buff *newsk)
  576. {
  577. struct sk_buff *next;
  578. list->qlen++;
  579. next = prev->next;
  580. newsk->next = next;
  581. newsk->prev = prev;
  582. next->prev = prev->next = newsk;
  583. }
  584. /**
  585. * __skb_queue_head - queue a buffer at the list head
  586. * @list: list to use
  587. * @newsk: buffer to queue
  588. *
  589. * Queue a buffer at the start of a list. This function takes no locks
  590. * and you must therefore hold required locks before calling it.
  591. *
  592. * A buffer cannot be placed on two lists at the same time.
  593. */
  594. extern void skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk);
  595. static inline void __skb_queue_head(struct sk_buff_head *list,
  596. struct sk_buff *newsk)
  597. {
  598. __skb_queue_after(list, (struct sk_buff *)list, newsk);
  599. }
  600. /**
  601. * __skb_queue_tail - queue a buffer at the list tail
  602. * @list: list to use
  603. * @newsk: buffer to queue
  604. *
  605. * Queue a buffer at the end of a list. This function takes no locks
  606. * and you must therefore hold required locks before calling it.
  607. *
  608. * A buffer cannot be placed on two lists at the same time.
  609. */
  610. extern void skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk);
  611. static inline void __skb_queue_tail(struct sk_buff_head *list,
  612. struct sk_buff *newsk)
  613. {
  614. struct sk_buff *prev, *next;
  615. list->qlen++;
  616. next = (struct sk_buff *)list;
  617. prev = next->prev;
  618. newsk->next = next;
  619. newsk->prev = prev;
  620. next->prev = prev->next = newsk;
  621. }
  622. /**
  623. * __skb_dequeue - remove from the head of the queue
  624. * @list: list to dequeue from
  625. *
  626. * Remove the head of the list. This function does not take any locks
  627. * so must be used with appropriate locks held only. The head item is
  628. * returned or %NULL if the list is empty.
  629. */
  630. extern struct sk_buff *skb_dequeue(struct sk_buff_head *list);
  631. static inline struct sk_buff *__skb_dequeue(struct sk_buff_head *list)
  632. {
  633. struct sk_buff *next, *prev, *result;
  634. prev = (struct sk_buff *) list;
  635. next = prev->next;
  636. result = NULL;
  637. if (next != prev) {
  638. result = next;
  639. next = next->next;
  640. list->qlen--;
  641. next->prev = prev;
  642. prev->next = next;
  643. result->next = result->prev = NULL;
  644. }
  645. return result;
  646. }
  647. /*
  648. * Insert a packet on a list.
  649. */
  650. extern void skb_insert(struct sk_buff *old, struct sk_buff *newsk, struct sk_buff_head *list);
  651. static inline void __skb_insert(struct sk_buff *newsk,
  652. struct sk_buff *prev, struct sk_buff *next,
  653. struct sk_buff_head *list)
  654. {
  655. newsk->next = next;
  656. newsk->prev = prev;
  657. next->prev = prev->next = newsk;
  658. list->qlen++;
  659. }
  660. /*
  661. * Place a packet after a given packet in a list.
  662. */
  663. extern void skb_append(struct sk_buff *old, struct sk_buff *newsk, struct sk_buff_head *list);
  664. static inline void __skb_append(struct sk_buff *old, struct sk_buff *newsk, struct sk_buff_head *list)
  665. {
  666. __skb_insert(newsk, old, old->next, list);
  667. }
  668. /*
  669. * remove sk_buff from list. _Must_ be called atomically, and with
  670. * the list known..
  671. */
  672. extern void skb_unlink(struct sk_buff *skb, struct sk_buff_head *list);
  673. static inline void __skb_unlink(struct sk_buff *skb, struct sk_buff_head *list)
  674. {
  675. struct sk_buff *next, *prev;
  676. list->qlen--;
  677. next = skb->next;
  678. prev = skb->prev;
  679. skb->next = skb->prev = NULL;
  680. next->prev = prev;
  681. prev->next = next;
  682. }
  683. /* XXX: more streamlined implementation */
  684. /**
  685. * __skb_dequeue_tail - remove from the tail of the queue
  686. * @list: list to dequeue from
  687. *
  688. * Remove the tail of the list. This function does not take any locks
  689. * so must be used with appropriate locks held only. The tail item is
  690. * returned or %NULL if the list is empty.
  691. */
  692. extern struct sk_buff *skb_dequeue_tail(struct sk_buff_head *list);
  693. static inline struct sk_buff *__skb_dequeue_tail(struct sk_buff_head *list)
  694. {
  695. struct sk_buff *skb = skb_peek_tail(list);
  696. if (skb)
  697. __skb_unlink(skb, list);
  698. return skb;
  699. }
  700. static inline int skb_is_nonlinear(const struct sk_buff *skb)
  701. {
  702. return skb->data_len;
  703. }
  704. static inline unsigned int skb_headlen(const struct sk_buff *skb)
  705. {
  706. return skb->len - skb->data_len;
  707. }
  708. static inline int skb_pagelen(const struct sk_buff *skb)
  709. {
  710. int i, len = 0;
  711. for (i = (int)skb_shinfo(skb)->nr_frags - 1; i >= 0; i--)
  712. len += skb_shinfo(skb)->frags[i].size;
  713. return len + skb_headlen(skb);
  714. }
  715. static inline void skb_fill_page_desc(struct sk_buff *skb, int i,
  716. struct page *page, int off, int size)
  717. {
  718. skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
  719. frag->page = page;
  720. frag->page_offset = off;
  721. frag->size = size;
  722. skb_shinfo(skb)->nr_frags = i + 1;
  723. }
  724. #define SKB_PAGE_ASSERT(skb) BUG_ON(skb_shinfo(skb)->nr_frags)
  725. #define SKB_FRAG_ASSERT(skb) BUG_ON(skb_shinfo(skb)->frag_list)
  726. #define SKB_LINEAR_ASSERT(skb) BUG_ON(skb_is_nonlinear(skb))
  727. /*
  728. * Add data to an sk_buff
  729. */
  730. static inline unsigned char *__skb_put(struct sk_buff *skb, unsigned int len)
  731. {
  732. unsigned char *tmp = skb->tail;
  733. SKB_LINEAR_ASSERT(skb);
  734. skb->tail += len;
  735. skb->len += len;
  736. return tmp;
  737. }
  738. /**
  739. * skb_put - add data to a buffer
  740. * @skb: buffer to use
  741. * @len: amount of data to add
  742. *
  743. * This function extends the used data area of the buffer. If this would
  744. * exceed the total buffer size the kernel will panic. A pointer to the
  745. * first byte of the extra data is returned.
  746. */
  747. static inline unsigned char *skb_put(struct sk_buff *skb, unsigned int len)
  748. {
  749. unsigned char *tmp = skb->tail;
  750. SKB_LINEAR_ASSERT(skb);
  751. skb->tail += len;
  752. skb->len += len;
  753. if (unlikely(skb->tail>skb->end))
  754. skb_over_panic(skb, len, current_text_addr());
  755. return tmp;
  756. }
  757. static inline unsigned char *__skb_push(struct sk_buff *skb, unsigned int len)
  758. {
  759. skb->data -= len;
  760. skb->len += len;
  761. return skb->data;
  762. }
  763. /**
  764. * skb_push - add data to the start of a buffer
  765. * @skb: buffer to use
  766. * @len: amount of data to add
  767. *
  768. * This function extends the used data area of the buffer at the buffer
  769. * start. If this would exceed the total buffer headroom the kernel will
  770. * panic. A pointer to the first byte of the extra data is returned.
  771. */
  772. static inline unsigned char *skb_push(struct sk_buff *skb, unsigned int len)
  773. {
  774. skb->data -= len;
  775. skb->len += len;
  776. if (unlikely(skb->data<skb->head))
  777. skb_under_panic(skb, len, current_text_addr());
  778. return skb->data;
  779. }
  780. static inline unsigned char *__skb_pull(struct sk_buff *skb, unsigned int len)
  781. {
  782. skb->len -= len;
  783. BUG_ON(skb->len < skb->data_len);
  784. return skb->data += len;
  785. }
  786. /**
  787. * skb_pull - remove data from the start of a buffer
  788. * @skb: buffer to use
  789. * @len: amount of data to remove
  790. *
  791. * This function removes data from the start of a buffer, returning
  792. * the memory to the headroom. A pointer to the next data in the buffer
  793. * is returned. Once the data has been pulled future pushes will overwrite
  794. * the old data.
  795. */
  796. static inline unsigned char *skb_pull(struct sk_buff *skb, unsigned int len)
  797. {
  798. return unlikely(len > skb->len) ? NULL : __skb_pull(skb, len);
  799. }
  800. extern unsigned char *__pskb_pull_tail(struct sk_buff *skb, int delta);
  801. static inline unsigned char *__pskb_pull(struct sk_buff *skb, unsigned int len)
  802. {
  803. if (len > skb_headlen(skb) &&
  804. !__pskb_pull_tail(skb, len-skb_headlen(skb)))
  805. return NULL;
  806. skb->len -= len;
  807. return skb->data += len;
  808. }
  809. static inline unsigned char *pskb_pull(struct sk_buff *skb, unsigned int len)
  810. {
  811. return unlikely(len > skb->len) ? NULL : __pskb_pull(skb, len);
  812. }
  813. static inline int pskb_may_pull(struct sk_buff *skb, unsigned int len)
  814. {
  815. if (likely(len <= skb_headlen(skb)))
  816. return 1;
  817. if (unlikely(len > skb->len))
  818. return 0;
  819. return __pskb_pull_tail(skb, len-skb_headlen(skb)) != NULL;
  820. }
  821. /**
  822. * skb_headroom - bytes at buffer head
  823. * @skb: buffer to check
  824. *
  825. * Return the number of bytes of free space at the head of an &sk_buff.
  826. */
  827. static inline int skb_headroom(const struct sk_buff *skb)
  828. {
  829. return skb->data - skb->head;
  830. }
  831. /**
  832. * skb_tailroom - bytes at buffer end
  833. * @skb: buffer to check
  834. *
  835. * Return the number of bytes of free space at the tail of an sk_buff
  836. */
  837. static inline int skb_tailroom(const struct sk_buff *skb)
  838. {
  839. return skb_is_nonlinear(skb) ? 0 : skb->end - skb->tail;
  840. }
  841. /**
  842. * skb_reserve - adjust headroom
  843. * @skb: buffer to alter
  844. * @len: bytes to move
  845. *
  846. * Increase the headroom of an empty &sk_buff by reducing the tail
  847. * room. This is only allowed for an empty buffer.
  848. */
  849. static inline void skb_reserve(struct sk_buff *skb, int len)
  850. {
  851. skb->data += len;
  852. skb->tail += len;
  853. }
  854. static inline void skb_reset_transport_header(struct sk_buff *skb)
  855. {
  856. skb->h.raw = skb->data;
  857. }
  858. static inline void skb_set_transport_header(struct sk_buff *skb,
  859. const int offset)
  860. {
  861. skb->h.raw = skb->data + offset;
  862. }
  863. static inline int skb_transport_offset(const struct sk_buff *skb)
  864. {
  865. return skb->h.raw - skb->data;
  866. }
  867. static inline unsigned char *skb_network_header(const struct sk_buff *skb)
  868. {
  869. return skb->nh.raw;
  870. }
  871. static inline void skb_reset_network_header(struct sk_buff *skb)
  872. {
  873. skb->nh.raw = skb->data;
  874. }
  875. static inline void skb_set_network_header(struct sk_buff *skb, const int offset)
  876. {
  877. skb->nh.raw = skb->data + offset;
  878. }
  879. static inline int skb_network_offset(const struct sk_buff *skb)
  880. {
  881. return skb->nh.raw - skb->data;
  882. }
  883. static inline unsigned char *skb_mac_header(const struct sk_buff *skb)
  884. {
  885. return skb->mac.raw;
  886. }
  887. static inline int skb_mac_header_was_set(const struct sk_buff *skb)
  888. {
  889. return skb->mac.raw != NULL;
  890. }
  891. static inline void skb_reset_mac_header(struct sk_buff *skb)
  892. {
  893. skb->mac.raw = skb->data;
  894. }
  895. static inline void skb_set_mac_header(struct sk_buff *skb, const int offset)
  896. {
  897. skb->mac.raw = skb->data + offset;
  898. }
  899. /*
  900. * CPUs often take a performance hit when accessing unaligned memory
  901. * locations. The actual performance hit varies, it can be small if the
  902. * hardware handles it or large if we have to take an exception and fix it
  903. * in software.
  904. *
  905. * Since an ethernet header is 14 bytes network drivers often end up with
  906. * the IP header at an unaligned offset. The IP header can be aligned by
  907. * shifting the start of the packet by 2 bytes. Drivers should do this
  908. * with:
  909. *
  910. * skb_reserve(NET_IP_ALIGN);
  911. *
  912. * The downside to this alignment of the IP header is that the DMA is now
  913. * unaligned. On some architectures the cost of an unaligned DMA is high
  914. * and this cost outweighs the gains made by aligning the IP header.
  915. *
  916. * Since this trade off varies between architectures, we allow NET_IP_ALIGN
  917. * to be overridden.
  918. */
  919. #ifndef NET_IP_ALIGN
  920. #define NET_IP_ALIGN 2
  921. #endif
  922. /*
  923. * The networking layer reserves some headroom in skb data (via
  924. * dev_alloc_skb). This is used to avoid having to reallocate skb data when
  925. * the header has to grow. In the default case, if the header has to grow
  926. * 16 bytes or less we avoid the reallocation.
  927. *
  928. * Unfortunately this headroom changes the DMA alignment of the resulting
  929. * network packet. As for NET_IP_ALIGN, this unaligned DMA is expensive
  930. * on some architectures. An architecture can override this value,
  931. * perhaps setting it to a cacheline in size (since that will maintain
  932. * cacheline alignment of the DMA). It must be a power of 2.
  933. *
  934. * Various parts of the networking layer expect at least 16 bytes of
  935. * headroom, you should not reduce this.
  936. */
  937. #ifndef NET_SKB_PAD
  938. #define NET_SKB_PAD 16
  939. #endif
  940. extern int ___pskb_trim(struct sk_buff *skb, unsigned int len);
  941. static inline void __skb_trim(struct sk_buff *skb, unsigned int len)
  942. {
  943. if (unlikely(skb->data_len)) {
  944. WARN_ON(1);
  945. return;
  946. }
  947. skb->len = len;
  948. skb->tail = skb->data + len;
  949. }
  950. /**
  951. * skb_trim - remove end from a buffer
  952. * @skb: buffer to alter
  953. * @len: new length
  954. *
  955. * Cut the length of a buffer down by removing data from the tail. If
  956. * the buffer is already under the length specified it is not modified.
  957. * The skb must be linear.
  958. */
  959. static inline void skb_trim(struct sk_buff *skb, unsigned int len)
  960. {
  961. if (skb->len > len)
  962. __skb_trim(skb, len);
  963. }
  964. static inline int __pskb_trim(struct sk_buff *skb, unsigned int len)
  965. {
  966. if (skb->data_len)
  967. return ___pskb_trim(skb, len);
  968. __skb_trim(skb, len);
  969. return 0;
  970. }
  971. static inline int pskb_trim(struct sk_buff *skb, unsigned int len)
  972. {
  973. return (len < skb->len) ? __pskb_trim(skb, len) : 0;
  974. }
  975. /**
  976. * pskb_trim_unique - remove end from a paged unique (not cloned) buffer
  977. * @skb: buffer to alter
  978. * @len: new length
  979. *
  980. * This is identical to pskb_trim except that the caller knows that
  981. * the skb is not cloned so we should never get an error due to out-
  982. * of-memory.
  983. */
  984. static inline void pskb_trim_unique(struct sk_buff *skb, unsigned int len)
  985. {
  986. int err = pskb_trim(skb, len);
  987. BUG_ON(err);
  988. }
  989. /**
  990. * skb_orphan - orphan a buffer
  991. * @skb: buffer to orphan
  992. *
  993. * If a buffer currently has an owner then we call the owner's
  994. * destructor function and make the @skb unowned. The buffer continues
  995. * to exist but is no longer charged to its former owner.
  996. */
  997. static inline void skb_orphan(struct sk_buff *skb)
  998. {
  999. if (skb->destructor)
  1000. skb->destructor(skb);
  1001. skb->destructor = NULL;
  1002. skb->sk = NULL;
  1003. }
  1004. /**
  1005. * __skb_queue_purge - empty a list
  1006. * @list: list to empty
  1007. *
  1008. * Delete all buffers on an &sk_buff list. Each buffer is removed from
  1009. * the list and one reference dropped. This function does not take the
  1010. * list lock and the caller must hold the relevant locks to use it.
  1011. */
  1012. extern void skb_queue_purge(struct sk_buff_head *list);
  1013. static inline void __skb_queue_purge(struct sk_buff_head *list)
  1014. {
  1015. struct sk_buff *skb;
  1016. while ((skb = __skb_dequeue(list)) != NULL)
  1017. kfree_skb(skb);
  1018. }
  1019. /**
  1020. * __dev_alloc_skb - allocate an skbuff for receiving
  1021. * @length: length to allocate
  1022. * @gfp_mask: get_free_pages mask, passed to alloc_skb
  1023. *
  1024. * Allocate a new &sk_buff and assign it a usage count of one. The
  1025. * buffer has unspecified headroom built in. Users should allocate
  1026. * the headroom they think they need without accounting for the
  1027. * built in space. The built in space is used for optimisations.
  1028. *
  1029. * %NULL is returned if there is no free memory.
  1030. */
  1031. static inline struct sk_buff *__dev_alloc_skb(unsigned int length,
  1032. gfp_t gfp_mask)
  1033. {
  1034. struct sk_buff *skb = alloc_skb(length + NET_SKB_PAD, gfp_mask);
  1035. if (likely(skb))
  1036. skb_reserve(skb, NET_SKB_PAD);
  1037. return skb;
  1038. }
  1039. /**
  1040. * dev_alloc_skb - allocate an skbuff for receiving
  1041. * @length: length to allocate
  1042. *
  1043. * Allocate a new &sk_buff and assign it a usage count of one. The
  1044. * buffer has unspecified headroom built in. Users should allocate
  1045. * the headroom they think they need without accounting for the
  1046. * built in space. The built in space is used for optimisations.
  1047. *
  1048. * %NULL is returned if there is no free memory. Although this function
  1049. * allocates memory it can be called from an interrupt.
  1050. */
  1051. static inline struct sk_buff *dev_alloc_skb(unsigned int length)
  1052. {
  1053. return __dev_alloc_skb(length, GFP_ATOMIC);
  1054. }
  1055. extern struct sk_buff *__netdev_alloc_skb(struct net_device *dev,
  1056. unsigned int length, gfp_t gfp_mask);
  1057. /**
  1058. * netdev_alloc_skb - allocate an skbuff for rx on a specific device
  1059. * @dev: network device to receive on
  1060. * @length: length to allocate
  1061. *
  1062. * Allocate a new &sk_buff and assign it a usage count of one. The
  1063. * buffer has unspecified headroom built in. Users should allocate
  1064. * the headroom they think they need without accounting for the
  1065. * built in space. The built in space is used for optimisations.
  1066. *
  1067. * %NULL is returned if there is no free memory. Although this function
  1068. * allocates memory it can be called from an interrupt.
  1069. */
  1070. static inline struct sk_buff *netdev_alloc_skb(struct net_device *dev,
  1071. unsigned int length)
  1072. {
  1073. return __netdev_alloc_skb(dev, length, GFP_ATOMIC);
  1074. }
  1075. /**
  1076. * skb_cow - copy header of skb when it is required
  1077. * @skb: buffer to cow
  1078. * @headroom: needed headroom
  1079. *
  1080. * If the skb passed lacks sufficient headroom or its data part
  1081. * is shared, data is reallocated. If reallocation fails, an error
  1082. * is returned and original skb is not changed.
  1083. *
  1084. * The result is skb with writable area skb->head...skb->tail
  1085. * and at least @headroom of space at head.
  1086. */
  1087. static inline int skb_cow(struct sk_buff *skb, unsigned int headroom)
  1088. {
  1089. int delta = (headroom > NET_SKB_PAD ? headroom : NET_SKB_PAD) -
  1090. skb_headroom(skb);
  1091. if (delta < 0)
  1092. delta = 0;
  1093. if (delta || skb_cloned(skb))
  1094. return pskb_expand_head(skb, (delta + (NET_SKB_PAD-1)) &
  1095. ~(NET_SKB_PAD-1), 0, GFP_ATOMIC);
  1096. return 0;
  1097. }
  1098. /**
  1099. * skb_padto - pad an skbuff up to a minimal size
  1100. * @skb: buffer to pad
  1101. * @len: minimal length
  1102. *
  1103. * Pads up a buffer to ensure the trailing bytes exist and are
  1104. * blanked. If the buffer already contains sufficient data it
  1105. * is untouched. Otherwise it is extended. Returns zero on
  1106. * success. The skb is freed on error.
  1107. */
  1108. static inline int skb_padto(struct sk_buff *skb, unsigned int len)
  1109. {
  1110. unsigned int size = skb->len;
  1111. if (likely(size >= len))
  1112. return 0;
  1113. return skb_pad(skb, len-size);
  1114. }
  1115. static inline int skb_add_data(struct sk_buff *skb,
  1116. char __user *from, int copy)
  1117. {
  1118. const int off = skb->len;
  1119. if (skb->ip_summed == CHECKSUM_NONE) {
  1120. int err = 0;
  1121. __wsum csum = csum_and_copy_from_user(from, skb_put(skb, copy),
  1122. copy, 0, &err);
  1123. if (!err) {
  1124. skb->csum = csum_block_add(skb->csum, csum, off);
  1125. return 0;
  1126. }
  1127. } else if (!copy_from_user(skb_put(skb, copy), from, copy))
  1128. return 0;
  1129. __skb_trim(skb, off);
  1130. return -EFAULT;
  1131. }
  1132. static inline int skb_can_coalesce(struct sk_buff *skb, int i,
  1133. struct page *page, int off)
  1134. {
  1135. if (i) {
  1136. struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i - 1];
  1137. return page == frag->page &&
  1138. off == frag->page_offset + frag->size;
  1139. }
  1140. return 0;
  1141. }
  1142. static inline int __skb_linearize(struct sk_buff *skb)
  1143. {
  1144. return __pskb_pull_tail(skb, skb->data_len) ? 0 : -ENOMEM;
  1145. }
  1146. /**
  1147. * skb_linearize - convert paged skb to linear one
  1148. * @skb: buffer to linarize
  1149. *
  1150. * If there is no free memory -ENOMEM is returned, otherwise zero
  1151. * is returned and the old skb data released.
  1152. */
  1153. static inline int skb_linearize(struct sk_buff *skb)
  1154. {
  1155. return skb_is_nonlinear(skb) ? __skb_linearize(skb) : 0;
  1156. }
  1157. /**
  1158. * skb_linearize_cow - make sure skb is linear and writable
  1159. * @skb: buffer to process
  1160. *
  1161. * If there is no free memory -ENOMEM is returned, otherwise zero
  1162. * is returned and the old skb data released.
  1163. */
  1164. static inline int skb_linearize_cow(struct sk_buff *skb)
  1165. {
  1166. return skb_is_nonlinear(skb) || skb_cloned(skb) ?
  1167. __skb_linearize(skb) : 0;
  1168. }
  1169. /**
  1170. * skb_postpull_rcsum - update checksum for received skb after pull
  1171. * @skb: buffer to update
  1172. * @start: start of data before pull
  1173. * @len: length of data pulled
  1174. *
  1175. * After doing a pull on a received packet, you need to call this to
  1176. * update the CHECKSUM_COMPLETE checksum, or set ip_summed to
  1177. * CHECKSUM_NONE so that it can be recomputed from scratch.
  1178. */
  1179. static inline void skb_postpull_rcsum(struct sk_buff *skb,
  1180. const void *start, unsigned int len)
  1181. {
  1182. if (skb->ip_summed == CHECKSUM_COMPLETE)
  1183. skb->csum = csum_sub(skb->csum, csum_partial(start, len, 0));
  1184. }
  1185. unsigned char *skb_pull_rcsum(struct sk_buff *skb, unsigned int len);
  1186. /**
  1187. * pskb_trim_rcsum - trim received skb and update checksum
  1188. * @skb: buffer to trim
  1189. * @len: new length
  1190. *
  1191. * This is exactly the same as pskb_trim except that it ensures the
  1192. * checksum of received packets are still valid after the operation.
  1193. */
  1194. static inline int pskb_trim_rcsum(struct sk_buff *skb, unsigned int len)
  1195. {
  1196. if (likely(len >= skb->len))
  1197. return 0;
  1198. if (skb->ip_summed == CHECKSUM_COMPLETE)
  1199. skb->ip_summed = CHECKSUM_NONE;
  1200. return __pskb_trim(skb, len);
  1201. }
  1202. #define skb_queue_walk(queue, skb) \
  1203. for (skb = (queue)->next; \
  1204. prefetch(skb->next), (skb != (struct sk_buff *)(queue)); \
  1205. skb = skb->next)
  1206. #define skb_queue_reverse_walk(queue, skb) \
  1207. for (skb = (queue)->prev; \
  1208. prefetch(skb->prev), (skb != (struct sk_buff *)(queue)); \
  1209. skb = skb->prev)
  1210. extern struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags,
  1211. int noblock, int *err);
  1212. extern unsigned int datagram_poll(struct file *file, struct socket *sock,
  1213. struct poll_table_struct *wait);
  1214. extern int skb_copy_datagram_iovec(const struct sk_buff *from,
  1215. int offset, struct iovec *to,
  1216. int size);
  1217. extern int skb_copy_and_csum_datagram_iovec(struct sk_buff *skb,
  1218. int hlen,
  1219. struct iovec *iov);
  1220. extern void skb_free_datagram(struct sock *sk, struct sk_buff *skb);
  1221. extern void skb_kill_datagram(struct sock *sk, struct sk_buff *skb,
  1222. unsigned int flags);
  1223. extern __wsum skb_checksum(const struct sk_buff *skb, int offset,
  1224. int len, __wsum csum);
  1225. extern int skb_copy_bits(const struct sk_buff *skb, int offset,
  1226. void *to, int len);
  1227. extern int skb_store_bits(const struct sk_buff *skb, int offset,
  1228. void *from, int len);
  1229. extern __wsum skb_copy_and_csum_bits(const struct sk_buff *skb,
  1230. int offset, u8 *to, int len,
  1231. __wsum csum);
  1232. extern void skb_copy_and_csum_dev(const struct sk_buff *skb, u8 *to);
  1233. extern void skb_split(struct sk_buff *skb,
  1234. struct sk_buff *skb1, const u32 len);
  1235. extern struct sk_buff *skb_segment(struct sk_buff *skb, int features);
  1236. static inline void *skb_header_pointer(const struct sk_buff *skb, int offset,
  1237. int len, void *buffer)
  1238. {
  1239. int hlen = skb_headlen(skb);
  1240. if (hlen - offset >= len)
  1241. return skb->data + offset;
  1242. if (skb_copy_bits(skb, offset, buffer, len) < 0)
  1243. return NULL;
  1244. return buffer;
  1245. }
  1246. extern void skb_init(void);
  1247. extern void skb_add_mtu(int mtu);
  1248. /**
  1249. * skb_get_timestamp - get timestamp from a skb
  1250. * @skb: skb to get stamp from
  1251. * @stamp: pointer to struct timeval to store stamp in
  1252. *
  1253. * Timestamps are stored in the skb as offsets to a base timestamp.
  1254. * This function converts the offset back to a struct timeval and stores
  1255. * it in stamp.
  1256. */
  1257. static inline void skb_get_timestamp(const struct sk_buff *skb, struct timeval *stamp)
  1258. {
  1259. *stamp = ktime_to_timeval(skb->tstamp);
  1260. }
  1261. static inline void __net_timestamp(struct sk_buff *skb)
  1262. {
  1263. skb->tstamp = ktime_get_real();
  1264. }
  1265. extern __sum16 __skb_checksum_complete_head(struct sk_buff *skb, int len);
  1266. extern __sum16 __skb_checksum_complete(struct sk_buff *skb);
  1267. /**
  1268. * skb_checksum_complete - Calculate checksum of an entire packet
  1269. * @skb: packet to process
  1270. *
  1271. * This function calculates the checksum over the entire packet plus
  1272. * the value of skb->csum. The latter can be used to supply the
  1273. * checksum of a pseudo header as used by TCP/UDP. It returns the
  1274. * checksum.
  1275. *
  1276. * For protocols that contain complete checksums such as ICMP/TCP/UDP,
  1277. * this function can be used to verify that checksum on received
  1278. * packets. In that case the function should return zero if the
  1279. * checksum is correct. In particular, this function will return zero
  1280. * if skb->ip_summed is CHECKSUM_UNNECESSARY which indicates that the
  1281. * hardware has already verified the correctness of the checksum.
  1282. */
  1283. static inline unsigned int skb_checksum_complete(struct sk_buff *skb)
  1284. {
  1285. return skb->ip_summed != CHECKSUM_UNNECESSARY &&
  1286. __skb_checksum_complete(skb);
  1287. }
  1288. #ifdef CONFIG_NETFILTER
  1289. static inline void nf_conntrack_put(struct nf_conntrack *nfct)
  1290. {
  1291. if (nfct && atomic_dec_and_test(&nfct->use))
  1292. nfct->destroy(nfct);
  1293. }
  1294. static inline void nf_conntrack_get(struct nf_conntrack *nfct)
  1295. {
  1296. if (nfct)
  1297. atomic_inc(&nfct->use);
  1298. }
  1299. #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
  1300. static inline void nf_conntrack_get_reasm(struct sk_buff *skb)
  1301. {
  1302. if (skb)
  1303. atomic_inc(&skb->users);
  1304. }
  1305. static inline void nf_conntrack_put_reasm(struct sk_buff *skb)
  1306. {
  1307. if (skb)
  1308. kfree_skb(skb);
  1309. }
  1310. #endif
  1311. #ifdef CONFIG_BRIDGE_NETFILTER
  1312. static inline void nf_bridge_put(struct nf_bridge_info *nf_bridge)
  1313. {
  1314. if (nf_bridge && atomic_dec_and_test(&nf_bridge->use))
  1315. kfree(nf_bridge);
  1316. }
  1317. static inline void nf_bridge_get(struct nf_bridge_info *nf_bridge)
  1318. {
  1319. if (nf_bridge)
  1320. atomic_inc(&nf_bridge->use);
  1321. }
  1322. #endif /* CONFIG_BRIDGE_NETFILTER */
  1323. static inline void nf_reset(struct sk_buff *skb)
  1324. {
  1325. nf_conntrack_put(skb->nfct);
  1326. skb->nfct = NULL;
  1327. #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
  1328. nf_conntrack_put_reasm(skb->nfct_reasm);
  1329. skb->nfct_reasm = NULL;
  1330. #endif
  1331. #ifdef CONFIG_BRIDGE_NETFILTER
  1332. nf_bridge_put(skb->nf_bridge);
  1333. skb->nf_bridge = NULL;
  1334. #endif
  1335. }
  1336. #else /* CONFIG_NETFILTER */
  1337. static inline void nf_reset(struct sk_buff *skb) {}
  1338. #endif /* CONFIG_NETFILTER */
  1339. #ifdef CONFIG_NETWORK_SECMARK
  1340. static inline void skb_copy_secmark(struct sk_buff *to, const struct sk_buff *from)
  1341. {
  1342. to->secmark = from->secmark;
  1343. }
  1344. static inline void skb_init_secmark(struct sk_buff *skb)
  1345. {
  1346. skb->secmark = 0;
  1347. }
  1348. #else
  1349. static inline void skb_copy_secmark(struct sk_buff *to, const struct sk_buff *from)
  1350. { }
  1351. static inline void skb_init_secmark(struct sk_buff *skb)
  1352. { }
  1353. #endif
  1354. static inline int skb_is_gso(const struct sk_buff *skb)
  1355. {
  1356. return skb_shinfo(skb)->gso_size;
  1357. }
  1358. #endif /* __KERNEL__ */
  1359. #endif /* _LINUX_SKBUFF_H */