xref: /linux/net/batman-adv/bat_v.c (revision a1c613ae4c322ddd58d5a8539dbfba2a0380a8c0)
1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) B.A.T.M.A.N. contributors:
3  *
4  * Linus Lüssing, Marek Lindner
5  */
6 
7 #include "bat_v.h"
8 #include "main.h"
9 
10 #include <linux/atomic.h>
11 #include <linux/cache.h>
12 #include <linux/errno.h>
13 #include <linux/if_ether.h>
14 #include <linux/init.h>
15 #include <linux/jiffies.h>
16 #include <linux/kref.h>
17 #include <linux/limits.h>
18 #include <linux/list.h>
19 #include <linux/minmax.h>
20 #include <linux/netdevice.h>
21 #include <linux/netlink.h>
22 #include <linux/rculist.h>
23 #include <linux/rcupdate.h>
24 #include <linux/skbuff.h>
25 #include <linux/spinlock.h>
26 #include <linux/stddef.h>
27 #include <linux/types.h>
28 #include <linux/workqueue.h>
29 #include <net/genetlink.h>
30 #include <net/netlink.h>
31 #include <uapi/linux/batadv_packet.h>
32 #include <uapi/linux/batman_adv.h>
33 
34 #include "bat_algo.h"
35 #include "bat_v_elp.h"
36 #include "bat_v_ogm.h"
37 #include "gateway_client.h"
38 #include "hard-interface.h"
39 #include "hash.h"
40 #include "log.h"
41 #include "netlink.h"
42 #include "originator.h"
43 
batadv_v_iface_activate(struct batadv_hard_iface * hard_iface)44 static void batadv_v_iface_activate(struct batadv_hard_iface *hard_iface)
45 {
46 	struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
47 	struct batadv_hard_iface *primary_if;
48 
49 	primary_if = batadv_primary_if_get_selected(bat_priv);
50 
51 	if (primary_if) {
52 		batadv_v_elp_iface_activate(primary_if, hard_iface);
53 		batadv_hardif_put(primary_if);
54 	}
55 
56 	/* B.A.T.M.A.N. V does not use any queuing mechanism, therefore it can
57 	 * set the interface as ACTIVE right away, without any risk of race
58 	 * condition
59 	 */
60 	if (hard_iface->if_status == BATADV_IF_TO_BE_ACTIVATED)
61 		hard_iface->if_status = BATADV_IF_ACTIVE;
62 }
63 
batadv_v_iface_enable(struct batadv_hard_iface * hard_iface)64 static int batadv_v_iface_enable(struct batadv_hard_iface *hard_iface)
65 {
66 	int ret;
67 
68 	ret = batadv_v_elp_iface_enable(hard_iface);
69 	if (ret < 0)
70 		return ret;
71 
72 	ret = batadv_v_ogm_iface_enable(hard_iface);
73 	if (ret < 0)
74 		batadv_v_elp_iface_disable(hard_iface);
75 
76 	return ret;
77 }
78 
batadv_v_iface_disable(struct batadv_hard_iface * hard_iface)79 static void batadv_v_iface_disable(struct batadv_hard_iface *hard_iface)
80 {
81 	batadv_v_ogm_iface_disable(hard_iface);
82 	batadv_v_elp_iface_disable(hard_iface);
83 }
84 
batadv_v_primary_iface_set(struct batadv_hard_iface * hard_iface)85 static void batadv_v_primary_iface_set(struct batadv_hard_iface *hard_iface)
86 {
87 	batadv_v_elp_primary_iface_set(hard_iface);
88 	batadv_v_ogm_primary_iface_set(hard_iface);
89 }
90 
91 /**
92  * batadv_v_iface_update_mac() - react to hard-interface MAC address change
93  * @hard_iface: the modified interface
94  *
95  * If the modified interface is the primary one, update the originator
96  * address in the ELP and OGM messages to reflect the new MAC address.
97  */
batadv_v_iface_update_mac(struct batadv_hard_iface * hard_iface)98 static void batadv_v_iface_update_mac(struct batadv_hard_iface *hard_iface)
99 {
100 	struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
101 	struct batadv_hard_iface *primary_if;
102 
103 	primary_if = batadv_primary_if_get_selected(bat_priv);
104 	if (primary_if != hard_iface)
105 		goto out;
106 
107 	batadv_v_primary_iface_set(hard_iface);
108 out:
109 	batadv_hardif_put(primary_if);
110 }
111 
112 static void
batadv_v_hardif_neigh_init(struct batadv_hardif_neigh_node * hardif_neigh)113 batadv_v_hardif_neigh_init(struct batadv_hardif_neigh_node *hardif_neigh)
114 {
115 	ewma_throughput_init(&hardif_neigh->bat_v.throughput);
116 	INIT_WORK(&hardif_neigh->bat_v.metric_work,
117 		  batadv_v_elp_throughput_metric_update);
118 }
119 
120 /**
121  * batadv_v_neigh_dump_neigh() - Dump a neighbour into a message
122  * @msg: Netlink message to dump into
123  * @portid: Port making netlink request
124  * @seq: Sequence number of netlink message
125  * @hardif_neigh: Neighbour to dump
126  *
127  * Return: Error code, or 0 on success
128  */
129 static int
batadv_v_neigh_dump_neigh(struct sk_buff * msg,u32 portid,u32 seq,struct batadv_hardif_neigh_node * hardif_neigh)130 batadv_v_neigh_dump_neigh(struct sk_buff *msg, u32 portid, u32 seq,
131 			  struct batadv_hardif_neigh_node *hardif_neigh)
132 {
133 	void *hdr;
134 	unsigned int last_seen_msecs;
135 	u32 throughput;
136 
137 	last_seen_msecs = jiffies_to_msecs(jiffies - hardif_neigh->last_seen);
138 	throughput = ewma_throughput_read(&hardif_neigh->bat_v.throughput);
139 	throughput = throughput * 100;
140 
141 	hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family, NLM_F_MULTI,
142 			  BATADV_CMD_GET_NEIGHBORS);
143 	if (!hdr)
144 		return -ENOBUFS;
145 
146 	if (nla_put(msg, BATADV_ATTR_NEIGH_ADDRESS, ETH_ALEN,
147 		    hardif_neigh->addr) ||
148 	    nla_put_string(msg, BATADV_ATTR_HARD_IFNAME,
149 			   hardif_neigh->if_incoming->net_dev->name) ||
150 	    nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX,
151 			hardif_neigh->if_incoming->net_dev->ifindex) ||
152 	    nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS,
153 			last_seen_msecs) ||
154 	    nla_put_u32(msg, BATADV_ATTR_THROUGHPUT, throughput))
155 		goto nla_put_failure;
156 
157 	genlmsg_end(msg, hdr);
158 	return 0;
159 
160  nla_put_failure:
161 	genlmsg_cancel(msg, hdr);
162 	return -EMSGSIZE;
163 }
164 
165 /**
166  * batadv_v_neigh_dump_hardif() - Dump the  neighbours of a hard interface into
167  *  a message
168  * @msg: Netlink message to dump into
169  * @portid: Port making netlink request
170  * @seq: Sequence number of netlink message
171  * @bat_priv: The bat priv with all the soft interface information
172  * @hard_iface: The hard interface to be dumped
173  * @idx_s: Entries to be skipped
174  *
175  * This function assumes the caller holds rcu_read_lock().
176  *
177  * Return: Error code, or 0 on success
178  */
179 static int
batadv_v_neigh_dump_hardif(struct sk_buff * msg,u32 portid,u32 seq,struct batadv_priv * bat_priv,struct batadv_hard_iface * hard_iface,int * idx_s)180 batadv_v_neigh_dump_hardif(struct sk_buff *msg, u32 portid, u32 seq,
181 			   struct batadv_priv *bat_priv,
182 			   struct batadv_hard_iface *hard_iface,
183 			   int *idx_s)
184 {
185 	struct batadv_hardif_neigh_node *hardif_neigh;
186 	int idx = 0;
187 
188 	hlist_for_each_entry_rcu(hardif_neigh,
189 				 &hard_iface->neigh_list, list) {
190 		if (idx++ < *idx_s)
191 			continue;
192 
193 		if (batadv_v_neigh_dump_neigh(msg, portid, seq, hardif_neigh)) {
194 			*idx_s = idx - 1;
195 			return -EMSGSIZE;
196 		}
197 	}
198 
199 	*idx_s = 0;
200 	return 0;
201 }
202 
203 /**
204  * batadv_v_neigh_dump() - Dump the neighbours of a hard interface  into a
205  *  message
206  * @msg: Netlink message to dump into
207  * @cb: Control block containing additional options
208  * @bat_priv: The bat priv with all the soft interface information
209  * @single_hardif: Limit dumping to this hard interface
210  */
211 static void
batadv_v_neigh_dump(struct sk_buff * msg,struct netlink_callback * cb,struct batadv_priv * bat_priv,struct batadv_hard_iface * single_hardif)212 batadv_v_neigh_dump(struct sk_buff *msg, struct netlink_callback *cb,
213 		    struct batadv_priv *bat_priv,
214 		    struct batadv_hard_iface *single_hardif)
215 {
216 	struct batadv_hard_iface *hard_iface;
217 	int i_hardif = 0;
218 	int i_hardif_s = cb->args[0];
219 	int idx = cb->args[1];
220 	int portid = NETLINK_CB(cb->skb).portid;
221 
222 	rcu_read_lock();
223 	if (single_hardif) {
224 		if (i_hardif_s == 0) {
225 			if (batadv_v_neigh_dump_hardif(msg, portid,
226 						       cb->nlh->nlmsg_seq,
227 						       bat_priv, single_hardif,
228 						       &idx) == 0)
229 				i_hardif++;
230 		}
231 	} else {
232 		list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
233 			if (hard_iface->soft_iface != bat_priv->soft_iface)
234 				continue;
235 
236 			if (i_hardif++ < i_hardif_s)
237 				continue;
238 
239 			if (batadv_v_neigh_dump_hardif(msg, portid,
240 						       cb->nlh->nlmsg_seq,
241 						       bat_priv, hard_iface,
242 						       &idx)) {
243 				i_hardif--;
244 				break;
245 			}
246 		}
247 	}
248 	rcu_read_unlock();
249 
250 	cb->args[0] = i_hardif;
251 	cb->args[1] = idx;
252 }
253 
254 /**
255  * batadv_v_orig_dump_subentry() - Dump an originator subentry into a message
256  * @msg: Netlink message to dump into
257  * @portid: Port making netlink request
258  * @seq: Sequence number of netlink message
259  * @bat_priv: The bat priv with all the soft interface information
260  * @if_outgoing: Limit dump to entries with this outgoing interface
261  * @orig_node: Originator to dump
262  * @neigh_node: Single hops neighbour
263  * @best: Is the best originator
264  *
265  * Return: Error code, or 0 on success
266  */
267 static int
batadv_v_orig_dump_subentry(struct sk_buff * msg,u32 portid,u32 seq,struct batadv_priv * bat_priv,struct batadv_hard_iface * if_outgoing,struct batadv_orig_node * orig_node,struct batadv_neigh_node * neigh_node,bool best)268 batadv_v_orig_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq,
269 			    struct batadv_priv *bat_priv,
270 			    struct batadv_hard_iface *if_outgoing,
271 			    struct batadv_orig_node *orig_node,
272 			    struct batadv_neigh_node *neigh_node,
273 			    bool best)
274 {
275 	struct batadv_neigh_ifinfo *n_ifinfo;
276 	unsigned int last_seen_msecs;
277 	u32 throughput;
278 	void *hdr;
279 
280 	n_ifinfo = batadv_neigh_ifinfo_get(neigh_node, if_outgoing);
281 	if (!n_ifinfo)
282 		return 0;
283 
284 	throughput = n_ifinfo->bat_v.throughput * 100;
285 
286 	batadv_neigh_ifinfo_put(n_ifinfo);
287 
288 	last_seen_msecs = jiffies_to_msecs(jiffies - orig_node->last_seen);
289 
290 	if (if_outgoing != BATADV_IF_DEFAULT &&
291 	    if_outgoing != neigh_node->if_incoming)
292 		return 0;
293 
294 	hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family, NLM_F_MULTI,
295 			  BATADV_CMD_GET_ORIGINATORS);
296 	if (!hdr)
297 		return -ENOBUFS;
298 
299 	if (nla_put(msg, BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN, orig_node->orig) ||
300 	    nla_put(msg, BATADV_ATTR_NEIGH_ADDRESS, ETH_ALEN,
301 		    neigh_node->addr) ||
302 	    nla_put_string(msg, BATADV_ATTR_HARD_IFNAME,
303 			   neigh_node->if_incoming->net_dev->name) ||
304 	    nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX,
305 			neigh_node->if_incoming->net_dev->ifindex) ||
306 	    nla_put_u32(msg, BATADV_ATTR_THROUGHPUT, throughput) ||
307 	    nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS,
308 			last_seen_msecs))
309 		goto nla_put_failure;
310 
311 	if (best && nla_put_flag(msg, BATADV_ATTR_FLAG_BEST))
312 		goto nla_put_failure;
313 
314 	genlmsg_end(msg, hdr);
315 	return 0;
316 
317  nla_put_failure:
318 	genlmsg_cancel(msg, hdr);
319 	return -EMSGSIZE;
320 }
321 
322 /**
323  * batadv_v_orig_dump_entry() - Dump an originator entry into a message
324  * @msg: Netlink message to dump into
325  * @portid: Port making netlink request
326  * @seq: Sequence number of netlink message
327  * @bat_priv: The bat priv with all the soft interface information
328  * @if_outgoing: Limit dump to entries with this outgoing interface
329  * @orig_node: Originator to dump
330  * @sub_s: Number of sub entries to skip
331  *
332  * This function assumes the caller holds rcu_read_lock().
333  *
334  * Return: Error code, or 0 on success
335  */
336 static int
batadv_v_orig_dump_entry(struct sk_buff * msg,u32 portid,u32 seq,struct batadv_priv * bat_priv,struct batadv_hard_iface * if_outgoing,struct batadv_orig_node * orig_node,int * sub_s)337 batadv_v_orig_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
338 			 struct batadv_priv *bat_priv,
339 			 struct batadv_hard_iface *if_outgoing,
340 			 struct batadv_orig_node *orig_node, int *sub_s)
341 {
342 	struct batadv_neigh_node *neigh_node_best;
343 	struct batadv_neigh_node *neigh_node;
344 	int sub = 0;
345 	bool best;
346 
347 	neigh_node_best = batadv_orig_router_get(orig_node, if_outgoing);
348 	if (!neigh_node_best)
349 		goto out;
350 
351 	hlist_for_each_entry_rcu(neigh_node, &orig_node->neigh_list, list) {
352 		if (sub++ < *sub_s)
353 			continue;
354 
355 		best = (neigh_node == neigh_node_best);
356 
357 		if (batadv_v_orig_dump_subentry(msg, portid, seq, bat_priv,
358 						if_outgoing, orig_node,
359 						neigh_node, best)) {
360 			batadv_neigh_node_put(neigh_node_best);
361 
362 			*sub_s = sub - 1;
363 			return -EMSGSIZE;
364 		}
365 	}
366 
367  out:
368 	batadv_neigh_node_put(neigh_node_best);
369 
370 	*sub_s = 0;
371 	return 0;
372 }
373 
374 /**
375  * batadv_v_orig_dump_bucket() - Dump an originator bucket into a message
376  * @msg: Netlink message to dump into
377  * @portid: Port making netlink request
378  * @seq: Sequence number of netlink message
379  * @bat_priv: The bat priv with all the soft interface information
380  * @if_outgoing: Limit dump to entries with this outgoing interface
381  * @head: Bucket to be dumped
382  * @idx_s: Number of entries to be skipped
383  * @sub: Number of sub entries to be skipped
384  *
385  * Return: Error code, or 0 on success
386  */
387 static int
batadv_v_orig_dump_bucket(struct sk_buff * msg,u32 portid,u32 seq,struct batadv_priv * bat_priv,struct batadv_hard_iface * if_outgoing,struct hlist_head * head,int * idx_s,int * sub)388 batadv_v_orig_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
389 			  struct batadv_priv *bat_priv,
390 			  struct batadv_hard_iface *if_outgoing,
391 			  struct hlist_head *head, int *idx_s, int *sub)
392 {
393 	struct batadv_orig_node *orig_node;
394 	int idx = 0;
395 
396 	rcu_read_lock();
397 	hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
398 		if (idx++ < *idx_s)
399 			continue;
400 
401 		if (batadv_v_orig_dump_entry(msg, portid, seq, bat_priv,
402 					     if_outgoing, orig_node, sub)) {
403 			rcu_read_unlock();
404 			*idx_s = idx - 1;
405 			return -EMSGSIZE;
406 		}
407 	}
408 	rcu_read_unlock();
409 
410 	*idx_s = 0;
411 	*sub = 0;
412 	return 0;
413 }
414 
415 /**
416  * batadv_v_orig_dump() - Dump the originators into a message
417  * @msg: Netlink message to dump into
418  * @cb: Control block containing additional options
419  * @bat_priv: The bat priv with all the soft interface information
420  * @if_outgoing: Limit dump to entries with this outgoing interface
421  */
422 static void
batadv_v_orig_dump(struct sk_buff * msg,struct netlink_callback * cb,struct batadv_priv * bat_priv,struct batadv_hard_iface * if_outgoing)423 batadv_v_orig_dump(struct sk_buff *msg, struct netlink_callback *cb,
424 		   struct batadv_priv *bat_priv,
425 		   struct batadv_hard_iface *if_outgoing)
426 {
427 	struct batadv_hashtable *hash = bat_priv->orig_hash;
428 	struct hlist_head *head;
429 	int bucket = cb->args[0];
430 	int idx = cb->args[1];
431 	int sub = cb->args[2];
432 	int portid = NETLINK_CB(cb->skb).portid;
433 
434 	while (bucket < hash->size) {
435 		head = &hash->table[bucket];
436 
437 		if (batadv_v_orig_dump_bucket(msg, portid,
438 					      cb->nlh->nlmsg_seq,
439 					      bat_priv, if_outgoing, head, &idx,
440 					      &sub))
441 			break;
442 
443 		bucket++;
444 	}
445 
446 	cb->args[0] = bucket;
447 	cb->args[1] = idx;
448 	cb->args[2] = sub;
449 }
450 
batadv_v_neigh_cmp(struct batadv_neigh_node * neigh1,struct batadv_hard_iface * if_outgoing1,struct batadv_neigh_node * neigh2,struct batadv_hard_iface * if_outgoing2)451 static int batadv_v_neigh_cmp(struct batadv_neigh_node *neigh1,
452 			      struct batadv_hard_iface *if_outgoing1,
453 			      struct batadv_neigh_node *neigh2,
454 			      struct batadv_hard_iface *if_outgoing2)
455 {
456 	struct batadv_neigh_ifinfo *ifinfo1, *ifinfo2;
457 	int ret = 0;
458 
459 	ifinfo1 = batadv_neigh_ifinfo_get(neigh1, if_outgoing1);
460 	if (!ifinfo1)
461 		goto err_ifinfo1;
462 
463 	ifinfo2 = batadv_neigh_ifinfo_get(neigh2, if_outgoing2);
464 	if (!ifinfo2)
465 		goto err_ifinfo2;
466 
467 	ret = ifinfo1->bat_v.throughput - ifinfo2->bat_v.throughput;
468 
469 	batadv_neigh_ifinfo_put(ifinfo2);
470 err_ifinfo2:
471 	batadv_neigh_ifinfo_put(ifinfo1);
472 err_ifinfo1:
473 	return ret;
474 }
475 
batadv_v_neigh_is_sob(struct batadv_neigh_node * neigh1,struct batadv_hard_iface * if_outgoing1,struct batadv_neigh_node * neigh2,struct batadv_hard_iface * if_outgoing2)476 static bool batadv_v_neigh_is_sob(struct batadv_neigh_node *neigh1,
477 				  struct batadv_hard_iface *if_outgoing1,
478 				  struct batadv_neigh_node *neigh2,
479 				  struct batadv_hard_iface *if_outgoing2)
480 {
481 	struct batadv_neigh_ifinfo *ifinfo1, *ifinfo2;
482 	u32 threshold;
483 	bool ret = false;
484 
485 	ifinfo1 = batadv_neigh_ifinfo_get(neigh1, if_outgoing1);
486 	if (!ifinfo1)
487 		goto err_ifinfo1;
488 
489 	ifinfo2 = batadv_neigh_ifinfo_get(neigh2, if_outgoing2);
490 	if (!ifinfo2)
491 		goto err_ifinfo2;
492 
493 	threshold = ifinfo1->bat_v.throughput / 4;
494 	threshold = ifinfo1->bat_v.throughput - threshold;
495 
496 	ret = ifinfo2->bat_v.throughput > threshold;
497 
498 	batadv_neigh_ifinfo_put(ifinfo2);
499 err_ifinfo2:
500 	batadv_neigh_ifinfo_put(ifinfo1);
501 err_ifinfo1:
502 	return ret;
503 }
504 
505 /**
506  * batadv_v_init_sel_class() - initialize GW selection class
507  * @bat_priv: the bat priv with all the soft interface information
508  */
batadv_v_init_sel_class(struct batadv_priv * bat_priv)509 static void batadv_v_init_sel_class(struct batadv_priv *bat_priv)
510 {
511 	/* set default throughput difference threshold to 5Mbps */
512 	atomic_set(&bat_priv->gw.sel_class, 50);
513 }
514 
515 /**
516  * batadv_v_gw_throughput_get() - retrieve the GW-bandwidth for a given GW
517  * @gw_node: the GW to retrieve the metric for
518  * @bw: the pointer where the metric will be stored. The metric is computed as
519  *  the minimum between the GW advertised throughput and the path throughput to
520  *  it in the mesh
521  *
522  * Return: 0 on success, -1 on failure
523  */
batadv_v_gw_throughput_get(struct batadv_gw_node * gw_node,u32 * bw)524 static int batadv_v_gw_throughput_get(struct batadv_gw_node *gw_node, u32 *bw)
525 {
526 	struct batadv_neigh_ifinfo *router_ifinfo = NULL;
527 	struct batadv_orig_node *orig_node;
528 	struct batadv_neigh_node *router;
529 	int ret = -1;
530 
531 	orig_node = gw_node->orig_node;
532 	router = batadv_orig_router_get(orig_node, BATADV_IF_DEFAULT);
533 	if (!router)
534 		goto out;
535 
536 	router_ifinfo = batadv_neigh_ifinfo_get(router, BATADV_IF_DEFAULT);
537 	if (!router_ifinfo)
538 		goto out;
539 
540 	/* the GW metric is computed as the minimum between the path throughput
541 	 * to reach the GW itself and the advertised bandwidth.
542 	 * This gives us an approximation of the effective throughput that the
543 	 * client can expect via this particular GW node
544 	 */
545 	*bw = router_ifinfo->bat_v.throughput;
546 	*bw = min_t(u32, *bw, gw_node->bandwidth_down);
547 
548 	ret = 0;
549 out:
550 	batadv_neigh_node_put(router);
551 	batadv_neigh_ifinfo_put(router_ifinfo);
552 
553 	return ret;
554 }
555 
556 /**
557  * batadv_v_gw_get_best_gw_node() - retrieve the best GW node
558  * @bat_priv: the bat priv with all the soft interface information
559  *
560  * Return: the GW node having the best GW-metric, NULL if no GW is known
561  */
562 static struct batadv_gw_node *
batadv_v_gw_get_best_gw_node(struct batadv_priv * bat_priv)563 batadv_v_gw_get_best_gw_node(struct batadv_priv *bat_priv)
564 {
565 	struct batadv_gw_node *gw_node, *curr_gw = NULL;
566 	u32 max_bw = 0, bw;
567 
568 	rcu_read_lock();
569 	hlist_for_each_entry_rcu(gw_node, &bat_priv->gw.gateway_list, list) {
570 		if (!kref_get_unless_zero(&gw_node->refcount))
571 			continue;
572 
573 		if (batadv_v_gw_throughput_get(gw_node, &bw) < 0)
574 			goto next;
575 
576 		if (curr_gw && bw <= max_bw)
577 			goto next;
578 
579 		batadv_gw_node_put(curr_gw);
580 
581 		curr_gw = gw_node;
582 		kref_get(&curr_gw->refcount);
583 		max_bw = bw;
584 
585 next:
586 		batadv_gw_node_put(gw_node);
587 	}
588 	rcu_read_unlock();
589 
590 	return curr_gw;
591 }
592 
593 /**
594  * batadv_v_gw_is_eligible() - check if a originator would be selected as GW
595  * @bat_priv: the bat priv with all the soft interface information
596  * @curr_gw_orig: originator representing the currently selected GW
597  * @orig_node: the originator representing the new candidate
598  *
599  * Return: true if orig_node can be selected as current GW, false otherwise
600  */
batadv_v_gw_is_eligible(struct batadv_priv * bat_priv,struct batadv_orig_node * curr_gw_orig,struct batadv_orig_node * orig_node)601 static bool batadv_v_gw_is_eligible(struct batadv_priv *bat_priv,
602 				    struct batadv_orig_node *curr_gw_orig,
603 				    struct batadv_orig_node *orig_node)
604 {
605 	struct batadv_gw_node *curr_gw, *orig_gw = NULL;
606 	u32 gw_throughput, orig_throughput, threshold;
607 	bool ret = false;
608 
609 	threshold = atomic_read(&bat_priv->gw.sel_class);
610 
611 	curr_gw = batadv_gw_node_get(bat_priv, curr_gw_orig);
612 	if (!curr_gw) {
613 		ret = true;
614 		goto out;
615 	}
616 
617 	if (batadv_v_gw_throughput_get(curr_gw, &gw_throughput) < 0) {
618 		ret = true;
619 		goto out;
620 	}
621 
622 	orig_gw = batadv_gw_node_get(bat_priv, orig_node);
623 	if (!orig_gw)
624 		goto out;
625 
626 	if (batadv_v_gw_throughput_get(orig_gw, &orig_throughput) < 0)
627 		goto out;
628 
629 	if (orig_throughput < gw_throughput)
630 		goto out;
631 
632 	if ((orig_throughput - gw_throughput) < threshold)
633 		goto out;
634 
635 	batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
636 		   "Restarting gateway selection: better gateway found (throughput curr: %u, throughput new: %u)\n",
637 		   gw_throughput, orig_throughput);
638 
639 	ret = true;
640 out:
641 	batadv_gw_node_put(curr_gw);
642 	batadv_gw_node_put(orig_gw);
643 
644 	return ret;
645 }
646 
647 /**
648  * batadv_v_gw_dump_entry() - Dump a gateway into a message
649  * @msg: Netlink message to dump into
650  * @portid: Port making netlink request
651  * @cb: Control block containing additional options
652  * @bat_priv: The bat priv with all the soft interface information
653  * @gw_node: Gateway to be dumped
654  *
655  * Return: Error code, or 0 on success
656  */
batadv_v_gw_dump_entry(struct sk_buff * msg,u32 portid,struct netlink_callback * cb,struct batadv_priv * bat_priv,struct batadv_gw_node * gw_node)657 static int batadv_v_gw_dump_entry(struct sk_buff *msg, u32 portid,
658 				  struct netlink_callback *cb,
659 				  struct batadv_priv *bat_priv,
660 				  struct batadv_gw_node *gw_node)
661 {
662 	struct batadv_neigh_ifinfo *router_ifinfo = NULL;
663 	struct batadv_neigh_node *router;
664 	struct batadv_gw_node *curr_gw = NULL;
665 	int ret = 0;
666 	void *hdr;
667 
668 	router = batadv_orig_router_get(gw_node->orig_node, BATADV_IF_DEFAULT);
669 	if (!router)
670 		goto out;
671 
672 	router_ifinfo = batadv_neigh_ifinfo_get(router, BATADV_IF_DEFAULT);
673 	if (!router_ifinfo)
674 		goto out;
675 
676 	curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
677 
678 	hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq,
679 			  &batadv_netlink_family, NLM_F_MULTI,
680 			  BATADV_CMD_GET_GATEWAYS);
681 	if (!hdr) {
682 		ret = -ENOBUFS;
683 		goto out;
684 	}
685 
686 	genl_dump_check_consistent(cb, hdr);
687 
688 	ret = -EMSGSIZE;
689 
690 	if (curr_gw == gw_node) {
691 		if (nla_put_flag(msg, BATADV_ATTR_FLAG_BEST)) {
692 			genlmsg_cancel(msg, hdr);
693 			goto out;
694 		}
695 	}
696 
697 	if (nla_put(msg, BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN,
698 		    gw_node->orig_node->orig)) {
699 		genlmsg_cancel(msg, hdr);
700 		goto out;
701 	}
702 
703 	if (nla_put_u32(msg, BATADV_ATTR_THROUGHPUT,
704 			router_ifinfo->bat_v.throughput)) {
705 		genlmsg_cancel(msg, hdr);
706 		goto out;
707 	}
708 
709 	if (nla_put(msg, BATADV_ATTR_ROUTER, ETH_ALEN, router->addr)) {
710 		genlmsg_cancel(msg, hdr);
711 		goto out;
712 	}
713 
714 	if (nla_put_string(msg, BATADV_ATTR_HARD_IFNAME,
715 			   router->if_incoming->net_dev->name)) {
716 		genlmsg_cancel(msg, hdr);
717 		goto out;
718 	}
719 
720 	if (nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX,
721 			router->if_incoming->net_dev->ifindex)) {
722 		genlmsg_cancel(msg, hdr);
723 		goto out;
724 	}
725 
726 	if (nla_put_u32(msg, BATADV_ATTR_BANDWIDTH_DOWN,
727 			gw_node->bandwidth_down)) {
728 		genlmsg_cancel(msg, hdr);
729 		goto out;
730 	}
731 
732 	if (nla_put_u32(msg, BATADV_ATTR_BANDWIDTH_UP, gw_node->bandwidth_up)) {
733 		genlmsg_cancel(msg, hdr);
734 		goto out;
735 	}
736 
737 	genlmsg_end(msg, hdr);
738 	ret = 0;
739 
740 out:
741 	batadv_gw_node_put(curr_gw);
742 	batadv_neigh_ifinfo_put(router_ifinfo);
743 	batadv_neigh_node_put(router);
744 	return ret;
745 }
746 
747 /**
748  * batadv_v_gw_dump() - Dump gateways into a message
749  * @msg: Netlink message to dump into
750  * @cb: Control block containing additional options
751  * @bat_priv: The bat priv with all the soft interface information
752  */
batadv_v_gw_dump(struct sk_buff * msg,struct netlink_callback * cb,struct batadv_priv * bat_priv)753 static void batadv_v_gw_dump(struct sk_buff *msg, struct netlink_callback *cb,
754 			     struct batadv_priv *bat_priv)
755 {
756 	int portid = NETLINK_CB(cb->skb).portid;
757 	struct batadv_gw_node *gw_node;
758 	int idx_skip = cb->args[0];
759 	int idx = 0;
760 
761 	spin_lock_bh(&bat_priv->gw.list_lock);
762 	cb->seq = bat_priv->gw.generation << 1 | 1;
763 
764 	hlist_for_each_entry(gw_node, &bat_priv->gw.gateway_list, list) {
765 		if (idx++ < idx_skip)
766 			continue;
767 
768 		if (batadv_v_gw_dump_entry(msg, portid, cb, bat_priv,
769 					   gw_node)) {
770 			idx_skip = idx - 1;
771 			goto unlock;
772 		}
773 	}
774 
775 	idx_skip = idx;
776 unlock:
777 	spin_unlock_bh(&bat_priv->gw.list_lock);
778 
779 	cb->args[0] = idx_skip;
780 }
781 
782 static struct batadv_algo_ops batadv_batman_v __read_mostly = {
783 	.name = "BATMAN_V",
784 	.iface = {
785 		.activate = batadv_v_iface_activate,
786 		.enable = batadv_v_iface_enable,
787 		.disable = batadv_v_iface_disable,
788 		.update_mac = batadv_v_iface_update_mac,
789 		.primary_set = batadv_v_primary_iface_set,
790 	},
791 	.neigh = {
792 		.hardif_init = batadv_v_hardif_neigh_init,
793 		.cmp = batadv_v_neigh_cmp,
794 		.is_similar_or_better = batadv_v_neigh_is_sob,
795 		.dump = batadv_v_neigh_dump,
796 	},
797 	.orig = {
798 		.dump = batadv_v_orig_dump,
799 	},
800 	.gw = {
801 		.init_sel_class = batadv_v_init_sel_class,
802 		.sel_class_max = U32_MAX,
803 		.get_best_gw_node = batadv_v_gw_get_best_gw_node,
804 		.is_eligible = batadv_v_gw_is_eligible,
805 		.dump = batadv_v_gw_dump,
806 	},
807 };
808 
809 /**
810  * batadv_v_hardif_init() - initialize the algorithm specific fields in the
811  *  hard-interface object
812  * @hard_iface: the hard-interface to initialize
813  */
batadv_v_hardif_init(struct batadv_hard_iface * hard_iface)814 void batadv_v_hardif_init(struct batadv_hard_iface *hard_iface)
815 {
816 	/* enable link throughput auto-detection by setting the throughput
817 	 * override to zero
818 	 */
819 	atomic_set(&hard_iface->bat_v.throughput_override, 0);
820 	atomic_set(&hard_iface->bat_v.elp_interval, 500);
821 
822 	hard_iface->bat_v.aggr_len = 0;
823 	skb_queue_head_init(&hard_iface->bat_v.aggr_list);
824 	INIT_DELAYED_WORK(&hard_iface->bat_v.aggr_wq,
825 			  batadv_v_ogm_aggr_work);
826 }
827 
828 /**
829  * batadv_v_mesh_init() - initialize the B.A.T.M.A.N. V private resources for a
830  *  mesh
831  * @bat_priv: the object representing the mesh interface to initialise
832  *
833  * Return: 0 on success or a negative error code otherwise
834  */
batadv_v_mesh_init(struct batadv_priv * bat_priv)835 int batadv_v_mesh_init(struct batadv_priv *bat_priv)
836 {
837 	int ret = 0;
838 
839 	ret = batadv_v_ogm_init(bat_priv);
840 	if (ret < 0)
841 		return ret;
842 
843 	return 0;
844 }
845 
846 /**
847  * batadv_v_mesh_free() - free the B.A.T.M.A.N. V private resources for a mesh
848  * @bat_priv: the object representing the mesh interface to free
849  */
batadv_v_mesh_free(struct batadv_priv * bat_priv)850 void batadv_v_mesh_free(struct batadv_priv *bat_priv)
851 {
852 	batadv_v_ogm_free(bat_priv);
853 }
854 
855 /**
856  * batadv_v_init() - B.A.T.M.A.N. V initialization function
857  *
858  * Description: Takes care of initializing all the subcomponents.
859  * It is invoked upon module load only.
860  *
861  * Return: 0 on success or a negative error code otherwise
862  */
batadv_v_init(void)863 int __init batadv_v_init(void)
864 {
865 	int ret;
866 
867 	/* B.A.T.M.A.N. V echo location protocol packet  */
868 	ret = batadv_recv_handler_register(BATADV_ELP,
869 					   batadv_v_elp_packet_recv);
870 	if (ret < 0)
871 		return ret;
872 
873 	ret = batadv_recv_handler_register(BATADV_OGM2,
874 					   batadv_v_ogm_packet_recv);
875 	if (ret < 0)
876 		goto elp_unregister;
877 
878 	ret = batadv_algo_register(&batadv_batman_v);
879 	if (ret < 0)
880 		goto ogm_unregister;
881 
882 	return ret;
883 
884 ogm_unregister:
885 	batadv_recv_handler_unregister(BATADV_OGM2);
886 
887 elp_unregister:
888 	batadv_recv_handler_unregister(BATADV_ELP);
889 
890 	return ret;
891 }
892