From: Jacob Keller <>

[ Upstream commit aaebaf50b502648b1d4d8c93b4be133944c2bbd0 ]

Hardware related to the ixgbe driver is limited to handling a single Tx
timestamp request at a time. Thus, the driver ignores requests for Tx
timestamp while waiting for the current request to finish. It uses
a state bit lock which enforces that only one timestamp request is
honored at a time.

Unfortunately this suffers from a simple race condition. The bit lock is
not cleared until after skb_tstamp_tx() is called notifying applications
of a new Tx timestamp. Even a well behaved application sending only one
packet at a time and waiting for a response can wake up and send a new
packet before the bit lock is cleared. This results in needlessly
dropping some Tx timestamp requests.

We can fix this by unlocking the state bit as soon as we read the
Timestamp register, as this is the first point at which it is safe to

To avoid issues with the skb pointer, we'll use a copy of the pointer
and set the global variable in the driver structure to NULL first. This
ensures that the next timestamp request does not modify our local copy
of the skb pointer.

This ensures that well behaved applications do not accidentally race
with the unlock bit. Obviously an application which sends multiple Tx
timestamp requests at once will still only timestamp one packet at
a time. Unfortunately there is nothing we can do about this.

Reported-by: David Mirabito <>
Signed-off-by: Jacob Keller <>
Tested-by: Andrew Bowers <>
Signed-off-by: Jeff Kirsher <>
Signed-off-by: Sasha Levin <>
 drivers/net/ethernet/intel/ixgbe/ixgbe_ptp.c | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_ptp.c 
index a92277683a64..079fe5ecb39c 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_ptp.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_ptp.c
@@ -672,17 +672,26 @@ static void ixgbe_ptp_clear_tx_timestamp(struct 
ixgbe_adapter *adapter)
 static void ixgbe_ptp_tx_hwtstamp(struct ixgbe_adapter *adapter)
+       struct sk_buff *skb = adapter->ptp_tx_skb;
        struct ixgbe_hw *hw = &adapter->hw;
        struct skb_shared_hwtstamps shhwtstamps;
        u64 regval = 0;
        regval |= (u64)IXGBE_READ_REG(hw, IXGBE_TXSTMPL);
        regval |= (u64)IXGBE_READ_REG(hw, IXGBE_TXSTMPH) << 32;
        ixgbe_ptp_convert_to_hwtstamp(adapter, &shhwtstamps, regval);
-       skb_tstamp_tx(adapter->ptp_tx_skb, &shhwtstamps);
-       ixgbe_ptp_clear_tx_timestamp(adapter);
+       /* Handle cleanup of the ptp_tx_skb ourselves, and unlock the state
+        * bit prior to notifying the stack via skb_tstamp_tx(). This prevents
+        * well behaved applications from attempting to timestamp again prior
+        * to the lock bit being clear.
+        */
+       adapter->ptp_tx_skb = NULL;
+       clear_bit_unlock(__IXGBE_PTP_TX_IN_PROGRESS, &adapter->state);
+       /* Notify the stack and then free the skb after we've unlocked */
+       skb_tstamp_tx(skb, &shhwtstamps);
+       dev_kfree_skb_any(skb);

Reply via email to