skbuff.h 41 KB

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