[batman-adv] master: Merge branch 'maint' (888f60e5) - commits - lists.open-mesh.org

11 Oct 2019

Repository : ssh://git@open-mesh.org/batman-adv
On branch  : master
...

commit 888f60e567994e4d11058d14c59a5275942f4a78
Merge: ab636a2b 9b8ceef2
Author: Sven Eckelmann sven@narfation.org
Date:   Fri Oct 11 14:49:29 2019 +0200
Merge branch 'maint'
...

888f60e567994e4d11058d14c59a5275942f4a78
 net/batman-adv/bat_iv_ogm.c | 33 +++++++++++++++++++++++++++------
 net/batman-adv/bat_v_ogm.c  | 32 +++++++++++++++++++++++++-------
 net/batman-adv/types.h      |  8 ++++----
 3 files changed, 56 insertions(+), 17 deletions(-)
diff --cc net/batman-adv/bat_v_ogm.c
index dc4f7430,034bdc5e..24d00a97

--- a/net/batman-adv/bat_v_ogm.c
+++ b/net/batman-adv/bat_v_ogm.c
@@@ -22,9 -21,9 +22,10 @@@
  #include <linux/random.h>
  #include <linux/rculist.h>
  #include <linux/rcupdate.h>
+ #include <linux/rtnetlink.h>
  #include <linux/skbuff.h>
  #include <linux/slab.h>
 +#include <linux/spinlock.h>
  #include <linux/stddef.h>
  #include <linux/string.h>
  #include <linux/types.h>
@@@ -131,139 -116,13 +132,137 @@@ static void batadv_v_ogm_send_to_if(str
    batadv_send_broadcast_skb(skb, hard_iface);
  }
+/**
 + * batadv_v_ogm_len() - OGMv2 packet length
 + * @skb: the OGM to check
 + *
 + * Return: Length of the given OGMv2 packet, including tvlv length, excluding
 + * ethernet header length.
 + */
 +static unsigned int batadv_v_ogm_len(struct sk_buff *skb)
 +{
 +	struct batadv_ogm2_packet *ogm_packet;
 +
 +	ogm_packet = (struct batadv_ogm2_packet *)skb->data;
 +	return BATADV_OGM2_HLEN + ntohs(ogm_packet->tvlv_len);
 +}
 +
 +/**
 + * batadv_v_ogm_queue_left() - check if given OGM still fits aggregation queue
 + * @skb: the OGM to check
 + * @hard_iface: the interface to use to send the OGM
 + *
 + * Caller needs to hold the hard_iface->bat_v.aggr_list_lock.
 + *
 + * Return: True, if the given OGMv2 packet still fits, false otherwise.
 + */
 +static bool batadv_v_ogm_queue_left(struct sk_buff *skb,
 +				    struct batadv_hard_iface *hard_iface)
 +{
 +	unsigned int max = min_t(unsigned int, hard_iface->net_dev->mtu,
 +				 BATADV_MAX_AGGREGATION_BYTES);
 +	unsigned int ogm_len = batadv_v_ogm_len(skb);
 +
 +	lockdep_assert_held(&hard_iface->bat_v.aggr_list_lock);
 +
 +	return hard_iface->bat_v.aggr_len + ogm_len <= max;
 +}
 +
 +/**
 + * batadv_v_ogm_aggr_list_free - free all elements in an aggregation queue
 + * @hard_iface: the interface holding the aggregation queue
 + *
 + * Empties the OGMv2 aggregation queue and frees all the skbs it contained.
 + *
 + * Caller needs to hold the hard_iface->bat_v.aggr_list_lock.
 + */
 +static void batadv_v_ogm_aggr_list_free(struct batadv_hard_iface *hard_iface)
 +{
 +	struct sk_buff *skb;
 +
 +	lockdep_assert_held(&hard_iface->bat_v.aggr_list_lock);
 +
 +	while ((skb = skb_dequeue(&hard_iface->bat_v.aggr_list)))
 +		kfree_skb(skb);
 +
 +	hard_iface->bat_v.aggr_len = 0;
 +}
 +
 +/**
 + * batadv_v_ogm_aggr_send() - flush & send aggregation queue
 + * @hard_iface: the interface with the aggregation queue to flush
 + *
 + * Aggregates all OGMv2 packets currently in the aggregation queue into a
 + * single OGMv2 packet and transmits this aggregate.
 + *
 + * The aggregation queue is empty after this call.
 + *
 + * Caller needs to hold the hard_iface->bat_v.aggr_list_lock.
 + */
 +static void batadv_v_ogm_aggr_send(struct batadv_hard_iface *hard_iface)
 +{
 +	unsigned int aggr_len = hard_iface->bat_v.aggr_len;
 +	struct sk_buff *skb_aggr;
 +	unsigned int ogm_len;
 +	struct sk_buff *skb;
 +
 +	lockdep_assert_held(&hard_iface->bat_v.aggr_list_lock);
 +
 +	if (!aggr_len)
 +		return;
 +
 +	skb_aggr = dev_alloc_skb(aggr_len + ETH_HLEN + NET_IP_ALIGN);
 +	if (!skb_aggr) {
 +		batadv_v_ogm_aggr_list_free(hard_iface);
 +		return;
 +	}
 +
 +	skb_reserve(skb_aggr, ETH_HLEN + NET_IP_ALIGN);
 +	skb_reset_network_header(skb_aggr);
 +
 +	while ((skb = skb_dequeue(&hard_iface->bat_v.aggr_list))) {
 +		hard_iface->bat_v.aggr_len -= batadv_v_ogm_len(skb);
 +
 +		ogm_len = batadv_v_ogm_len(skb);
 +		skb_put_data(skb_aggr, skb->data, ogm_len);
 +
 +		consume_skb(skb);
 +	}
 +
 +	batadv_v_ogm_send_to_if(skb_aggr, hard_iface);
 +}
 +
 +/**
 + * batadv_v_ogm_queue_on_if() - queue a batman ogm on a given interface
 + * @skb: the OGM to queue
 + * @hard_iface: the interface to queue the OGM on
 + */
 +static void batadv_v_ogm_queue_on_if(struct sk_buff *skb,
 +				     struct batadv_hard_iface *hard_iface)
 +{
 +	struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
 +
 +	if (!atomic_read(&bat_priv->aggregated_ogms)) {
 +		batadv_v_ogm_send_to_if(skb, hard_iface);
 +		return;
 +	}
 +
 +	spin_lock_bh(&hard_iface->bat_v.aggr_list_lock);
 +	if (!batadv_v_ogm_queue_left(skb, hard_iface))
 +		batadv_v_ogm_aggr_send(hard_iface);
 +
 +	hard_iface->bat_v.aggr_len += batadv_v_ogm_len(skb);
 +	skb_queue_tail(&hard_iface->bat_v.aggr_list, skb);
 +	spin_unlock_bh(&hard_iface->bat_v.aggr_list_lock);
 +}
 +
  /**
-  * batadv_v_ogm_send() - periodic worker broadcasting the own OGM
-  * @work: work queue item
+  * batadv_v_ogm_send_softif() - periodic worker broadcasting the own OGM
+  * @bat_priv: the bat priv with all the soft interface information
   */
- static void batadv_v_ogm_send(struct work_struct *work)
+ static void batadv_v_ogm_send_softif(struct batadv_priv *bat_priv)
  {
    struct batadv_hard_iface *hard_iface;
- 	struct batadv_priv_bat_v *bat_v;
- 	struct batadv_priv *bat_priv;
    struct batadv_ogm2_packet *ogm_packet;
    struct sk_buff *skb, *skb_tmp;
    unsigned char *ogm_buff;
@@@ -363,27 -221,22 +361,43 @@@ out
    return;
  }
+ /**
+  * batadv_v_ogm_send() - periodic worker broadcasting the own OGM
+  * @work: work queue item
+  */
+ static void batadv_v_ogm_send(struct work_struct *work)
+ {
+ 	struct batadv_priv_bat_v *bat_v;
+ 	struct batadv_priv *bat_priv;
+ 
+ 	rtnl_lock();
+ 	bat_v = container_of(work, struct batadv_priv_bat_v, ogm_wq.work);
+ 	bat_priv = container_of(bat_v, struct batadv_priv, bat_v);
+ 	batadv_v_ogm_send_softif(bat_priv);
+ 	rtnl_unlock();
+ }
+ 
 +/**
 + * batadv_v_ogm_aggr_work() - OGM queue periodic task per interface
 + * @work: work queue item
 + *
 + * Emits aggregated OGM message in regular intervals.
 + */
 +void batadv_v_ogm_aggr_work(struct work_struct *work)
 +{
 +	struct batadv_hard_iface_bat_v *batv;
 +	struct batadv_hard_iface *hard_iface;
 +
 +	batv = container_of(work, struct batadv_hard_iface_bat_v, aggr_wq.work);
 +	hard_iface = container_of(batv, struct batadv_hard_iface, bat_v);
 +
 +	spin_lock_bh(&hard_iface->bat_v.aggr_list_lock);
 +	batadv_v_ogm_aggr_send(hard_iface);
 +	spin_unlock_bh(&hard_iface->bat_v.aggr_list_lock);
 +
 +	batadv_v_ogm_start_queue_timer(hard_iface);
 +}
 +
  /**
   * batadv_v_ogm_iface_enable() - prepare an interface for B.A.T.M.A.N. V
   * @hard_iface: the interface to prepare

    