Skip to content

Commit ebda2f0

Browse files
kuba-mookuba-moo
committed
net: add netdev_lock() / netdev_unlock() helpers
Add helpers for locking the netdev instance, use it in drivers and the shaper code. This will make grepping for the lock usage much easier, as we extend the lock to cover more fields. Reviewed-by: Joe Damato <[email protected]> Reviewed-by: Eric Dumazet <[email protected]> Reviewed-by: Kuniyuki Iwashima <[email protected]> Reviewed-by: Przemek Kitszel <[email protected]> Link: https://patch.msgid.link/[email protected] Signed-off-by: Jakub Kicinski <[email protected]>
1 parent 0b6f659 commit ebda2f0

File tree

4 files changed

+63
-44
lines changed

4 files changed

+63
-44
lines changed

‎drivers/net/ethernet/intel/iavf/iavf_main.c‎

Lines changed: 37 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -1977,7 +1977,7 @@ static void iavf_finish_config(struct work_struct *work)
19771977
* The dev->lock is needed to update the queue number
19781978
*/
19791979
rtnl_lock();
1980-
mutex_lock(&adapter->netdev->lock);
1980+
netdev_lock(adapter->netdev);
19811981
mutex_lock(&adapter->crit_lock);
19821982

19831983
if ((adapter->flags & IAVF_FLAG_SETUP_NETDEV_FEATURES) &&
@@ -1997,7 +1997,7 @@ static void iavf_finish_config(struct work_struct *work)
19971997
netif_set_real_num_tx_queues(adapter->netdev, pairs);
19981998

19991999
if (adapter->netdev->reg_state != NETREG_REGISTERED) {
2000-
mutex_unlock(&adapter->netdev->lock);
2000+
netdev_unlock(adapter->netdev);
20012001
netdev_released = true;
20022002
err = register_netdevice(adapter->netdev);
20032003
if (err) {
@@ -2027,7 +2027,7 @@ static void iavf_finish_config(struct work_struct *work)
20272027
out:
20282028
mutex_unlock(&adapter->crit_lock);
20292029
if (!netdev_released)
2030-
mutex_unlock(&adapter->netdev->lock);
2030+
netdev_unlock(adapter->netdev);
20312031
rtnl_unlock();
20322032
}
20332033

@@ -2724,10 +2724,10 @@ static void iavf_watchdog_task(struct work_struct *work)
27242724
struct iavf_hw *hw = &adapter->hw;
27252725
u32 reg_val;
27262726

2727-
mutex_lock(&netdev->lock);
2727+
netdev_lock(netdev);
27282728
if (!mutex_trylock(&adapter->crit_lock)) {
27292729
if (adapter->state == __IAVF_REMOVE) {
2730-
mutex_unlock(&netdev->lock);
2730+
netdev_unlock(netdev);
27312731
return;
27322732
}
27332733

@@ -2741,35 +2741,35 @@ static void iavf_watchdog_task(struct work_struct *work)
27412741
case __IAVF_STARTUP:
27422742
iavf_startup(adapter);
27432743
mutex_unlock(&adapter->crit_lock);
2744-
mutex_unlock(&netdev->lock);
2744+
netdev_unlock(netdev);
27452745
queue_delayed_work(adapter->wq, &adapter->watchdog_task,
27462746
msecs_to_jiffies(30));
27472747
return;
27482748
case __IAVF_INIT_VERSION_CHECK:
27492749
iavf_init_version_check(adapter);
27502750
mutex_unlock(&adapter->crit_lock);
2751-
mutex_unlock(&netdev->lock);
2751+
netdev_unlock(netdev);
27522752
queue_delayed_work(adapter->wq, &adapter->watchdog_task,
27532753
msecs_to_jiffies(30));
27542754
return;
27552755
case __IAVF_INIT_GET_RESOURCES:
27562756
iavf_init_get_resources(adapter);
27572757
mutex_unlock(&adapter->crit_lock);
2758-
mutex_unlock(&netdev->lock);
2758+
netdev_unlock(netdev);
27592759
queue_delayed_work(adapter->wq, &adapter->watchdog_task,
27602760
msecs_to_jiffies(1));
27612761
return;
27622762
case __IAVF_INIT_EXTENDED_CAPS:
27632763
iavf_init_process_extended_caps(adapter);
27642764
mutex_unlock(&adapter->crit_lock);
2765-
mutex_unlock(&netdev->lock);
2765+
netdev_unlock(netdev);
27662766
queue_delayed_work(adapter->wq, &adapter->watchdog_task,
27672767
msecs_to_jiffies(1));
27682768
return;
27692769
case __IAVF_INIT_CONFIG_ADAPTER:
27702770
iavf_init_config_adapter(adapter);
27712771
mutex_unlock(&adapter->crit_lock);
2772-
mutex_unlock(&netdev->lock);
2772+
netdev_unlock(netdev);
27732773
queue_delayed_work(adapter->wq, &adapter->watchdog_task,
27742774
msecs_to_jiffies(1));
27752775
return;
@@ -2781,7 +2781,7 @@ static void iavf_watchdog_task(struct work_struct *work)
27812781
* as it can loop forever
27822782
*/
27832783
mutex_unlock(&adapter->crit_lock);
2784-
mutex_unlock(&netdev->lock);
2784+
netdev_unlock(netdev);
27852785
return;
27862786
}
27872787
if (++adapter->aq_wait_count > IAVF_AQ_MAX_ERR) {
@@ -2790,15 +2790,15 @@ static void iavf_watchdog_task(struct work_struct *work)
27902790
adapter->flags |= IAVF_FLAG_PF_COMMS_FAILED;
27912791
iavf_shutdown_adminq(hw);
27922792
mutex_unlock(&adapter->crit_lock);
2793-
mutex_unlock(&netdev->lock);
2793+
netdev_unlock(netdev);
27942794
queue_delayed_work(adapter->wq,
27952795
&adapter->watchdog_task, (5 * HZ));
27962796
return;
27972797
}
27982798
/* Try again from failed step*/
27992799
iavf_change_state(adapter, adapter->last_state);
28002800
mutex_unlock(&adapter->crit_lock);
2801-
mutex_unlock(&netdev->lock);
2801+
netdev_unlock(netdev);
28022802
queue_delayed_work(adapter->wq, &adapter->watchdog_task, HZ);
28032803
return;
28042804
case __IAVF_COMM_FAILED:
@@ -2811,7 +2811,7 @@ static void iavf_watchdog_task(struct work_struct *work)
28112811
iavf_change_state(adapter, __IAVF_INIT_FAILED);
28122812
adapter->flags &= ~IAVF_FLAG_PF_COMMS_FAILED;
28132813
mutex_unlock(&adapter->crit_lock);
2814-
mutex_unlock(&netdev->lock);
2814+
netdev_unlock(netdev);
28152815
return;
28162816
}
28172817
reg_val = rd32(hw, IAVF_VFGEN_RSTAT) &
@@ -2831,14 +2831,14 @@ static void iavf_watchdog_task(struct work_struct *work)
28312831
adapter->aq_required = 0;
28322832
adapter->current_op = VIRTCHNL_OP_UNKNOWN;
28332833
mutex_unlock(&adapter->crit_lock);
2834-
mutex_unlock(&netdev->lock);
2834+
netdev_unlock(netdev);
28352835
queue_delayed_work(adapter->wq,
28362836
&adapter->watchdog_task,
28372837
msecs_to_jiffies(10));
28382838
return;
28392839
case __IAVF_RESETTING:
28402840
mutex_unlock(&adapter->crit_lock);
2841-
mutex_unlock(&netdev->lock);
2841+
netdev_unlock(netdev);
28422842
queue_delayed_work(adapter->wq, &adapter->watchdog_task,
28432843
HZ * 2);
28442844
return;
@@ -2869,7 +2869,7 @@ static void iavf_watchdog_task(struct work_struct *work)
28692869
case __IAVF_REMOVE:
28702870
default:
28712871
mutex_unlock(&adapter->crit_lock);
2872-
mutex_unlock(&netdev->lock);
2872+
netdev_unlock(netdev);
28732873
return;
28742874
}
28752875

@@ -2881,14 +2881,14 @@ static void iavf_watchdog_task(struct work_struct *work)
28812881
dev_err(&adapter->pdev->dev, "Hardware reset detected\n");
28822882
iavf_schedule_reset(adapter, IAVF_FLAG_RESET_PENDING);
28832883
mutex_unlock(&adapter->crit_lock);
2884-
mutex_unlock(&netdev->lock);
2884+
netdev_unlock(netdev);
28852885
queue_delayed_work(adapter->wq,
28862886
&adapter->watchdog_task, HZ * 2);
28872887
return;
28882888
}
28892889

28902890
mutex_unlock(&adapter->crit_lock);
2891-
mutex_unlock(&netdev->lock);
2891+
netdev_unlock(netdev);
28922892
restart_watchdog:
28932893
if (adapter->state >= __IAVF_DOWN)
28942894
queue_work(adapter->wq, &adapter->adminq_task);
@@ -3015,12 +3015,12 @@ static void iavf_reset_task(struct work_struct *work)
30153015
/* When device is being removed it doesn't make sense to run the reset
30163016
* task, just return in such a case.
30173017
*/
3018-
mutex_lock(&netdev->lock);
3018+
netdev_lock(netdev);
30193019
if (!mutex_trylock(&adapter->crit_lock)) {
30203020
if (adapter->state != __IAVF_REMOVE)
30213021
queue_work(adapter->wq, &adapter->reset_task);
30223022

3023-
mutex_unlock(&netdev->lock);
3023+
netdev_unlock(netdev);
30243024
return;
30253025
}
30263026

@@ -3068,7 +3068,7 @@ static void iavf_reset_task(struct work_struct *work)
30683068
reg_val);
30693069
iavf_disable_vf(adapter);
30703070
mutex_unlock(&adapter->crit_lock);
3071-
mutex_unlock(&netdev->lock);
3071+
netdev_unlock(netdev);
30723072
return; /* Do not attempt to reinit. It's dead, Jim. */
30733073
}
30743074

@@ -3209,7 +3209,7 @@ static void iavf_reset_task(struct work_struct *work)
32093209

32103210
wake_up(&adapter->reset_waitqueue);
32113211
mutex_unlock(&adapter->crit_lock);
3212-
mutex_unlock(&netdev->lock);
3212+
netdev_unlock(netdev);
32133213

32143214
return;
32153215
reset_err:
@@ -3220,7 +3220,7 @@ static void iavf_reset_task(struct work_struct *work)
32203220
iavf_disable_vf(adapter);
32213221

32223222
mutex_unlock(&adapter->crit_lock);
3223-
mutex_unlock(&netdev->lock);
3223+
netdev_unlock(netdev);
32243224
dev_err(&adapter->pdev->dev, "failed to allocate resources during reinit\n");
32253225
}
32263226

@@ -3692,10 +3692,10 @@ static int __iavf_setup_tc(struct net_device *netdev, void *type_data)
36923692
if (test_bit(__IAVF_IN_REMOVE_TASK, &adapter->crit_section))
36933693
return 0;
36943694

3695-
mutex_lock(&netdev->lock);
3695+
netdev_lock(netdev);
36963696
netif_set_real_num_rx_queues(netdev, total_qps);
36973697
netif_set_real_num_tx_queues(netdev, total_qps);
3698-
mutex_unlock(&netdev->lock);
3698+
netdev_unlock(netdev);
36993699

37003700
return ret;
37013701
}
@@ -4365,15 +4365,15 @@ static int iavf_open(struct net_device *netdev)
43654365
return -EIO;
43664366
}
43674367

4368-
mutex_lock(&netdev->lock);
4368+
netdev_lock(netdev);
43694369
while (!mutex_trylock(&adapter->crit_lock)) {
43704370
/* If we are in __IAVF_INIT_CONFIG_ADAPTER state the crit_lock
43714371
* is already taken and iavf_open is called from an upper
43724372
* device's notifier reacting on NETDEV_REGISTER event.
43734373
* We have to leave here to avoid dead lock.
43744374
*/
43754375
if (adapter->state == __IAVF_INIT_CONFIG_ADAPTER) {
4376-
mutex_unlock(&netdev->lock);
4376+
netdev_unlock(netdev);
43774377
return -EBUSY;
43784378
}
43794379

@@ -4424,7 +4424,7 @@ static int iavf_open(struct net_device *netdev)
44244424
iavf_irq_enable(adapter, true);
44254425

44264426
mutex_unlock(&adapter->crit_lock);
4427-
mutex_unlock(&netdev->lock);
4427+
netdev_unlock(netdev);
44284428

44294429
return 0;
44304430

@@ -4437,7 +4437,7 @@ static int iavf_open(struct net_device *netdev)
44374437
iavf_free_all_tx_resources(adapter);
44384438
err_unlock:
44394439
mutex_unlock(&adapter->crit_lock);
4440-
mutex_unlock(&netdev->lock);
4440+
netdev_unlock(netdev);
44414441

44424442
return err;
44434443
}
@@ -4459,12 +4459,12 @@ static int iavf_close(struct net_device *netdev)
44594459
u64 aq_to_restore;
44604460
int status;
44614461

4462-
mutex_lock(&netdev->lock);
4462+
netdev_lock(netdev);
44634463
mutex_lock(&adapter->crit_lock);
44644464

44654465
if (adapter->state <= __IAVF_DOWN_PENDING) {
44664466
mutex_unlock(&adapter->crit_lock);
4467-
mutex_unlock(&netdev->lock);
4467+
netdev_unlock(netdev);
44684468
return 0;
44694469
}
44704470

@@ -4498,7 +4498,7 @@ static int iavf_close(struct net_device *netdev)
44984498
iavf_free_traffic_irqs(adapter);
44994499

45004500
mutex_unlock(&adapter->crit_lock);
4501-
mutex_unlock(&netdev->lock);
4501+
netdev_unlock(netdev);
45024502

45034503
/* We explicitly don't free resources here because the hardware is
45044504
* still active and can DMA into memory. Resources are cleared in
@@ -5375,7 +5375,7 @@ static int iavf_suspend(struct device *dev_d)
53755375

53765376
netif_device_detach(netdev);
53775377

5378-
mutex_lock(&netdev->lock);
5378+
netdev_lock(netdev);
53795379
mutex_lock(&adapter->crit_lock);
53805380

53815381
if (netif_running(netdev)) {
@@ -5387,7 +5387,7 @@ static int iavf_suspend(struct device *dev_d)
53875387
iavf_reset_interrupt_capability(adapter);
53885388

53895389
mutex_unlock(&adapter->crit_lock);
5390-
mutex_unlock(&netdev->lock);
5390+
netdev_unlock(netdev);
53915391

53925392
return 0;
53935393
}
@@ -5486,7 +5486,7 @@ static void iavf_remove(struct pci_dev *pdev)
54865486
if (netdev->reg_state == NETREG_REGISTERED)
54875487
unregister_netdev(netdev);
54885488

5489-
mutex_lock(&netdev->lock);
5489+
netdev_lock(netdev);
54905490
mutex_lock(&adapter->crit_lock);
54915491
dev_info(&adapter->pdev->dev, "Removing device\n");
54925492
iavf_change_state(adapter, __IAVF_REMOVE);
@@ -5523,7 +5523,7 @@ static void iavf_remove(struct pci_dev *pdev)
55235523
mutex_destroy(&hw->aq.asq_mutex);
55245524
mutex_unlock(&adapter->crit_lock);
55255525
mutex_destroy(&adapter->crit_lock);
5526-
mutex_unlock(&netdev->lock);
5526+
netdev_unlock(netdev);
55275527

55285528
iounmap(hw->hw_addr);
55295529
pci_release_regions(pdev);

‎drivers/net/netdevsim/ethtool.c‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -108,10 +108,10 @@ nsim_set_channels(struct net_device *dev, struct ethtool_channels *ch)
108108
struct netdevsim *ns = netdev_priv(dev);
109109
int err;
110110

111-
mutex_lock(&dev->lock);
111+
netdev_lock(dev);
112112
err = netif_set_real_num_queues(dev, ch->combined_count,
113113
ch->combined_count);
114-
mutex_unlock(&dev->lock);
114+
netdev_unlock(dev);
115115
if (err)
116116
return err;
117117

‎include/linux/netdevice.h‎

Lines changed: 21 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2444,8 +2444,12 @@ struct net_device {
24442444
u32 napi_defer_hard_irqs;
24452445

24462446
/**
2447-
* @lock: protects @net_shaper_hierarchy, feel free to use for other
2448-
* netdev-scope protection. Ordering: take after rtnl_lock.
2447+
* @lock: netdev-scope lock, protects a small selection of fields.
2448+
* Should always be taken using netdev_lock() / netdev_unlock() helpers.
2449+
* Drivers are free to use it for other protection.
2450+
*
2451+
* Protects: @net_shaper_hierarchy.
2452+
* Ordering: take after rtnl_lock.
24492453
*/
24502454
struct mutex lock;
24512455

@@ -2671,6 +2675,21 @@ void netif_queue_set_napi(struct net_device *dev, unsigned int queue_index,
26712675
enum netdev_queue_type type,
26722676
struct napi_struct *napi);
26732677

2678+
static inline void netdev_lock(struct net_device *dev)
2679+
{
2680+
mutex_lock(&dev->lock);
2681+
}
2682+
2683+
static inline void netdev_unlock(struct net_device *dev)
2684+
{
2685+
mutex_unlock(&dev->lock);
2686+
}
2687+
2688+
static inline void netdev_assert_locked(struct net_device *dev)
2689+
{
2690+
lockdep_assert_held(&dev->lock);
2691+
}
2692+
26742693
static inline void netif_napi_set_irq(struct napi_struct *napi, int irq)
26752694
{
26762695
napi->irq = irq;

‎net/shaper/shaper.c‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -40,7 +40,7 @@ static void net_shaper_lock(struct net_shaper_binding *binding)
4040
{
4141
switch (binding->type) {
4242
case NET_SHAPER_BINDING_TYPE_NETDEV:
43-
mutex_lock(&binding->netdev->lock);
43+
netdev_lock(binding->netdev);
4444
break;
4545
}
4646
}
@@ -49,7 +49,7 @@ static void net_shaper_unlock(struct net_shaper_binding *binding)
4949
{
5050
switch (binding->type) {
5151
case NET_SHAPER_BINDING_TYPE_NETDEV:
52-
mutex_unlock(&binding->netdev->lock);
52+
netdev_unlock(binding->netdev);
5353
break;
5454
}
5555
}
@@ -1398,7 +1398,7 @@ void net_shaper_set_real_num_tx_queues(struct net_device *dev,
13981398
/* Only drivers implementing shapers support ensure
13991399
* the lock is acquired in advance.
14001400
*/
1401-
lockdep_assert_held(&dev->lock);
1401+
netdev_assert_locked(dev);
14021402

14031403
/* Take action only when decreasing the tx queue number. */
14041404
for (i = txq; i < dev->real_num_tx_queues; ++i) {

0 commit comments

Comments
 (0)