Merge tag 'wireless-drivers-next-2021-08-22' of git://git.kernel.org/pub/scm/linux...
[linux-2.6-microblaze.git] / net / batman-adv / bat_v.c
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/list.h>
18 #include <linux/minmax.h>
19 #include <linux/netdevice.h>
20 #include <linux/netlink.h>
21 #include <linux/rculist.h>
22 #include <linux/rcupdate.h>
23 #include <linux/skbuff.h>
24 #include <linux/spinlock.h>
25 #include <linux/stddef.h>
26 #include <linux/types.h>
27 #include <linux/workqueue.h>
28 #include <net/genetlink.h>
29 #include <net/netlink.h>
30 #include <uapi/linux/batadv_packet.h>
31 #include <uapi/linux/batman_adv.h>
32
33 #include "bat_algo.h"
34 #include "bat_v_elp.h"
35 #include "bat_v_ogm.h"
36 #include "gateway_client.h"
37 #include "gateway_common.h"
38 #include "hard-interface.h"
39 #include "hash.h"
40 #include "log.h"
41 #include "netlink.h"
42 #include "originator.h"
43
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
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
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
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  */
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
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
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
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
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
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
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
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
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
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
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  */
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 static ssize_t batadv_v_store_sel_class(struct batadv_priv *bat_priv,
516                                         char *buff, size_t count)
517 {
518         u32 old_class, class;
519
520         if (!batadv_parse_throughput(bat_priv->soft_iface, buff,
521                                      "B.A.T.M.A.N. V GW selection class",
522                                      &class))
523                 return -EINVAL;
524
525         old_class = atomic_read(&bat_priv->gw.sel_class);
526         atomic_set(&bat_priv->gw.sel_class, class);
527
528         if (old_class != class)
529                 batadv_gw_reselect(bat_priv);
530
531         return count;
532 }
533
534 /**
535  * batadv_v_gw_throughput_get() - retrieve the GW-bandwidth for a given GW
536  * @gw_node: the GW to retrieve the metric for
537  * @bw: the pointer where the metric will be stored. The metric is computed as
538  *  the minimum between the GW advertised throughput and the path throughput to
539  *  it in the mesh
540  *
541  * Return: 0 on success, -1 on failure
542  */
543 static int batadv_v_gw_throughput_get(struct batadv_gw_node *gw_node, u32 *bw)
544 {
545         struct batadv_neigh_ifinfo *router_ifinfo = NULL;
546         struct batadv_orig_node *orig_node;
547         struct batadv_neigh_node *router;
548         int ret = -1;
549
550         orig_node = gw_node->orig_node;
551         router = batadv_orig_router_get(orig_node, BATADV_IF_DEFAULT);
552         if (!router)
553                 goto out;
554
555         router_ifinfo = batadv_neigh_ifinfo_get(router, BATADV_IF_DEFAULT);
556         if (!router_ifinfo)
557                 goto out;
558
559         /* the GW metric is computed as the minimum between the path throughput
560          * to reach the GW itself and the advertised bandwidth.
561          * This gives us an approximation of the effective throughput that the
562          * client can expect via this particular GW node
563          */
564         *bw = router_ifinfo->bat_v.throughput;
565         *bw = min_t(u32, *bw, gw_node->bandwidth_down);
566
567         ret = 0;
568 out:
569         batadv_neigh_node_put(router);
570         batadv_neigh_ifinfo_put(router_ifinfo);
571
572         return ret;
573 }
574
575 /**
576  * batadv_v_gw_get_best_gw_node() - retrieve the best GW node
577  * @bat_priv: the bat priv with all the soft interface information
578  *
579  * Return: the GW node having the best GW-metric, NULL if no GW is known
580  */
581 static struct batadv_gw_node *
582 batadv_v_gw_get_best_gw_node(struct batadv_priv *bat_priv)
583 {
584         struct batadv_gw_node *gw_node, *curr_gw = NULL;
585         u32 max_bw = 0, bw;
586
587         rcu_read_lock();
588         hlist_for_each_entry_rcu(gw_node, &bat_priv->gw.gateway_list, list) {
589                 if (!kref_get_unless_zero(&gw_node->refcount))
590                         continue;
591
592                 if (batadv_v_gw_throughput_get(gw_node, &bw) < 0)
593                         goto next;
594
595                 if (curr_gw && bw <= max_bw)
596                         goto next;
597
598                 batadv_gw_node_put(curr_gw);
599
600                 curr_gw = gw_node;
601                 kref_get(&curr_gw->refcount);
602                 max_bw = bw;
603
604 next:
605                 batadv_gw_node_put(gw_node);
606         }
607         rcu_read_unlock();
608
609         return curr_gw;
610 }
611
612 /**
613  * batadv_v_gw_is_eligible() - check if a originator would be selected as GW
614  * @bat_priv: the bat priv with all the soft interface information
615  * @curr_gw_orig: originator representing the currently selected GW
616  * @orig_node: the originator representing the new candidate
617  *
618  * Return: true if orig_node can be selected as current GW, false otherwise
619  */
620 static bool batadv_v_gw_is_eligible(struct batadv_priv *bat_priv,
621                                     struct batadv_orig_node *curr_gw_orig,
622                                     struct batadv_orig_node *orig_node)
623 {
624         struct batadv_gw_node *curr_gw, *orig_gw = NULL;
625         u32 gw_throughput, orig_throughput, threshold;
626         bool ret = false;
627
628         threshold = atomic_read(&bat_priv->gw.sel_class);
629
630         curr_gw = batadv_gw_node_get(bat_priv, curr_gw_orig);
631         if (!curr_gw) {
632                 ret = true;
633                 goto out;
634         }
635
636         if (batadv_v_gw_throughput_get(curr_gw, &gw_throughput) < 0) {
637                 ret = true;
638                 goto out;
639         }
640
641         orig_gw = batadv_gw_node_get(bat_priv, orig_node);
642         if (!orig_gw)
643                 goto out;
644
645         if (batadv_v_gw_throughput_get(orig_gw, &orig_throughput) < 0)
646                 goto out;
647
648         if (orig_throughput < gw_throughput)
649                 goto out;
650
651         if ((orig_throughput - gw_throughput) < threshold)
652                 goto out;
653
654         batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
655                    "Restarting gateway selection: better gateway found (throughput curr: %u, throughput new: %u)\n",
656                    gw_throughput, orig_throughput);
657
658         ret = true;
659 out:
660         batadv_gw_node_put(curr_gw);
661         batadv_gw_node_put(orig_gw);
662
663         return ret;
664 }
665
666 /**
667  * batadv_v_gw_dump_entry() - Dump a gateway into a message
668  * @msg: Netlink message to dump into
669  * @portid: Port making netlink request
670  * @cb: Control block containing additional options
671  * @bat_priv: The bat priv with all the soft interface information
672  * @gw_node: Gateway to be dumped
673  *
674  * Return: Error code, or 0 on success
675  */
676 static int batadv_v_gw_dump_entry(struct sk_buff *msg, u32 portid,
677                                   struct netlink_callback *cb,
678                                   struct batadv_priv *bat_priv,
679                                   struct batadv_gw_node *gw_node)
680 {
681         struct batadv_neigh_ifinfo *router_ifinfo = NULL;
682         struct batadv_neigh_node *router;
683         struct batadv_gw_node *curr_gw = NULL;
684         int ret = 0;
685         void *hdr;
686
687         router = batadv_orig_router_get(gw_node->orig_node, BATADV_IF_DEFAULT);
688         if (!router)
689                 goto out;
690
691         router_ifinfo = batadv_neigh_ifinfo_get(router, BATADV_IF_DEFAULT);
692         if (!router_ifinfo)
693                 goto out;
694
695         curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
696
697         hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq,
698                           &batadv_netlink_family, NLM_F_MULTI,
699                           BATADV_CMD_GET_GATEWAYS);
700         if (!hdr) {
701                 ret = -ENOBUFS;
702                 goto out;
703         }
704
705         genl_dump_check_consistent(cb, hdr);
706
707         ret = -EMSGSIZE;
708
709         if (curr_gw == gw_node) {
710                 if (nla_put_flag(msg, BATADV_ATTR_FLAG_BEST)) {
711                         genlmsg_cancel(msg, hdr);
712                         goto out;
713                 }
714         }
715
716         if (nla_put(msg, BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN,
717                     gw_node->orig_node->orig)) {
718                 genlmsg_cancel(msg, hdr);
719                 goto out;
720         }
721
722         if (nla_put_u32(msg, BATADV_ATTR_THROUGHPUT,
723                         router_ifinfo->bat_v.throughput)) {
724                 genlmsg_cancel(msg, hdr);
725                 goto out;
726         }
727
728         if (nla_put(msg, BATADV_ATTR_ROUTER, ETH_ALEN, router->addr)) {
729                 genlmsg_cancel(msg, hdr);
730                 goto out;
731         }
732
733         if (nla_put_string(msg, BATADV_ATTR_HARD_IFNAME,
734                            router->if_incoming->net_dev->name)) {
735                 genlmsg_cancel(msg, hdr);
736                 goto out;
737         }
738
739         if (nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX,
740                         router->if_incoming->net_dev->ifindex)) {
741                 genlmsg_cancel(msg, hdr);
742                 goto out;
743         }
744
745         if (nla_put_u32(msg, BATADV_ATTR_BANDWIDTH_DOWN,
746                         gw_node->bandwidth_down)) {
747                 genlmsg_cancel(msg, hdr);
748                 goto out;
749         }
750
751         if (nla_put_u32(msg, BATADV_ATTR_BANDWIDTH_UP, gw_node->bandwidth_up)) {
752                 genlmsg_cancel(msg, hdr);
753                 goto out;
754         }
755
756         genlmsg_end(msg, hdr);
757         ret = 0;
758
759 out:
760         batadv_gw_node_put(curr_gw);
761         batadv_neigh_ifinfo_put(router_ifinfo);
762         batadv_neigh_node_put(router);
763         return ret;
764 }
765
766 /**
767  * batadv_v_gw_dump() - Dump gateways into a message
768  * @msg: Netlink message to dump into
769  * @cb: Control block containing additional options
770  * @bat_priv: The bat priv with all the soft interface information
771  */
772 static void batadv_v_gw_dump(struct sk_buff *msg, struct netlink_callback *cb,
773                              struct batadv_priv *bat_priv)
774 {
775         int portid = NETLINK_CB(cb->skb).portid;
776         struct batadv_gw_node *gw_node;
777         int idx_skip = cb->args[0];
778         int idx = 0;
779
780         spin_lock_bh(&bat_priv->gw.list_lock);
781         cb->seq = bat_priv->gw.generation << 1 | 1;
782
783         hlist_for_each_entry(gw_node, &bat_priv->gw.gateway_list, list) {
784                 if (idx++ < idx_skip)
785                         continue;
786
787                 if (batadv_v_gw_dump_entry(msg, portid, cb, bat_priv,
788                                            gw_node)) {
789                         idx_skip = idx - 1;
790                         goto unlock;
791                 }
792         }
793
794         idx_skip = idx;
795 unlock:
796         spin_unlock_bh(&bat_priv->gw.list_lock);
797
798         cb->args[0] = idx_skip;
799 }
800
801 static struct batadv_algo_ops batadv_batman_v __read_mostly = {
802         .name = "BATMAN_V",
803         .iface = {
804                 .activate = batadv_v_iface_activate,
805                 .enable = batadv_v_iface_enable,
806                 .disable = batadv_v_iface_disable,
807                 .update_mac = batadv_v_iface_update_mac,
808                 .primary_set = batadv_v_primary_iface_set,
809         },
810         .neigh = {
811                 .hardif_init = batadv_v_hardif_neigh_init,
812                 .cmp = batadv_v_neigh_cmp,
813                 .is_similar_or_better = batadv_v_neigh_is_sob,
814                 .dump = batadv_v_neigh_dump,
815         },
816         .orig = {
817                 .dump = batadv_v_orig_dump,
818         },
819         .gw = {
820                 .init_sel_class = batadv_v_init_sel_class,
821                 .store_sel_class = batadv_v_store_sel_class,
822                 .get_best_gw_node = batadv_v_gw_get_best_gw_node,
823                 .is_eligible = batadv_v_gw_is_eligible,
824                 .dump = batadv_v_gw_dump,
825         },
826 };
827
828 /**
829  * batadv_v_hardif_init() - initialize the algorithm specific fields in the
830  *  hard-interface object
831  * @hard_iface: the hard-interface to initialize
832  */
833 void batadv_v_hardif_init(struct batadv_hard_iface *hard_iface)
834 {
835         /* enable link throughput auto-detection by setting the throughput
836          * override to zero
837          */
838         atomic_set(&hard_iface->bat_v.throughput_override, 0);
839         atomic_set(&hard_iface->bat_v.elp_interval, 500);
840
841         hard_iface->bat_v.aggr_len = 0;
842         skb_queue_head_init(&hard_iface->bat_v.aggr_list);
843         INIT_DELAYED_WORK(&hard_iface->bat_v.aggr_wq,
844                           batadv_v_ogm_aggr_work);
845 }
846
847 /**
848  * batadv_v_mesh_init() - initialize the B.A.T.M.A.N. V private resources for a
849  *  mesh
850  * @bat_priv: the object representing the mesh interface to initialise
851  *
852  * Return: 0 on success or a negative error code otherwise
853  */
854 int batadv_v_mesh_init(struct batadv_priv *bat_priv)
855 {
856         int ret = 0;
857
858         ret = batadv_v_ogm_init(bat_priv);
859         if (ret < 0)
860                 return ret;
861
862         return 0;
863 }
864
865 /**
866  * batadv_v_mesh_free() - free the B.A.T.M.A.N. V private resources for a mesh
867  * @bat_priv: the object representing the mesh interface to free
868  */
869 void batadv_v_mesh_free(struct batadv_priv *bat_priv)
870 {
871         batadv_v_ogm_free(bat_priv);
872 }
873
874 /**
875  * batadv_v_init() - B.A.T.M.A.N. V initialization function
876  *
877  * Description: Takes care of initializing all the subcomponents.
878  * It is invoked upon module load only.
879  *
880  * Return: 0 on success or a negative error code otherwise
881  */
882 int __init batadv_v_init(void)
883 {
884         int ret;
885
886         /* B.A.T.M.A.N. V echo location protocol packet  */
887         ret = batadv_recv_handler_register(BATADV_ELP,
888                                            batadv_v_elp_packet_recv);
889         if (ret < 0)
890                 return ret;
891
892         ret = batadv_recv_handler_register(BATADV_OGM2,
893                                            batadv_v_ogm_packet_recv);
894         if (ret < 0)
895                 goto elp_unregister;
896
897         ret = batadv_algo_register(&batadv_batman_v);
898         if (ret < 0)
899                 goto ogm_unregister;
900
901         return ret;
902
903 ogm_unregister:
904         batadv_recv_handler_unregister(BATADV_OGM2);
905
906 elp_unregister:
907         batadv_recv_handler_unregister(BATADV_ELP);
908
909         return ret;
910 }