1 /* Copyright (C) 2011-2017 B.A.T.M.A.N. contributors:
3 * Linus Lüssing, Marek Lindner
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of version 2 of the GNU General Public
7 * License as published by the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, see <http://www.gnu.org/licenses/>.
18 #include "bat_v_elp.h"
21 #include <linux/atomic.h>
22 #include <linux/bitops.h>
23 #include <linux/byteorder/generic.h>
24 #include <linux/errno.h>
25 #include <linux/etherdevice.h>
26 #include <linux/ethtool.h>
28 #include <linux/if_ether.h>
29 #include <linux/jiffies.h>
30 #include <linux/kernel.h>
31 #include <linux/kref.h>
32 #include <linux/netdevice.h>
33 #include <linux/nl80211.h>
34 #include <linux/random.h>
35 #include <linux/rculist.h>
36 #include <linux/rcupdate.h>
37 #include <linux/rtnetlink.h>
38 #include <linux/skbuff.h>
39 #include <linux/stddef.h>
40 #include <linux/string.h>
41 #include <linux/types.h>
42 #include <linux/workqueue.h>
43 #include <net/cfg80211.h>
46 #include "bat_v_ogm.h"
47 #include "hard-interface.h"
49 #include "originator.h"
55 * batadv_v_elp_start_timer - restart timer for ELP periodic work
56 * @hard_iface: the interface for which the timer has to be reset
58 static void batadv_v_elp_start_timer(struct batadv_hard_iface
*hard_iface
)
62 msecs
= atomic_read(&hard_iface
->bat_v
.elp_interval
) - BATADV_JITTER
;
63 msecs
+= prandom_u32() % (2 * BATADV_JITTER
);
65 queue_delayed_work(batadv_event_workqueue
, &hard_iface
->bat_v
.elp_wq
,
66 msecs_to_jiffies(msecs
));
70 * batadv_v_elp_get_throughput - get the throughput towards a neighbour
71 * @neigh: the neighbour for which the throughput has to be obtained
73 * Return: The throughput towards the given neighbour in multiples of 100kpbs
74 * (a value of '1' equals to 0.1Mbps, '10' equals 1Mbps, etc).
76 static u32
batadv_v_elp_get_throughput(struct batadv_hardif_neigh_node
*neigh
)
78 struct batadv_hard_iface
*hard_iface
= neigh
->if_incoming
;
79 struct ethtool_link_ksettings link_settings
;
80 struct net_device
*real_netdev
;
81 struct station_info sinfo
;
85 /* if the user specified a customised value for this interface, then
88 throughput
= atomic_read(&hard_iface
->bat_v
.throughput_override
);
92 /* if this is a wireless device, then ask its throughput through
95 if (batadv_is_wifi_hardif(hard_iface
)) {
96 if (!batadv_is_cfg80211_hardif(hard_iface
))
97 /* unsupported WiFi driver version */
98 goto default_throughput
;
100 real_netdev
= batadv_get_real_netdev(hard_iface
->net_dev
);
102 goto default_throughput
;
104 ret
= cfg80211_get_station(real_netdev
, neigh
->addr
, &sinfo
);
106 dev_put(real_netdev
);
107 if (ret
== -ENOENT
) {
108 /* Node is not associated anymore! It would be
109 * possible to delete this neighbor. For now set
110 * the throughput metric to 0.
115 goto default_throughput
;
116 if (!(sinfo
.filled
& BIT(NL80211_STA_INFO_EXPECTED_THROUGHPUT
)))
117 goto default_throughput
;
119 return sinfo
.expected_throughput
/ 100;
122 /* if not a wifi interface, check if this device provides data via
123 * ethtool (e.g. an Ethernet adapter)
125 memset(&link_settings
, 0, sizeof(link_settings
));
127 ret
= __ethtool_get_link_ksettings(hard_iface
->net_dev
, &link_settings
);
130 /* link characteristics might change over time */
131 if (link_settings
.base
.duplex
== DUPLEX_FULL
)
132 hard_iface
->bat_v
.flags
|= BATADV_FULL_DUPLEX
;
134 hard_iface
->bat_v
.flags
&= ~BATADV_FULL_DUPLEX
;
136 throughput
= link_settings
.base
.speed
;
137 if (throughput
&& (throughput
!= SPEED_UNKNOWN
))
138 return throughput
* 10;
142 if (!(hard_iface
->bat_v
.flags
& BATADV_WARNING_DEFAULT
)) {
143 batadv_info(hard_iface
->soft_iface
,
144 "WiFi driver or ethtool info does not provide information about link speeds on interface %s, therefore defaulting to hardcoded throughput values of %u.%1u Mbps. Consider overriding the throughput manually or checking your driver.\n",
145 hard_iface
->net_dev
->name
,
146 BATADV_THROUGHPUT_DEFAULT_VALUE
/ 10,
147 BATADV_THROUGHPUT_DEFAULT_VALUE
% 10);
148 hard_iface
->bat_v
.flags
|= BATADV_WARNING_DEFAULT
;
151 /* if none of the above cases apply, return the base_throughput */
152 return BATADV_THROUGHPUT_DEFAULT_VALUE
;
156 * batadv_v_elp_throughput_metric_update - worker updating the throughput metric
157 * of a single hop neighbour
158 * @work: the work queue item
160 void batadv_v_elp_throughput_metric_update(struct work_struct
*work
)
162 struct batadv_hardif_neigh_node_bat_v
*neigh_bat_v
;
163 struct batadv_hardif_neigh_node
*neigh
;
165 neigh_bat_v
= container_of(work
, struct batadv_hardif_neigh_node_bat_v
,
167 neigh
= container_of(neigh_bat_v
, struct batadv_hardif_neigh_node
,
170 ewma_throughput_add(&neigh
->bat_v
.throughput
,
171 batadv_v_elp_get_throughput(neigh
));
173 /* decrement refcounter to balance increment performed before scheduling
176 batadv_hardif_neigh_put(neigh
);
180 * batadv_v_elp_wifi_neigh_probe - send link probing packets to a neighbour
181 * @neigh: the neighbour to probe
183 * Sends a predefined number of unicast wifi packets to a given neighbour in
184 * order to trigger the throughput estimation on this link by the RC algorithm.
185 * Packets are sent only if there there is not enough payload unicast traffic
186 * towards this neighbour..
188 * Return: True on success and false in case of error during skb preparation.
191 batadv_v_elp_wifi_neigh_probe(struct batadv_hardif_neigh_node
*neigh
)
193 struct batadv_hard_iface
*hard_iface
= neigh
->if_incoming
;
194 struct batadv_priv
*bat_priv
= netdev_priv(hard_iface
->soft_iface
);
195 unsigned long last_tx_diff
;
200 /* this probing routine is for Wifi neighbours only */
201 if (!batadv_is_wifi_hardif(hard_iface
))
204 /* probe the neighbor only if no unicast packets have been sent
205 * to it in the last 100 milliseconds: this is the rate control
206 * algorithm sampling interval (minstrel). In this way, if not
207 * enough traffic has been sent to the neighbor, batman-adv can
208 * generate 2 probe packets and push the RC algorithm to perform
211 last_tx_diff
= jiffies_to_msecs(jiffies
- neigh
->bat_v
.last_unicast_tx
);
212 if (last_tx_diff
<= BATADV_ELP_PROBE_MAX_TX_DIFF
)
215 probe_len
= max_t(int, sizeof(struct batadv_elp_packet
),
216 BATADV_ELP_MIN_PROBE_SIZE
);
218 for (i
= 0; i
< BATADV_ELP_PROBES_PER_NODE
; i
++) {
219 elp_skb_len
= hard_iface
->bat_v
.elp_skb
->len
;
220 skb
= skb_copy_expand(hard_iface
->bat_v
.elp_skb
, 0,
221 probe_len
- elp_skb_len
,
226 /* Tell the skb to get as big as the allocated space (we want
227 * the packet to be exactly of that size to make the link
228 * throughput estimation effective.
230 skb_put(skb
, probe_len
- hard_iface
->bat_v
.elp_skb
->len
);
232 batadv_dbg(BATADV_DBG_BATMAN
, bat_priv
,
233 "Sending unicast (probe) ELP packet on interface %s to %pM\n",
234 hard_iface
->net_dev
->name
, neigh
->addr
);
236 batadv_send_skb_packet(skb
, hard_iface
, neigh
->addr
);
243 * batadv_v_elp_periodic_work - ELP periodic task per interface
244 * @work: work queue item
246 * Emits broadcast ELP message in regular intervals.
248 static void batadv_v_elp_periodic_work(struct work_struct
*work
)
250 struct batadv_hardif_neigh_node
*hardif_neigh
;
251 struct batadv_hard_iface
*hard_iface
;
252 struct batadv_hard_iface_bat_v
*bat_v
;
253 struct batadv_elp_packet
*elp_packet
;
254 struct batadv_priv
*bat_priv
;
258 bat_v
= container_of(work
, struct batadv_hard_iface_bat_v
, elp_wq
.work
);
259 hard_iface
= container_of(bat_v
, struct batadv_hard_iface
, bat_v
);
260 bat_priv
= netdev_priv(hard_iface
->soft_iface
);
262 if (atomic_read(&bat_priv
->mesh_state
) == BATADV_MESH_DEACTIVATING
)
265 /* we are in the process of shutting this interface down */
266 if ((hard_iface
->if_status
== BATADV_IF_NOT_IN_USE
) ||
267 (hard_iface
->if_status
== BATADV_IF_TO_BE_REMOVED
))
270 /* the interface was enabled but may not be ready yet */
271 if (hard_iface
->if_status
!= BATADV_IF_ACTIVE
)
274 skb
= skb_copy(hard_iface
->bat_v
.elp_skb
, GFP_ATOMIC
);
278 elp_packet
= (struct batadv_elp_packet
*)skb
->data
;
279 elp_packet
->seqno
= htonl(atomic_read(&hard_iface
->bat_v
.elp_seqno
));
280 elp_interval
= atomic_read(&hard_iface
->bat_v
.elp_interval
);
281 elp_packet
->elp_interval
= htonl(elp_interval
);
283 batadv_dbg(BATADV_DBG_BATMAN
, bat_priv
,
284 "Sending broadcast ELP packet on interface %s, seqno %u\n",
285 hard_iface
->net_dev
->name
,
286 atomic_read(&hard_iface
->bat_v
.elp_seqno
));
288 batadv_send_broadcast_skb(skb
, hard_iface
);
290 atomic_inc(&hard_iface
->bat_v
.elp_seqno
);
292 /* The throughput metric is updated on each sent packet. This way, if a
293 * node is dead and no longer sends packets, batman-adv is still able to
294 * react timely to its death.
296 * The throughput metric is updated by following these steps:
297 * 1) if the hard_iface is wifi => send a number of unicast ELPs for
298 * probing/sampling to each neighbor
299 * 2) update the throughput metric value of each neighbor (note that the
300 * value retrieved in this step might be 100ms old because the
301 * probing packets at point 1) could still be in the HW queue)
304 hlist_for_each_entry_rcu(hardif_neigh
, &hard_iface
->neigh_list
, list
) {
305 if (!batadv_v_elp_wifi_neigh_probe(hardif_neigh
))
306 /* if something goes wrong while probing, better to stop
307 * sending packets immediately and reschedule the task
311 if (!kref_get_unless_zero(&hardif_neigh
->refcount
))
314 /* Reading the estimated throughput from cfg80211 is a task that
315 * may sleep and that is not allowed in an rcu protected
316 * context. Therefore schedule a task for that.
318 queue_work(batadv_event_workqueue
,
319 &hardif_neigh
->bat_v
.metric_work
);
324 batadv_v_elp_start_timer(hard_iface
);
330 * batadv_v_elp_iface_enable - setup the ELP interface private resources
331 * @hard_iface: interface for which the data has to be prepared
333 * Return: 0 on success or a -ENOMEM in case of failure.
335 int batadv_v_elp_iface_enable(struct batadv_hard_iface
*hard_iface
)
337 struct batadv_elp_packet
*elp_packet
;
338 unsigned char *elp_buff
;
343 size
= ETH_HLEN
+ NET_IP_ALIGN
+ BATADV_ELP_HLEN
;
344 hard_iface
->bat_v
.elp_skb
= dev_alloc_skb(size
);
345 if (!hard_iface
->bat_v
.elp_skb
)
348 skb_reserve(hard_iface
->bat_v
.elp_skb
, ETH_HLEN
+ NET_IP_ALIGN
);
349 elp_buff
= skb_put_zero(hard_iface
->bat_v
.elp_skb
, BATADV_ELP_HLEN
);
350 elp_packet
= (struct batadv_elp_packet
*)elp_buff
;
352 elp_packet
->packet_type
= BATADV_ELP
;
353 elp_packet
->version
= BATADV_COMPAT_VERSION
;
355 /* randomize initial seqno to avoid collision */
356 get_random_bytes(&random_seqno
, sizeof(random_seqno
));
357 atomic_set(&hard_iface
->bat_v
.elp_seqno
, random_seqno
);
359 /* assume full-duplex by default */
360 hard_iface
->bat_v
.flags
|= BATADV_FULL_DUPLEX
;
362 /* warn the user (again) if there is no throughput data is available */
363 hard_iface
->bat_v
.flags
&= ~BATADV_WARNING_DEFAULT
;
365 if (batadv_is_wifi_hardif(hard_iface
))
366 hard_iface
->bat_v
.flags
&= ~BATADV_FULL_DUPLEX
;
368 INIT_DELAYED_WORK(&hard_iface
->bat_v
.elp_wq
,
369 batadv_v_elp_periodic_work
);
370 batadv_v_elp_start_timer(hard_iface
);
378 * batadv_v_elp_iface_disable - release ELP interface private resources
379 * @hard_iface: interface for which the resources have to be released
381 void batadv_v_elp_iface_disable(struct batadv_hard_iface
*hard_iface
)
383 cancel_delayed_work_sync(&hard_iface
->bat_v
.elp_wq
);
385 dev_kfree_skb(hard_iface
->bat_v
.elp_skb
);
386 hard_iface
->bat_v
.elp_skb
= NULL
;
390 * batadv_v_elp_iface_activate - update the ELP buffer belonging to the given
392 * @primary_iface: the new primary interface
393 * @hard_iface: interface holding the to-be-updated buffer
395 void batadv_v_elp_iface_activate(struct batadv_hard_iface
*primary_iface
,
396 struct batadv_hard_iface
*hard_iface
)
398 struct batadv_elp_packet
*elp_packet
;
401 if (!hard_iface
->bat_v
.elp_skb
)
404 skb
= hard_iface
->bat_v
.elp_skb
;
405 elp_packet
= (struct batadv_elp_packet
*)skb
->data
;
406 ether_addr_copy(elp_packet
->orig
,
407 primary_iface
->net_dev
->dev_addr
);
411 * batadv_v_elp_primary_iface_set - change internal data to reflect the new
413 * @primary_iface: the new primary interface
415 void batadv_v_elp_primary_iface_set(struct batadv_hard_iface
*primary_iface
)
417 struct batadv_hard_iface
*hard_iface
;
419 /* update orig field of every elp iface belonging to this mesh */
421 list_for_each_entry_rcu(hard_iface
, &batadv_hardif_list
, list
) {
422 if (primary_iface
->soft_iface
!= hard_iface
->soft_iface
)
425 batadv_v_elp_iface_activate(primary_iface
, hard_iface
);
431 * batadv_v_elp_neigh_update - update an ELP neighbour node
432 * @bat_priv: the bat priv with all the soft interface information
433 * @neigh_addr: the neighbour interface address
434 * @if_incoming: the interface the packet was received through
435 * @elp_packet: the received ELP packet
437 * Updates the ELP neighbour node state with the data received within the new
440 static void batadv_v_elp_neigh_update(struct batadv_priv
*bat_priv
,
442 struct batadv_hard_iface
*if_incoming
,
443 struct batadv_elp_packet
*elp_packet
)
446 struct batadv_neigh_node
*neigh
;
447 struct batadv_orig_node
*orig_neigh
;
448 struct batadv_hardif_neigh_node
*hardif_neigh
;
450 s32 elp_latest_seqno
;
452 orig_neigh
= batadv_v_ogm_orig_get(bat_priv
, elp_packet
->orig
);
456 neigh
= batadv_neigh_node_get_or_create(orig_neigh
,
457 if_incoming
, neigh_addr
);
461 hardif_neigh
= batadv_hardif_neigh_get(if_incoming
, neigh_addr
);
465 elp_latest_seqno
= hardif_neigh
->bat_v
.elp_latest_seqno
;
466 seqno_diff
= ntohl(elp_packet
->seqno
) - elp_latest_seqno
;
468 /* known or older sequence numbers are ignored. However always adopt
469 * if the router seems to have been restarted.
471 if (seqno_diff
< 1 && seqno_diff
> -BATADV_ELP_MAX_AGE
)
474 neigh
->last_seen
= jiffies
;
475 hardif_neigh
->last_seen
= jiffies
;
476 hardif_neigh
->bat_v
.elp_latest_seqno
= ntohl(elp_packet
->seqno
);
477 hardif_neigh
->bat_v
.elp_interval
= ntohl(elp_packet
->elp_interval
);
481 batadv_hardif_neigh_put(hardif_neigh
);
484 batadv_neigh_node_put(neigh
);
487 batadv_orig_node_put(orig_neigh
);
491 * batadv_v_elp_packet_recv - main ELP packet handler
492 * @skb: the received packet
493 * @if_incoming: the interface this packet was received through
495 * Return: NET_RX_SUCCESS and consumes the skb if the packet was peoperly
496 * processed or NET_RX_DROP in case of failure.
498 int batadv_v_elp_packet_recv(struct sk_buff
*skb
,
499 struct batadv_hard_iface
*if_incoming
)
501 struct batadv_priv
*bat_priv
= netdev_priv(if_incoming
->soft_iface
);
502 struct batadv_elp_packet
*elp_packet
;
503 struct batadv_hard_iface
*primary_if
;
504 struct ethhdr
*ethhdr
= (struct ethhdr
*)skb_mac_header(skb
);
506 int ret
= NET_RX_DROP
;
508 res
= batadv_check_management_packet(skb
, if_incoming
, BATADV_ELP_HLEN
);
512 if (batadv_is_my_mac(bat_priv
, ethhdr
->h_source
))
515 /* did we receive a B.A.T.M.A.N. V ELP packet on an interface
516 * that does not have B.A.T.M.A.N. V ELP enabled ?
518 if (strcmp(bat_priv
->algo_ops
->name
, "BATMAN_V") != 0)
521 elp_packet
= (struct batadv_elp_packet
*)skb
->data
;
523 batadv_dbg(BATADV_DBG_BATMAN
, bat_priv
,
524 "Received ELP packet from %pM seqno %u ORIG: %pM\n",
525 ethhdr
->h_source
, ntohl(elp_packet
->seqno
),
528 primary_if
= batadv_primary_if_get_selected(bat_priv
);
532 batadv_v_elp_neigh_update(bat_priv
, ethhdr
->h_source
, if_incoming
,
535 ret
= NET_RX_SUCCESS
;
536 batadv_hardif_put(primary_if
);
539 if (ret
== NET_RX_SUCCESS
)