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

source code of linux/net/batman-adv/bat_v.c