GNU Linux-libre 4.14.266-gnu1
[releases.git] / 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 }