Unverified Commit 033a13cf authored by openeuler-ci-bot's avatar openeuler-ci-bot Committed by Gitee
Browse files

!15728 *** CVE-2025-21823 *** 

Merge Pull Request from: @ci-robot 
 
PR sync from: Zicheng Qu <quzicheng@huawei.com>
https://mailweb.openeuler.org/archives/list/kernel@openeuler.org/message/RF73UKLS2VCUSOZUNEDYKE3SP5KXZ2VU/ 
*** BLURB HERE ***

Andy Strohman (1):
  batman-adv: fix panic during interface removal

Sven Eckelmann (4):
  batman-adv: Add new include for min/max helpers
  batman-adv: Drop initialization of flexible ethtool_link_ksettings
  batman-adv: Ignore neighbor throughput metrics in error case
  batman-adv: Drop unmanaged ELP metric worker

 
https://gitee.com/src-openeuler/kernel/issues/IBPLJA 
 
Link:https://gitee.com/openeuler/kernel/pulls/15728

 

Reviewed-by: default avatarLu Jialin <lujialin4@huawei.com>
Reviewed-by: default avatarYue Haibing <yuehaibing@huawei.com>
Reviewed-by: default avatarLi Nan <linan122@huawei.com>
Signed-off-by: default avatarLi Nan <linan122@huawei.com>
parents 1edb9337 ebf34d44

net/batman-adv/bat_v.c

+1 −2
Original line number Diff line number Diff line
@@ -16,6 +16,7 @@ 
#include <linux/kernel.h>

#include <linux/kref.h>

#include <linux/list.h>

#include <linux/minmax.h>

#include <linux/netdevice.h>

#include <linux/netlink.h>

#include <linux/rculist.h>
@@ -115,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

net/batman-adv/bat_v_elp.c

+87 −37
Original line number Diff line number Diff line
@@ -18,6 +18,8 @@ 
#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>

#include <linux/prandom.h>
@@ -26,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>
@@ -41,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
@@ -59,25 +74,36 @@ static void batadv_v_elp_start_timer(struct batadv_hard_iface *hard_iface) 
/**

 * batadv_v_elp_get_throughput() - get the throughput towards a neighbour

 * @neigh: the neighbour for which the throughput has to be obtained

 * @pthroughput: calculated throughput towards the given neighbour in multiples

 *  of 100kpbs (a value of '1' equals 0.1Mbps, '10' equals 1Mbps, etc).

 *

 * Return: The throughput towards the given neighbour in multiples of 100kpbs

 *         (a value of '1' equals 0.1Mbps, '10' equals 1Mbps, etc).

 * Return: true when value behind @pthroughput was set

 */

static u32 batadv_v_elp_get_throughput(struct batadv_hardif_neigh_node *neigh)

static bool batadv_v_elp_get_throughput(struct batadv_hardif_neigh_node *neigh,

					u32 *pthroughput)

{

	struct batadv_hard_iface *hard_iface = neigh->if_incoming;

	struct net_device *soft_iface = hard_iface->soft_iface;

	struct ethtool_link_ksettings link_settings;

	struct net_device *real_netdev;

	struct station_info sinfo;

	u32 throughput;

	int ret;



	/* don't query throughput when no longer associated with any

	 * batman-adv interface

	 */

	if (!soft_iface)

		return false;



	/* if the user specified a customised value for this interface, then

	 * return it directly

	 */

	throughput =  atomic_read(&hard_iface->bat_v.throughput_override);

	if (throughput != 0)

		return throughput;

	if (throughput != 0) {

		*pthroughput = throughput;

		return true;

	}



	/* if this is a wireless device, then ask its throughput through

	 * cfg80211 API
@@ -104,28 +130,39 @@ static u32 batadv_v_elp_get_throughput(struct batadv_hardif_neigh_node *neigh) 
			 * possible to delete this neighbor. For now set

			 * the throughput metric to 0.

			 */

			return 0;

			*pthroughput = 0;

			return true;

		}

		if (ret)

			goto default_throughput;



		if (sinfo.filled & BIT(NL80211_STA_INFO_EXPECTED_THROUGHPUT))

			return sinfo.expected_throughput / 100;

		if (sinfo.filled & BIT(NL80211_STA_INFO_EXPECTED_THROUGHPUT)) {

			*pthroughput = sinfo.expected_throughput / 100;

			return true;

		}



		/* try to estimate the expected throughput based on reported tx

		 * rates

		 */

		if (sinfo.filled & BIT(NL80211_STA_INFO_TX_BITRATE))

			return cfg80211_calculate_bitrate(&sinfo.txrate) / 3;

		if (sinfo.filled & BIT(NL80211_STA_INFO_TX_BITRATE)) {

			*pthroughput = cfg80211_calculate_bitrate(&sinfo.txrate) / 3;

			return true;

		}



		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)

	 */

	memset(&link_settings, 0, sizeof(link_settings));

	rtnl_lock();

	ret = __ethtool_get_link_ksettings(hard_iface->net_dev, &link_settings);

	rtnl_unlock();

	if (ret == 0) {
@@ -136,13 +173,15 @@ static u32 batadv_v_elp_get_throughput(struct batadv_hardif_neigh_node *neigh) 
			hard_iface->bat_v.flags &= ~BATADV_FULL_DUPLEX;



		throughput = link_settings.base.speed;

		if (throughput && throughput != SPEED_UNKNOWN)

			return throughput * 10;

		if (throughput && throughput != SPEED_UNKNOWN) {

			*pthroughput = throughput * 10;

			return true;

		}

	}



default_throughput:

	if (!(hard_iface->bat_v.flags & BATADV_WARNING_DEFAULT)) {

		batadv_info(hard_iface->soft_iface,

		batadv_info(soft_iface,

			    "WiFi driver or ethtool info does not provide information about link speeds on interface %s, therefore defaulting to hardcoded throughput values of %u.%1u Mbps. Consider overriding the throughput manually or checking your driver.\n",

			    hard_iface->net_dev->name,

			    BATADV_THROUGHPUT_DEFAULT_VALUE / 10,
@@ -151,31 +190,26 @@ static u32 batadv_v_elp_get_throughput(struct batadv_hardif_neigh_node *neigh) 
	}



	/* if none of the above cases apply, return the base_throughput */

	return BATADV_THROUGHPUT_DEFAULT_VALUE;

	*pthroughput = BATADV_THROUGHPUT_DEFAULT_VALUE;

	return true;

}



/**

 * 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;



	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);

	u32 throughput;

	bool valid;



	ewma_throughput_add(&neigh->bat_v.throughput,

			    batadv_v_elp_get_throughput(neigh));

	valid = batadv_v_elp_get_throughput(neigh, &throughput);

	if (!valid)

		return;



	/* decrement refcounter to balance increment performed before scheduling

	 * this task

	 */

	batadv_hardif_neigh_put(neigh);

	ewma_throughput_add(&neigh->bat_v.throughput, throughput);

}



/**
@@ -249,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);
@@ -292,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.
@@ -316,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:

net/batman-adv/bat_v_elp.h

+0 −2
Original line number Diff line number Diff line
@@ -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_ */

net/batman-adv/bat_v_ogm.c

+1 −0
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ 
#include <linux/kref.h>

#include <linux/list.h>

#include <linux/lockdep.h>

#include <linux/minmax.h>

#include <linux/mutex.h>

#include <linux/netdevice.h>

#include <linux/prandom.h>

net/batman-adv/fragmentation.c

+1 −1
Original line number Diff line number Diff line
@@ -14,8 +14,8 @@ 
#include <linux/gfp.h>

#include <linux/if_ether.h>

#include <linux/jiffies.h>

#include <linux/kernel.h>

#include <linux/lockdep.h>

#include <linux/minmax.h>

#include <linux/netdevice.h>

#include <linux/skbuff.h>

#include <linux/slab.h>