]>
Commit | Line | Data |
---|---|---|
ac79cbb9 | 1 | /* Copyright (C) 2013-2017 B.A.T.M.A.N. contributors: |
d6f94d91 LL |
2 | * |
3 | * Linus Lüssing, Marek Lindner | |
4 | * | |
5 | * This program is free software; you can redistribute it and/or | |
6 | * modify it under the terms of version 2 of the GNU General Public | |
7 | * License as published by the Free Software Foundation. | |
8 | * | |
9 | * This program is distributed in the hope that it will be useful, but | |
10 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
12 | * General Public License for more details. | |
13 | * | |
14 | * You should have received a copy of the GNU General Public License | |
15 | * along with this program; if not, see <http://www.gnu.org/licenses/>. | |
16 | */ | |
17 | ||
a2d08166 | 18 | #include "bat_v.h" |
d6f94d91 LL |
19 | #include "main.h" |
20 | ||
0b5ecc68 | 21 | #include <linux/atomic.h> |
97869060 | 22 | #include <linux/bug.h> |
d6f94d91 | 23 | #include <linux/cache.h> |
08686943 | 24 | #include <linux/errno.h> |
f02a478f | 25 | #include <linux/if_ether.h> |
d6f94d91 | 26 | #include <linux/init.h> |
261e264d | 27 | #include <linux/jiffies.h> |
08686943 | 28 | #include <linux/kernel.h> |
50164d8f | 29 | #include <linux/kref.h> |
261e264d | 30 | #include <linux/netdevice.h> |
f02a478f | 31 | #include <linux/netlink.h> |
261e264d AQ |
32 | #include <linux/rculist.h> |
33 | #include <linux/rcupdate.h> | |
34 | #include <linux/seq_file.h> | |
a45e932a | 35 | #include <linux/stddef.h> |
97869060 | 36 | #include <linux/types.h> |
c833484e | 37 | #include <linux/workqueue.h> |
f02a478f MS |
38 | #include <net/genetlink.h> |
39 | #include <net/netlink.h> | |
40 | #include <uapi/linux/batman_adv.h> | |
d6f94d91 | 41 | |
a2d08166 | 42 | #include "bat_algo.h" |
d6f94d91 | 43 | #include "bat_v_elp.h" |
0da00359 | 44 | #include "bat_v_ogm.h" |
08686943 AQ |
45 | #include "gateway_client.h" |
46 | #include "gateway_common.h" | |
b6cf5d49 | 47 | #include "hard-interface.h" |
261e264d | 48 | #include "hash.h" |
50164d8f | 49 | #include "log.h" |
f02a478f | 50 | #include "netlink.h" |
97869060 | 51 | #include "originator.h" |
162bd64c | 52 | #include "packet.h" |
d6f94d91 | 53 | |
f02a478f MS |
54 | struct sk_buff; |
55 | ||
b6cf5d49 AQ |
56 | static void batadv_v_iface_activate(struct batadv_hard_iface *hard_iface) |
57 | { | |
ebe24cea ML |
58 | struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface); |
59 | struct batadv_hard_iface *primary_if; | |
60 | ||
61 | primary_if = batadv_primary_if_get_selected(bat_priv); | |
62 | ||
63 | if (primary_if) { | |
64 | batadv_v_elp_iface_activate(primary_if, hard_iface); | |
65 | batadv_hardif_put(primary_if); | |
66 | } | |
67 | ||
b6cf5d49 AQ |
68 | /* B.A.T.M.A.N. V does not use any queuing mechanism, therefore it can |
69 | * set the interface as ACTIVE right away, without any risk of race | |
70 | * condition | |
71 | */ | |
72 | if (hard_iface->if_status == BATADV_IF_TO_BE_ACTIVATED) | |
73 | hard_iface->if_status = BATADV_IF_ACTIVE; | |
74 | } | |
75 | ||
d6f94d91 LL |
76 | static int batadv_v_iface_enable(struct batadv_hard_iface *hard_iface) |
77 | { | |
0da00359 AQ |
78 | int ret; |
79 | ||
80 | ret = batadv_v_elp_iface_enable(hard_iface); | |
81 | if (ret < 0) | |
82 | return ret; | |
83 | ||
84 | ret = batadv_v_ogm_iface_enable(hard_iface); | |
85 | if (ret < 0) | |
86 | batadv_v_elp_iface_disable(hard_iface); | |
87 | ||
88 | return ret; | |
d6f94d91 LL |
89 | } |
90 | ||
91 | static void batadv_v_iface_disable(struct batadv_hard_iface *hard_iface) | |
92 | { | |
93 | batadv_v_elp_iface_disable(hard_iface); | |
94 | } | |
95 | ||
d6f94d91 LL |
96 | static void batadv_v_primary_iface_set(struct batadv_hard_iface *hard_iface) |
97 | { | |
98 | batadv_v_elp_primary_iface_set(hard_iface); | |
0da00359 | 99 | batadv_v_ogm_primary_iface_set(hard_iface); |
d6f94d91 LL |
100 | } |
101 | ||
1653f61d AQ |
102 | /** |
103 | * batadv_v_iface_update_mac - react to hard-interface MAC address change | |
104 | * @hard_iface: the modified interface | |
105 | * | |
106 | * If the modified interface is the primary one, update the originator | |
107 | * address in the ELP and OGM messages to reflect the new MAC address. | |
108 | */ | |
109 | static void batadv_v_iface_update_mac(struct batadv_hard_iface *hard_iface) | |
110 | { | |
111 | struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface); | |
112 | struct batadv_hard_iface *primary_if; | |
113 | ||
114 | primary_if = batadv_primary_if_get_selected(bat_priv); | |
115 | if (primary_if != hard_iface) | |
116 | goto out; | |
117 | ||
118 | batadv_v_primary_iface_set(hard_iface); | |
119 | out: | |
120 | if (primary_if) | |
121 | batadv_hardif_put(primary_if); | |
122 | } | |
123 | ||
162bd64c LL |
124 | static void |
125 | batadv_v_hardif_neigh_init(struct batadv_hardif_neigh_node *hardif_neigh) | |
126 | { | |
127 | ewma_throughput_init(&hardif_neigh->bat_v.throughput); | |
c833484e AQ |
128 | INIT_WORK(&hardif_neigh->bat_v.metric_work, |
129 | batadv_v_elp_throughput_metric_update); | |
162bd64c LL |
130 | } |
131 | ||
dc1cbd14 | 132 | #ifdef CONFIG_BATMAN_ADV_DEBUGFS |
261e264d AQ |
133 | /** |
134 | * batadv_v_orig_print_neigh - print neighbors for the originator table | |
135 | * @orig_node: the orig_node for which the neighbors are printed | |
136 | * @if_outgoing: outgoing interface for these entries | |
137 | * @seq: debugfs table seq_file struct | |
138 | * | |
139 | * Must be called while holding an rcu lock. | |
140 | */ | |
141 | static void | |
142 | batadv_v_orig_print_neigh(struct batadv_orig_node *orig_node, | |
143 | struct batadv_hard_iface *if_outgoing, | |
144 | struct seq_file *seq) | |
145 | { | |
146 | struct batadv_neigh_node *neigh_node; | |
147 | struct batadv_neigh_ifinfo *n_ifinfo; | |
148 | ||
149 | hlist_for_each_entry_rcu(neigh_node, &orig_node->neigh_list, list) { | |
150 | n_ifinfo = batadv_neigh_ifinfo_get(neigh_node, if_outgoing); | |
151 | if (!n_ifinfo) | |
152 | continue; | |
153 | ||
154 | seq_printf(seq, " %pM (%9u.%1u)", | |
155 | neigh_node->addr, | |
156 | n_ifinfo->bat_v.throughput / 10, | |
157 | n_ifinfo->bat_v.throughput % 10); | |
158 | ||
159 | batadv_neigh_ifinfo_put(n_ifinfo); | |
160 | } | |
161 | } | |
162 | ||
626d23e8 LL |
163 | /** |
164 | * batadv_v_hardif_neigh_print - print a single ELP neighbour node | |
165 | * @seq: neighbour table seq_file struct | |
166 | * @hardif_neigh: hardif neighbour information | |
167 | */ | |
168 | static void | |
169 | batadv_v_hardif_neigh_print(struct seq_file *seq, | |
170 | struct batadv_hardif_neigh_node *hardif_neigh) | |
171 | { | |
172 | int last_secs, last_msecs; | |
173 | u32 throughput; | |
174 | ||
175 | last_secs = jiffies_to_msecs(jiffies - hardif_neigh->last_seen) / 1000; | |
176 | last_msecs = jiffies_to_msecs(jiffies - hardif_neigh->last_seen) % 1000; | |
177 | throughput = ewma_throughput_read(&hardif_neigh->bat_v.throughput); | |
178 | ||
179 | seq_printf(seq, "%pM %4i.%03is (%9u.%1u) [%10s]\n", | |
180 | hardif_neigh->addr, last_secs, last_msecs, throughput / 10, | |
181 | throughput % 10, hardif_neigh->if_incoming->net_dev->name); | |
182 | } | |
183 | ||
184 | /** | |
185 | * batadv_v_neigh_print - print the single hop neighbour list | |
186 | * @bat_priv: the bat priv with all the soft interface information | |
187 | * @seq: neighbour table seq_file struct | |
188 | */ | |
189 | static void batadv_v_neigh_print(struct batadv_priv *bat_priv, | |
190 | struct seq_file *seq) | |
191 | { | |
192 | struct net_device *net_dev = (struct net_device *)seq->private; | |
193 | struct batadv_hardif_neigh_node *hardif_neigh; | |
194 | struct batadv_hard_iface *hard_iface; | |
195 | int batman_count = 0; | |
196 | ||
925a6f37 AQ |
197 | seq_puts(seq, |
198 | " Neighbor last-seen ( throughput) [ IF]\n"); | |
626d23e8 LL |
199 | |
200 | rcu_read_lock(); | |
201 | list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { | |
202 | if (hard_iface->soft_iface != net_dev) | |
203 | continue; | |
204 | ||
205 | hlist_for_each_entry_rcu(hardif_neigh, | |
206 | &hard_iface->neigh_list, list) { | |
207 | batadv_v_hardif_neigh_print(seq, hardif_neigh); | |
208 | batman_count++; | |
209 | } | |
210 | } | |
211 | rcu_read_unlock(); | |
212 | ||
213 | if (batman_count == 0) | |
214 | seq_puts(seq, "No batman nodes in range ...\n"); | |
215 | } | |
dc1cbd14 | 216 | #endif |
626d23e8 | 217 | |
f02a478f MS |
218 | /** |
219 | * batadv_v_neigh_dump_neigh - Dump a neighbour into a message | |
220 | * @msg: Netlink message to dump into | |
221 | * @portid: Port making netlink request | |
222 | * @seq: Sequence number of netlink message | |
223 | * @hardif_neigh: Neighbour to dump | |
224 | * | |
225 | * Return: Error code, or 0 on success | |
226 | */ | |
227 | static int | |
228 | batadv_v_neigh_dump_neigh(struct sk_buff *msg, u32 portid, u32 seq, | |
229 | struct batadv_hardif_neigh_node *hardif_neigh) | |
230 | { | |
231 | void *hdr; | |
232 | unsigned int last_seen_msecs; | |
233 | u32 throughput; | |
234 | ||
235 | last_seen_msecs = jiffies_to_msecs(jiffies - hardif_neigh->last_seen); | |
236 | throughput = ewma_throughput_read(&hardif_neigh->bat_v.throughput); | |
237 | throughput = throughput * 100; | |
238 | ||
239 | hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family, NLM_F_MULTI, | |
240 | BATADV_CMD_GET_NEIGHBORS); | |
241 | if (!hdr) | |
242 | return -ENOBUFS; | |
243 | ||
244 | if (nla_put(msg, BATADV_ATTR_NEIGH_ADDRESS, ETH_ALEN, | |
245 | hardif_neigh->addr) || | |
246 | nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX, | |
247 | hardif_neigh->if_incoming->net_dev->ifindex) || | |
248 | nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS, | |
249 | last_seen_msecs) || | |
250 | nla_put_u32(msg, BATADV_ATTR_THROUGHPUT, throughput)) | |
251 | goto nla_put_failure; | |
252 | ||
253 | genlmsg_end(msg, hdr); | |
254 | return 0; | |
255 | ||
256 | nla_put_failure: | |
257 | genlmsg_cancel(msg, hdr); | |
258 | return -EMSGSIZE; | |
259 | } | |
260 | ||
261 | /** | |
262 | * batadv_v_neigh_dump_hardif - Dump the neighbours of a hard interface into | |
263 | * a message | |
264 | * @msg: Netlink message to dump into | |
265 | * @portid: Port making netlink request | |
266 | * @seq: Sequence number of netlink message | |
267 | * @bat_priv: The bat priv with all the soft interface information | |
268 | * @hard_iface: The hard interface to be dumped | |
269 | * @idx_s: Entries to be skipped | |
270 | * | |
271 | * This function assumes the caller holds rcu_read_lock(). | |
272 | * | |
273 | * Return: Error code, or 0 on success | |
274 | */ | |
275 | static int | |
276 | batadv_v_neigh_dump_hardif(struct sk_buff *msg, u32 portid, u32 seq, | |
277 | struct batadv_priv *bat_priv, | |
278 | struct batadv_hard_iface *hard_iface, | |
279 | int *idx_s) | |
280 | { | |
281 | struct batadv_hardif_neigh_node *hardif_neigh; | |
282 | int idx = 0; | |
283 | ||
284 | hlist_for_each_entry_rcu(hardif_neigh, | |
285 | &hard_iface->neigh_list, list) { | |
286 | if (idx++ < *idx_s) | |
287 | continue; | |
288 | ||
289 | if (batadv_v_neigh_dump_neigh(msg, portid, seq, hardif_neigh)) { | |
290 | *idx_s = idx - 1; | |
291 | return -EMSGSIZE; | |
292 | } | |
293 | } | |
294 | ||
295 | *idx_s = 0; | |
296 | return 0; | |
297 | } | |
298 | ||
299 | /** | |
300 | * batadv_v_neigh_dump - Dump the neighbours of a hard interface into a | |
301 | * message | |
302 | * @msg: Netlink message to dump into | |
303 | * @cb: Control block containing additional options | |
304 | * @bat_priv: The bat priv with all the soft interface information | |
305 | * @single_hardif: Limit dumping to this hard interface | |
306 | */ | |
307 | static void | |
308 | batadv_v_neigh_dump(struct sk_buff *msg, struct netlink_callback *cb, | |
309 | struct batadv_priv *bat_priv, | |
310 | struct batadv_hard_iface *single_hardif) | |
311 | { | |
312 | struct batadv_hard_iface *hard_iface; | |
313 | int i_hardif = 0; | |
314 | int i_hardif_s = cb->args[0]; | |
315 | int idx = cb->args[1]; | |
316 | int portid = NETLINK_CB(cb->skb).portid; | |
317 | ||
318 | rcu_read_lock(); | |
319 | if (single_hardif) { | |
320 | if (i_hardif_s == 0) { | |
321 | if (batadv_v_neigh_dump_hardif(msg, portid, | |
322 | cb->nlh->nlmsg_seq, | |
323 | bat_priv, single_hardif, | |
324 | &idx) == 0) | |
325 | i_hardif++; | |
326 | } | |
327 | } else { | |
328 | list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { | |
329 | if (hard_iface->soft_iface != bat_priv->soft_iface) | |
330 | continue; | |
331 | ||
332 | if (i_hardif++ < i_hardif_s) | |
333 | continue; | |
334 | ||
335 | if (batadv_v_neigh_dump_hardif(msg, portid, | |
336 | cb->nlh->nlmsg_seq, | |
337 | bat_priv, hard_iface, | |
338 | &idx)) { | |
339 | i_hardif--; | |
340 | break; | |
341 | } | |
342 | } | |
343 | } | |
344 | rcu_read_unlock(); | |
345 | ||
346 | cb->args[0] = i_hardif; | |
347 | cb->args[1] = idx; | |
348 | } | |
349 | ||
dc1cbd14 | 350 | #ifdef CONFIG_BATMAN_ADV_DEBUGFS |
261e264d AQ |
351 | /** |
352 | * batadv_v_orig_print - print the originator table | |
353 | * @bat_priv: the bat priv with all the soft interface information | |
354 | * @seq: debugfs table seq_file struct | |
355 | * @if_outgoing: the outgoing interface for which this should be printed | |
356 | */ | |
357 | static void batadv_v_orig_print(struct batadv_priv *bat_priv, | |
358 | struct seq_file *seq, | |
359 | struct batadv_hard_iface *if_outgoing) | |
360 | { | |
361 | struct batadv_neigh_node *neigh_node; | |
362 | struct batadv_hashtable *hash = bat_priv->orig_hash; | |
363 | int last_seen_msecs, last_seen_secs; | |
364 | struct batadv_orig_node *orig_node; | |
365 | struct batadv_neigh_ifinfo *n_ifinfo; | |
366 | unsigned long last_seen_jiffies; | |
367 | struct hlist_head *head; | |
368 | int batman_count = 0; | |
369 | u32 i; | |
370 | ||
925a6f37 AQ |
371 | seq_puts(seq, |
372 | " Originator last-seen ( throughput) Nexthop [outgoingIF]: Potential nexthops ...\n"); | |
261e264d AQ |
373 | |
374 | for (i = 0; i < hash->size; i++) { | |
375 | head = &hash->table[i]; | |
376 | ||
377 | rcu_read_lock(); | |
378 | hlist_for_each_entry_rcu(orig_node, head, hash_entry) { | |
379 | neigh_node = batadv_orig_router_get(orig_node, | |
380 | if_outgoing); | |
381 | if (!neigh_node) | |
382 | continue; | |
383 | ||
384 | n_ifinfo = batadv_neigh_ifinfo_get(neigh_node, | |
385 | if_outgoing); | |
386 | if (!n_ifinfo) | |
387 | goto next; | |
388 | ||
389 | last_seen_jiffies = jiffies - orig_node->last_seen; | |
390 | last_seen_msecs = jiffies_to_msecs(last_seen_jiffies); | |
391 | last_seen_secs = last_seen_msecs / 1000; | |
392 | last_seen_msecs = last_seen_msecs % 1000; | |
393 | ||
394 | seq_printf(seq, "%pM %4i.%03is (%9u.%1u) %pM [%10s]:", | |
395 | orig_node->orig, last_seen_secs, | |
396 | last_seen_msecs, | |
397 | n_ifinfo->bat_v.throughput / 10, | |
398 | n_ifinfo->bat_v.throughput % 10, | |
399 | neigh_node->addr, | |
400 | neigh_node->if_incoming->net_dev->name); | |
401 | ||
402 | batadv_v_orig_print_neigh(orig_node, if_outgoing, seq); | |
626caae9 | 403 | seq_putc(seq, '\n'); |
261e264d AQ |
404 | batman_count++; |
405 | ||
406 | next: | |
407 | batadv_neigh_node_put(neigh_node); | |
408 | if (n_ifinfo) | |
409 | batadv_neigh_ifinfo_put(n_ifinfo); | |
410 | } | |
411 | rcu_read_unlock(); | |
412 | } | |
413 | ||
414 | if (batman_count == 0) | |
415 | seq_puts(seq, "No batman nodes in range ...\n"); | |
416 | } | |
dc1cbd14 | 417 | #endif |
261e264d | 418 | |
f02a478f MS |
419 | /** |
420 | * batadv_v_orig_dump_subentry - Dump an originator subentry into a | |
421 | * message | |
422 | * @msg: Netlink message to dump into | |
423 | * @portid: Port making netlink request | |
424 | * @seq: Sequence number of netlink message | |
425 | * @bat_priv: The bat priv with all the soft interface information | |
426 | * @if_outgoing: Limit dump to entries with this outgoing interface | |
427 | * @orig_node: Originator to dump | |
428 | * @neigh_node: Single hops neighbour | |
429 | * @best: Is the best originator | |
430 | * | |
431 | * Return: Error code, or 0 on success | |
432 | */ | |
433 | static int | |
434 | batadv_v_orig_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq, | |
435 | struct batadv_priv *bat_priv, | |
436 | struct batadv_hard_iface *if_outgoing, | |
437 | struct batadv_orig_node *orig_node, | |
438 | struct batadv_neigh_node *neigh_node, | |
439 | bool best) | |
440 | { | |
441 | struct batadv_neigh_ifinfo *n_ifinfo; | |
442 | unsigned int last_seen_msecs; | |
443 | u32 throughput; | |
444 | void *hdr; | |
445 | ||
446 | n_ifinfo = batadv_neigh_ifinfo_get(neigh_node, if_outgoing); | |
447 | if (!n_ifinfo) | |
448 | return 0; | |
449 | ||
450 | throughput = n_ifinfo->bat_v.throughput * 100; | |
451 | ||
452 | batadv_neigh_ifinfo_put(n_ifinfo); | |
453 | ||
454 | last_seen_msecs = jiffies_to_msecs(jiffies - orig_node->last_seen); | |
455 | ||
456 | if (if_outgoing != BATADV_IF_DEFAULT && | |
457 | if_outgoing != neigh_node->if_incoming) | |
458 | return 0; | |
459 | ||
460 | hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family, NLM_F_MULTI, | |
461 | BATADV_CMD_GET_ORIGINATORS); | |
462 | if (!hdr) | |
463 | return -ENOBUFS; | |
464 | ||
465 | if (nla_put(msg, BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN, orig_node->orig) || | |
466 | nla_put(msg, BATADV_ATTR_NEIGH_ADDRESS, ETH_ALEN, | |
467 | neigh_node->addr) || | |
468 | nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX, | |
469 | neigh_node->if_incoming->net_dev->ifindex) || | |
470 | nla_put_u32(msg, BATADV_ATTR_THROUGHPUT, throughput) || | |
471 | nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS, | |
472 | last_seen_msecs)) | |
473 | goto nla_put_failure; | |
474 | ||
475 | if (best && nla_put_flag(msg, BATADV_ATTR_FLAG_BEST)) | |
476 | goto nla_put_failure; | |
477 | ||
478 | genlmsg_end(msg, hdr); | |
479 | return 0; | |
480 | ||
481 | nla_put_failure: | |
482 | genlmsg_cancel(msg, hdr); | |
483 | return -EMSGSIZE; | |
484 | } | |
485 | ||
486 | /** | |
487 | * batadv_v_orig_dump_entry - Dump an originator entry into a message | |
488 | * @msg: Netlink message to dump into | |
489 | * @portid: Port making netlink request | |
490 | * @seq: Sequence number of netlink message | |
491 | * @bat_priv: The bat priv with all the soft interface information | |
492 | * @if_outgoing: Limit dump to entries with this outgoing interface | |
493 | * @orig_node: Originator to dump | |
494 | * @sub_s: Number of sub entries to skip | |
495 | * | |
496 | * This function assumes the caller holds rcu_read_lock(). | |
497 | * | |
498 | * Return: Error code, or 0 on success | |
499 | */ | |
500 | static int | |
501 | batadv_v_orig_dump_entry(struct sk_buff *msg, u32 portid, u32 seq, | |
502 | struct batadv_priv *bat_priv, | |
503 | struct batadv_hard_iface *if_outgoing, | |
504 | struct batadv_orig_node *orig_node, int *sub_s) | |
505 | { | |
506 | struct batadv_neigh_node *neigh_node_best; | |
507 | struct batadv_neigh_node *neigh_node; | |
508 | int sub = 0; | |
509 | bool best; | |
510 | ||
511 | neigh_node_best = batadv_orig_router_get(orig_node, if_outgoing); | |
512 | if (!neigh_node_best) | |
513 | goto out; | |
514 | ||
515 | hlist_for_each_entry_rcu(neigh_node, &orig_node->neigh_list, list) { | |
516 | if (sub++ < *sub_s) | |
517 | continue; | |
518 | ||
519 | best = (neigh_node == neigh_node_best); | |
520 | ||
521 | if (batadv_v_orig_dump_subentry(msg, portid, seq, bat_priv, | |
522 | if_outgoing, orig_node, | |
523 | neigh_node, best)) { | |
524 | batadv_neigh_node_put(neigh_node_best); | |
525 | ||
526 | *sub_s = sub - 1; | |
527 | return -EMSGSIZE; | |
528 | } | |
529 | } | |
530 | ||
531 | out: | |
532 | if (neigh_node_best) | |
533 | batadv_neigh_node_put(neigh_node_best); | |
534 | ||
535 | *sub_s = 0; | |
536 | return 0; | |
537 | } | |
538 | ||
539 | /** | |
540 | * batadv_v_orig_dump_bucket - Dump an originator bucket into a | |
541 | * message | |
542 | * @msg: Netlink message to dump into | |
543 | * @portid: Port making netlink request | |
544 | * @seq: Sequence number of netlink message | |
545 | * @bat_priv: The bat priv with all the soft interface information | |
546 | * @if_outgoing: Limit dump to entries with this outgoing interface | |
547 | * @head: Bucket to be dumped | |
548 | * @idx_s: Number of entries to be skipped | |
549 | * @sub: Number of sub entries to be skipped | |
550 | * | |
551 | * Return: Error code, or 0 on success | |
552 | */ | |
553 | static int | |
554 | batadv_v_orig_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq, | |
555 | struct batadv_priv *bat_priv, | |
556 | struct batadv_hard_iface *if_outgoing, | |
557 | struct hlist_head *head, int *idx_s, int *sub) | |
558 | { | |
559 | struct batadv_orig_node *orig_node; | |
560 | int idx = 0; | |
561 | ||
562 | rcu_read_lock(); | |
563 | hlist_for_each_entry_rcu(orig_node, head, hash_entry) { | |
564 | if (idx++ < *idx_s) | |
565 | continue; | |
566 | ||
567 | if (batadv_v_orig_dump_entry(msg, portid, seq, bat_priv, | |
568 | if_outgoing, orig_node, sub)) { | |
569 | rcu_read_unlock(); | |
570 | *idx_s = idx - 1; | |
571 | return -EMSGSIZE; | |
572 | } | |
573 | } | |
574 | rcu_read_unlock(); | |
575 | ||
576 | *idx_s = 0; | |
577 | *sub = 0; | |
578 | return 0; | |
579 | } | |
580 | ||
581 | /** | |
582 | * batadv_v_orig_dump - Dump the originators into a message | |
583 | * @msg: Netlink message to dump into | |
584 | * @cb: Control block containing additional options | |
585 | * @bat_priv: The bat priv with all the soft interface information | |
586 | * @if_outgoing: Limit dump to entries with this outgoing interface | |
587 | */ | |
588 | static void | |
589 | batadv_v_orig_dump(struct sk_buff *msg, struct netlink_callback *cb, | |
590 | struct batadv_priv *bat_priv, | |
591 | struct batadv_hard_iface *if_outgoing) | |
592 | { | |
593 | struct batadv_hashtable *hash = bat_priv->orig_hash; | |
594 | struct hlist_head *head; | |
595 | int bucket = cb->args[0]; | |
596 | int idx = cb->args[1]; | |
597 | int sub = cb->args[2]; | |
598 | int portid = NETLINK_CB(cb->skb).portid; | |
599 | ||
600 | while (bucket < hash->size) { | |
601 | head = &hash->table[bucket]; | |
602 | ||
603 | if (batadv_v_orig_dump_bucket(msg, portid, | |
604 | cb->nlh->nlmsg_seq, | |
605 | bat_priv, if_outgoing, head, &idx, | |
606 | &sub)) | |
607 | break; | |
608 | ||
609 | bucket++; | |
610 | } | |
611 | ||
612 | cb->args[0] = bucket; | |
613 | cb->args[1] = idx; | |
614 | cb->args[2] = sub; | |
615 | } | |
616 | ||
97869060 AQ |
617 | static int batadv_v_neigh_cmp(struct batadv_neigh_node *neigh1, |
618 | struct batadv_hard_iface *if_outgoing1, | |
619 | struct batadv_neigh_node *neigh2, | |
620 | struct batadv_hard_iface *if_outgoing2) | |
621 | { | |
622 | struct batadv_neigh_ifinfo *ifinfo1, *ifinfo2; | |
71f9d27d | 623 | int ret = 0; |
97869060 AQ |
624 | |
625 | ifinfo1 = batadv_neigh_ifinfo_get(neigh1, if_outgoing1); | |
71f9d27d SE |
626 | if (WARN_ON(!ifinfo1)) |
627 | goto err_ifinfo1; | |
628 | ||
97869060 | 629 | ifinfo2 = batadv_neigh_ifinfo_get(neigh2, if_outgoing2); |
71f9d27d SE |
630 | if (WARN_ON(!ifinfo2)) |
631 | goto err_ifinfo2; | |
97869060 | 632 | |
71f9d27d | 633 | ret = ifinfo1->bat_v.throughput - ifinfo2->bat_v.throughput; |
97869060 | 634 | |
71f9d27d SE |
635 | batadv_neigh_ifinfo_put(ifinfo2); |
636 | err_ifinfo2: | |
637 | batadv_neigh_ifinfo_put(ifinfo1); | |
638 | err_ifinfo1: | |
639 | return ret; | |
97869060 AQ |
640 | } |
641 | ||
642 | static bool batadv_v_neigh_is_sob(struct batadv_neigh_node *neigh1, | |
643 | struct batadv_hard_iface *if_outgoing1, | |
644 | struct batadv_neigh_node *neigh2, | |
645 | struct batadv_hard_iface *if_outgoing2) | |
646 | { | |
647 | struct batadv_neigh_ifinfo *ifinfo1, *ifinfo2; | |
648 | u32 threshold; | |
71f9d27d | 649 | bool ret = false; |
97869060 AQ |
650 | |
651 | ifinfo1 = batadv_neigh_ifinfo_get(neigh1, if_outgoing1); | |
71f9d27d SE |
652 | if (WARN_ON(!ifinfo1)) |
653 | goto err_ifinfo1; | |
97869060 | 654 | |
71f9d27d SE |
655 | ifinfo2 = batadv_neigh_ifinfo_get(neigh2, if_outgoing2); |
656 | if (WARN_ON(!ifinfo2)) | |
657 | goto err_ifinfo2; | |
a45e932a | 658 | |
97869060 AQ |
659 | threshold = ifinfo1->bat_v.throughput / 4; |
660 | threshold = ifinfo1->bat_v.throughput - threshold; | |
661 | ||
71f9d27d SE |
662 | ret = ifinfo2->bat_v.throughput > threshold; |
663 | ||
664 | batadv_neigh_ifinfo_put(ifinfo2); | |
665 | err_ifinfo2: | |
666 | batadv_neigh_ifinfo_put(ifinfo1); | |
667 | err_ifinfo1: | |
668 | return ret; | |
97869060 AQ |
669 | } |
670 | ||
1a9070ec SE |
671 | /** |
672 | * batadv_v_init_sel_class - initialize GW selection class | |
673 | * @bat_priv: the bat priv with all the soft interface information | |
674 | */ | |
675 | static void batadv_v_init_sel_class(struct batadv_priv *bat_priv) | |
676 | { | |
677 | /* set default throughput difference threshold to 5Mbps */ | |
678 | atomic_set(&bat_priv->gw.sel_class, 50); | |
679 | } | |
680 | ||
08686943 AQ |
681 | static ssize_t batadv_v_store_sel_class(struct batadv_priv *bat_priv, |
682 | char *buff, size_t count) | |
683 | { | |
684 | u32 old_class, class; | |
685 | ||
686 | if (!batadv_parse_throughput(bat_priv->soft_iface, buff, | |
687 | "B.A.T.M.A.N. V GW selection class", | |
688 | &class)) | |
689 | return -EINVAL; | |
690 | ||
691 | old_class = atomic_read(&bat_priv->gw.sel_class); | |
692 | atomic_set(&bat_priv->gw.sel_class, class); | |
693 | ||
694 | if (old_class != class) | |
695 | batadv_gw_reselect(bat_priv); | |
696 | ||
697 | return count; | |
698 | } | |
699 | ||
700 | static ssize_t batadv_v_show_sel_class(struct batadv_priv *bat_priv, char *buff) | |
701 | { | |
702 | u32 class = atomic_read(&bat_priv->gw.sel_class); | |
703 | ||
704 | return sprintf(buff, "%u.%u MBit\n", class / 10, class % 10); | |
705 | } | |
706 | ||
50164d8f AQ |
707 | /** |
708 | * batadv_v_gw_throughput_get - retrieve the GW-bandwidth for a given GW | |
709 | * @gw_node: the GW to retrieve the metric for | |
710 | * @bw: the pointer where the metric will be stored. The metric is computed as | |
711 | * the minimum between the GW advertised throughput and the path throughput to | |
712 | * it in the mesh | |
713 | * | |
714 | * Return: 0 on success, -1 on failure | |
715 | */ | |
716 | static int batadv_v_gw_throughput_get(struct batadv_gw_node *gw_node, u32 *bw) | |
717 | { | |
718 | struct batadv_neigh_ifinfo *router_ifinfo = NULL; | |
719 | struct batadv_orig_node *orig_node; | |
720 | struct batadv_neigh_node *router; | |
721 | int ret = -1; | |
722 | ||
723 | orig_node = gw_node->orig_node; | |
724 | router = batadv_orig_router_get(orig_node, BATADV_IF_DEFAULT); | |
725 | if (!router) | |
726 | goto out; | |
727 | ||
728 | router_ifinfo = batadv_neigh_ifinfo_get(router, BATADV_IF_DEFAULT); | |
729 | if (!router_ifinfo) | |
730 | goto out; | |
731 | ||
732 | /* the GW metric is computed as the minimum between the path throughput | |
733 | * to reach the GW itself and the advertised bandwidth. | |
734 | * This gives us an approximation of the effective throughput that the | |
735 | * client can expect via this particular GW node | |
736 | */ | |
737 | *bw = router_ifinfo->bat_v.throughput; | |
738 | *bw = min_t(u32, *bw, gw_node->bandwidth_down); | |
739 | ||
740 | ret = 0; | |
741 | out: | |
742 | if (router) | |
743 | batadv_neigh_node_put(router); | |
744 | if (router_ifinfo) | |
745 | batadv_neigh_ifinfo_put(router_ifinfo); | |
746 | ||
747 | return ret; | |
748 | } | |
749 | ||
750 | /** | |
751 | * batadv_v_gw_get_best_gw_node - retrieve the best GW node | |
752 | * @bat_priv: the bat priv with all the soft interface information | |
753 | * | |
754 | * Return: the GW node having the best GW-metric, NULL if no GW is known | |
755 | */ | |
756 | static struct batadv_gw_node * | |
757 | batadv_v_gw_get_best_gw_node(struct batadv_priv *bat_priv) | |
758 | { | |
759 | struct batadv_gw_node *gw_node, *curr_gw = NULL; | |
760 | u32 max_bw = 0, bw; | |
761 | ||
762 | rcu_read_lock(); | |
70ea5cee | 763 | hlist_for_each_entry_rcu(gw_node, &bat_priv->gw.gateway_list, list) { |
50164d8f AQ |
764 | if (!kref_get_unless_zero(&gw_node->refcount)) |
765 | continue; | |
766 | ||
767 | if (batadv_v_gw_throughput_get(gw_node, &bw) < 0) | |
768 | goto next; | |
769 | ||
770 | if (curr_gw && (bw <= max_bw)) | |
771 | goto next; | |
772 | ||
773 | if (curr_gw) | |
774 | batadv_gw_node_put(curr_gw); | |
775 | ||
776 | curr_gw = gw_node; | |
777 | kref_get(&curr_gw->refcount); | |
778 | max_bw = bw; | |
779 | ||
780 | next: | |
781 | batadv_gw_node_put(gw_node); | |
782 | } | |
783 | rcu_read_unlock(); | |
784 | ||
785 | return curr_gw; | |
786 | } | |
787 | ||
788 | /** | |
789 | * batadv_v_gw_is_eligible - check if a originator would be selected as GW | |
790 | * @bat_priv: the bat priv with all the soft interface information | |
791 | * @curr_gw_orig: originator representing the currently selected GW | |
792 | * @orig_node: the originator representing the new candidate | |
793 | * | |
794 | * Return: true if orig_node can be selected as current GW, false otherwise | |
795 | */ | |
796 | static bool batadv_v_gw_is_eligible(struct batadv_priv *bat_priv, | |
797 | struct batadv_orig_node *curr_gw_orig, | |
798 | struct batadv_orig_node *orig_node) | |
799 | { | |
422d2f77 | 800 | struct batadv_gw_node *curr_gw, *orig_gw = NULL; |
50164d8f AQ |
801 | u32 gw_throughput, orig_throughput, threshold; |
802 | bool ret = false; | |
803 | ||
804 | threshold = atomic_read(&bat_priv->gw.sel_class); | |
805 | ||
806 | curr_gw = batadv_gw_node_get(bat_priv, curr_gw_orig); | |
807 | if (!curr_gw) { | |
808 | ret = true; | |
809 | goto out; | |
810 | } | |
811 | ||
812 | if (batadv_v_gw_throughput_get(curr_gw, &gw_throughput) < 0) { | |
813 | ret = true; | |
814 | goto out; | |
815 | } | |
816 | ||
817 | orig_gw = batadv_gw_node_get(bat_priv, orig_node); | |
818 | if (!orig_node) | |
819 | goto out; | |
820 | ||
821 | if (batadv_v_gw_throughput_get(orig_gw, &orig_throughput) < 0) | |
822 | goto out; | |
823 | ||
824 | if (orig_throughput < gw_throughput) | |
825 | goto out; | |
826 | ||
827 | if ((orig_throughput - gw_throughput) < threshold) | |
828 | goto out; | |
829 | ||
830 | batadv_dbg(BATADV_DBG_BATMAN, bat_priv, | |
831 | "Restarting gateway selection: better gateway found (throughput curr: %u, throughput new: %u)\n", | |
832 | gw_throughput, orig_throughput); | |
833 | ||
834 | ret = true; | |
835 | out: | |
836 | if (curr_gw) | |
837 | batadv_gw_node_put(curr_gw); | |
838 | if (orig_gw) | |
839 | batadv_gw_node_put(orig_gw); | |
840 | ||
841 | return ret; | |
842 | } | |
843 | ||
dc1cbd14 | 844 | #ifdef CONFIG_BATMAN_ADV_DEBUGFS |
50164d8f AQ |
845 | /* fails if orig_node has no router */ |
846 | static int batadv_v_gw_write_buffer_text(struct batadv_priv *bat_priv, | |
847 | struct seq_file *seq, | |
848 | const struct batadv_gw_node *gw_node) | |
849 | { | |
850 | struct batadv_gw_node *curr_gw; | |
851 | struct batadv_neigh_node *router; | |
852 | struct batadv_neigh_ifinfo *router_ifinfo = NULL; | |
853 | int ret = -1; | |
854 | ||
855 | router = batadv_orig_router_get(gw_node->orig_node, BATADV_IF_DEFAULT); | |
856 | if (!router) | |
857 | goto out; | |
858 | ||
859 | router_ifinfo = batadv_neigh_ifinfo_get(router, BATADV_IF_DEFAULT); | |
860 | if (!router_ifinfo) | |
861 | goto out; | |
862 | ||
863 | curr_gw = batadv_gw_get_selected_gw_node(bat_priv); | |
864 | ||
865 | seq_printf(seq, "%s %pM (%9u.%1u) %pM [%10s]: %u.%u/%u.%u MBit\n", | |
866 | (curr_gw == gw_node ? "=>" : " "), | |
867 | gw_node->orig_node->orig, | |
868 | router_ifinfo->bat_v.throughput / 10, | |
869 | router_ifinfo->bat_v.throughput % 10, router->addr, | |
870 | router->if_incoming->net_dev->name, | |
871 | gw_node->bandwidth_down / 10, | |
872 | gw_node->bandwidth_down % 10, | |
873 | gw_node->bandwidth_up / 10, | |
874 | gw_node->bandwidth_up % 10); | |
875 | ret = seq_has_overflowed(seq) ? -1 : 0; | |
876 | ||
877 | if (curr_gw) | |
878 | batadv_gw_node_put(curr_gw); | |
879 | out: | |
880 | if (router_ifinfo) | |
881 | batadv_neigh_ifinfo_put(router_ifinfo); | |
882 | if (router) | |
883 | batadv_neigh_node_put(router); | |
884 | return ret; | |
885 | } | |
886 | ||
887 | /** | |
888 | * batadv_v_gw_print - print the gateway list | |
889 | * @bat_priv: the bat priv with all the soft interface information | |
890 | * @seq: gateway table seq_file struct | |
891 | */ | |
892 | static void batadv_v_gw_print(struct batadv_priv *bat_priv, | |
893 | struct seq_file *seq) | |
894 | { | |
895 | struct batadv_gw_node *gw_node; | |
896 | int gw_count = 0; | |
897 | ||
898 | seq_puts(seq, | |
899 | " Gateway ( throughput) Nexthop [outgoingIF]: advertised uplink bandwidth\n"); | |
900 | ||
901 | rcu_read_lock(); | |
70ea5cee | 902 | hlist_for_each_entry_rcu(gw_node, &bat_priv->gw.gateway_list, list) { |
50164d8f AQ |
903 | /* fails if orig_node has no router */ |
904 | if (batadv_v_gw_write_buffer_text(bat_priv, seq, gw_node) < 0) | |
905 | continue; | |
906 | ||
907 | gw_count++; | |
908 | } | |
909 | rcu_read_unlock(); | |
910 | ||
911 | if (gw_count == 0) | |
912 | seq_puts(seq, "No gateways in range ...\n"); | |
913 | } | |
dc1cbd14 | 914 | #endif |
50164d8f | 915 | |
b71bb6f9 SE |
916 | /** |
917 | * batadv_v_gw_dump_entry - Dump a gateway into a message | |
918 | * @msg: Netlink message to dump into | |
919 | * @portid: Port making netlink request | |
920 | * @seq: Sequence number of netlink message | |
921 | * @bat_priv: The bat priv with all the soft interface information | |
922 | * @gw_node: Gateway to be dumped | |
923 | * | |
924 | * Return: Error code, or 0 on success | |
925 | */ | |
926 | static int batadv_v_gw_dump_entry(struct sk_buff *msg, u32 portid, u32 seq, | |
927 | struct batadv_priv *bat_priv, | |
928 | struct batadv_gw_node *gw_node) | |
929 | { | |
930 | struct batadv_neigh_ifinfo *router_ifinfo = NULL; | |
931 | struct batadv_neigh_node *router; | |
932 | struct batadv_gw_node *curr_gw; | |
933 | int ret = -EINVAL; | |
934 | void *hdr; | |
935 | ||
936 | router = batadv_orig_router_get(gw_node->orig_node, BATADV_IF_DEFAULT); | |
937 | if (!router) | |
938 | goto out; | |
939 | ||
940 | router_ifinfo = batadv_neigh_ifinfo_get(router, BATADV_IF_DEFAULT); | |
941 | if (!router_ifinfo) | |
942 | goto out; | |
943 | ||
944 | curr_gw = batadv_gw_get_selected_gw_node(bat_priv); | |
945 | ||
946 | hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family, | |
947 | NLM_F_MULTI, BATADV_CMD_GET_GATEWAYS); | |
948 | if (!hdr) { | |
949 | ret = -ENOBUFS; | |
950 | goto out; | |
951 | } | |
952 | ||
953 | ret = -EMSGSIZE; | |
954 | ||
955 | if (curr_gw == gw_node) { | |
956 | if (nla_put_flag(msg, BATADV_ATTR_FLAG_BEST)) { | |
957 | genlmsg_cancel(msg, hdr); | |
958 | goto out; | |
959 | } | |
960 | } | |
961 | ||
962 | if (nla_put(msg, BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN, | |
963 | gw_node->orig_node->orig)) { | |
964 | genlmsg_cancel(msg, hdr); | |
965 | goto out; | |
966 | } | |
967 | ||
968 | if (nla_put_u32(msg, BATADV_ATTR_THROUGHPUT, | |
969 | router_ifinfo->bat_v.throughput)) { | |
970 | genlmsg_cancel(msg, hdr); | |
971 | goto out; | |
972 | } | |
973 | ||
974 | if (nla_put(msg, BATADV_ATTR_ROUTER, ETH_ALEN, router->addr)) { | |
975 | genlmsg_cancel(msg, hdr); | |
976 | goto out; | |
977 | } | |
978 | ||
979 | if (nla_put_string(msg, BATADV_ATTR_HARD_IFNAME, | |
980 | router->if_incoming->net_dev->name)) { | |
981 | genlmsg_cancel(msg, hdr); | |
982 | goto out; | |
983 | } | |
984 | ||
985 | if (nla_put_u32(msg, BATADV_ATTR_BANDWIDTH_DOWN, | |
986 | gw_node->bandwidth_down)) { | |
987 | genlmsg_cancel(msg, hdr); | |
988 | goto out; | |
989 | } | |
990 | ||
991 | if (nla_put_u32(msg, BATADV_ATTR_BANDWIDTH_UP, gw_node->bandwidth_up)) { | |
992 | genlmsg_cancel(msg, hdr); | |
993 | goto out; | |
994 | } | |
995 | ||
996 | genlmsg_end(msg, hdr); | |
997 | ret = 0; | |
998 | ||
999 | out: | |
1000 | if (router_ifinfo) | |
1001 | batadv_neigh_ifinfo_put(router_ifinfo); | |
1002 | if (router) | |
1003 | batadv_neigh_node_put(router); | |
1004 | return ret; | |
1005 | } | |
1006 | ||
1007 | /** | |
1008 | * batadv_v_gw_dump - Dump gateways into a message | |
1009 | * @msg: Netlink message to dump into | |
1010 | * @cb: Control block containing additional options | |
1011 | * @bat_priv: The bat priv with all the soft interface information | |
1012 | */ | |
1013 | static void batadv_v_gw_dump(struct sk_buff *msg, struct netlink_callback *cb, | |
1014 | struct batadv_priv *bat_priv) | |
1015 | { | |
1016 | int portid = NETLINK_CB(cb->skb).portid; | |
1017 | struct batadv_gw_node *gw_node; | |
1018 | int idx_skip = cb->args[0]; | |
1019 | int idx = 0; | |
1020 | ||
1021 | rcu_read_lock(); | |
70ea5cee | 1022 | hlist_for_each_entry_rcu(gw_node, &bat_priv->gw.gateway_list, list) { |
b71bb6f9 SE |
1023 | if (idx++ < idx_skip) |
1024 | continue; | |
1025 | ||
1026 | if (batadv_v_gw_dump_entry(msg, portid, cb->nlh->nlmsg_seq, | |
1027 | bat_priv, gw_node)) { | |
1028 | idx_skip = idx - 1; | |
1029 | goto unlock; | |
1030 | } | |
1031 | } | |
1032 | ||
1033 | idx_skip = idx; | |
1034 | unlock: | |
1035 | rcu_read_unlock(); | |
1036 | ||
1037 | cb->args[0] = idx_skip; | |
1038 | } | |
1039 | ||
d6f94d91 LL |
1040 | static struct batadv_algo_ops batadv_batman_v __read_mostly = { |
1041 | .name = "BATMAN_V", | |
29824a55 AQ |
1042 | .iface = { |
1043 | .activate = batadv_v_iface_activate, | |
1044 | .enable = batadv_v_iface_enable, | |
1045 | .disable = batadv_v_iface_disable, | |
1046 | .update_mac = batadv_v_iface_update_mac, | |
1047 | .primary_set = batadv_v_primary_iface_set, | |
1048 | }, | |
1049 | .neigh = { | |
1050 | .hardif_init = batadv_v_hardif_neigh_init, | |
1051 | .cmp = batadv_v_neigh_cmp, | |
1052 | .is_similar_or_better = batadv_v_neigh_is_sob, | |
dc1cbd14 | 1053 | #ifdef CONFIG_BATMAN_ADV_DEBUGFS |
29824a55 | 1054 | .print = batadv_v_neigh_print, |
dc1cbd14 | 1055 | #endif |
f02a478f | 1056 | .dump = batadv_v_neigh_dump, |
29824a55 AQ |
1057 | }, |
1058 | .orig = { | |
dc1cbd14 | 1059 | #ifdef CONFIG_BATMAN_ADV_DEBUGFS |
29824a55 | 1060 | .print = batadv_v_orig_print, |
dc1cbd14 | 1061 | #endif |
f02a478f | 1062 | .dump = batadv_v_orig_dump, |
29824a55 | 1063 | }, |
08686943 | 1064 | .gw = { |
1a9070ec | 1065 | .init_sel_class = batadv_v_init_sel_class, |
08686943 AQ |
1066 | .store_sel_class = batadv_v_store_sel_class, |
1067 | .show_sel_class = batadv_v_show_sel_class, | |
50164d8f AQ |
1068 | .get_best_gw_node = batadv_v_gw_get_best_gw_node, |
1069 | .is_eligible = batadv_v_gw_is_eligible, | |
dc1cbd14 | 1070 | #ifdef CONFIG_BATMAN_ADV_DEBUGFS |
50164d8f | 1071 | .print = batadv_v_gw_print, |
dc1cbd14 | 1072 | #endif |
b71bb6f9 | 1073 | .dump = batadv_v_gw_dump, |
08686943 | 1074 | }, |
d6f94d91 LL |
1075 | }; |
1076 | ||
7db682d1 ML |
1077 | /** |
1078 | * batadv_v_hardif_init - initialize the algorithm specific fields in the | |
1079 | * hard-interface object | |
1080 | * @hard_iface: the hard-interface to initialize | |
1081 | */ | |
1082 | void batadv_v_hardif_init(struct batadv_hard_iface *hard_iface) | |
1083 | { | |
1084 | /* enable link throughput auto-detection by setting the throughput | |
1085 | * override to zero | |
1086 | */ | |
1087 | atomic_set(&hard_iface->bat_v.throughput_override, 0); | |
1088 | atomic_set(&hard_iface->bat_v.elp_interval, 500); | |
1089 | } | |
1090 | ||
0da00359 AQ |
1091 | /** |
1092 | * batadv_v_mesh_init - initialize the B.A.T.M.A.N. V private resources for a | |
1093 | * mesh | |
1094 | * @bat_priv: the object representing the mesh interface to initialise | |
1095 | * | |
1096 | * Return: 0 on success or a negative error code otherwise | |
1097 | */ | |
1098 | int batadv_v_mesh_init(struct batadv_priv *bat_priv) | |
1099 | { | |
50164d8f AQ |
1100 | int ret = 0; |
1101 | ||
1102 | ret = batadv_v_ogm_init(bat_priv); | |
1103 | if (ret < 0) | |
1104 | return ret; | |
1105 | ||
50164d8f | 1106 | return 0; |
0da00359 AQ |
1107 | } |
1108 | ||
1109 | /** | |
1110 | * batadv_v_mesh_free - free the B.A.T.M.A.N. V private resources for a mesh | |
1111 | * @bat_priv: the object representing the mesh interface to free | |
1112 | */ | |
1113 | void batadv_v_mesh_free(struct batadv_priv *bat_priv) | |
1114 | { | |
1115 | batadv_v_ogm_free(bat_priv); | |
1116 | } | |
1117 | ||
d6f94d91 LL |
1118 | /** |
1119 | * batadv_v_init - B.A.T.M.A.N. V initialization function | |
1120 | * | |
1121 | * Description: Takes care of initializing all the subcomponents. | |
1122 | * It is invoked upon module load only. | |
1123 | * | |
1124 | * Return: 0 on success or a negative error code otherwise | |
1125 | */ | |
1126 | int __init batadv_v_init(void) | |
1127 | { | |
162bd64c LL |
1128 | int ret; |
1129 | ||
1130 | /* B.A.T.M.A.N. V echo location protocol packet */ | |
1131 | ret = batadv_recv_handler_register(BATADV_ELP, | |
1132 | batadv_v_elp_packet_recv); | |
1133 | if (ret < 0) | |
1134 | return ret; | |
1135 | ||
0da00359 AQ |
1136 | ret = batadv_recv_handler_register(BATADV_OGM2, |
1137 | batadv_v_ogm_packet_recv); | |
1138 | if (ret < 0) | |
1139 | goto elp_unregister; | |
162bd64c | 1140 | |
0da00359 | 1141 | ret = batadv_algo_register(&batadv_batman_v); |
162bd64c | 1142 | if (ret < 0) |
0da00359 AQ |
1143 | goto ogm_unregister; |
1144 | ||
1145 | return ret; | |
1146 | ||
1147 | ogm_unregister: | |
1148 | batadv_recv_handler_unregister(BATADV_OGM2); | |
1149 | ||
1150 | elp_unregister: | |
1151 | batadv_recv_handler_unregister(BATADV_ELP); | |
162bd64c LL |
1152 | |
1153 | return ret; | |
d6f94d91 | 1154 | } |