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 | |
44 | static void batadv_v_iface_activate(struct batadv_hard_iface *hard_iface) |
45 | { |
46 | struct batadv_priv *bat_priv = netdev_priv(dev: 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_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 | |
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(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 | */ |
98 | static void batadv_v_iface_update_mac(struct batadv_hard_iface *hard_iface) |
99 | { |
100 | struct batadv_priv *bat_priv = netdev_priv(dev: 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(hard_iface: 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(e: &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(j: jiffies - hardif_neigh->last_seen); |
138 | throughput = ewma_throughput_read(e: &hardif_neigh->bat_v.throughput); |
139 | throughput = throughput * 100; |
140 | |
141 | hdr = genlmsg_put(skb: msg, portid, seq, family: &batadv_netlink_family, NLM_F_MULTI, |
142 | cmd: BATADV_CMD_GET_NEIGHBORS); |
143 | if (!hdr) |
144 | return -ENOBUFS; |
145 | |
146 | if (nla_put(skb: msg, attrtype: BATADV_ATTR_NEIGH_ADDRESS, ETH_ALEN, |
147 | data: hardif_neigh->addr) || |
148 | nla_put_string(skb: msg, attrtype: BATADV_ATTR_HARD_IFNAME, |
149 | str: hardif_neigh->if_incoming->net_dev->name) || |
150 | nla_put_u32(skb: msg, attrtype: BATADV_ATTR_HARD_IFINDEX, |
151 | value: hardif_neigh->if_incoming->net_dev->ifindex) || |
152 | nla_put_u32(skb: msg, attrtype: BATADV_ATTR_LAST_SEEN_MSECS, |
153 | value: last_seen_msecs) || |
154 | nla_put_u32(skb: msg, attrtype: BATADV_ATTR_THROUGHPUT, value: throughput)) |
155 | goto nla_put_failure; |
156 | |
157 | genlmsg_end(skb: msg, hdr); |
158 | return 0; |
159 | |
160 | nla_put_failure: |
161 | genlmsg_cancel(skb: 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 | seq: cb->nlh->nlmsg_seq, |
227 | bat_priv, hard_iface: single_hardif, |
228 | idx_s: &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 | seq: cb->nlh->nlmsg_seq, |
241 | bat_priv, hard_iface, |
242 | idx_s: &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: 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(neigh_ifinfo: n_ifinfo); |
287 | |
288 | last_seen_msecs = jiffies_to_msecs(j: 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(skb: msg, portid, seq, family: &batadv_netlink_family, NLM_F_MULTI, |
295 | cmd: BATADV_CMD_GET_ORIGINATORS); |
296 | if (!hdr) |
297 | return -ENOBUFS; |
298 | |
299 | if (nla_put(skb: msg, attrtype: BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN, data: orig_node->orig) || |
300 | nla_put(skb: msg, attrtype: BATADV_ATTR_NEIGH_ADDRESS, ETH_ALEN, |
301 | data: neigh_node->addr) || |
302 | nla_put_string(skb: msg, attrtype: BATADV_ATTR_HARD_IFNAME, |
303 | str: neigh_node->if_incoming->net_dev->name) || |
304 | nla_put_u32(skb: msg, attrtype: BATADV_ATTR_HARD_IFINDEX, |
305 | value: neigh_node->if_incoming->net_dev->ifindex) || |
306 | nla_put_u32(skb: msg, attrtype: BATADV_ATTR_THROUGHPUT, value: throughput) || |
307 | nla_put_u32(skb: msg, attrtype: BATADV_ATTR_LAST_SEEN_MSECS, |
308 | value: last_seen_msecs)) |
309 | goto nla_put_failure; |
310 | |
311 | if (best && nla_put_flag(skb: msg, attrtype: BATADV_ATTR_FLAG_BEST)) |
312 | goto nla_put_failure; |
313 | |
314 | genlmsg_end(skb: msg, hdr); |
315 | return 0; |
316 | |
317 | nla_put_failure: |
318 | genlmsg_cancel(skb: 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: neigh_node_best); |
361 | |
362 | *sub_s = sub - 1; |
363 | return -EMSGSIZE; |
364 | } |
365 | } |
366 | |
367 | out: |
368 | batadv_neigh_node_put(neigh_node: 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_s: 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 | seq: cb->nlh->nlmsg_seq, |
439 | bat_priv, if_outgoing, head, idx_s: &idx, |
440 | sub: &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(neigh: neigh1, if_outgoing: if_outgoing1); |
460 | if (!ifinfo1) |
461 | goto err_ifinfo1; |
462 | |
463 | ifinfo2 = batadv_neigh_ifinfo_get(neigh: neigh2, if_outgoing: 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(neigh_ifinfo: ifinfo2); |
470 | err_ifinfo2: |
471 | batadv_neigh_ifinfo_put(neigh_ifinfo: 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(neigh: neigh1, if_outgoing: if_outgoing1); |
486 | if (!ifinfo1) |
487 | goto err_ifinfo1; |
488 | |
489 | ifinfo2 = batadv_neigh_ifinfo_get(neigh: neigh2, if_outgoing: 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(neigh_ifinfo: ifinfo2); |
499 | err_ifinfo2: |
500 | batadv_neigh_ifinfo_put(neigh_ifinfo: 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(v: &bat_priv->gw.sel_class, i: 50); |
513 | } |
514 | |
515 | /** |
516 | * batadv_v_gw_throughput_get() - retrieve the GW-bandwidth for a given GW |
517 | * @gw_node: the GW to retrieve the metric for |
518 | * @bw: the pointer where the metric will be stored. The metric is computed as |
519 | * the minimum between the GW advertised throughput and the path throughput to |
520 | * it in the mesh |
521 | * |
522 | * Return: 0 on success, -1 on failure |
523 | */ |
524 | static int batadv_v_gw_throughput_get(struct batadv_gw_node *gw_node, u32 *bw) |
525 | { |
526 | struct batadv_neigh_ifinfo *router_ifinfo = NULL; |
527 | struct batadv_orig_node *orig_node; |
528 | struct batadv_neigh_node *router; |
529 | int ret = -1; |
530 | |
531 | orig_node = gw_node->orig_node; |
532 | router = batadv_orig_router_get(orig_node, BATADV_IF_DEFAULT); |
533 | if (!router) |
534 | goto out; |
535 | |
536 | router_ifinfo = batadv_neigh_ifinfo_get(neigh: router, BATADV_IF_DEFAULT); |
537 | if (!router_ifinfo) |
538 | goto out; |
539 | |
540 | /* the GW metric is computed as the minimum between the path throughput |
541 | * to reach the GW itself and the advertised bandwidth. |
542 | * This gives us an approximation of the effective throughput that the |
543 | * client can expect via this particular GW node |
544 | */ |
545 | *bw = router_ifinfo->bat_v.throughput; |
546 | *bw = min_t(u32, *bw, gw_node->bandwidth_down); |
547 | |
548 | ret = 0; |
549 | out: |
550 | batadv_neigh_node_put(neigh_node: router); |
551 | batadv_neigh_ifinfo_put(neigh_ifinfo: router_ifinfo); |
552 | |
553 | return ret; |
554 | } |
555 | |
556 | /** |
557 | * batadv_v_gw_get_best_gw_node() - retrieve the best GW node |
558 | * @bat_priv: the bat priv with all the soft interface information |
559 | * |
560 | * Return: the GW node having the best GW-metric, NULL if no GW is known |
561 | */ |
562 | static struct batadv_gw_node * |
563 | batadv_v_gw_get_best_gw_node(struct batadv_priv *bat_priv) |
564 | { |
565 | struct batadv_gw_node *gw_node, *curr_gw = NULL; |
566 | u32 max_bw = 0, bw; |
567 | |
568 | rcu_read_lock(); |
569 | hlist_for_each_entry_rcu(gw_node, &bat_priv->gw.gateway_list, list) { |
570 | if (!kref_get_unless_zero(kref: &gw_node->refcount)) |
571 | continue; |
572 | |
573 | if (batadv_v_gw_throughput_get(gw_node, bw: &bw) < 0) |
574 | goto next; |
575 | |
576 | if (curr_gw && bw <= max_bw) |
577 | goto next; |
578 | |
579 | batadv_gw_node_put(gw_node: curr_gw); |
580 | |
581 | curr_gw = gw_node; |
582 | kref_get(kref: &curr_gw->refcount); |
583 | max_bw = bw; |
584 | |
585 | next: |
586 | batadv_gw_node_put(gw_node); |
587 | } |
588 | rcu_read_unlock(); |
589 | |
590 | return curr_gw; |
591 | } |
592 | |
593 | /** |
594 | * batadv_v_gw_is_eligible() - check if a originator would be selected as GW |
595 | * @bat_priv: the bat priv with all the soft interface information |
596 | * @curr_gw_orig: originator representing the currently selected GW |
597 | * @orig_node: the originator representing the new candidate |
598 | * |
599 | * Return: true if orig_node can be selected as current GW, false otherwise |
600 | */ |
601 | static bool batadv_v_gw_is_eligible(struct batadv_priv *bat_priv, |
602 | struct batadv_orig_node *curr_gw_orig, |
603 | struct batadv_orig_node *orig_node) |
604 | { |
605 | struct batadv_gw_node *curr_gw, *orig_gw = NULL; |
606 | u32 gw_throughput, orig_throughput, threshold; |
607 | bool ret = false; |
608 | |
609 | threshold = atomic_read(v: &bat_priv->gw.sel_class); |
610 | |
611 | curr_gw = batadv_gw_node_get(bat_priv, orig_node: curr_gw_orig); |
612 | if (!curr_gw) { |
613 | ret = true; |
614 | goto out; |
615 | } |
616 | |
617 | if (batadv_v_gw_throughput_get(gw_node: curr_gw, bw: &gw_throughput) < 0) { |
618 | ret = true; |
619 | goto out; |
620 | } |
621 | |
622 | orig_gw = batadv_gw_node_get(bat_priv, orig_node); |
623 | if (!orig_gw) |
624 | goto out; |
625 | |
626 | if (batadv_v_gw_throughput_get(gw_node: orig_gw, bw: &orig_throughput) < 0) |
627 | goto out; |
628 | |
629 | if (orig_throughput < gw_throughput) |
630 | goto out; |
631 | |
632 | if ((orig_throughput - gw_throughput) < threshold) |
633 | goto out; |
634 | |
635 | batadv_dbg(BATADV_DBG_BATMAN, bat_priv, |
636 | "Restarting gateway selection: better gateway found (throughput curr: %u, throughput new: %u)\n" , |
637 | gw_throughput, orig_throughput); |
638 | |
639 | ret = true; |
640 | out: |
641 | batadv_gw_node_put(gw_node: curr_gw); |
642 | batadv_gw_node_put(gw_node: orig_gw); |
643 | |
644 | return ret; |
645 | } |
646 | |
647 | /** |
648 | * batadv_v_gw_dump_entry() - Dump a gateway into a message |
649 | * @msg: Netlink message to dump into |
650 | * @portid: Port making netlink request |
651 | * @cb: Control block containing additional options |
652 | * @bat_priv: The bat priv with all the soft interface information |
653 | * @gw_node: Gateway to be dumped |
654 | * |
655 | * Return: Error code, or 0 on success |
656 | */ |
657 | static int batadv_v_gw_dump_entry(struct sk_buff *msg, u32 portid, |
658 | struct netlink_callback *cb, |
659 | struct batadv_priv *bat_priv, |
660 | struct batadv_gw_node *gw_node) |
661 | { |
662 | struct batadv_neigh_ifinfo *router_ifinfo = NULL; |
663 | struct batadv_neigh_node *router; |
664 | struct batadv_gw_node *curr_gw = NULL; |
665 | int ret = 0; |
666 | void *hdr; |
667 | |
668 | router = batadv_orig_router_get(orig_node: gw_node->orig_node, BATADV_IF_DEFAULT); |
669 | if (!router) |
670 | goto out; |
671 | |
672 | router_ifinfo = batadv_neigh_ifinfo_get(neigh: router, BATADV_IF_DEFAULT); |
673 | if (!router_ifinfo) |
674 | goto out; |
675 | |
676 | curr_gw = batadv_gw_get_selected_gw_node(bat_priv); |
677 | |
678 | hdr = genlmsg_put(skb: msg, portid, seq: cb->nlh->nlmsg_seq, |
679 | family: &batadv_netlink_family, NLM_F_MULTI, |
680 | cmd: BATADV_CMD_GET_GATEWAYS); |
681 | if (!hdr) { |
682 | ret = -ENOBUFS; |
683 | goto out; |
684 | } |
685 | |
686 | genl_dump_check_consistent(cb, user_hdr: hdr); |
687 | |
688 | ret = -EMSGSIZE; |
689 | |
690 | if (curr_gw == gw_node) { |
691 | if (nla_put_flag(skb: msg, attrtype: BATADV_ATTR_FLAG_BEST)) { |
692 | genlmsg_cancel(skb: msg, hdr); |
693 | goto out; |
694 | } |
695 | } |
696 | |
697 | if (nla_put(skb: msg, attrtype: BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN, |
698 | data: gw_node->orig_node->orig)) { |
699 | genlmsg_cancel(skb: msg, hdr); |
700 | goto out; |
701 | } |
702 | |
703 | if (nla_put_u32(skb: msg, attrtype: BATADV_ATTR_THROUGHPUT, |
704 | value: router_ifinfo->bat_v.throughput)) { |
705 | genlmsg_cancel(skb: msg, hdr); |
706 | goto out; |
707 | } |
708 | |
709 | if (nla_put(skb: msg, attrtype: BATADV_ATTR_ROUTER, ETH_ALEN, data: router->addr)) { |
710 | genlmsg_cancel(skb: msg, hdr); |
711 | goto out; |
712 | } |
713 | |
714 | if (nla_put_string(skb: msg, attrtype: BATADV_ATTR_HARD_IFNAME, |
715 | str: router->if_incoming->net_dev->name)) { |
716 | genlmsg_cancel(skb: msg, hdr); |
717 | goto out; |
718 | } |
719 | |
720 | if (nla_put_u32(skb: msg, attrtype: BATADV_ATTR_HARD_IFINDEX, |
721 | value: router->if_incoming->net_dev->ifindex)) { |
722 | genlmsg_cancel(skb: msg, hdr); |
723 | goto out; |
724 | } |
725 | |
726 | if (nla_put_u32(skb: msg, attrtype: BATADV_ATTR_BANDWIDTH_DOWN, |
727 | value: gw_node->bandwidth_down)) { |
728 | genlmsg_cancel(skb: msg, hdr); |
729 | goto out; |
730 | } |
731 | |
732 | if (nla_put_u32(skb: msg, attrtype: BATADV_ATTR_BANDWIDTH_UP, value: gw_node->bandwidth_up)) { |
733 | genlmsg_cancel(skb: msg, hdr); |
734 | goto out; |
735 | } |
736 | |
737 | genlmsg_end(skb: msg, hdr); |
738 | ret = 0; |
739 | |
740 | out: |
741 | batadv_gw_node_put(gw_node: curr_gw); |
742 | batadv_neigh_ifinfo_put(neigh_ifinfo: router_ifinfo); |
743 | batadv_neigh_node_put(neigh_node: router); |
744 | return ret; |
745 | } |
746 | |
747 | /** |
748 | * batadv_v_gw_dump() - Dump gateways into a message |
749 | * @msg: Netlink message to dump into |
750 | * @cb: Control block containing additional options |
751 | * @bat_priv: The bat priv with all the soft interface information |
752 | */ |
753 | static void batadv_v_gw_dump(struct sk_buff *msg, struct netlink_callback *cb, |
754 | struct batadv_priv *bat_priv) |
755 | { |
756 | int portid = NETLINK_CB(cb->skb).portid; |
757 | struct batadv_gw_node *gw_node; |
758 | int idx_skip = cb->args[0]; |
759 | int idx = 0; |
760 | |
761 | spin_lock_bh(lock: &bat_priv->gw.list_lock); |
762 | cb->seq = bat_priv->gw.generation << 1 | 1; |
763 | |
764 | hlist_for_each_entry(gw_node, &bat_priv->gw.gateway_list, list) { |
765 | if (idx++ < idx_skip) |
766 | continue; |
767 | |
768 | if (batadv_v_gw_dump_entry(msg, portid, cb, bat_priv, |
769 | gw_node)) { |
770 | idx_skip = idx - 1; |
771 | goto unlock; |
772 | } |
773 | } |
774 | |
775 | idx_skip = idx; |
776 | unlock: |
777 | spin_unlock_bh(lock: &bat_priv->gw.list_lock); |
778 | |
779 | cb->args[0] = idx_skip; |
780 | } |
781 | |
782 | static struct batadv_algo_ops batadv_batman_v __read_mostly = { |
783 | .name = "BATMAN_V" , |
784 | .iface = { |
785 | .activate = batadv_v_iface_activate, |
786 | .enable = batadv_v_iface_enable, |
787 | .disable = batadv_v_iface_disable, |
788 | .update_mac = batadv_v_iface_update_mac, |
789 | .primary_set = batadv_v_primary_iface_set, |
790 | }, |
791 | .neigh = { |
792 | .hardif_init = batadv_v_hardif_neigh_init, |
793 | .cmp = batadv_v_neigh_cmp, |
794 | .is_similar_or_better = batadv_v_neigh_is_sob, |
795 | .dump = batadv_v_neigh_dump, |
796 | }, |
797 | .orig = { |
798 | .dump = batadv_v_orig_dump, |
799 | }, |
800 | .gw = { |
801 | .init_sel_class = batadv_v_init_sel_class, |
802 | .sel_class_max = U32_MAX, |
803 | .get_best_gw_node = batadv_v_gw_get_best_gw_node, |
804 | .is_eligible = batadv_v_gw_is_eligible, |
805 | .dump = batadv_v_gw_dump, |
806 | }, |
807 | }; |
808 | |
809 | /** |
810 | * batadv_v_hardif_init() - initialize the algorithm specific fields in the |
811 | * hard-interface object |
812 | * @hard_iface: the hard-interface to initialize |
813 | */ |
814 | void batadv_v_hardif_init(struct batadv_hard_iface *hard_iface) |
815 | { |
816 | /* enable link throughput auto-detection by setting the throughput |
817 | * override to zero |
818 | */ |
819 | atomic_set(v: &hard_iface->bat_v.throughput_override, i: 0); |
820 | atomic_set(v: &hard_iface->bat_v.elp_interval, i: 500); |
821 | |
822 | hard_iface->bat_v.aggr_len = 0; |
823 | skb_queue_head_init(list: &hard_iface->bat_v.aggr_list); |
824 | INIT_DELAYED_WORK(&hard_iface->bat_v.aggr_wq, |
825 | batadv_v_ogm_aggr_work); |
826 | } |
827 | |
828 | /** |
829 | * batadv_v_mesh_init() - initialize the B.A.T.M.A.N. V private resources for a |
830 | * mesh |
831 | * @bat_priv: the object representing the mesh interface to initialise |
832 | * |
833 | * Return: 0 on success or a negative error code otherwise |
834 | */ |
835 | int batadv_v_mesh_init(struct batadv_priv *bat_priv) |
836 | { |
837 | int ret = 0; |
838 | |
839 | ret = batadv_v_ogm_init(bat_priv); |
840 | if (ret < 0) |
841 | return ret; |
842 | |
843 | return 0; |
844 | } |
845 | |
846 | /** |
847 | * batadv_v_mesh_free() - free the B.A.T.M.A.N. V private resources for a mesh |
848 | * @bat_priv: the object representing the mesh interface to free |
849 | */ |
850 | void batadv_v_mesh_free(struct batadv_priv *bat_priv) |
851 | { |
852 | batadv_v_ogm_free(bat_priv); |
853 | } |
854 | |
855 | /** |
856 | * batadv_v_init() - B.A.T.M.A.N. V initialization function |
857 | * |
858 | * Description: Takes care of initializing all the subcomponents. |
859 | * It is invoked upon module load only. |
860 | * |
861 | * Return: 0 on success or a negative error code otherwise |
862 | */ |
863 | int __init batadv_v_init(void) |
864 | { |
865 | int ret; |
866 | |
867 | /* B.A.T.M.A.N. V echo location protocol packet */ |
868 | ret = batadv_recv_handler_register(packet_type: BATADV_ELP, |
869 | recv_handler: batadv_v_elp_packet_recv); |
870 | if (ret < 0) |
871 | return ret; |
872 | |
873 | ret = batadv_recv_handler_register(packet_type: BATADV_OGM2, |
874 | recv_handler: batadv_v_ogm_packet_recv); |
875 | if (ret < 0) |
876 | goto elp_unregister; |
877 | |
878 | ret = batadv_algo_register(bat_algo_ops: &batadv_batman_v); |
879 | if (ret < 0) |
880 | goto ogm_unregister; |
881 | |
882 | return ret; |
883 | |
884 | ogm_unregister: |
885 | batadv_recv_handler_unregister(packet_type: BATADV_OGM2); |
886 | |
887 | elp_unregister: |
888 | batadv_recv_handler_unregister(packet_type: BATADV_ELP); |
889 | |
890 | return ret; |
891 | } |
892 | |