Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge rsync://rsync.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6
+259
-201
+2
-2
drivers/net/3c515.c
+2
-2
drivers/net/3c515.c
···
822
822
break; /* Bad news! */
823
823
skb->dev = dev; /* Mark as being used by this device. */
824
824
skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
825
-
vp->rx_ring[i].addr = isa_virt_to_bus(skb->tail);
825
+
vp->rx_ring[i].addr = isa_virt_to_bus(skb->data);
826
826
}
827
827
vp->rx_ring[i - 1].next = isa_virt_to_bus(&vp->rx_ring[0]); /* Wrap the ring. */
828
828
outl(isa_virt_to_bus(&vp->rx_ring[0]), ioaddr + UpListPtr);
···
1406
1406
break; /* Bad news! */
1407
1407
skb->dev = dev; /* Mark as being used by this device. */
1408
1408
skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1409
-
vp->rx_ring[entry].addr = isa_virt_to_bus(skb->tail);
1409
+
vp->rx_ring[entry].addr = isa_virt_to_bus(skb->data);
1410
1410
vp->rx_skbuff[entry] = skb;
1411
1411
}
1412
1412
vp->rx_ring[entry].status = 0; /* Clear complete bit. */
+3
-3
drivers/net/3c59x.c
+3
-3
drivers/net/3c59x.c
···
1802
1802
break; /* Bad news! */
1803
1803
skb->dev = dev; /* Mark as being used by this device. */
1804
1804
skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1805
-
vp->rx_ring[i].addr = cpu_to_le32(pci_map_single(VORTEX_PCI(vp), skb->tail, PKT_BUF_SZ, PCI_DMA_FROMDEVICE));
1805
+
vp->rx_ring[i].addr = cpu_to_le32(pci_map_single(VORTEX_PCI(vp), skb->data, PKT_BUF_SZ, PCI_DMA_FROMDEVICE));
1806
1806
}
1807
1807
if (i != RX_RING_SIZE) {
1808
1808
int j;
···
2632
2632
pci_dma_sync_single_for_cpu(VORTEX_PCI(vp), dma, PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
2633
2633
/* 'skb_put()' points to the start of sk_buff data area. */
2634
2634
memcpy(skb_put(skb, pkt_len),
2635
-
vp->rx_skbuff[entry]->tail,
2635
+
vp->rx_skbuff[entry]->data,
2636
2636
pkt_len);
2637
2637
pci_dma_sync_single_for_device(VORTEX_PCI(vp), dma, PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
2638
2638
vp->rx_copy++;
···
2678
2678
}
2679
2679
skb->dev = dev; /* Mark as being used by this device. */
2680
2680
skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
2681
-
vp->rx_ring[entry].addr = cpu_to_le32(pci_map_single(VORTEX_PCI(vp), skb->tail, PKT_BUF_SZ, PCI_DMA_FROMDEVICE));
2681
+
vp->rx_ring[entry].addr = cpu_to_le32(pci_map_single(VORTEX_PCI(vp), skb->data, PKT_BUF_SZ, PCI_DMA_FROMDEVICE));
2682
2682
vp->rx_skbuff[entry] = skb;
2683
2683
}
2684
2684
vp->rx_ring[entry].status = 0; /* Clear complete bit. */
+2
-2
drivers/net/8139cp.c
+2
-2
drivers/net/8139cp.c
···
596
596
597
597
mapping =
598
598
cp->rx_skb[rx_tail].mapping =
599
-
pci_map_single(cp->pdev, new_skb->tail,
599
+
pci_map_single(cp->pdev, new_skb->data,
600
600
buflen, PCI_DMA_FROMDEVICE);
601
601
cp->rx_skb[rx_tail].skb = new_skb;
602
602
···
1101
1101
skb_reserve(skb, RX_OFFSET);
1102
1102
1103
1103
cp->rx_skb[i].mapping = pci_map_single(cp->pdev,
1104
-
skb->tail, cp->rx_buf_sz, PCI_DMA_FROMDEVICE);
1104
+
skb->data, cp->rx_buf_sz, PCI_DMA_FROMDEVICE);
1105
1105
cp->rx_skb[i].skb = skb;
1106
1106
1107
1107
cp->rx_ring[i].opts2 = 0;
+7
-7
drivers/net/82596.c
+7
-7
drivers/net/82596.c
···
546
546
rbd->b_next = WSWAPrbd(virt_to_bus(rbd+1));
547
547
rbd->b_addr = WSWAPrbd(virt_to_bus(rbd));
548
548
rbd->skb = skb;
549
-
rbd->v_data = skb->tail;
550
-
rbd->b_data = WSWAPchar(virt_to_bus(skb->tail));
549
+
rbd->v_data = skb->data;
550
+
rbd->b_data = WSWAPchar(virt_to_bus(skb->data));
551
551
rbd->size = PKT_BUF_SZ;
552
552
#ifdef __mc68000__
553
-
cache_clear(virt_to_phys(skb->tail), PKT_BUF_SZ);
553
+
cache_clear(virt_to_phys(skb->data), PKT_BUF_SZ);
554
554
#endif
555
555
}
556
556
lp->rbd_head = lp->rbds;
···
816
816
rx_in_place = 1;
817
817
rbd->skb = newskb;
818
818
newskb->dev = dev;
819
-
rbd->v_data = newskb->tail;
820
-
rbd->b_data = WSWAPchar(virt_to_bus(newskb->tail));
819
+
rbd->v_data = newskb->data;
820
+
rbd->b_data = WSWAPchar(virt_to_bus(newskb->data));
821
821
#ifdef __mc68000__
822
-
cache_clear(virt_to_phys(newskb->tail), PKT_BUF_SZ);
822
+
cache_clear(virt_to_phys(newskb->data), PKT_BUF_SZ);
823
823
#endif
824
824
}
825
825
else
···
840
840
skb->protocol=eth_type_trans(skb,dev);
841
841
skb->len = pkt_len;
842
842
#ifdef __mc68000__
843
-
cache_clear(virt_to_phys(rbd->skb->tail),
843
+
cache_clear(virt_to_phys(rbd->skb->data),
844
844
pkt_len);
845
845
#endif
846
846
netif_rx(skb);
+4
-4
drivers/net/dl2k.c
+4
-4
drivers/net/dl2k.c
···
547
547
skb_reserve (skb, 2);
548
548
np->rx_ring[entry].fraginfo =
549
549
cpu_to_le64 (pci_map_single
550
-
(np->pdev, skb->tail, np->rx_buf_sz,
550
+
(np->pdev, skb->data, np->rx_buf_sz,
551
551
PCI_DMA_FROMDEVICE));
552
552
}
553
553
np->rx_ring[entry].fraginfo |=
···
618
618
/* Rubicon now supports 40 bits of addressing space. */
619
619
np->rx_ring[i].fraginfo =
620
620
cpu_to_le64 ( pci_map_single (
621
-
np->pdev, skb->tail, np->rx_buf_sz,
621
+
np->pdev, skb->data, np->rx_buf_sz,
622
622
PCI_DMA_FROMDEVICE));
623
623
np->rx_ring[i].fraginfo |= cpu_to_le64 (np->rx_buf_sz) << 48;
624
624
}
···
906
906
/* 16 byte align the IP header */
907
907
skb_reserve (skb, 2);
908
908
eth_copy_and_sum (skb,
909
-
np->rx_skbuff[entry]->tail,
909
+
np->rx_skbuff[entry]->data,
910
910
pkt_len, 0);
911
911
skb_put (skb, pkt_len);
912
912
pci_dma_sync_single_for_device(np->pdev,
···
950
950
skb_reserve (skb, 2);
951
951
np->rx_ring[entry].fraginfo =
952
952
cpu_to_le64 (pci_map_single
953
-
(np->pdev, skb->tail, np->rx_buf_sz,
953
+
(np->pdev, skb->data, np->rx_buf_sz,
954
954
PCI_DMA_FROMDEVICE));
955
955
}
956
956
np->rx_ring[entry].fraginfo |=
+4
-4
drivers/net/eepro100.c
+4
-4
drivers/net/eepro100.c
···
1269
1269
if (skb == NULL)
1270
1270
break; /* OK. Just initially short of Rx bufs. */
1271
1271
skb->dev = dev; /* Mark as being used by this device. */
1272
-
rxf = (struct RxFD *)skb->tail;
1272
+
rxf = (struct RxFD *)skb->data;
1273
1273
sp->rx_ringp[i] = rxf;
1274
1274
sp->rx_ring_dma[i] =
1275
1275
pci_map_single(sp->pdev, rxf,
···
1661
1661
sp->rx_ringp[entry] = NULL;
1662
1662
return NULL;
1663
1663
}
1664
-
rxf = sp->rx_ringp[entry] = (struct RxFD *)skb->tail;
1664
+
rxf = sp->rx_ringp[entry] = (struct RxFD *)skb->data;
1665
1665
sp->rx_ring_dma[entry] =
1666
1666
pci_map_single(sp->pdev, rxf,
1667
1667
PKT_BUF_SZ + sizeof(struct RxFD), PCI_DMA_FROMDEVICE);
···
1808
1808
1809
1809
#if 1 || USE_IP_CSUM
1810
1810
/* Packet is in one chunk -- we can copy + cksum. */
1811
-
eth_copy_and_sum(skb, sp->rx_skbuff[entry]->tail, pkt_len, 0);
1811
+
eth_copy_and_sum(skb, sp->rx_skbuff[entry]->data, pkt_len, 0);
1812
1812
skb_put(skb, pkt_len);
1813
1813
#else
1814
-
memcpy(skb_put(skb, pkt_len), sp->rx_skbuff[entry]->tail,
1814
+
memcpy(skb_put(skb, pkt_len), sp->rx_skbuff[entry]->data,
1815
1815
pkt_len);
1816
1816
#endif
1817
1817
pci_dma_sync_single_for_device(sp->pdev, sp->rx_ring_dma[entry],
+3
-3
drivers/net/epic100.c
+3
-3
drivers/net/epic100.c
···
1003
1003
skb->dev = dev; /* Mark as being used by this device. */
1004
1004
skb_reserve(skb, 2); /* 16 byte align the IP header. */
1005
1005
ep->rx_ring[i].bufaddr = pci_map_single(ep->pci_dev,
1006
-
skb->tail, ep->rx_buf_sz, PCI_DMA_FROMDEVICE);
1006
+
skb->data, ep->rx_buf_sz, PCI_DMA_FROMDEVICE);
1007
1007
ep->rx_ring[i].rxstatus = cpu_to_le32(DescOwn);
1008
1008
}
1009
1009
ep->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
···
1274
1274
ep->rx_ring[entry].bufaddr,
1275
1275
ep->rx_buf_sz,
1276
1276
PCI_DMA_FROMDEVICE);
1277
-
eth_copy_and_sum(skb, ep->rx_skbuff[entry]->tail, pkt_len, 0);
1277
+
eth_copy_and_sum(skb, ep->rx_skbuff[entry]->data, pkt_len, 0);
1278
1278
skb_put(skb, pkt_len);
1279
1279
pci_dma_sync_single_for_device(ep->pci_dev,
1280
1280
ep->rx_ring[entry].bufaddr,
···
1308
1308
skb->dev = dev; /* Mark as being used by this device. */
1309
1309
skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1310
1310
ep->rx_ring[entry].bufaddr = pci_map_single(ep->pci_dev,
1311
-
skb->tail, ep->rx_buf_sz, PCI_DMA_FROMDEVICE);
1311
+
skb->data, ep->rx_buf_sz, PCI_DMA_FROMDEVICE);
1312
1312
work_done++;
1313
1313
}
1314
1314
ep->rx_ring[entry].rxstatus = cpu_to_le32(DescOwn);
+4
-4
drivers/net/fealnx.c
+4
-4
drivers/net/fealnx.c
···
1107
1107
1108
1108
skb->dev = dev; /* Mark as being used by this device. */
1109
1109
np->lack_rxbuf->skbuff = skb;
1110
-
np->lack_rxbuf->buffer = pci_map_single(np->pci_dev, skb->tail,
1110
+
np->lack_rxbuf->buffer = pci_map_single(np->pci_dev, skb->data,
1111
1111
np->rx_buf_sz, PCI_DMA_FROMDEVICE);
1112
1112
np->lack_rxbuf->status = RXOWN;
1113
1113
++np->really_rx_count;
···
1300
1300
++np->really_rx_count;
1301
1301
np->rx_ring[i].skbuff = skb;
1302
1302
skb->dev = dev; /* Mark as being used by this device. */
1303
-
np->rx_ring[i].buffer = pci_map_single(np->pci_dev, skb->tail,
1303
+
np->rx_ring[i].buffer = pci_map_single(np->pci_dev, skb->data,
1304
1304
np->rx_buf_sz, PCI_DMA_FROMDEVICE);
1305
1305
np->rx_ring[i].status = RXOWN;
1306
1306
np->rx_ring[i].control |= RXIC;
···
1737
1737
1738
1738
#if ! defined(__alpha__)
1739
1739
eth_copy_and_sum(skb,
1740
-
np->cur_rx->skbuff->tail, pkt_len, 0);
1740
+
np->cur_rx->skbuff->data, pkt_len, 0);
1741
1741
skb_put(skb, pkt_len);
1742
1742
#else
1743
1743
memcpy(skb_put(skb, pkt_len),
1744
-
np->cur_rx->skbuff->tail, pkt_len);
1744
+
np->cur_rx->skbuff->data, pkt_len);
1745
1745
#endif
1746
1746
pci_dma_sync_single_for_device(np->pci_dev,
1747
1747
np->cur_rx->buffer,
+6
-6
drivers/net/hamachi.c
+6
-6
drivers/net/hamachi.c
···
1149
1149
skb->dev = dev; /* Mark as being used by this device. */
1150
1150
skb_reserve(skb, 2); /* 16 byte align the IP header. */
1151
1151
hmp->rx_ring[i].addr = cpu_to_leXX(pci_map_single(hmp->pci_dev,
1152
-
skb->tail, hmp->rx_buf_sz, PCI_DMA_FROMDEVICE));
1152
+
skb->data, hmp->rx_buf_sz, PCI_DMA_FROMDEVICE));
1153
1153
hmp->rx_ring[i].status_n_length = cpu_to_le32(DescOwn |
1154
1154
DescEndPacket | DescIntr | (hmp->rx_buf_sz - 2));
1155
1155
}
···
1210
1210
skb->dev = dev; /* Mark as being used by this device. */
1211
1211
skb_reserve(skb, 2); /* 16 byte align the IP header. */
1212
1212
hmp->rx_ring[i].addr = cpu_to_leXX(pci_map_single(hmp->pci_dev,
1213
-
skb->tail, hmp->rx_buf_sz, PCI_DMA_FROMDEVICE));
1213
+
skb->data, hmp->rx_buf_sz, PCI_DMA_FROMDEVICE));
1214
1214
/* -2 because it doesn't REALLY have that first 2 bytes -KDU */
1215
1215
hmp->rx_ring[i].status_n_length = cpu_to_le32(DescOwn |
1216
1216
DescEndPacket | DescIntr | (hmp->rx_buf_sz -2));
···
1509
1509
desc->addr,
1510
1510
hmp->rx_buf_sz,
1511
1511
PCI_DMA_FROMDEVICE);
1512
-
buf_addr = (u8 *) hmp->rx_skbuff[entry]->tail;
1512
+
buf_addr = (u8 *) hmp->rx_skbuff[entry]->data;
1513
1513
frame_status = le32_to_cpu(get_unaligned((s32*)&(buf_addr[data_size - 12])));
1514
1514
if (hamachi_debug > 4)
1515
1515
printk(KERN_DEBUG " hamachi_rx() status was %8.8x.\n",
···
1678
1678
skb->dev = dev; /* Mark as being used by this device. */
1679
1679
skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1680
1680
desc->addr = cpu_to_leXX(pci_map_single(hmp->pci_dev,
1681
-
skb->tail, hmp->rx_buf_sz, PCI_DMA_FROMDEVICE));
1681
+
skb->data, hmp->rx_buf_sz, PCI_DMA_FROMDEVICE));
1682
1682
}
1683
1683
desc->status_n_length = cpu_to_le32(hmp->rx_buf_sz);
1684
1684
if (entry >= RX_RING_SIZE-1)
···
1772
1772
readl(ioaddr + RxCurPtr) == (long)&hmp->rx_ring[i] ? '>' : ' ',
1773
1773
i, hmp->rx_ring[i].status_n_length, hmp->rx_ring[i].addr);
1774
1774
if (hamachi_debug > 6) {
1775
-
if (*(u8*)hmp->rx_skbuff[i]->tail != 0x69) {
1775
+
if (*(u8*)hmp->rx_skbuff[i]->data != 0x69) {
1776
1776
u16 *addr = (u16 *)
1777
-
hmp->rx_skbuff[i]->tail;
1777
+
hmp->rx_skbuff[i]->data;
1778
1778
int j;
1779
1779
1780
1780
for (j = 0; j < 0x50; j++)
+1
-1
drivers/net/lance.c
+1
-1
drivers/net/lance.c
+4
-4
drivers/net/lasi_82596.c
+4
-4
drivers/net/lasi_82596.c
···
553
553
if (skb == NULL)
554
554
panic("%s: alloc_skb() failed", __FILE__);
555
555
skb_reserve(skb, 2);
556
-
dma_addr = dma_map_single(lp->dev, skb->tail,PKT_BUF_SZ,
556
+
dma_addr = dma_map_single(lp->dev, skb->data,PKT_BUF_SZ,
557
557
DMA_FROM_DEVICE);
558
558
skb->dev = dev;
559
559
rbd->v_next = rbd+1;
560
560
rbd->b_next = WSWAPrbd(virt_to_dma(lp,rbd+1));
561
561
rbd->b_addr = WSWAPrbd(virt_to_dma(lp,rbd));
562
562
rbd->skb = skb;
563
-
rbd->v_data = skb->tail;
563
+
rbd->v_data = skb->data;
564
564
rbd->b_data = WSWAPchar(dma_addr);
565
565
rbd->size = PKT_BUF_SZ;
566
566
}
···
783
783
rx_in_place = 1;
784
784
rbd->skb = newskb;
785
785
newskb->dev = dev;
786
-
dma_addr = dma_map_single(lp->dev, newskb->tail, PKT_BUF_SZ, DMA_FROM_DEVICE);
787
-
rbd->v_data = newskb->tail;
786
+
dma_addr = dma_map_single(lp->dev, newskb->data, PKT_BUF_SZ, DMA_FROM_DEVICE);
787
+
rbd->v_data = newskb->data;
788
788
rbd->b_data = WSWAPchar(dma_addr);
789
789
CHECK_WBACK_INV(rbd, sizeof(struct i596_rbd));
790
790
}
+2
-2
drivers/net/natsemi.c
+2
-2
drivers/net/natsemi.c
···
1926
1926
break; /* Better luck next round. */
1927
1927
skb->dev = dev; /* Mark as being used by this device. */
1928
1928
np->rx_dma[entry] = pci_map_single(np->pci_dev,
1929
-
skb->tail, buflen, PCI_DMA_FROMDEVICE);
1929
+
skb->data, buflen, PCI_DMA_FROMDEVICE);
1930
1930
np->rx_ring[entry].addr = cpu_to_le32(np->rx_dma[entry]);
1931
1931
}
1932
1932
np->rx_ring[entry].cmd_status = cpu_to_le32(np->rx_buf_sz);
···
2280
2280
buflen,
2281
2281
PCI_DMA_FROMDEVICE);
2282
2282
eth_copy_and_sum(skb,
2283
-
np->rx_skbuff[entry]->tail, pkt_len, 0);
2283
+
np->rx_skbuff[entry]->data, pkt_len, 0);
2284
2284
skb_put(skb, pkt_len);
2285
2285
pci_dma_sync_single_for_device(np->pci_dev,
2286
2286
np->rx_dma[entry],
+2
-2
drivers/net/ns83820.c
+2
-2
drivers/net/ns83820.c
···
574
574
575
575
dev->rx_info.next_empty = (next_empty + 1) % NR_RX_DESC;
576
576
cmdsts = REAL_RX_BUF_SIZE | CMDSTS_INTR;
577
-
buf = pci_map_single(dev->pci_dev, skb->tail,
577
+
buf = pci_map_single(dev->pci_dev, skb->data,
578
578
REAL_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
579
579
build_rx_desc(dev, sg, 0, buf, cmdsts, 0);
580
580
/* update link of previous rx */
···
604
604
if (unlikely(!skb))
605
605
break;
606
606
607
-
res = (long)skb->tail & 0xf;
607
+
res = (long)skb->data & 0xf;
608
608
res = 0x10 - res;
609
609
res &= 0xf;
610
610
skb_reserve(skb, res);
+3
-3
drivers/net/pcnet32.c
+3
-3
drivers/net/pcnet32.c
···
1602
1602
1603
1603
rmb();
1604
1604
if (lp->rx_dma_addr[i] == 0)
1605
-
lp->rx_dma_addr[i] = pci_map_single(lp->pci_dev, rx_skbuff->tail,
1605
+
lp->rx_dma_addr[i] = pci_map_single(lp->pci_dev, rx_skbuff->data,
1606
1606
PKT_BUF_SZ-2, PCI_DMA_FROMDEVICE);
1607
1607
lp->rx_ring[i].base = (u32)le32_to_cpu(lp->rx_dma_addr[i]);
1608
1608
lp->rx_ring[i].buf_length = le16_to_cpu(2-PKT_BUF_SZ);
···
1983
1983
lp->rx_skbuff[entry] = newskb;
1984
1984
newskb->dev = dev;
1985
1985
lp->rx_dma_addr[entry] =
1986
-
pci_map_single(lp->pci_dev, newskb->tail,
1986
+
pci_map_single(lp->pci_dev, newskb->data,
1987
1987
PKT_BUF_SZ-2, PCI_DMA_FROMDEVICE);
1988
1988
lp->rx_ring[entry].base = le32_to_cpu(lp->rx_dma_addr[entry]);
1989
1989
rx_in_place = 1;
···
2020
2020
PKT_BUF_SZ-2,
2021
2021
PCI_DMA_FROMDEVICE);
2022
2022
eth_copy_and_sum(skb,
2023
-
(unsigned char *)(lp->rx_skbuff[entry]->tail),
2023
+
(unsigned char *)(lp->rx_skbuff[entry]->data),
2024
2024
pkt_len,0);
2025
2025
pci_dma_sync_single_for_device(lp->pci_dev,
2026
2026
lp->rx_dma_addr[entry],
+2
-2
drivers/net/r8169.c
+2
-2
drivers/net/r8169.c
···
1876
1876
skb_reserve(skb, NET_IP_ALIGN);
1877
1877
*sk_buff = skb;
1878
1878
1879
-
mapping = pci_map_single(pdev, skb->tail, rx_buf_sz,
1879
+
mapping = pci_map_single(pdev, skb->data, rx_buf_sz,
1880
1880
PCI_DMA_FROMDEVICE);
1881
1881
1882
1882
rtl8169_map_to_asic(desc, mapping, rx_buf_sz);
···
2336
2336
skb = dev_alloc_skb(pkt_size + NET_IP_ALIGN);
2337
2337
if (skb) {
2338
2338
skb_reserve(skb, NET_IP_ALIGN);
2339
-
eth_copy_and_sum(skb, sk_buff[0]->tail, pkt_size, 0);
2339
+
eth_copy_and_sum(skb, sk_buff[0]->data, pkt_size, 0);
2340
2340
*sk_buff = skb;
2341
2341
rtl8169_mark_to_asic(desc, rx_buf_sz);
2342
2342
ret = 0;
+3
-5
drivers/net/s2io.c
+3
-5
drivers/net/s2io.c
···
1699
1699
#else
1700
1700
ba = &nic->ba[ring_no][block_no][off];
1701
1701
skb_reserve(skb, BUF0_LEN);
1702
-
tmp = (unsigned long) skb->data;
1703
-
tmp += ALIGN_SIZE;
1704
-
tmp &= ~ALIGN_SIZE;
1705
-
skb->data = (void *) tmp;
1706
-
skb->tail = (void *) tmp;
1702
+
tmp = ((unsigned long) skb->data & ALIGN_SIZE);
1703
+
if (tmp)
1704
+
skb_reserve(skb, (ALIGN_SIZE + 1) - tmp);
1707
1705
1708
1706
memset(rxdp, 0, sizeof(RxD_t));
1709
1707
rxdp->Buffer2_ptr = pci_map_single
+2
-2
drivers/net/sb1250-mac.c
+2
-2
drivers/net/sb1250-mac.c
···
963
963
/*
964
964
* Do not interrupt per DMA transfer.
965
965
*/
966
-
dsc->dscr_a = virt_to_phys(sb_new->tail) |
966
+
dsc->dscr_a = virt_to_phys(sb_new->data) |
967
967
V_DMA_DSCRA_A_SIZE(NUMCACHEBLKS(pktsize+ETHER_ALIGN)) |
968
968
0;
969
969
#else
970
-
dsc->dscr_a = virt_to_phys(sb_new->tail) |
970
+
dsc->dscr_a = virt_to_phys(sb_new->data) |
971
971
V_DMA_DSCRA_A_SIZE(NUMCACHEBLKS(pktsize+ETHER_ALIGN)) |
972
972
M_DMA_DSCRA_INTERRUPT;
973
973
#endif
+3
-3
drivers/net/sis900.c
+3
-3
drivers/net/sis900.c
···
1154
1154
sis_priv->rx_skbuff[i] = skb;
1155
1155
sis_priv->rx_ring[i].cmdsts = RX_BUF_SIZE;
1156
1156
sis_priv->rx_ring[i].bufptr = pci_map_single(sis_priv->pci_dev,
1157
-
skb->tail, RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
1157
+
skb->data, RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
1158
1158
}
1159
1159
sis_priv->dirty_rx = (unsigned int) (i - NUM_RX_DESC);
1160
1160
···
1776
1776
sis_priv->rx_skbuff[entry] = skb;
1777
1777
sis_priv->rx_ring[entry].cmdsts = RX_BUF_SIZE;
1778
1778
sis_priv->rx_ring[entry].bufptr =
1779
-
pci_map_single(sis_priv->pci_dev, skb->tail,
1779
+
pci_map_single(sis_priv->pci_dev, skb->data,
1780
1780
RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
1781
1781
sis_priv->dirty_rx++;
1782
1782
}
···
1809
1809
sis_priv->rx_skbuff[entry] = skb;
1810
1810
sis_priv->rx_ring[entry].cmdsts = RX_BUF_SIZE;
1811
1811
sis_priv->rx_ring[entry].bufptr =
1812
-
pci_map_single(sis_priv->pci_dev, skb->tail,
1812
+
pci_map_single(sis_priv->pci_dev, skb->data,
1813
1813
RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
1814
1814
}
1815
1815
}
+1
drivers/net/slip.c
+1
drivers/net/slip.c
+3
-3
drivers/net/starfire.c
+3
-3
drivers/net/starfire.c
···
1286
1286
np->rx_info[i].skb = skb;
1287
1287
if (skb == NULL)
1288
1288
break;
1289
-
np->rx_info[i].mapping = pci_map_single(np->pci_dev, skb->tail, np->rx_buf_sz, PCI_DMA_FROMDEVICE);
1289
+
np->rx_info[i].mapping = pci_map_single(np->pci_dev, skb->data, np->rx_buf_sz, PCI_DMA_FROMDEVICE);
1290
1290
skb->dev = dev; /* Mark as being used by this device. */
1291
1291
/* Grrr, we cannot offset to correctly align the IP header. */
1292
1292
np->rx_ring[i].rxaddr = cpu_to_dma(np->rx_info[i].mapping | RxDescValid);
···
1572
1572
pci_dma_sync_single_for_cpu(np->pci_dev,
1573
1573
np->rx_info[entry].mapping,
1574
1574
pkt_len, PCI_DMA_FROMDEVICE);
1575
-
eth_copy_and_sum(skb, np->rx_info[entry].skb->tail, pkt_len, 0);
1575
+
eth_copy_and_sum(skb, np->rx_info[entry].skb->data, pkt_len, 0);
1576
1576
pci_dma_sync_single_for_device(np->pci_dev,
1577
1577
np->rx_info[entry].mapping,
1578
1578
pkt_len, PCI_DMA_FROMDEVICE);
···
1696
1696
if (skb == NULL)
1697
1697
break; /* Better luck next round. */
1698
1698
np->rx_info[entry].mapping =
1699
-
pci_map_single(np->pci_dev, skb->tail, np->rx_buf_sz, PCI_DMA_FROMDEVICE);
1699
+
pci_map_single(np->pci_dev, skb->data, np->rx_buf_sz, PCI_DMA_FROMDEVICE);
1700
1700
skb->dev = dev; /* Mark as being used by this device. */
1701
1701
np->rx_ring[entry].rxaddr =
1702
1702
cpu_to_dma(np->rx_info[entry].mapping | RxDescValid);
+3
-3
drivers/net/sundance.c
+3
-3
drivers/net/sundance.c
···
1028
1028
skb->dev = dev; /* Mark as being used by this device. */
1029
1029
skb_reserve(skb, 2); /* 16 byte align the IP header. */
1030
1030
np->rx_ring[i].frag[0].addr = cpu_to_le32(
1031
-
pci_map_single(np->pci_dev, skb->tail, np->rx_buf_sz,
1031
+
pci_map_single(np->pci_dev, skb->data, np->rx_buf_sz,
1032
1032
PCI_DMA_FROMDEVICE));
1033
1033
np->rx_ring[i].frag[0].length = cpu_to_le32(np->rx_buf_sz | LastFrag);
1034
1034
}
···
1341
1341
np->rx_buf_sz,
1342
1342
PCI_DMA_FROMDEVICE);
1343
1343
1344
-
eth_copy_and_sum(skb, np->rx_skbuff[entry]->tail, pkt_len, 0);
1344
+
eth_copy_and_sum(skb, np->rx_skbuff[entry]->data, pkt_len, 0);
1345
1345
pci_dma_sync_single_for_device(np->pci_dev,
1346
1346
desc->frag[0].addr,
1347
1347
np->rx_buf_sz,
···
1400
1400
skb->dev = dev; /* Mark as being used by this device. */
1401
1401
skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1402
1402
np->rx_ring[entry].frag[0].addr = cpu_to_le32(
1403
-
pci_map_single(np->pci_dev, skb->tail,
1403
+
pci_map_single(np->pci_dev, skb->data,
1404
1404
np->rx_buf_sz, PCI_DMA_FROMDEVICE));
1405
1405
}
1406
1406
/* Perhaps we need not reset this field. */
+3
-3
drivers/net/tulip/de2104x.c
+3
-3
drivers/net/tulip/de2104x.c
···
446
446
447
447
mapping =
448
448
de->rx_skb[rx_tail].mapping =
449
-
pci_map_single(de->pdev, copy_skb->tail,
449
+
pci_map_single(de->pdev, copy_skb->data,
450
450
buflen, PCI_DMA_FROMDEVICE);
451
451
de->rx_skb[rx_tail].skb = copy_skb;
452
452
} else {
453
453
pci_dma_sync_single_for_cpu(de->pdev, mapping, len, PCI_DMA_FROMDEVICE);
454
454
skb_reserve(copy_skb, RX_OFFSET);
455
-
memcpy(skb_put(copy_skb, len), skb->tail, len);
455
+
memcpy(skb_put(copy_skb, len), skb->data, len);
456
456
457
457
pci_dma_sync_single_for_device(de->pdev, mapping, len, PCI_DMA_FROMDEVICE);
458
458
···
1269
1269
skb->dev = de->dev;
1270
1270
1271
1271
de->rx_skb[i].mapping = pci_map_single(de->pdev,
1272
-
skb->tail, de->rx_buf_sz, PCI_DMA_FROMDEVICE);
1272
+
skb->data, de->rx_buf_sz, PCI_DMA_FROMDEVICE);
1273
1273
de->rx_skb[i].skb = skb;
1274
1274
1275
1275
de->rx_ring[i].opts1 = cpu_to_le32(DescOwn);
+5
-5
drivers/net/tulip/dmfe.c
+5
-5
drivers/net/tulip/dmfe.c
···
945
945
946
946
/* Received Packet CRC check need or not */
947
947
if ( (db->dm910x_chk_mode & 1) &&
948
-
(cal_CRC(skb->tail, rxlen, 1) !=
949
-
(*(u32 *) (skb->tail+rxlen) ))) { /* FIXME (?) */
948
+
(cal_CRC(skb->data, rxlen, 1) !=
949
+
(*(u32 *) (skb->data+rxlen) ))) { /* FIXME (?) */
950
950
/* Found a error received packet */
951
951
dmfe_reuse_skb(db, rxptr->rx_skb_ptr);
952
952
db->dm910x_chk_mode = 3;
···
959
959
/* size less than COPY_SIZE, allocate a rxlen SKB */
960
960
skb->dev = dev;
961
961
skb_reserve(skb, 2); /* 16byte align */
962
-
memcpy(skb_put(skb, rxlen), rxptr->rx_skb_ptr->tail, rxlen);
962
+
memcpy(skb_put(skb, rxlen), rxptr->rx_skb_ptr->data, rxlen);
963
963
dmfe_reuse_skb(db, rxptr->rx_skb_ptr);
964
964
} else {
965
965
skb->dev = dev;
···
1252
1252
1253
1253
if (!(rxptr->rdes0 & cpu_to_le32(0x80000000))) {
1254
1254
rxptr->rx_skb_ptr = skb;
1255
-
rxptr->rdes2 = cpu_to_le32( pci_map_single(db->pdev, skb->tail, RX_ALLOC_SIZE, PCI_DMA_FROMDEVICE) );
1255
+
rxptr->rdes2 = cpu_to_le32( pci_map_single(db->pdev, skb->data, RX_ALLOC_SIZE, PCI_DMA_FROMDEVICE) );
1256
1256
wmb();
1257
1257
rxptr->rdes0 = cpu_to_le32(0x80000000);
1258
1258
db->rx_avail_cnt++;
···
1463
1463
if ( ( skb = dev_alloc_skb(RX_ALLOC_SIZE) ) == NULL )
1464
1464
break;
1465
1465
rxptr->rx_skb_ptr = skb; /* FIXME (?) */
1466
-
rxptr->rdes2 = cpu_to_le32( pci_map_single(db->pdev, skb->tail, RX_ALLOC_SIZE, PCI_DMA_FROMDEVICE) );
1466
+
rxptr->rdes2 = cpu_to_le32( pci_map_single(db->pdev, skb->data, RX_ALLOC_SIZE, PCI_DMA_FROMDEVICE) );
1467
1467
wmb();
1468
1468
rxptr->rdes0 = cpu_to_le32(0x80000000);
1469
1469
rxptr = rxptr->next_rx_desc;
+5
-5
drivers/net/tulip/interrupt.c
+5
-5
drivers/net/tulip/interrupt.c
···
78
78
if (skb == NULL)
79
79
break;
80
80
81
-
mapping = pci_map_single(tp->pdev, skb->tail, PKT_BUF_SZ,
81
+
mapping = pci_map_single(tp->pdev, skb->data, PKT_BUF_SZ,
82
82
PCI_DMA_FROMDEVICE);
83
83
tp->rx_buffers[entry].mapping = mapping;
84
84
···
199
199
tp->rx_buffers[entry].mapping,
200
200
pkt_len, PCI_DMA_FROMDEVICE);
201
201
#if ! defined(__alpha__)
202
-
eth_copy_and_sum(skb, tp->rx_buffers[entry].skb->tail,
202
+
eth_copy_and_sum(skb, tp->rx_buffers[entry].skb->data,
203
203
pkt_len, 0);
204
204
skb_put(skb, pkt_len);
205
205
#else
206
206
memcpy(skb_put(skb, pkt_len),
207
-
tp->rx_buffers[entry].skb->tail,
207
+
tp->rx_buffers[entry].skb->data,
208
208
pkt_len);
209
209
#endif
210
210
pci_dma_sync_single_for_device(tp->pdev,
···
423
423
tp->rx_buffers[entry].mapping,
424
424
pkt_len, PCI_DMA_FROMDEVICE);
425
425
#if ! defined(__alpha__)
426
-
eth_copy_and_sum(skb, tp->rx_buffers[entry].skb->tail,
426
+
eth_copy_and_sum(skb, tp->rx_buffers[entry].skb->data,
427
427
pkt_len, 0);
428
428
skb_put(skb, pkt_len);
429
429
#else
430
430
memcpy(skb_put(skb, pkt_len),
431
-
tp->rx_buffers[entry].skb->tail,
431
+
tp->rx_buffers[entry].skb->data,
432
432
pkt_len);
433
433
#endif
434
434
pci_dma_sync_single_for_device(tp->pdev,
+1
-1
drivers/net/tulip/tulip_core.c
+1
-1
drivers/net/tulip/tulip_core.c
···
625
625
tp->rx_buffers[i].skb = skb;
626
626
if (skb == NULL)
627
627
break;
628
-
mapping = pci_map_single(tp->pdev, skb->tail,
628
+
mapping = pci_map_single(tp->pdev, skb->data,
629
629
PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
630
630
tp->rx_buffers[i].mapping = mapping;
631
631
skb->dev = dev; /* Mark as being used by this device. */
+3
-3
drivers/net/tulip/winbond-840.c
+3
-3
drivers/net/tulip/winbond-840.c
···
849
849
if (skb == NULL)
850
850
break;
851
851
skb->dev = dev; /* Mark as being used by this device. */
852
-
np->rx_addr[i] = pci_map_single(np->pci_dev,skb->tail,
852
+
np->rx_addr[i] = pci_map_single(np->pci_dev,skb->data,
853
853
skb->len,PCI_DMA_FROMDEVICE);
854
854
855
855
np->rx_ring[i].buffer1 = np->rx_addr[i];
···
1269
1269
pci_dma_sync_single_for_cpu(np->pci_dev,np->rx_addr[entry],
1270
1270
np->rx_skbuff[entry]->len,
1271
1271
PCI_DMA_FROMDEVICE);
1272
-
eth_copy_and_sum(skb, np->rx_skbuff[entry]->tail, pkt_len, 0);
1272
+
eth_copy_and_sum(skb, np->rx_skbuff[entry]->data, pkt_len, 0);
1273
1273
skb_put(skb, pkt_len);
1274
1274
pci_dma_sync_single_for_device(np->pci_dev,np->rx_addr[entry],
1275
1275
np->rx_skbuff[entry]->len,
···
1315
1315
break; /* Better luck next round. */
1316
1316
skb->dev = dev; /* Mark as being used by this device. */
1317
1317
np->rx_addr[entry] = pci_map_single(np->pci_dev,
1318
-
skb->tail,
1318
+
skb->data,
1319
1319
skb->len, PCI_DMA_FROMDEVICE);
1320
1320
np->rx_ring[entry].buffer1 = np->rx_addr[entry];
1321
1321
}
+2
-2
drivers/net/tulip/xircom_tulip_cb.c
+2
-2
drivers/net/tulip/xircom_tulip_cb.c
···
899
899
break;
900
900
skb->dev = dev; /* Mark as being used by this device. */
901
901
tp->rx_ring[i].status = Rx0DescOwned; /* Owned by Xircom chip */
902
-
tp->rx_ring[i].buffer1 = virt_to_bus(skb->tail);
902
+
tp->rx_ring[i].buffer1 = virt_to_bus(skb->data);
903
903
}
904
904
tp->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
905
905
···
1291
1291
if (skb == NULL)
1292
1292
break;
1293
1293
skb->dev = dev; /* Mark as being used by this device. */
1294
-
tp->rx_ring[entry].buffer1 = virt_to_bus(skb->tail);
1294
+
tp->rx_ring[entry].buffer1 = virt_to_bus(skb->data);
1295
1295
work_done++;
1296
1296
}
1297
1297
tp->rx_ring[entry].status = Rx0DescOwned;
+2
-2
drivers/net/typhoon.c
+2
-2
drivers/net/typhoon.c
···
1661
1661
#endif
1662
1662
1663
1663
skb->dev = tp->dev;
1664
-
dma_addr = pci_map_single(tp->pdev, skb->tail,
1664
+
dma_addr = pci_map_single(tp->pdev, skb->data,
1665
1665
PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
1666
1666
1667
1667
/* Since no card does 64 bit DAC, the high bits will never
···
1721
1721
pci_dma_sync_single_for_cpu(tp->pdev, dma_addr,
1722
1722
PKT_BUF_SZ,
1723
1723
PCI_DMA_FROMDEVICE);
1724
-
eth_copy_and_sum(new_skb, skb->tail, pkt_len, 0);
1724
+
eth_copy_and_sum(new_skb, skb->data, pkt_len, 0);
1725
1725
pci_dma_sync_single_for_device(tp->pdev, dma_addr,
1726
1726
PKT_BUF_SZ,
1727
1727
PCI_DMA_FROMDEVICE);
+3
-3
drivers/net/via-rhine.c
+3
-3
drivers/net/via-rhine.c
···
990
990
skb->dev = dev; /* Mark as being used by this device. */
991
991
992
992
rp->rx_skbuff_dma[i] =
993
-
pci_map_single(rp->pdev, skb->tail, rp->rx_buf_sz,
993
+
pci_map_single(rp->pdev, skb->data, rp->rx_buf_sz,
994
994
PCI_DMA_FROMDEVICE);
995
995
996
996
rp->rx_ring[i].addr = cpu_to_le32(rp->rx_skbuff_dma[i]);
···
1518
1518
PCI_DMA_FROMDEVICE);
1519
1519
1520
1520
eth_copy_and_sum(skb,
1521
-
rp->rx_skbuff[entry]->tail,
1521
+
rp->rx_skbuff[entry]->data,
1522
1522
pkt_len, 0);
1523
1523
skb_put(skb, pkt_len);
1524
1524
pci_dma_sync_single_for_device(rp->pdev,
···
1561
1561
break; /* Better luck next round. */
1562
1562
skb->dev = dev; /* Mark as being used by this device. */
1563
1563
rp->rx_skbuff_dma[entry] =
1564
-
pci_map_single(rp->pdev, skb->tail,
1564
+
pci_map_single(rp->pdev, skb->data,
1565
1565
rp->rx_buf_sz,
1566
1566
PCI_DMA_FROMDEVICE);
1567
1567
rp->rx_ring[entry].addr = cpu_to_le32(rp->rx_skbuff_dma[entry]);
+3
-3
drivers/net/via-velocity.c
+3
-3
drivers/net/via-velocity.c
···
1335
1335
if (vptr->flags & VELOCITY_FLAGS_IP_ALIGN)
1336
1336
skb_reserve(new_skb, 2);
1337
1337
1338
-
memcpy(new_skb->data, rx_skb[0]->tail, pkt_size);
1338
+
memcpy(new_skb->data, rx_skb[0]->data, pkt_size);
1339
1339
*rx_skb = new_skb;
1340
1340
ret = 0;
1341
1341
}
···
1456
1456
* Do the gymnastics to get the buffer head for data at
1457
1457
* 64byte alignment.
1458
1458
*/
1459
-
skb_reserve(rd_info->skb, (unsigned long) rd_info->skb->tail & 63);
1459
+
skb_reserve(rd_info->skb, (unsigned long) rd_info->skb->data & 63);
1460
1460
rd_info->skb->dev = vptr->dev;
1461
-
rd_info->skb_dma = pci_map_single(vptr->pdev, rd_info->skb->tail, vptr->rx_buf_sz, PCI_DMA_FROMDEVICE);
1461
+
rd_info->skb_dma = pci_map_single(vptr->pdev, rd_info->skb->data, vptr->rx_buf_sz, PCI_DMA_FROMDEVICE);
1462
1462
1463
1463
/*
1464
1464
* Fill in the descriptor to match
+1
-1
drivers/net/wan/hdlc_cisco.c
+1
-1
drivers/net/wan/hdlc_cisco.c
+4
-4
drivers/net/yellowfin.c
+4
-4
drivers/net/yellowfin.c
···
786
786
skb->dev = dev; /* Mark as being used by this device. */
787
787
skb_reserve(skb, 2); /* 16 byte align the IP header. */
788
788
yp->rx_ring[i].addr = cpu_to_le32(pci_map_single(yp->pci_dev,
789
-
skb->tail, yp->rx_buf_sz, PCI_DMA_FROMDEVICE));
789
+
skb->data, yp->rx_buf_sz, PCI_DMA_FROMDEVICE));
790
790
}
791
791
yp->rx_ring[i-1].dbdma_cmd = cpu_to_le32(CMD_STOP);
792
792
yp->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
···
1111
1111
pci_dma_sync_single_for_cpu(yp->pci_dev, desc->addr,
1112
1112
yp->rx_buf_sz, PCI_DMA_FROMDEVICE);
1113
1113
desc_status = le32_to_cpu(desc->result_status) >> 16;
1114
-
buf_addr = rx_skb->tail;
1114
+
buf_addr = rx_skb->data;
1115
1115
data_size = (le32_to_cpu(desc->dbdma_cmd) -
1116
1116
le32_to_cpu(desc->result_status)) & 0xffff;
1117
1117
frame_status = le16_to_cpu(get_unaligned((s16*)&(buf_addr[data_size - 2])));
···
1185
1185
break;
1186
1186
skb->dev = dev;
1187
1187
skb_reserve(skb, 2); /* 16 byte align the IP header */
1188
-
eth_copy_and_sum(skb, rx_skb->tail, pkt_len, 0);
1188
+
eth_copy_and_sum(skb, rx_skb->data, pkt_len, 0);
1189
1189
skb_put(skb, pkt_len);
1190
1190
pci_dma_sync_single_for_device(yp->pci_dev, desc->addr,
1191
1191
yp->rx_buf_sz,
···
1211
1211
skb->dev = dev; /* Mark as being used by this device. */
1212
1212
skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1213
1213
yp->rx_ring[entry].addr = cpu_to_le32(pci_map_single(yp->pci_dev,
1214
-
skb->tail, yp->rx_buf_sz, PCI_DMA_FROMDEVICE));
1214
+
skb->data, yp->rx_buf_sz, PCI_DMA_FROMDEVICE));
1215
1215
}
1216
1216
yp->rx_ring[entry].dbdma_cmd = cpu_to_le32(CMD_STOP);
1217
1217
yp->rx_ring[entry].result_status = 0; /* Clear complete bit. */
+1
include/linux/etherdevice.h
+1
include/linux/etherdevice.h
+1
-1
include/linux/in6.h
+1
-1
include/linux/in6.h
+1
include/linux/netlink.h
+1
include/linux/netlink.h
+1
include/linux/pkt_cls.h
+1
include/linux/pkt_cls.h
+6
-3
include/linux/pkt_sched.h
+6
-3
include/linux/pkt_sched.h
···
221
221
/* gred setup */
222
222
struct tc_gred_sopt
223
223
{
224
-
__u32 DPs;
225
-
__u32 def_DP;
226
-
__u8 grio;
224
+
__u32 DPs;
225
+
__u32 def_DP;
226
+
__u8 grio;
227
+
__u8 pad1;
228
+
__u16 pad2;
227
229
};
228
230
229
231
/* HTB section */
···
353
351
#define TC_CBQ_OVL_DROP 3
354
352
#define TC_CBQ_OVL_RCLASSIC 4
355
353
unsigned char priority2;
354
+
__u16 pad;
356
355
__u32 penalty;
357
356
};
358
357
+9
-1
include/linux/rtnetlink.h
+9
-1
include/linux/rtnetlink.h
···
363
363
struct rta_session
364
364
{
365
365
__u8 proto;
366
+
__u8 pad1;
367
+
__u16 pad2;
366
368
367
369
union {
368
370
struct {
···
637
635
struct prefixmsg
638
636
{
639
637
unsigned char prefix_family;
638
+
unsigned char prefix_pad1;
639
+
unsigned short prefix_pad2;
640
640
int prefix_ifindex;
641
641
unsigned char prefix_type;
642
642
unsigned char prefix_len;
643
643
unsigned char prefix_flags;
644
+
unsigned char prefix_pad3;
644
645
};
645
646
646
647
enum
···
903
898
memcpy(skb_put(skb, attrlen), data, attrlen); })
904
899
905
900
#define RTA_PUT_NOHDR(skb, attrlen, data) \
906
-
RTA_APPEND(skb, RTA_ALIGN(attrlen), data)
901
+
({ RTA_APPEND(skb, RTA_ALIGN(attrlen), data); \
902
+
memset(skb->tail - (RTA_ALIGN(attrlen) - attrlen), 0, \
903
+
RTA_ALIGN(attrlen) - attrlen); })
907
904
908
905
#define RTA_PUT_U8(skb, attrtype, value) \
909
906
({ u8 _tmp = (value); \
···
985
978
rta = (struct rtattr*)skb_put(skb, RTA_ALIGN(size));
986
979
rta->rta_type = attrtype;
987
980
rta->rta_len = size;
981
+
memset(RTA_DATA(rta) + attrlen, 0, RTA_ALIGN(size) - size);
988
982
return rta;
989
983
}
990
984
+1
include/linux/sysctl.h
+1
include/linux/sysctl.h
-1
include/net/ipv6.h
-1
include/net/ipv6.h
+3
-15
include/net/sctp/constants.h
+3
-15
include/net/sctp/constants.h
···
263
263
enum { SCTP_MAX_DUP_TSNS = 16 };
264
264
enum { SCTP_MAX_GABS = 16 };
265
265
266
-
/* Here we define the default timers. */
266
+
/* Heartbeat interval - 30 secs */
267
+
#define SCTP_DEFAULT_TIMEOUT_HEARTBEAT (30 * HZ)
267
268
268
-
/* cookie timer def = ? seconds */
269
-
#define SCTP_DEFAULT_TIMEOUT_T1_COOKIE (3 * HZ)
270
-
271
-
/* init timer def = 3 seconds */
272
-
#define SCTP_DEFAULT_TIMEOUT_T1_INIT (3 * HZ)
273
-
274
-
/* shutdown timer def = 300 ms */
275
-
#define SCTP_DEFAULT_TIMEOUT_T2_SHUTDOWN ((300 * HZ) / 1000)
276
-
277
-
/* 0 seconds + RTO */
278
-
#define SCTP_DEFAULT_TIMEOUT_HEARTBEAT (10 * HZ)
279
-
280
-
/* recv timer def = 200ms (in usec) */
269
+
/* Delayed sack timer - 200ms */
281
270
#define SCTP_DEFAULT_TIMEOUT_SACK ((200 * HZ) / 1000)
282
-
#define SCTP_DEFAULT_TIMEOUT_SACK_MAX ((500 * HZ) / 1000) /* 500 ms */
283
271
284
272
/* RTO.Initial - 3 seconds
285
273
* RTO.Min - 1 second
+4
include/net/sctp/structs.h
+4
include/net/sctp/structs.h
···
161
161
*/
162
162
int sndbuf_policy;
163
163
164
+
/* Delayed SACK timeout 200ms default*/
165
+
int sack_timeout;
166
+
164
167
/* HB.interval - 30 seconds */
165
168
int hb_interval;
166
169
···
220
217
#define sctp_sndbuf_policy (sctp_globals.sndbuf_policy)
221
218
#define sctp_max_retrans_path (sctp_globals.max_retrans_path)
222
219
#define sctp_max_retrans_init (sctp_globals.max_retrans_init)
220
+
#define sctp_sack_timeout (sctp_globals.sack_timeout)
223
221
#define sctp_hb_interval (sctp_globals.hb_interval)
224
222
#define sctp_max_instreams (sctp_globals.max_instreams)
225
223
#define sctp_max_outstreams (sctp_globals.max_outstreams)
+1
-1
net/bridge/br_netfilter.c
+1
-1
net/bridge/br_netfilter.c
···
844
844
* doesn't use the bridge parent of the indev by using
845
845
* the BRNF_DONT_TAKE_PARENT mask. */
846
846
if (hook == NF_IP_FORWARD && nf_bridge->physindev == NULL) {
847
-
nf_bridge->mask &= BRNF_DONT_TAKE_PARENT;
847
+
nf_bridge->mask |= BRNF_DONT_TAKE_PARENT;
848
848
nf_bridge->physindev = (struct net_device *)in;
849
849
}
850
850
#if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
+2
-4
net/bridge/netfilter/ebt_log.c
+2
-4
net/bridge/netfilter/ebt_log.c
···
61
61
{
62
62
struct ebt_log_info *info = (struct ebt_log_info *)data;
63
63
char level_string[4] = "< >";
64
-
union {struct iphdr iph; struct tcpudphdr ports;
65
-
struct arphdr arph; struct arppayload arpp;} u;
66
64
67
65
level_string[1] = '0' + info->loglevel;
68
66
spin_lock_bh(&ebt_log_lock);
···
86
88
}
87
89
printk(" IP SRC=%u.%u.%u.%u IP DST=%u.%u.%u.%u,",
88
90
NIPQUAD(ih->saddr), NIPQUAD(ih->daddr));
89
-
printk(" IP tos=0x%02X, IP proto=%d", u.iph.tos,
91
+
printk(" IP tos=0x%02X, IP proto=%d", ih->tos,
90
92
ih->protocol);
91
93
if (ih->protocol == IPPROTO_TCP ||
92
94
ih->protocol == IPPROTO_UDP) {
···
125
127
ah->ar_pln == sizeof(uint32_t)) {
126
128
struct arppayload _arpp, *ap;
127
129
128
-
ap = skb_header_pointer(skb, sizeof(u.arph),
130
+
ap = skb_header_pointer(skb, sizeof(_arph),
129
131
sizeof(_arpp), &_arpp);
130
132
if (ap == NULL) {
131
133
printk(" INCOMPLETE ARP payload");
+6
net/core/neighbour.c
+6
net/core/neighbour.c
···
1598
1598
1599
1599
read_lock_bh(&tbl->lock);
1600
1600
ndtmsg->ndtm_family = tbl->family;
1601
+
ndtmsg->ndtm_pad1 = 0;
1602
+
ndtmsg->ndtm_pad2 = 0;
1601
1603
1602
1604
RTA_PUT_STRING(skb, NDTA_NAME, tbl->id);
1603
1605
RTA_PUT_MSECS(skb, NDTA_GC_INTERVAL, tbl->gc_interval);
···
1685
1683
1686
1684
read_lock_bh(&tbl->lock);
1687
1685
ndtmsg->ndtm_family = tbl->family;
1686
+
ndtmsg->ndtm_pad1 = 0;
1687
+
ndtmsg->ndtm_pad2 = 0;
1688
1688
RTA_PUT_STRING(skb, NDTA_NAME, tbl->id);
1689
1689
1690
1690
if (neightbl_fill_parms(skb, parms) < 0)
···
1876
1872
struct ndmsg *ndm = NLMSG_DATA(nlh);
1877
1873
1878
1874
ndm->ndm_family = n->ops->family;
1875
+
ndm->ndm_pad1 = 0;
1876
+
ndm->ndm_pad2 = 0;
1879
1877
ndm->ndm_flags = n->flags;
1880
1878
ndm->ndm_type = n->type;
1881
1879
ndm->ndm_ifindex = n->dev->ifindex;
+2
net/core/rtnetlink.c
+2
net/core/rtnetlink.c
···
126
126
rta->rta_type = attrtype;
127
127
rta->rta_len = size;
128
128
memcpy(RTA_DATA(rta), data, attrlen);
129
+
memset(RTA_DATA(rta) + attrlen, 0, RTA_ALIGN(size) - size);
129
130
}
130
131
131
132
size_t rtattr_strlcpy(char *dest, const struct rtattr *rta, size_t size)
···
189
188
nlh = NLMSG_NEW(skb, pid, seq, type, sizeof(*r), flags);
190
189
r = NLMSG_DATA(nlh);
191
190
r->ifi_family = AF_UNSPEC;
191
+
r->__ifi_pad = 0;
192
192
r->ifi_type = dev->type;
193
193
r->ifi_index = dev->ifindex;
194
194
r->ifi_flags = dev_get_flags(dev);
+1
net/core/wireless.c
+1
net/core/wireless.c
+3
-4
net/ethernet/eth.c
+3
-4
net/ethernet/eth.c
···
92
92
* Set the source hardware address.
93
93
*/
94
94
95
-
if(saddr)
96
-
memcpy(eth->h_source,saddr,dev->addr_len);
97
-
else
98
-
memcpy(eth->h_source,dev->dev_addr,dev->addr_len);
95
+
if(!saddr)
96
+
saddr = dev->dev_addr;
97
+
memcpy(eth->h_source,saddr,dev->addr_len);
99
98
100
99
/*
101
100
* Anyway, the loopback-device should never use this function...
+39
-17
net/ipv4/fib_trie.c
+39
-17
net/ipv4/fib_trie.c
···
43
43
* 2 of the License, or (at your option) any later version.
44
44
*/
45
45
46
-
#define VERSION "0.323"
46
+
#define VERSION "0.324"
47
47
48
48
#include <linux/config.h>
49
49
#include <asm/uaccess.h>
···
341
341
static struct leaf_info *leaf_info_new(int plen)
342
342
{
343
343
struct leaf_info *li = kmalloc(sizeof(struct leaf_info), GFP_KERNEL);
344
-
li->plen = plen;
345
-
INIT_LIST_HEAD(&li->falh);
344
+
if(li) {
345
+
li->plen = plen;
346
+
INIT_LIST_HEAD(&li->falh);
347
+
}
346
348
return li;
347
349
}
348
350
···
881
879
return (struct node*) tn;
882
880
}
883
881
884
-
static struct list_head *
885
-
fib_insert_node(struct trie *t, u32 key, int plen)
882
+
static struct list_head *
883
+
fib_insert_node(struct trie *t, int *err, u32 key, int plen)
886
884
{
887
885
int pos, newpos;
888
886
struct tnode *tp = NULL, *tn = NULL;
···
942
940
if(tp && IS_LEAF(tp))
943
941
BUG();
944
942
945
-
t->revision++;
946
943
947
944
/* Case 1: n is a leaf. Compare prefixes */
948
945
···
950
949
951
950
li = leaf_info_new(plen);
952
951
953
-
if(! li)
954
-
BUG();
952
+
if(! li) {
953
+
*err = -ENOMEM;
954
+
goto err;
955
+
}
955
956
956
957
fa_head = &li->falh;
957
958
insert_leaf_info(&l->list, li);
···
962
959
t->size++;
963
960
l = leaf_new();
964
961
965
-
if(! l)
966
-
BUG();
962
+
if(! l) {
963
+
*err = -ENOMEM;
964
+
goto err;
965
+
}
967
966
968
967
l->key = key;
969
968
li = leaf_info_new(plen);
970
969
971
-
if(! li)
972
-
BUG();
970
+
if(! li) {
971
+
tnode_free((struct tnode *) l);
972
+
*err = -ENOMEM;
973
+
goto err;
974
+
}
973
975
974
976
fa_head = &li->falh;
975
977
insert_leaf_info(&l->list, li);
···
1011
1003
newpos = 0;
1012
1004
tn = tnode_new(key, newpos, 1); /* First tnode */
1013
1005
}
1014
-
if(!tn)
1015
-
trie_bug("tnode_pfx_new failed");
1016
1006
1007
+
if(!tn) {
1008
+
free_leaf_info(li);
1009
+
tnode_free((struct tnode *) l);
1010
+
*err = -ENOMEM;
1011
+
goto err;
1012
+
}
1013
+
1017
1014
NODE_SET_PARENT(tn, tp);
1018
1015
1019
1016
missbit=tkey_extract_bits(key, newpos, 1);
···
1040
1027
}
1041
1028
/* Rebalance the trie */
1042
1029
t->trie = trie_rebalance(t, tp);
1043
-
done:;
1030
+
done:
1031
+
t->revision++;
1032
+
err:;
1044
1033
return fa_head;
1045
1034
}
1046
1035
···
1171
1156
* Insert new entry to the list.
1172
1157
*/
1173
1158
1174
-
if(!fa_head)
1175
-
fa_head = fib_insert_node(t, key, plen);
1159
+
if(!fa_head) {
1160
+
fa_head = fib_insert_node(t, &err, key, plen);
1161
+
err = 0;
1162
+
if(err)
1163
+
goto out_free_new_fa;
1164
+
}
1176
1165
1177
1166
write_lock_bh(&fib_lock);
1178
1167
···
1189
1170
rtmsg_fib(RTM_NEWROUTE, htonl(key), new_fa, plen, tb->tb_id, nlhdr, req);
1190
1171
succeeded:
1191
1172
return 0;
1173
+
1174
+
out_free_new_fa:
1175
+
kmem_cache_free(fn_alias_kmem, new_fa);
1192
1176
out:
1193
1177
fib_release_info(fi);
1194
1178
err:;
+5
-1
net/ipv4/ip_input.c
+5
-1
net/ipv4/ip_input.c
···
283
283
{
284
284
struct net_device *dev = skb->dev;
285
285
struct iphdr *iph = skb->nh.iph;
286
+
int err;
286
287
287
288
/*
288
289
* Initialise the virtual path cache for the packet. It describes
289
290
* how the packet travels inside Linux networking.
290
291
*/
291
292
if (skb->dst == NULL) {
292
-
if (ip_route_input(skb, iph->daddr, iph->saddr, iph->tos, dev))
293
+
if ((err = ip_route_input(skb, iph->daddr, iph->saddr, iph->tos, dev))) {
294
+
if (err == -EHOSTUNREACH)
295
+
IP_INC_STATS_BH(IPSTATS_MIB_INADDRERRORS);
293
296
goto drop;
297
+
}
294
298
}
295
299
296
300
#ifdef CONFIG_NET_CLS_ROUTE
+7
-1
net/ipv4/ip_output.c
+7
-1
net/ipv4/ip_output.c
···
188
188
skb = skb2;
189
189
}
190
190
191
-
nf_reset(skb);
191
+
#ifdef CONFIG_BRIDGE_NETFILTER
192
+
/* bridge-netfilter defers calling some IP hooks to the bridge layer
193
+
* and still needs the conntrack reference.
194
+
*/
195
+
if (skb->nf_bridge == NULL)
196
+
#endif
197
+
nf_reset(skb);
192
198
193
199
if (hh) {
194
200
int hh_alen;
+3
-1
net/ipv4/ipconfig.c
+3
-1
net/ipv4/ipconfig.c
+8
-2
net/ipv4/ipmr.c
+8
-2
net/ipv4/ipmr.c
···
297
297
static void ipmr_destroy_unres(struct mfc_cache *c)
298
298
{
299
299
struct sk_buff *skb;
300
+
struct nlmsgerr *e;
300
301
301
302
atomic_dec(&cache_resolve_queue_len);
302
303
···
307
306
nlh->nlmsg_type = NLMSG_ERROR;
308
307
nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
309
308
skb_trim(skb, nlh->nlmsg_len);
310
-
((struct nlmsgerr*)NLMSG_DATA(nlh))->error = -ETIMEDOUT;
309
+
e = NLMSG_DATA(nlh);
310
+
e->error = -ETIMEDOUT;
311
+
memset(&e->msg, 0, sizeof(e->msg));
311
312
netlink_unicast(rtnl, skb, NETLINK_CB(skb).dst_pid, MSG_DONTWAIT);
312
313
} else
313
314
kfree_skb(skb);
···
502
499
static void ipmr_cache_resolve(struct mfc_cache *uc, struct mfc_cache *c)
503
500
{
504
501
struct sk_buff *skb;
502
+
struct nlmsgerr *e;
505
503
506
504
/*
507
505
* Play the pending entries through our router
···
519
515
nlh->nlmsg_type = NLMSG_ERROR;
520
516
nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
521
517
skb_trim(skb, nlh->nlmsg_len);
522
-
((struct nlmsgerr*)NLMSG_DATA(nlh))->error = -EMSGSIZE;
518
+
e = NLMSG_DATA(nlh);
519
+
e->error = -EMSGSIZE;
520
+
memset(&e->msg, 0, sizeof(e->msg));
523
521
}
524
522
err = netlink_unicast(rtnl, skb, NETLINK_CB(skb).dst_pid, MSG_DONTWAIT);
525
523
} else
+4
-21
net/ipv4/ipvs/ip_vs_conn.c
+4
-21
net/ipv4/ipvs/ip_vs_conn.c
···
548
548
{
549
549
if (del_timer(&cp->timer))
550
550
mod_timer(&cp->timer, jiffies);
551
-
__ip_vs_conn_put(cp);
552
551
}
553
552
554
553
···
763
764
{
764
765
int idx;
765
766
struct ip_vs_conn *cp;
766
-
struct ip_vs_conn *ct;
767
767
768
768
/*
769
769
* Randomly scan 1/32 of the whole table every second
···
799
801
continue;
800
802
}
801
803
802
-
/*
803
-
* Drop the entry, and drop its ct if not referenced
804
-
*/
805
-
atomic_inc(&cp->refcnt);
806
-
ct_write_unlock(hash);
807
-
808
-
if ((ct = cp->control))
809
-
atomic_inc(&ct->refcnt);
810
804
IP_VS_DBG(4, "del connection\n");
811
805
ip_vs_conn_expire_now(cp);
812
-
if (ct) {
806
+
if (cp->control) {
813
807
IP_VS_DBG(4, "del conn template\n");
814
-
ip_vs_conn_expire_now(ct);
808
+
ip_vs_conn_expire_now(cp->control);
815
809
}
816
-
ct_write_lock(hash);
817
810
}
818
811
ct_write_unlock(hash);
819
812
}
···
818
829
{
819
830
int idx;
820
831
struct ip_vs_conn *cp;
821
-
struct ip_vs_conn *ct;
822
832
823
833
flush_again:
824
834
for (idx=0; idx<IP_VS_CONN_TAB_SIZE; idx++) {
···
827
839
ct_write_lock_bh(idx);
828
840
829
841
list_for_each_entry(cp, &ip_vs_conn_tab[idx], c_list) {
830
-
atomic_inc(&cp->refcnt);
831
-
ct_write_unlock(idx);
832
842
833
-
if ((ct = cp->control))
834
-
atomic_inc(&ct->refcnt);
835
843
IP_VS_DBG(4, "del connection\n");
836
844
ip_vs_conn_expire_now(cp);
837
-
if (ct) {
845
+
if (cp->control) {
838
846
IP_VS_DBG(4, "del conn template\n");
839
-
ip_vs_conn_expire_now(ct);
847
+
ip_vs_conn_expire_now(cp->control);
840
848
}
841
-
ct_write_lock(idx);
842
849
}
843
850
ct_write_unlock_bh(idx);
844
851
}
+4
-3
net/ipv4/netfilter/ipt_CLUSTERIP.c
+4
-3
net/ipv4/netfilter/ipt_CLUSTERIP.c
···
30
30
#include <linux/netfilter_ipv4/ipt_CLUSTERIP.h>
31
31
#include <linux/netfilter_ipv4/ip_conntrack.h>
32
32
33
-
#define CLUSTERIP_VERSION "0.6"
33
+
#define CLUSTERIP_VERSION "0.7"
34
34
35
35
#define DEBUG_CLUSTERIP
36
36
···
524
524
|| arp->ar_pln != 4 || arp->ar_hln != ETH_ALEN)
525
525
return NF_ACCEPT;
526
526
527
-
/* we only want to mangle arp replies */
528
-
if (arp->ar_op != htons(ARPOP_REPLY))
527
+
/* we only want to mangle arp requests and replies */
528
+
if (arp->ar_op != htons(ARPOP_REPLY)
529
+
&& arp->ar_op != htons(ARPOP_REQUEST))
529
530
return NF_ACCEPT;
530
531
531
532
payload = (void *)(arp+1);
+7
-2
net/ipv4/route.c
+7
-2
net/ipv4/route.c
···
1909
1909
*/
1910
1910
if ((err = fib_lookup(&fl, &res)) != 0) {
1911
1911
if (!IN_DEV_FORWARD(in_dev))
1912
-
goto e_inval;
1912
+
goto e_hostunreach;
1913
1913
goto no_route;
1914
1914
}
1915
1915
free_res = 1;
···
1933
1933
}
1934
1934
1935
1935
if (!IN_DEV_FORWARD(in_dev))
1936
-
goto e_inval;
1936
+
goto e_hostunreach;
1937
1937
if (res.type != RTN_UNICAST)
1938
1938
goto martian_destination;
1939
1939
···
2025
2025
"%u.%u.%u.%u, dev %s\n",
2026
2026
NIPQUAD(daddr), NIPQUAD(saddr), dev->name);
2027
2027
#endif
2028
+
2029
+
e_hostunreach:
2030
+
err = -EHOSTUNREACH;
2031
+
goto done;
2032
+
2028
2033
e_inval:
2029
2034
err = -EINVAL;
2030
2035
goto done;
+5
-14
net/ipv6/addrconf.c
+5
-14
net/ipv6/addrconf.c
···
2777
2777
read_lock_bh(&idev->lock);
2778
2778
switch (type) {
2779
2779
case UNICAST_ADDR:
2780
-
/* unicast address */
2780
+
/* unicast address incl. temp addr */
2781
2781
for (ifa = idev->addr_list; ifa;
2782
2782
ifa = ifa->if_next, ip_idx++) {
2783
2783
if (ip_idx < s_ip_idx)
···
2788
2788
NLM_F_MULTI)) <= 0)
2789
2789
goto done;
2790
2790
}
2791
-
/* temp addr */
2792
-
#ifdef CONFIG_IPV6_PRIVACY
2793
-
for (ifa = idev->tempaddr_list; ifa;
2794
-
ifa = ifa->tmp_next, ip_idx++) {
2795
-
if (ip_idx < s_ip_idx)
2796
-
continue;
2797
-
if ((err = inet6_fill_ifaddr(skb, ifa,
2798
-
NETLINK_CB(cb->skb).pid,
2799
-
cb->nlh->nlmsg_seq, RTM_NEWADDR,
2800
-
NLM_F_MULTI)) <= 0)
2801
-
goto done;
2802
-
}
2803
-
#endif
2804
2791
break;
2805
2792
case MULTICAST_ADDR:
2806
2793
/* multicast address */
···
2910
2923
nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*r), flags);
2911
2924
r = NLMSG_DATA(nlh);
2912
2925
r->ifi_family = AF_INET6;
2926
+
r->__ifi_pad = 0;
2913
2927
r->ifi_type = dev->type;
2914
2928
r->ifi_index = dev->ifindex;
2915
2929
r->ifi_flags = dev_get_flags(dev);
···
3018
3030
nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*pmsg), flags);
3019
3031
pmsg = NLMSG_DATA(nlh);
3020
3032
pmsg->prefix_family = AF_INET6;
3033
+
pmsg->prefix_pad1 = 0;
3034
+
pmsg->prefix_pad2 = 0;
3021
3035
pmsg->prefix_ifindex = idev->dev->ifindex;
3022
3036
pmsg->prefix_len = pinfo->prefix_len;
3023
3037
pmsg->prefix_type = pinfo->type;
3038
+
pmsg->prefix_pad3 = 0;
3024
3039
3025
3040
pmsg->prefix_flags = 0;
3026
3041
if (pinfo->onlink)
-1
net/ipv6/ip6_flowlabel.c
-1
net/ipv6/ip6_flowlabel.c
+9
-1
net/sched/act_api.c
+9
-1
net/sched/act_api.c
···
439
439
440
440
t = NLMSG_DATA(nlh);
441
441
t->tca_family = AF_UNSPEC;
442
+
t->tca__pad1 = 0;
443
+
t->tca__pad2 = 0;
442
444
443
445
x = (struct rtattr*) skb->tail;
444
446
RTA_PUT(skb, TCA_ACT_TAB, 0, NULL);
···
582
580
nlh = NLMSG_PUT(skb, pid, n->nlmsg_seq, RTM_DELACTION, sizeof(*t));
583
581
t = NLMSG_DATA(nlh);
584
582
t->tca_family = AF_UNSPEC;
583
+
t->tca__pad1 = 0;
584
+
t->tca__pad2 = 0;
585
585
586
586
x = (struct rtattr *) skb->tail;
587
587
RTA_PUT(skb, TCA_ACT_TAB, 0, NULL);
···
691
687
nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*t), flags);
692
688
t = NLMSG_DATA(nlh);
693
689
t->tca_family = AF_UNSPEC;
694
-
690
+
t->tca__pad1 = 0;
691
+
t->tca__pad2 = 0;
692
+
695
693
x = (struct rtattr*) skb->tail;
696
694
RTA_PUT(skb, TCA_ACT_TAB, 0, NULL);
697
695
···
848
842
cb->nlh->nlmsg_type, sizeof(*t));
849
843
t = NLMSG_DATA(nlh);
850
844
t->tca_family = AF_UNSPEC;
845
+
t->tca__pad1 = 0;
846
+
t->tca__pad2 = 0;
851
847
852
848
x = (struct rtattr *) skb->tail;
853
849
RTA_PUT(skb, TCA_ACT_TAB, 0, NULL);
+2
net/sched/cls_api.c
+2
net/sched/cls_api.c
···
331
331
nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*tcm), flags);
332
332
tcm = NLMSG_DATA(nlh);
333
333
tcm->tcm_family = AF_UNSPEC;
334
+
tcm->tcm__pad1 = 0;
335
+
tcm->tcm__pad1 = 0;
334
336
tcm->tcm_ifindex = tp->q->dev->ifindex;
335
337
tcm->tcm_parent = tp->classid;
336
338
tcm->tcm_info = TC_H_MAKE(tp->prio, tp->protocol);
+1
net/sched/cls_rsvp.h
+1
net/sched/cls_rsvp.h
+2
net/sched/sch_api.c
+2
net/sched/sch_api.c
···
770
770
nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*tcm), flags);
771
771
tcm = NLMSG_DATA(nlh);
772
772
tcm->tcm_family = AF_UNSPEC;
773
+
tcm->tcm__pad1 = 0;
774
+
tcm->tcm__pad2 = 0;
773
775
tcm->tcm_ifindex = q->dev->ifindex;
774
776
tcm->tcm_parent = clid;
775
777
tcm->tcm_handle = q->handle;
+3
net/sched/sch_cbq.c
+3
net/sched/sch_cbq.c
···
1528
1528
1529
1529
opt.strategy = cl->ovl_strategy;
1530
1530
opt.priority2 = cl->priority2+1;
1531
+
opt.pad = 0;
1531
1532
opt.penalty = (cl->penalty*1000)/HZ;
1532
1533
RTA_PUT(skb, TCA_CBQ_OVL_STRATEGY, sizeof(opt), &opt);
1533
1534
return skb->len;
···
1564
1563
1565
1564
if (cl->police) {
1566
1565
opt.police = cl->police;
1566
+
opt.__res1 = 0;
1567
+
opt.__res2 = 0;
1567
1568
RTA_PUT(skb, TCA_CBQ_POLICE, sizeof(opt), &opt);
1568
1569
}
1569
1570
return skb->len;
+5
-8
net/sctp/endpointola.c
+5
-8
net/sctp/endpointola.c
···
102
102
/* Set up the base timeout information. */
103
103
ep->timeouts[SCTP_EVENT_TIMEOUT_NONE] = 0;
104
104
ep->timeouts[SCTP_EVENT_TIMEOUT_T1_COOKIE] =
105
-
SCTP_DEFAULT_TIMEOUT_T1_COOKIE;
105
+
msecs_to_jiffies(sp->rtoinfo.srto_initial);
106
106
ep->timeouts[SCTP_EVENT_TIMEOUT_T1_INIT] =
107
-
SCTP_DEFAULT_TIMEOUT_T1_INIT;
107
+
msecs_to_jiffies(sp->rtoinfo.srto_initial);
108
108
ep->timeouts[SCTP_EVENT_TIMEOUT_T2_SHUTDOWN] =
109
109
msecs_to_jiffies(sp->rtoinfo.srto_initial);
110
110
ep->timeouts[SCTP_EVENT_TIMEOUT_T3_RTX] = 0;
···
117
117
ep->timeouts[SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD]
118
118
= 5 * msecs_to_jiffies(sp->rtoinfo.srto_max);
119
119
120
-
ep->timeouts[SCTP_EVENT_TIMEOUT_HEARTBEAT] =
121
-
SCTP_DEFAULT_TIMEOUT_HEARTBEAT;
122
-
ep->timeouts[SCTP_EVENT_TIMEOUT_SACK] =
123
-
SCTP_DEFAULT_TIMEOUT_SACK;
124
-
ep->timeouts[SCTP_EVENT_TIMEOUT_AUTOCLOSE] =
125
-
sp->autoclose * HZ;
120
+
ep->timeouts[SCTP_EVENT_TIMEOUT_HEARTBEAT] = 0;
121
+
ep->timeouts[SCTP_EVENT_TIMEOUT_SACK] = sctp_sack_timeout;
122
+
ep->timeouts[SCTP_EVENT_TIMEOUT_AUTOCLOSE] = sp->autoclose * HZ;
126
123
127
124
/* Use SCTP specific send buffer space queues. */
128
125
ep->sndbuf_policy = sctp_sndbuf_policy;
+4
-1
net/sctp/protocol.c
+4
-1
net/sctp/protocol.c
···
1050
1050
sctp_sndbuf_policy = 0;
1051
1051
1052
1052
/* HB.interval - 30 seconds */
1053
-
sctp_hb_interval = 30 * HZ;
1053
+
sctp_hb_interval = SCTP_DEFAULT_TIMEOUT_HEARTBEAT;
1054
+
1055
+
/* delayed SACK timeout */
1056
+
sctp_sack_timeout = SCTP_DEFAULT_TIMEOUT_SACK;
1054
1057
1055
1058
/* Implementation specific variables. */
1056
1059
+13
net/sctp/sysctl.c
+13
net/sctp/sysctl.c
···
47
47
static ctl_handler sctp_sysctl_jiffies_ms;
48
48
static long rto_timer_min = 1;
49
49
static long rto_timer_max = 86400000; /* One day */
50
+
static long sack_timer_min = 1;
51
+
static long sack_timer_max = 500;
50
52
51
53
static ctl_table sctp_table[] = {
52
54
{
···
188
186
.maxlen = sizeof(int),
189
187
.mode = 0644,
190
188
.proc_handler = &proc_dointvec
189
+
},
190
+
{
191
+
.ctl_name = NET_SCTP_SACK_TIMEOUT,
192
+
.procname = "sack_timeout",
193
+
.data = &sctp_sack_timeout,
194
+
.maxlen = sizeof(long),
195
+
.mode = 0644,
196
+
.proc_handler = &proc_doulongvec_ms_jiffies_minmax,
197
+
.strategy = &sctp_sysctl_jiffies_ms,
198
+
.extra1 = &sack_timer_min,
199
+
.extra2 = &sack_timer_max,
191
200
},
192
201
{ .ctl_name = 0 }
193
202
};