blob: 018b7495ad844cdf4f97f1590455bc205cdf3d71 [file] [log] [blame]
Sven Eckelmann9f6446c2015-04-23 13:16:35 +02001/* Copyright (C) 2009-2015 B.A.T.M.A.N. contributors:
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00002 *
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
Antonio Quartulliebf38fb2013-11-03 20:40:48 +010015 * along with this program; if not, see <http://www.gnu.org/licenses/>.
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000016 */
17
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000018#include "originator.h"
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020019#include "main.h"
20
21#include <linux/errno.h>
22#include <linux/etherdevice.h>
23#include <linux/fs.h>
24#include <linux/jiffies.h>
25#include <linux/kernel.h>
26#include <linux/list.h>
27#include <linux/lockdep.h>
28#include <linux/netdevice.h>
29#include <linux/seq_file.h>
30#include <linux/slab.h>
31#include <linux/spinlock.h>
32#include <linux/workqueue.h>
33
34#include "distributed-arp-table.h"
35#include "fragmentation.h"
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000036#include "gateway_client.h"
37#include "hard-interface.h"
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020038#include "hash.h"
Linus Lüssing60432d72014-02-15 17:47:51 +010039#include "multicast.h"
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020040#include "network-coding.h"
41#include "routing.h"
42#include "translation-table.h"
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000043
Antonio Quartullidec05072012-11-10 11:00:32 +010044/* hash class keys */
45static struct lock_class_key batadv_orig_hash_lock_class_key;
46
Sven Eckelmann03fc7f82012-05-12 18:34:00 +020047static void batadv_purge_orig(struct work_struct *work);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000048
Sven Eckelmannb8e2dd12011-06-15 15:08:59 +020049/* returns 1 if they are the same originator */
Antonio Quartullibbad0a52013-09-02 12:15:02 +020050int batadv_compare_orig(const struct hlist_node *node, const void *data2)
Sven Eckelmannb8e2dd12011-06-15 15:08:59 +020051{
Sven Eckelmann56303d32012-06-05 22:31:31 +020052 const void *data1 = container_of(node, struct batadv_orig_node,
53 hash_entry);
Sven Eckelmannb8e2dd12011-06-15 15:08:59 +020054
dingtianhong323813e2013-12-26 19:40:39 +080055 return batadv_compare_eth(data1, data2);
Sven Eckelmannb8e2dd12011-06-15 15:08:59 +020056}
57
Antonio Quartulli7ea7b4a2013-07-30 22:16:25 +020058/**
59 * batadv_orig_node_vlan_get - get an orig_node_vlan object
60 * @orig_node: the originator serving the VLAN
61 * @vid: the VLAN identifier
62 *
63 * Returns the vlan object identified by vid and belonging to orig_node or NULL
64 * if it does not exist.
65 */
66struct batadv_orig_node_vlan *
67batadv_orig_node_vlan_get(struct batadv_orig_node *orig_node,
68 unsigned short vid)
69{
70 struct batadv_orig_node_vlan *vlan = NULL, *tmp;
71
72 rcu_read_lock();
73 list_for_each_entry_rcu(tmp, &orig_node->vlan_list, list) {
74 if (tmp->vid != vid)
75 continue;
76
77 if (!atomic_inc_not_zero(&tmp->refcount))
78 continue;
79
80 vlan = tmp;
81
82 break;
83 }
84 rcu_read_unlock();
85
86 return vlan;
87}
88
89/**
90 * batadv_orig_node_vlan_new - search and possibly create an orig_node_vlan
91 * object
92 * @orig_node: the originator serving the VLAN
93 * @vid: the VLAN identifier
94 *
95 * Returns NULL in case of failure or the vlan object identified by vid and
96 * belonging to orig_node otherwise. The object is created and added to the list
97 * if it does not exist.
98 *
99 * The object is returned with refcounter increased by 1.
100 */
101struct batadv_orig_node_vlan *
102batadv_orig_node_vlan_new(struct batadv_orig_node *orig_node,
103 unsigned short vid)
104{
105 struct batadv_orig_node_vlan *vlan;
106
107 spin_lock_bh(&orig_node->vlan_list_lock);
108
109 /* first look if an object for this vid already exists */
110 vlan = batadv_orig_node_vlan_get(orig_node, vid);
111 if (vlan)
112 goto out;
113
114 vlan = kzalloc(sizeof(*vlan), GFP_ATOMIC);
115 if (!vlan)
116 goto out;
117
118 atomic_set(&vlan->refcount, 2);
119 vlan->vid = vid;
120
121 list_add_rcu(&vlan->list, &orig_node->vlan_list);
122
123out:
124 spin_unlock_bh(&orig_node->vlan_list_lock);
125
126 return vlan;
127}
128
129/**
130 * batadv_orig_node_vlan_free_ref - decrement the refcounter and possibly free
131 * the originator-vlan object
132 * @orig_vlan: the originator-vlan object to release
133 */
134void batadv_orig_node_vlan_free_ref(struct batadv_orig_node_vlan *orig_vlan)
135{
136 if (atomic_dec_and_test(&orig_vlan->refcount))
137 kfree_rcu(orig_vlan, rcu);
138}
139
Sven Eckelmann56303d32012-06-05 22:31:31 +0200140int batadv_originator_init(struct batadv_priv *bat_priv)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000141{
142 if (bat_priv->orig_hash)
Sven Eckelmann5346c352012-05-05 13:27:28 +0200143 return 0;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000144
Sven Eckelmann1a8eaf02012-05-12 02:09:32 +0200145 bat_priv->orig_hash = batadv_hash_new(1024);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000146
147 if (!bat_priv->orig_hash)
148 goto err;
149
Antonio Quartullidec05072012-11-10 11:00:32 +0100150 batadv_hash_set_lock_class(bat_priv->orig_hash,
151 &batadv_orig_hash_lock_class_key);
152
Antonio Quartulli72414442012-12-25 13:14:37 +0100153 INIT_DELAYED_WORK(&bat_priv->orig_work, batadv_purge_orig);
154 queue_delayed_work(batadv_event_workqueue,
155 &bat_priv->orig_work,
156 msecs_to_jiffies(BATADV_ORIG_WORK_PERIOD));
157
Sven Eckelmann5346c352012-05-05 13:27:28 +0200158 return 0;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000159
160err:
Sven Eckelmann5346c352012-05-05 13:27:28 +0200161 return -ENOMEM;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000162}
163
Simon Wunderlich89652332013-11-13 19:14:46 +0100164/**
165 * batadv_neigh_ifinfo_free_rcu - free the neigh_ifinfo object
166 * @rcu: rcu pointer of the neigh_ifinfo object
167 */
168static void batadv_neigh_ifinfo_free_rcu(struct rcu_head *rcu)
169{
170 struct batadv_neigh_ifinfo *neigh_ifinfo;
171
172 neigh_ifinfo = container_of(rcu, struct batadv_neigh_ifinfo, rcu);
173
174 if (neigh_ifinfo->if_outgoing != BATADV_IF_DEFAULT)
175 batadv_hardif_free_ref_now(neigh_ifinfo->if_outgoing);
176
177 kfree(neigh_ifinfo);
178}
179
180/**
181 * batadv_neigh_ifinfo_free_now - decrement the refcounter and possibly free
182 * the neigh_ifinfo (without rcu callback)
183 * @neigh_ifinfo: the neigh_ifinfo object to release
184 */
185static void
186batadv_neigh_ifinfo_free_ref_now(struct batadv_neigh_ifinfo *neigh_ifinfo)
187{
188 if (atomic_dec_and_test(&neigh_ifinfo->refcount))
189 batadv_neigh_ifinfo_free_rcu(&neigh_ifinfo->rcu);
190}
191
192/**
193 * batadv_neigh_ifinfo_free_ref - decrement the refcounter and possibly free
194 * the neigh_ifinfo
195 * @neigh_ifinfo: the neigh_ifinfo object to release
196 */
197void batadv_neigh_ifinfo_free_ref(struct batadv_neigh_ifinfo *neigh_ifinfo)
198{
199 if (atomic_dec_and_test(&neigh_ifinfo->refcount))
200 call_rcu(&neigh_ifinfo->rcu, batadv_neigh_ifinfo_free_rcu);
201}
202
203/**
204 * batadv_neigh_node_free_rcu - free the neigh_node
205 * @rcu: rcu pointer of the neigh_node
206 */
207static void batadv_neigh_node_free_rcu(struct rcu_head *rcu)
208{
209 struct hlist_node *node_tmp;
210 struct batadv_neigh_node *neigh_node;
211 struct batadv_neigh_ifinfo *neigh_ifinfo;
Antonio Quartullibcef1f32015-03-01 00:50:17 +0800212 struct batadv_algo_ops *bao;
Simon Wunderlich89652332013-11-13 19:14:46 +0100213
214 neigh_node = container_of(rcu, struct batadv_neigh_node, rcu);
Antonio Quartullibcef1f32015-03-01 00:50:17 +0800215 bao = neigh_node->orig_node->bat_priv->bat_algo_ops;
Simon Wunderlich89652332013-11-13 19:14:46 +0100216
217 hlist_for_each_entry_safe(neigh_ifinfo, node_tmp,
218 &neigh_node->ifinfo_list, list) {
219 batadv_neigh_ifinfo_free_ref_now(neigh_ifinfo);
220 }
Antonio Quartullibcef1f32015-03-01 00:50:17 +0800221
222 if (bao->bat_neigh_free)
223 bao->bat_neigh_free(neigh_node);
224
Simon Wunderlich89652332013-11-13 19:14:46 +0100225 batadv_hardif_free_ref_now(neigh_node->if_incoming);
226
227 kfree(neigh_node);
228}
229
230/**
231 * batadv_neigh_node_free_ref_now - decrement the neighbors refcounter
232 * and possibly free it (without rcu callback)
233 * @neigh_node: neigh neighbor to free
234 */
235static void
236batadv_neigh_node_free_ref_now(struct batadv_neigh_node *neigh_node)
237{
238 if (atomic_dec_and_test(&neigh_node->refcount))
239 batadv_neigh_node_free_rcu(&neigh_node->rcu);
240}
241
242/**
243 * batadv_neigh_node_free_ref - decrement the neighbors refcounter
244 * and possibly free it
245 * @neigh_node: neigh neighbor to free
246 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200247void batadv_neigh_node_free_ref(struct batadv_neigh_node *neigh_node)
Simon Wunderlicha4c135c2011-01-19 20:01:43 +0000248{
Marek Lindner44524fc2011-02-10 14:33:53 +0000249 if (atomic_dec_and_test(&neigh_node->refcount))
Simon Wunderlich89652332013-11-13 19:14:46 +0100250 call_rcu(&neigh_node->rcu, batadv_neigh_node_free_rcu);
Simon Wunderlicha4c135c2011-01-19 20:01:43 +0000251}
252
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100253/**
254 * batadv_orig_node_get_router - router to the originator depending on iface
255 * @orig_node: the orig node for the router
256 * @if_outgoing: the interface where the payload packet has been received or
257 * the OGM should be sent to
258 *
259 * Returns the neighbor which should be router for this orig_node/iface.
260 *
261 * The object is returned with refcounter increased by 1.
262 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200263struct batadv_neigh_node *
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100264batadv_orig_router_get(struct batadv_orig_node *orig_node,
265 const struct batadv_hard_iface *if_outgoing)
Linus Lüssinge1a5382f2011-03-14 22:43:37 +0000266{
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100267 struct batadv_orig_ifinfo *orig_ifinfo;
268 struct batadv_neigh_node *router = NULL;
Linus Lüssinge1a5382f2011-03-14 22:43:37 +0000269
270 rcu_read_lock();
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100271 hlist_for_each_entry_rcu(orig_ifinfo, &orig_node->ifinfo_list, list) {
272 if (orig_ifinfo->if_outgoing != if_outgoing)
273 continue;
274
275 router = rcu_dereference(orig_ifinfo->router);
276 break;
277 }
Linus Lüssinge1a5382f2011-03-14 22:43:37 +0000278
279 if (router && !atomic_inc_not_zero(&router->refcount))
280 router = NULL;
281
282 rcu_read_unlock();
283 return router;
284}
285
Antonio Quartulli0538f752013-09-02 12:15:01 +0200286/**
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100287 * batadv_orig_ifinfo_get - find the ifinfo from an orig_node
288 * @orig_node: the orig node to be queried
289 * @if_outgoing: the interface for which the ifinfo should be acquired
290 *
291 * Returns the requested orig_ifinfo or NULL if not found.
292 *
293 * The object is returned with refcounter increased by 1.
294 */
295struct batadv_orig_ifinfo *
296batadv_orig_ifinfo_get(struct batadv_orig_node *orig_node,
297 struct batadv_hard_iface *if_outgoing)
298{
299 struct batadv_orig_ifinfo *tmp, *orig_ifinfo = NULL;
300
301 rcu_read_lock();
302 hlist_for_each_entry_rcu(tmp, &orig_node->ifinfo_list,
303 list) {
304 if (tmp->if_outgoing != if_outgoing)
305 continue;
306
307 if (!atomic_inc_not_zero(&tmp->refcount))
308 continue;
309
310 orig_ifinfo = tmp;
311 break;
312 }
313 rcu_read_unlock();
314
315 return orig_ifinfo;
316}
317
318/**
319 * batadv_orig_ifinfo_new - search and possibly create an orig_ifinfo object
320 * @orig_node: the orig node to be queried
321 * @if_outgoing: the interface for which the ifinfo should be acquired
322 *
323 * Returns NULL in case of failure or the orig_ifinfo object for the if_outgoing
324 * interface otherwise. The object is created and added to the list
325 * if it does not exist.
326 *
327 * The object is returned with refcounter increased by 1.
328 */
329struct batadv_orig_ifinfo *
330batadv_orig_ifinfo_new(struct batadv_orig_node *orig_node,
331 struct batadv_hard_iface *if_outgoing)
332{
333 struct batadv_orig_ifinfo *orig_ifinfo = NULL;
334 unsigned long reset_time;
335
336 spin_lock_bh(&orig_node->neigh_list_lock);
337
338 orig_ifinfo = batadv_orig_ifinfo_get(orig_node, if_outgoing);
339 if (orig_ifinfo)
340 goto out;
341
342 orig_ifinfo = kzalloc(sizeof(*orig_ifinfo), GFP_ATOMIC);
343 if (!orig_ifinfo)
344 goto out;
345
346 if (if_outgoing != BATADV_IF_DEFAULT &&
347 !atomic_inc_not_zero(&if_outgoing->refcount)) {
348 kfree(orig_ifinfo);
349 orig_ifinfo = NULL;
350 goto out;
351 }
352
353 reset_time = jiffies - 1;
354 reset_time -= msecs_to_jiffies(BATADV_RESET_PROTECTION_MS);
355 orig_ifinfo->batman_seqno_reset = reset_time;
356 orig_ifinfo->if_outgoing = if_outgoing;
357 INIT_HLIST_NODE(&orig_ifinfo->list);
358 atomic_set(&orig_ifinfo->refcount, 2);
359 hlist_add_head_rcu(&orig_ifinfo->list,
360 &orig_node->ifinfo_list);
361out:
362 spin_unlock_bh(&orig_node->neigh_list_lock);
363 return orig_ifinfo;
364}
365
366/**
Simon Wunderlich89652332013-11-13 19:14:46 +0100367 * batadv_neigh_ifinfo_get - find the ifinfo from an neigh_node
368 * @neigh_node: the neigh node to be queried
369 * @if_outgoing: the interface for which the ifinfo should be acquired
370 *
371 * The object is returned with refcounter increased by 1.
372 *
373 * Returns the requested neigh_ifinfo or NULL if not found
374 */
375struct batadv_neigh_ifinfo *
376batadv_neigh_ifinfo_get(struct batadv_neigh_node *neigh,
377 struct batadv_hard_iface *if_outgoing)
378{
379 struct batadv_neigh_ifinfo *neigh_ifinfo = NULL,
380 *tmp_neigh_ifinfo;
381
382 rcu_read_lock();
383 hlist_for_each_entry_rcu(tmp_neigh_ifinfo, &neigh->ifinfo_list,
384 list) {
385 if (tmp_neigh_ifinfo->if_outgoing != if_outgoing)
386 continue;
387
388 if (!atomic_inc_not_zero(&tmp_neigh_ifinfo->refcount))
389 continue;
390
391 neigh_ifinfo = tmp_neigh_ifinfo;
392 break;
393 }
394 rcu_read_unlock();
395
396 return neigh_ifinfo;
397}
398
399/**
400 * batadv_neigh_ifinfo_new - search and possibly create an neigh_ifinfo object
401 * @neigh_node: the neigh node to be queried
402 * @if_outgoing: the interface for which the ifinfo should be acquired
403 *
404 * Returns NULL in case of failure or the neigh_ifinfo object for the
405 * if_outgoing interface otherwise. The object is created and added to the list
406 * if it does not exist.
407 *
408 * The object is returned with refcounter increased by 1.
409 */
410struct batadv_neigh_ifinfo *
411batadv_neigh_ifinfo_new(struct batadv_neigh_node *neigh,
412 struct batadv_hard_iface *if_outgoing)
413{
414 struct batadv_neigh_ifinfo *neigh_ifinfo;
415
416 spin_lock_bh(&neigh->ifinfo_lock);
417
418 neigh_ifinfo = batadv_neigh_ifinfo_get(neigh, if_outgoing);
419 if (neigh_ifinfo)
420 goto out;
421
422 neigh_ifinfo = kzalloc(sizeof(*neigh_ifinfo), GFP_ATOMIC);
423 if (!neigh_ifinfo)
424 goto out;
425
426 if (if_outgoing && !atomic_inc_not_zero(&if_outgoing->refcount)) {
427 kfree(neigh_ifinfo);
428 neigh_ifinfo = NULL;
429 goto out;
430 }
431
432 INIT_HLIST_NODE(&neigh_ifinfo->list);
433 atomic_set(&neigh_ifinfo->refcount, 2);
434 neigh_ifinfo->if_outgoing = if_outgoing;
435
436 hlist_add_head_rcu(&neigh_ifinfo->list, &neigh->ifinfo_list);
437
438out:
439 spin_unlock_bh(&neigh->ifinfo_lock);
440
441 return neigh_ifinfo;
442}
443
444/**
Antonio Quartulli0538f752013-09-02 12:15:01 +0200445 * batadv_neigh_node_new - create and init a new neigh_node object
446 * @hard_iface: the interface where the neighbour is connected to
447 * @neigh_addr: the mac address of the neighbour interface
448 * @orig_node: originator object representing the neighbour
449 *
450 * Allocates a new neigh_node object and initialises all the generic fields.
451 * Returns the new object or NULL on failure.
452 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200453struct batadv_neigh_node *
454batadv_neigh_node_new(struct batadv_hard_iface *hard_iface,
Antonio Quartulli0538f752013-09-02 12:15:01 +0200455 const uint8_t *neigh_addr,
456 struct batadv_orig_node *orig_node)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000457{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200458 struct batadv_neigh_node *neigh_node;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000459
Sven Eckelmann704509b2011-05-14 23:14:54 +0200460 neigh_node = kzalloc(sizeof(*neigh_node), GFP_ATOMIC);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000461 if (!neigh_node)
Marek Lindner7ae8b282012-03-01 15:35:21 +0800462 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000463
Marek Lindner9591a792010-12-12 21:57:11 +0000464 INIT_HLIST_NODE(&neigh_node->list);
Simon Wunderlich89652332013-11-13 19:14:46 +0100465 INIT_HLIST_HEAD(&neigh_node->ifinfo_list);
466 spin_lock_init(&neigh_node->ifinfo_lock);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000467
Antonio Quartulli8fdd0152014-01-22 00:42:11 +0100468 ether_addr_copy(neigh_node->addr, neigh_addr);
Antonio Quartulli0538f752013-09-02 12:15:01 +0200469 neigh_node->if_incoming = hard_iface;
470 neigh_node->orig_node = orig_node;
471
Marek Lindner1605d0d2011-02-18 12:28:11 +0000472 /* extra reference for return */
473 atomic_set(&neigh_node->refcount, 2);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000474
Marek Lindner7ae8b282012-03-01 15:35:21 +0800475out:
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000476 return neigh_node;
477}
478
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100479/**
Antonio Quartulli08bf0ed2014-01-29 11:25:12 +0100480 * batadv_neigh_node_get - retrieve a neighbour from the list
481 * @orig_node: originator which the neighbour belongs to
482 * @hard_iface: the interface where this neighbour is connected to
483 * @addr: the address of the neighbour
484 *
485 * Looks for and possibly returns a neighbour belonging to this originator list
486 * which is connected through the provided hard interface.
487 * Returns NULL if the neighbour is not found.
488 */
489struct batadv_neigh_node *
490batadv_neigh_node_get(const struct batadv_orig_node *orig_node,
491 const struct batadv_hard_iface *hard_iface,
492 const uint8_t *addr)
493{
494 struct batadv_neigh_node *tmp_neigh_node, *res = NULL;
495
496 rcu_read_lock();
497 hlist_for_each_entry_rcu(tmp_neigh_node, &orig_node->neigh_list, list) {
498 if (!batadv_compare_eth(tmp_neigh_node->addr, addr))
499 continue;
500
501 if (tmp_neigh_node->if_incoming != hard_iface)
502 continue;
503
504 if (!atomic_inc_not_zero(&tmp_neigh_node->refcount))
505 continue;
506
507 res = tmp_neigh_node;
508 break;
509 }
510 rcu_read_unlock();
511
512 return res;
513}
514
515/**
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100516 * batadv_orig_ifinfo_free_rcu - free the orig_ifinfo object
517 * @rcu: rcu pointer of the orig_ifinfo object
518 */
519static void batadv_orig_ifinfo_free_rcu(struct rcu_head *rcu)
520{
521 struct batadv_orig_ifinfo *orig_ifinfo;
Simon Wunderlich000c8df2014-03-26 15:46:22 +0100522 struct batadv_neigh_node *router;
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100523
524 orig_ifinfo = container_of(rcu, struct batadv_orig_ifinfo, rcu);
525
526 if (orig_ifinfo->if_outgoing != BATADV_IF_DEFAULT)
527 batadv_hardif_free_ref_now(orig_ifinfo->if_outgoing);
528
Simon Wunderlich000c8df2014-03-26 15:46:22 +0100529 /* this is the last reference to this object */
530 router = rcu_dereference_protected(orig_ifinfo->router, true);
531 if (router)
532 batadv_neigh_node_free_ref_now(router);
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100533 kfree(orig_ifinfo);
534}
535
536/**
537 * batadv_orig_ifinfo_free_ref - decrement the refcounter and possibly free
538 * the orig_ifinfo (without rcu callback)
539 * @orig_ifinfo: the orig_ifinfo object to release
540 */
541static void
542batadv_orig_ifinfo_free_ref_now(struct batadv_orig_ifinfo *orig_ifinfo)
543{
544 if (atomic_dec_and_test(&orig_ifinfo->refcount))
545 batadv_orig_ifinfo_free_rcu(&orig_ifinfo->rcu);
546}
547
548/**
549 * batadv_orig_ifinfo_free_ref - decrement the refcounter and possibly free
550 * the orig_ifinfo
551 * @orig_ifinfo: the orig_ifinfo object to release
552 */
553void batadv_orig_ifinfo_free_ref(struct batadv_orig_ifinfo *orig_ifinfo)
554{
555 if (atomic_dec_and_test(&orig_ifinfo->refcount))
556 call_rcu(&orig_ifinfo->rcu, batadv_orig_ifinfo_free_rcu);
557}
558
Sven Eckelmann03fc7f82012-05-12 18:34:00 +0200559static void batadv_orig_node_free_rcu(struct rcu_head *rcu)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000560{
Sasha Levinb67bfe02013-02-27 17:06:00 -0800561 struct hlist_node *node_tmp;
Simon Wunderlichf6c8b712013-11-13 19:14:45 +0100562 struct batadv_neigh_node *neigh_node;
Sven Eckelmann56303d32012-06-05 22:31:31 +0200563 struct batadv_orig_node *orig_node;
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100564 struct batadv_orig_ifinfo *orig_ifinfo;
Marek Lindner16b1aba2011-01-19 20:01:42 +0000565
Sven Eckelmann56303d32012-06-05 22:31:31 +0200566 orig_node = container_of(rcu, struct batadv_orig_node, rcu);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000567
Marek Lindnerf987ed62010-12-12 21:57:12 +0000568 spin_lock_bh(&orig_node->neigh_list_lock);
569
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000570 /* for all neighbors towards this originator ... */
Sasha Levinb67bfe02013-02-27 17:06:00 -0800571 hlist_for_each_entry_safe(neigh_node, node_tmp,
Marek Lindner9591a792010-12-12 21:57:11 +0000572 &orig_node->neigh_list, list) {
Marek Lindnerf987ed62010-12-12 21:57:12 +0000573 hlist_del_rcu(&neigh_node->list);
Simon Wunderlich89652332013-11-13 19:14:46 +0100574 batadv_neigh_node_free_ref_now(neigh_node);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000575 }
576
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100577 hlist_for_each_entry_safe(orig_ifinfo, node_tmp,
578 &orig_node->ifinfo_list, list) {
579 hlist_del_rcu(&orig_ifinfo->list);
580 batadv_orig_ifinfo_free_ref_now(orig_ifinfo);
581 }
Marek Lindnerf987ed62010-12-12 21:57:12 +0000582 spin_unlock_bh(&orig_node->neigh_list_lock);
583
Linus Lüssing60432d72014-02-15 17:47:51 +0100584 batadv_mcast_purge_orig(orig_node);
585
Martin Hundebølld56b1702013-01-25 11:12:39 +0100586 /* Free nc_nodes */
587 batadv_nc_purge_orig(orig_node->bat_priv, orig_node, NULL);
588
Martin Hundebøll610bfc6bc2013-05-23 16:53:02 +0200589 batadv_frag_purge_orig(orig_node, NULL);
590
Antonio Quartullid0015fd2013-09-03 11:10:23 +0200591 if (orig_node->bat_priv->bat_algo_ops->bat_orig_free)
592 orig_node->bat_priv->bat_algo_ops->bat_orig_free(orig_node);
593
Antonio Quartullia73105b2011-04-27 14:27:44 +0200594 kfree(orig_node->tt_buff);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000595 kfree(orig_node);
596}
597
Linus Lüssing72822222013-04-15 21:43:29 +0800598/**
599 * batadv_orig_node_free_ref - decrement the orig node refcounter and possibly
600 * schedule an rcu callback for freeing it
601 * @orig_node: the orig node to free
602 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200603void batadv_orig_node_free_ref(struct batadv_orig_node *orig_node)
Marek Lindner7b36e8e2011-02-18 12:28:10 +0000604{
605 if (atomic_dec_and_test(&orig_node->refcount))
Sven Eckelmann03fc7f82012-05-12 18:34:00 +0200606 call_rcu(&orig_node->rcu, batadv_orig_node_free_rcu);
Marek Lindner7b36e8e2011-02-18 12:28:10 +0000607}
608
Linus Lüssing72822222013-04-15 21:43:29 +0800609/**
610 * batadv_orig_node_free_ref_now - decrement the orig node refcounter and
611 * possibly free it (without rcu callback)
612 * @orig_node: the orig node to free
613 */
614void batadv_orig_node_free_ref_now(struct batadv_orig_node *orig_node)
615{
616 if (atomic_dec_and_test(&orig_node->refcount))
617 batadv_orig_node_free_rcu(&orig_node->rcu);
618}
619
Sven Eckelmann56303d32012-06-05 22:31:31 +0200620void batadv_originator_free(struct batadv_priv *bat_priv)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000621{
Sven Eckelmann5bf74e92012-06-05 22:31:28 +0200622 struct batadv_hashtable *hash = bat_priv->orig_hash;
Sasha Levinb67bfe02013-02-27 17:06:00 -0800623 struct hlist_node *node_tmp;
Marek Lindner16b1aba2011-01-19 20:01:42 +0000624 struct hlist_head *head;
Marek Lindner16b1aba2011-01-19 20:01:42 +0000625 spinlock_t *list_lock; /* spinlock to protect write access */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200626 struct batadv_orig_node *orig_node;
Antonio Quartullic90681b2011-10-05 17:05:25 +0200627 uint32_t i;
Marek Lindner16b1aba2011-01-19 20:01:42 +0000628
629 if (!hash)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000630 return;
631
632 cancel_delayed_work_sync(&bat_priv->orig_work);
633
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000634 bat_priv->orig_hash = NULL;
Marek Lindner16b1aba2011-01-19 20:01:42 +0000635
636 for (i = 0; i < hash->size; i++) {
637 head = &hash->table[i];
638 list_lock = &hash->list_locks[i];
639
640 spin_lock_bh(list_lock);
Sasha Levinb67bfe02013-02-27 17:06:00 -0800641 hlist_for_each_entry_safe(orig_node, node_tmp,
Marek Lindner7aadf882011-02-18 12:28:09 +0000642 head, hash_entry) {
Sasha Levinb67bfe02013-02-27 17:06:00 -0800643 hlist_del_rcu(&orig_node->hash_entry);
Sven Eckelmann7d211ef2012-05-12 02:09:34 +0200644 batadv_orig_node_free_ref(orig_node);
Marek Lindner16b1aba2011-01-19 20:01:42 +0000645 }
646 spin_unlock_bh(list_lock);
647 }
648
Sven Eckelmann1a8eaf02012-05-12 02:09:32 +0200649 batadv_hash_destroy(hash);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000650}
651
Antonio Quartullibbad0a52013-09-02 12:15:02 +0200652/**
653 * batadv_orig_node_new - creates a new orig_node
654 * @bat_priv: the bat priv with all the soft interface information
655 * @addr: the mac address of the originator
656 *
657 * Creates a new originator object and initialise all the generic fields.
658 * The new object is not added to the originator list.
659 * Returns the newly created object or NULL on failure.
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +0200660 */
Antonio Quartullibbad0a52013-09-02 12:15:02 +0200661struct batadv_orig_node *batadv_orig_node_new(struct batadv_priv *bat_priv,
Sven Eckelmann56303d32012-06-05 22:31:31 +0200662 const uint8_t *addr)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000663{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200664 struct batadv_orig_node *orig_node;
Antonio Quartulli7ea7b4a2013-07-30 22:16:25 +0200665 struct batadv_orig_node_vlan *vlan;
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200666 unsigned long reset_time;
Antonio Quartullibbad0a52013-09-02 12:15:02 +0200667 int i;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000668
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200669 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
670 "Creating new originator: %pM\n", addr);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000671
Sven Eckelmann704509b2011-05-14 23:14:54 +0200672 orig_node = kzalloc(sizeof(*orig_node), GFP_ATOMIC);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000673 if (!orig_node)
674 return NULL;
675
Marek Lindner9591a792010-12-12 21:57:11 +0000676 INIT_HLIST_HEAD(&orig_node->neigh_list);
Antonio Quartulli7ea7b4a2013-07-30 22:16:25 +0200677 INIT_LIST_HEAD(&orig_node->vlan_list);
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100678 INIT_HLIST_HEAD(&orig_node->ifinfo_list);
Marek Lindnerf3e00082011-01-25 21:52:11 +0000679 spin_lock_init(&orig_node->bcast_seqno_lock);
Marek Lindnerf987ed62010-12-12 21:57:12 +0000680 spin_lock_init(&orig_node->neigh_list_lock);
Antonio Quartullia73105b2011-04-27 14:27:44 +0200681 spin_lock_init(&orig_node->tt_buff_lock);
Antonio Quartullia70a9aa2013-07-30 22:16:24 +0200682 spin_lock_init(&orig_node->tt_lock);
Antonio Quartulli7ea7b4a2013-07-30 22:16:25 +0200683 spin_lock_init(&orig_node->vlan_list_lock);
Marek Lindner7b36e8e2011-02-18 12:28:10 +0000684
Martin Hundebølld56b1702013-01-25 11:12:39 +0100685 batadv_nc_init_orig(orig_node);
686
Marek Lindner7b36e8e2011-02-18 12:28:10 +0000687 /* extra reference for return */
688 atomic_set(&orig_node->refcount, 2);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000689
Marek Lindner16b1aba2011-01-19 20:01:42 +0000690 orig_node->bat_priv = bat_priv;
Antonio Quartulli8fdd0152014-01-22 00:42:11 +0100691 ether_addr_copy(orig_node->orig, addr);
Antonio Quartulli785ea112011-11-23 11:35:44 +0100692 batadv_dat_init_orig_node_addr(orig_node);
Antonio Quartullic8c991b2011-07-07 01:40:57 +0200693 atomic_set(&orig_node->last_ttvn, 0);
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200694 orig_node->tt_buff = NULL;
Antonio Quartullia73105b2011-04-27 14:27:44 +0200695 orig_node->tt_buff_len = 0;
Linus Lüssing2c667a32014-10-30 06:23:40 +0100696 orig_node->last_seen = jiffies;
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200697 reset_time = jiffies - 1 - msecs_to_jiffies(BATADV_RESET_PROTECTION_MS);
698 orig_node->bcast_seqno_reset = reset_time;
Linus Lüssing60432d72014-02-15 17:47:51 +0100699#ifdef CONFIG_BATMAN_ADV_MCAST
700 orig_node->mcast_flags = BATADV_NO_FLAGS;
701#endif
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000702
Antonio Quartulli7ea7b4a2013-07-30 22:16:25 +0200703 /* create a vlan object for the "untagged" LAN */
704 vlan = batadv_orig_node_vlan_new(orig_node, BATADV_NO_FLAGS);
705 if (!vlan)
706 goto free_orig_node;
707 /* batadv_orig_node_vlan_new() increases the refcounter.
708 * Immediately release vlan since it is not needed anymore in this
709 * context
710 */
711 batadv_orig_node_vlan_free_ref(vlan);
712
Martin Hundebøll610bfc6bc2013-05-23 16:53:02 +0200713 for (i = 0; i < BATADV_FRAG_BUFFER_COUNT; i++) {
714 INIT_HLIST_HEAD(&orig_node->fragments[i].head);
715 spin_lock_init(&orig_node->fragments[i].lock);
716 orig_node->fragments[i].size = 0;
717 }
718
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000719 return orig_node;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000720free_orig_node:
721 kfree(orig_node);
722 return NULL;
723}
724
Simon Wunderlich89652332013-11-13 19:14:46 +0100725/**
Simon Wunderlich709de132014-03-26 15:46:24 +0100726 * batadv_purge_neigh_ifinfo - purge obsolete ifinfo entries from neighbor
727 * @bat_priv: the bat priv with all the soft interface information
728 * @neigh: orig node which is to be checked
729 */
730static void
731batadv_purge_neigh_ifinfo(struct batadv_priv *bat_priv,
732 struct batadv_neigh_node *neigh)
733{
734 struct batadv_neigh_ifinfo *neigh_ifinfo;
735 struct batadv_hard_iface *if_outgoing;
736 struct hlist_node *node_tmp;
737
738 spin_lock_bh(&neigh->ifinfo_lock);
739
740 /* for all ifinfo objects for this neighinator */
741 hlist_for_each_entry_safe(neigh_ifinfo, node_tmp,
742 &neigh->ifinfo_list, list) {
743 if_outgoing = neigh_ifinfo->if_outgoing;
744
745 /* always keep the default interface */
746 if (if_outgoing == BATADV_IF_DEFAULT)
747 continue;
748
749 /* don't purge if the interface is not (going) down */
750 if ((if_outgoing->if_status != BATADV_IF_INACTIVE) &&
751 (if_outgoing->if_status != BATADV_IF_NOT_IN_USE) &&
752 (if_outgoing->if_status != BATADV_IF_TO_BE_REMOVED))
753 continue;
754
755 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
756 "neighbor/ifinfo purge: neighbor %pM, iface: %s\n",
757 neigh->addr, if_outgoing->net_dev->name);
758
759 hlist_del_rcu(&neigh_ifinfo->list);
760 batadv_neigh_ifinfo_free_ref(neigh_ifinfo);
761 }
762
763 spin_unlock_bh(&neigh->ifinfo_lock);
764}
765
766/**
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100767 * batadv_purge_orig_ifinfo - purge obsolete ifinfo entries from originator
768 * @bat_priv: the bat priv with all the soft interface information
769 * @orig_node: orig node which is to be checked
770 *
771 * Returns true if any ifinfo entry was purged, false otherwise.
772 */
773static bool
774batadv_purge_orig_ifinfo(struct batadv_priv *bat_priv,
775 struct batadv_orig_node *orig_node)
776{
777 struct batadv_orig_ifinfo *orig_ifinfo;
778 struct batadv_hard_iface *if_outgoing;
779 struct hlist_node *node_tmp;
780 bool ifinfo_purged = false;
781
782 spin_lock_bh(&orig_node->neigh_list_lock);
783
784 /* for all ifinfo objects for this originator */
785 hlist_for_each_entry_safe(orig_ifinfo, node_tmp,
786 &orig_node->ifinfo_list, list) {
787 if_outgoing = orig_ifinfo->if_outgoing;
788
789 /* always keep the default interface */
790 if (if_outgoing == BATADV_IF_DEFAULT)
791 continue;
792
793 /* don't purge if the interface is not (going) down */
794 if ((if_outgoing->if_status != BATADV_IF_INACTIVE) &&
795 (if_outgoing->if_status != BATADV_IF_NOT_IN_USE) &&
796 (if_outgoing->if_status != BATADV_IF_TO_BE_REMOVED))
797 continue;
798
799 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
800 "router/ifinfo purge: originator %pM, iface: %s\n",
801 orig_node->orig, if_outgoing->net_dev->name);
802
803 ifinfo_purged = true;
804
805 hlist_del_rcu(&orig_ifinfo->list);
806 batadv_orig_ifinfo_free_ref(orig_ifinfo);
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100807 if (orig_node->last_bonding_candidate == orig_ifinfo) {
808 orig_node->last_bonding_candidate = NULL;
809 batadv_orig_ifinfo_free_ref(orig_ifinfo);
810 }
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100811 }
812
813 spin_unlock_bh(&orig_node->neigh_list_lock);
814
815 return ifinfo_purged;
816}
817
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100818/**
Simon Wunderlich89652332013-11-13 19:14:46 +0100819 * batadv_purge_orig_neighbors - purges neighbors from originator
820 * @bat_priv: the bat priv with all the soft interface information
821 * @orig_node: orig node which is to be checked
822 *
823 * Returns true if any neighbor was purged, false otherwise
824 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200825static bool
826batadv_purge_orig_neighbors(struct batadv_priv *bat_priv,
Simon Wunderlich89652332013-11-13 19:14:46 +0100827 struct batadv_orig_node *orig_node)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000828{
Sasha Levinb67bfe02013-02-27 17:06:00 -0800829 struct hlist_node *node_tmp;
Sven Eckelmann56303d32012-06-05 22:31:31 +0200830 struct batadv_neigh_node *neigh_node;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000831 bool neigh_purged = false;
Marek Lindner0b0094e2012-03-01 15:35:20 +0800832 unsigned long last_seen;
Sven Eckelmann56303d32012-06-05 22:31:31 +0200833 struct batadv_hard_iface *if_incoming;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000834
Marek Lindnerf987ed62010-12-12 21:57:12 +0000835 spin_lock_bh(&orig_node->neigh_list_lock);
836
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000837 /* for all neighbors towards this originator ... */
Sasha Levinb67bfe02013-02-27 17:06:00 -0800838 hlist_for_each_entry_safe(neigh_node, node_tmp,
Marek Lindner9591a792010-12-12 21:57:11 +0000839 &orig_node->neigh_list, list) {
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200840 last_seen = neigh_node->last_seen;
841 if_incoming = neigh_node->if_incoming;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000842
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200843 if ((batadv_has_timed_out(last_seen, BATADV_PURGE_TIMEOUT)) ||
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200844 (if_incoming->if_status == BATADV_IF_INACTIVE) ||
845 (if_incoming->if_status == BATADV_IF_NOT_IN_USE) ||
846 (if_incoming->if_status == BATADV_IF_TO_BE_REMOVED)) {
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200847 if ((if_incoming->if_status == BATADV_IF_INACTIVE) ||
848 (if_incoming->if_status == BATADV_IF_NOT_IN_USE) ||
849 (if_incoming->if_status == BATADV_IF_TO_BE_REMOVED))
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200850 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200851 "neighbor purge: originator %pM, neighbor: %pM, iface: %s\n",
852 orig_node->orig, neigh_node->addr,
853 if_incoming->net_dev->name);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000854 else
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200855 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200856 "neighbor timeout: originator %pM, neighbor: %pM, last_seen: %u\n",
857 orig_node->orig, neigh_node->addr,
858 jiffies_to_msecs(last_seen));
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000859
860 neigh_purged = true;
Marek Lindner9591a792010-12-12 21:57:11 +0000861
Marek Lindnerf987ed62010-12-12 21:57:12 +0000862 hlist_del_rcu(&neigh_node->list);
Sven Eckelmann7d211ef2012-05-12 02:09:34 +0200863 batadv_neigh_node_free_ref(neigh_node);
Simon Wunderlich709de132014-03-26 15:46:24 +0100864 } else {
865 /* only necessary if not the whole neighbor is to be
866 * deleted, but some interface has been removed.
867 */
868 batadv_purge_neigh_ifinfo(bat_priv, neigh_node);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000869 }
870 }
Marek Lindnerf987ed62010-12-12 21:57:12 +0000871
872 spin_unlock_bh(&orig_node->neigh_list_lock);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000873 return neigh_purged;
874}
875
Simon Wunderlich89652332013-11-13 19:14:46 +0100876/**
877 * batadv_find_best_neighbor - finds the best neighbor after purging
878 * @bat_priv: the bat priv with all the soft interface information
879 * @orig_node: orig node which is to be checked
880 * @if_outgoing: the interface for which the metric should be compared
881 *
882 * Returns the current best neighbor, with refcount increased.
883 */
884static struct batadv_neigh_node *
885batadv_find_best_neighbor(struct batadv_priv *bat_priv,
886 struct batadv_orig_node *orig_node,
887 struct batadv_hard_iface *if_outgoing)
888{
889 struct batadv_neigh_node *best = NULL, *neigh;
890 struct batadv_algo_ops *bao = bat_priv->bat_algo_ops;
891
892 rcu_read_lock();
893 hlist_for_each_entry_rcu(neigh, &orig_node->neigh_list, list) {
894 if (best && (bao->bat_neigh_cmp(neigh, if_outgoing,
895 best, if_outgoing) <= 0))
896 continue;
897
898 if (!atomic_inc_not_zero(&neigh->refcount))
899 continue;
900
901 if (best)
902 batadv_neigh_node_free_ref(best);
903
904 best = neigh;
905 }
906 rcu_read_unlock();
907
908 return best;
909}
910
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100911/**
912 * batadv_purge_orig_node - purges obsolete information from an orig_node
913 * @bat_priv: the bat priv with all the soft interface information
914 * @orig_node: orig node which is to be checked
915 *
916 * This function checks if the orig_node or substructures of it have become
917 * obsolete, and purges this information if that's the case.
918 *
919 * Returns true if the orig_node is to be removed, false otherwise.
920 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200921static bool batadv_purge_orig_node(struct batadv_priv *bat_priv,
922 struct batadv_orig_node *orig_node)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000923{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200924 struct batadv_neigh_node *best_neigh_node;
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100925 struct batadv_hard_iface *hard_iface;
Simon Wunderlich7b955a92014-03-26 15:46:23 +0100926 bool changed_ifinfo, changed_neigh;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000927
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200928 if (batadv_has_timed_out(orig_node->last_seen,
929 2 * BATADV_PURGE_TIMEOUT)) {
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200930 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200931 "Originator timeout: originator %pM, last_seen %u\n",
932 orig_node->orig,
933 jiffies_to_msecs(orig_node->last_seen));
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000934 return true;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000935 }
Simon Wunderlich7b955a92014-03-26 15:46:23 +0100936 changed_ifinfo = batadv_purge_orig_ifinfo(bat_priv, orig_node);
937 changed_neigh = batadv_purge_orig_neighbors(bat_priv, orig_node);
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100938
Simon Wunderlich7b955a92014-03-26 15:46:23 +0100939 if (!changed_ifinfo && !changed_neigh)
Simon Wunderlich89652332013-11-13 19:14:46 +0100940 return false;
941
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100942 /* first for NULL ... */
Simon Wunderlich89652332013-11-13 19:14:46 +0100943 best_neigh_node = batadv_find_best_neighbor(bat_priv, orig_node,
944 BATADV_IF_DEFAULT);
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100945 batadv_update_route(bat_priv, orig_node, BATADV_IF_DEFAULT,
946 best_neigh_node);
Simon Wunderlich89652332013-11-13 19:14:46 +0100947 if (best_neigh_node)
948 batadv_neigh_node_free_ref(best_neigh_node);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000949
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100950 /* ... then for all other interfaces. */
951 rcu_read_lock();
952 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
953 if (hard_iface->if_status != BATADV_IF_ACTIVE)
954 continue;
955
956 if (hard_iface->soft_iface != bat_priv->soft_iface)
957 continue;
958
959 best_neigh_node = batadv_find_best_neighbor(bat_priv,
960 orig_node,
961 hard_iface);
962 batadv_update_route(bat_priv, orig_node, hard_iface,
963 best_neigh_node);
964 if (best_neigh_node)
965 batadv_neigh_node_free_ref(best_neigh_node);
966 }
967 rcu_read_unlock();
968
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000969 return false;
970}
971
Sven Eckelmann56303d32012-06-05 22:31:31 +0200972static void _batadv_purge_orig(struct batadv_priv *bat_priv)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000973{
Sven Eckelmann5bf74e92012-06-05 22:31:28 +0200974 struct batadv_hashtable *hash = bat_priv->orig_hash;
Sasha Levinb67bfe02013-02-27 17:06:00 -0800975 struct hlist_node *node_tmp;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000976 struct hlist_head *head;
Marek Lindnerfb778ea2011-01-19 20:01:40 +0000977 spinlock_t *list_lock; /* spinlock to protect write access */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200978 struct batadv_orig_node *orig_node;
Antonio Quartullic90681b2011-10-05 17:05:25 +0200979 uint32_t i;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000980
981 if (!hash)
982 return;
983
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000984 /* for all origins... */
985 for (i = 0; i < hash->size; i++) {
986 head = &hash->table[i];
Marek Lindnerfb778ea2011-01-19 20:01:40 +0000987 list_lock = &hash->list_locks[i];
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000988
Marek Lindnerfb778ea2011-01-19 20:01:40 +0000989 spin_lock_bh(list_lock);
Sasha Levinb67bfe02013-02-27 17:06:00 -0800990 hlist_for_each_entry_safe(orig_node, node_tmp,
Marek Lindner7aadf882011-02-18 12:28:09 +0000991 head, hash_entry) {
Sven Eckelmann03fc7f82012-05-12 18:34:00 +0200992 if (batadv_purge_orig_node(bat_priv, orig_node)) {
Marek Lindner414254e2013-04-23 21:39:58 +0800993 batadv_gw_node_delete(bat_priv, orig_node);
Sasha Levinb67bfe02013-02-27 17:06:00 -0800994 hlist_del_rcu(&orig_node->hash_entry);
Linus Lüssing9d31b3c2014-12-13 23:32:15 +0100995 batadv_tt_global_del_orig(orig_node->bat_priv,
996 orig_node, -1,
997 "originator timed out");
Sven Eckelmann7d211ef2012-05-12 02:09:34 +0200998 batadv_orig_node_free_ref(orig_node);
Marek Lindnerfb778ea2011-01-19 20:01:40 +0000999 continue;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001000 }
Martin Hundebøll610bfc6bc2013-05-23 16:53:02 +02001001
1002 batadv_frag_purge_orig(orig_node,
1003 batadv_frag_check_entry);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001004 }
Marek Lindnerfb778ea2011-01-19 20:01:40 +00001005 spin_unlock_bh(list_lock);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001006 }
1007
Sven Eckelmann7cf06bc2012-05-12 02:09:29 +02001008 batadv_gw_node_purge(bat_priv);
1009 batadv_gw_election(bat_priv);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001010}
1011
Sven Eckelmann03fc7f82012-05-12 18:34:00 +02001012static void batadv_purge_orig(struct work_struct *work)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001013{
Sven Eckelmann56303d32012-06-05 22:31:31 +02001014 struct delayed_work *delayed_work;
1015 struct batadv_priv *bat_priv;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001016
Sven Eckelmann56303d32012-06-05 22:31:31 +02001017 delayed_work = container_of(work, struct delayed_work, work);
1018 bat_priv = container_of(delayed_work, struct batadv_priv, orig_work);
Sven Eckelmann03fc7f82012-05-12 18:34:00 +02001019 _batadv_purge_orig(bat_priv);
Antonio Quartulli72414442012-12-25 13:14:37 +01001020 queue_delayed_work(batadv_event_workqueue,
1021 &bat_priv->orig_work,
1022 msecs_to_jiffies(BATADV_ORIG_WORK_PERIOD));
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001023}
1024
Sven Eckelmann56303d32012-06-05 22:31:31 +02001025void batadv_purge_orig_ref(struct batadv_priv *bat_priv)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001026{
Sven Eckelmann03fc7f82012-05-12 18:34:00 +02001027 _batadv_purge_orig(bat_priv);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001028}
1029
Sven Eckelmann7d211ef2012-05-12 02:09:34 +02001030int batadv_orig_seq_print_text(struct seq_file *seq, void *offset)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001031{
1032 struct net_device *net_dev = (struct net_device *)seq->private;
Sven Eckelmann56303d32012-06-05 22:31:31 +02001033 struct batadv_priv *bat_priv = netdev_priv(net_dev);
Sven Eckelmann56303d32012-06-05 22:31:31 +02001034 struct batadv_hard_iface *primary_if;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001035
Marek Lindner30da63a2012-08-03 17:15:46 +02001036 primary_if = batadv_seq_print_text_primary_if_get(seq);
1037 if (!primary_if)
Antonio Quartulli737a2a222013-09-02 12:15:03 +02001038 return 0;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001039
Antonio Quartulli737a2a222013-09-02 12:15:03 +02001040 seq_printf(seq, "[B.A.T.M.A.N. adv %s, MainIF/MAC: %s/%pM (%s %s)]\n",
Sven Eckelmann42d0b042012-06-03 22:19:17 +02001041 BATADV_SOURCE_VERSION, primary_if->net_dev->name,
Antonio Quartulli737a2a222013-09-02 12:15:03 +02001042 primary_if->net_dev->dev_addr, net_dev->name,
1043 bat_priv->bat_algo_ops->name);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001044
Antonio Quartulli737a2a222013-09-02 12:15:03 +02001045 batadv_hardif_free_ref(primary_if);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001046
Antonio Quartulli737a2a222013-09-02 12:15:03 +02001047 if (!bat_priv->bat_algo_ops->bat_orig_print) {
1048 seq_puts(seq,
1049 "No printing function for this routing protocol\n");
1050 return 0;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001051 }
1052
Simon Wunderlichcb1c92e2013-11-21 11:52:16 +01001053 bat_priv->bat_algo_ops->bat_orig_print(bat_priv, seq,
1054 BATADV_IF_DEFAULT);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001055
Marek Lindner30da63a2012-08-03 17:15:46 +02001056 return 0;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001057}
1058
Simon Wunderlichcb1c92e2013-11-21 11:52:16 +01001059/**
1060 * batadv_orig_hardif_seq_print_text - writes originator infos for a specific
1061 * outgoing interface
1062 * @seq: debugfs table seq_file struct
1063 * @offset: not used
1064 *
1065 * Returns 0
1066 */
1067int batadv_orig_hardif_seq_print_text(struct seq_file *seq, void *offset)
1068{
1069 struct net_device *net_dev = (struct net_device *)seq->private;
1070 struct batadv_hard_iface *hard_iface;
1071 struct batadv_priv *bat_priv;
1072
1073 hard_iface = batadv_hardif_get_by_netdev(net_dev);
1074
1075 if (!hard_iface || !hard_iface->soft_iface) {
1076 seq_puts(seq, "Interface not known to B.A.T.M.A.N.\n");
1077 goto out;
1078 }
1079
1080 bat_priv = netdev_priv(hard_iface->soft_iface);
1081 if (!bat_priv->bat_algo_ops->bat_orig_print) {
1082 seq_puts(seq,
1083 "No printing function for this routing protocol\n");
1084 goto out;
1085 }
1086
1087 if (hard_iface->if_status != BATADV_IF_ACTIVE) {
1088 seq_puts(seq, "Interface not active\n");
1089 goto out;
1090 }
1091
1092 seq_printf(seq, "[B.A.T.M.A.N. adv %s, IF/MAC: %s/%pM (%s %s)]\n",
1093 BATADV_SOURCE_VERSION, hard_iface->net_dev->name,
1094 hard_iface->net_dev->dev_addr,
1095 hard_iface->soft_iface->name, bat_priv->bat_algo_ops->name);
1096
1097 bat_priv->bat_algo_ops->bat_orig_print(bat_priv, seq, hard_iface);
1098
1099out:
Marek Lindner16a41422014-04-24 03:44:25 +08001100 if (hard_iface)
1101 batadv_hardif_free_ref(hard_iface);
Simon Wunderlichcb1c92e2013-11-21 11:52:16 +01001102 return 0;
1103}
1104
Sven Eckelmann56303d32012-06-05 22:31:31 +02001105int batadv_orig_hash_add_if(struct batadv_hard_iface *hard_iface,
1106 int max_if_num)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001107{
Sven Eckelmann56303d32012-06-05 22:31:31 +02001108 struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
Antonio Quartullid0015fd2013-09-03 11:10:23 +02001109 struct batadv_algo_ops *bao = bat_priv->bat_algo_ops;
Sven Eckelmann5bf74e92012-06-05 22:31:28 +02001110 struct batadv_hashtable *hash = bat_priv->orig_hash;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001111 struct hlist_head *head;
Sven Eckelmann56303d32012-06-05 22:31:31 +02001112 struct batadv_orig_node *orig_node;
Antonio Quartullic90681b2011-10-05 17:05:25 +02001113 uint32_t i;
1114 int ret;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001115
1116 /* resize all orig nodes because orig_node->bcast_own(_sum) depend on
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +02001117 * if_num
1118 */
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001119 for (i = 0; i < hash->size; i++) {
1120 head = &hash->table[i];
1121
Marek Lindnerfb778ea2011-01-19 20:01:40 +00001122 rcu_read_lock();
Sasha Levinb67bfe02013-02-27 17:06:00 -08001123 hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
Antonio Quartullid0015fd2013-09-03 11:10:23 +02001124 ret = 0;
1125 if (bao->bat_orig_add_if)
1126 ret = bao->bat_orig_add_if(orig_node,
1127 max_if_num);
Sven Eckelmann5346c352012-05-05 13:27:28 +02001128 if (ret == -ENOMEM)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001129 goto err;
1130 }
Marek Lindnerfb778ea2011-01-19 20:01:40 +00001131 rcu_read_unlock();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001132 }
1133
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001134 return 0;
1135
1136err:
Marek Lindnerfb778ea2011-01-19 20:01:40 +00001137 rcu_read_unlock();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001138 return -ENOMEM;
1139}
1140
Sven Eckelmann56303d32012-06-05 22:31:31 +02001141int batadv_orig_hash_del_if(struct batadv_hard_iface *hard_iface,
1142 int max_if_num)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001143{
Sven Eckelmann56303d32012-06-05 22:31:31 +02001144 struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
Sven Eckelmann5bf74e92012-06-05 22:31:28 +02001145 struct batadv_hashtable *hash = bat_priv->orig_hash;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001146 struct hlist_head *head;
Sven Eckelmann56303d32012-06-05 22:31:31 +02001147 struct batadv_hard_iface *hard_iface_tmp;
1148 struct batadv_orig_node *orig_node;
Antonio Quartullid0015fd2013-09-03 11:10:23 +02001149 struct batadv_algo_ops *bao = bat_priv->bat_algo_ops;
Antonio Quartullic90681b2011-10-05 17:05:25 +02001150 uint32_t i;
1151 int ret;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001152
1153 /* resize all orig nodes because orig_node->bcast_own(_sum) depend on
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +02001154 * if_num
1155 */
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001156 for (i = 0; i < hash->size; i++) {
1157 head = &hash->table[i];
1158
Marek Lindnerfb778ea2011-01-19 20:01:40 +00001159 rcu_read_lock();
Sasha Levinb67bfe02013-02-27 17:06:00 -08001160 hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
Antonio Quartullid0015fd2013-09-03 11:10:23 +02001161 ret = 0;
1162 if (bao->bat_orig_del_if)
1163 ret = bao->bat_orig_del_if(orig_node,
1164 max_if_num,
1165 hard_iface->if_num);
Sven Eckelmann5346c352012-05-05 13:27:28 +02001166 if (ret == -ENOMEM)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001167 goto err;
1168 }
Marek Lindnerfb778ea2011-01-19 20:01:40 +00001169 rcu_read_unlock();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001170 }
1171
1172 /* renumber remaining batman interfaces _inside_ of orig_hash_lock */
1173 rcu_read_lock();
Sven Eckelmann3193e8f2012-05-12 02:09:42 +02001174 list_for_each_entry_rcu(hard_iface_tmp, &batadv_hardif_list, list) {
Sven Eckelmanne9a4f292012-06-03 22:19:19 +02001175 if (hard_iface_tmp->if_status == BATADV_IF_NOT_IN_USE)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001176 continue;
1177
Marek Lindnere6c10f42011-02-18 12:33:20 +00001178 if (hard_iface == hard_iface_tmp)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001179 continue;
1180
Marek Lindnere6c10f42011-02-18 12:33:20 +00001181 if (hard_iface->soft_iface != hard_iface_tmp->soft_iface)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001182 continue;
1183
Marek Lindnere6c10f42011-02-18 12:33:20 +00001184 if (hard_iface_tmp->if_num > hard_iface->if_num)
1185 hard_iface_tmp->if_num--;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001186 }
1187 rcu_read_unlock();
1188
Marek Lindnere6c10f42011-02-18 12:33:20 +00001189 hard_iface->if_num = -1;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001190 return 0;
1191
1192err:
Marek Lindnerfb778ea2011-01-19 20:01:40 +00001193 rcu_read_unlock();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001194 return -ENOMEM;
1195}