1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
36
37#include <linux/module.h>
38#include <linux/types.h>
39#include <linux/kernel.h>
40#include <linux/mm.h>
41#include <linux/interrupt.h>
42#include <linux/in.h>
43#include <linux/inet.h>
44#include <linux/slab.h>
45#include <linux/tcp.h>
46#include <linux/udp.h>
47#include <linux/sctp.h>
48#include <linux/netdevice.h>
49#ifdef CONFIG_NET_CLS_ACT
50#include <net/pkt_sched.h>
51#endif
52#include <linux/string.h>
53#include <linux/skbuff.h>
54#include <linux/splice.h>
55#include <linux/cache.h>
56#include <linux/rtnetlink.h>
57#include <linux/init.h>
58#include <linux/scatterlist.h>
59#include <linux/errqueue.h>
60#include <linux/prefetch.h>
61#include <linux/if_vlan.h>
62#include <linux/mpls.h>
63#include <linux/kcov.h>
64
65#include <net/protocol.h>
66#include <net/dst.h>
67#include <net/sock.h>
68#include <net/checksum.h>
69#include <net/ip6_checksum.h>
70#include <net/xfrm.h>
71#include <net/mpls.h>
72#include <net/mptcp.h>
73#include <net/page_pool.h>
74
75#include <linux/uaccess.h>
76#include <trace/events/skb.h>
77#include <linux/highmem.h>
78#include <linux/capability.h>
79#include <linux/user_namespace.h>
80#include <linux/indirect_call_wrapper.h>
81
82#include "datagram.h"
83#include "sock_destructor.h"
84
85struct kmem_cache *skbuff_head_cache __ro_after_init;
86static struct kmem_cache *skbuff_fclone_cache __ro_after_init;
87#ifdef CONFIG_SKB_EXTENSIONS
88static struct kmem_cache *skbuff_ext_cache __ro_after_init;
89#endif
90int sysctl_max_skb_frags __read_mostly = MAX_SKB_FRAGS;
91EXPORT_SYMBOL(sysctl_max_skb_frags);
92
93
94
95
96
97
98
99
100
101
102
103
104
105static void skb_panic(struct sk_buff *skb, unsigned int sz, void *addr,
106 const char msg[])
107{
108 pr_emerg("%s: text:%px len:%d put:%d head:%px data:%px tail:%#lx end:%#lx dev:%s\n",
109 msg, addr, skb->len, sz, skb->head, skb->data,
110 (unsigned long)skb->tail, (unsigned long)skb->end,
111 skb->dev ? skb->dev->name : "<NULL>");
112 BUG();
113}
114
115static void skb_over_panic(struct sk_buff *skb, unsigned int sz, void *addr)
116{
117 skb_panic(skb, sz, addr, __func__);
118}
119
120static void skb_under_panic(struct sk_buff *skb, unsigned int sz, void *addr)
121{
122 skb_panic(skb, sz, addr, __func__);
123}
124
125#define NAPI_SKB_CACHE_SIZE 64
126#define NAPI_SKB_CACHE_BULK 16
127#define NAPI_SKB_CACHE_HALF (NAPI_SKB_CACHE_SIZE / 2)
128
129struct napi_alloc_cache {
130 struct page_frag_cache page;
131 unsigned int skb_count;
132 void *skb_cache[NAPI_SKB_CACHE_SIZE];
133};
134
135static DEFINE_PER_CPU(struct page_frag_cache, netdev_alloc_cache);
136static DEFINE_PER_CPU(struct napi_alloc_cache, napi_alloc_cache);
137
138static void *__alloc_frag_align(unsigned int fragsz, gfp_t gfp_mask,
139 unsigned int align_mask)
140{
141 struct napi_alloc_cache *nc = this_cpu_ptr(&napi_alloc_cache);
142
143 return page_frag_alloc_align(&nc->page, fragsz, gfp_mask, align_mask);
144}
145
146void *__napi_alloc_frag_align(unsigned int fragsz, unsigned int align_mask)
147{
148 fragsz = SKB_DATA_ALIGN(fragsz);
149
150 return __alloc_frag_align(fragsz, GFP_ATOMIC, align_mask);
151}
152EXPORT_SYMBOL(__napi_alloc_frag_align);
153
154void *__netdev_alloc_frag_align(unsigned int fragsz, unsigned int align_mask)
155{
156 struct page_frag_cache *nc;
157 void *data;
158
159 fragsz = SKB_DATA_ALIGN(fragsz);
160 if (in_hardirq() || irqs_disabled()) {
161 nc = this_cpu_ptr(&netdev_alloc_cache);
162 data = page_frag_alloc_align(nc, fragsz, GFP_ATOMIC, align_mask);
163 } else {
164 local_bh_disable();
165 data = __alloc_frag_align(fragsz, GFP_ATOMIC, align_mask);
166 local_bh_enable();
167 }
168 return data;
169}
170EXPORT_SYMBOL(__netdev_alloc_frag_align);
171
172static struct sk_buff *napi_skb_cache_get(void)
173{
174 struct napi_alloc_cache *nc = this_cpu_ptr(&napi_alloc_cache);
175 struct sk_buff *skb;
176
177 if (unlikely(!nc->skb_count))
178 nc->skb_count = kmem_cache_alloc_bulk(skbuff_head_cache,
179 GFP_ATOMIC,
180 NAPI_SKB_CACHE_BULK,
181 nc->skb_cache);
182 if (unlikely(!nc->skb_count))
183 return NULL;
184
185 skb = nc->skb_cache[--nc->skb_count];
186 kasan_unpoison_object_data(skbuff_head_cache, skb);
187
188 return skb;
189}
190
191
192static void __build_skb_around(struct sk_buff *skb, void *data,
193 unsigned int frag_size)
194{
195 struct skb_shared_info *shinfo;
196 unsigned int size = frag_size ? : ksize(data);
197
198 size -= SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
199
200
201 skb->truesize = SKB_TRUESIZE(size);
202 refcount_set(&skb->users, 1);
203 skb->head = data;
204 skb->data = data;
205 skb_reset_tail_pointer(skb);
206 skb->end = skb->tail + size;
207 skb->mac_header = (typeof(skb->mac_header))~0U;
208 skb->transport_header = (typeof(skb->transport_header))~0U;
209
210
211 shinfo = skb_shinfo(skb);
212 memset(shinfo, 0, offsetof(struct skb_shared_info, dataref));
213 atomic_set(&shinfo->dataref, 1);
214
215 skb_set_kcov_handle(skb, kcov_common_handle());
216}
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237struct sk_buff *__build_skb(void *data, unsigned int frag_size)
238{
239 struct sk_buff *skb;
240
241 skb = kmem_cache_alloc(skbuff_head_cache, GFP_ATOMIC);
242 if (unlikely(!skb))
243 return NULL;
244
245 memset(skb, 0, offsetof(struct sk_buff, tail));
246 __build_skb_around(skb, data, frag_size);
247
248 return skb;
249}
250
251
252
253
254
255
256struct sk_buff *build_skb(void *data, unsigned int frag_size)
257{
258 struct sk_buff *skb = __build_skb(data, frag_size);
259
260 if (skb && frag_size) {
261 skb->head_frag = 1;
262 if (page_is_pfmemalloc(virt_to_head_page(data)))
263 skb->pfmemalloc = 1;
264 }
265 return skb;
266}
267EXPORT_SYMBOL(build_skb);
268
269
270
271
272
273
274
275struct sk_buff *build_skb_around(struct sk_buff *skb,
276 void *data, unsigned int frag_size)
277{
278 if (unlikely(!skb))
279 return NULL;
280
281 __build_skb_around(skb, data, frag_size);
282
283 if (frag_size) {
284 skb->head_frag = 1;
285 if (page_is_pfmemalloc(virt_to_head_page(data)))
286 skb->pfmemalloc = 1;
287 }
288 return skb;
289}
290EXPORT_SYMBOL(build_skb_around);
291
292
293
294
295
296
297
298
299
300
301
302static struct sk_buff *__napi_build_skb(void *data, unsigned int frag_size)
303{
304 struct sk_buff *skb;
305
306 skb = napi_skb_cache_get();
307 if (unlikely(!skb))
308 return NULL;
309
310 memset(skb, 0, offsetof(struct sk_buff, tail));
311 __build_skb_around(skb, data, frag_size);
312
313 return skb;
314}
315
316
317
318
319
320
321
322
323
324
325
326struct sk_buff *napi_build_skb(void *data, unsigned int frag_size)
327{
328 struct sk_buff *skb = __napi_build_skb(data, frag_size);
329
330 if (likely(skb) && frag_size) {
331 skb->head_frag = 1;
332 skb_propagate_pfmemalloc(virt_to_head_page(data), skb);
333 }
334
335 return skb;
336}
337EXPORT_SYMBOL(napi_build_skb);
338
339
340
341
342
343
344
345
346static void *kmalloc_reserve(size_t size, gfp_t flags, int node,
347 bool *pfmemalloc)
348{
349 void *obj;
350 bool ret_pfmemalloc = false;
351
352
353
354
355
356 obj = kmalloc_node_track_caller(size,
357 flags | __GFP_NOMEMALLOC | __GFP_NOWARN,
358 node);
359 if (obj || !(gfp_pfmemalloc_allowed(flags)))
360 goto out;
361
362
363 ret_pfmemalloc = true;
364 obj = kmalloc_node_track_caller(size, flags, node);
365
366out:
367 if (pfmemalloc)
368 *pfmemalloc = ret_pfmemalloc;
369
370 return obj;
371}
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask,
397 int flags, int node)
398{
399 struct kmem_cache *cache;
400 struct sk_buff *skb;
401 u8 *data;
402 bool pfmemalloc;
403
404 cache = (flags & SKB_ALLOC_FCLONE)
405 ? skbuff_fclone_cache : skbuff_head_cache;
406
407 if (sk_memalloc_socks() && (flags & SKB_ALLOC_RX))
408 gfp_mask |= __GFP_MEMALLOC;
409
410
411 if ((flags & (SKB_ALLOC_FCLONE | SKB_ALLOC_NAPI)) == SKB_ALLOC_NAPI &&
412 likely(node == NUMA_NO_NODE || node == numa_mem_id()))
413 skb = napi_skb_cache_get();
414 else
415 skb = kmem_cache_alloc_node(cache, gfp_mask & ~GFP_DMA, node);
416 if (unlikely(!skb))
417 return NULL;
418 prefetchw(skb);
419
420
421
422
423
424
425 size = SKB_DATA_ALIGN(size);
426 size += SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
427 data = kmalloc_reserve(size, gfp_mask, node, &pfmemalloc);
428 if (unlikely(!data))
429 goto nodata;
430
431
432
433
434 size = SKB_WITH_OVERHEAD(ksize(data));
435 prefetchw(data + size);
436
437
438
439
440
441
442 memset(skb, 0, offsetof(struct sk_buff, tail));
443 __build_skb_around(skb, data, 0);
444 skb->pfmemalloc = pfmemalloc;
445
446 if (flags & SKB_ALLOC_FCLONE) {
447 struct sk_buff_fclones *fclones;
448
449 fclones = container_of(skb, struct sk_buff_fclones, skb1);
450
451 skb->fclone = SKB_FCLONE_ORIG;
452 refcount_set(&fclones->fclone_ref, 1);
453
454 fclones->skb2.fclone = SKB_FCLONE_CLONE;
455 }
456
457 return skb;
458
459nodata:
460 kmem_cache_free(cache, skb);
461 return NULL;
462}
463EXPORT_SYMBOL(__alloc_skb);
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478struct sk_buff *__netdev_alloc_skb(struct net_device *dev, unsigned int len,
479 gfp_t gfp_mask)
480{
481 struct page_frag_cache *nc;
482 struct sk_buff *skb;
483 bool pfmemalloc;
484 void *data;
485
486 len += NET_SKB_PAD;
487
488
489
490
491 if (len <= SKB_WITH_OVERHEAD(1024) ||
492 len > SKB_WITH_OVERHEAD(PAGE_SIZE) ||
493 (gfp_mask & (__GFP_DIRECT_RECLAIM | GFP_DMA))) {
494 skb = __alloc_skb(len, gfp_mask, SKB_ALLOC_RX, NUMA_NO_NODE);
495 if (!skb)
496 goto skb_fail;
497 goto skb_success;
498 }
499
500 len += SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
501 len = SKB_DATA_ALIGN(len);
502
503 if (sk_memalloc_socks())
504 gfp_mask |= __GFP_MEMALLOC;
505
506 if (in_hardirq() || irqs_disabled()) {
507 nc = this_cpu_ptr(&netdev_alloc_cache);
508 data = page_frag_alloc(nc, len, gfp_mask);
509 pfmemalloc = nc->pfmemalloc;
510 } else {
511 local_bh_disable();
512 nc = this_cpu_ptr(&napi_alloc_cache.page);
513 data = page_frag_alloc(nc, len, gfp_mask);
514 pfmemalloc = nc->pfmemalloc;
515 local_bh_enable();
516 }
517
518 if (unlikely(!data))
519 return NULL;
520
521 skb = __build_skb(data, len);
522 if (unlikely(!skb)) {
523 skb_free_frag(data);
524 return NULL;
525 }
526
527 if (pfmemalloc)
528 skb->pfmemalloc = 1;
529 skb->head_frag = 1;
530
531skb_success:
532 skb_reserve(skb, NET_SKB_PAD);
533 skb->dev = dev;
534
535skb_fail:
536 return skb;
537}
538EXPORT_SYMBOL(__netdev_alloc_skb);
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553struct sk_buff *__napi_alloc_skb(struct napi_struct *napi, unsigned int len,
554 gfp_t gfp_mask)
555{
556 struct napi_alloc_cache *nc;
557 struct sk_buff *skb;
558 void *data;
559
560 len += NET_SKB_PAD + NET_IP_ALIGN;
561
562
563
564
565 if (len <= SKB_WITH_OVERHEAD(1024) ||
566 len > SKB_WITH_OVERHEAD(PAGE_SIZE) ||
567 (gfp_mask & (__GFP_DIRECT_RECLAIM | GFP_DMA))) {
568 skb = __alloc_skb(len, gfp_mask, SKB_ALLOC_RX | SKB_ALLOC_NAPI,
569 NUMA_NO_NODE);
570 if (!skb)
571 goto skb_fail;
572 goto skb_success;
573 }
574
575 nc = this_cpu_ptr(&napi_alloc_cache);
576 len += SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
577 len = SKB_DATA_ALIGN(len);
578
579 if (sk_memalloc_socks())
580 gfp_mask |= __GFP_MEMALLOC;
581
582 data = page_frag_alloc(&nc->page, len, gfp_mask);
583 if (unlikely(!data))
584 return NULL;
585
586 skb = __napi_build_skb(data, len);
587 if (unlikely(!skb)) {
588 skb_free_frag(data);
589 return NULL;
590 }
591
592 if (nc->page.pfmemalloc)
593 skb->pfmemalloc = 1;
594 skb->head_frag = 1;
595
596skb_success:
597 skb_reserve(skb, NET_SKB_PAD + NET_IP_ALIGN);
598 skb->dev = napi->dev;
599
600skb_fail:
601 return skb;
602}
603EXPORT_SYMBOL(__napi_alloc_skb);
604
605void skb_add_rx_frag(struct sk_buff *skb, int i, struct page *page, int off,
606 int size, unsigned int truesize)
607{
608 skb_fill_page_desc(skb, i, page, off, size);
609 skb->len += size;
610 skb->data_len += size;
611 skb->truesize += truesize;
612}
613EXPORT_SYMBOL(skb_add_rx_frag);
614
615void skb_coalesce_rx_frag(struct sk_buff *skb, int i, int size,
616 unsigned int truesize)
617{
618 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
619
620 skb_frag_size_add(frag, size);
621 skb->len += size;
622 skb->data_len += size;
623 skb->truesize += truesize;
624}
625EXPORT_SYMBOL(skb_coalesce_rx_frag);
626
627static void skb_drop_list(struct sk_buff **listp)
628{
629 kfree_skb_list(*listp);
630 *listp = NULL;
631}
632
633static inline void skb_drop_fraglist(struct sk_buff *skb)
634{
635 skb_drop_list(&skb_shinfo(skb)->frag_list);
636}
637
638static void skb_clone_fraglist(struct sk_buff *skb)
639{
640 struct sk_buff *list;
641
642 skb_walk_frags(skb, list)
643 skb_get(list);
644}
645
646static void skb_free_head(struct sk_buff *skb)
647{
648 unsigned char *head = skb->head;
649
650 if (skb->head_frag) {
651 if (skb_pp_recycle(skb, head))
652 return;
653 skb_free_frag(head);
654 } else {
655 kfree(head);
656 }
657}
658
659static void skb_release_data(struct sk_buff *skb)
660{
661 struct skb_shared_info *shinfo = skb_shinfo(skb);
662 int i;
663
664 if (skb->cloned &&
665 atomic_sub_return(skb->nohdr ? (1 << SKB_DATAREF_SHIFT) + 1 : 1,
666 &shinfo->dataref))
667 goto exit;
668
669 skb_zcopy_clear(skb, true);
670
671 for (i = 0; i < shinfo->nr_frags; i++)
672 __skb_frag_unref(&shinfo->frags[i], skb->pp_recycle);
673
674 if (shinfo->frag_list)
675 kfree_skb_list(shinfo->frag_list);
676
677 skb_free_head(skb);
678exit:
679
680
681
682
683
684
685
686
687
688 skb->pp_recycle = 0;
689}
690
691
692
693
694static void kfree_skbmem(struct sk_buff *skb)
695{
696 struct sk_buff_fclones *fclones;
697
698 switch (skb->fclone) {
699 case SKB_FCLONE_UNAVAILABLE:
700 kmem_cache_free(skbuff_head_cache, skb);
701 return;
702
703 case SKB_FCLONE_ORIG:
704 fclones = container_of(skb, struct sk_buff_fclones, skb1);
705
706
707
708
709
710 if (refcount_read(&fclones->fclone_ref) == 1)
711 goto fastpath;
712 break;
713
714 default:
715 fclones = container_of(skb, struct sk_buff_fclones, skb2);
716 break;
717 }
718 if (!refcount_dec_and_test(&fclones->fclone_ref))
719 return;
720fastpath:
721 kmem_cache_free(skbuff_fclone_cache, fclones);
722}
723
724void skb_release_head_state(struct sk_buff *skb)
725{
726 skb_dst_drop(skb);
727 if (skb->destructor) {
728 WARN_ON(in_hardirq());
729 skb->destructor(skb);
730 }
731#if IS_ENABLED(CONFIG_NF_CONNTRACK)
732 nf_conntrack_put(skb_nfct(skb));
733#endif
734 skb_ext_put(skb);
735}
736
737
738static void skb_release_all(struct sk_buff *skb)
739{
740 skb_release_head_state(skb);
741 if (likely(skb->head))
742 skb_release_data(skb);
743}
744
745
746
747
748
749
750
751
752
753
754void __kfree_skb(struct sk_buff *skb)
755{
756 skb_release_all(skb);
757 kfree_skbmem(skb);
758}
759EXPORT_SYMBOL(__kfree_skb);
760
761
762
763
764
765
766
767
768void kfree_skb(struct sk_buff *skb)
769{
770 if (!skb_unref(skb))
771 return;
772
773 trace_kfree_skb(skb, __builtin_return_address(0));
774 __kfree_skb(skb);
775}
776EXPORT_SYMBOL(kfree_skb);
777
778void kfree_skb_list(struct sk_buff *segs)
779{
780 while (segs) {
781 struct sk_buff *next = segs->next;
782
783 kfree_skb(segs);
784 segs = next;
785 }
786}
787EXPORT_SYMBOL(kfree_skb_list);
788
789
790
791
792
793
794
795void skb_dump(const char *level, const struct sk_buff *skb, bool full_pkt)
796{
797 struct skb_shared_info *sh = skb_shinfo(skb);
798 struct net_device *dev = skb->dev;
799 struct sock *sk = skb->sk;
800 struct sk_buff *list_skb;
801 bool has_mac, has_trans;
802 int headroom, tailroom;
803 int i, len, seg_len;
804
805 if (full_pkt)
806 len = skb->len;
807 else
808 len = min_t(int, skb->len, MAX_HEADER + 128);
809
810 headroom = skb_headroom(skb);
811 tailroom = skb_tailroom(skb);
812
813 has_mac = skb_mac_header_was_set(skb);
814 has_trans = skb_transport_header_was_set(skb);
815
816 printk("%sskb len=%u headroom=%u headlen=%u tailroom=%u\n"
817 "mac=(%d,%d) net=(%d,%d) trans=%d\n"
818 "shinfo(txflags=%u nr_frags=%u gso(size=%hu type=%u segs=%hu))\n"
819 "csum(0x%x ip_summed=%u complete_sw=%u valid=%u level=%u)\n"
820 "hash(0x%x sw=%u l4=%u) proto=0x%04x pkttype=%u iif=%d\n",
821 level, skb->len, headroom, skb_headlen(skb), tailroom,
822 has_mac ? skb->mac_header : -1,
823 has_mac ? skb_mac_header_len(skb) : -1,
824 skb->network_header,
825 has_trans ? skb_network_header_len(skb) : -1,
826 has_trans ? skb->transport_header : -1,
827 sh->tx_flags, sh->nr_frags,
828 sh->gso_size, sh->gso_type, sh->gso_segs,
829 skb->csum, skb->ip_summed, skb->csum_complete_sw,
830 skb->csum_valid, skb->csum_level,
831 skb->hash, skb->sw_hash, skb->l4_hash,
832 ntohs(skb->protocol), skb->pkt_type, skb->skb_iif);
833
834 if (dev)
835 printk("%sdev name=%s feat=0x%pNF\n",
836 level, dev->name, &dev->features);
837 if (sk)
838 printk("%ssk family=%hu type=%u proto=%u\n",
839 level, sk->sk_family, sk->sk_type, sk->sk_protocol);
840
841 if (full_pkt && headroom)
842 print_hex_dump(level, "skb headroom: ", DUMP_PREFIX_OFFSET,
843 16, 1, skb->head, headroom, false);
844
845 seg_len = min_t(int, skb_headlen(skb), len);
846 if (seg_len)
847 print_hex_dump(level, "skb linear: ", DUMP_PREFIX_OFFSET,
848 16, 1, skb->data, seg_len, false);
849 len -= seg_len;
850
851 if (full_pkt && tailroom)
852 print_hex_dump(level, "skb tailroom: ", DUMP_PREFIX_OFFSET,
853 16, 1, skb_tail_pointer(skb), tailroom, false);
854
855 for (i = 0; len && i < skb_shinfo(skb)->nr_frags; i++) {
856 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
857 u32 p_off, p_len, copied;
858 struct page *p;
859 u8 *vaddr;
860
861 skb_frag_foreach_page(frag, skb_frag_off(frag),
862 skb_frag_size(frag), p, p_off, p_len,
863 copied) {
864 seg_len = min_t(int, p_len, len);
865 vaddr = kmap_atomic(p);
866 print_hex_dump(level, "skb frag: ",
867 DUMP_PREFIX_OFFSET,
868 16, 1, vaddr + p_off, seg_len, false);
869 kunmap_atomic(vaddr);
870 len -= seg_len;
871 if (!len)
872 break;
873 }
874 }
875
876 if (full_pkt && skb_has_frag_list(skb)) {
877 printk("skb fraglist:\n");
878 skb_walk_frags(skb, list_skb)
879 skb_dump(level, list_skb, true);
880 }
881}
882EXPORT_SYMBOL(skb_dump);
883
884
885
886
887
888
889
890
891void skb_tx_error(struct sk_buff *skb)
892{
893 skb_zcopy_clear(skb, true);
894}
895EXPORT_SYMBOL(skb_tx_error);
896
897#ifdef CONFIG_TRACEPOINTS
898
899
900
901
902
903
904
905
906void consume_skb(struct sk_buff *skb)
907{
908 if (!skb_unref(skb))
909 return;
910
911 trace_consume_skb(skb);
912 __kfree_skb(skb);
913}
914EXPORT_SYMBOL(consume_skb);
915#endif
916
917
918
919
920
921
922
923
924void __consume_stateless_skb(struct sk_buff *skb)
925{
926 trace_consume_skb(skb);
927 skb_release_data(skb);
928 kfree_skbmem(skb);
929}
930
931static void napi_skb_cache_put(struct sk_buff *skb)
932{
933 struct napi_alloc_cache *nc = this_cpu_ptr(&napi_alloc_cache);
934 u32 i;
935
936 kasan_poison_object_data(skbuff_head_cache, skb);
937 nc->skb_cache[nc->skb_count++] = skb;
938
939 if (unlikely(nc->skb_count == NAPI_SKB_CACHE_SIZE)) {
940 for (i = NAPI_SKB_CACHE_HALF; i < NAPI_SKB_CACHE_SIZE; i++)
941 kasan_unpoison_object_data(skbuff_head_cache,
942 nc->skb_cache[i]);
943
944 kmem_cache_free_bulk(skbuff_head_cache, NAPI_SKB_CACHE_HALF,
945 nc->skb_cache + NAPI_SKB_CACHE_HALF);
946 nc->skb_count = NAPI_SKB_CACHE_HALF;
947 }
948}
949
950void __kfree_skb_defer(struct sk_buff *skb)
951{
952 skb_release_all(skb);
953 napi_skb_cache_put(skb);
954}
955
956void napi_skb_free_stolen_head(struct sk_buff *skb)
957{
958 if (unlikely(skb->slow_gro)) {
959 nf_reset_ct(skb);
960 skb_dst_drop(skb);
961 skb_ext_put(skb);
962 skb_orphan(skb);
963 skb->slow_gro = 0;
964 }
965 napi_skb_cache_put(skb);
966}
967
968void napi_consume_skb(struct sk_buff *skb, int budget)
969{
970
971 if (unlikely(!budget)) {
972 dev_consume_skb_any(skb);
973 return;
974 }
975
976 lockdep_assert_in_softirq();
977
978 if (!skb_unref(skb))
979 return;
980
981
982 trace_consume_skb(skb);
983
984
985 if (skb->fclone != SKB_FCLONE_UNAVAILABLE) {
986 __kfree_skb(skb);
987 return;
988 }
989
990 skb_release_all(skb);
991 napi_skb_cache_put(skb);
992}
993EXPORT_SYMBOL(napi_consume_skb);
994
995
996#define CHECK_SKB_FIELD(field) \
997 BUILD_BUG_ON(offsetof(struct sk_buff, field) < \
998 offsetof(struct sk_buff, headers_start)); \
999 BUILD_BUG_ON(offsetof(struct sk_buff, field) > \
1000 offsetof(struct sk_buff, headers_end)); \
1001
1002static void __copy_skb_header(struct sk_buff *new, const struct sk_buff *old)
1003{
1004 new->tstamp = old->tstamp;
1005
1006 new->dev = old->dev;
1007 memcpy(new->cb, old->cb, sizeof(old->cb));
1008 skb_dst_copy(new, old);
1009 __skb_ext_copy(new, old);
1010 __nf_copy(new, old, false);
1011
1012
1013
1014
1015 new->queue_mapping = old->queue_mapping;
1016
1017 memcpy(&new->headers_start, &old->headers_start,
1018 offsetof(struct sk_buff, headers_end) -
1019 offsetof(struct sk_buff, headers_start));
1020 CHECK_SKB_FIELD(protocol);
1021 CHECK_SKB_FIELD(csum);
1022 CHECK_SKB_FIELD(hash);
1023 CHECK_SKB_FIELD(priority);
1024 CHECK_SKB_FIELD(skb_iif);
1025 CHECK_SKB_FIELD(vlan_proto);
1026 CHECK_SKB_FIELD(vlan_tci);
1027 CHECK_SKB_FIELD(transport_header);
1028 CHECK_SKB_FIELD(network_header);
1029 CHECK_SKB_FIELD(mac_header);
1030 CHECK_SKB_FIELD(inner_protocol);
1031 CHECK_SKB_FIELD(inner_transport_header);
1032 CHECK_SKB_FIELD(inner_network_header);
1033 CHECK_SKB_FIELD(inner_mac_header);
1034 CHECK_SKB_FIELD(mark);
1035#ifdef CONFIG_NETWORK_SECMARK
1036 CHECK_SKB_FIELD(secmark);
1037#endif
1038#ifdef CONFIG_NET_RX_BUSY_POLL
1039 CHECK_SKB_FIELD(napi_id);
1040#endif
1041#ifdef CONFIG_XPS
1042 CHECK_SKB_FIELD(sender_cpu);
1043#endif
1044#ifdef CONFIG_NET_SCHED
1045 CHECK_SKB_FIELD(tc_index);
1046#endif
1047
1048}
1049
1050
1051
1052
1053
1054static struct sk_buff *__skb_clone(struct sk_buff *n, struct sk_buff *skb)
1055{
1056#define C(x) n->x = skb->x
1057
1058 n->next = n->prev = NULL;
1059 n->sk = NULL;
1060 __copy_skb_header(n, skb);
1061
1062 C(len);
1063 C(data_len);
1064 C(mac_len);
1065 n->hdr_len = skb->nohdr ? skb_headroom(skb) : skb->hdr_len;
1066 n->cloned = 1;
1067 n->nohdr = 0;
1068 n->peeked = 0;
1069 C(pfmemalloc);
1070 C(pp_recycle);
1071 n->destructor = NULL;
1072 C(tail);
1073 C(end);
1074 C(head);
1075 C(head_frag);
1076 C(data);
1077 C(truesize);
1078 refcount_set(&n->users, 1);
1079
1080 atomic_inc(&(skb_shinfo(skb)->dataref));
1081 skb->cloned = 1;
1082
1083 return n;
1084#undef C
1085}
1086
1087
1088
1089
1090
1091struct sk_buff *alloc_skb_for_msg(struct sk_buff *first)
1092{
1093 struct sk_buff *n;
1094
1095 n = alloc_skb(0, GFP_ATOMIC);
1096 if (!n)
1097 return NULL;
1098
1099 n->len = first->len;
1100 n->data_len = first->len;
1101 n->truesize = first->truesize;
1102
1103 skb_shinfo(n)->frag_list = first;
1104
1105 __copy_skb_header(n, first);
1106 n->destructor = NULL;
1107
1108 return n;
1109}
1110EXPORT_SYMBOL_GPL(alloc_skb_for_msg);
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122struct sk_buff *skb_morph(struct sk_buff *dst, struct sk_buff *src)
1123{
1124 skb_release_all(dst);
1125 return __skb_clone(dst, src);
1126}
1127EXPORT_SYMBOL_GPL(skb_morph);
1128
1129int mm_account_pinned_pages(struct mmpin *mmp, size_t size)
1130{
1131 unsigned long max_pg, num_pg, new_pg, old_pg;
1132 struct user_struct *user;
1133
1134 if (capable(CAP_IPC_LOCK) || !size)
1135 return 0;
1136
1137 num_pg = (size >> PAGE_SHIFT) + 2;
1138 max_pg = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
1139 user = mmp->user ? : current_user();
1140
1141 do {
1142 old_pg = atomic_long_read(&user->locked_vm);
1143 new_pg = old_pg + num_pg;
1144 if (new_pg > max_pg)
1145 return -ENOBUFS;
1146 } while (atomic_long_cmpxchg(&user->locked_vm, old_pg, new_pg) !=
1147 old_pg);
1148
1149 if (!mmp->user) {
1150 mmp->user = get_uid(user);
1151 mmp->num_pg = num_pg;
1152 } else {
1153 mmp->num_pg += num_pg;
1154 }
1155
1156 return 0;
1157}
1158EXPORT_SYMBOL_GPL(mm_account_pinned_pages);
1159
1160void mm_unaccount_pinned_pages(struct mmpin *mmp)
1161{
1162 if (mmp->user) {
1163 atomic_long_sub(mmp->num_pg, &mmp->user->locked_vm);
1164 free_uid(mmp->user);
1165 }
1166}
1167EXPORT_SYMBOL_GPL(mm_unaccount_pinned_pages);
1168
1169struct ubuf_info *msg_zerocopy_alloc(struct sock *sk, size_t size)
1170{
1171 struct ubuf_info *uarg;
1172 struct sk_buff *skb;
1173
1174 WARN_ON_ONCE(!in_task());
1175
1176 skb = sock_omalloc(sk, 0, GFP_KERNEL);
1177 if (!skb)
1178 return NULL;
1179
1180 BUILD_BUG_ON(sizeof(*uarg) > sizeof(skb->cb));
1181 uarg = (void *)skb->cb;
1182 uarg->mmp.user = NULL;
1183
1184 if (mm_account_pinned_pages(&uarg->mmp, size)) {
1185 kfree_skb(skb);
1186 return NULL;
1187 }
1188
1189 uarg->callback = msg_zerocopy_callback;
1190 uarg->id = ((u32)atomic_inc_return(&sk->sk_zckey)) - 1;
1191 uarg->len = 1;
1192 uarg->bytelen = size;
1193 uarg->zerocopy = 1;
1194 uarg->flags = SKBFL_ZEROCOPY_FRAG;
1195 refcount_set(&uarg->refcnt, 1);
1196 sock_hold(sk);
1197
1198 return uarg;
1199}
1200EXPORT_SYMBOL_GPL(msg_zerocopy_alloc);
1201
1202static inline struct sk_buff *skb_from_uarg(struct ubuf_info *uarg)
1203{
1204 return container_of((void *)uarg, struct sk_buff, cb);
1205}
1206
1207struct ubuf_info *msg_zerocopy_realloc(struct sock *sk, size_t size,
1208 struct ubuf_info *uarg)
1209{
1210 if (uarg) {
1211 const u32 byte_limit = 1 << 19;
1212 u32 bytelen, next;
1213
1214
1215
1216
1217 if (!sock_owned_by_user(sk)) {
1218 WARN_ON_ONCE(1);
1219 return NULL;
1220 }
1221
1222 bytelen = uarg->bytelen + size;
1223 if (uarg->len == USHRT_MAX - 1 || bytelen > byte_limit) {
1224
1225 if (sk->sk_type == SOCK_STREAM)
1226 goto new_alloc;
1227 return NULL;
1228 }
1229
1230 next = (u32)atomic_read(&sk->sk_zckey);
1231 if ((u32)(uarg->id + uarg->len) == next) {
1232 if (mm_account_pinned_pages(&uarg->mmp, size))
1233 return NULL;
1234 uarg->len++;
1235 uarg->bytelen = bytelen;
1236 atomic_set(&sk->sk_zckey, ++next);
1237
1238
1239 if (sk->sk_type == SOCK_STREAM)
1240 net_zcopy_get(uarg);
1241
1242 return uarg;
1243 }
1244 }
1245
1246new_alloc:
1247 return msg_zerocopy_alloc(sk, size);
1248}
1249EXPORT_SYMBOL_GPL(msg_zerocopy_realloc);
1250
1251static bool skb_zerocopy_notify_extend(struct sk_buff *skb, u32 lo, u16 len)
1252{
1253 struct sock_exterr_skb *serr = SKB_EXT_ERR(skb);
1254 u32 old_lo, old_hi;
1255 u64 sum_len;
1256
1257 old_lo = serr->ee.ee_info;
1258 old_hi = serr->ee.ee_data;
1259 sum_len = old_hi - old_lo + 1ULL + len;
1260
1261 if (sum_len >= (1ULL << 32))
1262 return false;
1263
1264 if (lo != old_hi + 1)
1265 return false;
1266
1267 serr->ee.ee_data += len;
1268 return true;
1269}
1270
1271static void __msg_zerocopy_callback(struct ubuf_info *uarg)
1272{
1273 struct sk_buff *tail, *skb = skb_from_uarg(uarg);
1274 struct sock_exterr_skb *serr;
1275 struct sock *sk = skb->sk;
1276 struct sk_buff_head *q;
1277 unsigned long flags;
1278 bool is_zerocopy;
1279 u32 lo, hi;
1280 u16 len;
1281
1282 mm_unaccount_pinned_pages(&uarg->mmp);
1283
1284
1285
1286
1287 if (!uarg->len || sock_flag(sk, SOCK_DEAD))
1288 goto release;
1289
1290 len = uarg->len;
1291 lo = uarg->id;
1292 hi = uarg->id + len - 1;
1293 is_zerocopy = uarg->zerocopy;
1294
1295 serr = SKB_EXT_ERR(skb);
1296 memset(serr, 0, sizeof(*serr));
1297 serr->ee.ee_errno = 0;
1298 serr->ee.ee_origin = SO_EE_ORIGIN_ZEROCOPY;
1299 serr->ee.ee_data = hi;
1300 serr->ee.ee_info = lo;
1301 if (!is_zerocopy)
1302 serr->ee.ee_code |= SO_EE_CODE_ZEROCOPY_COPIED;
1303
1304 q = &sk->sk_error_queue;
1305 spin_lock_irqsave(&q->lock, flags);
1306 tail = skb_peek_tail(q);
1307 if (!tail || SKB_EXT_ERR(tail)->ee.ee_origin != SO_EE_ORIGIN_ZEROCOPY ||
1308 !skb_zerocopy_notify_extend(tail, lo, len)) {
1309 __skb_queue_tail(q, skb);
1310 skb = NULL;
1311 }
1312 spin_unlock_irqrestore(&q->lock, flags);
1313
1314 sk_error_report(sk);
1315
1316release:
1317 consume_skb(skb);
1318 sock_put(sk);
1319}
1320
1321void msg_zerocopy_callback(struct sk_buff *skb, struct ubuf_info *uarg,
1322 bool success)
1323{
1324 uarg->zerocopy = uarg->zerocopy & success;
1325
1326 if (refcount_dec_and_test(&uarg->refcnt))
1327 __msg_zerocopy_callback(uarg);
1328}
1329EXPORT_SYMBOL_GPL(msg_zerocopy_callback);
1330
1331void msg_zerocopy_put_abort(struct ubuf_info *uarg, bool have_uref)
1332{
1333 struct sock *sk = skb_from_uarg(uarg)->sk;
1334
1335 atomic_dec(&sk->sk_zckey);
1336 uarg->len--;
1337
1338 if (have_uref)
1339 msg_zerocopy_callback(NULL, uarg, true);
1340}
1341EXPORT_SYMBOL_GPL(msg_zerocopy_put_abort);
1342
1343int skb_zerocopy_iter_dgram(struct sk_buff *skb, struct msghdr *msg, int len)
1344{
1345 return __zerocopy_sg_from_iter(skb->sk, skb, &msg->msg_iter, len);
1346}
1347EXPORT_SYMBOL_GPL(skb_zerocopy_iter_dgram);
1348
1349int skb_zerocopy_iter_stream(struct sock *sk, struct sk_buff *skb,
1350 struct msghdr *msg, int len,
1351 struct ubuf_info *uarg)
1352{
1353 struct ubuf_info *orig_uarg = skb_zcopy(skb);
1354 struct iov_iter orig_iter = msg->msg_iter;
1355 int err, orig_len = skb->len;
1356
1357
1358
1359
1360 if (orig_uarg && uarg != orig_uarg)
1361 return -EEXIST;
1362
1363 err = __zerocopy_sg_from_iter(sk, skb, &msg->msg_iter, len);
1364 if (err == -EFAULT || (err == -EMSGSIZE && skb->len == orig_len)) {
1365 struct sock *save_sk = skb->sk;
1366
1367
1368 msg->msg_iter = orig_iter;
1369 skb->sk = sk;
1370 ___pskb_trim(skb, orig_len);
1371 skb->sk = save_sk;
1372 return err;
1373 }
1374
1375 skb_zcopy_set(skb, uarg, NULL);
1376 return skb->len - orig_len;
1377}
1378EXPORT_SYMBOL_GPL(skb_zerocopy_iter_stream);
1379
1380static int skb_zerocopy_clone(struct sk_buff *nskb, struct sk_buff *orig,
1381 gfp_t gfp_mask)
1382{
1383 if (skb_zcopy(orig)) {
1384 if (skb_zcopy(nskb)) {
1385
1386 if (!gfp_mask) {
1387 WARN_ON_ONCE(1);
1388 return -ENOMEM;
1389 }
1390 if (skb_uarg(nskb) == skb_uarg(orig))
1391 return 0;
1392 if (skb_copy_ubufs(nskb, GFP_ATOMIC))
1393 return -EIO;
1394 }
1395 skb_zcopy_set(nskb, skb_uarg(orig), NULL);
1396 }
1397 return 0;
1398}
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415int skb_copy_ubufs(struct sk_buff *skb, gfp_t gfp_mask)
1416{
1417 int num_frags = skb_shinfo(skb)->nr_frags;
1418 struct page *page, *head = NULL;
1419 int i, new_frags;
1420 u32 d_off;
1421
1422 if (skb_shared(skb) || skb_unclone(skb, gfp_mask))
1423 return -EINVAL;
1424
1425 if (!num_frags)
1426 goto release;
1427
1428 new_frags = (__skb_pagelen(skb) + PAGE_SIZE - 1) >> PAGE_SHIFT;
1429 for (i = 0; i < new_frags; i++) {
1430 page = alloc_page(gfp_mask);
1431 if (!page) {
1432 while (head) {
1433 struct page *next = (struct page *)page_private(head);
1434 put_page(head);
1435 head = next;
1436 }
1437 return -ENOMEM;
1438 }
1439 set_page_private(page, (unsigned long)head);
1440 head = page;
1441 }
1442
1443 page = head;
1444 d_off = 0;
1445 for (i = 0; i < num_frags; i++) {
1446 skb_frag_t *f = &skb_shinfo(skb)->frags[i];
1447 u32 p_off, p_len, copied;
1448 struct page *p;
1449 u8 *vaddr;
1450
1451 skb_frag_foreach_page(f, skb_frag_off(f), skb_frag_size(f),
1452 p, p_off, p_len, copied) {
1453 u32 copy, done = 0;
1454 vaddr = kmap_atomic(p);
1455
1456 while (done < p_len) {
1457 if (d_off == PAGE_SIZE) {
1458 d_off = 0;
1459 page = (struct page *)page_private(page);
1460 }
1461 copy = min_t(u32, PAGE_SIZE - d_off, p_len - done);
1462 memcpy(page_address(page) + d_off,
1463 vaddr + p_off + done, copy);
1464 done += copy;
1465 d_off += copy;
1466 }
1467 kunmap_atomic(vaddr);
1468 }
1469 }
1470
1471
1472 for (i = 0; i < num_frags; i++)
1473 skb_frag_unref(skb, i);
1474
1475
1476 for (i = 0; i < new_frags - 1; i++) {
1477 __skb_fill_page_desc(skb, i, head, 0, PAGE_SIZE);
1478 head = (struct page *)page_private(head);
1479 }
1480 __skb_fill_page_desc(skb, new_frags - 1, head, 0, d_off);
1481 skb_shinfo(skb)->nr_frags = new_frags;
1482
1483release:
1484 skb_zcopy_clear(skb, false);
1485 return 0;
1486}
1487EXPORT_SYMBOL_GPL(skb_copy_ubufs);
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t gfp_mask)
1504{
1505 struct sk_buff_fclones *fclones = container_of(skb,
1506 struct sk_buff_fclones,
1507 skb1);
1508 struct sk_buff *n;
1509
1510 if (skb_orphan_frags(skb, gfp_mask))
1511 return NULL;
1512
1513 if (skb->fclone == SKB_FCLONE_ORIG &&
1514 refcount_read(&fclones->fclone_ref) == 1) {
1515 n = &fclones->skb2;
1516 refcount_set(&fclones->fclone_ref, 2);
1517 } else {
1518 if (skb_pfmemalloc(skb))
1519 gfp_mask |= __GFP_MEMALLOC;
1520
1521 n = kmem_cache_alloc(skbuff_head_cache, gfp_mask);
1522 if (!n)
1523 return NULL;
1524
1525 n->fclone = SKB_FCLONE_UNAVAILABLE;
1526 }
1527
1528 return __skb_clone(n, skb);
1529}
1530EXPORT_SYMBOL(skb_clone);
1531
1532void skb_headers_offset_update(struct sk_buff *skb, int off)
1533{
1534
1535 if (skb->ip_summed == CHECKSUM_PARTIAL)
1536 skb->csum_start += off;
1537
1538 skb->transport_header += off;
1539 skb->network_header += off;
1540 if (skb_mac_header_was_set(skb))
1541 skb->mac_header += off;
1542 skb->inner_transport_header += off;
1543 skb->inner_network_header += off;
1544 skb->inner_mac_header += off;
1545}
1546EXPORT_SYMBOL(skb_headers_offset_update);
1547
1548void skb_copy_header(struct sk_buff *new, const struct sk_buff *old)
1549{
1550 __copy_skb_header(new, old);
1551
1552 skb_shinfo(new)->gso_size = skb_shinfo(old)->gso_size;
1553 skb_shinfo(new)->gso_segs = skb_shinfo(old)->gso_segs;
1554 skb_shinfo(new)->gso_type = skb_shinfo(old)->gso_type;
1555}
1556EXPORT_SYMBOL(skb_copy_header);
1557
1558static inline int skb_alloc_rx_flag(const struct sk_buff *skb)
1559{
1560 if (skb_pfmemalloc(skb))
1561 return SKB_ALLOC_RX;
1562 return 0;
1563}
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582struct sk_buff *skb_copy(const struct sk_buff *skb, gfp_t gfp_mask)
1583{
1584 int headerlen = skb_headroom(skb);
1585 unsigned int size = skb_end_offset(skb) + skb->data_len;
1586 struct sk_buff *n = __alloc_skb(size, gfp_mask,
1587 skb_alloc_rx_flag(skb), NUMA_NO_NODE);
1588
1589 if (!n)
1590 return NULL;
1591
1592
1593 skb_reserve(n, headerlen);
1594
1595 skb_put(n, skb->len);
1596
1597 BUG_ON(skb_copy_bits(skb, -headerlen, n->head, headerlen + skb->len));
1598
1599 skb_copy_header(n, skb);
1600 return n;
1601}
1602EXPORT_SYMBOL(skb_copy);
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621struct sk_buff *__pskb_copy_fclone(struct sk_buff *skb, int headroom,
1622 gfp_t gfp_mask, bool fclone)
1623{
1624 unsigned int size = skb_headlen(skb) + headroom;
1625 int flags = skb_alloc_rx_flag(skb) | (fclone ? SKB_ALLOC_FCLONE : 0);
1626 struct sk_buff *n = __alloc_skb(size, gfp_mask, flags, NUMA_NO_NODE);
1627
1628 if (!n)
1629 goto out;
1630
1631
1632 skb_reserve(n, headroom);
1633
1634 skb_put(n, skb_headlen(skb));
1635
1636 skb_copy_from_linear_data(skb, n->data, n->len);
1637
1638 n->truesize += skb->data_len;
1639 n->data_len = skb->data_len;
1640 n->len = skb->len;
1641
1642 if (skb_shinfo(skb)->nr_frags) {
1643 int i;
1644
1645 if (skb_orphan_frags(skb, gfp_mask) ||
1646 skb_zerocopy_clone(n, skb, gfp_mask)) {
1647 kfree_skb(n);
1648 n = NULL;
1649 goto out;
1650 }
1651 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1652 skb_shinfo(n)->frags[i] = skb_shinfo(skb)->frags[i];
1653 skb_frag_ref(skb, i);
1654 }
1655 skb_shinfo(n)->nr_frags = i;
1656 }
1657
1658 if (skb_has_frag_list(skb)) {
1659 skb_shinfo(n)->frag_list = skb_shinfo(skb)->frag_list;
1660 skb_clone_fraglist(n);
1661 }
1662
1663 skb_copy_header(n, skb);
1664out:
1665 return n;
1666}
1667EXPORT_SYMBOL(__pskb_copy_fclone);
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685int pskb_expand_head(struct sk_buff *skb, int nhead, int ntail,
1686 gfp_t gfp_mask)
1687{
1688 int i, osize = skb_end_offset(skb);
1689 int size = osize + nhead + ntail;
1690 long off;
1691 u8 *data;
1692
1693 BUG_ON(nhead < 0);
1694
1695 BUG_ON(skb_shared(skb));
1696
1697 size = SKB_DATA_ALIGN(size);
1698
1699 if (skb_pfmemalloc(skb))
1700 gfp_mask |= __GFP_MEMALLOC;
1701 data = kmalloc_reserve(size + SKB_DATA_ALIGN(sizeof(struct skb_shared_info)),
1702 gfp_mask, NUMA_NO_NODE, NULL);
1703 if (!data)
1704 goto nodata;
1705 size = SKB_WITH_OVERHEAD(ksize(data));
1706
1707
1708
1709
1710 memcpy(data + nhead, skb->head, skb_tail_pointer(skb) - skb->head);
1711
1712 memcpy((struct skb_shared_info *)(data + size),
1713 skb_shinfo(skb),
1714 offsetof(struct skb_shared_info, frags[skb_shinfo(skb)->nr_frags]));
1715
1716
1717
1718
1719
1720
1721 if (skb_cloned(skb)) {
1722 if (skb_orphan_frags(skb, gfp_mask))
1723 goto nofrags;
1724 if (skb_zcopy(skb))
1725 refcount_inc(&skb_uarg(skb)->refcnt);
1726 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
1727 skb_frag_ref(skb, i);
1728
1729 if (skb_has_frag_list(skb))
1730 skb_clone_fraglist(skb);
1731
1732 skb_release_data(skb);
1733 } else {
1734 skb_free_head(skb);
1735 }
1736 off = (data + nhead) - skb->head;
1737
1738 skb->head = data;
1739 skb->head_frag = 0;
1740 skb->data += off;
1741#ifdef NET_SKBUFF_DATA_USES_OFFSET
1742 skb->end = size;
1743 off = nhead;
1744#else
1745 skb->end = skb->head + size;
1746#endif
1747 skb->tail += off;
1748 skb_headers_offset_update(skb, nhead);
1749 skb->cloned = 0;
1750 skb->hdr_len = 0;
1751 skb->nohdr = 0;
1752 atomic_set(&skb_shinfo(skb)->dataref, 1);
1753
1754 skb_metadata_clear(skb);
1755
1756
1757
1758
1759
1760 if (!skb->sk || skb->destructor == sock_edemux)
1761 skb->truesize += size - osize;
1762
1763 return 0;
1764
1765nofrags:
1766 kfree(data);
1767nodata:
1768 return -ENOMEM;
1769}
1770EXPORT_SYMBOL(pskb_expand_head);
1771
1772
1773
1774struct sk_buff *skb_realloc_headroom(struct sk_buff *skb, unsigned int headroom)
1775{
1776 struct sk_buff *skb2;
1777 int delta = headroom - skb_headroom(skb);
1778
1779 if (delta <= 0)
1780 skb2 = pskb_copy(skb, GFP_ATOMIC);
1781 else {
1782 skb2 = skb_clone(skb, GFP_ATOMIC);
1783 if (skb2 && pskb_expand_head(skb2, SKB_DATA_ALIGN(delta), 0,
1784 GFP_ATOMIC)) {
1785 kfree_skb(skb2);
1786 skb2 = NULL;
1787 }
1788 }
1789 return skb2;
1790}
1791EXPORT_SYMBOL(skb_realloc_headroom);
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805struct sk_buff *skb_expand_head(struct sk_buff *skb, unsigned int headroom)
1806{
1807 int delta = headroom - skb_headroom(skb);
1808 int osize = skb_end_offset(skb);
1809 struct sock *sk = skb->sk;
1810
1811 if (WARN_ONCE(delta <= 0,
1812 "%s is expecting an increase in the headroom", __func__))
1813 return skb;
1814
1815 delta = SKB_DATA_ALIGN(delta);
1816
1817 if (skb_shared(skb) || !is_skb_wmem(skb)) {
1818 struct sk_buff *nskb = skb_clone(skb, GFP_ATOMIC);
1819
1820 if (unlikely(!nskb))
1821 goto fail;
1822
1823 if (sk)
1824 skb_set_owner_w(nskb, sk);
1825 consume_skb(skb);
1826 skb = nskb;
1827 }
1828 if (pskb_expand_head(skb, delta, 0, GFP_ATOMIC))
1829 goto fail;
1830
1831 if (sk && is_skb_wmem(skb)) {
1832 delta = skb_end_offset(skb) - osize;
1833 refcount_add(delta, &sk->sk_wmem_alloc);
1834 skb->truesize += delta;
1835 }
1836 return skb;
1837
1838fail:
1839 kfree_skb(skb);
1840 return NULL;
1841}
1842EXPORT_SYMBOL(skb_expand_head);
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862struct sk_buff *skb_copy_expand(const struct sk_buff *skb,
1863 int newheadroom, int newtailroom,
1864 gfp_t gfp_mask)
1865{
1866
1867
1868
1869 struct sk_buff *n = __alloc_skb(newheadroom + skb->len + newtailroom,
1870 gfp_mask, skb_alloc_rx_flag(skb),
1871 NUMA_NO_NODE);
1872 int oldheadroom = skb_headroom(skb);
1873 int head_copy_len, head_copy_off;
1874
1875 if (!n)
1876 return NULL;
1877
1878 skb_reserve(n, newheadroom);
1879
1880
1881 skb_put(n, skb->len);
1882
1883 head_copy_len = oldheadroom;
1884 head_copy_off = 0;
1885 if (newheadroom <= head_copy_len)
1886 head_copy_len = newheadroom;
1887 else
1888 head_copy_off = newheadroom - head_copy_len;
1889
1890
1891 BUG_ON(skb_copy_bits(skb, -head_copy_len, n->head + head_copy_off,
1892 skb->len + head_copy_len));
1893
1894 skb_copy_header(n, skb);
1895
1896 skb_headers_offset_update(n, newheadroom - oldheadroom);
1897
1898 return n;
1899}
1900EXPORT_SYMBOL(skb_copy_expand);
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916int __skb_pad(struct sk_buff *skb, int pad, bool free_on_error)
1917{
1918 int err;
1919 int ntail;
1920
1921
1922 if (!skb_cloned(skb) && skb_tailroom(skb) >= pad) {
1923 memset(skb->data+skb->len, 0, pad);
1924 return 0;
1925 }
1926
1927 ntail = skb->data_len + pad - (skb->end - skb->tail);
1928 if (likely(skb_cloned(skb) || ntail > 0)) {
1929 err = pskb_expand_head(skb, 0, ntail, GFP_ATOMIC);
1930 if (unlikely(err))
1931 goto free_skb;
1932 }
1933
1934
1935
1936
1937 err = skb_linearize(skb);
1938 if (unlikely(err))
1939 goto free_skb;
1940
1941 memset(skb->data + skb->len, 0, pad);
1942 return 0;
1943
1944free_skb:
1945 if (free_on_error)
1946 kfree_skb(skb);
1947 return err;
1948}
1949EXPORT_SYMBOL(__skb_pad);
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964void *pskb_put(struct sk_buff *skb, struct sk_buff *tail, int len)
1965{
1966 if (tail != skb) {
1967 skb->data_len += len;
1968 skb->len += len;
1969 }
1970 return skb_put(tail, len);
1971}
1972EXPORT_SYMBOL_GPL(pskb_put);
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983void *skb_put(struct sk_buff *skb, unsigned int len)
1984{
1985 void *tmp = skb_tail_pointer(skb);
1986 SKB_LINEAR_ASSERT(skb);
1987 skb->tail += len;
1988 skb->len += len;
1989 if (unlikely(skb->tail > skb->end))
1990 skb_over_panic(skb, len, __builtin_return_address(0));
1991 return tmp;
1992}
1993EXPORT_SYMBOL(skb_put);
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004void *skb_push(struct sk_buff *skb, unsigned int len)
2005{
2006 skb->data -= len;
2007 skb->len += len;
2008 if (unlikely(skb->data < skb->head))
2009 skb_under_panic(skb, len, __builtin_return_address(0));
2010 return skb->data;
2011}
2012EXPORT_SYMBOL(skb_push);
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024void *skb_pull(struct sk_buff *skb, unsigned int len)
2025{
2026 return skb_pull_inline(skb, len);
2027}
2028EXPORT_SYMBOL(skb_pull);
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039void skb_trim(struct sk_buff *skb, unsigned int len)
2040{
2041 if (skb->len > len)
2042 __skb_trim(skb, len);
2043}
2044EXPORT_SYMBOL(skb_trim);
2045
2046
2047
2048
2049int ___pskb_trim(struct sk_buff *skb, unsigned int len)
2050{
2051 struct sk_buff **fragp;
2052 struct sk_buff *frag;
2053 int offset = skb_headlen(skb);
2054 int nfrags = skb_shinfo(skb)->nr_frags;
2055 int i;
2056 int err;
2057
2058 if (skb_cloned(skb) &&
2059 unlikely((err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC))))
2060 return err;
2061
2062 i = 0;
2063 if (offset >= len)
2064 goto drop_pages;
2065
2066 for (; i < nfrags; i++) {
2067 int end = offset + skb_frag_size(&skb_shinfo(skb)->frags[i]);
2068
2069 if (end < len) {
2070 offset = end;
2071 continue;
2072 }
2073
2074 skb_frag_size_set(&skb_shinfo(skb)->frags[i++], len - offset);
2075
2076drop_pages:
2077 skb_shinfo(skb)->nr_frags = i;
2078
2079 for (; i < nfrags; i++)
2080 skb_frag_unref(skb, i);
2081
2082 if (skb_has_frag_list(skb))
2083 skb_drop_fraglist(skb);
2084 goto done;
2085 }
2086
2087 for (fragp = &skb_shinfo(skb)->frag_list; (frag = *fragp);
2088 fragp = &frag->next) {
2089 int end = offset + frag->len;
2090
2091 if (skb_shared(frag)) {
2092 struct sk_buff *nfrag;
2093
2094 nfrag = skb_clone(frag, GFP_ATOMIC);
2095 if (unlikely(!nfrag))
2096 return -ENOMEM;
2097
2098 nfrag->next = frag->next;
2099 consume_skb(frag);
2100 frag = nfrag;
2101 *fragp = frag;
2102 }
2103
2104 if (end < len) {
2105 offset = end;
2106 continue;
2107 }
2108
2109 if (end > len &&
2110 unlikely((err = pskb_trim(frag, len - offset))))
2111 return err;
2112
2113 if (frag->next)
2114 skb_drop_list(&frag->next);
2115 break;
2116 }
2117
2118done:
2119 if (len > skb_headlen(skb)) {
2120 skb->data_len -= skb->len - len;
2121 skb->len = len;
2122 } else {
2123 skb->len = len;
2124 skb->data_len = 0;
2125 skb_set_tail_pointer(skb, len);
2126 }
2127
2128 if (!skb->sk || skb->destructor == sock_edemux)
2129 skb_condense(skb);
2130 return 0;
2131}
2132EXPORT_SYMBOL(___pskb_trim);
2133
2134
2135
2136int pskb_trim_rcsum_slow(struct sk_buff *skb, unsigned int len)
2137{
2138 if (skb->ip_summed == CHECKSUM_COMPLETE) {
2139 int delta = skb->len - len;
2140
2141 skb->csum = csum_block_sub(skb->csum,
2142 skb_checksum(skb, len, delta, 0),
2143 len);
2144 } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
2145 int hdlen = (len > skb_headlen(skb)) ? skb_headlen(skb) : len;
2146 int offset = skb_checksum_start_offset(skb) + skb->csum_offset;
2147
2148 if (offset + sizeof(__sum16) > hdlen)
2149 return -EINVAL;
2150 }
2151 return __pskb_trim(skb, len);
2152}
2153EXPORT_SYMBOL(pskb_trim_rcsum_slow);
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180void *__pskb_pull_tail(struct sk_buff *skb, int delta)
2181{
2182
2183
2184
2185
2186 int i, k, eat = (skb->tail + delta) - skb->end;
2187
2188 if (eat > 0 || skb_cloned(skb)) {
2189 if (pskb_expand_head(skb, 0, eat > 0 ? eat + 128 : 0,
2190 GFP_ATOMIC))
2191 return NULL;
2192 }
2193
2194 BUG_ON(skb_copy_bits(skb, skb_headlen(skb),
2195 skb_tail_pointer(skb), delta));
2196
2197
2198
2199
2200 if (!skb_has_frag_list(skb))
2201 goto pull_pages;
2202
2203
2204 eat = delta;
2205 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2206 int size = skb_frag_size(&skb_shinfo(skb)->frags[i]);
2207
2208 if (size >= eat)
2209 goto pull_pages;
2210 eat -= size;
2211 }
2212
2213
2214
2215
2216
2217
2218
2219
2220 if (eat) {
2221 struct sk_buff *list = skb_shinfo(skb)->frag_list;
2222 struct sk_buff *clone = NULL;
2223 struct sk_buff *insp = NULL;
2224
2225 do {
2226 if (list->len <= eat) {
2227
2228 eat -= list->len;
2229 list = list->next;
2230 insp = list;
2231 } else {
2232
2233
2234 if (skb_shared(list)) {
2235
2236 clone = skb_clone(list, GFP_ATOMIC);
2237 if (!clone)
2238 return NULL;
2239 insp = list->next;
2240 list = clone;
2241 } else {
2242
2243
2244 insp = list;
2245 }
2246 if (!pskb_pull(list, eat)) {
2247 kfree_skb(clone);
2248 return NULL;
2249 }
2250 break;
2251 }
2252 } while (eat);
2253
2254
2255 while ((list = skb_shinfo(skb)->frag_list) != insp) {
2256 skb_shinfo(skb)->frag_list = list->next;
2257 kfree_skb(list);
2258 }
2259
2260 if (clone) {
2261 clone->next = list;
2262 skb_shinfo(skb)->frag_list = clone;
2263 }
2264 }
2265
2266
2267pull_pages:
2268 eat = delta;
2269 k = 0;
2270 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2271 int size = skb_frag_size(&skb_shinfo(skb)->frags[i]);
2272
2273 if (size <= eat) {
2274 skb_frag_unref(skb, i);
2275 eat -= size;
2276 } else {
2277 skb_frag_t *frag = &skb_shinfo(skb)->frags[k];
2278
2279 *frag = skb_shinfo(skb)->frags[i];
2280 if (eat) {
2281 skb_frag_off_add(frag, eat);
2282 skb_frag_size_sub(frag, eat);
2283 if (!i)
2284 goto end;
2285 eat = 0;
2286 }
2287 k++;
2288 }
2289 }
2290 skb_shinfo(skb)->nr_frags = k;
2291
2292end:
2293 skb->tail += delta;
2294 skb->data_len -= delta;
2295
2296 if (!skb->data_len)
2297 skb_zcopy_clear(skb, false);
2298
2299 return skb_tail_pointer(skb);
2300}
2301EXPORT_SYMBOL(__pskb_pull_tail);
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318int skb_copy_bits(const struct sk_buff *skb, int offset, void *to, int len)
2319{
2320 int start = skb_headlen(skb);
2321 struct sk_buff *frag_iter;
2322 int i, copy;
2323
2324 if (offset > (int)skb->len - len)
2325 goto fault;
2326
2327
2328 if ((copy = start - offset) > 0) {
2329 if (copy > len)
2330 copy = len;
2331 skb_copy_from_linear_data_offset(skb, offset, to, copy);
2332 if ((len -= copy) == 0)
2333 return 0;
2334 offset += copy;
2335 to += copy;
2336 }
2337
2338 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2339 int end;
2340 skb_frag_t *f = &skb_shinfo(skb)->frags[i];
2341
2342 WARN_ON(start > offset + len);
2343
2344 end = start + skb_frag_size(f);
2345 if ((copy = end - offset) > 0) {
2346 u32 p_off, p_len, copied;
2347 struct page *p;
2348 u8 *vaddr;
2349
2350 if (copy > len)
2351 copy = len;
2352
2353 skb_frag_foreach_page(f,
2354 skb_frag_off(f) + offset - start,
2355 copy, p, p_off, p_len, copied) {
2356 vaddr = kmap_atomic(p);
2357 memcpy(to + copied, vaddr + p_off, p_len);
2358 kunmap_atomic(vaddr);
2359 }
2360
2361 if ((len -= copy) == 0)
2362 return 0;
2363 offset += copy;
2364 to += copy;
2365 }
2366 start = end;
2367 }
2368
2369 skb_walk_frags(skb, frag_iter) {
2370 int end;
2371
2372 WARN_ON(start > offset + len);
2373
2374 end = start + frag_iter->len;
2375 if ((copy = end - offset) > 0) {
2376 if (copy > len)
2377 copy = len;
2378 if (skb_copy_bits(frag_iter, offset - start, to, copy))
2379 goto fault;
2380 if ((len -= copy) == 0)
2381 return 0;
2382 offset += copy;
2383 to += copy;
2384 }
2385 start = end;
2386 }
2387
2388 if (!len)
2389 return 0;
2390
2391fault:
2392 return -EFAULT;
2393}
2394EXPORT_SYMBOL(skb_copy_bits);
2395
2396
2397
2398
2399
2400static void sock_spd_release(struct splice_pipe_desc *spd, unsigned int i)
2401{
2402 put_page(spd->pages[i]);
2403}
2404
2405static struct page *linear_to_page(struct page *page, unsigned int *len,
2406 unsigned int *offset,
2407 struct sock *sk)
2408{
2409 struct page_frag *pfrag = sk_page_frag(sk);
2410
2411 if (!sk_page_frag_refill(sk, pfrag))
2412 return NULL;
2413
2414 *len = min_t(unsigned int, *len, pfrag->size - pfrag->offset);
2415
2416 memcpy(page_address(pfrag->page) + pfrag->offset,
2417 page_address(page) + *offset, *len);
2418 *offset = pfrag->offset;
2419 pfrag->offset += *len;
2420
2421 return pfrag->page;
2422}
2423
2424static bool spd_can_coalesce(const struct splice_pipe_desc *spd,
2425 struct page *page,
2426 unsigned int offset)
2427{
2428 return spd->nr_pages &&
2429 spd->pages[spd->nr_pages - 1] == page &&
2430 (spd->partial[spd->nr_pages - 1].offset +
2431 spd->partial[spd->nr_pages - 1].len == offset);
2432}
2433
2434
2435
2436
2437static bool spd_fill_page(struct splice_pipe_desc *spd,
2438 struct pipe_inode_info *pipe, struct page *page,
2439 unsigned int *len, unsigned int offset,
2440 bool linear,
2441 struct sock *sk)
2442{
2443 if (unlikely(spd->nr_pages == MAX_SKB_FRAGS))
2444 return true;
2445
2446 if (linear) {
2447 page = linear_to_page(page, len, &offset, sk);
2448 if (!page)
2449 return true;
2450 }
2451 if (spd_can_coalesce(spd, page, offset)) {
2452 spd->partial[spd->nr_pages - 1].len += *len;
2453 return false;
2454 }
2455 get_page(page);
2456 spd->pages[spd->nr_pages] = page;
2457 spd->partial[spd->nr_pages].len = *len;
2458 spd->partial[spd->nr_pages].offset = offset;
2459 spd->nr_pages++;
2460
2461 return false;
2462}
2463
2464static bool __splice_segment(struct page *page, unsigned int poff,
2465 unsigned int plen, unsigned int *off,
2466 unsigned int *len,
2467 struct splice_pipe_desc *spd, bool linear,
2468 struct sock *sk,
2469 struct pipe_inode_info *pipe)
2470{
2471 if (!*len)
2472 return true;
2473
2474
2475 if (*off >= plen) {
2476 *off -= plen;
2477 return false;
2478 }
2479
2480
2481 poff += *off;
2482 plen -= *off;
2483 *off = 0;
2484
2485 do {
2486 unsigned int flen = min(*len, plen);
2487
2488 if (spd_fill_page(spd, pipe, page, &flen, poff,
2489 linear, sk))
2490 return true;
2491 poff += flen;
2492 plen -= flen;
2493 *len -= flen;
2494 } while (*len && plen);
2495
2496 return false;
2497}
2498
2499
2500
2501
2502
2503static bool __skb_splice_bits(struct sk_buff *skb, struct pipe_inode_info *pipe,
2504 unsigned int *offset, unsigned int *len,
2505 struct splice_pipe_desc *spd, struct sock *sk)
2506{
2507 int seg;
2508 struct sk_buff *iter;
2509
2510
2511
2512
2513
2514
2515 if (__splice_segment(virt_to_page(skb->data),
2516 (unsigned long) skb->data & (PAGE_SIZE - 1),
2517 skb_headlen(skb),
2518 offset, len, spd,
2519 skb_head_is_locked(skb),
2520 sk, pipe))
2521 return true;
2522
2523
2524
2525
2526 for (seg = 0; seg < skb_shinfo(skb)->nr_frags; seg++) {
2527 const skb_frag_t *f = &skb_shinfo(skb)->frags[seg];
2528
2529 if (__splice_segment(skb_frag_page(f),
2530 skb_frag_off(f), skb_frag_size(f),
2531 offset, len, spd, false, sk, pipe))
2532 return true;
2533 }
2534
2535 skb_walk_frags(skb, iter) {
2536 if (*offset >= iter->len) {
2537 *offset -= iter->len;
2538 continue;
2539 }
2540
2541
2542
2543
2544 if (__skb_splice_bits(iter, pipe, offset, len, spd, sk))
2545 return true;
2546 }
2547
2548 return false;
2549}
2550
2551
2552
2553
2554
2555int skb_splice_bits(struct sk_buff *skb, struct sock *sk, unsigned int offset,
2556 struct pipe_inode_info *pipe, unsigned int tlen,
2557 unsigned int flags)
2558{
2559 struct partial_page partial[MAX_SKB_FRAGS];
2560 struct page *pages[MAX_SKB_FRAGS];
2561 struct splice_pipe_desc spd = {
2562 .pages = pages,
2563 .partial = partial,
2564 .nr_pages_max = MAX_SKB_FRAGS,
2565 .ops = &nosteal_pipe_buf_ops,
2566 .spd_release = sock_spd_release,
2567 };
2568 int ret = 0;
2569
2570 __skb_splice_bits(skb, pipe, &offset, &tlen, &spd, sk);
2571
2572 if (spd.nr_pages)
2573 ret = splice_to_pipe(pipe, &spd);
2574
2575 return ret;
2576}
2577EXPORT_SYMBOL_GPL(skb_splice_bits);
2578
2579static int sendmsg_unlocked(struct sock *sk, struct msghdr *msg,
2580 struct kvec *vec, size_t num, size_t size)
2581{
2582 struct socket *sock = sk->sk_socket;
2583
2584 if (!sock)
2585 return -EINVAL;
2586 return kernel_sendmsg(sock, msg, vec, num, size);
2587}
2588
2589static int sendpage_unlocked(struct sock *sk, struct page *page, int offset,
2590 size_t size, int flags)
2591{
2592 struct socket *sock = sk->sk_socket;
2593
2594 if (!sock)
2595 return -EINVAL;
2596 return kernel_sendpage(sock, page, offset, size, flags);
2597}
2598
2599typedef int (*sendmsg_func)(struct sock *sk, struct msghdr *msg,
2600 struct kvec *vec, size_t num, size_t size);
2601typedef int (*sendpage_func)(struct sock *sk, struct page *page, int offset,
2602 size_t size, int flags);
2603static int __skb_send_sock(struct sock *sk, struct sk_buff *skb, int offset,
2604 int len, sendmsg_func sendmsg, sendpage_func sendpage)
2605{
2606 unsigned int orig_len = len;
2607 struct sk_buff *head = skb;
2608 unsigned short fragidx;
2609 int slen, ret;
2610
2611do_frag_list:
2612
2613
2614 while (offset < skb_headlen(skb) && len) {
2615 struct kvec kv;
2616 struct msghdr msg;
2617
2618 slen = min_t(int, len, skb_headlen(skb) - offset);
2619 kv.iov_base = skb->data + offset;
2620 kv.iov_len = slen;
2621 memset(&msg, 0, sizeof(msg));
2622 msg.msg_flags = MSG_DONTWAIT;
2623
2624 ret = INDIRECT_CALL_2(sendmsg, kernel_sendmsg_locked,
2625 sendmsg_unlocked, sk, &msg, &kv, 1, slen);
2626 if (ret <= 0)
2627 goto error;
2628
2629 offset += ret;
2630 len -= ret;
2631 }
2632
2633
2634 if (!len)
2635 goto out;
2636
2637
2638 offset -= skb_headlen(skb);
2639
2640
2641 for (fragidx = 0; fragidx < skb_shinfo(skb)->nr_frags; fragidx++) {
2642 skb_frag_t *frag = &skb_shinfo(skb)->frags[fragidx];
2643
2644 if (offset < skb_frag_size(frag))
2645 break;
2646
2647 offset -= skb_frag_size(frag);
2648 }
2649
2650 for (; len && fragidx < skb_shinfo(skb)->nr_frags; fragidx++) {
2651 skb_frag_t *frag = &skb_shinfo(skb)->frags[fragidx];
2652
2653 slen = min_t(size_t, len, skb_frag_size(frag) - offset);
2654
2655 while (slen) {
2656 ret = INDIRECT_CALL_2(sendpage, kernel_sendpage_locked,
2657 sendpage_unlocked, sk,
2658 skb_frag_page(frag),
2659 skb_frag_off(frag) + offset,
2660 slen, MSG_DONTWAIT);
2661 if (ret <= 0)
2662 goto error;
2663
2664 len -= ret;
2665 offset += ret;
2666 slen -= ret;
2667 }
2668
2669 offset = 0;
2670 }
2671
2672 if (len) {
2673
2674
2675 if (skb == head) {
2676 if (skb_has_frag_list(skb)) {
2677 skb = skb_shinfo(skb)->frag_list;
2678 goto do_frag_list;
2679 }
2680 } else if (skb->next) {
2681 skb = skb->next;
2682 goto do_frag_list;
2683 }
2684 }
2685
2686out:
2687 return orig_len - len;
2688
2689error:
2690 return orig_len == len ? ret : orig_len - len;
2691}
2692
2693
2694int skb_send_sock_locked(struct sock *sk, struct sk_buff *skb, int offset,
2695 int len)
2696{
2697 return __skb_send_sock(sk, skb, offset, len, kernel_sendmsg_locked,
2698 kernel_sendpage_locked);
2699}
2700EXPORT_SYMBOL_GPL(skb_send_sock_locked);
2701
2702
2703int skb_send_sock(struct sock *sk, struct sk_buff *skb, int offset, int len)
2704{
2705 return __skb_send_sock(sk, skb, offset, len, sendmsg_unlocked,
2706 sendpage_unlocked);
2707}
2708
2709
2710
2711
2712
2713
2714
2715
2716
2717
2718
2719
2720
2721int skb_store_bits(struct sk_buff *skb, int offset, const void *from, int len)
2722{
2723 int start = skb_headlen(skb);
2724 struct sk_buff *frag_iter;
2725 int i, copy;
2726
2727 if (offset > (int)skb->len - len)
2728 goto fault;
2729
2730 if ((copy = start - offset) > 0) {
2731 if (copy > len)
2732 copy = len;
2733 skb_copy_to_linear_data_offset(skb, offset, from, copy);
2734 if ((len -= copy) == 0)
2735 return 0;
2736 offset += copy;
2737 from += copy;
2738 }
2739
2740 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2741 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2742 int end;
2743
2744 WARN_ON(start > offset + len);
2745
2746 end = start + skb_frag_size(frag);
2747 if ((copy = end - offset) > 0) {
2748 u32 p_off, p_len, copied;
2749 struct page *p;
2750 u8 *vaddr;
2751
2752 if (copy > len)
2753 copy = len;
2754
2755 skb_frag_foreach_page(frag,
2756 skb_frag_off(frag) + offset - start,
2757 copy, p, p_off, p_len, copied) {
2758 vaddr = kmap_atomic(p);
2759 memcpy(vaddr + p_off, from + copied, p_len);
2760 kunmap_atomic(vaddr);
2761 }
2762
2763 if ((len -= copy) == 0)
2764 return 0;
2765 offset += copy;
2766 from += copy;
2767 }
2768 start = end;
2769 }
2770
2771 skb_walk_frags(skb, frag_iter) {
2772 int end;
2773
2774 WARN_ON(start > offset + len);
2775
2776 end = start + frag_iter->len;
2777 if ((copy = end - offset) > 0) {
2778 if (copy > len)
2779 copy = len;
2780 if (skb_store_bits(frag_iter, offset - start,
2781 from, copy))
2782 goto fault;
2783 if ((len -= copy) == 0)
2784 return 0;
2785 offset += copy;
2786 from += copy;
2787 }
2788 start = end;
2789 }
2790 if (!len)
2791 return 0;
2792
2793fault:
2794 return -EFAULT;
2795}
2796EXPORT_SYMBOL(skb_store_bits);
2797
2798
2799__wsum __skb_checksum(const struct sk_buff *skb, int offset, int len,
2800 __wsum csum, const struct skb_checksum_ops *ops)
2801{
2802 int start = skb_headlen(skb);
2803 int i, copy = start - offset;
2804 struct sk_buff *frag_iter;
2805 int pos = 0;
2806
2807
2808 if (copy > 0) {
2809 if (copy > len)
2810 copy = len;
2811 csum = INDIRECT_CALL_1(ops->update, csum_partial_ext,
2812 skb->data + offset, copy, csum);
2813 if ((len -= copy) == 0)
2814 return csum;
2815 offset += copy;
2816 pos = copy;
2817 }
2818
2819 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2820 int end;
2821 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2822
2823 WARN_ON(start > offset + len);
2824
2825 end = start + skb_frag_size(frag);
2826 if ((copy = end - offset) > 0) {
2827 u32 p_off, p_len, copied;
2828 struct page *p;
2829 __wsum csum2;
2830 u8 *vaddr;
2831
2832 if (copy > len)
2833 copy = len;
2834
2835 skb_frag_foreach_page(frag,
2836 skb_frag_off(frag) + offset - start,
2837 copy, p, p_off, p_len, copied) {
2838 vaddr = kmap_atomic(p);
2839 csum2 = INDIRECT_CALL_1(ops->update,
2840 csum_partial_ext,
2841 vaddr + p_off, p_len, 0);
2842 kunmap_atomic(vaddr);
2843 csum = INDIRECT_CALL_1(ops->combine,
2844 csum_block_add_ext, csum,
2845 csum2, pos, p_len);
2846 pos += p_len;
2847 }
2848
2849 if (!(len -= copy))
2850 return csum;
2851 offset += copy;
2852 }
2853 start = end;
2854 }
2855
2856 skb_walk_frags(skb, frag_iter) {
2857 int end;
2858
2859 WARN_ON(start > offset + len);
2860
2861 end = start + frag_iter->len;
2862 if ((copy = end - offset) > 0) {
2863 __wsum csum2;
2864 if (copy > len)
2865 copy = len;
2866 csum2 = __skb_checksum(frag_iter, offset - start,
2867 copy, 0, ops);
2868 csum = INDIRECT_CALL_1(ops->combine, csum_block_add_ext,
2869 csum, csum2, pos, copy);
2870 if ((len -= copy) == 0)
2871 return csum;
2872 offset += copy;
2873 pos += copy;
2874 }
2875 start = end;
2876 }
2877 BUG_ON(len);
2878
2879 return csum;
2880}
2881EXPORT_SYMBOL(__skb_checksum);
2882
2883__wsum skb_checksum(const struct sk_buff *skb, int offset,
2884 int len, __wsum csum)
2885{
2886 const struct skb_checksum_ops ops = {
2887 .update = csum_partial_ext,
2888 .combine = csum_block_add_ext,
2889 };
2890
2891 return __skb_checksum(skb, offset, len, csum, &ops);
2892}
2893EXPORT_SYMBOL(skb_checksum);
2894
2895
2896
2897__wsum skb_copy_and_csum_bits(const struct sk_buff *skb, int offset,
2898 u8 *to, int len)
2899{
2900 int start = skb_headlen(skb);
2901 int i, copy = start - offset;
2902 struct sk_buff *frag_iter;
2903 int pos = 0;
2904 __wsum csum = 0;
2905
2906
2907 if (copy > 0) {
2908 if (copy > len)
2909 copy = len;
2910 csum = csum_partial_copy_nocheck(skb->data + offset, to,
2911 copy);
2912 if ((len -= copy) == 0)
2913 return csum;
2914 offset += copy;
2915 to += copy;
2916 pos = copy;
2917 }
2918
2919 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2920 int end;
2921
2922 WARN_ON(start > offset + len);
2923
2924 end = start + skb_frag_size(&skb_shinfo(skb)->frags[i]);
2925 if ((copy = end - offset) > 0) {
2926 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2927 u32 p_off, p_len, copied;
2928 struct page *p;
2929 __wsum csum2;
2930 u8 *vaddr;
2931
2932 if (copy > len)
2933 copy = len;
2934
2935 skb_frag_foreach_page(frag,
2936 skb_frag_off(frag) + offset - start,
2937 copy, p, p_off, p_len, copied) {
2938 vaddr = kmap_atomic(p);
2939 csum2 = csum_partial_copy_nocheck(vaddr + p_off,
2940 to + copied,
2941 p_len);
2942 kunmap_atomic(vaddr);
2943 csum = csum_block_add(csum, csum2, pos);
2944 pos += p_len;
2945 }
2946
2947 if (!(len -= copy))
2948 return csum;
2949 offset += copy;
2950 to += copy;
2951 }
2952 start = end;
2953 }
2954
2955 skb_walk_frags(skb, frag_iter) {
2956 __wsum csum2;
2957 int end;
2958
2959 WARN_ON(start > offset + len);
2960
2961 end = start + frag_iter->len;
2962 if ((copy = end - offset) > 0) {
2963 if (copy > len)
2964 copy = len;
2965 csum2 = skb_copy_and_csum_bits(frag_iter,
2966 offset - start,
2967 to, copy);
2968 csum = csum_block_add(csum, csum2, pos);
2969 if ((len -= copy) == 0)
2970 return csum;
2971 offset += copy;
2972 to += copy;
2973 pos += copy;
2974 }
2975 start = end;
2976 }
2977 BUG_ON(len);
2978 return csum;
2979}
2980EXPORT_SYMBOL(skb_copy_and_csum_bits);
2981
2982__sum16 __skb_checksum_complete_head(struct sk_buff *skb, int len)
2983{
2984 __sum16 sum;
2985
2986 sum = csum_fold(skb_checksum(skb, 0, len, skb->csum));
2987
2988 if (likely(!sum)) {
2989 if (unlikely(skb->ip_summed == CHECKSUM_COMPLETE) &&
2990 !skb->csum_complete_sw)
2991 netdev_rx_csum_fault(skb->dev, skb);
2992 }
2993 if (!skb_shared(skb))
2994 skb->csum_valid = !sum;
2995 return sum;
2996}
2997EXPORT_SYMBOL(__skb_checksum_complete_head);
2998
2999
3000
3001
3002
3003
3004
3005
3006
3007
3008__sum16 __skb_checksum_complete(struct sk_buff *skb)
3009{
3010 __wsum csum;
3011 __sum16 sum;
3012
3013 csum = skb_checksum(skb, 0, skb->len, 0);
3014
3015 sum = csum_fold(csum_add(skb->csum, csum));
3016
3017
3018
3019
3020
3021
3022
3023 if (likely(!sum)) {
3024 if (unlikely(skb->ip_summed == CHECKSUM_COMPLETE) &&
3025 !skb->csum_complete_sw)
3026 netdev_rx_csum_fault(skb->dev, skb);
3027 }
3028
3029 if (!skb_shared(skb)) {
3030
3031 skb->csum = csum;
3032 skb->ip_summed = CHECKSUM_COMPLETE;
3033 skb->csum_complete_sw = 1;
3034 skb->csum_valid = !sum;
3035 }
3036
3037 return sum;
3038}
3039EXPORT_SYMBOL(__skb_checksum_complete);
3040
3041static __wsum warn_crc32c_csum_update(const void *buff, int len, __wsum sum)
3042{
3043 net_warn_ratelimited(
3044 "%s: attempt to compute crc32c without libcrc32c.ko\n",
3045 __func__);
3046 return 0;
3047}
3048
3049static __wsum warn_crc32c_csum_combine(__wsum csum, __wsum csum2,
3050 int offset, int len)
3051{
3052 net_warn_ratelimited(
3053 "%s: attempt to compute crc32c without libcrc32c.ko\n",
3054 __func__);
3055 return 0;
3056}
3057
3058static const struct skb_checksum_ops default_crc32c_ops = {
3059 .update = warn_crc32c_csum_update,
3060 .combine = warn_crc32c_csum_combine,
3061};
3062
3063const struct skb_checksum_ops *crc32c_csum_stub __read_mostly =
3064 &default_crc32c_ops;
3065EXPORT_SYMBOL(crc32c_csum_stub);
3066
3067
3068
3069
3070
3071
3072
3073
3074unsigned int
3075skb_zerocopy_headlen(const struct sk_buff *from)
3076{
3077 unsigned int hlen = 0;
3078
3079 if (!from->head_frag ||
3080 skb_headlen(from) < L1_CACHE_BYTES ||
3081 skb_shinfo(from)->nr_frags >= MAX_SKB_FRAGS) {
3082 hlen = skb_headlen(from);
3083 if (!hlen)
3084 hlen = from->len;
3085 }
3086
3087 if (skb_has_frag_list(from))
3088 hlen = from->len;
3089
3090 return hlen;
3091}
3092EXPORT_SYMBOL_GPL(skb_zerocopy_headlen);
3093
3094
3095
3096
3097
3098
3099
3100
3101
3102
3103
3104
3105
3106
3107
3108
3109
3110
3111
3112int
3113skb_zerocopy(struct sk_buff *to, struct sk_buff *from, int len, int hlen)
3114{
3115 int i, j = 0;
3116 int plen = 0;
3117 int ret;
3118 struct page *page;
3119 unsigned int offset;
3120
3121 BUG_ON(!from->head_frag && !hlen);
3122
3123
3124 if (len <= skb_tailroom(to))
3125 return skb_copy_bits(from, 0, skb_put(to, len), len);
3126
3127 if (hlen) {
3128 ret = skb_copy_bits(from, 0, skb_put(to, hlen), hlen);
3129 if (unlikely(ret))
3130 return ret;
3131 len -= hlen;
3132 } else {
3133 plen = min_t(int, skb_headlen(from), len);
3134 if (plen) {
3135 page = virt_to_head_page(from->head);
3136 offset = from->data - (unsigned char *)page_address(page);
3137 __skb_fill_page_desc(to, 0, page, offset, plen);
3138 get_page(page);
3139 j = 1;
3140 len -= plen;
3141 }
3142 }
3143
3144 to->truesize += len + plen;
3145 to->len += len + plen;
3146 to->data_len += len + plen;
3147
3148 if (unlikely(skb_orphan_frags(from, GFP_ATOMIC))) {
3149 skb_tx_error(from);
3150 return -ENOMEM;
3151 }
3152 skb_zerocopy_clone(to, from, GFP_ATOMIC);
3153
3154 for (i = 0; i < skb_shinfo(from)->nr_frags; i++) {
3155 int size;
3156
3157 if (!len)
3158 break;
3159 skb_shinfo(to)->frags[j] = skb_shinfo(from)->frags[i];
3160 size = min_t(int, skb_frag_size(&skb_shinfo(to)->frags[j]),
3161 len);
3162 skb_frag_size_set(&skb_shinfo(to)->frags[j], size);
3163 len -= size;
3164 skb_frag_ref(to, j);
3165 j++;
3166 }
3167 skb_shinfo(to)->nr_frags = j;
3168
3169 return 0;
3170}
3171EXPORT_SYMBOL_GPL(skb_zerocopy);
3172
3173void skb_copy_and_csum_dev(const struct sk_buff *skb, u8 *to)
3174{
3175 __wsum csum;
3176 long csstart;
3177
3178 if (skb->ip_summed == CHECKSUM_PARTIAL)
3179 csstart = skb_checksum_start_offset(skb);
3180 else
3181 csstart = skb_headlen(skb);
3182
3183 BUG_ON(csstart > skb_headlen(skb));
3184
3185 skb_copy_from_linear_data(skb, to, csstart);
3186
3187 csum = 0;
3188 if (csstart != skb->len)
3189 csum = skb_copy_and_csum_bits(skb, csstart, to + csstart,
3190 skb->len - csstart);
3191
3192 if (skb->ip_summed == CHECKSUM_PARTIAL) {
3193 long csstuff = csstart + skb->csum_offset;
3194
3195 *((__sum16 *)(to + csstuff)) = csum_fold(csum);
3196 }
3197}
3198EXPORT_SYMBOL(skb_copy_and_csum_dev);
3199
3200
3201
3202
3203
3204
3205
3206
3207
3208
3209struct sk_buff *skb_dequeue(struct sk_buff_head *list)
3210{
3211 unsigned long flags;
3212 struct sk_buff *result;
3213
3214 spin_lock_irqsave(&list->lock, flags);
3215 result = __skb_dequeue(list);
3216 spin_unlock_irqrestore(&list->lock, flags);
3217 return result;
3218}
3219EXPORT_SYMBOL(skb_dequeue);
3220
3221
3222
3223
3224
3225
3226
3227
3228
3229struct sk_buff *skb_dequeue_tail(struct sk_buff_head *list)
3230{
3231 unsigned long flags;
3232 struct sk_buff *result;
3233
3234 spin_lock_irqsave(&list->lock, flags);
3235 result = __skb_dequeue_tail(list);
3236 spin_unlock_irqrestore(&list->lock, flags);
3237 return result;
3238}
3239EXPORT_SYMBOL(skb_dequeue_tail);
3240
3241
3242
3243
3244
3245
3246
3247
3248
3249void skb_queue_purge(struct sk_buff_head *list)
3250{
3251 struct sk_buff *skb;
3252 while ((skb = skb_dequeue(list)) != NULL)
3253 kfree_skb(skb);
3254}
3255EXPORT_SYMBOL(skb_queue_purge);
3256
3257
3258
3259
3260
3261
3262
3263
3264
3265
3266
3267unsigned int skb_rbtree_purge(struct rb_root *root)
3268{
3269 struct rb_node *p = rb_first(root);
3270 unsigned int sum = 0;
3271
3272 while (p) {
3273 struct sk_buff *skb = rb_entry(p, struct sk_buff, rbnode);
3274
3275 p = rb_next(p);
3276 rb_erase(&skb->rbnode, root);
3277 sum += skb->truesize;
3278 kfree_skb(skb);
3279 }
3280 return sum;
3281}
3282
3283
3284
3285
3286
3287
3288
3289
3290
3291
3292
3293
3294void skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk)
3295{
3296 unsigned long flags;
3297
3298 spin_lock_irqsave(&list->lock, flags);
3299 __skb_queue_head(list, newsk);
3300 spin_unlock_irqrestore(&list->lock, flags);
3301}
3302EXPORT_SYMBOL(skb_queue_head);
3303
3304
3305
3306
3307
3308
3309
3310
3311
3312
3313
3314
3315void skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk)
3316{
3317 unsigned long flags;
3318
3319 spin_lock_irqsave(&list->lock, flags);
3320 __skb_queue_tail(list, newsk);
3321 spin_unlock_irqrestore(&list->lock, flags);
3322}
3323EXPORT_SYMBOL(skb_queue_tail);
3324
3325
3326
3327
3328
3329
3330
3331
3332
3333
3334
3335void skb_unlink(struct sk_buff *skb, struct sk_buff_head *list)
3336{
3337 unsigned long flags;
3338
3339 spin_lock_irqsave(&list->lock, flags);
3340 __skb_unlink(skb, list);
3341 spin_unlock_irqrestore(&list->lock, flags);
3342}
3343EXPORT_SYMBOL(skb_unlink);
3344
3345
3346
3347
3348
3349
3350
3351
3352
3353
3354
3355void skb_append(struct sk_buff *old, struct sk_buff *newsk, struct sk_buff_head *list)
3356{
3357 unsigned long flags;
3358
3359 spin_lock_irqsave(&list->lock, flags);
3360 __skb_queue_after(list, old, newsk);
3361 spin_unlock_irqrestore(&list->lock, flags);
3362}
3363EXPORT_SYMBOL(skb_append);
3364
3365static inline void skb_split_inside_header(struct sk_buff *skb,
3366 struct sk_buff* skb1,
3367 const u32 len, const int pos)
3368{
3369 int i;
3370
3371 skb_copy_from_linear_data_offset(skb, len, skb_put(skb1, pos - len),
3372 pos - len);
3373
3374 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
3375 skb_shinfo(skb1)->frags[i] = skb_shinfo(skb)->frags[i];
3376
3377 skb_shinfo(skb1)->nr_frags = skb_shinfo(skb)->nr_frags;
3378 skb_shinfo(skb)->nr_frags = 0;
3379 skb1->data_len = skb->data_len;
3380 skb1->len += skb1->data_len;
3381 skb->data_len = 0;
3382 skb->len = len;
3383 skb_set_tail_pointer(skb, len);
3384}
3385
3386static inline void skb_split_no_header(struct sk_buff *skb,
3387 struct sk_buff* skb1,
3388 const u32 len, int pos)
3389{
3390 int i, k = 0;
3391 const int nfrags = skb_shinfo(skb)->nr_frags;
3392
3393 skb_shinfo(skb)->nr_frags = 0;
3394 skb1->len = skb1->data_len = skb->len - len;
3395 skb->len = len;
3396 skb->data_len = len - pos;
3397
3398 for (i = 0; i < nfrags; i++) {
3399 int size = skb_frag_size(&skb_shinfo(skb)->frags[i]);
3400
3401 if (pos + size > len) {
3402 skb_shinfo(skb1)->frags[k] = skb_shinfo(skb)->frags[i];
3403
3404 if (pos < len) {
3405
3406
3407
3408
3409
3410
3411
3412
3413 skb_frag_ref(skb, i);
3414 skb_frag_off_add(&skb_shinfo(skb1)->frags[0], len - pos);
3415 skb_frag_size_sub(&skb_shinfo(skb1)->frags[0], len - pos);
3416 skb_frag_size_set(&skb_shinfo(skb)->frags[i], len - pos);
3417 skb_shinfo(skb)->nr_frags++;
3418 }
3419 k++;
3420 } else
3421 skb_shinfo(skb)->nr_frags++;
3422 pos += size;
3423 }
3424 skb_shinfo(skb1)->nr_frags = k;
3425}
3426
3427
3428
3429
3430
3431
3432
3433void skb_split(struct sk_buff *skb, struct sk_buff *skb1, const u32 len)
3434{
3435 int pos = skb_headlen(skb);
3436
3437 skb_shinfo(skb1)->flags |= skb_shinfo(skb)->flags & SKBFL_SHARED_FRAG;
3438 skb_zerocopy_clone(skb1, skb, 0);
3439 if (len < pos)
3440 skb_split_inside_header(skb, skb1, len, pos);
3441 else
3442 skb_split_no_header(skb, skb1, len, pos);
3443}
3444EXPORT_SYMBOL(skb_split);
3445
3446
3447
3448
3449
3450static int skb_prepare_for_shift(struct sk_buff *skb)
3451{
3452 int ret = 0;
3453
3454 if (skb_cloned(skb)) {
3455
3456
3457
3458
3459 unsigned int save_truesize = skb->truesize;
3460
3461 ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
3462 skb->truesize = save_truesize;
3463 }
3464 return ret;
3465}
3466
3467
3468
3469
3470
3471
3472
3473
3474
3475
3476
3477
3478
3479
3480
3481
3482
3483
3484
3485int skb_shift(struct sk_buff *tgt, struct sk_buff *skb, int shiftlen)
3486{
3487 int from, to, merge, todo;
3488 skb_frag_t *fragfrom, *fragto;
3489
3490 BUG_ON(shiftlen > skb->len);
3491
3492 if (skb_headlen(skb))
3493 return 0;
3494 if (skb_zcopy(tgt) || skb_zcopy(skb))
3495 return 0;
3496
3497 todo = shiftlen;
3498 from = 0;
3499 to = skb_shinfo(tgt)->nr_frags;
3500 fragfrom = &skb_shinfo(skb)->frags[from];
3501
3502
3503
3504
3505 if (!to ||
3506 !skb_can_coalesce(tgt, to, skb_frag_page(fragfrom),
3507 skb_frag_off(fragfrom))) {
3508 merge = -1;
3509 } else {
3510 merge = to - 1;
3511
3512 todo -= skb_frag_size(fragfrom);
3513 if (todo < 0) {
3514 if (skb_prepare_for_shift(skb) ||
3515 skb_prepare_for_shift(tgt))
3516 return 0;
3517
3518
3519 fragfrom = &skb_shinfo(skb)->frags[from];
3520 fragto = &skb_shinfo(tgt)->frags[merge];
3521
3522 skb_frag_size_add(fragto, shiftlen);
3523 skb_frag_size_sub(fragfrom, shiftlen);
3524 skb_frag_off_add(fragfrom, shiftlen);
3525
3526 goto onlymerged;
3527 }
3528
3529 from++;
3530 }
3531
3532
3533 if ((shiftlen == skb->len) &&
3534 (skb_shinfo(skb)->nr_frags - from) > (MAX_SKB_FRAGS - to))
3535 return 0;
3536
3537 if (skb_prepare_for_shift(skb) || skb_prepare_for_shift(tgt))
3538 return 0;
3539
3540 while ((todo > 0) && (from < skb_shinfo(skb)->nr_frags)) {
3541 if (to == MAX_SKB_FRAGS)
3542 return 0;
3543
3544 fragfrom = &skb_shinfo(skb)->frags[from];
3545 fragto = &skb_shinfo(tgt)->frags[to];
3546
3547 if (todo >= skb_frag_size(fragfrom)) {
3548 *fragto = *fragfrom;
3549 todo -= skb_frag_size(fragfrom);
3550 from++;
3551 to++;
3552
3553 } else {
3554 __skb_frag_ref(fragfrom);
3555 skb_frag_page_copy(fragto, fragfrom);
3556 skb_frag_off_copy(fragto, fragfrom);
3557 skb_frag_size_set(fragto, todo);
3558
3559 skb_frag_off_add(fragfrom, todo);
3560 skb_frag_size_sub(fragfrom, todo);
3561 todo = 0;
3562
3563 to++;
3564 break;
3565 }
3566 }
3567
3568
3569 skb_shinfo(tgt)->nr_frags = to;
3570
3571 if (merge >= 0) {
3572 fragfrom = &skb_shinfo(skb)->frags[0];
3573 fragto = &skb_shinfo(tgt)->frags[merge];
3574
3575 skb_frag_size_add(fragto, skb_frag_size(fragfrom));
3576 __skb_frag_unref(fragfrom, skb->pp_recycle);
3577 }
3578
3579
3580 to = 0;
3581 while (from < skb_shinfo(skb)->nr_frags)
3582 skb_shinfo(skb)->frags[to++] = skb_shinfo(skb)->frags[from++];
3583 skb_shinfo(skb)->nr_frags = to;
3584
3585 BUG_ON(todo > 0 && !skb_shinfo(skb)->nr_frags);
3586
3587onlymerged:
3588
3589
3590
3591 tgt->ip_summed = CHECKSUM_PARTIAL;
3592 skb->ip_summed = CHECKSUM_PARTIAL;
3593
3594
3595 skb->len -= shiftlen;
3596 skb->data_len -= shiftlen;
3597 skb->truesize -= shiftlen;
3598 tgt->len += shiftlen;
3599 tgt->data_len += shiftlen;
3600 tgt->truesize += shiftlen;
3601
3602 return shiftlen;
3603}
3604
3605
3606
3607
3608
3609
3610
3611
3612
3613
3614
3615void skb_prepare_seq_read(struct sk_buff *skb, unsigned int from,
3616 unsigned int to, struct skb_seq_state *st)
3617{
3618 st->lower_offset = from;
3619 st->upper_offset = to;
3620 st->root_skb = st->cur_skb = skb;
3621 st->frag_idx = st->stepped_offset = 0;
3622 st->frag_data = NULL;
3623 st->frag_off = 0;
3624}
3625EXPORT_SYMBOL(skb_prepare_seq_read);
3626
3627
3628
3629
3630
3631
3632
3633
3634
3635
3636
3637
3638
3639
3640
3641
3642
3643
3644
3645
3646
3647
3648
3649
3650
3651
3652unsigned int skb_seq_read(unsigned int consumed, const u8 **data,
3653 struct skb_seq_state *st)
3654{
3655 unsigned int block_limit, abs_offset = consumed + st->lower_offset;
3656 skb_frag_t *frag;
3657
3658 if (unlikely(abs_offset >= st->upper_offset)) {
3659 if (st->frag_data) {
3660 kunmap_atomic(st->frag_data);
3661 st->frag_data = NULL;
3662 }
3663 return 0;
3664 }
3665
3666next_skb:
3667 block_limit = skb_headlen(st->cur_skb) + st->stepped_offset;
3668
3669 if (abs_offset < block_limit && !st->frag_data) {
3670 *data = st->cur_skb->data + (abs_offset - st->stepped_offset);
3671 return block_limit - abs_offset;
3672 }
3673
3674 if (st->frag_idx == 0 && !st->frag_data)
3675 st->stepped_offset += skb_headlen(st->cur_skb);
3676
3677 while (st->frag_idx < skb_shinfo(st->cur_skb)->nr_frags) {
3678 unsigned int pg_idx, pg_off, pg_sz;
3679
3680 frag = &skb_shinfo(st->cur_skb)->frags[st->frag_idx];
3681
3682 pg_idx = 0;
3683 pg_off = skb_frag_off(frag);
3684 pg_sz = skb_frag_size(frag);
3685
3686 if (skb_frag_must_loop(skb_frag_page(frag))) {
3687 pg_idx = (pg_off + st->frag_off) >> PAGE_SHIFT;
3688 pg_off = offset_in_page(pg_off + st->frag_off);
3689 pg_sz = min_t(unsigned int, pg_sz - st->frag_off,
3690 PAGE_SIZE - pg_off);
3691 }
3692
3693 block_limit = pg_sz + st->stepped_offset;
3694 if (abs_offset < block_limit) {
3695 if (!st->frag_data)
3696 st->frag_data = kmap_atomic(skb_frag_page(frag) + pg_idx);
3697
3698 *data = (u8 *)st->frag_data + pg_off +
3699 (abs_offset - st->stepped_offset);
3700
3701 return block_limit - abs_offset;
3702 }
3703
3704 if (st->frag_data) {
3705 kunmap_atomic(st->frag_data);
3706 st->frag_data = NULL;
3707 }
3708
3709 st->stepped_offset += pg_sz;
3710 st->frag_off += pg_sz;
3711 if (st->frag_off == skb_frag_size(frag)) {
3712 st->frag_off = 0;
3713 st->frag_idx++;
3714 }
3715 }
3716
3717 if (st->frag_data) {
3718 kunmap_atomic(st->frag_data);
3719 st->frag_data = NULL;
3720 }
3721
3722 if (st->root_skb == st->cur_skb && skb_has_frag_list(st->root_skb)) {
3723 st->cur_skb = skb_shinfo(st->root_skb)->frag_list;
3724 st->frag_idx = 0;
3725 goto next_skb;
3726 } else if (st->cur_skb->next) {
3727 st->cur_skb = st->cur_skb->next;
3728 st->frag_idx = 0;
3729 goto next_skb;
3730 }
3731
3732 return 0;
3733}
3734EXPORT_SYMBOL(skb_seq_read);
3735
3736
3737
3738
3739
3740
3741
3742
3743void skb_abort_seq_read(struct skb_seq_state *st)
3744{
3745 if (st->frag_data)
3746 kunmap_atomic(st->frag_data);
3747}
3748EXPORT_SYMBOL(skb_abort_seq_read);
3749
3750#define TS_SKB_CB(state) ((struct skb_seq_state *) &((state)->cb))
3751
3752static unsigned int skb_ts_get_next_block(unsigned int offset, const u8 **text,
3753 struct ts_config *conf,
3754 struct ts_state *state)
3755{
3756 return skb_seq_read(offset, text, TS_SKB_CB(state));
3757}
3758
3759static void skb_ts_finish(struct ts_config *conf, struct ts_state *state)
3760{
3761 skb_abort_seq_read(TS_SKB_CB(state));
3762}
3763
3764
3765
3766
3767
3768
3769
3770
3771
3772
3773
3774
3775
3776unsigned int skb_find_text(struct sk_buff *skb, unsigned int from,
3777 unsigned int to, struct ts_config *config)
3778{
3779 struct ts_state state;
3780 unsigned int ret;
3781
3782 BUILD_BUG_ON(sizeof(struct skb_seq_state) > sizeof(state.cb));
3783
3784 config->get_next_block = skb_ts_get_next_block;
3785 config->finish = skb_ts_finish;
3786
3787 skb_prepare_seq_read(skb, from, to, TS_SKB_CB(&state));
3788
3789 ret = textsearch_find(config, &state);
3790 return (ret <= to - from ? ret : UINT_MAX);
3791}
3792EXPORT_SYMBOL(skb_find_text);
3793
3794int skb_append_pagefrags(struct sk_buff *skb, struct page *page,
3795 int offset, size_t size)
3796{
3797 int i = skb_shinfo(skb)->nr_frags;
3798
3799 if (skb_can_coalesce(skb, i, page, offset)) {
3800 skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], size);
3801 } else if (i < MAX_SKB_FRAGS) {
3802 get_page(page);
3803 skb_fill_page_desc(skb, i, page, offset, size);
3804 } else {
3805 return -EMSGSIZE;
3806 }
3807
3808 return 0;
3809}
3810EXPORT_SYMBOL_GPL(skb_append_pagefrags);
3811
3812
3813
3814
3815
3816
3817
3818
3819
3820
3821
3822
3823void *skb_pull_rcsum(struct sk_buff *skb, unsigned int len)
3824{
3825 unsigned char *data = skb->data;
3826
3827 BUG_ON(len > skb->len);
3828 __skb_pull(skb, len);
3829 skb_postpull_rcsum(skb, data, len);
3830 return skb->data;
3831}
3832EXPORT_SYMBOL_GPL(skb_pull_rcsum);
3833
3834static inline skb_frag_t skb_head_frag_to_page_desc(struct sk_buff *frag_skb)
3835{
3836 skb_frag_t head_frag;
3837 struct page *page;
3838
3839 page = virt_to_head_page(frag_skb->head);
3840 __skb_frag_set_page(&head_frag, page);
3841 skb_frag_off_set(&head_frag, frag_skb->data -
3842 (unsigned char *)page_address(page));
3843 skb_frag_size_set(&head_frag, skb_headlen(frag_skb));
3844 return head_frag;
3845}
3846
3847struct sk_buff *skb_segment_list(struct sk_buff *skb,
3848 netdev_features_t features,
3849 unsigned int offset)
3850{
3851 struct sk_buff *list_skb = skb_shinfo(skb)->frag_list;
3852 unsigned int tnl_hlen = skb_tnl_header_len(skb);
3853 unsigned int delta_truesize = 0;
3854 unsigned int delta_len = 0;
3855 struct sk_buff *tail = NULL;
3856 struct sk_buff *nskb, *tmp;
3857 int err;
3858
3859 skb_push(skb, -skb_network_offset(skb) + offset);
3860
3861 skb_shinfo(skb)->frag_list = NULL;
3862
3863 do {
3864 nskb = list_skb;
3865 list_skb = list_skb->next;
3866
3867 err = 0;
3868 if (skb_shared(nskb)) {
3869 tmp = skb_clone(nskb, GFP_ATOMIC);
3870 if (tmp) {
3871 consume_skb(nskb);
3872 nskb = tmp;
3873 err = skb_unclone(nskb, GFP_ATOMIC);
3874 } else {
3875 err = -ENOMEM;
3876 }
3877 }
3878
3879 if (!tail)
3880 skb->next = nskb;
3881 else
3882 tail->next = nskb;
3883
3884 if (unlikely(err)) {
3885 nskb->next = list_skb;
3886 goto err_linearize;
3887 }
3888
3889 tail = nskb;
3890
3891 delta_len += nskb->len;
3892 delta_truesize += nskb->truesize;
3893
3894 skb_push(nskb, -skb_network_offset(nskb) + offset);
3895
3896 skb_release_head_state(nskb);
3897 __copy_skb_header(nskb, skb);
3898
3899 skb_headers_offset_update(nskb, skb_headroom(nskb) - skb_headroom(skb));
3900 skb_copy_from_linear_data_offset(skb, -tnl_hlen,
3901 nskb->data - tnl_hlen,
3902 offset + tnl_hlen);
3903
3904 if (skb_needs_linearize(nskb, features) &&
3905 __skb_linearize(nskb))
3906 goto err_linearize;
3907
3908 } while (list_skb);
3909
3910 skb->truesize = skb->truesize - delta_truesize;
3911 skb->data_len = skb->data_len - delta_len;
3912 skb->len = skb->len - delta_len;
3913
3914 skb_gso_reset(skb);
3915
3916 skb->prev = tail;
3917
3918 if (skb_needs_linearize(skb, features) &&
3919 __skb_linearize(skb))
3920 goto err_linearize;
3921
3922 skb_get(skb);
3923
3924 return skb;
3925
3926err_linearize:
3927 kfree_skb_list(skb->next);
3928 skb->next = NULL;
3929 return ERR_PTR(-ENOMEM);
3930}
3931EXPORT_SYMBOL_GPL(skb_segment_list);
3932
3933int skb_gro_receive_list(struct sk_buff *p, struct sk_buff *skb)
3934{
3935 if (unlikely(p->len + skb->len >= 65536))
3936 return -E2BIG;
3937
3938 if (NAPI_GRO_CB(p)->last == p)
3939 skb_shinfo(p)->frag_list = skb;
3940 else
3941 NAPI_GRO_CB(p)->last->next = skb;
3942
3943 skb_pull(skb, skb_gro_offset(skb));
3944
3945 NAPI_GRO_CB(p)->last = skb;
3946 NAPI_GRO_CB(p)->count++;
3947 p->data_len += skb->len;
3948
3949
3950 skb->destructor = NULL;
3951 p->truesize += skb->truesize;
3952 p->len += skb->len;
3953
3954 NAPI_GRO_CB(skb)->same_flow = 1;
3955
3956 return 0;
3957}
3958
3959
3960
3961
3962
3963
3964
3965
3966
3967
3968struct sk_buff *skb_segment(struct sk_buff *head_skb,
3969 netdev_features_t features)
3970{
3971 struct sk_buff *segs = NULL;
3972 struct sk_buff *tail = NULL;
3973 struct sk_buff *list_skb = skb_shinfo(head_skb)->frag_list;
3974 skb_frag_t *frag = skb_shinfo(head_skb)->frags;
3975 unsigned int mss = skb_shinfo(head_skb)->gso_size;
3976 unsigned int doffset = head_skb->data - skb_mac_header(head_skb);
3977 struct sk_buff *frag_skb = head_skb;
3978 unsigned int offset = doffset;
3979 unsigned int tnl_hlen = skb_tnl_header_len(head_skb);
3980 unsigned int partial_segs = 0;
3981 unsigned int headroom;
3982 unsigned int len = head_skb->len;
3983 __be16 proto;
3984 bool csum, sg;
3985 int nfrags = skb_shinfo(head_skb)->nr_frags;
3986 int err = -ENOMEM;
3987 int i = 0;
3988 int pos;
3989
3990 if (list_skb && !list_skb->head_frag && skb_headlen(list_skb) &&
3991 (skb_shinfo(head_skb)->gso_type & SKB_GSO_DODGY)) {
3992
3993
3994
3995
3996
3997
3998
3999
4000
4001
4002
4003
4004
4005 if (mss != GSO_BY_FRAGS && mss != skb_headlen(head_skb))
4006 features &= ~NETIF_F_SG;
4007 }
4008
4009 __skb_push(head_skb, doffset);
4010 proto = skb_network_protocol(head_skb, NULL);
4011 if (unlikely(!proto))
4012 return ERR_PTR(-EINVAL);
4013
4014 sg = !!(features & NETIF_F_SG);
4015 csum = !!can_checksum_protocol(features, proto);
4016
4017 if (sg && csum && (mss != GSO_BY_FRAGS)) {
4018 if (!(features & NETIF_F_GSO_PARTIAL)) {
4019 struct sk_buff *iter;
4020 unsigned int frag_len;
4021
4022 if (!list_skb ||
4023 !net_gso_ok(features, skb_shinfo(head_skb)->gso_type))
4024 goto normal;
4025
4026
4027
4028
4029
4030
4031
4032
4033
4034 frag_len = list_skb->len;
4035 skb_walk_frags(head_skb, iter) {
4036 if (frag_len != iter->len && iter->next)
4037 goto normal;
4038 if (skb_headlen(iter) && !iter->head_frag)
4039 goto normal;
4040
4041 len -= iter->len;
4042 }
4043
4044 if (len != frag_len)
4045 goto normal;
4046 }
4047
4048
4049
4050
4051
4052 partial_segs = len / mss;
4053 if (partial_segs > 1)
4054 mss *= partial_segs;
4055 else
4056 partial_segs = 0;
4057 }
4058
4059normal:
4060 headroom = skb_headroom(head_skb);
4061 pos = skb_headlen(head_skb);
4062
4063 do {
4064 struct sk_buff *nskb;
4065 skb_frag_t *nskb_frag;
4066 int hsize;
4067 int size;
4068
4069 if (unlikely(mss == GSO_BY_FRAGS)) {
4070 len = list_skb->len;
4071 } else {
4072 len = head_skb->len - offset;
4073 if (len > mss)
4074 len = mss;
4075 }
4076
4077 hsize = skb_headlen(head_skb) - offset;
4078
4079 if (hsize <= 0 && i >= nfrags && skb_headlen(list_skb) &&
4080 (skb_headlen(list_skb) == len || sg)) {
4081 BUG_ON(skb_headlen(list_skb) > len);
4082
4083 i = 0;
4084 nfrags = skb_shinfo(list_skb)->nr_frags;
4085 frag = skb_shinfo(list_skb)->frags;
4086 frag_skb = list_skb;
4087 pos += skb_headlen(list_skb);
4088
4089 while (pos < offset + len) {
4090 BUG_ON(i >= nfrags);
4091
4092 size = skb_frag_size(frag);
4093 if (pos + size > offset + len)
4094 break;
4095
4096 i++;
4097 pos += size;
4098 frag++;
4099 }
4100
4101 nskb = skb_clone(list_skb, GFP_ATOMIC);
4102 list_skb = list_skb->next;
4103
4104 if (unlikely(!nskb))
4105 goto err;
4106
4107 if (unlikely(pskb_trim(nskb, len))) {
4108 kfree_skb(nskb);
4109 goto err;
4110 }
4111
4112 hsize = skb_end_offset(nskb);
4113 if (skb_cow_head(nskb, doffset + headroom)) {
4114 kfree_skb(nskb);
4115 goto err;
4116 }
4117
4118 nskb->truesize += skb_end_offset(nskb) - hsize;
4119 skb_release_head_state(nskb);
4120 __skb_push(nskb, doffset);
4121 } else {
4122 if (hsize < 0)
4123 hsize = 0;
4124 if (hsize > len || !sg)
4125 hsize = len;
4126
4127 nskb = __alloc_skb(hsize + doffset + headroom,
4128 GFP_ATOMIC, skb_alloc_rx_flag(head_skb),
4129 NUMA_NO_NODE);
4130
4131 if (unlikely(!nskb))
4132 goto err;
4133
4134 skb_reserve(nskb, headroom);
4135 __skb_put(nskb, doffset);
4136 }
4137
4138 if (segs)
4139 tail->next = nskb;
4140 else
4141 segs = nskb;
4142 tail = nskb;
4143
4144 __copy_skb_header(nskb, head_skb);
4145
4146 skb_headers_offset_update(nskb, skb_headroom(nskb) - headroom);
4147 skb_reset_mac_len(nskb);
4148
4149 skb_copy_from_linear_data_offset(head_skb, -tnl_hlen,
4150 nskb->data - tnl_hlen,
4151 doffset + tnl_hlen);
4152
4153 if (nskb->len == len + doffset)
4154 goto perform_csum_check;
4155
4156 if (!sg) {
4157 if (!csum) {
4158 if (!nskb->remcsum_offload)
4159 nskb->ip_summed = CHECKSUM_NONE;
4160 SKB_GSO_CB(nskb)->csum =
4161 skb_copy_and_csum_bits(head_skb, offset,
4162 skb_put(nskb,
4163 len),
4164 len);
4165 SKB_GSO_CB(nskb)->csum_start =
4166 skb_headroom(nskb) + doffset;
4167 } else {
4168 skb_copy_bits(head_skb, offset,
4169 skb_put(nskb, len),
4170 len);
4171 }
4172 continue;
4173 }
4174
4175 nskb_frag = skb_shinfo(nskb)->frags;
4176
4177 skb_copy_from_linear_data_offset(head_skb, offset,
4178 skb_put(nskb, hsize), hsize);
4179
4180 skb_shinfo(nskb)->flags |= skb_shinfo(head_skb)->flags &
4181 SKBFL_SHARED_FRAG;
4182
4183 if (skb_orphan_frags(frag_skb, GFP_ATOMIC) ||
4184 skb_zerocopy_clone(nskb, frag_skb, GFP_ATOMIC))
4185 goto err;
4186
4187 while (pos < offset + len) {
4188 if (i >= nfrags) {
4189 i = 0;
4190 nfrags = skb_shinfo(list_skb)->nr_frags;
4191 frag = skb_shinfo(list_skb)->frags;
4192 frag_skb = list_skb;
4193 if (!skb_headlen(list_skb)) {
4194 BUG_ON(!nfrags);
4195 } else {
4196 BUG_ON(!list_skb->head_frag);
4197
4198
4199 i--;
4200 frag--;
4201 }
4202 if (skb_orphan_frags(frag_skb, GFP_ATOMIC) ||
4203 skb_zerocopy_clone(nskb, frag_skb,
4204 GFP_ATOMIC))
4205 goto err;
4206
4207 list_skb = list_skb->next;
4208 }
4209
4210 if (unlikely(skb_shinfo(nskb)->nr_frags >=
4211 MAX_SKB_FRAGS)) {
4212 net_warn_ratelimited(
4213 "skb_segment: too many frags: %u %u\n",
4214 pos, mss);
4215 err = -EINVAL;
4216 goto err;
4217 }
4218
4219 *nskb_frag = (i < 0) ? skb_head_frag_to_page_desc(frag_skb) : *frag;
4220 __skb_frag_ref(nskb_frag);
4221 size = skb_frag_size(nskb_frag);
4222
4223 if (pos < offset) {
4224 skb_frag_off_add(nskb_frag, offset - pos);
4225 skb_frag_size_sub(nskb_frag, offset - pos);
4226 }
4227
4228 skb_shinfo(nskb)->nr_frags++;
4229
4230 if (pos + size <= offset + len) {
4231 i++;
4232 frag++;
4233 pos += size;
4234 } else {
4235 skb_frag_size_sub(nskb_frag, pos + size - (offset + len));
4236 goto skip_fraglist;
4237 }
4238
4239 nskb_frag++;
4240 }
4241
4242skip_fraglist:
4243 nskb->data_len = len - hsize;
4244 nskb->len += nskb->data_len;
4245 nskb->truesize += nskb->data_len;
4246
4247perform_csum_check:
4248 if (!csum) {
4249 if (skb_has_shared_frag(nskb) &&
4250 __skb_linearize(nskb))
4251 goto err;
4252
4253 if (!nskb->remcsum_offload)
4254 nskb->ip_summed = CHECKSUM_NONE;
4255 SKB_GSO_CB(nskb)->csum =
4256 skb_checksum(nskb, doffset,
4257 nskb->len - doffset, 0);
4258 SKB_GSO_CB(nskb)->csum_start =
4259 skb_headroom(nskb) + doffset;
4260 }
4261 } while ((offset += len) < head_skb->len);
4262
4263
4264
4265
4266
4267 segs->prev = tail;
4268
4269 if (partial_segs) {
4270 struct sk_buff *iter;
4271 int type = skb_shinfo(head_skb)->gso_type;
4272 unsigned short gso_size = skb_shinfo(head_skb)->gso_size;
4273
4274
4275 type |= (features & NETIF_F_GSO_PARTIAL) / NETIF_F_GSO_PARTIAL * SKB_GSO_PARTIAL;
4276 type &= ~SKB_GSO_DODGY;
4277
4278
4279
4280
4281 for (iter = segs; iter; iter = iter->next) {
4282 skb_shinfo(iter)->gso_size = gso_size;
4283 skb_shinfo(iter)->gso_segs = partial_segs;
4284 skb_shinfo(iter)->gso_type = type;
4285 SKB_GSO_CB(iter)->data_offset = skb_headroom(iter) + doffset;
4286 }
4287
4288 if (tail->len - doffset <= gso_size)
4289 skb_shinfo(tail)->gso_size = 0;
4290 else if (tail != segs)
4291 skb_shinfo(tail)->gso_segs = DIV_ROUND_UP(tail->len - doffset, gso_size);
4292 }
4293
4294
4295
4296
4297
4298 if (head_skb->destructor == sock_wfree) {
4299 swap(tail->truesize, head_skb->truesize);
4300 swap(tail->destructor, head_skb->destructor);
4301 swap(tail->sk, head_skb->sk);
4302 }
4303 return segs;
4304
4305err:
4306 kfree_skb_list(segs);
4307 return ERR_PTR(err);
4308}
4309EXPORT_SYMBOL_GPL(skb_segment);
4310
4311int skb_gro_receive(struct sk_buff *p, struct sk_buff *skb)
4312{
4313 struct skb_shared_info *pinfo, *skbinfo = skb_shinfo(skb);
4314 unsigned int offset = skb_gro_offset(skb);
4315 unsigned int headlen = skb_headlen(skb);
4316 unsigned int len = skb_gro_len(skb);
4317 unsigned int delta_truesize;
4318 unsigned int new_truesize;
4319 struct sk_buff *lp;
4320
4321 if (unlikely(p->len + len >= 65536 || NAPI_GRO_CB(skb)->flush))
4322 return -E2BIG;
4323
4324 lp = NAPI_GRO_CB(p)->last;
4325 pinfo = skb_shinfo(lp);
4326
4327 if (headlen <= offset) {
4328 skb_frag_t *frag;
4329 skb_frag_t *frag2;
4330 int i = skbinfo->nr_frags;
4331 int nr_frags = pinfo->nr_frags + i;
4332
4333 if (nr_frags > MAX_SKB_FRAGS)
4334 goto merge;
4335
4336 offset -= headlen;
4337 pinfo->nr_frags = nr_frags;
4338 skbinfo->nr_frags = 0;
4339
4340 frag = pinfo->frags + nr_frags;
4341 frag2 = skbinfo->frags + i;
4342 do {
4343 *--frag = *--frag2;
4344 } while (--i);
4345
4346 skb_frag_off_add(frag, offset);
4347 skb_frag_size_sub(frag, offset);
4348
4349
4350 new_truesize = SKB_TRUESIZE(skb_end_offset(skb));
4351 delta_truesize = skb->truesize - new_truesize;
4352
4353 skb->truesize = new_truesize;
4354 skb->len -= skb->data_len;
4355 skb->data_len = 0;
4356
4357 NAPI_GRO_CB(skb)->free = NAPI_GRO_FREE;
4358 goto done;
4359 } else if (skb->head_frag) {
4360 int nr_frags = pinfo->nr_frags;
4361 skb_frag_t *frag = pinfo->frags + nr_frags;
4362 struct page *page = virt_to_head_page(skb->head);
4363 unsigned int first_size = headlen - offset;
4364 unsigned int first_offset;
4365
4366 if (nr_frags + 1 + skbinfo->nr_frags > MAX_SKB_FRAGS)
4367 goto merge;
4368
4369 first_offset = skb->data -
4370 (unsigned char *)page_address(page) +
4371 offset;
4372
4373 pinfo->nr_frags = nr_frags + 1 + skbinfo->nr_frags;
4374
4375 __skb_frag_set_page(frag, page);
4376 skb_frag_off_set(frag, first_offset);
4377 skb_frag_size_set(frag, first_size);
4378
4379 memcpy(frag + 1, skbinfo->frags, sizeof(*frag) * skbinfo->nr_frags);
4380
4381
4382 new_truesize = SKB_DATA_ALIGN(sizeof(struct sk_buff));
4383 delta_truesize = skb->truesize - new_truesize;
4384 skb->truesize = new_truesize;
4385 NAPI_GRO_CB(skb)->free = NAPI_GRO_FREE_STOLEN_HEAD;
4386 goto done;
4387 }
4388
4389merge:
4390
4391 skb->destructor = NULL;
4392 delta_truesize = skb->truesize;
4393 if (offset > headlen) {
4394 unsigned int eat = offset - headlen;
4395
4396 skb_frag_off_add(&skbinfo->frags[0], eat);
4397 skb_frag_size_sub(&skbinfo->frags[0], eat);
4398 skb->data_len -= eat;
4399 skb->len -= eat;
4400 offset = headlen;
4401 }
4402
4403 __skb_pull(skb, offset);
4404
4405 if (NAPI_GRO_CB(p)->last == p)
4406 skb_shinfo(p)->frag_list = skb;
4407 else
4408 NAPI_GRO_CB(p)->last->next = skb;
4409 NAPI_GRO_CB(p)->last = skb;
4410 __skb_header_release(skb);
4411 lp = p;
4412
4413done:
4414 NAPI_GRO_CB(p)->count++;
4415 p->data_len += len;
4416 p->truesize += delta_truesize;
4417 p->len += len;
4418 if (lp != p) {
4419 lp->data_len += len;
4420 lp->truesize += delta_truesize;
4421 lp->len += len;
4422 }
4423 NAPI_GRO_CB(skb)->same_flow = 1;
4424 return 0;
4425}
4426
4427#ifdef CONFIG_SKB_EXTENSIONS
4428#define SKB_EXT_ALIGN_VALUE 8
4429#define SKB_EXT_CHUNKSIZEOF(x) (ALIGN((sizeof(x)), SKB_EXT_ALIGN_VALUE) / SKB_EXT_ALIGN_VALUE)
4430
4431static const u8 skb_ext_type_len[] = {
4432#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
4433 [SKB_EXT_BRIDGE_NF] = SKB_EXT_CHUNKSIZEOF(struct nf_bridge_info),
4434#endif
4435#ifdef CONFIG_XFRM
4436 [SKB_EXT_SEC_PATH] = SKB_EXT_CHUNKSIZEOF(struct sec_path),
4437#endif
4438#if IS_ENABLED(CONFIG_NET_TC_SKB_EXT)
4439 [TC_SKB_EXT] = SKB_EXT_CHUNKSIZEOF(struct tc_skb_ext),
4440#endif
4441#if IS_ENABLED(CONFIG_MPTCP)
4442 [SKB_EXT_MPTCP] = SKB_EXT_CHUNKSIZEOF(struct mptcp_ext),
4443#endif
4444};
4445
4446static __always_inline unsigned int skb_ext_total_length(void)
4447{
4448 return SKB_EXT_CHUNKSIZEOF(struct skb_ext) +
4449#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
4450 skb_ext_type_len[SKB_EXT_BRIDGE_NF] +
4451#endif
4452#ifdef CONFIG_XFRM
4453 skb_ext_type_len[SKB_EXT_SEC_PATH] +
4454#endif
4455#if IS_ENABLED(CONFIG_NET_TC_SKB_EXT)
4456 skb_ext_type_len[TC_SKB_EXT] +
4457#endif
4458#if IS_ENABLED(CONFIG_MPTCP)
4459 skb_ext_type_len[SKB_EXT_MPTCP] +
4460#endif
4461 0;
4462}
4463
4464static void skb_extensions_init(void)
4465{
4466 BUILD_BUG_ON(SKB_EXT_NUM >= 8);
4467 BUILD_BUG_ON(skb_ext_total_length() > 255);
4468
4469 skbuff_ext_cache = kmem_cache_create("skbuff_ext_cache",
4470 SKB_EXT_ALIGN_VALUE * skb_ext_total_length(),
4471 0,
4472 SLAB_HWCACHE_ALIGN|SLAB_PANIC,
4473 NULL);
4474}
4475#else
4476static void skb_extensions_init(void) {}
4477#endif
4478
4479void __init skb_init(void)
4480{
4481 skbuff_head_cache = kmem_cache_create_usercopy("skbuff_head_cache",
4482 sizeof(struct sk_buff),
4483 0,
4484 SLAB_HWCACHE_ALIGN|SLAB_PANIC,
4485 offsetof(struct sk_buff, cb),
4486 sizeof_field(struct sk_buff, cb),
4487 NULL);
4488 skbuff_fclone_cache = kmem_cache_create("skbuff_fclone_cache",
4489 sizeof(struct sk_buff_fclones),
4490 0,
4491 SLAB_HWCACHE_ALIGN|SLAB_PANIC,
4492 NULL);
4493 skb_extensions_init();
4494}
4495
4496static int
4497__skb_to_sgvec(struct sk_buff *skb, struct scatterlist *sg, int offset, int len,
4498 unsigned int recursion_level)
4499{
4500 int start = skb_headlen(skb);
4501 int i, copy = start - offset;
4502 struct sk_buff *frag_iter;
4503 int elt = 0;
4504
4505 if (unlikely(recursion_level >= 24))
4506 return -EMSGSIZE;
4507
4508 if (copy > 0) {
4509 if (copy > len)
4510 copy = len;
4511 sg_set_buf(sg, skb->data + offset, copy);
4512 elt++;
4513 if ((len -= copy) == 0)
4514 return elt;
4515 offset += copy;
4516 }
4517
4518 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
4519 int end;
4520
4521 WARN_ON(start > offset + len);
4522
4523 end = start + skb_frag_size(&skb_shinfo(skb)->frags[i]);
4524 if ((copy = end - offset) > 0) {
4525 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
4526 if (unlikely(elt && sg_is_last(&sg[elt - 1])))
4527 return -EMSGSIZE;
4528
4529 if (copy > len)
4530 copy = len;
4531 sg_set_page(&sg[elt], skb_frag_page(frag), copy,
4532 skb_frag_off(frag) + offset - start);
4533 elt++;
4534 if (!(len -= copy))
4535 return elt;
4536 offset += copy;
4537 }
4538 start = end;
4539 }
4540
4541 skb_walk_frags(skb, frag_iter) {
4542 int end, ret;
4543
4544 WARN_ON(start > offset + len);
4545
4546 end = start + frag_iter->len;
4547 if ((copy = end - offset) > 0) {
4548 if (unlikely(elt && sg_is_last(&sg[elt - 1])))
4549 return -EMSGSIZE;
4550
4551 if (copy > len)
4552 copy = len;
4553 ret = __skb_to_sgvec(frag_iter, sg+elt, offset - start,
4554 copy, recursion_level + 1);
4555 if (unlikely(ret < 0))
4556 return ret;
4557 elt += ret;
4558 if ((len -= copy) == 0)
4559 return elt;
4560 offset += copy;
4561 }
4562 start = end;
4563 }
4564 BUG_ON(len);
4565 return elt;
4566}
4567
4568
4569
4570
4571
4572
4573
4574
4575
4576
4577
4578
4579
4580int skb_to_sgvec(struct sk_buff *skb, struct scatterlist *sg, int offset, int len)
4581{
4582 int nsg = __skb_to_sgvec(skb, sg, offset, len, 0);
4583
4584 if (nsg <= 0)
4585 return nsg;
4586
4587 sg_mark_end(&sg[nsg - 1]);
4588
4589 return nsg;
4590}
4591EXPORT_SYMBOL_GPL(skb_to_sgvec);
4592
4593
4594
4595
4596
4597
4598
4599
4600
4601
4602
4603
4604
4605
4606
4607
4608
4609
4610
4611
4612int skb_to_sgvec_nomark(struct sk_buff *skb, struct scatterlist *sg,
4613 int offset, int len)
4614{
4615 return __skb_to_sgvec(skb, sg, offset, len, 0);
4616}
4617EXPORT_SYMBOL_GPL(skb_to_sgvec_nomark);
4618
4619
4620
4621
4622
4623
4624
4625
4626
4627
4628
4629
4630
4631
4632
4633
4634
4635
4636
4637
4638int skb_cow_data(struct sk_buff *skb, int tailbits, struct sk_buff **trailer)
4639{
4640 int copyflag;
4641 int elt;
4642 struct sk_buff *skb1, **skb_p;
4643
4644
4645
4646
4647
4648 if ((skb_cloned(skb) || skb_shinfo(skb)->nr_frags) &&
4649 !__pskb_pull_tail(skb, __skb_pagelen(skb)))
4650 return -ENOMEM;
4651
4652
4653 if (!skb_has_frag_list(skb)) {
4654
4655
4656
4657
4658
4659 if (skb_tailroom(skb) < tailbits &&
4660 pskb_expand_head(skb, 0, tailbits-skb_tailroom(skb)+128, GFP_ATOMIC))
4661 return -ENOMEM;
4662
4663
4664 *trailer = skb;
4665 return 1;
4666 }
4667
4668
4669
4670 elt = 1;
4671 skb_p = &skb_shinfo(skb)->frag_list;
4672 copyflag = 0;
4673
4674 while ((skb1 = *skb_p) != NULL) {
4675 int ntail = 0;
4676
4677
4678
4679
4680
4681 if (skb_shared(skb1))
4682 copyflag = 1;
4683
4684
4685
4686 if (skb1->next == NULL && tailbits) {
4687 if (skb_shinfo(skb1)->nr_frags ||
4688 skb_has_frag_list(skb1) ||
4689 skb_tailroom(skb1) < tailbits)
4690 ntail = tailbits + 128;
4691 }
4692
4693 if (copyflag ||
4694 skb_cloned(skb1) ||
4695 ntail ||
4696 skb_shinfo(skb1)->nr_frags ||
4697 skb_has_frag_list(skb1)) {
4698 struct sk_buff *skb2;
4699
4700
4701 if (ntail == 0)
4702 skb2 = skb_copy(skb1, GFP_ATOMIC);
4703 else
4704 skb2 = skb_copy_expand(skb1,
4705 skb_headroom(skb1),
4706 ntail,
4707 GFP_ATOMIC);
4708 if (unlikely(skb2 == NULL))
4709 return -ENOMEM;
4710
4711 if (skb1->sk)
4712 skb_set_owner_w(skb2, skb1->sk);
4713
4714
4715
4716
4717 skb2->next = skb1->next;
4718 *skb_p = skb2;
4719 kfree_skb(skb1);
4720 skb1 = skb2;
4721 }
4722 elt++;
4723 *trailer = skb1;
4724 skb_p = &skb1->next;
4725 }
4726
4727 return elt;
4728}
4729EXPORT_SYMBOL_GPL(skb_cow_data);
4730
4731static void sock_rmem_free(struct sk_buff *skb)
4732{
4733 struct sock *sk = skb->sk;
4734
4735 atomic_sub(skb->truesize, &sk->sk_rmem_alloc);
4736}
4737
4738static void skb_set_err_queue(struct sk_buff *skb)
4739{
4740
4741
4742
4743 skb->pkt_type = PACKET_OUTGOING;
4744 BUILD_BUG_ON(PACKET_OUTGOING == 0);
4745}
4746
4747
4748
4749
4750int sock_queue_err_skb(struct sock *sk, struct sk_buff *skb)
4751{
4752 if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
4753 (unsigned int)READ_ONCE(sk->sk_rcvbuf))
4754 return -ENOMEM;
4755
4756 skb_orphan(skb);
4757 skb->sk = sk;
4758 skb->destructor = sock_rmem_free;
4759 atomic_add(skb->truesize, &sk->sk_rmem_alloc);
4760 skb_set_err_queue(skb);
4761
4762
4763 skb_dst_force(skb);
4764
4765 skb_queue_tail(&sk->sk_error_queue, skb);
4766 if (!sock_flag(sk, SOCK_DEAD))
4767 sk_error_report(sk);
4768 return 0;
4769}
4770EXPORT_SYMBOL(sock_queue_err_skb);
4771
4772static bool is_icmp_err_skb(const struct sk_buff *skb)
4773{
4774 return skb && (SKB_EXT_ERR(skb)->ee.ee_origin == SO_EE_ORIGIN_ICMP ||
4775 SKB_EXT_ERR(skb)->ee.ee_origin == SO_EE_ORIGIN_ICMP6);
4776}
4777
4778struct sk_buff *sock_dequeue_err_skb(struct sock *sk)
4779{
4780 struct sk_buff_head *q = &sk->sk_error_queue;
4781 struct sk_buff *skb, *skb_next = NULL;
4782 bool icmp_next = false;
4783 unsigned long flags;
4784
4785 spin_lock_irqsave(&q->lock, flags);
4786 skb = __skb_dequeue(q);
4787 if (skb && (skb_next = skb_peek(q))) {
4788 icmp_next = is_icmp_err_skb(skb_next);
4789 if (icmp_next)
4790 sk->sk_err = SKB_EXT_ERR(skb_next)->ee.ee_errno;
4791 }
4792 spin_unlock_irqrestore(&q->lock, flags);
4793
4794 if (is_icmp_err_skb(skb) && !icmp_next)
4795 sk->sk_err = 0;
4796
4797 if (skb_next)
4798 sk_error_report(sk);
4799
4800 return skb;
4801}
4802EXPORT_SYMBOL(sock_dequeue_err_skb);
4803
4804
4805
4806
4807
4808
4809
4810
4811
4812
4813
4814
4815
4816
4817struct sk_buff *skb_clone_sk(struct sk_buff *skb)
4818{
4819 struct sock *sk = skb->sk;
4820 struct sk_buff *clone;
4821
4822 if (!sk || !refcount_inc_not_zero(&sk->sk_refcnt))
4823 return NULL;
4824
4825 clone = skb_clone(skb, GFP_ATOMIC);
4826 if (!clone) {
4827 sock_put(sk);
4828 return NULL;
4829 }
4830
4831 clone->sk = sk;
4832 clone->destructor = sock_efree;
4833
4834 return clone;
4835}
4836EXPORT_SYMBOL(skb_clone_sk);
4837
4838static void __skb_complete_tx_timestamp(struct sk_buff *skb,
4839 struct sock *sk,
4840 int tstype,
4841 bool opt_stats)
4842{
4843 struct sock_exterr_skb *serr;
4844 int err;
4845
4846 BUILD_BUG_ON(sizeof(struct sock_exterr_skb) > sizeof(skb->cb));
4847
4848 serr = SKB_EXT_ERR(skb);
4849 memset(serr, 0, sizeof(*serr));
4850 serr->ee.ee_errno = ENOMSG;
4851 serr->ee.ee_origin = SO_EE_ORIGIN_TIMESTAMPING;
4852 serr->ee.ee_info = tstype;
4853 serr->opt_stats = opt_stats;
4854 serr->header.h4.iif = skb->dev ? skb->dev->ifindex : 0;
4855 if (sk->sk_tsflags & SOF_TIMESTAMPING_OPT_ID) {
4856 serr->ee.ee_data = skb_shinfo(skb)->tskey;
4857 if (sk->sk_protocol == IPPROTO_TCP &&
4858 sk->sk_type == SOCK_STREAM)
4859 serr->ee.ee_data -= sk->sk_tskey;
4860 }
4861
4862 err = sock_queue_err_skb(sk, skb);
4863
4864 if (err)
4865 kfree_skb(skb);
4866}
4867
4868static bool skb_may_tx_timestamp(struct sock *sk, bool tsonly)
4869{
4870 bool ret;
4871
4872 if (likely(sysctl_tstamp_allow_data || tsonly))
4873 return true;
4874
4875 read_lock_bh(&sk->sk_callback_lock);
4876 ret = sk->sk_socket && sk->sk_socket->file &&
4877 file_ns_capable(sk->sk_socket->file, &init_user_ns, CAP_NET_RAW);
4878 read_unlock_bh(&sk->sk_callback_lock);
4879 return ret;
4880}
4881
4882void skb_complete_tx_timestamp(struct sk_buff *skb,
4883 struct skb_shared_hwtstamps *hwtstamps)
4884{
4885 struct sock *sk = skb->sk;
4886
4887 if (!skb_may_tx_timestamp(sk, false))
4888 goto err;
4889
4890
4891
4892
4893 if (likely(refcount_inc_not_zero(&sk->sk_refcnt))) {
4894 *skb_hwtstamps(skb) = *hwtstamps;
4895 __skb_complete_tx_timestamp(skb, sk, SCM_TSTAMP_SND, false);
4896 sock_put(sk);
4897 return;
4898 }
4899
4900err:
4901 kfree_skb(skb);
4902}
4903EXPORT_SYMBOL_GPL(skb_complete_tx_timestamp);
4904
4905void __skb_tstamp_tx(struct sk_buff *orig_skb,
4906 const struct sk_buff *ack_skb,
4907 struct skb_shared_hwtstamps *hwtstamps,
4908 struct sock *sk, int tstype)
4909{
4910 struct sk_buff *skb;
4911 bool tsonly, opt_stats = false;
4912
4913 if (!sk)
4914 return;
4915
4916 if (!hwtstamps && !(sk->sk_tsflags & SOF_TIMESTAMPING_OPT_TX_SWHW) &&
4917 skb_shinfo(orig_skb)->tx_flags & SKBTX_IN_PROGRESS)
4918 return;
4919
4920 tsonly = sk->sk_tsflags & SOF_TIMESTAMPING_OPT_TSONLY;
4921 if (!skb_may_tx_timestamp(sk, tsonly))
4922 return;
4923
4924 if (tsonly) {
4925#ifdef CONFIG_INET
4926 if ((sk->sk_tsflags & SOF_TIMESTAMPING_OPT_STATS) &&
4927 sk->sk_protocol == IPPROTO_TCP &&
4928 sk->sk_type == SOCK_STREAM) {
4929 skb = tcp_get_timestamping_opt_stats(sk, orig_skb,
4930 ack_skb);
4931 opt_stats = true;
4932 } else
4933#endif
4934 skb = alloc_skb(0, GFP_ATOMIC);
4935 } else {
4936 skb = skb_clone(orig_skb, GFP_ATOMIC);
4937 }
4938 if (!skb)
4939 return;
4940
4941 if (tsonly) {
4942 skb_shinfo(skb)->tx_flags |= skb_shinfo(orig_skb)->tx_flags &
4943 SKBTX_ANY_TSTAMP;
4944 skb_shinfo(skb)->tskey = skb_shinfo(orig_skb)->tskey;
4945 }
4946
4947 if (hwtstamps)
4948 *skb_hwtstamps(skb) = *hwtstamps;
4949 else
4950 skb->tstamp = ktime_get_real();
4951
4952 __skb_complete_tx_timestamp(skb, sk, tstype, opt_stats);
4953}
4954EXPORT_SYMBOL_GPL(__skb_tstamp_tx);
4955
4956void skb_tstamp_tx(struct sk_buff *orig_skb,
4957 struct skb_shared_hwtstamps *hwtstamps)
4958{
4959 return __skb_tstamp_tx(orig_skb, NULL, hwtstamps, orig_skb->sk,
4960 SCM_TSTAMP_SND);
4961}
4962EXPORT_SYMBOL_GPL(skb_tstamp_tx);
4963
4964void skb_complete_wifi_ack(struct sk_buff *skb, bool acked)
4965{
4966 struct sock *sk = skb->sk;
4967 struct sock_exterr_skb *serr;
4968 int err = 1;
4969
4970 skb->wifi_acked_valid = 1;
4971 skb->wifi_acked = acked;
4972
4973 serr = SKB_EXT_ERR(skb);
4974 memset(serr, 0, sizeof(*serr));
4975 serr->ee.ee_errno = ENOMSG;
4976 serr->ee.ee_origin = SO_EE_ORIGIN_TXSTATUS;
4977
4978
4979
4980
4981 if (likely(refcount_inc_not_zero(&sk->sk_refcnt))) {
4982 err = sock_queue_err_skb(sk, skb);
4983 sock_put(sk);
4984 }
4985 if (err)
4986 kfree_skb(skb);
4987}
4988EXPORT_SYMBOL_GPL(skb_complete_wifi_ack);
4989
4990
4991
4992
4993
4994
4995
4996
4997
4998
4999
5000
5001
5002bool skb_partial_csum_set(struct sk_buff *skb, u16 start, u16 off)
5003{
5004 u32 csum_end = (u32)start + (u32)off + sizeof(__sum16);
5005 u32 csum_start = skb_headroom(skb) + (u32)start;
5006
5007 if (unlikely(csum_start > U16_MAX || csum_end > skb_headlen(skb))) {
5008 net_warn_ratelimited("bad partial csum: csum=%u/%u headroom=%u headlen=%u\n",
5009 start, off, skb_headroom(skb), skb_headlen(skb));
5010 return false;
5011 }
5012 skb->ip_summed = CHECKSUM_PARTIAL;
5013 skb->csum_start = csum_start;
5014 skb->csum_offset = off;
5015 skb_set_transport_header(skb, start);
5016 return true;
5017}
5018EXPORT_SYMBOL_GPL(skb_partial_csum_set);
5019
5020static int skb_maybe_pull_tail(struct sk_buff *skb, unsigned int len,
5021 unsigned int max)
5022{
5023 if (skb_headlen(skb) >= len)
5024 return 0;
5025
5026
5027
5028
5029 if (max > skb->len)
5030 max = skb->len;
5031
5032 if (__pskb_pull_tail(skb, max - skb_headlen(skb)) == NULL)
5033 return -ENOMEM;
5034
5035 if (skb_headlen(skb) < len)
5036 return -EPROTO;
5037
5038 return 0;
5039}
5040
5041#define MAX_TCP_HDR_LEN (15 * 4)
5042
5043static __sum16 *skb_checksum_setup_ip(struct sk_buff *skb,
5044 typeof(IPPROTO_IP) proto,
5045 unsigned int off)
5046{
5047 int err;
5048
5049 switch (proto) {
5050 case IPPROTO_TCP:
5051 err = skb_maybe_pull_tail(skb, off + sizeof(struct tcphdr),
5052 off + MAX_TCP_HDR_LEN);
5053 if (!err && !skb_partial_csum_set(skb, off,
5054 offsetof(struct tcphdr,
5055 check)))
5056 err = -EPROTO;
5057 return err ? ERR_PTR(err) : &tcp_hdr(skb)->check;
5058
5059 case IPPROTO_UDP:
5060 err = skb_maybe_pull_tail(skb, off + sizeof(struct udphdr),
5061 off + sizeof(struct udphdr));
5062 if (!err && !skb_partial_csum_set(skb, off,
5063 offsetof(struct udphdr,
5064 check)))
5065 err = -EPROTO;
5066 return err ? ERR_PTR(err) : &udp_hdr(skb)->check;
5067 }
5068
5069 return ERR_PTR(-EPROTO);
5070}
5071
5072
5073
5074
5075#define MAX_IP_HDR_LEN 128
5076
5077static int skb_checksum_setup_ipv4(struct sk_buff *skb, bool recalculate)
5078{
5079 unsigned int off;
5080 bool fragment;
5081 __sum16 *csum;
5082 int err;
5083
5084 fragment = false;
5085
5086 err = skb_maybe_pull_tail(skb,
5087 sizeof(struct iphdr),
5088 MAX_IP_HDR_LEN);
5089 if (err < 0)
5090 goto out;
5091
5092 if (ip_is_fragment(ip_hdr(skb)))
5093 fragment = true;
5094
5095 off = ip_hdrlen(skb);
5096
5097 err = -EPROTO;
5098
5099 if (fragment)
5100 goto out;
5101
5102 csum = skb_checksum_setup_ip(skb, ip_hdr(skb)->protocol, off);
5103 if (IS_ERR(csum))
5104 return PTR_ERR(csum);
5105
5106 if (recalculate)
5107 *csum = ~csum_tcpudp_magic(ip_hdr(skb)->saddr,
5108 ip_hdr(skb)->daddr,
5109 skb->len - off,
5110 ip_hdr(skb)->protocol, 0);
5111 err = 0;
5112
5113out:
5114 return err;
5115}
5116
5117
5118
5119
5120#define MAX_IPV6_HDR_LEN 256
5121
5122#define OPT_HDR(type, skb, off) \
5123 (type *)(skb_network_header(skb) + (off))
5124
5125static int skb_checksum_setup_ipv6(struct sk_buff *skb, bool recalculate)
5126{
5127 int err;
5128 u8 nexthdr;
5129 unsigned int off;
5130 unsigned int len;
5131 bool fragment;
5132 bool done;
5133 __sum16 *csum;
5134
5135 fragment = false;
5136 done = false;
5137
5138 off = sizeof(struct ipv6hdr);
5139
5140 err = skb_maybe_pull_tail(skb, off, MAX_IPV6_HDR_LEN);
5141 if (err < 0)
5142 goto out;
5143
5144 nexthdr = ipv6_hdr(skb)->nexthdr;
5145
5146 len = sizeof(struct ipv6hdr) + ntohs(ipv6_hdr(skb)->payload_len);
5147 while (off <= len && !done) {
5148 switch (nexthdr) {
5149 case IPPROTO_DSTOPTS:
5150 case IPPROTO_HOPOPTS:
5151 case IPPROTO_ROUTING: {
5152 struct ipv6_opt_hdr *hp;
5153
5154 err = skb_maybe_pull_tail(skb,
5155 off +
5156 sizeof(struct ipv6_opt_hdr),
5157 MAX_IPV6_HDR_LEN);
5158 if (err < 0)
5159 goto out;
5160
5161 hp = OPT_HDR(struct ipv6_opt_hdr, skb, off);
5162 nexthdr = hp->nexthdr;
5163 off += ipv6_optlen(hp);
5164 break;
5165 }
5166 case IPPROTO_AH: {
5167 struct ip_auth_hdr *hp;
5168
5169 err = skb_maybe_pull_tail(skb,
5170 off +
5171 sizeof(struct ip_auth_hdr),
5172 MAX_IPV6_HDR_LEN);
5173 if (err < 0)
5174 goto out;
5175
5176 hp = OPT_HDR(struct ip_auth_hdr, skb, off);
5177 nexthdr = hp->nexthdr;
5178 off += ipv6_authlen(hp);
5179 break;
5180 }
5181 case IPPROTO_FRAGMENT: {
5182 struct frag_hdr *hp;
5183
5184 err = skb_maybe_pull_tail(skb,
5185 off +
5186 sizeof(struct frag_hdr),
5187 MAX_IPV6_HDR_LEN);
5188 if (err < 0)
5189 goto out;
5190
5191 hp = OPT_HDR(struct frag_hdr, skb, off);
5192
5193 if (hp->frag_off & htons(IP6_OFFSET | IP6_MF))
5194 fragment = true;
5195
5196 nexthdr = hp->nexthdr;
5197 off += sizeof(struct frag_hdr);
5198 break;
5199 }
5200 default:
5201 done = true;
5202 break;
5203 }
5204 }
5205
5206 err = -EPROTO;
5207
5208 if (!done || fragment)
5209 goto out;
5210
5211 csum = skb_checksum_setup_ip(skb, nexthdr, off);
5212 if (IS_ERR(csum))
5213 return PTR_ERR(csum);
5214
5215 if (recalculate)
5216 *csum = ~csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
5217 &ipv6_hdr(skb)->daddr,
5218 skb->len - off, nexthdr, 0);
5219 err = 0;
5220
5221out:
5222 return err;
5223}
5224
5225
5226
5227
5228
5229
5230int skb_checksum_setup(struct sk_buff *skb, bool recalculate)
5231{
5232 int err;
5233
5234 switch (skb->protocol) {
5235 case htons(ETH_P_IP):
5236 err = skb_checksum_setup_ipv4(skb, recalculate);
5237 break;
5238
5239 case htons(ETH_P_IPV6):
5240 err = skb_checksum_setup_ipv6(skb, recalculate);
5241 break;
5242
5243 default:
5244 err = -EPROTO;
5245 break;
5246 }
5247
5248 return err;
5249}
5250EXPORT_SYMBOL(skb_checksum_setup);
5251
5252
5253
5254
5255
5256
5257
5258
5259
5260
5261
5262
5263
5264
5265static struct sk_buff *skb_checksum_maybe_trim(struct sk_buff *skb,
5266 unsigned int transport_len)
5267{
5268 struct sk_buff *skb_chk;
5269 unsigned int len = skb_transport_offset(skb) + transport_len;
5270 int ret;
5271
5272 if (skb->len < len)
5273 return NULL;
5274 else if (skb->len == len)
5275 return skb;
5276
5277 skb_chk = skb_clone(skb, GFP_ATOMIC);
5278 if (!skb_chk)
5279 return NULL;
5280
5281 ret = pskb_trim_rcsum(skb_chk, len);
5282 if (ret) {
5283 kfree_skb(skb_chk);
5284 return NULL;
5285 }
5286
5287 return skb_chk;
5288}
5289
5290
5291
5292
5293
5294
5295
5296
5297
5298
5299
5300
5301
5302
5303
5304
5305struct sk_buff *skb_checksum_trimmed(struct sk_buff *skb,
5306 unsigned int transport_len,
5307 __sum16(*skb_chkf)(struct sk_buff *skb))
5308{
5309 struct sk_buff *skb_chk;
5310 unsigned int offset = skb_transport_offset(skb);
5311 __sum16 ret;
5312
5313 skb_chk = skb_checksum_maybe_trim(skb, transport_len);
5314 if (!skb_chk)
5315 goto err;
5316
5317 if (!pskb_may_pull(skb_chk, offset))
5318 goto err;
5319
5320 skb_pull_rcsum(skb_chk, offset);
5321 ret = skb_chkf(skb_chk);
5322 skb_push_rcsum(skb_chk, offset);
5323
5324 if (ret)
5325 goto err;
5326
5327 return skb_chk;
5328
5329err:
5330 if (skb_chk && skb_chk != skb)
5331 kfree_skb(skb_chk);
5332
5333 return NULL;
5334
5335}
5336EXPORT_SYMBOL(skb_checksum_trimmed);
5337
5338void __skb_warn_lro_forwarding(const struct sk_buff *skb)
5339{
5340 net_warn_ratelimited("%s: received packets cannot be forwarded while LRO is enabled\n",
5341 skb->dev->name);
5342}
5343EXPORT_SYMBOL(__skb_warn_lro_forwarding);
5344
5345void kfree_skb_partial(struct sk_buff *skb, bool head_stolen)
5346{
5347 if (head_stolen) {
5348 skb_release_head_state(skb);
5349 kmem_cache_free(skbuff_head_cache, skb);
5350 } else {
5351 __kfree_skb(skb);
5352 }
5353}
5354EXPORT_SYMBOL(kfree_skb_partial);
5355
5356
5357
5358
5359
5360
5361
5362
5363bool skb_try_coalesce(struct sk_buff *to, struct sk_buff *from,
5364 bool *fragstolen, int *delta_truesize)
5365{
5366 struct skb_shared_info *to_shinfo, *from_shinfo;
5367 int i, delta, len = from->len;
5368
5369 *fragstolen = false;
5370
5371 if (skb_cloned(to))
5372 return false;
5373
5374
5375
5376
5377
5378 if (to->pp_recycle != from->pp_recycle)
5379 return false;
5380
5381 if (len <= skb_tailroom(to)) {
5382 if (len)
5383 BUG_ON(skb_copy_bits(from, 0, skb_put(to, len), len));
5384 *delta_truesize = 0;
5385 return true;
5386 }
5387
5388 to_shinfo = skb_shinfo(to);
5389 from_shinfo = skb_shinfo(from);
5390 if (to_shinfo->frag_list || from_shinfo->frag_list)
5391 return false;
5392 if (skb_zcopy(to) || skb_zcopy(from))
5393 return false;
5394
5395 if (skb_headlen(from) != 0) {
5396 struct page *page;
5397 unsigned int offset;
5398
5399 if (to_shinfo->nr_frags +
5400 from_shinfo->nr_frags >= MAX_SKB_FRAGS)
5401 return false;
5402
5403 if (skb_head_is_locked(from))
5404 return false;
5405
5406 delta = from->truesize - SKB_DATA_ALIGN(sizeof(struct sk_buff));
5407
5408 page = virt_to_head_page(from->head);
5409 offset = from->data - (unsigned char *)page_address(page);
5410
5411 skb_fill_page_desc(to, to_shinfo->nr_frags,
5412 page, offset, skb_headlen(from));
5413 *fragstolen = true;
5414 } else {
5415 if (to_shinfo->nr_frags +
5416 from_shinfo->nr_frags > MAX_SKB_FRAGS)
5417 return false;
5418
5419 delta = from->truesize - SKB_TRUESIZE(skb_end_offset(from));
5420 }
5421
5422 WARN_ON_ONCE(delta < len);
5423
5424 memcpy(to_shinfo->frags + to_shinfo->nr_frags,
5425 from_shinfo->frags,
5426 from_shinfo->nr_frags * sizeof(skb_frag_t));
5427 to_shinfo->nr_frags += from_shinfo->nr_frags;
5428
5429 if (!skb_cloned(from))
5430 from_shinfo->nr_frags = 0;
5431
5432
5433
5434
5435 for (i = 0; i < from_shinfo->nr_frags; i++)
5436 __skb_frag_ref(&from_shinfo->frags[i]);
5437
5438 to->truesize += delta;
5439 to->len += len;
5440 to->data_len += len;
5441
5442 *delta_truesize = delta;
5443 return true;
5444}
5445EXPORT_SYMBOL(skb_try_coalesce);
5446
5447
5448
5449
5450
5451
5452
5453
5454
5455
5456
5457
5458
5459
5460void skb_scrub_packet(struct sk_buff *skb, bool xnet)
5461{
5462 skb->pkt_type = PACKET_HOST;
5463 skb->skb_iif = 0;
5464 skb->ignore_df = 0;
5465 skb_dst_drop(skb);
5466 skb_ext_reset(skb);
5467 nf_reset_ct(skb);
5468 nf_reset_trace(skb);
5469
5470#ifdef CONFIG_NET_SWITCHDEV
5471 skb->offload_fwd_mark = 0;
5472 skb->offload_l3_fwd_mark = 0;
5473#endif
5474
5475 if (!xnet)
5476 return;
5477
5478 ipvs_reset(skb);
5479 skb->mark = 0;
5480 skb->tstamp = 0;
5481}
5482EXPORT_SYMBOL_GPL(skb_scrub_packet);
5483
5484
5485
5486
5487
5488
5489
5490
5491
5492
5493
5494static unsigned int skb_gso_transport_seglen(const struct sk_buff *skb)
5495{
5496 const struct skb_shared_info *shinfo = skb_shinfo(skb);
5497 unsigned int thlen = 0;
5498
5499 if (skb->encapsulation) {
5500 thlen = skb_inner_transport_header(skb) -
5501 skb_transport_header(skb);
5502
5503 if (likely(shinfo->gso_type & (SKB_GSO_TCPV4 | SKB_GSO_TCPV6)))
5504 thlen += inner_tcp_hdrlen(skb);
5505 } else if (likely(shinfo->gso_type & (SKB_GSO_TCPV4 | SKB_GSO_TCPV6))) {
5506 thlen = tcp_hdrlen(skb);
5507 } else if (unlikely(skb_is_gso_sctp(skb))) {
5508 thlen = sizeof(struct sctphdr);
5509 } else if (shinfo->gso_type & SKB_GSO_UDP_L4) {
5510 thlen = sizeof(struct udphdr);
5511 }
5512
5513
5514
5515
5516 return thlen + shinfo->gso_size;
5517}
5518
5519
5520
5521
5522
5523
5524
5525
5526
5527
5528
5529static unsigned int skb_gso_network_seglen(const struct sk_buff *skb)
5530{
5531 unsigned int hdr_len = skb_transport_header(skb) -
5532 skb_network_header(skb);
5533
5534 return hdr_len + skb_gso_transport_seglen(skb);
5535}
5536
5537
5538
5539
5540
5541
5542
5543
5544
5545
5546static unsigned int skb_gso_mac_seglen(const struct sk_buff *skb)
5547{
5548 unsigned int hdr_len = skb_transport_header(skb) - skb_mac_header(skb);
5549
5550 return hdr_len + skb_gso_transport_seglen(skb);
5551}
5552
5553
5554
5555
5556
5557
5558
5559
5560
5561
5562
5563
5564
5565
5566
5567
5568
5569
5570
5571
5572
5573
5574static inline bool skb_gso_size_check(const struct sk_buff *skb,
5575 unsigned int seg_len,
5576 unsigned int max_len) {
5577 const struct skb_shared_info *shinfo = skb_shinfo(skb);
5578 const struct sk_buff *iter;
5579
5580 if (shinfo->gso_size != GSO_BY_FRAGS)
5581 return seg_len <= max_len;
5582
5583
5584 seg_len -= GSO_BY_FRAGS;
5585
5586 skb_walk_frags(skb, iter) {
5587 if (seg_len + skb_headlen(iter) > max_len)
5588 return false;
5589 }
5590
5591 return true;
5592}
5593
5594
5595
5596
5597
5598
5599
5600
5601
5602
5603
5604bool skb_gso_validate_network_len(const struct sk_buff *skb, unsigned int mtu)
5605{
5606 return skb_gso_size_check(skb, skb_gso_network_seglen(skb), mtu);
5607}
5608EXPORT_SYMBOL_GPL(skb_gso_validate_network_len);
5609
5610
5611
5612
5613
5614
5615
5616
5617
5618
5619bool skb_gso_validate_mac_len(const struct sk_buff *skb, unsigned int len)
5620{
5621 return skb_gso_size_check(skb, skb_gso_mac_seglen(skb), len);
5622}
5623EXPORT_SYMBOL_GPL(skb_gso_validate_mac_len);
5624
5625static struct sk_buff *skb_reorder_vlan_header(struct sk_buff *skb)
5626{
5627 int mac_len, meta_len;
5628 void *meta;
5629
5630 if (skb_cow(skb, skb_headroom(skb)) < 0) {
5631 kfree_skb(skb);
5632 return NULL;
5633 }
5634
5635 mac_len = skb->data - skb_mac_header(skb);
5636 if (likely(mac_len > VLAN_HLEN + ETH_TLEN)) {
5637 memmove(skb_mac_header(skb) + VLAN_HLEN, skb_mac_header(skb),
5638 mac_len - VLAN_HLEN - ETH_TLEN);
5639 }
5640
5641 meta_len = skb_metadata_len(skb);
5642 if (meta_len) {
5643 meta = skb_metadata_end(skb) - meta_len;
5644 memmove(meta + VLAN_HLEN, meta, meta_len);
5645 }
5646
5647 skb->mac_header += VLAN_HLEN;
5648 return skb;
5649}
5650
5651struct sk_buff *skb_vlan_untag(struct sk_buff *skb)
5652{
5653 struct vlan_hdr *vhdr;
5654 u16 vlan_tci;
5655
5656 if (unlikely(skb_vlan_tag_present(skb))) {
5657
5658 return skb;
5659 }
5660
5661 skb = skb_share_check(skb, GFP_ATOMIC);
5662 if (unlikely(!skb))
5663 goto err_free;
5664
5665 if (unlikely(!pskb_may_pull(skb, VLAN_HLEN + sizeof(unsigned short))))
5666 goto err_free;
5667
5668 vhdr = (struct vlan_hdr *)skb->data;
5669 vlan_tci = ntohs(vhdr->h_vlan_TCI);
5670 __vlan_hwaccel_put_tag(skb, skb->protocol, vlan_tci);
5671
5672 skb_pull_rcsum(skb, VLAN_HLEN);
5673 vlan_set_encap_proto(skb, vhdr);
5674
5675 skb = skb_reorder_vlan_header(skb);
5676 if (unlikely(!skb))
5677 goto err_free;
5678
5679 skb_reset_network_header(skb);
5680 if (!skb_transport_header_was_set(skb))
5681 skb_reset_transport_header(skb);
5682 skb_reset_mac_len(skb);
5683
5684 return skb;
5685
5686err_free:
5687 kfree_skb(skb);
5688 return NULL;
5689}
5690EXPORT_SYMBOL(skb_vlan_untag);
5691
5692int skb_ensure_writable(struct sk_buff *skb, int write_len)
5693{
5694 if (!pskb_may_pull(skb, write_len))
5695 return -ENOMEM;
5696
5697 if (!skb_cloned(skb) || skb_clone_writable(skb, write_len))
5698 return 0;
5699
5700 return pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
5701}
5702EXPORT_SYMBOL(skb_ensure_writable);
5703
5704
5705
5706
5707int __skb_vlan_pop(struct sk_buff *skb, u16 *vlan_tci)
5708{
5709 struct vlan_hdr *vhdr;
5710 int offset = skb->data - skb_mac_header(skb);
5711 int err;
5712
5713 if (WARN_ONCE(offset,
5714 "__skb_vlan_pop got skb with skb->data not at mac header (offset %d)\n",
5715 offset)) {
5716 return -EINVAL;
5717 }
5718
5719 err = skb_ensure_writable(skb, VLAN_ETH_HLEN);
5720 if (unlikely(err))
5721 return err;
5722
5723 skb_postpull_rcsum(skb, skb->data + (2 * ETH_ALEN), VLAN_HLEN);
5724
5725 vhdr = (struct vlan_hdr *)(skb->data + ETH_HLEN);
5726 *vlan_tci = ntohs(vhdr->h_vlan_TCI);
5727
5728 memmove(skb->data + VLAN_HLEN, skb->data, 2 * ETH_ALEN);
5729 __skb_pull(skb, VLAN_HLEN);
5730
5731 vlan_set_encap_proto(skb, vhdr);
5732 skb->mac_header += VLAN_HLEN;
5733
5734 if (skb_network_offset(skb) < ETH_HLEN)
5735 skb_set_network_header(skb, ETH_HLEN);
5736
5737 skb_reset_mac_len(skb);
5738
5739 return err;
5740}
5741EXPORT_SYMBOL(__skb_vlan_pop);
5742
5743
5744
5745
5746int skb_vlan_pop(struct sk_buff *skb)
5747{
5748 u16 vlan_tci;
5749 __be16 vlan_proto;
5750 int err;
5751
5752 if (likely(skb_vlan_tag_present(skb))) {
5753 __vlan_hwaccel_clear_tag(skb);
5754 } else {
5755 if (unlikely(!eth_type_vlan(skb->protocol)))
5756 return 0;
5757
5758 err = __skb_vlan_pop(skb, &vlan_tci);
5759 if (err)
5760 return err;
5761 }
5762
5763 if (likely(!eth_type_vlan(skb->protocol)))
5764 return 0;
5765
5766 vlan_proto = skb->protocol;
5767 err = __skb_vlan_pop(skb, &vlan_tci);
5768 if (unlikely(err))
5769 return err;
5770
5771 __vlan_hwaccel_put_tag(skb, vlan_proto, vlan_tci);
5772 return 0;
5773}
5774EXPORT_SYMBOL(skb_vlan_pop);
5775
5776
5777
5778
5779int skb_vlan_push(struct sk_buff *skb, __be16 vlan_proto, u16 vlan_tci)
5780{
5781 if (skb_vlan_tag_present(skb)) {
5782 int offset = skb->data - skb_mac_header(skb);
5783 int err;
5784
5785 if (WARN_ONCE(offset,
5786 "skb_vlan_push got skb with skb->data not at mac header (offset %d)\n",
5787 offset)) {
5788 return -EINVAL;
5789 }
5790
5791 err = __vlan_insert_tag(skb, skb->vlan_proto,
5792 skb_vlan_tag_get(skb));
5793 if (err)
5794 return err;
5795
5796 skb->protocol = skb->vlan_proto;
5797 skb->mac_len += VLAN_HLEN;
5798
5799 skb_postpush_rcsum(skb, skb->data + (2 * ETH_ALEN), VLAN_HLEN);
5800 }
5801 __vlan_hwaccel_put_tag(skb, vlan_proto, vlan_tci);
5802 return 0;
5803}
5804EXPORT_SYMBOL(skb_vlan_push);
5805
5806
5807
5808
5809
5810
5811
5812
5813
5814
5815
5816
5817
5818int skb_eth_pop(struct sk_buff *skb)
5819{
5820 if (!pskb_may_pull(skb, ETH_HLEN) || skb_vlan_tagged(skb) ||
5821 skb_network_offset(skb) < ETH_HLEN)
5822 return -EPROTO;
5823
5824 skb_pull_rcsum(skb, ETH_HLEN);
5825 skb_reset_mac_header(skb);
5826 skb_reset_mac_len(skb);
5827
5828 return 0;
5829}
5830EXPORT_SYMBOL(skb_eth_pop);
5831
5832
5833
5834
5835
5836
5837
5838
5839
5840
5841
5842
5843
5844
5845int skb_eth_push(struct sk_buff *skb, const unsigned char *dst,
5846 const unsigned char *src)
5847{
5848 struct ethhdr *eth;
5849 int err;
5850
5851 if (skb_network_offset(skb) || skb_vlan_tag_present(skb))
5852 return -EPROTO;
5853
5854 err = skb_cow_head(skb, sizeof(*eth));
5855 if (err < 0)
5856 return err;
5857
5858 skb_push(skb, sizeof(*eth));
5859 skb_reset_mac_header(skb);
5860 skb_reset_mac_len(skb);
5861
5862 eth = eth_hdr(skb);
5863 ether_addr_copy(eth->h_dest, dst);
5864 ether_addr_copy(eth->h_source, src);
5865 eth->h_proto = skb->protocol;
5866
5867 skb_postpush_rcsum(skb, eth, sizeof(*eth));
5868
5869 return 0;
5870}
5871EXPORT_SYMBOL(skb_eth_push);
5872
5873
5874static void skb_mod_eth_type(struct sk_buff *skb, struct ethhdr *hdr,
5875 __be16 ethertype)
5876{
5877 if (skb->ip_summed == CHECKSUM_COMPLETE) {
5878 __be16 diff[] = { ~hdr->h_proto, ethertype };
5879
5880 skb->csum = csum_partial((char *)diff, sizeof(diff), skb->csum);
5881 }
5882
5883 hdr->h_proto = ethertype;
5884}
5885
5886
5887
5888
5889
5890
5891
5892
5893
5894
5895
5896
5897
5898
5899
5900
5901int skb_mpls_push(struct sk_buff *skb, __be32 mpls_lse, __be16 mpls_proto,
5902 int mac_len, bool ethernet)
5903{
5904 struct mpls_shim_hdr *lse;
5905 int err;
5906
5907 if (unlikely(!eth_p_mpls(mpls_proto)))
5908 return -EINVAL;
5909
5910
5911 if (skb->encapsulation)
5912 return -EINVAL;
5913
5914 err = skb_cow_head(skb, MPLS_HLEN);
5915 if (unlikely(err))
5916 return err;
5917
5918 if (!skb->inner_protocol) {
5919 skb_set_inner_network_header(skb, skb_network_offset(skb));
5920 skb_set_inner_protocol(skb, skb->protocol);
5921 }
5922
5923 skb_push(skb, MPLS_HLEN);
5924 memmove(skb_mac_header(skb) - MPLS_HLEN, skb_mac_header(skb),
5925 mac_len);
5926 skb_reset_mac_header(skb);
5927 skb_set_network_header(skb, mac_len);
5928 skb_reset_mac_len(skb);
5929
5930 lse = mpls_hdr(skb);
5931 lse->label_stack_entry = mpls_lse;
5932 skb_postpush_rcsum(skb, lse, MPLS_HLEN);
5933
5934 if (ethernet && mac_len >= ETH_HLEN)
5935 skb_mod_eth_type(skb, eth_hdr(skb), mpls_proto);
5936 skb->protocol = mpls_proto;
5937
5938 return 0;
5939}
5940EXPORT_SYMBOL_GPL(skb_mpls_push);
5941
5942
5943
5944
5945
5946
5947
5948
5949
5950
5951
5952
5953
5954int skb_mpls_pop(struct sk_buff *skb, __be16 next_proto, int mac_len,
5955 bool ethernet)
5956{
5957 int err;
5958
5959 if (unlikely(!eth_p_mpls(skb->protocol)))
5960 return 0;
5961
5962 err = skb_ensure_writable(skb, mac_len + MPLS_HLEN);
5963 if (unlikely(err))
5964 return err;
5965
5966 skb_postpull_rcsum(skb, mpls_hdr(skb), MPLS_HLEN);
5967 memmove(skb_mac_header(skb) + MPLS_HLEN, skb_mac_header(skb),
5968 mac_len);
5969
5970 __skb_pull(skb, MPLS_HLEN);
5971 skb_reset_mac_header(skb);
5972 skb_set_network_header(skb, mac_len);
5973
5974 if (ethernet && mac_len >= ETH_HLEN) {
5975 struct ethhdr *hdr;
5976
5977
5978 hdr = (struct ethhdr *)((void *)mpls_hdr(skb) - ETH_HLEN);
5979 skb_mod_eth_type(skb, hdr, next_proto);
5980 }
5981 skb->protocol = next_proto;
5982
5983 return 0;
5984}
5985EXPORT_SYMBOL_GPL(skb_mpls_pop);
5986
5987
5988
5989
5990
5991
5992
5993
5994
5995
5996
5997int skb_mpls_update_lse(struct sk_buff *skb, __be32 mpls_lse)
5998{
5999 int err;
6000
6001 if (unlikely(!eth_p_mpls(skb->protocol)))
6002 return -EINVAL;
6003
6004 err = skb_ensure_writable(skb, skb->mac_len + MPLS_HLEN);
6005 if (unlikely(err))
6006 return err;
6007
6008 if (skb->ip_summed == CHECKSUM_COMPLETE) {
6009 __be32 diff[] = { ~mpls_hdr(skb)->label_stack_entry, mpls_lse };
6010
6011 skb->csum = csum_partial((char *)diff, sizeof(diff), skb->csum);
6012 }
6013
6014 mpls_hdr(skb)->label_stack_entry = mpls_lse;
6015
6016 return 0;
6017}
6018EXPORT_SYMBOL_GPL(skb_mpls_update_lse);
6019
6020
6021
6022
6023
6024
6025
6026
6027
6028
6029int skb_mpls_dec_ttl(struct sk_buff *skb)
6030{
6031 u32 lse;
6032 u8 ttl;
6033
6034 if (unlikely(!eth_p_mpls(skb->protocol)))
6035 return -EINVAL;
6036
6037 if (!pskb_may_pull(skb, skb_network_offset(skb) + MPLS_HLEN))
6038 return -ENOMEM;
6039
6040 lse = be32_to_cpu(mpls_hdr(skb)->label_stack_entry);
6041 ttl = (lse & MPLS_LS_TTL_MASK) >> MPLS_LS_TTL_SHIFT;
6042 if (!--ttl)
6043 return -EINVAL;
6044
6045 lse &= ~MPLS_LS_TTL_MASK;
6046 lse |= ttl << MPLS_LS_TTL_SHIFT;
6047
6048 return skb_mpls_update_lse(skb, cpu_to_be32(lse));
6049}
6050EXPORT_SYMBOL_GPL(skb_mpls_dec_ttl);
6051
6052
6053
6054
6055
6056
6057
6058
6059
6060
6061
6062
6063struct sk_buff *alloc_skb_with_frags(unsigned long header_len,
6064 unsigned long data_len,
6065 int max_page_order,
6066 int *errcode,
6067 gfp_t gfp_mask)
6068{
6069 int npages = (data_len + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
6070 unsigned long chunk;
6071 struct sk_buff *skb;
6072 struct page *page;
6073 int i;
6074
6075 *errcode = -EMSGSIZE;
6076
6077
6078
6079 if (npages > MAX_SKB_FRAGS)
6080 return NULL;
6081
6082 *errcode = -ENOBUFS;
6083 skb = alloc_skb(header_len, gfp_mask);
6084 if (!skb)
6085 return NULL;
6086
6087 skb->truesize += npages << PAGE_SHIFT;
6088
6089 for (i = 0; npages > 0; i++) {
6090 int order = max_page_order;
6091
6092 while (order) {
6093 if (npages >= 1 << order) {
6094 page = alloc_pages((gfp_mask & ~__GFP_DIRECT_RECLAIM) |
6095 __GFP_COMP |
6096 __GFP_NOWARN,
6097 order);
6098 if (page)
6099 goto fill_page;
6100
6101 order = 1;
6102 max_page_order = 0;
6103 }
6104 order--;
6105 }
6106 page = alloc_page(gfp_mask);
6107 if (!page)
6108 goto failure;
6109fill_page:
6110 chunk = min_t(unsigned long, data_len,
6111 PAGE_SIZE << order);
6112 skb_fill_page_desc(skb, i, page, 0, chunk);
6113 data_len -= chunk;
6114 npages -= 1 << order;
6115 }
6116 return skb;
6117
6118failure:
6119 kfree_skb(skb);
6120 return NULL;
6121}
6122EXPORT_SYMBOL(alloc_skb_with_frags);
6123
6124
6125static int pskb_carve_inside_header(struct sk_buff *skb, const u32 off,
6126 const int headlen, gfp_t gfp_mask)
6127{
6128 int i;
6129 int size = skb_end_offset(skb);
6130 int new_hlen = headlen - off;
6131 u8 *data;
6132
6133 size = SKB_DATA_ALIGN(size);
6134
6135 if (skb_pfmemalloc(skb))
6136 gfp_mask |= __GFP_MEMALLOC;
6137 data = kmalloc_reserve(size +
6138 SKB_DATA_ALIGN(sizeof(struct skb_shared_info)),
6139 gfp_mask, NUMA_NO_NODE, NULL);
6140 if (!data)
6141 return -ENOMEM;
6142
6143 size = SKB_WITH_OVERHEAD(ksize(data));
6144
6145
6146 skb_copy_from_linear_data_offset(skb, off, data, new_hlen);
6147 skb->len -= off;
6148
6149 memcpy((struct skb_shared_info *)(data + size),
6150 skb_shinfo(skb),
6151 offsetof(struct skb_shared_info,
6152 frags[skb_shinfo(skb)->nr_frags]));
6153 if (skb_cloned(skb)) {
6154
6155 if (skb_orphan_frags(skb, gfp_mask)) {
6156 kfree(data);
6157 return -ENOMEM;
6158 }
6159 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
6160 skb_frag_ref(skb, i);
6161 if (skb_has_frag_list(skb))
6162 skb_clone_fraglist(skb);
6163 skb_release_data(skb);
6164 } else {
6165
6166
6167
6168 skb_free_head(skb);
6169 }
6170
6171 skb->head = data;
6172 skb->data = data;
6173 skb->head_frag = 0;
6174#ifdef NET_SKBUFF_DATA_USES_OFFSET
6175 skb->end = size;
6176#else
6177 skb->end = skb->head + size;
6178#endif
6179 skb_set_tail_pointer(skb, skb_headlen(skb));
6180 skb_headers_offset_update(skb, 0);
6181 skb->cloned = 0;
6182 skb->hdr_len = 0;
6183 skb->nohdr = 0;
6184 atomic_set(&skb_shinfo(skb)->dataref, 1);
6185
6186 return 0;
6187}
6188
6189static int pskb_carve(struct sk_buff *skb, const u32 off, gfp_t gfp);
6190
6191
6192
6193
6194static int pskb_carve_frag_list(struct sk_buff *skb,
6195 struct skb_shared_info *shinfo, int eat,
6196 gfp_t gfp_mask)
6197{
6198 struct sk_buff *list = shinfo->frag_list;
6199 struct sk_buff *clone = NULL;
6200 struct sk_buff *insp = NULL;
6201
6202 do {
6203 if (!list) {
6204 pr_err("Not enough bytes to eat. Want %d\n", eat);
6205 return -EFAULT;
6206 }
6207 if (list->len <= eat) {
6208
6209 eat -= list->len;
6210 list = list->next;
6211 insp = list;
6212 } else {
6213
6214 if (skb_shared(list)) {
6215 clone = skb_clone(list, gfp_mask);
6216 if (!clone)
6217 return -ENOMEM;
6218 insp = list->next;
6219 list = clone;
6220 } else {
6221
6222 insp = list;
6223 }
6224 if (pskb_carve(list, eat, gfp_mask) < 0) {
6225 kfree_skb(clone);
6226 return -ENOMEM;
6227 }
6228 break;
6229 }
6230 } while (eat);
6231
6232
6233 while ((list = shinfo->frag_list) != insp) {
6234 shinfo->frag_list = list->next;
6235 kfree_skb(list);
6236 }
6237
6238 if (clone) {
6239 clone->next = list;
6240 shinfo->frag_list = clone;
6241 }
6242 return 0;
6243}
6244
6245
6246
6247
6248static int pskb_carve_inside_nonlinear(struct sk_buff *skb, const u32 off,
6249 int pos, gfp_t gfp_mask)
6250{
6251 int i, k = 0;
6252 int size = skb_end_offset(skb);
6253 u8 *data;
6254 const int nfrags = skb_shinfo(skb)->nr_frags;
6255 struct skb_shared_info *shinfo;
6256
6257 size = SKB_DATA_ALIGN(size);
6258
6259 if (skb_pfmemalloc(skb))
6260 gfp_mask |= __GFP_MEMALLOC;
6261 data = kmalloc_reserve(size +
6262 SKB_DATA_ALIGN(sizeof(struct skb_shared_info)),
6263 gfp_mask, NUMA_NO_NODE, NULL);
6264 if (!data)
6265 return -ENOMEM;
6266
6267 size = SKB_WITH_OVERHEAD(ksize(data));
6268
6269 memcpy((struct skb_shared_info *)(data + size),
6270 skb_shinfo(skb), offsetof(struct skb_shared_info, frags[0]));
6271 if (skb_orphan_frags(skb, gfp_mask)) {
6272 kfree(data);
6273 return -ENOMEM;
6274 }
6275 shinfo = (struct skb_shared_info *)(data + size);
6276 for (i = 0; i < nfrags; i++) {
6277 int fsize = skb_frag_size(&skb_shinfo(skb)->frags[i]);
6278
6279 if (pos + fsize > off) {
6280 shinfo->frags[k] = skb_shinfo(skb)->frags[i];
6281
6282 if (pos < off) {
6283
6284
6285
6286
6287
6288
6289
6290
6291 skb_frag_off_add(&shinfo->frags[0], off - pos);
6292 skb_frag_size_sub(&shinfo->frags[0], off - pos);
6293 }
6294 skb_frag_ref(skb, i);
6295 k++;
6296 }
6297 pos += fsize;
6298 }
6299 shinfo->nr_frags = k;
6300 if (skb_has_frag_list(skb))
6301 skb_clone_fraglist(skb);
6302
6303
6304 if (k == 0 && pskb_carve_frag_list(skb, shinfo, off - pos, gfp_mask)) {
6305
6306 if (skb_has_frag_list(skb))
6307 kfree_skb_list(skb_shinfo(skb)->frag_list);
6308 kfree(data);
6309 return -ENOMEM;
6310 }
6311 skb_release_data(skb);
6312
6313 skb->head = data;
6314 skb->head_frag = 0;
6315 skb->data = data;
6316#ifdef NET_SKBUFF_DATA_USES_OFFSET
6317 skb->end = size;
6318#else
6319 skb->end = skb->head + size;
6320#endif
6321 skb_reset_tail_pointer(skb);
6322 skb_headers_offset_update(skb, 0);
6323 skb->cloned = 0;
6324 skb->hdr_len = 0;
6325 skb->nohdr = 0;
6326 skb->len -= off;
6327 skb->data_len = skb->len;
6328 atomic_set(&skb_shinfo(skb)->dataref, 1);
6329 return 0;
6330}
6331
6332
6333static int pskb_carve(struct sk_buff *skb, const u32 len, gfp_t gfp)
6334{
6335 int headlen = skb_headlen(skb);
6336
6337 if (len < headlen)
6338 return pskb_carve_inside_header(skb, len, headlen, gfp);
6339 else
6340 return pskb_carve_inside_nonlinear(skb, len, headlen, gfp);
6341}
6342
6343
6344
6345
6346struct sk_buff *pskb_extract(struct sk_buff *skb, int off,
6347 int to_copy, gfp_t gfp)
6348{
6349 struct sk_buff *clone = skb_clone(skb, gfp);
6350
6351 if (!clone)
6352 return NULL;
6353
6354 if (pskb_carve(clone, off, gfp) < 0 ||
6355 pskb_trim(clone, to_copy)) {
6356 kfree_skb(clone);
6357 return NULL;
6358 }
6359 return clone;
6360}
6361EXPORT_SYMBOL(pskb_extract);
6362
6363
6364
6365
6366
6367
6368
6369
6370
6371
6372
6373
6374
6375void skb_condense(struct sk_buff *skb)
6376{
6377 if (skb->data_len) {
6378 if (skb->data_len > skb->end - skb->tail ||
6379 skb_cloned(skb))
6380 return;
6381
6382
6383 __pskb_pull_tail(skb, skb->data_len);
6384 }
6385
6386
6387
6388
6389
6390
6391
6392 skb->truesize = SKB_TRUESIZE(skb_end_offset(skb));
6393}
6394
6395#ifdef CONFIG_SKB_EXTENSIONS
6396static void *skb_ext_get_ptr(struct skb_ext *ext, enum skb_ext_id id)
6397{
6398 return (void *)ext + (ext->offset[id] * SKB_EXT_ALIGN_VALUE);
6399}
6400
6401
6402
6403
6404
6405
6406
6407
6408
6409
6410struct skb_ext *__skb_ext_alloc(gfp_t flags)
6411{
6412 struct skb_ext *new = kmem_cache_alloc(skbuff_ext_cache, flags);
6413
6414 if (new) {
6415 memset(new->offset, 0, sizeof(new->offset));
6416 refcount_set(&new->refcnt, 1);
6417 }
6418
6419 return new;
6420}
6421
6422static struct skb_ext *skb_ext_maybe_cow(struct skb_ext *old,
6423 unsigned int old_active)
6424{
6425 struct skb_ext *new;
6426
6427 if (refcount_read(&old->refcnt) == 1)
6428 return old;
6429
6430 new = kmem_cache_alloc(skbuff_ext_cache, GFP_ATOMIC);
6431 if (!new)
6432 return NULL;
6433
6434 memcpy(new, old, old->chunks * SKB_EXT_ALIGN_VALUE);
6435 refcount_set(&new->refcnt, 1);
6436
6437#ifdef CONFIG_XFRM
6438 if (old_active & (1 << SKB_EXT_SEC_PATH)) {
6439 struct sec_path *sp = skb_ext_get_ptr(old, SKB_EXT_SEC_PATH);
6440 unsigned int i;
6441
6442 for (i = 0; i < sp->len; i++)
6443 xfrm_state_hold(sp->xvec[i]);
6444 }
6445#endif
6446 __skb_ext_put(old);
6447 return new;
6448}
6449
6450
6451
6452
6453
6454
6455
6456
6457
6458
6459
6460void *__skb_ext_set(struct sk_buff *skb, enum skb_ext_id id,
6461 struct skb_ext *ext)
6462{
6463 unsigned int newlen, newoff = SKB_EXT_CHUNKSIZEOF(*ext);
6464
6465 skb_ext_put(skb);
6466 newlen = newoff + skb_ext_type_len[id];
6467 ext->chunks = newlen;
6468 ext->offset[id] = newoff;
6469 skb->extensions = ext;
6470 skb->active_extensions = 1 << id;
6471 return skb_ext_get_ptr(ext, id);
6472}
6473
6474
6475
6476
6477
6478
6479
6480
6481
6482
6483
6484
6485
6486
6487
6488void *skb_ext_add(struct sk_buff *skb, enum skb_ext_id id)
6489{
6490 struct skb_ext *new, *old = NULL;
6491 unsigned int newlen, newoff;
6492
6493 if (skb->active_extensions) {
6494 old = skb->extensions;
6495
6496 new = skb_ext_maybe_cow(old, skb->active_extensions);
6497 if (!new)
6498 return NULL;
6499
6500 if (__skb_ext_exist(new, id))
6501 goto set_active;
6502
6503 newoff = new->chunks;
6504 } else {
6505 newoff = SKB_EXT_CHUNKSIZEOF(*new);
6506
6507 new = __skb_ext_alloc(GFP_ATOMIC);
6508 if (!new)
6509 return NULL;
6510 }
6511
6512 newlen = newoff + skb_ext_type_len[id];
6513 new->chunks = newlen;
6514 new->offset[id] = newoff;
6515set_active:
6516 skb->slow_gro = 1;
6517 skb->extensions = new;
6518 skb->active_extensions |= 1 << id;
6519 return skb_ext_get_ptr(new, id);
6520}
6521EXPORT_SYMBOL(skb_ext_add);
6522
6523#ifdef CONFIG_XFRM
6524static void skb_ext_put_sp(struct sec_path *sp)
6525{
6526 unsigned int i;
6527
6528 for (i = 0; i < sp->len; i++)
6529 xfrm_state_put(sp->xvec[i]);
6530}
6531#endif
6532
6533void __skb_ext_del(struct sk_buff *skb, enum skb_ext_id id)
6534{
6535 struct skb_ext *ext = skb->extensions;
6536
6537 skb->active_extensions &= ~(1 << id);
6538 if (skb->active_extensions == 0) {
6539 skb->extensions = NULL;
6540 __skb_ext_put(ext);
6541#ifdef CONFIG_XFRM
6542 } else if (id == SKB_EXT_SEC_PATH &&
6543 refcount_read(&ext->refcnt) == 1) {
6544 struct sec_path *sp = skb_ext_get_ptr(ext, SKB_EXT_SEC_PATH);
6545
6546 skb_ext_put_sp(sp);
6547 sp->len = 0;
6548#endif
6549 }
6550}
6551EXPORT_SYMBOL(__skb_ext_del);
6552
6553void __skb_ext_put(struct skb_ext *ext)
6554{
6555
6556
6557
6558 if (refcount_read(&ext->refcnt) == 1)
6559 goto free_now;
6560
6561 if (!refcount_dec_and_test(&ext->refcnt))
6562 return;
6563free_now:
6564#ifdef CONFIG_XFRM
6565 if (__skb_ext_exist(ext, SKB_EXT_SEC_PATH))
6566 skb_ext_put_sp(skb_ext_get_ptr(ext, SKB_EXT_SEC_PATH));
6567#endif
6568
6569 kmem_cache_free(skbuff_ext_cache, ext);
6570}
6571EXPORT_SYMBOL(__skb_ext_put);
6572#endif
6573