tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net

Pull networking fixes from David Miller:
"I'm hoping this is the very last batch of networking fixes for 3.13,
here goes nothing:

1) Fix crashes in VLAN's header_ops passthru.

2) Bridge multicast code needs to use BH spinlocks to prevent
deadlocks with timers. From Curt Brune.

3) ipv6 tunnels lack proper synchornization when updating percpu
statistics. From Li RongQing.

4) Fixes to bnx2x driver from Yaniv Rosner, Dmitry Kravkov and Michal
Kalderon.

5) Avoid undefined operator evaluation order in llc code, from Daniel
Borkmann.

6) Error paths in various GSO offload paths do not unwind properly,
in particular they must undo any modifications they have made to
the SKB. From Wei-Chun Chao.

7) Fix RX refill races during restore in virtio-net, from Jason Wang.

8) Fix SKB use after free in LLC code, from Daniel Borkmann.

9) Missing unlock and OOPS in netpoll code when VLAN tag handling
fails.

10) Fix vxlan device attachment wrt ipv6, from Fan Du.

11) Don't allow creating infiniband links to non-infiniband devices,
from Hangbin Liu.

12) Revert FEC phy reset active low change, it breaks things. From
Fabio Estevam.

13) Fix header pointer handling in 6lowpan header building code, from
Daniel Borkmann.

14) Fix RSS handling in be2net driver, from Vasundhara Volam.

15) Fix modem port indexing in HSO driver, from Dan Williams"

* http://git.kernel.org/pub/scm/linux/kernel/git/davem/net: (38 commits)
bridge: use spin_lock_bh() in br_multicast_set_hash_max
ipv6: don't install anycast address for /128 addresses on routers
hso: fix handling of modem port SERIAL_STATE notifications
isdn: Drop big endian cpp checks from telespci and hfc_pci drivers
be2net: fix max_evt_qs calculation for BE3 in SR-IOV config
be2net: increase the timeout value for loopback-test FW cmd
be2net: disable RSS when number of RXQs is reduced to 1 via set-channels
xen-netback: Include header for vmalloc
net: 6lowpan: fix lowpan_header_create non-compression memcpy call
fec: Revert "fec: Do not assume that PHY reset is active low"
bnx2x: fix VLAN configuration for VFs.
bnx2x: fix AFEX memory overflow
bnx2x: Clean before update RSS arrives
bnx2x: Correct number of MSI-X vectors for VFs
bnx2x: limit number of interrupt vectors for 57711
qlcnic: Fix bug in Tx completion path
infiniband: make sure the src net is infiniband when create new link
{vxlan, inet6} Mark vxlan_dev flags with VXLAN_F_IPV6 properly
cxgb4: allow large buffer size to have page size
netpoll: Fix missing TXQ unlock and and OOPS.
...

Linus Torvalds a707271a f0a679af

+486 -335
+2 -1
drivers/infiniband/ulp/ipoib/ipoib_netlink.c
··· 31 31 */ 32 32 33 33 #include <linux/netdevice.h> 34 + #include <linux/if_arp.h> /* For ARPHRD_xxx */ 34 35 #include <linux/module.h> 35 36 #include <net/rtnetlink.h> 36 37 #include "ipoib.h" ··· 104 103 return -EINVAL; 105 104 106 105 pdev = __dev_get_by_index(src_net, nla_get_u32(tb[IFLA_LINK])); 107 - if (!pdev) 106 + if (!pdev || pdev->type != ARPHRD_INFINIBAND) 108 107 return -ENODEV; 109 108 110 109 ppriv = netdev_priv(pdev);
-4
drivers/isdn/hisax/hfc_pci.c
··· 1643 1643 int i; 1644 1644 struct pci_dev *tmp_hfcpci = NULL; 1645 1645 1646 - #ifdef __BIG_ENDIAN 1647 - #error "not running on big endian machines now" 1648 - #endif 1649 - 1650 1646 strcpy(tmp, hfcpci_revision); 1651 1647 printk(KERN_INFO "HiSax: HFC-PCI driver Rev. %s\n", HiSax_getrev(tmp)); 1652 1648
-4
drivers/isdn/hisax/telespci.c
··· 290 290 struct IsdnCardState *cs = card->cs; 291 291 char tmp[64]; 292 292 293 - #ifdef __BIG_ENDIAN 294 - #error "not running on big endian machines now" 295 - #endif 296 - 297 293 strcpy(tmp, telespci_revision); 298 294 printk(KERN_INFO "HiSax: Teles/PCI driver Rev. %s\n", HiSax_getrev(tmp)); 299 295 if (cs->typ != ISDN_CTYPE_TELESPCI)
+6 -1
drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
··· 1250 1250 * Therefore, if they would have been defined in the same union, 1251 1251 * data can get corrupted. 1252 1252 */ 1253 - struct afex_vif_list_ramrod_data func_afex_rdata; 1253 + union { 1254 + struct afex_vif_list_ramrod_data viflist_data; 1255 + struct function_update_data func_update; 1256 + } func_afex_rdata; 1254 1257 1255 1258 /* used by dmae command executer */ 1256 1259 struct dmae_command dmae[MAX_DMAE_C]; ··· 2501 2498 2502 2499 #define MCPR_SCRATCH_BASE(bp) \ 2503 2500 (CHIP_IS_E1x(bp) ? MCP_REG_MCPR_SCRATCH : MCP_A_REG_MCPR_SCRATCH) 2501 + 2502 + #define E1H_MAX_MF_SB_COUNT (HC_SB_MAX_SB_E1X/(E1HVN_MAX * PORT_MAX)) 2504 2503 2505 2504 #endif /* bnx2x.h */
+58 -36
drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.c
··· 3865 3865 3866 3866 bnx2x_warpcore_enable_AN_KR2(phy, params, vars); 3867 3867 } else { 3868 + /* Enable Auto-Detect to support 1G over CL37 as well */ 3869 + bnx2x_cl45_write(bp, phy, MDIO_WC_DEVAD, 3870 + MDIO_WC_REG_SERDESDIGITAL_CONTROL1000X1, 0x10); 3871 + 3872 + /* Force cl48 sync_status LOW to avoid getting stuck in CL73 3873 + * parallel-detect loop when CL73 and CL37 are enabled. 3874 + */ 3875 + CL22_WR_OVER_CL45(bp, phy, MDIO_REG_BANK_AER_BLOCK, 3876 + MDIO_AER_BLOCK_AER_REG, 0); 3877 + bnx2x_cl45_write(bp, phy, MDIO_WC_DEVAD, 3878 + MDIO_WC_REG_RXB_ANA_RX_CONTROL_PCI, 0x0800); 3879 + bnx2x_set_aer_mmd(params, phy); 3880 + 3868 3881 bnx2x_disable_kr2(params, vars, phy); 3869 3882 } 3870 3883 ··· 8133 8120 *edc_mode = EDC_MODE_ACTIVE_DAC; 8134 8121 else 8135 8122 check_limiting_mode = 1; 8136 - } else if (copper_module_type & 8137 - SFP_EEPROM_FC_TX_TECH_BITMASK_COPPER_PASSIVE) { 8123 + } else { 8124 + *edc_mode = EDC_MODE_PASSIVE_DAC; 8125 + /* Even in case PASSIVE_DAC indication is not set, 8126 + * treat it as a passive DAC cable, since some cables 8127 + * don't have this indication. 8128 + */ 8129 + if (copper_module_type & 8130 + SFP_EEPROM_FC_TX_TECH_BITMASK_COPPER_PASSIVE) { 8138 8131 DP(NETIF_MSG_LINK, 8139 8132 "Passive Copper cable detected\n"); 8140 - *edc_mode = 8141 - EDC_MODE_PASSIVE_DAC; 8142 - } else { 8143 - DP(NETIF_MSG_LINK, 8144 - "Unknown copper-cable-type 0x%x !!!\n", 8145 - copper_module_type); 8146 - return -EINVAL; 8133 + } else { 8134 + DP(NETIF_MSG_LINK, 8135 + "Unknown copper-cable-type\n"); 8136 + } 8147 8137 } 8148 8138 break; 8149 8139 } ··· 10841 10825 (1<<11)); 10842 10826 10843 10827 if (((phy->req_line_speed == SPEED_AUTO_NEG) && 10844 - (phy->speed_cap_mask & 10845 - PORT_HW_CFG_SPEED_CAPABILITY_D0_1G)) || 10846 - (phy->req_line_speed == SPEED_1000)) { 10828 + (phy->speed_cap_mask & 10829 + PORT_HW_CFG_SPEED_CAPABILITY_D0_1G)) || 10830 + (phy->req_line_speed == SPEED_1000)) { 10847 10831 an_1000_val |= (1<<8); 10848 10832 autoneg_val |= (1<<9 | 1<<12); 10849 10833 if (phy->req_duplex == DUPLEX_FULL) ··· 10859 10843 0x09, 10860 10844 &an_1000_val); 10861 10845 10862 - /* Set 100 speed advertisement */ 10863 - if (((phy->req_line_speed == SPEED_AUTO_NEG) && 10864 - (phy->speed_cap_mask & 10865 - (PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_FULL | 10866 - PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_HALF)))) { 10867 - an_10_100_val |= (1<<7); 10868 - /* Enable autoneg and restart autoneg for legacy speeds */ 10869 - autoneg_val |= (1<<9 | 1<<12); 10870 - 10871 - if (phy->req_duplex == DUPLEX_FULL) 10872 - an_10_100_val |= (1<<8); 10873 - DP(NETIF_MSG_LINK, "Advertising 100M\n"); 10874 - } 10875 - 10876 - /* Set 10 speed advertisement */ 10877 - if (((phy->req_line_speed == SPEED_AUTO_NEG) && 10878 - (phy->speed_cap_mask & 10879 - (PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_FULL | 10880 - PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_HALF)))) { 10881 - an_10_100_val |= (1<<5); 10882 - autoneg_val |= (1<<9 | 1<<12); 10883 - if (phy->req_duplex == DUPLEX_FULL) 10846 + /* Advertise 10/100 link speed */ 10847 + if (phy->req_line_speed == SPEED_AUTO_NEG) { 10848 + if (phy->speed_cap_mask & 10849 + PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_HALF) { 10850 + an_10_100_val |= (1<<5); 10851 + autoneg_val |= (1<<9 | 1<<12); 10852 + DP(NETIF_MSG_LINK, "Advertising 10M-HD\n"); 10853 + } 10854 + if (phy->speed_cap_mask & 10855 + PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_FULL) { 10884 10856 an_10_100_val |= (1<<6); 10885 - DP(NETIF_MSG_LINK, "Advertising 10M\n"); 10857 + autoneg_val |= (1<<9 | 1<<12); 10858 + DP(NETIF_MSG_LINK, "Advertising 10M-FD\n"); 10859 + } 10860 + if (phy->speed_cap_mask & 10861 + PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_HALF) { 10862 + an_10_100_val |= (1<<7); 10863 + autoneg_val |= (1<<9 | 1<<12); 10864 + DP(NETIF_MSG_LINK, "Advertising 100M-HD\n"); 10865 + } 10866 + if (phy->speed_cap_mask & 10867 + PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_FULL) { 10868 + an_10_100_val |= (1<<8); 10869 + autoneg_val |= (1<<9 | 1<<12); 10870 + DP(NETIF_MSG_LINK, "Advertising 100M-FD\n"); 10871 + } 10886 10872 } 10887 10873 10888 10874 /* Only 10/100 are allowed to work in FORCE mode */ ··· 13360 13342 DP(NETIF_MSG_LINK, "Link changed:[%x %x]->%x\n", vars->link_up, 13361 13343 old_status, status); 13362 13344 13345 + /* Do not touch the link in case physical link down */ 13346 + if ((vars->phy_flags & PHY_PHYSICAL_LINK_FLAG) == 0) 13347 + return 1; 13348 + 13363 13349 /* a. Update shmem->link_status accordingly 13364 13350 * b. Update link_vars->link_up 13365 13351 */ ··· 13572 13550 */ 13573 13551 not_kr2_device = (((base_page & 0x8000) == 0) || 13574 13552 (((base_page & 0x8000) && 13575 - ((next_page & 0xe0) == 0x2)))); 13553 + ((next_page & 0xe0) == 0x20)))); 13576 13554 13577 13555 /* In case KR2 is already disabled, check if we need to re-enable it */ 13578 13556 if (!(vars->link_attr_sync & LINK_ATTR_SYNC_KR2_ENABLE)) {
+3 -3
drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
··· 11447 11447 } 11448 11448 } 11449 11449 11450 - /* adjust igu_sb_cnt to MF for E1x */ 11451 - if (CHIP_IS_E1x(bp) && IS_MF(bp)) 11452 - bp->igu_sb_cnt /= E1HVN_MAX; 11450 + /* adjust igu_sb_cnt to MF for E1H */ 11451 + if (CHIP_IS_E1H(bp) && IS_MF(bp)) 11452 + bp->igu_sb_cnt = min_t(u8, bp->igu_sb_cnt, E1H_MAX_MF_SB_COUNT); 11453 11453 11454 11454 /* port info */ 11455 11455 bnx2x_get_port_hwinfo(bp);
+1
drivers/net/ethernet/broadcom/bnx2x/bnx2x_reg.h
··· 7179 7179 #define MDIO_WC_REG_RX1_PCI_CTRL 0x80ca 7180 7180 #define MDIO_WC_REG_RX2_PCI_CTRL 0x80da 7181 7181 #define MDIO_WC_REG_RX3_PCI_CTRL 0x80ea 7182 + #define MDIO_WC_REG_RXB_ANA_RX_CONTROL_PCI 0x80fa 7182 7183 #define MDIO_WC_REG_XGXSBLK2_UNICORE_MODE_10G 0x8104 7183 7184 #define MDIO_WC_REG_XGXS_STATUS3 0x8129 7184 7185 #define MDIO_WC_REG_PAR_DET_10G_STATUS 0x8130
+11 -4
drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.c
··· 2038 2038 struct bnx2x_vlan_mac_ramrod_params p; 2039 2039 struct bnx2x_exe_queue_obj *exeq = &o->exe_queue; 2040 2040 struct bnx2x_exeq_elem *exeq_pos, *exeq_pos_n; 2041 + unsigned long flags; 2041 2042 int read_lock; 2042 2043 int rc = 0; 2043 2044 ··· 2047 2046 spin_lock_bh(&exeq->lock); 2048 2047 2049 2048 list_for_each_entry_safe(exeq_pos, exeq_pos_n, &exeq->exe_queue, link) { 2050 - if (exeq_pos->cmd_data.vlan_mac.vlan_mac_flags == 2051 - *vlan_mac_flags) { 2049 + flags = exeq_pos->cmd_data.vlan_mac.vlan_mac_flags; 2050 + if (BNX2X_VLAN_MAC_CMP_FLAGS(flags) == 2051 + BNX2X_VLAN_MAC_CMP_FLAGS(*vlan_mac_flags)) { 2052 2052 rc = exeq->remove(bp, exeq->owner, exeq_pos); 2053 2053 if (rc) { 2054 2054 BNX2X_ERR("Failed to remove command\n"); ··· 2082 2080 return read_lock; 2083 2081 2084 2082 list_for_each_entry(pos, &o->head, link) { 2085 - if (pos->vlan_mac_flags == *vlan_mac_flags) { 2083 + flags = pos->vlan_mac_flags; 2084 + if (BNX2X_VLAN_MAC_CMP_FLAGS(flags) == 2085 + BNX2X_VLAN_MAC_CMP_FLAGS(*vlan_mac_flags)) { 2086 2086 p.user_req.vlan_mac_flags = pos->vlan_mac_flags; 2087 2087 memcpy(&p.user_req.u, &pos->u, sizeof(pos->u)); 2088 2088 rc = bnx2x_config_vlan_mac(bp, &p); ··· 4386 4382 struct bnx2x_raw_obj *r = &o->raw; 4387 4383 4388 4384 /* Do nothing if only driver cleanup was requested */ 4389 - if (test_bit(RAMROD_DRV_CLR_ONLY, &p->ramrod_flags)) 4385 + if (test_bit(RAMROD_DRV_CLR_ONLY, &p->ramrod_flags)) { 4386 + DP(BNX2X_MSG_SP, "Not configuring RSS ramrod_flags=%lx\n", 4387 + p->ramrod_flags); 4390 4388 return 0; 4389 + } 4391 4390 4392 4391 r->set_pending(r); 4393 4392
+7
drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.h
··· 266 266 BNX2X_DONT_CONSUME_CAM_CREDIT, 267 267 BNX2X_DONT_CONSUME_CAM_CREDIT_DEST, 268 268 }; 269 + /* When looking for matching filters, some flags are not interesting */ 270 + #define BNX2X_VLAN_MAC_CMP_MASK (1 << BNX2X_UC_LIST_MAC | \ 271 + 1 << BNX2X_ETH_MAC | \ 272 + 1 << BNX2X_ISCSI_ETH_MAC | \ 273 + 1 << BNX2X_NETQ_ETH_MAC) 274 + #define BNX2X_VLAN_MAC_CMP_FLAGS(flags) \ 275 + ((flags) & BNX2X_VLAN_MAC_CMP_MASK) 269 276 270 277 struct bnx2x_vlan_mac_ramrod_params { 271 278 /* Object to run the command from */
+152 -118
drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c
··· 1209 1209 /* next state */ 1210 1210 vfop->state = BNX2X_VFOP_RXMODE_DONE; 1211 1211 1212 + /* record the accept flags in vfdb so hypervisor can modify them 1213 + * if necessary 1214 + */ 1215 + bnx2x_vfq(vf, ramrod->cl_id - vf->igu_base_id, accept_flags) = 1216 + ramrod->rx_accept_flags; 1212 1217 vfop->rc = bnx2x_config_rx_mode(bp, ramrod); 1213 1218 bnx2x_vfop_finalize(vf, vfop->rc, VFOP_DONE); 1214 1219 op_err: ··· 1229 1224 return; 1230 1225 } 1231 1226 1227 + static void bnx2x_vf_prep_rx_mode(struct bnx2x *bp, u8 qid, 1228 + struct bnx2x_rx_mode_ramrod_params *ramrod, 1229 + struct bnx2x_virtf *vf, 1230 + unsigned long accept_flags) 1231 + { 1232 + struct bnx2x_vf_queue *vfq = vfq_get(vf, qid); 1233 + 1234 + memset(ramrod, 0, sizeof(*ramrod)); 1235 + ramrod->cid = vfq->cid; 1236 + ramrod->cl_id = vfq_cl_id(vf, vfq); 1237 + ramrod->rx_mode_obj = &bp->rx_mode_obj; 1238 + ramrod->func_id = FW_VF_HANDLE(vf->abs_vfid); 1239 + ramrod->rx_accept_flags = accept_flags; 1240 + ramrod->tx_accept_flags = accept_flags; 1241 + ramrod->pstate = &vf->filter_state; 1242 + ramrod->state = BNX2X_FILTER_RX_MODE_PENDING; 1243 + 1244 + set_bit(BNX2X_FILTER_RX_MODE_PENDING, &vf->filter_state); 1245 + set_bit(RAMROD_RX, &ramrod->ramrod_flags); 1246 + set_bit(RAMROD_TX, &ramrod->ramrod_flags); 1247 + 1248 + ramrod->rdata = bnx2x_vf_sp(bp, vf, rx_mode_rdata.e2); 1249 + ramrod->rdata_mapping = bnx2x_vf_sp_map(bp, vf, rx_mode_rdata.e2); 1250 + } 1251 + 1232 1252 int bnx2x_vfop_rxmode_cmd(struct bnx2x *bp, 1233 1253 struct bnx2x_virtf *vf, 1234 1254 struct bnx2x_vfop_cmd *cmd, 1235 1255 int qid, unsigned long accept_flags) 1236 1256 { 1237 - struct bnx2x_vf_queue *vfq = vfq_get(vf, qid); 1238 1257 struct bnx2x_vfop *vfop = bnx2x_vfop_add(bp, vf); 1239 1258 1240 1259 if (vfop) { 1241 1260 struct bnx2x_rx_mode_ramrod_params *ramrod = 1242 1261 &vf->op_params.rx_mode; 1243 1262 1244 - memset(ramrod, 0, sizeof(*ramrod)); 1245 - 1246 - /* Prepare ramrod parameters */ 1247 - ramrod->cid = vfq->cid; 1248 - ramrod->cl_id = vfq_cl_id(vf, vfq); 1249 - ramrod->rx_mode_obj = &bp->rx_mode_obj; 1250 - ramrod->func_id = FW_VF_HANDLE(vf->abs_vfid); 1251 - 1252 - ramrod->rx_accept_flags = accept_flags; 1253 - ramrod->tx_accept_flags = accept_flags; 1254 - ramrod->pstate = &vf->filter_state; 1255 - ramrod->state = BNX2X_FILTER_RX_MODE_PENDING; 1256 - 1257 - set_bit(BNX2X_FILTER_RX_MODE_PENDING, &vf->filter_state); 1258 - set_bit(RAMROD_RX, &ramrod->ramrod_flags); 1259 - set_bit(RAMROD_TX, &ramrod->ramrod_flags); 1260 - 1261 - ramrod->rdata = 1262 - bnx2x_vf_sp(bp, vf, rx_mode_rdata.e2); 1263 - ramrod->rdata_mapping = 1264 - bnx2x_vf_sp_map(bp, vf, rx_mode_rdata.e2); 1263 + bnx2x_vf_prep_rx_mode(bp, qid, ramrod, vf, accept_flags); 1265 1264 1266 1265 bnx2x_vfop_opset(BNX2X_VFOP_RXMODE_CONFIG, 1267 1266 bnx2x_vfop_rxmode, cmd->done); ··· 3211 3202 bnx2x_iov_static_resc(bp, vf); 3212 3203 } 3213 3204 3214 - /* prepare msix vectors in VF configuration space */ 3205 + /* prepare msix vectors in VF configuration space - the value in the 3206 + * PCI configuration space should be the index of the last entry, 3207 + * namely one less than the actual size of the table 3208 + */ 3215 3209 for (vf_idx = first_vf; vf_idx < first_vf + req_vfs; vf_idx++) { 3216 3210 bnx2x_pretend_func(bp, HW_VF_HANDLE(bp, vf_idx)); 3217 3211 REG_WR(bp, PCICFG_OFFSET + GRC_CONFIG_REG_VF_MSIX_CONTROL, 3218 - num_vf_queues); 3212 + num_vf_queues - 1); 3219 3213 DP(BNX2X_MSG_IOV, "set msix vec num in VF %d cfg space to %d\n", 3220 - vf_idx, num_vf_queues); 3214 + vf_idx, num_vf_queues - 1); 3221 3215 } 3222 3216 bnx2x_pretend_func(bp, BP_ABS_FUNC(bp)); 3223 3217 ··· 3448 3436 3449 3437 int bnx2x_set_vf_vlan(struct net_device *dev, int vfidx, u16 vlan, u8 qos) 3450 3438 { 3451 - struct bnx2x *bp = netdev_priv(dev); 3452 - int rc, q_logical_state; 3453 - struct bnx2x_virtf *vf = NULL; 3439 + struct bnx2x_queue_state_params q_params = {NULL}; 3440 + struct bnx2x_vlan_mac_ramrod_params ramrod_param; 3441 + struct bnx2x_queue_update_params *update_params; 3454 3442 struct pf_vf_bulletin_content *bulletin = NULL; 3443 + struct bnx2x_rx_mode_ramrod_params rx_ramrod; 3444 + struct bnx2x *bp = netdev_priv(dev); 3445 + struct bnx2x_vlan_mac_obj *vlan_obj; 3446 + unsigned long vlan_mac_flags = 0; 3447 + unsigned long ramrod_flags = 0; 3448 + struct bnx2x_virtf *vf = NULL; 3449 + unsigned long accept_flags; 3450 + int rc; 3455 3451 3456 3452 /* sanity and init */ 3457 3453 rc = bnx2x_vf_ndo_prep(bp, vfidx, &vf, &bulletin); ··· 3477 3457 /* update PF's copy of the VF's bulletin. No point in posting the vlan 3478 3458 * to the VF since it doesn't have anything to do with it. But it useful 3479 3459 * to store it here in case the VF is not up yet and we can only 3480 - * configure the vlan later when it does. 3460 + * configure the vlan later when it does. Treat vlan id 0 as remove the 3461 + * Host tag. 3481 3462 */ 3482 - bulletin->valid_bitmap |= 1 << VLAN_VALID; 3463 + if (vlan > 0) 3464 + bulletin->valid_bitmap |= 1 << VLAN_VALID; 3465 + else 3466 + bulletin->valid_bitmap &= ~(1 << VLAN_VALID); 3483 3467 bulletin->vlan = vlan; 3484 3468 3485 3469 /* is vf initialized and queue set up? */ 3486 - q_logical_state = 3487 - bnx2x_get_q_logical_state(bp, &bnx2x_leading_vfq(vf, sp_obj)); 3488 - if (vf->state == VF_ENABLED && 3489 - q_logical_state == BNX2X_Q_LOGICAL_STATE_ACTIVE) { 3490 - /* configure the vlan in device on this vf's queue */ 3491 - unsigned long ramrod_flags = 0; 3492 - unsigned long vlan_mac_flags = 0; 3493 - struct bnx2x_vlan_mac_obj *vlan_obj = 3494 - &bnx2x_leading_vfq(vf, vlan_obj); 3495 - struct bnx2x_vlan_mac_ramrod_params ramrod_param; 3496 - struct bnx2x_queue_state_params q_params = {NULL}; 3497 - struct bnx2x_queue_update_params *update_params; 3470 + if (vf->state != VF_ENABLED || 3471 + bnx2x_get_q_logical_state(bp, &bnx2x_leading_vfq(vf, sp_obj)) != 3472 + BNX2X_Q_LOGICAL_STATE_ACTIVE) 3473 + return rc; 3498 3474 3499 - rc = validate_vlan_mac(bp, &bnx2x_leading_vfq(vf, mac_obj)); 3500 - if (rc) 3501 - return rc; 3502 - memset(&ramrod_param, 0, sizeof(ramrod_param)); 3475 + /* configure the vlan in device on this vf's queue */ 3476 + vlan_obj = &bnx2x_leading_vfq(vf, vlan_obj); 3477 + rc = validate_vlan_mac(bp, &bnx2x_leading_vfq(vf, mac_obj)); 3478 + if (rc) 3479 + return rc; 3503 3480 3504 - /* must lock vfpf channel to protect against vf flows */ 3505 - bnx2x_lock_vf_pf_channel(bp, vf, CHANNEL_TLV_PF_SET_VLAN); 3481 + /* must lock vfpf channel to protect against vf flows */ 3482 + bnx2x_lock_vf_pf_channel(bp, vf, CHANNEL_TLV_PF_SET_VLAN); 3506 3483 3507 - /* remove existing vlans */ 3508 - __set_bit(RAMROD_COMP_WAIT, &ramrod_flags); 3509 - rc = vlan_obj->delete_all(bp, vlan_obj, &vlan_mac_flags, 3510 - &ramrod_flags); 3511 - if (rc) { 3512 - BNX2X_ERR("failed to delete vlans\n"); 3513 - rc = -EINVAL; 3514 - goto out; 3515 - } 3516 - 3517 - /* send queue update ramrod to configure default vlan and silent 3518 - * vlan removal 3519 - */ 3520 - __set_bit(RAMROD_COMP_WAIT, &q_params.ramrod_flags); 3521 - q_params.cmd = BNX2X_Q_CMD_UPDATE; 3522 - q_params.q_obj = &bnx2x_leading_vfq(vf, sp_obj); 3523 - update_params = &q_params.params.update; 3524 - __set_bit(BNX2X_Q_UPDATE_DEF_VLAN_EN_CHNG, 3525 - &update_params->update_flags); 3526 - __set_bit(BNX2X_Q_UPDATE_SILENT_VLAN_REM_CHNG, 3527 - &update_params->update_flags); 3528 - 3529 - if (vlan == 0) { 3530 - /* if vlan is 0 then we want to leave the VF traffic 3531 - * untagged, and leave the incoming traffic untouched 3532 - * (i.e. do not remove any vlan tags). 3533 - */ 3534 - __clear_bit(BNX2X_Q_UPDATE_DEF_VLAN_EN, 3535 - &update_params->update_flags); 3536 - __clear_bit(BNX2X_Q_UPDATE_SILENT_VLAN_REM, 3537 - &update_params->update_flags); 3538 - } else { 3539 - /* configure the new vlan to device */ 3540 - __set_bit(RAMROD_COMP_WAIT, &ramrod_flags); 3541 - ramrod_param.vlan_mac_obj = vlan_obj; 3542 - ramrod_param.ramrod_flags = ramrod_flags; 3543 - ramrod_param.user_req.u.vlan.vlan = vlan; 3544 - ramrod_param.user_req.cmd = BNX2X_VLAN_MAC_ADD; 3545 - rc = bnx2x_config_vlan_mac(bp, &ramrod_param); 3546 - if (rc) { 3547 - BNX2X_ERR("failed to configure vlan\n"); 3548 - rc = -EINVAL; 3549 - goto out; 3550 - } 3551 - 3552 - /* configure default vlan to vf queue and set silent 3553 - * vlan removal (the vf remains unaware of this vlan). 3554 - */ 3555 - update_params = &q_params.params.update; 3556 - __set_bit(BNX2X_Q_UPDATE_DEF_VLAN_EN, 3557 - &update_params->update_flags); 3558 - __set_bit(BNX2X_Q_UPDATE_SILENT_VLAN_REM, 3559 - &update_params->update_flags); 3560 - update_params->def_vlan = vlan; 3561 - } 3562 - 3563 - /* Update the Queue state */ 3564 - rc = bnx2x_queue_state_change(bp, &q_params); 3565 - if (rc) { 3566 - BNX2X_ERR("Failed to configure default VLAN\n"); 3567 - goto out; 3568 - } 3569 - 3570 - /* clear the flag indicating that this VF needs its vlan 3571 - * (will only be set if the HV configured the Vlan before vf was 3572 - * up and we were called because the VF came up later 3573 - */ 3574 - out: 3575 - vf->cfg_flags &= ~VF_CFG_VLAN; 3576 - bnx2x_unlock_vf_pf_channel(bp, vf, CHANNEL_TLV_PF_SET_VLAN); 3484 + /* remove existing vlans */ 3485 + __set_bit(RAMROD_COMP_WAIT, &ramrod_flags); 3486 + rc = vlan_obj->delete_all(bp, vlan_obj, &vlan_mac_flags, 3487 + &ramrod_flags); 3488 + if (rc) { 3489 + BNX2X_ERR("failed to delete vlans\n"); 3490 + rc = -EINVAL; 3491 + goto out; 3577 3492 } 3493 + 3494 + /* need to remove/add the VF's accept_any_vlan bit */ 3495 + accept_flags = bnx2x_leading_vfq(vf, accept_flags); 3496 + if (vlan) 3497 + clear_bit(BNX2X_ACCEPT_ANY_VLAN, &accept_flags); 3498 + else 3499 + set_bit(BNX2X_ACCEPT_ANY_VLAN, &accept_flags); 3500 + 3501 + bnx2x_vf_prep_rx_mode(bp, LEADING_IDX, &rx_ramrod, vf, 3502 + accept_flags); 3503 + bnx2x_leading_vfq(vf, accept_flags) = accept_flags; 3504 + bnx2x_config_rx_mode(bp, &rx_ramrod); 3505 + 3506 + /* configure the new vlan to device */ 3507 + memset(&ramrod_param, 0, sizeof(ramrod_param)); 3508 + __set_bit(RAMROD_COMP_WAIT, &ramrod_flags); 3509 + ramrod_param.vlan_mac_obj = vlan_obj; 3510 + ramrod_param.ramrod_flags = ramrod_flags; 3511 + set_bit(BNX2X_DONT_CONSUME_CAM_CREDIT, 3512 + &ramrod_param.user_req.vlan_mac_flags); 3513 + ramrod_param.user_req.u.vlan.vlan = vlan; 3514 + ramrod_param.user_req.cmd = BNX2X_VLAN_MAC_ADD; 3515 + rc = bnx2x_config_vlan_mac(bp, &ramrod_param); 3516 + if (rc) { 3517 + BNX2X_ERR("failed to configure vlan\n"); 3518 + rc = -EINVAL; 3519 + goto out; 3520 + } 3521 + 3522 + /* send queue update ramrod to configure default vlan and silent 3523 + * vlan removal 3524 + */ 3525 + __set_bit(RAMROD_COMP_WAIT, &q_params.ramrod_flags); 3526 + q_params.cmd = BNX2X_Q_CMD_UPDATE; 3527 + q_params.q_obj = &bnx2x_leading_vfq(vf, sp_obj); 3528 + update_params = &q_params.params.update; 3529 + __set_bit(BNX2X_Q_UPDATE_DEF_VLAN_EN_CHNG, 3530 + &update_params->update_flags); 3531 + __set_bit(BNX2X_Q_UPDATE_SILENT_VLAN_REM_CHNG, 3532 + &update_params->update_flags); 3533 + if (vlan == 0) { 3534 + /* if vlan is 0 then we want to leave the VF traffic 3535 + * untagged, and leave the incoming traffic untouched 3536 + * (i.e. do not remove any vlan tags). 3537 + */ 3538 + __clear_bit(BNX2X_Q_UPDATE_DEF_VLAN_EN, 3539 + &update_params->update_flags); 3540 + __clear_bit(BNX2X_Q_UPDATE_SILENT_VLAN_REM, 3541 + &update_params->update_flags); 3542 + } else { 3543 + /* configure default vlan to vf queue and set silent 3544 + * vlan removal (the vf remains unaware of this vlan). 3545 + */ 3546 + __set_bit(BNX2X_Q_UPDATE_DEF_VLAN_EN, 3547 + &update_params->update_flags); 3548 + __set_bit(BNX2X_Q_UPDATE_SILENT_VLAN_REM, 3549 + &update_params->update_flags); 3550 + update_params->def_vlan = vlan; 3551 + update_params->silent_removal_value = 3552 + vlan & VLAN_VID_MASK; 3553 + update_params->silent_removal_mask = VLAN_VID_MASK; 3554 + } 3555 + 3556 + /* Update the Queue state */ 3557 + rc = bnx2x_queue_state_change(bp, &q_params); 3558 + if (rc) { 3559 + BNX2X_ERR("Failed to configure default VLAN\n"); 3560 + goto out; 3561 + } 3562 + 3563 + 3564 + /* clear the flag indicating that this VF needs its vlan 3565 + * (will only be set if the HV configured the Vlan before vf was 3566 + * up and we were called because the VF came up later 3567 + */ 3568 + out: 3569 + vf->cfg_flags &= ~VF_CFG_VLAN; 3570 + bnx2x_unlock_vf_pf_channel(bp, vf, CHANNEL_TLV_PF_SET_VLAN); 3571 + 3578 3572 return rc; 3579 3573 } 3580 3574
+1
drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.h
··· 74 74 /* VLANs object */ 75 75 struct bnx2x_vlan_mac_obj vlan_obj; 76 76 atomic_t vlan_count; /* 0 means vlan-0 is set ~ untagged */ 77 + unsigned long accept_flags; /* last accept flags configured */ 77 78 78 79 /* Queue Slow-path State object */ 79 80 struct bnx2x_queue_sp_obj sp_obj;
+24 -2
drivers/net/ethernet/broadcom/bnx2x/bnx2x_vfpf.c
··· 1598 1598 1599 1599 if (msg->flags & VFPF_SET_Q_FILTERS_RX_MASK_CHANGED) { 1600 1600 unsigned long accept = 0; 1601 + struct pf_vf_bulletin_content *bulletin = 1602 + BP_VF_BULLETIN(bp, vf->index); 1601 1603 1602 1604 /* covert VF-PF if mask to bnx2x accept flags */ 1603 1605 if (msg->rx_mask & VFPF_RX_MASK_ACCEPT_MATCHED_UNICAST) ··· 1619 1617 __set_bit(BNX2X_ACCEPT_BROADCAST, &accept); 1620 1618 1621 1619 /* A packet arriving the vf's mac should be accepted 1622 - * with any vlan 1620 + * with any vlan, unless a vlan has already been 1621 + * configured. 1623 1622 */ 1624 - __set_bit(BNX2X_ACCEPT_ANY_VLAN, &accept); 1623 + if (!(bulletin->valid_bitmap & (1 << VLAN_VALID))) 1624 + __set_bit(BNX2X_ACCEPT_ANY_VLAN, &accept); 1625 1625 1626 1626 /* set rx-mode */ 1627 1627 rc = bnx2x_vfop_rxmode_cmd(bp, vf, &cmd, ··· 1712 1708 1713 1709 vf->op_rc = -EPERM; 1714 1710 goto response; 1711 + } 1712 + } 1713 + /* if vlan was set by hypervisor we don't allow guest to config vlan */ 1714 + if (bulletin->valid_bitmap & 1 << VLAN_VALID) { 1715 + int i; 1716 + 1717 + /* search for vlan filters */ 1718 + for (i = 0; i < filters->n_mac_vlan_filters; i++) { 1719 + if (filters->filters[i].flags & 1720 + VFPF_Q_FILTER_VLAN_TAG_VALID) { 1721 + BNX2X_ERR("VF[%d] attempted to configure vlan but one was already set by Hypervisor. Aborting request\n", 1722 + vf->abs_vfid); 1723 + vf->op_rc = -EPERM; 1724 + goto response; 1725 + } 1715 1726 } 1716 1727 } 1717 1728 ··· 1824 1805 vf_op_params->rss_result_mask = rss_tlv->rss_result_mask; 1825 1806 1826 1807 /* flags handled individually for backward/forward compatability */ 1808 + vf_op_params->rss_flags = 0; 1809 + vf_op_params->ramrod_flags = 0; 1810 + 1827 1811 if (rss_tlv->rss_flags & VFPF_RSS_MODE_DISABLED) 1828 1812 __set_bit(BNX2X_RSS_MODE_DISABLED, &vf_op_params->rss_flags); 1829 1813 if (rss_tlv->rss_flags & VFPF_RSS_MODE_REGULAR)
+1 -1
drivers/net/ethernet/chelsio/cxgb4/sge.c
··· 2581 2581 #undef READ_FL_BUF 2582 2582 2583 2583 if (fl_small_pg != PAGE_SIZE || 2584 - (fl_large_pg != 0 && (fl_large_pg <= fl_small_pg || 2584 + (fl_large_pg != 0 && (fl_large_pg < fl_small_pg || 2585 2585 (fl_large_pg & (fl_large_pg-1)) != 0))) { 2586 2586 dev_err(adap->pdev_dev, "bad SGE FL page buffer sizes [%d, %d]\n", 2587 2587 fl_small_pg, fl_large_pg);
+2 -1
drivers/net/ethernet/emulex/benet/be.h
··· 104 104 #define BE3_MAX_RSS_QS 16 105 105 #define BE3_MAX_TX_QS 16 106 106 #define BE3_MAX_EVT_QS 16 107 + #define BE3_SRIOV_MAX_EVT_QS 8 107 108 108 109 #define MAX_RX_QS 32 109 110 #define MAX_EVT_QS 32 ··· 481 480 struct list_head entry; 482 481 483 482 u32 flash_status; 484 - struct completion flash_compl; 483 + struct completion et_cmd_compl; 485 484 486 485 struct be_resources res; /* resources available for the func */ 487 486 u16 num_vfs; /* Number of VFs provisioned by PF */
+23 -10
drivers/net/ethernet/emulex/benet/be_cmds.c
··· 141 141 subsystem = resp_hdr->subsystem; 142 142 } 143 143 144 + if (opcode == OPCODE_LOWLEVEL_LOOPBACK_TEST && 145 + subsystem == CMD_SUBSYSTEM_LOWLEVEL) { 146 + complete(&adapter->et_cmd_compl); 147 + return 0; 148 + } 149 + 144 150 if (((opcode == OPCODE_COMMON_WRITE_FLASHROM) || 145 151 (opcode == OPCODE_COMMON_WRITE_OBJECT)) && 146 152 (subsystem == CMD_SUBSYSTEM_COMMON)) { 147 153 adapter->flash_status = compl_status; 148 - complete(&adapter->flash_compl); 154 + complete(&adapter->et_cmd_compl); 149 155 } 150 156 151 157 if (compl_status == MCC_STATUS_SUCCESS) { ··· 2023 2017 0x3ea83c02, 0x4a110304}; 2024 2018 int status; 2025 2019 2020 + if (!(be_if_cap_flags(adapter) & BE_IF_FLAGS_RSS)) 2021 + return 0; 2022 + 2026 2023 if (mutex_lock_interruptible(&adapter->mbox_lock)) 2027 2024 return -1; 2028 2025 ··· 2169 2160 be_mcc_notify(adapter); 2170 2161 spin_unlock_bh(&adapter->mcc_lock); 2171 2162 2172 - if (!wait_for_completion_timeout(&adapter->flash_compl, 2163 + if (!wait_for_completion_timeout(&adapter->et_cmd_compl, 2173 2164 msecs_to_jiffies(60000))) 2174 2165 status = -1; 2175 2166 else ··· 2264 2255 be_mcc_notify(adapter); 2265 2256 spin_unlock_bh(&adapter->mcc_lock); 2266 2257 2267 - if (!wait_for_completion_timeout(&adapter->flash_compl, 2268 - msecs_to_jiffies(40000))) 2258 + if (!wait_for_completion_timeout(&adapter->et_cmd_compl, 2259 + msecs_to_jiffies(40000))) 2269 2260 status = -1; 2270 2261 else 2271 2262 status = adapter->flash_status; ··· 2376 2367 { 2377 2368 struct be_mcc_wrb *wrb; 2378 2369 struct be_cmd_req_loopback_test *req; 2370 + struct be_cmd_resp_loopback_test *resp; 2379 2371 int status; 2380 2372 2381 2373 spin_lock_bh(&adapter->mcc_lock); ··· 2391 2381 2392 2382 be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_LOWLEVEL, 2393 2383 OPCODE_LOWLEVEL_LOOPBACK_TEST, sizeof(*req), wrb, NULL); 2394 - req->hdr.timeout = cpu_to_le32(4); 2395 2384 2385 + req->hdr.timeout = cpu_to_le32(15); 2396 2386 req->pattern = cpu_to_le64(pattern); 2397 2387 req->src_port = cpu_to_le32(port_num); 2398 2388 req->dest_port = cpu_to_le32(port_num); ··· 2400 2390 req->num_pkts = cpu_to_le32(num_pkts); 2401 2391 req->loopback_type = cpu_to_le32(loopback_type); 2402 2392 2403 - status = be_mcc_notify_wait(adapter); 2404 - if (!status) { 2405 - struct be_cmd_resp_loopback_test *resp = embedded_payload(wrb); 2406 - status = le32_to_cpu(resp->status); 2407 - } 2393 + be_mcc_notify(adapter); 2408 2394 2395 + spin_unlock_bh(&adapter->mcc_lock); 2396 + 2397 + wait_for_completion(&adapter->et_cmd_compl); 2398 + resp = embedded_payload(wrb); 2399 + status = le32_to_cpu(resp->status); 2400 + 2401 + return status; 2409 2402 err: 2410 2403 spin_unlock_bh(&adapter->mcc_lock); 2411 2404 return status;
+18 -11
drivers/net/ethernet/emulex/benet/be_main.c
··· 2744 2744 if (!BEx_chip(adapter)) 2745 2745 adapter->rss_flags |= RSS_ENABLE_UDP_IPV4 | 2746 2746 RSS_ENABLE_UDP_IPV6; 2747 + } else { 2748 + /* Disable RSS, if only default RX Q is created */ 2749 + adapter->rss_flags = RSS_ENABLE_NONE; 2750 + } 2747 2751 2748 - rc = be_cmd_rss_config(adapter, rsstable, adapter->rss_flags, 2749 - 128); 2750 - if (rc) { 2751 - adapter->rss_flags = 0; 2752 - return rc; 2753 - } 2752 + rc = be_cmd_rss_config(adapter, rsstable, adapter->rss_flags, 2753 + 128); 2754 + if (rc) { 2755 + adapter->rss_flags = RSS_ENABLE_NONE; 2756 + return rc; 2754 2757 } 2755 2758 2756 2759 /* First time posting */ ··· 3127 3124 { 3128 3125 struct pci_dev *pdev = adapter->pdev; 3129 3126 bool use_sriov = false; 3127 + int max_vfs; 3128 + 3129 + max_vfs = pci_sriov_get_totalvfs(pdev); 3130 3130 3131 3131 if (BE3_chip(adapter) && sriov_want(adapter)) { 3132 - int max_vfs; 3133 - 3134 - max_vfs = pci_sriov_get_totalvfs(pdev); 3135 3132 res->max_vfs = max_vfs > 0 ? min(MAX_VFS, max_vfs) : 0; 3136 3133 use_sriov = res->max_vfs; 3137 3134 } ··· 3162 3159 BE3_MAX_RSS_QS : BE2_MAX_RSS_QS; 3163 3160 res->max_rx_qs = res->max_rss_qs + 1; 3164 3161 3165 - res->max_evt_qs = be_physfn(adapter) ? BE3_MAX_EVT_QS : 1; 3162 + if (be_physfn(adapter)) 3163 + res->max_evt_qs = (max_vfs > 0) ? 3164 + BE3_SRIOV_MAX_EVT_QS : BE3_MAX_EVT_QS; 3165 + else 3166 + res->max_evt_qs = 1; 3166 3167 3167 3168 res->if_cap_flags = BE_IF_CAP_FLAGS_WANT; 3168 3169 if (!(adapter->function_caps & BE_FUNCTION_CAPS_RSS)) ··· 4212 4205 spin_lock_init(&adapter->mcc_lock); 4213 4206 spin_lock_init(&adapter->mcc_cq_lock); 4214 4207 4215 - init_completion(&adapter->flash_compl); 4208 + init_completion(&adapter->et_cmd_compl); 4216 4209 pci_save_state(adapter->pdev); 4217 4210 return 0; 4218 4211
+4 -10
drivers/net/ethernet/freescale/fec_main.c
··· 2049 2049 int err, phy_reset; 2050 2050 int msec = 1; 2051 2051 struct device_node *np = pdev->dev.of_node; 2052 - enum of_gpio_flags flags; 2053 - bool port; 2054 2052 2055 2053 if (!np) 2056 2054 return; ··· 2058 2060 if (msec > 1000) 2059 2061 msec = 1; 2060 2062 2061 - phy_reset = of_get_named_gpio_flags(np, "phy-reset-gpios", 0, &flags); 2063 + phy_reset = of_get_named_gpio(np, "phy-reset-gpios", 0); 2062 2064 if (!gpio_is_valid(phy_reset)) 2063 2065 return; 2064 2066 2065 - if (flags & OF_GPIO_ACTIVE_LOW) 2066 - port = GPIOF_OUT_INIT_LOW; 2067 - else 2068 - port = GPIOF_OUT_INIT_HIGH; 2069 - 2070 - err = devm_gpio_request_one(&pdev->dev, phy_reset, port, "phy-reset"); 2067 + err = devm_gpio_request_one(&pdev->dev, phy_reset, 2068 + GPIOF_OUT_INIT_LOW, "phy-reset"); 2071 2069 if (err) { 2072 2070 dev_err(&pdev->dev, "failed to get phy-reset-gpios: %d\n", err); 2073 2071 return; 2074 2072 } 2075 2073 msleep(msec); 2076 - gpio_set_value(phy_reset, !port); 2074 + gpio_set_value(phy_reset, 1); 2077 2075 } 2078 2076 #else /* CONFIG_OF */ 2079 2077 static void fec_reset_phy(struct platform_device *pdev)
+4 -1
drivers/net/ethernet/qlogic/qlcnic/qlcnic.h
··· 487 487 struct qlcnic_mailbox *mailbox; 488 488 u8 extend_lb_time; 489 489 u8 phys_port_id[ETH_ALEN]; 490 + u8 lb_mode; 490 491 }; 491 492 492 493 struct qlcnic_adapter_stats { ··· 579 578 dma_addr_t phys_addr; 580 579 dma_addr_t hw_cons_phys_addr; 581 580 struct netdev_queue *txq; 581 + /* Lock to protect Tx descriptors cleanup */ 582 + spinlock_t tx_clean_lock; 582 583 } ____cacheline_internodealigned_in_smp; 583 584 584 585 /* ··· 811 808 812 809 #define QLCNIC_ILB_MODE 0x1 813 810 #define QLCNIC_ELB_MODE 0x2 811 + #define QLCNIC_LB_MODE_MASK 0x3 814 812 815 813 #define QLCNIC_LINKEVENT 0x1 816 814 #define QLCNIC_LB_RESPONSE 0x2 ··· 1097 1093 struct qlcnic_filter_hash rx_fhash; 1098 1094 struct list_head vf_mc_list; 1099 1095 1100 - spinlock_t tx_clean_lock; 1101 1096 spinlock_t mac_learn_lock; 1102 1097 /* spinlock for catching rcv filters for eswitch traffic */ 1103 1098 spinlock_t rx_mac_learn_lock;
+1 -6
drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_hw.c
··· 1684 1684 } 1685 1685 } while ((adapter->ahw->linkup && ahw->has_link_events) != 1); 1686 1686 1687 - /* Make sure carrier is off and queue is stopped during loopback */ 1688 - if (netif_running(netdev)) { 1689 - netif_carrier_off(netdev); 1690 - netif_tx_stop_all_queues(netdev); 1691 - } 1692 - 1693 1687 ret = qlcnic_do_lb_test(adapter, mode); 1694 1688 1695 1689 qlcnic_83xx_clear_lb_mode(adapter, mode); ··· 2115 2121 ahw->link_autoneg = MSB(MSW(data[3])); 2116 2122 ahw->module_type = MSB(LSW(data[3])); 2117 2123 ahw->has_link_events = 1; 2124 + ahw->lb_mode = data[4] & QLCNIC_LB_MODE_MASK; 2118 2125 qlcnic_advert_link_change(adapter, link_status); 2119 2126 } 2120 2127
+4
drivers/net/ethernet/qlogic/qlcnic/qlcnic_init.c
··· 134 134 struct qlcnic_skb_frag *buffrag; 135 135 int i, j; 136 136 137 + spin_lock(&tx_ring->tx_clean_lock); 138 + 137 139 cmd_buf = tx_ring->cmd_buf_arr; 138 140 for (i = 0; i < tx_ring->num_desc; i++) { 139 141 buffrag = cmd_buf->frag_array; ··· 159 157 } 160 158 cmd_buf++; 161 159 } 160 + 161 + spin_unlock(&tx_ring->tx_clean_lock); 162 162 } 163 163 164 164 void qlcnic_free_sw_resources(struct qlcnic_adapter *adapter)
+9 -3
drivers/net/ethernet/qlogic/qlcnic/qlcnic_io.c
··· 689 689 adapter->ahw->linkup = 0; 690 690 netif_carrier_off(netdev); 691 691 } else if (!adapter->ahw->linkup && linkup) { 692 + /* Do not advertise Link up if the port is in loopback mode */ 693 + if (qlcnic_83xx_check(adapter) && adapter->ahw->lb_mode) 694 + return; 695 + 692 696 netdev_info(netdev, "NIC Link is up\n"); 693 697 adapter->ahw->linkup = 1; 694 698 netif_carrier_on(netdev); ··· 782 778 struct net_device *netdev = adapter->netdev; 783 779 struct qlcnic_skb_frag *frag; 784 780 785 - if (!spin_trylock(&adapter->tx_clean_lock)) 781 + if (!spin_trylock(&tx_ring->tx_clean_lock)) 786 782 return 1; 787 783 788 784 sw_consumer = tx_ring->sw_consumer; ··· 811 807 break; 812 808 } 813 809 810 + tx_ring->sw_consumer = sw_consumer; 811 + 814 812 if (count && netif_running(netdev)) { 815 - tx_ring->sw_consumer = sw_consumer; 816 813 smp_mb(); 817 814 if (netif_tx_queue_stopped(tx_ring->txq) && 818 815 netif_carrier_ok(netdev)) { ··· 839 834 */ 840 835 hw_consumer = le32_to_cpu(*(tx_ring->hw_consumer)); 841 836 done = (sw_consumer == hw_consumer); 842 - spin_unlock(&adapter->tx_clean_lock); 837 + 838 + spin_unlock(&tx_ring->tx_clean_lock); 843 839 844 840 return done; 845 841 }
+1 -3
drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c
··· 1756 1756 if (qlcnic_sriov_vf_check(adapter)) 1757 1757 qlcnic_sriov_cleanup_async_list(&adapter->ahw->sriov->bc); 1758 1758 smp_mb(); 1759 - spin_lock(&adapter->tx_clean_lock); 1760 1759 netif_carrier_off(netdev); 1761 1760 adapter->ahw->linkup = 0; 1762 1761 netif_tx_disable(netdev); ··· 1776 1777 1777 1778 for (ring = 0; ring < adapter->drv_tx_rings; ring++) 1778 1779 qlcnic_release_tx_buffers(adapter, &adapter->tx_ring[ring]); 1779 - spin_unlock(&adapter->tx_clean_lock); 1780 1780 } 1781 1781 1782 1782 /* Usage: During suspend and firmware recovery module */ ··· 2170 2172 } 2171 2173 memset(cmd_buf_arr, 0, TX_BUFF_RINGSIZE(tx_ring)); 2172 2174 tx_ring->cmd_buf_arr = cmd_buf_arr; 2175 + spin_lock_init(&tx_ring->tx_clean_lock); 2173 2176 } 2174 2177 2175 2178 if (qlcnic_83xx_check(adapter) || ··· 2298 2299 rwlock_init(&adapter->ahw->crb_lock); 2299 2300 mutex_init(&adapter->ahw->mem_lock); 2300 2301 2301 - spin_lock_init(&adapter->tx_clean_lock); 2302 2302 INIT_LIST_HEAD(&adapter->mac_list); 2303 2303 2304 2304 qlcnic_register_dcb(adapter);
+2 -1
drivers/net/ethernet/qlogic/qlcnic/qlcnic_sriov_pf.c
··· 75 75 num_vfs = sriov->num_vfs; 76 76 max = num_vfs + 1; 77 77 info->bit_offsets = 0xffff; 78 - info->max_tx_ques = res->num_tx_queues / max; 79 78 info->max_rx_mcast_mac_filters = res->num_rx_mcast_mac_filters; 80 79 num_vf_macs = QLCNIC_SRIOV_VF_MAX_MAC; 81 80 ··· 85 86 info->max_tx_mac_filters = temp; 86 87 info->min_tx_bw = 0; 87 88 info->max_tx_bw = MAX_BW; 89 + info->max_tx_ques = res->num_tx_queues - sriov->num_vfs; 88 90 } else { 89 91 id = qlcnic_sriov_func_to_index(adapter, func); 90 92 if (id < 0) ··· 95 95 info->max_tx_bw = vp->max_tx_bw; 96 96 info->max_rx_ucast_mac_filters = num_vf_macs; 97 97 info->max_tx_mac_filters = num_vf_macs; 98 + info->max_tx_ques = QLCNIC_SINGLE_RING; 98 99 } 99 100 100 101 info->max_rx_ip_addr = res->num_destip / max;
+11 -2
drivers/net/usb/hso.c
··· 185 185 #define BM_REQUEST_TYPE (0xa1) 186 186 #define B_NOTIFICATION (0x20) 187 187 #define W_VALUE (0x0) 188 - #define W_INDEX (0x2) 189 188 #define W_LENGTH (0x2) 190 189 191 190 #define B_OVERRUN (0x1<<6) ··· 1486 1487 struct uart_icount *icount; 1487 1488 struct hso_serial_state_notification *serial_state_notification; 1488 1489 struct usb_device *usb; 1490 + int if_num; 1489 1491 1490 1492 /* Sanity checks */ 1491 1493 if (!serial) ··· 1495 1495 handle_usb_error(status, __func__, serial->parent); 1496 1496 return; 1497 1497 } 1498 + 1499 + /* tiocmget is only supported on HSO_PORT_MODEM */ 1498 1500 tiocmget = serial->tiocmget; 1499 1501 if (!tiocmget) 1500 1502 return; 1503 + BUG_ON((serial->parent->port_spec & HSO_PORT_MASK) != HSO_PORT_MODEM); 1504 + 1501 1505 usb = serial->parent->usb; 1506 + if_num = serial->parent->interface->altsetting->desc.bInterfaceNumber; 1507 + 1508 + /* wIndex should be the USB interface number of the port to which the 1509 + * notification applies, which should always be the Modem port. 1510 + */ 1502 1511 serial_state_notification = &tiocmget->serial_state_notification; 1503 1512 if (serial_state_notification->bmRequestType != BM_REQUEST_TYPE || 1504 1513 serial_state_notification->bNotification != B_NOTIFICATION || 1505 1514 le16_to_cpu(serial_state_notification->wValue) != W_VALUE || 1506 - le16_to_cpu(serial_state_notification->wIndex) != W_INDEX || 1515 + le16_to_cpu(serial_state_notification->wIndex) != if_num || 1507 1516 le16_to_cpu(serial_state_notification->wLength) != W_LENGTH) { 1508 1517 dev_warn(&usb->dev, 1509 1518 "hso received invalid serial state notification\n");
+4 -15
drivers/net/usb/mcs7830.c
··· 117 117 struct mcs7830_data { 118 118 u8 multi_filter[8]; 119 119 u8 config; 120 - u8 link_counter; 121 120 }; 122 121 123 122 static const char driver_name[] = "MOSCHIP usb-ethernet driver"; ··· 560 561 { 561 562 u8 *buf = urb->transfer_buffer; 562 563 bool link, link_changed; 563 - struct mcs7830_data *data = mcs7830_get_data(dev); 564 564 565 565 if (urb->actual_length < 16) 566 566 return; 567 567 568 - link = !(buf[1] & 0x20); 568 + link = !(buf[1] == 0x20); 569 569 link_changed = netif_carrier_ok(dev->net) != link; 570 570 if (link_changed) { 571 - data->link_counter++; 572 - /* 573 - track link state 20 times to guard against erroneous 574 - link state changes reported sometimes by the chip 575 - */ 576 - if (data->link_counter > 20) { 577 - data->link_counter = 0; 578 - usbnet_link_change(dev, link, 0); 579 - netdev_dbg(dev->net, "Link Status is: %d\n", link); 580 - } 581 - } else 582 - data->link_counter = 0; 571 + usbnet_link_change(dev, link, 0); 572 + netdev_dbg(dev->net, "Link Status is: %d\n", link); 573 + } 583 574 } 584 575 585 576 static const struct driver_info moschip_info = {
+6 -5
drivers/net/virtio_net.c
··· 1797 1797 if (err) 1798 1798 return err; 1799 1799 1800 - if (netif_running(vi->dev)) 1800 + if (netif_running(vi->dev)) { 1801 + for (i = 0; i < vi->curr_queue_pairs; i++) 1802 + if (!try_fill_recv(&vi->rq[i], GFP_KERNEL)) 1803 + schedule_delayed_work(&vi->refill, 0); 1804 + 1801 1805 for (i = 0; i < vi->max_queue_pairs; i++) 1802 1806 virtnet_napi_enable(&vi->rq[i]); 1807 + } 1803 1808 1804 1809 netif_device_attach(vi->dev); 1805 - 1806 - for (i = 0; i < vi->curr_queue_pairs; i++) 1807 - if (!try_fill_recv(&vi->rq[i], GFP_KERNEL)) 1808 - schedule_delayed_work(&vi->refill, 0); 1809 1810 1810 1811 mutex_lock(&vi->config_lock); 1811 1812 vi->config_enable = true;
+2 -1
drivers/net/vxlan.c
··· 2440 2440 /* update header length based on lower device */ 2441 2441 dev->hard_header_len = lowerdev->hard_header_len + 2442 2442 (use_ipv6 ? VXLAN6_HEADROOM : VXLAN_HEADROOM); 2443 - } 2443 + } else if (use_ipv6) 2444 + vxlan->flags |= VXLAN_F_IPV6; 2444 2445 2445 2446 if (data[IFLA_VXLAN_TOS]) 2446 2447 vxlan->tos = nla_get_u8(data[IFLA_VXLAN_TOS]);
+1
drivers/net/xen-netback/interface.c
··· 34 34 #include <linux/ethtool.h> 35 35 #include <linux/rtnetlink.h> 36 36 #include <linux/if_vlan.h> 37 + #include <linux/vmalloc.h> 37 38 38 39 #include <xen/events.h> 39 40 #include <asm/xen/hypercall.h>
+22
include/linux/netdevice.h
··· 1912 1912 return dev->header_ops->parse(skb, haddr); 1913 1913 } 1914 1914 1915 + static inline int dev_rebuild_header(struct sk_buff *skb) 1916 + { 1917 + const struct net_device *dev = skb->dev; 1918 + 1919 + if (!dev->header_ops || !dev->header_ops->rebuild) 1920 + return 0; 1921 + return dev->header_ops->rebuild(skb); 1922 + } 1923 + 1915 1924 typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len); 1916 1925 int register_gifconf(unsigned int family, gifconf_func_t *gifconf); 1917 1926 static inline int unregister_gifconf(unsigned int family) ··· 3015 3006 unsigned int size) 3016 3007 { 3017 3008 dev->gso_max_size = size; 3009 + } 3010 + 3011 + static inline void skb_gso_error_unwind(struct sk_buff *skb, __be16 protocol, 3012 + int pulled_hlen, u16 mac_offset, 3013 + int mac_len) 3014 + { 3015 + skb->protocol = protocol; 3016 + skb->encapsulation = 1; 3017 + skb_push(skb, pulled_hlen); 3018 + skb_reset_transport_header(skb); 3019 + skb->mac_header = mac_offset; 3020 + skb->network_header = skb->mac_header + mac_len; 3021 + skb->mac_len = mac_len; 3018 3022 } 3019 3023 3020 3024 static inline bool netif_is_macvlan(struct net_device *dev)
+1 -1
include/net/llc_pdu.h
··· 142 142 #define LLC_S_PF_IS_1(pdu) ((pdu->ctrl_2 & LLC_S_PF_BIT_MASK) ? 1 : 0) 143 143 144 144 #define PDU_SUPV_GET_Nr(pdu) ((pdu->ctrl_2 & 0xFE) >> 1) 145 - #define PDU_GET_NEXT_Vr(sn) (++sn & ~LLC_2_SEQ_NBR_MODULO) 145 + #define PDU_GET_NEXT_Vr(sn) (((sn) + 1) & ~LLC_2_SEQ_NBR_MODULO) 146 146 147 147 /* FRMR information field macros */ 148 148
-3
include/net/sctp/structs.h
··· 1046 1046 1047 1047 /* Corked? */ 1048 1048 char cork; 1049 - 1050 - /* Is this structure empty? */ 1051 - char empty; 1052 1049 }; 1053 1050 1054 1051 void sctp_outq_init(struct sctp_association *, struct sctp_outq *);
+18 -1
net/8021q/vlan_dev.c
··· 530 530 .parse = eth_header_parse, 531 531 }; 532 532 533 + static int vlan_passthru_hard_header(struct sk_buff *skb, struct net_device *dev, 534 + unsigned short type, 535 + const void *daddr, const void *saddr, 536 + unsigned int len) 537 + { 538 + struct vlan_dev_priv *vlan = vlan_dev_priv(dev); 539 + struct net_device *real_dev = vlan->real_dev; 540 + 541 + return dev_hard_header(skb, real_dev, type, daddr, saddr, len); 542 + } 543 + 544 + static const struct header_ops vlan_passthru_header_ops = { 545 + .create = vlan_passthru_hard_header, 546 + .rebuild = dev_rebuild_header, 547 + .parse = eth_header_parse, 548 + }; 549 + 533 550 static struct device_type vlan_type = { 534 551 .name = "vlan", 535 552 }; ··· 590 573 591 574 dev->needed_headroom = real_dev->needed_headroom; 592 575 if (real_dev->features & NETIF_F_HW_VLAN_CTAG_TX) { 593 - dev->header_ops = real_dev->header_ops; 576 + dev->header_ops = &vlan_passthru_header_ops; 594 577 dev->hard_header_len = real_dev->hard_header_len; 595 578 } else { 596 579 dev->header_ops = &vlan_header_ops;
+2 -2
net/bridge/br_multicast.c
··· 1998 1998 u32 old; 1999 1999 struct net_bridge_mdb_htable *mdb; 2000 2000 2001 - spin_lock(&br->multicast_lock); 2001 + spin_lock_bh(&br->multicast_lock); 2002 2002 if (!netif_running(br->dev)) 2003 2003 goto unlock; 2004 2004 ··· 2030 2030 } 2031 2031 2032 2032 unlock: 2033 - spin_unlock(&br->multicast_lock); 2033 + spin_unlock_bh(&br->multicast_lock); 2034 2034 2035 2035 return err; 2036 2036 }
+1 -1
net/core/neighbour.c
··· 1275 1275 1276 1276 if (dev_hard_header(skb, dev, ntohs(skb->protocol), NULL, NULL, 1277 1277 skb->len) < 0 && 1278 - dev->header_ops->rebuild(skb)) 1278 + dev_rebuild_header(skb)) 1279 1279 return 0; 1280 1280 1281 1281 return dev_queue_xmit(skb);
+9 -2
net/core/netpoll.c
··· 386 386 !vlan_hw_offload_capable(netif_skb_features(skb), 387 387 skb->vlan_proto)) { 388 388 skb = __vlan_put_tag(skb, skb->vlan_proto, vlan_tx_tag_get(skb)); 389 - if (unlikely(!skb)) 390 - break; 389 + if (unlikely(!skb)) { 390 + /* This is actually a packet drop, but we 391 + * don't want the code at the end of this 392 + * function to try and re-queue a NULL skb. 393 + */ 394 + status = NETDEV_TX_OK; 395 + goto unlock_txq; 396 + } 391 397 skb->vlan_tci = 0; 392 398 } 393 399 ··· 401 395 if (status == NETDEV_TX_OK) 402 396 txq_trans_update(txq); 403 397 } 398 + unlock_txq: 404 399 __netif_tx_unlock(txq); 405 400 406 401 if (status == NETDEV_TX_OK)
+1 -1
net/ieee802154/6lowpan.c
··· 547 547 hc06_ptr += 3; 548 548 } else { 549 549 /* compress nothing */ 550 - memcpy(hc06_ptr, &hdr, 4); 550 + memcpy(hc06_ptr, hdr, 4); 551 551 /* replace the top byte with new ECN | DSCP format */ 552 552 *hc06_ptr = tmp; 553 553 hc06_ptr += 4;
+7 -4
net/ipv4/gre_offload.c
··· 28 28 netdev_features_t enc_features; 29 29 int ghl = GRE_HEADER_SECTION; 30 30 struct gre_base_hdr *greh; 31 + u16 mac_offset = skb->mac_header; 31 32 int mac_len = skb->mac_len; 32 33 __be16 protocol = skb->protocol; 33 34 int tnl_hlen; ··· 59 58 } else 60 59 csum = false; 61 60 61 + if (unlikely(!pskb_may_pull(skb, ghl))) 62 + goto out; 63 + 62 64 /* setup inner skb. */ 63 65 skb->protocol = greh->protocol; 64 66 skb->encapsulation = 0; 65 - 66 - if (unlikely(!pskb_may_pull(skb, ghl))) 67 - goto out; 68 67 69 68 __skb_pull(skb, ghl); 70 69 skb_reset_mac_header(skb); ··· 74 73 /* segment inner packet. */ 75 74 enc_features = skb->dev->hw_enc_features & netif_skb_features(skb); 76 75 segs = skb_mac_gso_segment(skb, enc_features); 77 - if (!segs || IS_ERR(segs)) 76 + if (!segs || IS_ERR(segs)) { 77 + skb_gso_error_unwind(skb, protocol, ghl, mac_offset, mac_len); 78 78 goto out; 79 + } 79 80 80 81 skb = segs; 81 82 tnl_hlen = skb_tnl_header_len(skb);
+5 -1
net/ipv4/udp.c
··· 2478 2478 netdev_features_t features) 2479 2479 { 2480 2480 struct sk_buff *segs = ERR_PTR(-EINVAL); 2481 + u16 mac_offset = skb->mac_header; 2481 2482 int mac_len = skb->mac_len; 2482 2483 int tnl_hlen = skb_inner_mac_header(skb) - skb_transport_header(skb); 2483 2484 __be16 protocol = skb->protocol; ··· 2498 2497 /* segment inner packet. */ 2499 2498 enc_features = skb->dev->hw_enc_features & netif_skb_features(skb); 2500 2499 segs = skb_mac_gso_segment(skb, enc_features); 2501 - if (!segs || IS_ERR(segs)) 2500 + if (!segs || IS_ERR(segs)) { 2501 + skb_gso_error_unwind(skb, protocol, tnl_hlen, mac_offset, 2502 + mac_len); 2502 2503 goto out; 2504 + } 2503 2505 2504 2506 outer_hlen = skb_tnl_header_len(skb); 2505 2507 skb = segs;
+19 -18
net/ipv4/udp_offload.c
··· 41 41 { 42 42 struct sk_buff *segs = ERR_PTR(-EINVAL); 43 43 unsigned int mss; 44 + int offset; 45 + __wsum csum; 46 + 47 + if (skb->encapsulation && 48 + skb_shinfo(skb)->gso_type & SKB_GSO_UDP_TUNNEL) { 49 + segs = skb_udp_tunnel_segment(skb, features); 50 + goto out; 51 + } 44 52 45 53 mss = skb_shinfo(skb)->gso_size; 46 54 if (unlikely(skb->len <= mss)) ··· 71 63 goto out; 72 64 } 73 65 66 + /* Do software UFO. Complete and fill in the UDP checksum as 67 + * HW cannot do checksum of UDP packets sent as multiple 68 + * IP fragments. 69 + */ 70 + offset = skb_checksum_start_offset(skb); 71 + csum = skb_checksum(skb, offset, skb->len - offset, 0); 72 + offset += skb->csum_offset; 73 + *(__sum16 *)(skb->data + offset) = csum_fold(csum); 74 + skb->ip_summed = CHECKSUM_NONE; 75 + 74 76 /* Fragment the skb. IP headers of the fragments are updated in 75 77 * inet_gso_segment() 76 78 */ 77 - if (skb->encapsulation && skb_shinfo(skb)->gso_type & SKB_GSO_UDP_TUNNEL) 78 - segs = skb_udp_tunnel_segment(skb, features); 79 - else { 80 - int offset; 81 - __wsum csum; 82 - 83 - /* Do software UFO. Complete and fill in the UDP checksum as 84 - * HW cannot do checksum of UDP packets sent as multiple 85 - * IP fragments. 86 - */ 87 - offset = skb_checksum_start_offset(skb); 88 - csum = skb_checksum(skb, offset, skb->len - offset, 0); 89 - offset += skb->csum_offset; 90 - *(__sum16 *)(skb->data + offset) = csum_fold(csum); 91 - skb->ip_summed = CHECKSUM_NONE; 92 - 93 - segs = skb_segment(skb, features); 94 - } 79 + segs = skb_segment(skb, features); 95 80 out: 96 81 return segs; 97 82 }
+12 -5
net/ipv6/addrconf.c
··· 1671 1671 static void addrconf_join_anycast(struct inet6_ifaddr *ifp) 1672 1672 { 1673 1673 struct in6_addr addr; 1674 - if (ifp->prefix_len == 127) /* RFC 6164 */ 1674 + if (ifp->prefix_len >= 127) /* RFC 6164 */ 1675 1675 return; 1676 1676 ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len); 1677 1677 if (ipv6_addr_any(&addr)) ··· 1682 1682 static void addrconf_leave_anycast(struct inet6_ifaddr *ifp) 1683 1683 { 1684 1684 struct in6_addr addr; 1685 - if (ifp->prefix_len == 127) /* RFC 6164 */ 1685 + if (ifp->prefix_len >= 127) /* RFC 6164 */ 1686 1686 return; 1687 1687 ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len); 1688 1688 if (ipv6_addr_any(&addr)) ··· 3456 3456 &inet6_addr_lst[i], addr_lst) { 3457 3457 unsigned long age; 3458 3458 3459 - if (ifp->flags & IFA_F_PERMANENT) 3459 + /* When setting preferred_lft to a value not zero or 3460 + * infinity, while valid_lft is infinity 3461 + * IFA_F_PERMANENT has a non-infinity life time. 3462 + */ 3463 + if ((ifp->flags & IFA_F_PERMANENT) && 3464 + (ifp->prefered_lft == INFINITY_LIFE_TIME)) 3460 3465 continue; 3461 3466 3462 3467 spin_lock(&ifp->lock); ··· 3486 3481 ifp->flags |= IFA_F_DEPRECATED; 3487 3482 } 3488 3483 3489 - if (time_before(ifp->tstamp + ifp->valid_lft * HZ, next)) 3484 + if ((ifp->valid_lft != INFINITY_LIFE_TIME) && 3485 + (time_before(ifp->tstamp + ifp->valid_lft * HZ, next))) 3490 3486 next = ifp->tstamp + ifp->valid_lft * HZ; 3491 3487 3492 3488 spin_unlock(&ifp->lock); ··· 3767 3761 put_ifaddrmsg(nlh, ifa->prefix_len, ifa->flags, rt_scope(ifa->scope), 3768 3762 ifa->idev->dev->ifindex); 3769 3763 3770 - if (!(ifa->flags&IFA_F_PERMANENT)) { 3764 + if (!((ifa->flags&IFA_F_PERMANENT) && 3765 + (ifa->prefered_lft == INFINITY_LIFE_TIME))) { 3771 3766 preferred = ifa->prefered_lft; 3772 3767 valid = ifa->valid_lft; 3773 3768 if (preferred != INFINITY_LIFE_TIME) {
+16 -5
net/ipv6/ip6_tunnel.c
··· 103 103 104 104 static struct net_device_stats *ip6_get_stats(struct net_device *dev) 105 105 { 106 - struct pcpu_tstats sum = { 0 }; 106 + struct pcpu_tstats tmp, sum = { 0 }; 107 107 int i; 108 108 109 109 for_each_possible_cpu(i) { 110 + unsigned int start; 110 111 const struct pcpu_tstats *tstats = per_cpu_ptr(dev->tstats, i); 111 112 112 - sum.rx_packets += tstats->rx_packets; 113 - sum.rx_bytes += tstats->rx_bytes; 114 - sum.tx_packets += tstats->tx_packets; 115 - sum.tx_bytes += tstats->tx_bytes; 113 + do { 114 + start = u64_stats_fetch_begin_bh(&tstats->syncp); 115 + tmp.rx_packets = tstats->rx_packets; 116 + tmp.rx_bytes = tstats->rx_bytes; 117 + tmp.tx_packets = tstats->tx_packets; 118 + tmp.tx_bytes = tstats->tx_bytes; 119 + } while (u64_stats_fetch_retry_bh(&tstats->syncp, start)); 120 + 121 + sum.rx_packets += tmp.rx_packets; 122 + sum.rx_bytes += tmp.rx_bytes; 123 + sum.tx_packets += tmp.tx_packets; 124 + sum.tx_bytes += tmp.tx_bytes; 116 125 } 117 126 dev->stats.rx_packets = sum.rx_packets; 118 127 dev->stats.rx_bytes = sum.rx_bytes; ··· 833 824 } 834 825 835 826 tstats = this_cpu_ptr(t->dev->tstats); 827 + u64_stats_update_begin(&tstats->syncp); 836 828 tstats->rx_packets++; 837 829 tstats->rx_bytes += skb->len; 830 + u64_stats_update_end(&tstats->syncp); 838 831 839 832 netif_rx(skb); 840 833
+3 -21
net/ipv6/ip6_vti.c
··· 75 75 struct ip6_tnl __rcu **tnls[2]; 76 76 }; 77 77 78 - static struct net_device_stats *vti6_get_stats(struct net_device *dev) 79 - { 80 - struct pcpu_tstats sum = { 0 }; 81 - int i; 82 - 83 - for_each_possible_cpu(i) { 84 - const struct pcpu_tstats *tstats = per_cpu_ptr(dev->tstats, i); 85 - 86 - sum.rx_packets += tstats->rx_packets; 87 - sum.rx_bytes += tstats->rx_bytes; 88 - sum.tx_packets += tstats->tx_packets; 89 - sum.tx_bytes += tstats->tx_bytes; 90 - } 91 - dev->stats.rx_packets = sum.rx_packets; 92 - dev->stats.rx_bytes = sum.rx_bytes; 93 - dev->stats.tx_packets = sum.tx_packets; 94 - dev->stats.tx_bytes = sum.tx_bytes; 95 - return &dev->stats; 96 - } 97 - 98 78 #define for_each_vti6_tunnel_rcu(start) \ 99 79 for (t = rcu_dereference(start); t; t = rcu_dereference(t->next)) 100 80 ··· 311 331 } 312 332 313 333 tstats = this_cpu_ptr(t->dev->tstats); 334 + u64_stats_update_begin(&tstats->syncp); 314 335 tstats->rx_packets++; 315 336 tstats->rx_bytes += skb->len; 337 + u64_stats_update_end(&tstats->syncp); 316 338 317 339 skb->mark = 0; 318 340 secpath_reset(skb); ··· 698 716 .ndo_start_xmit = vti6_tnl_xmit, 699 717 .ndo_do_ioctl = vti6_ioctl, 700 718 .ndo_change_mtu = vti6_change_mtu, 701 - .ndo_get_stats = vti6_get_stats, 719 + .ndo_get_stats64 = ip_tunnel_get_stats64, 702 720 }; 703 721 704 722 /**
+2
net/ipv6/sit.c
··· 702 702 } 703 703 704 704 tstats = this_cpu_ptr(tunnel->dev->tstats); 705 + u64_stats_update_begin(&tstats->syncp); 705 706 tstats->rx_packets++; 706 707 tstats->rx_bytes += skb->len; 708 + u64_stats_update_end(&tstats->syncp); 707 709 708 710 netif_rx(skb); 709 711
+3 -2
net/llc/af_llc.c
··· 715 715 unsigned long cpu_flags; 716 716 size_t copied = 0; 717 717 u32 peek_seq = 0; 718 - u32 *seq; 718 + u32 *seq, skb_len; 719 719 unsigned long used; 720 720 int target; /* Read at least this many bytes */ 721 721 long timeo; ··· 812 812 } 813 813 continue; 814 814 found_ok_skb: 815 + skb_len = skb->len; 815 816 /* Ok so how much can we use? */ 816 817 used = skb->len - offset; 817 818 if (len < used) ··· 845 844 } 846 845 847 846 /* Partial read */ 848 - if (used + offset < skb->len) 847 + if (used + offset < skb_len) 849 848 continue; 850 849 } while (len > 0); 851 850
+7 -25
net/sctp/outqueue.c
··· 208 208 INIT_LIST_HEAD(&q->retransmit); 209 209 INIT_LIST_HEAD(&q->sacked); 210 210 INIT_LIST_HEAD(&q->abandoned); 211 - 212 - q->empty = 1; 213 211 } 214 212 215 213 /* Free the outqueue structure and any related pending chunks. ··· 330 332 SCTP_INC_STATS(net, SCTP_MIB_OUTUNORDERCHUNKS); 331 333 else 332 334 SCTP_INC_STATS(net, SCTP_MIB_OUTORDERCHUNKS); 333 - q->empty = 0; 334 335 break; 335 336 } 336 337 } else { ··· 651 654 if (chunk->fast_retransmit == SCTP_NEED_FRTX) 652 655 chunk->fast_retransmit = SCTP_DONT_FRTX; 653 656 654 - q->empty = 0; 655 657 q->asoc->stats.rtxchunks++; 656 658 break; 657 659 } ··· 1061 1065 1062 1066 sctp_transport_reset_timers(transport); 1063 1067 1064 - q->empty = 0; 1065 - 1066 1068 /* Only let one DATA chunk get bundled with a 1067 1069 * COOKIE-ECHO chunk. 1068 1070 */ ··· 1269 1275 "advertised peer ack point:0x%x\n", __func__, asoc, ctsn, 1270 1276 asoc->adv_peer_ack_point); 1271 1277 1272 - /* See if all chunks are acked. 1273 - * Make sure the empty queue handler will get run later. 1274 - */ 1275 - q->empty = (list_empty(&q->out_chunk_list) && 1276 - list_empty(&q->retransmit)); 1277 - if (!q->empty) 1278 - goto finish; 1279 - 1280 - list_for_each_entry(transport, transport_list, transports) { 1281 - q->empty = q->empty && list_empty(&transport->transmitted); 1282 - if (!q->empty) 1283 - goto finish; 1284 - } 1285 - 1286 - pr_debug("%s: sack queue is empty\n", __func__); 1287 - finish: 1288 - return q->empty; 1278 + return sctp_outq_is_empty(q); 1289 1279 } 1290 1280 1291 - /* Is the outqueue empty? */ 1281 + /* Is the outqueue empty? 1282 + * The queue is empty when we have not pending data, no in-flight data 1283 + * and nothing pending retransmissions. 1284 + */ 1292 1285 int sctp_outq_is_empty(const struct sctp_outq *q) 1293 1286 { 1294 - return q->empty; 1287 + return q->out_qlen == 0 && q->outstanding_bytes == 0 && 1288 + list_empty(&q->retransmit); 1295 1289 } 1296 1290 1297 1291 /********************************************************************