Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6] / net / core / skbuff.c
1 /*
2  *      Routines having to do with the 'struct sk_buff' memory handlers.
3  *
4  *      Authors:        Alan Cox <alan@lxorguk.ukuu.org.uk>
5  *                      Florian La Roche <rzsfl@rz.uni-sb.de>
6  *
7  *      Fixes:
8  *              Alan Cox        :       Fixed the worst of the load
9  *                                      balancer bugs.
10  *              Dave Platt      :       Interrupt stacking fix.
11  *      Richard Kooijman        :       Timestamp fixes.
12  *              Alan Cox        :       Changed buffer format.
13  *              Alan Cox        :       destructor hook for AF_UNIX etc.
14  *              Linus Torvalds  :       Better skb_clone.
15  *              Alan Cox        :       Added skb_copy.
16  *              Alan Cox        :       Added all the changed routines Linus
17  *                                      only put in the headers
18  *              Ray VanTassle   :       Fixed --skb->lock in free
19  *              Alan Cox        :       skb_copy copy arp field
20  *              Andi Kleen      :       slabified it.
21  *              Robert Olsson   :       Removed skb_head_pool
22  *
23  *      NOTE:
24  *              The __skb_ routines should be called with interrupts
25  *      disabled, or you better be *real* sure that the operation is atomic
26  *      with respect to whatever list is being frobbed (e.g. via lock_sock()
27  *      or via disabling bottom half handlers, etc).
28  *
29  *      This program is free software; you can redistribute it and/or
30  *      modify it under the terms of the GNU General Public License
31  *      as published by the Free Software Foundation; either version
32  *      2 of the License, or (at your option) any later version.
33  */
34
35 /*
36  *      The functions in this file will not compile correctly with gcc 2.4.x
37  */
38
39 #include <linux/module.h>
40 #include <linux/types.h>
41 #include <linux/kernel.h>
42 #include <linux/mm.h>
43 #include <linux/interrupt.h>
44 #include <linux/in.h>
45 #include <linux/inet.h>
46 #include <linux/slab.h>
47 #include <linux/netdevice.h>
48 #ifdef CONFIG_NET_CLS_ACT
49 #include <net/pkt_sched.h>
50 #endif
51 #include <linux/string.h>
52 #include <linux/skbuff.h>
53 #include <linux/splice.h>
54 #include <linux/cache.h>
55 #include <linux/rtnetlink.h>
56 #include <linux/init.h>
57 #include <linux/scatterlist.h>
58 #include <linux/errqueue.h>
59
60 #include <net/protocol.h>
61 #include <net/dst.h>
62 #include <net/sock.h>
63 #include <net/checksum.h>
64 #include <net/xfrm.h>
65
66 #include <asm/uaccess.h>
67 #include <asm/system.h>
68 #include <trace/skb.h>
69
70 #include "kmap_skb.h"
71
72 static struct kmem_cache *skbuff_head_cache __read_mostly;
73 static struct kmem_cache *skbuff_fclone_cache __read_mostly;
74
75 static void sock_pipe_buf_release(struct pipe_inode_info *pipe,
76                                   struct pipe_buffer *buf)
77 {
78         put_page(buf->page);
79 }
80
81 static void sock_pipe_buf_get(struct pipe_inode_info *pipe,
82                                 struct pipe_buffer *buf)
83 {
84         get_page(buf->page);
85 }
86
87 static int sock_pipe_buf_steal(struct pipe_inode_info *pipe,
88                                struct pipe_buffer *buf)
89 {
90         return 1;
91 }
92
93
94 /* Pipe buffer operations for a socket. */
95 static struct pipe_buf_operations sock_pipe_buf_ops = {
96         .can_merge = 0,
97         .map = generic_pipe_buf_map,
98         .unmap = generic_pipe_buf_unmap,
99         .confirm = generic_pipe_buf_confirm,
100         .release = sock_pipe_buf_release,
101         .steal = sock_pipe_buf_steal,
102         .get = sock_pipe_buf_get,
103 };
104
105 /*
106  *      Keep out-of-line to prevent kernel bloat.
107  *      __builtin_return_address is not used because it is not always
108  *      reliable.
109  */
110
111 /**
112  *      skb_over_panic  -       private function
113  *      @skb: buffer
114  *      @sz: size
115  *      @here: address
116  *
117  *      Out of line support code for skb_put(). Not user callable.
118  */
119 void skb_over_panic(struct sk_buff *skb, int sz, void *here)
120 {
121         printk(KERN_EMERG "skb_over_panic: text:%p len:%d put:%d head:%p "
122                           "data:%p tail:%#lx end:%#lx dev:%s\n",
123                here, skb->len, sz, skb->head, skb->data,
124                (unsigned long)skb->tail, (unsigned long)skb->end,
125                skb->dev ? skb->dev->name : "<NULL>");
126         BUG();
127 }
128 EXPORT_SYMBOL(skb_over_panic);
129
130 /**
131  *      skb_under_panic -       private function
132  *      @skb: buffer
133  *      @sz: size
134  *      @here: address
135  *
136  *      Out of line support code for skb_push(). Not user callable.
137  */
138
139 void skb_under_panic(struct sk_buff *skb, int sz, void *here)
140 {
141         printk(KERN_EMERG "skb_under_panic: text:%p len:%d put:%d head:%p "
142                           "data:%p tail:%#lx end:%#lx dev:%s\n",
143                here, skb->len, sz, skb->head, skb->data,
144                (unsigned long)skb->tail, (unsigned long)skb->end,
145                skb->dev ? skb->dev->name : "<NULL>");
146         BUG();
147 }
148 EXPORT_SYMBOL(skb_under_panic);
149
150 /*      Allocate a new skbuff. We do this ourselves so we can fill in a few
151  *      'private' fields and also do memory statistics to find all the
152  *      [BEEP] leaks.
153  *
154  */
155
156 /**
157  *      __alloc_skb     -       allocate a network buffer
158  *      @size: size to allocate
159  *      @gfp_mask: allocation mask
160  *      @fclone: allocate from fclone cache instead of head cache
161  *              and allocate a cloned (child) skb
162  *      @node: numa node to allocate memory on
163  *
164  *      Allocate a new &sk_buff. The returned buffer has no headroom and a
165  *      tail room of size bytes. The object has a reference count of one.
166  *      The return is the buffer. On a failure the return is %NULL.
167  *
168  *      Buffers may only be allocated from interrupts using a @gfp_mask of
169  *      %GFP_ATOMIC.
170  */
171 struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask,
172                             int fclone, int node)
173 {
174         struct kmem_cache *cache;
175         struct skb_shared_info *shinfo;
176         struct sk_buff *skb;
177         u8 *data;
178
179         cache = fclone ? skbuff_fclone_cache : skbuff_head_cache;
180
181         /* Get the HEAD */
182         skb = kmem_cache_alloc_node(cache, gfp_mask & ~__GFP_DMA, node);
183         if (!skb)
184                 goto out;
185
186         size = SKB_DATA_ALIGN(size);
187         data = kmalloc_node_track_caller(size + sizeof(struct skb_shared_info),
188                         gfp_mask, node);
189         if (!data)
190                 goto nodata;
191
192         /*
193          * Only clear those fields we need to clear, not those that we will
194          * actually initialise below. Hence, don't put any more fields after
195          * the tail pointer in struct sk_buff!
196          */
197         memset(skb, 0, offsetof(struct sk_buff, tail));
198         skb->truesize = size + sizeof(struct sk_buff);
199         atomic_set(&skb->users, 1);
200         skb->head = data;
201         skb->data = data;
202         skb_reset_tail_pointer(skb);
203         skb->end = skb->tail + size;
204         /* make sure we initialize shinfo sequentially */
205         shinfo = skb_shinfo(skb);
206         atomic_set(&shinfo->dataref, 1);
207         shinfo->nr_frags  = 0;
208         shinfo->gso_size = 0;
209         shinfo->gso_segs = 0;
210         shinfo->gso_type = 0;
211         shinfo->ip6_frag_id = 0;
212         shinfo->tx_flags.flags = 0;
213         shinfo->frag_list = NULL;
214         memset(&shinfo->hwtstamps, 0, sizeof(shinfo->hwtstamps));
215
216         if (fclone) {
217                 struct sk_buff *child = skb + 1;
218                 atomic_t *fclone_ref = (atomic_t *) (child + 1);
219
220                 skb->fclone = SKB_FCLONE_ORIG;
221                 atomic_set(fclone_ref, 1);
222
223                 child->fclone = SKB_FCLONE_UNAVAILABLE;
224         }
225 out:
226         return skb;
227 nodata:
228         kmem_cache_free(cache, skb);
229         skb = NULL;
230         goto out;
231 }
232 EXPORT_SYMBOL(__alloc_skb);
233
234 /**
235  *      __netdev_alloc_skb - allocate an skbuff for rx on a specific device
236  *      @dev: network device to receive on
237  *      @length: length to allocate
238  *      @gfp_mask: get_free_pages mask, passed to alloc_skb
239  *
240  *      Allocate a new &sk_buff and assign it a usage count of one. The
241  *      buffer has unspecified headroom built in. Users should allocate
242  *      the headroom they think they need without accounting for the
243  *      built in space. The built in space is used for optimisations.
244  *
245  *      %NULL is returned if there is no free memory.
246  */
247 struct sk_buff *__netdev_alloc_skb(struct net_device *dev,
248                 unsigned int length, gfp_t gfp_mask)
249 {
250         int node = dev->dev.parent ? dev_to_node(dev->dev.parent) : -1;
251         struct sk_buff *skb;
252
253         skb = __alloc_skb(length + NET_SKB_PAD, gfp_mask, 0, node);
254         if (likely(skb)) {
255                 skb_reserve(skb, NET_SKB_PAD);
256                 skb->dev = dev;
257         }
258         return skb;
259 }
260 EXPORT_SYMBOL(__netdev_alloc_skb);
261
262 struct page *__netdev_alloc_page(struct net_device *dev, gfp_t gfp_mask)
263 {
264         int node = dev->dev.parent ? dev_to_node(dev->dev.parent) : -1;
265         struct page *page;
266
267         page = alloc_pages_node(node, gfp_mask, 0);
268         return page;
269 }
270 EXPORT_SYMBOL(__netdev_alloc_page);
271
272 void skb_add_rx_frag(struct sk_buff *skb, int i, struct page *page, int off,
273                 int size)
274 {
275         skb_fill_page_desc(skb, i, page, off, size);
276         skb->len += size;
277         skb->data_len += size;
278         skb->truesize += size;
279 }
280 EXPORT_SYMBOL(skb_add_rx_frag);
281
282 /**
283  *      dev_alloc_skb - allocate an skbuff for receiving
284  *      @length: length to allocate
285  *
286  *      Allocate a new &sk_buff and assign it a usage count of one. The
287  *      buffer has unspecified headroom built in. Users should allocate
288  *      the headroom they think they need without accounting for the
289  *      built in space. The built in space is used for optimisations.
290  *
291  *      %NULL is returned if there is no free memory. Although this function
292  *      allocates memory it can be called from an interrupt.
293  */
294 struct sk_buff *dev_alloc_skb(unsigned int length)
295 {
296         /*
297          * There is more code here than it seems:
298          * __dev_alloc_skb is an inline
299          */
300         return __dev_alloc_skb(length, GFP_ATOMIC);
301 }
302 EXPORT_SYMBOL(dev_alloc_skb);
303
304 static void skb_drop_list(struct sk_buff **listp)
305 {
306         struct sk_buff *list = *listp;
307
308         *listp = NULL;
309
310         do {
311                 struct sk_buff *this = list;
312                 list = list->next;
313                 kfree_skb(this);
314         } while (list);
315 }
316
317 static inline void skb_drop_fraglist(struct sk_buff *skb)
318 {
319         skb_drop_list(&skb_shinfo(skb)->frag_list);
320 }
321
322 static void skb_clone_fraglist(struct sk_buff *skb)
323 {
324         struct sk_buff *list;
325
326         for (list = skb_shinfo(skb)->frag_list; list; list = list->next)
327                 skb_get(list);
328 }
329
330 static void skb_release_data(struct sk_buff *skb)
331 {
332         if (!skb->cloned ||
333             !atomic_sub_return(skb->nohdr ? (1 << SKB_DATAREF_SHIFT) + 1 : 1,
334                                &skb_shinfo(skb)->dataref)) {
335                 if (skb_shinfo(skb)->nr_frags) {
336                         int i;
337                         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
338                                 put_page(skb_shinfo(skb)->frags[i].page);
339                 }
340
341                 if (skb_shinfo(skb)->frag_list)
342                         skb_drop_fraglist(skb);
343
344                 kfree(skb->head);
345         }
346 }
347
348 /*
349  *      Free an skbuff by memory without cleaning the state.
350  */
351 static void kfree_skbmem(struct sk_buff *skb)
352 {
353         struct sk_buff *other;
354         atomic_t *fclone_ref;
355
356         switch (skb->fclone) {
357         case SKB_FCLONE_UNAVAILABLE:
358                 kmem_cache_free(skbuff_head_cache, skb);
359                 break;
360
361         case SKB_FCLONE_ORIG:
362                 fclone_ref = (atomic_t *) (skb + 2);
363                 if (atomic_dec_and_test(fclone_ref))
364                         kmem_cache_free(skbuff_fclone_cache, skb);
365                 break;
366
367         case SKB_FCLONE_CLONE:
368                 fclone_ref = (atomic_t *) (skb + 1);
369                 other = skb - 1;
370
371                 /* The clone portion is available for
372                  * fast-cloning again.
373                  */
374                 skb->fclone = SKB_FCLONE_UNAVAILABLE;
375
376                 if (atomic_dec_and_test(fclone_ref))
377                         kmem_cache_free(skbuff_fclone_cache, other);
378                 break;
379         }
380 }
381
382 static void skb_release_head_state(struct sk_buff *skb)
383 {
384         dst_release(skb->dst);
385 #ifdef CONFIG_XFRM
386         secpath_put(skb->sp);
387 #endif
388         if (skb->destructor) {
389                 WARN_ON(in_irq());
390                 skb->destructor(skb);
391         }
392 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
393         nf_conntrack_put(skb->nfct);
394         nf_conntrack_put_reasm(skb->nfct_reasm);
395 #endif
396 #ifdef CONFIG_BRIDGE_NETFILTER
397         nf_bridge_put(skb->nf_bridge);
398 #endif
399 /* XXX: IS this still necessary? - JHS */
400 #ifdef CONFIG_NET_SCHED
401         skb->tc_index = 0;
402 #ifdef CONFIG_NET_CLS_ACT
403         skb->tc_verd = 0;
404 #endif
405 #endif
406 }
407
408 /* Free everything but the sk_buff shell. */
409 static void skb_release_all(struct sk_buff *skb)
410 {
411         skb_release_head_state(skb);
412         skb_release_data(skb);
413 }
414
415 /**
416  *      __kfree_skb - private function
417  *      @skb: buffer
418  *
419  *      Free an sk_buff. Release anything attached to the buffer.
420  *      Clean the state. This is an internal helper function. Users should
421  *      always call kfree_skb
422  */
423
424 void __kfree_skb(struct sk_buff *skb)
425 {
426         skb_release_all(skb);
427         kfree_skbmem(skb);
428 }
429 EXPORT_SYMBOL(__kfree_skb);
430
431 /**
432  *      kfree_skb - free an sk_buff
433  *      @skb: buffer to free
434  *
435  *      Drop a reference to the buffer and free it if the usage count has
436  *      hit zero.
437  */
438 void kfree_skb(struct sk_buff *skb)
439 {
440         if (unlikely(!skb))
441                 return;
442         if (likely(atomic_read(&skb->users) == 1))
443                 smp_rmb();
444         else if (likely(!atomic_dec_and_test(&skb->users)))
445                 return;
446         trace_kfree_skb(skb, __builtin_return_address(0));
447         __kfree_skb(skb);
448 }
449 EXPORT_SYMBOL(kfree_skb);
450
451 /**
452  *      consume_skb - free an skbuff
453  *      @skb: buffer to free
454  *
455  *      Drop a ref to the buffer and free it if the usage count has hit zero
456  *      Functions identically to kfree_skb, but kfree_skb assumes that the frame
457  *      is being dropped after a failure and notes that
458  */
459 void consume_skb(struct sk_buff *skb)
460 {
461         if (unlikely(!skb))
462                 return;
463         if (likely(atomic_read(&skb->users) == 1))
464                 smp_rmb();
465         else if (likely(!atomic_dec_and_test(&skb->users)))
466                 return;
467         __kfree_skb(skb);
468 }
469 EXPORT_SYMBOL(consume_skb);
470
471 /**
472  *      skb_recycle_check - check if skb can be reused for receive
473  *      @skb: buffer
474  *      @skb_size: minimum receive buffer size
475  *
476  *      Checks that the skb passed in is not shared or cloned, and
477  *      that it is linear and its head portion at least as large as
478  *      skb_size so that it can be recycled as a receive buffer.
479  *      If these conditions are met, this function does any necessary
480  *      reference count dropping and cleans up the skbuff as if it
481  *      just came from __alloc_skb().
482  */
483 int skb_recycle_check(struct sk_buff *skb, int skb_size)
484 {
485         struct skb_shared_info *shinfo;
486
487         if (skb_is_nonlinear(skb) || skb->fclone != SKB_FCLONE_UNAVAILABLE)
488                 return 0;
489
490         skb_size = SKB_DATA_ALIGN(skb_size + NET_SKB_PAD);
491         if (skb_end_pointer(skb) - skb->head < skb_size)
492                 return 0;
493
494         if (skb_shared(skb) || skb_cloned(skb))
495                 return 0;
496
497         skb_release_head_state(skb);
498         shinfo = skb_shinfo(skb);
499         atomic_set(&shinfo->dataref, 1);
500         shinfo->nr_frags = 0;
501         shinfo->gso_size = 0;
502         shinfo->gso_segs = 0;
503         shinfo->gso_type = 0;
504         shinfo->ip6_frag_id = 0;
505         shinfo->frag_list = NULL;
506
507         memset(skb, 0, offsetof(struct sk_buff, tail));
508         skb->data = skb->head + NET_SKB_PAD;
509         skb_reset_tail_pointer(skb);
510
511         return 1;
512 }
513 EXPORT_SYMBOL(skb_recycle_check);
514
515 static void __copy_skb_header(struct sk_buff *new, const struct sk_buff *old)
516 {
517         new->tstamp             = old->tstamp;
518         new->dev                = old->dev;
519         new->transport_header   = old->transport_header;
520         new->network_header     = old->network_header;
521         new->mac_header         = old->mac_header;
522         new->dst                = dst_clone(old->dst);
523 #ifdef CONFIG_XFRM
524         new->sp                 = secpath_get(old->sp);
525 #endif
526         memcpy(new->cb, old->cb, sizeof(old->cb));
527         new->csum_start         = old->csum_start;
528         new->csum_offset        = old->csum_offset;
529         new->local_df           = old->local_df;
530         new->pkt_type           = old->pkt_type;
531         new->ip_summed          = old->ip_summed;
532         skb_copy_queue_mapping(new, old);
533         new->priority           = old->priority;
534 #if defined(CONFIG_IP_VS) || defined(CONFIG_IP_VS_MODULE)
535         new->ipvs_property      = old->ipvs_property;
536 #endif
537         new->protocol           = old->protocol;
538         new->mark               = old->mark;
539         __nf_copy(new, old);
540 #if defined(CONFIG_NETFILTER_XT_TARGET_TRACE) || \
541     defined(CONFIG_NETFILTER_XT_TARGET_TRACE_MODULE)
542         new->nf_trace           = old->nf_trace;
543 #endif
544 #ifdef CONFIG_NET_SCHED
545         new->tc_index           = old->tc_index;
546 #ifdef CONFIG_NET_CLS_ACT
547         new->tc_verd            = old->tc_verd;
548 #endif
549 #endif
550         new->vlan_tci           = old->vlan_tci;
551
552         skb_copy_secmark(new, old);
553 }
554
555 static struct sk_buff *__skb_clone(struct sk_buff *n, struct sk_buff *skb)
556 {
557 #define C(x) n->x = skb->x
558
559         n->next = n->prev = NULL;
560         n->sk = NULL;
561         __copy_skb_header(n, skb);
562
563         C(len);
564         C(data_len);
565         C(mac_len);
566         n->hdr_len = skb->nohdr ? skb_headroom(skb) : skb->hdr_len;
567         n->cloned = 1;
568         n->nohdr = 0;
569         n->destructor = NULL;
570         C(iif);
571         C(tail);
572         C(end);
573         C(head);
574         C(data);
575         C(truesize);
576 #if defined(CONFIG_MAC80211) || defined(CONFIG_MAC80211_MODULE)
577         C(do_not_encrypt);
578         C(requeue);
579 #endif
580         atomic_set(&n->users, 1);
581
582         atomic_inc(&(skb_shinfo(skb)->dataref));
583         skb->cloned = 1;
584
585         return n;
586 #undef C
587 }
588
589 /**
590  *      skb_morph       -       morph one skb into another
591  *      @dst: the skb to receive the contents
592  *      @src: the skb to supply the contents
593  *
594  *      This is identical to skb_clone except that the target skb is
595  *      supplied by the user.
596  *
597  *      The target skb is returned upon exit.
598  */
599 struct sk_buff *skb_morph(struct sk_buff *dst, struct sk_buff *src)
600 {
601         skb_release_all(dst);
602         return __skb_clone(dst, src);
603 }
604 EXPORT_SYMBOL_GPL(skb_morph);
605
606 /**
607  *      skb_clone       -       duplicate an sk_buff
608  *      @skb: buffer to clone
609  *      @gfp_mask: allocation priority
610  *
611  *      Duplicate an &sk_buff. The new one is not owned by a socket. Both
612  *      copies share the same packet data but not structure. The new
613  *      buffer has a reference count of 1. If the allocation fails the
614  *      function returns %NULL otherwise the new buffer is returned.
615  *
616  *      If this function is called from an interrupt gfp_mask() must be
617  *      %GFP_ATOMIC.
618  */
619
620 struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t gfp_mask)
621 {
622         struct sk_buff *n;
623
624         n = skb + 1;
625         if (skb->fclone == SKB_FCLONE_ORIG &&
626             n->fclone == SKB_FCLONE_UNAVAILABLE) {
627                 atomic_t *fclone_ref = (atomic_t *) (n + 1);
628                 n->fclone = SKB_FCLONE_CLONE;
629                 atomic_inc(fclone_ref);
630         } else {
631                 n = kmem_cache_alloc(skbuff_head_cache, gfp_mask);
632                 if (!n)
633                         return NULL;
634                 n->fclone = SKB_FCLONE_UNAVAILABLE;
635         }
636
637         return __skb_clone(n, skb);
638 }
639 EXPORT_SYMBOL(skb_clone);
640
641 static void copy_skb_header(struct sk_buff *new, const struct sk_buff *old)
642 {
643 #ifndef NET_SKBUFF_DATA_USES_OFFSET
644         /*
645          *      Shift between the two data areas in bytes
646          */
647         unsigned long offset = new->data - old->data;
648 #endif
649
650         __copy_skb_header(new, old);
651
652 #ifndef NET_SKBUFF_DATA_USES_OFFSET
653         /* {transport,network,mac}_header are relative to skb->head */
654         new->transport_header += offset;
655         new->network_header   += offset;
656         new->mac_header       += offset;
657 #endif
658         skb_shinfo(new)->gso_size = skb_shinfo(old)->gso_size;
659         skb_shinfo(new)->gso_segs = skb_shinfo(old)->gso_segs;
660         skb_shinfo(new)->gso_type = skb_shinfo(old)->gso_type;
661 }
662
663 /**
664  *      skb_copy        -       create private copy of an sk_buff
665  *      @skb: buffer to copy
666  *      @gfp_mask: allocation priority
667  *
668  *      Make a copy of both an &sk_buff and its data. This is used when the
669  *      caller wishes to modify the data and needs a private copy of the
670  *      data to alter. Returns %NULL on failure or the pointer to the buffer
671  *      on success. The returned buffer has a reference count of 1.
672  *
673  *      As by-product this function converts non-linear &sk_buff to linear
674  *      one, so that &sk_buff becomes completely private and caller is allowed
675  *      to modify all the data of returned buffer. This means that this
676  *      function is not recommended for use in circumstances when only
677  *      header is going to be modified. Use pskb_copy() instead.
678  */
679
680 struct sk_buff *skb_copy(const struct sk_buff *skb, gfp_t gfp_mask)
681 {
682         int headerlen = skb->data - skb->head;
683         /*
684          *      Allocate the copy buffer
685          */
686         struct sk_buff *n;
687 #ifdef NET_SKBUFF_DATA_USES_OFFSET
688         n = alloc_skb(skb->end + skb->data_len, gfp_mask);
689 #else
690         n = alloc_skb(skb->end - skb->head + skb->data_len, gfp_mask);
691 #endif
692         if (!n)
693                 return NULL;
694
695         /* Set the data pointer */
696         skb_reserve(n, headerlen);
697         /* Set the tail pointer and length */
698         skb_put(n, skb->len);
699
700         if (skb_copy_bits(skb, -headerlen, n->head, headerlen + skb->len))
701                 BUG();
702
703         copy_skb_header(n, skb);
704         return n;
705 }
706 EXPORT_SYMBOL(skb_copy);
707
708 /**
709  *      pskb_copy       -       create copy of an sk_buff with private head.
710  *      @skb: buffer to copy
711  *      @gfp_mask: allocation priority
712  *
713  *      Make a copy of both an &sk_buff and part of its data, located
714  *      in header. Fragmented data remain shared. This is used when
715  *      the caller wishes to modify only header of &sk_buff and needs
716  *      private copy of the header to alter. Returns %NULL on failure
717  *      or the pointer to the buffer on success.
718  *      The returned buffer has a reference count of 1.
719  */
720
721 struct sk_buff *pskb_copy(struct sk_buff *skb, gfp_t gfp_mask)
722 {
723         /*
724          *      Allocate the copy buffer
725          */
726         struct sk_buff *n;
727 #ifdef NET_SKBUFF_DATA_USES_OFFSET
728         n = alloc_skb(skb->end, gfp_mask);
729 #else
730         n = alloc_skb(skb->end - skb->head, gfp_mask);
731 #endif
732         if (!n)
733                 goto out;
734
735         /* Set the data pointer */
736         skb_reserve(n, skb->data - skb->head);
737         /* Set the tail pointer and length */
738         skb_put(n, skb_headlen(skb));
739         /* Copy the bytes */
740         skb_copy_from_linear_data(skb, n->data, n->len);
741
742         n->truesize += skb->data_len;
743         n->data_len  = skb->data_len;
744         n->len       = skb->len;
745
746         if (skb_shinfo(skb)->nr_frags) {
747                 int i;
748
749                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
750                         skb_shinfo(n)->frags[i] = skb_shinfo(skb)->frags[i];
751                         get_page(skb_shinfo(n)->frags[i].page);
752                 }
753                 skb_shinfo(n)->nr_frags = i;
754         }
755
756         if (skb_shinfo(skb)->frag_list) {
757                 skb_shinfo(n)->frag_list = skb_shinfo(skb)->frag_list;
758                 skb_clone_fraglist(n);
759         }
760
761         copy_skb_header(n, skb);
762 out:
763         return n;
764 }
765 EXPORT_SYMBOL(pskb_copy);
766
767 /**
768  *      pskb_expand_head - reallocate header of &sk_buff
769  *      @skb: buffer to reallocate
770  *      @nhead: room to add at head
771  *      @ntail: room to add at tail
772  *      @gfp_mask: allocation priority
773  *
774  *      Expands (or creates identical copy, if &nhead and &ntail are zero)
775  *      header of skb. &sk_buff itself is not changed. &sk_buff MUST have
776  *      reference count of 1. Returns zero in the case of success or error,
777  *      if expansion failed. In the last case, &sk_buff is not changed.
778  *
779  *      All the pointers pointing into skb header may change and must be
780  *      reloaded after call to this function.
781  */
782
783 int pskb_expand_head(struct sk_buff *skb, int nhead, int ntail,
784                      gfp_t gfp_mask)
785 {
786         int i;
787         u8 *data;
788 #ifdef NET_SKBUFF_DATA_USES_OFFSET
789         int size = nhead + skb->end + ntail;
790 #else
791         int size = nhead + (skb->end - skb->head) + ntail;
792 #endif
793         long off;
794
795         BUG_ON(nhead < 0);
796
797         if (skb_shared(skb))
798                 BUG();
799
800         size = SKB_DATA_ALIGN(size);
801
802         data = kmalloc(size + sizeof(struct skb_shared_info), gfp_mask);
803         if (!data)
804                 goto nodata;
805
806         /* Copy only real data... and, alas, header. This should be
807          * optimized for the cases when header is void. */
808 #ifdef NET_SKBUFF_DATA_USES_OFFSET
809         memcpy(data + nhead, skb->head, skb->tail);
810 #else
811         memcpy(data + nhead, skb->head, skb->tail - skb->head);
812 #endif
813         memcpy(data + size, skb_end_pointer(skb),
814                sizeof(struct skb_shared_info));
815
816         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
817                 get_page(skb_shinfo(skb)->frags[i].page);
818
819         if (skb_shinfo(skb)->frag_list)
820                 skb_clone_fraglist(skb);
821
822         skb_release_data(skb);
823
824         off = (data + nhead) - skb->head;
825
826         skb->head     = data;
827         skb->data    += off;
828 #ifdef NET_SKBUFF_DATA_USES_OFFSET
829         skb->end      = size;
830         off           = nhead;
831 #else
832         skb->end      = skb->head + size;
833 #endif
834         /* {transport,network,mac}_header and tail are relative to skb->head */
835         skb->tail             += off;
836         skb->transport_header += off;
837         skb->network_header   += off;
838         skb->mac_header       += off;
839         skb->csum_start       += nhead;
840         skb->cloned   = 0;
841         skb->hdr_len  = 0;
842         skb->nohdr    = 0;
843         atomic_set(&skb_shinfo(skb)->dataref, 1);
844         return 0;
845
846 nodata:
847         return -ENOMEM;
848 }
849 EXPORT_SYMBOL(pskb_expand_head);
850
851 /* Make private copy of skb with writable head and some headroom */
852
853 struct sk_buff *skb_realloc_headroom(struct sk_buff *skb, unsigned int headroom)
854 {
855         struct sk_buff *skb2;
856         int delta = headroom - skb_headroom(skb);
857
858         if (delta <= 0)
859                 skb2 = pskb_copy(skb, GFP_ATOMIC);
860         else {
861                 skb2 = skb_clone(skb, GFP_ATOMIC);
862                 if (skb2 && pskb_expand_head(skb2, SKB_DATA_ALIGN(delta), 0,
863                                              GFP_ATOMIC)) {
864                         kfree_skb(skb2);
865                         skb2 = NULL;
866                 }
867         }
868         return skb2;
869 }
870 EXPORT_SYMBOL(skb_realloc_headroom);
871
872 /**
873  *      skb_copy_expand -       copy and expand sk_buff
874  *      @skb: buffer to copy
875  *      @newheadroom: new free bytes at head
876  *      @newtailroom: new free bytes at tail
877  *      @gfp_mask: allocation priority
878  *
879  *      Make a copy of both an &sk_buff and its data and while doing so
880  *      allocate additional space.
881  *
882  *      This is used when the caller wishes to modify the data and needs a
883  *      private copy of the data to alter as well as more space for new fields.
884  *      Returns %NULL on failure or the pointer to the buffer
885  *      on success. The returned buffer has a reference count of 1.
886  *
887  *      You must pass %GFP_ATOMIC as the allocation priority if this function
888  *      is called from an interrupt.
889  */
890 struct sk_buff *skb_copy_expand(const struct sk_buff *skb,
891                                 int newheadroom, int newtailroom,
892                                 gfp_t gfp_mask)
893 {
894         /*
895          *      Allocate the copy buffer
896          */
897         struct sk_buff *n = alloc_skb(newheadroom + skb->len + newtailroom,
898                                       gfp_mask);
899         int oldheadroom = skb_headroom(skb);
900         int head_copy_len, head_copy_off;
901         int off;
902
903         if (!n)
904                 return NULL;
905
906         skb_reserve(n, newheadroom);
907
908         /* Set the tail pointer and length */
909         skb_put(n, skb->len);
910
911         head_copy_len = oldheadroom;
912         head_copy_off = 0;
913         if (newheadroom <= head_copy_len)
914                 head_copy_len = newheadroom;
915         else
916                 head_copy_off = newheadroom - head_copy_len;
917
918         /* Copy the linear header and data. */
919         if (skb_copy_bits(skb, -head_copy_len, n->head + head_copy_off,
920                           skb->len + head_copy_len))
921                 BUG();
922
923         copy_skb_header(n, skb);
924
925         off                  = newheadroom - oldheadroom;
926         n->csum_start       += off;
927 #ifdef NET_SKBUFF_DATA_USES_OFFSET
928         n->transport_header += off;
929         n->network_header   += off;
930         n->mac_header       += off;
931 #endif
932
933         return n;
934 }
935 EXPORT_SYMBOL(skb_copy_expand);
936
937 /**
938  *      skb_pad                 -       zero pad the tail of an skb
939  *      @skb: buffer to pad
940  *      @pad: space to pad
941  *
942  *      Ensure that a buffer is followed by a padding area that is zero
943  *      filled. Used by network drivers which may DMA or transfer data
944  *      beyond the buffer end onto the wire.
945  *
946  *      May return error in out of memory cases. The skb is freed on error.
947  */
948
949 int skb_pad(struct sk_buff *skb, int pad)
950 {
951         int err;
952         int ntail;
953
954         /* If the skbuff is non linear tailroom is always zero.. */
955         if (!skb_cloned(skb) && skb_tailroom(skb) >= pad) {
956                 memset(skb->data+skb->len, 0, pad);
957                 return 0;
958         }
959
960         ntail = skb->data_len + pad - (skb->end - skb->tail);
961         if (likely(skb_cloned(skb) || ntail > 0)) {
962                 err = pskb_expand_head(skb, 0, ntail, GFP_ATOMIC);
963                 if (unlikely(err))
964                         goto free_skb;
965         }
966
967         /* FIXME: The use of this function with non-linear skb's really needs
968          * to be audited.
969          */
970         err = skb_linearize(skb);
971         if (unlikely(err))
972                 goto free_skb;
973
974         memset(skb->data + skb->len, 0, pad);
975         return 0;
976
977 free_skb:
978         kfree_skb(skb);
979         return err;
980 }
981 EXPORT_SYMBOL(skb_pad);
982
983 /**
984  *      skb_put - add data to a buffer
985  *      @skb: buffer to use
986  *      @len: amount of data to add
987  *
988  *      This function extends the used data area of the buffer. If this would
989  *      exceed the total buffer size the kernel will panic. A pointer to the
990  *      first byte of the extra data is returned.
991  */
992 unsigned char *skb_put(struct sk_buff *skb, unsigned int len)
993 {
994         unsigned char *tmp = skb_tail_pointer(skb);
995         SKB_LINEAR_ASSERT(skb);
996         skb->tail += len;
997         skb->len  += len;
998         if (unlikely(skb->tail > skb->end))
999                 skb_over_panic(skb, len, __builtin_return_address(0));
1000         return tmp;
1001 }
1002 EXPORT_SYMBOL(skb_put);
1003
1004 /**
1005  *      skb_push - add data to the start of a buffer
1006  *      @skb: buffer to use
1007  *      @len: amount of data to add
1008  *
1009  *      This function extends the used data area of the buffer at the buffer
1010  *      start. If this would exceed the total buffer headroom the kernel will
1011  *      panic. A pointer to the first byte of the extra data is returned.
1012  */
1013 unsigned char *skb_push(struct sk_buff *skb, unsigned int len)
1014 {
1015         skb->data -= len;
1016         skb->len  += len;
1017         if (unlikely(skb->data<skb->head))
1018                 skb_under_panic(skb, len, __builtin_return_address(0));
1019         return skb->data;
1020 }
1021 EXPORT_SYMBOL(skb_push);
1022
1023 /**
1024  *      skb_pull - remove data from the start of a buffer
1025  *      @skb: buffer to use
1026  *      @len: amount of data to remove
1027  *
1028  *      This function removes data from the start of a buffer, returning
1029  *      the memory to the headroom. A pointer to the next data in the buffer
1030  *      is returned. Once the data has been pulled future pushes will overwrite
1031  *      the old data.
1032  */
1033 unsigned char *skb_pull(struct sk_buff *skb, unsigned int len)
1034 {
1035         return unlikely(len > skb->len) ? NULL : __skb_pull(skb, len);
1036 }
1037 EXPORT_SYMBOL(skb_pull);
1038
1039 /**
1040  *      skb_trim - remove end from a buffer
1041  *      @skb: buffer to alter
1042  *      @len: new length
1043  *
1044  *      Cut the length of a buffer down by removing data from the tail. If
1045  *      the buffer is already under the length specified it is not modified.
1046  *      The skb must be linear.
1047  */
1048 void skb_trim(struct sk_buff *skb, unsigned int len)
1049 {
1050         if (skb->len > len)
1051                 __skb_trim(skb, len);
1052 }
1053 EXPORT_SYMBOL(skb_trim);
1054
1055 /* Trims skb to length len. It can change skb pointers.
1056  */
1057
1058 int ___pskb_trim(struct sk_buff *skb, unsigned int len)
1059 {
1060         struct sk_buff **fragp;
1061         struct sk_buff *frag;
1062         int offset = skb_headlen(skb);
1063         int nfrags = skb_shinfo(skb)->nr_frags;
1064         int i;
1065         int err;
1066
1067         if (skb_cloned(skb) &&
1068             unlikely((err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC))))
1069                 return err;
1070
1071         i = 0;
1072         if (offset >= len)
1073                 goto drop_pages;
1074
1075         for (; i < nfrags; i++) {
1076                 int end = offset + skb_shinfo(skb)->frags[i].size;
1077
1078                 if (end < len) {
1079                         offset = end;
1080                         continue;
1081                 }
1082
1083                 skb_shinfo(skb)->frags[i++].size = len - offset;
1084
1085 drop_pages:
1086                 skb_shinfo(skb)->nr_frags = i;
1087
1088                 for (; i < nfrags; i++)
1089                         put_page(skb_shinfo(skb)->frags[i].page);
1090
1091                 if (skb_shinfo(skb)->frag_list)
1092                         skb_drop_fraglist(skb);
1093                 goto done;
1094         }
1095
1096         for (fragp = &skb_shinfo(skb)->frag_list; (frag = *fragp);
1097              fragp = &frag->next) {
1098                 int end = offset + frag->len;
1099
1100                 if (skb_shared(frag)) {
1101                         struct sk_buff *nfrag;
1102
1103                         nfrag = skb_clone(frag, GFP_ATOMIC);
1104                         if (unlikely(!nfrag))
1105                                 return -ENOMEM;
1106
1107                         nfrag->next = frag->next;
1108                         kfree_skb(frag);
1109                         frag = nfrag;
1110                         *fragp = frag;
1111                 }
1112
1113                 if (end < len) {
1114                         offset = end;
1115                         continue;
1116                 }
1117
1118                 if (end > len &&
1119                     unlikely((err = pskb_trim(frag, len - offset))))
1120                         return err;
1121
1122                 if (frag->next)
1123                         skb_drop_list(&frag->next);
1124                 break;
1125         }
1126
1127 done:
1128         if (len > skb_headlen(skb)) {
1129                 skb->data_len -= skb->len - len;
1130                 skb->len       = len;
1131         } else {
1132                 skb->len       = len;
1133                 skb->data_len  = 0;
1134                 skb_set_tail_pointer(skb, len);
1135         }
1136
1137         return 0;
1138 }
1139 EXPORT_SYMBOL(___pskb_trim);
1140
1141 /**
1142  *      __pskb_pull_tail - advance tail of skb header
1143  *      @skb: buffer to reallocate
1144  *      @delta: number of bytes to advance tail
1145  *
1146  *      The function makes a sense only on a fragmented &sk_buff,
1147  *      it expands header moving its tail forward and copying necessary
1148  *      data from fragmented part.
1149  *
1150  *      &sk_buff MUST have reference count of 1.
1151  *
1152  *      Returns %NULL (and &sk_buff does not change) if pull failed
1153  *      or value of new tail of skb in the case of success.
1154  *
1155  *      All the pointers pointing into skb header may change and must be
1156  *      reloaded after call to this function.
1157  */
1158
1159 /* Moves tail of skb head forward, copying data from fragmented part,
1160  * when it is necessary.
1161  * 1. It may fail due to malloc failure.
1162  * 2. It may change skb pointers.
1163  *
1164  * It is pretty complicated. Luckily, it is called only in exceptional cases.
1165  */
1166 unsigned char *__pskb_pull_tail(struct sk_buff *skb, int delta)
1167 {
1168         /* If skb has not enough free space at tail, get new one
1169          * plus 128 bytes for future expansions. If we have enough
1170          * room at tail, reallocate without expansion only if skb is cloned.
1171          */
1172         int i, k, eat = (skb->tail + delta) - skb->end;
1173
1174         if (eat > 0 || skb_cloned(skb)) {
1175                 if (pskb_expand_head(skb, 0, eat > 0 ? eat + 128 : 0,
1176                                      GFP_ATOMIC))
1177                         return NULL;
1178         }
1179
1180         if (skb_copy_bits(skb, skb_headlen(skb), skb_tail_pointer(skb), delta))
1181                 BUG();
1182
1183         /* Optimization: no fragments, no reasons to preestimate
1184          * size of pulled pages. Superb.
1185          */
1186         if (!skb_shinfo(skb)->frag_list)
1187                 goto pull_pages;
1188
1189         /* Estimate size of pulled pages. */
1190         eat = delta;
1191         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1192                 if (skb_shinfo(skb)->frags[i].size >= eat)
1193                         goto pull_pages;
1194                 eat -= skb_shinfo(skb)->frags[i].size;
1195         }
1196
1197         /* If we need update frag list, we are in troubles.
1198          * Certainly, it possible to add an offset to skb data,
1199          * but taking into account that pulling is expected to
1200          * be very rare operation, it is worth to fight against
1201          * further bloating skb head and crucify ourselves here instead.
1202          * Pure masohism, indeed. 8)8)
1203          */
1204         if (eat) {
1205                 struct sk_buff *list = skb_shinfo(skb)->frag_list;
1206                 struct sk_buff *clone = NULL;
1207                 struct sk_buff *insp = NULL;
1208
1209                 do {
1210                         BUG_ON(!list);
1211
1212                         if (list->len <= eat) {
1213                                 /* Eaten as whole. */
1214                                 eat -= list->len;
1215                                 list = list->next;
1216                                 insp = list;
1217                         } else {
1218                                 /* Eaten partially. */
1219
1220                                 if (skb_shared(list)) {
1221                                         /* Sucks! We need to fork list. :-( */
1222                                         clone = skb_clone(list, GFP_ATOMIC);
1223                                         if (!clone)
1224                                                 return NULL;
1225                                         insp = list->next;
1226                                         list = clone;
1227                                 } else {
1228                                         /* This may be pulled without
1229                                          * problems. */
1230                                         insp = list;
1231                                 }
1232                                 if (!pskb_pull(list, eat)) {
1233                                         kfree_skb(clone);
1234                                         return NULL;
1235                                 }
1236                                 break;
1237                         }
1238                 } while (eat);
1239
1240                 /* Free pulled out fragments. */
1241                 while ((list = skb_shinfo(skb)->frag_list) != insp) {
1242                         skb_shinfo(skb)->frag_list = list->next;
1243                         kfree_skb(list);
1244                 }
1245                 /* And insert new clone at head. */
1246                 if (clone) {
1247                         clone->next = list;
1248                         skb_shinfo(skb)->frag_list = clone;
1249                 }
1250         }
1251         /* Success! Now we may commit changes to skb data. */
1252
1253 pull_pages:
1254         eat = delta;
1255         k = 0;
1256         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1257                 if (skb_shinfo(skb)->frags[i].size <= eat) {
1258                         put_page(skb_shinfo(skb)->frags[i].page);
1259                         eat -= skb_shinfo(skb)->frags[i].size;
1260                 } else {
1261                         skb_shinfo(skb)->frags[k] = skb_shinfo(skb)->frags[i];
1262                         if (eat) {
1263                                 skb_shinfo(skb)->frags[k].page_offset += eat;
1264                                 skb_shinfo(skb)->frags[k].size -= eat;
1265                                 eat = 0;
1266                         }
1267                         k++;
1268                 }
1269         }
1270         skb_shinfo(skb)->nr_frags = k;
1271
1272         skb->tail     += delta;
1273         skb->data_len -= delta;
1274
1275         return skb_tail_pointer(skb);
1276 }
1277 EXPORT_SYMBOL(__pskb_pull_tail);
1278
1279 /* Copy some data bits from skb to kernel buffer. */
1280
1281 int skb_copy_bits(const struct sk_buff *skb, int offset, void *to, int len)
1282 {
1283         int i, copy;
1284         int start = skb_headlen(skb);
1285
1286         if (offset > (int)skb->len - len)
1287                 goto fault;
1288
1289         /* Copy header. */
1290         if ((copy = start - offset) > 0) {
1291                 if (copy > len)
1292                         copy = len;
1293                 skb_copy_from_linear_data_offset(skb, offset, to, copy);
1294                 if ((len -= copy) == 0)
1295                         return 0;
1296                 offset += copy;
1297                 to     += copy;
1298         }
1299
1300         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1301                 int end;
1302
1303                 WARN_ON(start > offset + len);
1304
1305                 end = start + skb_shinfo(skb)->frags[i].size;
1306                 if ((copy = end - offset) > 0) {
1307                         u8 *vaddr;
1308
1309                         if (copy > len)
1310                                 copy = len;
1311
1312                         vaddr = kmap_skb_frag(&skb_shinfo(skb)->frags[i]);
1313                         memcpy(to,
1314                                vaddr + skb_shinfo(skb)->frags[i].page_offset+
1315                                offset - start, copy);
1316                         kunmap_skb_frag(vaddr);
1317
1318                         if ((len -= copy) == 0)
1319                                 return 0;
1320                         offset += copy;
1321                         to     += copy;
1322                 }
1323                 start = end;
1324         }
1325
1326         if (skb_shinfo(skb)->frag_list) {
1327                 struct sk_buff *list = skb_shinfo(skb)->frag_list;
1328
1329                 for (; list; list = list->next) {
1330                         int end;
1331
1332                         WARN_ON(start > offset + len);
1333
1334                         end = start + list->len;
1335                         if ((copy = end - offset) > 0) {
1336                                 if (copy > len)
1337                                         copy = len;
1338                                 if (skb_copy_bits(list, offset - start,
1339                                                   to, copy))
1340                                         goto fault;
1341                                 if ((len -= copy) == 0)
1342                                         return 0;
1343                                 offset += copy;
1344                                 to     += copy;
1345                         }
1346                         start = end;
1347                 }
1348         }
1349         if (!len)
1350                 return 0;
1351
1352 fault:
1353         return -EFAULT;
1354 }
1355 EXPORT_SYMBOL(skb_copy_bits);
1356
1357 /*
1358  * Callback from splice_to_pipe(), if we need to release some pages
1359  * at the end of the spd in case we error'ed out in filling the pipe.
1360  */
1361 static void sock_spd_release(struct splice_pipe_desc *spd, unsigned int i)
1362 {
1363         put_page(spd->pages[i]);
1364 }
1365
1366 static inline struct page *linear_to_page(struct page *page, unsigned int *len,
1367                                           unsigned int *offset,
1368                                           struct sk_buff *skb, struct sock *sk)
1369 {
1370         struct page *p = sk->sk_sndmsg_page;
1371         unsigned int off;
1372
1373         if (!p) {
1374 new_page:
1375                 p = sk->sk_sndmsg_page = alloc_pages(sk->sk_allocation, 0);
1376                 if (!p)
1377                         return NULL;
1378
1379                 off = sk->sk_sndmsg_off = 0;
1380                 /* hold one ref to this page until it's full */
1381         } else {
1382                 unsigned int mlen;
1383
1384                 off = sk->sk_sndmsg_off;
1385                 mlen = PAGE_SIZE - off;
1386                 if (mlen < 64 && mlen < *len) {
1387                         put_page(p);
1388                         goto new_page;
1389                 }
1390
1391                 *len = min_t(unsigned int, *len, mlen);
1392         }
1393
1394         memcpy(page_address(p) + off, page_address(page) + *offset, *len);
1395         sk->sk_sndmsg_off += *len;
1396         *offset = off;
1397         get_page(p);
1398
1399         return p;
1400 }
1401
1402 /*
1403  * Fill page/offset/length into spd, if it can hold more pages.
1404  */
1405 static inline int spd_fill_page(struct splice_pipe_desc *spd, struct page *page,
1406                                 unsigned int *len, unsigned int offset,
1407                                 struct sk_buff *skb, int linear,
1408                                 struct sock *sk)
1409 {
1410         if (unlikely(spd->nr_pages == PIPE_BUFFERS))
1411                 return 1;
1412
1413         if (linear) {
1414                 page = linear_to_page(page, len, &offset, skb, sk);
1415                 if (!page)
1416                         return 1;
1417         } else
1418                 get_page(page);
1419
1420         spd->pages[spd->nr_pages] = page;
1421         spd->partial[spd->nr_pages].len = *len;
1422         spd->partial[spd->nr_pages].offset = offset;
1423         spd->nr_pages++;
1424
1425         return 0;
1426 }
1427
1428 static inline void __segment_seek(struct page **page, unsigned int *poff,
1429                                   unsigned int *plen, unsigned int off)
1430 {
1431         unsigned long n;
1432
1433         *poff += off;
1434         n = *poff / PAGE_SIZE;
1435         if (n)
1436                 *page = nth_page(*page, n);
1437
1438         *poff = *poff % PAGE_SIZE;
1439         *plen -= off;
1440 }
1441
1442 static inline int __splice_segment(struct page *page, unsigned int poff,
1443                                    unsigned int plen, unsigned int *off,
1444                                    unsigned int *len, struct sk_buff *skb,
1445                                    struct splice_pipe_desc *spd, int linear,
1446                                    struct sock *sk)
1447 {
1448         if (!*len)
1449                 return 1;
1450
1451         /* skip this segment if already processed */
1452         if (*off >= plen) {
1453                 *off -= plen;
1454                 return 0;
1455         }
1456
1457         /* ignore any bits we already processed */
1458         if (*off) {
1459                 __segment_seek(&page, &poff, &plen, *off);
1460                 *off = 0;
1461         }
1462
1463         do {
1464                 unsigned int flen = min(*len, plen);
1465
1466                 /* the linear region may spread across several pages  */
1467                 flen = min_t(unsigned int, flen, PAGE_SIZE - poff);
1468
1469                 if (spd_fill_page(spd, page, &flen, poff, skb, linear, sk))
1470                         return 1;
1471
1472                 __segment_seek(&page, &poff, &plen, flen);
1473                 *len -= flen;
1474
1475         } while (*len && plen);
1476
1477         return 0;
1478 }
1479
1480 /*
1481  * Map linear and fragment data from the skb to spd. It reports failure if the
1482  * pipe is full or if we already spliced the requested length.
1483  */
1484 static int __skb_splice_bits(struct sk_buff *skb, unsigned int *offset,
1485                              unsigned int *len, struct splice_pipe_desc *spd,
1486                              struct sock *sk)
1487 {
1488         int seg;
1489
1490         /*
1491          * map the linear part
1492          */
1493         if (__splice_segment(virt_to_page(skb->data),
1494                              (unsigned long) skb->data & (PAGE_SIZE - 1),
1495                              skb_headlen(skb),
1496                              offset, len, skb, spd, 1, sk))
1497                 return 1;
1498
1499         /*
1500          * then map the fragments
1501          */
1502         for (seg = 0; seg < skb_shinfo(skb)->nr_frags; seg++) {
1503                 const skb_frag_t *f = &skb_shinfo(skb)->frags[seg];
1504
1505                 if (__splice_segment(f->page, f->page_offset, f->size,
1506                                      offset, len, skb, spd, 0, sk))
1507                         return 1;
1508         }
1509
1510         return 0;
1511 }
1512
1513 /*
1514  * Map data from the skb to a pipe. Should handle both the linear part,
1515  * the fragments, and the frag list. It does NOT handle frag lists within
1516  * the frag list, if such a thing exists. We'd probably need to recurse to
1517  * handle that cleanly.
1518  */
1519 int skb_splice_bits(struct sk_buff *skb, unsigned int offset,
1520                     struct pipe_inode_info *pipe, unsigned int tlen,
1521                     unsigned int flags)
1522 {
1523         struct partial_page partial[PIPE_BUFFERS];
1524         struct page *pages[PIPE_BUFFERS];
1525         struct splice_pipe_desc spd = {
1526                 .pages = pages,
1527                 .partial = partial,
1528                 .flags = flags,
1529                 .ops = &sock_pipe_buf_ops,
1530                 .spd_release = sock_spd_release,
1531         };
1532         struct sock *sk = skb->sk;
1533
1534         /*
1535          * __skb_splice_bits() only fails if the output has no room left,
1536          * so no point in going over the frag_list for the error case.
1537          */
1538         if (__skb_splice_bits(skb, &offset, &tlen, &spd, sk))
1539                 goto done;
1540         else if (!tlen)
1541                 goto done;
1542
1543         /*
1544          * now see if we have a frag_list to map
1545          */
1546         if (skb_shinfo(skb)->frag_list) {
1547                 struct sk_buff *list = skb_shinfo(skb)->frag_list;
1548
1549                 for (; list && tlen; list = list->next) {
1550                         if (__skb_splice_bits(list, &offset, &tlen, &spd, sk))
1551                                 break;
1552                 }
1553         }
1554
1555 done:
1556         if (spd.nr_pages) {
1557                 int ret;
1558
1559                 /*
1560                  * Drop the socket lock, otherwise we have reverse
1561                  * locking dependencies between sk_lock and i_mutex
1562                  * here as compared to sendfile(). We enter here
1563                  * with the socket lock held, and splice_to_pipe() will
1564                  * grab the pipe inode lock. For sendfile() emulation,
1565                  * we call into ->sendpage() with the i_mutex lock held
1566                  * and networking will grab the socket lock.
1567                  */
1568                 release_sock(sk);
1569                 ret = splice_to_pipe(pipe, &spd);
1570                 lock_sock(sk);
1571                 return ret;
1572         }
1573
1574         return 0;
1575 }
1576
1577 /**
1578  *      skb_store_bits - store bits from kernel buffer to skb
1579  *      @skb: destination buffer
1580  *      @offset: offset in destination
1581  *      @from: source buffer
1582  *      @len: number of bytes to copy
1583  *
1584  *      Copy the specified number of bytes from the source buffer to the
1585  *      destination skb.  This function handles all the messy bits of
1586  *      traversing fragment lists and such.
1587  */
1588
1589 int skb_store_bits(struct sk_buff *skb, int offset, const void *from, int len)
1590 {
1591         int i, copy;
1592         int start = skb_headlen(skb);
1593
1594         if (offset > (int)skb->len - len)
1595                 goto fault;
1596
1597         if ((copy = start - offset) > 0) {
1598                 if (copy > len)
1599                         copy = len;
1600                 skb_copy_to_linear_data_offset(skb, offset, from, copy);
1601                 if ((len -= copy) == 0)
1602                         return 0;
1603                 offset += copy;
1604                 from += copy;
1605         }
1606
1607         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1608                 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
1609                 int end;
1610
1611                 WARN_ON(start > offset + len);
1612
1613                 end = start + frag->size;
1614                 if ((copy = end - offset) > 0) {
1615                         u8 *vaddr;
1616
1617                         if (copy > len)
1618                                 copy = len;
1619
1620                         vaddr = kmap_skb_frag(frag);
1621                         memcpy(vaddr + frag->page_offset + offset - start,
1622                                from, copy);
1623                         kunmap_skb_frag(vaddr);
1624
1625                         if ((len -= copy) == 0)
1626                                 return 0;
1627                         offset += copy;
1628                         from += copy;
1629                 }
1630                 start = end;
1631         }
1632
1633         if (skb_shinfo(skb)->frag_list) {
1634                 struct sk_buff *list = skb_shinfo(skb)->frag_list;
1635
1636                 for (; list; list = list->next) {
1637                         int end;
1638
1639                         WARN_ON(start > offset + len);
1640
1641                         end = start + list->len;
1642                         if ((copy = end - offset) > 0) {
1643                                 if (copy > len)
1644                                         copy = len;
1645                                 if (skb_store_bits(list, offset - start,
1646                                                    from, copy))
1647                                         goto fault;
1648                                 if ((len -= copy) == 0)
1649                                         return 0;
1650                                 offset += copy;
1651                                 from += copy;
1652                         }
1653                         start = end;
1654                 }
1655         }
1656         if (!len)
1657                 return 0;
1658
1659 fault:
1660         return -EFAULT;
1661 }
1662 EXPORT_SYMBOL(skb_store_bits);
1663
1664 /* Checksum skb data. */
1665
1666 __wsum skb_checksum(const struct sk_buff *skb, int offset,
1667                           int len, __wsum csum)
1668 {
1669         int start = skb_headlen(skb);
1670         int i, copy = start - offset;
1671         int pos = 0;
1672
1673         /* Checksum header. */
1674         if (copy > 0) {
1675                 if (copy > len)
1676                         copy = len;
1677                 csum = csum_partial(skb->data + offset, copy, csum);
1678                 if ((len -= copy) == 0)
1679                         return csum;
1680                 offset += copy;
1681                 pos     = copy;
1682         }
1683
1684         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1685                 int end;
1686
1687                 WARN_ON(start > offset + len);
1688
1689                 end = start + skb_shinfo(skb)->frags[i].size;
1690                 if ((copy = end - offset) > 0) {
1691                         __wsum csum2;
1692                         u8 *vaddr;
1693                         skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
1694
1695                         if (copy > len)
1696                                 copy = len;
1697                         vaddr = kmap_skb_frag(frag);
1698                         csum2 = csum_partial(vaddr + frag->page_offset +
1699                                              offset - start, copy, 0);
1700                         kunmap_skb_frag(vaddr);
1701                         csum = csum_block_add(csum, csum2, pos);
1702                         if (!(len -= copy))
1703                                 return csum;
1704                         offset += copy;
1705                         pos    += copy;
1706                 }
1707                 start = end;
1708         }
1709
1710         if (skb_shinfo(skb)->frag_list) {
1711                 struct sk_buff *list = skb_shinfo(skb)->frag_list;
1712
1713                 for (; list; list = list->next) {
1714                         int end;
1715
1716                         WARN_ON(start > offset + len);
1717
1718                         end = start + list->len;
1719                         if ((copy = end - offset) > 0) {
1720                                 __wsum csum2;
1721                                 if (copy > len)
1722                                         copy = len;
1723                                 csum2 = skb_checksum(list, offset - start,
1724                                                      copy, 0);
1725                                 csum = csum_block_add(csum, csum2, pos);
1726                                 if ((len -= copy) == 0)
1727                                         return csum;
1728                                 offset += copy;
1729                                 pos    += copy;
1730                         }
1731                         start = end;
1732                 }
1733         }
1734         BUG_ON(len);
1735
1736         return csum;
1737 }
1738 EXPORT_SYMBOL(skb_checksum);
1739
1740 /* Both of above in one bottle. */
1741
1742 __wsum skb_copy_and_csum_bits(const struct sk_buff *skb, int offset,
1743                                     u8 *to, int len, __wsum csum)
1744 {
1745         int start = skb_headlen(skb);
1746         int i, copy = start - offset;
1747         int pos = 0;
1748
1749         /* Copy header. */
1750         if (copy > 0) {
1751                 if (copy > len)
1752                         copy = len;
1753                 csum = csum_partial_copy_nocheck(skb->data + offset, to,
1754                                                  copy, csum);
1755                 if ((len -= copy) == 0)
1756                         return csum;
1757                 offset += copy;
1758                 to     += copy;
1759                 pos     = copy;
1760         }
1761
1762         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1763                 int end;
1764
1765                 WARN_ON(start > offset + len);
1766
1767                 end = start + skb_shinfo(skb)->frags[i].size;
1768                 if ((copy = end - offset) > 0) {
1769                         __wsum csum2;
1770                         u8 *vaddr;
1771                         skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
1772
1773                         if (copy > len)
1774                                 copy = len;
1775                         vaddr = kmap_skb_frag(frag);
1776                         csum2 = csum_partial_copy_nocheck(vaddr +
1777                                                           frag->page_offset +
1778                                                           offset - start, to,
1779                                                           copy, 0);
1780                         kunmap_skb_frag(vaddr);
1781                         csum = csum_block_add(csum, csum2, pos);
1782                         if (!(len -= copy))
1783                                 return csum;
1784                         offset += copy;
1785                         to     += copy;
1786                         pos    += copy;
1787                 }
1788                 start = end;
1789         }
1790
1791         if (skb_shinfo(skb)->frag_list) {
1792                 struct sk_buff *list = skb_shinfo(skb)->frag_list;
1793
1794                 for (; list; list = list->next) {
1795                         __wsum csum2;
1796                         int end;
1797
1798                         WARN_ON(start > offset + len);
1799
1800                         end = start + list->len;
1801                         if ((copy = end - offset) > 0) {
1802                                 if (copy > len)
1803                                         copy = len;
1804                                 csum2 = skb_copy_and_csum_bits(list,
1805                                                                offset - start,
1806                                                                to, copy, 0);
1807                                 csum = csum_block_add(csum, csum2, pos);
1808                                 if ((len -= copy) == 0)
1809                                         return csum;
1810                                 offset += copy;
1811                                 to     += copy;
1812                                 pos    += copy;
1813                         }
1814                         start = end;
1815                 }
1816         }
1817         BUG_ON(len);
1818         return csum;
1819 }
1820 EXPORT_SYMBOL(skb_copy_and_csum_bits);
1821
1822 void skb_copy_and_csum_dev(const struct sk_buff *skb, u8 *to)
1823 {
1824         __wsum csum;
1825         long csstart;
1826
1827         if (skb->ip_summed == CHECKSUM_PARTIAL)
1828                 csstart = skb->csum_start - skb_headroom(skb);
1829         else
1830                 csstart = skb_headlen(skb);
1831
1832         BUG_ON(csstart > skb_headlen(skb));
1833
1834         skb_copy_from_linear_data(skb, to, csstart);
1835
1836         csum = 0;
1837         if (csstart != skb->len)
1838                 csum = skb_copy_and_csum_bits(skb, csstart, to + csstart,
1839                                               skb->len - csstart, 0);
1840
1841         if (skb->ip_summed == CHECKSUM_PARTIAL) {
1842                 long csstuff = csstart + skb->csum_offset;
1843
1844                 *((__sum16 *)(to + csstuff)) = csum_fold(csum);
1845         }
1846 }
1847 EXPORT_SYMBOL(skb_copy_and_csum_dev);
1848
1849 /**
1850  *      skb_dequeue - remove from the head of the queue
1851  *      @list: list to dequeue from
1852  *
1853  *      Remove the head of the list. The list lock is taken so the function
1854  *      may be used safely with other locking list functions. The head item is
1855  *      returned or %NULL if the list is empty.
1856  */
1857
1858 struct sk_buff *skb_dequeue(struct sk_buff_head *list)
1859 {
1860         unsigned long flags;
1861         struct sk_buff *result;
1862
1863         spin_lock_irqsave(&list->lock, flags);
1864         result = __skb_dequeue(list);
1865         spin_unlock_irqrestore(&list->lock, flags);
1866         return result;
1867 }
1868 EXPORT_SYMBOL(skb_dequeue);
1869
1870 /**
1871  *      skb_dequeue_tail - remove from the tail of the queue
1872  *      @list: list to dequeue from
1873  *
1874  *      Remove the tail of the list. The list lock is taken so the function
1875  *      may be used safely with other locking list functions. The tail item is
1876  *      returned or %NULL if the list is empty.
1877  */
1878 struct sk_buff *skb_dequeue_tail(struct sk_buff_head *list)
1879 {
1880         unsigned long flags;
1881         struct sk_buff *result;
1882
1883         spin_lock_irqsave(&list->lock, flags);
1884         result = __skb_dequeue_tail(list);
1885         spin_unlock_irqrestore(&list->lock, flags);
1886         return result;
1887 }
1888 EXPORT_SYMBOL(skb_dequeue_tail);
1889
1890 /**
1891  *      skb_queue_purge - empty a list
1892  *      @list: list to empty
1893  *
1894  *      Delete all buffers on an &sk_buff list. Each buffer is removed from
1895  *      the list and one reference dropped. This function takes the list
1896  *      lock and is atomic with respect to other list locking functions.
1897  */
1898 void skb_queue_purge(struct sk_buff_head *list)
1899 {
1900         struct sk_buff *skb;
1901         while ((skb = skb_dequeue(list)) != NULL)
1902                 kfree_skb(skb);
1903 }
1904 EXPORT_SYMBOL(skb_queue_purge);
1905
1906 /**
1907  *      skb_queue_head - queue a buffer at the list head
1908  *      @list: list to use
1909  *      @newsk: buffer to queue
1910  *
1911  *      Queue a buffer at the start of the list. This function takes the
1912  *      list lock and can be used safely with other locking &sk_buff functions
1913  *      safely.
1914  *
1915  *      A buffer cannot be placed on two lists at the same time.
1916  */
1917 void skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk)
1918 {
1919         unsigned long flags;
1920
1921         spin_lock_irqsave(&list->lock, flags);
1922         __skb_queue_head(list, newsk);
1923         spin_unlock_irqrestore(&list->lock, flags);
1924 }
1925 EXPORT_SYMBOL(skb_queue_head);
1926
1927 /**
1928  *      skb_queue_tail - queue a buffer at the list tail
1929  *      @list: list to use
1930  *      @newsk: buffer to queue
1931  *
1932  *      Queue a buffer at the tail of the list. This function takes the
1933  *      list lock and can be used safely with other locking &sk_buff functions
1934  *      safely.
1935  *
1936  *      A buffer cannot be placed on two lists at the same time.
1937  */
1938 void skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk)
1939 {
1940         unsigned long flags;
1941
1942         spin_lock_irqsave(&list->lock, flags);
1943         __skb_queue_tail(list, newsk);
1944         spin_unlock_irqrestore(&list->lock, flags);
1945 }
1946 EXPORT_SYMBOL(skb_queue_tail);
1947
1948 /**
1949  *      skb_unlink      -       remove a buffer from a list
1950  *      @skb: buffer to remove
1951  *      @list: list to use
1952  *
1953  *      Remove a packet from a list. The list locks are taken and this
1954  *      function is atomic with respect to other list locked calls
1955  *
1956  *      You must know what list the SKB is on.
1957  */
1958 void skb_unlink(struct sk_buff *skb, struct sk_buff_head *list)
1959 {
1960         unsigned long flags;
1961
1962         spin_lock_irqsave(&list->lock, flags);
1963         __skb_unlink(skb, list);
1964         spin_unlock_irqrestore(&list->lock, flags);
1965 }
1966 EXPORT_SYMBOL(skb_unlink);
1967
1968 /**
1969  *      skb_append      -       append a buffer
1970  *      @old: buffer to insert after
1971  *      @newsk: buffer to insert
1972  *      @list: list to use
1973  *
1974  *      Place a packet after a given packet in a list. The list locks are taken
1975  *      and this function is atomic with respect to other list locked calls.
1976  *      A buffer cannot be placed on two lists at the same time.
1977  */
1978 void skb_append(struct sk_buff *old, struct sk_buff *newsk, struct sk_buff_head *list)
1979 {
1980         unsigned long flags;
1981
1982         spin_lock_irqsave(&list->lock, flags);
1983         __skb_queue_after(list, old, newsk);
1984         spin_unlock_irqrestore(&list->lock, flags);
1985 }
1986 EXPORT_SYMBOL(skb_append);
1987
1988 /**
1989  *      skb_insert      -       insert a buffer
1990  *      @old: buffer to insert before
1991  *      @newsk: buffer to insert
1992  *      @list: list to use
1993  *
1994  *      Place a packet before a given packet in a list. The list locks are
1995  *      taken and this function is atomic with respect to other list locked
1996  *      calls.
1997  *
1998  *      A buffer cannot be placed on two lists at the same time.
1999  */
2000 void skb_insert(struct sk_buff *old, struct sk_buff *newsk, struct sk_buff_head *list)
2001 {
2002         unsigned long flags;
2003
2004         spin_lock_irqsave(&list->lock, flags);
2005         __skb_insert(newsk, old->prev, old, list);
2006         spin_unlock_irqrestore(&list->lock, flags);
2007 }
2008 EXPORT_SYMBOL(skb_insert);
2009
2010 static inline void skb_split_inside_header(struct sk_buff *skb,
2011                                            struct sk_buff* skb1,
2012                                            const u32 len, const int pos)
2013 {
2014         int i;
2015
2016         skb_copy_from_linear_data_offset(skb, len, skb_put(skb1, pos - len),
2017                                          pos - len);
2018         /* And move data appendix as is. */
2019         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
2020                 skb_shinfo(skb1)->frags[i] = skb_shinfo(skb)->frags[i];
2021
2022         skb_shinfo(skb1)->nr_frags = skb_shinfo(skb)->nr_frags;
2023         skb_shinfo(skb)->nr_frags  = 0;
2024         skb1->data_len             = skb->data_len;
2025         skb1->len                  += skb1->data_len;
2026         skb->data_len              = 0;
2027         skb->len                   = len;
2028         skb_set_tail_pointer(skb, len);
2029 }
2030
2031 static inline void skb_split_no_header(struct sk_buff *skb,
2032                                        struct sk_buff* skb1,
2033                                        const u32 len, int pos)
2034 {
2035         int i, k = 0;
2036         const int nfrags = skb_shinfo(skb)->nr_frags;
2037
2038         skb_shinfo(skb)->nr_frags = 0;
2039         skb1->len                 = skb1->data_len = skb->len - len;
2040         skb->len                  = len;
2041         skb->data_len             = len - pos;
2042
2043         for (i = 0; i < nfrags; i++) {
2044                 int size = skb_shinfo(skb)->frags[i].size;
2045
2046                 if (pos + size > len) {
2047                         skb_shinfo(skb1)->frags[k] = skb_shinfo(skb)->frags[i];
2048
2049                         if (pos < len) {
2050                                 /* Split frag.
2051                                  * We have two variants in this case:
2052                                  * 1. Move all the frag to the second
2053                                  *    part, if it is possible. F.e.
2054                                  *    this approach is mandatory for TUX,
2055                                  *    where splitting is expensive.
2056                                  * 2. Split is accurately. We make this.
2057                                  */
2058                                 get_page(skb_shinfo(skb)->frags[i].page);
2059                                 skb_shinfo(skb1)->frags[0].page_offset += len - pos;
2060                                 skb_shinfo(skb1)->frags[0].size -= len - pos;
2061                                 skb_shinfo(skb)->frags[i].size  = len - pos;
2062                                 skb_shinfo(skb)->nr_frags++;
2063                         }
2064                         k++;
2065                 } else
2066                         skb_shinfo(skb)->nr_frags++;
2067                 pos += size;
2068         }
2069         skb_shinfo(skb1)->nr_frags = k;
2070 }
2071
2072 /**
2073  * skb_split - Split fragmented skb to two parts at length len.
2074  * @skb: the buffer to split
2075  * @skb1: the buffer to receive the second part
2076  * @len: new length for skb
2077  */
2078 void skb_split(struct sk_buff *skb, struct sk_buff *skb1, const u32 len)
2079 {
2080         int pos = skb_headlen(skb);
2081
2082         if (len < pos)  /* Split line is inside header. */
2083                 skb_split_inside_header(skb, skb1, len, pos);
2084         else            /* Second chunk has no header, nothing to copy. */
2085                 skb_split_no_header(skb, skb1, len, pos);
2086 }
2087 EXPORT_SYMBOL(skb_split);
2088
2089 /* Shifting from/to a cloned skb is a no-go.
2090  *
2091  * Caller cannot keep skb_shinfo related pointers past calling here!
2092  */
2093 static int skb_prepare_for_shift(struct sk_buff *skb)
2094 {
2095         return skb_cloned(skb) && pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
2096 }
2097
2098 /**
2099  * skb_shift - Shifts paged data partially from skb to another
2100  * @tgt: buffer into which tail data gets added
2101  * @skb: buffer from which the paged data comes from
2102  * @shiftlen: shift up to this many bytes
2103  *
2104  * Attempts to shift up to shiftlen worth of bytes, which may be less than
2105  * the length of the skb, from tgt to skb. Returns number bytes shifted.
2106  * It's up to caller to free skb if everything was shifted.
2107  *
2108  * If @tgt runs out of frags, the whole operation is aborted.
2109  *
2110  * Skb cannot include anything else but paged data while tgt is allowed
2111  * to have non-paged data as well.
2112  *
2113  * TODO: full sized shift could be optimized but that would need
2114  * specialized skb free'er to handle frags without up-to-date nr_frags.
2115  */
2116 int skb_shift(struct sk_buff *tgt, struct sk_buff *skb, int shiftlen)
2117 {
2118         int from, to, merge, todo;
2119         struct skb_frag_struct *fragfrom, *fragto;
2120
2121         BUG_ON(shiftlen > skb->len);
2122         BUG_ON(skb_headlen(skb));       /* Would corrupt stream */
2123
2124         todo = shiftlen;
2125         from = 0;
2126         to = skb_shinfo(tgt)->nr_frags;
2127         fragfrom = &skb_shinfo(skb)->frags[from];
2128
2129         /* Actual merge is delayed until the point when we know we can
2130          * commit all, so that we don't have to undo partial changes
2131          */
2132         if (!to ||
2133             !skb_can_coalesce(tgt, to, fragfrom->page, fragfrom->page_offset)) {
2134                 merge = -1;
2135         } else {
2136                 merge = to - 1;
2137
2138                 todo -= fragfrom->size;
2139                 if (todo < 0) {
2140                         if (skb_prepare_for_shift(skb) ||
2141                             skb_prepare_for_shift(tgt))
2142                                 return 0;
2143
2144                         /* All previous frag pointers might be stale! */
2145                         fragfrom = &skb_shinfo(skb)->frags[from];
2146                         fragto = &skb_shinfo(tgt)->frags[merge];
2147
2148                         fragto->size += shiftlen;
2149                         fragfrom->size -= shiftlen;
2150                         fragfrom->page_offset += shiftlen;
2151
2152                         goto onlymerged;
2153                 }
2154
2155                 from++;
2156         }
2157
2158         /* Skip full, not-fitting skb to avoid expensive operations */
2159         if ((shiftlen == skb->len) &&
2160             (skb_shinfo(skb)->nr_frags - from) > (MAX_SKB_FRAGS - to))
2161                 return 0;
2162
2163         if (skb_prepare_for_shift(skb) || skb_prepare_for_shift(tgt))
2164                 return 0;
2165
2166         while ((todo > 0) && (from < skb_shinfo(skb)->nr_frags)) {
2167                 if (to == MAX_SKB_FRAGS)
2168                         return 0;
2169
2170                 fragfrom = &skb_shinfo(skb)->frags[from];
2171                 fragto = &skb_shinfo(tgt)->frags[to];
2172
2173                 if (todo >= fragfrom->size) {
2174                         *fragto = *fragfrom;
2175                         todo -= fragfrom->size;
2176                         from++;
2177                         to++;
2178
2179                 } else {
2180                         get_page(fragfrom->page);
2181                         fragto->page = fragfrom->page;
2182                         fragto->page_offset = fragfrom->page_offset;
2183                         fragto->size = todo;
2184
2185                         fragfrom->page_offset += todo;
2186                         fragfrom->size -= todo;
2187                         todo = 0;
2188
2189                         to++;
2190                         break;
2191                 }
2192         }
2193
2194         /* Ready to "commit" this state change to tgt */
2195         skb_shinfo(tgt)->nr_frags = to;
2196
2197         if (merge >= 0) {
2198                 fragfrom = &skb_shinfo(skb)->frags[0];
2199                 fragto = &skb_shinfo(tgt)->frags[merge];
2200
2201                 fragto->size += fragfrom->size;
2202                 put_page(fragfrom->page);
2203         }
2204
2205         /* Reposition in the original skb */
2206         to = 0;
2207         while (from < skb_shinfo(skb)->nr_frags)
2208                 skb_shinfo(skb)->frags[to++] = skb_shinfo(skb)->frags[from++];
2209         skb_shinfo(skb)->nr_frags = to;
2210
2211         BUG_ON(todo > 0 && !skb_shinfo(skb)->nr_frags);
2212
2213 onlymerged:
2214         /* Most likely the tgt won't ever need its checksum anymore, skb on
2215          * the other hand might need it if it needs to be resent
2216          */
2217         tgt->ip_summed = CHECKSUM_PARTIAL;
2218         skb->ip_summed = CHECKSUM_PARTIAL;
2219
2220         /* Yak, is it really working this way? Some helper please? */
2221         skb->len -= shiftlen;
2222         skb->data_len -= shiftlen;
2223         skb->truesize -= shiftlen;
2224         tgt->len += shiftlen;
2225         tgt->data_len += shiftlen;
2226         tgt->truesize += shiftlen;
2227
2228         return shiftlen;
2229 }
2230
2231 /**
2232  * skb_prepare_seq_read - Prepare a sequential read of skb data
2233  * @skb: the buffer to read
2234  * @from: lower offset of data to be read
2235  * @to: upper offset of data to be read
2236  * @st: state variable
2237  *
2238  * Initializes the specified state variable. Must be called before
2239  * invoking skb_seq_read() for the first time.
2240  */
2241 void skb_prepare_seq_read(struct sk_buff *skb, unsigned int from,
2242                           unsigned int to, struct skb_seq_state *st)
2243 {
2244         st->lower_offset = from;
2245         st->upper_offset = to;
2246         st->root_skb = st->cur_skb = skb;
2247         st->frag_idx = st->stepped_offset = 0;
2248         st->frag_data = NULL;
2249 }
2250 EXPORT_SYMBOL(skb_prepare_seq_read);
2251
2252 /**
2253  * skb_seq_read - Sequentially read skb data
2254  * @consumed: number of bytes consumed by the caller so far
2255  * @data: destination pointer for data to be returned
2256  * @st: state variable
2257  *
2258  * Reads a block of skb data at &consumed relative to the
2259  * lower offset specified to skb_prepare_seq_read(). Assigns
2260  * the head of the data block to &data and returns the length
2261  * of the block or 0 if the end of the skb data or the upper
2262  * offset has been reached.
2263  *
2264  * The caller is not required to consume all of the data
2265  * returned, i.e. &consumed is typically set to the number
2266  * of bytes already consumed and the next call to
2267  * skb_seq_read() will return the remaining part of the block.
2268  *
2269  * Note 1: The size of each block of data returned can be arbitary,
2270  *       this limitation is the cost for zerocopy seqeuental
2271  *       reads of potentially non linear data.
2272  *
2273  * Note 2: Fragment lists within fragments are not implemented
2274  *       at the moment, state->root_skb could be replaced with
2275  *       a stack for this purpose.
2276  */
2277 unsigned int skb_seq_read(unsigned int consumed, const u8 **data,
2278                           struct skb_seq_state *st)
2279 {
2280         unsigned int block_limit, abs_offset = consumed + st->lower_offset;
2281         skb_frag_t *frag;
2282
2283         if (unlikely(abs_offset >= st->upper_offset))
2284                 return 0;
2285
2286 next_skb:
2287         block_limit = skb_headlen(st->cur_skb) + st->stepped_offset;
2288
2289         if (abs_offset < block_limit) {
2290                 *data = st->cur_skb->data + (abs_offset - st->stepped_offset);
2291                 return block_limit - abs_offset;
2292         }
2293
2294         if (st->frag_idx == 0 && !st->frag_data)
2295                 st->stepped_offset += skb_headlen(st->cur_skb);
2296
2297         while (st->frag_idx < skb_shinfo(st->cur_skb)->nr_frags) {
2298                 frag = &skb_shinfo(st->cur_skb)->frags[st->frag_idx];
2299                 block_limit = frag->size + st->stepped_offset;
2300
2301                 if (abs_offset < block_limit) {
2302                         if (!st->frag_data)
2303                                 st->frag_data = kmap_skb_frag(frag);
2304
2305                         *data = (u8 *) st->frag_data + frag->page_offset +
2306                                 (abs_offset - st->stepped_offset);
2307
2308                         return block_limit - abs_offset;
2309                 }
2310
2311                 if (st->frag_data) {
2312                         kunmap_skb_frag(st->frag_data);
2313                         st->frag_data = NULL;
2314                 }
2315
2316                 st->frag_idx++;
2317                 st->stepped_offset += frag->size;
2318         }
2319
2320         if (st->frag_data) {
2321                 kunmap_skb_frag(st->frag_data);
2322                 st->frag_data = NULL;
2323         }
2324
2325         if (st->root_skb == st->cur_skb &&
2326             skb_shinfo(st->root_skb)->frag_list) {
2327                 st->cur_skb = skb_shinfo(st->root_skb)->frag_list;
2328                 st->frag_idx = 0;
2329                 goto next_skb;
2330         } else if (st->cur_skb->next) {
2331                 st->cur_skb = st->cur_skb->next;
2332                 st->frag_idx = 0;
2333                 goto next_skb;
2334         }
2335
2336         return 0;
2337 }
2338 EXPORT_SYMBOL(skb_seq_read);
2339
2340 /**
2341  * skb_abort_seq_read - Abort a sequential read of skb data
2342  * @st: state variable
2343  *
2344  * Must be called if skb_seq_read() was not called until it
2345  * returned 0.
2346  */
2347 void skb_abort_seq_read(struct skb_seq_state *st)
2348 {
2349         if (st->frag_data)
2350                 kunmap_skb_frag(st->frag_data);
2351 }
2352 EXPORT_SYMBOL(skb_abort_seq_read);
2353
2354 #define TS_SKB_CB(state)        ((struct skb_seq_state *) &((state)->cb))
2355
2356 static unsigned int skb_ts_get_next_block(unsigned int offset, const u8 **text,
2357                                           struct ts_config *conf,
2358                                           struct ts_state *state)
2359 {
2360         return skb_seq_read(offset, text, TS_SKB_CB(state));
2361 }
2362
2363 static void skb_ts_finish(struct ts_config *conf, struct ts_state *state)
2364 {
2365         skb_abort_seq_read(TS_SKB_CB(state));
2366 }
2367
2368 /**
2369  * skb_find_text - Find a text pattern in skb data
2370  * @skb: the buffer to look in
2371  * @from: search offset
2372  * @to: search limit
2373  * @config: textsearch configuration
2374  * @state: uninitialized textsearch state variable
2375  *
2376  * Finds a pattern in the skb data according to the specified
2377  * textsearch configuration. Use textsearch_next() to retrieve
2378  * subsequent occurrences of the pattern. Returns the offset
2379  * to the first occurrence or UINT_MAX if no match was found.
2380  */
2381 unsigned int skb_find_text(struct sk_buff *skb, unsigned int from,
2382                            unsigned int to, struct ts_config *config,
2383                            struct ts_state *state)
2384 {
2385         unsigned int ret;
2386
2387         config->get_next_block = skb_ts_get_next_block;
2388         config->finish = skb_ts_finish;
2389
2390         skb_prepare_seq_read(skb, from, to, TS_SKB_CB(state));
2391
2392         ret = textsearch_find(config, state);
2393         return (ret <= to - from ? ret : UINT_MAX);
2394 }
2395 EXPORT_SYMBOL(skb_find_text);
2396
2397 /**
2398  * skb_append_datato_frags: - append the user data to a skb
2399  * @sk: sock  structure
2400  * @skb: skb structure to be appened with user data.
2401  * @getfrag: call back function to be used for getting the user data
2402  * @from: pointer to user message iov
2403  * @length: length of the iov message
2404  *
2405  * Description: This procedure append the user data in the fragment part
2406  * of the skb if any page alloc fails user this procedure returns  -ENOMEM
2407  */
2408 int skb_append_datato_frags(struct sock *sk, struct sk_buff *skb,
2409                         int (*getfrag)(void *from, char *to, int offset,
2410                                         int len, int odd, struct sk_buff *skb),
2411                         void *from, int length)
2412 {
2413         int frg_cnt = 0;
2414         skb_frag_t *frag = NULL;
2415         struct page *page = NULL;
2416         int copy, left;
2417         int offset = 0;
2418         int ret;
2419
2420         do {
2421                 /* Return error if we don't have space for new frag */
2422                 frg_cnt = skb_shinfo(skb)->nr_frags;
2423                 if (frg_cnt >= MAX_SKB_FRAGS)
2424                         return -EFAULT;
2425
2426                 /* allocate a new page for next frag */
2427                 page = alloc_pages(sk->sk_allocation, 0);
2428
2429                 /* If alloc_page fails just return failure and caller will
2430                  * free previous allocated pages by doing kfree_skb()
2431                  */
2432                 if (page == NULL)
2433                         return -ENOMEM;
2434
2435                 /* initialize the next frag */
2436                 sk->sk_sndmsg_page = page;
2437                 sk->sk_sndmsg_off = 0;
2438                 skb_fill_page_desc(skb, frg_cnt, page, 0, 0);
2439                 skb->truesize += PAGE_SIZE;
2440                 atomic_add(PAGE_SIZE, &sk->sk_wmem_alloc);
2441
2442                 /* get the new initialized frag */
2443                 frg_cnt = skb_shinfo(skb)->nr_frags;
2444                 frag = &skb_shinfo(skb)->frags[frg_cnt - 1];
2445
2446                 /* copy the user data to page */
2447                 left = PAGE_SIZE - frag->page_offset;
2448                 copy = (length > left)? left : length;
2449
2450                 ret = getfrag(from, (page_address(frag->page) +
2451                             frag->page_offset + frag->size),
2452                             offset, copy, 0, skb);
2453                 if (ret < 0)
2454                         return -EFAULT;
2455
2456                 /* copy was successful so update the size parameters */
2457                 sk->sk_sndmsg_off += copy;
2458                 frag->size += copy;
2459                 skb->len += copy;
2460                 skb->data_len += copy;
2461                 offset += copy;
2462                 length -= copy;
2463
2464         } while (length > 0);
2465
2466         return 0;
2467 }
2468 EXPORT_SYMBOL(skb_append_datato_frags);
2469
2470 /**
2471  *      skb_pull_rcsum - pull skb and update receive checksum
2472  *      @skb: buffer to update
2473  *      @len: length of data pulled
2474  *
2475  *      This function performs an skb_pull on the packet and updates
2476  *      the CHECKSUM_COMPLETE checksum.  It should be used on
2477  *      receive path processing instead of skb_pull unless you know
2478  *      that the checksum difference is zero (e.g., a valid IP header)
2479  *      or you are setting ip_summed to CHECKSUM_NONE.
2480  */
2481 unsigned char *skb_pull_rcsum(struct sk_buff *skb, unsigned int len)
2482 {
2483         BUG_ON(len > skb->len);
2484         skb->len -= len;
2485         BUG_ON(skb->len < skb->data_len);
2486         skb_postpull_rcsum(skb, skb->data, len);
2487         return skb->data += len;
2488 }
2489
2490 EXPORT_SYMBOL_GPL(skb_pull_rcsum);
2491
2492 /**
2493  *      skb_segment - Perform protocol segmentation on skb.
2494  *      @skb: buffer to segment
2495  *      @features: features for the output path (see dev->features)
2496  *
2497  *      This function performs segmentation on the given skb.  It returns
2498  *      a pointer to the first in a list of new skbs for the segments.
2499  *      In case of error it returns ERR_PTR(err).
2500  */
2501 struct sk_buff *skb_segment(struct sk_buff *skb, int features)
2502 {
2503         struct sk_buff *segs = NULL;
2504         struct sk_buff *tail = NULL;
2505         struct sk_buff *fskb = skb_shinfo(skb)->frag_list;
2506         unsigned int mss = skb_shinfo(skb)->gso_size;
2507         unsigned int doffset = skb->data - skb_mac_header(skb);
2508         unsigned int offset = doffset;
2509         unsigned int headroom;
2510         unsigned int len;
2511         int sg = features & NETIF_F_SG;
2512         int nfrags = skb_shinfo(skb)->nr_frags;
2513         int err = -ENOMEM;
2514         int i = 0;
2515         int pos;
2516
2517         __skb_push(skb, doffset);
2518         headroom = skb_headroom(skb);
2519         pos = skb_headlen(skb);
2520
2521         do {
2522                 struct sk_buff *nskb;
2523                 skb_frag_t *frag;
2524                 int hsize;
2525                 int size;
2526
2527                 len = skb->len - offset;
2528                 if (len > mss)
2529                         len = mss;
2530
2531                 hsize = skb_headlen(skb) - offset;
2532                 if (hsize < 0)
2533                         hsize = 0;
2534                 if (hsize > len || !sg)
2535                         hsize = len;
2536
2537                 if (!hsize && i >= nfrags) {
2538                         BUG_ON(fskb->len != len);
2539
2540                         pos += len;
2541                         nskb = skb_clone(fskb, GFP_ATOMIC);
2542                         fskb = fskb->next;
2543
2544                         if (unlikely(!nskb))
2545                                 goto err;
2546
2547                         hsize = skb_end_pointer(nskb) - nskb->head;
2548                         if (skb_cow_head(nskb, doffset + headroom)) {
2549                                 kfree_skb(nskb);
2550                                 goto err;
2551                         }
2552
2553                         nskb->truesize += skb_end_pointer(nskb) - nskb->head -
2554                                           hsize;
2555                         skb_release_head_state(nskb);
2556                         __skb_push(nskb, doffset);
2557                 } else {
2558                         nskb = alloc_skb(hsize + doffset + headroom,
2559                                          GFP_ATOMIC);
2560
2561                         if (unlikely(!nskb))
2562                                 goto err;
2563
2564                         skb_reserve(nskb, headroom);
2565                         __skb_put(nskb, doffset);
2566                 }
2567
2568                 if (segs)
2569                         tail->next = nskb;
2570                 else
2571                         segs = nskb;
2572                 tail = nskb;
2573
2574                 __copy_skb_header(nskb, skb);
2575                 nskb->mac_len = skb->mac_len;
2576
2577                 skb_reset_mac_header(nskb);
2578                 skb_set_network_header(nskb, skb->mac_len);
2579                 nskb->transport_header = (nskb->network_header +
2580                                           skb_network_header_len(skb));
2581                 skb_copy_from_linear_data(skb, nskb->data, doffset);
2582
2583                 if (fskb != skb_shinfo(skb)->frag_list)
2584                         continue;
2585
2586                 if (!sg) {
2587                         nskb->ip_summed = CHECKSUM_NONE;
2588                         nskb->csum = skb_copy_and_csum_bits(skb, offset,
2589                                                             skb_put(nskb, len),
2590                                                             len, 0);
2591                         continue;
2592                 }
2593
2594                 frag = skb_shinfo(nskb)->frags;
2595
2596                 skb_copy_from_linear_data_offset(skb, offset,
2597                                                  skb_put(nskb, hsize), hsize);
2598
2599                 while (pos < offset + len && i < nfrags) {
2600                         *frag = skb_shinfo(skb)->frags[i];
2601                         get_page(frag->page);
2602                         size = frag->size;
2603
2604                         if (pos < offset) {
2605                                 frag->page_offset += offset - pos;
2606                                 frag->size -= offset - pos;
2607                         }
2608
2609                         skb_shinfo(nskb)->nr_frags++;
2610
2611                         if (pos + size <= offset + len) {
2612                                 i++;
2613                                 pos += size;
2614                         } else {
2615                                 frag->size -= pos + size - (offset + len);
2616                                 goto skip_fraglist;
2617                         }
2618
2619                         frag++;
2620                 }
2621
2622                 if (pos < offset + len) {
2623                         struct sk_buff *fskb2 = fskb;
2624
2625                         BUG_ON(pos + fskb->len != offset + len);
2626
2627                         pos += fskb->len;
2628                         fskb = fskb->next;
2629
2630                         if (fskb2->next) {
2631                                 fskb2 = skb_clone(fskb2, GFP_ATOMIC);
2632                                 if (!fskb2)
2633                                         goto err;
2634                         } else
2635                                 skb_get(fskb2);
2636
2637                         BUG_ON(skb_shinfo(nskb)->frag_list);
2638                         skb_shinfo(nskb)->frag_list = fskb2;
2639                 }
2640
2641 skip_fraglist:
2642                 nskb->data_len = len - hsize;
2643                 nskb->len += nskb->data_len;
2644                 nskb->truesize += nskb->data_len;
2645         } while ((offset += len) < skb->len);
2646
2647         return segs;
2648
2649 err:
2650         while ((skb = segs)) {
2651                 segs = skb->next;
2652                 kfree_skb(skb);
2653         }
2654         return ERR_PTR(err);
2655 }
2656 EXPORT_SYMBOL_GPL(skb_segment);
2657
2658 int skb_gro_receive(struct sk_buff **head, struct sk_buff *skb)
2659 {
2660         struct sk_buff *p = *head;
2661         struct sk_buff *nskb;
2662         unsigned int headroom;
2663         unsigned int len = skb_gro_len(skb);
2664
2665         if (p->len + len >= 65536)
2666                 return -E2BIG;
2667
2668         if (skb_shinfo(p)->frag_list)
2669                 goto merge;
2670         else if (skb_headlen(skb) <= skb_gro_offset(skb)) {
2671                 if (skb_shinfo(p)->nr_frags + skb_shinfo(skb)->nr_frags >
2672                     MAX_SKB_FRAGS)
2673                         return -E2BIG;
2674
2675                 skb_shinfo(skb)->frags[0].page_offset +=
2676                         skb_gro_offset(skb) - skb_headlen(skb);
2677                 skb_shinfo(skb)->frags[0].size -=
2678                         skb_gro_offset(skb) - skb_headlen(skb);
2679
2680                 memcpy(skb_shinfo(p)->frags + skb_shinfo(p)->nr_frags,
2681                        skb_shinfo(skb)->frags,
2682                        skb_shinfo(skb)->nr_frags * sizeof(skb_frag_t));
2683
2684                 skb_shinfo(p)->nr_frags += skb_shinfo(skb)->nr_frags;
2685                 skb_shinfo(skb)->nr_frags = 0;
2686
2687                 skb->truesize -= skb->data_len;
2688                 skb->len -= skb->data_len;
2689                 skb->data_len = 0;
2690
2691                 NAPI_GRO_CB(skb)->free = 1;
2692                 goto done;
2693         }
2694
2695         headroom = skb_headroom(p);
2696         nskb = netdev_alloc_skb(p->dev, headroom + skb_gro_offset(p));
2697         if (unlikely(!nskb))
2698                 return -ENOMEM;
2699
2700         __copy_skb_header(nskb, p);
2701         nskb->mac_len = p->mac_len;
2702
2703         skb_reserve(nskb, headroom);
2704         __skb_put(nskb, skb_gro_offset(p));
2705
2706         skb_set_mac_header(nskb, skb_mac_header(p) - p->data);
2707         skb_set_network_header(nskb, skb_network_offset(p));
2708         skb_set_transport_header(nskb, skb_transport_offset(p));
2709
2710         __skb_pull(p, skb_gro_offset(p));
2711         memcpy(skb_mac_header(nskb), skb_mac_header(p),
2712                p->data - skb_mac_header(p));
2713
2714         *NAPI_GRO_CB(nskb) = *NAPI_GRO_CB(p);
2715         skb_shinfo(nskb)->frag_list = p;
2716         skb_shinfo(nskb)->gso_size = skb_shinfo(p)->gso_size;
2717         skb_header_release(p);
2718         nskb->prev = p;
2719
2720         nskb->data_len += p->len;
2721         nskb->truesize += p->len;
2722         nskb->len += p->len;
2723
2724         *head = nskb;
2725         nskb->next = p->next;
2726         p->next = NULL;
2727
2728         p = nskb;
2729
2730 merge:
2731         if (skb_gro_offset(skb) > skb_headlen(skb)) {
2732                 skb_shinfo(skb)->frags[0].page_offset +=
2733                         skb_gro_offset(skb) - skb_headlen(skb);
2734                 skb_shinfo(skb)->frags[0].size -=
2735                         skb_gro_offset(skb) - skb_headlen(skb);
2736                 skb_gro_reset_offset(skb);
2737                 skb_gro_pull(skb, skb_headlen(skb));
2738         }
2739
2740         __skb_pull(skb, skb_gro_offset(skb));
2741
2742         p->prev->next = skb;
2743         p->prev = skb;
2744         skb_header_release(skb);
2745
2746 done:
2747         NAPI_GRO_CB(p)->count++;
2748         p->data_len += len;
2749         p->truesize += len;
2750         p->len += len;
2751
2752         NAPI_GRO_CB(skb)->same_flow = 1;
2753         return 0;
2754 }
2755 EXPORT_SYMBOL_GPL(skb_gro_receive);
2756
2757 void __init skb_init(void)
2758 {
2759         skbuff_head_cache = kmem_cache_create("skbuff_head_cache",
2760                                               sizeof(struct sk_buff),
2761                                               0,
2762                                               SLAB_HWCACHE_ALIGN|SLAB_PANIC,
2763                                               NULL);
2764         skbuff_fclone_cache = kmem_cache_create("skbuff_fclone_cache",
2765                                                 (2*sizeof(struct sk_buff)) +
2766                                                 sizeof(atomic_t),
2767                                                 0,
2768                                                 SLAB_HWCACHE_ALIGN|SLAB_PANIC,
2769                                                 NULL);
2770 }
2771
2772 /**
2773  *      skb_to_sgvec - Fill a scatter-gather list from a socket buffer
2774  *      @skb: Socket buffer containing the buffers to be mapped
2775  *      @sg: The scatter-gather list to map into
2776  *      @offset: The offset into the buffer's contents to start mapping
2777  *      @len: Length of buffer space to be mapped
2778  *
2779  *      Fill the specified scatter-gather list with mappings/pointers into a
2780  *      region of the buffer space attached to a socket buffer.
2781  */
2782 static int
2783 __skb_to_sgvec(struct sk_buff *skb, struct scatterlist *sg, int offset, int len)
2784 {
2785         int start = skb_headlen(skb);
2786         int i, copy = start - offset;
2787         int elt = 0;
2788
2789         if (copy > 0) {
2790                 if (copy > len)
2791                         copy = len;
2792                 sg_set_buf(sg, skb->data + offset, copy);
2793                 elt++;
2794                 if ((len -= copy) == 0)
2795                         return elt;
2796                 offset += copy;
2797         }
2798
2799         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2800                 int end;
2801
2802                 WARN_ON(start > offset + len);
2803
2804                 end = start + skb_shinfo(skb)->frags[i].size;
2805                 if ((copy = end - offset) > 0) {
2806                         skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2807
2808                         if (copy > len)
2809                                 copy = len;
2810                         sg_set_page(&sg[elt], frag->page, copy,
2811                                         frag->page_offset+offset-start);
2812                         elt++;
2813                         if (!(len -= copy))
2814                                 return elt;
2815                         offset += copy;
2816                 }
2817                 start = end;
2818         }
2819
2820         if (skb_shinfo(skb)->frag_list) {
2821                 struct sk_buff *list = skb_shinfo(skb)->frag_list;
2822
2823                 for (; list; list = list->next) {
2824                         int end;
2825
2826                         WARN_ON(start > offset + len);
2827
2828                         end = start + list->len;
2829                         if ((copy = end - offset) > 0) {
2830                                 if (copy > len)
2831                                         copy = len;
2832                                 elt += __skb_to_sgvec(list, sg+elt, offset - start,
2833                                                       copy);
2834                                 if ((len -= copy) == 0)
2835                                         return elt;
2836                                 offset += copy;
2837                         }
2838                         start = end;
2839                 }
2840         }
2841         BUG_ON(len);
2842         return elt;
2843 }
2844
2845 int skb_to_sgvec(struct sk_buff *skb, struct scatterlist *sg, int offset, int len)
2846 {
2847         int nsg = __skb_to_sgvec(skb, sg, offset, len);
2848
2849         sg_mark_end(&sg[nsg - 1]);
2850
2851         return nsg;
2852 }
2853 EXPORT_SYMBOL_GPL(skb_to_sgvec);
2854
2855 /**
2856  *      skb_cow_data - Check that a socket buffer's data buffers are writable
2857  *      @skb: The socket buffer to check.
2858  *      @tailbits: Amount of trailing space to be added
2859  *      @trailer: Returned pointer to the skb where the @tailbits space begins
2860  *
2861  *      Make sure that the data buffers attached to a socket buffer are
2862  *      writable. If they are not, private copies are made of the data buffers
2863  *      and the socket buffer is set to use these instead.
2864  *
2865  *      If @tailbits is given, make sure that there is space to write @tailbits
2866  *      bytes of data beyond current end of socket buffer.  @trailer will be
2867  *      set to point to the skb in which this space begins.
2868  *
2869  *      The number of scatterlist elements required to completely map the
2870  *      COW'd and extended socket buffer will be returned.
2871  */
2872 int skb_cow_data(struct sk_buff *skb, int tailbits, struct sk_buff **trailer)
2873 {
2874         int copyflag;
2875         int elt;
2876         struct sk_buff *skb1, **skb_p;
2877
2878         /* If skb is cloned or its head is paged, reallocate
2879          * head pulling out all the pages (pages are considered not writable
2880          * at the moment even if they are anonymous).
2881          */
2882         if ((skb_cloned(skb) || skb_shinfo(skb)->nr_frags) &&
2883             __pskb_pull_tail(skb, skb_pagelen(skb)-skb_headlen(skb)) == NULL)
2884                 return -ENOMEM;
2885
2886         /* Easy case. Most of packets will go this way. */
2887         if (!skb_shinfo(skb)->frag_list) {
2888                 /* A little of trouble, not enough of space for trailer.
2889                  * This should not happen, when stack is tuned to generate
2890                  * good frames. OK, on miss we reallocate and reserve even more
2891                  * space, 128 bytes is fair. */
2892
2893                 if (skb_tailroom(skb) < tailbits &&
2894                     pskb_expand_head(skb, 0, tailbits-skb_tailroom(skb)+128, GFP_ATOMIC))
2895                         return -ENOMEM;
2896
2897                 /* Voila! */
2898                 *trailer = skb;
2899                 return 1;
2900         }
2901
2902         /* Misery. We are in troubles, going to mincer fragments... */
2903
2904         elt = 1;
2905         skb_p = &skb_shinfo(skb)->frag_list;
2906         copyflag = 0;
2907
2908         while ((skb1 = *skb_p) != NULL) {
2909                 int ntail = 0;
2910
2911                 /* The fragment is partially pulled by someone,
2912                  * this can happen on input. Copy it and everything
2913                  * after it. */
2914
2915                 if (skb_shared(skb1))
2916                         copyflag = 1;
2917
2918                 /* If the skb is the last, worry about trailer. */
2919
2920                 if (skb1->next == NULL && tailbits) {
2921                         if (skb_shinfo(skb1)->nr_frags ||
2922                             skb_shinfo(skb1)->frag_list ||
2923                             skb_tailroom(skb1) < tailbits)
2924                                 ntail = tailbits + 128;
2925                 }
2926
2927                 if (copyflag ||
2928                     skb_cloned(skb1) ||
2929                     ntail ||
2930                     skb_shinfo(skb1)->nr_frags ||
2931                     skb_shinfo(skb1)->frag_list) {
2932                         struct sk_buff *skb2;
2933
2934                         /* Fuck, we are miserable poor guys... */
2935                         if (ntail == 0)
2936                                 skb2 = skb_copy(skb1, GFP_ATOMIC);
2937                         else
2938                                 skb2 = skb_copy_expand(skb1,
2939                                                        skb_headroom(skb1),
2940                                                        ntail,
2941                                                        GFP_ATOMIC);
2942                         if (unlikely(skb2 == NULL))
2943                                 return -ENOMEM;
2944
2945                         if (skb1->sk)
2946                                 skb_set_owner_w(skb2, skb1->sk);
2947
2948                         /* Looking around. Are we still alive?
2949                          * OK, link new skb, drop old one */
2950
2951                         skb2->next = skb1->next;
2952                         *skb_p = skb2;
2953                         kfree_skb(skb1);
2954                         skb1 = skb2;
2955                 }
2956                 elt++;
2957                 *trailer = skb1;
2958                 skb_p = &skb1->next;
2959         }
2960
2961         return elt;
2962 }
2963 EXPORT_SYMBOL_GPL(skb_cow_data);
2964
2965 void skb_tstamp_tx(struct sk_buff *orig_skb,
2966                 struct skb_shared_hwtstamps *hwtstamps)
2967 {
2968         struct sock *sk = orig_skb->sk;
2969         struct sock_exterr_skb *serr;
2970         struct sk_buff *skb;
2971         int err;
2972
2973         if (!sk)
2974                 return;
2975
2976         skb = skb_clone(orig_skb, GFP_ATOMIC);
2977         if (!skb)
2978                 return;
2979
2980         if (hwtstamps) {
2981                 *skb_hwtstamps(skb) =
2982                         *hwtstamps;
2983         } else {
2984                 /*
2985                  * no hardware time stamps available,
2986                  * so keep the skb_shared_tx and only
2987                  * store software time stamp
2988                  */
2989                 skb->tstamp = ktime_get_real();
2990         }
2991
2992         serr = SKB_EXT_ERR(skb);
2993         memset(serr, 0, sizeof(*serr));
2994         serr->ee.ee_errno = ENOMSG;
2995         serr->ee.ee_origin = SO_EE_ORIGIN_TIMESTAMPING;
2996         err = sock_queue_err_skb(sk, skb);
2997         if (err)
2998                 kfree_skb(skb);
2999 }
3000 EXPORT_SYMBOL_GPL(skb_tstamp_tx);
3001
3002
3003 /**
3004  * skb_partial_csum_set - set up and verify partial csum values for packet
3005  * @skb: the skb to set
3006  * @start: the number of bytes after skb->data to start checksumming.
3007  * @off: the offset from start to place the checksum.
3008  *
3009  * For untrusted partially-checksummed packets, we need to make sure the values
3010  * for skb->csum_start and skb->csum_offset are valid so we don't oops.
3011  *
3012  * This function checks and sets those values and skb->ip_summed: if this
3013  * returns false you should drop the packet.
3014  */
3015 bool skb_partial_csum_set(struct sk_buff *skb, u16 start, u16 off)
3016 {
3017         if (unlikely(start > skb->len - 2) ||
3018             unlikely((int)start + off > skb->len - 2)) {
3019                 if (net_ratelimit())
3020                         printk(KERN_WARNING
3021                                "bad partial csum: csum=%u/%u len=%u\n",
3022                                start, off, skb->len);
3023                 return false;
3024         }
3025         skb->ip_summed = CHECKSUM_PARTIAL;
3026         skb->csum_start = skb_headroom(skb) + start;
3027         skb->csum_offset = off;
3028         return true;
3029 }
3030 EXPORT_SYMBOL_GPL(skb_partial_csum_set);
3031
3032 void __skb_warn_lro_forwarding(const struct sk_buff *skb)
3033 {
3034         if (net_ratelimit())
3035                 pr_warning("%s: received packets cannot be forwarded"
3036                            " while LRO is enabled\n", skb->dev->name);
3037 }
3038 EXPORT_SYMBOL(__skb_warn_lro_forwarding);