1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (C) 2009-2019 B.A.T.M.A.N. contributors: 3 * 4 * Marek Lindner, Simon Wunderlich 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 "originator.h" 20 #include "main.h" 21 22 #include <linux/atomic.h> 23 #include <linux/errno.h> 24 #include <linux/etherdevice.h> 25 #include <linux/gfp.h> 26 #include <linux/jiffies.h> 27 #include <linux/kernel.h> 28 #include <linux/kref.h> 29 #include <linux/list.h> 30 #include <linux/lockdep.h> 31 #include <linux/netdevice.h> 32 #include <linux/netlink.h> 33 #include <linux/rculist.h> 34 #include <linux/rcupdate.h> 35 #include <linux/seq_file.h> 36 #include <linux/skbuff.h> 37 #include <linux/slab.h> 38 #include <linux/spinlock.h> 39 #include <linux/stddef.h> 40 #include <linux/workqueue.h> 41 #include <net/sock.h> 42 #include <uapi/linux/batman_adv.h> 43 44 #include "bat_algo.h" 45 #include "distributed-arp-table.h" 46 #include "fragmentation.h" 47 #include "gateway_client.h" 48 #include "hard-interface.h" 49 #include "hash.h" 50 #include "log.h" 51 #include "multicast.h" 52 #include "netlink.h" 53 #include "network-coding.h" 54 #include "routing.h" 55 #include "soft-interface.h" 56 #include "translation-table.h" 57 58 /* hash class keys */ 59 static struct lock_class_key batadv_orig_hash_lock_class_key; 60 61 /** 62 * batadv_orig_hash_find() - Find and return originator from orig_hash 63 * @bat_priv: the bat priv with all the soft interface information 64 * @data: mac address of the originator 65 * 66 * Return: orig_node (with increased refcnt), NULL on errors 67 */ 68 struct batadv_orig_node * 69 batadv_orig_hash_find(struct batadv_priv *bat_priv, const void *data) 70 { 71 struct batadv_hashtable *hash = bat_priv->orig_hash; 72 struct hlist_head *head; 73 struct batadv_orig_node *orig_node, *orig_node_tmp = NULL; 74 int index; 75 76 if (!hash) 77 return NULL; 78 79 index = batadv_choose_orig(data, hash->size); 80 head = &hash->table[index]; 81 82 rcu_read_lock(); 83 hlist_for_each_entry_rcu(orig_node, head, hash_entry) { 84 if (!batadv_compare_eth(orig_node, data)) 85 continue; 86 87 if (!kref_get_unless_zero(&orig_node->refcount)) 88 continue; 89 90 orig_node_tmp = orig_node; 91 break; 92 } 93 rcu_read_unlock(); 94 95 return orig_node_tmp; 96 } 97 98 static void batadv_purge_orig(struct work_struct *work); 99 100 /** 101 * batadv_compare_orig() - comparing function used in the originator hash table 102 * @node: node in the local table 103 * @data2: second object to compare the node to 104 * 105 * Return: true if they are the same originator 106 */ 107 bool batadv_compare_orig(const struct hlist_node *node, const void *data2) 108 { 109 const void *data1 = container_of(node, struct batadv_orig_node, 110 hash_entry); 111 112 return batadv_compare_eth(data1, data2); 113 } 114 115 /** 116 * batadv_orig_node_vlan_get() - get an orig_node_vlan object 117 * @orig_node: the originator serving the VLAN 118 * @vid: the VLAN identifier 119 * 120 * Return: the vlan object identified by vid and belonging to orig_node or NULL 121 * if it does not exist. 122 */ 123 struct batadv_orig_node_vlan * 124 batadv_orig_node_vlan_get(struct batadv_orig_node *orig_node, 125 unsigned short vid) 126 { 127 struct batadv_orig_node_vlan *vlan = NULL, *tmp; 128 129 rcu_read_lock(); 130 hlist_for_each_entry_rcu(tmp, &orig_node->vlan_list, list) { 131 if (tmp->vid != vid) 132 continue; 133 134 if (!kref_get_unless_zero(&tmp->refcount)) 135 continue; 136 137 vlan = tmp; 138 139 break; 140 } 141 rcu_read_unlock(); 142 143 return vlan; 144 } 145 146 /** 147 * batadv_orig_node_vlan_new() - search and possibly create an orig_node_vlan 148 * object 149 * @orig_node: the originator serving the VLAN 150 * @vid: the VLAN identifier 151 * 152 * Return: NULL in case of failure or the vlan object identified by vid and 153 * belonging to orig_node otherwise. The object is created and added to the list 154 * if it does not exist. 155 * 156 * The object is returned with refcounter increased by 1. 157 */ 158 struct batadv_orig_node_vlan * 159 batadv_orig_node_vlan_new(struct batadv_orig_node *orig_node, 160 unsigned short vid) 161 { 162 struct batadv_orig_node_vlan *vlan; 163 164 spin_lock_bh(&orig_node->vlan_list_lock); 165 166 /* first look if an object for this vid already exists */ 167 vlan = batadv_orig_node_vlan_get(orig_node, vid); 168 if (vlan) 169 goto out; 170 171 vlan = kzalloc(sizeof(*vlan), GFP_ATOMIC); 172 if (!vlan) 173 goto out; 174 175 kref_init(&vlan->refcount); 176 vlan->vid = vid; 177 178 kref_get(&vlan->refcount); 179 hlist_add_head_rcu(&vlan->list, &orig_node->vlan_list); 180 181 out: 182 spin_unlock_bh(&orig_node->vlan_list_lock); 183 184 return vlan; 185 } 186 187 /** 188 * batadv_orig_node_vlan_release() - release originator-vlan object from lists 189 * and queue for free after rcu grace period 190 * @ref: kref pointer of the originator-vlan object 191 */ 192 static void batadv_orig_node_vlan_release(struct kref *ref) 193 { 194 struct batadv_orig_node_vlan *orig_vlan; 195 196 orig_vlan = container_of(ref, struct batadv_orig_node_vlan, refcount); 197 198 kfree_rcu(orig_vlan, rcu); 199 } 200 201 /** 202 * batadv_orig_node_vlan_put() - decrement the refcounter and possibly release 203 * the originator-vlan object 204 * @orig_vlan: the originator-vlan object to release 205 */ 206 void batadv_orig_node_vlan_put(struct batadv_orig_node_vlan *orig_vlan) 207 { 208 kref_put(&orig_vlan->refcount, batadv_orig_node_vlan_release); 209 } 210 211 /** 212 * batadv_originator_init() - Initialize all originator structures 213 * @bat_priv: the bat priv with all the soft interface information 214 * 215 * Return: 0 on success or negative error number in case of failure 216 */ 217 int batadv_originator_init(struct batadv_priv *bat_priv) 218 { 219 if (bat_priv->orig_hash) 220 return 0; 221 222 bat_priv->orig_hash = batadv_hash_new(1024); 223 224 if (!bat_priv->orig_hash) 225 goto err; 226 227 batadv_hash_set_lock_class(bat_priv->orig_hash, 228 &batadv_orig_hash_lock_class_key); 229 230 INIT_DELAYED_WORK(&bat_priv->orig_work, batadv_purge_orig); 231 queue_delayed_work(batadv_event_workqueue, 232 &bat_priv->orig_work, 233 msecs_to_jiffies(BATADV_ORIG_WORK_PERIOD)); 234 235 return 0; 236 237 err: 238 return -ENOMEM; 239 } 240 241 /** 242 * batadv_neigh_ifinfo_release() - release neigh_ifinfo from lists and queue for 243 * free after rcu grace period 244 * @ref: kref pointer of the neigh_ifinfo 245 */ 246 static void batadv_neigh_ifinfo_release(struct kref *ref) 247 { 248 struct batadv_neigh_ifinfo *neigh_ifinfo; 249 250 neigh_ifinfo = container_of(ref, struct batadv_neigh_ifinfo, refcount); 251 252 if (neigh_ifinfo->if_outgoing != BATADV_IF_DEFAULT) 253 batadv_hardif_put(neigh_ifinfo->if_outgoing); 254 255 kfree_rcu(neigh_ifinfo, rcu); 256 } 257 258 /** 259 * batadv_neigh_ifinfo_put() - decrement the refcounter and possibly release 260 * the neigh_ifinfo 261 * @neigh_ifinfo: the neigh_ifinfo object to release 262 */ 263 void batadv_neigh_ifinfo_put(struct batadv_neigh_ifinfo *neigh_ifinfo) 264 { 265 kref_put(&neigh_ifinfo->refcount, batadv_neigh_ifinfo_release); 266 } 267 268 /** 269 * batadv_hardif_neigh_release() - release hardif neigh node from lists and 270 * queue for free after rcu grace period 271 * @ref: kref pointer of the neigh_node 272 */ 273 static void batadv_hardif_neigh_release(struct kref *ref) 274 { 275 struct batadv_hardif_neigh_node *hardif_neigh; 276 277 hardif_neigh = container_of(ref, struct batadv_hardif_neigh_node, 278 refcount); 279 280 spin_lock_bh(&hardif_neigh->if_incoming->neigh_list_lock); 281 hlist_del_init_rcu(&hardif_neigh->list); 282 spin_unlock_bh(&hardif_neigh->if_incoming->neigh_list_lock); 283 284 batadv_hardif_put(hardif_neigh->if_incoming); 285 kfree_rcu(hardif_neigh, rcu); 286 } 287 288 /** 289 * batadv_hardif_neigh_put() - decrement the hardif neighbors refcounter 290 * and possibly release it 291 * @hardif_neigh: hardif neigh neighbor to free 292 */ 293 void batadv_hardif_neigh_put(struct batadv_hardif_neigh_node *hardif_neigh) 294 { 295 kref_put(&hardif_neigh->refcount, batadv_hardif_neigh_release); 296 } 297 298 /** 299 * batadv_neigh_node_release() - release neigh_node from lists and queue for 300 * free after rcu grace period 301 * @ref: kref pointer of the neigh_node 302 */ 303 static void batadv_neigh_node_release(struct kref *ref) 304 { 305 struct hlist_node *node_tmp; 306 struct batadv_neigh_node *neigh_node; 307 struct batadv_neigh_ifinfo *neigh_ifinfo; 308 309 neigh_node = container_of(ref, struct batadv_neigh_node, refcount); 310 311 hlist_for_each_entry_safe(neigh_ifinfo, node_tmp, 312 &neigh_node->ifinfo_list, list) { 313 batadv_neigh_ifinfo_put(neigh_ifinfo); 314 } 315 316 batadv_hardif_neigh_put(neigh_node->hardif_neigh); 317 318 batadv_hardif_put(neigh_node->if_incoming); 319 320 kfree_rcu(neigh_node, rcu); 321 } 322 323 /** 324 * batadv_neigh_node_put() - decrement the neighbors refcounter and possibly 325 * release it 326 * @neigh_node: neigh neighbor to free 327 */ 328 void batadv_neigh_node_put(struct batadv_neigh_node *neigh_node) 329 { 330 kref_put(&neigh_node->refcount, batadv_neigh_node_release); 331 } 332 333 /** 334 * batadv_orig_router_get() - router to the originator depending on iface 335 * @orig_node: the orig node for the router 336 * @if_outgoing: the interface where the payload packet has been received or 337 * the OGM should be sent to 338 * 339 * Return: the neighbor which should be router for this orig_node/iface. 340 * 341 * The object is returned with refcounter increased by 1. 342 */ 343 struct batadv_neigh_node * 344 batadv_orig_router_get(struct batadv_orig_node *orig_node, 345 const struct batadv_hard_iface *if_outgoing) 346 { 347 struct batadv_orig_ifinfo *orig_ifinfo; 348 struct batadv_neigh_node *router = NULL; 349 350 rcu_read_lock(); 351 hlist_for_each_entry_rcu(orig_ifinfo, &orig_node->ifinfo_list, list) { 352 if (orig_ifinfo->if_outgoing != if_outgoing) 353 continue; 354 355 router = rcu_dereference(orig_ifinfo->router); 356 break; 357 } 358 359 if (router && !kref_get_unless_zero(&router->refcount)) 360 router = NULL; 361 362 rcu_read_unlock(); 363 return router; 364 } 365 366 /** 367 * batadv_orig_ifinfo_get() - find the ifinfo from an orig_node 368 * @orig_node: the orig node to be queried 369 * @if_outgoing: the interface for which the ifinfo should be acquired 370 * 371 * Return: the requested orig_ifinfo or NULL if not found. 372 * 373 * The object is returned with refcounter increased by 1. 374 */ 375 struct batadv_orig_ifinfo * 376 batadv_orig_ifinfo_get(struct batadv_orig_node *orig_node, 377 struct batadv_hard_iface *if_outgoing) 378 { 379 struct batadv_orig_ifinfo *tmp, *orig_ifinfo = NULL; 380 381 rcu_read_lock(); 382 hlist_for_each_entry_rcu(tmp, &orig_node->ifinfo_list, 383 list) { 384 if (tmp->if_outgoing != if_outgoing) 385 continue; 386 387 if (!kref_get_unless_zero(&tmp->refcount)) 388 continue; 389 390 orig_ifinfo = tmp; 391 break; 392 } 393 rcu_read_unlock(); 394 395 return orig_ifinfo; 396 } 397 398 /** 399 * batadv_orig_ifinfo_new() - search and possibly create an orig_ifinfo object 400 * @orig_node: the orig node to be queried 401 * @if_outgoing: the interface for which the ifinfo should be acquired 402 * 403 * Return: NULL in case of failure or the orig_ifinfo object for the if_outgoing 404 * interface otherwise. The object is created and added to the list 405 * if it does not exist. 406 * 407 * The object is returned with refcounter increased by 1. 408 */ 409 struct batadv_orig_ifinfo * 410 batadv_orig_ifinfo_new(struct batadv_orig_node *orig_node, 411 struct batadv_hard_iface *if_outgoing) 412 { 413 struct batadv_orig_ifinfo *orig_ifinfo; 414 unsigned long reset_time; 415 416 spin_lock_bh(&orig_node->neigh_list_lock); 417 418 orig_ifinfo = batadv_orig_ifinfo_get(orig_node, if_outgoing); 419 if (orig_ifinfo) 420 goto out; 421 422 orig_ifinfo = kzalloc(sizeof(*orig_ifinfo), GFP_ATOMIC); 423 if (!orig_ifinfo) 424 goto out; 425 426 if (if_outgoing != BATADV_IF_DEFAULT) 427 kref_get(&if_outgoing->refcount); 428 429 reset_time = jiffies - 1; 430 reset_time -= msecs_to_jiffies(BATADV_RESET_PROTECTION_MS); 431 orig_ifinfo->batman_seqno_reset = reset_time; 432 orig_ifinfo->if_outgoing = if_outgoing; 433 INIT_HLIST_NODE(&orig_ifinfo->list); 434 kref_init(&orig_ifinfo->refcount); 435 436 kref_get(&orig_ifinfo->refcount); 437 hlist_add_head_rcu(&orig_ifinfo->list, 438 &orig_node->ifinfo_list); 439 out: 440 spin_unlock_bh(&orig_node->neigh_list_lock); 441 return orig_ifinfo; 442 } 443 444 /** 445 * batadv_neigh_ifinfo_get() - find the ifinfo from an neigh_node 446 * @neigh: the neigh node to be queried 447 * @if_outgoing: the interface for which the ifinfo should be acquired 448 * 449 * The object is returned with refcounter increased by 1. 450 * 451 * Return: the requested neigh_ifinfo or NULL if not found 452 */ 453 struct batadv_neigh_ifinfo * 454 batadv_neigh_ifinfo_get(struct batadv_neigh_node *neigh, 455 struct batadv_hard_iface *if_outgoing) 456 { 457 struct batadv_neigh_ifinfo *neigh_ifinfo = NULL, 458 *tmp_neigh_ifinfo; 459 460 rcu_read_lock(); 461 hlist_for_each_entry_rcu(tmp_neigh_ifinfo, &neigh->ifinfo_list, 462 list) { 463 if (tmp_neigh_ifinfo->if_outgoing != if_outgoing) 464 continue; 465 466 if (!kref_get_unless_zero(&tmp_neigh_ifinfo->refcount)) 467 continue; 468 469 neigh_ifinfo = tmp_neigh_ifinfo; 470 break; 471 } 472 rcu_read_unlock(); 473 474 return neigh_ifinfo; 475 } 476 477 /** 478 * batadv_neigh_ifinfo_new() - search and possibly create an neigh_ifinfo object 479 * @neigh: the neigh node to be queried 480 * @if_outgoing: the interface for which the ifinfo should be acquired 481 * 482 * Return: NULL in case of failure or the neigh_ifinfo object for the 483 * if_outgoing interface otherwise. The object is created and added to the list 484 * if it does not exist. 485 * 486 * The object is returned with refcounter increased by 1. 487 */ 488 struct batadv_neigh_ifinfo * 489 batadv_neigh_ifinfo_new(struct batadv_neigh_node *neigh, 490 struct batadv_hard_iface *if_outgoing) 491 { 492 struct batadv_neigh_ifinfo *neigh_ifinfo; 493 494 spin_lock_bh(&neigh->ifinfo_lock); 495 496 neigh_ifinfo = batadv_neigh_ifinfo_get(neigh, if_outgoing); 497 if (neigh_ifinfo) 498 goto out; 499 500 neigh_ifinfo = kzalloc(sizeof(*neigh_ifinfo), GFP_ATOMIC); 501 if (!neigh_ifinfo) 502 goto out; 503 504 if (if_outgoing) 505 kref_get(&if_outgoing->refcount); 506 507 INIT_HLIST_NODE(&neigh_ifinfo->list); 508 kref_init(&neigh_ifinfo->refcount); 509 neigh_ifinfo->if_outgoing = if_outgoing; 510 511 kref_get(&neigh_ifinfo->refcount); 512 hlist_add_head_rcu(&neigh_ifinfo->list, &neigh->ifinfo_list); 513 514 out: 515 spin_unlock_bh(&neigh->ifinfo_lock); 516 517 return neigh_ifinfo; 518 } 519 520 /** 521 * batadv_neigh_node_get() - retrieve a neighbour from the list 522 * @orig_node: originator which the neighbour belongs to 523 * @hard_iface: the interface where this neighbour is connected to 524 * @addr: the address of the neighbour 525 * 526 * Looks for and possibly returns a neighbour belonging to this originator list 527 * which is connected through the provided hard interface. 528 * 529 * Return: neighbor when found. Othwerwise NULL 530 */ 531 static struct batadv_neigh_node * 532 batadv_neigh_node_get(const struct batadv_orig_node *orig_node, 533 const struct batadv_hard_iface *hard_iface, 534 const u8 *addr) 535 { 536 struct batadv_neigh_node *tmp_neigh_node, *res = NULL; 537 538 rcu_read_lock(); 539 hlist_for_each_entry_rcu(tmp_neigh_node, &orig_node->neigh_list, list) { 540 if (!batadv_compare_eth(tmp_neigh_node->addr, addr)) 541 continue; 542 543 if (tmp_neigh_node->if_incoming != hard_iface) 544 continue; 545 546 if (!kref_get_unless_zero(&tmp_neigh_node->refcount)) 547 continue; 548 549 res = tmp_neigh_node; 550 break; 551 } 552 rcu_read_unlock(); 553 554 return res; 555 } 556 557 /** 558 * batadv_hardif_neigh_create() - create a hardif neighbour node 559 * @hard_iface: the interface this neighbour is connected to 560 * @neigh_addr: the interface address of the neighbour to retrieve 561 * @orig_node: originator object representing the neighbour 562 * 563 * Return: the hardif neighbour node if found or created or NULL otherwise. 564 */ 565 static struct batadv_hardif_neigh_node * 566 batadv_hardif_neigh_create(struct batadv_hard_iface *hard_iface, 567 const u8 *neigh_addr, 568 struct batadv_orig_node *orig_node) 569 { 570 struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface); 571 struct batadv_hardif_neigh_node *hardif_neigh; 572 573 spin_lock_bh(&hard_iface->neigh_list_lock); 574 575 /* check if neighbor hasn't been added in the meantime */ 576 hardif_neigh = batadv_hardif_neigh_get(hard_iface, neigh_addr); 577 if (hardif_neigh) 578 goto out; 579 580 hardif_neigh = kzalloc(sizeof(*hardif_neigh), GFP_ATOMIC); 581 if (!hardif_neigh) 582 goto out; 583 584 kref_get(&hard_iface->refcount); 585 INIT_HLIST_NODE(&hardif_neigh->list); 586 ether_addr_copy(hardif_neigh->addr, neigh_addr); 587 ether_addr_copy(hardif_neigh->orig, orig_node->orig); 588 hardif_neigh->if_incoming = hard_iface; 589 hardif_neigh->last_seen = jiffies; 590 591 kref_init(&hardif_neigh->refcount); 592 593 if (bat_priv->algo_ops->neigh.hardif_init) 594 bat_priv->algo_ops->neigh.hardif_init(hardif_neigh); 595 596 hlist_add_head_rcu(&hardif_neigh->list, &hard_iface->neigh_list); 597 598 out: 599 spin_unlock_bh(&hard_iface->neigh_list_lock); 600 return hardif_neigh; 601 } 602 603 /** 604 * batadv_hardif_neigh_get_or_create() - retrieve or create a hardif neighbour 605 * node 606 * @hard_iface: the interface this neighbour is connected to 607 * @neigh_addr: the interface address of the neighbour to retrieve 608 * @orig_node: originator object representing the neighbour 609 * 610 * Return: the hardif neighbour node if found or created or NULL otherwise. 611 */ 612 static struct batadv_hardif_neigh_node * 613 batadv_hardif_neigh_get_or_create(struct batadv_hard_iface *hard_iface, 614 const u8 *neigh_addr, 615 struct batadv_orig_node *orig_node) 616 { 617 struct batadv_hardif_neigh_node *hardif_neigh; 618 619 /* first check without locking to avoid the overhead */ 620 hardif_neigh = batadv_hardif_neigh_get(hard_iface, neigh_addr); 621 if (hardif_neigh) 622 return hardif_neigh; 623 624 return batadv_hardif_neigh_create(hard_iface, neigh_addr, orig_node); 625 } 626 627 /** 628 * batadv_hardif_neigh_get() - retrieve a hardif neighbour from the list 629 * @hard_iface: the interface where this neighbour is connected to 630 * @neigh_addr: the address of the neighbour 631 * 632 * Looks for and possibly returns a neighbour belonging to this hard interface. 633 * 634 * Return: neighbor when found. Othwerwise NULL 635 */ 636 struct batadv_hardif_neigh_node * 637 batadv_hardif_neigh_get(const struct batadv_hard_iface *hard_iface, 638 const u8 *neigh_addr) 639 { 640 struct batadv_hardif_neigh_node *tmp_hardif_neigh, *hardif_neigh = NULL; 641 642 rcu_read_lock(); 643 hlist_for_each_entry_rcu(tmp_hardif_neigh, 644 &hard_iface->neigh_list, list) { 645 if (!batadv_compare_eth(tmp_hardif_neigh->addr, neigh_addr)) 646 continue; 647 648 if (!kref_get_unless_zero(&tmp_hardif_neigh->refcount)) 649 continue; 650 651 hardif_neigh = tmp_hardif_neigh; 652 break; 653 } 654 rcu_read_unlock(); 655 656 return hardif_neigh; 657 } 658 659 /** 660 * batadv_neigh_node_create() - create a neigh node object 661 * @orig_node: originator object representing the neighbour 662 * @hard_iface: the interface where the neighbour is connected to 663 * @neigh_addr: the mac address of the neighbour interface 664 * 665 * Allocates a new neigh_node object and initialises all the generic fields. 666 * 667 * Return: the neighbour node if found or created or NULL otherwise. 668 */ 669 static struct batadv_neigh_node * 670 batadv_neigh_node_create(struct batadv_orig_node *orig_node, 671 struct batadv_hard_iface *hard_iface, 672 const u8 *neigh_addr) 673 { 674 struct batadv_neigh_node *neigh_node; 675 struct batadv_hardif_neigh_node *hardif_neigh = NULL; 676 677 spin_lock_bh(&orig_node->neigh_list_lock); 678 679 neigh_node = batadv_neigh_node_get(orig_node, hard_iface, neigh_addr); 680 if (neigh_node) 681 goto out; 682 683 hardif_neigh = batadv_hardif_neigh_get_or_create(hard_iface, 684 neigh_addr, orig_node); 685 if (!hardif_neigh) 686 goto out; 687 688 neigh_node = kzalloc(sizeof(*neigh_node), GFP_ATOMIC); 689 if (!neigh_node) 690 goto out; 691 692 INIT_HLIST_NODE(&neigh_node->list); 693 INIT_HLIST_HEAD(&neigh_node->ifinfo_list); 694 spin_lock_init(&neigh_node->ifinfo_lock); 695 696 kref_get(&hard_iface->refcount); 697 ether_addr_copy(neigh_node->addr, neigh_addr); 698 neigh_node->if_incoming = hard_iface; 699 neigh_node->orig_node = orig_node; 700 neigh_node->last_seen = jiffies; 701 702 /* increment unique neighbor refcount */ 703 kref_get(&hardif_neigh->refcount); 704 neigh_node->hardif_neigh = hardif_neigh; 705 706 /* extra reference for return */ 707 kref_init(&neigh_node->refcount); 708 709 kref_get(&neigh_node->refcount); 710 hlist_add_head_rcu(&neigh_node->list, &orig_node->neigh_list); 711 712 batadv_dbg(BATADV_DBG_BATMAN, orig_node->bat_priv, 713 "Creating new neighbor %pM for orig_node %pM on interface %s\n", 714 neigh_addr, orig_node->orig, hard_iface->net_dev->name); 715 716 out: 717 spin_unlock_bh(&orig_node->neigh_list_lock); 718 719 if (hardif_neigh) 720 batadv_hardif_neigh_put(hardif_neigh); 721 return neigh_node; 722 } 723 724 /** 725 * batadv_neigh_node_get_or_create() - retrieve or create a neigh node object 726 * @orig_node: originator object representing the neighbour 727 * @hard_iface: the interface where the neighbour is connected to 728 * @neigh_addr: the mac address of the neighbour interface 729 * 730 * Return: the neighbour node if found or created or NULL otherwise. 731 */ 732 struct batadv_neigh_node * 733 batadv_neigh_node_get_or_create(struct batadv_orig_node *orig_node, 734 struct batadv_hard_iface *hard_iface, 735 const u8 *neigh_addr) 736 { 737 struct batadv_neigh_node *neigh_node; 738 739 /* first check without locking to avoid the overhead */ 740 neigh_node = batadv_neigh_node_get(orig_node, hard_iface, neigh_addr); 741 if (neigh_node) 742 return neigh_node; 743 744 return batadv_neigh_node_create(orig_node, hard_iface, neigh_addr); 745 } 746 747 #ifdef CONFIG_BATMAN_ADV_DEBUGFS 748 /** 749 * batadv_hardif_neigh_seq_print_text() - print the single hop neighbour list 750 * @seq: neighbour table seq_file struct 751 * @offset: not used 752 * 753 * Return: always 0 754 */ 755 int batadv_hardif_neigh_seq_print_text(struct seq_file *seq, void *offset) 756 { 757 struct net_device *net_dev = (struct net_device *)seq->private; 758 struct batadv_priv *bat_priv = netdev_priv(net_dev); 759 struct batadv_hard_iface *primary_if; 760 761 primary_if = batadv_seq_print_text_primary_if_get(seq); 762 if (!primary_if) 763 return 0; 764 765 seq_printf(seq, "[B.A.T.M.A.N. adv %s, MainIF/MAC: %s/%pM (%s %s)]\n", 766 BATADV_SOURCE_VERSION, primary_if->net_dev->name, 767 primary_if->net_dev->dev_addr, net_dev->name, 768 bat_priv->algo_ops->name); 769 770 batadv_hardif_put(primary_if); 771 772 if (!bat_priv->algo_ops->neigh.print) { 773 seq_puts(seq, 774 "No printing function for this routing protocol\n"); 775 return 0; 776 } 777 778 bat_priv->algo_ops->neigh.print(bat_priv, seq); 779 return 0; 780 } 781 #endif 782 783 /** 784 * batadv_hardif_neigh_dump() - Dump to netlink the neighbor infos for a 785 * specific outgoing interface 786 * @msg: message to dump into 787 * @cb: parameters for the dump 788 * 789 * Return: 0 or error value 790 */ 791 int batadv_hardif_neigh_dump(struct sk_buff *msg, struct netlink_callback *cb) 792 { 793 struct net *net = sock_net(cb->skb->sk); 794 struct net_device *soft_iface; 795 struct net_device *hard_iface = NULL; 796 struct batadv_hard_iface *hardif = BATADV_IF_DEFAULT; 797 struct batadv_priv *bat_priv; 798 struct batadv_hard_iface *primary_if = NULL; 799 int ret; 800 int ifindex, hard_ifindex; 801 802 ifindex = batadv_netlink_get_ifindex(cb->nlh, BATADV_ATTR_MESH_IFINDEX); 803 if (!ifindex) 804 return -EINVAL; 805 806 soft_iface = dev_get_by_index(net, ifindex); 807 if (!soft_iface || !batadv_softif_is_valid(soft_iface)) { 808 ret = -ENODEV; 809 goto out; 810 } 811 812 bat_priv = netdev_priv(soft_iface); 813 814 primary_if = batadv_primary_if_get_selected(bat_priv); 815 if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) { 816 ret = -ENOENT; 817 goto out; 818 } 819 820 hard_ifindex = batadv_netlink_get_ifindex(cb->nlh, 821 BATADV_ATTR_HARD_IFINDEX); 822 if (hard_ifindex) { 823 hard_iface = dev_get_by_index(net, hard_ifindex); 824 if (hard_iface) 825 hardif = batadv_hardif_get_by_netdev(hard_iface); 826 827 if (!hardif) { 828 ret = -ENODEV; 829 goto out; 830 } 831 832 if (hardif->soft_iface != soft_iface) { 833 ret = -ENOENT; 834 goto out; 835 } 836 } 837 838 if (!bat_priv->algo_ops->neigh.dump) { 839 ret = -EOPNOTSUPP; 840 goto out; 841 } 842 843 bat_priv->algo_ops->neigh.dump(msg, cb, bat_priv, hardif); 844 845 ret = msg->len; 846 847 out: 848 if (hardif) 849 batadv_hardif_put(hardif); 850 if (hard_iface) 851 dev_put(hard_iface); 852 if (primary_if) 853 batadv_hardif_put(primary_if); 854 if (soft_iface) 855 dev_put(soft_iface); 856 857 return ret; 858 } 859 860 /** 861 * batadv_orig_ifinfo_release() - release orig_ifinfo from lists and queue for 862 * free after rcu grace period 863 * @ref: kref pointer of the orig_ifinfo 864 */ 865 static void batadv_orig_ifinfo_release(struct kref *ref) 866 { 867 struct batadv_orig_ifinfo *orig_ifinfo; 868 struct batadv_neigh_node *router; 869 870 orig_ifinfo = container_of(ref, struct batadv_orig_ifinfo, refcount); 871 872 if (orig_ifinfo->if_outgoing != BATADV_IF_DEFAULT) 873 batadv_hardif_put(orig_ifinfo->if_outgoing); 874 875 /* this is the last reference to this object */ 876 router = rcu_dereference_protected(orig_ifinfo->router, true); 877 if (router) 878 batadv_neigh_node_put(router); 879 880 kfree_rcu(orig_ifinfo, rcu); 881 } 882 883 /** 884 * batadv_orig_ifinfo_put() - decrement the refcounter and possibly release 885 * the orig_ifinfo 886 * @orig_ifinfo: the orig_ifinfo object to release 887 */ 888 void batadv_orig_ifinfo_put(struct batadv_orig_ifinfo *orig_ifinfo) 889 { 890 kref_put(&orig_ifinfo->refcount, batadv_orig_ifinfo_release); 891 } 892 893 /** 894 * batadv_orig_node_free_rcu() - free the orig_node 895 * @rcu: rcu pointer of the orig_node 896 */ 897 static void batadv_orig_node_free_rcu(struct rcu_head *rcu) 898 { 899 struct batadv_orig_node *orig_node; 900 901 orig_node = container_of(rcu, struct batadv_orig_node, rcu); 902 903 batadv_mcast_purge_orig(orig_node); 904 905 batadv_frag_purge_orig(orig_node, NULL); 906 907 kfree(orig_node->tt_buff); 908 kfree(orig_node); 909 } 910 911 /** 912 * batadv_orig_node_release() - release orig_node from lists and queue for 913 * free after rcu grace period 914 * @ref: kref pointer of the orig_node 915 */ 916 static void batadv_orig_node_release(struct kref *ref) 917 { 918 struct hlist_node *node_tmp; 919 struct batadv_neigh_node *neigh_node; 920 struct batadv_orig_node *orig_node; 921 struct batadv_orig_ifinfo *orig_ifinfo; 922 struct batadv_orig_node_vlan *vlan; 923 struct batadv_orig_ifinfo *last_candidate; 924 925 orig_node = container_of(ref, struct batadv_orig_node, refcount); 926 927 spin_lock_bh(&orig_node->neigh_list_lock); 928 929 /* for all neighbors towards this originator ... */ 930 hlist_for_each_entry_safe(neigh_node, node_tmp, 931 &orig_node->neigh_list, list) { 932 hlist_del_rcu(&neigh_node->list); 933 batadv_neigh_node_put(neigh_node); 934 } 935 936 hlist_for_each_entry_safe(orig_ifinfo, node_tmp, 937 &orig_node->ifinfo_list, list) { 938 hlist_del_rcu(&orig_ifinfo->list); 939 batadv_orig_ifinfo_put(orig_ifinfo); 940 } 941 942 last_candidate = orig_node->last_bonding_candidate; 943 orig_node->last_bonding_candidate = NULL; 944 spin_unlock_bh(&orig_node->neigh_list_lock); 945 946 if (last_candidate) 947 batadv_orig_ifinfo_put(last_candidate); 948 949 spin_lock_bh(&orig_node->vlan_list_lock); 950 hlist_for_each_entry_safe(vlan, node_tmp, &orig_node->vlan_list, list) { 951 hlist_del_rcu(&vlan->list); 952 batadv_orig_node_vlan_put(vlan); 953 } 954 spin_unlock_bh(&orig_node->vlan_list_lock); 955 956 /* Free nc_nodes */ 957 batadv_nc_purge_orig(orig_node->bat_priv, orig_node, NULL); 958 959 call_rcu(&orig_node->rcu, batadv_orig_node_free_rcu); 960 } 961 962 /** 963 * batadv_orig_node_put() - decrement the orig node refcounter and possibly 964 * release it 965 * @orig_node: the orig node to free 966 */ 967 void batadv_orig_node_put(struct batadv_orig_node *orig_node) 968 { 969 kref_put(&orig_node->refcount, batadv_orig_node_release); 970 } 971 972 /** 973 * batadv_originator_free() - Free all originator structures 974 * @bat_priv: the bat priv with all the soft interface information 975 */ 976 void batadv_originator_free(struct batadv_priv *bat_priv) 977 { 978 struct batadv_hashtable *hash = bat_priv->orig_hash; 979 struct hlist_node *node_tmp; 980 struct hlist_head *head; 981 spinlock_t *list_lock; /* spinlock to protect write access */ 982 struct batadv_orig_node *orig_node; 983 u32 i; 984 985 if (!hash) 986 return; 987 988 cancel_delayed_work_sync(&bat_priv->orig_work); 989 990 bat_priv->orig_hash = NULL; 991 992 for (i = 0; i < hash->size; i++) { 993 head = &hash->table[i]; 994 list_lock = &hash->list_locks[i]; 995 996 spin_lock_bh(list_lock); 997 hlist_for_each_entry_safe(orig_node, node_tmp, 998 head, hash_entry) { 999 hlist_del_rcu(&orig_node->hash_entry); 1000 batadv_orig_node_put(orig_node); 1001 } 1002 spin_unlock_bh(list_lock); 1003 } 1004 1005 batadv_hash_destroy(hash); 1006 } 1007 1008 /** 1009 * batadv_orig_node_new() - creates a new orig_node 1010 * @bat_priv: the bat priv with all the soft interface information 1011 * @addr: the mac address of the originator 1012 * 1013 * Creates a new originator object and initialise all the generic fields. 1014 * The new object is not added to the originator list. 1015 * 1016 * Return: the newly created object or NULL on failure. 1017 */ 1018 struct batadv_orig_node *batadv_orig_node_new(struct batadv_priv *bat_priv, 1019 const u8 *addr) 1020 { 1021 struct batadv_orig_node *orig_node; 1022 struct batadv_orig_node_vlan *vlan; 1023 unsigned long reset_time; 1024 int i; 1025 1026 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 1027 "Creating new originator: %pM\n", addr); 1028 1029 orig_node = kzalloc(sizeof(*orig_node), GFP_ATOMIC); 1030 if (!orig_node) 1031 return NULL; 1032 1033 INIT_HLIST_HEAD(&orig_node->neigh_list); 1034 INIT_HLIST_HEAD(&orig_node->vlan_list); 1035 INIT_HLIST_HEAD(&orig_node->ifinfo_list); 1036 spin_lock_init(&orig_node->bcast_seqno_lock); 1037 spin_lock_init(&orig_node->neigh_list_lock); 1038 spin_lock_init(&orig_node->tt_buff_lock); 1039 spin_lock_init(&orig_node->tt_lock); 1040 spin_lock_init(&orig_node->vlan_list_lock); 1041 1042 batadv_nc_init_orig(orig_node); 1043 1044 /* extra reference for return */ 1045 kref_init(&orig_node->refcount); 1046 1047 orig_node->bat_priv = bat_priv; 1048 ether_addr_copy(orig_node->orig, addr); 1049 batadv_dat_init_orig_node_addr(orig_node); 1050 atomic_set(&orig_node->last_ttvn, 0); 1051 orig_node->tt_buff = NULL; 1052 orig_node->tt_buff_len = 0; 1053 orig_node->last_seen = jiffies; 1054 reset_time = jiffies - 1 - msecs_to_jiffies(BATADV_RESET_PROTECTION_MS); 1055 orig_node->bcast_seqno_reset = reset_time; 1056 1057 #ifdef CONFIG_BATMAN_ADV_MCAST 1058 orig_node->mcast_flags = BATADV_NO_FLAGS; 1059 INIT_HLIST_NODE(&orig_node->mcast_want_all_unsnoopables_node); 1060 INIT_HLIST_NODE(&orig_node->mcast_want_all_ipv4_node); 1061 INIT_HLIST_NODE(&orig_node->mcast_want_all_ipv6_node); 1062 spin_lock_init(&orig_node->mcast_handler_lock); 1063 #endif 1064 1065 /* create a vlan object for the "untagged" LAN */ 1066 vlan = batadv_orig_node_vlan_new(orig_node, BATADV_NO_FLAGS); 1067 if (!vlan) 1068 goto free_orig_node; 1069 /* batadv_orig_node_vlan_new() increases the refcounter. 1070 * Immediately release vlan since it is not needed anymore in this 1071 * context 1072 */ 1073 batadv_orig_node_vlan_put(vlan); 1074 1075 for (i = 0; i < BATADV_FRAG_BUFFER_COUNT; i++) { 1076 INIT_HLIST_HEAD(&orig_node->fragments[i].fragment_list); 1077 spin_lock_init(&orig_node->fragments[i].lock); 1078 orig_node->fragments[i].size = 0; 1079 } 1080 1081 return orig_node; 1082 free_orig_node: 1083 kfree(orig_node); 1084 return NULL; 1085 } 1086 1087 /** 1088 * batadv_purge_neigh_ifinfo() - purge obsolete ifinfo entries from neighbor 1089 * @bat_priv: the bat priv with all the soft interface information 1090 * @neigh: orig node which is to be checked 1091 */ 1092 static void 1093 batadv_purge_neigh_ifinfo(struct batadv_priv *bat_priv, 1094 struct batadv_neigh_node *neigh) 1095 { 1096 struct batadv_neigh_ifinfo *neigh_ifinfo; 1097 struct batadv_hard_iface *if_outgoing; 1098 struct hlist_node *node_tmp; 1099 1100 spin_lock_bh(&neigh->ifinfo_lock); 1101 1102 /* for all ifinfo objects for this neighinator */ 1103 hlist_for_each_entry_safe(neigh_ifinfo, node_tmp, 1104 &neigh->ifinfo_list, list) { 1105 if_outgoing = neigh_ifinfo->if_outgoing; 1106 1107 /* always keep the default interface */ 1108 if (if_outgoing == BATADV_IF_DEFAULT) 1109 continue; 1110 1111 /* don't purge if the interface is not (going) down */ 1112 if (if_outgoing->if_status != BATADV_IF_INACTIVE && 1113 if_outgoing->if_status != BATADV_IF_NOT_IN_USE && 1114 if_outgoing->if_status != BATADV_IF_TO_BE_REMOVED) 1115 continue; 1116 1117 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 1118 "neighbor/ifinfo purge: neighbor %pM, iface: %s\n", 1119 neigh->addr, if_outgoing->net_dev->name); 1120 1121 hlist_del_rcu(&neigh_ifinfo->list); 1122 batadv_neigh_ifinfo_put(neigh_ifinfo); 1123 } 1124 1125 spin_unlock_bh(&neigh->ifinfo_lock); 1126 } 1127 1128 /** 1129 * batadv_purge_orig_ifinfo() - purge obsolete ifinfo entries from originator 1130 * @bat_priv: the bat priv with all the soft interface information 1131 * @orig_node: orig node which is to be checked 1132 * 1133 * Return: true if any ifinfo entry was purged, false otherwise. 1134 */ 1135 static bool 1136 batadv_purge_orig_ifinfo(struct batadv_priv *bat_priv, 1137 struct batadv_orig_node *orig_node) 1138 { 1139 struct batadv_orig_ifinfo *orig_ifinfo; 1140 struct batadv_hard_iface *if_outgoing; 1141 struct hlist_node *node_tmp; 1142 bool ifinfo_purged = false; 1143 1144 spin_lock_bh(&orig_node->neigh_list_lock); 1145 1146 /* for all ifinfo objects for this originator */ 1147 hlist_for_each_entry_safe(orig_ifinfo, node_tmp, 1148 &orig_node->ifinfo_list, list) { 1149 if_outgoing = orig_ifinfo->if_outgoing; 1150 1151 /* always keep the default interface */ 1152 if (if_outgoing == BATADV_IF_DEFAULT) 1153 continue; 1154 1155 /* don't purge if the interface is not (going) down */ 1156 if (if_outgoing->if_status != BATADV_IF_INACTIVE && 1157 if_outgoing->if_status != BATADV_IF_NOT_IN_USE && 1158 if_outgoing->if_status != BATADV_IF_TO_BE_REMOVED) 1159 continue; 1160 1161 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 1162 "router/ifinfo purge: originator %pM, iface: %s\n", 1163 orig_node->orig, if_outgoing->net_dev->name); 1164 1165 ifinfo_purged = true; 1166 1167 hlist_del_rcu(&orig_ifinfo->list); 1168 batadv_orig_ifinfo_put(orig_ifinfo); 1169 if (orig_node->last_bonding_candidate == orig_ifinfo) { 1170 orig_node->last_bonding_candidate = NULL; 1171 batadv_orig_ifinfo_put(orig_ifinfo); 1172 } 1173 } 1174 1175 spin_unlock_bh(&orig_node->neigh_list_lock); 1176 1177 return ifinfo_purged; 1178 } 1179 1180 /** 1181 * batadv_purge_orig_neighbors() - purges neighbors from originator 1182 * @bat_priv: the bat priv with all the soft interface information 1183 * @orig_node: orig node which is to be checked 1184 * 1185 * Return: true if any neighbor was purged, false otherwise 1186 */ 1187 static bool 1188 batadv_purge_orig_neighbors(struct batadv_priv *bat_priv, 1189 struct batadv_orig_node *orig_node) 1190 { 1191 struct hlist_node *node_tmp; 1192 struct batadv_neigh_node *neigh_node; 1193 bool neigh_purged = false; 1194 unsigned long last_seen; 1195 struct batadv_hard_iface *if_incoming; 1196 1197 spin_lock_bh(&orig_node->neigh_list_lock); 1198 1199 /* for all neighbors towards this originator ... */ 1200 hlist_for_each_entry_safe(neigh_node, node_tmp, 1201 &orig_node->neigh_list, list) { 1202 last_seen = neigh_node->last_seen; 1203 if_incoming = neigh_node->if_incoming; 1204 1205 if (batadv_has_timed_out(last_seen, BATADV_PURGE_TIMEOUT) || 1206 if_incoming->if_status == BATADV_IF_INACTIVE || 1207 if_incoming->if_status == BATADV_IF_NOT_IN_USE || 1208 if_incoming->if_status == BATADV_IF_TO_BE_REMOVED) { 1209 if (if_incoming->if_status == BATADV_IF_INACTIVE || 1210 if_incoming->if_status == BATADV_IF_NOT_IN_USE || 1211 if_incoming->if_status == BATADV_IF_TO_BE_REMOVED) 1212 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 1213 "neighbor purge: originator %pM, neighbor: %pM, iface: %s\n", 1214 orig_node->orig, neigh_node->addr, 1215 if_incoming->net_dev->name); 1216 else 1217 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 1218 "neighbor timeout: originator %pM, neighbor: %pM, last_seen: %u\n", 1219 orig_node->orig, neigh_node->addr, 1220 jiffies_to_msecs(last_seen)); 1221 1222 neigh_purged = true; 1223 1224 hlist_del_rcu(&neigh_node->list); 1225 batadv_neigh_node_put(neigh_node); 1226 } else { 1227 /* only necessary if not the whole neighbor is to be 1228 * deleted, but some interface has been removed. 1229 */ 1230 batadv_purge_neigh_ifinfo(bat_priv, neigh_node); 1231 } 1232 } 1233 1234 spin_unlock_bh(&orig_node->neigh_list_lock); 1235 return neigh_purged; 1236 } 1237 1238 /** 1239 * batadv_find_best_neighbor() - finds the best neighbor after purging 1240 * @bat_priv: the bat priv with all the soft interface information 1241 * @orig_node: orig node which is to be checked 1242 * @if_outgoing: the interface for which the metric should be compared 1243 * 1244 * Return: the current best neighbor, with refcount increased. 1245 */ 1246 static struct batadv_neigh_node * 1247 batadv_find_best_neighbor(struct batadv_priv *bat_priv, 1248 struct batadv_orig_node *orig_node, 1249 struct batadv_hard_iface *if_outgoing) 1250 { 1251 struct batadv_neigh_node *best = NULL, *neigh; 1252 struct batadv_algo_ops *bao = bat_priv->algo_ops; 1253 1254 rcu_read_lock(); 1255 hlist_for_each_entry_rcu(neigh, &orig_node->neigh_list, list) { 1256 if (best && (bao->neigh.cmp(neigh, if_outgoing, best, 1257 if_outgoing) <= 0)) 1258 continue; 1259 1260 if (!kref_get_unless_zero(&neigh->refcount)) 1261 continue; 1262 1263 if (best) 1264 batadv_neigh_node_put(best); 1265 1266 best = neigh; 1267 } 1268 rcu_read_unlock(); 1269 1270 return best; 1271 } 1272 1273 /** 1274 * batadv_purge_orig_node() - purges obsolete information from an orig_node 1275 * @bat_priv: the bat priv with all the soft interface information 1276 * @orig_node: orig node which is to be checked 1277 * 1278 * This function checks if the orig_node or substructures of it have become 1279 * obsolete, and purges this information if that's the case. 1280 * 1281 * Return: true if the orig_node is to be removed, false otherwise. 1282 */ 1283 static bool batadv_purge_orig_node(struct batadv_priv *bat_priv, 1284 struct batadv_orig_node *orig_node) 1285 { 1286 struct batadv_neigh_node *best_neigh_node; 1287 struct batadv_hard_iface *hard_iface; 1288 bool changed_ifinfo, changed_neigh; 1289 1290 if (batadv_has_timed_out(orig_node->last_seen, 1291 2 * BATADV_PURGE_TIMEOUT)) { 1292 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 1293 "Originator timeout: originator %pM, last_seen %u\n", 1294 orig_node->orig, 1295 jiffies_to_msecs(orig_node->last_seen)); 1296 return true; 1297 } 1298 changed_ifinfo = batadv_purge_orig_ifinfo(bat_priv, orig_node); 1299 changed_neigh = batadv_purge_orig_neighbors(bat_priv, orig_node); 1300 1301 if (!changed_ifinfo && !changed_neigh) 1302 return false; 1303 1304 /* first for NULL ... */ 1305 best_neigh_node = batadv_find_best_neighbor(bat_priv, orig_node, 1306 BATADV_IF_DEFAULT); 1307 batadv_update_route(bat_priv, orig_node, BATADV_IF_DEFAULT, 1308 best_neigh_node); 1309 if (best_neigh_node) 1310 batadv_neigh_node_put(best_neigh_node); 1311 1312 /* ... then for all other interfaces. */ 1313 rcu_read_lock(); 1314 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { 1315 if (hard_iface->if_status != BATADV_IF_ACTIVE) 1316 continue; 1317 1318 if (hard_iface->soft_iface != bat_priv->soft_iface) 1319 continue; 1320 1321 if (!kref_get_unless_zero(&hard_iface->refcount)) 1322 continue; 1323 1324 best_neigh_node = batadv_find_best_neighbor(bat_priv, 1325 orig_node, 1326 hard_iface); 1327 batadv_update_route(bat_priv, orig_node, hard_iface, 1328 best_neigh_node); 1329 if (best_neigh_node) 1330 batadv_neigh_node_put(best_neigh_node); 1331 1332 batadv_hardif_put(hard_iface); 1333 } 1334 rcu_read_unlock(); 1335 1336 return false; 1337 } 1338 1339 /** 1340 * batadv_purge_orig_ref() - Purge all outdated originators 1341 * @bat_priv: the bat priv with all the soft interface information 1342 */ 1343 void batadv_purge_orig_ref(struct batadv_priv *bat_priv) 1344 { 1345 struct batadv_hashtable *hash = bat_priv->orig_hash; 1346 struct hlist_node *node_tmp; 1347 struct hlist_head *head; 1348 spinlock_t *list_lock; /* spinlock to protect write access */ 1349 struct batadv_orig_node *orig_node; 1350 u32 i; 1351 1352 if (!hash) 1353 return; 1354 1355 /* for all origins... */ 1356 for (i = 0; i < hash->size; i++) { 1357 head = &hash->table[i]; 1358 list_lock = &hash->list_locks[i]; 1359 1360 spin_lock_bh(list_lock); 1361 hlist_for_each_entry_safe(orig_node, node_tmp, 1362 head, hash_entry) { 1363 if (batadv_purge_orig_node(bat_priv, orig_node)) { 1364 batadv_gw_node_delete(bat_priv, orig_node); 1365 hlist_del_rcu(&orig_node->hash_entry); 1366 batadv_tt_global_del_orig(orig_node->bat_priv, 1367 orig_node, -1, 1368 "originator timed out"); 1369 batadv_orig_node_put(orig_node); 1370 continue; 1371 } 1372 1373 batadv_frag_purge_orig(orig_node, 1374 batadv_frag_check_entry); 1375 } 1376 spin_unlock_bh(list_lock); 1377 } 1378 1379 batadv_gw_election(bat_priv); 1380 } 1381 1382 static void batadv_purge_orig(struct work_struct *work) 1383 { 1384 struct delayed_work *delayed_work; 1385 struct batadv_priv *bat_priv; 1386 1387 delayed_work = to_delayed_work(work); 1388 bat_priv = container_of(delayed_work, struct batadv_priv, orig_work); 1389 batadv_purge_orig_ref(bat_priv); 1390 queue_delayed_work(batadv_event_workqueue, 1391 &bat_priv->orig_work, 1392 msecs_to_jiffies(BATADV_ORIG_WORK_PERIOD)); 1393 } 1394 1395 #ifdef CONFIG_BATMAN_ADV_DEBUGFS 1396 1397 /** 1398 * batadv_orig_seq_print_text() - Print the originator table in a seq file 1399 * @seq: seq file to print on 1400 * @offset: not used 1401 * 1402 * Return: always 0 1403 */ 1404 int batadv_orig_seq_print_text(struct seq_file *seq, void *offset) 1405 { 1406 struct net_device *net_dev = (struct net_device *)seq->private; 1407 struct batadv_priv *bat_priv = netdev_priv(net_dev); 1408 struct batadv_hard_iface *primary_if; 1409 1410 primary_if = batadv_seq_print_text_primary_if_get(seq); 1411 if (!primary_if) 1412 return 0; 1413 1414 seq_printf(seq, "[B.A.T.M.A.N. adv %s, MainIF/MAC: %s/%pM (%s %s)]\n", 1415 BATADV_SOURCE_VERSION, primary_if->net_dev->name, 1416 primary_if->net_dev->dev_addr, net_dev->name, 1417 bat_priv->algo_ops->name); 1418 1419 batadv_hardif_put(primary_if); 1420 1421 if (!bat_priv->algo_ops->orig.print) { 1422 seq_puts(seq, 1423 "No printing function for this routing protocol\n"); 1424 return 0; 1425 } 1426 1427 bat_priv->algo_ops->orig.print(bat_priv, seq, BATADV_IF_DEFAULT); 1428 1429 return 0; 1430 } 1431 1432 /** 1433 * batadv_orig_hardif_seq_print_text() - writes originator infos for a specific 1434 * outgoing interface 1435 * @seq: debugfs table seq_file struct 1436 * @offset: not used 1437 * 1438 * Return: 0 1439 */ 1440 int batadv_orig_hardif_seq_print_text(struct seq_file *seq, void *offset) 1441 { 1442 struct net_device *net_dev = (struct net_device *)seq->private; 1443 struct batadv_hard_iface *hard_iface; 1444 struct batadv_priv *bat_priv; 1445 1446 hard_iface = batadv_hardif_get_by_netdev(net_dev); 1447 1448 if (!hard_iface || !hard_iface->soft_iface) { 1449 seq_puts(seq, "Interface not known to B.A.T.M.A.N.\n"); 1450 goto out; 1451 } 1452 1453 bat_priv = netdev_priv(hard_iface->soft_iface); 1454 if (!bat_priv->algo_ops->orig.print) { 1455 seq_puts(seq, 1456 "No printing function for this routing protocol\n"); 1457 goto out; 1458 } 1459 1460 if (hard_iface->if_status != BATADV_IF_ACTIVE) { 1461 seq_puts(seq, "Interface not active\n"); 1462 goto out; 1463 } 1464 1465 seq_printf(seq, "[B.A.T.M.A.N. adv %s, IF/MAC: %s/%pM (%s %s)]\n", 1466 BATADV_SOURCE_VERSION, hard_iface->net_dev->name, 1467 hard_iface->net_dev->dev_addr, 1468 hard_iface->soft_iface->name, bat_priv->algo_ops->name); 1469 1470 bat_priv->algo_ops->orig.print(bat_priv, seq, hard_iface); 1471 1472 out: 1473 if (hard_iface) 1474 batadv_hardif_put(hard_iface); 1475 return 0; 1476 } 1477 #endif 1478 1479 /** 1480 * batadv_orig_dump() - Dump to netlink the originator infos for a specific 1481 * outgoing interface 1482 * @msg: message to dump into 1483 * @cb: parameters for the dump 1484 * 1485 * Return: 0 or error value 1486 */ 1487 int batadv_orig_dump(struct sk_buff *msg, struct netlink_callback *cb) 1488 { 1489 struct net *net = sock_net(cb->skb->sk); 1490 struct net_device *soft_iface; 1491 struct net_device *hard_iface = NULL; 1492 struct batadv_hard_iface *hardif = BATADV_IF_DEFAULT; 1493 struct batadv_priv *bat_priv; 1494 struct batadv_hard_iface *primary_if = NULL; 1495 int ret; 1496 int ifindex, hard_ifindex; 1497 1498 ifindex = batadv_netlink_get_ifindex(cb->nlh, BATADV_ATTR_MESH_IFINDEX); 1499 if (!ifindex) 1500 return -EINVAL; 1501 1502 soft_iface = dev_get_by_index(net, ifindex); 1503 if (!soft_iface || !batadv_softif_is_valid(soft_iface)) { 1504 ret = -ENODEV; 1505 goto out; 1506 } 1507 1508 bat_priv = netdev_priv(soft_iface); 1509 1510 primary_if = batadv_primary_if_get_selected(bat_priv); 1511 if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) { 1512 ret = -ENOENT; 1513 goto out; 1514 } 1515 1516 hard_ifindex = batadv_netlink_get_ifindex(cb->nlh, 1517 BATADV_ATTR_HARD_IFINDEX); 1518 if (hard_ifindex) { 1519 hard_iface = dev_get_by_index(net, hard_ifindex); 1520 if (hard_iface) 1521 hardif = batadv_hardif_get_by_netdev(hard_iface); 1522 1523 if (!hardif) { 1524 ret = -ENODEV; 1525 goto out; 1526 } 1527 1528 if (hardif->soft_iface != soft_iface) { 1529 ret = -ENOENT; 1530 goto out; 1531 } 1532 } 1533 1534 if (!bat_priv->algo_ops->orig.dump) { 1535 ret = -EOPNOTSUPP; 1536 goto out; 1537 } 1538 1539 bat_priv->algo_ops->orig.dump(msg, cb, bat_priv, hardif); 1540 1541 ret = msg->len; 1542 1543 out: 1544 if (hardif) 1545 batadv_hardif_put(hardif); 1546 if (hard_iface) 1547 dev_put(hard_iface); 1548 if (primary_if) 1549 batadv_hardif_put(primary_if); 1550 if (soft_iface) 1551 dev_put(soft_iface); 1552 1553 return ret; 1554 } 1555