net/batman-adv/originator.c

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