Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6
* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6: (47 commits)
tcp: Fix >4GB writes on 64-bit.
net/9p: Mount only matching virtio channels
de2104x: fix ethtool
tproxy: check for transparent flag in ip_route_newports
ipv6: add IPv6 to neighbour table overflow warning
tcp: fix TSO FACK loss marking in tcp_mark_head_lost
3c59x: fix regression from patch "Add ethtool WOL support"
ipv6: add a missing unregister_pernet_subsys call
s390: use free_netdev(netdev) instead of kfree()
sgiseeq: use free_netdev(netdev) instead of kfree()
rionet: use free_netdev(netdev) instead of kfree()
ibm_newemac: use free_netdev(netdev) instead of kfree()
smsc911x: Add MODULE_ALIAS()
net: reset skb queue mapping when rx'ing over tunnel
br2684: fix scheduling while atomic
de2104x: fix TP link detection
de2104x: fix power management
de2104x: disable autonegotiation on broken hardware
net: fix a lockdep splat
e1000e: 82579 do not gate auto config of PHY by hardware during nominal use
...
+444
-196
+10
drivers/net/3c59x.c
+10
drivers/net/3c59x.c
···
2942
2942
{
2943
2943
struct vortex_private *vp = netdev_priv(dev);
2944
2944
2945
+
if (!VORTEX_PCI(vp))
2946
+
return;
2947
+
2945
2948
wol->supported = WAKE_MAGIC;
2946
2949
2947
2950
wol->wolopts = 0;
···
2955
2952
static int vortex_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
2956
2953
{
2957
2954
struct vortex_private *vp = netdev_priv(dev);
2955
+
2956
+
if (!VORTEX_PCI(vp))
2957
+
return -EOPNOTSUPP;
2958
+
2958
2959
if (wol->wolopts & ~WAKE_MAGIC)
2959
2960
return -EINVAL;
2960
2961
···
3207
3200
vp->enable_wol = 0;
3208
3201
return;
3209
3202
}
3203
+
3204
+
if (VORTEX_PCI(vp)->current_state < PCI_D3hot)
3205
+
return;
3210
3206
3211
3207
/* Change the power state to D3; RxEnable doesn't take effect. */
3212
3208
pci_set_power_state(VORTEX_PCI(vp), PCI_D3hot);
+9
-2
drivers/net/atlx/atl1.c
+9
-2
drivers/net/atlx/atl1.c
···
1251
1251
1252
1252
rrd_ring->desc = NULL;
1253
1253
rrd_ring->dma = 0;
1254
+
1255
+
adapter->cmb.dma = 0;
1256
+
adapter->cmb.cmb = NULL;
1257
+
1258
+
adapter->smb.dma = 0;
1259
+
adapter->smb.smb = NULL;
1254
1260
}
1255
1261
1256
1262
static void atl1_setup_mac_ctrl(struct atl1_adapter *adapter)
···
2853
2847
pci_enable_wake(pdev, PCI_D3cold, 0);
2854
2848
2855
2849
atl1_reset_hw(&adapter->hw);
2856
-
adapter->cmb.cmb->int_stats = 0;
2857
2850
2858
-
if (netif_running(netdev))
2851
+
if (netif_running(netdev)) {
2852
+
adapter->cmb.cmb->int_stats = 0;
2859
2853
atl1_up(adapter);
2854
+
}
2860
2855
netif_device_attach(netdev);
2861
2856
2862
2857
return 0;
+1
drivers/net/e1000e/hw.h
+1
drivers/net/e1000e/hw.h
···
57
57
E1000_SCTL = 0x00024, /* SerDes Control - RW */
58
58
E1000_FCAL = 0x00028, /* Flow Control Address Low - RW */
59
59
E1000_FCAH = 0x0002C, /* Flow Control Address High -RW */
60
+
E1000_FEXTNVM4 = 0x00024, /* Future Extended NVM 4 - RW */
60
61
E1000_FEXTNVM = 0x00028, /* Future Extended NVM - RW */
61
62
E1000_FCT = 0x00030, /* Flow Control Type - RW */
62
63
E1000_VET = 0x00038, /* VLAN Ether Type - RW */
+164
-33
drivers/net/e1000e/ich8lan.c
+164
-33
drivers/net/e1000e/ich8lan.c
···
105
105
#define E1000_FEXTNVM_SW_CONFIG 1
106
106
#define E1000_FEXTNVM_SW_CONFIG_ICH8M (1 << 27) /* Bit redefined for ICH8M :/ */
107
107
108
+
#define E1000_FEXTNVM4_BEACON_DURATION_MASK 0x7
109
+
#define E1000_FEXTNVM4_BEACON_DURATION_8USEC 0x7
110
+
#define E1000_FEXTNVM4_BEACON_DURATION_16USEC 0x3
111
+
108
112
#define PCIE_ICH8_SNOOP_ALL PCIE_NO_SNOOP_ALL
109
113
110
114
#define E1000_ICH_RAR_ENTRIES 7
···
129
125
130
126
/* SMBus Address Phy Register */
131
127
#define HV_SMB_ADDR PHY_REG(768, 26)
128
+
#define HV_SMB_ADDR_MASK 0x007F
132
129
#define HV_SMB_ADDR_PEC_EN 0x0200
133
130
#define HV_SMB_ADDR_VALID 0x0080
134
131
···
242
237
static s32 e1000_set_mdio_slow_mode_hv(struct e1000_hw *hw);
243
238
static bool e1000_check_mng_mode_ich8lan(struct e1000_hw *hw);
244
239
static bool e1000_check_mng_mode_pchlan(struct e1000_hw *hw);
240
+
static s32 e1000_k1_workaround_lv(struct e1000_hw *hw);
241
+
static void e1000_gate_hw_phy_config_ich8lan(struct e1000_hw *hw, bool gate);
245
242
246
243
static inline u16 __er16flash(struct e1000_hw *hw, unsigned long reg)
247
244
{
···
279
272
static s32 e1000_init_phy_params_pchlan(struct e1000_hw *hw)
280
273
{
281
274
struct e1000_phy_info *phy = &hw->phy;
282
-
u32 ctrl;
275
+
u32 ctrl, fwsm;
283
276
s32 ret_val = 0;
284
277
285
278
phy->addr = 1;
···
301
294
* disabled, then toggle the LANPHYPC Value bit to force
302
295
* the interconnect to PCIe mode.
303
296
*/
304
-
if (!(er32(FWSM) & E1000_ICH_FWSM_FW_VALID)) {
297
+
fwsm = er32(FWSM);
298
+
if (!(fwsm & E1000_ICH_FWSM_FW_VALID)) {
305
299
ctrl = er32(CTRL);
306
300
ctrl |= E1000_CTRL_LANPHYPC_OVERRIDE;
307
301
ctrl &= ~E1000_CTRL_LANPHYPC_VALUE;
···
311
303
ctrl &= ~E1000_CTRL_LANPHYPC_OVERRIDE;
312
304
ew32(CTRL, ctrl);
313
305
msleep(50);
306
+
307
+
/*
308
+
* Gate automatic PHY configuration by hardware on
309
+
* non-managed 82579
310
+
*/
311
+
if (hw->mac.type == e1000_pch2lan)
312
+
e1000_gate_hw_phy_config_ich8lan(hw, true);
314
313
}
315
314
316
315
/*
···
329
314
ret_val = e1000e_phy_hw_reset_generic(hw);
330
315
if (ret_val)
331
316
goto out;
317
+
318
+
/* Ungate automatic PHY configuration on non-managed 82579 */
319
+
if ((hw->mac.type == e1000_pch2lan) &&
320
+
!(fwsm & E1000_ICH_FWSM_FW_VALID)) {
321
+
msleep(10);
322
+
e1000_gate_hw_phy_config_ich8lan(hw, false);
323
+
}
332
324
333
325
phy->id = e1000_phy_unknown;
334
326
ret_val = e1000e_get_phy_id(hw);
···
583
561
if (mac->type == e1000_ich8lan)
584
562
e1000e_set_kmrn_lock_loss_workaround_ich8lan(hw, true);
585
563
586
-
/* Disable PHY configuration by hardware, config by software */
587
-
if (mac->type == e1000_pch2lan) {
588
-
u32 extcnf_ctrl = er32(EXTCNF_CTRL);
589
-
590
-
extcnf_ctrl |= E1000_EXTCNF_CTRL_GATE_PHY_CFG;
591
-
ew32(EXTCNF_CTRL, extcnf_ctrl);
592
-
}
564
+
/* Gate automatic PHY configuration by hardware on managed 82579 */
565
+
if ((mac->type == e1000_pch2lan) &&
566
+
(er32(FWSM) & E1000_ICH_FWSM_FW_VALID))
567
+
e1000_gate_hw_phy_config_ich8lan(hw, true);
593
568
594
569
return 0;
595
570
}
···
667
648
668
649
if (hw->phy.type == e1000_phy_82578) {
669
650
ret_val = e1000_link_stall_workaround_hv(hw);
651
+
if (ret_val)
652
+
goto out;
653
+
}
654
+
655
+
if (hw->mac.type == e1000_pch2lan) {
656
+
ret_val = e1000_k1_workaround_lv(hw);
670
657
if (ret_val)
671
658
goto out;
672
659
}
···
920
895
}
921
896
922
897
/**
898
+
* e1000_write_smbus_addr - Write SMBus address to PHY needed during Sx states
899
+
* @hw: pointer to the HW structure
900
+
*
901
+
* Assumes semaphore already acquired.
902
+
*
903
+
**/
904
+
static s32 e1000_write_smbus_addr(struct e1000_hw *hw)
905
+
{
906
+
u16 phy_data;
907
+
u32 strap = er32(STRAP);
908
+
s32 ret_val = 0;
909
+
910
+
strap &= E1000_STRAP_SMBUS_ADDRESS_MASK;
911
+
912
+
ret_val = e1000_read_phy_reg_hv_locked(hw, HV_SMB_ADDR, &phy_data);
913
+
if (ret_val)
914
+
goto out;
915
+
916
+
phy_data &= ~HV_SMB_ADDR_MASK;
917
+
phy_data |= (strap >> E1000_STRAP_SMBUS_ADDRESS_SHIFT);
918
+
phy_data |= HV_SMB_ADDR_PEC_EN | HV_SMB_ADDR_VALID;
919
+
ret_val = e1000_write_phy_reg_hv_locked(hw, HV_SMB_ADDR, phy_data);
920
+
921
+
out:
922
+
return ret_val;
923
+
}
924
+
925
+
/**
923
926
* e1000_sw_lcd_config_ich8lan - SW-based LCD Configuration
924
927
* @hw: pointer to the HW structure
925
928
*
···
956
903
**/
957
904
static s32 e1000_sw_lcd_config_ich8lan(struct e1000_hw *hw)
958
905
{
959
-
struct e1000_adapter *adapter = hw->adapter;
960
906
struct e1000_phy_info *phy = &hw->phy;
961
907
u32 i, data, cnf_size, cnf_base_addr, sw_cfg_mask;
962
908
s32 ret_val = 0;
···
973
921
if (phy->type != e1000_phy_igp_3)
974
922
return ret_val;
975
923
976
-
if (adapter->pdev->device == E1000_DEV_ID_ICH8_IGP_AMT) {
924
+
if ((hw->adapter->pdev->device == E1000_DEV_ID_ICH8_IGP_AMT) ||
925
+
(hw->adapter->pdev->device == E1000_DEV_ID_ICH8_IGP_C)) {
977
926
sw_cfg_mask = E1000_FEXTNVM_SW_CONFIG;
978
927
break;
979
928
}
···
1014
961
cnf_base_addr = data & E1000_EXTCNF_CTRL_EXT_CNF_POINTER_MASK;
1015
962
cnf_base_addr >>= E1000_EXTCNF_CTRL_EXT_CNF_POINTER_SHIFT;
1016
963
1017
-
if (!(data & E1000_EXTCNF_CTRL_OEM_WRITE_ENABLE) &&
1018
-
((hw->mac.type == e1000_pchlan) ||
1019
-
(hw->mac.type == e1000_pch2lan))) {
964
+
if ((!(data & E1000_EXTCNF_CTRL_OEM_WRITE_ENABLE) &&
965
+
(hw->mac.type == e1000_pchlan)) ||
966
+
(hw->mac.type == e1000_pch2lan)) {
1020
967
/*
1021
968
* HW configures the SMBus address and LEDs when the
1022
969
* OEM and LCD Write Enable bits are set in the NVM.
1023
970
* When both NVM bits are cleared, SW will configure
1024
971
* them instead.
1025
972
*/
1026
-
data = er32(STRAP);
1027
-
data &= E1000_STRAP_SMBUS_ADDRESS_MASK;
1028
-
reg_data = data >> E1000_STRAP_SMBUS_ADDRESS_SHIFT;
1029
-
reg_data |= HV_SMB_ADDR_PEC_EN | HV_SMB_ADDR_VALID;
1030
-
ret_val = e1000_write_phy_reg_hv_locked(hw, HV_SMB_ADDR,
1031
-
reg_data);
973
+
ret_val = e1000_write_smbus_addr(hw);
1032
974
if (ret_val)
1033
975
goto out;
1034
976
···
1488
1440
goto out;
1489
1441
1490
1442
/* Enable jumbo frame workaround in the PHY */
1491
-
e1e_rphy(hw, PHY_REG(769, 20), &data);
1492
-
ret_val = e1e_wphy(hw, PHY_REG(769, 20), data & ~(1 << 14));
1493
-
if (ret_val)
1494
-
goto out;
1495
1443
e1e_rphy(hw, PHY_REG(769, 23), &data);
1496
1444
data &= ~(0x7F << 5);
1497
1445
data |= (0x37 << 5);
···
1496
1452
goto out;
1497
1453
e1e_rphy(hw, PHY_REG(769, 16), &data);
1498
1454
data &= ~(1 << 13);
1499
-
data |= (1 << 12);
1500
1455
ret_val = e1e_wphy(hw, PHY_REG(769, 16), data);
1501
1456
if (ret_val)
1502
1457
goto out;
···
1520
1477
1521
1478
mac_reg = er32(RCTL);
1522
1479
mac_reg &= ~E1000_RCTL_SECRC;
1523
-
ew32(FFLT_DBG, mac_reg);
1480
+
ew32(RCTL, mac_reg);
1524
1481
1525
1482
ret_val = e1000e_read_kmrn_reg(hw,
1526
1483
E1000_KMRNCTRLSTA_CTRL_OFFSET,
···
1546
1503
goto out;
1547
1504
1548
1505
/* Write PHY register values back to h/w defaults */
1549
-
e1e_rphy(hw, PHY_REG(769, 20), &data);
1550
-
ret_val = e1e_wphy(hw, PHY_REG(769, 20), data & ~(1 << 14));
1551
-
if (ret_val)
1552
-
goto out;
1553
1506
e1e_rphy(hw, PHY_REG(769, 23), &data);
1554
1507
data &= ~(0x7F << 5);
1555
1508
ret_val = e1e_wphy(hw, PHY_REG(769, 23), data);
1556
1509
if (ret_val)
1557
1510
goto out;
1558
1511
e1e_rphy(hw, PHY_REG(769, 16), &data);
1559
-
data &= ~(1 << 12);
1560
1512
data |= (1 << 13);
1561
1513
ret_val = e1e_wphy(hw, PHY_REG(769, 16), data);
1562
1514
if (ret_val)
···
1594
1556
1595
1557
out:
1596
1558
return ret_val;
1559
+
}
1560
+
1561
+
/**
1562
+
* e1000_k1_gig_workaround_lv - K1 Si workaround
1563
+
* @hw: pointer to the HW structure
1564
+
*
1565
+
* Workaround to set the K1 beacon duration for 82579 parts
1566
+
**/
1567
+
static s32 e1000_k1_workaround_lv(struct e1000_hw *hw)
1568
+
{
1569
+
s32 ret_val = 0;
1570
+
u16 status_reg = 0;
1571
+
u32 mac_reg;
1572
+
1573
+
if (hw->mac.type != e1000_pch2lan)
1574
+
goto out;
1575
+
1576
+
/* Set K1 beacon duration based on 1Gbps speed or otherwise */
1577
+
ret_val = e1e_rphy(hw, HV_M_STATUS, &status_reg);
1578
+
if (ret_val)
1579
+
goto out;
1580
+
1581
+
if ((status_reg & (HV_M_STATUS_LINK_UP | HV_M_STATUS_AUTONEG_COMPLETE))
1582
+
== (HV_M_STATUS_LINK_UP | HV_M_STATUS_AUTONEG_COMPLETE)) {
1583
+
mac_reg = er32(FEXTNVM4);
1584
+
mac_reg &= ~E1000_FEXTNVM4_BEACON_DURATION_MASK;
1585
+
1586
+
if (status_reg & HV_M_STATUS_SPEED_1000)
1587
+
mac_reg |= E1000_FEXTNVM4_BEACON_DURATION_8USEC;
1588
+
else
1589
+
mac_reg |= E1000_FEXTNVM4_BEACON_DURATION_16USEC;
1590
+
1591
+
ew32(FEXTNVM4, mac_reg);
1592
+
}
1593
+
1594
+
out:
1595
+
return ret_val;
1596
+
}
1597
+
1598
+
/**
1599
+
* e1000_gate_hw_phy_config_ich8lan - disable PHY config via hardware
1600
+
* @hw: pointer to the HW structure
1601
+
* @gate: boolean set to true to gate, false to ungate
1602
+
*
1603
+
* Gate/ungate the automatic PHY configuration via hardware; perform
1604
+
* the configuration via software instead.
1605
+
**/
1606
+
static void e1000_gate_hw_phy_config_ich8lan(struct e1000_hw *hw, bool gate)
1607
+
{
1608
+
u32 extcnf_ctrl;
1609
+
1610
+
if (hw->mac.type != e1000_pch2lan)
1611
+
return;
1612
+
1613
+
extcnf_ctrl = er32(EXTCNF_CTRL);
1614
+
1615
+
if (gate)
1616
+
extcnf_ctrl |= E1000_EXTCNF_CTRL_GATE_PHY_CFG;
1617
+
else
1618
+
extcnf_ctrl &= ~E1000_EXTCNF_CTRL_GATE_PHY_CFG;
1619
+
1620
+
ew32(EXTCNF_CTRL, extcnf_ctrl);
1621
+
return;
1597
1622
}
1598
1623
1599
1624
/**
···
1703
1602
if (e1000_check_reset_block(hw))
1704
1603
goto out;
1705
1604
1605
+
/* Allow time for h/w to get to quiescent state after reset */
1606
+
msleep(10);
1607
+
1706
1608
/* Perform any necessary post-reset workarounds */
1707
1609
switch (hw->mac.type) {
1708
1610
case e1000_pchlan:
···
1734
1630
/* Configure the LCD with the OEM bits in NVM */
1735
1631
ret_val = e1000_oem_bits_config_ich8lan(hw, true);
1736
1632
1633
+
/* Ungate automatic PHY configuration on non-managed 82579 */
1634
+
if ((hw->mac.type == e1000_pch2lan) &&
1635
+
!(er32(FWSM) & E1000_ICH_FWSM_FW_VALID)) {
1636
+
msleep(10);
1637
+
e1000_gate_hw_phy_config_ich8lan(hw, false);
1638
+
}
1639
+
1737
1640
out:
1738
1641
return ret_val;
1739
1642
}
···
1756
1645
static s32 e1000_phy_hw_reset_ich8lan(struct e1000_hw *hw)
1757
1646
{
1758
1647
s32 ret_val = 0;
1648
+
1649
+
/* Gate automatic PHY configuration by hardware on non-managed 82579 */
1650
+
if ((hw->mac.type == e1000_pch2lan) &&
1651
+
!(er32(FWSM) & E1000_ICH_FWSM_FW_VALID))
1652
+
e1000_gate_hw_phy_config_ich8lan(hw, true);
1759
1653
1760
1654
ret_val = e1000e_phy_hw_reset_generic(hw);
1761
1655
if (ret_val)
···
3026
2910
* external PHY is reset.
3027
2911
*/
3028
2912
ctrl |= E1000_CTRL_PHY_RST;
2913
+
2914
+
/*
2915
+
* Gate automatic PHY configuration by hardware on
2916
+
* non-managed 82579
2917
+
*/
2918
+
if ((hw->mac.type == e1000_pch2lan) &&
2919
+
!(er32(FWSM) & E1000_ICH_FWSM_FW_VALID))
2920
+
e1000_gate_hw_phy_config_ich8lan(hw, true);
3029
2921
}
3030
2922
ret_val = e1000_acquire_swflag_ich8lan(hw);
3031
2923
e_dbg("Issuing a global reset to ich8lan\n");
···
3584
3460
void e1000e_disable_gig_wol_ich8lan(struct e1000_hw *hw)
3585
3461
{
3586
3462
u32 phy_ctrl;
3463
+
s32 ret_val;
3587
3464
3588
3465
phy_ctrl = er32(PHY_CTRL);
3589
3466
phy_ctrl |= E1000_PHY_CTRL_D0A_LPLU | E1000_PHY_CTRL_GBE_DISABLE;
3590
3467
ew32(PHY_CTRL, phy_ctrl);
3591
3468
3592
-
if (hw->mac.type >= e1000_pchlan)
3593
-
e1000_phy_hw_reset_ich8lan(hw);
3469
+
if (hw->mac.type >= e1000_pchlan) {
3470
+
e1000_oem_bits_config_ich8lan(hw, true);
3471
+
ret_val = hw->phy.ops.acquire(hw);
3472
+
if (ret_val)
3473
+
return;
3474
+
e1000_write_smbus_addr(hw);
3475
+
hw->phy.ops.release(hw);
3476
+
}
3594
3477
}
3595
3478
3596
3479
/**
+19
-10
drivers/net/e1000e/netdev.c
+19
-10
drivers/net/e1000e/netdev.c
···
2704
2704
u32 psrctl = 0;
2705
2705
u32 pages = 0;
2706
2706
2707
+
/* Workaround Si errata on 82579 - configure jumbo frame flow */
2708
+
if (hw->mac.type == e1000_pch2lan) {
2709
+
s32 ret_val;
2710
+
2711
+
if (adapter->netdev->mtu > ETH_DATA_LEN)
2712
+
ret_val = e1000_lv_jumbo_workaround_ich8lan(hw, true);
2713
+
else
2714
+
ret_val = e1000_lv_jumbo_workaround_ich8lan(hw, false);
2715
+
}
2716
+
2707
2717
/* Program MC offset vector base */
2708
2718
rctl = er32(RCTL);
2709
2719
rctl &= ~(3 << E1000_RCTL_MO_SHIFT);
···
2752
2742
e1e_wphy(hw, 0x10, 0x2823);
2753
2743
e1e_wphy(hw, 0x11, 0x0003);
2754
2744
e1e_wphy(hw, 22, phy_data);
2755
-
}
2756
-
2757
-
/* Workaround Si errata on 82579 - configure jumbo frame flow */
2758
-
if (hw->mac.type == e1000_pch2lan) {
2759
-
s32 ret_val;
2760
-
2761
-
if (rctl & E1000_RCTL_LPE)
2762
-
ret_val = e1000_lv_jumbo_workaround_ich8lan(hw, true);
2763
-
else
2764
-
ret_val = e1000_lv_jumbo_workaround_ich8lan(hw, false);
2765
2745
}
2766
2746
2767
2747
/* Setup buffer sizes */
···
4830
4830
if ((new_mtu < ETH_ZLEN + ETH_FCS_LEN + VLAN_HLEN) ||
4831
4831
(max_frame > adapter->max_hw_frame_size)) {
4832
4832
e_err("Unsupported MTU setting\n");
4833
+
return -EINVAL;
4834
+
}
4835
+
4836
+
/* Jumbo frame workaround on 82579 requires CRC be stripped */
4837
+
if ((adapter->hw.mac.type == e1000_pch2lan) &&
4838
+
!(adapter->flags2 & FLAG2_CRC_STRIPPING) &&
4839
+
(new_mtu > ETH_DATA_LEN)) {
4840
+
e_err("Jumbo Frames not supported on 82579 when CRC "
4841
+
"stripping is disabled.\n");
4833
4842
return -EINVAL;
4834
4843
}
4835
4844
+2
-2
drivers/net/ibm_newemac/core.c
+2
-2
drivers/net/ibm_newemac/core.c
···
2928
2928
if (dev->emac_irq != NO_IRQ)
2929
2929
irq_dispose_mapping(dev->emac_irq);
2930
2930
err_free:
2931
-
kfree(ndev);
2931
+
free_netdev(ndev);
2932
2932
err_gone:
2933
2933
/* if we were on the bootlist, remove us as we won't show up and
2934
2934
* wake up all waiters to notify them in case they were waiting
···
2971
2971
if (dev->emac_irq != NO_IRQ)
2972
2972
irq_dispose_mapping(dev->emac_irq);
2973
2973
2974
-
kfree(dev->ndev);
2974
+
free_netdev(dev->ndev);
2975
2975
2976
2976
return 0;
2977
2977
}
-3
drivers/net/netxen/netxen_nic_init.c
-3
drivers/net/netxen/netxen_nic_init.c
···
1540
1540
if (pkt_offset)
1541
1541
skb_pull(skb, pkt_offset);
1542
1542
1543
-
skb->truesize = skb->len + sizeof(struct sk_buff);
1544
1543
skb->protocol = eth_type_trans(skb, netdev);
1545
1544
1546
1545
napi_gro_receive(&sds_ring->napi, skb);
···
1600
1601
data_offset = l4_hdr_offset + TCP_HDR_SIZE;
1601
1602
1602
1603
skb_put(skb, lro_length + data_offset);
1603
-
1604
-
skb->truesize = skb->len + sizeof(struct sk_buff) + skb_headroom(skb);
1605
1604
1606
1605
skb_pull(skb, l2_hdr_offset);
1607
1606
skb->protocol = eth_type_trans(skb, netdev);
+1
-6
drivers/net/qlcnic/qlcnic_init.c
+1
-6
drivers/net/qlcnic/qlcnic_init.c
···
1316
1316
return -ENOMEM;
1317
1317
}
1318
1318
1319
-
skb_reserve(skb, 2);
1319
+
skb_reserve(skb, NET_IP_ALIGN);
1320
1320
1321
1321
dma = pci_map_single(pdev, skb->data,
1322
1322
rds_ring->dma_size, PCI_DMA_FROMDEVICE);
···
1404
1404
if (pkt_offset)
1405
1405
skb_pull(skb, pkt_offset);
1406
1406
1407
-
skb->truesize = skb->len + sizeof(struct sk_buff);
1408
1407
skb->protocol = eth_type_trans(skb, netdev);
1409
1408
1410
1409
napi_gro_receive(&sds_ring->napi, skb);
···
1464
1465
data_offset = l4_hdr_offset + QLC_TCP_HDR_SIZE;
1465
1466
1466
1467
skb_put(skb, lro_length + data_offset);
1467
-
1468
-
skb->truesize = skb->len + sizeof(struct sk_buff) + skb_headroom(skb);
1469
1468
1470
1469
skb_pull(skb, l2_hdr_offset);
1471
1470
skb->protocol = eth_type_trans(skb, netdev);
···
1696
1699
1697
1700
if (pkt_offset)
1698
1701
skb_pull(skb, pkt_offset);
1699
-
1700
-
skb->truesize = skb->len + sizeof(struct sk_buff);
1701
1702
1702
1703
if (!qlcnic_check_loopback_buff(skb->data))
1703
1704
adapter->diag_cnt++;
+1
-1
drivers/net/rionet.c
+1
-1
drivers/net/rionet.c
···
384
384
free_pages((unsigned long)rionet_active, rdev->net->hport->sys_size ?
385
385
__ilog2(sizeof(void *)) + 4 : 0);
386
386
unregister_netdev(ndev);
387
-
kfree(ndev);
387
+
free_netdev(ndev);
388
388
389
389
list_for_each_entry_safe(peer, tmp, &rionet_peers, node) {
390
390
list_del(&peer->node);
+1
-1
drivers/net/sgiseeq.c
+1
-1
drivers/net/sgiseeq.c
+1
drivers/net/smsc911x.c
+1
drivers/net/smsc911x.c
+38
-5
drivers/net/tulip/de2104x.c
+38
-5
drivers/net/tulip/de2104x.c
···
243
243
NWayState = (1 << 14) | (1 << 13) | (1 << 12),
244
244
NWayRestart = (1 << 12),
245
245
NonselPortActive = (1 << 9),
246
+
SelPortActive = (1 << 8),
246
247
LinkFailStatus = (1 << 2),
247
248
NetCxnErr = (1 << 1),
248
249
};
···
364
363
365
364
/* 21041 transceiver register settings: TP AUTO, BNC, AUI, TP, TP FD*/
366
365
static u16 t21041_csr13[] = { 0xEF01, 0xEF09, 0xEF09, 0xEF01, 0xEF09, };
367
-
static u16 t21041_csr14[] = { 0xFFFF, 0xF7FD, 0xF7FD, 0x6F3F, 0x6F3D, };
366
+
static u16 t21041_csr14[] = { 0xFFFF, 0xF7FD, 0xF7FD, 0x7F3F, 0x7F3D, };
367
+
/* If on-chip autonegotiation is broken, use half-duplex (FF3F) instead */
368
+
static u16 t21041_csr14_brk[] = { 0xFF3F, 0xF7FD, 0xF7FD, 0x7F3F, 0x7F3D, };
368
369
static u16 t21041_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, };
369
370
370
371
···
1067
1064
unsigned int carrier;
1068
1065
unsigned long flags;
1069
1066
1067
+
/* clear port active bits */
1068
+
dw32(SIAStatus, NonselPortActive | SelPortActive);
1069
+
1070
1070
carrier = (status & NetCxnErr) ? 0 : 1;
1071
1071
1072
1072
if (carrier) {
···
1164
1158
static void de_media_interrupt (struct de_private *de, u32 status)
1165
1159
{
1166
1160
if (status & LinkPass) {
1161
+
/* Ignore if current media is AUI or BNC and we can't use TP */
1162
+
if ((de->media_type == DE_MEDIA_AUI ||
1163
+
de->media_type == DE_MEDIA_BNC) &&
1164
+
(de->media_lock ||
1165
+
!de_ok_to_advertise(de, DE_MEDIA_TP_AUTO)))
1166
+
return;
1167
+
/* If current media is not TP, change it to TP */
1168
+
if ((de->media_type == DE_MEDIA_AUI ||
1169
+
de->media_type == DE_MEDIA_BNC)) {
1170
+
de->media_type = DE_MEDIA_TP_AUTO;
1171
+
de_stop_rxtx(de);
1172
+
de_set_media(de);
1173
+
de_start_rxtx(de);
1174
+
}
1167
1175
de_link_up(de);
1168
1176
mod_timer(&de->media_timer, jiffies + DE_TIMER_LINK);
1169
1177
return;
1170
1178
}
1171
1179
1172
1180
BUG_ON(!(status & LinkFail));
1173
-
1174
-
if (netif_carrier_ok(de->dev)) {
1181
+
/* Mark the link as down only if current media is TP */
1182
+
if (netif_carrier_ok(de->dev) && de->media_type != DE_MEDIA_AUI &&
1183
+
de->media_type != DE_MEDIA_BNC) {
1175
1184
de_link_down(de);
1176
1185
mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1177
1186
}
···
1250
1229
if (de->de21040)
1251
1230
return;
1252
1231
1232
+
dw32(CSR13, 0); /* Reset phy */
1253
1233
pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1254
1234
pmctl |= PM_Sleep;
1255
1235
pci_write_config_dword(de->pdev, PCIPM, pmctl);
···
1596
1574
return 0; /* nothing to change */
1597
1575
1598
1576
de_link_down(de);
1577
+
mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1599
1578
de_stop_rxtx(de);
1600
1579
1601
1580
de->media_type = new_media;
1602
1581
de->media_lock = media_lock;
1603
1582
de->media_advertise = ecmd->advertising;
1604
1583
de_set_media(de);
1584
+
if (netif_running(de->dev))
1585
+
de_start_rxtx(de);
1605
1586
1606
1587
return 0;
1607
1588
}
···
1936
1911
for (i = 0; i < DE_MAX_MEDIA; i++) {
1937
1912
if (de->media[i].csr13 == 0xffff)
1938
1913
de->media[i].csr13 = t21041_csr13[i];
1939
-
if (de->media[i].csr14 == 0xffff)
1940
-
de->media[i].csr14 = t21041_csr14[i];
1914
+
if (de->media[i].csr14 == 0xffff) {
1915
+
/* autonegotiation is broken at least on some chip
1916
+
revisions - rev. 0x21 works, 0x11 does not */
1917
+
if (de->pdev->revision < 0x20)
1918
+
de->media[i].csr14 = t21041_csr14_brk[i];
1919
+
else
1920
+
de->media[i].csr14 = t21041_csr14[i];
1921
+
}
1941
1922
if (de->media[i].csr15 == 0xffff)
1942
1923
de->media[i].csr15 = t21041_csr15[i];
1943
1924
}
···
2189
2158
dev_err(&dev->dev, "pci_enable_device failed in resume\n");
2190
2159
goto out;
2191
2160
}
2161
+
pci_set_master(pdev);
2162
+
de_init_rings(de);
2192
2163
de_init_hw(de);
2193
2164
out_attach:
2194
2165
netif_device_attach(dev);
+5
drivers/net/wireless/iwlwifi/iwl-core.c
+5
drivers/net/wireless/iwlwifi/iwl-core.c
···
2613
2613
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
2614
2614
return -EINVAL;
2615
2615
2616
+
if (test_bit(STATUS_SCANNING, &priv->status)) {
2617
+
IWL_DEBUG_INFO(priv, "scan in progress.\n");
2618
+
return -EINVAL;
2619
+
}
2620
+
2616
2621
if (mode >= IWL_MAX_FORCE_RESET) {
2617
2622
IWL_DEBUG_INFO(priv, "invalid reset request.\n");
2618
2623
return -EINVAL;
+2
-2
drivers/s390/net/ctcm_main.c
+2
-2
drivers/s390/net/ctcm_main.c
···
1154
1154
dev_fsm, dev_fsm_len, GFP_KERNEL);
1155
1155
if (priv->fsm == NULL) {
1156
1156
CTCMY_DBF_DEV(SETUP, dev, "init_fsm error");
1157
-
kfree(dev);
1157
+
free_netdev(dev);
1158
1158
return NULL;
1159
1159
}
1160
1160
fsm_newstate(priv->fsm, DEV_STATE_STOPPED);
···
1165
1165
grp = ctcmpc_init_mpc_group(priv);
1166
1166
if (grp == NULL) {
1167
1167
MPC_DBF_DEV(SETUP, dev, "init_mpc_group error");
1168
-
kfree(dev);
1168
+
free_netdev(dev);
1169
1169
return NULL;
1170
1170
}
1171
1171
tasklet_init(&grp->mpc_tasklet2,
+1
-1
drivers/vhost/net.c
+1
-1
drivers/vhost/net.c
+4
-3
drivers/vhost/vhost.c
+4
-3
drivers/vhost/vhost.c
···
858
858
if (r < 0)
859
859
return r;
860
860
len -= l;
861
-
if (!len)
861
+
if (!len) {
862
+
if (vq->log_ctx)
863
+
eventfd_signal(vq->log_ctx, 1);
862
864
return 0;
865
+
}
863
866
}
864
-
if (vq->log_ctx)
865
-
eventfd_signal(vq->log_ctx, 1);
866
867
/* Length written exceeds what we have stored. This is a bug. */
867
868
BUG();
868
869
return 0;
+2
-2
include/linux/netlink.h
+2
-2
include/linux/netlink.h
···
27
27
28
28
#define MAX_LINKS 32
29
29
30
-
struct net;
31
-
32
30
struct sockaddr_nl {
33
31
sa_family_t nl_family; /* AF_NETLINK */
34
32
unsigned short nl_pad; /* zero */
···
148
150
149
151
#include <linux/capability.h>
150
152
#include <linux/skbuff.h>
153
+
154
+
struct net;
151
155
152
156
static inline struct nlmsghdr *nlmsg_hdr(const struct sk_buff *skb)
153
157
{
+1
-1
include/linux/socket.h
+1
-1
include/linux/socket.h
···
322
322
int offset,
323
323
unsigned int len, __wsum *csump);
324
324
325
-
extern int verify_iovec(struct msghdr *m, struct iovec *iov, struct sockaddr *address, int mode);
325
+
extern long verify_iovec(struct msghdr *m, struct iovec *iov, struct sockaddr *address, int mode);
326
326
extern int memcpy_toiovec(struct iovec *v, unsigned char *kdata, int len);
327
327
extern int memcpy_toiovecend(const struct iovec *v, unsigned char *kdata,
328
328
int offset, int len);
+1
include/net/addrconf.h
+1
include/net/addrconf.h
···
121
121
* IPv6 Address Label subsystem (addrlabel.c)
122
122
*/
123
123
extern int ipv6_addr_label_init(void);
124
+
extern void ipv6_addr_label_cleanup(void);
124
125
extern void ipv6_addr_label_rtnl_register(void);
125
126
extern u32 ipv6_addr_label(struct net *net,
126
127
const struct in6_addr *addr,
+1
include/net/dst.h
+1
include/net/dst.h
+2
include/net/route.h
+2
include/net/route.h
+2
-2
include/net/xfrm.h
+2
-2
include/net/xfrm.h
···
298
298
const struct xfrm_type *type_map[IPPROTO_MAX];
299
299
struct xfrm_mode *mode_map[XFRM_MODE_MAX];
300
300
int (*init_flags)(struct xfrm_state *x);
301
-
void (*init_tempsel)(struct xfrm_state *x, struct flowi *fl,
302
-
struct xfrm_tmpl *tmpl,
301
+
void (*init_tempsel)(struct xfrm_selector *sel, struct flowi *fl);
302
+
void (*init_temprop)(struct xfrm_state *x, struct xfrm_tmpl *tmpl,
303
303
xfrm_address_t *daddr, xfrm_address_t *saddr);
304
304
int (*tmpl_sort)(struct xfrm_tmpl **dst, struct xfrm_tmpl **src, int n);
305
305
int (*state_sort)(struct xfrm_state **dst, struct xfrm_state **src, int n);
+2
-1
net/9p/trans_virtio.c
+2
-1
net/9p/trans_virtio.c
···
329
329
330
330
mutex_lock(&virtio_9p_lock);
331
331
list_for_each_entry(chan, &virtio_chan_list, chan_list) {
332
-
if (!strncmp(devname, chan->tag, chan->tag_len)) {
332
+
if (!strncmp(devname, chan->tag, chan->tag_len) &&
333
+
strlen(devname) == chan->tag_len) {
333
334
if (!chan->inuse) {
334
335
chan->inuse = true;
335
336
found = 1;
+2
-10
net/atm/br2684.c
+2
-10
net/atm/br2684.c
···
399
399
unregister_netdev(net_dev);
400
400
free_netdev(net_dev);
401
401
}
402
-
read_lock_irq(&devs_lock);
403
-
if (list_empty(&br2684_devs)) {
404
-
/* last br2684 device */
405
-
unregister_atmdevice_notifier(&atm_dev_notifier);
406
-
}
407
-
read_unlock_irq(&devs_lock);
408
402
return;
409
403
}
410
404
···
669
675
670
676
if (list_empty(&br2684_devs)) {
671
677
/* 1st br2684 device */
672
-
register_atmdevice_notifier(&atm_dev_notifier);
673
678
brdev->number = 1;
674
679
} else
675
680
brdev->number = BRPRIV(list_entry_brdev(br2684_devs.prev))->number + 1;
···
808
815
return -ENOMEM;
809
816
#endif
810
817
register_atm_ioctl(&br2684_ioctl_ops);
818
+
register_atmdevice_notifier(&atm_dev_notifier);
811
819
return 0;
812
820
}
813
821
···
824
830
#endif
825
831
826
832
827
-
/* if not already empty */
828
-
if (!list_empty(&br2684_devs))
829
-
unregister_atmdevice_notifier(&atm_dev_notifier);
833
+
unregister_atmdevice_notifier(&atm_dev_notifier);
830
834
831
835
while (!list_empty(&br2684_devs)) {
832
836
net_dev = list_entry_brdev(br2684_devs.next);
+3
-2
net/core/iovec.c
+3
-2
net/core/iovec.c
···
35
35
* in any case.
36
36
*/
37
37
38
-
int verify_iovec(struct msghdr *m, struct iovec *iov, struct sockaddr *address, int mode)
38
+
long verify_iovec(struct msghdr *m, struct iovec *iov, struct sockaddr *address, int mode)
39
39
{
40
-
int size, err, ct;
40
+
int size, ct;
41
+
long err;
41
42
42
43
if (m->msg_namelen) {
43
44
if (mode == VERIFY_READ) {
+4
-4
net/core/sock.c
+4
-4
net/core/sock.c
···
1351
1351
{
1352
1352
int uid;
1353
1353
1354
-
read_lock(&sk->sk_callback_lock);
1354
+
read_lock_bh(&sk->sk_callback_lock);
1355
1355
uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : 0;
1356
-
read_unlock(&sk->sk_callback_lock);
1356
+
read_unlock_bh(&sk->sk_callback_lock);
1357
1357
return uid;
1358
1358
}
1359
1359
EXPORT_SYMBOL(sock_i_uid);
···
1362
1362
{
1363
1363
unsigned long ino;
1364
1364
1365
-
read_lock(&sk->sk_callback_lock);
1365
+
read_lock_bh(&sk->sk_callback_lock);
1366
1366
ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0;
1367
-
read_unlock(&sk->sk_callback_lock);
1367
+
read_unlock_bh(&sk->sk_callback_lock);
1368
1368
return ino;
1369
1369
}
1370
1370
EXPORT_SYMBOL(sock_i_ino);
+4
-4
net/ipv4/ip_gre.c
+4
-4
net/ipv4/ip_gre.c
···
45
45
#include <net/netns/generic.h>
46
46
#include <net/rtnetlink.h>
47
47
48
-
#ifdef CONFIG_IPV6
48
+
#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
49
49
#include <net/ipv6.h>
50
50
#include <net/ip6_fib.h>
51
51
#include <net/ip6_route.h>
···
699
699
if ((dst = rt->rt_gateway) == 0)
700
700
goto tx_error_icmp;
701
701
}
702
-
#ifdef CONFIG_IPV6
702
+
#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
703
703
else if (skb->protocol == htons(ETH_P_IPV6)) {
704
704
struct in6_addr *addr6;
705
705
int addr_type;
···
774
774
goto tx_error;
775
775
}
776
776
}
777
-
#ifdef CONFIG_IPV6
777
+
#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
778
778
else if (skb->protocol == htons(ETH_P_IPV6)) {
779
779
struct rt6_info *rt6 = (struct rt6_info *)skb_dst(skb);
780
780
···
850
850
if ((iph->ttl = tiph->ttl) == 0) {
851
851
if (skb->protocol == htons(ETH_P_IP))
852
852
iph->ttl = old_iph->ttl;
853
-
#ifdef CONFIG_IPV6
853
+
#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
854
854
else if (skb->protocol == htons(ETH_P_IPV6))
855
855
iph->ttl = ((struct ipv6hdr *)old_iph)->hop_limit;
856
856
#endif
+13
-6
net/ipv4/ip_output.c
+13
-6
net/ipv4/ip_output.c
···
488
488
* we can switch to copy when see the first bad fragment.
489
489
*/
490
490
if (skb_has_frags(skb)) {
491
-
struct sk_buff *frag;
491
+
struct sk_buff *frag, *frag2;
492
492
int first_len = skb_pagelen(skb);
493
-
int truesizes = 0;
494
493
495
494
if (first_len - hlen > mtu ||
496
495
((first_len - hlen) & 7) ||
···
502
503
if (frag->len > mtu ||
503
504
((frag->len & 7) && frag->next) ||
504
505
skb_headroom(frag) < hlen)
505
-
goto slow_path;
506
+
goto slow_path_clean;
506
507
507
508
/* Partially cloned skb? */
508
509
if (skb_shared(frag))
509
-
goto slow_path;
510
+
goto slow_path_clean;
510
511
511
512
BUG_ON(frag->sk);
512
513
if (skb->sk) {
513
514
frag->sk = skb->sk;
514
515
frag->destructor = sock_wfree;
515
516
}
516
-
truesizes += frag->truesize;
517
+
skb->truesize -= frag->truesize;
517
518
}
518
519
519
520
/* Everything is OK. Generate! */
···
523
524
frag = skb_shinfo(skb)->frag_list;
524
525
skb_frag_list_init(skb);
525
526
skb->data_len = first_len - skb_headlen(skb);
526
-
skb->truesize -= truesizes;
527
527
skb->len = first_len;
528
528
iph->tot_len = htons(first_len);
529
529
iph->frag_off = htons(IP_MF);
···
574
576
}
575
577
IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGFAILS);
576
578
return err;
579
+
580
+
slow_path_clean:
581
+
skb_walk_frags(skb, frag2) {
582
+
if (frag2 == frag)
583
+
break;
584
+
frag2->sk = NULL;
585
+
frag2->destructor = NULL;
586
+
skb->truesize += frag2->truesize;
587
+
}
577
588
}
578
589
579
590
slow_path:
+1
net/ipv4/netfilter/ipt_REJECT.c
+1
net/ipv4/netfilter/ipt_REJECT.c
+3
-1
net/ipv4/netfilter/nf_defrag_ipv4.c
+3
-1
net/ipv4/netfilter/nf_defrag_ipv4.c
···
66
66
const struct net_device *out,
67
67
int (*okfn)(struct sk_buff *))
68
68
{
69
+
struct sock *sk = skb->sk;
69
70
struct inet_sock *inet = inet_sk(skb->sk);
70
71
71
-
if (inet && inet->nodefrag)
72
+
if (sk && (sk->sk_family == PF_INET) &&
73
+
inet->nodefrag)
72
74
return NF_ACCEPT;
73
75
74
76
#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
+4
-2
net/ipv4/netfilter/nf_nat_snmp_basic.c
+4
-2
net/ipv4/netfilter/nf_nat_snmp_basic.c
···
893
893
unsigned char s[4];
894
894
895
895
if (offset & 1) {
896
-
s[0] = s[2] = 0;
896
+
s[0] = ~0;
897
897
s[1] = ~*optr;
898
+
s[2] = 0;
898
899
s[3] = *nptr;
899
900
} else {
900
-
s[1] = s[3] = 0;
901
901
s[0] = ~*optr;
902
+
s[1] = ~0;
902
903
s[2] = *nptr;
904
+
s[3] = 0;
903
905
}
904
906
905
907
*csum = csum_fold(csum_partial(s, 4, ~csum_unfold(*csum)));
+1
-1
net/ipv4/route.c
+1
-1
net/ipv4/route.c
+6
-3
net/ipv4/tcp.c
+6
-3
net/ipv4/tcp.c
···
386
386
*/
387
387
388
388
mask = 0;
389
-
if (sk->sk_err)
390
-
mask = POLLERR;
391
389
392
390
/*
393
391
* POLLHUP is certainly not done right. But poll() doesn't
···
455
457
if (tp->urg_data & TCP_URG_VALID)
456
458
mask |= POLLPRI;
457
459
}
460
+
/* This barrier is coupled with smp_wmb() in tcp_reset() */
461
+
smp_rmb();
462
+
if (sk->sk_err)
463
+
mask |= POLLERR;
464
+
458
465
return mask;
459
466
}
460
467
EXPORT_SYMBOL(tcp_poll);
···
943
940
sg = sk->sk_route_caps & NETIF_F_SG;
944
941
945
942
while (--iovlen >= 0) {
946
-
int seglen = iov->iov_len;
943
+
size_t seglen = iov->iov_len;
947
944
unsigned char __user *from = iov->iov_base;
948
945
949
946
iov++;
+4
-1
net/ipv4/tcp_input.c
+4
-1
net/ipv4/tcp_input.c
···
2545
2545
cnt += tcp_skb_pcount(skb);
2546
2546
2547
2547
if (cnt > packets) {
2548
-
if (tcp_is_sack(tp) || (oldcnt >= packets))
2548
+
if ((tcp_is_sack(tp) && !tcp_is_fack(tp)) ||
2549
+
(oldcnt >= packets))
2549
2550
break;
2550
2551
2551
2552
mss = skb_shinfo(skb)->gso_size;
···
4049
4048
default:
4050
4049
sk->sk_err = ECONNRESET;
4051
4050
}
4051
+
/* This barrier is coupled with smp_rmb() in tcp_poll() */
4052
+
smp_wmb();
4052
4053
4053
4054
if (!sock_flag(sk, SOCK_DEAD))
4054
4055
sk->sk_error_report(sk);
+1
-1
net/ipv4/xfrm4_policy.c
+1
-1
net/ipv4/xfrm4_policy.c
+19
-14
net/ipv4/xfrm4_state.c
+19
-14
net/ipv4/xfrm4_state.c
···
21
21
}
22
22
23
23
static void
24
-
__xfrm4_init_tempsel(struct xfrm_state *x, struct flowi *fl,
25
-
struct xfrm_tmpl *tmpl,
26
-
xfrm_address_t *daddr, xfrm_address_t *saddr)
24
+
__xfrm4_init_tempsel(struct xfrm_selector *sel, struct flowi *fl)
27
25
{
28
-
x->sel.daddr.a4 = fl->fl4_dst;
29
-
x->sel.saddr.a4 = fl->fl4_src;
30
-
x->sel.dport = xfrm_flowi_dport(fl);
31
-
x->sel.dport_mask = htons(0xffff);
32
-
x->sel.sport = xfrm_flowi_sport(fl);
33
-
x->sel.sport_mask = htons(0xffff);
34
-
x->sel.family = AF_INET;
35
-
x->sel.prefixlen_d = 32;
36
-
x->sel.prefixlen_s = 32;
37
-
x->sel.proto = fl->proto;
38
-
x->sel.ifindex = fl->oif;
26
+
sel->daddr.a4 = fl->fl4_dst;
27
+
sel->saddr.a4 = fl->fl4_src;
28
+
sel->dport = xfrm_flowi_dport(fl);
29
+
sel->dport_mask = htons(0xffff);
30
+
sel->sport = xfrm_flowi_sport(fl);
31
+
sel->sport_mask = htons(0xffff);
32
+
sel->family = AF_INET;
33
+
sel->prefixlen_d = 32;
34
+
sel->prefixlen_s = 32;
35
+
sel->proto = fl->proto;
36
+
sel->ifindex = fl->oif;
37
+
}
38
+
39
+
static void
40
+
xfrm4_init_temprop(struct xfrm_state *x, struct xfrm_tmpl *tmpl,
41
+
xfrm_address_t *daddr, xfrm_address_t *saddr)
42
+
{
39
43
x->id = tmpl->id;
40
44
if (x->id.daddr.a4 == 0)
41
45
x->id.daddr.a4 = daddr->a4;
···
74
70
.owner = THIS_MODULE,
75
71
.init_flags = xfrm4_init_flags,
76
72
.init_tempsel = __xfrm4_init_tempsel,
73
+
.init_temprop = xfrm4_init_temprop,
77
74
.output = xfrm4_output,
78
75
.extract_input = xfrm4_extract_input,
79
76
.extract_output = xfrm4_extract_output,
+8
-3
net/ipv6/addrconf.c
+8
-3
net/ipv6/addrconf.c
···
4637
4637
if (err < 0) {
4638
4638
printk(KERN_CRIT "IPv6 Addrconf:"
4639
4639
" cannot initialize default policy table: %d.\n", err);
4640
-
return err;
4640
+
goto out;
4641
4641
}
4642
4642
4643
-
register_pernet_subsys(&addrconf_ops);
4643
+
err = register_pernet_subsys(&addrconf_ops);
4644
+
if (err < 0)
4645
+
goto out_addrlabel;
4644
4646
4645
4647
/* The addrconf netdev notifier requires that loopback_dev
4646
4648
* has it's ipv6 private information allocated and setup
···
4694
4692
unregister_netdevice_notifier(&ipv6_dev_notf);
4695
4693
errlo:
4696
4694
unregister_pernet_subsys(&addrconf_ops);
4697
-
4695
+
out_addrlabel:
4696
+
ipv6_addr_label_cleanup();
4697
+
out:
4698
4698
return err;
4699
4699
}
4700
4700
···
4707
4703
4708
4704
unregister_netdevice_notifier(&ipv6_dev_notf);
4709
4705
unregister_pernet_subsys(&addrconf_ops);
4706
+
ipv6_addr_label_cleanup();
4710
4707
4711
4708
rtnl_lock();
4712
4709
+5
net/ipv6/addrlabel.c
+5
net/ipv6/addrlabel.c
···
393
393
return register_pernet_subsys(&ipv6_addr_label_ops);
394
394
}
395
395
396
+
void ipv6_addr_label_cleanup(void)
397
+
{
398
+
unregister_pernet_subsys(&ipv6_addr_label_ops);
399
+
}
400
+
396
401
static const struct nla_policy ifal_policy[IFAL_MAX+1] = {
397
402
[IFAL_ADDRESS] = { .len = sizeof(struct in6_addr), },
398
403
[IFAL_LABEL] = { .len = sizeof(u32), },
+13
-5
net/ipv6/ip6_output.c
+13
-5
net/ipv6/ip6_output.c
···
639
639
640
640
if (skb_has_frags(skb)) {
641
641
int first_len = skb_pagelen(skb);
642
-
int truesizes = 0;
642
+
struct sk_buff *frag2;
643
643
644
644
if (first_len - hlen > mtu ||
645
645
((first_len - hlen) & 7) ||
···
651
651
if (frag->len > mtu ||
652
652
((frag->len & 7) && frag->next) ||
653
653
skb_headroom(frag) < hlen)
654
-
goto slow_path;
654
+
goto slow_path_clean;
655
655
656
656
/* Partially cloned skb? */
657
657
if (skb_shared(frag))
658
-
goto slow_path;
658
+
goto slow_path_clean;
659
659
660
660
BUG_ON(frag->sk);
661
661
if (skb->sk) {
662
662
frag->sk = skb->sk;
663
663
frag->destructor = sock_wfree;
664
-
truesizes += frag->truesize;
665
664
}
665
+
skb->truesize -= frag->truesize;
666
666
}
667
667
668
668
err = 0;
···
693
693
694
694
first_len = skb_pagelen(skb);
695
695
skb->data_len = first_len - skb_headlen(skb);
696
-
skb->truesize -= truesizes;
697
696
skb->len = first_len;
698
697
ipv6_hdr(skb)->payload_len = htons(first_len -
699
698
sizeof(struct ipv6hdr));
···
755
756
IPSTATS_MIB_FRAGFAILS);
756
757
dst_release(&rt->dst);
757
758
return err;
759
+
760
+
slow_path_clean:
761
+
skb_walk_frags(skb, frag2) {
762
+
if (frag2 == frag)
763
+
break;
764
+
frag2->sk = NULL;
765
+
frag2->destructor = NULL;
766
+
skb->truesize += frag2->truesize;
767
+
}
758
768
}
759
769
760
770
slow_path:
+1
-1
net/ipv6/route.c
+1
-1
net/ipv6/route.c
+19
-14
net/ipv6/xfrm6_state.c
+19
-14
net/ipv6/xfrm6_state.c
···
20
20
#include <net/addrconf.h>
21
21
22
22
static void
23
-
__xfrm6_init_tempsel(struct xfrm_state *x, struct flowi *fl,
24
-
struct xfrm_tmpl *tmpl,
25
-
xfrm_address_t *daddr, xfrm_address_t *saddr)
23
+
__xfrm6_init_tempsel(struct xfrm_selector *sel, struct flowi *fl)
26
24
{
27
25
/* Initialize temporary selector matching only
28
26
* to current session. */
29
-
ipv6_addr_copy((struct in6_addr *)&x->sel.daddr, &fl->fl6_dst);
30
-
ipv6_addr_copy((struct in6_addr *)&x->sel.saddr, &fl->fl6_src);
31
-
x->sel.dport = xfrm_flowi_dport(fl);
32
-
x->sel.dport_mask = htons(0xffff);
33
-
x->sel.sport = xfrm_flowi_sport(fl);
34
-
x->sel.sport_mask = htons(0xffff);
35
-
x->sel.family = AF_INET6;
36
-
x->sel.prefixlen_d = 128;
37
-
x->sel.prefixlen_s = 128;
38
-
x->sel.proto = fl->proto;
39
-
x->sel.ifindex = fl->oif;
27
+
ipv6_addr_copy((struct in6_addr *)&sel->daddr, &fl->fl6_dst);
28
+
ipv6_addr_copy((struct in6_addr *)&sel->saddr, &fl->fl6_src);
29
+
sel->dport = xfrm_flowi_dport(fl);
30
+
sel->dport_mask = htons(0xffff);
31
+
sel->sport = xfrm_flowi_sport(fl);
32
+
sel->sport_mask = htons(0xffff);
33
+
sel->family = AF_INET6;
34
+
sel->prefixlen_d = 128;
35
+
sel->prefixlen_s = 128;
36
+
sel->proto = fl->proto;
37
+
sel->ifindex = fl->oif;
38
+
}
39
+
40
+
static void
41
+
xfrm6_init_temprop(struct xfrm_state *x, struct xfrm_tmpl *tmpl,
42
+
xfrm_address_t *daddr, xfrm_address_t *saddr)
43
+
{
40
44
x->id = tmpl->id;
41
45
if (ipv6_addr_any((struct in6_addr*)&x->id.daddr))
42
46
memcpy(&x->id.daddr, daddr, sizeof(x->sel.daddr));
···
172
168
.eth_proto = htons(ETH_P_IPV6),
173
169
.owner = THIS_MODULE,
174
170
.init_tempsel = __xfrm6_init_tempsel,
171
+
.init_temprop = xfrm6_init_temprop,
175
172
.tmpl_sort = __xfrm6_tmpl_sort,
176
173
.state_sort = __xfrm6_state_sort,
177
174
.output = xfrm6_output,
+3
-1
net/netfilter/nf_conntrack_extend.c
+3
-1
net/netfilter/nf_conntrack_extend.c
···
48
48
{
49
49
unsigned int off, len;
50
50
struct nf_ct_ext_type *t;
51
+
size_t alloc_size;
51
52
52
53
rcu_read_lock();
53
54
t = rcu_dereference(nf_ct_ext_types[id]);
54
55
BUG_ON(t == NULL);
55
56
off = ALIGN(sizeof(struct nf_ct_ext), t->align);
56
57
len = off + t->len;
58
+
alloc_size = t->alloc_size;
57
59
rcu_read_unlock();
58
60
59
-
*ext = kzalloc(t->alloc_size, gfp);
61
+
*ext = kzalloc(alloc_size, gfp);
60
62
if (!*ext)
61
63
return NULL;
62
64
+1
-1
net/netfilter/nf_conntrack_sip.c
+1
-1
net/netfilter/nf_conntrack_sip.c
+5
-1
net/netfilter/nf_tproxy_core.c
+5
-1
net/netfilter/nf_tproxy_core.c
···
70
70
int
71
71
nf_tproxy_assign_sock(struct sk_buff *skb, struct sock *sk)
72
72
{
73
-
if (inet_sk(sk)->transparent) {
73
+
bool transparent = (sk->sk_state == TCP_TIME_WAIT) ?
74
+
inet_twsk(sk)->tw_transparent :
75
+
inet_sk(sk)->transparent;
76
+
77
+
if (transparent) {
74
78
skb_orphan(skb);
75
79
skb->sk = sk;
76
80
skb->destructor = nf_tproxy_destructor;
+2
-2
net/rds/tcp_connect.c
+2
-2
net/rds/tcp_connect.c
···
43
43
struct rds_connection *conn;
44
44
struct rds_tcp_connection *tc;
45
45
46
-
read_lock(&sk->sk_callback_lock);
46
+
read_lock_bh(&sk->sk_callback_lock);
47
47
conn = sk->sk_user_data;
48
48
if (conn == NULL) {
49
49
state_change = sk->sk_state_change;
···
68
68
break;
69
69
}
70
70
out:
71
-
read_unlock(&sk->sk_callback_lock);
71
+
read_unlock_bh(&sk->sk_callback_lock);
72
72
state_change(sk);
73
73
}
74
74
+2
-2
net/rds/tcp_listen.c
+2
-2
net/rds/tcp_listen.c
···
114
114
115
115
rdsdebug("listen data ready sk %p\n", sk);
116
116
117
-
read_lock(&sk->sk_callback_lock);
117
+
read_lock_bh(&sk->sk_callback_lock);
118
118
ready = sk->sk_user_data;
119
119
if (ready == NULL) { /* check for teardown race */
120
120
ready = sk->sk_data_ready;
···
131
131
queue_work(rds_wq, &rds_tcp_listen_work);
132
132
133
133
out:
134
-
read_unlock(&sk->sk_callback_lock);
134
+
read_unlock_bh(&sk->sk_callback_lock);
135
135
ready(sk, bytes);
136
136
}
137
137
+2
-2
net/rds/tcp_recv.c
+2
-2
net/rds/tcp_recv.c
···
324
324
325
325
rdsdebug("data ready sk %p bytes %d\n", sk, bytes);
326
326
327
-
read_lock(&sk->sk_callback_lock);
327
+
read_lock_bh(&sk->sk_callback_lock);
328
328
conn = sk->sk_user_data;
329
329
if (conn == NULL) { /* check for teardown race */
330
330
ready = sk->sk_data_ready;
···
338
338
if (rds_tcp_read_sock(conn, GFP_ATOMIC, KM_SOFTIRQ0) == -ENOMEM)
339
339
queue_delayed_work(rds_wq, &conn->c_recv_w, 0);
340
340
out:
341
-
read_unlock(&sk->sk_callback_lock);
341
+
read_unlock_bh(&sk->sk_callback_lock);
342
342
ready(sk, bytes);
343
343
}
344
344
+2
-2
net/rds/tcp_send.c
+2
-2
net/rds/tcp_send.c
···
224
224
struct rds_connection *conn;
225
225
struct rds_tcp_connection *tc;
226
226
227
-
read_lock(&sk->sk_callback_lock);
227
+
read_lock_bh(&sk->sk_callback_lock);
228
228
conn = sk->sk_user_data;
229
229
if (conn == NULL) {
230
230
write_space = sk->sk_write_space;
···
244
244
queue_delayed_work(rds_wq, &conn->c_send_w, 0);
245
245
246
246
out:
247
-
read_unlock(&sk->sk_callback_lock);
247
+
read_unlock_bh(&sk->sk_callback_lock);
248
248
249
249
/*
250
250
* write_space is only called when data leaves tcp's send queue if
+2
-2
net/rose/af_rose.c
+2
-2
net/rose/af_rose.c
···
679
679
if (addr_len == sizeof(struct sockaddr_rose) && addr->srose_ndigis > 1)
680
680
return -EINVAL;
681
681
682
-
if (addr->srose_ndigis > ROSE_MAX_DIGIS)
682
+
if ((unsigned int) addr->srose_ndigis > ROSE_MAX_DIGIS)
683
683
return -EINVAL;
684
684
685
685
if ((dev = rose_dev_get(&addr->srose_addr)) == NULL) {
···
739
739
if (addr_len == sizeof(struct sockaddr_rose) && addr->srose_ndigis > 1)
740
740
return -EINVAL;
741
741
742
-
if (addr->srose_ndigis > ROSE_MAX_DIGIS)
742
+
if ((unsigned int) addr->srose_ndigis > ROSE_MAX_DIGIS)
743
743
return -EINVAL;
744
744
745
745
/* Source + Destination digis should not exceed ROSE_MAX_DIGIS */
+14
-14
net/sunrpc/xprtsock.c
+14
-14
net/sunrpc/xprtsock.c
···
800
800
u32 _xid;
801
801
__be32 *xp;
802
802
803
-
read_lock(&sk->sk_callback_lock);
803
+
read_lock_bh(&sk->sk_callback_lock);
804
804
dprintk("RPC: xs_udp_data_ready...\n");
805
805
if (!(xprt = xprt_from_sock(sk)))
806
806
goto out;
···
852
852
dropit:
853
853
skb_free_datagram(sk, skb);
854
854
out:
855
-
read_unlock(&sk->sk_callback_lock);
855
+
read_unlock_bh(&sk->sk_callback_lock);
856
856
}
857
857
858
858
static inline void xs_tcp_read_fraghdr(struct rpc_xprt *xprt, struct xdr_skb_reader *desc)
···
1229
1229
1230
1230
dprintk("RPC: xs_tcp_data_ready...\n");
1231
1231
1232
-
read_lock(&sk->sk_callback_lock);
1232
+
read_lock_bh(&sk->sk_callback_lock);
1233
1233
if (!(xprt = xprt_from_sock(sk)))
1234
1234
goto out;
1235
1235
if (xprt->shutdown)
···
1248
1248
read = tcp_read_sock(sk, &rd_desc, xs_tcp_data_recv);
1249
1249
} while (read > 0);
1250
1250
out:
1251
-
read_unlock(&sk->sk_callback_lock);
1251
+
read_unlock_bh(&sk->sk_callback_lock);
1252
1252
}
1253
1253
1254
1254
/*
···
1301
1301
{
1302
1302
struct rpc_xprt *xprt;
1303
1303
1304
-
read_lock(&sk->sk_callback_lock);
1304
+
read_lock_bh(&sk->sk_callback_lock);
1305
1305
if (!(xprt = xprt_from_sock(sk)))
1306
1306
goto out;
1307
1307
dprintk("RPC: xs_tcp_state_change client %p...\n", xprt);
···
1313
1313
1314
1314
switch (sk->sk_state) {
1315
1315
case TCP_ESTABLISHED:
1316
-
spin_lock_bh(&xprt->transport_lock);
1316
+
spin_lock(&xprt->transport_lock);
1317
1317
if (!xprt_test_and_set_connected(xprt)) {
1318
1318
struct sock_xprt *transport = container_of(xprt,
1319
1319
struct sock_xprt, xprt);
···
1327
1327
1328
1328
xprt_wake_pending_tasks(xprt, -EAGAIN);
1329
1329
}
1330
-
spin_unlock_bh(&xprt->transport_lock);
1330
+
spin_unlock(&xprt->transport_lock);
1331
1331
break;
1332
1332
case TCP_FIN_WAIT1:
1333
1333
/* The client initiated a shutdown of the socket */
···
1365
1365
xs_sock_mark_closed(xprt);
1366
1366
}
1367
1367
out:
1368
-
read_unlock(&sk->sk_callback_lock);
1368
+
read_unlock_bh(&sk->sk_callback_lock);
1369
1369
}
1370
1370
1371
1371
/**
···
1376
1376
{
1377
1377
struct rpc_xprt *xprt;
1378
1378
1379
-
read_lock(&sk->sk_callback_lock);
1379
+
read_lock_bh(&sk->sk_callback_lock);
1380
1380
if (!(xprt = xprt_from_sock(sk)))
1381
1381
goto out;
1382
1382
dprintk("RPC: %s client %p...\n"
···
1384
1384
__func__, xprt, sk->sk_err);
1385
1385
xprt_wake_pending_tasks(xprt, -EAGAIN);
1386
1386
out:
1387
-
read_unlock(&sk->sk_callback_lock);
1387
+
read_unlock_bh(&sk->sk_callback_lock);
1388
1388
}
1389
1389
1390
1390
static void xs_write_space(struct sock *sk)
···
1416
1416
*/
1417
1417
static void xs_udp_write_space(struct sock *sk)
1418
1418
{
1419
-
read_lock(&sk->sk_callback_lock);
1419
+
read_lock_bh(&sk->sk_callback_lock);
1420
1420
1421
1421
/* from net/core/sock.c:sock_def_write_space */
1422
1422
if (sock_writeable(sk))
1423
1423
xs_write_space(sk);
1424
1424
1425
-
read_unlock(&sk->sk_callback_lock);
1425
+
read_unlock_bh(&sk->sk_callback_lock);
1426
1426
}
1427
1427
1428
1428
/**
···
1437
1437
*/
1438
1438
static void xs_tcp_write_space(struct sock *sk)
1439
1439
{
1440
-
read_lock(&sk->sk_callback_lock);
1440
+
read_lock_bh(&sk->sk_callback_lock);
1441
1441
1442
1442
/* from net/core/stream.c:sk_stream_write_space */
1443
1443
if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk))
1444
1444
xs_write_space(sk);
1445
1445
1446
-
read_unlock(&sk->sk_callback_lock);
1446
+
read_unlock_bh(&sk->sk_callback_lock);
1447
1447
}
1448
1448
1449
1449
static void xs_udp_do_set_buffer_size(struct rpc_xprt *xprt)
+1
-1
net/wireless/wext-priv.c
+1
-1
net/wireless/wext-priv.c
+2
-3
net/xfrm/xfrm_policy.c
+2
-3
net/xfrm/xfrm_policy.c
···
1175
1175
tmpl->mode == XFRM_MODE_BEET) {
1176
1176
remote = &tmpl->id.daddr;
1177
1177
local = &tmpl->saddr;
1178
-
family = tmpl->encap_family;
1179
-
if (xfrm_addr_any(local, family)) {
1180
-
error = xfrm_get_saddr(net, &tmp, remote, family);
1178
+
if (xfrm_addr_any(local, tmpl->encap_family)) {
1179
+
error = xfrm_get_saddr(net, &tmp, remote, tmpl->encap_family);
1181
1180
if (error)
1182
1181
goto fail;
1183
1182
local = &tmp;
+27
-18
net/xfrm/xfrm_state.c
+27
-18
net/xfrm/xfrm_state.c
···
656
656
EXPORT_SYMBOL(xfrm_sad_getinfo);
657
657
658
658
static int
659
-
xfrm_init_tempsel(struct xfrm_state *x, struct flowi *fl,
660
-
struct xfrm_tmpl *tmpl,
661
-
xfrm_address_t *daddr, xfrm_address_t *saddr,
662
-
unsigned short family)
659
+
xfrm_init_tempstate(struct xfrm_state *x, struct flowi *fl,
660
+
struct xfrm_tmpl *tmpl,
661
+
xfrm_address_t *daddr, xfrm_address_t *saddr,
662
+
unsigned short family)
663
663
{
664
664
struct xfrm_state_afinfo *afinfo = xfrm_state_get_afinfo(family);
665
665
if (!afinfo)
666
666
return -1;
667
-
afinfo->init_tempsel(x, fl, tmpl, daddr, saddr);
667
+
afinfo->init_tempsel(&x->sel, fl);
668
+
669
+
if (family != tmpl->encap_family) {
670
+
xfrm_state_put_afinfo(afinfo);
671
+
afinfo = xfrm_state_get_afinfo(tmpl->encap_family);
672
+
if (!afinfo)
673
+
return -1;
674
+
}
675
+
afinfo->init_temprop(x, tmpl, daddr, saddr);
668
676
xfrm_state_put_afinfo(afinfo);
669
677
return 0;
670
678
}
···
798
790
int error = 0;
799
791
struct xfrm_state *best = NULL;
800
792
u32 mark = pol->mark.v & pol->mark.m;
793
+
unsigned short encap_family = tmpl->encap_family;
801
794
802
795
to_put = NULL;
803
796
804
797
spin_lock_bh(&xfrm_state_lock);
805
-
h = xfrm_dst_hash(net, daddr, saddr, tmpl->reqid, family);
798
+
h = xfrm_dst_hash(net, daddr, saddr, tmpl->reqid, encap_family);
806
799
hlist_for_each_entry(x, entry, net->xfrm.state_bydst+h, bydst) {
807
-
if (x->props.family == family &&
800
+
if (x->props.family == encap_family &&
808
801
x->props.reqid == tmpl->reqid &&
809
802
(mark & x->mark.m) == x->mark.v &&
810
803
!(x->props.flags & XFRM_STATE_WILDRECV) &&
811
-
xfrm_state_addr_check(x, daddr, saddr, family) &&
804
+
xfrm_state_addr_check(x, daddr, saddr, encap_family) &&
812
805
tmpl->mode == x->props.mode &&
813
806
tmpl->id.proto == x->id.proto &&
814
807
(tmpl->id.spi == x->id.spi || !tmpl->id.spi))
815
-
xfrm_state_look_at(pol, x, fl, family, daddr, saddr,
808
+
xfrm_state_look_at(pol, x, fl, encap_family, daddr, saddr,
816
809
&best, &acquire_in_progress, &error);
817
810
}
818
811
if (best)
819
812
goto found;
820
813
821
-
h_wildcard = xfrm_dst_hash(net, daddr, &saddr_wildcard, tmpl->reqid, family);
814
+
h_wildcard = xfrm_dst_hash(net, daddr, &saddr_wildcard, tmpl->reqid, encap_family);
822
815
hlist_for_each_entry(x, entry, net->xfrm.state_bydst+h_wildcard, bydst) {
823
-
if (x->props.family == family &&
816
+
if (x->props.family == encap_family &&
824
817
x->props.reqid == tmpl->reqid &&
825
818
(mark & x->mark.m) == x->mark.v &&
826
819
!(x->props.flags & XFRM_STATE_WILDRECV) &&
827
-
xfrm_state_addr_check(x, daddr, saddr, family) &&
820
+
xfrm_state_addr_check(x, daddr, saddr, encap_family) &&
828
821
tmpl->mode == x->props.mode &&
829
822
tmpl->id.proto == x->id.proto &&
830
823
(tmpl->id.spi == x->id.spi || !tmpl->id.spi))
831
-
xfrm_state_look_at(pol, x, fl, family, daddr, saddr,
824
+
xfrm_state_look_at(pol, x, fl, encap_family, daddr, saddr,
832
825
&best, &acquire_in_progress, &error);
833
826
}
834
827
···
838
829
if (!x && !error && !acquire_in_progress) {
839
830
if (tmpl->id.spi &&
840
831
(x0 = __xfrm_state_lookup(net, mark, daddr, tmpl->id.spi,
841
-
tmpl->id.proto, family)) != NULL) {
832
+
tmpl->id.proto, encap_family)) != NULL) {
842
833
to_put = x0;
843
834
error = -EEXIST;
844
835
goto out;
···
848
839
error = -ENOMEM;
849
840
goto out;
850
841
}
851
-
/* Initialize temporary selector matching only
842
+
/* Initialize temporary state matching only
852
843
* to current session. */
853
-
xfrm_init_tempsel(x, fl, tmpl, daddr, saddr, family);
844
+
xfrm_init_tempstate(x, fl, tmpl, daddr, saddr, family);
854
845
memcpy(&x->mark, &pol->mark, sizeof(x->mark));
855
846
856
847
error = security_xfrm_state_alloc_acquire(x, pol->security, fl->secid);
···
865
856
x->km.state = XFRM_STATE_ACQ;
866
857
list_add(&x->km.all, &net->xfrm.state_all);
867
858
hlist_add_head(&x->bydst, net->xfrm.state_bydst+h);
868
-
h = xfrm_src_hash(net, daddr, saddr, family);
859
+
h = xfrm_src_hash(net, daddr, saddr, encap_family);
869
860
hlist_add_head(&x->bysrc, net->xfrm.state_bysrc+h);
870
861
if (x->id.spi) {
871
-
h = xfrm_spi_hash(net, &x->id.daddr, x->id.spi, x->id.proto, family);
862
+
h = xfrm_spi_hash(net, &x->id.daddr, x->id.spi, x->id.proto, encap_family);
872
863
hlist_add_head(&x->byspi, net->xfrm.state_byspi+h);
873
864
}
874
865
x->lft.hard_add_expires_seconds = net->xfrm.sysctl_acq_expires;