net-sysfs: fix race conditions in the xps code
Subsystems (2)
v3 cover net-sysfs: fix race conditions in the xps code
Hello all,
This series fixes race conditions in the xps code, where out of bound accesses can occur when dev->num_tc is updated, triggering oops. The root cause is linked to locking issues. An explanation is given in each of the commit logs.
We had a discussion on the v1 of this series about using the xps_map mutex instead of the rtnl lock. While that seemed a better compromise, v2 showed the added complexity wasn't best for fixes. So we decided to go back to v1 and use the rtnl lock.
Because of this, the only differences between v1 and v3 are improvements in the commit messages.
Thanks!
Antoine
Antoine Tenart (4):
net-sysfs: take the rtnl lock when storing xps_cpus
net-sysfs: take the rtnl lock when accessing xps_cpus_map and num_tc
net-sysfs: take the rtnl lock when storing xps_rxqs
net-sysfs: take the rtnl lock when accessing xps_rxqs_map and num_tc
net/core/net-sysfs.c | 65 ++++++++++++++++++++++++++++++++++++-------- 1 file changed, 53 insertions(+), 12 deletions(-)
Signature · 1 line
2.29.2
PATCH v3 1/4 net-sysfs: take the rtnl lock when storing xps_cpus
Two race conditions can be triggered when storing xps cpus, resulting in various oops and invalid memory accesses:
1. Calling netdev_set_num_tc while netif_set_xps_queue:
- netif_set_xps_queue uses dev->tc_num as one of the parameters to compute the size of new_dev_maps when allocating it. dev->tc_num is also used to access the map, and the compiler may generate code to retrieve this field multiple times in the function.
- netdev_set_num_tc sets dev->tc_num.
If new_dev_maps is allocated using dev->tc_num and then dev->tc_num is set to a higher value through netdev_set_num_tc, later accesses to new_dev_maps in netif_set_xps_queue could lead to accessing memory outside of new_dev_maps; triggering an oops.
2. Calling netif_set_xps_queue while netdev_set_num_tc is running:
2.1. netdev_set_num_tc starts by resetting the xps queues,
dev->tc_num isn't updated yet.
2.2. netif_set_xps_queue is called, setting up the map with the
*old* dev->num_tc.
2.3. netdev_set_num_tc updates dev->tc_num.
2.4. Later accesses to the map lead to out of bound accesses and
oops.
A similar issue can be found with netdev_reset_tc.
One way of triggering this is to set an iface up (for which the driver uses netdev_set_num_tc in the open path, such as bnx2x) and writing to xps_cpus in a concurrent thread. With the right timing an oops is triggered.
Both issues have the same fix: netif_set_xps_queue, netdev_set_num_tc and netdev_reset_tc should be mutually exclusive. We do that by taking the rtnl lock in xps_cpus_store.
--- net/core/net-sysfs.c | 6 ++++++ 1 file changed, 6 insertions(+)
net/core/net-sysfs.c +6 -0
@@ -1396,7 +1396,13 @@ static ssize_t xps_cpus_store(struct netdev_queue *queue,return err; } +if (!rtnl_trylock ()) { +free_cpumask_var (mask); +return restart_syscall (); + } + err =netif_set_xps_queue (dev, mask, index); +rtnl_unlock ();free_cpumask_var (mask);
Signature · 1 line
2.29.2
PATCH v3 2/4 net-sysfs: take the rtnl lock when accessing xps_cpus_map and num_tc
In reply to Antoine TenartAccesses to dev->xps_cpus_map (when using dev->num_tc) should be protected by the rtnl lock, like we do for netif_set_xps_queue. I didn't see an actual bug being triggered, but let's be safe here and take the rtnl lock while accessing the map in sysfs.
--- net/core/net-sysfs.c | 29 ++++++++++++++++++++++------- 1 file changed, 22 insertions(+), 7 deletions(-)
net/core/net-sysfs.c +22 -7
@@ -1317,8 +1317,8 @@ static const struct attribute_group dql_group = {static ssize_t xps_cpus_show (struct netdev_queue *queue,char *buf) { +int cpu, len, ret, num_tc =1 , tc =0 ;struct net_device *dev = queue->dev; -int cpu, len, num_tc =1 , tc =0 ;struct xps_dev_maps *dev_maps;cpumask_var_t mask;unsigned long index;
@@ -1328,22 +1328,31 @@ static ssize_t xps_cpus_show(struct netdev_queue *queue, index =get_netdev_queue_index (queue); +if (!rtnl_trylock ()) +return restart_syscall (); +if (dev->num_tc) {/* Do not allow XPS on subordinate device directly */ num_tc = dev->num_tc; -if (num_tc <0 ) -return -EINVAL ; +if (num_tc <0 ) { + ret = -EINVAL ; + goto err_rtnl_unlock; + }/* If queue belongs to subordinate dev use its map */ dev =netdev_get_tx_queue (dev, index)->sb_dev ? : dev; tc =netdev_txq_to_tc (dev, index); -if (tc <0 ) -return -EINVAL ; +if (tc <0 ) { + ret = -EINVAL ; + goto err_rtnl_unlock; + } } -if (!zalloc_cpumask_var (&mask,GFP_KERNEL )) -return -ENOMEM ; +if (!zalloc_cpumask_var (&mask,GFP_KERNEL )) { + ret = -ENOMEM ; + goto err_rtnl_unlock; + }rcu_read_lock (); dev_maps =rcu_dereference (dev->xps_cpus_map);
@@ -1366,9 +1375,15 @@ static ssize_t xps_cpus_show(struct netdev_queue *queue, }rcu_read_unlock (); +rtnl_unlock (); + len =snprintf (buf,PAGE_SIZE ,"%*pb\n" ,cpumask_pr_args (mask));free_cpumask_var (mask);return len <PAGE_SIZE ? len : -EINVAL ; + +err_rtnl_unlock: +rtnl_unlock (); +return ret; } static ssize_t xps_cpus_store(struct netdev_queue *queue,
Signature · 1 line
2.29.2
PATCH v3 3/4 net-sysfs: take the rtnl lock when storing xps_rxqs
In reply to Antoine TenartTwo race conditions can be triggered when storing xps rxqs, resulting in various oops and invalid memory accesses:
1. Calling netdev_set_num_tc while netif_set_xps_queue:
- netif_set_xps_queue uses dev->tc_num as one of the parameters to compute the size of new_dev_maps when allocating it. dev->tc_num is also used to access the map, and the compiler may generate code to retrieve this field multiple times in the function.
- netdev_set_num_tc sets dev->tc_num.
If new_dev_maps is allocated using dev->tc_num and then dev->tc_num is set to a higher value through netdev_set_num_tc, later accesses to new_dev_maps in netif_set_xps_queue could lead to accessing memory outside of new_dev_maps; triggering an oops.
2. Calling netif_set_xps_queue while netdev_set_num_tc is running:
2.1. netdev_set_num_tc starts by resetting the xps queues,
dev->tc_num isn't updated yet.
2.2. netif_set_xps_queue is called, setting up the map with the
*old* dev->num_tc.
2.3. netdev_set_num_tc updates dev->tc_num.
2.4. Later accesses to the map lead to out of bound accesses and
oops.
A similar issue can be found with netdev_reset_tc.
One way of triggering this is to set an iface up (for which the driver uses netdev_set_num_tc in the open path, such as bnx2x) and writing to xps_rxqs in a concurrent thread. With the right timing an oops is triggered.
Both issues have the same fix: netif_set_xps_queue, netdev_set_num_tc and netdev_reset_tc should be mutually exclusive. We do that by taking the rtnl lock in xps_rxqs_store.
--- net/core/net-sysfs.c | 7 +++++++ 1 file changed, 7 insertions(+)
net/core/net-sysfs.c +7 -0
@@ -1499,10 +1499,17 @@ static ssize_t xps_rxqs_store(struct netdev_queue *queue, const char *buf,return err; } +if (!rtnl_trylock ()) { +bitmap_free (mask); +return restart_syscall (); + } +cpus_read_lock (); err =__netif_set_xps_queue (dev, mask, index, true);cpus_read_unlock (); +rtnl_unlock (); +bitmap_free (mask);return err ? : len; }
Signature · 1 line
2.29.2
PATCH v3 4/4 net-sysfs: take the rtnl lock when accessing xps_rxqs_map and num_tc
In reply to Antoine TenartAccesses to dev->xps_rxqs_map (when using dev->num_tc) should be protected by the rtnl lock, like we do for netif_set_xps_queue. I didn't see an actual bug being triggered, but let's be safe here and take the rtnl lock while accessing the map in sysfs.
--- net/core/net-sysfs.c | 23 ++++++++++++++++++----- 1 file changed, 18 insertions(+), 5 deletions(-)
net/core/net-sysfs.c +18 -5
@@ -1429,22 +1429,29 @@ static struct netdev_queue_attribute xps_cpus_attribute __ro_after_initstatic ssize_t xps_rxqs_show (struct netdev_queue *queue,char *buf) { +int j, len, ret, num_tc =1 , tc =0 ;struct net_device *dev = queue->dev;struct xps_dev_maps *dev_maps;unsigned long *mask, index; -int j, len, num_tc =1 , tc =0 ; index =get_netdev_queue_index (queue); +if (!rtnl_trylock ()) +return restart_syscall (); +if (dev->num_tc) { num_tc = dev->num_tc; tc =netdev_txq_to_tc (dev, index); -if (tc <0 ) -return -EINVAL ; +if (tc <0 ) { + ret = -EINVAL ; + goto err_rtnl_unlock; + } } mask =bitmap_zalloc (dev->num_rx_queues,GFP_KERNEL ); -if (!mask) -return -ENOMEM ; +if (!mask) { + ret = -ENOMEM ; + goto err_rtnl_unlock; + }rcu_read_lock (); dev_maps =rcu_dereference (dev->xps_rxqs_map);
@@ -1470,10 +1477,16 @@ static ssize_t xps_rxqs_show(struct netdev_queue *queue, char *buf) out_no_maps:rcu_read_unlock (); +rtnl_unlock (); + len =bitmap_print_to_pagebuf (false, buf, mask, dev->num_rx_queues);bitmap_free (mask);return len <PAGE_SIZE ? len : -EINVAL ; + +err_rtnl_unlock: +rtnl_unlock (); +return ret; } static ssize_t xps_rxqs_store(struct netdev_queue *queue, const char *buf,
Signature · 1 line
2.29.2
Quoted 19 lines · Antoine Tenart
Hello all,
This series fixes race conditions in the xps code, where out of bound accesses can occur when
dev->num_tcis updated, triggering oops. The root cause is linked to locking issues. An explanation is given in each of the commit logs.We had a discussion on the v1 of this series about using the
xps_mapmutex instead of the rtnl lock. While that seemed a better compromise, v2 showed the added complexity wasn't best for fixes. So we decided to go back to v1 and use the rtnl lock.Because of this, the only differences between v1 and v3 are improvements in the commit messages.
Thanks!
Antoine
Quoted 9 lines
Antoine Tenart (4):
net-sysfs: take the rtnl lock when storingxps_cpus
net-sysfs: take the rtnl lock when accessingxps_cpus_mapandnum_tc
net-sysfs: take the rtnl lock when storingxps_rxqs
net-sysfs: take the rtnl lock when accessingxps_rxqs_mapandnum_tcnet/core/net-sysfs.c | 65 ++++++++++++++++++++++++++++++++++++-------- 1 file changed, 53 insertions(+), 12 deletions(-)
The series looks fine to me. Not the prettiest in the case of showing the maps, but I don't think much can be done about that since we have to return an error type and release the rtnl_lock.
Quoted 30 lines · On Wed, 23 Dec 2020 15:26:08 -0800 Alexander Duyck wrote:
Quoted 19 lines · Antoine Tenart
Hello all,
This series fixes race conditions in the xps code, where out of bound accesses can occur when
dev->num_tcis updated, triggering oops. The root cause is linked to locking issues. An explanation is given in each of the commit logs.We had a discussion on the v1 of this series about using the
xps_mapmutex instead of the rtnl lock. While that seemed a better compromise, v2 showed the added complexity wasn't best for fixes. So we decided to go back to v1 and use the rtnl lock.Because of this, the only differences between v1 and v3 are improvements in the commit messages.
Thanks!
AntoineQuoted 9 lines
Antoine Tenart (4):
net-sysfs: take the rtnl lock when storingxps_cpus
net-sysfs: take the rtnl lock when accessingxps_cpus_mapandnum_tc
net-sysfs: take the rtnl lock when storingxps_rxqs
net-sysfs: take the rtnl lock when accessingxps_rxqs_mapandnum_tcnet/core/net-sysfs.c | 65 ++++++++++++++++++++++++++++++++++++-------- 1 file changed, 53 insertions(+), 12 deletions(-)
Quoted 5 lines
The series looks fine to me. Not the prettiest in the case of showing the maps, but I don't think much can be done about that since we have to return an error type and release the
rtnl_lock.Reviewed-by Alexander Duyck <[email protected]>
Applied, thanks!