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