batman-adv: Drop unmanaged ELP metric worker

[ Upstream commit 8c8ecc98f5c65947b0070a24bac11e12e47cc65d ]

The ELP worker needs to calculate new metric values for all neighbors
"reachable" over an interface. Some of the used metric sources require
locks which might need to sleep. This sleep is incompatible with the RCU
list iterator used for the recorded neighbors. The initial approach to work
around of this problem was to queue another work item per neighbor and then
run this in a new context.

Even when this solved the RCU vs might_sleep() conflict, it has a major
problems: Nothing was stopping the work item in case it is not needed
anymore - for example because one of the related interfaces was removed or
the batman-adv module was unloaded - resulting in potential invalid memory
accesses.

Directly canceling the metric worker also has various problems:

* cancel_work_sync for a to-be-deactivated interface is called with
  rtnl_lock held. But the code in the ELP metric worker also tries to use
  rtnl_lock() - which will never return in this case. This also means that
  cancel_work_sync would never return because it is waiting for the worker
  to finish.
* iterating over the neighbor list for the to-be-deactivated interface is
  currently done using the RCU specific methods. Which means that it is
  possible to miss items when iterating over it without the associated
  spinlock - a behaviour which is acceptable for a periodic metric check
  but not for a cleanup routine (which must "stop" all still running
  workers)

The better approch is to get rid of the per interface neighbor metric
worker and handle everything in the interface worker. The original problems
are solved by:

* creating a list of neighbors which require new metric information inside
  the RCU protected context, gathering the metric according to the new list
  outside the RCU protected context
* only use rcu_trylock inside metric gathering code to avoid a deadlock
  when the cancel_delayed_work_sync is called in the interface removal code
  (which is called with the rtnl_lock held)

Cc: stable@vger.kernel.org
Fixes: c833484e5f38 ("batman-adv: ELP - compute the metric based on the estimated throughput")
Signed-off-by: Sven Eckelmann <sven@narfation.org>
Signed-off-by: Simon Wunderlich <sw@simonwunderlich.de>
Signed-off-by: Sasha Levin <sashal@kernel.org>

diff --git a/net/batman-adv/bat_v.c b/net/batman-adv/bat_v.c
index e91d2c0720c4c83a862baf490030d79ee7c78ad2..6dc39fc0350e6aa419288ee762ca2403119ebc90 100644 (file)
--- a/net/batman-adv/bat_v.c
+++ b/net/batman-adv/bat_v.c
@@ -116,8 +116,6 @@ static void
 batadv_v_hardif_neigh_init(struct batadv_hardif_neigh_node *hardif_neigh)
 {
        ewma_throughput_init(&hardif_neigh->bat_v.throughput);
-       INIT_WORK(&hardif_neigh->bat_v.metric_work,
-                 batadv_v_elp_throughput_metric_update);
 }
 
 #ifdef CONFIG_BATMAN_ADV_DEBUGFS

diff --git a/net/batman-adv/bat_v_elp.c b/net/batman-adv/bat_v_elp.c
index 81b9dfec7151a98dd1fe823d8afa4431955454d5..eacf53161304a212ea7737cfb29f24ee80ed0364 100644 (file)
--- a/net/batman-adv/bat_v_elp.c
+++ b/net/batman-adv/bat_v_elp.c
@@ -18,6 +18,7 @@
 #include <linux/jiffies.h>
 #include <linux/kernel.h>
 #include <linux/kref.h>
+#include <linux/list.h>
 #include <linux/minmax.h>
 #include <linux/netdevice.h>
 #include <linux/nl80211.h>
@@ -27,6 +28,7 @@
 #include <linux/rcupdate.h>
 #include <linux/rtnetlink.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <linux/stddef.h>
 #include <linux/string.h>
 #include <linux/types.h>
@@ -42,6 +44,18 @@
 #include "routing.h"
 #include "send.h"
 
+/**
+ * struct batadv_v_metric_queue_entry - list of hardif neighbors which require
+ *  and metric update
+ */
+struct batadv_v_metric_queue_entry {
+       /** @hardif_neigh: hardif neighbor scheduled for metric update */
+       struct batadv_hardif_neigh_node *hardif_neigh;
+
+       /** @list: list node for metric_queue */
+       struct list_head list;
+};
+
 /**
  * batadv_v_elp_start_timer() - restart timer for ELP periodic work
  * @hard_iface: the interface for which the timer has to be reset
@@ -138,10 +152,17 @@ static bool batadv_v_elp_get_throughput(struct batadv_hardif_neigh_node *neigh,
                goto default_throughput;
        }
 
+       /* only use rtnl_trylock because the elp worker will be cancelled while
+        * the rntl_lock is held. the cancel_delayed_work_sync() would otherwise
+        * wait forever when the elp work_item was started and it is then also
+        * trying to rtnl_lock
+        */
+       if (!rtnl_trylock())
+               return false;
+
        /* if not a wifi interface, check if this device provides data via
         * ethtool (e.g. an Ethernet adapter)
         */
-       rtnl_lock();
        ret = __ethtool_get_link_ksettings(hard_iface->net_dev, &link_settings);
        rtnl_unlock();
        if (ret == 0) {
@@ -176,31 +197,19 @@ default_throughput:
 /**
  * batadv_v_elp_throughput_metric_update() - worker updating the throughput
  *  metric of a single hop neighbour
- * @work: the work queue item
+ * @neigh: the neighbour to probe
  */
-void batadv_v_elp_throughput_metric_update(struct work_struct *work)
+static void
+batadv_v_elp_throughput_metric_update(struct batadv_hardif_neigh_node *neigh)
 {
-       struct batadv_hardif_neigh_node_bat_v *neigh_bat_v;
-       struct batadv_hardif_neigh_node *neigh;
        u32 throughput;
        bool valid;
 
-       neigh_bat_v = container_of(work, struct batadv_hardif_neigh_node_bat_v,
-                                  metric_work);
-       neigh = container_of(neigh_bat_v, struct batadv_hardif_neigh_node,
-                            bat_v);
-
        valid = batadv_v_elp_get_throughput(neigh, &throughput);
        if (!valid)
-               goto put_neigh;
+               return;
 
        ewma_throughput_add(&neigh->bat_v.throughput, throughput);
-
-put_neigh:
-       /* decrement refcounter to balance increment performed before scheduling
-        * this task
-        */
-       batadv_hardif_neigh_put(neigh);
 }
 
 /**
@@ -274,14 +283,16 @@ batadv_v_elp_wifi_neigh_probe(struct batadv_hardif_neigh_node *neigh)
  */
 static void batadv_v_elp_periodic_work(struct work_struct *work)
 {
+       struct batadv_v_metric_queue_entry *metric_entry;
+       struct batadv_v_metric_queue_entry *metric_safe;
        struct batadv_hardif_neigh_node *hardif_neigh;
        struct batadv_hard_iface *hard_iface;
        struct batadv_hard_iface_bat_v *bat_v;
        struct batadv_elp_packet *elp_packet;
+       struct list_head metric_queue;
        struct batadv_priv *bat_priv;
        struct sk_buff *skb;
        u32 elp_interval;
-       bool ret;
 
        bat_v = container_of(work, struct batadv_hard_iface_bat_v, elp_wq.work);
        hard_iface = container_of(bat_v, struct batadv_hard_iface, bat_v);
@@ -317,6 +328,8 @@ static void batadv_v_elp_periodic_work(struct work_struct *work)
 
        atomic_inc(&hard_iface->bat_v.elp_seqno);
 
+       INIT_LIST_HEAD(&metric_queue);
+
        /* The throughput metric is updated on each sent packet. This way, if a
         * node is dead and no longer sends packets, batman-adv is still able to
         * react timely to its death.
@@ -341,16 +354,28 @@ static void batadv_v_elp_periodic_work(struct work_struct *work)
 
                /* Reading the estimated throughput from cfg80211 is a task that
                 * may sleep and that is not allowed in an rcu protected
-                * context. Therefore schedule a task for that.
+                * context. Therefore add it to metric_queue and process it
+                * outside rcu protected context.
                 */
-               ret = queue_work(batadv_event_workqueue,
-                                &hardif_neigh->bat_v.metric_work);
-
-               if (!ret)
+               metric_entry = kzalloc(sizeof(*metric_entry), GFP_ATOMIC);
+               if (!metric_entry) {
                        batadv_hardif_neigh_put(hardif_neigh);
+                       continue;
+               }
+
+               metric_entry->hardif_neigh = hardif_neigh;
+               list_add(&metric_entry->list, &metric_queue);
        }
        rcu_read_unlock();
 
+       list_for_each_entry_safe(metric_entry, metric_safe, &metric_queue, list) {
+               batadv_v_elp_throughput_metric_update(metric_entry->hardif_neigh);
+
+               batadv_hardif_neigh_put(metric_entry->hardif_neigh);
+               list_del(&metric_entry->list);
+               kfree(metric_entry);
+       }
+
 restart_timer:
        batadv_v_elp_start_timer(hard_iface);
 out:

diff --git a/net/batman-adv/bat_v_elp.h b/net/batman-adv/bat_v_elp.h
index 4358d436be2a809f14c436299fda65c8cffcc4d4..f814f87f3a6a43eee4b631679e61c8f54ad32073 100644 (file)
--- a/net/batman-adv/bat_v_elp.h
+++ b/net/batman-adv/bat_v_elp.h
@@ -10,7 +10,6 @@
 #include "main.h"
 
 #include <linux/skbuff.h>
-#include <linux/workqueue.h>
 
 int batadv_v_elp_iface_enable(struct batadv_hard_iface *hard_iface);
 void batadv_v_elp_iface_disable(struct batadv_hard_iface *hard_iface);
@@ -19,6 +18,5 @@ void batadv_v_elp_iface_activate(struct batadv_hard_iface *primary_iface,
 void batadv_v_elp_primary_iface_set(struct batadv_hard_iface *primary_iface);
 int batadv_v_elp_packet_recv(struct sk_buff *skb,
                             struct batadv_hard_iface *if_incoming);
-void batadv_v_elp_throughput_metric_update(struct work_struct *work);
 
 #endif /* _NET_BATMAN_ADV_BAT_V_ELP_H_ */

diff --git a/net/batman-adv/types.h b/net/batman-adv/types.h
index 7d47fe7534c184f36f396167bc3896120e9da6f0..cc3334afbdd05506aa5660b4d151c862cd74a42e 100644 (file)
--- a/net/batman-adv/types.h
+++ b/net/batman-adv/types.h
@@ -606,9 +606,6 @@ struct batadv_hardif_neigh_node_bat_v {
         *  neighbor
         */
        unsigned long last_unicast_tx;
-
-       /** @metric_work: work queue callback item for metric update */
-       struct work_struct metric_work;
 };
 
 /**