1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) 2011-2019 B.A.T.M.A.N. contributors:
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of version 2 of the GNU General Public
8 * License as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, see <http://www.gnu.org/licenses/>.
19 #include "bridge_loop_avoidance.h"
22 #include <linux/atomic.h>
23 #include <linux/byteorder/generic.h>
24 #include <linux/compiler.h>
25 #include <linux/crc16.h>
26 #include <linux/errno.h>
27 #include <linux/etherdevice.h>
28 #include <linux/gfp.h>
29 #include <linux/if_arp.h>
30 #include <linux/if_ether.h>
31 #include <linux/if_vlan.h>
32 #include <linux/jhash.h>
33 #include <linux/jiffies.h>
34 #include <linux/kernel.h>
35 #include <linux/kref.h>
36 #include <linux/list.h>
37 #include <linux/lockdep.h>
38 #include <linux/netdevice.h>
39 #include <linux/netlink.h>
40 #include <linux/rculist.h>
41 #include <linux/rcupdate.h>
42 #include <linux/seq_file.h>
43 #include <linux/skbuff.h>
44 #include <linux/slab.h>
45 #include <linux/spinlock.h>
46 #include <linux/stddef.h>
47 #include <linux/string.h>
48 #include <linux/workqueue.h>
50 #include <net/genetlink.h>
51 #include <net/netlink.h>
53 #include <uapi/linux/batadv_packet.h>
54 #include <uapi/linux/batman_adv.h>
56 #include "hard-interface.h"
60 #include "originator.h"
61 #include "soft-interface.h"
63 #include "translation-table.h"
65 static const u8 batadv_announce_mac[4] = {0x43, 0x05, 0x43, 0x05};
67 static void batadv_bla_periodic_work(struct work_struct *work);
69 batadv_bla_send_announce(struct batadv_priv *bat_priv,
70 struct batadv_bla_backbone_gw *backbone_gw);
73 * batadv_choose_claim() - choose the right bucket for a claim.
75 * @size: size of the hash table
77 * Return: the hash index of the claim
79 static inline u32 batadv_choose_claim(const void *data, u32 size)
81 struct batadv_bla_claim *claim = (struct batadv_bla_claim *)data;
84 hash = jhash(&claim->addr, sizeof(claim->addr), hash);
85 hash = jhash(&claim->vid, sizeof(claim->vid), hash);
91 * batadv_choose_backbone_gw() - choose the right bucket for a backbone gateway.
93 * @size: size of the hash table
95 * Return: the hash index of the backbone gateway
97 static inline u32 batadv_choose_backbone_gw(const void *data, u32 size)
99 const struct batadv_bla_claim *claim = (struct batadv_bla_claim *)data;
102 hash = jhash(&claim->addr, sizeof(claim->addr), hash);
103 hash = jhash(&claim->vid, sizeof(claim->vid), hash);
109 * batadv_compare_backbone_gw() - compare address and vid of two backbone gws
110 * @node: list node of the first entry to compare
111 * @data2: pointer to the second backbone gateway
113 * Return: true if the backbones have the same data, false otherwise
115 static bool batadv_compare_backbone_gw(const struct hlist_node *node,
118 const void *data1 = container_of(node, struct batadv_bla_backbone_gw,
120 const struct batadv_bla_backbone_gw *gw1 = data1;
121 const struct batadv_bla_backbone_gw *gw2 = data2;
123 if (!batadv_compare_eth(gw1->orig, gw2->orig))
126 if (gw1->vid != gw2->vid)
133 * batadv_compare_claim() - compare address and vid of two claims
134 * @node: list node of the first entry to compare
135 * @data2: pointer to the second claims
137 * Return: true if the claim have the same data, 0 otherwise
139 static bool batadv_compare_claim(const struct hlist_node *node,
142 const void *data1 = container_of(node, struct batadv_bla_claim,
144 const struct batadv_bla_claim *cl1 = data1;
145 const struct batadv_bla_claim *cl2 = data2;
147 if (!batadv_compare_eth(cl1->addr, cl2->addr))
150 if (cl1->vid != cl2->vid)
157 * batadv_backbone_gw_release() - release backbone gw from lists and queue for
158 * free after rcu grace period
159 * @ref: kref pointer of the backbone gw
161 static void batadv_backbone_gw_release(struct kref *ref)
163 struct batadv_bla_backbone_gw *backbone_gw;
165 backbone_gw = container_of(ref, struct batadv_bla_backbone_gw,
168 kfree_rcu(backbone_gw, rcu);
172 * batadv_backbone_gw_put() - decrement the backbone gw refcounter and possibly
174 * @backbone_gw: backbone gateway to be free'd
176 static void batadv_backbone_gw_put(struct batadv_bla_backbone_gw *backbone_gw)
178 kref_put(&backbone_gw->refcount, batadv_backbone_gw_release);
182 * batadv_claim_release() - release claim from lists and queue for free after
184 * @ref: kref pointer of the claim
186 static void batadv_claim_release(struct kref *ref)
188 struct batadv_bla_claim *claim;
189 struct batadv_bla_backbone_gw *old_backbone_gw;
191 claim = container_of(ref, struct batadv_bla_claim, refcount);
193 spin_lock_bh(&claim->backbone_lock);
194 old_backbone_gw = claim->backbone_gw;
195 claim->backbone_gw = NULL;
196 spin_unlock_bh(&claim->backbone_lock);
198 spin_lock_bh(&old_backbone_gw->crc_lock);
199 old_backbone_gw->crc ^= crc16(0, claim->addr, ETH_ALEN);
200 spin_unlock_bh(&old_backbone_gw->crc_lock);
202 batadv_backbone_gw_put(old_backbone_gw);
204 kfree_rcu(claim, rcu);
208 * batadv_claim_put() - decrement the claim refcounter and possibly release it
209 * @claim: claim to be free'd
211 static void batadv_claim_put(struct batadv_bla_claim *claim)
213 kref_put(&claim->refcount, batadv_claim_release);
217 * batadv_claim_hash_find() - looks for a claim in the claim hash
218 * @bat_priv: the bat priv with all the soft interface information
219 * @data: search data (may be local/static data)
221 * Return: claim if found or NULL otherwise.
223 static struct batadv_bla_claim *
224 batadv_claim_hash_find(struct batadv_priv *bat_priv,
225 struct batadv_bla_claim *data)
227 struct batadv_hashtable *hash = bat_priv->bla.claim_hash;
228 struct hlist_head *head;
229 struct batadv_bla_claim *claim;
230 struct batadv_bla_claim *claim_tmp = NULL;
236 index = batadv_choose_claim(data, hash->size);
237 head = &hash->table[index];
240 hlist_for_each_entry_rcu(claim, head, hash_entry) {
241 if (!batadv_compare_claim(&claim->hash_entry, data))
244 if (!kref_get_unless_zero(&claim->refcount))
256 * batadv_backbone_hash_find() - looks for a backbone gateway in the hash
257 * @bat_priv: the bat priv with all the soft interface information
258 * @addr: the address of the originator
261 * Return: backbone gateway if found or NULL otherwise
263 static struct batadv_bla_backbone_gw *
264 batadv_backbone_hash_find(struct batadv_priv *bat_priv, u8 *addr,
267 struct batadv_hashtable *hash = bat_priv->bla.backbone_hash;
268 struct hlist_head *head;
269 struct batadv_bla_backbone_gw search_entry, *backbone_gw;
270 struct batadv_bla_backbone_gw *backbone_gw_tmp = NULL;
276 ether_addr_copy(search_entry.orig, addr);
277 search_entry.vid = vid;
279 index = batadv_choose_backbone_gw(&search_entry, hash->size);
280 head = &hash->table[index];
283 hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
284 if (!batadv_compare_backbone_gw(&backbone_gw->hash_entry,
288 if (!kref_get_unless_zero(&backbone_gw->refcount))
291 backbone_gw_tmp = backbone_gw;
296 return backbone_gw_tmp;
300 * batadv_bla_del_backbone_claims() - delete all claims for a backbone
301 * @backbone_gw: backbone gateway where the claims should be removed
304 batadv_bla_del_backbone_claims(struct batadv_bla_backbone_gw *backbone_gw)
306 struct batadv_hashtable *hash;
307 struct hlist_node *node_tmp;
308 struct hlist_head *head;
309 struct batadv_bla_claim *claim;
311 spinlock_t *list_lock; /* protects write access to the hash lists */
313 hash = backbone_gw->bat_priv->bla.claim_hash;
317 for (i = 0; i < hash->size; i++) {
318 head = &hash->table[i];
319 list_lock = &hash->list_locks[i];
321 spin_lock_bh(list_lock);
322 hlist_for_each_entry_safe(claim, node_tmp,
324 if (claim->backbone_gw != backbone_gw)
327 batadv_claim_put(claim);
328 hlist_del_rcu(&claim->hash_entry);
330 spin_unlock_bh(list_lock);
333 /* all claims gone, initialize CRC */
334 spin_lock_bh(&backbone_gw->crc_lock);
335 backbone_gw->crc = BATADV_BLA_CRC_INIT;
336 spin_unlock_bh(&backbone_gw->crc_lock);
340 * batadv_bla_send_claim() - sends a claim frame according to the provided info
341 * @bat_priv: the bat priv with all the soft interface information
342 * @mac: the mac address to be announced within the claim
344 * @claimtype: the type of the claim (CLAIM, UNCLAIM, ANNOUNCE, ...)
346 static void batadv_bla_send_claim(struct batadv_priv *bat_priv, u8 *mac,
347 unsigned short vid, int claimtype)
350 struct ethhdr *ethhdr;
351 struct batadv_hard_iface *primary_if;
352 struct net_device *soft_iface;
354 struct batadv_bla_claim_dst local_claim_dest;
357 primary_if = batadv_primary_if_get_selected(bat_priv);
361 memcpy(&local_claim_dest, &bat_priv->bla.claim_dest,
362 sizeof(local_claim_dest));
363 local_claim_dest.type = claimtype;
365 soft_iface = primary_if->soft_iface;
367 skb = arp_create(ARPOP_REPLY, ETH_P_ARP,
368 /* IP DST: 0.0.0.0 */
370 primary_if->soft_iface,
371 /* IP SRC: 0.0.0.0 */
373 /* Ethernet DST: Broadcast */
375 /* Ethernet SRC/HW SRC: originator mac */
376 primary_if->net_dev->dev_addr,
377 /* HW DST: FF:43:05:XX:YY:YY
378 * with XX = claim type
379 * and YY:YY = group id
381 (u8 *)&local_claim_dest);
386 ethhdr = (struct ethhdr *)skb->data;
387 hw_src = (u8 *)ethhdr + ETH_HLEN + sizeof(struct arphdr);
389 /* now we pretend that the client would have sent this ... */
391 case BATADV_CLAIM_TYPE_CLAIM:
392 /* normal claim frame
393 * set Ethernet SRC to the clients mac
395 ether_addr_copy(ethhdr->h_source, mac);
396 batadv_dbg(BATADV_DBG_BLA, bat_priv,
397 "%s(): CLAIM %pM on vid %d\n", __func__, mac,
398 batadv_print_vid(vid));
400 case BATADV_CLAIM_TYPE_UNCLAIM:
402 * set HW SRC to the clients mac
404 ether_addr_copy(hw_src, mac);
405 batadv_dbg(BATADV_DBG_BLA, bat_priv,
406 "%s(): UNCLAIM %pM on vid %d\n", __func__, mac,
407 batadv_print_vid(vid));
409 case BATADV_CLAIM_TYPE_ANNOUNCE:
410 /* announcement frame
411 * set HW SRC to the special mac containg the crc
413 ether_addr_copy(hw_src, mac);
414 batadv_dbg(BATADV_DBG_BLA, bat_priv,
415 "%s(): ANNOUNCE of %pM on vid %d\n", __func__,
416 ethhdr->h_source, batadv_print_vid(vid));
418 case BATADV_CLAIM_TYPE_REQUEST:
420 * set HW SRC and header destination to the receiving backbone
423 ether_addr_copy(hw_src, mac);
424 ether_addr_copy(ethhdr->h_dest, mac);
425 batadv_dbg(BATADV_DBG_BLA, bat_priv,
426 "%s(): REQUEST of %pM to %pM on vid %d\n", __func__,
427 ethhdr->h_source, ethhdr->h_dest,
428 batadv_print_vid(vid));
430 case BATADV_CLAIM_TYPE_LOOPDETECT:
431 ether_addr_copy(ethhdr->h_source, mac);
432 batadv_dbg(BATADV_DBG_BLA, bat_priv,
433 "%s(): LOOPDETECT of %pM to %pM on vid %d\n",
434 __func__, ethhdr->h_source, ethhdr->h_dest,
435 batadv_print_vid(vid));
440 if (vid & BATADV_VLAN_HAS_TAG) {
441 skb = vlan_insert_tag(skb, htons(ETH_P_8021Q),
442 vid & VLAN_VID_MASK);
447 skb_reset_mac_header(skb);
448 skb->protocol = eth_type_trans(skb, soft_iface);
449 batadv_inc_counter(bat_priv, BATADV_CNT_RX);
450 batadv_add_counter(bat_priv, BATADV_CNT_RX_BYTES,
451 skb->len + ETH_HLEN);
456 batadv_hardif_put(primary_if);
460 * batadv_bla_loopdetect_report() - worker for reporting the loop
461 * @work: work queue item
463 * Throws an uevent, as the loopdetect check function can't do that itself
464 * since the kernel may sleep while throwing uevents.
466 static void batadv_bla_loopdetect_report(struct work_struct *work)
468 struct batadv_bla_backbone_gw *backbone_gw;
469 struct batadv_priv *bat_priv;
470 char vid_str[6] = { '\0' };
472 backbone_gw = container_of(work, struct batadv_bla_backbone_gw,
474 bat_priv = backbone_gw->bat_priv;
476 batadv_info(bat_priv->soft_iface,
477 "Possible loop on VLAN %d detected which can't be handled by BLA - please check your network setup!\n",
478 batadv_print_vid(backbone_gw->vid));
479 snprintf(vid_str, sizeof(vid_str), "%d",
480 batadv_print_vid(backbone_gw->vid));
481 vid_str[sizeof(vid_str) - 1] = 0;
483 batadv_throw_uevent(bat_priv, BATADV_UEV_BLA, BATADV_UEV_LOOPDETECT,
486 batadv_backbone_gw_put(backbone_gw);
490 * batadv_bla_get_backbone_gw() - finds or creates a backbone gateway
491 * @bat_priv: the bat priv with all the soft interface information
492 * @orig: the mac address of the originator
494 * @own_backbone: set if the requested backbone is local
496 * Return: the (possibly created) backbone gateway or NULL on error
498 static struct batadv_bla_backbone_gw *
499 batadv_bla_get_backbone_gw(struct batadv_priv *bat_priv, u8 *orig,
500 unsigned short vid, bool own_backbone)
502 struct batadv_bla_backbone_gw *entry;
503 struct batadv_orig_node *orig_node;
506 entry = batadv_backbone_hash_find(bat_priv, orig, vid);
511 batadv_dbg(BATADV_DBG_BLA, bat_priv,
512 "%s(): not found (%pM, %d), creating new entry\n", __func__,
513 orig, batadv_print_vid(vid));
515 entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
520 entry->lasttime = jiffies;
521 entry->crc = BATADV_BLA_CRC_INIT;
522 entry->bat_priv = bat_priv;
523 spin_lock_init(&entry->crc_lock);
524 atomic_set(&entry->request_sent, 0);
525 atomic_set(&entry->wait_periods, 0);
526 ether_addr_copy(entry->orig, orig);
527 INIT_WORK(&entry->report_work, batadv_bla_loopdetect_report);
528 kref_init(&entry->refcount);
530 kref_get(&entry->refcount);
531 hash_added = batadv_hash_add(bat_priv->bla.backbone_hash,
532 batadv_compare_backbone_gw,
533 batadv_choose_backbone_gw, entry,
536 if (unlikely(hash_added != 0)) {
537 /* hash failed, free the structure */
542 /* this is a gateway now, remove any TT entry on this VLAN */
543 orig_node = batadv_orig_hash_find(bat_priv, orig);
545 batadv_tt_global_del_orig(bat_priv, orig_node, vid,
546 "became a backbone gateway");
547 batadv_orig_node_put(orig_node);
551 batadv_bla_send_announce(bat_priv, entry);
553 /* this will be decreased in the worker thread */
554 atomic_inc(&entry->request_sent);
555 atomic_set(&entry->wait_periods, BATADV_BLA_WAIT_PERIODS);
556 atomic_inc(&bat_priv->bla.num_requests);
563 * batadv_bla_update_own_backbone_gw() - updates the own backbone gw for a VLAN
564 * @bat_priv: the bat priv with all the soft interface information
565 * @primary_if: the selected primary interface
566 * @vid: VLAN identifier
568 * update or add the own backbone gw to make sure we announce
569 * where we receive other backbone gws
572 batadv_bla_update_own_backbone_gw(struct batadv_priv *bat_priv,
573 struct batadv_hard_iface *primary_if,
576 struct batadv_bla_backbone_gw *backbone_gw;
578 backbone_gw = batadv_bla_get_backbone_gw(bat_priv,
579 primary_if->net_dev->dev_addr,
581 if (unlikely(!backbone_gw))
584 backbone_gw->lasttime = jiffies;
585 batadv_backbone_gw_put(backbone_gw);
589 * batadv_bla_answer_request() - answer a bla request by sending own claims
590 * @bat_priv: the bat priv with all the soft interface information
591 * @primary_if: interface where the request came on
592 * @vid: the vid where the request came on
594 * Repeat all of our own claims, and finally send an ANNOUNCE frame
595 * to allow the requester another check if the CRC is correct now.
597 static void batadv_bla_answer_request(struct batadv_priv *bat_priv,
598 struct batadv_hard_iface *primary_if,
601 struct hlist_head *head;
602 struct batadv_hashtable *hash;
603 struct batadv_bla_claim *claim;
604 struct batadv_bla_backbone_gw *backbone_gw;
607 batadv_dbg(BATADV_DBG_BLA, bat_priv,
608 "%s(): received a claim request, send all of our own claims again\n",
611 backbone_gw = batadv_backbone_hash_find(bat_priv,
612 primary_if->net_dev->dev_addr,
617 hash = bat_priv->bla.claim_hash;
618 for (i = 0; i < hash->size; i++) {
619 head = &hash->table[i];
622 hlist_for_each_entry_rcu(claim, head, hash_entry) {
623 /* only own claims are interesting */
624 if (claim->backbone_gw != backbone_gw)
627 batadv_bla_send_claim(bat_priv, claim->addr, claim->vid,
628 BATADV_CLAIM_TYPE_CLAIM);
633 /* finally, send an announcement frame */
634 batadv_bla_send_announce(bat_priv, backbone_gw);
635 batadv_backbone_gw_put(backbone_gw);
639 * batadv_bla_send_request() - send a request to repeat claims
640 * @backbone_gw: the backbone gateway from whom we are out of sync
642 * When the crc is wrong, ask the backbone gateway for a full table update.
643 * After the request, it will repeat all of his own claims and finally
644 * send an announcement claim with which we can check again.
646 static void batadv_bla_send_request(struct batadv_bla_backbone_gw *backbone_gw)
648 /* first, remove all old entries */
649 batadv_bla_del_backbone_claims(backbone_gw);
651 batadv_dbg(BATADV_DBG_BLA, backbone_gw->bat_priv,
652 "Sending REQUEST to %pM\n", backbone_gw->orig);
655 batadv_bla_send_claim(backbone_gw->bat_priv, backbone_gw->orig,
656 backbone_gw->vid, BATADV_CLAIM_TYPE_REQUEST);
658 /* no local broadcasts should be sent or received, for now. */
659 if (!atomic_read(&backbone_gw->request_sent)) {
660 atomic_inc(&backbone_gw->bat_priv->bla.num_requests);
661 atomic_set(&backbone_gw->request_sent, 1);
666 * batadv_bla_send_announce() - Send an announcement frame
667 * @bat_priv: the bat priv with all the soft interface information
668 * @backbone_gw: our backbone gateway which should be announced
670 static void batadv_bla_send_announce(struct batadv_priv *bat_priv,
671 struct batadv_bla_backbone_gw *backbone_gw)
676 memcpy(mac, batadv_announce_mac, 4);
677 spin_lock_bh(&backbone_gw->crc_lock);
678 crc = htons(backbone_gw->crc);
679 spin_unlock_bh(&backbone_gw->crc_lock);
680 memcpy(&mac[4], &crc, 2);
682 batadv_bla_send_claim(bat_priv, mac, backbone_gw->vid,
683 BATADV_CLAIM_TYPE_ANNOUNCE);
687 * batadv_bla_add_claim() - Adds a claim in the claim hash
688 * @bat_priv: the bat priv with all the soft interface information
689 * @mac: the mac address of the claim
690 * @vid: the VLAN ID of the frame
691 * @backbone_gw: the backbone gateway which claims it
693 static void batadv_bla_add_claim(struct batadv_priv *bat_priv,
694 const u8 *mac, const unsigned short vid,
695 struct batadv_bla_backbone_gw *backbone_gw)
697 struct batadv_bla_backbone_gw *old_backbone_gw;
698 struct batadv_bla_claim *claim;
699 struct batadv_bla_claim search_claim;
700 bool remove_crc = false;
703 ether_addr_copy(search_claim.addr, mac);
704 search_claim.vid = vid;
705 claim = batadv_claim_hash_find(bat_priv, &search_claim);
707 /* create a new claim entry if it does not exist yet. */
709 claim = kzalloc(sizeof(*claim), GFP_ATOMIC);
713 ether_addr_copy(claim->addr, mac);
714 spin_lock_init(&claim->backbone_lock);
716 claim->lasttime = jiffies;
717 kref_get(&backbone_gw->refcount);
718 claim->backbone_gw = backbone_gw;
719 kref_init(&claim->refcount);
721 batadv_dbg(BATADV_DBG_BLA, bat_priv,
722 "%s(): adding new entry %pM, vid %d to hash ...\n",
723 __func__, mac, batadv_print_vid(vid));
725 kref_get(&claim->refcount);
726 hash_added = batadv_hash_add(bat_priv->bla.claim_hash,
727 batadv_compare_claim,
728 batadv_choose_claim, claim,
731 if (unlikely(hash_added != 0)) {
732 /* only local changes happened. */
737 claim->lasttime = jiffies;
738 if (claim->backbone_gw == backbone_gw)
739 /* no need to register a new backbone */
742 batadv_dbg(BATADV_DBG_BLA, bat_priv,
743 "%s(): changing ownership for %pM, vid %d to gw %pM\n",
744 __func__, mac, batadv_print_vid(vid),
750 /* replace backbone_gw atomically and adjust reference counters */
751 spin_lock_bh(&claim->backbone_lock);
752 old_backbone_gw = claim->backbone_gw;
753 kref_get(&backbone_gw->refcount);
754 claim->backbone_gw = backbone_gw;
755 spin_unlock_bh(&claim->backbone_lock);
758 /* remove claim address from old backbone_gw */
759 spin_lock_bh(&old_backbone_gw->crc_lock);
760 old_backbone_gw->crc ^= crc16(0, claim->addr, ETH_ALEN);
761 spin_unlock_bh(&old_backbone_gw->crc_lock);
764 batadv_backbone_gw_put(old_backbone_gw);
766 /* add claim address to new backbone_gw */
767 spin_lock_bh(&backbone_gw->crc_lock);
768 backbone_gw->crc ^= crc16(0, claim->addr, ETH_ALEN);
769 spin_unlock_bh(&backbone_gw->crc_lock);
770 backbone_gw->lasttime = jiffies;
773 batadv_claim_put(claim);
777 * batadv_bla_claim_get_backbone_gw() - Get valid reference for backbone_gw of
779 * @claim: claim whose backbone_gw should be returned
781 * Return: valid reference to claim::backbone_gw
783 static struct batadv_bla_backbone_gw *
784 batadv_bla_claim_get_backbone_gw(struct batadv_bla_claim *claim)
786 struct batadv_bla_backbone_gw *backbone_gw;
788 spin_lock_bh(&claim->backbone_lock);
789 backbone_gw = claim->backbone_gw;
790 kref_get(&backbone_gw->refcount);
791 spin_unlock_bh(&claim->backbone_lock);
797 * batadv_bla_del_claim() - delete a claim from the claim hash
798 * @bat_priv: the bat priv with all the soft interface information
799 * @mac: mac address of the claim to be removed
800 * @vid: VLAN id for the claim to be removed
802 static void batadv_bla_del_claim(struct batadv_priv *bat_priv,
803 const u8 *mac, const unsigned short vid)
805 struct batadv_bla_claim search_claim, *claim;
806 struct batadv_bla_claim *claim_removed_entry;
807 struct hlist_node *claim_removed_node;
809 ether_addr_copy(search_claim.addr, mac);
810 search_claim.vid = vid;
811 claim = batadv_claim_hash_find(bat_priv, &search_claim);
815 batadv_dbg(BATADV_DBG_BLA, bat_priv, "%s(): %pM, vid %d\n", __func__,
816 mac, batadv_print_vid(vid));
818 claim_removed_node = batadv_hash_remove(bat_priv->bla.claim_hash,
819 batadv_compare_claim,
820 batadv_choose_claim, claim);
821 if (!claim_removed_node)
824 /* reference from the hash is gone */
825 claim_removed_entry = hlist_entry(claim_removed_node,
826 struct batadv_bla_claim, hash_entry);
827 batadv_claim_put(claim_removed_entry);
830 /* don't need the reference from hash_find() anymore */
831 batadv_claim_put(claim);
835 * batadv_handle_announce() - check for ANNOUNCE frame
836 * @bat_priv: the bat priv with all the soft interface information
837 * @an_addr: announcement mac address (ARP Sender HW address)
838 * @backbone_addr: originator address of the sender (Ethernet source MAC)
839 * @vid: the VLAN ID of the frame
841 * Return: true if handled
843 static bool batadv_handle_announce(struct batadv_priv *bat_priv, u8 *an_addr,
844 u8 *backbone_addr, unsigned short vid)
846 struct batadv_bla_backbone_gw *backbone_gw;
847 u16 backbone_crc, crc;
849 if (memcmp(an_addr, batadv_announce_mac, 4) != 0)
852 backbone_gw = batadv_bla_get_backbone_gw(bat_priv, backbone_addr, vid,
855 if (unlikely(!backbone_gw))
858 /* handle as ANNOUNCE frame */
859 backbone_gw->lasttime = jiffies;
860 crc = ntohs(*((__be16 *)(&an_addr[4])));
862 batadv_dbg(BATADV_DBG_BLA, bat_priv,
863 "%s(): ANNOUNCE vid %d (sent by %pM)... CRC = %#.4x\n",
864 __func__, batadv_print_vid(vid), backbone_gw->orig, crc);
866 spin_lock_bh(&backbone_gw->crc_lock);
867 backbone_crc = backbone_gw->crc;
868 spin_unlock_bh(&backbone_gw->crc_lock);
870 if (backbone_crc != crc) {
871 batadv_dbg(BATADV_DBG_BLA, backbone_gw->bat_priv,
872 "%s(): CRC FAILED for %pM/%d (my = %#.4x, sent = %#.4x)\n",
873 __func__, backbone_gw->orig,
874 batadv_print_vid(backbone_gw->vid),
877 batadv_bla_send_request(backbone_gw);
879 /* if we have sent a request and the crc was OK,
880 * we can allow traffic again.
882 if (atomic_read(&backbone_gw->request_sent)) {
883 atomic_dec(&backbone_gw->bat_priv->bla.num_requests);
884 atomic_set(&backbone_gw->request_sent, 0);
888 batadv_backbone_gw_put(backbone_gw);
893 * batadv_handle_request() - check for REQUEST frame
894 * @bat_priv: the bat priv with all the soft interface information
895 * @primary_if: the primary hard interface of this batman soft interface
896 * @backbone_addr: backbone address to be requested (ARP sender HW MAC)
897 * @ethhdr: ethernet header of a packet
898 * @vid: the VLAN ID of the frame
900 * Return: true if handled
902 static bool batadv_handle_request(struct batadv_priv *bat_priv,
903 struct batadv_hard_iface *primary_if,
904 u8 *backbone_addr, struct ethhdr *ethhdr,
907 /* check for REQUEST frame */
908 if (!batadv_compare_eth(backbone_addr, ethhdr->h_dest))
911 /* sanity check, this should not happen on a normal switch,
912 * we ignore it in this case.
914 if (!batadv_compare_eth(ethhdr->h_dest, primary_if->net_dev->dev_addr))
917 batadv_dbg(BATADV_DBG_BLA, bat_priv,
918 "%s(): REQUEST vid %d (sent by %pM)...\n",
919 __func__, batadv_print_vid(vid), ethhdr->h_source);
921 batadv_bla_answer_request(bat_priv, primary_if, vid);
926 * batadv_handle_unclaim() - check for UNCLAIM frame
927 * @bat_priv: the bat priv with all the soft interface information
928 * @primary_if: the primary hard interface of this batman soft interface
929 * @backbone_addr: originator address of the backbone (Ethernet source)
930 * @claim_addr: Client to be unclaimed (ARP sender HW MAC)
931 * @vid: the VLAN ID of the frame
933 * Return: true if handled
935 static bool batadv_handle_unclaim(struct batadv_priv *bat_priv,
936 struct batadv_hard_iface *primary_if,
937 u8 *backbone_addr, u8 *claim_addr,
940 struct batadv_bla_backbone_gw *backbone_gw;
942 /* unclaim in any case if it is our own */
943 if (primary_if && batadv_compare_eth(backbone_addr,
944 primary_if->net_dev->dev_addr))
945 batadv_bla_send_claim(bat_priv, claim_addr, vid,
946 BATADV_CLAIM_TYPE_UNCLAIM);
948 backbone_gw = batadv_backbone_hash_find(bat_priv, backbone_addr, vid);
953 /* this must be an UNCLAIM frame */
954 batadv_dbg(BATADV_DBG_BLA, bat_priv,
955 "%s(): UNCLAIM %pM on vid %d (sent by %pM)...\n", __func__,
956 claim_addr, batadv_print_vid(vid), backbone_gw->orig);
958 batadv_bla_del_claim(bat_priv, claim_addr, vid);
959 batadv_backbone_gw_put(backbone_gw);
964 * batadv_handle_claim() - check for CLAIM frame
965 * @bat_priv: the bat priv with all the soft interface information
966 * @primary_if: the primary hard interface of this batman soft interface
967 * @backbone_addr: originator address of the backbone (Ethernet Source)
968 * @claim_addr: client mac address to be claimed (ARP sender HW MAC)
969 * @vid: the VLAN ID of the frame
971 * Return: true if handled
973 static bool batadv_handle_claim(struct batadv_priv *bat_priv,
974 struct batadv_hard_iface *primary_if,
975 u8 *backbone_addr, u8 *claim_addr,
978 struct batadv_bla_backbone_gw *backbone_gw;
980 /* register the gateway if not yet available, and add the claim. */
982 backbone_gw = batadv_bla_get_backbone_gw(bat_priv, backbone_addr, vid,
985 if (unlikely(!backbone_gw))
988 /* this must be a CLAIM frame */
989 batadv_bla_add_claim(bat_priv, claim_addr, vid, backbone_gw);
990 if (batadv_compare_eth(backbone_addr, primary_if->net_dev->dev_addr))
991 batadv_bla_send_claim(bat_priv, claim_addr, vid,
992 BATADV_CLAIM_TYPE_CLAIM);
994 /* TODO: we could call something like tt_local_del() here. */
996 batadv_backbone_gw_put(backbone_gw);
1001 * batadv_check_claim_group() - check for claim group membership
1002 * @bat_priv: the bat priv with all the soft interface information
1003 * @primary_if: the primary interface of this batman interface
1004 * @hw_src: the Hardware source in the ARP Header
1005 * @hw_dst: the Hardware destination in the ARP Header
1006 * @ethhdr: pointer to the Ethernet header of the claim frame
1008 * checks if it is a claim packet and if its on the same group.
1009 * This function also applies the group ID of the sender
1010 * if it is in the same mesh.
1013 * 2 - if it is a claim packet and on the same group
1014 * 1 - if is a claim packet from another group
1015 * 0 - if it is not a claim packet
1017 static int batadv_check_claim_group(struct batadv_priv *bat_priv,
1018 struct batadv_hard_iface *primary_if,
1019 u8 *hw_src, u8 *hw_dst,
1020 struct ethhdr *ethhdr)
1023 struct batadv_orig_node *orig_node;
1024 struct batadv_bla_claim_dst *bla_dst, *bla_dst_own;
1026 bla_dst = (struct batadv_bla_claim_dst *)hw_dst;
1027 bla_dst_own = &bat_priv->bla.claim_dest;
1029 /* if announcement packet, use the source,
1030 * otherwise assume it is in the hw_src
1032 switch (bla_dst->type) {
1033 case BATADV_CLAIM_TYPE_CLAIM:
1034 backbone_addr = hw_src;
1036 case BATADV_CLAIM_TYPE_REQUEST:
1037 case BATADV_CLAIM_TYPE_ANNOUNCE:
1038 case BATADV_CLAIM_TYPE_UNCLAIM:
1039 backbone_addr = ethhdr->h_source;
1045 /* don't accept claim frames from ourselves */
1046 if (batadv_compare_eth(backbone_addr, primary_if->net_dev->dev_addr))
1049 /* if its already the same group, it is fine. */
1050 if (bla_dst->group == bla_dst_own->group)
1053 /* lets see if this originator is in our mesh */
1054 orig_node = batadv_orig_hash_find(bat_priv, backbone_addr);
1056 /* dont accept claims from gateways which are not in
1057 * the same mesh or group.
1062 /* if our mesh friends mac is bigger, use it for ourselves. */
1063 if (ntohs(bla_dst->group) > ntohs(bla_dst_own->group)) {
1064 batadv_dbg(BATADV_DBG_BLA, bat_priv,
1065 "taking other backbones claim group: %#.4x\n",
1066 ntohs(bla_dst->group));
1067 bla_dst_own->group = bla_dst->group;
1070 batadv_orig_node_put(orig_node);
1076 * batadv_bla_process_claim() - Check if this is a claim frame, and process it
1077 * @bat_priv: the bat priv with all the soft interface information
1078 * @primary_if: the primary hard interface of this batman soft interface
1079 * @skb: the frame to be checked
1081 * Return: true if it was a claim frame, otherwise return false to
1082 * tell the callee that it can use the frame on its own.
1084 static bool batadv_bla_process_claim(struct batadv_priv *bat_priv,
1085 struct batadv_hard_iface *primary_if,
1086 struct sk_buff *skb)
1088 struct batadv_bla_claim_dst *bla_dst, *bla_dst_own;
1089 u8 *hw_src, *hw_dst;
1090 struct vlan_hdr *vhdr, vhdr_buf;
1091 struct ethhdr *ethhdr;
1092 struct arphdr *arphdr;
1099 vid = batadv_get_vid(skb, 0);
1100 ethhdr = eth_hdr(skb);
1102 proto = ethhdr->h_proto;
1104 if (vid & BATADV_VLAN_HAS_TAG) {
1105 /* Traverse the VLAN/Ethertypes.
1107 * At this point it is known that the first protocol is a VLAN
1108 * header, so start checking at the encapsulated protocol.
1110 * The depth of the VLAN headers is recorded to drop BLA claim
1111 * frames encapsulated into multiple VLAN headers (QinQ).
1114 vhdr = skb_header_pointer(skb, headlen, VLAN_HLEN,
1119 proto = vhdr->h_vlan_encapsulated_proto;
1120 headlen += VLAN_HLEN;
1122 } while (proto == htons(ETH_P_8021Q));
1125 if (proto != htons(ETH_P_ARP))
1126 return false; /* not a claim frame */
1128 /* this must be a ARP frame. check if it is a claim. */
1130 if (unlikely(!pskb_may_pull(skb, headlen + arp_hdr_len(skb->dev))))
1133 /* pskb_may_pull() may have modified the pointers, get ethhdr again */
1134 ethhdr = eth_hdr(skb);
1135 arphdr = (struct arphdr *)((u8 *)ethhdr + headlen);
1137 /* Check whether the ARP frame carries a valid
1140 if (arphdr->ar_hrd != htons(ARPHRD_ETHER))
1142 if (arphdr->ar_pro != htons(ETH_P_IP))
1144 if (arphdr->ar_hln != ETH_ALEN)
1146 if (arphdr->ar_pln != 4)
1149 hw_src = (u8 *)arphdr + sizeof(struct arphdr);
1150 hw_dst = hw_src + ETH_ALEN + 4;
1151 bla_dst = (struct batadv_bla_claim_dst *)hw_dst;
1152 bla_dst_own = &bat_priv->bla.claim_dest;
1154 /* check if it is a claim frame in general */
1155 if (memcmp(bla_dst->magic, bla_dst_own->magic,
1156 sizeof(bla_dst->magic)) != 0)
1159 /* check if there is a claim frame encapsulated deeper in (QinQ) and
1160 * drop that, as this is not supported by BLA but should also not be
1161 * sent via the mesh.
1166 /* Let the loopdetect frames on the mesh in any case. */
1167 if (bla_dst->type == BATADV_CLAIM_TYPE_LOOPDETECT)
1170 /* check if it is a claim frame. */
1171 ret = batadv_check_claim_group(bat_priv, primary_if, hw_src, hw_dst,
1174 batadv_dbg(BATADV_DBG_BLA, bat_priv,
1175 "%s(): received a claim frame from another group. From: %pM on vid %d ...(hw_src %pM, hw_dst %pM)\n",
1176 __func__, ethhdr->h_source, batadv_print_vid(vid),
1182 /* become a backbone gw ourselves on this vlan if not happened yet */
1183 batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
1185 /* check for the different types of claim frames ... */
1186 switch (bla_dst->type) {
1187 case BATADV_CLAIM_TYPE_CLAIM:
1188 if (batadv_handle_claim(bat_priv, primary_if, hw_src,
1189 ethhdr->h_source, vid))
1192 case BATADV_CLAIM_TYPE_UNCLAIM:
1193 if (batadv_handle_unclaim(bat_priv, primary_if,
1194 ethhdr->h_source, hw_src, vid))
1198 case BATADV_CLAIM_TYPE_ANNOUNCE:
1199 if (batadv_handle_announce(bat_priv, hw_src, ethhdr->h_source,
1203 case BATADV_CLAIM_TYPE_REQUEST:
1204 if (batadv_handle_request(bat_priv, primary_if, hw_src, ethhdr,
1210 batadv_dbg(BATADV_DBG_BLA, bat_priv,
1211 "%s(): ERROR - this looks like a claim frame, but is useless. eth src %pM on vid %d ...(hw_src %pM, hw_dst %pM)\n",
1212 __func__, ethhdr->h_source, batadv_print_vid(vid), hw_src,
1218 * batadv_bla_purge_backbone_gw() - Remove backbone gateways after a timeout or
1220 * @bat_priv: the bat priv with all the soft interface information
1221 * @now: whether the whole hash shall be wiped now
1223 * Check when we last heard from other nodes, and remove them in case of
1224 * a time out, or clean all backbone gws if now is set.
1226 static void batadv_bla_purge_backbone_gw(struct batadv_priv *bat_priv, int now)
1228 struct batadv_bla_backbone_gw *backbone_gw;
1229 struct hlist_node *node_tmp;
1230 struct hlist_head *head;
1231 struct batadv_hashtable *hash;
1232 spinlock_t *list_lock; /* protects write access to the hash lists */
1235 hash = bat_priv->bla.backbone_hash;
1239 for (i = 0; i < hash->size; i++) {
1240 head = &hash->table[i];
1241 list_lock = &hash->list_locks[i];
1243 spin_lock_bh(list_lock);
1244 hlist_for_each_entry_safe(backbone_gw, node_tmp,
1248 if (!batadv_has_timed_out(backbone_gw->lasttime,
1249 BATADV_BLA_BACKBONE_TIMEOUT))
1252 batadv_dbg(BATADV_DBG_BLA, backbone_gw->bat_priv,
1253 "%s(): backbone gw %pM timed out\n",
1254 __func__, backbone_gw->orig);
1257 /* don't wait for the pending request anymore */
1258 if (atomic_read(&backbone_gw->request_sent))
1259 atomic_dec(&bat_priv->bla.num_requests);
1261 batadv_bla_del_backbone_claims(backbone_gw);
1263 hlist_del_rcu(&backbone_gw->hash_entry);
1264 batadv_backbone_gw_put(backbone_gw);
1266 spin_unlock_bh(list_lock);
1271 * batadv_bla_purge_claims() - Remove claims after a timeout or immediately
1272 * @bat_priv: the bat priv with all the soft interface information
1273 * @primary_if: the selected primary interface, may be NULL if now is set
1274 * @now: whether the whole hash shall be wiped now
1276 * Check when we heard last time from our own claims, and remove them in case of
1277 * a time out, or clean all claims if now is set
1279 static void batadv_bla_purge_claims(struct batadv_priv *bat_priv,
1280 struct batadv_hard_iface *primary_if,
1283 struct batadv_bla_backbone_gw *backbone_gw;
1284 struct batadv_bla_claim *claim;
1285 struct hlist_head *head;
1286 struct batadv_hashtable *hash;
1289 hash = bat_priv->bla.claim_hash;
1293 for (i = 0; i < hash->size; i++) {
1294 head = &hash->table[i];
1297 hlist_for_each_entry_rcu(claim, head, hash_entry) {
1298 backbone_gw = batadv_bla_claim_get_backbone_gw(claim);
1302 if (!batadv_compare_eth(backbone_gw->orig,
1303 primary_if->net_dev->dev_addr))
1306 if (!batadv_has_timed_out(claim->lasttime,
1307 BATADV_BLA_CLAIM_TIMEOUT))
1310 batadv_dbg(BATADV_DBG_BLA, bat_priv,
1311 "%s(): timed out.\n", __func__);
1314 batadv_dbg(BATADV_DBG_BLA, bat_priv,
1315 "%s(): %pM, vid %d\n", __func__,
1316 claim->addr, claim->vid);
1318 batadv_handle_unclaim(bat_priv, primary_if,
1320 claim->addr, claim->vid);
1322 batadv_backbone_gw_put(backbone_gw);
1329 * batadv_bla_update_orig_address() - Update the backbone gateways when the own
1330 * originator address changes
1331 * @bat_priv: the bat priv with all the soft interface information
1332 * @primary_if: the new selected primary_if
1333 * @oldif: the old primary interface, may be NULL
1335 void batadv_bla_update_orig_address(struct batadv_priv *bat_priv,
1336 struct batadv_hard_iface *primary_if,
1337 struct batadv_hard_iface *oldif)
1339 struct batadv_bla_backbone_gw *backbone_gw;
1340 struct hlist_head *head;
1341 struct batadv_hashtable *hash;
1345 /* reset bridge loop avoidance group id */
1346 group = htons(crc16(0, primary_if->net_dev->dev_addr, ETH_ALEN));
1347 bat_priv->bla.claim_dest.group = group;
1349 /* purge everything when bridge loop avoidance is turned off */
1350 if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1354 batadv_bla_purge_claims(bat_priv, NULL, 1);
1355 batadv_bla_purge_backbone_gw(bat_priv, 1);
1359 hash = bat_priv->bla.backbone_hash;
1363 for (i = 0; i < hash->size; i++) {
1364 head = &hash->table[i];
1367 hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
1368 /* own orig still holds the old value. */
1369 if (!batadv_compare_eth(backbone_gw->orig,
1370 oldif->net_dev->dev_addr))
1373 ether_addr_copy(backbone_gw->orig,
1374 primary_if->net_dev->dev_addr);
1375 /* send an announce frame so others will ask for our
1376 * claims and update their tables.
1378 batadv_bla_send_announce(bat_priv, backbone_gw);
1385 * batadv_bla_send_loopdetect() - send a loopdetect frame
1386 * @bat_priv: the bat priv with all the soft interface information
1387 * @backbone_gw: the backbone gateway for which a loop should be detected
1389 * To detect loops that the bridge loop avoidance can't handle, send a loop
1390 * detection packet on the backbone. Unlike other BLA frames, this frame will
1391 * be allowed on the mesh by other nodes. If it is received on the mesh, this
1392 * indicates that there is a loop.
1395 batadv_bla_send_loopdetect(struct batadv_priv *bat_priv,
1396 struct batadv_bla_backbone_gw *backbone_gw)
1398 batadv_dbg(BATADV_DBG_BLA, bat_priv, "Send loopdetect frame for vid %d\n",
1400 batadv_bla_send_claim(bat_priv, bat_priv->bla.loopdetect_addr,
1401 backbone_gw->vid, BATADV_CLAIM_TYPE_LOOPDETECT);
1405 * batadv_bla_status_update() - purge bla interfaces if necessary
1406 * @net_dev: the soft interface net device
1408 void batadv_bla_status_update(struct net_device *net_dev)
1410 struct batadv_priv *bat_priv = netdev_priv(net_dev);
1411 struct batadv_hard_iface *primary_if;
1413 primary_if = batadv_primary_if_get_selected(bat_priv);
1417 /* this function already purges everything when bla is disabled,
1418 * so just call that one.
1420 batadv_bla_update_orig_address(bat_priv, primary_if, primary_if);
1421 batadv_hardif_put(primary_if);
1425 * batadv_bla_periodic_work() - performs periodic bla work
1426 * @work: kernel work struct
1428 * periodic work to do:
1429 * * purge structures when they are too old
1430 * * send announcements
1432 static void batadv_bla_periodic_work(struct work_struct *work)
1434 struct delayed_work *delayed_work;
1435 struct batadv_priv *bat_priv;
1436 struct batadv_priv_bla *priv_bla;
1437 struct hlist_head *head;
1438 struct batadv_bla_backbone_gw *backbone_gw;
1439 struct batadv_hashtable *hash;
1440 struct batadv_hard_iface *primary_if;
1441 bool send_loopdetect = false;
1444 delayed_work = to_delayed_work(work);
1445 priv_bla = container_of(delayed_work, struct batadv_priv_bla, work);
1446 bat_priv = container_of(priv_bla, struct batadv_priv, bla);
1447 primary_if = batadv_primary_if_get_selected(bat_priv);
1451 batadv_bla_purge_claims(bat_priv, primary_if, 0);
1452 batadv_bla_purge_backbone_gw(bat_priv, 0);
1454 if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1457 if (atomic_dec_and_test(&bat_priv->bla.loopdetect_next)) {
1458 /* set a new random mac address for the next bridge loop
1459 * detection frames. Set the locally administered bit to avoid
1460 * collisions with users mac addresses.
1462 eth_random_addr(bat_priv->bla.loopdetect_addr);
1463 bat_priv->bla.loopdetect_addr[0] = 0xba;
1464 bat_priv->bla.loopdetect_addr[1] = 0xbe;
1465 bat_priv->bla.loopdetect_lasttime = jiffies;
1466 atomic_set(&bat_priv->bla.loopdetect_next,
1467 BATADV_BLA_LOOPDETECT_PERIODS);
1469 /* mark for sending loop detect on all VLANs */
1470 send_loopdetect = true;
1473 hash = bat_priv->bla.backbone_hash;
1477 for (i = 0; i < hash->size; i++) {
1478 head = &hash->table[i];
1481 hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
1482 if (!batadv_compare_eth(backbone_gw->orig,
1483 primary_if->net_dev->dev_addr))
1486 backbone_gw->lasttime = jiffies;
1488 batadv_bla_send_announce(bat_priv, backbone_gw);
1489 if (send_loopdetect)
1490 batadv_bla_send_loopdetect(bat_priv,
1493 /* request_sent is only set after creation to avoid
1494 * problems when we are not yet known as backbone gw
1497 * We can reset this now after we waited some periods
1498 * to give bridge forward delays and bla group forming
1502 if (atomic_read(&backbone_gw->request_sent) == 0)
1505 if (!atomic_dec_and_test(&backbone_gw->wait_periods))
1508 atomic_dec(&backbone_gw->bat_priv->bla.num_requests);
1509 atomic_set(&backbone_gw->request_sent, 0);
1515 batadv_hardif_put(primary_if);
1517 queue_delayed_work(batadv_event_workqueue, &bat_priv->bla.work,
1518 msecs_to_jiffies(BATADV_BLA_PERIOD_LENGTH));
1521 /* The hash for claim and backbone hash receive the same key because they
1522 * are getting initialized by hash_new with the same key. Reinitializing
1523 * them with to different keys to allow nested locking without generating
1526 static struct lock_class_key batadv_claim_hash_lock_class_key;
1527 static struct lock_class_key batadv_backbone_hash_lock_class_key;
1530 * batadv_bla_init() - initialize all bla structures
1531 * @bat_priv: the bat priv with all the soft interface information
1533 * Return: 0 on success, < 0 on error.
1535 int batadv_bla_init(struct batadv_priv *bat_priv)
1538 u8 claim_dest[ETH_ALEN] = {0xff, 0x43, 0x05, 0x00, 0x00, 0x00};
1539 struct batadv_hard_iface *primary_if;
1541 unsigned long entrytime;
1543 spin_lock_init(&bat_priv->bla.bcast_duplist_lock);
1545 batadv_dbg(BATADV_DBG_BLA, bat_priv, "bla hash registering\n");
1547 /* setting claim destination address */
1548 memcpy(&bat_priv->bla.claim_dest.magic, claim_dest, 3);
1549 bat_priv->bla.claim_dest.type = 0;
1550 primary_if = batadv_primary_if_get_selected(bat_priv);
1552 crc = crc16(0, primary_if->net_dev->dev_addr, ETH_ALEN);
1553 bat_priv->bla.claim_dest.group = htons(crc);
1554 batadv_hardif_put(primary_if);
1556 bat_priv->bla.claim_dest.group = 0; /* will be set later */
1559 /* initialize the duplicate list */
1560 entrytime = jiffies - msecs_to_jiffies(BATADV_DUPLIST_TIMEOUT);
1561 for (i = 0; i < BATADV_DUPLIST_SIZE; i++)
1562 bat_priv->bla.bcast_duplist[i].entrytime = entrytime;
1563 bat_priv->bla.bcast_duplist_curr = 0;
1565 atomic_set(&bat_priv->bla.loopdetect_next,
1566 BATADV_BLA_LOOPDETECT_PERIODS);
1568 if (bat_priv->bla.claim_hash)
1571 bat_priv->bla.claim_hash = batadv_hash_new(128);
1572 bat_priv->bla.backbone_hash = batadv_hash_new(32);
1574 if (!bat_priv->bla.claim_hash || !bat_priv->bla.backbone_hash)
1577 batadv_hash_set_lock_class(bat_priv->bla.claim_hash,
1578 &batadv_claim_hash_lock_class_key);
1579 batadv_hash_set_lock_class(bat_priv->bla.backbone_hash,
1580 &batadv_backbone_hash_lock_class_key);
1582 batadv_dbg(BATADV_DBG_BLA, bat_priv, "bla hashes initialized\n");
1584 INIT_DELAYED_WORK(&bat_priv->bla.work, batadv_bla_periodic_work);
1586 queue_delayed_work(batadv_event_workqueue, &bat_priv->bla.work,
1587 msecs_to_jiffies(BATADV_BLA_PERIOD_LENGTH));
1592 * batadv_bla_check_bcast_duplist() - Check if a frame is in the broadcast dup.
1593 * @bat_priv: the bat priv with all the soft interface information
1594 * @skb: contains the bcast_packet to be checked
1596 * check if it is on our broadcast list. Another gateway might
1597 * have sent the same packet because it is connected to the same backbone,
1598 * so we have to remove this duplicate.
1600 * This is performed by checking the CRC, which will tell us
1601 * with a good chance that it is the same packet. If it is furthermore
1602 * sent by another host, drop it. We allow equal packets from
1603 * the same host however as this might be intended.
1605 * Return: true if a packet is in the duplicate list, false otherwise.
1607 bool batadv_bla_check_bcast_duplist(struct batadv_priv *bat_priv,
1608 struct sk_buff *skb)
1612 struct batadv_bcast_packet *bcast_packet;
1613 struct batadv_bcast_duplist_entry *entry;
1616 bcast_packet = (struct batadv_bcast_packet *)skb->data;
1618 /* calculate the crc ... */
1619 crc = batadv_skb_crc32(skb, (u8 *)(bcast_packet + 1));
1621 spin_lock_bh(&bat_priv->bla.bcast_duplist_lock);
1623 for (i = 0; i < BATADV_DUPLIST_SIZE; i++) {
1624 curr = (bat_priv->bla.bcast_duplist_curr + i);
1625 curr %= BATADV_DUPLIST_SIZE;
1626 entry = &bat_priv->bla.bcast_duplist[curr];
1628 /* we can stop searching if the entry is too old ;
1629 * later entries will be even older
1631 if (batadv_has_timed_out(entry->entrytime,
1632 BATADV_DUPLIST_TIMEOUT))
1635 if (entry->crc != crc)
1638 if (batadv_compare_eth(entry->orig, bcast_packet->orig))
1641 /* this entry seems to match: same crc, not too old,
1642 * and from another gw. therefore return true to forbid it.
1647 /* not found, add a new entry (overwrite the oldest entry)
1648 * and allow it, its the first occurrence.
1650 curr = (bat_priv->bla.bcast_duplist_curr + BATADV_DUPLIST_SIZE - 1);
1651 curr %= BATADV_DUPLIST_SIZE;
1652 entry = &bat_priv->bla.bcast_duplist[curr];
1654 entry->entrytime = jiffies;
1655 ether_addr_copy(entry->orig, bcast_packet->orig);
1656 bat_priv->bla.bcast_duplist_curr = curr;
1659 spin_unlock_bh(&bat_priv->bla.bcast_duplist_lock);
1665 * batadv_bla_is_backbone_gw_orig() - Check if the originator is a gateway for
1666 * the VLAN identified by vid.
1667 * @bat_priv: the bat priv with all the soft interface information
1668 * @orig: originator mac address
1669 * @vid: VLAN identifier
1671 * Return: true if orig is a backbone for this vid, false otherwise.
1673 bool batadv_bla_is_backbone_gw_orig(struct batadv_priv *bat_priv, u8 *orig,
1676 struct batadv_hashtable *hash = bat_priv->bla.backbone_hash;
1677 struct hlist_head *head;
1678 struct batadv_bla_backbone_gw *backbone_gw;
1681 if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1687 for (i = 0; i < hash->size; i++) {
1688 head = &hash->table[i];
1691 hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
1692 if (batadv_compare_eth(backbone_gw->orig, orig) &&
1693 backbone_gw->vid == vid) {
1705 * batadv_bla_is_backbone_gw() - check if originator is a backbone gw for a VLAN
1706 * @skb: the frame to be checked
1707 * @orig_node: the orig_node of the frame
1708 * @hdr_size: maximum length of the frame
1710 * Return: true if the orig_node is also a gateway on the soft interface,
1711 * otherwise it returns false.
1713 bool batadv_bla_is_backbone_gw(struct sk_buff *skb,
1714 struct batadv_orig_node *orig_node, int hdr_size)
1716 struct batadv_bla_backbone_gw *backbone_gw;
1719 if (!atomic_read(&orig_node->bat_priv->bridge_loop_avoidance))
1722 /* first, find out the vid. */
1723 if (!pskb_may_pull(skb, hdr_size + ETH_HLEN))
1726 vid = batadv_get_vid(skb, hdr_size);
1728 /* see if this originator is a backbone gw for this VLAN */
1729 backbone_gw = batadv_backbone_hash_find(orig_node->bat_priv,
1730 orig_node->orig, vid);
1734 batadv_backbone_gw_put(backbone_gw);
1739 * batadv_bla_free() - free all bla structures
1740 * @bat_priv: the bat priv with all the soft interface information
1742 * for softinterface free or module unload
1744 void batadv_bla_free(struct batadv_priv *bat_priv)
1746 struct batadv_hard_iface *primary_if;
1748 cancel_delayed_work_sync(&bat_priv->bla.work);
1749 primary_if = batadv_primary_if_get_selected(bat_priv);
1751 if (bat_priv->bla.claim_hash) {
1752 batadv_bla_purge_claims(bat_priv, primary_if, 1);
1753 batadv_hash_destroy(bat_priv->bla.claim_hash);
1754 bat_priv->bla.claim_hash = NULL;
1756 if (bat_priv->bla.backbone_hash) {
1757 batadv_bla_purge_backbone_gw(bat_priv, 1);
1758 batadv_hash_destroy(bat_priv->bla.backbone_hash);
1759 bat_priv->bla.backbone_hash = NULL;
1762 batadv_hardif_put(primary_if);
1766 * batadv_bla_loopdetect_check() - check and handle a detected loop
1767 * @bat_priv: the bat priv with all the soft interface information
1768 * @skb: the packet to check
1769 * @primary_if: interface where the request came on
1770 * @vid: the VLAN ID of the frame
1772 * Checks if this packet is a loop detect frame which has been sent by us,
1773 * throw an uevent and log the event if that is the case.
1775 * Return: true if it is a loop detect frame which is to be dropped, false
1779 batadv_bla_loopdetect_check(struct batadv_priv *bat_priv, struct sk_buff *skb,
1780 struct batadv_hard_iface *primary_if,
1783 struct batadv_bla_backbone_gw *backbone_gw;
1784 struct ethhdr *ethhdr;
1787 ethhdr = eth_hdr(skb);
1789 /* Only check for the MAC address and skip more checks here for
1790 * performance reasons - this function is on the hotpath, after all.
1792 if (!batadv_compare_eth(ethhdr->h_source,
1793 bat_priv->bla.loopdetect_addr))
1796 /* If the packet came too late, don't forward it on the mesh
1797 * but don't consider that as loop. It might be a coincidence.
1799 if (batadv_has_timed_out(bat_priv->bla.loopdetect_lasttime,
1800 BATADV_BLA_LOOPDETECT_TIMEOUT))
1803 backbone_gw = batadv_bla_get_backbone_gw(bat_priv,
1804 primary_if->net_dev->dev_addr,
1806 if (unlikely(!backbone_gw))
1809 ret = queue_work(batadv_event_workqueue, &backbone_gw->report_work);
1811 /* backbone_gw is unreferenced in the report work function function
1812 * if queue_work() call was successful
1815 batadv_backbone_gw_put(backbone_gw);
1821 * batadv_bla_rx() - check packets coming from the mesh.
1822 * @bat_priv: the bat priv with all the soft interface information
1823 * @skb: the frame to be checked
1824 * @vid: the VLAN ID of the frame
1825 * @is_bcast: the packet came in a broadcast packet type.
1827 * batadv_bla_rx avoidance checks if:
1828 * * we have to race for a claim
1829 * * if the frame is allowed on the LAN
1831 * in these cases, the skb is further handled by this function
1833 * Return: true if handled, otherwise it returns false and the caller shall
1834 * further process the skb.
1836 bool batadv_bla_rx(struct batadv_priv *bat_priv, struct sk_buff *skb,
1837 unsigned short vid, bool is_bcast)
1839 struct batadv_bla_backbone_gw *backbone_gw;
1840 struct ethhdr *ethhdr;
1841 struct batadv_bla_claim search_claim, *claim = NULL;
1842 struct batadv_hard_iface *primary_if;
1846 ethhdr = eth_hdr(skb);
1848 primary_if = batadv_primary_if_get_selected(bat_priv);
1852 if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1855 if (batadv_bla_loopdetect_check(bat_priv, skb, primary_if, vid))
1858 if (unlikely(atomic_read(&bat_priv->bla.num_requests)))
1859 /* don't allow broadcasts while requests are in flight */
1860 if (is_multicast_ether_addr(ethhdr->h_dest) && is_bcast)
1863 ether_addr_copy(search_claim.addr, ethhdr->h_source);
1864 search_claim.vid = vid;
1865 claim = batadv_claim_hash_find(bat_priv, &search_claim);
1868 /* possible optimization: race for a claim */
1869 /* No claim exists yet, claim it for us!
1872 batadv_dbg(BATADV_DBG_BLA, bat_priv,
1873 "%s(): Unclaimed MAC %pM found. Claim it. Local: %s\n",
1874 __func__, ethhdr->h_source,
1875 batadv_is_my_client(bat_priv,
1876 ethhdr->h_source, vid) ?
1878 batadv_handle_claim(bat_priv, primary_if,
1879 primary_if->net_dev->dev_addr,
1880 ethhdr->h_source, vid);
1884 /* if it is our own claim ... */
1885 backbone_gw = batadv_bla_claim_get_backbone_gw(claim);
1886 own_claim = batadv_compare_eth(backbone_gw->orig,
1887 primary_if->net_dev->dev_addr);
1888 batadv_backbone_gw_put(backbone_gw);
1891 /* ... allow it in any case */
1892 claim->lasttime = jiffies;
1896 /* if it is a broadcast ... */
1897 if (is_multicast_ether_addr(ethhdr->h_dest) && is_bcast) {
1898 /* ... drop it. the responsible gateway is in charge.
1900 * We need to check is_bcast because with the gateway
1901 * feature, broadcasts (like DHCP requests) may be sent
1902 * using a unicast packet type.
1906 /* seems the client considers us as its best gateway.
1907 * send a claim and update the claim table
1910 batadv_handle_claim(bat_priv, primary_if,
1911 primary_if->net_dev->dev_addr,
1912 ethhdr->h_source, vid);
1916 batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
1926 batadv_hardif_put(primary_if);
1928 batadv_claim_put(claim);
1933 * batadv_bla_tx() - check packets going into the mesh
1934 * @bat_priv: the bat priv with all the soft interface information
1935 * @skb: the frame to be checked
1936 * @vid: the VLAN ID of the frame
1938 * batadv_bla_tx checks if:
1939 * * a claim was received which has to be processed
1940 * * the frame is allowed on the mesh
1942 * in these cases, the skb is further handled by this function.
1944 * This call might reallocate skb data.
1946 * Return: true if handled, otherwise it returns false and the caller shall
1947 * further process the skb.
1949 bool batadv_bla_tx(struct batadv_priv *bat_priv, struct sk_buff *skb,
1952 struct ethhdr *ethhdr;
1953 struct batadv_bla_claim search_claim, *claim = NULL;
1954 struct batadv_bla_backbone_gw *backbone_gw;
1955 struct batadv_hard_iface *primary_if;
1959 primary_if = batadv_primary_if_get_selected(bat_priv);
1963 if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1966 if (batadv_bla_process_claim(bat_priv, primary_if, skb))
1969 ethhdr = eth_hdr(skb);
1971 if (unlikely(atomic_read(&bat_priv->bla.num_requests)))
1972 /* don't allow broadcasts while requests are in flight */
1973 if (is_multicast_ether_addr(ethhdr->h_dest))
1976 ether_addr_copy(search_claim.addr, ethhdr->h_source);
1977 search_claim.vid = vid;
1979 claim = batadv_claim_hash_find(bat_priv, &search_claim);
1981 /* if no claim exists, allow it. */
1985 /* check if we are responsible. */
1986 backbone_gw = batadv_bla_claim_get_backbone_gw(claim);
1987 client_roamed = batadv_compare_eth(backbone_gw->orig,
1988 primary_if->net_dev->dev_addr);
1989 batadv_backbone_gw_put(backbone_gw);
1991 if (client_roamed) {
1992 /* if yes, the client has roamed and we have
1995 if (batadv_has_timed_out(claim->lasttime, 100)) {
1996 /* only unclaim if the last claim entry is
1997 * older than 100 ms to make sure we really
1998 * have a roaming client here.
2000 batadv_dbg(BATADV_DBG_BLA, bat_priv, "%s(): Roaming client %pM detected. Unclaim it.\n",
2001 __func__, ethhdr->h_source);
2002 batadv_handle_unclaim(bat_priv, primary_if,
2003 primary_if->net_dev->dev_addr,
2004 ethhdr->h_source, vid);
2007 batadv_dbg(BATADV_DBG_BLA, bat_priv, "%s(): Race for claim %pM detected. Drop packet.\n",
2008 __func__, ethhdr->h_source);
2013 /* check if it is a multicast/broadcast frame */
2014 if (is_multicast_ether_addr(ethhdr->h_dest)) {
2015 /* drop it. the responsible gateway has forwarded it into
2016 * the backbone network.
2020 /* we must allow it. at least if we are
2021 * responsible for the DESTINATION.
2026 batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
2033 batadv_hardif_put(primary_if);
2035 batadv_claim_put(claim);
2039 #ifdef CONFIG_BATMAN_ADV_DEBUGFS
2041 * batadv_bla_claim_table_seq_print_text() - print the claim table in a seq file
2042 * @seq: seq file to print on
2047 int batadv_bla_claim_table_seq_print_text(struct seq_file *seq, void *offset)
2049 struct net_device *net_dev = (struct net_device *)seq->private;
2050 struct batadv_priv *bat_priv = netdev_priv(net_dev);
2051 struct batadv_hashtable *hash = bat_priv->bla.claim_hash;
2052 struct batadv_bla_backbone_gw *backbone_gw;
2053 struct batadv_bla_claim *claim;
2054 struct batadv_hard_iface *primary_if;
2055 struct hlist_head *head;
2061 primary_if = batadv_seq_print_text_primary_if_get(seq);
2065 primary_addr = primary_if->net_dev->dev_addr;
2067 "Claims announced for the mesh %s (orig %pM, group id %#.4x)\n",
2068 net_dev->name, primary_addr,
2069 ntohs(bat_priv->bla.claim_dest.group));
2071 " Client VID Originator [o] (CRC )\n");
2072 for (i = 0; i < hash->size; i++) {
2073 head = &hash->table[i];
2076 hlist_for_each_entry_rcu(claim, head, hash_entry) {
2077 backbone_gw = batadv_bla_claim_get_backbone_gw(claim);
2079 is_own = batadv_compare_eth(backbone_gw->orig,
2082 spin_lock_bh(&backbone_gw->crc_lock);
2083 backbone_crc = backbone_gw->crc;
2084 spin_unlock_bh(&backbone_gw->crc_lock);
2085 seq_printf(seq, " * %pM on %5d by %pM [%c] (%#.4x)\n",
2086 claim->addr, batadv_print_vid(claim->vid),
2088 (is_own ? 'x' : ' '),
2091 batadv_backbone_gw_put(backbone_gw);
2097 batadv_hardif_put(primary_if);
2103 * batadv_bla_claim_dump_entry() - dump one entry of the claim table
2104 * to a netlink socket
2105 * @msg: buffer for the message
2106 * @portid: netlink port
2107 * @cb: Control block containing additional options
2108 * @primary_if: primary interface
2109 * @claim: entry to dump
2111 * Return: 0 or error code.
2114 batadv_bla_claim_dump_entry(struct sk_buff *msg, u32 portid,
2115 struct netlink_callback *cb,
2116 struct batadv_hard_iface *primary_if,
2117 struct batadv_bla_claim *claim)
2119 u8 *primary_addr = primary_if->net_dev->dev_addr;
2125 hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq,
2126 &batadv_netlink_family, NLM_F_MULTI,
2127 BATADV_CMD_GET_BLA_CLAIM);
2133 genl_dump_check_consistent(cb, hdr);
2135 is_own = batadv_compare_eth(claim->backbone_gw->orig,
2138 spin_lock_bh(&claim->backbone_gw->crc_lock);
2139 backbone_crc = claim->backbone_gw->crc;
2140 spin_unlock_bh(&claim->backbone_gw->crc_lock);
2143 if (nla_put_flag(msg, BATADV_ATTR_BLA_OWN)) {
2144 genlmsg_cancel(msg, hdr);
2148 if (nla_put(msg, BATADV_ATTR_BLA_ADDRESS, ETH_ALEN, claim->addr) ||
2149 nla_put_u16(msg, BATADV_ATTR_BLA_VID, claim->vid) ||
2150 nla_put(msg, BATADV_ATTR_BLA_BACKBONE, ETH_ALEN,
2151 claim->backbone_gw->orig) ||
2152 nla_put_u16(msg, BATADV_ATTR_BLA_CRC,
2154 genlmsg_cancel(msg, hdr);
2158 genlmsg_end(msg, hdr);
2166 * batadv_bla_claim_dump_bucket() - dump one bucket of the claim table
2167 * to a netlink socket
2168 * @msg: buffer for the message
2169 * @portid: netlink port
2170 * @cb: Control block containing additional options
2171 * @primary_if: primary interface
2172 * @hash: hash to dump
2173 * @bucket: bucket index to dump
2174 * @idx_skip: How many entries to skip
2179 batadv_bla_claim_dump_bucket(struct sk_buff *msg, u32 portid,
2180 struct netlink_callback *cb,
2181 struct batadv_hard_iface *primary_if,
2182 struct batadv_hashtable *hash, unsigned int bucket,
2185 struct batadv_bla_claim *claim;
2189 spin_lock_bh(&hash->list_locks[bucket]);
2190 cb->seq = atomic_read(&hash->generation) << 1 | 1;
2192 hlist_for_each_entry(claim, &hash->table[bucket], hash_entry) {
2193 if (idx++ < *idx_skip)
2196 ret = batadv_bla_claim_dump_entry(msg, portid, cb,
2199 *idx_skip = idx - 1;
2206 spin_unlock_bh(&hash->list_locks[bucket]);
2211 * batadv_bla_claim_dump() - dump claim table to a netlink socket
2212 * @msg: buffer for the message
2213 * @cb: callback structure containing arguments
2215 * Return: message length.
2217 int batadv_bla_claim_dump(struct sk_buff *msg, struct netlink_callback *cb)
2219 struct batadv_hard_iface *primary_if = NULL;
2220 int portid = NETLINK_CB(cb->skb).portid;
2221 struct net *net = sock_net(cb->skb->sk);
2222 struct net_device *soft_iface;
2223 struct batadv_hashtable *hash;
2224 struct batadv_priv *bat_priv;
2225 int bucket = cb->args[0];
2226 int idx = cb->args[1];
2230 ifindex = batadv_netlink_get_ifindex(cb->nlh,
2231 BATADV_ATTR_MESH_IFINDEX);
2235 soft_iface = dev_get_by_index(net, ifindex);
2236 if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
2241 bat_priv = netdev_priv(soft_iface);
2242 hash = bat_priv->bla.claim_hash;
2244 primary_if = batadv_primary_if_get_selected(bat_priv);
2245 if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
2250 while (bucket < hash->size) {
2251 if (batadv_bla_claim_dump_bucket(msg, portid, cb, primary_if,
2252 hash, bucket, &idx))
2257 cb->args[0] = bucket;
2264 batadv_hardif_put(primary_if);
2267 dev_put(soft_iface);
2272 #ifdef CONFIG_BATMAN_ADV_DEBUGFS
2274 * batadv_bla_backbone_table_seq_print_text() - print the backbone table in a
2276 * @seq: seq file to print on
2281 int batadv_bla_backbone_table_seq_print_text(struct seq_file *seq, void *offset)
2283 struct net_device *net_dev = (struct net_device *)seq->private;
2284 struct batadv_priv *bat_priv = netdev_priv(net_dev);
2285 struct batadv_hashtable *hash = bat_priv->bla.backbone_hash;
2286 struct batadv_bla_backbone_gw *backbone_gw;
2287 struct batadv_hard_iface *primary_if;
2288 struct hlist_head *head;
2295 primary_if = batadv_seq_print_text_primary_if_get(seq);
2299 primary_addr = primary_if->net_dev->dev_addr;
2301 "Backbones announced for the mesh %s (orig %pM, group id %#.4x)\n",
2302 net_dev->name, primary_addr,
2303 ntohs(bat_priv->bla.claim_dest.group));
2304 seq_puts(seq, " Originator VID last seen (CRC )\n");
2305 for (i = 0; i < hash->size; i++) {
2306 head = &hash->table[i];
2309 hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
2310 msecs = jiffies_to_msecs(jiffies -
2311 backbone_gw->lasttime);
2312 secs = msecs / 1000;
2313 msecs = msecs % 1000;
2315 is_own = batadv_compare_eth(backbone_gw->orig,
2320 spin_lock_bh(&backbone_gw->crc_lock);
2321 backbone_crc = backbone_gw->crc;
2322 spin_unlock_bh(&backbone_gw->crc_lock);
2324 seq_printf(seq, " * %pM on %5d %4i.%03is (%#.4x)\n",
2326 batadv_print_vid(backbone_gw->vid), secs,
2327 msecs, backbone_crc);
2333 batadv_hardif_put(primary_if);
2339 * batadv_bla_backbone_dump_entry() - dump one entry of the backbone table to a
2341 * @msg: buffer for the message
2342 * @portid: netlink port
2343 * @cb: Control block containing additional options
2344 * @primary_if: primary interface
2345 * @backbone_gw: entry to dump
2347 * Return: 0 or error code.
2350 batadv_bla_backbone_dump_entry(struct sk_buff *msg, u32 portid,
2351 struct netlink_callback *cb,
2352 struct batadv_hard_iface *primary_if,
2353 struct batadv_bla_backbone_gw *backbone_gw)
2355 u8 *primary_addr = primary_if->net_dev->dev_addr;
2362 hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq,
2363 &batadv_netlink_family, NLM_F_MULTI,
2364 BATADV_CMD_GET_BLA_BACKBONE);
2370 genl_dump_check_consistent(cb, hdr);
2372 is_own = batadv_compare_eth(backbone_gw->orig, primary_addr);
2374 spin_lock_bh(&backbone_gw->crc_lock);
2375 backbone_crc = backbone_gw->crc;
2376 spin_unlock_bh(&backbone_gw->crc_lock);
2378 msecs = jiffies_to_msecs(jiffies - backbone_gw->lasttime);
2381 if (nla_put_flag(msg, BATADV_ATTR_BLA_OWN)) {
2382 genlmsg_cancel(msg, hdr);
2386 if (nla_put(msg, BATADV_ATTR_BLA_BACKBONE, ETH_ALEN,
2387 backbone_gw->orig) ||
2388 nla_put_u16(msg, BATADV_ATTR_BLA_VID, backbone_gw->vid) ||
2389 nla_put_u16(msg, BATADV_ATTR_BLA_CRC,
2391 nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS, msecs)) {
2392 genlmsg_cancel(msg, hdr);
2396 genlmsg_end(msg, hdr);
2404 * batadv_bla_backbone_dump_bucket() - dump one bucket of the backbone table to
2406 * @msg: buffer for the message
2407 * @portid: netlink port
2408 * @cb: Control block containing additional options
2409 * @primary_if: primary interface
2410 * @hash: hash to dump
2411 * @bucket: bucket index to dump
2412 * @idx_skip: How many entries to skip
2417 batadv_bla_backbone_dump_bucket(struct sk_buff *msg, u32 portid,
2418 struct netlink_callback *cb,
2419 struct batadv_hard_iface *primary_if,
2420 struct batadv_hashtable *hash,
2421 unsigned int bucket, int *idx_skip)
2423 struct batadv_bla_backbone_gw *backbone_gw;
2427 spin_lock_bh(&hash->list_locks[bucket]);
2428 cb->seq = atomic_read(&hash->generation) << 1 | 1;
2430 hlist_for_each_entry(backbone_gw, &hash->table[bucket], hash_entry) {
2431 if (idx++ < *idx_skip)
2434 ret = batadv_bla_backbone_dump_entry(msg, portid, cb,
2435 primary_if, backbone_gw);
2437 *idx_skip = idx - 1;
2444 spin_unlock_bh(&hash->list_locks[bucket]);
2449 * batadv_bla_backbone_dump() - dump backbone table to a netlink socket
2450 * @msg: buffer for the message
2451 * @cb: callback structure containing arguments
2453 * Return: message length.
2455 int batadv_bla_backbone_dump(struct sk_buff *msg, struct netlink_callback *cb)
2457 struct batadv_hard_iface *primary_if = NULL;
2458 int portid = NETLINK_CB(cb->skb).portid;
2459 struct net *net = sock_net(cb->skb->sk);
2460 struct net_device *soft_iface;
2461 struct batadv_hashtable *hash;
2462 struct batadv_priv *bat_priv;
2463 int bucket = cb->args[0];
2464 int idx = cb->args[1];
2468 ifindex = batadv_netlink_get_ifindex(cb->nlh,
2469 BATADV_ATTR_MESH_IFINDEX);
2473 soft_iface = dev_get_by_index(net, ifindex);
2474 if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
2479 bat_priv = netdev_priv(soft_iface);
2480 hash = bat_priv->bla.backbone_hash;
2482 primary_if = batadv_primary_if_get_selected(bat_priv);
2483 if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
2488 while (bucket < hash->size) {
2489 if (batadv_bla_backbone_dump_bucket(msg, portid, cb, primary_if,
2490 hash, bucket, &idx))
2495 cb->args[0] = bucket;
2502 batadv_hardif_put(primary_if);
2505 dev_put(soft_iface);
2510 #ifdef CONFIG_BATMAN_ADV_DAT
2512 * batadv_bla_check_claim() - check if address is claimed
2514 * @bat_priv: the bat priv with all the soft interface information
2515 * @addr: mac address of which the claim status is checked
2518 * addr is checked if this address is claimed by the local device itself.
2520 * Return: true if bla is disabled or the mac is claimed by the device,
2521 * false if the device addr is already claimed by another gateway
2523 bool batadv_bla_check_claim(struct batadv_priv *bat_priv,
2524 u8 *addr, unsigned short vid)
2526 struct batadv_bla_claim search_claim;
2527 struct batadv_bla_claim *claim = NULL;
2528 struct batadv_hard_iface *primary_if = NULL;
2531 if (!atomic_read(&bat_priv->bridge_loop_avoidance))
2534 primary_if = batadv_primary_if_get_selected(bat_priv);
2538 /* First look if the mac address is claimed */
2539 ether_addr_copy(search_claim.addr, addr);
2540 search_claim.vid = vid;
2542 claim = batadv_claim_hash_find(bat_priv, &search_claim);
2544 /* If there is a claim and we are not owner of the claim,
2548 if (!batadv_compare_eth(claim->backbone_gw->orig,
2549 primary_if->net_dev->dev_addr))
2551 batadv_claim_put(claim);
2554 batadv_hardif_put(primary_if);