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 /* 1383 * CPUs often take a performance hit when accessing unaligned memory 1384 * locations. The actual performance hit varies, it can be small if the 1385 * hardware handles it or large if we have to take an exception and fix it 1386 * in software. 1387 * 1388 * Since an ethernet header is 14 bytes network drivers often end up with 1389 * the IP header at an unaligned offset. The IP header can be aligned by 1390 * shifting the start of the packet by 2 bytes. Drivers should do this 1391 * with: 1392 * 1393 * skb_reserve(skb, NET_IP_ALIGN); 1394 * 1395 * The downside to this alignment of the IP header is that the DMA is now 1396 * unaligned. On some architectures the cost of an unaligned DMA is high 1397 * and this cost outweighs the gains made by aligning the IP header. 1398 * 1399 * Since this trade off varies between architectures, we allow NET_IP_ALIGN 1400 * to be overridden. 1401 */ 1402 #ifndef NET_IP_ALIGN 1403 #define NET_IP_ALIGN 2 1404 #endif 1405 1406 /* 1407 * The networking layer reserves some headroom in skb data (via 1408 * dev_alloc_skb). This is used to avoid having to reallocate skb data when 1409 * the header has to grow. In the default case, if the header has to grow 1410 * 32 bytes or less we avoid the reallocation. 1411 * 1412 * Unfortunately this headroom changes the DMA alignment of the resulting 1413 * network packet. As for NET_IP_ALIGN, this unaligned DMA is expensive 1414 * on some architectures. An architecture can override this value, 1415 * perhaps setting it to a cacheline in size (since that will maintain 1416 * cacheline alignment of the DMA). It must be a power of 2. 1417 * 1418 * Various parts of the networking layer expect at least 32 bytes of 1419 * headroom, you should not reduce this. 1420 * 1421 * Using max(32, L1_CACHE_BYTES) makes sense (especially with RPS) 1422 * to reduce average number of cache lines per packet. 1423 * get_rps_cpus() for example only access one 64 bytes aligned block : 1424 * NET_IP_ALIGN(2) + ethernet_header(14) + IP_header(20/40) + ports(8) 1425 */ 1426 #ifndef NET_SKB_PAD 1427 #define NET_SKB_PAD max(32, L1_CACHE_BYTES) 1428 #endif 1429 1430 extern int ___pskb_trim(struct sk_buff *skb, unsigned int len); 1431 1432 static inline void __skb_trim(struct sk_buff *skb, unsigned int len) 1433 { 1434 if (unlikely(skb->data_len)) { 1435 WARN_ON(1); 1436 return; 1437 } 1438 skb->len = len; 1439 skb_set_tail_pointer(skb, len); 1440 } 1441 1442 extern void skb_trim(struct sk_buff *skb, unsigned int len); 1443 1444 static inline int __pskb_trim(struct sk_buff *skb, unsigned int len) 1445 { 1446 if (skb->data_len) 1447 return ___pskb_trim(skb, len); 1448 __skb_trim(skb, len); 1449 return 0; 1450 } 1451 1452 static inline int pskb_trim(struct sk_buff *skb, unsigned int len) 1453 { 1454 return (len < skb->len) ? __pskb_trim(skb, len) : 0; 1455 } 1456 1457 /** 1458 * pskb_trim_unique - remove end from a paged unique (not cloned) buffer 1459 * @skb: buffer to alter 1460 * @len: new length 1461 * 1462 * This is identical to pskb_trim except that the caller knows that 1463 * the skb is not cloned so we should never get an error due to out- 1464 * of-memory. 1465 */ 1466 static inline void pskb_trim_unique(struct sk_buff *skb, unsigned int len) 1467 { 1468 int err = pskb_trim(skb, len); 1469 BUG_ON(err); 1470 } 1471 1472 /** 1473 * skb_orphan - orphan a buffer 1474 * @skb: buffer to orphan 1475 * 1476 * If a buffer currently has an owner then we call the owner's 1477 * destructor function and make the @skb unowned. The buffer continues 1478 * to exist but is no longer charged to its former owner. 1479 */ 1480 static inline void skb_orphan(struct sk_buff *skb) 1481 { 1482 if (skb->destructor) 1483 skb->destructor(skb); 1484 skb->destructor = NULL; 1485 skb->sk = NULL; 1486 } 1487 1488 /** 1489 * __skb_queue_purge - empty a list 1490 * @list: list to empty 1491 * 1492 * Delete all buffers on an &sk_buff list. Each buffer is removed from 1493 * the list and one reference dropped. This function does not take the 1494 * list lock and the caller must hold the relevant locks to use it. 1495 */ 1496 extern void skb_queue_purge(struct sk_buff_head *list); 1497 static inline void __skb_queue_purge(struct sk_buff_head *list) 1498 { 1499 struct sk_buff *skb; 1500 while ((skb = __skb_dequeue(list)) != NULL) 1501 kfree_skb(skb); 1502 } 1503 1504 /** 1505 * __dev_alloc_skb - allocate an skbuff for receiving 1506 * @length: length to allocate 1507 * @gfp_mask: get_free_pages mask, passed to alloc_skb 1508 * 1509 * Allocate a new &sk_buff and assign it a usage count of one. The 1510 * buffer has unspecified headroom built in. Users should allocate 1511 * the headroom they think they need without accounting for the 1512 * built in space. The built in space is used for optimisations. 1513 * 1514 * %NULL is returned if there is no free memory. 1515 */ 1516 static inline struct sk_buff *__dev_alloc_skb(unsigned int length, 1517 gfp_t gfp_mask) 1518 { 1519 struct sk_buff *skb = alloc_skb(length + NET_SKB_PAD, gfp_mask); 1520 if (likely(skb)) 1521 skb_reserve(skb, NET_SKB_PAD); 1522 return skb; 1523 } 1524 1525 extern struct sk_buff *dev_alloc_skb(unsigned int length); 1526 1527 extern struct sk_buff *__netdev_alloc_skb(struct net_device *dev, 1528 unsigned int length, gfp_t gfp_mask); 1529 1530 /** 1531 * netdev_alloc_skb - allocate an skbuff for rx on a specific device 1532 * @dev: network device to receive on 1533 * @length: length to allocate 1534 * 1535 * Allocate a new &sk_buff and assign it a usage count of one. The 1536 * buffer has unspecified headroom built in. Users should allocate 1537 * the headroom they think they need without accounting for the 1538 * built in space. The built in space is used for optimisations. 1539 * 1540 * %NULL is returned if there is no free memory. Although this function 1541 * allocates memory it can be called from an interrupt. 1542 */ 1543 static inline struct sk_buff *netdev_alloc_skb(struct net_device *dev, 1544 unsigned int length) 1545 { 1546 return __netdev_alloc_skb(dev, length, GFP_ATOMIC); 1547 } 1548 1549 static inline struct sk_buff *netdev_alloc_skb_ip_align(struct net_device *dev, 1550 unsigned int length) 1551 { 1552 struct sk_buff *skb = netdev_alloc_skb(dev, length + NET_IP_ALIGN); 1553 1554 if (NET_IP_ALIGN && skb) 1555 skb_reserve(skb, NET_IP_ALIGN); 1556 return skb; 1557 } 1558 1559 extern struct page *__netdev_alloc_page(struct net_device *dev, gfp_t gfp_mask); 1560 1561 /** 1562 * netdev_alloc_page - allocate a page for ps-rx on a specific device 1563 * @dev: network device to receive on 1564 * 1565 * Allocate a new page node local to the specified device. 1566 * 1567 * %NULL is returned if there is no free memory. 1568 */ 1569 static inline struct page *netdev_alloc_page(struct net_device *dev) 1570 { 1571 return __netdev_alloc_page(dev, GFP_ATOMIC); 1572 } 1573 1574 static inline void netdev_free_page(struct net_device *dev, struct page *page) 1575 { 1576 __free_page(page); 1577 } 1578 1579 /** 1580 * skb_clone_writable - is the header of a clone writable 1581 * @skb: buffer to check 1582 * @len: length up to which to write 1583 * 1584 * Returns true if modifying the header part of the cloned buffer 1585 * does not requires the data to be copied. 1586 */ 1587 static inline int skb_clone_writable(struct sk_buff *skb, unsigned int len) 1588 { 1589 return !skb_header_cloned(skb) && 1590 skb_headroom(skb) + len <= skb->hdr_len; 1591 } 1592 1593 static inline int __skb_cow(struct sk_buff *skb, unsigned int headroom, 1594 int cloned) 1595 { 1596 int delta = 0; 1597 1598 if (headroom < NET_SKB_PAD) 1599 headroom = NET_SKB_PAD; 1600 if (headroom > skb_headroom(skb)) 1601 delta = headroom - skb_headroom(skb); 1602 1603 if (delta || cloned) 1604 return pskb_expand_head(skb, ALIGN(delta, NET_SKB_PAD), 0, 1605 GFP_ATOMIC); 1606 return 0; 1607 } 1608 1609 /** 1610 * skb_cow - copy header of skb when it is required 1611 * @skb: buffer to cow 1612 * @headroom: needed headroom 1613 * 1614 * If the skb passed lacks sufficient headroom or its data part 1615 * is shared, data is reallocated. If reallocation fails, an error 1616 * is returned and original skb is not changed. 1617 * 1618 * The result is skb with writable area skb->head...skb->tail 1619 * and at least @headroom of space at head. 1620 */ 1621 static inline int skb_cow(struct sk_buff *skb, unsigned int headroom) 1622 { 1623 return __skb_cow(skb, headroom, skb_cloned(skb)); 1624 } 1625 1626 /** 1627 * skb_cow_head - skb_cow but only making the head writable 1628 * @skb: buffer to cow 1629 * @headroom: needed headroom 1630 * 1631 * This function is identical to skb_cow except that we replace the 1632 * skb_cloned check by skb_header_cloned. It should be used when 1633 * you only need to push on some header and do not need to modify 1634 * the data. 1635 */ 1636 static inline int skb_cow_head(struct sk_buff *skb, unsigned int headroom) 1637 { 1638 return __skb_cow(skb, headroom, skb_header_cloned(skb)); 1639 } 1640 1641 /** 1642 * skb_padto - pad an skbuff up to a minimal size 1643 * @skb: buffer to pad 1644 * @len: minimal length 1645 * 1646 * Pads up a buffer to ensure the trailing bytes exist and are 1647 * blanked. If the buffer already contains sufficient data it 1648 * is untouched. Otherwise it is extended. Returns zero on 1649 * success. The skb is freed on error. 1650 */ 1651 1652 static inline int skb_padto(struct sk_buff *skb, unsigned int len) 1653 { 1654 unsigned int size = skb->len; 1655 if (likely(size >= len)) 1656 return 0; 1657 return skb_pad(skb, len - size); 1658 } 1659 1660 static inline int skb_add_data(struct sk_buff *skb, 1661 char __user *from, int copy) 1662 { 1663 const int off = skb->len; 1664 1665 if (skb->ip_summed == CHECKSUM_NONE) { 1666 int err = 0; 1667 __wsum csum = csum_and_copy_from_user(from, skb_put(skb, copy), 1668 copy, 0, &err); 1669 if (!err) { 1670 skb->csum = csum_block_add(skb->csum, csum, off); 1671 return 0; 1672 } 1673 } else if (!copy_from_user(skb_put(skb, copy), from, copy)) 1674 return 0; 1675 1676 __skb_trim(skb, off); 1677 return -EFAULT; 1678 } 1679 1680 static inline int skb_can_coalesce(struct sk_buff *skb, int i, 1681 struct page *page, int off) 1682 { 1683 if (i) { 1684 struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i - 1]; 1685 1686 return page == frag->page && 1687 off == frag->page_offset + frag->size; 1688 } 1689 return 0; 1690 } 1691 1692 static inline int __skb_linearize(struct sk_buff *skb) 1693 { 1694 return __pskb_pull_tail(skb, skb->data_len) ? 0 : -ENOMEM; 1695 } 1696 1697 /** 1698 * skb_linearize - convert paged skb to linear one 1699 * @skb: buffer to linarize 1700 * 1701 * If there is no free memory -ENOMEM is returned, otherwise zero 1702 * is returned and the old skb data released. 1703 */ 1704 static inline int skb_linearize(struct sk_buff *skb) 1705 { 1706 return skb_is_nonlinear(skb) ? __skb_linearize(skb) : 0; 1707 } 1708 1709 /** 1710 * skb_linearize_cow - make sure skb is linear and writable 1711 * @skb: buffer to process 1712 * 1713 * If there is no free memory -ENOMEM is returned, otherwise zero 1714 * is returned and the old skb data released. 1715 */ 1716 static inline int skb_linearize_cow(struct sk_buff *skb) 1717 { 1718 return skb_is_nonlinear(skb) || skb_cloned(skb) ? 1719 __skb_linearize(skb) : 0; 1720 } 1721 1722 /** 1723 * skb_postpull_rcsum - update checksum for received skb after pull 1724 * @skb: buffer to update 1725 * @start: start of data before pull 1726 * @len: length of data pulled 1727 * 1728 * After doing a pull on a received packet, you need to call this to 1729 * update the CHECKSUM_COMPLETE checksum, or set ip_summed to 1730 * CHECKSUM_NONE so that it can be recomputed from scratch. 1731 */ 1732 1733 static inline void skb_postpull_rcsum(struct sk_buff *skb, 1734 const void *start, unsigned int len) 1735 { 1736 if (skb->ip_summed == CHECKSUM_COMPLETE) 1737 skb->csum = csum_sub(skb->csum, csum_partial(start, len, 0)); 1738 } 1739 1740 unsigned char *skb_pull_rcsum(struct sk_buff *skb, unsigned int len); 1741 1742 /** 1743 * pskb_trim_rcsum - trim received skb and update checksum 1744 * @skb: buffer to trim 1745 * @len: new length 1746 * 1747 * This is exactly the same as pskb_trim except that it ensures the 1748 * checksum of received packets are still valid after the operation. 1749 */ 1750 1751 static inline int pskb_trim_rcsum(struct sk_buff *skb, unsigned int len) 1752 { 1753 if (likely(len >= skb->len)) 1754 return 0; 1755 if (skb->ip_summed == CHECKSUM_COMPLETE) 1756 skb->ip_summed = CHECKSUM_NONE; 1757 return __pskb_trim(skb, len); 1758 } 1759 1760 #define skb_queue_walk(queue, skb) \ 1761 for (skb = (queue)->next; \ 1762 prefetch(skb->next), (skb != (struct sk_buff *)(queue)); \ 1763 skb = skb->next) 1764 1765 #define skb_queue_walk_safe(queue, skb, tmp) \ 1766 for (skb = (queue)->next, tmp = skb->next; \ 1767 skb != (struct sk_buff *)(queue); \ 1768 skb = tmp, tmp = skb->next) 1769 1770 #define skb_queue_walk_from(queue, skb) \ 1771 for (; prefetch(skb->next), (skb != (struct sk_buff *)(queue)); \ 1772 skb = skb->next) 1773 1774 #define skb_queue_walk_from_safe(queue, skb, tmp) \ 1775 for (tmp = skb->next; \ 1776 skb != (struct sk_buff *)(queue); \ 1777 skb = tmp, tmp = skb->next) 1778 1779 #define skb_queue_reverse_walk(queue, skb) \ 1780 for (skb = (queue)->prev; \ 1781 prefetch(skb->prev), (skb != (struct sk_buff *)(queue)); \ 1782 skb = skb->prev) 1783 1784 1785 static inline bool skb_has_frags(const struct sk_buff *skb) 1786 { 1787 return skb_shinfo(skb)->frag_list != NULL; 1788 } 1789 1790 static inline void skb_frag_list_init(struct sk_buff *skb) 1791 { 1792 skb_shinfo(skb)->frag_list = NULL; 1793 } 1794 1795 static inline void skb_frag_add_head(struct sk_buff *skb, struct sk_buff *frag) 1796 { 1797 frag->next = skb_shinfo(skb)->frag_list; 1798 skb_shinfo(skb)->frag_list = frag; 1799 } 1800 1801 #define skb_walk_frags(skb, iter) \ 1802 for (iter = skb_shinfo(skb)->frag_list; iter; iter = iter->next) 1803 1804 extern struct sk_buff *__skb_recv_datagram(struct sock *sk, unsigned flags, 1805 int *peeked, int *err); 1806 extern struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags, 1807 int noblock, int *err); 1808 extern unsigned int datagram_poll(struct file *file, struct socket *sock, 1809 struct poll_table_struct *wait); 1810 extern int skb_copy_datagram_iovec(const struct sk_buff *from, 1811 int offset, struct iovec *to, 1812 int size); 1813 extern int skb_copy_and_csum_datagram_iovec(struct sk_buff *skb, 1814 int hlen, 1815 struct iovec *iov); 1816 extern int skb_copy_datagram_from_iovec(struct sk_buff *skb, 1817 int offset, 1818 const struct iovec *from, 1819 int from_offset, 1820 int len); 1821 extern int skb_copy_datagram_const_iovec(const struct sk_buff *from, 1822 int offset, 1823 const struct iovec *to, 1824 int to_offset, 1825 int size); 1826 extern void skb_free_datagram(struct sock *sk, struct sk_buff *skb); 1827 extern void skb_free_datagram_locked(struct sock *sk, 1828 struct sk_buff *skb); 1829 extern int skb_kill_datagram(struct sock *sk, struct sk_buff *skb, 1830 unsigned int flags); 1831 extern __wsum skb_checksum(const struct sk_buff *skb, int offset, 1832 int len, __wsum csum); 1833 extern int skb_copy_bits(const struct sk_buff *skb, int offset, 1834 void *to, int len); 1835 extern int skb_store_bits(struct sk_buff *skb, int offset, 1836 const void *from, int len); 1837 extern __wsum skb_copy_and_csum_bits(const struct sk_buff *skb, 1838 int offset, u8 *to, int len, 1839 __wsum csum); 1840 extern int skb_splice_bits(struct sk_buff *skb, 1841 unsigned int offset, 1842 struct pipe_inode_info *pipe, 1843 unsigned int len, 1844 unsigned int flags); 1845 extern void skb_copy_and_csum_dev(const struct sk_buff *skb, u8 *to); 1846 extern void skb_split(struct sk_buff *skb, 1847 struct sk_buff *skb1, const u32 len); 1848 extern int skb_shift(struct sk_buff *tgt, struct sk_buff *skb, 1849 int shiftlen); 1850 1851 extern struct sk_buff *skb_segment(struct sk_buff *skb, int features); 1852 1853 static inline void *skb_header_pointer(const struct sk_buff *skb, int offset, 1854 int len, void *buffer) 1855 { 1856 int hlen = skb_headlen(skb); 1857 1858 if (hlen - offset >= len) 1859 return skb->data + offset; 1860 1861 if (skb_copy_bits(skb, offset, buffer, len) < 0) 1862 return NULL; 1863 1864 return buffer; 1865 } 1866 1867 static inline void skb_copy_from_linear_data(const struct sk_buff *skb, 1868 void *to, 1869 const unsigned int len) 1870 { 1871 memcpy(to, skb->data, len); 1872 } 1873 1874 static inline void skb_copy_from_linear_data_offset(const struct sk_buff *skb, 1875 const int offset, void *to, 1876 const unsigned int len) 1877 { 1878 memcpy(to, skb->data + offset, len); 1879 } 1880 1881 static inline void skb_copy_to_linear_data(struct sk_buff *skb, 1882 const void *from, 1883 const unsigned int len) 1884 { 1885 memcpy(skb->data, from, len); 1886 } 1887 1888 static inline void skb_copy_to_linear_data_offset(struct sk_buff *skb, 1889 const int offset, 1890 const void *from, 1891 const unsigned int len) 1892 { 1893 memcpy(skb->data + offset, from, len); 1894 } 1895 1896 extern void skb_init(void); 1897 1898 static inline ktime_t skb_get_ktime(const struct sk_buff *skb) 1899 { 1900 return skb->tstamp; 1901 } 1902 1903 /** 1904 * skb_get_timestamp - get timestamp from a skb 1905 * @skb: skb to get stamp from 1906 * @stamp: pointer to struct timeval to store stamp in 1907 * 1908 * Timestamps are stored in the skb as offsets to a base timestamp. 1909 * This function converts the offset back to a struct timeval and stores 1910 * it in stamp. 1911 */ 1912 static inline void skb_get_timestamp(const struct sk_buff *skb, 1913 struct timeval *stamp) 1914 { 1915 *stamp = ktime_to_timeval(skb->tstamp); 1916 } 1917 1918 static inline void skb_get_timestampns(const struct sk_buff *skb, 1919 struct timespec *stamp) 1920 { 1921 *stamp = ktime_to_timespec(skb->tstamp); 1922 } 1923 1924 static inline void __net_timestamp(struct sk_buff *skb) 1925 { 1926 skb->tstamp = ktime_get_real(); 1927 } 1928 1929 static inline ktime_t net_timedelta(ktime_t t) 1930 { 1931 return ktime_sub(ktime_get_real(), t); 1932 } 1933 1934 static inline ktime_t net_invalid_timestamp(void) 1935 { 1936 return ktime_set(0, 0); 1937 } 1938 1939 extern void skb_timestamping_init(void); 1940 1941 #ifdef CONFIG_NETWORK_PHY_TIMESTAMPING 1942 1943 extern void skb_clone_tx_timestamp(struct sk_buff *skb); 1944 extern bool skb_defer_rx_timestamp(struct sk_buff *skb); 1945 1946 #else /* CONFIG_NETWORK_PHY_TIMESTAMPING */ 1947 1948 static inline void skb_clone_tx_timestamp(struct sk_buff *skb) 1949 { 1950 } 1951 1952 static inline bool skb_defer_rx_timestamp(struct sk_buff *skb) 1953 { 1954 return false; 1955 } 1956 1957 #endif /* !CONFIG_NETWORK_PHY_TIMESTAMPING */ 1958 1959 /** 1960 * skb_complete_tx_timestamp() - deliver cloned skb with tx timestamps 1961 * 1962 * @skb: clone of the the original outgoing packet 1963 * @hwtstamps: hardware time stamps 1964 * 1965 */ 1966 void skb_complete_tx_timestamp(struct sk_buff *skb, 1967 struct skb_shared_hwtstamps *hwtstamps); 1968 1969 /** 1970 * skb_tstamp_tx - queue clone of skb with send time stamps 1971 * @orig_skb: the original outgoing packet 1972 * @hwtstamps: hardware time stamps, may be NULL if not available 1973 * 1974 * If the skb has a socket associated, then this function clones the 1975 * skb (thus sharing the actual data and optional structures), stores 1976 * the optional hardware time stamping information (if non NULL) or 1977 * generates a software time stamp (otherwise), then queues the clone 1978 * to the error queue of the socket. Errors are silently ignored. 1979 */ 1980 extern void skb_tstamp_tx(struct sk_buff *orig_skb, 1981 struct skb_shared_hwtstamps *hwtstamps); 1982 1983 static inline void sw_tx_timestamp(struct sk_buff *skb) 1984 { 1985 union skb_shared_tx *shtx = skb_tx(skb); 1986 if (shtx->software && !shtx->in_progress) 1987 skb_tstamp_tx(skb, NULL); 1988 } 1989 1990 /** 1991 * skb_tx_timestamp() - Driver hook for transmit timestamping 1992 * 1993 * Ethernet MAC Drivers should call this function in their hard_xmit() 1994 * function as soon as possible after giving the sk_buff to the MAC 1995 * hardware, but before freeing the sk_buff. 1996 * 1997 * @skb: A socket buffer. 1998 */ 1999 static inline void skb_tx_timestamp(struct sk_buff *skb) 2000 { 2001 skb_clone_tx_timestamp(skb); 2002 sw_tx_timestamp(skb); 2003 } 2004 2005 extern __sum16 __skb_checksum_complete_head(struct sk_buff *skb, int len); 2006 extern __sum16 __skb_checksum_complete(struct sk_buff *skb); 2007 2008 static inline int skb_csum_unnecessary(const struct sk_buff *skb) 2009 { 2010 return skb->ip_summed & CHECKSUM_UNNECESSARY; 2011 } 2012 2013 /** 2014 * skb_checksum_complete - Calculate checksum of an entire packet 2015 * @skb: packet to process 2016 * 2017 * This function calculates the checksum over the entire packet plus 2018 * the value of skb->csum. The latter can be used to supply the 2019 * checksum of a pseudo header as used by TCP/UDP. It returns the 2020 * checksum. 2021 * 2022 * For protocols that contain complete checksums such as ICMP/TCP/UDP, 2023 * this function can be used to verify that checksum on received 2024 * packets. In that case the function should return zero if the 2025 * checksum is correct. In particular, this function will return zero 2026 * if skb->ip_summed is CHECKSUM_UNNECESSARY which indicates that the 2027 * hardware has already verified the correctness of the checksum. 2028 */ 2029 static inline __sum16 skb_checksum_complete(struct sk_buff *skb) 2030 { 2031 return skb_csum_unnecessary(skb) ? 2032 0 : __skb_checksum_complete(skb); 2033 } 2034 2035 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE) 2036 extern void nf_conntrack_destroy(struct nf_conntrack *nfct); 2037 static inline void nf_conntrack_put(struct nf_conntrack *nfct) 2038 { 2039 if (nfct && atomic_dec_and_test(&nfct->use)) 2040 nf_conntrack_destroy(nfct); 2041 } 2042 static inline void nf_conntrack_get(struct nf_conntrack *nfct) 2043 { 2044 if (nfct) 2045 atomic_inc(&nfct->use); 2046 } 2047 static inline void nf_conntrack_get_reasm(struct sk_buff *skb) 2048 { 2049 if (skb) 2050 atomic_inc(&skb->users); 2051 } 2052 static inline void nf_conntrack_put_reasm(struct sk_buff *skb) 2053 { 2054 if (skb) 2055 kfree_skb(skb); 2056 } 2057 #endif 2058 #ifdef CONFIG_BRIDGE_NETFILTER 2059 static inline void nf_bridge_put(struct nf_bridge_info *nf_bridge) 2060 { 2061 if (nf_bridge && atomic_dec_and_test(&nf_bridge->use)) 2062 kfree(nf_bridge); 2063 } 2064 static inline void nf_bridge_get(struct nf_bridge_info *nf_bridge) 2065 { 2066 if (nf_bridge) 2067 atomic_inc(&nf_bridge->use); 2068 } 2069 #endif /* CONFIG_BRIDGE_NETFILTER */ 2070 static inline void nf_reset(struct sk_buff *skb) 2071 { 2072 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE) 2073 nf_conntrack_put(skb->nfct); 2074 skb->nfct = NULL; 2075 nf_conntrack_put_reasm(skb->nfct_reasm); 2076 skb->nfct_reasm = NULL; 2077 #endif 2078 #ifdef CONFIG_BRIDGE_NETFILTER 2079 nf_bridge_put(skb->nf_bridge); 2080 skb->nf_bridge = NULL; 2081 #endif 2082 } 2083 2084 /* Note: This doesn't put any conntrack and bridge info in dst. */ 2085 static inline void __nf_copy(struct sk_buff *dst, const struct sk_buff *src) 2086 { 2087 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE) 2088 dst->nfct = src->nfct; 2089 nf_conntrack_get(src->nfct); 2090 dst->nfctinfo = src->nfctinfo; 2091 dst->nfct_reasm = src->nfct_reasm; 2092 nf_conntrack_get_reasm(src->nfct_reasm); 2093 #endif 2094 #ifdef CONFIG_BRIDGE_NETFILTER 2095 dst->nf_bridge = src->nf_bridge; 2096 nf_bridge_get(src->nf_bridge); 2097 #endif 2098 } 2099 2100 static inline void nf_copy(struct sk_buff *dst, const struct sk_buff *src) 2101 { 2102 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE) 2103 nf_conntrack_put(dst->nfct); 2104 nf_conntrack_put_reasm(dst->nfct_reasm); 2105 #endif 2106 #ifdef CONFIG_BRIDGE_NETFILTER 2107 nf_bridge_put(dst->nf_bridge); 2108 #endif 2109 __nf_copy(dst, src); 2110 } 2111 2112 #ifdef CONFIG_NETWORK_SECMARK 2113 static inline void skb_copy_secmark(struct sk_buff *to, const struct sk_buff *from) 2114 { 2115 to->secmark = from->secmark; 2116 } 2117 2118 static inline void skb_init_secmark(struct sk_buff *skb) 2119 { 2120 skb->secmark = 0; 2121 } 2122 #else 2123 static inline void skb_copy_secmark(struct sk_buff *to, const struct sk_buff *from) 2124 { } 2125 2126 static inline void skb_init_secmark(struct sk_buff *skb) 2127 { } 2128 #endif 2129 2130 static inline void skb_set_queue_mapping(struct sk_buff *skb, u16 queue_mapping) 2131 { 2132 skb->queue_mapping = queue_mapping; 2133 } 2134 2135 static inline u16 skb_get_queue_mapping(const struct sk_buff *skb) 2136 { 2137 return skb->queue_mapping; 2138 } 2139 2140 static inline void skb_copy_queue_mapping(struct sk_buff *to, const struct sk_buff *from) 2141 { 2142 to->queue_mapping = from->queue_mapping; 2143 } 2144 2145 static inline void skb_record_rx_queue(struct sk_buff *skb, u16 rx_queue) 2146 { 2147 skb->queue_mapping = rx_queue + 1; 2148 } 2149 2150 static inline u16 skb_get_rx_queue(const struct sk_buff *skb) 2151 { 2152 return skb->queue_mapping - 1; 2153 } 2154 2155 static inline bool skb_rx_queue_recorded(const struct sk_buff *skb) 2156 { 2157 return (skb->queue_mapping != 0); 2158 } 2159 2160 extern u16 skb_tx_hash(const struct net_device *dev, 2161 const struct sk_buff *skb); 2162 2163 #ifdef CONFIG_XFRM 2164 static inline struct sec_path *skb_sec_path(struct sk_buff *skb) 2165 { 2166 return skb->sp; 2167 } 2168 #else 2169 static inline struct sec_path *skb_sec_path(struct sk_buff *skb) 2170 { 2171 return NULL; 2172 } 2173 #endif 2174 2175 static inline int skb_is_gso(const struct sk_buff *skb) 2176 { 2177 return skb_shinfo(skb)->gso_size; 2178 } 2179 2180 static inline int skb_is_gso_v6(const struct sk_buff *skb) 2181 { 2182 return skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6; 2183 } 2184 2185 extern void __skb_warn_lro_forwarding(const struct sk_buff *skb); 2186 2187 static inline bool skb_warn_if_lro(const struct sk_buff *skb) 2188 { 2189 /* LRO sets gso_size but not gso_type, whereas if GSO is really 2190 * wanted then gso_type will be set. */ 2191 struct skb_shared_info *shinfo = skb_shinfo(skb); 2192 if (skb_is_nonlinear(skb) && shinfo->gso_size != 0 && 2193 unlikely(shinfo->gso_type == 0)) { 2194 __skb_warn_lro_forwarding(skb); 2195 return true; 2196 } 2197 return false; 2198 } 2199 2200 static inline void skb_forward_csum(struct sk_buff *skb) 2201 { 2202 /* Unfortunately we don't support this one. Any brave souls? */ 2203 if (skb->ip_summed == CHECKSUM_COMPLETE) 2204 skb->ip_summed = CHECKSUM_NONE; 2205 } 2206 2207 bool skb_partial_csum_set(struct sk_buff *skb, u16 start, u16 off); 2208 #endif /* __KERNEL__ */ 2209 #endif /* _LINUX_SKBUFF_H */ 2210