1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* Copyright (C) B.A.T.M.A.N. contributors: |
3 | * |
4 | * Marek Lindner, Simon Wunderlich |
5 | */ |
6 | |
7 | #include "send.h" |
8 | #include "main.h" |
9 | |
10 | #include <linux/atomic.h> |
11 | #include <linux/bug.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/gfp.h> |
17 | #include <linux/if.h> |
18 | #include <linux/if_ether.h> |
19 | #include <linux/jiffies.h> |
20 | #include <linux/kref.h> |
21 | #include <linux/list.h> |
22 | #include <linux/netdevice.h> |
23 | #include <linux/printk.h> |
24 | #include <linux/rculist.h> |
25 | #include <linux/rcupdate.h> |
26 | #include <linux/skbuff.h> |
27 | #include <linux/slab.h> |
28 | #include <linux/spinlock.h> |
29 | #include <linux/stddef.h> |
30 | #include <linux/workqueue.h> |
31 | |
32 | #include "distributed-arp-table.h" |
33 | #include "fragmentation.h" |
34 | #include "gateway_client.h" |
35 | #include "hard-interface.h" |
36 | #include "log.h" |
37 | #include "network-coding.h" |
38 | #include "originator.h" |
39 | #include "routing.h" |
40 | #include "soft-interface.h" |
41 | #include "translation-table.h" |
42 | |
43 | static void batadv_send_outstanding_bcast_packet(struct work_struct *work); |
44 | |
45 | /** |
46 | * batadv_send_skb_packet() - send an already prepared packet |
47 | * @skb: the packet to send |
48 | * @hard_iface: the interface to use to send the broadcast packet |
49 | * @dst_addr: the payload destination |
50 | * |
51 | * Send out an already prepared packet to the given neighbor or broadcast it |
52 | * using the specified interface. Either hard_iface or neigh_node must be not |
53 | * NULL. |
54 | * If neigh_node is NULL, then the packet is broadcasted using hard_iface, |
55 | * otherwise it is sent as unicast to the given neighbor. |
56 | * |
57 | * Regardless of the return value, the skb is consumed. |
58 | * |
59 | * Return: A negative errno code is returned on a failure. A success does not |
60 | * guarantee the frame will be transmitted as it may be dropped due |
61 | * to congestion or traffic shaping. |
62 | */ |
63 | int batadv_send_skb_packet(struct sk_buff *skb, |
64 | struct batadv_hard_iface *hard_iface, |
65 | const u8 *dst_addr) |
66 | { |
67 | struct batadv_priv *bat_priv; |
68 | struct ethhdr *ethhdr; |
69 | int ret; |
70 | |
71 | bat_priv = netdev_priv(dev: hard_iface->soft_iface); |
72 | |
73 | if (hard_iface->if_status != BATADV_IF_ACTIVE) |
74 | goto send_skb_err; |
75 | |
76 | if (unlikely(!hard_iface->net_dev)) |
77 | goto send_skb_err; |
78 | |
79 | if (!(hard_iface->net_dev->flags & IFF_UP)) { |
80 | pr_warn("Interface %s is not up - can't send packet via that interface!\n" , |
81 | hard_iface->net_dev->name); |
82 | goto send_skb_err; |
83 | } |
84 | |
85 | /* push to the ethernet header. */ |
86 | if (batadv_skb_head_push(skb, ETH_HLEN) < 0) |
87 | goto send_skb_err; |
88 | |
89 | skb_reset_mac_header(skb); |
90 | |
91 | ethhdr = eth_hdr(skb); |
92 | ether_addr_copy(dst: ethhdr->h_source, src: hard_iface->net_dev->dev_addr); |
93 | ether_addr_copy(dst: ethhdr->h_dest, src: dst_addr); |
94 | ethhdr->h_proto = htons(ETH_P_BATMAN); |
95 | |
96 | skb_set_network_header(skb, ETH_HLEN); |
97 | skb->protocol = htons(ETH_P_BATMAN); |
98 | |
99 | skb->dev = hard_iface->net_dev; |
100 | |
101 | /* Save a clone of the skb to use when decoding coded packets */ |
102 | batadv_nc_skb_store_for_decoding(bat_priv, skb); |
103 | |
104 | /* dev_queue_xmit() returns a negative result on error. However on |
105 | * congestion and traffic shaping, it drops and returns NET_XMIT_DROP |
106 | * (which is > 0). This will not be treated as an error. |
107 | */ |
108 | ret = dev_queue_xmit(skb); |
109 | return net_xmit_eval(ret); |
110 | send_skb_err: |
111 | kfree_skb(skb); |
112 | return NET_XMIT_DROP; |
113 | } |
114 | |
115 | /** |
116 | * batadv_send_broadcast_skb() - Send broadcast packet via hard interface |
117 | * @skb: packet to be transmitted (with batadv header and no outer eth header) |
118 | * @hard_iface: outgoing interface |
119 | * |
120 | * Return: A negative errno code is returned on a failure. A success does not |
121 | * guarantee the frame will be transmitted as it may be dropped due |
122 | * to congestion or traffic shaping. |
123 | */ |
124 | int batadv_send_broadcast_skb(struct sk_buff *skb, |
125 | struct batadv_hard_iface *hard_iface) |
126 | { |
127 | return batadv_send_skb_packet(skb, hard_iface, dst_addr: batadv_broadcast_addr); |
128 | } |
129 | |
130 | /** |
131 | * batadv_send_unicast_skb() - Send unicast packet to neighbor |
132 | * @skb: packet to be transmitted (with batadv header and no outer eth header) |
133 | * @neigh: neighbor which is used as next hop to destination |
134 | * |
135 | * Return: A negative errno code is returned on a failure. A success does not |
136 | * guarantee the frame will be transmitted as it may be dropped due |
137 | * to congestion or traffic shaping. |
138 | */ |
139 | int batadv_send_unicast_skb(struct sk_buff *skb, |
140 | struct batadv_neigh_node *neigh) |
141 | { |
142 | #ifdef CONFIG_BATMAN_ADV_BATMAN_V |
143 | struct batadv_hardif_neigh_node *hardif_neigh; |
144 | #endif |
145 | int ret; |
146 | |
147 | ret = batadv_send_skb_packet(skb, hard_iface: neigh->if_incoming, dst_addr: neigh->addr); |
148 | |
149 | #ifdef CONFIG_BATMAN_ADV_BATMAN_V |
150 | hardif_neigh = batadv_hardif_neigh_get(hard_iface: neigh->if_incoming, neigh_addr: neigh->addr); |
151 | |
152 | if (hardif_neigh && ret != NET_XMIT_DROP) |
153 | hardif_neigh->bat_v.last_unicast_tx = jiffies; |
154 | |
155 | batadv_hardif_neigh_put(hardif_neigh); |
156 | #endif |
157 | |
158 | return ret; |
159 | } |
160 | |
161 | /** |
162 | * batadv_send_skb_to_orig() - Lookup next-hop and transmit skb. |
163 | * @skb: Packet to be transmitted. |
164 | * @orig_node: Final destination of the packet. |
165 | * @recv_if: Interface used when receiving the packet (can be NULL). |
166 | * |
167 | * Looks up the best next-hop towards the passed originator and passes the |
168 | * skb on for preparation of MAC header. If the packet originated from this |
169 | * host, NULL can be passed as recv_if and no interface alternating is |
170 | * attempted. |
171 | * |
172 | * Return: negative errno code on a failure, -EINPROGRESS if the skb is |
173 | * buffered for later transmit or the NET_XMIT status returned by the |
174 | * lower routine if the packet has been passed down. |
175 | */ |
176 | int batadv_send_skb_to_orig(struct sk_buff *skb, |
177 | struct batadv_orig_node *orig_node, |
178 | struct batadv_hard_iface *recv_if) |
179 | { |
180 | struct batadv_priv *bat_priv = orig_node->bat_priv; |
181 | struct batadv_neigh_node *neigh_node; |
182 | int ret; |
183 | |
184 | /* batadv_find_router() increases neigh_nodes refcount if found. */ |
185 | neigh_node = batadv_find_router(bat_priv, orig_node, recv_if); |
186 | if (!neigh_node) { |
187 | ret = -EINVAL; |
188 | goto free_skb; |
189 | } |
190 | |
191 | /* Check if the skb is too large to send in one piece and fragment |
192 | * it if needed. |
193 | */ |
194 | if (atomic_read(v: &bat_priv->fragmentation) && |
195 | skb->len > neigh_node->if_incoming->net_dev->mtu) { |
196 | /* Fragment and send packet. */ |
197 | ret = batadv_frag_send_packet(skb, orig_node, neigh_node); |
198 | /* skb was consumed */ |
199 | skb = NULL; |
200 | |
201 | goto put_neigh_node; |
202 | } |
203 | |
204 | /* try to network code the packet, if it is received on an interface |
205 | * (i.e. being forwarded). If the packet originates from this node or if |
206 | * network coding fails, then send the packet as usual. |
207 | */ |
208 | if (recv_if && batadv_nc_skb_forward(skb, neigh_node)) |
209 | ret = -EINPROGRESS; |
210 | else |
211 | ret = batadv_send_unicast_skb(skb, neigh: neigh_node); |
212 | |
213 | /* skb was consumed */ |
214 | skb = NULL; |
215 | |
216 | put_neigh_node: |
217 | batadv_neigh_node_put(neigh_node); |
218 | free_skb: |
219 | kfree_skb(skb); |
220 | |
221 | return ret; |
222 | } |
223 | |
224 | /** |
225 | * batadv_send_skb_push_fill_unicast() - extend the buffer and initialize the |
226 | * common fields for unicast packets |
227 | * @skb: the skb carrying the unicast header to initialize |
228 | * @hdr_size: amount of bytes to push at the beginning of the skb |
229 | * @orig_node: the destination node |
230 | * |
231 | * Return: false if the buffer extension was not possible or true otherwise. |
232 | */ |
233 | static bool |
234 | batadv_send_skb_push_fill_unicast(struct sk_buff *skb, int hdr_size, |
235 | struct batadv_orig_node *orig_node) |
236 | { |
237 | struct batadv_unicast_packet *unicast_packet; |
238 | u8 ttvn = (u8)atomic_read(v: &orig_node->last_ttvn); |
239 | |
240 | if (batadv_skb_head_push(skb, len: hdr_size) < 0) |
241 | return false; |
242 | |
243 | unicast_packet = (struct batadv_unicast_packet *)skb->data; |
244 | unicast_packet->version = BATADV_COMPAT_VERSION; |
245 | /* batman packet type: unicast */ |
246 | unicast_packet->packet_type = BATADV_UNICAST; |
247 | /* set unicast ttl */ |
248 | unicast_packet->ttl = BATADV_TTL; |
249 | /* copy the destination for faster routing */ |
250 | ether_addr_copy(dst: unicast_packet->dest, src: orig_node->orig); |
251 | /* set the destination tt version number */ |
252 | unicast_packet->ttvn = ttvn; |
253 | |
254 | return true; |
255 | } |
256 | |
257 | /** |
258 | * batadv_send_skb_prepare_unicast() - encapsulate an skb with a unicast header |
259 | * @skb: the skb containing the payload to encapsulate |
260 | * @orig_node: the destination node |
261 | * |
262 | * Return: false if the payload could not be encapsulated or true otherwise. |
263 | */ |
264 | static bool batadv_send_skb_prepare_unicast(struct sk_buff *skb, |
265 | struct batadv_orig_node *orig_node) |
266 | { |
267 | size_t uni_size = sizeof(struct batadv_unicast_packet); |
268 | |
269 | return batadv_send_skb_push_fill_unicast(skb, hdr_size: uni_size, orig_node); |
270 | } |
271 | |
272 | /** |
273 | * batadv_send_skb_prepare_unicast_4addr() - encapsulate an skb with a |
274 | * unicast 4addr header |
275 | * @bat_priv: the bat priv with all the soft interface information |
276 | * @skb: the skb containing the payload to encapsulate |
277 | * @orig: the destination node |
278 | * @packet_subtype: the unicast 4addr packet subtype to use |
279 | * |
280 | * Return: false if the payload could not be encapsulated or true otherwise. |
281 | */ |
282 | bool batadv_send_skb_prepare_unicast_4addr(struct batadv_priv *bat_priv, |
283 | struct sk_buff *skb, |
284 | struct batadv_orig_node *orig, |
285 | int packet_subtype) |
286 | { |
287 | struct batadv_hard_iface *primary_if; |
288 | struct batadv_unicast_4addr_packet *uc_4addr_packet; |
289 | bool ret = false; |
290 | |
291 | primary_if = batadv_primary_if_get_selected(bat_priv); |
292 | if (!primary_if) |
293 | goto out; |
294 | |
295 | /* Pull the header space and fill the unicast_packet substructure. |
296 | * We can do that because the first member of the uc_4addr_packet |
297 | * is of type struct unicast_packet |
298 | */ |
299 | if (!batadv_send_skb_push_fill_unicast(skb, hdr_size: sizeof(*uc_4addr_packet), |
300 | orig_node: orig)) |
301 | goto out; |
302 | |
303 | uc_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data; |
304 | uc_4addr_packet->u.packet_type = BATADV_UNICAST_4ADDR; |
305 | ether_addr_copy(dst: uc_4addr_packet->src, src: primary_if->net_dev->dev_addr); |
306 | uc_4addr_packet->subtype = packet_subtype; |
307 | uc_4addr_packet->reserved = 0; |
308 | |
309 | ret = true; |
310 | out: |
311 | batadv_hardif_put(hard_iface: primary_if); |
312 | return ret; |
313 | } |
314 | |
315 | /** |
316 | * batadv_send_skb_unicast() - encapsulate and send an skb via unicast |
317 | * @bat_priv: the bat priv with all the soft interface information |
318 | * @skb: payload to send |
319 | * @packet_type: the batman unicast packet type to use |
320 | * @packet_subtype: the unicast 4addr packet subtype (only relevant for unicast |
321 | * 4addr packets) |
322 | * @orig_node: the originator to send the packet to |
323 | * @vid: the vid to be used to search the translation table |
324 | * |
325 | * Wrap the given skb into a batman-adv unicast or unicast-4addr header |
326 | * depending on whether BATADV_UNICAST or BATADV_UNICAST_4ADDR was supplied |
327 | * as packet_type. Then send this frame to the given orig_node. |
328 | * |
329 | * Return: NET_XMIT_DROP in case of error or NET_XMIT_SUCCESS otherwise. |
330 | */ |
331 | int batadv_send_skb_unicast(struct batadv_priv *bat_priv, |
332 | struct sk_buff *skb, int packet_type, |
333 | int packet_subtype, |
334 | struct batadv_orig_node *orig_node, |
335 | unsigned short vid) |
336 | { |
337 | struct batadv_unicast_packet *unicast_packet; |
338 | struct ethhdr *ethhdr; |
339 | int ret = NET_XMIT_DROP; |
340 | |
341 | if (!orig_node) |
342 | goto out; |
343 | |
344 | switch (packet_type) { |
345 | case BATADV_UNICAST: |
346 | if (!batadv_send_skb_prepare_unicast(skb, orig_node)) |
347 | goto out; |
348 | break; |
349 | case BATADV_UNICAST_4ADDR: |
350 | if (!batadv_send_skb_prepare_unicast_4addr(bat_priv, skb, |
351 | orig: orig_node, |
352 | packet_subtype)) |
353 | goto out; |
354 | break; |
355 | default: |
356 | /* this function supports UNICAST and UNICAST_4ADDR only. It |
357 | * should never be invoked with any other packet type |
358 | */ |
359 | goto out; |
360 | } |
361 | |
362 | /* skb->data might have been reallocated by |
363 | * batadv_send_skb_prepare_unicast{,_4addr}() |
364 | */ |
365 | ethhdr = eth_hdr(skb); |
366 | unicast_packet = (struct batadv_unicast_packet *)skb->data; |
367 | |
368 | /* inform the destination node that we are still missing a correct route |
369 | * for this client. The destination will receive this packet and will |
370 | * try to reroute it because the ttvn contained in the header is less |
371 | * than the current one |
372 | */ |
373 | if (batadv_tt_global_client_is_roaming(bat_priv, addr: ethhdr->h_dest, vid)) |
374 | unicast_packet->ttvn = unicast_packet->ttvn - 1; |
375 | |
376 | ret = batadv_send_skb_to_orig(skb, orig_node, NULL); |
377 | /* skb was consumed */ |
378 | skb = NULL; |
379 | |
380 | out: |
381 | kfree_skb(skb); |
382 | return ret; |
383 | } |
384 | |
385 | /** |
386 | * batadv_send_skb_via_tt_generic() - send an skb via TT lookup |
387 | * @bat_priv: the bat priv with all the soft interface information |
388 | * @skb: payload to send |
389 | * @packet_type: the batman unicast packet type to use |
390 | * @packet_subtype: the unicast 4addr packet subtype (only relevant for unicast |
391 | * 4addr packets) |
392 | * @dst_hint: can be used to override the destination contained in the skb |
393 | * @vid: the vid to be used to search the translation table |
394 | * |
395 | * Look up the recipient node for the destination address in the ethernet |
396 | * header via the translation table. Wrap the given skb into a batman-adv |
397 | * unicast or unicast-4addr header depending on whether BATADV_UNICAST or |
398 | * BATADV_UNICAST_4ADDR was supplied as packet_type. Then send this frame |
399 | * to the according destination node. |
400 | * |
401 | * Return: NET_XMIT_DROP in case of error or NET_XMIT_SUCCESS otherwise. |
402 | */ |
403 | int batadv_send_skb_via_tt_generic(struct batadv_priv *bat_priv, |
404 | struct sk_buff *skb, int packet_type, |
405 | int packet_subtype, u8 *dst_hint, |
406 | unsigned short vid) |
407 | { |
408 | struct ethhdr *ethhdr = (struct ethhdr *)skb->data; |
409 | struct batadv_orig_node *orig_node; |
410 | u8 *src, *dst; |
411 | int ret; |
412 | |
413 | src = ethhdr->h_source; |
414 | dst = ethhdr->h_dest; |
415 | |
416 | /* if we got an hint! let's send the packet to this client (if any) */ |
417 | if (dst_hint) { |
418 | src = NULL; |
419 | dst = dst_hint; |
420 | } |
421 | orig_node = batadv_transtable_search(bat_priv, src, addr: dst, vid); |
422 | |
423 | ret = batadv_send_skb_unicast(bat_priv, skb, packet_type, |
424 | packet_subtype, orig_node, vid); |
425 | |
426 | batadv_orig_node_put(orig_node); |
427 | |
428 | return ret; |
429 | } |
430 | |
431 | /** |
432 | * batadv_send_skb_via_gw() - send an skb via gateway lookup |
433 | * @bat_priv: the bat priv with all the soft interface information |
434 | * @skb: payload to send |
435 | * @vid: the vid to be used to search the translation table |
436 | * |
437 | * Look up the currently selected gateway. Wrap the given skb into a batman-adv |
438 | * unicast header and send this frame to this gateway node. |
439 | * |
440 | * Return: NET_XMIT_DROP in case of error or NET_XMIT_SUCCESS otherwise. |
441 | */ |
442 | int batadv_send_skb_via_gw(struct batadv_priv *bat_priv, struct sk_buff *skb, |
443 | unsigned short vid) |
444 | { |
445 | struct batadv_orig_node *orig_node; |
446 | int ret; |
447 | |
448 | orig_node = batadv_gw_get_selected_orig(bat_priv); |
449 | ret = batadv_send_skb_unicast(bat_priv, skb, packet_type: BATADV_UNICAST_4ADDR, |
450 | packet_subtype: BATADV_P_DATA, orig_node, vid); |
451 | |
452 | batadv_orig_node_put(orig_node); |
453 | |
454 | return ret; |
455 | } |
456 | |
457 | /** |
458 | * batadv_forw_packet_free() - free a forwarding packet |
459 | * @forw_packet: The packet to free |
460 | * @dropped: whether the packet is freed because is dropped |
461 | * |
462 | * This frees a forwarding packet and releases any resources it might |
463 | * have claimed. |
464 | */ |
465 | void batadv_forw_packet_free(struct batadv_forw_packet *forw_packet, |
466 | bool dropped) |
467 | { |
468 | if (dropped) |
469 | kfree_skb(skb: forw_packet->skb); |
470 | else |
471 | consume_skb(skb: forw_packet->skb); |
472 | |
473 | batadv_hardif_put(hard_iface: forw_packet->if_incoming); |
474 | batadv_hardif_put(hard_iface: forw_packet->if_outgoing); |
475 | if (forw_packet->queue_left) |
476 | atomic_inc(v: forw_packet->queue_left); |
477 | kfree(objp: forw_packet); |
478 | } |
479 | |
480 | /** |
481 | * batadv_forw_packet_alloc() - allocate a forwarding packet |
482 | * @if_incoming: The (optional) if_incoming to be grabbed |
483 | * @if_outgoing: The (optional) if_outgoing to be grabbed |
484 | * @queue_left: The (optional) queue counter to decrease |
485 | * @bat_priv: The bat_priv for the mesh of this forw_packet |
486 | * @skb: The raw packet this forwarding packet shall contain |
487 | * |
488 | * Allocates a forwarding packet and tries to get a reference to the |
489 | * (optional) if_incoming, if_outgoing and queue_left. If queue_left |
490 | * is NULL then bat_priv is optional, too. |
491 | * |
492 | * Return: An allocated forwarding packet on success, NULL otherwise. |
493 | */ |
494 | struct batadv_forw_packet * |
495 | batadv_forw_packet_alloc(struct batadv_hard_iface *if_incoming, |
496 | struct batadv_hard_iface *if_outgoing, |
497 | atomic_t *queue_left, |
498 | struct batadv_priv *bat_priv, |
499 | struct sk_buff *skb) |
500 | { |
501 | struct batadv_forw_packet *forw_packet; |
502 | const char *qname; |
503 | |
504 | if (queue_left && !batadv_atomic_dec_not_zero(queue_left)) { |
505 | qname = "unknown" ; |
506 | |
507 | if (queue_left == &bat_priv->bcast_queue_left) |
508 | qname = "bcast" ; |
509 | |
510 | if (queue_left == &bat_priv->batman_queue_left) |
511 | qname = "batman" ; |
512 | |
513 | batadv_dbg(BATADV_DBG_BATMAN, bat_priv, |
514 | "%s queue is full\n" , qname); |
515 | |
516 | return NULL; |
517 | } |
518 | |
519 | forw_packet = kmalloc(size: sizeof(*forw_packet), GFP_ATOMIC); |
520 | if (!forw_packet) |
521 | goto err; |
522 | |
523 | if (if_incoming) |
524 | kref_get(kref: &if_incoming->refcount); |
525 | |
526 | if (if_outgoing) |
527 | kref_get(kref: &if_outgoing->refcount); |
528 | |
529 | INIT_HLIST_NODE(h: &forw_packet->list); |
530 | INIT_HLIST_NODE(h: &forw_packet->cleanup_list); |
531 | forw_packet->skb = skb; |
532 | forw_packet->queue_left = queue_left; |
533 | forw_packet->if_incoming = if_incoming; |
534 | forw_packet->if_outgoing = if_outgoing; |
535 | forw_packet->num_packets = 0; |
536 | |
537 | return forw_packet; |
538 | |
539 | err: |
540 | if (queue_left) |
541 | atomic_inc(v: queue_left); |
542 | |
543 | return NULL; |
544 | } |
545 | |
546 | /** |
547 | * batadv_forw_packet_was_stolen() - check whether someone stole this packet |
548 | * @forw_packet: the forwarding packet to check |
549 | * |
550 | * This function checks whether the given forwarding packet was claimed by |
551 | * someone else for free(). |
552 | * |
553 | * Return: True if someone stole it, false otherwise. |
554 | */ |
555 | static bool |
556 | batadv_forw_packet_was_stolen(struct batadv_forw_packet *forw_packet) |
557 | { |
558 | return !hlist_unhashed(h: &forw_packet->cleanup_list); |
559 | } |
560 | |
561 | /** |
562 | * batadv_forw_packet_steal() - claim a forw_packet for free() |
563 | * @forw_packet: the forwarding packet to steal |
564 | * @lock: a key to the store to steal from (e.g. forw_{bat,bcast}_list_lock) |
565 | * |
566 | * This function tries to steal a specific forw_packet from global |
567 | * visibility for the purpose of getting it for free(). That means |
568 | * the caller is *not* allowed to requeue it afterwards. |
569 | * |
570 | * Return: True if stealing was successful. False if someone else stole it |
571 | * before us. |
572 | */ |
573 | bool batadv_forw_packet_steal(struct batadv_forw_packet *forw_packet, |
574 | spinlock_t *lock) |
575 | { |
576 | /* did purging routine steal it earlier? */ |
577 | spin_lock_bh(lock); |
578 | if (batadv_forw_packet_was_stolen(forw_packet)) { |
579 | spin_unlock_bh(lock); |
580 | return false; |
581 | } |
582 | |
583 | hlist_del_init(n: &forw_packet->list); |
584 | |
585 | /* Just to spot misuse of this function */ |
586 | hlist_add_fake(n: &forw_packet->cleanup_list); |
587 | |
588 | spin_unlock_bh(lock); |
589 | return true; |
590 | } |
591 | |
592 | /** |
593 | * batadv_forw_packet_list_steal() - claim a list of forward packets for free() |
594 | * @forw_list: the to be stolen forward packets |
595 | * @cleanup_list: a backup pointer, to be able to dispose the packet later |
596 | * @hard_iface: the interface to steal forward packets from |
597 | * |
598 | * This function claims responsibility to free any forw_packet queued on the |
599 | * given hard_iface. If hard_iface is NULL forwarding packets on all hard |
600 | * interfaces will be claimed. |
601 | * |
602 | * The packets are being moved from the forw_list to the cleanup_list. This |
603 | * makes it possible for already running threads to notice the claim. |
604 | */ |
605 | static void |
606 | batadv_forw_packet_list_steal(struct hlist_head *forw_list, |
607 | struct hlist_head *cleanup_list, |
608 | const struct batadv_hard_iface *hard_iface) |
609 | { |
610 | struct batadv_forw_packet *forw_packet; |
611 | struct hlist_node *safe_tmp_node; |
612 | |
613 | hlist_for_each_entry_safe(forw_packet, safe_tmp_node, |
614 | forw_list, list) { |
615 | /* if purge_outstanding_packets() was called with an argument |
616 | * we delete only packets belonging to the given interface |
617 | */ |
618 | if (hard_iface && |
619 | forw_packet->if_incoming != hard_iface && |
620 | forw_packet->if_outgoing != hard_iface) |
621 | continue; |
622 | |
623 | hlist_del(n: &forw_packet->list); |
624 | hlist_add_head(n: &forw_packet->cleanup_list, h: cleanup_list); |
625 | } |
626 | } |
627 | |
628 | /** |
629 | * batadv_forw_packet_list_free() - free a list of forward packets |
630 | * @head: a list of to be freed forw_packets |
631 | * |
632 | * This function cancels the scheduling of any packet in the provided list, |
633 | * waits for any possibly running packet forwarding thread to finish and |
634 | * finally, safely frees this forward packet. |
635 | * |
636 | * This function might sleep. |
637 | */ |
638 | static void batadv_forw_packet_list_free(struct hlist_head *head) |
639 | { |
640 | struct batadv_forw_packet *forw_packet; |
641 | struct hlist_node *safe_tmp_node; |
642 | |
643 | hlist_for_each_entry_safe(forw_packet, safe_tmp_node, head, |
644 | cleanup_list) { |
645 | cancel_delayed_work_sync(dwork: &forw_packet->delayed_work); |
646 | |
647 | hlist_del(n: &forw_packet->cleanup_list); |
648 | batadv_forw_packet_free(forw_packet, dropped: true); |
649 | } |
650 | } |
651 | |
652 | /** |
653 | * batadv_forw_packet_queue() - try to queue a forwarding packet |
654 | * @forw_packet: the forwarding packet to queue |
655 | * @lock: a key to the store (e.g. forw_{bat,bcast}_list_lock) |
656 | * @head: the shelve to queue it on (e.g. forw_{bat,bcast}_list) |
657 | * @send_time: timestamp (jiffies) when the packet is to be sent |
658 | * |
659 | * This function tries to (re)queue a forwarding packet. Requeuing |
660 | * is prevented if the according interface is shutting down |
661 | * (e.g. if batadv_forw_packet_list_steal() was called for this |
662 | * packet earlier). |
663 | * |
664 | * Calling batadv_forw_packet_queue() after a call to |
665 | * batadv_forw_packet_steal() is forbidden! |
666 | * |
667 | * Caller needs to ensure that forw_packet->delayed_work was initialized. |
668 | */ |
669 | static void batadv_forw_packet_queue(struct batadv_forw_packet *forw_packet, |
670 | spinlock_t *lock, struct hlist_head *head, |
671 | unsigned long send_time) |
672 | { |
673 | spin_lock_bh(lock); |
674 | |
675 | /* did purging routine steal it from us? */ |
676 | if (batadv_forw_packet_was_stolen(forw_packet)) { |
677 | /* If you got it for free() without trouble, then |
678 | * don't get back into the queue after stealing... |
679 | */ |
680 | WARN_ONCE(hlist_fake(&forw_packet->cleanup_list), |
681 | "Requeuing after batadv_forw_packet_steal() not allowed!\n" ); |
682 | |
683 | spin_unlock_bh(lock); |
684 | return; |
685 | } |
686 | |
687 | hlist_del_init(n: &forw_packet->list); |
688 | hlist_add_head(n: &forw_packet->list, h: head); |
689 | |
690 | queue_delayed_work(wq: batadv_event_workqueue, |
691 | dwork: &forw_packet->delayed_work, |
692 | delay: send_time - jiffies); |
693 | spin_unlock_bh(lock); |
694 | } |
695 | |
696 | /** |
697 | * batadv_forw_packet_bcast_queue() - try to queue a broadcast packet |
698 | * @bat_priv: the bat priv with all the soft interface information |
699 | * @forw_packet: the forwarding packet to queue |
700 | * @send_time: timestamp (jiffies) when the packet is to be sent |
701 | * |
702 | * This function tries to (re)queue a broadcast packet. |
703 | * |
704 | * Caller needs to ensure that forw_packet->delayed_work was initialized. |
705 | */ |
706 | static void |
707 | batadv_forw_packet_bcast_queue(struct batadv_priv *bat_priv, |
708 | struct batadv_forw_packet *forw_packet, |
709 | unsigned long send_time) |
710 | { |
711 | batadv_forw_packet_queue(forw_packet, lock: &bat_priv->forw_bcast_list_lock, |
712 | head: &bat_priv->forw_bcast_list, send_time); |
713 | } |
714 | |
715 | /** |
716 | * batadv_forw_packet_ogmv1_queue() - try to queue an OGMv1 packet |
717 | * @bat_priv: the bat priv with all the soft interface information |
718 | * @forw_packet: the forwarding packet to queue |
719 | * @send_time: timestamp (jiffies) when the packet is to be sent |
720 | * |
721 | * This function tries to (re)queue an OGMv1 packet. |
722 | * |
723 | * Caller needs to ensure that forw_packet->delayed_work was initialized. |
724 | */ |
725 | void batadv_forw_packet_ogmv1_queue(struct batadv_priv *bat_priv, |
726 | struct batadv_forw_packet *forw_packet, |
727 | unsigned long send_time) |
728 | { |
729 | batadv_forw_packet_queue(forw_packet, lock: &bat_priv->forw_bat_list_lock, |
730 | head: &bat_priv->forw_bat_list, send_time); |
731 | } |
732 | |
733 | /** |
734 | * batadv_forw_bcast_packet_to_list() - queue broadcast packet for transmissions |
735 | * @bat_priv: the bat priv with all the soft interface information |
736 | * @skb: broadcast packet to add |
737 | * @delay: number of jiffies to wait before sending |
738 | * @own_packet: true if it is a self-generated broadcast packet |
739 | * @if_in: the interface where the packet was received on |
740 | * @if_out: the outgoing interface to queue on |
741 | * |
742 | * Adds a broadcast packet to the queue and sets up timers. Broadcast packets |
743 | * are sent multiple times to increase probability for being received. |
744 | * |
745 | * This call clones the given skb, hence the caller needs to take into |
746 | * account that the data segment of the original skb might not be |
747 | * modifiable anymore. |
748 | * |
749 | * Return: NETDEV_TX_OK on success and NETDEV_TX_BUSY on errors. |
750 | */ |
751 | static int batadv_forw_bcast_packet_to_list(struct batadv_priv *bat_priv, |
752 | struct sk_buff *skb, |
753 | unsigned long delay, |
754 | bool own_packet, |
755 | struct batadv_hard_iface *if_in, |
756 | struct batadv_hard_iface *if_out) |
757 | { |
758 | struct batadv_forw_packet *forw_packet; |
759 | unsigned long send_time = jiffies; |
760 | struct sk_buff *newskb; |
761 | |
762 | newskb = skb_clone(skb, GFP_ATOMIC); |
763 | if (!newskb) |
764 | goto err; |
765 | |
766 | forw_packet = batadv_forw_packet_alloc(if_incoming: if_in, if_outgoing: if_out, |
767 | queue_left: &bat_priv->bcast_queue_left, |
768 | bat_priv, skb: newskb); |
769 | if (!forw_packet) |
770 | goto err_packet_free; |
771 | |
772 | forw_packet->own = own_packet; |
773 | |
774 | INIT_DELAYED_WORK(&forw_packet->delayed_work, |
775 | batadv_send_outstanding_bcast_packet); |
776 | |
777 | send_time += delay ? delay : msecs_to_jiffies(m: 5); |
778 | |
779 | batadv_forw_packet_bcast_queue(bat_priv, forw_packet, send_time); |
780 | return NETDEV_TX_OK; |
781 | |
782 | err_packet_free: |
783 | kfree_skb(skb: newskb); |
784 | err: |
785 | return NETDEV_TX_BUSY; |
786 | } |
787 | |
788 | /** |
789 | * batadv_forw_bcast_packet_if() - forward and queue a broadcast packet |
790 | * @bat_priv: the bat priv with all the soft interface information |
791 | * @skb: broadcast packet to add |
792 | * @delay: number of jiffies to wait before sending |
793 | * @own_packet: true if it is a self-generated broadcast packet |
794 | * @if_in: the interface where the packet was received on |
795 | * @if_out: the outgoing interface to forward to |
796 | * |
797 | * Transmits a broadcast packet on the specified interface either immediately |
798 | * or if a delay is given after that. Furthermore, queues additional |
799 | * retransmissions if this interface is a wireless one. |
800 | * |
801 | * This call clones the given skb, hence the caller needs to take into |
802 | * account that the data segment of the original skb might not be |
803 | * modifiable anymore. |
804 | * |
805 | * Return: NETDEV_TX_OK on success and NETDEV_TX_BUSY on errors. |
806 | */ |
807 | static int batadv_forw_bcast_packet_if(struct batadv_priv *bat_priv, |
808 | struct sk_buff *skb, |
809 | unsigned long delay, |
810 | bool own_packet, |
811 | struct batadv_hard_iface *if_in, |
812 | struct batadv_hard_iface *if_out) |
813 | { |
814 | unsigned int num_bcasts = if_out->num_bcasts; |
815 | struct sk_buff *newskb; |
816 | int ret = NETDEV_TX_OK; |
817 | |
818 | if (!delay) { |
819 | newskb = skb_clone(skb, GFP_ATOMIC); |
820 | if (!newskb) |
821 | return NETDEV_TX_BUSY; |
822 | |
823 | batadv_send_broadcast_skb(skb: newskb, hard_iface: if_out); |
824 | num_bcasts--; |
825 | } |
826 | |
827 | /* delayed broadcast or rebroadcasts? */ |
828 | if (num_bcasts >= 1) { |
829 | BATADV_SKB_CB(skb)->num_bcasts = num_bcasts; |
830 | |
831 | ret = batadv_forw_bcast_packet_to_list(bat_priv, skb, delay, |
832 | own_packet, if_in, |
833 | if_out); |
834 | } |
835 | |
836 | return ret; |
837 | } |
838 | |
839 | /** |
840 | * batadv_send_no_broadcast() - check whether (re)broadcast is necessary |
841 | * @bat_priv: the bat priv with all the soft interface information |
842 | * @skb: broadcast packet to check |
843 | * @own_packet: true if it is a self-generated broadcast packet |
844 | * @if_out: the outgoing interface checked and considered for (re)broadcast |
845 | * |
846 | * Return: False if a packet needs to be (re)broadcasted on the given interface, |
847 | * true otherwise. |
848 | */ |
849 | static bool batadv_send_no_broadcast(struct batadv_priv *bat_priv, |
850 | struct sk_buff *skb, bool own_packet, |
851 | struct batadv_hard_iface *if_out) |
852 | { |
853 | struct batadv_hardif_neigh_node *neigh_node = NULL; |
854 | struct batadv_bcast_packet *bcast_packet; |
855 | u8 *orig_neigh; |
856 | u8 *neigh_addr; |
857 | char *type; |
858 | int ret; |
859 | |
860 | if (!own_packet) { |
861 | neigh_addr = eth_hdr(skb)->h_source; |
862 | neigh_node = batadv_hardif_neigh_get(hard_iface: if_out, |
863 | neigh_addr); |
864 | } |
865 | |
866 | bcast_packet = (struct batadv_bcast_packet *)skb->data; |
867 | orig_neigh = neigh_node ? neigh_node->orig : NULL; |
868 | |
869 | ret = batadv_hardif_no_broadcast(if_outgoing: if_out, orig_addr: bcast_packet->orig, |
870 | orig_neigh); |
871 | |
872 | batadv_hardif_neigh_put(hardif_neigh: neigh_node); |
873 | |
874 | /* ok, may broadcast */ |
875 | if (!ret) |
876 | return false; |
877 | |
878 | /* no broadcast */ |
879 | switch (ret) { |
880 | case BATADV_HARDIF_BCAST_NORECIPIENT: |
881 | type = "no neighbor" ; |
882 | break; |
883 | case BATADV_HARDIF_BCAST_DUPFWD: |
884 | type = "single neighbor is source" ; |
885 | break; |
886 | case BATADV_HARDIF_BCAST_DUPORIG: |
887 | type = "single neighbor is originator" ; |
888 | break; |
889 | default: |
890 | type = "unknown" ; |
891 | } |
892 | |
893 | batadv_dbg(BATADV_DBG_BATMAN, bat_priv, |
894 | "BCAST packet from orig %pM on %s suppressed: %s\n" , |
895 | bcast_packet->orig, |
896 | if_out->net_dev->name, type); |
897 | |
898 | return true; |
899 | } |
900 | |
901 | /** |
902 | * __batadv_forw_bcast_packet() - forward and queue a broadcast packet |
903 | * @bat_priv: the bat priv with all the soft interface information |
904 | * @skb: broadcast packet to add |
905 | * @delay: number of jiffies to wait before sending |
906 | * @own_packet: true if it is a self-generated broadcast packet |
907 | * |
908 | * Transmits a broadcast packet either immediately or if a delay is given |
909 | * after that. Furthermore, queues additional retransmissions on wireless |
910 | * interfaces. |
911 | * |
912 | * This call clones the given skb, hence the caller needs to take into |
913 | * account that the data segment of the given skb might not be |
914 | * modifiable anymore. |
915 | * |
916 | * Return: NETDEV_TX_OK on success and NETDEV_TX_BUSY on errors. |
917 | */ |
918 | static int __batadv_forw_bcast_packet(struct batadv_priv *bat_priv, |
919 | struct sk_buff *skb, |
920 | unsigned long delay, |
921 | bool own_packet) |
922 | { |
923 | struct batadv_hard_iface *hard_iface; |
924 | struct batadv_hard_iface *primary_if; |
925 | int ret = NETDEV_TX_OK; |
926 | |
927 | primary_if = batadv_primary_if_get_selected(bat_priv); |
928 | if (!primary_if) |
929 | return NETDEV_TX_BUSY; |
930 | |
931 | rcu_read_lock(); |
932 | list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { |
933 | if (hard_iface->soft_iface != bat_priv->soft_iface) |
934 | continue; |
935 | |
936 | if (!kref_get_unless_zero(kref: &hard_iface->refcount)) |
937 | continue; |
938 | |
939 | if (batadv_send_no_broadcast(bat_priv, skb, own_packet, |
940 | if_out: hard_iface)) { |
941 | batadv_hardif_put(hard_iface); |
942 | continue; |
943 | } |
944 | |
945 | ret = batadv_forw_bcast_packet_if(bat_priv, skb, delay, |
946 | own_packet, if_in: primary_if, |
947 | if_out: hard_iface); |
948 | batadv_hardif_put(hard_iface); |
949 | |
950 | if (ret == NETDEV_TX_BUSY) |
951 | break; |
952 | } |
953 | rcu_read_unlock(); |
954 | |
955 | batadv_hardif_put(hard_iface: primary_if); |
956 | return ret; |
957 | } |
958 | |
959 | /** |
960 | * batadv_forw_bcast_packet() - forward and queue a broadcast packet |
961 | * @bat_priv: the bat priv with all the soft interface information |
962 | * @skb: broadcast packet to add |
963 | * @delay: number of jiffies to wait before sending |
964 | * @own_packet: true if it is a self-generated broadcast packet |
965 | * |
966 | * Transmits a broadcast packet either immediately or if a delay is given |
967 | * after that. Furthermore, queues additional retransmissions on wireless |
968 | * interfaces. |
969 | * |
970 | * Return: NETDEV_TX_OK on success and NETDEV_TX_BUSY on errors. |
971 | */ |
972 | int batadv_forw_bcast_packet(struct batadv_priv *bat_priv, |
973 | struct sk_buff *skb, |
974 | unsigned long delay, |
975 | bool own_packet) |
976 | { |
977 | return __batadv_forw_bcast_packet(bat_priv, skb, delay, own_packet); |
978 | } |
979 | |
980 | /** |
981 | * batadv_send_bcast_packet() - send and queue a broadcast packet |
982 | * @bat_priv: the bat priv with all the soft interface information |
983 | * @skb: broadcast packet to add |
984 | * @delay: number of jiffies to wait before sending |
985 | * @own_packet: true if it is a self-generated broadcast packet |
986 | * |
987 | * Transmits a broadcast packet either immediately or if a delay is given |
988 | * after that. Furthermore, queues additional retransmissions on wireless |
989 | * interfaces. |
990 | * |
991 | * Consumes the provided skb. |
992 | */ |
993 | void batadv_send_bcast_packet(struct batadv_priv *bat_priv, |
994 | struct sk_buff *skb, |
995 | unsigned long delay, |
996 | bool own_packet) |
997 | { |
998 | __batadv_forw_bcast_packet(bat_priv, skb, delay, own_packet); |
999 | consume_skb(skb); |
1000 | } |
1001 | |
1002 | /** |
1003 | * batadv_forw_packet_bcasts_left() - check if a retransmission is necessary |
1004 | * @forw_packet: the forwarding packet to check |
1005 | * |
1006 | * Checks whether a given packet has any (re)transmissions left on the provided |
1007 | * interface. |
1008 | * |
1009 | * hard_iface may be NULL: In that case the number of transmissions this skb had |
1010 | * so far is compared with the maximum amount of retransmissions independent of |
1011 | * any interface instead. |
1012 | * |
1013 | * Return: True if (re)transmissions are left, false otherwise. |
1014 | */ |
1015 | static bool |
1016 | batadv_forw_packet_bcasts_left(struct batadv_forw_packet *forw_packet) |
1017 | { |
1018 | return BATADV_SKB_CB(forw_packet->skb)->num_bcasts; |
1019 | } |
1020 | |
1021 | /** |
1022 | * batadv_forw_packet_bcasts_dec() - decrement retransmission counter of a |
1023 | * packet |
1024 | * @forw_packet: the packet to decrease the counter for |
1025 | */ |
1026 | static void |
1027 | batadv_forw_packet_bcasts_dec(struct batadv_forw_packet *forw_packet) |
1028 | { |
1029 | BATADV_SKB_CB(forw_packet->skb)->num_bcasts--; |
1030 | } |
1031 | |
1032 | /** |
1033 | * batadv_forw_packet_is_rebroadcast() - check packet for previous transmissions |
1034 | * @forw_packet: the packet to check |
1035 | * |
1036 | * Return: True if this packet was transmitted before, false otherwise. |
1037 | */ |
1038 | bool batadv_forw_packet_is_rebroadcast(struct batadv_forw_packet *forw_packet) |
1039 | { |
1040 | unsigned char num_bcasts = BATADV_SKB_CB(forw_packet->skb)->num_bcasts; |
1041 | |
1042 | return num_bcasts != forw_packet->if_outgoing->num_bcasts; |
1043 | } |
1044 | |
1045 | /** |
1046 | * batadv_send_outstanding_bcast_packet() - transmit a queued broadcast packet |
1047 | * @work: work queue item |
1048 | * |
1049 | * Transmits a queued broadcast packet and if necessary reschedules it. |
1050 | */ |
1051 | static void batadv_send_outstanding_bcast_packet(struct work_struct *work) |
1052 | { |
1053 | unsigned long send_time = jiffies + msecs_to_jiffies(m: 5); |
1054 | struct batadv_forw_packet *forw_packet; |
1055 | struct delayed_work *delayed_work; |
1056 | struct batadv_priv *bat_priv; |
1057 | struct sk_buff *skb1; |
1058 | bool dropped = false; |
1059 | |
1060 | delayed_work = to_delayed_work(work); |
1061 | forw_packet = container_of(delayed_work, struct batadv_forw_packet, |
1062 | delayed_work); |
1063 | bat_priv = netdev_priv(dev: forw_packet->if_incoming->soft_iface); |
1064 | |
1065 | if (atomic_read(v: &bat_priv->mesh_state) == BATADV_MESH_DEACTIVATING) { |
1066 | dropped = true; |
1067 | goto out; |
1068 | } |
1069 | |
1070 | if (batadv_dat_drop_broadcast_packet(bat_priv, forw_packet)) { |
1071 | dropped = true; |
1072 | goto out; |
1073 | } |
1074 | |
1075 | /* send a copy of the saved skb */ |
1076 | skb1 = skb_clone(skb: forw_packet->skb, GFP_ATOMIC); |
1077 | if (!skb1) |
1078 | goto out; |
1079 | |
1080 | batadv_send_broadcast_skb(skb: skb1, hard_iface: forw_packet->if_outgoing); |
1081 | batadv_forw_packet_bcasts_dec(forw_packet); |
1082 | |
1083 | if (batadv_forw_packet_bcasts_left(forw_packet)) { |
1084 | batadv_forw_packet_bcast_queue(bat_priv, forw_packet, |
1085 | send_time); |
1086 | return; |
1087 | } |
1088 | |
1089 | out: |
1090 | /* do we get something for free()? */ |
1091 | if (batadv_forw_packet_steal(forw_packet, |
1092 | lock: &bat_priv->forw_bcast_list_lock)) |
1093 | batadv_forw_packet_free(forw_packet, dropped); |
1094 | } |
1095 | |
1096 | /** |
1097 | * batadv_purge_outstanding_packets() - stop/purge scheduled bcast/OGMv1 packets |
1098 | * @bat_priv: the bat priv with all the soft interface information |
1099 | * @hard_iface: the hard interface to cancel and purge bcast/ogm packets on |
1100 | * |
1101 | * This method cancels and purges any broadcast and OGMv1 packet on the given |
1102 | * hard_iface. If hard_iface is NULL, broadcast and OGMv1 packets on all hard |
1103 | * interfaces will be canceled and purged. |
1104 | * |
1105 | * This function might sleep. |
1106 | */ |
1107 | void |
1108 | batadv_purge_outstanding_packets(struct batadv_priv *bat_priv, |
1109 | const struct batadv_hard_iface *hard_iface) |
1110 | { |
1111 | struct hlist_head head = HLIST_HEAD_INIT; |
1112 | |
1113 | if (hard_iface) |
1114 | batadv_dbg(BATADV_DBG_BATMAN, bat_priv, |
1115 | "%s(): %s\n" , |
1116 | __func__, hard_iface->net_dev->name); |
1117 | else |
1118 | batadv_dbg(BATADV_DBG_BATMAN, bat_priv, |
1119 | "%s()\n" , __func__); |
1120 | |
1121 | /* claim bcast list for free() */ |
1122 | spin_lock_bh(lock: &bat_priv->forw_bcast_list_lock); |
1123 | batadv_forw_packet_list_steal(forw_list: &bat_priv->forw_bcast_list, cleanup_list: &head, |
1124 | hard_iface); |
1125 | spin_unlock_bh(lock: &bat_priv->forw_bcast_list_lock); |
1126 | |
1127 | /* claim batman packet list for free() */ |
1128 | spin_lock_bh(lock: &bat_priv->forw_bat_list_lock); |
1129 | batadv_forw_packet_list_steal(forw_list: &bat_priv->forw_bat_list, cleanup_list: &head, |
1130 | hard_iface); |
1131 | spin_unlock_bh(lock: &bat_priv->forw_bat_list_lock); |
1132 | |
1133 | /* then cancel or wait for packet workers to finish and free */ |
1134 | batadv_forw_packet_list_free(head: &head); |
1135 | } |
1136 | |