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