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