Commit | Line | Data |
---|---|---|
7db7d9f3 | 1 | // SPDX-License-Identifier: GPL-2.0 |
cfa55c6d | 2 | /* Copyright (C) B.A.T.M.A.N. contributors: |
d6f94d91 LL |
3 | * |
4 | * Linus Lüssing, Marek Lindner | |
d6f94d91 LL |
5 | */ |
6 | ||
a2d08166 | 7 | #include "bat_v.h" |
d6f94d91 LL |
8 | #include "main.h" |
9 | ||
0b5ecc68 | 10 | #include <linux/atomic.h> |
d6f94d91 | 11 | #include <linux/cache.h> |
08686943 | 12 | #include <linux/errno.h> |
f02a478f | 13 | #include <linux/if_ether.h> |
d6f94d91 | 14 | #include <linux/init.h> |
261e264d | 15 | #include <linux/jiffies.h> |
50164d8f | 16 | #include <linux/kref.h> |
6f96d46f | 17 | #include <linux/limits.h> |
9264c85c | 18 | #include <linux/list.h> |
fcd193e1 | 19 | #include <linux/minmax.h> |
261e264d | 20 | #include <linux/netdevice.h> |
f02a478f | 21 | #include <linux/netlink.h> |
261e264d AQ |
22 | #include <linux/rculist.h> |
23 | #include <linux/rcupdate.h> | |
68a600de | 24 | #include <linux/skbuff.h> |
9264c85c | 25 | #include <linux/spinlock.h> |
a45e932a | 26 | #include <linux/stddef.h> |
97869060 | 27 | #include <linux/types.h> |
c833484e | 28 | #include <linux/workqueue.h> |
f02a478f MS |
29 | #include <net/genetlink.h> |
30 | #include <net/netlink.h> | |
fec149f5 | 31 | #include <uapi/linux/batadv_packet.h> |
f02a478f | 32 | #include <uapi/linux/batman_adv.h> |
d6f94d91 | 33 | |
a2d08166 | 34 | #include "bat_algo.h" |
d6f94d91 | 35 | #include "bat_v_elp.h" |
0da00359 | 36 | #include "bat_v_ogm.h" |
08686943 | 37 | #include "gateway_client.h" |
b6cf5d49 | 38 | #include "hard-interface.h" |
261e264d | 39 | #include "hash.h" |
50164d8f | 40 | #include "log.h" |
f02a478f | 41 | #include "netlink.h" |
97869060 | 42 | #include "originator.h" |
d6f94d91 | 43 | |
b6cf5d49 AQ |
44 | static void batadv_v_iface_activate(struct batadv_hard_iface *hard_iface) |
45 | { | |
ebe24cea ML |
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 | ||
b6cf5d49 AQ |
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 | ||
d6f94d91 LL |
64 | static int batadv_v_iface_enable(struct batadv_hard_iface *hard_iface) |
65 | { | |
0da00359 AQ |
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; | |
d6f94d91 LL |
77 | } |
78 | ||
79 | static void batadv_v_iface_disable(struct batadv_hard_iface *hard_iface) | |
80 | { | |
f89255a0 | 81 | batadv_v_ogm_iface_disable(hard_iface); |
d6f94d91 LL |
82 | batadv_v_elp_iface_disable(hard_iface); |
83 | } | |
84 | ||
d6f94d91 LL |
85 | static void batadv_v_primary_iface_set(struct batadv_hard_iface *hard_iface) |
86 | { | |
87 | batadv_v_elp_primary_iface_set(hard_iface); | |
0da00359 | 88 | batadv_v_ogm_primary_iface_set(hard_iface); |
d6f94d91 LL |
89 | } |
90 | ||
1653f61d | 91 | /** |
7e9a8c2c | 92 | * batadv_v_iface_update_mac() - react to hard-interface MAC address change |
1653f61d AQ |
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: | |
79a0bffb | 109 | batadv_hardif_put(primary_if); |
1653f61d AQ |
110 | } |
111 | ||
162bd64c LL |
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); | |
c833484e AQ |
116 | INIT_WORK(&hardif_neigh->bat_v.metric_work, |
117 | batadv_v_elp_throughput_metric_update); | |
162bd64c LL |
118 | } |
119 | ||
f02a478f | 120 | /** |
7e9a8c2c | 121 | * batadv_v_neigh_dump_neigh() - Dump a neighbour into a message |
f02a478f MS |
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) || | |
d295345a SE |
148 | nla_put_string(msg, BATADV_ATTR_HARD_IFNAME, |
149 | hardif_neigh->if_incoming->net_dev->name) || | |
f02a478f MS |
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 | /** | |
7e9a8c2c | 166 | * batadv_v_neigh_dump_hardif() - Dump the neighbours of a hard interface into |
f02a478f MS |
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 | /** | |
7e9a8c2c | 204 | * batadv_v_neigh_dump() - Dump the neighbours of a hard interface into a |
f02a478f MS |
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 | ||
f02a478f | 254 | /** |
7e9a8c2c | 255 | * batadv_v_orig_dump_subentry() - Dump an originator subentry into a message |
f02a478f MS |
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) || | |
d295345a SE |
302 | nla_put_string(msg, BATADV_ATTR_HARD_IFNAME, |
303 | neigh_node->if_incoming->net_dev->name) || | |
f02a478f MS |
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 | /** | |
7e9a8c2c | 323 | * batadv_v_orig_dump_entry() - Dump an originator entry into a message |
f02a478f MS |
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: | |
79a0bffb | 368 | batadv_neigh_node_put(neigh_node_best); |
f02a478f MS |
369 | |
370 | *sub_s = 0; | |
371 | return 0; | |
372 | } | |
373 | ||
374 | /** | |
7e9a8c2c | 375 | * batadv_v_orig_dump_bucket() - Dump an originator bucket into a message |
f02a478f MS |
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 | /** | |
7e9a8c2c | 416 | * batadv_v_orig_dump() - Dump the originators into a message |
f02a478f MS |
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 | ||
97869060 AQ |
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; | |
71f9d27d | 457 | int ret = 0; |
97869060 AQ |
458 | |
459 | ifinfo1 = batadv_neigh_ifinfo_get(neigh1, if_outgoing1); | |
6a4bc44b | 460 | if (!ifinfo1) |
71f9d27d SE |
461 | goto err_ifinfo1; |
462 | ||
97869060 | 463 | ifinfo2 = batadv_neigh_ifinfo_get(neigh2, if_outgoing2); |
6a4bc44b | 464 | if (!ifinfo2) |
71f9d27d | 465 | goto err_ifinfo2; |
97869060 | 466 | |
71f9d27d | 467 | ret = ifinfo1->bat_v.throughput - ifinfo2->bat_v.throughput; |
97869060 | 468 | |
71f9d27d SE |
469 | batadv_neigh_ifinfo_put(ifinfo2); |
470 | err_ifinfo2: | |
471 | batadv_neigh_ifinfo_put(ifinfo1); | |
472 | err_ifinfo1: | |
473 | return ret; | |
97869060 AQ |
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; | |
71f9d27d | 483 | bool ret = false; |
97869060 AQ |
484 | |
485 | ifinfo1 = batadv_neigh_ifinfo_get(neigh1, if_outgoing1); | |
6a4bc44b | 486 | if (!ifinfo1) |
71f9d27d | 487 | goto err_ifinfo1; |
97869060 | 488 | |
71f9d27d | 489 | ifinfo2 = batadv_neigh_ifinfo_get(neigh2, if_outgoing2); |
6a4bc44b | 490 | if (!ifinfo2) |
71f9d27d | 491 | goto err_ifinfo2; |
a45e932a | 492 | |
97869060 AQ |
493 | threshold = ifinfo1->bat_v.throughput / 4; |
494 | threshold = ifinfo1->bat_v.throughput - threshold; | |
495 | ||
71f9d27d SE |
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; | |
97869060 AQ |
503 | } |
504 | ||
1a9070ec | 505 | /** |
7e9a8c2c | 506 | * batadv_v_init_sel_class() - initialize GW selection class |
1a9070ec SE |
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 | ||
50164d8f | 515 | /** |
7e9a8c2c | 516 | * batadv_v_gw_throughput_get() - retrieve the GW-bandwidth for a given GW |
50164d8f AQ |
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(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: | |
79a0bffb SE |
550 | batadv_neigh_node_put(router); |
551 | batadv_neigh_ifinfo_put(router_ifinfo); | |
50164d8f AQ |
552 | |
553 | return ret; | |
554 | } | |
555 | ||
556 | /** | |
7e9a8c2c | 557 | * batadv_v_gw_get_best_gw_node() - retrieve the best GW node |
50164d8f AQ |
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(); | |
70ea5cee | 569 | hlist_for_each_entry_rcu(gw_node, &bat_priv->gw.gateway_list, list) { |
50164d8f AQ |
570 | if (!kref_get_unless_zero(&gw_node->refcount)) |
571 | continue; | |
572 | ||
573 | if (batadv_v_gw_throughput_get(gw_node, &bw) < 0) | |
574 | goto next; | |
575 | ||
825ffe1f | 576 | if (curr_gw && bw <= max_bw) |
50164d8f AQ |
577 | goto next; |
578 | ||
79a0bffb | 579 | batadv_gw_node_put(curr_gw); |
50164d8f AQ |
580 | |
581 | curr_gw = gw_node; | |
582 | kref_get(&curr_gw->refcount); | |
583 | max_bw = bw; | |
584 | ||
585 | next: | |
586 | batadv_gw_node_put(gw_node); | |
587 | } | |
588 | rcu_read_unlock(); | |
589 | ||
590 | return curr_gw; | |
591 | } | |
592 | ||
593 | /** | |
7e9a8c2c | 594 | * batadv_v_gw_is_eligible() - check if a originator would be selected as GW |
50164d8f AQ |
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 | { | |
422d2f77 | 605 | struct batadv_gw_node *curr_gw, *orig_gw = NULL; |
50164d8f AQ |
606 | u32 gw_throughput, orig_throughput, threshold; |
607 | bool ret = false; | |
608 | ||
609 | threshold = atomic_read(&bat_priv->gw.sel_class); | |
610 | ||
611 | curr_gw = batadv_gw_node_get(bat_priv, curr_gw_orig); | |
612 | if (!curr_gw) { | |
613 | ret = true; | |
614 | goto out; | |
615 | } | |
616 | ||
617 | if (batadv_v_gw_throughput_get(curr_gw, &gw_throughput) < 0) { | |
618 | ret = true; | |
619 | goto out; | |
620 | } | |
621 | ||
622 | orig_gw = batadv_gw_node_get(bat_priv, orig_node); | |
198a62dd | 623 | if (!orig_gw) |
50164d8f AQ |
624 | goto out; |
625 | ||
626 | if (batadv_v_gw_throughput_get(orig_gw, &orig_throughput) < 0) | |
627 | goto out; | |
628 | ||
629 | if (orig_throughput < gw_throughput) | |
630 | goto out; | |
631 | ||
632 | if ((orig_throughput - gw_throughput) < threshold) | |
633 | goto out; | |
634 | ||
635 | batadv_dbg(BATADV_DBG_BATMAN, bat_priv, | |
636 | "Restarting gateway selection: better gateway found (throughput curr: %u, throughput new: %u)\n", | |
637 | gw_throughput, orig_throughput); | |
638 | ||
639 | ret = true; | |
640 | out: | |
79a0bffb SE |
641 | batadv_gw_node_put(curr_gw); |
642 | batadv_gw_node_put(orig_gw); | |
50164d8f AQ |
643 | |
644 | return ret; | |
645 | } | |
646 | ||
b71bb6f9 | 647 | /** |
7e9a8c2c | 648 | * batadv_v_gw_dump_entry() - Dump a gateway into a message |
b71bb6f9 SE |
649 | * @msg: Netlink message to dump into |
650 | * @portid: Port making netlink request | |
9264c85c | 651 | * @cb: Control block containing additional options |
b71bb6f9 SE |
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 | */ | |
9264c85c SE |
657 | static int batadv_v_gw_dump_entry(struct sk_buff *msg, u32 portid, |
658 | struct netlink_callback *cb, | |
b71bb6f9 SE |
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; | |
9713cb0c | 664 | struct batadv_gw_node *curr_gw = NULL; |
011c935f | 665 | int ret = 0; |
b71bb6f9 SE |
666 | void *hdr; |
667 | ||
668 | router = batadv_orig_router_get(gw_node->orig_node, BATADV_IF_DEFAULT); | |
669 | if (!router) | |
670 | goto out; | |
671 | ||
672 | router_ifinfo = batadv_neigh_ifinfo_get(router, BATADV_IF_DEFAULT); | |
673 | if (!router_ifinfo) | |
674 | goto out; | |
675 | ||
676 | curr_gw = batadv_gw_get_selected_gw_node(bat_priv); | |
677 | ||
9264c85c SE |
678 | hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq, |
679 | &batadv_netlink_family, NLM_F_MULTI, | |
680 | BATADV_CMD_GET_GATEWAYS); | |
b71bb6f9 SE |
681 | if (!hdr) { |
682 | ret = -ENOBUFS; | |
683 | goto out; | |
684 | } | |
685 | ||
9264c85c SE |
686 | genl_dump_check_consistent(cb, hdr); |
687 | ||
b71bb6f9 SE |
688 | ret = -EMSGSIZE; |
689 | ||
690 | if (curr_gw == gw_node) { | |
691 | if (nla_put_flag(msg, BATADV_ATTR_FLAG_BEST)) { | |
692 | genlmsg_cancel(msg, hdr); | |
693 | goto out; | |
694 | } | |
695 | } | |
696 | ||
697 | if (nla_put(msg, BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN, | |
698 | gw_node->orig_node->orig)) { | |
699 | genlmsg_cancel(msg, hdr); | |
700 | goto out; | |
701 | } | |
702 | ||
703 | if (nla_put_u32(msg, BATADV_ATTR_THROUGHPUT, | |
704 | router_ifinfo->bat_v.throughput)) { | |
705 | genlmsg_cancel(msg, hdr); | |
706 | goto out; | |
707 | } | |
708 | ||
709 | if (nla_put(msg, BATADV_ATTR_ROUTER, ETH_ALEN, router->addr)) { | |
710 | genlmsg_cancel(msg, hdr); | |
711 | goto out; | |
712 | } | |
713 | ||
714 | if (nla_put_string(msg, BATADV_ATTR_HARD_IFNAME, | |
715 | router->if_incoming->net_dev->name)) { | |
716 | genlmsg_cancel(msg, hdr); | |
717 | goto out; | |
d295345a SE |
718 | } |
719 | ||
720 | if (nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX, | |
721 | router->if_incoming->net_dev->ifindex)) { | |
722 | genlmsg_cancel(msg, hdr); | |
723 | goto out; | |
b71bb6f9 SE |
724 | } |
725 | ||
726 | if (nla_put_u32(msg, BATADV_ATTR_BANDWIDTH_DOWN, | |
727 | gw_node->bandwidth_down)) { | |
728 | genlmsg_cancel(msg, hdr); | |
729 | goto out; | |
730 | } | |
731 | ||
732 | if (nla_put_u32(msg, BATADV_ATTR_BANDWIDTH_UP, gw_node->bandwidth_up)) { | |
733 | genlmsg_cancel(msg, hdr); | |
734 | goto out; | |
735 | } | |
736 | ||
737 | genlmsg_end(msg, hdr); | |
738 | ret = 0; | |
739 | ||
740 | out: | |
79a0bffb SE |
741 | batadv_gw_node_put(curr_gw); |
742 | batadv_neigh_ifinfo_put(router_ifinfo); | |
743 | batadv_neigh_node_put(router); | |
b71bb6f9 SE |
744 | return ret; |
745 | } | |
746 | ||
747 | /** | |
7e9a8c2c | 748 | * batadv_v_gw_dump() - Dump gateways into a message |
b71bb6f9 SE |
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 | ||
9264c85c SE |
761 | spin_lock_bh(&bat_priv->gw.list_lock); |
762 | cb->seq = bat_priv->gw.generation << 1 | 1; | |
763 | ||
764 | hlist_for_each_entry(gw_node, &bat_priv->gw.gateway_list, list) { | |
b71bb6f9 SE |
765 | if (idx++ < idx_skip) |
766 | continue; | |
767 | ||
9264c85c SE |
768 | if (batadv_v_gw_dump_entry(msg, portid, cb, bat_priv, |
769 | gw_node)) { | |
b71bb6f9 SE |
770 | idx_skip = idx - 1; |
771 | goto unlock; | |
772 | } | |
773 | } | |
774 | ||
775 | idx_skip = idx; | |
776 | unlock: | |
9264c85c | 777 | spin_unlock_bh(&bat_priv->gw.list_lock); |
b71bb6f9 SE |
778 | |
779 | cb->args[0] = idx_skip; | |
780 | } | |
781 | ||
d6f94d91 LL |
782 | static struct batadv_algo_ops batadv_batman_v __read_mostly = { |
783 | .name = "BATMAN_V", | |
29824a55 AQ |
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, | |
f02a478f | 795 | .dump = batadv_v_neigh_dump, |
29824a55 AQ |
796 | }, |
797 | .orig = { | |
f02a478f | 798 | .dump = batadv_v_orig_dump, |
29824a55 | 799 | }, |
08686943 | 800 | .gw = { |
1a9070ec | 801 | .init_sel_class = batadv_v_init_sel_class, |
6f96d46f | 802 | .sel_class_max = U32_MAX, |
50164d8f AQ |
803 | .get_best_gw_node = batadv_v_gw_get_best_gw_node, |
804 | .is_eligible = batadv_v_gw_is_eligible, | |
b71bb6f9 | 805 | .dump = batadv_v_gw_dump, |
08686943 | 806 | }, |
d6f94d91 LL |
807 | }; |
808 | ||
7db682d1 | 809 | /** |
7e9a8c2c | 810 | * batadv_v_hardif_init() - initialize the algorithm specific fields in the |
7db682d1 ML |
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(&hard_iface->bat_v.throughput_override, 0); | |
820 | atomic_set(&hard_iface->bat_v.elp_interval, 500); | |
f89255a0 LL |
821 | |
822 | hard_iface->bat_v.aggr_len = 0; | |
823 | skb_queue_head_init(&hard_iface->bat_v.aggr_list); | |
f89255a0 LL |
824 | INIT_DELAYED_WORK(&hard_iface->bat_v.aggr_wq, |
825 | batadv_v_ogm_aggr_work); | |
7db682d1 ML |
826 | } |
827 | ||
0da00359 | 828 | /** |
7e9a8c2c | 829 | * batadv_v_mesh_init() - initialize the B.A.T.M.A.N. V private resources for a |
0da00359 AQ |
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 | { | |
50164d8f AQ |
837 | int ret = 0; |
838 | ||
839 | ret = batadv_v_ogm_init(bat_priv); | |
840 | if (ret < 0) | |
841 | return ret; | |
842 | ||
50164d8f | 843 | return 0; |
0da00359 AQ |
844 | } |
845 | ||
846 | /** | |
7e9a8c2c | 847 | * batadv_v_mesh_free() - free the B.A.T.M.A.N. V private resources for a mesh |
0da00359 AQ |
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 | ||
d6f94d91 | 855 | /** |
7e9a8c2c | 856 | * batadv_v_init() - B.A.T.M.A.N. V initialization function |
d6f94d91 LL |
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 | { | |
162bd64c LL |
865 | int ret; |
866 | ||
867 | /* B.A.T.M.A.N. V echo location protocol packet */ | |
868 | ret = batadv_recv_handler_register(BATADV_ELP, | |
869 | batadv_v_elp_packet_recv); | |
870 | if (ret < 0) | |
871 | return ret; | |
872 | ||
0da00359 AQ |
873 | ret = batadv_recv_handler_register(BATADV_OGM2, |
874 | batadv_v_ogm_packet_recv); | |
875 | if (ret < 0) | |
876 | goto elp_unregister; | |
162bd64c | 877 | |
0da00359 | 878 | ret = batadv_algo_register(&batadv_batman_v); |
162bd64c | 879 | if (ret < 0) |
0da00359 AQ |
880 | goto ogm_unregister; |
881 | ||
882 | return ret; | |
883 | ||
884 | ogm_unregister: | |
885 | batadv_recv_handler_unregister(BATADV_OGM2); | |
886 | ||
887 | elp_unregister: | |
888 | batadv_recv_handler_unregister(BATADV_ELP); | |
162bd64c LL |
889 | |
890 | return ret; | |
d6f94d91 | 891 | } |