fm10k: use a BITMAP for flags to avoid race conditions
Subsystems (2)
PATCH 1/5 fm10k: use a BITMAP for flags to avoid race conditions
Replace bitwise operators and #defines with a BITMAP and enumeration values. This is similar to how we handle the "state" values as well.
This has two distinct advantages over the old method. First, we ensure correctness of operations which are currently problematic due to race conditions. Suppose that two kernel threads are running, such as the watchdog and an ethtool ioctl, and both modify flags. We'll say that the watchdog is CPU A, and the ethtool ioctl is CPU B.
CPU A sets FLAG_1, which can be seen as
CPU A read FLAGS
CPU A write FLAGS | FLAG_1
CPU B sets FLAG_2, which can be seen as
CPU B read FLAGS
CPU A write FLAGS | FLAG_2
However, "|=" and "&=" operators are not actually atomic. So this could be ordered like the following:
CPU A read FLAGS -> variable
CPU B read FLAGS -> variable
CPU A write FLAGS (variable | FLAG_1)
CPU B write FLAGS (variable | FLAG_2)
Notice how the 2nd write from CPU B could actually undo the write from CPU A because it isn't guaranteed that the |= operation is atomic.
In practice the race windows for most flag writes is incredibly narrow so it is not easy to isolate issues. However, the more flags we have, the more likely they will cause problems. Additionally, if such a problem were to arise, it would be incredibly difficult to track down.
Second, there is an additional advantage beyond code correctness. We can now automatically size the BITMAP if more flags were added, so that we do not need to remember that flags is u32 and thus if we added too many flags we would over-run the variable. This is not a likely occurrence for fm10k driver, but this patch can serve as an example for other drivers which have many more flags.
This particular change does have a bit of trouble converting some of the idioms previously used with the #defines for flags. Specifically, when converting FM10K_FLAG_RSS_FIELD_IPV[46]_UDP flags. This whole operation was actually quite problematic, because we actually stored flags separately. This could more easily show the problem of the above re-ordering issue.
This is really difficult to test whether atomics make a difference in practical scenarios, but you can ensure that basic functionality remains the same. This patch has a lot of code coverage, but most of it is relatively simple.
While we are modifying these files, update their copyright year.
--- drivers/net/ethernet/intel/fm10k/fm10k.h | 27 ++++++++--- drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c | 62 ++++++++++++++++-------- drivers/net/ethernet/intel/fm10k/fm10k_main.c | 6 +-- drivers/net/ethernet/intel/fm10k/fm10k_netdev.c | 4 +- drivers/net/ethernet/intel/fm10k/fm10k_pci.c | 31 ++++++------ 5 files changed, 82 insertions(+), 48 deletions(-)
drivers/net/ethernet/intel/fm10k/fm10k.h +21 -6
@@ -1,5 +1,5 @@/* Intel(R) Ethernet Switch Host Interface Driver -* Copyright(c) 2013 - 2016 Intel Corporation. +* Copyright(c) 2013 - 2017 Intel Corporation. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU General Public License,
@@ -249,6 +249,23 @@ struct fm10k_udp_port {/* one work queue for entire driver */ extern struct workqueue_struct *fm10k_workqueue; +/* The following enumeration contains flags which indicate or enable modified +* driver behaviors. To avoid race conditions, the flags are stored in +* a BITMAP in the fm10k_intfc structure. The BITMAP should be accessed using +* atomic *_bit() operations. +*/ +enum fm10k_flags_t { +FM10K_FLAG_RESET_REQUESTED , +FM10K_FLAG_RSS_FIELD_IPV4_UDP , +FM10K_FLAG_RSS_FIELD_IPV6_UDP , +FM10K_FLAG_SWPRI_CONFIG , +/* __FM10K_FLAGS_SIZE__ is used to calculate the size of +* interface->flags and must be the last value in this +* enumeration. +*/ + __FM10K_FLAGS_SIZE__ +}; +struct fm10k_intfc {unsigned long active_vlans[BITS_TO_LONGS (VLAN_N_VID )];struct net_device *netdev;
@@ -256,11 +273,9 @@ struct fm10k_intfc {struct pci_dev *pdev;unsigned long state; -u32 flags; -#define FM10K_FLAG_RESET_REQUESTED (u32)(BIT(0)) -#define FM10K_FLAG_RSS_FIELD_IPV4_UDP (u32)(BIT(1)) -#define FM10K_FLAG_RSS_FIELD_IPV6_UDP (u32)(BIT(2)) -#define FM10K_FLAG_SWPRI_CONFIG (u32)(BIT(3)) +/* Access flag values using atomic *_bit() operations */ +DECLARE_BITMAP (flags, __FM10K_FLAGS_SIZE__); +int xcast_mode;/* Tx fast path data */
drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c +41 -21
120 lines not on this page · raw message
drivers/net/ethernet/intel/fm10k/fm10k_main.c +3 -3
@@ -1,5 +1,5 @@/* Intel(R) Ethernet Switch Host Interface Driver -* Copyright(c) 2013 - 2016 Intel Corporation. +* Copyright(c) 2013 - 2017 Intel Corporation. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU General Public License,
@@ -34,7 +34,7 @@ const char fm10k_driver_version[] = DRV_VERSION;char fm10k_driver_name[] ="fm10k" ;static const char fm10k_driver_string[] =DRV_SUMMARY ;static const char fm10k_copyright[] = -"Copyright (c) 2013 - 2016 Intel Corporation." ; +"Copyright(c) 2013 - 2017 Intel Corporation." ;MODULE_AUTHOR ("Intel Corporation, <[email protected]>" );MODULE_DESCRIPTION (DRV_SUMMARY );
@@ -1193,7 +1193,7 @@ void fm10k_tx_timeout_reset(struct fm10k_intfc *interface)/* Do the reset outside of interrupt context */ if (!test_bit (__FM10K_DOWN, &interface->state)) { interface->tx_timeout_count++; - interface->flags |=FM10K_FLAG_RESET_REQUESTED ; +set_bit (FM10K_FLAG_RESET_REQUESTED , interface->flags);fm10k_service_event_schedule (interface); } }
drivers/net/ethernet/intel/fm10k/fm10k_netdev.c +2 -2
@@ -1,5 +1,5 @@/* Intel(R) Ethernet Switch Host Interface Driver -* Copyright(c) 2013 - 2016 Intel Corporation. +* Copyright(c) 2013 - 2017 Intel Corporation. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU General Public License,
@@ -1207,7 +1207,7 @@ int fm10k_setup_tc(struct net_device *dev, u8 tc) goto err_open;/* flag to indicate SWPRI has yet to be updated */ - interface->flags |=FM10K_FLAG_SWPRI_CONFIG ; +set_bit (FM10K_FLAG_SWPRI_CONFIG , interface->flags);return 0 ; err_open:
drivers/net/ethernet/intel/fm10k/fm10k_pci.c +15 -16
@@ -1,5 +1,5 @@/* Intel(R) Ethernet Switch Host Interface Driver -* Copyright(c) 2013 - 2016 Intel Corporation. +* Copyright(c) 2013 - 2017 Intel Corporation. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU General Public License,
@@ -136,7 +136,7 @@ static void fm10k_detach_subtask(struct fm10k_intfc *interface)if (~value) { interface->hw.hw_addr = interface->uc_addr;netif_device_attach (netdev); - interface->flags |=FM10K_FLAG_RESET_REQUESTED ; +set_bit (FM10K_FLAG_RESET_REQUESTED , interface->flags);netdev_warn (netdev,"PCIe link restored, device now attached\n" );return ; }
@@ -272,11 +272,10 @@ static void fm10k_reinit(struct fm10k_intfc *interface)static void fm10k_reset_subtask (struct fm10k_intfc *interface) { -if (!(interface->flags &FM10K_FLAG_RESET_REQUESTED )) +if (!test_and_clear_bit (FM10K_FLAG_RESET_REQUESTED , + interface->flags))return ; - interface->flags &= ~FM10K_FLAG_RESET_REQUESTED ; -netdev_err (interface->netdev,"Reset interface\n" );fm10k_reinit (interface);
@@ -295,7 +294,7 @@ static void fm10k_configure_swpri_map(struct fm10k_intfc *interface)int i;/* clear flag indicating update is needed */ - interface->flags &= ~FM10K_FLAG_SWPRI_CONFIG ; +clear_bit (FM10K_FLAG_SWPRI_CONFIG , interface->flags);/* these registers are only available on the PF */ if (hw->mac.type != fm10k_mac_pf)
@@ -323,7 +322,7 @@ static void fm10k_watchdog_update_host_state(struct fm10k_intfc *interface)clear_bit (__FM10K_LINK_DOWN, &interface->state); } -if (interface->flags &FM10K_FLAG_SWPRI_CONFIG ) { +if (test_bit (FM10K_FLAG_SWPRI_CONFIG , interface->flags)) {if (rtnl_trylock ()) {fm10k_configure_swpri_map (interface);rtnl_unlock ();
@@ -335,7 +334,7 @@ static void fm10k_watchdog_update_host_state(struct fm10k_intfc *interface) err = hw->mac.ops.get_host_state (hw, &interface->host_ready);if (err &&time_is_before_jiffies (interface->last_reset)) - interface->flags |=FM10K_FLAG_RESET_REQUESTED ; +set_bit (FM10K_FLAG_RESET_REQUESTED , interface->flags);/* free the lock */ fm10k_mbx_unlock (interface);
@@ -522,7 +521,7 @@ static void fm10k_watchdog_flush_tx(struct fm10k_intfc *interface)* controller to flush Tx. */ if (some_tx_pending) - interface->flags |=FM10K_FLAG_RESET_REQUESTED ; +set_bit (FM10K_FLAG_RESET_REQUESTED , interface->flags); }/**
@@ -863,9 +862,9 @@ static void fm10k_configure_dglort(struct fm10k_intfc *interface)FM10K_MRQC_IPV6 |FM10K_MRQC_TCP_IPV6 ; -if (interface->flags &FM10K_FLAG_RSS_FIELD_IPV4_UDP ) +if (test_bit (FM10K_FLAG_RSS_FIELD_IPV4_UDP , interface->flags)) mrqc |=FM10K_MRQC_UDP_IPV4 ; -if (interface->flags &FM10K_FLAG_RSS_FIELD_IPV6_UDP ) +if (test_bit (FM10K_FLAG_RSS_FIELD_IPV6_UDP , interface->flags)) mrqc |=FM10K_MRQC_UDP_IPV6 ;fm10k_write_reg (hw,FM10K_MRQC (0 ), mrqc);
@@ -1167,7 +1166,7 @@ static irqreturn_t fm10k_msix_mbx_pf(int __always_unused irq, void *data) }if (err ==FM10K_ERR_RESET_REQUESTED ) - interface->flags |=FM10K_FLAG_RESET_REQUESTED ; +set_bit (FM10K_FLAG_RESET_REQUESTED , interface->flags);/* if switch toggled state we should reset GLORTs */ if (eicr &FM10K_EICR_SWITCHNOTREADY ) {
@@ -1246,12 +1245,12 @@ static s32 fm10k_mbx_mac_addr(struct fm10k_hw *hw, u32 **results,/* MAC was changed so we need reset */ if (is_valid_ether_addr (hw->mac.perm_addr) && !ether_addr_equal (hw->mac.perm_addr, hw->mac.addr)) - interface->flags |=FM10K_FLAG_RESET_REQUESTED ; +set_bit (FM10K_FLAG_RESET_REQUESTED , interface->flags);/* VLAN override was changed, or default VLAN changed */ if ((vlan_override != hw->mac.vlan_override) || (default_vid != hw->mac.default_vid)) - interface->flags |=FM10K_FLAG_RESET_REQUESTED ; +set_bit (FM10K_FLAG_RESET_REQUESTED , interface->flags);return 0 ; }
@@ -1356,7 +1355,7 @@ static s32 fm10k_lport_map(struct fm10k_hw *hw, u32 **results,/* we need to reset if port count was just updated */ if (dglort_map != hw->mac.dglort_map) - interface->flags |=FM10K_FLAG_RESET_REQUESTED ; +set_bit (FM10K_FLAG_RESET_REQUESTED , interface->flags);return 0 ; }
@@ -1395,7 +1394,7 @@ static s32 fm10k_update_pvid(struct fm10k_hw *hw, u32 **results,/* we need to reset if default VLAN was just updated */ if (pvid != hw->mac.default_vid) - interface->flags |=FM10K_FLAG_RESET_REQUESTED ; +set_bit (FM10K_FLAG_RESET_REQUESTED , interface->flags); hw->mac.default_vid = pvid;
Signature · 1 line
2.11.0.403.g196674b8396b
PATCH 2/5 fm10k: future-proof state bitmaps using DECLARE_BITMAP
This ensures that future programmers do not have to remember to re-size the bitmaps due to adding new values. Although this is unlikely for this driver, it may happen and it's best to prevent it from ever being an issue.
--- drivers/net/ethernet/intel/fm10k/fm10k.h | 40 ++++++++------- drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c | 4 +- drivers/net/ethernet/intel/fm10k/fm10k_main.c | 10 ++-- drivers/net/ethernet/intel/fm10k/fm10k_netdev.c | 2 +- drivers/net/ethernet/intel/fm10k/fm10k_pci.c | 62 ++++++++++++------------ 5 files changed, 61 insertions(+), 57 deletions(-)
drivers/net/ethernet/intel/fm10k/fm10k.h +22 -18
@@ -65,14 +65,16 @@ enum fm10k_ring_state_t { __FM10K_TX_DETECT_HANG, __FM10K_HANG_CHECK_ARMED, __FM10K_TX_XPS_INIT_DONE, +/* This must be last and is used to calculate BITMAP size */ + __FM10K_TX_STATE_SIZE__, };#define check_for_tx_hang (ring) \ - test_bit(__FM10K_TX_DETECT_HANG, &(ring)->state) + test_bit(__FM10K_TX_DETECT_HANG, (ring)->state)#define set_check_for_tx_hang (ring) \ - set_bit(__FM10K_TX_DETECT_HANG, &(ring)->state) + set_bit(__FM10K_TX_DETECT_HANG, (ring)->state)#define clear_check_for_tx_hang (ring) \ - clear_bit(__FM10K_TX_DETECT_HANG, &(ring)->state) + clear_bit(__FM10K_TX_DETECT_HANG, (ring)->state)struct fm10k_tx_buffer {struct fm10k_tx_desc *next_to_watch;
@@ -126,7 +128,7 @@ struct fm10k_ring {struct fm10k_rx_buffer *rx_buffer; };u32 __iomem *tail; -unsigned long state; +DECLARE_BITMAP (state, __FM10K_TX_STATE_SIZE__);dma_addr_t dma;/* phys. address of descriptor ring */ unsigned int size;/* length in bytes */
@@ -266,12 +268,24 @@ enum fm10k_flags_t {__FM10K_FLAGS_SIZE__ }; +enum fm10k_state_t { + __FM10K_RESETTING, + __FM10K_DOWN, + __FM10K_SERVICE_SCHED, + __FM10K_SERVICE_DISABLE, + __FM10K_MBX_LOCK, + __FM10K_LINK_DOWN, + __FM10K_UPDATING_STATS, +/* This value must be last and determines the BITMAP size */ + __FM10K_STATE_SIZE__, +}; +struct fm10k_intfc {unsigned long active_vlans[BITS_TO_LONGS (VLAN_N_VID )];struct net_device *netdev;struct fm10k_l2_accel *l2_accel;/* pointer to L2 acceleration list */ struct pci_dev *pdev; -unsigned long state; + DECLARE_BITMAP(state, __FM10K_STATE_SIZE__);/* Access flag values using atomic *_bit() operations */ DECLARE_BITMAP(flags, __FM10K_FLAGS_SIZE__);
@@ -367,22 +381,12 @@ struct fm10k_intfc {u16 vid; }; -enum fm10k_state_t { - __FM10K_RESETTING, - __FM10K_DOWN, - __FM10K_SERVICE_SCHED, - __FM10K_SERVICE_DISABLE, - __FM10K_MBX_LOCK, - __FM10K_LINK_DOWN, - __FM10K_UPDATING_STATS, -}; -static inline void fm10k_mbx_lock (struct fm10k_intfc *interface) {/* busy loop if we cannot obtain the lock as some calls * such as ndo_set_rx_mode may be made in atomic context */ -while (test_and_set_bit (__FM10K_MBX_LOCK, &interface->state)) +while (test_and_set_bit (__FM10K_MBX_LOCK, interface->state))udelay (20 ); }
@@ -390,12 +394,12 @@ static inline void fm10k_mbx_unlock(struct fm10k_intfc *interface) {/* flush memory to make sure state is correct */ smp_mb__before_atomic (); -clear_bit (__FM10K_MBX_LOCK, &interface->state); +clear_bit (__FM10K_MBX_LOCK, interface->state); }static inline int fm10k_mbx_trylock (struct fm10k_intfc *interface) { -return !test_and_set_bit (__FM10K_MBX_LOCK, &interface->state); +return !test_and_set_bit (__FM10K_MBX_LOCK, interface->state); }/* fm10k_test_staterr - test bits in Rx descriptor status and error fields */
drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c +2 -2
@@ -562,7 +562,7 @@ static int fm10k_set_ringparam(struct net_device *netdev,return 0 ; } -while (test_and_set_bit (__FM10K_RESETTING, &interface->state)) +while (test_and_set_bit (__FM10K_RESETTING, interface->state))usleep_range (1000 ,2000 );if (!netif_running (interface->netdev)) {
@@ -648,7 +648,7 @@ static int fm10k_set_ringparam(struct net_device *netdev,fm10k_up (interface);vfree (temp_ring); clear_reset: -clear_bit (__FM10K_RESETTING, &interface->state); +clear_bit (__FM10K_RESETTING, interface->state);return err; }
drivers/net/ethernet/intel/fm10k/fm10k_main.c +5 -5
@@ -1175,13 +1175,13 @@ bool fm10k_check_tx_hang(struct fm10k_ring *tx_ring)/* update completed stats and continue */ tx_ring->tx_stats.tx_done_old = tx_done;/* reset the countdown */ -clear_bit (__FM10K_HANG_CHECK_ARMED, &tx_ring->state); +clear_bit (__FM10K_HANG_CHECK_ARMED, tx_ring->state);return false; }/* make sure it is true for two checks in a row */ -return test_and_set_bit (__FM10K_HANG_CHECK_ARMED, &tx_ring->state); +return test_and_set_bit (__FM10K_HANG_CHECK_ARMED, tx_ring->state); }/**
@@ -1191,7 +1191,7 @@ bool fm10k_check_tx_hang(struct fm10k_ring *tx_ring)void fm10k_tx_timeout_reset (struct fm10k_intfc *interface) {/* Do the reset outside of interrupt context */ -if (!test_bit (__FM10K_DOWN, &interface->state)) { +if (!test_bit (__FM10K_DOWN, interface->state)) { interface->tx_timeout_count++;set_bit (FM10K_FLAG_RESET_REQUESTED , interface->flags);fm10k_service_event_schedule (interface);
@@ -1214,7 +1214,7 @@ static bool fm10k_clean_tx_irq(struct fm10k_q_vector *q_vector,unsigned int budget = q_vector->tx.work_limit;unsigned int i = tx_ring->next_to_clean; -if (test_bit (__FM10K_DOWN, &interface->state)) +if (test_bit (__FM10K_DOWN, interface->state))return true; tx_buffer = &tx_ring->tx_buffer[i];
@@ -1344,7 +1344,7 @@ static bool fm10k_clean_tx_irq(struct fm10k_q_vector *q_vector,smp_mb ();if (__netif_subqueue_stopped (tx_ring->netdev, tx_ring->queue_index) && - !test_bit (__FM10K_DOWN, &interface->state)) { + !test_bit (__FM10K_DOWN, interface->state)) {netif_wake_subqueue (tx_ring->netdev, tx_ring->queue_index); ++tx_ring->tx_stats.restart_queue;
drivers/net/ethernet/intel/fm10k/fm10k_netdev.c +1 -1
@@ -822,7 +822,7 @@ static int fm10k_update_vid(struct net_device *netdev, u16 vid, bool set)/* Do not throw an error if the interface is down. We will sync once * we come up */ -if (test_bit (__FM10K_DOWN, &interface->state)) +if (test_bit (__FM10K_DOWN, interface->state))return 0 ;fm10k_mbx_lock (interface);
drivers/net/ethernet/intel/fm10k/fm10k_pci.c +31 -31
209 lines not on this page · raw message
Signature · 1 line
2.11.0.403.g196674b8396b
Singh
PATCH 2/5 fm10k: future-proof state bitmaps using DECLARE_BITMAP
-----Original Message-----
From: Intel-wired-lan [mailto:intel-wired-lan-bounces at lists.osuosl.org] On Behalf Of Jacob Keller
Sent: Thursday, January 12, 2017 4:00 PM
To: Intel Wired LAN <[email protected]>
Subject: [Intel-wired-lan] [PATCH 2/5] fm10k: future-proof state bitmaps using DECLARE_BITMAP
This ensures that future programmers do not have to remember to re-size the bitmaps due to adding new values. Although this is unlikely for this driver, it may happen and it's best to prevent it from ever being an issue.
---
PATCH 3/5 fm10k: allow service task to reschedule itself
In reply to Jacob KellerIf some code path executes fm10k_service_event_schedule(), it is guaranteed that we only queue the service task once, since we use __FM10K_SERVICE_SCHED flag. Unfortunately this has a side effect that if a service request occurs while we are currently running the watchdog, it is possible that we will fail to notice the request and ignore it until the next time the request occurs.
This can cause problems with pf/vf mailbox communication and other service event tasks. To avoid this, introduce a FM10K_SERVICE_REQUEST bit. When we successfully schedule (and set the _SCHED bit) the service task, we will clear this bit. However, if we are unable to currently schedule the service event, we just set the new SERVICE_REQUEST bit.
Finally, after the service event completes, we will re-schedule if the request bit has been set.
This should ensure that we do not miss any service event schedules, since we will re-schedule it once the currently running task finishes. This means that for each request, we will always schedule the service task to run at least once in full after the request came in.
This will avoid timing issues that can occur with the service event scheduling. We do pay a cost in re-running many tasks, but all the service event tasks use either flags to avoid duplicate work, or are tolerant of being run multiple times.
--- drivers/net/ethernet/intel/fm10k/fm10k.h | 1 + drivers/net/ethernet/intel/fm10k/fm10k_pci.c | 13 ++++++++++++- 2 files changed, 13 insertions(+), 1 deletion(-)
drivers/net/ethernet/intel/fm10k/fm10k.h +1 -0
@@ -272,6 +272,7 @@ enum fm10k_state_t { __FM10K_RESETTING, __FM10K_DOWN, __FM10K_SERVICE_SCHED, + __FM10K_SERVICE_REQUEST, __FM10K_SERVICE_DISABLE, __FM10K_MBX_LOCK, __FM10K_LINK_DOWN,
drivers/net/ethernet/intel/fm10k/fm10k_pci.c +12 -1
@@ -93,8 +93,12 @@ static int fm10k_hw_ready(struct fm10k_intfc *interface)void fm10k_service_event_schedule (struct fm10k_intfc *interface) {if (!test_bit (__FM10K_SERVICE_DISABLE, interface->state) && - !test_and_set_bit (__FM10K_SERVICE_SCHED, interface->state)) + !test_and_set_bit (__FM10K_SERVICE_SCHED, interface->state)) { +clear_bit (__FM10K_SERVICE_REQUEST, interface->state);queue_work (fm10k_workqueue, &interface->service_task); + }else { +set_bit (__FM10K_SERVICE_REQUEST, interface->state); + } }static void fm10k_service_event_complete (struct fm10k_intfc *interface)
@@ -104,6 +108,13 @@ static void fm10k_service_event_complete(struct fm10k_intfc *interface)/* flush memory to make sure state is correct before next watchog */ smp_mb__before_atomic ();clear_bit (__FM10K_SERVICE_SCHED, interface->state); + +/* If a service event was requested since we started, immediately +* re-schedule now. This ensures we don't drop a request until the +* next timer event. +*/ +if (test_bit (__FM10K_SERVICE_REQUEST, interface->state)) +fm10k_service_event_schedule (interface); }/**
Signature · 1 line
2.11.0.403.g196674b8396b
Singh
PATCH 3/5 fm10k: allow service task to reschedule itself
-----Original Message-----
From: Intel-wired-lan [mailto:intel-wired-lan-bounces at lists.osuosl.org] On Behalf Of Jacob Keller
Sent: Thursday, January 12, 2017 4:00 PM
To: Intel Wired LAN <[email protected]>
Subject: [Intel-wired-lan] [PATCH 3/5] fm10k: allow service task to reschedule itself
If some code path executes fm10k_service_event_schedule(), it is guaranteed that we only queue the service task once, since we use __FM10K_SERVICE_SCHED flag. Unfortunately this has a side effect that if a service request occurs while we are currently running the watchdog, it is possible that we will fail to notice the request and ignore it until the next time the request occurs.
This can cause problems with pf/vf mailbox communication and other service event tasks. To avoid this, introduce a FM10K_SERVICE_REQUEST bit. When we successfully schedule (and set the _SCHED bit) the service task, we will clear this bit. However, if we are unable to currently schedule the service event, we just set the new SERVICE_REQUEST bit.
Finally, after the service event completes, we will re-schedule if the request bit has been set.
This should ensure that we do not miss any service event schedules, since we will re-schedule it once the currently running task finishes. This means that for each request, we will always schedule the service task to run at least once in full after the request came in.
This will avoid timing issues that can occur with the service event scheduling. We do pay a cost in re-running many tasks, but all the service event tasks use either flags to avoid duplicate work, or are tolerant of being run multiple times.
---
PATCH 4/5 fm10k: update function header comment for fm10k_get_stats64
In reply to Jacob KellerRe-word the comment to avoid stating that we return a value for this void function. Additionally, there is no need to mention older kernels, since this is the upstream kernel.
--- drivers/net/ethernet/intel/fm10k/fm10k_netdev.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/net/ethernet/intel/fm10k/fm10k_netdev.c +2 -2
@@ -1115,8 +1115,8 @@ void fm10k_reset_rx_state(struct fm10k_intfc *interface)* @netdev: network interface device structure * @stats: storage space for 64bit statistics * -* Returns 64bit statistics, for use in the ndo_get_stats64 callback. This -* function replaces fm10k_get_stats for kernels which support it. +* Obtain 64bit statistics in a way that is safe for both 32bit and 64bit +* architectures. */ static void fm10k_get_stats64 (struct net_device *netdev,struct rtnl_link_stats64 *stats)
Signature · 1 line
2.11.0.403.g196674b8396b
Singh
PATCH 4/5 fm10k: update function header comment for fm10k_get_stats64
-----Original Message-----
From: Intel-wired-lan [mailto:intel-wired-lan-bounces at lists.osuosl.org] On Behalf Of Jacob Keller
Sent: Thursday, January 12, 2017 4:00 PM
To: Intel Wired LAN <[email protected]>
Subject: [Intel-wired-lan] [PATCH 4/5] fm10k: update function header comment for fm10k_get_stats64
Re-word the comment to avoid stating that we return a value for this void function. Additionally, there is no need to mention older kernels, since this is the upstream kernel.
---
PATCH 5/5 fm10k: disable receive queue when configuring ring
In reply to Jacob KellerFrom: Ngai-Mint Kwan <[email protected]>
Write to RXQCTL register to disable the receive queue when configuring the RX ring.
--- drivers/net/ethernet/intel/fm10k/fm10k_pci.c | 1 + 1 file changed, 1 insertion(+)
drivers/net/ethernet/intel/fm10k/fm10k_pci.c +1 -0
@@ -753,6 +753,7 @@ static void fm10k_configure_rx_ring(struct fm10k_intfc *interface,/* disable queue to avoid issues while updating state */ rxqctl =fm10k_read_reg (hw,FM10K_RXQCTL (reg_idx)); rxqctl &= ~FM10K_RXQCTL_ENABLE ; +fm10k_write_reg (hw,FM10K_RXQCTL (reg_idx), rxqctl);fm10k_write_flush (hw);/* possible poll here to verify ring resources have been cleaned */
Signature · 1 line
2.11.0.403.g196674b8396b
Singh
PATCH 5/5 fm10k: disable receive queue when configuring ring
-----Original Message-----
From: Intel-wired-lan [mailto:intel-wired-lan-bounces at lists.osuosl.org] On Behalf Of Jacob Keller
Sent: Thursday, January 12, 2017 4:00 PM
To: Intel Wired LAN <[email protected]>
Cc: Kwan, Ngai-mint <[email protected]>
Subject: [Intel-wired-lan] [PATCH 5/5] fm10k: disable receive queue when configuring ring
From: Ngai-Mint Kwan <[email protected]>
Write to RXQCTL register to disable the receive queue when configuring the RX ring.
---
Singh
PATCH 1/5 fm10k: use a BITMAP for flags to avoid race conditions
In reply to Jacob Keller-----Original Message-----
From: Intel-wired-lan [mailto:intel-wired-lan-bounces at lists.osuosl.org] On Behalf Of Jacob Keller
Sent: Thursday, January 12, 2017 4:00 PM
To: Intel Wired LAN <[email protected]>
Subject: [Intel-wired-lan] [PATCH 1/5] fm10k: use a BITMAP for flags to avoid race conditions
Replace bitwise operators and #defines with a BITMAP and enumeration values. This is similar to how we handle the "state" values as well.
This has two distinct advantages over the old method. First, we ensure correctness of operations which are currently problematic due to race conditions. Suppose that two kernel threads are running, such as the watchdog and an ethtool ioctl, and both modify flags. We'll say that the watchdog is CPU A, and the ethtool ioctl is CPU B.
CPU A sets FLAG_1, which can be seen as
CPU A read FLAGS
CPU A write FLAGS | FLAG_1
CPU B sets FLAG_2, which can be seen as
CPU B read FLAGS
CPU A write FLAGS | FLAG_2
However, "|=" and "&=" operators are not actually atomic. So this could be ordered like the following:
CPU A read FLAGS -> variable
CPU B read FLAGS -> variable
CPU A write FLAGS (variable | FLAG_1)
CPU B write FLAGS (variable | FLAG_2)
Notice how the 2nd write from CPU B could actually undo the write from CPU A because it isn't guaranteed that the |= operation is atomic.
In practice the race windows for most flag writes is incredibly narrow so it is not easy to isolate issues. However, the more flags we have, the more likely they will cause problems. Additionally, if such a problem were to arise, it would be incredibly difficult to track down.
Second, there is an additional advantage beyond code correctness. We can now automatically size the BITMAP if more flags were added, so that we do not need to remember that flags is u32 and thus if we added too many flags we would over-run the variable. This is not a likely occurrence for fm10k driver, but this patch can serve as an example for other drivers which have many more flags.
This particular change does have a bit of trouble converting some of the idioms previously used with the #defines for flags. Specifically, when converting FM10K_FLAG_RSS_FIELD_IPV[46]_UDP flags. This whole operation was actually quite problematic, because we actually stored flags separately. This could more easily show the problem of the above re-ordering issue.
This is really difficult to test whether atomics make a difference in practical scenarios, but you can ensure that basic functionality remains the same. This patch has a lot of code coverage, but most of it is relatively simple.
While we are modifying these files, update their copyright year.
---