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