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