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_elp.h" |
8 | #include "main.h" |
9 | |
10 | #include <linux/atomic.h> |
11 | #include <linux/bitops.h> |
12 | #include <linux/byteorder/generic.h> |
13 | #include <linux/container_of.h> |
14 | #include <linux/errno.h> |
15 | #include <linux/etherdevice.h> |
16 | #include <linux/ethtool.h> |
17 | #include <linux/gfp.h> |
18 | #include <linux/if_ether.h> |
19 | #include <linux/jiffies.h> |
20 | #include <linux/kref.h> |
21 | #include <linux/minmax.h> |
22 | #include <linux/netdevice.h> |
23 | #include <linux/nl80211.h> |
24 | #include <linux/random.h> |
25 | #include <linux/rculist.h> |
26 | #include <linux/rcupdate.h> |
27 | #include <linux/rtnetlink.h> |
28 | #include <linux/skbuff.h> |
29 | #include <linux/stddef.h> |
30 | #include <linux/string.h> |
31 | #include <linux/types.h> |
32 | #include <linux/workqueue.h> |
33 | #include <net/cfg80211.h> |
34 | #include <uapi/linux/batadv_packet.h> |
35 | |
36 | #include "bat_algo.h" |
37 | #include "bat_v_ogm.h" |
38 | #include "hard-interface.h" |
39 | #include "log.h" |
40 | #include "originator.h" |
41 | #include "routing.h" |
42 | #include "send.h" |
43 | |
44 | /** |
45 | * batadv_v_elp_start_timer() - restart timer for ELP periodic work |
46 | * @hard_iface: the interface for which the timer has to be reset |
47 | */ |
48 | static void batadv_v_elp_start_timer(struct batadv_hard_iface *hard_iface) |
49 | { |
50 | unsigned int msecs; |
51 | |
52 | msecs = atomic_read(v: &hard_iface->bat_v.elp_interval) - BATADV_JITTER; |
53 | msecs += get_random_u32_below(ceil: 2 * BATADV_JITTER); |
54 | |
55 | queue_delayed_work(wq: batadv_event_workqueue, dwork: &hard_iface->bat_v.elp_wq, |
56 | delay: msecs_to_jiffies(m: msecs)); |
57 | } |
58 | |
59 | /** |
60 | * batadv_v_elp_get_throughput() - get the throughput towards a neighbour |
61 | * @neigh: the neighbour for which the throughput has to be obtained |
62 | * |
63 | * Return: The throughput towards the given neighbour in multiples of 100kpbs |
64 | * (a value of '1' equals 0.1Mbps, '10' equals 1Mbps, etc). |
65 | */ |
66 | static u32 batadv_v_elp_get_throughput(struct batadv_hardif_neigh_node *neigh) |
67 | { |
68 | struct batadv_hard_iface *hard_iface = neigh->if_incoming; |
69 | struct ethtool_link_ksettings link_settings; |
70 | struct net_device *real_netdev; |
71 | struct station_info sinfo; |
72 | u32 throughput; |
73 | int ret; |
74 | |
75 | /* if the user specified a customised value for this interface, then |
76 | * return it directly |
77 | */ |
78 | throughput = atomic_read(v: &hard_iface->bat_v.throughput_override); |
79 | if (throughput != 0) |
80 | return throughput; |
81 | |
82 | /* if this is a wireless device, then ask its throughput through |
83 | * cfg80211 API |
84 | */ |
85 | if (batadv_is_wifi_hardif(hard_iface)) { |
86 | if (!batadv_is_cfg80211_hardif(hard_iface)) |
87 | /* unsupported WiFi driver version */ |
88 | goto default_throughput; |
89 | |
90 | real_netdev = batadv_get_real_netdev(net_device: hard_iface->net_dev); |
91 | if (!real_netdev) |
92 | goto default_throughput; |
93 | |
94 | ret = cfg80211_get_station(dev: real_netdev, mac_addr: neigh->addr, sinfo: &sinfo); |
95 | |
96 | if (!ret) { |
97 | /* free the TID stats immediately */ |
98 | cfg80211_sinfo_release_content(sinfo: &sinfo); |
99 | } |
100 | |
101 | dev_put(dev: real_netdev); |
102 | if (ret == -ENOENT) { |
103 | /* Node is not associated anymore! It would be |
104 | * possible to delete this neighbor. For now set |
105 | * the throughput metric to 0. |
106 | */ |
107 | return 0; |
108 | } |
109 | if (ret) |
110 | goto default_throughput; |
111 | |
112 | if (sinfo.filled & BIT(NL80211_STA_INFO_EXPECTED_THROUGHPUT)) |
113 | return sinfo.expected_throughput / 100; |
114 | |
115 | /* try to estimate the expected throughput based on reported tx |
116 | * rates |
117 | */ |
118 | if (sinfo.filled & BIT(NL80211_STA_INFO_TX_BITRATE)) |
119 | return cfg80211_calculate_bitrate(rate: &sinfo.txrate) / 3; |
120 | |
121 | goto default_throughput; |
122 | } |
123 | |
124 | /* if not a wifi interface, check if this device provides data via |
125 | * ethtool (e.g. an Ethernet adapter) |
126 | */ |
127 | rtnl_lock(); |
128 | ret = __ethtool_get_link_ksettings(dev: hard_iface->net_dev, link_ksettings: &link_settings); |
129 | rtnl_unlock(); |
130 | if (ret == 0) { |
131 | /* link characteristics might change over time */ |
132 | if (link_settings.base.duplex == DUPLEX_FULL) |
133 | hard_iface->bat_v.flags |= BATADV_FULL_DUPLEX; |
134 | else |
135 | hard_iface->bat_v.flags &= ~BATADV_FULL_DUPLEX; |
136 | |
137 | throughput = link_settings.base.speed; |
138 | if (throughput && throughput != SPEED_UNKNOWN) |
139 | return throughput * 10; |
140 | } |
141 | |
142 | default_throughput: |
143 | if (!(hard_iface->bat_v.flags & BATADV_WARNING_DEFAULT)) { |
144 | batadv_info(hard_iface->soft_iface, |
145 | "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" , |
146 | hard_iface->net_dev->name, |
147 | BATADV_THROUGHPUT_DEFAULT_VALUE / 10, |
148 | BATADV_THROUGHPUT_DEFAULT_VALUE % 10); |
149 | hard_iface->bat_v.flags |= BATADV_WARNING_DEFAULT; |
150 | } |
151 | |
152 | /* if none of the above cases apply, return the base_throughput */ |
153 | return BATADV_THROUGHPUT_DEFAULT_VALUE; |
154 | } |
155 | |
156 | /** |
157 | * batadv_v_elp_throughput_metric_update() - worker updating the throughput |
158 | * metric of a single hop neighbour |
159 | * @work: the work queue item |
160 | */ |
161 | void batadv_v_elp_throughput_metric_update(struct work_struct *work) |
162 | { |
163 | struct batadv_hardif_neigh_node_bat_v *neigh_bat_v; |
164 | struct batadv_hardif_neigh_node *neigh; |
165 | |
166 | neigh_bat_v = container_of(work, struct batadv_hardif_neigh_node_bat_v, |
167 | metric_work); |
168 | neigh = container_of(neigh_bat_v, struct batadv_hardif_neigh_node, |
169 | bat_v); |
170 | |
171 | ewma_throughput_add(e: &neigh->bat_v.throughput, |
172 | val: batadv_v_elp_get_throughput(neigh)); |
173 | |
174 | /* decrement refcounter to balance increment performed before scheduling |
175 | * this task |
176 | */ |
177 | batadv_hardif_neigh_put(hardif_neigh: neigh); |
178 | } |
179 | |
180 | /** |
181 | * batadv_v_elp_wifi_neigh_probe() - send link probing packets to a neighbour |
182 | * @neigh: the neighbour to probe |
183 | * |
184 | * Sends a predefined number of unicast wifi packets to a given neighbour in |
185 | * order to trigger the throughput estimation on this link by the RC algorithm. |
186 | * Packets are sent only if there is not enough payload unicast traffic towards |
187 | * this neighbour.. |
188 | * |
189 | * Return: True on success and false in case of error during skb preparation. |
190 | */ |
191 | static bool |
192 | batadv_v_elp_wifi_neigh_probe(struct batadv_hardif_neigh_node *neigh) |
193 | { |
194 | struct batadv_hard_iface *hard_iface = neigh->if_incoming; |
195 | struct batadv_priv *bat_priv = netdev_priv(dev: hard_iface->soft_iface); |
196 | unsigned long last_tx_diff; |
197 | struct sk_buff *skb; |
198 | int probe_len, i; |
199 | int elp_skb_len; |
200 | |
201 | /* this probing routine is for Wifi neighbours only */ |
202 | if (!batadv_is_wifi_hardif(hard_iface)) |
203 | return true; |
204 | |
205 | /* probe the neighbor only if no unicast packets have been sent |
206 | * to it in the last 100 milliseconds: this is the rate control |
207 | * algorithm sampling interval (minstrel). In this way, if not |
208 | * enough traffic has been sent to the neighbor, batman-adv can |
209 | * generate 2 probe packets and push the RC algorithm to perform |
210 | * the sampling |
211 | */ |
212 | last_tx_diff = jiffies_to_msecs(j: jiffies - neigh->bat_v.last_unicast_tx); |
213 | if (last_tx_diff <= BATADV_ELP_PROBE_MAX_TX_DIFF) |
214 | return true; |
215 | |
216 | probe_len = max_t(int, sizeof(struct batadv_elp_packet), |
217 | BATADV_ELP_MIN_PROBE_SIZE); |
218 | |
219 | for (i = 0; i < BATADV_ELP_PROBES_PER_NODE; i++) { |
220 | elp_skb_len = hard_iface->bat_v.elp_skb->len; |
221 | skb = skb_copy_expand(skb: hard_iface->bat_v.elp_skb, newheadroom: 0, |
222 | newtailroom: probe_len - elp_skb_len, |
223 | GFP_ATOMIC); |
224 | if (!skb) |
225 | return false; |
226 | |
227 | /* Tell the skb to get as big as the allocated space (we want |
228 | * the packet to be exactly of that size to make the link |
229 | * throughput estimation effective. |
230 | */ |
231 | skb_put_zero(skb, len: probe_len - hard_iface->bat_v.elp_skb->len); |
232 | |
233 | batadv_dbg(BATADV_DBG_BATMAN, bat_priv, |
234 | "Sending unicast (probe) ELP packet on interface %s to %pM\n" , |
235 | hard_iface->net_dev->name, neigh->addr); |
236 | |
237 | batadv_send_skb_packet(skb, hard_iface, dst_addr: neigh->addr); |
238 | } |
239 | |
240 | return true; |
241 | } |
242 | |
243 | /** |
244 | * batadv_v_elp_periodic_work() - ELP periodic task per interface |
245 | * @work: work queue item |
246 | * |
247 | * Emits broadcast ELP messages in regular intervals. |
248 | */ |
249 | static void batadv_v_elp_periodic_work(struct work_struct *work) |
250 | { |
251 | struct batadv_hardif_neigh_node *hardif_neigh; |
252 | struct batadv_hard_iface *hard_iface; |
253 | struct batadv_hard_iface_bat_v *bat_v; |
254 | struct batadv_elp_packet *elp_packet; |
255 | struct batadv_priv *bat_priv; |
256 | struct sk_buff *skb; |
257 | u32 elp_interval; |
258 | bool ret; |
259 | |
260 | bat_v = container_of(work, struct batadv_hard_iface_bat_v, elp_wq.work); |
261 | hard_iface = container_of(bat_v, struct batadv_hard_iface, bat_v); |
262 | bat_priv = netdev_priv(dev: hard_iface->soft_iface); |
263 | |
264 | if (atomic_read(v: &bat_priv->mesh_state) == BATADV_MESH_DEACTIVATING) |
265 | goto out; |
266 | |
267 | /* we are in the process of shutting this interface down */ |
268 | if (hard_iface->if_status == BATADV_IF_NOT_IN_USE || |
269 | hard_iface->if_status == BATADV_IF_TO_BE_REMOVED) |
270 | goto out; |
271 | |
272 | /* the interface was enabled but may not be ready yet */ |
273 | if (hard_iface->if_status != BATADV_IF_ACTIVE) |
274 | goto restart_timer; |
275 | |
276 | skb = skb_copy(skb: hard_iface->bat_v.elp_skb, GFP_ATOMIC); |
277 | if (!skb) |
278 | goto restart_timer; |
279 | |
280 | elp_packet = (struct batadv_elp_packet *)skb->data; |
281 | elp_packet->seqno = htonl(atomic_read(&hard_iface->bat_v.elp_seqno)); |
282 | elp_interval = atomic_read(v: &hard_iface->bat_v.elp_interval); |
283 | elp_packet->elp_interval = htonl(elp_interval); |
284 | |
285 | batadv_dbg(BATADV_DBG_BATMAN, bat_priv, |
286 | "Sending broadcast ELP packet on interface %s, seqno %u\n" , |
287 | hard_iface->net_dev->name, |
288 | atomic_read(&hard_iface->bat_v.elp_seqno)); |
289 | |
290 | batadv_send_broadcast_skb(skb, hard_iface); |
291 | |
292 | atomic_inc(v: &hard_iface->bat_v.elp_seqno); |
293 | |
294 | /* The throughput metric is updated on each sent packet. This way, if a |
295 | * node is dead and no longer sends packets, batman-adv is still able to |
296 | * react timely to its death. |
297 | * |
298 | * The throughput metric is updated by following these steps: |
299 | * 1) if the hard_iface is wifi => send a number of unicast ELPs for |
300 | * probing/sampling to each neighbor |
301 | * 2) update the throughput metric value of each neighbor (note that the |
302 | * value retrieved in this step might be 100ms old because the |
303 | * probing packets at point 1) could still be in the HW queue) |
304 | */ |
305 | rcu_read_lock(); |
306 | hlist_for_each_entry_rcu(hardif_neigh, &hard_iface->neigh_list, list) { |
307 | if (!batadv_v_elp_wifi_neigh_probe(neigh: hardif_neigh)) |
308 | /* if something goes wrong while probing, better to stop |
309 | * sending packets immediately and reschedule the task |
310 | */ |
311 | break; |
312 | |
313 | if (!kref_get_unless_zero(kref: &hardif_neigh->refcount)) |
314 | continue; |
315 | |
316 | /* Reading the estimated throughput from cfg80211 is a task that |
317 | * may sleep and that is not allowed in an rcu protected |
318 | * context. Therefore schedule a task for that. |
319 | */ |
320 | ret = queue_work(wq: batadv_event_workqueue, |
321 | work: &hardif_neigh->bat_v.metric_work); |
322 | |
323 | if (!ret) |
324 | batadv_hardif_neigh_put(hardif_neigh); |
325 | } |
326 | rcu_read_unlock(); |
327 | |
328 | restart_timer: |
329 | batadv_v_elp_start_timer(hard_iface); |
330 | out: |
331 | return; |
332 | } |
333 | |
334 | /** |
335 | * batadv_v_elp_iface_enable() - setup the ELP interface private resources |
336 | * @hard_iface: interface for which the data has to be prepared |
337 | * |
338 | * Return: 0 on success or a -ENOMEM in case of failure. |
339 | */ |
340 | int batadv_v_elp_iface_enable(struct batadv_hard_iface *hard_iface) |
341 | { |
342 | static const size_t tvlv_padding = sizeof(__be32); |
343 | struct batadv_elp_packet *elp_packet; |
344 | unsigned char *elp_buff; |
345 | u32 random_seqno; |
346 | size_t size; |
347 | int res = -ENOMEM; |
348 | |
349 | size = ETH_HLEN + NET_IP_ALIGN + BATADV_ELP_HLEN + tvlv_padding; |
350 | hard_iface->bat_v.elp_skb = dev_alloc_skb(length: size); |
351 | if (!hard_iface->bat_v.elp_skb) |
352 | goto out; |
353 | |
354 | skb_reserve(skb: hard_iface->bat_v.elp_skb, ETH_HLEN + NET_IP_ALIGN); |
355 | elp_buff = skb_put_zero(skb: hard_iface->bat_v.elp_skb, |
356 | BATADV_ELP_HLEN + tvlv_padding); |
357 | elp_packet = (struct batadv_elp_packet *)elp_buff; |
358 | |
359 | elp_packet->packet_type = BATADV_ELP; |
360 | elp_packet->version = BATADV_COMPAT_VERSION; |
361 | |
362 | /* randomize initial seqno to avoid collision */ |
363 | get_random_bytes(buf: &random_seqno, len: sizeof(random_seqno)); |
364 | atomic_set(v: &hard_iface->bat_v.elp_seqno, i: random_seqno); |
365 | |
366 | /* assume full-duplex by default */ |
367 | hard_iface->bat_v.flags |= BATADV_FULL_DUPLEX; |
368 | |
369 | /* warn the user (again) if there is no throughput data is available */ |
370 | hard_iface->bat_v.flags &= ~BATADV_WARNING_DEFAULT; |
371 | |
372 | if (batadv_is_wifi_hardif(hard_iface)) |
373 | hard_iface->bat_v.flags &= ~BATADV_FULL_DUPLEX; |
374 | |
375 | INIT_DELAYED_WORK(&hard_iface->bat_v.elp_wq, |
376 | batadv_v_elp_periodic_work); |
377 | batadv_v_elp_start_timer(hard_iface); |
378 | res = 0; |
379 | |
380 | out: |
381 | return res; |
382 | } |
383 | |
384 | /** |
385 | * batadv_v_elp_iface_disable() - release ELP interface private resources |
386 | * @hard_iface: interface for which the resources have to be released |
387 | */ |
388 | void batadv_v_elp_iface_disable(struct batadv_hard_iface *hard_iface) |
389 | { |
390 | cancel_delayed_work_sync(dwork: &hard_iface->bat_v.elp_wq); |
391 | |
392 | dev_kfree_skb(hard_iface->bat_v.elp_skb); |
393 | hard_iface->bat_v.elp_skb = NULL; |
394 | } |
395 | |
396 | /** |
397 | * batadv_v_elp_iface_activate() - update the ELP buffer belonging to the given |
398 | * hard-interface |
399 | * @primary_iface: the new primary interface |
400 | * @hard_iface: interface holding the to-be-updated buffer |
401 | */ |
402 | void batadv_v_elp_iface_activate(struct batadv_hard_iface *primary_iface, |
403 | struct batadv_hard_iface *hard_iface) |
404 | { |
405 | struct batadv_elp_packet *elp_packet; |
406 | struct sk_buff *skb; |
407 | |
408 | if (!hard_iface->bat_v.elp_skb) |
409 | return; |
410 | |
411 | skb = hard_iface->bat_v.elp_skb; |
412 | elp_packet = (struct batadv_elp_packet *)skb->data; |
413 | ether_addr_copy(dst: elp_packet->orig, |
414 | src: primary_iface->net_dev->dev_addr); |
415 | } |
416 | |
417 | /** |
418 | * batadv_v_elp_primary_iface_set() - change internal data to reflect the new |
419 | * primary interface |
420 | * @primary_iface: the new primary interface |
421 | */ |
422 | void batadv_v_elp_primary_iface_set(struct batadv_hard_iface *primary_iface) |
423 | { |
424 | struct batadv_hard_iface *hard_iface; |
425 | |
426 | /* update orig field of every elp iface belonging to this mesh */ |
427 | rcu_read_lock(); |
428 | list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { |
429 | if (primary_iface->soft_iface != hard_iface->soft_iface) |
430 | continue; |
431 | |
432 | batadv_v_elp_iface_activate(primary_iface, hard_iface); |
433 | } |
434 | rcu_read_unlock(); |
435 | } |
436 | |
437 | /** |
438 | * batadv_v_elp_neigh_update() - update an ELP neighbour node |
439 | * @bat_priv: the bat priv with all the soft interface information |
440 | * @neigh_addr: the neighbour interface address |
441 | * @if_incoming: the interface the packet was received through |
442 | * @elp_packet: the received ELP packet |
443 | * |
444 | * Updates the ELP neighbour node state with the data received within the new |
445 | * ELP packet. |
446 | */ |
447 | static void batadv_v_elp_neigh_update(struct batadv_priv *bat_priv, |
448 | u8 *neigh_addr, |
449 | struct batadv_hard_iface *if_incoming, |
450 | struct batadv_elp_packet *elp_packet) |
451 | |
452 | { |
453 | struct batadv_neigh_node *neigh; |
454 | struct batadv_orig_node *orig_neigh; |
455 | struct batadv_hardif_neigh_node *hardif_neigh; |
456 | s32 seqno_diff; |
457 | s32 elp_latest_seqno; |
458 | |
459 | orig_neigh = batadv_v_ogm_orig_get(bat_priv, addr: elp_packet->orig); |
460 | if (!orig_neigh) |
461 | return; |
462 | |
463 | neigh = batadv_neigh_node_get_or_create(orig_node: orig_neigh, |
464 | hard_iface: if_incoming, neigh_addr); |
465 | if (!neigh) |
466 | goto orig_free; |
467 | |
468 | hardif_neigh = batadv_hardif_neigh_get(hard_iface: if_incoming, neigh_addr); |
469 | if (!hardif_neigh) |
470 | goto neigh_free; |
471 | |
472 | elp_latest_seqno = hardif_neigh->bat_v.elp_latest_seqno; |
473 | seqno_diff = ntohl(elp_packet->seqno) - elp_latest_seqno; |
474 | |
475 | /* known or older sequence numbers are ignored. However always adopt |
476 | * if the router seems to have been restarted. |
477 | */ |
478 | if (seqno_diff < 1 && seqno_diff > -BATADV_ELP_MAX_AGE) |
479 | goto hardif_free; |
480 | |
481 | neigh->last_seen = jiffies; |
482 | hardif_neigh->last_seen = jiffies; |
483 | hardif_neigh->bat_v.elp_latest_seqno = ntohl(elp_packet->seqno); |
484 | hardif_neigh->bat_v.elp_interval = ntohl(elp_packet->elp_interval); |
485 | |
486 | hardif_free: |
487 | batadv_hardif_neigh_put(hardif_neigh); |
488 | neigh_free: |
489 | batadv_neigh_node_put(neigh_node: neigh); |
490 | orig_free: |
491 | batadv_orig_node_put(orig_node: orig_neigh); |
492 | } |
493 | |
494 | /** |
495 | * batadv_v_elp_packet_recv() - main ELP packet handler |
496 | * @skb: the received packet |
497 | * @if_incoming: the interface this packet was received through |
498 | * |
499 | * Return: NET_RX_SUCCESS and consumes the skb if the packet was properly |
500 | * processed or NET_RX_DROP in case of failure. |
501 | */ |
502 | int batadv_v_elp_packet_recv(struct sk_buff *skb, |
503 | struct batadv_hard_iface *if_incoming) |
504 | { |
505 | struct batadv_priv *bat_priv = netdev_priv(dev: if_incoming->soft_iface); |
506 | struct batadv_elp_packet *elp_packet; |
507 | struct batadv_hard_iface *primary_if; |
508 | struct ethhdr *ethhdr; |
509 | bool res; |
510 | int ret = NET_RX_DROP; |
511 | |
512 | res = batadv_check_management_packet(skb, hard_iface: if_incoming, BATADV_ELP_HLEN); |
513 | if (!res) |
514 | goto free_skb; |
515 | |
516 | ethhdr = eth_hdr(skb); |
517 | if (batadv_is_my_mac(bat_priv, addr: ethhdr->h_source)) |
518 | goto free_skb; |
519 | |
520 | /* did we receive a B.A.T.M.A.N. V ELP packet on an interface |
521 | * that does not have B.A.T.M.A.N. V ELP enabled ? |
522 | */ |
523 | if (strcmp(bat_priv->algo_ops->name, "BATMAN_V" ) != 0) |
524 | goto free_skb; |
525 | |
526 | elp_packet = (struct batadv_elp_packet *)skb->data; |
527 | |
528 | batadv_dbg(BATADV_DBG_BATMAN, bat_priv, |
529 | "Received ELP packet from %pM seqno %u ORIG: %pM\n" , |
530 | ethhdr->h_source, ntohl(elp_packet->seqno), |
531 | elp_packet->orig); |
532 | |
533 | primary_if = batadv_primary_if_get_selected(bat_priv); |
534 | if (!primary_if) |
535 | goto free_skb; |
536 | |
537 | batadv_v_elp_neigh_update(bat_priv, neigh_addr: ethhdr->h_source, if_incoming, |
538 | elp_packet); |
539 | |
540 | ret = NET_RX_SUCCESS; |
541 | batadv_hardif_put(hard_iface: primary_if); |
542 | |
543 | free_skb: |
544 | if (ret == NET_RX_SUCCESS) |
545 | consume_skb(skb); |
546 | else |
547 | kfree_skb(skb); |
548 | |
549 | return ret; |
550 | } |
551 | |