1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (C) 2007-2018 B.A.T.M.A.N. contributors: 3 * 4 * Marek Lindner, Simon Wunderlich, Antonio Quartulli 5 * 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. 9 * 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. 14 * 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/>. 17 */ 18 19 #include "translation-table.h" 20 #include "main.h" 21 22 #include <linux/atomic.h> 23 #include <linux/bitops.h> 24 #include <linux/build_bug.h> 25 #include <linux/byteorder/generic.h> 26 #include <linux/cache.h> 27 #include <linux/compiler.h> 28 #include <linux/crc32c.h> 29 #include <linux/errno.h> 30 #include <linux/etherdevice.h> 31 #include <linux/gfp.h> 32 #include <linux/if_ether.h> 33 #include <linux/init.h> 34 #include <linux/jhash.h> 35 #include <linux/jiffies.h> 36 #include <linux/kernel.h> 37 #include <linux/kref.h> 38 #include <linux/list.h> 39 #include <linux/lockdep.h> 40 #include <linux/net.h> 41 #include <linux/netdevice.h> 42 #include <linux/netlink.h> 43 #include <linux/rculist.h> 44 #include <linux/rcupdate.h> 45 #include <linux/seq_file.h> 46 #include <linux/skbuff.h> 47 #include <linux/slab.h> 48 #include <linux/spinlock.h> 49 #include <linux/stddef.h> 50 #include <linux/string.h> 51 #include <linux/workqueue.h> 52 #include <net/genetlink.h> 53 #include <net/netlink.h> 54 #include <net/sock.h> 55 #include <uapi/linux/batadv_packet.h> 56 #include <uapi/linux/batman_adv.h> 57 58 #include "bridge_loop_avoidance.h" 59 #include "hard-interface.h" 60 #include "hash.h" 61 #include "log.h" 62 #include "netlink.h" 63 #include "originator.h" 64 #include "soft-interface.h" 65 #include "tvlv.h" 66 67 static struct kmem_cache *batadv_tl_cache __read_mostly; 68 static struct kmem_cache *batadv_tg_cache __read_mostly; 69 static struct kmem_cache *batadv_tt_orig_cache __read_mostly; 70 static struct kmem_cache *batadv_tt_change_cache __read_mostly; 71 static struct kmem_cache *batadv_tt_req_cache __read_mostly; 72 static struct kmem_cache *batadv_tt_roam_cache __read_mostly; 73 74 /* hash class keys */ 75 static struct lock_class_key batadv_tt_local_hash_lock_class_key; 76 static struct lock_class_key batadv_tt_global_hash_lock_class_key; 77 78 static void batadv_send_roam_adv(struct batadv_priv *bat_priv, u8 *client, 79 unsigned short vid, 80 struct batadv_orig_node *orig_node); 81 static void batadv_tt_purge(struct work_struct *work); 82 static void 83 batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry); 84 static void batadv_tt_global_del(struct batadv_priv *bat_priv, 85 struct batadv_orig_node *orig_node, 86 const unsigned char *addr, 87 unsigned short vid, const char *message, 88 bool roaming); 89 90 /** 91 * batadv_compare_tt() - check if two TT entries are the same 92 * @node: the list element pointer of the first TT entry 93 * @data2: pointer to the tt_common_entry of the second TT entry 94 * 95 * Compare the MAC address and the VLAN ID of the two TT entries and check if 96 * they are the same TT client. 97 * Return: true if the two TT clients are the same, false otherwise 98 */ 99 static bool batadv_compare_tt(const struct hlist_node *node, const void *data2) 100 { 101 const void *data1 = container_of(node, struct batadv_tt_common_entry, 102 hash_entry); 103 const struct batadv_tt_common_entry *tt1 = data1; 104 const struct batadv_tt_common_entry *tt2 = data2; 105 106 return (tt1->vid == tt2->vid) && batadv_compare_eth(data1, data2); 107 } 108 109 /** 110 * batadv_choose_tt() - return the index of the tt entry in the hash table 111 * @data: pointer to the tt_common_entry object to map 112 * @size: the size of the hash table 113 * 114 * Return: the hash index where the object represented by 'data' should be 115 * stored at. 116 */ 117 static inline u32 batadv_choose_tt(const void *data, u32 size) 118 { 119 struct batadv_tt_common_entry *tt; 120 u32 hash = 0; 121 122 tt = (struct batadv_tt_common_entry *)data; 123 hash = jhash(&tt->addr, ETH_ALEN, hash); 124 hash = jhash(&tt->vid, sizeof(tt->vid), hash); 125 126 return hash % size; 127 } 128 129 /** 130 * batadv_tt_hash_find() - look for a client in the given hash table 131 * @hash: the hash table to search 132 * @addr: the mac address of the client to look for 133 * @vid: VLAN identifier 134 * 135 * Return: a pointer to the tt_common struct belonging to the searched client if 136 * found, NULL otherwise. 137 */ 138 static struct batadv_tt_common_entry * 139 batadv_tt_hash_find(struct batadv_hashtable *hash, const u8 *addr, 140 unsigned short vid) 141 { 142 struct hlist_head *head; 143 struct batadv_tt_common_entry to_search, *tt, *tt_tmp = NULL; 144 u32 index; 145 146 if (!hash) 147 return NULL; 148 149 ether_addr_copy(to_search.addr, addr); 150 to_search.vid = vid; 151 152 index = batadv_choose_tt(&to_search, hash->size); 153 head = &hash->table[index]; 154 155 rcu_read_lock(); 156 hlist_for_each_entry_rcu(tt, head, hash_entry) { 157 if (!batadv_compare_eth(tt, addr)) 158 continue; 159 160 if (tt->vid != vid) 161 continue; 162 163 if (!kref_get_unless_zero(&tt->refcount)) 164 continue; 165 166 tt_tmp = tt; 167 break; 168 } 169 rcu_read_unlock(); 170 171 return tt_tmp; 172 } 173 174 /** 175 * batadv_tt_local_hash_find() - search the local table for a given client 176 * @bat_priv: the bat priv with all the soft interface information 177 * @addr: the mac address of the client to look for 178 * @vid: VLAN identifier 179 * 180 * Return: a pointer to the corresponding tt_local_entry struct if the client is 181 * found, NULL otherwise. 182 */ 183 static struct batadv_tt_local_entry * 184 batadv_tt_local_hash_find(struct batadv_priv *bat_priv, const u8 *addr, 185 unsigned short vid) 186 { 187 struct batadv_tt_common_entry *tt_common_entry; 188 struct batadv_tt_local_entry *tt_local_entry = NULL; 189 190 tt_common_entry = batadv_tt_hash_find(bat_priv->tt.local_hash, addr, 191 vid); 192 if (tt_common_entry) 193 tt_local_entry = container_of(tt_common_entry, 194 struct batadv_tt_local_entry, 195 common); 196 return tt_local_entry; 197 } 198 199 /** 200 * batadv_tt_global_hash_find() - search the global table for a given client 201 * @bat_priv: the bat priv with all the soft interface information 202 * @addr: the mac address of the client to look for 203 * @vid: VLAN identifier 204 * 205 * Return: a pointer to the corresponding tt_global_entry struct if the client 206 * is found, NULL otherwise. 207 */ 208 static struct batadv_tt_global_entry * 209 batadv_tt_global_hash_find(struct batadv_priv *bat_priv, const u8 *addr, 210 unsigned short vid) 211 { 212 struct batadv_tt_common_entry *tt_common_entry; 213 struct batadv_tt_global_entry *tt_global_entry = NULL; 214 215 tt_common_entry = batadv_tt_hash_find(bat_priv->tt.global_hash, addr, 216 vid); 217 if (tt_common_entry) 218 tt_global_entry = container_of(tt_common_entry, 219 struct batadv_tt_global_entry, 220 common); 221 return tt_global_entry; 222 } 223 224 /** 225 * batadv_tt_local_entry_free_rcu() - free the tt_local_entry 226 * @rcu: rcu pointer of the tt_local_entry 227 */ 228 static void batadv_tt_local_entry_free_rcu(struct rcu_head *rcu) 229 { 230 struct batadv_tt_local_entry *tt_local_entry; 231 232 tt_local_entry = container_of(rcu, struct batadv_tt_local_entry, 233 common.rcu); 234 235 kmem_cache_free(batadv_tl_cache, tt_local_entry); 236 } 237 238 /** 239 * batadv_tt_local_entry_release() - release tt_local_entry from lists and queue 240 * for free after rcu grace period 241 * @ref: kref pointer of the nc_node 242 */ 243 static void batadv_tt_local_entry_release(struct kref *ref) 244 { 245 struct batadv_tt_local_entry *tt_local_entry; 246 247 tt_local_entry = container_of(ref, struct batadv_tt_local_entry, 248 common.refcount); 249 250 batadv_softif_vlan_put(tt_local_entry->vlan); 251 252 call_rcu(&tt_local_entry->common.rcu, batadv_tt_local_entry_free_rcu); 253 } 254 255 /** 256 * batadv_tt_local_entry_put() - decrement the tt_local_entry refcounter and 257 * possibly release it 258 * @tt_local_entry: tt_local_entry to be free'd 259 */ 260 static void 261 batadv_tt_local_entry_put(struct batadv_tt_local_entry *tt_local_entry) 262 { 263 kref_put(&tt_local_entry->common.refcount, 264 batadv_tt_local_entry_release); 265 } 266 267 /** 268 * batadv_tt_global_entry_free_rcu() - free the tt_global_entry 269 * @rcu: rcu pointer of the tt_global_entry 270 */ 271 static void batadv_tt_global_entry_free_rcu(struct rcu_head *rcu) 272 { 273 struct batadv_tt_global_entry *tt_global_entry; 274 275 tt_global_entry = container_of(rcu, struct batadv_tt_global_entry, 276 common.rcu); 277 278 kmem_cache_free(batadv_tg_cache, tt_global_entry); 279 } 280 281 /** 282 * batadv_tt_global_entry_release() - release tt_global_entry from lists and 283 * queue for free after rcu grace period 284 * @ref: kref pointer of the nc_node 285 */ 286 static void batadv_tt_global_entry_release(struct kref *ref) 287 { 288 struct batadv_tt_global_entry *tt_global_entry; 289 290 tt_global_entry = container_of(ref, struct batadv_tt_global_entry, 291 common.refcount); 292 293 batadv_tt_global_del_orig_list(tt_global_entry); 294 295 call_rcu(&tt_global_entry->common.rcu, batadv_tt_global_entry_free_rcu); 296 } 297 298 /** 299 * batadv_tt_global_entry_put() - decrement the tt_global_entry refcounter and 300 * possibly release it 301 * @tt_global_entry: tt_global_entry to be free'd 302 */ 303 static void 304 batadv_tt_global_entry_put(struct batadv_tt_global_entry *tt_global_entry) 305 { 306 kref_put(&tt_global_entry->common.refcount, 307 batadv_tt_global_entry_release); 308 } 309 310 /** 311 * batadv_tt_global_hash_count() - count the number of orig entries 312 * @bat_priv: the bat priv with all the soft interface information 313 * @addr: the mac address of the client to count entries for 314 * @vid: VLAN identifier 315 * 316 * Return: the number of originators advertising the given address/data 317 * (excluding ourself). 318 */ 319 int batadv_tt_global_hash_count(struct batadv_priv *bat_priv, 320 const u8 *addr, unsigned short vid) 321 { 322 struct batadv_tt_global_entry *tt_global_entry; 323 int count; 324 325 tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid); 326 if (!tt_global_entry) 327 return 0; 328 329 count = atomic_read(&tt_global_entry->orig_list_count); 330 batadv_tt_global_entry_put(tt_global_entry); 331 332 return count; 333 } 334 335 /** 336 * batadv_tt_local_size_mod() - change the size by v of the local table 337 * identified by vid 338 * @bat_priv: the bat priv with all the soft interface information 339 * @vid: the VLAN identifier of the sub-table to change 340 * @v: the amount to sum to the local table size 341 */ 342 static void batadv_tt_local_size_mod(struct batadv_priv *bat_priv, 343 unsigned short vid, int v) 344 { 345 struct batadv_softif_vlan *vlan; 346 347 vlan = batadv_softif_vlan_get(bat_priv, vid); 348 if (!vlan) 349 return; 350 351 atomic_add(v, &vlan->tt.num_entries); 352 353 batadv_softif_vlan_put(vlan); 354 } 355 356 /** 357 * batadv_tt_local_size_inc() - increase by one the local table size for the 358 * given vid 359 * @bat_priv: the bat priv with all the soft interface information 360 * @vid: the VLAN identifier 361 */ 362 static void batadv_tt_local_size_inc(struct batadv_priv *bat_priv, 363 unsigned short vid) 364 { 365 batadv_tt_local_size_mod(bat_priv, vid, 1); 366 } 367 368 /** 369 * batadv_tt_local_size_dec() - decrease by one the local table size for the 370 * given vid 371 * @bat_priv: the bat priv with all the soft interface information 372 * @vid: the VLAN identifier 373 */ 374 static void batadv_tt_local_size_dec(struct batadv_priv *bat_priv, 375 unsigned short vid) 376 { 377 batadv_tt_local_size_mod(bat_priv, vid, -1); 378 } 379 380 /** 381 * batadv_tt_global_size_mod() - change the size by v of the global table 382 * for orig_node identified by vid 383 * @orig_node: the originator for which the table has to be modified 384 * @vid: the VLAN identifier 385 * @v: the amount to sum to the global table size 386 */ 387 static void batadv_tt_global_size_mod(struct batadv_orig_node *orig_node, 388 unsigned short vid, int v) 389 { 390 struct batadv_orig_node_vlan *vlan; 391 392 vlan = batadv_orig_node_vlan_new(orig_node, vid); 393 if (!vlan) 394 return; 395 396 if (atomic_add_return(v, &vlan->tt.num_entries) == 0) { 397 spin_lock_bh(&orig_node->vlan_list_lock); 398 if (!hlist_unhashed(&vlan->list)) { 399 hlist_del_init_rcu(&vlan->list); 400 batadv_orig_node_vlan_put(vlan); 401 } 402 spin_unlock_bh(&orig_node->vlan_list_lock); 403 } 404 405 batadv_orig_node_vlan_put(vlan); 406 } 407 408 /** 409 * batadv_tt_global_size_inc() - increase by one the global table size for the 410 * given vid 411 * @orig_node: the originator which global table size has to be decreased 412 * @vid: the vlan identifier 413 */ 414 static void batadv_tt_global_size_inc(struct batadv_orig_node *orig_node, 415 unsigned short vid) 416 { 417 batadv_tt_global_size_mod(orig_node, vid, 1); 418 } 419 420 /** 421 * batadv_tt_global_size_dec() - decrease by one the global table size for the 422 * given vid 423 * @orig_node: the originator which global table size has to be decreased 424 * @vid: the vlan identifier 425 */ 426 static void batadv_tt_global_size_dec(struct batadv_orig_node *orig_node, 427 unsigned short vid) 428 { 429 batadv_tt_global_size_mod(orig_node, vid, -1); 430 } 431 432 /** 433 * batadv_tt_orig_list_entry_free_rcu() - free the orig_entry 434 * @rcu: rcu pointer of the orig_entry 435 */ 436 static void batadv_tt_orig_list_entry_free_rcu(struct rcu_head *rcu) 437 { 438 struct batadv_tt_orig_list_entry *orig_entry; 439 440 orig_entry = container_of(rcu, struct batadv_tt_orig_list_entry, rcu); 441 442 kmem_cache_free(batadv_tt_orig_cache, orig_entry); 443 } 444 445 /** 446 * batadv_tt_orig_list_entry_release() - release tt orig entry from lists and 447 * queue for free after rcu grace period 448 * @ref: kref pointer of the tt orig entry 449 */ 450 static void batadv_tt_orig_list_entry_release(struct kref *ref) 451 { 452 struct batadv_tt_orig_list_entry *orig_entry; 453 454 orig_entry = container_of(ref, struct batadv_tt_orig_list_entry, 455 refcount); 456 457 batadv_orig_node_put(orig_entry->orig_node); 458 call_rcu(&orig_entry->rcu, batadv_tt_orig_list_entry_free_rcu); 459 } 460 461 /** 462 * batadv_tt_orig_list_entry_put() - decrement the tt orig entry refcounter and 463 * possibly release it 464 * @orig_entry: tt orig entry to be free'd 465 */ 466 static void 467 batadv_tt_orig_list_entry_put(struct batadv_tt_orig_list_entry *orig_entry) 468 { 469 kref_put(&orig_entry->refcount, batadv_tt_orig_list_entry_release); 470 } 471 472 /** 473 * batadv_tt_local_event() - store a local TT event (ADD/DEL) 474 * @bat_priv: the bat priv with all the soft interface information 475 * @tt_local_entry: the TT entry involved in the event 476 * @event_flags: flags to store in the event structure 477 */ 478 static void batadv_tt_local_event(struct batadv_priv *bat_priv, 479 struct batadv_tt_local_entry *tt_local_entry, 480 u8 event_flags) 481 { 482 struct batadv_tt_change_node *tt_change_node, *entry, *safe; 483 struct batadv_tt_common_entry *common = &tt_local_entry->common; 484 u8 flags = common->flags | event_flags; 485 bool event_removed = false; 486 bool del_op_requested, del_op_entry; 487 488 tt_change_node = kmem_cache_alloc(batadv_tt_change_cache, GFP_ATOMIC); 489 if (!tt_change_node) 490 return; 491 492 tt_change_node->change.flags = flags; 493 memset(tt_change_node->change.reserved, 0, 494 sizeof(tt_change_node->change.reserved)); 495 ether_addr_copy(tt_change_node->change.addr, common->addr); 496 tt_change_node->change.vid = htons(common->vid); 497 498 del_op_requested = flags & BATADV_TT_CLIENT_DEL; 499 500 /* check for ADD+DEL or DEL+ADD events */ 501 spin_lock_bh(&bat_priv->tt.changes_list_lock); 502 list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list, 503 list) { 504 if (!batadv_compare_eth(entry->change.addr, common->addr)) 505 continue; 506 507 /* DEL+ADD in the same orig interval have no effect and can be 508 * removed to avoid silly behaviour on the receiver side. The 509 * other way around (ADD+DEL) can happen in case of roaming of 510 * a client still in the NEW state. Roaming of NEW clients is 511 * now possible due to automatically recognition of "temporary" 512 * clients 513 */ 514 del_op_entry = entry->change.flags & BATADV_TT_CLIENT_DEL; 515 if (!del_op_requested && del_op_entry) 516 goto del; 517 if (del_op_requested && !del_op_entry) 518 goto del; 519 520 /* this is a second add in the same originator interval. It 521 * means that flags have been changed: update them! 522 */ 523 if (!del_op_requested && !del_op_entry) 524 entry->change.flags = flags; 525 526 continue; 527 del: 528 list_del(&entry->list); 529 kmem_cache_free(batadv_tt_change_cache, entry); 530 kmem_cache_free(batadv_tt_change_cache, tt_change_node); 531 event_removed = true; 532 goto unlock; 533 } 534 535 /* track the change in the OGMinterval list */ 536 list_add_tail(&tt_change_node->list, &bat_priv->tt.changes_list); 537 538 unlock: 539 spin_unlock_bh(&bat_priv->tt.changes_list_lock); 540 541 if (event_removed) 542 atomic_dec(&bat_priv->tt.local_changes); 543 else 544 atomic_inc(&bat_priv->tt.local_changes); 545 } 546 547 /** 548 * batadv_tt_len() - compute length in bytes of given number of tt changes 549 * @changes_num: number of tt changes 550 * 551 * Return: computed length in bytes. 552 */ 553 static int batadv_tt_len(int changes_num) 554 { 555 return changes_num * sizeof(struct batadv_tvlv_tt_change); 556 } 557 558 /** 559 * batadv_tt_entries() - compute the number of entries fitting in tt_len bytes 560 * @tt_len: available space 561 * 562 * Return: the number of entries. 563 */ 564 static u16 batadv_tt_entries(u16 tt_len) 565 { 566 return tt_len / batadv_tt_len(1); 567 } 568 569 /** 570 * batadv_tt_local_table_transmit_size() - calculates the local translation 571 * table size when transmitted over the air 572 * @bat_priv: the bat priv with all the soft interface information 573 * 574 * Return: local translation table size in bytes. 575 */ 576 static int batadv_tt_local_table_transmit_size(struct batadv_priv *bat_priv) 577 { 578 u16 num_vlan = 0; 579 u16 tt_local_entries = 0; 580 struct batadv_softif_vlan *vlan; 581 int hdr_size; 582 583 rcu_read_lock(); 584 hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) { 585 num_vlan++; 586 tt_local_entries += atomic_read(&vlan->tt.num_entries); 587 } 588 rcu_read_unlock(); 589 590 /* header size of tvlv encapsulated tt response payload */ 591 hdr_size = sizeof(struct batadv_unicast_tvlv_packet); 592 hdr_size += sizeof(struct batadv_tvlv_hdr); 593 hdr_size += sizeof(struct batadv_tvlv_tt_data); 594 hdr_size += num_vlan * sizeof(struct batadv_tvlv_tt_vlan_data); 595 596 return hdr_size + batadv_tt_len(tt_local_entries); 597 } 598 599 static int batadv_tt_local_init(struct batadv_priv *bat_priv) 600 { 601 if (bat_priv->tt.local_hash) 602 return 0; 603 604 bat_priv->tt.local_hash = batadv_hash_new(1024); 605 606 if (!bat_priv->tt.local_hash) 607 return -ENOMEM; 608 609 batadv_hash_set_lock_class(bat_priv->tt.local_hash, 610 &batadv_tt_local_hash_lock_class_key); 611 612 return 0; 613 } 614 615 static void batadv_tt_global_free(struct batadv_priv *bat_priv, 616 struct batadv_tt_global_entry *tt_global, 617 const char *message) 618 { 619 batadv_dbg(BATADV_DBG_TT, bat_priv, 620 "Deleting global tt entry %pM (vid: %d): %s\n", 621 tt_global->common.addr, 622 batadv_print_vid(tt_global->common.vid), message); 623 624 batadv_hash_remove(bat_priv->tt.global_hash, batadv_compare_tt, 625 batadv_choose_tt, &tt_global->common); 626 batadv_tt_global_entry_put(tt_global); 627 } 628 629 /** 630 * batadv_tt_local_add() - add a new client to the local table or update an 631 * existing client 632 * @soft_iface: netdev struct of the mesh interface 633 * @addr: the mac address of the client to add 634 * @vid: VLAN identifier 635 * @ifindex: index of the interface where the client is connected to (useful to 636 * identify wireless clients) 637 * @mark: the value contained in the skb->mark field of the received packet (if 638 * any) 639 * 640 * Return: true if the client was successfully added, false otherwise. 641 */ 642 bool batadv_tt_local_add(struct net_device *soft_iface, const u8 *addr, 643 unsigned short vid, int ifindex, u32 mark) 644 { 645 struct batadv_priv *bat_priv = netdev_priv(soft_iface); 646 struct batadv_tt_local_entry *tt_local; 647 struct batadv_tt_global_entry *tt_global = NULL; 648 struct net *net = dev_net(soft_iface); 649 struct batadv_softif_vlan *vlan; 650 struct net_device *in_dev = NULL; 651 struct batadv_hard_iface *in_hardif = NULL; 652 struct hlist_head *head; 653 struct batadv_tt_orig_list_entry *orig_entry; 654 int hash_added, table_size, packet_size_max; 655 bool ret = false; 656 bool roamed_back = false; 657 u8 remote_flags; 658 u32 match_mark; 659 660 if (ifindex != BATADV_NULL_IFINDEX) 661 in_dev = dev_get_by_index(net, ifindex); 662 663 if (in_dev) 664 in_hardif = batadv_hardif_get_by_netdev(in_dev); 665 666 tt_local = batadv_tt_local_hash_find(bat_priv, addr, vid); 667 668 if (!is_multicast_ether_addr(addr)) 669 tt_global = batadv_tt_global_hash_find(bat_priv, addr, vid); 670 671 if (tt_local) { 672 tt_local->last_seen = jiffies; 673 if (tt_local->common.flags & BATADV_TT_CLIENT_PENDING) { 674 batadv_dbg(BATADV_DBG_TT, bat_priv, 675 "Re-adding pending client %pM (vid: %d)\n", 676 addr, batadv_print_vid(vid)); 677 /* whatever the reason why the PENDING flag was set, 678 * this is a client which was enqueued to be removed in 679 * this orig_interval. Since it popped up again, the 680 * flag can be reset like it was never enqueued 681 */ 682 tt_local->common.flags &= ~BATADV_TT_CLIENT_PENDING; 683 goto add_event; 684 } 685 686 if (tt_local->common.flags & BATADV_TT_CLIENT_ROAM) { 687 batadv_dbg(BATADV_DBG_TT, bat_priv, 688 "Roaming client %pM (vid: %d) came back to its original location\n", 689 addr, batadv_print_vid(vid)); 690 /* the ROAM flag is set because this client roamed away 691 * and the node got a roaming_advertisement message. Now 692 * that the client popped up again at its original 693 * location such flag can be unset 694 */ 695 tt_local->common.flags &= ~BATADV_TT_CLIENT_ROAM; 696 roamed_back = true; 697 } 698 goto check_roaming; 699 } 700 701 /* Ignore the client if we cannot send it in a full table response. */ 702 table_size = batadv_tt_local_table_transmit_size(bat_priv); 703 table_size += batadv_tt_len(1); 704 packet_size_max = atomic_read(&bat_priv->packet_size_max); 705 if (table_size > packet_size_max) { 706 net_ratelimited_function(batadv_info, soft_iface, 707 "Local translation table size (%i) exceeds maximum packet size (%i); Ignoring new local tt entry: %pM\n", 708 table_size, packet_size_max, addr); 709 goto out; 710 } 711 712 tt_local = kmem_cache_alloc(batadv_tl_cache, GFP_ATOMIC); 713 if (!tt_local) 714 goto out; 715 716 /* increase the refcounter of the related vlan */ 717 vlan = batadv_softif_vlan_get(bat_priv, vid); 718 if (!vlan) { 719 net_ratelimited_function(batadv_info, soft_iface, 720 "adding TT local entry %pM to non-existent VLAN %d\n", 721 addr, batadv_print_vid(vid)); 722 kmem_cache_free(batadv_tl_cache, tt_local); 723 tt_local = NULL; 724 goto out; 725 } 726 727 batadv_dbg(BATADV_DBG_TT, bat_priv, 728 "Creating new local tt entry: %pM (vid: %d, ttvn: %d)\n", 729 addr, batadv_print_vid(vid), 730 (u8)atomic_read(&bat_priv->tt.vn)); 731 732 ether_addr_copy(tt_local->common.addr, addr); 733 /* The local entry has to be marked as NEW to avoid to send it in 734 * a full table response going out before the next ttvn increment 735 * (consistency check) 736 */ 737 tt_local->common.flags = BATADV_TT_CLIENT_NEW; 738 tt_local->common.vid = vid; 739 if (batadv_is_wifi_hardif(in_hardif)) 740 tt_local->common.flags |= BATADV_TT_CLIENT_WIFI; 741 kref_init(&tt_local->common.refcount); 742 tt_local->last_seen = jiffies; 743 tt_local->common.added_at = tt_local->last_seen; 744 tt_local->vlan = vlan; 745 746 /* the batman interface mac and multicast addresses should never be 747 * purged 748 */ 749 if (batadv_compare_eth(addr, soft_iface->dev_addr) || 750 is_multicast_ether_addr(addr)) 751 tt_local->common.flags |= BATADV_TT_CLIENT_NOPURGE; 752 753 kref_get(&tt_local->common.refcount); 754 hash_added = batadv_hash_add(bat_priv->tt.local_hash, batadv_compare_tt, 755 batadv_choose_tt, &tt_local->common, 756 &tt_local->common.hash_entry); 757 758 if (unlikely(hash_added != 0)) { 759 /* remove the reference for the hash */ 760 batadv_tt_local_entry_put(tt_local); 761 goto out; 762 } 763 764 add_event: 765 batadv_tt_local_event(bat_priv, tt_local, BATADV_NO_FLAGS); 766 767 check_roaming: 768 /* Check whether it is a roaming, but don't do anything if the roaming 769 * process has already been handled 770 */ 771 if (tt_global && !(tt_global->common.flags & BATADV_TT_CLIENT_ROAM)) { 772 /* These node are probably going to update their tt table */ 773 head = &tt_global->orig_list; 774 rcu_read_lock(); 775 hlist_for_each_entry_rcu(orig_entry, head, list) { 776 batadv_send_roam_adv(bat_priv, tt_global->common.addr, 777 tt_global->common.vid, 778 orig_entry->orig_node); 779 } 780 rcu_read_unlock(); 781 if (roamed_back) { 782 batadv_tt_global_free(bat_priv, tt_global, 783 "Roaming canceled"); 784 tt_global = NULL; 785 } else { 786 /* The global entry has to be marked as ROAMING and 787 * has to be kept for consistency purpose 788 */ 789 tt_global->common.flags |= BATADV_TT_CLIENT_ROAM; 790 tt_global->roam_at = jiffies; 791 } 792 } 793 794 /* store the current remote flags before altering them. This helps 795 * understanding is flags are changing or not 796 */ 797 remote_flags = tt_local->common.flags & BATADV_TT_REMOTE_MASK; 798 799 if (batadv_is_wifi_hardif(in_hardif)) 800 tt_local->common.flags |= BATADV_TT_CLIENT_WIFI; 801 else 802 tt_local->common.flags &= ~BATADV_TT_CLIENT_WIFI; 803 804 /* check the mark in the skb: if it's equal to the configured 805 * isolation_mark, it means the packet is coming from an isolated 806 * non-mesh client 807 */ 808 match_mark = (mark & bat_priv->isolation_mark_mask); 809 if (bat_priv->isolation_mark_mask && 810 match_mark == bat_priv->isolation_mark) 811 tt_local->common.flags |= BATADV_TT_CLIENT_ISOLA; 812 else 813 tt_local->common.flags &= ~BATADV_TT_CLIENT_ISOLA; 814 815 /* if any "dynamic" flag has been modified, resend an ADD event for this 816 * entry so that all the nodes can get the new flags 817 */ 818 if (remote_flags ^ (tt_local->common.flags & BATADV_TT_REMOTE_MASK)) 819 batadv_tt_local_event(bat_priv, tt_local, BATADV_NO_FLAGS); 820 821 ret = true; 822 out: 823 if (in_hardif) 824 batadv_hardif_put(in_hardif); 825 if (in_dev) 826 dev_put(in_dev); 827 if (tt_local) 828 batadv_tt_local_entry_put(tt_local); 829 if (tt_global) 830 batadv_tt_global_entry_put(tt_global); 831 return ret; 832 } 833 834 /** 835 * batadv_tt_prepare_tvlv_global_data() - prepare the TVLV TT header to send 836 * within a TT Response directed to another node 837 * @orig_node: originator for which the TT data has to be prepared 838 * @tt_data: uninitialised pointer to the address of the TVLV buffer 839 * @tt_change: uninitialised pointer to the address of the area where the TT 840 * changed can be stored 841 * @tt_len: pointer to the length to reserve to the tt_change. if -1 this 842 * function reserves the amount of space needed to send the entire global TT 843 * table. In case of success the value is updated with the real amount of 844 * reserved bytes 845 * Allocate the needed amount of memory for the entire TT TVLV and write its 846 * header made up by one tvlv_tt_data object and a series of tvlv_tt_vlan_data 847 * objects, one per active VLAN served by the originator node. 848 * 849 * Return: the size of the allocated buffer or 0 in case of failure. 850 */ 851 static u16 852 batadv_tt_prepare_tvlv_global_data(struct batadv_orig_node *orig_node, 853 struct batadv_tvlv_tt_data **tt_data, 854 struct batadv_tvlv_tt_change **tt_change, 855 s32 *tt_len) 856 { 857 u16 num_vlan = 0; 858 u16 num_entries = 0; 859 u16 change_offset; 860 u16 tvlv_len; 861 struct batadv_tvlv_tt_vlan_data *tt_vlan; 862 struct batadv_orig_node_vlan *vlan; 863 u8 *tt_change_ptr; 864 865 spin_lock_bh(&orig_node->vlan_list_lock); 866 hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) { 867 num_vlan++; 868 num_entries += atomic_read(&vlan->tt.num_entries); 869 } 870 871 change_offset = sizeof(**tt_data); 872 change_offset += num_vlan * sizeof(*tt_vlan); 873 874 /* if tt_len is negative, allocate the space needed by the full table */ 875 if (*tt_len < 0) 876 *tt_len = batadv_tt_len(num_entries); 877 878 tvlv_len = *tt_len; 879 tvlv_len += change_offset; 880 881 *tt_data = kmalloc(tvlv_len, GFP_ATOMIC); 882 if (!*tt_data) { 883 *tt_len = 0; 884 goto out; 885 } 886 887 (*tt_data)->flags = BATADV_NO_FLAGS; 888 (*tt_data)->ttvn = atomic_read(&orig_node->last_ttvn); 889 (*tt_data)->num_vlan = htons(num_vlan); 890 891 tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(*tt_data + 1); 892 hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) { 893 tt_vlan->vid = htons(vlan->vid); 894 tt_vlan->crc = htonl(vlan->tt.crc); 895 896 tt_vlan++; 897 } 898 899 tt_change_ptr = (u8 *)*tt_data + change_offset; 900 *tt_change = (struct batadv_tvlv_tt_change *)tt_change_ptr; 901 902 out: 903 spin_unlock_bh(&orig_node->vlan_list_lock); 904 return tvlv_len; 905 } 906 907 /** 908 * batadv_tt_prepare_tvlv_local_data() - allocate and prepare the TT TVLV for 909 * this node 910 * @bat_priv: the bat priv with all the soft interface information 911 * @tt_data: uninitialised pointer to the address of the TVLV buffer 912 * @tt_change: uninitialised pointer to the address of the area where the TT 913 * changes can be stored 914 * @tt_len: pointer to the length to reserve to the tt_change. if -1 this 915 * function reserves the amount of space needed to send the entire local TT 916 * table. In case of success the value is updated with the real amount of 917 * reserved bytes 918 * 919 * Allocate the needed amount of memory for the entire TT TVLV and write its 920 * header made up by one tvlv_tt_data object and a series of tvlv_tt_vlan_data 921 * objects, one per active VLAN. 922 * 923 * Return: the size of the allocated buffer or 0 in case of failure. 924 */ 925 static u16 926 batadv_tt_prepare_tvlv_local_data(struct batadv_priv *bat_priv, 927 struct batadv_tvlv_tt_data **tt_data, 928 struct batadv_tvlv_tt_change **tt_change, 929 s32 *tt_len) 930 { 931 struct batadv_tvlv_tt_vlan_data *tt_vlan; 932 struct batadv_softif_vlan *vlan; 933 u16 num_vlan = 0; 934 u16 vlan_entries = 0; 935 u16 total_entries = 0; 936 u16 tvlv_len; 937 u8 *tt_change_ptr; 938 int change_offset; 939 940 spin_lock_bh(&bat_priv->softif_vlan_list_lock); 941 hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) { 942 vlan_entries = atomic_read(&vlan->tt.num_entries); 943 if (vlan_entries < 1) 944 continue; 945 946 num_vlan++; 947 total_entries += vlan_entries; 948 } 949 950 change_offset = sizeof(**tt_data); 951 change_offset += num_vlan * sizeof(*tt_vlan); 952 953 /* if tt_len is negative, allocate the space needed by the full table */ 954 if (*tt_len < 0) 955 *tt_len = batadv_tt_len(total_entries); 956 957 tvlv_len = *tt_len; 958 tvlv_len += change_offset; 959 960 *tt_data = kmalloc(tvlv_len, GFP_ATOMIC); 961 if (!*tt_data) { 962 tvlv_len = 0; 963 goto out; 964 } 965 966 (*tt_data)->flags = BATADV_NO_FLAGS; 967 (*tt_data)->ttvn = atomic_read(&bat_priv->tt.vn); 968 (*tt_data)->num_vlan = htons(num_vlan); 969 970 tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(*tt_data + 1); 971 hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) { 972 vlan_entries = atomic_read(&vlan->tt.num_entries); 973 if (vlan_entries < 1) 974 continue; 975 976 tt_vlan->vid = htons(vlan->vid); 977 tt_vlan->crc = htonl(vlan->tt.crc); 978 979 tt_vlan++; 980 } 981 982 tt_change_ptr = (u8 *)*tt_data + change_offset; 983 *tt_change = (struct batadv_tvlv_tt_change *)tt_change_ptr; 984 985 out: 986 spin_unlock_bh(&bat_priv->softif_vlan_list_lock); 987 return tvlv_len; 988 } 989 990 /** 991 * batadv_tt_tvlv_container_update() - update the translation table tvlv 992 * container after local tt changes have been committed 993 * @bat_priv: the bat priv with all the soft interface information 994 */ 995 static void batadv_tt_tvlv_container_update(struct batadv_priv *bat_priv) 996 { 997 struct batadv_tt_change_node *entry, *safe; 998 struct batadv_tvlv_tt_data *tt_data; 999 struct batadv_tvlv_tt_change *tt_change; 1000 int tt_diff_len, tt_change_len = 0; 1001 int tt_diff_entries_num = 0; 1002 int tt_diff_entries_count = 0; 1003 u16 tvlv_len; 1004 1005 tt_diff_entries_num = atomic_read(&bat_priv->tt.local_changes); 1006 tt_diff_len = batadv_tt_len(tt_diff_entries_num); 1007 1008 /* if we have too many changes for one packet don't send any 1009 * and wait for the tt table request which will be fragmented 1010 */ 1011 if (tt_diff_len > bat_priv->soft_iface->mtu) 1012 tt_diff_len = 0; 1013 1014 tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv, &tt_data, 1015 &tt_change, &tt_diff_len); 1016 if (!tvlv_len) 1017 return; 1018 1019 tt_data->flags = BATADV_TT_OGM_DIFF; 1020 1021 if (tt_diff_len == 0) 1022 goto container_register; 1023 1024 spin_lock_bh(&bat_priv->tt.changes_list_lock); 1025 atomic_set(&bat_priv->tt.local_changes, 0); 1026 1027 list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list, 1028 list) { 1029 if (tt_diff_entries_count < tt_diff_entries_num) { 1030 memcpy(tt_change + tt_diff_entries_count, 1031 &entry->change, 1032 sizeof(struct batadv_tvlv_tt_change)); 1033 tt_diff_entries_count++; 1034 } 1035 list_del(&entry->list); 1036 kmem_cache_free(batadv_tt_change_cache, entry); 1037 } 1038 spin_unlock_bh(&bat_priv->tt.changes_list_lock); 1039 1040 /* Keep the buffer for possible tt_request */ 1041 spin_lock_bh(&bat_priv->tt.last_changeset_lock); 1042 kfree(bat_priv->tt.last_changeset); 1043 bat_priv->tt.last_changeset_len = 0; 1044 bat_priv->tt.last_changeset = NULL; 1045 tt_change_len = batadv_tt_len(tt_diff_entries_count); 1046 /* check whether this new OGM has no changes due to size problems */ 1047 if (tt_diff_entries_count > 0) { 1048 /* if kmalloc() fails we will reply with the full table 1049 * instead of providing the diff 1050 */ 1051 bat_priv->tt.last_changeset = kzalloc(tt_diff_len, GFP_ATOMIC); 1052 if (bat_priv->tt.last_changeset) { 1053 memcpy(bat_priv->tt.last_changeset, 1054 tt_change, tt_change_len); 1055 bat_priv->tt.last_changeset_len = tt_diff_len; 1056 } 1057 } 1058 spin_unlock_bh(&bat_priv->tt.last_changeset_lock); 1059 1060 container_register: 1061 batadv_tvlv_container_register(bat_priv, BATADV_TVLV_TT, 1, tt_data, 1062 tvlv_len); 1063 kfree(tt_data); 1064 } 1065 1066 #ifdef CONFIG_BATMAN_ADV_DEBUGFS 1067 1068 /** 1069 * batadv_tt_local_seq_print_text() - Print the local tt table in a seq file 1070 * @seq: seq file to print on 1071 * @offset: not used 1072 * 1073 * Return: always 0 1074 */ 1075 int batadv_tt_local_seq_print_text(struct seq_file *seq, void *offset) 1076 { 1077 struct net_device *net_dev = (struct net_device *)seq->private; 1078 struct batadv_priv *bat_priv = netdev_priv(net_dev); 1079 struct batadv_hashtable *hash = bat_priv->tt.local_hash; 1080 struct batadv_tt_common_entry *tt_common_entry; 1081 struct batadv_tt_local_entry *tt_local; 1082 struct batadv_hard_iface *primary_if; 1083 struct hlist_head *head; 1084 u32 i; 1085 int last_seen_secs; 1086 int last_seen_msecs; 1087 unsigned long last_seen_jiffies; 1088 bool no_purge; 1089 u16 np_flag = BATADV_TT_CLIENT_NOPURGE; 1090 1091 primary_if = batadv_seq_print_text_primary_if_get(seq); 1092 if (!primary_if) 1093 goto out; 1094 1095 seq_printf(seq, 1096 "Locally retrieved addresses (from %s) announced via TT (TTVN: %u):\n", 1097 net_dev->name, (u8)atomic_read(&bat_priv->tt.vn)); 1098 seq_puts(seq, 1099 " Client VID Flags Last seen (CRC )\n"); 1100 1101 for (i = 0; i < hash->size; i++) { 1102 head = &hash->table[i]; 1103 1104 rcu_read_lock(); 1105 hlist_for_each_entry_rcu(tt_common_entry, 1106 head, hash_entry) { 1107 tt_local = container_of(tt_common_entry, 1108 struct batadv_tt_local_entry, 1109 common); 1110 last_seen_jiffies = jiffies - tt_local->last_seen; 1111 last_seen_msecs = jiffies_to_msecs(last_seen_jiffies); 1112 last_seen_secs = last_seen_msecs / 1000; 1113 last_seen_msecs = last_seen_msecs % 1000; 1114 1115 no_purge = tt_common_entry->flags & np_flag; 1116 seq_printf(seq, 1117 " * %pM %4i [%c%c%c%c%c%c] %3u.%03u (%#.8x)\n", 1118 tt_common_entry->addr, 1119 batadv_print_vid(tt_common_entry->vid), 1120 ((tt_common_entry->flags & 1121 BATADV_TT_CLIENT_ROAM) ? 'R' : '.'), 1122 no_purge ? 'P' : '.', 1123 ((tt_common_entry->flags & 1124 BATADV_TT_CLIENT_NEW) ? 'N' : '.'), 1125 ((tt_common_entry->flags & 1126 BATADV_TT_CLIENT_PENDING) ? 'X' : '.'), 1127 ((tt_common_entry->flags & 1128 BATADV_TT_CLIENT_WIFI) ? 'W' : '.'), 1129 ((tt_common_entry->flags & 1130 BATADV_TT_CLIENT_ISOLA) ? 'I' : '.'), 1131 no_purge ? 0 : last_seen_secs, 1132 no_purge ? 0 : last_seen_msecs, 1133 tt_local->vlan->tt.crc); 1134 } 1135 rcu_read_unlock(); 1136 } 1137 out: 1138 if (primary_if) 1139 batadv_hardif_put(primary_if); 1140 return 0; 1141 } 1142 #endif 1143 1144 /** 1145 * batadv_tt_local_dump_entry() - Dump one TT local entry into a message 1146 * @msg :Netlink message to dump into 1147 * @portid: Port making netlink request 1148 * @seq: Sequence number of netlink message 1149 * @bat_priv: The bat priv with all the soft interface information 1150 * @common: tt local & tt global common data 1151 * 1152 * Return: Error code, or 0 on success 1153 */ 1154 static int 1155 batadv_tt_local_dump_entry(struct sk_buff *msg, u32 portid, u32 seq, 1156 struct batadv_priv *bat_priv, 1157 struct batadv_tt_common_entry *common) 1158 { 1159 void *hdr; 1160 struct batadv_softif_vlan *vlan; 1161 struct batadv_tt_local_entry *local; 1162 unsigned int last_seen_msecs; 1163 u32 crc; 1164 1165 local = container_of(common, struct batadv_tt_local_entry, common); 1166 last_seen_msecs = jiffies_to_msecs(jiffies - local->last_seen); 1167 1168 vlan = batadv_softif_vlan_get(bat_priv, common->vid); 1169 if (!vlan) 1170 return 0; 1171 1172 crc = vlan->tt.crc; 1173 1174 batadv_softif_vlan_put(vlan); 1175 1176 hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family, 1177 NLM_F_MULTI, 1178 BATADV_CMD_GET_TRANSTABLE_LOCAL); 1179 if (!hdr) 1180 return -ENOBUFS; 1181 1182 if (nla_put(msg, BATADV_ATTR_TT_ADDRESS, ETH_ALEN, common->addr) || 1183 nla_put_u32(msg, BATADV_ATTR_TT_CRC32, crc) || 1184 nla_put_u16(msg, BATADV_ATTR_TT_VID, common->vid) || 1185 nla_put_u32(msg, BATADV_ATTR_TT_FLAGS, common->flags)) 1186 goto nla_put_failure; 1187 1188 if (!(common->flags & BATADV_TT_CLIENT_NOPURGE) && 1189 nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS, last_seen_msecs)) 1190 goto nla_put_failure; 1191 1192 genlmsg_end(msg, hdr); 1193 return 0; 1194 1195 nla_put_failure: 1196 genlmsg_cancel(msg, hdr); 1197 return -EMSGSIZE; 1198 } 1199 1200 /** 1201 * batadv_tt_local_dump_bucket() - Dump one TT local bucket into a message 1202 * @msg: Netlink message to dump into 1203 * @portid: Port making netlink request 1204 * @seq: Sequence number of netlink message 1205 * @bat_priv: The bat priv with all the soft interface information 1206 * @head: Pointer to the list containing the local tt entries 1207 * @idx_s: Number of entries to skip 1208 * 1209 * Return: Error code, or 0 on success 1210 */ 1211 static int 1212 batadv_tt_local_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq, 1213 struct batadv_priv *bat_priv, 1214 struct hlist_head *head, int *idx_s) 1215 { 1216 struct batadv_tt_common_entry *common; 1217 int idx = 0; 1218 1219 rcu_read_lock(); 1220 hlist_for_each_entry_rcu(common, head, hash_entry) { 1221 if (idx++ < *idx_s) 1222 continue; 1223 1224 if (batadv_tt_local_dump_entry(msg, portid, seq, bat_priv, 1225 common)) { 1226 rcu_read_unlock(); 1227 *idx_s = idx - 1; 1228 return -EMSGSIZE; 1229 } 1230 } 1231 rcu_read_unlock(); 1232 1233 *idx_s = 0; 1234 return 0; 1235 } 1236 1237 /** 1238 * batadv_tt_local_dump() - Dump TT local entries into a message 1239 * @msg: Netlink message to dump into 1240 * @cb: Parameters from query 1241 * 1242 * Return: Error code, or 0 on success 1243 */ 1244 int batadv_tt_local_dump(struct sk_buff *msg, struct netlink_callback *cb) 1245 { 1246 struct net *net = sock_net(cb->skb->sk); 1247 struct net_device *soft_iface; 1248 struct batadv_priv *bat_priv; 1249 struct batadv_hard_iface *primary_if = NULL; 1250 struct batadv_hashtable *hash; 1251 struct hlist_head *head; 1252 int ret; 1253 int ifindex; 1254 int bucket = cb->args[0]; 1255 int idx = cb->args[1]; 1256 int portid = NETLINK_CB(cb->skb).portid; 1257 1258 ifindex = batadv_netlink_get_ifindex(cb->nlh, BATADV_ATTR_MESH_IFINDEX); 1259 if (!ifindex) 1260 return -EINVAL; 1261 1262 soft_iface = dev_get_by_index(net, ifindex); 1263 if (!soft_iface || !batadv_softif_is_valid(soft_iface)) { 1264 ret = -ENODEV; 1265 goto out; 1266 } 1267 1268 bat_priv = netdev_priv(soft_iface); 1269 1270 primary_if = batadv_primary_if_get_selected(bat_priv); 1271 if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) { 1272 ret = -ENOENT; 1273 goto out; 1274 } 1275 1276 hash = bat_priv->tt.local_hash; 1277 1278 while (bucket < hash->size) { 1279 head = &hash->table[bucket]; 1280 1281 if (batadv_tt_local_dump_bucket(msg, portid, cb->nlh->nlmsg_seq, 1282 bat_priv, head, &idx)) 1283 break; 1284 1285 bucket++; 1286 } 1287 1288 ret = msg->len; 1289 1290 out: 1291 if (primary_if) 1292 batadv_hardif_put(primary_if); 1293 if (soft_iface) 1294 dev_put(soft_iface); 1295 1296 cb->args[0] = bucket; 1297 cb->args[1] = idx; 1298 1299 return ret; 1300 } 1301 1302 static void 1303 batadv_tt_local_set_pending(struct batadv_priv *bat_priv, 1304 struct batadv_tt_local_entry *tt_local_entry, 1305 u16 flags, const char *message) 1306 { 1307 batadv_tt_local_event(bat_priv, tt_local_entry, flags); 1308 1309 /* The local client has to be marked as "pending to be removed" but has 1310 * to be kept in the table in order to send it in a full table 1311 * response issued before the net ttvn increment (consistency check) 1312 */ 1313 tt_local_entry->common.flags |= BATADV_TT_CLIENT_PENDING; 1314 1315 batadv_dbg(BATADV_DBG_TT, bat_priv, 1316 "Local tt entry (%pM, vid: %d) pending to be removed: %s\n", 1317 tt_local_entry->common.addr, 1318 batadv_print_vid(tt_local_entry->common.vid), message); 1319 } 1320 1321 /** 1322 * batadv_tt_local_remove() - logically remove an entry from the local table 1323 * @bat_priv: the bat priv with all the soft interface information 1324 * @addr: the MAC address of the client to remove 1325 * @vid: VLAN identifier 1326 * @message: message to append to the log on deletion 1327 * @roaming: true if the deletion is due to a roaming event 1328 * 1329 * Return: the flags assigned to the local entry before being deleted 1330 */ 1331 u16 batadv_tt_local_remove(struct batadv_priv *bat_priv, const u8 *addr, 1332 unsigned short vid, const char *message, 1333 bool roaming) 1334 { 1335 struct batadv_tt_local_entry *tt_local_entry; 1336 u16 flags, curr_flags = BATADV_NO_FLAGS; 1337 void *tt_entry_exists; 1338 1339 tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid); 1340 if (!tt_local_entry) 1341 goto out; 1342 1343 curr_flags = tt_local_entry->common.flags; 1344 1345 flags = BATADV_TT_CLIENT_DEL; 1346 /* if this global entry addition is due to a roaming, the node has to 1347 * mark the local entry as "roamed" in order to correctly reroute 1348 * packets later 1349 */ 1350 if (roaming) { 1351 flags |= BATADV_TT_CLIENT_ROAM; 1352 /* mark the local client as ROAMed */ 1353 tt_local_entry->common.flags |= BATADV_TT_CLIENT_ROAM; 1354 } 1355 1356 if (!(tt_local_entry->common.flags & BATADV_TT_CLIENT_NEW)) { 1357 batadv_tt_local_set_pending(bat_priv, tt_local_entry, flags, 1358 message); 1359 goto out; 1360 } 1361 /* if this client has been added right now, it is possible to 1362 * immediately purge it 1363 */ 1364 batadv_tt_local_event(bat_priv, tt_local_entry, BATADV_TT_CLIENT_DEL); 1365 1366 tt_entry_exists = batadv_hash_remove(bat_priv->tt.local_hash, 1367 batadv_compare_tt, 1368 batadv_choose_tt, 1369 &tt_local_entry->common); 1370 if (!tt_entry_exists) 1371 goto out; 1372 1373 /* extra call to free the local tt entry */ 1374 batadv_tt_local_entry_put(tt_local_entry); 1375 1376 out: 1377 if (tt_local_entry) 1378 batadv_tt_local_entry_put(tt_local_entry); 1379 1380 return curr_flags; 1381 } 1382 1383 /** 1384 * batadv_tt_local_purge_list() - purge inactive tt local entries 1385 * @bat_priv: the bat priv with all the soft interface information 1386 * @head: pointer to the list containing the local tt entries 1387 * @timeout: parameter deciding whether a given tt local entry is considered 1388 * inactive or not 1389 */ 1390 static void batadv_tt_local_purge_list(struct batadv_priv *bat_priv, 1391 struct hlist_head *head, 1392 int timeout) 1393 { 1394 struct batadv_tt_local_entry *tt_local_entry; 1395 struct batadv_tt_common_entry *tt_common_entry; 1396 struct hlist_node *node_tmp; 1397 1398 hlist_for_each_entry_safe(tt_common_entry, node_tmp, head, 1399 hash_entry) { 1400 tt_local_entry = container_of(tt_common_entry, 1401 struct batadv_tt_local_entry, 1402 common); 1403 if (tt_local_entry->common.flags & BATADV_TT_CLIENT_NOPURGE) 1404 continue; 1405 1406 /* entry already marked for deletion */ 1407 if (tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING) 1408 continue; 1409 1410 if (!batadv_has_timed_out(tt_local_entry->last_seen, timeout)) 1411 continue; 1412 1413 batadv_tt_local_set_pending(bat_priv, tt_local_entry, 1414 BATADV_TT_CLIENT_DEL, "timed out"); 1415 } 1416 } 1417 1418 /** 1419 * batadv_tt_local_purge() - purge inactive tt local entries 1420 * @bat_priv: the bat priv with all the soft interface information 1421 * @timeout: parameter deciding whether a given tt local entry is considered 1422 * inactive or not 1423 */ 1424 static void batadv_tt_local_purge(struct batadv_priv *bat_priv, 1425 int timeout) 1426 { 1427 struct batadv_hashtable *hash = bat_priv->tt.local_hash; 1428 struct hlist_head *head; 1429 spinlock_t *list_lock; /* protects write access to the hash lists */ 1430 u32 i; 1431 1432 for (i = 0; i < hash->size; i++) { 1433 head = &hash->table[i]; 1434 list_lock = &hash->list_locks[i]; 1435 1436 spin_lock_bh(list_lock); 1437 batadv_tt_local_purge_list(bat_priv, head, timeout); 1438 spin_unlock_bh(list_lock); 1439 } 1440 } 1441 1442 static void batadv_tt_local_table_free(struct batadv_priv *bat_priv) 1443 { 1444 struct batadv_hashtable *hash; 1445 spinlock_t *list_lock; /* protects write access to the hash lists */ 1446 struct batadv_tt_common_entry *tt_common_entry; 1447 struct batadv_tt_local_entry *tt_local; 1448 struct hlist_node *node_tmp; 1449 struct hlist_head *head; 1450 u32 i; 1451 1452 if (!bat_priv->tt.local_hash) 1453 return; 1454 1455 hash = bat_priv->tt.local_hash; 1456 1457 for (i = 0; i < hash->size; i++) { 1458 head = &hash->table[i]; 1459 list_lock = &hash->list_locks[i]; 1460 1461 spin_lock_bh(list_lock); 1462 hlist_for_each_entry_safe(tt_common_entry, node_tmp, 1463 head, hash_entry) { 1464 hlist_del_rcu(&tt_common_entry->hash_entry); 1465 tt_local = container_of(tt_common_entry, 1466 struct batadv_tt_local_entry, 1467 common); 1468 1469 batadv_tt_local_entry_put(tt_local); 1470 } 1471 spin_unlock_bh(list_lock); 1472 } 1473 1474 batadv_hash_destroy(hash); 1475 1476 bat_priv->tt.local_hash = NULL; 1477 } 1478 1479 static int batadv_tt_global_init(struct batadv_priv *bat_priv) 1480 { 1481 if (bat_priv->tt.global_hash) 1482 return 0; 1483 1484 bat_priv->tt.global_hash = batadv_hash_new(1024); 1485 1486 if (!bat_priv->tt.global_hash) 1487 return -ENOMEM; 1488 1489 batadv_hash_set_lock_class(bat_priv->tt.global_hash, 1490 &batadv_tt_global_hash_lock_class_key); 1491 1492 return 0; 1493 } 1494 1495 static void batadv_tt_changes_list_free(struct batadv_priv *bat_priv) 1496 { 1497 struct batadv_tt_change_node *entry, *safe; 1498 1499 spin_lock_bh(&bat_priv->tt.changes_list_lock); 1500 1501 list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list, 1502 list) { 1503 list_del(&entry->list); 1504 kmem_cache_free(batadv_tt_change_cache, entry); 1505 } 1506 1507 atomic_set(&bat_priv->tt.local_changes, 0); 1508 spin_unlock_bh(&bat_priv->tt.changes_list_lock); 1509 } 1510 1511 /** 1512 * batadv_tt_global_orig_entry_find() - find a TT orig_list_entry 1513 * @entry: the TT global entry where the orig_list_entry has to be 1514 * extracted from 1515 * @orig_node: the originator for which the orig_list_entry has to be found 1516 * 1517 * retrieve the orig_tt_list_entry belonging to orig_node from the 1518 * batadv_tt_global_entry list 1519 * 1520 * Return: it with an increased refcounter, NULL if not found 1521 */ 1522 static struct batadv_tt_orig_list_entry * 1523 batadv_tt_global_orig_entry_find(const struct batadv_tt_global_entry *entry, 1524 const struct batadv_orig_node *orig_node) 1525 { 1526 struct batadv_tt_orig_list_entry *tmp_orig_entry, *orig_entry = NULL; 1527 const struct hlist_head *head; 1528 1529 rcu_read_lock(); 1530 head = &entry->orig_list; 1531 hlist_for_each_entry_rcu(tmp_orig_entry, head, list) { 1532 if (tmp_orig_entry->orig_node != orig_node) 1533 continue; 1534 if (!kref_get_unless_zero(&tmp_orig_entry->refcount)) 1535 continue; 1536 1537 orig_entry = tmp_orig_entry; 1538 break; 1539 } 1540 rcu_read_unlock(); 1541 1542 return orig_entry; 1543 } 1544 1545 /** 1546 * batadv_tt_global_entry_has_orig() - check if a TT global entry is also 1547 * handled by a given originator 1548 * @entry: the TT global entry to check 1549 * @orig_node: the originator to search in the list 1550 * @flags: a pointer to store TT flags for the given @entry received 1551 * from @orig_node 1552 * 1553 * find out if an orig_node is already in the list of a tt_global_entry. 1554 * 1555 * Return: true if found, false otherwise 1556 */ 1557 static bool 1558 batadv_tt_global_entry_has_orig(const struct batadv_tt_global_entry *entry, 1559 const struct batadv_orig_node *orig_node, 1560 u8 *flags) 1561 { 1562 struct batadv_tt_orig_list_entry *orig_entry; 1563 bool found = false; 1564 1565 orig_entry = batadv_tt_global_orig_entry_find(entry, orig_node); 1566 if (orig_entry) { 1567 found = true; 1568 1569 if (flags) 1570 *flags = orig_entry->flags; 1571 1572 batadv_tt_orig_list_entry_put(orig_entry); 1573 } 1574 1575 return found; 1576 } 1577 1578 /** 1579 * batadv_tt_global_sync_flags() - update TT sync flags 1580 * @tt_global: the TT global entry to update sync flags in 1581 * 1582 * Updates the sync flag bits in the tt_global flag attribute with a logical 1583 * OR of all sync flags from any of its TT orig entries. 1584 */ 1585 static void 1586 batadv_tt_global_sync_flags(struct batadv_tt_global_entry *tt_global) 1587 { 1588 struct batadv_tt_orig_list_entry *orig_entry; 1589 const struct hlist_head *head; 1590 u16 flags = BATADV_NO_FLAGS; 1591 1592 rcu_read_lock(); 1593 head = &tt_global->orig_list; 1594 hlist_for_each_entry_rcu(orig_entry, head, list) 1595 flags |= orig_entry->flags; 1596 rcu_read_unlock(); 1597 1598 flags |= tt_global->common.flags & (~BATADV_TT_SYNC_MASK); 1599 tt_global->common.flags = flags; 1600 } 1601 1602 /** 1603 * batadv_tt_global_orig_entry_add() - add or update a TT orig entry 1604 * @tt_global: the TT global entry to add an orig entry in 1605 * @orig_node: the originator to add an orig entry for 1606 * @ttvn: translation table version number of this changeset 1607 * @flags: TT sync flags 1608 */ 1609 static void 1610 batadv_tt_global_orig_entry_add(struct batadv_tt_global_entry *tt_global, 1611 struct batadv_orig_node *orig_node, int ttvn, 1612 u8 flags) 1613 { 1614 struct batadv_tt_orig_list_entry *orig_entry; 1615 1616 orig_entry = batadv_tt_global_orig_entry_find(tt_global, orig_node); 1617 if (orig_entry) { 1618 /* refresh the ttvn: the current value could be a bogus one that 1619 * was added during a "temporary client detection" 1620 */ 1621 orig_entry->ttvn = ttvn; 1622 orig_entry->flags = flags; 1623 goto sync_flags; 1624 } 1625 1626 orig_entry = kmem_cache_zalloc(batadv_tt_orig_cache, GFP_ATOMIC); 1627 if (!orig_entry) 1628 goto out; 1629 1630 INIT_HLIST_NODE(&orig_entry->list); 1631 kref_get(&orig_node->refcount); 1632 batadv_tt_global_size_inc(orig_node, tt_global->common.vid); 1633 orig_entry->orig_node = orig_node; 1634 orig_entry->ttvn = ttvn; 1635 orig_entry->flags = flags; 1636 kref_init(&orig_entry->refcount); 1637 1638 spin_lock_bh(&tt_global->list_lock); 1639 kref_get(&orig_entry->refcount); 1640 hlist_add_head_rcu(&orig_entry->list, 1641 &tt_global->orig_list); 1642 spin_unlock_bh(&tt_global->list_lock); 1643 atomic_inc(&tt_global->orig_list_count); 1644 1645 sync_flags: 1646 batadv_tt_global_sync_flags(tt_global); 1647 out: 1648 if (orig_entry) 1649 batadv_tt_orig_list_entry_put(orig_entry); 1650 } 1651 1652 /** 1653 * batadv_tt_global_add() - add a new TT global entry or update an existing one 1654 * @bat_priv: the bat priv with all the soft interface information 1655 * @orig_node: the originator announcing the client 1656 * @tt_addr: the mac address of the non-mesh client 1657 * @vid: VLAN identifier 1658 * @flags: TT flags that have to be set for this non-mesh client 1659 * @ttvn: the tt version number ever announcing this non-mesh client 1660 * 1661 * Add a new TT global entry for the given originator. If the entry already 1662 * exists add a new reference to the given originator (a global entry can have 1663 * references to multiple originators) and adjust the flags attribute to reflect 1664 * the function argument. 1665 * If a TT local entry exists for this non-mesh client remove it. 1666 * 1667 * The caller must hold orig_node refcount. 1668 * 1669 * Return: true if the new entry has been added, false otherwise 1670 */ 1671 static bool batadv_tt_global_add(struct batadv_priv *bat_priv, 1672 struct batadv_orig_node *orig_node, 1673 const unsigned char *tt_addr, 1674 unsigned short vid, u16 flags, u8 ttvn) 1675 { 1676 struct batadv_tt_global_entry *tt_global_entry; 1677 struct batadv_tt_local_entry *tt_local_entry; 1678 bool ret = false; 1679 int hash_added; 1680 struct batadv_tt_common_entry *common; 1681 u16 local_flags; 1682 1683 /* ignore global entries from backbone nodes */ 1684 if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig, vid)) 1685 return true; 1686 1687 tt_global_entry = batadv_tt_global_hash_find(bat_priv, tt_addr, vid); 1688 tt_local_entry = batadv_tt_local_hash_find(bat_priv, tt_addr, vid); 1689 1690 /* if the node already has a local client for this entry, it has to wait 1691 * for a roaming advertisement instead of manually messing up the global 1692 * table 1693 */ 1694 if ((flags & BATADV_TT_CLIENT_TEMP) && tt_local_entry && 1695 !(tt_local_entry->common.flags & BATADV_TT_CLIENT_NEW)) 1696 goto out; 1697 1698 if (!tt_global_entry) { 1699 tt_global_entry = kmem_cache_zalloc(batadv_tg_cache, 1700 GFP_ATOMIC); 1701 if (!tt_global_entry) 1702 goto out; 1703 1704 common = &tt_global_entry->common; 1705 ether_addr_copy(common->addr, tt_addr); 1706 common->vid = vid; 1707 1708 common->flags = flags; 1709 tt_global_entry->roam_at = 0; 1710 /* node must store current time in case of roaming. This is 1711 * needed to purge this entry out on timeout (if nobody claims 1712 * it) 1713 */ 1714 if (flags & BATADV_TT_CLIENT_ROAM) 1715 tt_global_entry->roam_at = jiffies; 1716 kref_init(&common->refcount); 1717 common->added_at = jiffies; 1718 1719 INIT_HLIST_HEAD(&tt_global_entry->orig_list); 1720 atomic_set(&tt_global_entry->orig_list_count, 0); 1721 spin_lock_init(&tt_global_entry->list_lock); 1722 1723 kref_get(&common->refcount); 1724 hash_added = batadv_hash_add(bat_priv->tt.global_hash, 1725 batadv_compare_tt, 1726 batadv_choose_tt, common, 1727 &common->hash_entry); 1728 1729 if (unlikely(hash_added != 0)) { 1730 /* remove the reference for the hash */ 1731 batadv_tt_global_entry_put(tt_global_entry); 1732 goto out_remove; 1733 } 1734 } else { 1735 common = &tt_global_entry->common; 1736 /* If there is already a global entry, we can use this one for 1737 * our processing. 1738 * But if we are trying to add a temporary client then here are 1739 * two options at this point: 1740 * 1) the global client is not a temporary client: the global 1741 * client has to be left as it is, temporary information 1742 * should never override any already known client state 1743 * 2) the global client is a temporary client: purge the 1744 * originator list and add the new one orig_entry 1745 */ 1746 if (flags & BATADV_TT_CLIENT_TEMP) { 1747 if (!(common->flags & BATADV_TT_CLIENT_TEMP)) 1748 goto out; 1749 if (batadv_tt_global_entry_has_orig(tt_global_entry, 1750 orig_node, NULL)) 1751 goto out_remove; 1752 batadv_tt_global_del_orig_list(tt_global_entry); 1753 goto add_orig_entry; 1754 } 1755 1756 /* if the client was temporary added before receiving the first 1757 * OGM announcing it, we have to clear the TEMP flag. Also, 1758 * remove the previous temporary orig node and re-add it 1759 * if required. If the orig entry changed, the new one which 1760 * is a non-temporary entry is preferred. 1761 */ 1762 if (common->flags & BATADV_TT_CLIENT_TEMP) { 1763 batadv_tt_global_del_orig_list(tt_global_entry); 1764 common->flags &= ~BATADV_TT_CLIENT_TEMP; 1765 } 1766 1767 /* the change can carry possible "attribute" flags like the 1768 * TT_CLIENT_TEMP, therefore they have to be copied in the 1769 * client entry 1770 */ 1771 common->flags |= flags & (~BATADV_TT_SYNC_MASK); 1772 1773 /* If there is the BATADV_TT_CLIENT_ROAM flag set, there is only 1774 * one originator left in the list and we previously received a 1775 * delete + roaming change for this originator. 1776 * 1777 * We should first delete the old originator before adding the 1778 * new one. 1779 */ 1780 if (common->flags & BATADV_TT_CLIENT_ROAM) { 1781 batadv_tt_global_del_orig_list(tt_global_entry); 1782 common->flags &= ~BATADV_TT_CLIENT_ROAM; 1783 tt_global_entry->roam_at = 0; 1784 } 1785 } 1786 add_orig_entry: 1787 /* add the new orig_entry (if needed) or update it */ 1788 batadv_tt_global_orig_entry_add(tt_global_entry, orig_node, ttvn, 1789 flags & BATADV_TT_SYNC_MASK); 1790 1791 batadv_dbg(BATADV_DBG_TT, bat_priv, 1792 "Creating new global tt entry: %pM (vid: %d, via %pM)\n", 1793 common->addr, batadv_print_vid(common->vid), 1794 orig_node->orig); 1795 ret = true; 1796 1797 out_remove: 1798 /* Do not remove multicast addresses from the local hash on 1799 * global additions 1800 */ 1801 if (is_multicast_ether_addr(tt_addr)) 1802 goto out; 1803 1804 /* remove address from local hash if present */ 1805 local_flags = batadv_tt_local_remove(bat_priv, tt_addr, vid, 1806 "global tt received", 1807 flags & BATADV_TT_CLIENT_ROAM); 1808 tt_global_entry->common.flags |= local_flags & BATADV_TT_CLIENT_WIFI; 1809 1810 if (!(flags & BATADV_TT_CLIENT_ROAM)) 1811 /* this is a normal global add. Therefore the client is not in a 1812 * roaming state anymore. 1813 */ 1814 tt_global_entry->common.flags &= ~BATADV_TT_CLIENT_ROAM; 1815 1816 out: 1817 if (tt_global_entry) 1818 batadv_tt_global_entry_put(tt_global_entry); 1819 if (tt_local_entry) 1820 batadv_tt_local_entry_put(tt_local_entry); 1821 return ret; 1822 } 1823 1824 /** 1825 * batadv_transtable_best_orig() - Get best originator list entry from tt entry 1826 * @bat_priv: the bat priv with all the soft interface information 1827 * @tt_global_entry: global translation table entry to be analyzed 1828 * 1829 * This functon assumes the caller holds rcu_read_lock(). 1830 * Return: best originator list entry or NULL on errors. 1831 */ 1832 static struct batadv_tt_orig_list_entry * 1833 batadv_transtable_best_orig(struct batadv_priv *bat_priv, 1834 struct batadv_tt_global_entry *tt_global_entry) 1835 { 1836 struct batadv_neigh_node *router, *best_router = NULL; 1837 struct batadv_algo_ops *bao = bat_priv->algo_ops; 1838 struct hlist_head *head; 1839 struct batadv_tt_orig_list_entry *orig_entry, *best_entry = NULL; 1840 1841 head = &tt_global_entry->orig_list; 1842 hlist_for_each_entry_rcu(orig_entry, head, list) { 1843 router = batadv_orig_router_get(orig_entry->orig_node, 1844 BATADV_IF_DEFAULT); 1845 if (!router) 1846 continue; 1847 1848 if (best_router && 1849 bao->neigh.cmp(router, BATADV_IF_DEFAULT, best_router, 1850 BATADV_IF_DEFAULT) <= 0) { 1851 batadv_neigh_node_put(router); 1852 continue; 1853 } 1854 1855 /* release the refcount for the "old" best */ 1856 if (best_router) 1857 batadv_neigh_node_put(best_router); 1858 1859 best_entry = orig_entry; 1860 best_router = router; 1861 } 1862 1863 if (best_router) 1864 batadv_neigh_node_put(best_router); 1865 1866 return best_entry; 1867 } 1868 1869 #ifdef CONFIG_BATMAN_ADV_DEBUGFS 1870 /** 1871 * batadv_tt_global_print_entry() - print all orig nodes who announce the 1872 * address for this global entry 1873 * @bat_priv: the bat priv with all the soft interface information 1874 * @tt_global_entry: global translation table entry to be printed 1875 * @seq: debugfs table seq_file struct 1876 * 1877 * This functon assumes the caller holds rcu_read_lock(). 1878 */ 1879 static void 1880 batadv_tt_global_print_entry(struct batadv_priv *bat_priv, 1881 struct batadv_tt_global_entry *tt_global_entry, 1882 struct seq_file *seq) 1883 { 1884 struct batadv_tt_orig_list_entry *orig_entry, *best_entry; 1885 struct batadv_tt_common_entry *tt_common_entry; 1886 struct batadv_orig_node_vlan *vlan; 1887 struct hlist_head *head; 1888 u8 last_ttvn; 1889 u16 flags; 1890 1891 tt_common_entry = &tt_global_entry->common; 1892 flags = tt_common_entry->flags; 1893 1894 best_entry = batadv_transtable_best_orig(bat_priv, tt_global_entry); 1895 if (best_entry) { 1896 vlan = batadv_orig_node_vlan_get(best_entry->orig_node, 1897 tt_common_entry->vid); 1898 if (!vlan) { 1899 seq_printf(seq, 1900 " * Cannot retrieve VLAN %d for originator %pM\n", 1901 batadv_print_vid(tt_common_entry->vid), 1902 best_entry->orig_node->orig); 1903 goto print_list; 1904 } 1905 1906 last_ttvn = atomic_read(&best_entry->orig_node->last_ttvn); 1907 seq_printf(seq, 1908 " %c %pM %4i (%3u) via %pM (%3u) (%#.8x) [%c%c%c%c]\n", 1909 '*', tt_global_entry->common.addr, 1910 batadv_print_vid(tt_global_entry->common.vid), 1911 best_entry->ttvn, best_entry->orig_node->orig, 1912 last_ttvn, vlan->tt.crc, 1913 ((flags & BATADV_TT_CLIENT_ROAM) ? 'R' : '.'), 1914 ((flags & BATADV_TT_CLIENT_WIFI) ? 'W' : '.'), 1915 ((flags & BATADV_TT_CLIENT_ISOLA) ? 'I' : '.'), 1916 ((flags & BATADV_TT_CLIENT_TEMP) ? 'T' : '.')); 1917 1918 batadv_orig_node_vlan_put(vlan); 1919 } 1920 1921 print_list: 1922 head = &tt_global_entry->orig_list; 1923 1924 hlist_for_each_entry_rcu(orig_entry, head, list) { 1925 if (best_entry == orig_entry) 1926 continue; 1927 1928 vlan = batadv_orig_node_vlan_get(orig_entry->orig_node, 1929 tt_common_entry->vid); 1930 if (!vlan) { 1931 seq_printf(seq, 1932 " + Cannot retrieve VLAN %d for originator %pM\n", 1933 batadv_print_vid(tt_common_entry->vid), 1934 orig_entry->orig_node->orig); 1935 continue; 1936 } 1937 1938 last_ttvn = atomic_read(&orig_entry->orig_node->last_ttvn); 1939 seq_printf(seq, 1940 " %c %pM %4d (%3u) via %pM (%3u) (%#.8x) [%c%c%c%c]\n", 1941 '+', tt_global_entry->common.addr, 1942 batadv_print_vid(tt_global_entry->common.vid), 1943 orig_entry->ttvn, orig_entry->orig_node->orig, 1944 last_ttvn, vlan->tt.crc, 1945 ((flags & BATADV_TT_CLIENT_ROAM) ? 'R' : '.'), 1946 ((flags & BATADV_TT_CLIENT_WIFI) ? 'W' : '.'), 1947 ((flags & BATADV_TT_CLIENT_ISOLA) ? 'I' : '.'), 1948 ((flags & BATADV_TT_CLIENT_TEMP) ? 'T' : '.')); 1949 1950 batadv_orig_node_vlan_put(vlan); 1951 } 1952 } 1953 1954 /** 1955 * batadv_tt_global_seq_print_text() - Print the global tt table in a seq file 1956 * @seq: seq file to print on 1957 * @offset: not used 1958 * 1959 * Return: always 0 1960 */ 1961 int batadv_tt_global_seq_print_text(struct seq_file *seq, void *offset) 1962 { 1963 struct net_device *net_dev = (struct net_device *)seq->private; 1964 struct batadv_priv *bat_priv = netdev_priv(net_dev); 1965 struct batadv_hashtable *hash = bat_priv->tt.global_hash; 1966 struct batadv_tt_common_entry *tt_common_entry; 1967 struct batadv_tt_global_entry *tt_global; 1968 struct batadv_hard_iface *primary_if; 1969 struct hlist_head *head; 1970 u32 i; 1971 1972 primary_if = batadv_seq_print_text_primary_if_get(seq); 1973 if (!primary_if) 1974 goto out; 1975 1976 seq_printf(seq, 1977 "Globally announced TT entries received via the mesh %s\n", 1978 net_dev->name); 1979 seq_puts(seq, 1980 " Client VID (TTVN) Originator (Curr TTVN) (CRC ) Flags\n"); 1981 1982 for (i = 0; i < hash->size; i++) { 1983 head = &hash->table[i]; 1984 1985 rcu_read_lock(); 1986 hlist_for_each_entry_rcu(tt_common_entry, 1987 head, hash_entry) { 1988 tt_global = container_of(tt_common_entry, 1989 struct batadv_tt_global_entry, 1990 common); 1991 batadv_tt_global_print_entry(bat_priv, tt_global, seq); 1992 } 1993 rcu_read_unlock(); 1994 } 1995 out: 1996 if (primary_if) 1997 batadv_hardif_put(primary_if); 1998 return 0; 1999 } 2000 #endif 2001 2002 /** 2003 * batadv_tt_global_dump_subentry() - Dump all TT local entries into a message 2004 * @msg: Netlink message to dump into 2005 * @portid: Port making netlink request 2006 * @seq: Sequence number of netlink message 2007 * @common: tt local & tt global common data 2008 * @orig: Originator node announcing a non-mesh client 2009 * @best: Is the best originator for the TT entry 2010 * 2011 * Return: Error code, or 0 on success 2012 */ 2013 static int 2014 batadv_tt_global_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq, 2015 struct batadv_tt_common_entry *common, 2016 struct batadv_tt_orig_list_entry *orig, 2017 bool best) 2018 { 2019 u16 flags = (common->flags & (~BATADV_TT_SYNC_MASK)) | orig->flags; 2020 void *hdr; 2021 struct batadv_orig_node_vlan *vlan; 2022 u8 last_ttvn; 2023 u32 crc; 2024 2025 vlan = batadv_orig_node_vlan_get(orig->orig_node, 2026 common->vid); 2027 if (!vlan) 2028 return 0; 2029 2030 crc = vlan->tt.crc; 2031 2032 batadv_orig_node_vlan_put(vlan); 2033 2034 hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family, 2035 NLM_F_MULTI, 2036 BATADV_CMD_GET_TRANSTABLE_GLOBAL); 2037 if (!hdr) 2038 return -ENOBUFS; 2039 2040 last_ttvn = atomic_read(&orig->orig_node->last_ttvn); 2041 2042 if (nla_put(msg, BATADV_ATTR_TT_ADDRESS, ETH_ALEN, common->addr) || 2043 nla_put(msg, BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN, 2044 orig->orig_node->orig) || 2045 nla_put_u8(msg, BATADV_ATTR_TT_TTVN, orig->ttvn) || 2046 nla_put_u8(msg, BATADV_ATTR_TT_LAST_TTVN, last_ttvn) || 2047 nla_put_u32(msg, BATADV_ATTR_TT_CRC32, crc) || 2048 nla_put_u16(msg, BATADV_ATTR_TT_VID, common->vid) || 2049 nla_put_u32(msg, BATADV_ATTR_TT_FLAGS, flags)) 2050 goto nla_put_failure; 2051 2052 if (best && nla_put_flag(msg, BATADV_ATTR_FLAG_BEST)) 2053 goto nla_put_failure; 2054 2055 genlmsg_end(msg, hdr); 2056 return 0; 2057 2058 nla_put_failure: 2059 genlmsg_cancel(msg, hdr); 2060 return -EMSGSIZE; 2061 } 2062 2063 /** 2064 * batadv_tt_global_dump_entry() - Dump one TT global entry into a message 2065 * @msg: Netlink message to dump into 2066 * @portid: Port making netlink request 2067 * @seq: Sequence number of netlink message 2068 * @bat_priv: The bat priv with all the soft interface information 2069 * @common: tt local & tt global common data 2070 * @sub_s: Number of entries to skip 2071 * 2072 * This function assumes the caller holds rcu_read_lock(). 2073 * 2074 * Return: Error code, or 0 on success 2075 */ 2076 static int 2077 batadv_tt_global_dump_entry(struct sk_buff *msg, u32 portid, u32 seq, 2078 struct batadv_priv *bat_priv, 2079 struct batadv_tt_common_entry *common, int *sub_s) 2080 { 2081 struct batadv_tt_orig_list_entry *orig_entry, *best_entry; 2082 struct batadv_tt_global_entry *global; 2083 struct hlist_head *head; 2084 int sub = 0; 2085 bool best; 2086 2087 global = container_of(common, struct batadv_tt_global_entry, common); 2088 best_entry = batadv_transtable_best_orig(bat_priv, global); 2089 head = &global->orig_list; 2090 2091 hlist_for_each_entry_rcu(orig_entry, head, list) { 2092 if (sub++ < *sub_s) 2093 continue; 2094 2095 best = (orig_entry == best_entry); 2096 2097 if (batadv_tt_global_dump_subentry(msg, portid, seq, common, 2098 orig_entry, best)) { 2099 *sub_s = sub - 1; 2100 return -EMSGSIZE; 2101 } 2102 } 2103 2104 *sub_s = 0; 2105 return 0; 2106 } 2107 2108 /** 2109 * batadv_tt_global_dump_bucket() - Dump one TT local bucket into a message 2110 * @msg: Netlink message to dump into 2111 * @portid: Port making netlink request 2112 * @seq: Sequence number of netlink message 2113 * @bat_priv: The bat priv with all the soft interface information 2114 * @head: Pointer to the list containing the global tt entries 2115 * @idx_s: Number of entries to skip 2116 * @sub: Number of entries to skip 2117 * 2118 * Return: Error code, or 0 on success 2119 */ 2120 static int 2121 batadv_tt_global_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq, 2122 struct batadv_priv *bat_priv, 2123 struct hlist_head *head, int *idx_s, int *sub) 2124 { 2125 struct batadv_tt_common_entry *common; 2126 int idx = 0; 2127 2128 rcu_read_lock(); 2129 hlist_for_each_entry_rcu(common, head, hash_entry) { 2130 if (idx++ < *idx_s) 2131 continue; 2132 2133 if (batadv_tt_global_dump_entry(msg, portid, seq, bat_priv, 2134 common, sub)) { 2135 rcu_read_unlock(); 2136 *idx_s = idx - 1; 2137 return -EMSGSIZE; 2138 } 2139 } 2140 rcu_read_unlock(); 2141 2142 *idx_s = 0; 2143 *sub = 0; 2144 return 0; 2145 } 2146 2147 /** 2148 * batadv_tt_global_dump() - Dump TT global entries into a message 2149 * @msg: Netlink message to dump into 2150 * @cb: Parameters from query 2151 * 2152 * Return: Error code, or length of message on success 2153 */ 2154 int batadv_tt_global_dump(struct sk_buff *msg, struct netlink_callback *cb) 2155 { 2156 struct net *net = sock_net(cb->skb->sk); 2157 struct net_device *soft_iface; 2158 struct batadv_priv *bat_priv; 2159 struct batadv_hard_iface *primary_if = NULL; 2160 struct batadv_hashtable *hash; 2161 struct hlist_head *head; 2162 int ret; 2163 int ifindex; 2164 int bucket = cb->args[0]; 2165 int idx = cb->args[1]; 2166 int sub = cb->args[2]; 2167 int portid = NETLINK_CB(cb->skb).portid; 2168 2169 ifindex = batadv_netlink_get_ifindex(cb->nlh, BATADV_ATTR_MESH_IFINDEX); 2170 if (!ifindex) 2171 return -EINVAL; 2172 2173 soft_iface = dev_get_by_index(net, ifindex); 2174 if (!soft_iface || !batadv_softif_is_valid(soft_iface)) { 2175 ret = -ENODEV; 2176 goto out; 2177 } 2178 2179 bat_priv = netdev_priv(soft_iface); 2180 2181 primary_if = batadv_primary_if_get_selected(bat_priv); 2182 if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) { 2183 ret = -ENOENT; 2184 goto out; 2185 } 2186 2187 hash = bat_priv->tt.global_hash; 2188 2189 while (bucket < hash->size) { 2190 head = &hash->table[bucket]; 2191 2192 if (batadv_tt_global_dump_bucket(msg, portid, 2193 cb->nlh->nlmsg_seq, bat_priv, 2194 head, &idx, &sub)) 2195 break; 2196 2197 bucket++; 2198 } 2199 2200 ret = msg->len; 2201 2202 out: 2203 if (primary_if) 2204 batadv_hardif_put(primary_if); 2205 if (soft_iface) 2206 dev_put(soft_iface); 2207 2208 cb->args[0] = bucket; 2209 cb->args[1] = idx; 2210 cb->args[2] = sub; 2211 2212 return ret; 2213 } 2214 2215 /** 2216 * _batadv_tt_global_del_orig_entry() - remove and free an orig_entry 2217 * @tt_global_entry: the global entry to remove the orig_entry from 2218 * @orig_entry: the orig entry to remove and free 2219 * 2220 * Remove an orig_entry from its list in the given tt_global_entry and 2221 * free this orig_entry afterwards. 2222 * 2223 * Caller must hold tt_global_entry->list_lock and ensure orig_entry->list is 2224 * part of a list. 2225 */ 2226 static void 2227 _batadv_tt_global_del_orig_entry(struct batadv_tt_global_entry *tt_global_entry, 2228 struct batadv_tt_orig_list_entry *orig_entry) 2229 { 2230 lockdep_assert_held(&tt_global_entry->list_lock); 2231 2232 batadv_tt_global_size_dec(orig_entry->orig_node, 2233 tt_global_entry->common.vid); 2234 atomic_dec(&tt_global_entry->orig_list_count); 2235 /* requires holding tt_global_entry->list_lock and orig_entry->list 2236 * being part of a list 2237 */ 2238 hlist_del_rcu(&orig_entry->list); 2239 batadv_tt_orig_list_entry_put(orig_entry); 2240 } 2241 2242 /* deletes the orig list of a tt_global_entry */ 2243 static void 2244 batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry) 2245 { 2246 struct hlist_head *head; 2247 struct hlist_node *safe; 2248 struct batadv_tt_orig_list_entry *orig_entry; 2249 2250 spin_lock_bh(&tt_global_entry->list_lock); 2251 head = &tt_global_entry->orig_list; 2252 hlist_for_each_entry_safe(orig_entry, safe, head, list) 2253 _batadv_tt_global_del_orig_entry(tt_global_entry, orig_entry); 2254 spin_unlock_bh(&tt_global_entry->list_lock); 2255 } 2256 2257 /** 2258 * batadv_tt_global_del_orig_node() - remove orig_node from a global tt entry 2259 * @bat_priv: the bat priv with all the soft interface information 2260 * @tt_global_entry: the global entry to remove the orig_node from 2261 * @orig_node: the originator announcing the client 2262 * @message: message to append to the log on deletion 2263 * 2264 * Remove the given orig_node and its according orig_entry from the given 2265 * global tt entry. 2266 */ 2267 static void 2268 batadv_tt_global_del_orig_node(struct batadv_priv *bat_priv, 2269 struct batadv_tt_global_entry *tt_global_entry, 2270 struct batadv_orig_node *orig_node, 2271 const char *message) 2272 { 2273 struct hlist_head *head; 2274 struct hlist_node *safe; 2275 struct batadv_tt_orig_list_entry *orig_entry; 2276 unsigned short vid; 2277 2278 spin_lock_bh(&tt_global_entry->list_lock); 2279 head = &tt_global_entry->orig_list; 2280 hlist_for_each_entry_safe(orig_entry, safe, head, list) { 2281 if (orig_entry->orig_node == orig_node) { 2282 vid = tt_global_entry->common.vid; 2283 batadv_dbg(BATADV_DBG_TT, bat_priv, 2284 "Deleting %pM from global tt entry %pM (vid: %d): %s\n", 2285 orig_node->orig, 2286 tt_global_entry->common.addr, 2287 batadv_print_vid(vid), message); 2288 _batadv_tt_global_del_orig_entry(tt_global_entry, 2289 orig_entry); 2290 } 2291 } 2292 spin_unlock_bh(&tt_global_entry->list_lock); 2293 } 2294 2295 /* If the client is to be deleted, we check if it is the last origantor entry 2296 * within tt_global entry. If yes, we set the BATADV_TT_CLIENT_ROAM flag and the 2297 * timer, otherwise we simply remove the originator scheduled for deletion. 2298 */ 2299 static void 2300 batadv_tt_global_del_roaming(struct batadv_priv *bat_priv, 2301 struct batadv_tt_global_entry *tt_global_entry, 2302 struct batadv_orig_node *orig_node, 2303 const char *message) 2304 { 2305 bool last_entry = true; 2306 struct hlist_head *head; 2307 struct batadv_tt_orig_list_entry *orig_entry; 2308 2309 /* no local entry exists, case 1: 2310 * Check if this is the last one or if other entries exist. 2311 */ 2312 2313 rcu_read_lock(); 2314 head = &tt_global_entry->orig_list; 2315 hlist_for_each_entry_rcu(orig_entry, head, list) { 2316 if (orig_entry->orig_node != orig_node) { 2317 last_entry = false; 2318 break; 2319 } 2320 } 2321 rcu_read_unlock(); 2322 2323 if (last_entry) { 2324 /* its the last one, mark for roaming. */ 2325 tt_global_entry->common.flags |= BATADV_TT_CLIENT_ROAM; 2326 tt_global_entry->roam_at = jiffies; 2327 } else { 2328 /* there is another entry, we can simply delete this 2329 * one and can still use the other one. 2330 */ 2331 batadv_tt_global_del_orig_node(bat_priv, tt_global_entry, 2332 orig_node, message); 2333 } 2334 } 2335 2336 /** 2337 * batadv_tt_global_del() - remove a client from the global table 2338 * @bat_priv: the bat priv with all the soft interface information 2339 * @orig_node: an originator serving this client 2340 * @addr: the mac address of the client 2341 * @vid: VLAN identifier 2342 * @message: a message explaining the reason for deleting the client to print 2343 * for debugging purpose 2344 * @roaming: true if the deletion has been triggered by a roaming event 2345 */ 2346 static void batadv_tt_global_del(struct batadv_priv *bat_priv, 2347 struct batadv_orig_node *orig_node, 2348 const unsigned char *addr, unsigned short vid, 2349 const char *message, bool roaming) 2350 { 2351 struct batadv_tt_global_entry *tt_global_entry; 2352 struct batadv_tt_local_entry *local_entry = NULL; 2353 2354 tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid); 2355 if (!tt_global_entry) 2356 goto out; 2357 2358 if (!roaming) { 2359 batadv_tt_global_del_orig_node(bat_priv, tt_global_entry, 2360 orig_node, message); 2361 2362 if (hlist_empty(&tt_global_entry->orig_list)) 2363 batadv_tt_global_free(bat_priv, tt_global_entry, 2364 message); 2365 2366 goto out; 2367 } 2368 2369 /* if we are deleting a global entry due to a roam 2370 * event, there are two possibilities: 2371 * 1) the client roamed from node A to node B => if there 2372 * is only one originator left for this client, we mark 2373 * it with BATADV_TT_CLIENT_ROAM, we start a timer and we 2374 * wait for node B to claim it. In case of timeout 2375 * the entry is purged. 2376 * 2377 * If there are other originators left, we directly delete 2378 * the originator. 2379 * 2) the client roamed to us => we can directly delete 2380 * the global entry, since it is useless now. 2381 */ 2382 local_entry = batadv_tt_local_hash_find(bat_priv, 2383 tt_global_entry->common.addr, 2384 vid); 2385 if (local_entry) { 2386 /* local entry exists, case 2: client roamed to us. */ 2387 batadv_tt_global_del_orig_list(tt_global_entry); 2388 batadv_tt_global_free(bat_priv, tt_global_entry, message); 2389 } else { 2390 /* no local entry exists, case 1: check for roaming */ 2391 batadv_tt_global_del_roaming(bat_priv, tt_global_entry, 2392 orig_node, message); 2393 } 2394 2395 out: 2396 if (tt_global_entry) 2397 batadv_tt_global_entry_put(tt_global_entry); 2398 if (local_entry) 2399 batadv_tt_local_entry_put(local_entry); 2400 } 2401 2402 /** 2403 * batadv_tt_global_del_orig() - remove all the TT global entries belonging to 2404 * the given originator matching the provided vid 2405 * @bat_priv: the bat priv with all the soft interface information 2406 * @orig_node: the originator owning the entries to remove 2407 * @match_vid: the VLAN identifier to match. If negative all the entries will be 2408 * removed 2409 * @message: debug message to print as "reason" 2410 */ 2411 void batadv_tt_global_del_orig(struct batadv_priv *bat_priv, 2412 struct batadv_orig_node *orig_node, 2413 s32 match_vid, 2414 const char *message) 2415 { 2416 struct batadv_tt_global_entry *tt_global; 2417 struct batadv_tt_common_entry *tt_common_entry; 2418 u32 i; 2419 struct batadv_hashtable *hash = bat_priv->tt.global_hash; 2420 struct hlist_node *safe; 2421 struct hlist_head *head; 2422 spinlock_t *list_lock; /* protects write access to the hash lists */ 2423 unsigned short vid; 2424 2425 if (!hash) 2426 return; 2427 2428 for (i = 0; i < hash->size; i++) { 2429 head = &hash->table[i]; 2430 list_lock = &hash->list_locks[i]; 2431 2432 spin_lock_bh(list_lock); 2433 hlist_for_each_entry_safe(tt_common_entry, safe, 2434 head, hash_entry) { 2435 /* remove only matching entries */ 2436 if (match_vid >= 0 && tt_common_entry->vid != match_vid) 2437 continue; 2438 2439 tt_global = container_of(tt_common_entry, 2440 struct batadv_tt_global_entry, 2441 common); 2442 2443 batadv_tt_global_del_orig_node(bat_priv, tt_global, 2444 orig_node, message); 2445 2446 if (hlist_empty(&tt_global->orig_list)) { 2447 vid = tt_global->common.vid; 2448 batadv_dbg(BATADV_DBG_TT, bat_priv, 2449 "Deleting global tt entry %pM (vid: %d): %s\n", 2450 tt_global->common.addr, 2451 batadv_print_vid(vid), message); 2452 hlist_del_rcu(&tt_common_entry->hash_entry); 2453 batadv_tt_global_entry_put(tt_global); 2454 } 2455 } 2456 spin_unlock_bh(list_lock); 2457 } 2458 clear_bit(BATADV_ORIG_CAPA_HAS_TT, &orig_node->capa_initialized); 2459 } 2460 2461 static bool batadv_tt_global_to_purge(struct batadv_tt_global_entry *tt_global, 2462 char **msg) 2463 { 2464 bool purge = false; 2465 unsigned long roam_timeout = BATADV_TT_CLIENT_ROAM_TIMEOUT; 2466 unsigned long temp_timeout = BATADV_TT_CLIENT_TEMP_TIMEOUT; 2467 2468 if ((tt_global->common.flags & BATADV_TT_CLIENT_ROAM) && 2469 batadv_has_timed_out(tt_global->roam_at, roam_timeout)) { 2470 purge = true; 2471 *msg = "Roaming timeout\n"; 2472 } 2473 2474 if ((tt_global->common.flags & BATADV_TT_CLIENT_TEMP) && 2475 batadv_has_timed_out(tt_global->common.added_at, temp_timeout)) { 2476 purge = true; 2477 *msg = "Temporary client timeout\n"; 2478 } 2479 2480 return purge; 2481 } 2482 2483 static void batadv_tt_global_purge(struct batadv_priv *bat_priv) 2484 { 2485 struct batadv_hashtable *hash = bat_priv->tt.global_hash; 2486 struct hlist_head *head; 2487 struct hlist_node *node_tmp; 2488 spinlock_t *list_lock; /* protects write access to the hash lists */ 2489 u32 i; 2490 char *msg = NULL; 2491 struct batadv_tt_common_entry *tt_common; 2492 struct batadv_tt_global_entry *tt_global; 2493 2494 for (i = 0; i < hash->size; i++) { 2495 head = &hash->table[i]; 2496 list_lock = &hash->list_locks[i]; 2497 2498 spin_lock_bh(list_lock); 2499 hlist_for_each_entry_safe(tt_common, node_tmp, head, 2500 hash_entry) { 2501 tt_global = container_of(tt_common, 2502 struct batadv_tt_global_entry, 2503 common); 2504 2505 if (!batadv_tt_global_to_purge(tt_global, &msg)) 2506 continue; 2507 2508 batadv_dbg(BATADV_DBG_TT, bat_priv, 2509 "Deleting global tt entry %pM (vid: %d): %s\n", 2510 tt_global->common.addr, 2511 batadv_print_vid(tt_global->common.vid), 2512 msg); 2513 2514 hlist_del_rcu(&tt_common->hash_entry); 2515 2516 batadv_tt_global_entry_put(tt_global); 2517 } 2518 spin_unlock_bh(list_lock); 2519 } 2520 } 2521 2522 static void batadv_tt_global_table_free(struct batadv_priv *bat_priv) 2523 { 2524 struct batadv_hashtable *hash; 2525 spinlock_t *list_lock; /* protects write access to the hash lists */ 2526 struct batadv_tt_common_entry *tt_common_entry; 2527 struct batadv_tt_global_entry *tt_global; 2528 struct hlist_node *node_tmp; 2529 struct hlist_head *head; 2530 u32 i; 2531 2532 if (!bat_priv->tt.global_hash) 2533 return; 2534 2535 hash = bat_priv->tt.global_hash; 2536 2537 for (i = 0; i < hash->size; i++) { 2538 head = &hash->table[i]; 2539 list_lock = &hash->list_locks[i]; 2540 2541 spin_lock_bh(list_lock); 2542 hlist_for_each_entry_safe(tt_common_entry, node_tmp, 2543 head, hash_entry) { 2544 hlist_del_rcu(&tt_common_entry->hash_entry); 2545 tt_global = container_of(tt_common_entry, 2546 struct batadv_tt_global_entry, 2547 common); 2548 batadv_tt_global_entry_put(tt_global); 2549 } 2550 spin_unlock_bh(list_lock); 2551 } 2552 2553 batadv_hash_destroy(hash); 2554 2555 bat_priv->tt.global_hash = NULL; 2556 } 2557 2558 static bool 2559 _batadv_is_ap_isolated(struct batadv_tt_local_entry *tt_local_entry, 2560 struct batadv_tt_global_entry *tt_global_entry) 2561 { 2562 if (tt_local_entry->common.flags & BATADV_TT_CLIENT_WIFI && 2563 tt_global_entry->common.flags & BATADV_TT_CLIENT_WIFI) 2564 return true; 2565 2566 /* check if the two clients are marked as isolated */ 2567 if (tt_local_entry->common.flags & BATADV_TT_CLIENT_ISOLA && 2568 tt_global_entry->common.flags & BATADV_TT_CLIENT_ISOLA) 2569 return true; 2570 2571 return false; 2572 } 2573 2574 /** 2575 * batadv_transtable_search() - get the mesh destination for a given client 2576 * @bat_priv: the bat priv with all the soft interface information 2577 * @src: mac address of the source client 2578 * @addr: mac address of the destination client 2579 * @vid: VLAN identifier 2580 * 2581 * Return: a pointer to the originator that was selected as destination in the 2582 * mesh for contacting the client 'addr', NULL otherwise. 2583 * In case of multiple originators serving the same client, the function returns 2584 * the best one (best in terms of metric towards the destination node). 2585 * 2586 * If the two clients are AP isolated the function returns NULL. 2587 */ 2588 struct batadv_orig_node *batadv_transtable_search(struct batadv_priv *bat_priv, 2589 const u8 *src, 2590 const u8 *addr, 2591 unsigned short vid) 2592 { 2593 struct batadv_tt_local_entry *tt_local_entry = NULL; 2594 struct batadv_tt_global_entry *tt_global_entry = NULL; 2595 struct batadv_orig_node *orig_node = NULL; 2596 struct batadv_tt_orig_list_entry *best_entry; 2597 2598 if (src && batadv_vlan_ap_isola_get(bat_priv, vid)) { 2599 tt_local_entry = batadv_tt_local_hash_find(bat_priv, src, vid); 2600 if (!tt_local_entry || 2601 (tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING)) 2602 goto out; 2603 } 2604 2605 tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid); 2606 if (!tt_global_entry) 2607 goto out; 2608 2609 /* check whether the clients should not communicate due to AP 2610 * isolation 2611 */ 2612 if (tt_local_entry && 2613 _batadv_is_ap_isolated(tt_local_entry, tt_global_entry)) 2614 goto out; 2615 2616 rcu_read_lock(); 2617 best_entry = batadv_transtable_best_orig(bat_priv, tt_global_entry); 2618 /* found anything? */ 2619 if (best_entry) 2620 orig_node = best_entry->orig_node; 2621 if (orig_node && !kref_get_unless_zero(&orig_node->refcount)) 2622 orig_node = NULL; 2623 rcu_read_unlock(); 2624 2625 out: 2626 if (tt_global_entry) 2627 batadv_tt_global_entry_put(tt_global_entry); 2628 if (tt_local_entry) 2629 batadv_tt_local_entry_put(tt_local_entry); 2630 2631 return orig_node; 2632 } 2633 2634 /** 2635 * batadv_tt_global_crc() - calculates the checksum of the local table belonging 2636 * to the given orig_node 2637 * @bat_priv: the bat priv with all the soft interface information 2638 * @orig_node: originator for which the CRC should be computed 2639 * @vid: VLAN identifier for which the CRC32 has to be computed 2640 * 2641 * This function computes the checksum for the global table corresponding to a 2642 * specific originator. In particular, the checksum is computed as follows: For 2643 * each client connected to the originator the CRC32C of the MAC address and the 2644 * VID is computed and then all the CRC32Cs of the various clients are xor'ed 2645 * together. 2646 * 2647 * The idea behind is that CRC32C should be used as much as possible in order to 2648 * produce a unique hash of the table, but since the order which is used to feed 2649 * the CRC32C function affects the result and since every node in the network 2650 * probably sorts the clients differently, the hash function cannot be directly 2651 * computed over the entire table. Hence the CRC32C is used only on 2652 * the single client entry, while all the results are then xor'ed together 2653 * because the XOR operation can combine them all while trying to reduce the 2654 * noise as much as possible. 2655 * 2656 * Return: the checksum of the global table of a given originator. 2657 */ 2658 static u32 batadv_tt_global_crc(struct batadv_priv *bat_priv, 2659 struct batadv_orig_node *orig_node, 2660 unsigned short vid) 2661 { 2662 struct batadv_hashtable *hash = bat_priv->tt.global_hash; 2663 struct batadv_tt_orig_list_entry *tt_orig; 2664 struct batadv_tt_common_entry *tt_common; 2665 struct batadv_tt_global_entry *tt_global; 2666 struct hlist_head *head; 2667 u32 i, crc_tmp, crc = 0; 2668 u8 flags; 2669 __be16 tmp_vid; 2670 2671 for (i = 0; i < hash->size; i++) { 2672 head = &hash->table[i]; 2673 2674 rcu_read_lock(); 2675 hlist_for_each_entry_rcu(tt_common, head, hash_entry) { 2676 tt_global = container_of(tt_common, 2677 struct batadv_tt_global_entry, 2678 common); 2679 /* compute the CRC only for entries belonging to the 2680 * VLAN identified by the vid passed as parameter 2681 */ 2682 if (tt_common->vid != vid) 2683 continue; 2684 2685 /* Roaming clients are in the global table for 2686 * consistency only. They don't have to be 2687 * taken into account while computing the 2688 * global crc 2689 */ 2690 if (tt_common->flags & BATADV_TT_CLIENT_ROAM) 2691 continue; 2692 /* Temporary clients have not been announced yet, so 2693 * they have to be skipped while computing the global 2694 * crc 2695 */ 2696 if (tt_common->flags & BATADV_TT_CLIENT_TEMP) 2697 continue; 2698 2699 /* find out if this global entry is announced by this 2700 * originator 2701 */ 2702 tt_orig = batadv_tt_global_orig_entry_find(tt_global, 2703 orig_node); 2704 if (!tt_orig) 2705 continue; 2706 2707 /* use network order to read the VID: this ensures that 2708 * every node reads the bytes in the same order. 2709 */ 2710 tmp_vid = htons(tt_common->vid); 2711 crc_tmp = crc32c(0, &tmp_vid, sizeof(tmp_vid)); 2712 2713 /* compute the CRC on flags that have to be kept in sync 2714 * among nodes 2715 */ 2716 flags = tt_orig->flags; 2717 crc_tmp = crc32c(crc_tmp, &flags, sizeof(flags)); 2718 2719 crc ^= crc32c(crc_tmp, tt_common->addr, ETH_ALEN); 2720 2721 batadv_tt_orig_list_entry_put(tt_orig); 2722 } 2723 rcu_read_unlock(); 2724 } 2725 2726 return crc; 2727 } 2728 2729 /** 2730 * batadv_tt_local_crc() - calculates the checksum of the local table 2731 * @bat_priv: the bat priv with all the soft interface information 2732 * @vid: VLAN identifier for which the CRC32 has to be computed 2733 * 2734 * For details about the computation, please refer to the documentation for 2735 * batadv_tt_global_crc(). 2736 * 2737 * Return: the checksum of the local table 2738 */ 2739 static u32 batadv_tt_local_crc(struct batadv_priv *bat_priv, 2740 unsigned short vid) 2741 { 2742 struct batadv_hashtable *hash = bat_priv->tt.local_hash; 2743 struct batadv_tt_common_entry *tt_common; 2744 struct hlist_head *head; 2745 u32 i, crc_tmp, crc = 0; 2746 u8 flags; 2747 __be16 tmp_vid; 2748 2749 for (i = 0; i < hash->size; i++) { 2750 head = &hash->table[i]; 2751 2752 rcu_read_lock(); 2753 hlist_for_each_entry_rcu(tt_common, head, hash_entry) { 2754 /* compute the CRC only for entries belonging to the 2755 * VLAN identified by vid 2756 */ 2757 if (tt_common->vid != vid) 2758 continue; 2759 2760 /* not yet committed clients have not to be taken into 2761 * account while computing the CRC 2762 */ 2763 if (tt_common->flags & BATADV_TT_CLIENT_NEW) 2764 continue; 2765 2766 /* use network order to read the VID: this ensures that 2767 * every node reads the bytes in the same order. 2768 */ 2769 tmp_vid = htons(tt_common->vid); 2770 crc_tmp = crc32c(0, &tmp_vid, sizeof(tmp_vid)); 2771 2772 /* compute the CRC on flags that have to be kept in sync 2773 * among nodes 2774 */ 2775 flags = tt_common->flags & BATADV_TT_SYNC_MASK; 2776 crc_tmp = crc32c(crc_tmp, &flags, sizeof(flags)); 2777 2778 crc ^= crc32c(crc_tmp, tt_common->addr, ETH_ALEN); 2779 } 2780 rcu_read_unlock(); 2781 } 2782 2783 return crc; 2784 } 2785 2786 /** 2787 * batadv_tt_req_node_release() - free tt_req node entry 2788 * @ref: kref pointer of the tt req_node entry 2789 */ 2790 static void batadv_tt_req_node_release(struct kref *ref) 2791 { 2792 struct batadv_tt_req_node *tt_req_node; 2793 2794 tt_req_node = container_of(ref, struct batadv_tt_req_node, refcount); 2795 2796 kmem_cache_free(batadv_tt_req_cache, tt_req_node); 2797 } 2798 2799 /** 2800 * batadv_tt_req_node_put() - decrement the tt_req_node refcounter and 2801 * possibly release it 2802 * @tt_req_node: tt_req_node to be free'd 2803 */ 2804 static void batadv_tt_req_node_put(struct batadv_tt_req_node *tt_req_node) 2805 { 2806 kref_put(&tt_req_node->refcount, batadv_tt_req_node_release); 2807 } 2808 2809 static void batadv_tt_req_list_free(struct batadv_priv *bat_priv) 2810 { 2811 struct batadv_tt_req_node *node; 2812 struct hlist_node *safe; 2813 2814 spin_lock_bh(&bat_priv->tt.req_list_lock); 2815 2816 hlist_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) { 2817 hlist_del_init(&node->list); 2818 batadv_tt_req_node_put(node); 2819 } 2820 2821 spin_unlock_bh(&bat_priv->tt.req_list_lock); 2822 } 2823 2824 static void batadv_tt_save_orig_buffer(struct batadv_priv *bat_priv, 2825 struct batadv_orig_node *orig_node, 2826 const void *tt_buff, 2827 u16 tt_buff_len) 2828 { 2829 /* Replace the old buffer only if I received something in the 2830 * last OGM (the OGM could carry no changes) 2831 */ 2832 spin_lock_bh(&orig_node->tt_buff_lock); 2833 if (tt_buff_len > 0) { 2834 kfree(orig_node->tt_buff); 2835 orig_node->tt_buff_len = 0; 2836 orig_node->tt_buff = kmalloc(tt_buff_len, GFP_ATOMIC); 2837 if (orig_node->tt_buff) { 2838 memcpy(orig_node->tt_buff, tt_buff, tt_buff_len); 2839 orig_node->tt_buff_len = tt_buff_len; 2840 } 2841 } 2842 spin_unlock_bh(&orig_node->tt_buff_lock); 2843 } 2844 2845 static void batadv_tt_req_purge(struct batadv_priv *bat_priv) 2846 { 2847 struct batadv_tt_req_node *node; 2848 struct hlist_node *safe; 2849 2850 spin_lock_bh(&bat_priv->tt.req_list_lock); 2851 hlist_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) { 2852 if (batadv_has_timed_out(node->issued_at, 2853 BATADV_TT_REQUEST_TIMEOUT)) { 2854 hlist_del_init(&node->list); 2855 batadv_tt_req_node_put(node); 2856 } 2857 } 2858 spin_unlock_bh(&bat_priv->tt.req_list_lock); 2859 } 2860 2861 /** 2862 * batadv_tt_req_node_new() - search and possibly create a tt_req_node object 2863 * @bat_priv: the bat priv with all the soft interface information 2864 * @orig_node: orig node this request is being issued for 2865 * 2866 * Return: the pointer to the new tt_req_node struct if no request 2867 * has already been issued for this orig_node, NULL otherwise. 2868 */ 2869 static struct batadv_tt_req_node * 2870 batadv_tt_req_node_new(struct batadv_priv *bat_priv, 2871 struct batadv_orig_node *orig_node) 2872 { 2873 struct batadv_tt_req_node *tt_req_node_tmp, *tt_req_node = NULL; 2874 2875 spin_lock_bh(&bat_priv->tt.req_list_lock); 2876 hlist_for_each_entry(tt_req_node_tmp, &bat_priv->tt.req_list, list) { 2877 if (batadv_compare_eth(tt_req_node_tmp, orig_node) && 2878 !batadv_has_timed_out(tt_req_node_tmp->issued_at, 2879 BATADV_TT_REQUEST_TIMEOUT)) 2880 goto unlock; 2881 } 2882 2883 tt_req_node = kmem_cache_alloc(batadv_tt_req_cache, GFP_ATOMIC); 2884 if (!tt_req_node) 2885 goto unlock; 2886 2887 kref_init(&tt_req_node->refcount); 2888 ether_addr_copy(tt_req_node->addr, orig_node->orig); 2889 tt_req_node->issued_at = jiffies; 2890 2891 kref_get(&tt_req_node->refcount); 2892 hlist_add_head(&tt_req_node->list, &bat_priv->tt.req_list); 2893 unlock: 2894 spin_unlock_bh(&bat_priv->tt.req_list_lock); 2895 return tt_req_node; 2896 } 2897 2898 /** 2899 * batadv_tt_local_valid() - verify local tt entry and get flags 2900 * @entry_ptr: to be checked local tt entry 2901 * @data_ptr: not used but definition required to satisfy the callback prototype 2902 * @flags: a pointer to store TT flags for this client to 2903 * 2904 * Checks the validity of the given local TT entry. If it is, then the provided 2905 * flags pointer is updated. 2906 * 2907 * Return: true if the entry is a valid, false otherwise. 2908 */ 2909 static bool batadv_tt_local_valid(const void *entry_ptr, 2910 const void *data_ptr, 2911 u8 *flags) 2912 { 2913 const struct batadv_tt_common_entry *tt_common_entry = entry_ptr; 2914 2915 if (tt_common_entry->flags & BATADV_TT_CLIENT_NEW) 2916 return false; 2917 2918 if (flags) 2919 *flags = tt_common_entry->flags; 2920 2921 return true; 2922 } 2923 2924 /** 2925 * batadv_tt_global_valid() - verify global tt entry and get flags 2926 * @entry_ptr: to be checked global tt entry 2927 * @data_ptr: an orig_node object (may be NULL) 2928 * @flags: a pointer to store TT flags for this client to 2929 * 2930 * Checks the validity of the given global TT entry. If it is, then the provided 2931 * flags pointer is updated either with the common (summed) TT flags if data_ptr 2932 * is NULL or the specific, per originator TT flags otherwise. 2933 * 2934 * Return: true if the entry is a valid, false otherwise. 2935 */ 2936 static bool batadv_tt_global_valid(const void *entry_ptr, 2937 const void *data_ptr, 2938 u8 *flags) 2939 { 2940 const struct batadv_tt_common_entry *tt_common_entry = entry_ptr; 2941 const struct batadv_tt_global_entry *tt_global_entry; 2942 const struct batadv_orig_node *orig_node = data_ptr; 2943 2944 if (tt_common_entry->flags & BATADV_TT_CLIENT_ROAM || 2945 tt_common_entry->flags & BATADV_TT_CLIENT_TEMP) 2946 return false; 2947 2948 tt_global_entry = container_of(tt_common_entry, 2949 struct batadv_tt_global_entry, 2950 common); 2951 2952 return batadv_tt_global_entry_has_orig(tt_global_entry, orig_node, 2953 flags); 2954 } 2955 2956 /** 2957 * batadv_tt_tvlv_generate() - fill the tvlv buff with the tt entries from the 2958 * specified tt hash 2959 * @bat_priv: the bat priv with all the soft interface information 2960 * @hash: hash table containing the tt entries 2961 * @tt_len: expected tvlv tt data buffer length in number of bytes 2962 * @tvlv_buff: pointer to the buffer to fill with the TT data 2963 * @valid_cb: function to filter tt change entries and to return TT flags 2964 * @cb_data: data passed to the filter function as argument 2965 * 2966 * Fills the tvlv buff with the tt entries from the specified hash. If valid_cb 2967 * is not provided then this becomes a no-op. 2968 */ 2969 static void batadv_tt_tvlv_generate(struct batadv_priv *bat_priv, 2970 struct batadv_hashtable *hash, 2971 void *tvlv_buff, u16 tt_len, 2972 bool (*valid_cb)(const void *, 2973 const void *, 2974 u8 *flags), 2975 void *cb_data) 2976 { 2977 struct batadv_tt_common_entry *tt_common_entry; 2978 struct batadv_tvlv_tt_change *tt_change; 2979 struct hlist_head *head; 2980 u16 tt_tot, tt_num_entries = 0; 2981 u8 flags; 2982 bool ret; 2983 u32 i; 2984 2985 tt_tot = batadv_tt_entries(tt_len); 2986 tt_change = (struct batadv_tvlv_tt_change *)tvlv_buff; 2987 2988 if (!valid_cb) 2989 return; 2990 2991 rcu_read_lock(); 2992 for (i = 0; i < hash->size; i++) { 2993 head = &hash->table[i]; 2994 2995 hlist_for_each_entry_rcu(tt_common_entry, 2996 head, hash_entry) { 2997 if (tt_tot == tt_num_entries) 2998 break; 2999 3000 ret = valid_cb(tt_common_entry, cb_data, &flags); 3001 if (!ret) 3002 continue; 3003 3004 ether_addr_copy(tt_change->addr, tt_common_entry->addr); 3005 tt_change->flags = flags; 3006 tt_change->vid = htons(tt_common_entry->vid); 3007 memset(tt_change->reserved, 0, 3008 sizeof(tt_change->reserved)); 3009 3010 tt_num_entries++; 3011 tt_change++; 3012 } 3013 } 3014 rcu_read_unlock(); 3015 } 3016 3017 /** 3018 * batadv_tt_global_check_crc() - check if all the CRCs are correct 3019 * @orig_node: originator for which the CRCs have to be checked 3020 * @tt_vlan: pointer to the first tvlv VLAN entry 3021 * @num_vlan: number of tvlv VLAN entries 3022 * 3023 * Return: true if all the received CRCs match the locally stored ones, false 3024 * otherwise 3025 */ 3026 static bool batadv_tt_global_check_crc(struct batadv_orig_node *orig_node, 3027 struct batadv_tvlv_tt_vlan_data *tt_vlan, 3028 u16 num_vlan) 3029 { 3030 struct batadv_tvlv_tt_vlan_data *tt_vlan_tmp; 3031 struct batadv_orig_node_vlan *vlan; 3032 int i, orig_num_vlan; 3033 u32 crc; 3034 3035 /* check if each received CRC matches the locally stored one */ 3036 for (i = 0; i < num_vlan; i++) { 3037 tt_vlan_tmp = tt_vlan + i; 3038 3039 /* if orig_node is a backbone node for this VLAN, don't check 3040 * the CRC as we ignore all the global entries over it 3041 */ 3042 if (batadv_bla_is_backbone_gw_orig(orig_node->bat_priv, 3043 orig_node->orig, 3044 ntohs(tt_vlan_tmp->vid))) 3045 continue; 3046 3047 vlan = batadv_orig_node_vlan_get(orig_node, 3048 ntohs(tt_vlan_tmp->vid)); 3049 if (!vlan) 3050 return false; 3051 3052 crc = vlan->tt.crc; 3053 batadv_orig_node_vlan_put(vlan); 3054 3055 if (crc != ntohl(tt_vlan_tmp->crc)) 3056 return false; 3057 } 3058 3059 /* check if any excess VLANs exist locally for the originator 3060 * which are not mentioned in the TVLV from the originator. 3061 */ 3062 rcu_read_lock(); 3063 orig_num_vlan = 0; 3064 hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) 3065 orig_num_vlan++; 3066 rcu_read_unlock(); 3067 3068 if (orig_num_vlan > num_vlan) 3069 return false; 3070 3071 return true; 3072 } 3073 3074 /** 3075 * batadv_tt_local_update_crc() - update all the local CRCs 3076 * @bat_priv: the bat priv with all the soft interface information 3077 */ 3078 static void batadv_tt_local_update_crc(struct batadv_priv *bat_priv) 3079 { 3080 struct batadv_softif_vlan *vlan; 3081 3082 /* recompute the global CRC for each VLAN */ 3083 rcu_read_lock(); 3084 hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) { 3085 vlan->tt.crc = batadv_tt_local_crc(bat_priv, vlan->vid); 3086 } 3087 rcu_read_unlock(); 3088 } 3089 3090 /** 3091 * batadv_tt_global_update_crc() - update all the global CRCs for this orig_node 3092 * @bat_priv: the bat priv with all the soft interface information 3093 * @orig_node: the orig_node for which the CRCs have to be updated 3094 */ 3095 static void batadv_tt_global_update_crc(struct batadv_priv *bat_priv, 3096 struct batadv_orig_node *orig_node) 3097 { 3098 struct batadv_orig_node_vlan *vlan; 3099 u32 crc; 3100 3101 /* recompute the global CRC for each VLAN */ 3102 rcu_read_lock(); 3103 hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) { 3104 /* if orig_node is a backbone node for this VLAN, don't compute 3105 * the CRC as we ignore all the global entries over it 3106 */ 3107 if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig, 3108 vlan->vid)) 3109 continue; 3110 3111 crc = batadv_tt_global_crc(bat_priv, orig_node, vlan->vid); 3112 vlan->tt.crc = crc; 3113 } 3114 rcu_read_unlock(); 3115 } 3116 3117 /** 3118 * batadv_send_tt_request() - send a TT Request message to a given node 3119 * @bat_priv: the bat priv with all the soft interface information 3120 * @dst_orig_node: the destination of the message 3121 * @ttvn: the version number that the source of the message is looking for 3122 * @tt_vlan: pointer to the first tvlv VLAN object to request 3123 * @num_vlan: number of tvlv VLAN entries 3124 * @full_table: ask for the entire translation table if true, while only for the 3125 * last TT diff otherwise 3126 * 3127 * Return: true if the TT Request was sent, false otherwise 3128 */ 3129 static bool batadv_send_tt_request(struct batadv_priv *bat_priv, 3130 struct batadv_orig_node *dst_orig_node, 3131 u8 ttvn, 3132 struct batadv_tvlv_tt_vlan_data *tt_vlan, 3133 u16 num_vlan, bool full_table) 3134 { 3135 struct batadv_tvlv_tt_data *tvlv_tt_data = NULL; 3136 struct batadv_tt_req_node *tt_req_node = NULL; 3137 struct batadv_tvlv_tt_vlan_data *tt_vlan_req; 3138 struct batadv_hard_iface *primary_if; 3139 bool ret = false; 3140 int i, size; 3141 3142 primary_if = batadv_primary_if_get_selected(bat_priv); 3143 if (!primary_if) 3144 goto out; 3145 3146 /* The new tt_req will be issued only if I'm not waiting for a 3147 * reply from the same orig_node yet 3148 */ 3149 tt_req_node = batadv_tt_req_node_new(bat_priv, dst_orig_node); 3150 if (!tt_req_node) 3151 goto out; 3152 3153 size = sizeof(*tvlv_tt_data) + sizeof(*tt_vlan_req) * num_vlan; 3154 tvlv_tt_data = kzalloc(size, GFP_ATOMIC); 3155 if (!tvlv_tt_data) 3156 goto out; 3157 3158 tvlv_tt_data->flags = BATADV_TT_REQUEST; 3159 tvlv_tt_data->ttvn = ttvn; 3160 tvlv_tt_data->num_vlan = htons(num_vlan); 3161 3162 /* send all the CRCs within the request. This is needed by intermediate 3163 * nodes to ensure they have the correct table before replying 3164 */ 3165 tt_vlan_req = (struct batadv_tvlv_tt_vlan_data *)(tvlv_tt_data + 1); 3166 for (i = 0; i < num_vlan; i++) { 3167 tt_vlan_req->vid = tt_vlan->vid; 3168 tt_vlan_req->crc = tt_vlan->crc; 3169 3170 tt_vlan_req++; 3171 tt_vlan++; 3172 } 3173 3174 if (full_table) 3175 tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE; 3176 3177 batadv_dbg(BATADV_DBG_TT, bat_priv, "Sending TT_REQUEST to %pM [%c]\n", 3178 dst_orig_node->orig, full_table ? 'F' : '.'); 3179 3180 batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_TX); 3181 batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr, 3182 dst_orig_node->orig, BATADV_TVLV_TT, 1, 3183 tvlv_tt_data, size); 3184 ret = true; 3185 3186 out: 3187 if (primary_if) 3188 batadv_hardif_put(primary_if); 3189 3190 if (ret && tt_req_node) { 3191 spin_lock_bh(&bat_priv->tt.req_list_lock); 3192 if (!hlist_unhashed(&tt_req_node->list)) { 3193 hlist_del_init(&tt_req_node->list); 3194 batadv_tt_req_node_put(tt_req_node); 3195 } 3196 spin_unlock_bh(&bat_priv->tt.req_list_lock); 3197 } 3198 3199 if (tt_req_node) 3200 batadv_tt_req_node_put(tt_req_node); 3201 3202 kfree(tvlv_tt_data); 3203 return ret; 3204 } 3205 3206 /** 3207 * batadv_send_other_tt_response() - send reply to tt request concerning another 3208 * node's translation table 3209 * @bat_priv: the bat priv with all the soft interface information 3210 * @tt_data: tt data containing the tt request information 3211 * @req_src: mac address of tt request sender 3212 * @req_dst: mac address of tt request recipient 3213 * 3214 * Return: true if tt request reply was sent, false otherwise. 3215 */ 3216 static bool batadv_send_other_tt_response(struct batadv_priv *bat_priv, 3217 struct batadv_tvlv_tt_data *tt_data, 3218 u8 *req_src, u8 *req_dst) 3219 { 3220 struct batadv_orig_node *req_dst_orig_node; 3221 struct batadv_orig_node *res_dst_orig_node = NULL; 3222 struct batadv_tvlv_tt_change *tt_change; 3223 struct batadv_tvlv_tt_data *tvlv_tt_data = NULL; 3224 struct batadv_tvlv_tt_vlan_data *tt_vlan; 3225 bool ret = false, full_table; 3226 u8 orig_ttvn, req_ttvn; 3227 u16 tvlv_len; 3228 s32 tt_len; 3229 3230 batadv_dbg(BATADV_DBG_TT, bat_priv, 3231 "Received TT_REQUEST from %pM for ttvn: %u (%pM) [%c]\n", 3232 req_src, tt_data->ttvn, req_dst, 3233 ((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.')); 3234 3235 /* Let's get the orig node of the REAL destination */ 3236 req_dst_orig_node = batadv_orig_hash_find(bat_priv, req_dst); 3237 if (!req_dst_orig_node) 3238 goto out; 3239 3240 res_dst_orig_node = batadv_orig_hash_find(bat_priv, req_src); 3241 if (!res_dst_orig_node) 3242 goto out; 3243 3244 orig_ttvn = (u8)atomic_read(&req_dst_orig_node->last_ttvn); 3245 req_ttvn = tt_data->ttvn; 3246 3247 tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(tt_data + 1); 3248 /* this node doesn't have the requested data */ 3249 if (orig_ttvn != req_ttvn || 3250 !batadv_tt_global_check_crc(req_dst_orig_node, tt_vlan, 3251 ntohs(tt_data->num_vlan))) 3252 goto out; 3253 3254 /* If the full table has been explicitly requested */ 3255 if (tt_data->flags & BATADV_TT_FULL_TABLE || 3256 !req_dst_orig_node->tt_buff) 3257 full_table = true; 3258 else 3259 full_table = false; 3260 3261 /* TT fragmentation hasn't been implemented yet, so send as many 3262 * TT entries fit a single packet as possible only 3263 */ 3264 if (!full_table) { 3265 spin_lock_bh(&req_dst_orig_node->tt_buff_lock); 3266 tt_len = req_dst_orig_node->tt_buff_len; 3267 3268 tvlv_len = batadv_tt_prepare_tvlv_global_data(req_dst_orig_node, 3269 &tvlv_tt_data, 3270 &tt_change, 3271 &tt_len); 3272 if (!tt_len) 3273 goto unlock; 3274 3275 /* Copy the last orig_node's OGM buffer */ 3276 memcpy(tt_change, req_dst_orig_node->tt_buff, 3277 req_dst_orig_node->tt_buff_len); 3278 spin_unlock_bh(&req_dst_orig_node->tt_buff_lock); 3279 } else { 3280 /* allocate the tvlv, put the tt_data and all the tt_vlan_data 3281 * in the initial part 3282 */ 3283 tt_len = -1; 3284 tvlv_len = batadv_tt_prepare_tvlv_global_data(req_dst_orig_node, 3285 &tvlv_tt_data, 3286 &tt_change, 3287 &tt_len); 3288 if (!tt_len) 3289 goto out; 3290 3291 /* fill the rest of the tvlv with the real TT entries */ 3292 batadv_tt_tvlv_generate(bat_priv, bat_priv->tt.global_hash, 3293 tt_change, tt_len, 3294 batadv_tt_global_valid, 3295 req_dst_orig_node); 3296 } 3297 3298 /* Don't send the response, if larger than fragmented packet. */ 3299 tt_len = sizeof(struct batadv_unicast_tvlv_packet) + tvlv_len; 3300 if (tt_len > atomic_read(&bat_priv->packet_size_max)) { 3301 net_ratelimited_function(batadv_info, bat_priv->soft_iface, 3302 "Ignoring TT_REQUEST from %pM; Response size exceeds max packet size.\n", 3303 res_dst_orig_node->orig); 3304 goto out; 3305 } 3306 3307 tvlv_tt_data->flags = BATADV_TT_RESPONSE; 3308 tvlv_tt_data->ttvn = req_ttvn; 3309 3310 if (full_table) 3311 tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE; 3312 3313 batadv_dbg(BATADV_DBG_TT, bat_priv, 3314 "Sending TT_RESPONSE %pM for %pM [%c] (ttvn: %u)\n", 3315 res_dst_orig_node->orig, req_dst_orig_node->orig, 3316 full_table ? 'F' : '.', req_ttvn); 3317 3318 batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX); 3319 3320 batadv_tvlv_unicast_send(bat_priv, req_dst_orig_node->orig, 3321 req_src, BATADV_TVLV_TT, 1, tvlv_tt_data, 3322 tvlv_len); 3323 3324 ret = true; 3325 goto out; 3326 3327 unlock: 3328 spin_unlock_bh(&req_dst_orig_node->tt_buff_lock); 3329 3330 out: 3331 if (res_dst_orig_node) 3332 batadv_orig_node_put(res_dst_orig_node); 3333 if (req_dst_orig_node) 3334 batadv_orig_node_put(req_dst_orig_node); 3335 kfree(tvlv_tt_data); 3336 return ret; 3337 } 3338 3339 /** 3340 * batadv_send_my_tt_response() - send reply to tt request concerning this 3341 * node's translation table 3342 * @bat_priv: the bat priv with all the soft interface information 3343 * @tt_data: tt data containing the tt request information 3344 * @req_src: mac address of tt request sender 3345 * 3346 * Return: true if tt request reply was sent, false otherwise. 3347 */ 3348 static bool batadv_send_my_tt_response(struct batadv_priv *bat_priv, 3349 struct batadv_tvlv_tt_data *tt_data, 3350 u8 *req_src) 3351 { 3352 struct batadv_tvlv_tt_data *tvlv_tt_data = NULL; 3353 struct batadv_hard_iface *primary_if = NULL; 3354 struct batadv_tvlv_tt_change *tt_change; 3355 struct batadv_orig_node *orig_node; 3356 u8 my_ttvn, req_ttvn; 3357 u16 tvlv_len; 3358 bool full_table; 3359 s32 tt_len; 3360 3361 batadv_dbg(BATADV_DBG_TT, bat_priv, 3362 "Received TT_REQUEST from %pM for ttvn: %u (me) [%c]\n", 3363 req_src, tt_data->ttvn, 3364 ((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.')); 3365 3366 spin_lock_bh(&bat_priv->tt.commit_lock); 3367 3368 my_ttvn = (u8)atomic_read(&bat_priv->tt.vn); 3369 req_ttvn = tt_data->ttvn; 3370 3371 orig_node = batadv_orig_hash_find(bat_priv, req_src); 3372 if (!orig_node) 3373 goto out; 3374 3375 primary_if = batadv_primary_if_get_selected(bat_priv); 3376 if (!primary_if) 3377 goto out; 3378 3379 /* If the full table has been explicitly requested or the gap 3380 * is too big send the whole local translation table 3381 */ 3382 if (tt_data->flags & BATADV_TT_FULL_TABLE || my_ttvn != req_ttvn || 3383 !bat_priv->tt.last_changeset) 3384 full_table = true; 3385 else 3386 full_table = false; 3387 3388 /* TT fragmentation hasn't been implemented yet, so send as many 3389 * TT entries fit a single packet as possible only 3390 */ 3391 if (!full_table) { 3392 spin_lock_bh(&bat_priv->tt.last_changeset_lock); 3393 3394 tt_len = bat_priv->tt.last_changeset_len; 3395 tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv, 3396 &tvlv_tt_data, 3397 &tt_change, 3398 &tt_len); 3399 if (!tt_len || !tvlv_len) 3400 goto unlock; 3401 3402 /* Copy the last orig_node's OGM buffer */ 3403 memcpy(tt_change, bat_priv->tt.last_changeset, 3404 bat_priv->tt.last_changeset_len); 3405 spin_unlock_bh(&bat_priv->tt.last_changeset_lock); 3406 } else { 3407 req_ttvn = (u8)atomic_read(&bat_priv->tt.vn); 3408 3409 /* allocate the tvlv, put the tt_data and all the tt_vlan_data 3410 * in the initial part 3411 */ 3412 tt_len = -1; 3413 tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv, 3414 &tvlv_tt_data, 3415 &tt_change, 3416 &tt_len); 3417 if (!tt_len || !tvlv_len) 3418 goto out; 3419 3420 /* fill the rest of the tvlv with the real TT entries */ 3421 batadv_tt_tvlv_generate(bat_priv, bat_priv->tt.local_hash, 3422 tt_change, tt_len, 3423 batadv_tt_local_valid, NULL); 3424 } 3425 3426 tvlv_tt_data->flags = BATADV_TT_RESPONSE; 3427 tvlv_tt_data->ttvn = req_ttvn; 3428 3429 if (full_table) 3430 tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE; 3431 3432 batadv_dbg(BATADV_DBG_TT, bat_priv, 3433 "Sending TT_RESPONSE to %pM [%c] (ttvn: %u)\n", 3434 orig_node->orig, full_table ? 'F' : '.', req_ttvn); 3435 3436 batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX); 3437 3438 batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr, 3439 req_src, BATADV_TVLV_TT, 1, tvlv_tt_data, 3440 tvlv_len); 3441 3442 goto out; 3443 3444 unlock: 3445 spin_unlock_bh(&bat_priv->tt.last_changeset_lock); 3446 out: 3447 spin_unlock_bh(&bat_priv->tt.commit_lock); 3448 if (orig_node) 3449 batadv_orig_node_put(orig_node); 3450 if (primary_if) 3451 batadv_hardif_put(primary_if); 3452 kfree(tvlv_tt_data); 3453 /* The packet was for this host, so it doesn't need to be re-routed */ 3454 return true; 3455 } 3456 3457 /** 3458 * batadv_send_tt_response() - send reply to tt request 3459 * @bat_priv: the bat priv with all the soft interface information 3460 * @tt_data: tt data containing the tt request information 3461 * @req_src: mac address of tt request sender 3462 * @req_dst: mac address of tt request recipient 3463 * 3464 * Return: true if tt request reply was sent, false otherwise. 3465 */ 3466 static bool batadv_send_tt_response(struct batadv_priv *bat_priv, 3467 struct batadv_tvlv_tt_data *tt_data, 3468 u8 *req_src, u8 *req_dst) 3469 { 3470 if (batadv_is_my_mac(bat_priv, req_dst)) 3471 return batadv_send_my_tt_response(bat_priv, tt_data, req_src); 3472 return batadv_send_other_tt_response(bat_priv, tt_data, req_src, 3473 req_dst); 3474 } 3475 3476 static void _batadv_tt_update_changes(struct batadv_priv *bat_priv, 3477 struct batadv_orig_node *orig_node, 3478 struct batadv_tvlv_tt_change *tt_change, 3479 u16 tt_num_changes, u8 ttvn) 3480 { 3481 int i; 3482 int roams; 3483 3484 for (i = 0; i < tt_num_changes; i++) { 3485 if ((tt_change + i)->flags & BATADV_TT_CLIENT_DEL) { 3486 roams = (tt_change + i)->flags & BATADV_TT_CLIENT_ROAM; 3487 batadv_tt_global_del(bat_priv, orig_node, 3488 (tt_change + i)->addr, 3489 ntohs((tt_change + i)->vid), 3490 "tt removed by changes", 3491 roams); 3492 } else { 3493 if (!batadv_tt_global_add(bat_priv, orig_node, 3494 (tt_change + i)->addr, 3495 ntohs((tt_change + i)->vid), 3496 (tt_change + i)->flags, ttvn)) 3497 /* In case of problem while storing a 3498 * global_entry, we stop the updating 3499 * procedure without committing the 3500 * ttvn change. This will avoid to send 3501 * corrupted data on tt_request 3502 */ 3503 return; 3504 } 3505 } 3506 set_bit(BATADV_ORIG_CAPA_HAS_TT, &orig_node->capa_initialized); 3507 } 3508 3509 static void batadv_tt_fill_gtable(struct batadv_priv *bat_priv, 3510 struct batadv_tvlv_tt_change *tt_change, 3511 u8 ttvn, u8 *resp_src, 3512 u16 num_entries) 3513 { 3514 struct batadv_orig_node *orig_node; 3515 3516 orig_node = batadv_orig_hash_find(bat_priv, resp_src); 3517 if (!orig_node) 3518 goto out; 3519 3520 /* Purge the old table first.. */ 3521 batadv_tt_global_del_orig(bat_priv, orig_node, -1, 3522 "Received full table"); 3523 3524 _batadv_tt_update_changes(bat_priv, orig_node, tt_change, num_entries, 3525 ttvn); 3526 3527 spin_lock_bh(&orig_node->tt_buff_lock); 3528 kfree(orig_node->tt_buff); 3529 orig_node->tt_buff_len = 0; 3530 orig_node->tt_buff = NULL; 3531 spin_unlock_bh(&orig_node->tt_buff_lock); 3532 3533 atomic_set(&orig_node->last_ttvn, ttvn); 3534 3535 out: 3536 if (orig_node) 3537 batadv_orig_node_put(orig_node); 3538 } 3539 3540 static void batadv_tt_update_changes(struct batadv_priv *bat_priv, 3541 struct batadv_orig_node *orig_node, 3542 u16 tt_num_changes, u8 ttvn, 3543 struct batadv_tvlv_tt_change *tt_change) 3544 { 3545 _batadv_tt_update_changes(bat_priv, orig_node, tt_change, 3546 tt_num_changes, ttvn); 3547 3548 batadv_tt_save_orig_buffer(bat_priv, orig_node, tt_change, 3549 batadv_tt_len(tt_num_changes)); 3550 atomic_set(&orig_node->last_ttvn, ttvn); 3551 } 3552 3553 /** 3554 * batadv_is_my_client() - check if a client is served by the local node 3555 * @bat_priv: the bat priv with all the soft interface information 3556 * @addr: the mac address of the client to check 3557 * @vid: VLAN identifier 3558 * 3559 * Return: true if the client is served by this node, false otherwise. 3560 */ 3561 bool batadv_is_my_client(struct batadv_priv *bat_priv, const u8 *addr, 3562 unsigned short vid) 3563 { 3564 struct batadv_tt_local_entry *tt_local_entry; 3565 bool ret = false; 3566 3567 tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid); 3568 if (!tt_local_entry) 3569 goto out; 3570 /* Check if the client has been logically deleted (but is kept for 3571 * consistency purpose) 3572 */ 3573 if ((tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING) || 3574 (tt_local_entry->common.flags & BATADV_TT_CLIENT_ROAM)) 3575 goto out; 3576 ret = true; 3577 out: 3578 if (tt_local_entry) 3579 batadv_tt_local_entry_put(tt_local_entry); 3580 return ret; 3581 } 3582 3583 /** 3584 * batadv_handle_tt_response() - process incoming tt reply 3585 * @bat_priv: the bat priv with all the soft interface information 3586 * @tt_data: tt data containing the tt request information 3587 * @resp_src: mac address of tt reply sender 3588 * @num_entries: number of tt change entries appended to the tt data 3589 */ 3590 static void batadv_handle_tt_response(struct batadv_priv *bat_priv, 3591 struct batadv_tvlv_tt_data *tt_data, 3592 u8 *resp_src, u16 num_entries) 3593 { 3594 struct batadv_tt_req_node *node; 3595 struct hlist_node *safe; 3596 struct batadv_orig_node *orig_node = NULL; 3597 struct batadv_tvlv_tt_change *tt_change; 3598 u8 *tvlv_ptr = (u8 *)tt_data; 3599 u16 change_offset; 3600 3601 batadv_dbg(BATADV_DBG_TT, bat_priv, 3602 "Received TT_RESPONSE from %pM for ttvn %d t_size: %d [%c]\n", 3603 resp_src, tt_data->ttvn, num_entries, 3604 ((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.')); 3605 3606 orig_node = batadv_orig_hash_find(bat_priv, resp_src); 3607 if (!orig_node) 3608 goto out; 3609 3610 spin_lock_bh(&orig_node->tt_lock); 3611 3612 change_offset = sizeof(struct batadv_tvlv_tt_vlan_data); 3613 change_offset *= ntohs(tt_data->num_vlan); 3614 change_offset += sizeof(*tt_data); 3615 tvlv_ptr += change_offset; 3616 3617 tt_change = (struct batadv_tvlv_tt_change *)tvlv_ptr; 3618 if (tt_data->flags & BATADV_TT_FULL_TABLE) { 3619 batadv_tt_fill_gtable(bat_priv, tt_change, tt_data->ttvn, 3620 resp_src, num_entries); 3621 } else { 3622 batadv_tt_update_changes(bat_priv, orig_node, num_entries, 3623 tt_data->ttvn, tt_change); 3624 } 3625 3626 /* Recalculate the CRC for this orig_node and store it */ 3627 batadv_tt_global_update_crc(bat_priv, orig_node); 3628 3629 spin_unlock_bh(&orig_node->tt_lock); 3630 3631 /* Delete the tt_req_node from pending tt_requests list */ 3632 spin_lock_bh(&bat_priv->tt.req_list_lock); 3633 hlist_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) { 3634 if (!batadv_compare_eth(node->addr, resp_src)) 3635 continue; 3636 hlist_del_init(&node->list); 3637 batadv_tt_req_node_put(node); 3638 } 3639 3640 spin_unlock_bh(&bat_priv->tt.req_list_lock); 3641 out: 3642 if (orig_node) 3643 batadv_orig_node_put(orig_node); 3644 } 3645 3646 static void batadv_tt_roam_list_free(struct batadv_priv *bat_priv) 3647 { 3648 struct batadv_tt_roam_node *node, *safe; 3649 3650 spin_lock_bh(&bat_priv->tt.roam_list_lock); 3651 3652 list_for_each_entry_safe(node, safe, &bat_priv->tt.roam_list, list) { 3653 list_del(&node->list); 3654 kmem_cache_free(batadv_tt_roam_cache, node); 3655 } 3656 3657 spin_unlock_bh(&bat_priv->tt.roam_list_lock); 3658 } 3659 3660 static void batadv_tt_roam_purge(struct batadv_priv *bat_priv) 3661 { 3662 struct batadv_tt_roam_node *node, *safe; 3663 3664 spin_lock_bh(&bat_priv->tt.roam_list_lock); 3665 list_for_each_entry_safe(node, safe, &bat_priv->tt.roam_list, list) { 3666 if (!batadv_has_timed_out(node->first_time, 3667 BATADV_ROAMING_MAX_TIME)) 3668 continue; 3669 3670 list_del(&node->list); 3671 kmem_cache_free(batadv_tt_roam_cache, node); 3672 } 3673 spin_unlock_bh(&bat_priv->tt.roam_list_lock); 3674 } 3675 3676 /** 3677 * batadv_tt_check_roam_count() - check if a client has roamed too frequently 3678 * @bat_priv: the bat priv with all the soft interface information 3679 * @client: mac address of the roaming client 3680 * 3681 * This function checks whether the client already reached the 3682 * maximum number of possible roaming phases. In this case the ROAMING_ADV 3683 * will not be sent. 3684 * 3685 * Return: true if the ROAMING_ADV can be sent, false otherwise 3686 */ 3687 static bool batadv_tt_check_roam_count(struct batadv_priv *bat_priv, u8 *client) 3688 { 3689 struct batadv_tt_roam_node *tt_roam_node; 3690 bool ret = false; 3691 3692 spin_lock_bh(&bat_priv->tt.roam_list_lock); 3693 /* The new tt_req will be issued only if I'm not waiting for a 3694 * reply from the same orig_node yet 3695 */ 3696 list_for_each_entry(tt_roam_node, &bat_priv->tt.roam_list, list) { 3697 if (!batadv_compare_eth(tt_roam_node->addr, client)) 3698 continue; 3699 3700 if (batadv_has_timed_out(tt_roam_node->first_time, 3701 BATADV_ROAMING_MAX_TIME)) 3702 continue; 3703 3704 if (!batadv_atomic_dec_not_zero(&tt_roam_node->counter)) 3705 /* Sorry, you roamed too many times! */ 3706 goto unlock; 3707 ret = true; 3708 break; 3709 } 3710 3711 if (!ret) { 3712 tt_roam_node = kmem_cache_alloc(batadv_tt_roam_cache, 3713 GFP_ATOMIC); 3714 if (!tt_roam_node) 3715 goto unlock; 3716 3717 tt_roam_node->first_time = jiffies; 3718 atomic_set(&tt_roam_node->counter, 3719 BATADV_ROAMING_MAX_COUNT - 1); 3720 ether_addr_copy(tt_roam_node->addr, client); 3721 3722 list_add(&tt_roam_node->list, &bat_priv->tt.roam_list); 3723 ret = true; 3724 } 3725 3726 unlock: 3727 spin_unlock_bh(&bat_priv->tt.roam_list_lock); 3728 return ret; 3729 } 3730 3731 /** 3732 * batadv_send_roam_adv() - send a roaming advertisement message 3733 * @bat_priv: the bat priv with all the soft interface information 3734 * @client: mac address of the roaming client 3735 * @vid: VLAN identifier 3736 * @orig_node: message destination 3737 * 3738 * Send a ROAMING_ADV message to the node which was previously serving this 3739 * client. This is done to inform the node that from now on all traffic destined 3740 * for this particular roamed client has to be forwarded to the sender of the 3741 * roaming message. 3742 */ 3743 static void batadv_send_roam_adv(struct batadv_priv *bat_priv, u8 *client, 3744 unsigned short vid, 3745 struct batadv_orig_node *orig_node) 3746 { 3747 struct batadv_hard_iface *primary_if; 3748 struct batadv_tvlv_roam_adv tvlv_roam; 3749 3750 primary_if = batadv_primary_if_get_selected(bat_priv); 3751 if (!primary_if) 3752 goto out; 3753 3754 /* before going on we have to check whether the client has 3755 * already roamed to us too many times 3756 */ 3757 if (!batadv_tt_check_roam_count(bat_priv, client)) 3758 goto out; 3759 3760 batadv_dbg(BATADV_DBG_TT, bat_priv, 3761 "Sending ROAMING_ADV to %pM (client %pM, vid: %d)\n", 3762 orig_node->orig, client, batadv_print_vid(vid)); 3763 3764 batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_TX); 3765 3766 memcpy(tvlv_roam.client, client, sizeof(tvlv_roam.client)); 3767 tvlv_roam.vid = htons(vid); 3768 3769 batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr, 3770 orig_node->orig, BATADV_TVLV_ROAM, 1, 3771 &tvlv_roam, sizeof(tvlv_roam)); 3772 3773 out: 3774 if (primary_if) 3775 batadv_hardif_put(primary_if); 3776 } 3777 3778 static void batadv_tt_purge(struct work_struct *work) 3779 { 3780 struct delayed_work *delayed_work; 3781 struct batadv_priv_tt *priv_tt; 3782 struct batadv_priv *bat_priv; 3783 3784 delayed_work = to_delayed_work(work); 3785 priv_tt = container_of(delayed_work, struct batadv_priv_tt, work); 3786 bat_priv = container_of(priv_tt, struct batadv_priv, tt); 3787 3788 batadv_tt_local_purge(bat_priv, BATADV_TT_LOCAL_TIMEOUT); 3789 batadv_tt_global_purge(bat_priv); 3790 batadv_tt_req_purge(bat_priv); 3791 batadv_tt_roam_purge(bat_priv); 3792 3793 queue_delayed_work(batadv_event_workqueue, &bat_priv->tt.work, 3794 msecs_to_jiffies(BATADV_TT_WORK_PERIOD)); 3795 } 3796 3797 /** 3798 * batadv_tt_free() - Free translation table of soft interface 3799 * @bat_priv: the bat priv with all the soft interface information 3800 */ 3801 void batadv_tt_free(struct batadv_priv *bat_priv) 3802 { 3803 batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_TT, 1); 3804 batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_TT, 1); 3805 3806 cancel_delayed_work_sync(&bat_priv->tt.work); 3807 3808 batadv_tt_local_table_free(bat_priv); 3809 batadv_tt_global_table_free(bat_priv); 3810 batadv_tt_req_list_free(bat_priv); 3811 batadv_tt_changes_list_free(bat_priv); 3812 batadv_tt_roam_list_free(bat_priv); 3813 3814 kfree(bat_priv->tt.last_changeset); 3815 } 3816 3817 /** 3818 * batadv_tt_local_set_flags() - set or unset the specified flags on the local 3819 * table and possibly count them in the TT size 3820 * @bat_priv: the bat priv with all the soft interface information 3821 * @flags: the flag to switch 3822 * @enable: whether to set or unset the flag 3823 * @count: whether to increase the TT size by the number of changed entries 3824 */ 3825 static void batadv_tt_local_set_flags(struct batadv_priv *bat_priv, u16 flags, 3826 bool enable, bool count) 3827 { 3828 struct batadv_hashtable *hash = bat_priv->tt.local_hash; 3829 struct batadv_tt_common_entry *tt_common_entry; 3830 struct hlist_head *head; 3831 u32 i; 3832 3833 if (!hash) 3834 return; 3835 3836 for (i = 0; i < hash->size; i++) { 3837 head = &hash->table[i]; 3838 3839 rcu_read_lock(); 3840 hlist_for_each_entry_rcu(tt_common_entry, 3841 head, hash_entry) { 3842 if (enable) { 3843 if ((tt_common_entry->flags & flags) == flags) 3844 continue; 3845 tt_common_entry->flags |= flags; 3846 } else { 3847 if (!(tt_common_entry->flags & flags)) 3848 continue; 3849 tt_common_entry->flags &= ~flags; 3850 } 3851 3852 if (!count) 3853 continue; 3854 3855 batadv_tt_local_size_inc(bat_priv, 3856 tt_common_entry->vid); 3857 } 3858 rcu_read_unlock(); 3859 } 3860 } 3861 3862 /* Purge out all the tt local entries marked with BATADV_TT_CLIENT_PENDING */ 3863 static void batadv_tt_local_purge_pending_clients(struct batadv_priv *bat_priv) 3864 { 3865 struct batadv_hashtable *hash = bat_priv->tt.local_hash; 3866 struct batadv_tt_common_entry *tt_common; 3867 struct batadv_tt_local_entry *tt_local; 3868 struct hlist_node *node_tmp; 3869 struct hlist_head *head; 3870 spinlock_t *list_lock; /* protects write access to the hash lists */ 3871 u32 i; 3872 3873 if (!hash) 3874 return; 3875 3876 for (i = 0; i < hash->size; i++) { 3877 head = &hash->table[i]; 3878 list_lock = &hash->list_locks[i]; 3879 3880 spin_lock_bh(list_lock); 3881 hlist_for_each_entry_safe(tt_common, node_tmp, head, 3882 hash_entry) { 3883 if (!(tt_common->flags & BATADV_TT_CLIENT_PENDING)) 3884 continue; 3885 3886 batadv_dbg(BATADV_DBG_TT, bat_priv, 3887 "Deleting local tt entry (%pM, vid: %d): pending\n", 3888 tt_common->addr, 3889 batadv_print_vid(tt_common->vid)); 3890 3891 batadv_tt_local_size_dec(bat_priv, tt_common->vid); 3892 hlist_del_rcu(&tt_common->hash_entry); 3893 tt_local = container_of(tt_common, 3894 struct batadv_tt_local_entry, 3895 common); 3896 3897 batadv_tt_local_entry_put(tt_local); 3898 } 3899 spin_unlock_bh(list_lock); 3900 } 3901 } 3902 3903 /** 3904 * batadv_tt_local_commit_changes_nolock() - commit all pending local tt changes 3905 * which have been queued in the time since the last commit 3906 * @bat_priv: the bat priv with all the soft interface information 3907 * 3908 * Caller must hold tt->commit_lock. 3909 */ 3910 static void batadv_tt_local_commit_changes_nolock(struct batadv_priv *bat_priv) 3911 { 3912 lockdep_assert_held(&bat_priv->tt.commit_lock); 3913 3914 if (atomic_read(&bat_priv->tt.local_changes) < 1) { 3915 if (!batadv_atomic_dec_not_zero(&bat_priv->tt.ogm_append_cnt)) 3916 batadv_tt_tvlv_container_update(bat_priv); 3917 return; 3918 } 3919 3920 batadv_tt_local_set_flags(bat_priv, BATADV_TT_CLIENT_NEW, false, true); 3921 3922 batadv_tt_local_purge_pending_clients(bat_priv); 3923 batadv_tt_local_update_crc(bat_priv); 3924 3925 /* Increment the TTVN only once per OGM interval */ 3926 atomic_inc(&bat_priv->tt.vn); 3927 batadv_dbg(BATADV_DBG_TT, bat_priv, 3928 "Local changes committed, updating to ttvn %u\n", 3929 (u8)atomic_read(&bat_priv->tt.vn)); 3930 3931 /* reset the sending counter */ 3932 atomic_set(&bat_priv->tt.ogm_append_cnt, BATADV_TT_OGM_APPEND_MAX); 3933 batadv_tt_tvlv_container_update(bat_priv); 3934 } 3935 3936 /** 3937 * batadv_tt_local_commit_changes() - commit all pending local tt changes which 3938 * have been queued in the time since the last commit 3939 * @bat_priv: the bat priv with all the soft interface information 3940 */ 3941 void batadv_tt_local_commit_changes(struct batadv_priv *bat_priv) 3942 { 3943 spin_lock_bh(&bat_priv->tt.commit_lock); 3944 batadv_tt_local_commit_changes_nolock(bat_priv); 3945 spin_unlock_bh(&bat_priv->tt.commit_lock); 3946 } 3947 3948 /** 3949 * batadv_is_ap_isolated() - Check if packet from upper layer should be dropped 3950 * @bat_priv: the bat priv with all the soft interface information 3951 * @src: source mac address of packet 3952 * @dst: destination mac address of packet 3953 * @vid: vlan id of packet 3954 * 3955 * Return: true when src+dst(+vid) pair should be isolated, false otherwise 3956 */ 3957 bool batadv_is_ap_isolated(struct batadv_priv *bat_priv, u8 *src, u8 *dst, 3958 unsigned short vid) 3959 { 3960 struct batadv_tt_local_entry *tt_local_entry; 3961 struct batadv_tt_global_entry *tt_global_entry; 3962 struct batadv_softif_vlan *vlan; 3963 bool ret = false; 3964 3965 vlan = batadv_softif_vlan_get(bat_priv, vid); 3966 if (!vlan) 3967 return false; 3968 3969 if (!atomic_read(&vlan->ap_isolation)) 3970 goto vlan_put; 3971 3972 tt_local_entry = batadv_tt_local_hash_find(bat_priv, dst, vid); 3973 if (!tt_local_entry) 3974 goto vlan_put; 3975 3976 tt_global_entry = batadv_tt_global_hash_find(bat_priv, src, vid); 3977 if (!tt_global_entry) 3978 goto local_entry_put; 3979 3980 if (_batadv_is_ap_isolated(tt_local_entry, tt_global_entry)) 3981 ret = true; 3982 3983 batadv_tt_global_entry_put(tt_global_entry); 3984 local_entry_put: 3985 batadv_tt_local_entry_put(tt_local_entry); 3986 vlan_put: 3987 batadv_softif_vlan_put(vlan); 3988 return ret; 3989 } 3990 3991 /** 3992 * batadv_tt_update_orig() - update global translation table with new tt 3993 * information received via ogms 3994 * @bat_priv: the bat priv with all the soft interface information 3995 * @orig_node: the orig_node of the ogm 3996 * @tt_buff: pointer to the first tvlv VLAN entry 3997 * @tt_num_vlan: number of tvlv VLAN entries 3998 * @tt_change: pointer to the first entry in the TT buffer 3999 * @tt_num_changes: number of tt changes inside the tt buffer 4000 * @ttvn: translation table version number of this changeset 4001 */ 4002 static void batadv_tt_update_orig(struct batadv_priv *bat_priv, 4003 struct batadv_orig_node *orig_node, 4004 const void *tt_buff, u16 tt_num_vlan, 4005 struct batadv_tvlv_tt_change *tt_change, 4006 u16 tt_num_changes, u8 ttvn) 4007 { 4008 u8 orig_ttvn = (u8)atomic_read(&orig_node->last_ttvn); 4009 struct batadv_tvlv_tt_vlan_data *tt_vlan; 4010 bool full_table = true; 4011 bool has_tt_init; 4012 4013 tt_vlan = (struct batadv_tvlv_tt_vlan_data *)tt_buff; 4014 has_tt_init = test_bit(BATADV_ORIG_CAPA_HAS_TT, 4015 &orig_node->capa_initialized); 4016 4017 /* orig table not initialised AND first diff is in the OGM OR the ttvn 4018 * increased by one -> we can apply the attached changes 4019 */ 4020 if ((!has_tt_init && ttvn == 1) || ttvn - orig_ttvn == 1) { 4021 /* the OGM could not contain the changes due to their size or 4022 * because they have already been sent BATADV_TT_OGM_APPEND_MAX 4023 * times. 4024 * In this case send a tt request 4025 */ 4026 if (!tt_num_changes) { 4027 full_table = false; 4028 goto request_table; 4029 } 4030 4031 spin_lock_bh(&orig_node->tt_lock); 4032 4033 batadv_tt_update_changes(bat_priv, orig_node, tt_num_changes, 4034 ttvn, tt_change); 4035 4036 /* Even if we received the precomputed crc with the OGM, we 4037 * prefer to recompute it to spot any possible inconsistency 4038 * in the global table 4039 */ 4040 batadv_tt_global_update_crc(bat_priv, orig_node); 4041 4042 spin_unlock_bh(&orig_node->tt_lock); 4043 4044 /* The ttvn alone is not enough to guarantee consistency 4045 * because a single value could represent different states 4046 * (due to the wrap around). Thus a node has to check whether 4047 * the resulting table (after applying the changes) is still 4048 * consistent or not. E.g. a node could disconnect while its 4049 * ttvn is X and reconnect on ttvn = X + TTVN_MAX: in this case 4050 * checking the CRC value is mandatory to detect the 4051 * inconsistency 4052 */ 4053 if (!batadv_tt_global_check_crc(orig_node, tt_vlan, 4054 tt_num_vlan)) 4055 goto request_table; 4056 } else { 4057 /* if we missed more than one change or our tables are not 4058 * in sync anymore -> request fresh tt data 4059 */ 4060 if (!has_tt_init || ttvn != orig_ttvn || 4061 !batadv_tt_global_check_crc(orig_node, tt_vlan, 4062 tt_num_vlan)) { 4063 request_table: 4064 batadv_dbg(BATADV_DBG_TT, bat_priv, 4065 "TT inconsistency for %pM. Need to retrieve the correct information (ttvn: %u last_ttvn: %u num_changes: %u)\n", 4066 orig_node->orig, ttvn, orig_ttvn, 4067 tt_num_changes); 4068 batadv_send_tt_request(bat_priv, orig_node, ttvn, 4069 tt_vlan, tt_num_vlan, 4070 full_table); 4071 return; 4072 } 4073 } 4074 } 4075 4076 /** 4077 * batadv_tt_global_client_is_roaming() - check if a client is marked as roaming 4078 * @bat_priv: the bat priv with all the soft interface information 4079 * @addr: the mac address of the client to check 4080 * @vid: VLAN identifier 4081 * 4082 * Return: true if we know that the client has moved from its old originator 4083 * to another one. This entry is still kept for consistency purposes and will be 4084 * deleted later by a DEL or because of timeout 4085 */ 4086 bool batadv_tt_global_client_is_roaming(struct batadv_priv *bat_priv, 4087 u8 *addr, unsigned short vid) 4088 { 4089 struct batadv_tt_global_entry *tt_global_entry; 4090 bool ret = false; 4091 4092 tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid); 4093 if (!tt_global_entry) 4094 goto out; 4095 4096 ret = tt_global_entry->common.flags & BATADV_TT_CLIENT_ROAM; 4097 batadv_tt_global_entry_put(tt_global_entry); 4098 out: 4099 return ret; 4100 } 4101 4102 /** 4103 * batadv_tt_local_client_is_roaming() - tells whether the client is roaming 4104 * @bat_priv: the bat priv with all the soft interface information 4105 * @addr: the mac address of the local client to query 4106 * @vid: VLAN identifier 4107 * 4108 * Return: true if the local client is known to be roaming (it is not served by 4109 * this node anymore) or not. If yes, the client is still present in the table 4110 * to keep the latter consistent with the node TTVN 4111 */ 4112 bool batadv_tt_local_client_is_roaming(struct batadv_priv *bat_priv, 4113 u8 *addr, unsigned short vid) 4114 { 4115 struct batadv_tt_local_entry *tt_local_entry; 4116 bool ret = false; 4117 4118 tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid); 4119 if (!tt_local_entry) 4120 goto out; 4121 4122 ret = tt_local_entry->common.flags & BATADV_TT_CLIENT_ROAM; 4123 batadv_tt_local_entry_put(tt_local_entry); 4124 out: 4125 return ret; 4126 } 4127 4128 /** 4129 * batadv_tt_add_temporary_global_entry() - Add temporary entry to global TT 4130 * @bat_priv: the bat priv with all the soft interface information 4131 * @orig_node: orig node which the temporary entry should be associated with 4132 * @addr: mac address of the client 4133 * @vid: VLAN id of the new temporary global translation table 4134 * 4135 * Return: true when temporary tt entry could be added, false otherwise 4136 */ 4137 bool batadv_tt_add_temporary_global_entry(struct batadv_priv *bat_priv, 4138 struct batadv_orig_node *orig_node, 4139 const unsigned char *addr, 4140 unsigned short vid) 4141 { 4142 /* ignore loop detect macs, they are not supposed to be in the tt local 4143 * data as well. 4144 */ 4145 if (batadv_bla_is_loopdetect_mac(addr)) 4146 return false; 4147 4148 if (!batadv_tt_global_add(bat_priv, orig_node, addr, vid, 4149 BATADV_TT_CLIENT_TEMP, 4150 atomic_read(&orig_node->last_ttvn))) 4151 return false; 4152 4153 batadv_dbg(BATADV_DBG_TT, bat_priv, 4154 "Added temporary global client (addr: %pM, vid: %d, orig: %pM)\n", 4155 addr, batadv_print_vid(vid), orig_node->orig); 4156 4157 return true; 4158 } 4159 4160 /** 4161 * batadv_tt_local_resize_to_mtu() - resize the local translation table fit the 4162 * maximum packet size that can be transported through the mesh 4163 * @soft_iface: netdev struct of the mesh interface 4164 * 4165 * Remove entries older than 'timeout' and half timeout if more entries need 4166 * to be removed. 4167 */ 4168 void batadv_tt_local_resize_to_mtu(struct net_device *soft_iface) 4169 { 4170 struct batadv_priv *bat_priv = netdev_priv(soft_iface); 4171 int packet_size_max = atomic_read(&bat_priv->packet_size_max); 4172 int table_size, timeout = BATADV_TT_LOCAL_TIMEOUT / 2; 4173 bool reduced = false; 4174 4175 spin_lock_bh(&bat_priv->tt.commit_lock); 4176 4177 while (true) { 4178 table_size = batadv_tt_local_table_transmit_size(bat_priv); 4179 if (packet_size_max >= table_size) 4180 break; 4181 4182 batadv_tt_local_purge(bat_priv, timeout); 4183 batadv_tt_local_purge_pending_clients(bat_priv); 4184 4185 timeout /= 2; 4186 reduced = true; 4187 net_ratelimited_function(batadv_info, soft_iface, 4188 "Forced to purge local tt entries to fit new maximum fragment MTU (%i)\n", 4189 packet_size_max); 4190 } 4191 4192 /* commit these changes immediately, to avoid synchronization problem 4193 * with the TTVN 4194 */ 4195 if (reduced) 4196 batadv_tt_local_commit_changes_nolock(bat_priv); 4197 4198 spin_unlock_bh(&bat_priv->tt.commit_lock); 4199 } 4200 4201 /** 4202 * batadv_tt_tvlv_ogm_handler_v1() - process incoming tt tvlv container 4203 * @bat_priv: the bat priv with all the soft interface information 4204 * @orig: the orig_node of the ogm 4205 * @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags) 4206 * @tvlv_value: tvlv buffer containing the gateway data 4207 * @tvlv_value_len: tvlv buffer length 4208 */ 4209 static void batadv_tt_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv, 4210 struct batadv_orig_node *orig, 4211 u8 flags, void *tvlv_value, 4212 u16 tvlv_value_len) 4213 { 4214 struct batadv_tvlv_tt_vlan_data *tt_vlan; 4215 struct batadv_tvlv_tt_change *tt_change; 4216 struct batadv_tvlv_tt_data *tt_data; 4217 u16 num_entries, num_vlan; 4218 4219 if (tvlv_value_len < sizeof(*tt_data)) 4220 return; 4221 4222 tt_data = (struct batadv_tvlv_tt_data *)tvlv_value; 4223 tvlv_value_len -= sizeof(*tt_data); 4224 4225 num_vlan = ntohs(tt_data->num_vlan); 4226 4227 if (tvlv_value_len < sizeof(*tt_vlan) * num_vlan) 4228 return; 4229 4230 tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(tt_data + 1); 4231 tt_change = (struct batadv_tvlv_tt_change *)(tt_vlan + num_vlan); 4232 tvlv_value_len -= sizeof(*tt_vlan) * num_vlan; 4233 4234 num_entries = batadv_tt_entries(tvlv_value_len); 4235 4236 batadv_tt_update_orig(bat_priv, orig, tt_vlan, num_vlan, tt_change, 4237 num_entries, tt_data->ttvn); 4238 } 4239 4240 /** 4241 * batadv_tt_tvlv_unicast_handler_v1() - process incoming (unicast) tt tvlv 4242 * container 4243 * @bat_priv: the bat priv with all the soft interface information 4244 * @src: mac address of tt tvlv sender 4245 * @dst: mac address of tt tvlv recipient 4246 * @tvlv_value: tvlv buffer containing the tt data 4247 * @tvlv_value_len: tvlv buffer length 4248 * 4249 * Return: NET_RX_DROP if the tt tvlv is to be re-routed, NET_RX_SUCCESS 4250 * otherwise. 4251 */ 4252 static int batadv_tt_tvlv_unicast_handler_v1(struct batadv_priv *bat_priv, 4253 u8 *src, u8 *dst, 4254 void *tvlv_value, 4255 u16 tvlv_value_len) 4256 { 4257 struct batadv_tvlv_tt_data *tt_data; 4258 u16 tt_vlan_len, tt_num_entries; 4259 char tt_flag; 4260 bool ret; 4261 4262 if (tvlv_value_len < sizeof(*tt_data)) 4263 return NET_RX_SUCCESS; 4264 4265 tt_data = (struct batadv_tvlv_tt_data *)tvlv_value; 4266 tvlv_value_len -= sizeof(*tt_data); 4267 4268 tt_vlan_len = sizeof(struct batadv_tvlv_tt_vlan_data); 4269 tt_vlan_len *= ntohs(tt_data->num_vlan); 4270 4271 if (tvlv_value_len < tt_vlan_len) 4272 return NET_RX_SUCCESS; 4273 4274 tvlv_value_len -= tt_vlan_len; 4275 tt_num_entries = batadv_tt_entries(tvlv_value_len); 4276 4277 switch (tt_data->flags & BATADV_TT_DATA_TYPE_MASK) { 4278 case BATADV_TT_REQUEST: 4279 batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_RX); 4280 4281 /* If this node cannot provide a TT response the tt_request is 4282 * forwarded 4283 */ 4284 ret = batadv_send_tt_response(bat_priv, tt_data, src, dst); 4285 if (!ret) { 4286 if (tt_data->flags & BATADV_TT_FULL_TABLE) 4287 tt_flag = 'F'; 4288 else 4289 tt_flag = '.'; 4290 4291 batadv_dbg(BATADV_DBG_TT, bat_priv, 4292 "Routing TT_REQUEST to %pM [%c]\n", 4293 dst, tt_flag); 4294 /* tvlv API will re-route the packet */ 4295 return NET_RX_DROP; 4296 } 4297 break; 4298 case BATADV_TT_RESPONSE: 4299 batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_RX); 4300 4301 if (batadv_is_my_mac(bat_priv, dst)) { 4302 batadv_handle_tt_response(bat_priv, tt_data, 4303 src, tt_num_entries); 4304 return NET_RX_SUCCESS; 4305 } 4306 4307 if (tt_data->flags & BATADV_TT_FULL_TABLE) 4308 tt_flag = 'F'; 4309 else 4310 tt_flag = '.'; 4311 4312 batadv_dbg(BATADV_DBG_TT, bat_priv, 4313 "Routing TT_RESPONSE to %pM [%c]\n", dst, tt_flag); 4314 4315 /* tvlv API will re-route the packet */ 4316 return NET_RX_DROP; 4317 } 4318 4319 return NET_RX_SUCCESS; 4320 } 4321 4322 /** 4323 * batadv_roam_tvlv_unicast_handler_v1() - process incoming tt roam tvlv 4324 * container 4325 * @bat_priv: the bat priv with all the soft interface information 4326 * @src: mac address of tt tvlv sender 4327 * @dst: mac address of tt tvlv recipient 4328 * @tvlv_value: tvlv buffer containing the tt data 4329 * @tvlv_value_len: tvlv buffer length 4330 * 4331 * Return: NET_RX_DROP if the tt roam tvlv is to be re-routed, NET_RX_SUCCESS 4332 * otherwise. 4333 */ 4334 static int batadv_roam_tvlv_unicast_handler_v1(struct batadv_priv *bat_priv, 4335 u8 *src, u8 *dst, 4336 void *tvlv_value, 4337 u16 tvlv_value_len) 4338 { 4339 struct batadv_tvlv_roam_adv *roaming_adv; 4340 struct batadv_orig_node *orig_node = NULL; 4341 4342 /* If this node is not the intended recipient of the 4343 * roaming advertisement the packet is forwarded 4344 * (the tvlv API will re-route the packet). 4345 */ 4346 if (!batadv_is_my_mac(bat_priv, dst)) 4347 return NET_RX_DROP; 4348 4349 if (tvlv_value_len < sizeof(*roaming_adv)) 4350 goto out; 4351 4352 orig_node = batadv_orig_hash_find(bat_priv, src); 4353 if (!orig_node) 4354 goto out; 4355 4356 batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_RX); 4357 roaming_adv = (struct batadv_tvlv_roam_adv *)tvlv_value; 4358 4359 batadv_dbg(BATADV_DBG_TT, bat_priv, 4360 "Received ROAMING_ADV from %pM (client %pM)\n", 4361 src, roaming_adv->client); 4362 4363 batadv_tt_global_add(bat_priv, orig_node, roaming_adv->client, 4364 ntohs(roaming_adv->vid), BATADV_TT_CLIENT_ROAM, 4365 atomic_read(&orig_node->last_ttvn) + 1); 4366 4367 out: 4368 if (orig_node) 4369 batadv_orig_node_put(orig_node); 4370 return NET_RX_SUCCESS; 4371 } 4372 4373 /** 4374 * batadv_tt_init() - initialise the translation table internals 4375 * @bat_priv: the bat priv with all the soft interface information 4376 * 4377 * Return: 0 on success or negative error number in case of failure. 4378 */ 4379 int batadv_tt_init(struct batadv_priv *bat_priv) 4380 { 4381 int ret; 4382 4383 /* synchronized flags must be remote */ 4384 BUILD_BUG_ON(!(BATADV_TT_SYNC_MASK & BATADV_TT_REMOTE_MASK)); 4385 4386 ret = batadv_tt_local_init(bat_priv); 4387 if (ret < 0) 4388 return ret; 4389 4390 ret = batadv_tt_global_init(bat_priv); 4391 if (ret < 0) 4392 return ret; 4393 4394 batadv_tvlv_handler_register(bat_priv, batadv_tt_tvlv_ogm_handler_v1, 4395 batadv_tt_tvlv_unicast_handler_v1, 4396 BATADV_TVLV_TT, 1, BATADV_NO_FLAGS); 4397 4398 batadv_tvlv_handler_register(bat_priv, NULL, 4399 batadv_roam_tvlv_unicast_handler_v1, 4400 BATADV_TVLV_ROAM, 1, BATADV_NO_FLAGS); 4401 4402 INIT_DELAYED_WORK(&bat_priv->tt.work, batadv_tt_purge); 4403 queue_delayed_work(batadv_event_workqueue, &bat_priv->tt.work, 4404 msecs_to_jiffies(BATADV_TT_WORK_PERIOD)); 4405 4406 return 1; 4407 } 4408 4409 /** 4410 * batadv_tt_global_is_isolated() - check if a client is marked as isolated 4411 * @bat_priv: the bat priv with all the soft interface information 4412 * @addr: the mac address of the client 4413 * @vid: the identifier of the VLAN where this client is connected 4414 * 4415 * Return: true if the client is marked with the TT_CLIENT_ISOLA flag, false 4416 * otherwise 4417 */ 4418 bool batadv_tt_global_is_isolated(struct batadv_priv *bat_priv, 4419 const u8 *addr, unsigned short vid) 4420 { 4421 struct batadv_tt_global_entry *tt; 4422 bool ret; 4423 4424 tt = batadv_tt_global_hash_find(bat_priv, addr, vid); 4425 if (!tt) 4426 return false; 4427 4428 ret = tt->common.flags & BATADV_TT_CLIENT_ISOLA; 4429 4430 batadv_tt_global_entry_put(tt); 4431 4432 return ret; 4433 } 4434 4435 /** 4436 * batadv_tt_cache_init() - Initialize tt memory object cache 4437 * 4438 * Return: 0 on success or negative error number in case of failure. 4439 */ 4440 int __init batadv_tt_cache_init(void) 4441 { 4442 size_t tl_size = sizeof(struct batadv_tt_local_entry); 4443 size_t tg_size = sizeof(struct batadv_tt_global_entry); 4444 size_t tt_orig_size = sizeof(struct batadv_tt_orig_list_entry); 4445 size_t tt_change_size = sizeof(struct batadv_tt_change_node); 4446 size_t tt_req_size = sizeof(struct batadv_tt_req_node); 4447 size_t tt_roam_size = sizeof(struct batadv_tt_roam_node); 4448 4449 batadv_tl_cache = kmem_cache_create("batadv_tl_cache", tl_size, 0, 4450 SLAB_HWCACHE_ALIGN, NULL); 4451 if (!batadv_tl_cache) 4452 return -ENOMEM; 4453 4454 batadv_tg_cache = kmem_cache_create("batadv_tg_cache", tg_size, 0, 4455 SLAB_HWCACHE_ALIGN, NULL); 4456 if (!batadv_tg_cache) 4457 goto err_tt_tl_destroy; 4458 4459 batadv_tt_orig_cache = kmem_cache_create("batadv_tt_orig_cache", 4460 tt_orig_size, 0, 4461 SLAB_HWCACHE_ALIGN, NULL); 4462 if (!batadv_tt_orig_cache) 4463 goto err_tt_tg_destroy; 4464 4465 batadv_tt_change_cache = kmem_cache_create("batadv_tt_change_cache", 4466 tt_change_size, 0, 4467 SLAB_HWCACHE_ALIGN, NULL); 4468 if (!batadv_tt_change_cache) 4469 goto err_tt_orig_destroy; 4470 4471 batadv_tt_req_cache = kmem_cache_create("batadv_tt_req_cache", 4472 tt_req_size, 0, 4473 SLAB_HWCACHE_ALIGN, NULL); 4474 if (!batadv_tt_req_cache) 4475 goto err_tt_change_destroy; 4476 4477 batadv_tt_roam_cache = kmem_cache_create("batadv_tt_roam_cache", 4478 tt_roam_size, 0, 4479 SLAB_HWCACHE_ALIGN, NULL); 4480 if (!batadv_tt_roam_cache) 4481 goto err_tt_req_destroy; 4482 4483 return 0; 4484 4485 err_tt_req_destroy: 4486 kmem_cache_destroy(batadv_tt_req_cache); 4487 batadv_tt_req_cache = NULL; 4488 err_tt_change_destroy: 4489 kmem_cache_destroy(batadv_tt_change_cache); 4490 batadv_tt_change_cache = NULL; 4491 err_tt_orig_destroy: 4492 kmem_cache_destroy(batadv_tt_orig_cache); 4493 batadv_tt_orig_cache = NULL; 4494 err_tt_tg_destroy: 4495 kmem_cache_destroy(batadv_tg_cache); 4496 batadv_tg_cache = NULL; 4497 err_tt_tl_destroy: 4498 kmem_cache_destroy(batadv_tl_cache); 4499 batadv_tl_cache = NULL; 4500 4501 return -ENOMEM; 4502 } 4503 4504 /** 4505 * batadv_tt_cache_destroy() - Destroy tt memory object cache 4506 */ 4507 void batadv_tt_cache_destroy(void) 4508 { 4509 kmem_cache_destroy(batadv_tl_cache); 4510 kmem_cache_destroy(batadv_tg_cache); 4511 kmem_cache_destroy(batadv_tt_orig_cache); 4512 kmem_cache_destroy(batadv_tt_change_cache); 4513 kmem_cache_destroy(batadv_tt_req_cache); 4514 kmem_cache_destroy(batadv_tt_roam_cache); 4515 } 4516