← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise-security

« back to all changes in this revision

Viewing changes to net/ipv4/inet_lro.c

  • Committer: Package Import Robot
  • Author(s): Paolo Pisati, Paolo Pisati
  • Date: 2011-12-06 15:56:07 UTC
  • Revision ID: package-import@ubuntu.com-20111206155607-pcf44kv5fmhk564f
Tags: 3.2.0-1401.1
[ Paolo Pisati ]

* Rebased on top of Ubuntu-3.2.0-3.8
* Tilt-tracking @ ef2487af4bb15bdd0689631774b5a5e3a59f74e2
* Delete debian.ti-omap4/control, it shoudln't be tracked
* Fix architecture spelling (s/armel/armhf/)
* [Config] Update configs following 3.2 import
* [Config] Fix compilation: disable CODA and ARCH_OMAP3
* [Config] Fix compilation: disable Ethernet Faraday
* Update series to precise

Show diffs side-by-side

added added

removed removed

Lines of Context:
net/ipv4/inet_lro.c
146
146
}
147
147
 
148
148
static void lro_init_desc(struct net_lro_desc *lro_desc, struct sk_buff *skb,
149
 
                          struct iphdr *iph, struct tcphdr *tcph,
150
 
                          u16 vlan_tag, struct vlan_group *vgrp)
 
149
                          struct iphdr *iph, struct tcphdr *tcph)
151
150
{
152
151
        int nr_frags;
153
152
        __be32 *ptr;
173
172
        }
174
173
 
175
174
        lro_desc->mss = tcp_data_len;
176
 
        lro_desc->vgrp = vgrp;
177
 
        lro_desc->vlan_tag = vlan_tag;
178
175
        lro_desc->active = 1;
179
176
 
180
177
        lro_desc->data_csum = lro_tcp_data_csum(iph, tcph,
247
244
        skb->truesize += truesize;
248
245
 
249
246
        skb_frags[0].page_offset += hlen;
250
 
        skb_frags[0].size -= hlen;
 
247
        skb_frag_size_sub(&skb_frags[0], hlen);
251
248
 
252
249
        while (tcp_data_len > 0) {
253
250
                *(lro_desc->next_frag) = *skb_frags;
254
 
                tcp_data_len -= skb_frags->size;
 
251
                tcp_data_len -= skb_frag_size(skb_frags);
255
252
                lro_desc->next_frag++;
256
253
                skb_frags++;
257
254
                skb_shinfo(skb)->nr_frags++;
309
306
 
310
307
        skb_shinfo(lro_desc->parent)->gso_size = lro_desc->mss;
311
308
 
312
 
        if (lro_desc->vgrp) {
313
 
                if (lro_mgr->features & LRO_F_NAPI)
314
 
                        vlan_hwaccel_receive_skb(lro_desc->parent,
315
 
                                                 lro_desc->vgrp,
316
 
                                                 lro_desc->vlan_tag);
317
 
                else
318
 
                        vlan_hwaccel_rx(lro_desc->parent,
319
 
                                        lro_desc->vgrp,
320
 
                                        lro_desc->vlan_tag);
321
 
 
322
 
        } else {
323
 
                if (lro_mgr->features & LRO_F_NAPI)
324
 
                        netif_receive_skb(lro_desc->parent);
325
 
                else
326
 
                        netif_rx(lro_desc->parent);
327
 
        }
 
309
        if (lro_mgr->features & LRO_F_NAPI)
 
310
                netif_receive_skb(lro_desc->parent);
 
311
        else
 
312
                netif_rx(lro_desc->parent);
328
313
 
329
314
        LRO_INC_STATS(lro_mgr, flushed);
330
315
        lro_clear_desc(lro_desc);
331
316
}
332
317
 
333
318
static int __lro_proc_skb(struct net_lro_mgr *lro_mgr, struct sk_buff *skb,
334
 
                          struct vlan_group *vgrp, u16 vlan_tag, void *priv)
 
319
                          void *priv)
335
320
{
336
321
        struct net_lro_desc *lro_desc;
337
322
        struct iphdr *iph;
360
345
                        goto out;
361
346
 
362
347
                skb->ip_summed = lro_mgr->ip_summed_aggr;
363
 
                lro_init_desc(lro_desc, skb, iph, tcph, vlan_tag, vgrp);
 
348
                lro_init_desc(lro_desc, skb, iph, tcph);
364
349
                LRO_INC_STATS(lro_mgr, aggregated);
365
350
                return 0;
366
351
        }
415
400
        skb_frags = skb_shinfo(skb)->frags;
416
401
        while (data_len > 0) {
417
402
                *skb_frags = *frags;
418
 
                data_len -= frags->size;
 
403
                data_len -= skb_frag_size(frags);
419
404
                skb_frags++;
420
405
                frags++;
421
406
                skb_shinfo(skb)->nr_frags++;
422
407
        }
423
408
 
424
409
        skb_shinfo(skb)->frags[0].page_offset += hdr_len;
425
 
        skb_shinfo(skb)->frags[0].size -= hdr_len;
 
410
        skb_frag_size_sub(&skb_shinfo(skb)->frags[0], hdr_len);
426
411
 
427
412
        skb->ip_summed = ip_summed;
428
413
        skb->csum = sum;
433
418
static struct sk_buff *__lro_proc_segment(struct net_lro_mgr *lro_mgr,
434
419
                                          struct skb_frag_struct *frags,
435
420
                                          int len, int true_size,
436
 
                                          struct vlan_group *vgrp,
437
 
                                          u16 vlan_tag, void *priv, __wsum sum)
 
421
                                          void *priv, __wsum sum)
438
422
{
439
423
        struct net_lro_desc *lro_desc;
440
424
        struct iphdr *iph;
449
433
        if (!lro_mgr->get_frag_header ||
450
434
            lro_mgr->get_frag_header(frags, (void *)&mac_hdr, (void *)&iph,
451
435
                                     (void *)&tcph, &flags, priv)) {
452
 
                mac_hdr = page_address(frags->page) + frags->page_offset;
 
436
                mac_hdr = skb_frag_address(frags);
453
437
                goto out1;
454
438
        }
455
439
 
480
464
                tcph = (void *)((u8 *)skb->data + vlan_hdr_len
481
465
                                + IP_HDR_LEN(iph));
482
466
 
483
 
                lro_init_desc(lro_desc, skb, iph, tcph, 0, NULL);
 
467
                lro_init_desc(lro_desc, skb, iph, tcph);
484
468
                LRO_INC_STATS(lro_mgr, aggregated);
485
469
                return NULL;
486
470
        }
514
498
                     struct sk_buff *skb,
515
499
                     void *priv)
516
500
{
517
 
        if (__lro_proc_skb(lro_mgr, skb, NULL, 0, priv)) {
 
501
        if (__lro_proc_skb(lro_mgr, skb, priv)) {
518
502
                if (lro_mgr->features & LRO_F_NAPI)
519
503
                        netif_receive_skb(skb);
520
504
                else
523
507
}
524
508
EXPORT_SYMBOL(lro_receive_skb);
525
509
 
526
 
void lro_vlan_hwaccel_receive_skb(struct net_lro_mgr *lro_mgr,
527
 
                                  struct sk_buff *skb,
528
 
                                  struct vlan_group *vgrp,
529
 
                                  u16 vlan_tag,
530
 
                                  void *priv)
531
 
{
532
 
        if (__lro_proc_skb(lro_mgr, skb, vgrp, vlan_tag, priv)) {
533
 
                if (lro_mgr->features & LRO_F_NAPI)
534
 
                        vlan_hwaccel_receive_skb(skb, vgrp, vlan_tag);
535
 
                else
536
 
                        vlan_hwaccel_rx(skb, vgrp, vlan_tag);
537
 
        }
538
 
}
539
 
EXPORT_SYMBOL(lro_vlan_hwaccel_receive_skb);
540
 
 
541
510
void lro_receive_frags(struct net_lro_mgr *lro_mgr,
542
511
                       struct skb_frag_struct *frags,
543
512
                       int len, int true_size, void *priv, __wsum sum)
544
513
{
545
514
        struct sk_buff *skb;
546
515
 
547
 
        skb = __lro_proc_segment(lro_mgr, frags, len, true_size, NULL, 0,
548
 
                                 priv, sum);
 
516
        skb = __lro_proc_segment(lro_mgr, frags, len, true_size, priv, sum);
549
517
        if (!skb)
550
518
                return;
551
519
 
556
524
}
557
525
EXPORT_SYMBOL(lro_receive_frags);
558
526
 
559
 
void lro_vlan_hwaccel_receive_frags(struct net_lro_mgr *lro_mgr,
560
 
                                    struct skb_frag_struct *frags,
561
 
                                    int len, int true_size,
562
 
                                    struct vlan_group *vgrp,
563
 
                                    u16 vlan_tag, void *priv, __wsum sum)
564
 
{
565
 
        struct sk_buff *skb;
566
 
 
567
 
        skb = __lro_proc_segment(lro_mgr, frags, len, true_size, vgrp,
568
 
                                 vlan_tag, priv, sum);
569
 
        if (!skb)
570
 
                return;
571
 
 
572
 
        if (lro_mgr->features & LRO_F_NAPI)
573
 
                vlan_hwaccel_receive_skb(skb, vgrp, vlan_tag);
574
 
        else
575
 
                vlan_hwaccel_rx(skb, vgrp, vlan_tag);
576
 
}
577
 
EXPORT_SYMBOL(lro_vlan_hwaccel_receive_frags);
578
 
 
579
527
void lro_flush_all(struct net_lro_mgr *lro_mgr)
580
528
{
581
529
        int i;