net/batman-adv/originator.c

   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 }