net/batman-adv/originator.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (C) 2009-2018  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         if (orig_node->bat_priv->algo_ops->orig.free)
 908                 orig_node->bat_priv->algo_ops->orig.free(orig_node);
 909
 910         kfree(orig_node->tt_buff);
 911         kfree(orig_node);
 912 }
 913
 914 /**
 915  * batadv_orig_node_release() - release orig_node from lists and queue for
 916  *  free after rcu grace period
 917  * @ref: kref pointer of the orig_node
 918  */
 919 static void batadv_orig_node_release(struct kref *ref)
 920 {
 921         struct hlist_node *node_tmp;
 922         struct batadv_neigh_node *neigh_node;
 923         struct batadv_orig_node *orig_node;
 924         struct batadv_orig_ifinfo *orig_ifinfo;
 925         struct batadv_orig_node_vlan *vlan;
 926         struct batadv_orig_ifinfo *last_candidate;
 927
 928         orig_node = container_of(ref, struct batadv_orig_node, refcount);
 929
 930         spin_lock_bh(&orig_node->neigh_list_lock);
 931
 932         /* for all neighbors towards this originator ... */
 933         hlist_for_each_entry_safe(neigh_node, node_tmp,
 934                                   &orig_node->neigh_list, list) {
 935                 hlist_del_rcu(&neigh_node->list);
 936                 batadv_neigh_node_put(neigh_node);
 937         }
 938
 939         hlist_for_each_entry_safe(orig_ifinfo, node_tmp,
 940                                   &orig_node->ifinfo_list, list) {
 941                 hlist_del_rcu(&orig_ifinfo->list);
 942                 batadv_orig_ifinfo_put(orig_ifinfo);
 943         }
 944
 945         last_candidate = orig_node->last_bonding_candidate;
 946         orig_node->last_bonding_candidate = NULL;
 947         spin_unlock_bh(&orig_node->neigh_list_lock);
 948
 949         if (last_candidate)
 950                 batadv_orig_ifinfo_put(last_candidate);
 951
 952         spin_lock_bh(&orig_node->vlan_list_lock);
 953         hlist_for_each_entry_safe(vlan, node_tmp, &orig_node->vlan_list, list) {
 954                 hlist_del_rcu(&vlan->list);
 955                 batadv_orig_node_vlan_put(vlan);
 956         }
 957         spin_unlock_bh(&orig_node->vlan_list_lock);
 958
 959         /* Free nc_nodes */
 960         batadv_nc_purge_orig(orig_node->bat_priv, orig_node, NULL);
 961
 962         call_rcu(&orig_node->rcu, batadv_orig_node_free_rcu);
 963 }
 964
 965 /**
 966  * batadv_orig_node_put() - decrement the orig node refcounter and possibly
 967  *  release it
 968  * @orig_node: the orig node to free
 969  */
 970 void batadv_orig_node_put(struct batadv_orig_node *orig_node)
 971 {
 972         kref_put(&orig_node->refcount, batadv_orig_node_release);
 973 }
 974
 975 /**
 976  * batadv_originator_free() - Free all originator structures
 977  * @bat_priv: the bat priv with all the soft interface information
 978  */
 979 void batadv_originator_free(struct batadv_priv *bat_priv)
 980 {
 981         struct batadv_hashtable *hash = bat_priv->orig_hash;
 982         struct hlist_node *node_tmp;
 983         struct hlist_head *head;
 984         spinlock_t *list_lock; /* spinlock to protect write access */
 985         struct batadv_orig_node *orig_node;
 986         u32 i;
 987
 988         if (!hash)
 989                 return;
 990
 991         cancel_delayed_work_sync(&bat_priv->orig_work);
 992
 993         bat_priv->orig_hash = NULL;
 994
 995         for (i = 0; i < hash->size; i++) {
 996                 head = &hash->table[i];
 997                 list_lock = &hash->list_locks[i];
 998
 999                 spin_lock_bh(list_lock);
1000                 hlist_for_each_entry_safe(orig_node, node_tmp,
1001                                           head, hash_entry) {
1002                         hlist_del_rcu(&orig_node->hash_entry);
1003                         batadv_orig_node_put(orig_node);
1004                 }
1005                 spin_unlock_bh(list_lock);
1006         }
1007
1008         batadv_hash_destroy(hash);
1009 }
1010
1011 /**
1012  * batadv_orig_node_new() - creates a new orig_node
1013  * @bat_priv: the bat priv with all the soft interface information
1014  * @addr: the mac address of the originator
1015  *
1016  * Creates a new originator object and initialise all the generic fields.
1017  * The new object is not added to the originator list.
1018  *
1019  * Return: the newly created object or NULL on failure.
1020  */
1021 struct batadv_orig_node *batadv_orig_node_new(struct batadv_priv *bat_priv,
1022                                               const u8 *addr)
1023 {
1024         struct batadv_orig_node *orig_node;
1025         struct batadv_orig_node_vlan *vlan;
1026         unsigned long reset_time;
1027         int i;
1028
1029         batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1030                    "Creating new originator: %pM\n", addr);
1031
1032         orig_node = kzalloc(sizeof(*orig_node), GFP_ATOMIC);
1033         if (!orig_node)
1034                 return NULL;
1035
1036         INIT_HLIST_HEAD(&orig_node->neigh_list);
1037         INIT_HLIST_HEAD(&orig_node->vlan_list);
1038         INIT_HLIST_HEAD(&orig_node->ifinfo_list);
1039         spin_lock_init(&orig_node->bcast_seqno_lock);
1040         spin_lock_init(&orig_node->neigh_list_lock);
1041         spin_lock_init(&orig_node->tt_buff_lock);
1042         spin_lock_init(&orig_node->tt_lock);
1043         spin_lock_init(&orig_node->vlan_list_lock);
1044
1045         batadv_nc_init_orig(orig_node);
1046
1047         /* extra reference for return */
1048         kref_init(&orig_node->refcount);
1049
1050         orig_node->bat_priv = bat_priv;
1051         ether_addr_copy(orig_node->orig, addr);
1052         batadv_dat_init_orig_node_addr(orig_node);
1053         atomic_set(&orig_node->last_ttvn, 0);
1054         orig_node->tt_buff = NULL;
1055         orig_node->tt_buff_len = 0;
1056         orig_node->last_seen = jiffies;
1057         reset_time = jiffies - 1 - msecs_to_jiffies(BATADV_RESET_PROTECTION_MS);
1058         orig_node->bcast_seqno_reset = reset_time;
1059
1060 #ifdef CONFIG_BATMAN_ADV_MCAST
1061         orig_node->mcast_flags = BATADV_NO_FLAGS;
1062         INIT_HLIST_NODE(&orig_node->mcast_want_all_unsnoopables_node);
1063         INIT_HLIST_NODE(&orig_node->mcast_want_all_ipv4_node);
1064         INIT_HLIST_NODE(&orig_node->mcast_want_all_ipv6_node);
1065         spin_lock_init(&orig_node->mcast_handler_lock);
1066 #endif
1067
1068         /* create a vlan object for the "untagged" LAN */
1069         vlan = batadv_orig_node_vlan_new(orig_node, BATADV_NO_FLAGS);
1070         if (!vlan)
1071                 goto free_orig_node;
1072         /* batadv_orig_node_vlan_new() increases the refcounter.
1073          * Immediately release vlan since it is not needed anymore in this
1074          * context
1075          */
1076         batadv_orig_node_vlan_put(vlan);
1077
1078         for (i = 0; i < BATADV_FRAG_BUFFER_COUNT; i++) {
1079                 INIT_HLIST_HEAD(&orig_node->fragments[i].fragment_list);
1080                 spin_lock_init(&orig_node->fragments[i].lock);
1081                 orig_node->fragments[i].size = 0;
1082         }
1083
1084         return orig_node;
1085 free_orig_node:
1086         kfree(orig_node);
1087         return NULL;
1088 }
1089
1090 /**
1091  * batadv_purge_neigh_ifinfo() - purge obsolete ifinfo entries from neighbor
1092  * @bat_priv: the bat priv with all the soft interface information
1093  * @neigh: orig node which is to be checked
1094  */
1095 static void
1096 batadv_purge_neigh_ifinfo(struct batadv_priv *bat_priv,
1097                           struct batadv_neigh_node *neigh)
1098 {
1099         struct batadv_neigh_ifinfo *neigh_ifinfo;
1100         struct batadv_hard_iface *if_outgoing;
1101         struct hlist_node *node_tmp;
1102
1103         spin_lock_bh(&neigh->ifinfo_lock);
1104
1105         /* for all ifinfo objects for this neighinator */
1106         hlist_for_each_entry_safe(neigh_ifinfo, node_tmp,
1107                                   &neigh->ifinfo_list, list) {
1108                 if_outgoing = neigh_ifinfo->if_outgoing;
1109
1110                 /* always keep the default interface */
1111                 if (if_outgoing == BATADV_IF_DEFAULT)
1112                         continue;
1113
1114                 /* don't purge if the interface is not (going) down */
1115                 if (if_outgoing->if_status != BATADV_IF_INACTIVE &&
1116                     if_outgoing->if_status != BATADV_IF_NOT_IN_USE &&
1117                     if_outgoing->if_status != BATADV_IF_TO_BE_REMOVED)
1118                         continue;
1119
1120                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1121                            "neighbor/ifinfo purge: neighbor %pM, iface: %s\n",
1122                            neigh->addr, if_outgoing->net_dev->name);
1123
1124                 hlist_del_rcu(&neigh_ifinfo->list);
1125                 batadv_neigh_ifinfo_put(neigh_ifinfo);
1126         }
1127
1128         spin_unlock_bh(&neigh->ifinfo_lock);
1129 }
1130
1131 /**
1132  * batadv_purge_orig_ifinfo() - purge obsolete ifinfo entries from originator
1133  * @bat_priv: the bat priv with all the soft interface information
1134  * @orig_node: orig node which is to be checked
1135  *
1136  * Return: true if any ifinfo entry was purged, false otherwise.
1137  */
1138 static bool
1139 batadv_purge_orig_ifinfo(struct batadv_priv *bat_priv,
1140                          struct batadv_orig_node *orig_node)
1141 {
1142         struct batadv_orig_ifinfo *orig_ifinfo;
1143         struct batadv_hard_iface *if_outgoing;
1144         struct hlist_node *node_tmp;
1145         bool ifinfo_purged = false;
1146
1147         spin_lock_bh(&orig_node->neigh_list_lock);
1148
1149         /* for all ifinfo objects for this originator */
1150         hlist_for_each_entry_safe(orig_ifinfo, node_tmp,
1151                                   &orig_node->ifinfo_list, list) {
1152                 if_outgoing = orig_ifinfo->if_outgoing;
1153
1154                 /* always keep the default interface */
1155                 if (if_outgoing == BATADV_IF_DEFAULT)
1156                         continue;
1157
1158                 /* don't purge if the interface is not (going) down */
1159                 if (if_outgoing->if_status != BATADV_IF_INACTIVE &&
1160                     if_outgoing->if_status != BATADV_IF_NOT_IN_USE &&
1161                     if_outgoing->if_status != BATADV_IF_TO_BE_REMOVED)
1162                         continue;
1163
1164                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1165                            "router/ifinfo purge: originator %pM, iface: %s\n",
1166                            orig_node->orig, if_outgoing->net_dev->name);
1167
1168                 ifinfo_purged = true;
1169
1170                 hlist_del_rcu(&orig_ifinfo->list);
1171                 batadv_orig_ifinfo_put(orig_ifinfo);
1172                 if (orig_node->last_bonding_candidate == orig_ifinfo) {
1173                         orig_node->last_bonding_candidate = NULL;
1174                         batadv_orig_ifinfo_put(orig_ifinfo);
1175                 }
1176         }
1177
1178         spin_unlock_bh(&orig_node->neigh_list_lock);
1179
1180         return ifinfo_purged;
1181 }
1182
1183 /**
1184  * batadv_purge_orig_neighbors() - purges neighbors from originator
1185  * @bat_priv: the bat priv with all the soft interface information
1186  * @orig_node: orig node which is to be checked
1187  *
1188  * Return: true if any neighbor was purged, false otherwise
1189  */
1190 static bool
1191 batadv_purge_orig_neighbors(struct batadv_priv *bat_priv,
1192                             struct batadv_orig_node *orig_node)
1193 {
1194         struct hlist_node *node_tmp;
1195         struct batadv_neigh_node *neigh_node;
1196         bool neigh_purged = false;
1197         unsigned long last_seen;
1198         struct batadv_hard_iface *if_incoming;
1199
1200         spin_lock_bh(&orig_node->neigh_list_lock);
1201
1202         /* for all neighbors towards this originator ... */
1203         hlist_for_each_entry_safe(neigh_node, node_tmp,
1204                                   &orig_node->neigh_list, list) {
1205                 last_seen = neigh_node->last_seen;
1206                 if_incoming = neigh_node->if_incoming;
1207
1208                 if (batadv_has_timed_out(last_seen, BATADV_PURGE_TIMEOUT) ||
1209                     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                         if (if_incoming->if_status == BATADV_IF_INACTIVE ||
1213                             if_incoming->if_status == BATADV_IF_NOT_IN_USE ||
1214                             if_incoming->if_status == BATADV_IF_TO_BE_REMOVED)
1215                                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1216                                            "neighbor purge: originator %pM, neighbor: %pM, iface: %s\n",
1217                                            orig_node->orig, neigh_node->addr,
1218                                            if_incoming->net_dev->name);
1219                         else
1220                                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1221                                            "neighbor timeout: originator %pM, neighbor: %pM, last_seen: %u\n",
1222                                            orig_node->orig, neigh_node->addr,
1223                                            jiffies_to_msecs(last_seen));
1224
1225                         neigh_purged = true;
1226
1227                         hlist_del_rcu(&neigh_node->list);
1228                         batadv_neigh_node_put(neigh_node);
1229                 } else {
1230                         /* only necessary if not the whole neighbor is to be
1231                          * deleted, but some interface has been removed.
1232                          */
1233                         batadv_purge_neigh_ifinfo(bat_priv, neigh_node);
1234                 }
1235         }
1236
1237         spin_unlock_bh(&orig_node->neigh_list_lock);
1238         return neigh_purged;
1239 }
1240
1241 /**
1242  * batadv_find_best_neighbor() - finds the best neighbor after purging
1243  * @bat_priv: the bat priv with all the soft interface information
1244  * @orig_node: orig node which is to be checked
1245  * @if_outgoing: the interface for which the metric should be compared
1246  *
1247  * Return: the current best neighbor, with refcount increased.
1248  */
1249 static struct batadv_neigh_node *
1250 batadv_find_best_neighbor(struct batadv_priv *bat_priv,
1251                           struct batadv_orig_node *orig_node,
1252                           struct batadv_hard_iface *if_outgoing)
1253 {
1254         struct batadv_neigh_node *best = NULL, *neigh;
1255         struct batadv_algo_ops *bao = bat_priv->algo_ops;
1256
1257         rcu_read_lock();
1258         hlist_for_each_entry_rcu(neigh, &orig_node->neigh_list, list) {
1259                 if (best && (bao->neigh.cmp(neigh, if_outgoing, best,
1260                                             if_outgoing) <= 0))
1261                         continue;
1262
1263                 if (!kref_get_unless_zero(&neigh->refcount))
1264                         continue;
1265
1266                 if (best)
1267                         batadv_neigh_node_put(best);
1268
1269                 best = neigh;
1270         }
1271         rcu_read_unlock();
1272
1273         return best;
1274 }
1275
1276 /**
1277  * batadv_purge_orig_node() - purges obsolete information from an orig_node
1278  * @bat_priv: the bat priv with all the soft interface information
1279  * @orig_node: orig node which is to be checked
1280  *
1281  * This function checks if the orig_node or substructures of it have become
1282  * obsolete, and purges this information if that's the case.
1283  *
1284  * Return: true if the orig_node is to be removed, false otherwise.
1285  */
1286 static bool batadv_purge_orig_node(struct batadv_priv *bat_priv,
1287                                    struct batadv_orig_node *orig_node)
1288 {
1289         struct batadv_neigh_node *best_neigh_node;
1290         struct batadv_hard_iface *hard_iface;
1291         bool changed_ifinfo, changed_neigh;
1292
1293         if (batadv_has_timed_out(orig_node->last_seen,
1294                                  2 * BATADV_PURGE_TIMEOUT)) {
1295                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1296                            "Originator timeout: originator %pM, last_seen %u\n",
1297                            orig_node->orig,
1298                            jiffies_to_msecs(orig_node->last_seen));
1299                 return true;
1300         }
1301         changed_ifinfo = batadv_purge_orig_ifinfo(bat_priv, orig_node);
1302         changed_neigh = batadv_purge_orig_neighbors(bat_priv, orig_node);
1303
1304         if (!changed_ifinfo && !changed_neigh)
1305                 return false;
1306
1307         /* first for NULL ... */
1308         best_neigh_node = batadv_find_best_neighbor(bat_priv, orig_node,
1309                                                     BATADV_IF_DEFAULT);
1310         batadv_update_route(bat_priv, orig_node, BATADV_IF_DEFAULT,
1311                             best_neigh_node);
1312         if (best_neigh_node)
1313                 batadv_neigh_node_put(best_neigh_node);
1314
1315         /* ... then for all other interfaces. */
1316         rcu_read_lock();
1317         list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
1318                 if (hard_iface->if_status != BATADV_IF_ACTIVE)
1319                         continue;
1320
1321                 if (hard_iface->soft_iface != bat_priv->soft_iface)
1322                         continue;
1323
1324                 if (!kref_get_unless_zero(&hard_iface->refcount))
1325                         continue;
1326
1327                 best_neigh_node = batadv_find_best_neighbor(bat_priv,
1328                                                             orig_node,
1329                                                             hard_iface);
1330                 batadv_update_route(bat_priv, orig_node, hard_iface,
1331                                     best_neigh_node);
1332                 if (best_neigh_node)
1333                         batadv_neigh_node_put(best_neigh_node);
1334
1335                 batadv_hardif_put(hard_iface);
1336         }
1337         rcu_read_unlock();
1338
1339         return false;
1340 }
1341
1342 /**
1343  * batadv_purge_orig_ref() - Purge all outdated originators
1344  * @bat_priv: the bat priv with all the soft interface information
1345  */
1346 void batadv_purge_orig_ref(struct batadv_priv *bat_priv)
1347 {
1348         struct batadv_hashtable *hash = bat_priv->orig_hash;
1349         struct hlist_node *node_tmp;
1350         struct hlist_head *head;
1351         spinlock_t *list_lock; /* spinlock to protect write access */
1352         struct batadv_orig_node *orig_node;
1353         u32 i;
1354
1355         if (!hash)
1356                 return;
1357
1358         /* for all origins... */
1359         for (i = 0; i < hash->size; i++) {
1360                 head = &hash->table[i];
1361                 list_lock = &hash->list_locks[i];
1362
1363                 spin_lock_bh(list_lock);
1364                 hlist_for_each_entry_safe(orig_node, node_tmp,
1365                                           head, hash_entry) {
1366                         if (batadv_purge_orig_node(bat_priv, orig_node)) {
1367                                 batadv_gw_node_delete(bat_priv, orig_node);
1368                                 hlist_del_rcu(&orig_node->hash_entry);
1369                                 batadv_tt_global_del_orig(orig_node->bat_priv,
1370                                                           orig_node, -1,
1371                                                           "originator timed out");
1372                                 batadv_orig_node_put(orig_node);
1373                                 continue;
1374                         }
1375
1376                         batadv_frag_purge_orig(orig_node,
1377                                                batadv_frag_check_entry);
1378                 }
1379                 spin_unlock_bh(list_lock);
1380         }
1381
1382         batadv_gw_election(bat_priv);
1383 }
1384
1385 static void batadv_purge_orig(struct work_struct *work)
1386 {
1387         struct delayed_work *delayed_work;
1388         struct batadv_priv *bat_priv;
1389
1390         delayed_work = to_delayed_work(work);
1391         bat_priv = container_of(delayed_work, struct batadv_priv, orig_work);
1392         batadv_purge_orig_ref(bat_priv);
1393         queue_delayed_work(batadv_event_workqueue,
1394                            &bat_priv->orig_work,
1395                            msecs_to_jiffies(BATADV_ORIG_WORK_PERIOD));
1396 }
1397
1398 #ifdef CONFIG_BATMAN_ADV_DEBUGFS
1399
1400 /**
1401  * batadv_orig_seq_print_text() - Print the originator table in a seq file
1402  * @seq: seq file to print on
1403  * @offset: not used
1404  *
1405  * Return: always 0
1406  */
1407 int batadv_orig_seq_print_text(struct seq_file *seq, void *offset)
1408 {
1409         struct net_device *net_dev = (struct net_device *)seq->private;
1410         struct batadv_priv *bat_priv = netdev_priv(net_dev);
1411         struct batadv_hard_iface *primary_if;
1412
1413         primary_if = batadv_seq_print_text_primary_if_get(seq);
1414         if (!primary_if)
1415                 return 0;
1416
1417         seq_printf(seq, "[B.A.T.M.A.N. adv %s, MainIF/MAC: %s/%pM (%s %s)]\n",
1418                    BATADV_SOURCE_VERSION, primary_if->net_dev->name,
1419                    primary_if->net_dev->dev_addr, net_dev->name,
1420                    bat_priv->algo_ops->name);
1421
1422         batadv_hardif_put(primary_if);
1423
1424         if (!bat_priv->algo_ops->orig.print) {
1425                 seq_puts(seq,
1426                          "No printing function for this routing protocol\n");
1427                 return 0;
1428         }
1429
1430         bat_priv->algo_ops->orig.print(bat_priv, seq, BATADV_IF_DEFAULT);
1431
1432         return 0;
1433 }
1434
1435 /**
1436  * batadv_orig_hardif_seq_print_text() - writes originator infos for a specific
1437  *  outgoing interface
1438  * @seq: debugfs table seq_file struct
1439  * @offset: not used
1440  *
1441  * Return: 0
1442  */
1443 int batadv_orig_hardif_seq_print_text(struct seq_file *seq, void *offset)
1444 {
1445         struct net_device *net_dev = (struct net_device *)seq->private;
1446         struct batadv_hard_iface *hard_iface;
1447         struct batadv_priv *bat_priv;
1448
1449         hard_iface = batadv_hardif_get_by_netdev(net_dev);
1450
1451         if (!hard_iface || !hard_iface->soft_iface) {
1452                 seq_puts(seq, "Interface not known to B.A.T.M.A.N.\n");
1453                 goto out;
1454         }
1455
1456         bat_priv = netdev_priv(hard_iface->soft_iface);
1457         if (!bat_priv->algo_ops->orig.print) {
1458                 seq_puts(seq,
1459                          "No printing function for this routing protocol\n");
1460                 goto out;
1461         }
1462
1463         if (hard_iface->if_status != BATADV_IF_ACTIVE) {
1464                 seq_puts(seq, "Interface not active\n");
1465                 goto out;
1466         }
1467
1468         seq_printf(seq, "[B.A.T.M.A.N. adv %s, IF/MAC: %s/%pM (%s %s)]\n",
1469                    BATADV_SOURCE_VERSION, hard_iface->net_dev->name,
1470                    hard_iface->net_dev->dev_addr,
1471                    hard_iface->soft_iface->name, bat_priv->algo_ops->name);
1472
1473         bat_priv->algo_ops->orig.print(bat_priv, seq, hard_iface);
1474
1475 out:
1476         if (hard_iface)
1477                 batadv_hardif_put(hard_iface);
1478         return 0;
1479 }
1480 #endif
1481
1482 /**
1483  * batadv_orig_dump() - Dump to netlink the originator infos for a specific
1484  *  outgoing interface
1485  * @msg: message to dump into
1486  * @cb: parameters for the dump
1487  *
1488  * Return: 0 or error value
1489  */
1490 int batadv_orig_dump(struct sk_buff *msg, struct netlink_callback *cb)
1491 {
1492         struct net *net = sock_net(cb->skb->sk);
1493         struct net_device *soft_iface;
1494         struct net_device *hard_iface = NULL;
1495         struct batadv_hard_iface *hardif = BATADV_IF_DEFAULT;
1496         struct batadv_priv *bat_priv;
1497         struct batadv_hard_iface *primary_if = NULL;
1498         int ret;
1499         int ifindex, hard_ifindex;
1500
1501         ifindex = batadv_netlink_get_ifindex(cb->nlh, BATADV_ATTR_MESH_IFINDEX);
1502         if (!ifindex)
1503                 return -EINVAL;
1504
1505         soft_iface = dev_get_by_index(net, ifindex);
1506         if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
1507                 ret = -ENODEV;
1508                 goto out;
1509         }
1510
1511         bat_priv = netdev_priv(soft_iface);
1512
1513         primary_if = batadv_primary_if_get_selected(bat_priv);
1514         if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
1515                 ret = -ENOENT;
1516                 goto out;
1517         }
1518
1519         hard_ifindex = batadv_netlink_get_ifindex(cb->nlh,
1520                                                   BATADV_ATTR_HARD_IFINDEX);
1521         if (hard_ifindex) {
1522                 hard_iface = dev_get_by_index(net, hard_ifindex);
1523                 if (hard_iface)
1524                         hardif = batadv_hardif_get_by_netdev(hard_iface);
1525
1526                 if (!hardif) {
1527                         ret = -ENODEV;
1528                         goto out;
1529                 }
1530
1531                 if (hardif->soft_iface != soft_iface) {
1532                         ret = -ENOENT;
1533                         goto out;
1534                 }
1535         }
1536
1537         if (!bat_priv->algo_ops->orig.dump) {
1538                 ret = -EOPNOTSUPP;
1539                 goto out;
1540         }
1541
1542         bat_priv->algo_ops->orig.dump(msg, cb, bat_priv, hardif);
1543
1544         ret = msg->len;
1545
1546  out:
1547         if (hardif)
1548                 batadv_hardif_put(hardif);
1549         if (hard_iface)
1550                 dev_put(hard_iface);
1551         if (primary_if)
1552                 batadv_hardif_put(primary_if);
1553         if (soft_iface)
1554                 dev_put(soft_iface);
1555
1556         return ret;
1557 }
1558
1559 /**
1560  * batadv_orig_hash_add_if() - Add interface to originators in orig_hash
1561  * @hard_iface: hard interface to add (already slave of the soft interface)
1562  * @max_if_num: new number of interfaces
1563  *
1564  * Return: 0 on success or negative error number in case of failure
1565  */
1566 int batadv_orig_hash_add_if(struct batadv_hard_iface *hard_iface,
1567                             unsigned int max_if_num)
1568 {
1569         struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
1570         struct batadv_algo_ops *bao = bat_priv->algo_ops;
1571         struct batadv_hashtable *hash = bat_priv->orig_hash;
1572         struct hlist_head *head;
1573         struct batadv_orig_node *orig_node;
1574         u32 i;
1575         int ret;
1576
1577         /* resize all orig nodes because orig_node->bcast_own(_sum) depend on
1578          * if_num
1579          */
1580         for (i = 0; i < hash->size; i++) {
1581                 head = &hash->table[i];
1582
1583                 rcu_read_lock();
1584                 hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
1585                         ret = 0;
1586                         if (bao->orig.add_if)
1587                                 ret = bao->orig.add_if(orig_node, max_if_num);
1588                         if (ret == -ENOMEM)
1589                                 goto err;
1590                 }
1591                 rcu_read_unlock();
1592         }
1593
1594         return 0;
1595
1596 err:
1597         rcu_read_unlock();
1598         return -ENOMEM;
1599 }
1600
1601 /**
1602  * batadv_orig_hash_del_if() - Remove interface from originators in orig_hash
1603  * @hard_iface: hard interface to remove (still slave of the soft interface)
1604  * @max_if_num: new number of interfaces
1605  *
1606  * Return: 0 on success or negative error number in case of failure
1607  */
1608 int batadv_orig_hash_del_if(struct batadv_hard_iface *hard_iface,
1609                             unsigned int max_if_num)
1610 {
1611         struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
1612         struct batadv_hashtable *hash = bat_priv->orig_hash;
1613         struct hlist_head *head;
1614         struct batadv_hard_iface *hard_iface_tmp;
1615         struct batadv_orig_node *orig_node;
1616         struct batadv_algo_ops *bao = bat_priv->algo_ops;
1617         u32 i;
1618         int ret;
1619
1620         /* resize all orig nodes because orig_node->bcast_own(_sum) depend on
1621          * if_num
1622          */
1623         for (i = 0; i < hash->size; i++) {
1624                 head = &hash->table[i];
1625
1626                 rcu_read_lock();
1627                 hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
1628                         ret = 0;
1629                         if (bao->orig.del_if)
1630                                 ret = bao->orig.del_if(orig_node, max_if_num,
1631                                                        hard_iface->if_num);
1632                         if (ret == -ENOMEM)
1633                                 goto err;
1634                 }
1635                 rcu_read_unlock();
1636         }
1637
1638         /* renumber remaining batman interfaces _inside_ of orig_hash_lock */
1639         rcu_read_lock();
1640         list_for_each_entry_rcu(hard_iface_tmp, &batadv_hardif_list, list) {
1641                 if (hard_iface_tmp->if_status == BATADV_IF_NOT_IN_USE)
1642                         continue;
1643
1644                 if (hard_iface == hard_iface_tmp)
1645                         continue;
1646
1647                 if (hard_iface->soft_iface != hard_iface_tmp->soft_iface)
1648                         continue;
1649
1650                 if (hard_iface_tmp->if_num > hard_iface->if_num)
1651                         hard_iface_tmp->if_num--;
1652         }
1653         rcu_read_unlock();
1654
1655         hard_iface->if_num = -1;
1656         return 0;
1657
1658 err:
1659         rcu_read_unlock();
1660         return -ENOMEM;
1661 }