1 /* 2 * Definitions for the 'struct sk_buff' memory handlers. 3 * 4 * Authors: 5 * Alan Cox, <[email protected]> 6 * Florian La Roche, <[email protected]> 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License 10 * as published by the Free Software Foundation; either version 11 * 2 of the License, or (at your option) any later version. 12 */ 13 14 #ifndef _LINUX_SKBUFF_H 15 #define _LINUX_SKBUFF_H 16 17 #include <linux/kernel.h> 18 #include <linux/kmemcheck.h> 19 #include <linux/compiler.h> 20 #include <linux/time.h> 21 #include <linux/cache.h> 22 23 #include <asm/atomic.h> 24 #include <asm/types.h> 25 #include <linux/spinlock.h> 26 #include <linux/net.h> 27 #include <linux/textsearch.h> 28 #include <net/checksum.h> 29 #include <linux/rcupdate.h> 30 #include <linux/dmaengine.h> 31 #include <linux/hrtimer.h> 32 33 /* Don't change this without changing skb_csum_unnecessary! */ 34 #define CHECKSUM_NONE 0 35 #define CHECKSUM_UNNECESSARY 1 36 #define CHECKSUM_COMPLETE 2 37 #define CHECKSUM_PARTIAL 3 38 39 #define SKB_DATA_ALIGN(X) (((X) + (SMP_CACHE_BYTES - 1)) & \ 40 ~(SMP_CACHE_BYTES - 1)) 41 #define SKB_WITH_OVERHEAD(X) \ 42 ((X) - SKB_DATA_ALIGN(sizeof(struct skb_shared_info))) 43 #define SKB_MAX_ORDER(X, ORDER) \ 44 SKB_WITH_OVERHEAD((PAGE_SIZE << (ORDER)) - (X)) 45 #define SKB_MAX_HEAD(X) (SKB_MAX_ORDER((X), 0)) 46 #define SKB_MAX_ALLOC (SKB_MAX_ORDER(0, 2)) 47 48 /* A. Checksumming of received packets by device. 49 * 50 * NONE: device failed to checksum this packet. 51 * skb->csum is undefined. 52 * 53 * UNNECESSARY: device parsed packet and wouldbe verified checksum. 54 * skb->csum is undefined. 55 * It is bad option, but, unfortunately, many of vendors do this. 56 * Apparently with secret goal to sell you new device, when you 57 * will add new protocol to your host. F.e. IPv6. 8) 58 * 59 * COMPLETE: the most generic way. Device supplied checksum of _all_ 60 * the packet as seen by netif_rx in skb->csum. 61 * NOTE: Even if device supports only some protocols, but 62 * is able to produce some skb->csum, it MUST use COMPLETE, 63 * not UNNECESSARY. 64 * 65 * PARTIAL: identical to the case for output below. This may occur 66 * on a packet received directly from another Linux OS, e.g., 67 * a virtualised Linux kernel on the same host. The packet can 68 * be treated in the same way as UNNECESSARY except that on 69 * output (i.e., forwarding) the checksum must be filled in 70 * by the OS or the hardware. 71 * 72 * B. Checksumming on output. 73 * 74 * NONE: skb is checksummed by protocol or csum is not required. 75 * 76 * PARTIAL: device is required to csum packet as seen by hard_start_xmit 77 * from skb->csum_start to the end and to record the checksum 78 * at skb->csum_start + skb->csum_offset. 79 * 80 * Device must show its capabilities in dev->features, set 81 * at device setup time. 82 * NETIF_F_HW_CSUM - it is clever device, it is able to checksum 83 * everything. 84 * NETIF_F_NO_CSUM - loopback or reliable single hop media. 85 * NETIF_F_IP_CSUM - device is dumb. It is able to csum only 86 * TCP/UDP over IPv4. Sigh. Vendors like this 87 * way by an unknown reason. Though, see comment above 88 * about CHECKSUM_UNNECESSARY. 8) 89 * NETIF_F_IPV6_CSUM about as dumb as the last one but does IPv6 instead. 90 * 91 * Any questions? No questions, good. --ANK 92 */ 93 94 struct net_device; 95 struct scatterlist; 96 struct pipe_inode_info; 97 98 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE) 99 struct nf_conntrack { 100 atomic_t use; 101 }; 102 #endif 103 104 #ifdef CONFIG_BRIDGE_NETFILTER 105 struct nf_bridge_info { 106 atomic_t use; 107 struct net_device *physindev; 108 struct net_device *physoutdev; 109 unsigned int mask; 110 unsigned long data[32 / sizeof(unsigned long)]; 111 }; 112 #endif 113 114 struct sk_buff_head { 115 /* These two members must be first. */ 116 struct sk_buff *next; 117 struct sk_buff *prev; 118 119 __u32 qlen; 120 spinlock_t lock; 121 }; 122 123 struct sk_buff; 124 125 /* To allow 64K frame to be packed as single skb without frag_list */ 126 #define MAX_SKB_FRAGS (65536/PAGE_SIZE + 2) 127 128 typedef struct skb_frag_struct skb_frag_t; 129 130 struct skb_frag_struct { 131 struct page *page; 132 __u32 page_offset; 133 __u32 size; 134 }; 135 136 #define HAVE_HW_TIME_STAMP 137 138 /** 139 * struct skb_shared_hwtstamps - hardware time stamps 140 * @hwtstamp: hardware time stamp transformed into duration 141 * since arbitrary point in time 142 * @syststamp: hwtstamp transformed to system time base 143 * 144 * Software time stamps generated by ktime_get_real() are stored in 145 * skb->tstamp. The relation between the different kinds of time 146 * stamps is as follows: 147 * 148 * syststamp and tstamp can be compared against each other in 149 * arbitrary combinations. The accuracy of a 150 * syststamp/tstamp/"syststamp from other device" comparison is 151 * limited by the accuracy of the transformation into system time 152 * base. This depends on the device driver and its underlying 153 * hardware. 154 * 155 * hwtstamps can only be compared against other hwtstamps from 156 * the same device. 157 * 158 * This structure is attached to packets as part of the 159 * &skb_shared_info. Use skb_hwtstamps() to get a pointer. 160 */ 161 struct skb_shared_hwtstamps { 162 ktime_t hwtstamp; 163 ktime_t syststamp; 164 }; 165 166 /** 167 * struct skb_shared_tx - instructions for time stamping of outgoing packets 168 * @hardware: generate hardware time stamp 169 * @software: generate software time stamp 170 * @in_progress: device driver is going to provide 171 * hardware time stamp 172 * @prevent_sk_orphan: make sk reference available on driver level 173 * @flags: all shared_tx flags 174 * 175 * These flags are attached to packets as part of the 176 * &skb_shared_info. Use skb_tx() to get a pointer. 177 */ 178 union skb_shared_tx { 179 struct { 180 __u8 hardware:1, 181 software:1, 182 in_progress:1, 183 prevent_sk_orphan:1; 184 }; 185 __u8 flags; 186 }; 187 188 /* This data is invariant across clones and lives at 189 * the end of the header data, ie. at skb->end. 190 */ 191 struct skb_shared_info { 192 unsigned short nr_frags; 193 unsigned short gso_size; 194 /* Warning: this field is not always filled in (UFO)! */ 195 unsigned short gso_segs; 196 unsigned short gso_type; 197 __be32 ip6_frag_id; 198 union skb_shared_tx tx_flags; 199 struct sk_buff *frag_list; 200 struct skb_shared_hwtstamps hwtstamps; 201 202 /* 203 * Warning : all fields before dataref are cleared in __alloc_skb() 204 */ 205 atomic_t dataref; 206 207 /* Intermediate layers must ensure that destructor_arg 208 * remains valid until skb destructor */ 209 void * destructor_arg; 210 /* must be last field, see pskb_expand_head() */ 211 skb_frag_t frags[MAX_SKB_FRAGS]; 212 }; 213 214 /* We divide dataref into two halves. The higher 16 bits hold references 215 * to the payload part of skb->data. The lower 16 bits hold references to 216 * the entire skb->data. A clone of a headerless skb holds the length of 217 * the header in skb->hdr_len. 218 * 219 * All users must obey the rule that the skb->data reference count must be 220 * greater than or equal to the payload reference count. 221 * 222 * Holding a reference to the payload part means that the user does not 223 * care about modifications to the header part of skb->data. 224 */ 225 #define SKB_DATAREF_SHIFT 16 226 #define SKB_DATAREF_MASK ((1 << SKB_DATAREF_SHIFT) - 1) 227 228 229 enum { 230 SKB_FCLONE_UNAVAILABLE, 231 SKB_FCLONE_ORIG, 232 SKB_FCLONE_CLONE, 233 }; 234 235 enum { 236 SKB_GSO_TCPV4 = 1 << 0, 237 SKB_GSO_UDP = 1 << 1, 238 239 /* This indicates the skb is from an untrusted source. */ 240 SKB_GSO_DODGY = 1 << 2, 241 242 /* This indicates the tcp segment has CWR set. */ 243 SKB_GSO_TCP_ECN = 1 << 3, 244 245 SKB_GSO_TCPV6 = 1 << 4, 246 247 SKB_GSO_FCOE = 1 << 5, 248 }; 249 250 #if BITS_PER_LONG > 32 251 #define NET_SKBUFF_DATA_USES_OFFSET 1 252 #endif 253 254 #ifdef NET_SKBUFF_DATA_USES_OFFSET 255 typedef unsigned int sk_buff_data_t; 256 #else 257 typedef unsigned char *sk_buff_data_t; 258 #endif 259 260 /** 261 * struct sk_buff - socket buffer 262 * @next: Next buffer in list 263 * @prev: Previous buffer in list 264 * @sk: Socket we are owned by 265 * @tstamp: Time we arrived 266 * @dev: Device we arrived on/are leaving by 267 * @transport_header: Transport layer header 268 * @network_header: Network layer header 269 * @mac_header: Link layer header 270 * @_skb_refdst: destination entry (with norefcount bit) 271 * @sp: the security path, used for xfrm 272 * @cb: Control buffer. Free for use by every layer. Put private vars here 273 * @len: Length of actual data 274 * @data_len: Data length 275 * @mac_len: Length of link layer header 276 * @hdr_len: writable header length of cloned skb 277 * @csum: Checksum (must include start/offset pair) 278 * @csum_start: Offset from skb->head where checksumming should start 279 * @csum_offset: Offset from csum_start where checksum should be stored 280 * @local_df: allow local fragmentation 281 * @cloned: Head may be cloned (check refcnt to be sure) 282 * @nohdr: Payload reference only, must not modify header 283 * @pkt_type: Packet class 284 * @fclone: skbuff clone status 285 * @ip_summed: Driver fed us an IP checksum 286 * @priority: Packet queueing priority 287 * @users: User count - see {datagram,tcp}.c 288 * @protocol: Packet protocol from driver 289 * @truesize: Buffer size 290 * @head: Head of buffer 291 * @data: Data head pointer 292 * @tail: Tail pointer 293 * @end: End pointer 294 * @destructor: Destruct function 295 * @mark: Generic packet mark 296 * @nfct: Associated connection, if any 297 * @ipvs_property: skbuff is owned by ipvs 298 * @peeked: this packet has been seen already, so stats have been 299 * done for it, don't do them again 300 * @nf_trace: netfilter packet trace flag 301 * @nfctinfo: Relationship of this skb to the connection 302 * @nfct_reasm: netfilter conntrack re-assembly pointer 303 * @nf_bridge: Saved data about a bridged frame - see br_netfilter.c 304 * @skb_iif: ifindex of device we arrived on 305 * @rxhash: the packet hash computed on receive 306 * @queue_mapping: Queue mapping for multiqueue devices 307 * @tc_index: Traffic control index 308 * @tc_verd: traffic control verdict 309 * @ndisc_nodetype: router type (from link layer) 310 * @dma_cookie: a cookie to one of several possible DMA operations 311 * done by skb DMA functions 312 * @secmark: security marking 313 * @vlan_tci: vlan tag control information 314 */ 315 316 struct sk_buff { 317 /* These two members must be first. */ 318 struct sk_buff *next; 319 struct sk_buff *prev; 320 321 ktime_t tstamp; 322 323 struct sock *sk; 324 struct net_device *dev; 325 326 /* 327 * This is the control buffer. It is free to use for every 328 * layer. Please put your private variables there. If you 329 * want to keep them across layers you have to do a skb_clone() 330 * first. This is owned by whoever has the skb queued ATM. 331 */ 332 char cb[48] __aligned(8); 333 334 unsigned long _skb_refdst; 335 #ifdef CONFIG_XFRM 336 struct sec_path *sp; 337 #endif 338 unsigned int len, 339 data_len; 340 __u16 mac_len, 341 hdr_len; 342 union { 343 __wsum csum; 344 struct { 345 __u16 csum_start; 346 __u16 csum_offset; 347 }; 348 }; 349 __u32 priority; 350 kmemcheck_bitfield_begin(flags1); 351 __u8 local_df:1, 352 cloned:1, 353 ip_summed:2, 354 nohdr:1, 355 nfctinfo:3; 356 __u8 pkt_type:3, 357 fclone:2, 358 ipvs_property:1, 359 peeked:1, 360 nf_trace:1; 361 kmemcheck_bitfield_end(flags1); 362 __be16 protocol; 363 364 void (*destructor)(struct sk_buff *skb); 365 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE) 366 struct nf_conntrack *nfct; 367 struct sk_buff *nfct_reasm; 368 #endif 369 #ifdef CONFIG_BRIDGE_NETFILTER 370 struct nf_bridge_info *nf_bridge; 371 #endif 372 373 int skb_iif; 374 #ifdef CONFIG_NET_SCHED 375 __u16 tc_index; /* traffic control index */ 376 #ifdef CONFIG_NET_CLS_ACT 377 __u16 tc_verd; /* traffic control verdict */ 378 #endif 379 #endif 380 381 __u32 rxhash; 382 383 kmemcheck_bitfield_begin(flags2); 384 __u16 queue_mapping:16; 385 #ifdef CONFIG_IPV6_NDISC_NODETYPE 386 __u8 ndisc_nodetype:2, 387 deliver_no_wcard:1; 388 #else 389 __u8 deliver_no_wcard:1; 390 #endif 391 kmemcheck_bitfield_end(flags2); 392 393 /* 0/14 bit hole */ 394 395 #ifdef CONFIG_NET_DMA 396 dma_cookie_t dma_cookie; 397 #endif 398 #ifdef CONFIG_NETWORK_SECMARK 399 __u32 secmark; 400 #endif 401 union { 402 __u32 mark; 403 __u32 dropcount; 404 }; 405 406 __u16 vlan_tci; 407 408 sk_buff_data_t transport_header; 409 sk_buff_data_t network_header; 410 sk_buff_data_t mac_header; 411 /* These elements must be at the end, see alloc_skb() for details. */ 412 sk_buff_data_t tail; 413 sk_buff_data_t end; 414 unsigned char *head, 415 *data; 416 unsigned int truesize; 417 atomic_t users; 418 }; 419 420 #ifdef __KERNEL__ 421 /* 422 * Handling routines are only of interest to the kernel 423 */ 424 #include <linux/slab.h> 425 426 #include <asm/system.h> 427 428 /* 429 * skb might have a dst pointer attached, refcounted or not. 430 * _skb_refdst low order bit is set if refcount was _not_ taken 431 */ 432 #define SKB_DST_NOREF 1UL 433 #define SKB_DST_PTRMASK ~(SKB_DST_NOREF) 434 435 /** 436 * skb_dst - returns skb dst_entry 437 * @skb: buffer 438 * 439 * Returns skb dst_entry, regardless of reference taken or not. 440 */ 441 static inline struct dst_entry *skb_dst(const struct sk_buff *skb) 442 { 443 /* If refdst was not refcounted, check we still are in a 444 * rcu_read_lock section 445 */ 446 WARN_ON((skb->_skb_refdst & SKB_DST_NOREF) && 447 !rcu_read_lock_held() && 448 !rcu_read_lock_bh_held()); 449 return (struct dst_entry *)(skb->_skb_refdst & SKB_DST_PTRMASK); 450 } 451 452 /** 453 * skb_dst_set - sets skb dst 454 * @skb: buffer 455 * @dst: dst entry 456 * 457 * Sets skb dst, assuming a reference was taken on dst and should 458 * be released by skb_dst_drop() 459 */ 460 static inline void skb_dst_set(struct sk_buff *skb, struct dst_entry *dst) 461 { 462 skb->_skb_refdst = (unsigned long)dst; 463 } 464 465 /** 466 * skb_dst_set_noref - sets skb dst, without a reference 467 * @skb: buffer 468 * @dst: dst entry 469 * 470 * Sets skb dst, assuming a reference was not taken on dst 471 * skb_dst_drop() should not dst_release() this dst 472 */ 473 static inline void skb_dst_set_noref(struct sk_buff *skb, struct dst_entry *dst) 474 { 475 WARN_ON(!rcu_read_lock_held() && !rcu_read_lock_bh_held()); 476 skb->_skb_refdst = (unsigned long)dst | SKB_DST_NOREF; 477 } 478 479 /** 480 * skb_dst_is_noref - Test if skb dst isnt refcounted 481 * @skb: buffer 482 */ 483 static inline bool skb_dst_is_noref(const struct sk_buff *skb) 484 { 485 return (skb->_skb_refdst & SKB_DST_NOREF) && skb_dst(skb); 486 } 487 488 static inline struct rtable *skb_rtable(const struct sk_buff *skb) 489 { 490 return (struct rtable *)skb_dst(skb); 491 } 492 493 extern void kfree_skb(struct sk_buff *skb); 494 extern void consume_skb(struct sk_buff *skb); 495 extern void __kfree_skb(struct sk_buff *skb); 496 extern struct sk_buff *__alloc_skb(unsigned int size, 497 gfp_t priority, int fclone, int node); 498 static inline struct sk_buff *alloc_skb(unsigned int size, 499 gfp_t priority) 500 { 501 return __alloc_skb(size, priority, 0, -1); 502 } 503 504 static inline struct sk_buff *alloc_skb_fclone(unsigned int size, 505 gfp_t priority) 506 { 507 return __alloc_skb(size, priority, 1, -1); 508 } 509 510 extern bool skb_recycle_check(struct sk_buff *skb, int skb_size); 511 512 extern struct sk_buff *skb_morph(struct sk_buff *dst, struct sk_buff *src); 513 extern struct sk_buff *skb_clone(struct sk_buff *skb, 514 gfp_t priority); 515 extern struct sk_buff *skb_copy(const struct sk_buff *skb, 516 gfp_t priority); 517 extern struct sk_buff *pskb_copy(struct sk_buff *skb, 518 gfp_t gfp_mask); 519 extern int pskb_expand_head(struct sk_buff *skb, 520 int nhead, int ntail, 521 gfp_t gfp_mask); 522 extern struct sk_buff *skb_realloc_headroom(struct sk_buff *skb, 523 unsigned int headroom); 524 extern struct sk_buff *skb_copy_expand(const struct sk_buff *skb, 525 int newheadroom, int newtailroom, 526 gfp_t priority); 527 extern int skb_to_sgvec(struct sk_buff *skb, 528 struct scatterlist *sg, int offset, 529 int len); 530 extern int skb_cow_data(struct sk_buff *skb, int tailbits, 531 struct sk_buff **trailer); 532 extern int skb_pad(struct sk_buff *skb, int pad); 533 #define dev_kfree_skb(a) consume_skb(a) 534 535 extern int skb_append_datato_frags(struct sock *sk, struct sk_buff *skb, 536 int getfrag(void *from, char *to, int offset, 537 int len,int odd, struct sk_buff *skb), 538 void *from, int length); 539 540 struct skb_seq_state { 541 __u32 lower_offset; 542 __u32 upper_offset; 543 __u32 frag_idx; 544 __u32 stepped_offset; 545 struct sk_buff *root_skb; 546 struct sk_buff *cur_skb; 547 __u8 *frag_data; 548 }; 549 550 extern void skb_prepare_seq_read(struct sk_buff *skb, 551 unsigned int from, unsigned int to, 552 struct skb_seq_state *st); 553 extern unsigned int skb_seq_read(unsigned int consumed, const u8 **data, 554 struct skb_seq_state *st); 555 extern void skb_abort_seq_read(struct skb_seq_state *st); 556 557 extern unsigned int skb_find_text(struct sk_buff *skb, unsigned int from, 558 unsigned int to, struct ts_config *config, 559 struct ts_state *state); 560 561 #ifdef NET_SKBUFF_DATA_USES_OFFSET 562 static inline unsigned char *skb_end_pointer(const struct sk_buff *skb) 563 { 564 return skb->head + skb->end; 565 } 566 #else 567 static inline unsigned char *skb_end_pointer(const struct sk_buff *skb) 568 { 569 return skb->end; 570 } 571 #endif 572 573 /* Internal */ 574 #define skb_shinfo(SKB) ((struct skb_shared_info *)(skb_end_pointer(SKB))) 575 576 static inline struct skb_shared_hwtstamps *skb_hwtstamps(struct sk_buff *skb) 577 { 578 return &skb_shinfo(skb)->hwtstamps; 579 } 580 581 static inline union skb_shared_tx *skb_tx(struct sk_buff *skb) 582 { 583 return &skb_shinfo(skb)->tx_flags; 584 } 585 586 /** 587 * skb_queue_empty - check if a queue is empty 588 * @list: queue head 589 * 590 * Returns true if the queue is empty, false otherwise. 591 */ 592 static inline int skb_queue_empty(const struct sk_buff_head *list) 593 { 594 return list->next == (struct sk_buff *)list; 595 } 596 597 /** 598 * skb_queue_is_last - check if skb is the last entry in the queue 599 * @list: queue head 600 * @skb: buffer 601 * 602 * Returns true if @skb is the last buffer on the list. 603 */ 604 static inline bool skb_queue_is_last(const struct sk_buff_head *list, 605 const struct sk_buff *skb) 606 { 607 return (skb->next == (struct sk_buff *) list); 608 } 609 610 /** 611 * skb_queue_is_first - check if skb is the first entry in the queue 612 * @list: queue head 613 * @skb: buffer 614 * 615 * Returns true if @skb is the first buffer on the list. 616 */ 617 static inline bool skb_queue_is_first(const struct sk_buff_head *list, 618 const struct sk_buff *skb) 619 { 620 return (skb->prev == (struct sk_buff *) list); 621 } 622 623 /** 624 * skb_queue_next - return the next packet in the queue 625 * @list: queue head 626 * @skb: current buffer 627 * 628 * Return the next packet in @list after @skb. It is only valid to 629 * call this if skb_queue_is_last() evaluates to false. 630 */ 631 static inline struct sk_buff *skb_queue_next(const struct sk_buff_head *list, 632 const struct sk_buff *skb) 633 { 634 /* This BUG_ON may seem severe, but if we just return then we 635 * are going to dereference garbage. 636 */ 637 BUG_ON(skb_queue_is_last(list, skb)); 638 return skb->next; 639 } 640 641 /** 642 * skb_queue_prev - return the prev packet in the queue 643 * @list: queue head 644 * @skb: current buffer 645 * 646 * Return the prev packet in @list before @skb. It is only valid to 647 * call this if skb_queue_is_first() evaluates to false. 648 */ 649 static inline struct sk_buff *skb_queue_prev(const struct sk_buff_head *list, 650 const struct sk_buff *skb) 651 { 652 /* This BUG_ON may seem severe, but if we just return then we 653 * are going to dereference garbage. 654 */ 655 BUG_ON(skb_queue_is_first(list, skb)); 656 return skb->prev; 657 } 658 659 /** 660 * skb_get - reference buffer 661 * @skb: buffer to reference 662 * 663 * Makes another reference to a socket buffer and returns a pointer 664 * to the buffer. 665 */ 666 static inline struct sk_buff *skb_get(struct sk_buff *skb) 667 { 668 atomic_inc(&skb->users); 669 return skb; 670 } 671 672 /* 673 * If users == 1, we are the only owner and are can avoid redundant 674 * atomic change. 675 */ 676 677 /** 678 * skb_cloned - is the buffer a clone 679 * @skb: buffer to check 680 * 681 * Returns true if the buffer was generated with skb_clone() and is 682 * one of multiple shared copies of the buffer. Cloned buffers are 683 * shared data so must not be written to under normal circumstances. 684 */ 685 static inline int skb_cloned(const struct sk_buff *skb) 686 { 687 return skb->cloned && 688 (atomic_read(&skb_shinfo(skb)->dataref) & SKB_DATAREF_MASK) != 1; 689 } 690 691 /** 692 * skb_header_cloned - is the header a clone 693 * @skb: buffer to check 694 * 695 * Returns true if modifying the header part of the buffer requires 696 * the data to be copied. 697 */ 698 static inline int skb_header_cloned(const struct sk_buff *skb) 699 { 700 int dataref; 701 702 if (!skb->cloned) 703 return 0; 704 705 dataref = atomic_read(&skb_shinfo(skb)->dataref); 706 dataref = (dataref & SKB_DATAREF_MASK) - (dataref >> SKB_DATAREF_SHIFT); 707 return dataref != 1; 708 } 709 710 /** 711 * skb_header_release - release reference to header 712 * @skb: buffer to operate on 713 * 714 * Drop a reference to the header part of the buffer. This is done 715 * by acquiring a payload reference. You must not read from the header 716 * part of skb->data after this. 717 */ 718 static inline void skb_header_release(struct sk_buff *skb) 719 { 720 BUG_ON(skb->nohdr); 721 skb->nohdr = 1; 722 atomic_add(1 << SKB_DATAREF_SHIFT, &skb_shinfo(skb)->dataref); 723 } 724 725 /** 726 * skb_shared - is the buffer shared 727 * @skb: buffer to check 728 * 729 * Returns true if more than one person has a reference to this 730 * buffer. 731 */ 732 static inline int skb_shared(const struct sk_buff *skb) 733 { 734 return atomic_read(&skb->users) != 1; 735 } 736 737 /** 738 * skb_share_check - check if buffer is shared and if so clone it 739 * @skb: buffer to check 740 * @pri: priority for memory allocation 741 * 742 * If the buffer is shared the buffer is cloned and the old copy 743 * drops a reference. A new clone with a single reference is returned. 744 * If the buffer is not shared the original buffer is returned. When 745 * being called from interrupt status or with spinlocks held pri must 746 * be GFP_ATOMIC. 747 * 748 * NULL is returned on a memory allocation failure. 749 */ 750 static inline struct sk_buff *skb_share_check(struct sk_buff *skb, 751 gfp_t pri) 752 { 753 might_sleep_if(pri & __GFP_WAIT); 754 if (skb_shared(skb)) { 755 struct sk_buff *nskb = skb_clone(skb, pri); 756 kfree_skb(skb); 757 skb = nskb; 758 } 759 return skb; 760 } 761 762 /* 763 * Copy shared buffers into a new sk_buff. We effectively do COW on 764 * packets to handle cases where we have a local reader and forward 765 * and a couple of other messy ones. The normal one is tcpdumping 766 * a packet thats being forwarded. 767 */ 768 769 /** 770 * skb_unshare - make a copy of a shared buffer 771 * @skb: buffer to check 772 * @pri: priority for memory allocation 773 * 774 * If the socket buffer is a clone then this function creates a new 775 * copy of the data, drops a reference count on the old copy and returns 776 * the new copy with the reference count at 1. If the buffer is not a clone 777 * the original buffer is returned. When called with a spinlock held or 778 * from interrupt state @pri must be %GFP_ATOMIC 779 * 780 * %NULL is returned on a memory allocation failure. 781 */ 782 static inline struct sk_buff *skb_unshare(struct sk_buff *skb, 783 gfp_t pri) 784 { 785 might_sleep_if(pri & __GFP_WAIT); 786 if (skb_cloned(skb)) { 787 struct sk_buff *nskb = skb_copy(skb, pri); 788 kfree_skb(skb); /* Free our shared copy */ 789 skb = nskb; 790 } 791 return skb; 792 } 793 794 /** 795 * skb_peek - peek at the head of an &sk_buff_head 796 * @list_: list to peek at 797 * 798 * Peek an &sk_buff. Unlike most other operations you _MUST_ 799 * be careful with this one. A peek leaves the buffer on the 800 * list and someone else may run off with it. You must hold 801 * the appropriate locks or have a private queue to do this. 802 * 803 * Returns %NULL for an empty list or a pointer to the head element. 804 * The reference count is not incremented and the reference is therefore 805 * volatile. Use with caution. 806 */ 807 static inline struct sk_buff *skb_peek(struct sk_buff_head *list_) 808 { 809 struct sk_buff *list = ((struct sk_buff *)list_)->next; 810 if (list == (struct sk_buff *)list_) 811 list = NULL; 812 return list; 813 } 814 815 /** 816 * skb_peek_tail - peek at the tail of an &sk_buff_head 817 * @list_: list to peek at 818 * 819 * Peek an &sk_buff. Unlike most other operations you _MUST_ 820 * be careful with this one. A peek leaves the buffer on the 821 * list and someone else may run off with it. You must hold 822 * the appropriate locks or have a private queue to do this. 823 * 824 * Returns %NULL for an empty list or a pointer to the tail element. 825 * The reference count is not incremented and the reference is therefore 826 * volatile. Use with caution. 827 */ 828 static inline struct sk_buff *skb_peek_tail(struct sk_buff_head *list_) 829 { 830 struct sk_buff *list = ((struct sk_buff *)list_)->prev; 831 if (list == (struct sk_buff *)list_) 832 list = NULL; 833 return list; 834 } 835 836 /** 837 * skb_queue_len - get queue length 838 * @list_: list to measure 839 * 840 * Return the length of an &sk_buff queue. 841 */ 842 static inline __u32 skb_queue_len(const struct sk_buff_head *list_) 843 { 844 return list_->qlen; 845 } 846 847 /** 848 * __skb_queue_head_init - initialize non-spinlock portions of sk_buff_head 849 * @list: queue to initialize 850 * 851 * This initializes only the list and queue length aspects of 852 * an sk_buff_head object. This allows to initialize the list 853 * aspects of an sk_buff_head without reinitializing things like 854 * the spinlock. It can also be used for on-stack sk_buff_head 855 * objects where the spinlock is known to not be used. 856 */ 857 static inline void __skb_queue_head_init(struct sk_buff_head *list) 858 { 859 list->prev = list->next = (struct sk_buff *)list; 860 list->qlen = 0; 861 } 862 863 /* 864 * This function creates a split out lock class for each invocation; 865 * this is needed for now since a whole lot of users of the skb-queue 866 * infrastructure in drivers have different locking usage (in hardirq) 867 * than the networking core (in softirq only). In the long run either the 868 * network layer or drivers should need annotation to consolidate the 869 * main types of usage into 3 classes. 870 */ 871 static inline void skb_queue_head_init(struct sk_buff_head *list) 872 { 873 spin_lock_init(&list->lock); 874 __skb_queue_head_init(list); 875 } 876 877 static inline void skb_queue_head_init_class(struct sk_buff_head *list, 878 struct lock_class_key *class) 879 { 880 skb_queue_head_init(list); 881 lockdep_set_class(&list->lock, class); 882 } 883 884 /* 885 * Insert an sk_buff on a list. 886 * 887 * The "__skb_xxxx()" functions are the non-atomic ones that 888 * can only be called with interrupts disabled. 889 */ 890 extern void skb_insert(struct sk_buff *old, struct sk_buff *newsk, struct sk_buff_head *list); 891 static inline void __skb_insert(struct sk_buff *newsk, 892 struct sk_buff *prev, struct sk_buff *next, 893 struct sk_buff_head *list) 894 { 895 newsk->next = next; 896 newsk->prev = prev; 897 next->prev = prev->next = newsk; 898 list->qlen++; 899 } 900 901 static inline void __skb_queue_splice(const struct sk_buff_head *list, 902 struct sk_buff *prev, 903 struct sk_buff *next) 904 { 905 struct sk_buff *first = list->next; 906 struct sk_buff *last = list->prev; 907 908 first->prev = prev; 909 prev->next = first; 910 911 last->next = next; 912 next->prev = last; 913 } 914 915 /** 916 * skb_queue_splice - join two skb lists, this is designed for stacks 917 * @list: the new list to add 918 * @head: the place to add it in the first list 919 */ 920 static inline void skb_queue_splice(const struct sk_buff_head *list, 921 struct sk_buff_head *head) 922 { 923 if (!skb_queue_empty(list)) { 924 __skb_queue_splice(list, (struct sk_buff *) head, head->next); 925 head->qlen += list->qlen; 926 } 927 } 928 929 /** 930 * skb_queue_splice - join two skb lists and reinitialise the emptied list 931 * @list: the new list to add 932 * @head: the place to add it in the first list 933 * 934 * The list at @list is reinitialised 935 */ 936 static inline void skb_queue_splice_init(struct sk_buff_head *list, 937 struct sk_buff_head *head) 938 { 939 if (!skb_queue_empty(list)) { 940 __skb_queue_splice(list, (struct sk_buff *) head, head->next); 941 head->qlen += list->qlen; 942 __skb_queue_head_init(list); 943 } 944 } 945 946 /** 947 * skb_queue_splice_tail - join two skb lists, each list being a queue 948 * @list: the new list to add 949 * @head: the place to add it in the first list 950 */ 951 static inline void skb_queue_splice_tail(const struct sk_buff_head *list, 952 struct sk_buff_head *head) 953 { 954 if (!skb_queue_empty(list)) { 955 __skb_queue_splice(list, head->prev, (struct sk_buff *) head); 956 head->qlen += list->qlen; 957 } 958 } 959 960 /** 961 * skb_queue_splice_tail - join two skb lists and reinitialise the emptied list 962 * @list: the new list to add 963 * @head: the place to add it in the first list 964 * 965 * Each of the lists is a queue. 966 * The list at @list is reinitialised 967 */ 968 static inline void skb_queue_splice_tail_init(struct sk_buff_head *list, 969 struct sk_buff_head *head) 970 { 971 if (!skb_queue_empty(list)) { 972 __skb_queue_splice(list, head->prev, (struct sk_buff *) head); 973 head->qlen += list->qlen; 974 __skb_queue_head_init(list); 975 } 976 } 977 978 /** 979 * __skb_queue_after - queue a buffer at the list head 980 * @list: list to use 981 * @prev: place after this buffer 982 * @newsk: buffer to queue 983 * 984 * Queue a buffer int the middle of a list. This function takes no locks 985 * and you must therefore hold required locks before calling it. 986 * 987 * A buffer cannot be placed on two lists at the same time. 988 */ 989 static inline void __skb_queue_after(struct sk_buff_head *list, 990 struct sk_buff *prev, 991 struct sk_buff *newsk) 992 { 993 __skb_insert(newsk, prev, prev->next, list); 994 } 995 996 extern void skb_append(struct sk_buff *old, struct sk_buff *newsk, 997 struct sk_buff_head *list); 998 999 static inline void __skb_queue_before(struct sk_buff_head *list, 1000 struct sk_buff *next, 1001 struct sk_buff *newsk) 1002 { 1003 __skb_insert(newsk, next->prev, next, list); 1004 } 1005 1006 /** 1007 * __skb_queue_head - queue a buffer at the list head 1008 * @list: list to use 1009 * @newsk: buffer to queue 1010 * 1011 * Queue a buffer at the start of a list. This function takes no locks 1012 * and you must therefore hold required locks before calling it. 1013 * 1014 * A buffer cannot be placed on two lists at the same time. 1015 */ 1016 extern void skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk); 1017 static inline void __skb_queue_head(struct sk_buff_head *list, 1018 struct sk_buff *newsk) 1019 { 1020 __skb_queue_after(list, (struct sk_buff *)list, newsk); 1021 } 1022 1023 /** 1024 * __skb_queue_tail - queue a buffer at the list tail 1025 * @list: list to use 1026 * @newsk: buffer to queue 1027 * 1028 * Queue a buffer at the end of a list. This function takes no locks 1029 * and you must therefore hold required locks before calling it. 1030 * 1031 * A buffer cannot be placed on two lists at the same time. 1032 */ 1033 extern void skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk); 1034 static inline void __skb_queue_tail(struct sk_buff_head *list, 1035 struct sk_buff *newsk) 1036 { 1037 __skb_queue_before(list, (struct sk_buff *)list, newsk); 1038 } 1039 1040 /* 1041 * remove sk_buff from list. _Must_ be called atomically, and with 1042 * the list known.. 1043 */ 1044 extern void skb_unlink(struct sk_buff *skb, struct sk_buff_head *list); 1045 static inline void __skb_unlink(struct sk_buff *skb, struct sk_buff_head *list) 1046 { 1047 struct sk_buff *next, *prev; 1048 1049 list->qlen--; 1050 next = skb->next; 1051 prev = skb->prev; 1052 skb->next = skb->prev = NULL; 1053 next->prev = prev; 1054 prev->next = next; 1055 } 1056 1057 /** 1058 * __skb_dequeue - remove from the head of the queue 1059 * @list: list to dequeue from 1060 * 1061 * Remove the head of the list. This function does not take any locks 1062 * so must be used with appropriate locks held only. The head item is 1063 * returned or %NULL if the list is empty. 1064 */ 1065 extern struct sk_buff *skb_dequeue(struct sk_buff_head *list); 1066 static inline struct sk_buff *__skb_dequeue(struct sk_buff_head *list) 1067 { 1068 struct sk_buff *skb = skb_peek(list); 1069 if (skb) 1070 __skb_unlink(skb, list); 1071 return skb; 1072 } 1073 1074 /** 1075 * __skb_dequeue_tail - remove from the tail of the queue 1076 * @list: list to dequeue from 1077 * 1078 * Remove the tail of the list. This function does not take any locks 1079 * so must be used with appropriate locks held only. The tail item is 1080 * returned or %NULL if the list is empty. 1081 */ 1082 extern struct sk_buff *skb_dequeue_tail(struct sk_buff_head *list); 1083 static inline struct sk_buff *__skb_dequeue_tail(struct sk_buff_head *list) 1084 { 1085 struct sk_buff *skb = skb_peek_tail(list); 1086 if (skb) 1087 __skb_unlink(skb, list); 1088 return skb; 1089 } 1090 1091 1092 static inline int skb_is_nonlinear(const struct sk_buff *skb) 1093 { 1094 return skb->data_len; 1095 } 1096 1097 static inline unsigned int skb_headlen(const struct sk_buff *skb) 1098 { 1099 return skb->len - skb->data_len; 1100 } 1101 1102 static inline int skb_pagelen(const struct sk_buff *skb) 1103 { 1104 int i, len = 0; 1105 1106 for (i = (int)skb_shinfo(skb)->nr_frags - 1; i >= 0; i--) 1107 len += skb_shinfo(skb)->frags[i].size; 1108 return len + skb_headlen(skb); 1109 } 1110 1111 static inline void skb_fill_page_desc(struct sk_buff *skb, int i, 1112 struct page *page, int off, int size) 1113 { 1114 skb_frag_t *frag = &skb_shinfo(skb)->frags[i]; 1115 1116 frag->page = page; 1117 frag->page_offset = off; 1118 frag->size = size; 1119 skb_shinfo(skb)->nr_frags = i + 1; 1120 } 1121 1122 extern void skb_add_rx_frag(struct sk_buff *skb, int i, struct page *page, 1123 int off, int size); 1124 1125 #define SKB_PAGE_ASSERT(skb) BUG_ON(skb_shinfo(skb)->nr_frags) 1126 #define SKB_FRAG_ASSERT(skb) BUG_ON(skb_has_frags(skb)) 1127 #define SKB_LINEAR_ASSERT(skb) BUG_ON(skb_is_nonlinear(skb)) 1128 1129 #ifdef NET_SKBUFF_DATA_USES_OFFSET 1130 static inline unsigned char *skb_tail_pointer(const struct sk_buff *skb) 1131 { 1132 return skb->head + skb->tail; 1133 } 1134 1135 static inline void skb_reset_tail_pointer(struct sk_buff *skb) 1136 { 1137 skb->tail = skb->data - skb->head; 1138 } 1139 1140 static inline void skb_set_tail_pointer(struct sk_buff *skb, const int offset) 1141 { 1142 skb_reset_tail_pointer(skb); 1143 skb->tail += offset; 1144 } 1145 #else /* NET_SKBUFF_DATA_USES_OFFSET */ 1146 static inline unsigned char *skb_tail_pointer(const struct sk_buff *skb) 1147 { 1148 return skb->tail; 1149 } 1150 1151 static inline void skb_reset_tail_pointer(struct sk_buff *skb) 1152 { 1153 skb->tail = skb->data; 1154 } 1155 1156 static inline void skb_set_tail_pointer(struct sk_buff *skb, const int offset) 1157 { 1158 skb->tail = skb->data + offset; 1159 } 1160 1161 #endif /* NET_SKBUFF_DATA_USES_OFFSET */ 1162 1163 /* 1164 * Add data to an sk_buff 1165 */ 1166 extern unsigned char *skb_put(struct sk_buff *skb, unsigned int len); 1167 static inline unsigned char *__skb_put(struct sk_buff *skb, unsigned int len) 1168 { 1169 unsigned char *tmp = skb_tail_pointer(skb); 1170 SKB_LINEAR_ASSERT(skb); 1171 skb->tail += len; 1172 skb->len += len; 1173 return tmp; 1174 } 1175 1176 extern unsigned char *skb_push(struct sk_buff *skb, unsigned int len); 1177 static inline unsigned char *__skb_push(struct sk_buff *skb, unsigned int len) 1178 { 1179 skb->data -= len; 1180 skb->len += len; 1181 return skb->data; 1182 } 1183 1184 extern unsigned char *skb_pull(struct sk_buff *skb, unsigned int len); 1185 static inline unsigned char *__skb_pull(struct sk_buff *skb, unsigned int len) 1186 { 1187 skb->len -= len; 1188 BUG_ON(skb->len < skb->data_len); 1189 return skb->data += len; 1190 } 1191 1192 static inline unsigned char *skb_pull_inline(struct sk_buff *skb, unsigned int len) 1193 { 1194 return unlikely(len > skb->len) ? NULL : __skb_pull(skb, len); 1195 } 1196 1197 extern unsigned char *__pskb_pull_tail(struct sk_buff *skb, int delta); 1198 1199 static inline unsigned char *__pskb_pull(struct sk_buff *skb, unsigned int len) 1200 { 1201 if (len > skb_headlen(skb) && 1202 !__pskb_pull_tail(skb, len - skb_headlen(skb))) 1203 return NULL; 1204 skb->len -= len; 1205 return skb->data += len; 1206 } 1207 1208 static inline unsigned char *pskb_pull(struct sk_buff *skb, unsigned int len) 1209 { 1210 return unlikely(len > skb->len) ? NULL : __pskb_pull(skb, len); 1211 } 1212 1213 static inline int pskb_may_pull(struct sk_buff *skb, unsigned int len) 1214 { 1215 if (likely(len <= skb_headlen(skb))) 1216 return 1; 1217 if (unlikely(len > skb->len)) 1218 return 0; 1219 return __pskb_pull_tail(skb, len - skb_headlen(skb)) != NULL; 1220 } 1221 1222 /** 1223 * skb_headroom - bytes at buffer head 1224 * @skb: buffer to check 1225 * 1226 * Return the number of bytes of free space at the head of an &sk_buff. 1227 */ 1228 static inline unsigned int skb_headroom(const struct sk_buff *skb) 1229 { 1230 return skb->data - skb->head; 1231 } 1232 1233 /** 1234 * skb_tailroom - bytes at buffer end 1235 * @skb: buffer to check 1236 * 1237 * Return the number of bytes of free space at the tail of an sk_buff 1238 */ 1239 static inline int skb_tailroom(const struct sk_buff *skb) 1240 { 1241 return skb_is_nonlinear(skb) ? 0 : skb->end - skb->tail; 1242 } 1243 1244 /** 1245 * skb_reserve - adjust headroom 1246 * @skb: buffer to alter 1247 * @len: bytes to move 1248 * 1249 * Increase the headroom of an empty &sk_buff by reducing the tail 1250 * room. This is only allowed for an empty buffer. 1251 */ 1252 static inline void skb_reserve(struct sk_buff *skb, int len) 1253 { 1254 skb->data += len; 1255 skb->tail += len; 1256 } 1257 1258 #ifdef NET_SKBUFF_DATA_USES_OFFSET 1259 static inline unsigned char *skb_transport_header(const struct sk_buff *skb) 1260 { 1261 return skb->head + skb->transport_header; 1262 } 1263 1264 static inline void skb_reset_transport_header(struct sk_buff *skb) 1265 { 1266 skb->transport_header = skb->data - skb->head; 1267 } 1268 1269 static inline void skb_set_transport_header(struct sk_buff *skb, 1270 const int offset) 1271 { 1272 skb_reset_transport_header(skb); 1273 skb->transport_header += offset; 1274 } 1275 1276 static inline unsigned char *skb_network_header(const struct sk_buff *skb) 1277 { 1278 return skb->head + skb->network_header; 1279 } 1280 1281 static inline void skb_reset_network_header(struct sk_buff *skb) 1282 { 1283 skb->network_header = skb->data - skb->head; 1284 } 1285 1286 static inline void skb_set_network_header(struct sk_buff *skb, const int offset) 1287 { 1288 skb_reset_network_header(skb); 1289 skb->network_header += offset; 1290 } 1291 1292 static inline unsigned char *skb_mac_header(const struct sk_buff *skb) 1293 { 1294 return skb->head + skb->mac_header; 1295 } 1296 1297 static inline int skb_mac_header_was_set(const struct sk_buff *skb) 1298 { 1299 return skb->mac_header != ~0U; 1300 } 1301 1302 static inline void skb_reset_mac_header(struct sk_buff *skb) 1303 { 1304 skb->mac_header = skb->data - skb->head; 1305 } 1306 1307 static inline void skb_set_mac_header(struct sk_buff *skb, const int offset) 1308 { 1309 skb_reset_mac_header(skb); 1310 skb->mac_header += offset; 1311 } 1312 1313 #else /* NET_SKBUFF_DATA_USES_OFFSET */ 1314 1315 static inline unsigned char *skb_transport_header(const struct sk_buff *skb) 1316 { 1317 return skb->transport_header; 1318 } 1319 1320 static inline void skb_reset_transport_header(struct sk_buff *skb) 1321 { 1322 skb->transport_header = skb->data; 1323 } 1324 1325 static inline void skb_set_transport_header(struct sk_buff *skb, 1326 const int offset) 1327 { 1328 skb->transport_header = skb->data + offset; 1329 } 1330 1331 static inline unsigned char *skb_network_header(const struct sk_buff *skb) 1332 { 1333 return skb->network_header; 1334 } 1335 1336 static inline void skb_reset_network_header(struct sk_buff *skb) 1337 { 1338 skb->network_header = skb->data; 1339 } 1340 1341 static inline void skb_set_network_header(struct sk_buff *skb, const int offset) 1342 { 1343 skb->network_header = skb->data + offset; 1344 } 1345 1346 static inline unsigned char *skb_mac_header(const struct sk_buff *skb) 1347 { 1348 return skb->mac_header; 1349 } 1350 1351 static inline int skb_mac_header_was_set(const struct sk_buff *skb) 1352 { 1353 return skb->mac_header != NULL; 1354 } 1355 1356 static inline void skb_reset_mac_header(struct sk_buff *skb) 1357 { 1358 skb->mac_header = skb->data; 1359 } 1360 1361 static inline void skb_set_mac_header(struct sk_buff *skb, const int offset) 1362 { 1363 skb->mac_header = skb->data + offset; 1364 } 1365 #endif /* NET_SKBUFF_DATA_USES_OFFSET */ 1366 1367 static inline int skb_transport_offset(const struct sk_buff *skb) 1368 { 1369 return skb_transport_header(skb) - skb->data; 1370 } 1371 1372 static inline u32 skb_network_header_len(const struct sk_buff *skb) 1373 { 1374 return skb->transport_header - skb->network_header; 1375 } 1376 1377 static inline int skb_network_offset(const struct sk_buff *skb) 1378 { 1379 return skb_network_header(skb) - skb->data; 1380 } 1381 1382 static inline int pskb_network_may_pull(struct sk_buff *skb, unsigned int len) 1383 { 1384 return pskb_may_pull(skb, skb_network_offset(skb) + len); 1385 } 1386 1387 /* 1388 * CPUs often take a performance hit when accessing unaligned memory 1389 * locations. The actual performance hit varies, it can be small if the 1390 * hardware handles it or large if we have to take an exception and fix it 1391 * in software. 1392 * 1393 * Since an ethernet header is 14 bytes network drivers often end up with 1394 * the IP header at an unaligned offset. The IP header can be aligned by 1395 * shifting the start of the packet by 2 bytes. Drivers should do this 1396 * with: 1397 * 1398 * skb_reserve(skb, NET_IP_ALIGN); 1399 * 1400 * The downside to this alignment of the IP header is that the DMA is now 1401 * unaligned. On some architectures the cost of an unaligned DMA is high 1402 * and this cost outweighs the gains made by aligning the IP header. 1403 * 1404 * Since this trade off varies between architectures, we allow NET_IP_ALIGN 1405 * to be overridden. 1406 */ 1407 #ifndef NET_IP_ALIGN 1408 #define NET_IP_ALIGN 2 1409 #endif 1410 1411 /* 1412 * The networking layer reserves some headroom in skb data (via 1413 * dev_alloc_skb). This is used to avoid having to reallocate skb data when 1414 * the header has to grow. In the default case, if the header has to grow 1415 * 32 bytes or less we avoid the reallocation. 1416 * 1417 * Unfortunately this headroom changes the DMA alignment of the resulting 1418 * network packet. As for NET_IP_ALIGN, this unaligned DMA is expensive 1419 * on some architectures. An architecture can override this value, 1420 * perhaps setting it to a cacheline in size (since that will maintain 1421 * cacheline alignment of the DMA). It must be a power of 2. 1422 * 1423 * Various parts of the networking layer expect at least 32 bytes of 1424 * headroom, you should not reduce this. 1425 * 1426 * Using max(32, L1_CACHE_BYTES) makes sense (especially with RPS) 1427 * to reduce average number of cache lines per packet. 1428 * get_rps_cpus() for example only access one 64 bytes aligned block : 1429 * NET_IP_ALIGN(2) + ethernet_header(14) + IP_header(20/40) + ports(8) 1430 */ 1431 #ifndef NET_SKB_PAD 1432 #define NET_SKB_PAD max(32, L1_CACHE_BYTES) 1433 #endif 1434 1435 extern int ___pskb_trim(struct sk_buff *skb, unsigned int len); 1436 1437 static inline void __skb_trim(struct sk_buff *skb, unsigned int len) 1438 { 1439 if (unlikely(skb->data_len)) { 1440 WARN_ON(1); 1441 return; 1442 } 1443 skb->len = len; 1444 skb_set_tail_pointer(skb, len); 1445 } 1446 1447 extern void skb_trim(struct sk_buff *skb, unsigned int len); 1448 1449 static inline int __pskb_trim(struct sk_buff *skb, unsigned int len) 1450 { 1451 if (skb->data_len) 1452 return ___pskb_trim(skb, len); 1453 __skb_trim(skb, len); 1454 return 0; 1455 } 1456 1457 static inline int pskb_trim(struct sk_buff *skb, unsigned int len) 1458 { 1459 return (len < skb->len) ? __pskb_trim(skb, len) : 0; 1460 } 1461 1462 /** 1463 * pskb_trim_unique - remove end from a paged unique (not cloned) buffer 1464 * @skb: buffer to alter 1465 * @len: new length 1466 * 1467 * This is identical to pskb_trim except that the caller knows that 1468 * the skb is not cloned so we should never get an error due to out- 1469 * of-memory. 1470 */ 1471 static inline void pskb_trim_unique(struct sk_buff *skb, unsigned int len) 1472 { 1473 int err = pskb_trim(skb, len); 1474 BUG_ON(err); 1475 } 1476 1477 /** 1478 * skb_orphan - orphan a buffer 1479 * @skb: buffer to orphan 1480 * 1481 * If a buffer currently has an owner then we call the owner's 1482 * destructor function and make the @skb unowned. The buffer continues 1483 * to exist but is no longer charged to its former owner. 1484 */ 1485 static inline void skb_orphan(struct sk_buff *skb) 1486 { 1487 if (skb->destructor) 1488 skb->destructor(skb); 1489 skb->destructor = NULL; 1490 skb->sk = NULL; 1491 } 1492 1493 /** 1494 * __skb_queue_purge - empty a list 1495 * @list: list to empty 1496 * 1497 * Delete all buffers on an &sk_buff list. Each buffer is removed from 1498 * the list and one reference dropped. This function does not take the 1499 * list lock and the caller must hold the relevant locks to use it. 1500 */ 1501 extern void skb_queue_purge(struct sk_buff_head *list); 1502 static inline void __skb_queue_purge(struct sk_buff_head *list) 1503 { 1504 struct sk_buff *skb; 1505 while ((skb = __skb_dequeue(list)) != NULL) 1506 kfree_skb(skb); 1507 } 1508 1509 /** 1510 * __dev_alloc_skb - allocate an skbuff for receiving 1511 * @length: length to allocate 1512 * @gfp_mask: get_free_pages mask, passed to alloc_skb 1513 * 1514 * Allocate a new &sk_buff and assign it a usage count of one. The 1515 * buffer has unspecified headroom built in. Users should allocate 1516 * the headroom they think they need without accounting for the 1517 * built in space. The built in space is used for optimisations. 1518 * 1519 * %NULL is returned if there is no free memory. 1520 */ 1521 static inline struct sk_buff *__dev_alloc_skb(unsigned int length, 1522 gfp_t gfp_mask) 1523 { 1524 struct sk_buff *skb = alloc_skb(length + NET_SKB_PAD, gfp_mask); 1525 if (likely(skb)) 1526 skb_reserve(skb, NET_SKB_PAD); 1527 return skb; 1528 } 1529 1530 extern struct sk_buff *dev_alloc_skb(unsigned int length); 1531 1532 extern struct sk_buff *__netdev_alloc_skb(struct net_device *dev, 1533 unsigned int length, gfp_t gfp_mask); 1534 1535 /** 1536 * netdev_alloc_skb - allocate an skbuff for rx on a specific device 1537 * @dev: network device to receive on 1538 * @length: length to allocate 1539 * 1540 * Allocate a new &sk_buff and assign it a usage count of one. The 1541 * buffer has unspecified headroom built in. Users should allocate 1542 * the headroom they think they need without accounting for the 1543 * built in space. The built in space is used for optimisations. 1544 * 1545 * %NULL is returned if there is no free memory. Although this function 1546 * allocates memory it can be called from an interrupt. 1547 */ 1548 static inline struct sk_buff *netdev_alloc_skb(struct net_device *dev, 1549 unsigned int length) 1550 { 1551 return __netdev_alloc_skb(dev, length, GFP_ATOMIC); 1552 } 1553 1554 static inline struct sk_buff *netdev_alloc_skb_ip_align(struct net_device *dev, 1555 unsigned int length) 1556 { 1557 struct sk_buff *skb = netdev_alloc_skb(dev, length + NET_IP_ALIGN); 1558 1559 if (NET_IP_ALIGN && skb) 1560 skb_reserve(skb, NET_IP_ALIGN); 1561 return skb; 1562 } 1563 1564 extern struct page *__netdev_alloc_page(struct net_device *dev, gfp_t gfp_mask); 1565 1566 /** 1567 * netdev_alloc_page - allocate a page for ps-rx on a specific device 1568 * @dev: network device to receive on 1569 * 1570 * Allocate a new page node local to the specified device. 1571 * 1572 * %NULL is returned if there is no free memory. 1573 */ 1574 static inline struct page *netdev_alloc_page(struct net_device *dev) 1575 { 1576 return __netdev_alloc_page(dev, GFP_ATOMIC); 1577 } 1578 1579 static inline void netdev_free_page(struct net_device *dev, struct page *page) 1580 { 1581 __free_page(page); 1582 } 1583 1584 /** 1585 * skb_clone_writable - is the header of a clone writable 1586 * @skb: buffer to check 1587 * @len: length up to which to write 1588 * 1589 * Returns true if modifying the header part of the cloned buffer 1590 * does not requires the data to be copied. 1591 */ 1592 static inline int skb_clone_writable(struct sk_buff *skb, unsigned int len) 1593 { 1594 return !skb_header_cloned(skb) && 1595 skb_headroom(skb) + len <= skb->hdr_len; 1596 } 1597 1598 static inline int __skb_cow(struct sk_buff *skb, unsigned int headroom, 1599 int cloned) 1600 { 1601 int delta = 0; 1602 1603 if (headroom < NET_SKB_PAD) 1604 headroom = NET_SKB_PAD; 1605 if (headroom > skb_headroom(skb)) 1606 delta = headroom - skb_headroom(skb); 1607 1608 if (delta || cloned) 1609 return pskb_expand_head(skb, ALIGN(delta, NET_SKB_PAD), 0, 1610 GFP_ATOMIC); 1611 return 0; 1612 } 1613 1614 /** 1615 * skb_cow - copy header of skb when it is required 1616 * @skb: buffer to cow 1617 * @headroom: needed headroom 1618 * 1619 * If the skb passed lacks sufficient headroom or its data part 1620 * is shared, data is reallocated. If reallocation fails, an error 1621 * is returned and original skb is not changed. 1622 * 1623 * The result is skb with writable area skb->head...skb->tail 1624 * and at least @headroom of space at head. 1625 */ 1626 static inline int skb_cow(struct sk_buff *skb, unsigned int headroom) 1627 { 1628 return __skb_cow(skb, headroom, skb_cloned(skb)); 1629 } 1630 1631 /** 1632 * skb_cow_head - skb_cow but only making the head writable 1633 * @skb: buffer to cow 1634 * @headroom: needed headroom 1635 * 1636 * This function is identical to skb_cow except that we replace the 1637 * skb_cloned check by skb_header_cloned. It should be used when 1638 * you only need to push on some header and do not need to modify 1639 * the data. 1640 */ 1641 static inline int skb_cow_head(struct sk_buff *skb, unsigned int headroom) 1642 { 1643 return __skb_cow(skb, headroom, skb_header_cloned(skb)); 1644 } 1645 1646 /** 1647 * skb_padto - pad an skbuff up to a minimal size 1648 * @skb: buffer to pad 1649 * @len: minimal length 1650 * 1651 * Pads up a buffer to ensure the trailing bytes exist and are 1652 * blanked. If the buffer already contains sufficient data it 1653 * is untouched. Otherwise it is extended. Returns zero on 1654 * success. The skb is freed on error. 1655 */ 1656 1657 static inline int skb_padto(struct sk_buff *skb, unsigned int len) 1658 { 1659 unsigned int size = skb->len; 1660 if (likely(size >= len)) 1661 return 0; 1662 return skb_pad(skb, len - size); 1663 } 1664 1665 static inline int skb_add_data(struct sk_buff *skb, 1666 char __user *from, int copy) 1667 { 1668 const int off = skb->len; 1669 1670 if (skb->ip_summed == CHECKSUM_NONE) { 1671 int err = 0; 1672 __wsum csum = csum_and_copy_from_user(from, skb_put(skb, copy), 1673 copy, 0, &err); 1674 if (!err) { 1675 skb->csum = csum_block_add(skb->csum, csum, off); 1676 return 0; 1677 } 1678 } else if (!copy_from_user(skb_put(skb, copy), from, copy)) 1679 return 0; 1680 1681 __skb_trim(skb, off); 1682 return -EFAULT; 1683 } 1684 1685 static inline int skb_can_coalesce(struct sk_buff *skb, int i, 1686 struct page *page, int off) 1687 { 1688 if (i) { 1689 struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i - 1]; 1690 1691 return page == frag->page && 1692 off == frag->page_offset + frag->size; 1693 } 1694 return 0; 1695 } 1696 1697 static inline int __skb_linearize(struct sk_buff *skb) 1698 { 1699 return __pskb_pull_tail(skb, skb->data_len) ? 0 : -ENOMEM; 1700 } 1701 1702 /** 1703 * skb_linearize - convert paged skb to linear one 1704 * @skb: buffer to linarize 1705 * 1706 * If there is no free memory -ENOMEM is returned, otherwise zero 1707 * is returned and the old skb data released. 1708 */ 1709 static inline int skb_linearize(struct sk_buff *skb) 1710 { 1711 return skb_is_nonlinear(skb) ? __skb_linearize(skb) : 0; 1712 } 1713 1714 /** 1715 * skb_linearize_cow - make sure skb is linear and writable 1716 * @skb: buffer to process 1717 * 1718 * If there is no free memory -ENOMEM is returned, otherwise zero 1719 * is returned and the old skb data released. 1720 */ 1721 static inline int skb_linearize_cow(struct sk_buff *skb) 1722 { 1723 return skb_is_nonlinear(skb) || skb_cloned(skb) ? 1724 __skb_linearize(skb) : 0; 1725 } 1726 1727 /** 1728 * skb_postpull_rcsum - update checksum for received skb after pull 1729 * @skb: buffer to update 1730 * @start: start of data before pull 1731 * @len: length of data pulled 1732 * 1733 * After doing a pull on a received packet, you need to call this to 1734 * update the CHECKSUM_COMPLETE checksum, or set ip_summed to 1735 * CHECKSUM_NONE so that it can be recomputed from scratch. 1736 */ 1737 1738 static inline void skb_postpull_rcsum(struct sk_buff *skb, 1739 const void *start, unsigned int len) 1740 { 1741 if (skb->ip_summed == CHECKSUM_COMPLETE) 1742 skb->csum = csum_sub(skb->csum, csum_partial(start, len, 0)); 1743 } 1744 1745 unsigned char *skb_pull_rcsum(struct sk_buff *skb, unsigned int len); 1746 1747 /** 1748 * pskb_trim_rcsum - trim received skb and update checksum 1749 * @skb: buffer to trim 1750 * @len: new length 1751 * 1752 * This is exactly the same as pskb_trim except that it ensures the 1753 * checksum of received packets are still valid after the operation. 1754 */ 1755 1756 static inline int pskb_trim_rcsum(struct sk_buff *skb, unsigned int len) 1757 { 1758 if (likely(len >= skb->len)) 1759 return 0; 1760 if (skb->ip_summed == CHECKSUM_COMPLETE) 1761 skb->ip_summed = CHECKSUM_NONE; 1762 return __pskb_trim(skb, len); 1763 } 1764 1765 #define skb_queue_walk(queue, skb) \ 1766 for (skb = (queue)->next; \ 1767 prefetch(skb->next), (skb != (struct sk_buff *)(queue)); \ 1768 skb = skb->next) 1769 1770 #define skb_queue_walk_safe(queue, skb, tmp) \ 1771 for (skb = (queue)->next, tmp = skb->next; \ 1772 skb != (struct sk_buff *)(queue); \ 1773 skb = tmp, tmp = skb->next) 1774 1775 #define skb_queue_walk_from(queue, skb) \ 1776 for (; prefetch(skb->next), (skb != (struct sk_buff *)(queue)); \ 1777 skb = skb->next) 1778 1779 #define skb_queue_walk_from_safe(queue, skb, tmp) \ 1780 for (tmp = skb->next; \ 1781 skb != (struct sk_buff *)(queue); \ 1782 skb = tmp, tmp = skb->next) 1783 1784 #define skb_queue_reverse_walk(queue, skb) \ 1785 for (skb = (queue)->prev; \ 1786 prefetch(skb->prev), (skb != (struct sk_buff *)(queue)); \ 1787 skb = skb->prev) 1788 1789 1790 static inline bool skb_has_frags(const struct sk_buff *skb) 1791 { 1792 return skb_shinfo(skb)->frag_list != NULL; 1793 } 1794 1795 static inline void skb_frag_list_init(struct sk_buff *skb) 1796 { 1797 skb_shinfo(skb)->frag_list = NULL; 1798 } 1799 1800 static inline void skb_frag_add_head(struct sk_buff *skb, struct sk_buff *frag) 1801 { 1802 frag->next = skb_shinfo(skb)->frag_list; 1803 skb_shinfo(skb)->frag_list = frag; 1804 } 1805 1806 #define skb_walk_frags(skb, iter) \ 1807 for (iter = skb_shinfo(skb)->frag_list; iter; iter = iter->next) 1808 1809 extern struct sk_buff *__skb_recv_datagram(struct sock *sk, unsigned flags, 1810 int *peeked, int *err); 1811 extern struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags, 1812 int noblock, int *err); 1813 extern unsigned int datagram_poll(struct file *file, struct socket *sock, 1814 struct poll_table_struct *wait); 1815 extern int skb_copy_datagram_iovec(const struct sk_buff *from, 1816 int offset, struct iovec *to, 1817 int size); 1818 extern int skb_copy_and_csum_datagram_iovec(struct sk_buff *skb, 1819 int hlen, 1820 struct iovec *iov); 1821 extern int skb_copy_datagram_from_iovec(struct sk_buff *skb, 1822 int offset, 1823 const struct iovec *from, 1824 int from_offset, 1825 int len); 1826 extern int skb_copy_datagram_const_iovec(const struct sk_buff *from, 1827 int offset, 1828 const struct iovec *to, 1829 int to_offset, 1830 int size); 1831 extern void skb_free_datagram(struct sock *sk, struct sk_buff *skb); 1832 extern void skb_free_datagram_locked(struct sock *sk, 1833 struct sk_buff *skb); 1834 extern int skb_kill_datagram(struct sock *sk, struct sk_buff *skb, 1835 unsigned int flags); 1836 extern __wsum skb_checksum(const struct sk_buff *skb, int offset, 1837 int len, __wsum csum); 1838 extern int skb_copy_bits(const struct sk_buff *skb, int offset, 1839 void *to, int len); 1840 extern int skb_store_bits(struct sk_buff *skb, int offset, 1841 const void *from, int len); 1842 extern __wsum skb_copy_and_csum_bits(const struct sk_buff *skb, 1843 int offset, u8 *to, int len, 1844 __wsum csum); 1845 extern int skb_splice_bits(struct sk_buff *skb, 1846 unsigned int offset, 1847 struct pipe_inode_info *pipe, 1848 unsigned int len, 1849 unsigned int flags); 1850 extern void skb_copy_and_csum_dev(const struct sk_buff *skb, u8 *to); 1851 extern void skb_split(struct sk_buff *skb, 1852 struct sk_buff *skb1, const u32 len); 1853 extern int skb_shift(struct sk_buff *tgt, struct sk_buff *skb, 1854 int shiftlen); 1855 1856 extern struct sk_buff *skb_segment(struct sk_buff *skb, int features); 1857 1858 static inline void *skb_header_pointer(const struct sk_buff *skb, int offset, 1859 int len, void *buffer) 1860 { 1861 int hlen = skb_headlen(skb); 1862 1863 if (hlen - offset >= len) 1864 return skb->data + offset; 1865 1866 if (skb_copy_bits(skb, offset, buffer, len) < 0) 1867 return NULL; 1868 1869 return buffer; 1870 } 1871 1872 static inline void skb_copy_from_linear_data(const struct sk_buff *skb, 1873 void *to, 1874 const unsigned int len) 1875 { 1876 memcpy(to, skb->data, len); 1877 } 1878 1879 static inline void skb_copy_from_linear_data_offset(const struct sk_buff *skb, 1880 const int offset, void *to, 1881 const unsigned int len) 1882 { 1883 memcpy(to, skb->data + offset, len); 1884 } 1885 1886 static inline void skb_copy_to_linear_data(struct sk_buff *skb, 1887 const void *from, 1888 const unsigned int len) 1889 { 1890 memcpy(skb->data, from, len); 1891 } 1892 1893 static inline void skb_copy_to_linear_data_offset(struct sk_buff *skb, 1894 const int offset, 1895 const void *from, 1896 const unsigned int len) 1897 { 1898 memcpy(skb->data + offset, from, len); 1899 } 1900 1901 extern void skb_init(void); 1902 1903 static inline ktime_t skb_get_ktime(const struct sk_buff *skb) 1904 { 1905 return skb->tstamp; 1906 } 1907 1908 /** 1909 * skb_get_timestamp - get timestamp from a skb 1910 * @skb: skb to get stamp from 1911 * @stamp: pointer to struct timeval to store stamp in 1912 * 1913 * Timestamps are stored in the skb as offsets to a base timestamp. 1914 * This function converts the offset back to a struct timeval and stores 1915 * it in stamp. 1916 */ 1917 static inline void skb_get_timestamp(const struct sk_buff *skb, 1918 struct timeval *stamp) 1919 { 1920 *stamp = ktime_to_timeval(skb->tstamp); 1921 } 1922 1923 static inline void skb_get_timestampns(const struct sk_buff *skb, 1924 struct timespec *stamp) 1925 { 1926 *stamp = ktime_to_timespec(skb->tstamp); 1927 } 1928 1929 static inline void __net_timestamp(struct sk_buff *skb) 1930 { 1931 skb->tstamp = ktime_get_real(); 1932 } 1933 1934 static inline ktime_t net_timedelta(ktime_t t) 1935 { 1936 return ktime_sub(ktime_get_real(), t); 1937 } 1938 1939 static inline ktime_t net_invalid_timestamp(void) 1940 { 1941 return ktime_set(0, 0); 1942 } 1943 1944 extern void skb_timestamping_init(void); 1945 1946 #ifdef CONFIG_NETWORK_PHY_TIMESTAMPING 1947 1948 extern void skb_clone_tx_timestamp(struct sk_buff *skb); 1949 extern bool skb_defer_rx_timestamp(struct sk_buff *skb); 1950 1951 #else /* CONFIG_NETWORK_PHY_TIMESTAMPING */ 1952 1953 static inline void skb_clone_tx_timestamp(struct sk_buff *skb) 1954 { 1955 } 1956 1957 static inline bool skb_defer_rx_timestamp(struct sk_buff *skb) 1958 { 1959 return false; 1960 } 1961 1962 #endif /* !CONFIG_NETWORK_PHY_TIMESTAMPING */ 1963 1964 /** 1965 * skb_complete_tx_timestamp() - deliver cloned skb with tx timestamps 1966 * 1967 * @skb: clone of the the original outgoing packet 1968 * @hwtstamps: hardware time stamps 1969 * 1970 */ 1971 void skb_complete_tx_timestamp(struct sk_buff *skb, 1972 struct skb_shared_hwtstamps *hwtstamps); 1973 1974 /** 1975 * skb_tstamp_tx - queue clone of skb with send time stamps 1976 * @orig_skb: the original outgoing packet 1977 * @hwtstamps: hardware time stamps, may be NULL if not available 1978 * 1979 * If the skb has a socket associated, then this function clones the 1980 * skb (thus sharing the actual data and optional structures), stores 1981 * the optional hardware time stamping information (if non NULL) or 1982 * generates a software time stamp (otherwise), then queues the clone 1983 * to the error queue of the socket. Errors are silently ignored. 1984 */ 1985 extern void skb_tstamp_tx(struct sk_buff *orig_skb, 1986 struct skb_shared_hwtstamps *hwtstamps); 1987 1988 static inline void sw_tx_timestamp(struct sk_buff *skb) 1989 { 1990 union skb_shared_tx *shtx = skb_tx(skb); 1991 if (shtx->software && !shtx->in_progress) 1992 skb_tstamp_tx(skb, NULL); 1993 } 1994 1995 /** 1996 * skb_tx_timestamp() - Driver hook for transmit timestamping 1997 * 1998 * Ethernet MAC Drivers should call this function in their hard_xmit() 1999 * function as soon as possible after giving the sk_buff to the MAC 2000 * hardware, but before freeing the sk_buff. 2001 * 2002 * @skb: A socket buffer. 2003 */ 2004 static inline void skb_tx_timestamp(struct sk_buff *skb) 2005 { 2006 skb_clone_tx_timestamp(skb); 2007 sw_tx_timestamp(skb); 2008 } 2009 2010 extern __sum16 __skb_checksum_complete_head(struct sk_buff *skb, int len); 2011 extern __sum16 __skb_checksum_complete(struct sk_buff *skb); 2012 2013 static inline int skb_csum_unnecessary(const struct sk_buff *skb) 2014 { 2015 return skb->ip_summed & CHECKSUM_UNNECESSARY; 2016 } 2017 2018 /** 2019 * skb_checksum_complete - Calculate checksum of an entire packet 2020 * @skb: packet to process 2021 * 2022 * This function calculates the checksum over the entire packet plus 2023 * the value of skb->csum. The latter can be used to supply the 2024 * checksum of a pseudo header as used by TCP/UDP. It returns the 2025 * checksum. 2026 * 2027 * For protocols that contain complete checksums such as ICMP/TCP/UDP, 2028 * this function can be used to verify that checksum on received 2029 * packets. In that case the function should return zero if the 2030 * checksum is correct. In particular, this function will return zero 2031 * if skb->ip_summed is CHECKSUM_UNNECESSARY which indicates that the 2032 * hardware has already verified the correctness of the checksum. 2033 */ 2034 static inline __sum16 skb_checksum_complete(struct sk_buff *skb) 2035 { 2036 return skb_csum_unnecessary(skb) ? 2037 0 : __skb_checksum_complete(skb); 2038 } 2039 2040 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE) 2041 extern void nf_conntrack_destroy(struct nf_conntrack *nfct); 2042 static inline void nf_conntrack_put(struct nf_conntrack *nfct) 2043 { 2044 if (nfct && atomic_dec_and_test(&nfct->use)) 2045 nf_conntrack_destroy(nfct); 2046 } 2047 static inline void nf_conntrack_get(struct nf_conntrack *nfct) 2048 { 2049 if (nfct) 2050 atomic_inc(&nfct->use); 2051 } 2052 static inline void nf_conntrack_get_reasm(struct sk_buff *skb) 2053 { 2054 if (skb) 2055 atomic_inc(&skb->users); 2056 } 2057 static inline void nf_conntrack_put_reasm(struct sk_buff *skb) 2058 { 2059 if (skb) 2060 kfree_skb(skb); 2061 } 2062 #endif 2063 #ifdef CONFIG_BRIDGE_NETFILTER 2064 static inline void nf_bridge_put(struct nf_bridge_info *nf_bridge) 2065 { 2066 if (nf_bridge && atomic_dec_and_test(&nf_bridge->use)) 2067 kfree(nf_bridge); 2068 } 2069 static inline void nf_bridge_get(struct nf_bridge_info *nf_bridge) 2070 { 2071 if (nf_bridge) 2072 atomic_inc(&nf_bridge->use); 2073 } 2074 #endif /* CONFIG_BRIDGE_NETFILTER */ 2075 static inline void nf_reset(struct sk_buff *skb) 2076 { 2077 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE) 2078 nf_conntrack_put(skb->nfct); 2079 skb->nfct = NULL; 2080 nf_conntrack_put_reasm(skb->nfct_reasm); 2081 skb->nfct_reasm = NULL; 2082 #endif 2083 #ifdef CONFIG_BRIDGE_NETFILTER 2084 nf_bridge_put(skb->nf_bridge); 2085 skb->nf_bridge = NULL; 2086 #endif 2087 } 2088 2089 /* Note: This doesn't put any conntrack and bridge info in dst. */ 2090 static inline void __nf_copy(struct sk_buff *dst, const struct sk_buff *src) 2091 { 2092 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE) 2093 dst->nfct = src->nfct; 2094 nf_conntrack_get(src->nfct); 2095 dst->nfctinfo = src->nfctinfo; 2096 dst->nfct_reasm = src->nfct_reasm; 2097 nf_conntrack_get_reasm(src->nfct_reasm); 2098 #endif 2099 #ifdef CONFIG_BRIDGE_NETFILTER 2100 dst->nf_bridge = src->nf_bridge; 2101 nf_bridge_get(src->nf_bridge); 2102 #endif 2103 } 2104 2105 static inline void nf_copy(struct sk_buff *dst, const struct sk_buff *src) 2106 { 2107 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE) 2108 nf_conntrack_put(dst->nfct); 2109 nf_conntrack_put_reasm(dst->nfct_reasm); 2110 #endif 2111 #ifdef CONFIG_BRIDGE_NETFILTER 2112 nf_bridge_put(dst->nf_bridge); 2113 #endif 2114 __nf_copy(dst, src); 2115 } 2116 2117 #ifdef CONFIG_NETWORK_SECMARK 2118 static inline void skb_copy_secmark(struct sk_buff *to, const struct sk_buff *from) 2119 { 2120 to->secmark = from->secmark; 2121 } 2122 2123 static inline void skb_init_secmark(struct sk_buff *skb) 2124 { 2125 skb->secmark = 0; 2126 } 2127 #else 2128 static inline void skb_copy_secmark(struct sk_buff *to, const struct sk_buff *from) 2129 { } 2130 2131 static inline void skb_init_secmark(struct sk_buff *skb) 2132 { } 2133 #endif 2134 2135 static inline void skb_set_queue_mapping(struct sk_buff *skb, u16 queue_mapping) 2136 { 2137 skb->queue_mapping = queue_mapping; 2138 } 2139 2140 static inline u16 skb_get_queue_mapping(const struct sk_buff *skb) 2141 { 2142 return skb->queue_mapping; 2143 } 2144 2145 static inline void skb_copy_queue_mapping(struct sk_buff *to, const struct sk_buff *from) 2146 { 2147 to->queue_mapping = from->queue_mapping; 2148 } 2149 2150 static inline void skb_record_rx_queue(struct sk_buff *skb, u16 rx_queue) 2151 { 2152 skb->queue_mapping = rx_queue + 1; 2153 } 2154 2155 static inline u16 skb_get_rx_queue(const struct sk_buff *skb) 2156 { 2157 return skb->queue_mapping - 1; 2158 } 2159 2160 static inline bool skb_rx_queue_recorded(const struct sk_buff *skb) 2161 { 2162 return (skb->queue_mapping != 0); 2163 } 2164 2165 extern u16 skb_tx_hash(const struct net_device *dev, 2166 const struct sk_buff *skb); 2167 2168 #ifdef CONFIG_XFRM 2169 static inline struct sec_path *skb_sec_path(struct sk_buff *skb) 2170 { 2171 return skb->sp; 2172 } 2173 #else 2174 static inline struct sec_path *skb_sec_path(struct sk_buff *skb) 2175 { 2176 return NULL; 2177 } 2178 #endif 2179 2180 static inline int skb_is_gso(const struct sk_buff *skb) 2181 { 2182 return skb_shinfo(skb)->gso_size; 2183 } 2184 2185 static inline int skb_is_gso_v6(const struct sk_buff *skb) 2186 { 2187 return skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6; 2188 } 2189 2190 extern void __skb_warn_lro_forwarding(const struct sk_buff *skb); 2191 2192 static inline bool skb_warn_if_lro(const struct sk_buff *skb) 2193 { 2194 /* LRO sets gso_size but not gso_type, whereas if GSO is really 2195 * wanted then gso_type will be set. */ 2196 struct skb_shared_info *shinfo = skb_shinfo(skb); 2197 if (skb_is_nonlinear(skb) && shinfo->gso_size != 0 && 2198 unlikely(shinfo->gso_type == 0)) { 2199 __skb_warn_lro_forwarding(skb); 2200 return true; 2201 } 2202 return false; 2203 } 2204 2205 static inline void skb_forward_csum(struct sk_buff *skb) 2206 { 2207 /* Unfortunately we don't support this one. Any brave souls? */ 2208 if (skb->ip_summed == CHECKSUM_COMPLETE) 2209 skb->ip_summed = CHECKSUM_NONE; 2210 } 2211 2212 bool skb_partial_csum_set(struct sk_buff *skb, u16 start, u16 off); 2213 #endif /* __KERNEL__ */ 2214 #endif /* _LINUX_SKBUFF_H */ 2215