blob: 5f3bfc41aeb1ca5e505a232a480ad5671d85265a [file] [log] [blame]
Sven Eckelmann0046b042016-01-01 00:01:03 +01001/* Copyright (C) 2009-2016 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
Sven Eckelmann7c124392016-01-16 10:29:56 +010021#include <linux/atomic.h>
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020022#include <linux/errno.h>
23#include <linux/etherdevice.h>
24#include <linux/fs.h>
25#include <linux/jiffies.h>
26#include <linux/kernel.h>
Sven Eckelmann90f564d2016-01-16 10:29:40 +010027#include <linux/kref.h>
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020028#include <linux/list.h>
29#include <linux/lockdep.h>
30#include <linux/netdevice.h>
Matthias Schiffer85cf8c82016-07-03 13:31:39 +020031#include <linux/netlink.h>
Marek Lindnerd0fa4f32015-06-22 00:30:22 +080032#include <linux/rculist.h>
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020033#include <linux/seq_file.h>
Matthias Schiffer85cf8c82016-07-03 13:31:39 +020034#include <linux/skbuff.h>
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020035#include <linux/slab.h>
36#include <linux/spinlock.h>
37#include <linux/workqueue.h>
Matthias Schiffer85cf8c82016-07-03 13:31:39 +020038#include <net/sock.h>
39#include <uapi/linux/batman_adv.h>
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020040
Sven Eckelmann01d350d2016-05-15 11:07:44 +020041#include "bat_algo.h"
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020042#include "distributed-arp-table.h"
43#include "fragmentation.h"
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000044#include "gateway_client.h"
45#include "hard-interface.h"
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020046#include "hash.h"
Sven Eckelmannba412082016-05-15 23:48:31 +020047#include "log.h"
Linus Lüssing60432d72014-02-15 17:47:51 +010048#include "multicast.h"
Matthias Schiffer85cf8c82016-07-03 13:31:39 +020049#include "netlink.h"
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020050#include "network-coding.h"
51#include "routing.h"
Matthias Schiffer85cf8c82016-07-03 13:31:39 +020052#include "soft-interface.h"
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020053#include "translation-table.h"
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000054
Antonio Quartullidec05072012-11-10 11:00:32 +010055/* hash class keys */
56static struct lock_class_key batadv_orig_hash_lock_class_key;
57
Sven Eckelmann03fc7f82012-05-12 18:34:00 +020058static void batadv_purge_orig(struct work_struct *work);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000059
Sven Eckelmann62fe7102015-09-15 19:00:48 +020060/**
Sven Eckelmann7afcbbe2015-10-31 12:29:29 +010061 * 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
Sven Eckelmann62fe7102015-09-15 19:00:48 +020064 *
Sven Eckelmann4b426b12016-02-22 21:02:39 +010065 * Return: true if they are the same originator
Sven Eckelmann62fe7102015-09-15 19:00:48 +020066 */
Sven Eckelmann4b426b12016-02-22 21:02:39 +010067bool batadv_compare_orig(const struct hlist_node *node, const void *data2)
Sven Eckelmannb8e2dd12011-06-15 15:08:59 +020068{
Sven Eckelmann56303d32012-06-05 22:31:31 +020069 const void *data1 = container_of(node, struct batadv_orig_node,
70 hash_entry);
Sven Eckelmannb8e2dd12011-06-15 15:08:59 +020071
dingtianhong323813e2013-12-26 19:40:39 +080072 return batadv_compare_eth(data1, data2);
Sven Eckelmannb8e2dd12011-06-15 15:08:59 +020073}
74
Antonio Quartulli7ea7b4a2013-07-30 22:16:25 +020075/**
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 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +020080 * Return: the vlan object identified by vid and belonging to orig_node or NULL
Antonio Quartulli7ea7b4a2013-07-30 22:16:25 +020081 * if it does not exist.
82 */
83struct batadv_orig_node_vlan *
84batadv_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();
Marek Lindnerd0fa4f32015-06-22 00:30:22 +080090 hlist_for_each_entry_rcu(tmp, &orig_node->vlan_list, list) {
Antonio Quartulli7ea7b4a2013-07-30 22:16:25 +020091 if (tmp->vid != vid)
92 continue;
93
Sven Eckelmann161a3be2016-01-16 10:29:55 +010094 if (!kref_get_unless_zero(&tmp->refcount))
Antonio Quartulli7ea7b4a2013-07-30 22:16:25 +020095 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 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200112 * Return: NULL in case of failure or the vlan object identified by vid and
Antonio Quartulli7ea7b4a2013-07-30 22:16:25 +0200113 * 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 */
118struct batadv_orig_node_vlan *
119batadv_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
Sven Eckelmann161a3be2016-01-16 10:29:55 +0100135 kref_init(&vlan->refcount);
Antonio Quartulli7ea7b4a2013-07-30 22:16:25 +0200136 vlan->vid = vid;
137
Sven Eckelmann09537d12016-07-15 17:39:16 +0200138 kref_get(&vlan->refcount);
Marek Lindnerd0fa4f32015-06-22 00:30:22 +0800139 hlist_add_head_rcu(&vlan->list, &orig_node->vlan_list);
Antonio Quartulli7ea7b4a2013-07-30 22:16:25 +0200140
141out:
142 spin_unlock_bh(&orig_node->vlan_list_lock);
143
144 return vlan;
145}
146
147/**
Sven Eckelmann161a3be2016-01-16 10:29:55 +0100148 * 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 */
152static 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/**
Sven Eckelmann21754e22016-01-17 11:01:24 +0100162 * batadv_orig_node_vlan_put - decrement the refcounter and possibly release
163 * the originator-vlan object
Antonio Quartulli7ea7b4a2013-07-30 22:16:25 +0200164 * @orig_vlan: the originator-vlan object to release
165 */
Sven Eckelmann21754e22016-01-17 11:01:24 +0100166void batadv_orig_node_vlan_put(struct batadv_orig_node_vlan *orig_vlan)
Antonio Quartulli7ea7b4a2013-07-30 22:16:25 +0200167{
Sven Eckelmann161a3be2016-01-16 10:29:55 +0100168 kref_put(&orig_vlan->refcount, batadv_orig_node_vlan_release);
Antonio Quartulli7ea7b4a2013-07-30 22:16:25 +0200169}
170
Sven Eckelmann56303d32012-06-05 22:31:31 +0200171int batadv_originator_init(struct batadv_priv *bat_priv)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000172{
173 if (bat_priv->orig_hash)
Sven Eckelmann5346c352012-05-05 13:27:28 +0200174 return 0;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000175
Sven Eckelmann1a8eaf02012-05-12 02:09:32 +0200176 bat_priv->orig_hash = batadv_hash_new(1024);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000177
178 if (!bat_priv->orig_hash)
179 goto err;
180
Antonio Quartullidec05072012-11-10 11:00:32 +0100181 batadv_hash_set_lock_class(bat_priv->orig_hash,
182 &batadv_orig_hash_lock_class_key);
183
Antonio Quartulli72414442012-12-25 13:14:37 +0100184 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
Sven Eckelmann5346c352012-05-05 13:27:28 +0200189 return 0;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000190
191err:
Sven Eckelmann5346c352012-05-05 13:27:28 +0200192 return -ENOMEM;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000193}
194
Simon Wunderlich89652332013-11-13 19:14:46 +0100195/**
Sven Eckelmannae3e1e32016-01-05 12:06:24 +0100196 * batadv_neigh_ifinfo_release - release neigh_ifinfo from lists and queue for
197 * free after rcu grace period
Sven Eckelmann962c6832016-01-16 10:29:51 +0100198 * @ref: kref pointer of the neigh_ifinfo
Simon Wunderlich89652332013-11-13 19:14:46 +0100199 */
Sven Eckelmann962c6832016-01-16 10:29:51 +0100200static void batadv_neigh_ifinfo_release(struct kref *ref)
Simon Wunderlich89652332013-11-13 19:14:46 +0100201{
Sven Eckelmann962c6832016-01-16 10:29:51 +0100202 struct batadv_neigh_ifinfo *neigh_ifinfo;
203
204 neigh_ifinfo = container_of(ref, struct batadv_neigh_ifinfo, refcount);
205
Sven Eckelmannae3e1e32016-01-05 12:06:24 +0100206 if (neigh_ifinfo->if_outgoing != BATADV_IF_DEFAULT)
Sven Eckelmann82047ad2016-01-17 11:01:10 +0100207 batadv_hardif_put(neigh_ifinfo->if_outgoing);
Sven Eckelmannae3e1e32016-01-05 12:06:24 +0100208
209 kfree_rcu(neigh_ifinfo, rcu);
Simon Wunderlich89652332013-11-13 19:14:46 +0100210}
211
212/**
Sven Eckelmann044fa3a2016-01-17 11:01:12 +0100213 * batadv_neigh_ifinfo_put - decrement the refcounter and possibly release
Simon Wunderlich89652332013-11-13 19:14:46 +0100214 * the neigh_ifinfo
215 * @neigh_ifinfo: the neigh_ifinfo object to release
216 */
Sven Eckelmann044fa3a2016-01-17 11:01:12 +0100217void batadv_neigh_ifinfo_put(struct batadv_neigh_ifinfo *neigh_ifinfo)
Simon Wunderlich89652332013-11-13 19:14:46 +0100218{
Sven Eckelmann962c6832016-01-16 10:29:51 +0100219 kref_put(&neigh_ifinfo->refcount, batadv_neigh_ifinfo_release);
Simon Wunderlich89652332013-11-13 19:14:46 +0100220}
221
222/**
Sven Eckelmannf6389692016-01-05 12:06:23 +0100223 * batadv_hardif_neigh_release - release hardif neigh node from lists and
224 * queue for free after rcu grace period
Sven Eckelmann90f564d2016-01-16 10:29:40 +0100225 * @ref: kref pointer of the neigh_node
Marek Lindnercef63412015-08-04 21:09:55 +0800226 */
Sven Eckelmann90f564d2016-01-16 10:29:40 +0100227static void batadv_hardif_neigh_release(struct kref *ref)
Marek Lindnercef63412015-08-04 21:09:55 +0800228{
Sven Eckelmann90f564d2016-01-16 10:29:40 +0100229 struct batadv_hardif_neigh_node *hardif_neigh;
230
231 hardif_neigh = container_of(ref, struct batadv_hardif_neigh_node,
232 refcount);
233
Sven Eckelmannf6389692016-01-05 12:06:23 +0100234 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);
Sven Eckelmannbab7c6c2016-01-05 12:06:17 +0100237
Sven Eckelmann82047ad2016-01-17 11:01:10 +0100238 batadv_hardif_put(hardif_neigh->if_incoming);
Sven Eckelmannf6389692016-01-05 12:06:23 +0100239 kfree_rcu(hardif_neigh, rcu);
Marek Lindnercef63412015-08-04 21:09:55 +0800240}
241
242/**
Sven Eckelmannaccadc32016-01-17 11:01:14 +0100243 * batadv_hardif_neigh_put - decrement the hardif neighbors refcounter
Sven Eckelmannf6389692016-01-05 12:06:23 +0100244 * and possibly release it
Marek Lindnercef63412015-08-04 21:09:55 +0800245 * @hardif_neigh: hardif neigh neighbor to free
246 */
Sven Eckelmannaccadc32016-01-17 11:01:14 +0100247void batadv_hardif_neigh_put(struct batadv_hardif_neigh_node *hardif_neigh)
Marek Lindnercef63412015-08-04 21:09:55 +0800248{
Sven Eckelmann90f564d2016-01-16 10:29:40 +0100249 kref_put(&hardif_neigh->refcount, batadv_hardif_neigh_release);
Marek Lindnercef63412015-08-04 21:09:55 +0800250}
251
252/**
Sven Eckelmannb4d922c2016-01-05 12:06:25 +0100253 * batadv_neigh_node_release - release neigh_node from lists and queue for
254 * free after rcu grace period
Sven Eckelmann77ae32e2016-01-16 10:29:53 +0100255 * @ref: kref pointer of the neigh_node
Simon Wunderlich89652332013-11-13 19:14:46 +0100256 */
Sven Eckelmann77ae32e2016-01-16 10:29:53 +0100257static void batadv_neigh_node_release(struct kref *ref)
Simon Wunderlich89652332013-11-13 19:14:46 +0100258{
259 struct hlist_node *node_tmp;
Sven Eckelmann77ae32e2016-01-16 10:29:53 +0100260 struct batadv_neigh_node *neigh_node;
Simon Wunderlich89652332013-11-13 19:14:46 +0100261 struct batadv_neigh_ifinfo *neigh_ifinfo;
262
Sven Eckelmann77ae32e2016-01-16 10:29:53 +0100263 neigh_node = container_of(ref, struct batadv_neigh_node, refcount);
Simon Wunderlich89652332013-11-13 19:14:46 +0100264
265 hlist_for_each_entry_safe(neigh_ifinfo, node_tmp,
266 &neigh_node->ifinfo_list, list) {
Sven Eckelmann044fa3a2016-01-17 11:01:12 +0100267 batadv_neigh_ifinfo_put(neigh_ifinfo);
Simon Wunderlich89652332013-11-13 19:14:46 +0100268 }
Antonio Quartullibcef1f32015-03-01 00:50:17 +0800269
Sven Eckelmannabe59c62016-03-11 16:44:06 +0100270 batadv_hardif_neigh_put(neigh_node->hardif_neigh);
Marek Lindnercef63412015-08-04 21:09:55 +0800271
Sven Eckelmann82047ad2016-01-17 11:01:10 +0100272 batadv_hardif_put(neigh_node->if_incoming);
Simon Wunderlich89652332013-11-13 19:14:46 +0100273
Sven Eckelmannb4d922c2016-01-05 12:06:25 +0100274 kfree_rcu(neigh_node, rcu);
Simon Wunderlich89652332013-11-13 19:14:46 +0100275}
276
277/**
Sven Eckelmann25bb2502016-01-17 11:01:11 +0100278 * batadv_neigh_node_put - decrement the neighbors refcounter and possibly
Sven Eckelmann77ae32e2016-01-16 10:29:53 +0100279 * release it
Simon Wunderlich89652332013-11-13 19:14:46 +0100280 * @neigh_node: neigh neighbor to free
281 */
Sven Eckelmann25bb2502016-01-17 11:01:11 +0100282void batadv_neigh_node_put(struct batadv_neigh_node *neigh_node)
Simon Wunderlicha4c135c2011-01-19 20:01:43 +0000283{
Sven Eckelmann77ae32e2016-01-16 10:29:53 +0100284 kref_put(&neigh_node->refcount, batadv_neigh_node_release);
Simon Wunderlicha4c135c2011-01-19 20:01:43 +0000285}
286
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100287/**
Antonio Quartulli6d030de2016-03-11 16:36:19 +0100288 * batadv_orig_router_get - router to the originator depending on iface
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100289 * @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 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200293 * Return: the neighbor which should be router for this orig_node/iface.
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100294 *
295 * The object is returned with refcounter increased by 1.
296 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200297struct batadv_neigh_node *
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100298batadv_orig_router_get(struct batadv_orig_node *orig_node,
299 const struct batadv_hard_iface *if_outgoing)
Linus Lüssinge1a5382f2011-03-14 22:43:37 +0000300{
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100301 struct batadv_orig_ifinfo *orig_ifinfo;
302 struct batadv_neigh_node *router = NULL;
Linus Lüssinge1a5382f2011-03-14 22:43:37 +0000303
304 rcu_read_lock();
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100305 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 }
Linus Lüssinge1a5382f2011-03-14 22:43:37 +0000312
Sven Eckelmann77ae32e2016-01-16 10:29:53 +0100313 if (router && !kref_get_unless_zero(&router->refcount))
Linus Lüssinge1a5382f2011-03-14 22:43:37 +0000314 router = NULL;
315
316 rcu_read_unlock();
317 return router;
318}
319
Antonio Quartulli0538f752013-09-02 12:15:01 +0200320/**
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100321 * 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 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200325 * Return: the requested orig_ifinfo or NULL if not found.
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100326 *
327 * The object is returned with refcounter increased by 1.
328 */
329struct batadv_orig_ifinfo *
330batadv_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
Sven Eckelmanna6ba0d32016-01-16 10:29:52 +0100341 if (!kref_get_unless_zero(&tmp->refcount))
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100342 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 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200357 * Return: NULL in case of failure or the orig_ifinfo object for the if_outgoing
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100358 * 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 */
363struct batadv_orig_ifinfo *
364batadv_orig_ifinfo_new(struct batadv_orig_node *orig_node,
365 struct batadv_hard_iface *if_outgoing)
366{
367 struct batadv_orig_ifinfo *orig_ifinfo = NULL;
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
Sven Eckelmann17a86912016-04-11 13:06:40 +0200380 if (if_outgoing != BATADV_IF_DEFAULT)
381 kref_get(&if_outgoing->refcount);
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100382
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);
Sven Eckelmanna6ba0d32016-01-16 10:29:52 +0100388 kref_init(&orig_ifinfo->refcount);
Sven Eckelmannf257b992016-07-15 17:39:17 +0200389
Sven Eckelmanna6ba0d32016-01-16 10:29:52 +0100390 kref_get(&orig_ifinfo->refcount);
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100391 hlist_add_head_rcu(&orig_ifinfo->list,
392 &orig_node->ifinfo_list);
393out:
394 spin_unlock_bh(&orig_node->neigh_list_lock);
395 return orig_ifinfo;
396}
397
398/**
Simon Wunderlich89652332013-11-13 19:14:46 +0100399 * batadv_neigh_ifinfo_get - find the ifinfo from an neigh_node
Sven Eckelmanne51f0392015-09-06 21:38:51 +0200400 * @neigh: the neigh node to be queried
Simon Wunderlich89652332013-11-13 19:14:46 +0100401 * @if_outgoing: the interface for which the ifinfo should be acquired
402 *
403 * The object is returned with refcounter increased by 1.
404 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200405 * Return: the requested neigh_ifinfo or NULL if not found
Simon Wunderlich89652332013-11-13 19:14:46 +0100406 */
407struct batadv_neigh_ifinfo *
408batadv_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
Sven Eckelmann962c6832016-01-16 10:29:51 +0100420 if (!kref_get_unless_zero(&tmp_neigh_ifinfo->refcount))
Simon Wunderlich89652332013-11-13 19:14:46 +0100421 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
Sven Eckelmanne51f0392015-09-06 21:38:51 +0200433 * @neigh: the neigh node to be queried
Simon Wunderlich89652332013-11-13 19:14:46 +0100434 * @if_outgoing: the interface for which the ifinfo should be acquired
435 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200436 * Return: NULL in case of failure or the neigh_ifinfo object for the
Simon Wunderlich89652332013-11-13 19:14:46 +0100437 * 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 */
442struct batadv_neigh_ifinfo *
443batadv_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
Sven Eckelmann17a86912016-04-11 13:06:40 +0200458 if (if_outgoing)
459 kref_get(&if_outgoing->refcount);
Simon Wunderlich89652332013-11-13 19:14:46 +0100460
461 INIT_HLIST_NODE(&neigh_ifinfo->list);
Sven Eckelmann962c6832016-01-16 10:29:51 +0100462 kref_init(&neigh_ifinfo->refcount);
Simon Wunderlich89652332013-11-13 19:14:46 +0100463 neigh_ifinfo->if_outgoing = if_outgoing;
464
Sven Eckelmann2e774ac2016-07-15 17:39:19 +0200465 kref_get(&neigh_ifinfo->refcount);
Simon Wunderlich89652332013-11-13 19:14:46 +0100466 hlist_add_head_rcu(&neigh_ifinfo->list, &neigh->ifinfo_list);
467
468out:
469 spin_unlock_bh(&neigh->ifinfo_lock);
470
471 return neigh_ifinfo;
472}
473
474/**
Marek Lindnered292662015-08-04 23:31:44 +0800475 * 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.
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200482 *
483 * Return: neighbor when found. Othwerwise NULL
Marek Lindnered292662015-08-04 23:31:44 +0800484 */
485static struct batadv_neigh_node *
486batadv_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
Sven Eckelmann77ae32e2016-01-16 10:29:53 +0100500 if (!kref_get_unless_zero(&tmp_neigh_node->refcount))
Marek Lindnered292662015-08-04 23:31:44 +0800501 continue;
502
503 res = tmp_neigh_node;
504 break;
505 }
506 rcu_read_unlock();
507
508 return res;
509}
510
511/**
Marek Lindnercef63412015-08-04 21:09:55 +0800512 * 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 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200516 * Return: the hardif neighbour node if found or created or NULL otherwise.
Marek Lindnercef63412015-08-04 21:09:55 +0800517 */
518static struct batadv_hardif_neigh_node *
519batadv_hardif_neigh_create(struct batadv_hard_iface *hard_iface,
520 const u8 *neigh_addr)
521{
Marek Lindner8248a4c2015-08-04 21:09:56 +0800522 struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
Marek Lindnercef63412015-08-04 21:09:55 +0800523 struct batadv_hardif_neigh_node *hardif_neigh = NULL;
524
525 spin_lock_bh(&hard_iface->neigh_list_lock);
526
527 /* check if neighbor hasn't been added in the meantime */
528 hardif_neigh = batadv_hardif_neigh_get(hard_iface, neigh_addr);
529 if (hardif_neigh)
530 goto out;
531
Marek Lindnercef63412015-08-04 21:09:55 +0800532 hardif_neigh = kzalloc(sizeof(*hardif_neigh), GFP_ATOMIC);
Sven Eckelmann17a86912016-04-11 13:06:40 +0200533 if (!hardif_neigh)
Marek Lindnercef63412015-08-04 21:09:55 +0800534 goto out;
Marek Lindnercef63412015-08-04 21:09:55 +0800535
Sven Eckelmann17a86912016-04-11 13:06:40 +0200536 kref_get(&hard_iface->refcount);
Marek Lindnercef63412015-08-04 21:09:55 +0800537 INIT_HLIST_NODE(&hardif_neigh->list);
538 ether_addr_copy(hardif_neigh->addr, neigh_addr);
539 hardif_neigh->if_incoming = hard_iface;
540 hardif_neigh->last_seen = jiffies;
541
Sven Eckelmann90f564d2016-01-16 10:29:40 +0100542 kref_init(&hardif_neigh->refcount);
Marek Lindnercef63412015-08-04 21:09:55 +0800543
Antonio Quartulli29824a52016-05-25 23:27:31 +0800544 if (bat_priv->algo_ops->neigh.hardif_init)
545 bat_priv->algo_ops->neigh.hardif_init(hardif_neigh);
Marek Lindner8248a4c2015-08-04 21:09:56 +0800546
Marek Lindnercef63412015-08-04 21:09:55 +0800547 hlist_add_head(&hardif_neigh->list, &hard_iface->neigh_list);
548
549out:
550 spin_unlock_bh(&hard_iface->neigh_list_lock);
551 return hardif_neigh;
552}
553
554/**
555 * batadv_hardif_neigh_get_or_create - retrieve or create a hardif neighbour
556 * node
557 * @hard_iface: the interface this neighbour is connected to
558 * @neigh_addr: the interface address of the neighbour to retrieve
559 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200560 * Return: the hardif neighbour node if found or created or NULL otherwise.
Marek Lindnercef63412015-08-04 21:09:55 +0800561 */
562static struct batadv_hardif_neigh_node *
563batadv_hardif_neigh_get_or_create(struct batadv_hard_iface *hard_iface,
564 const u8 *neigh_addr)
565{
566 struct batadv_hardif_neigh_node *hardif_neigh = NULL;
567
568 /* first check without locking to avoid the overhead */
569 hardif_neigh = batadv_hardif_neigh_get(hard_iface, neigh_addr);
570 if (hardif_neigh)
571 return hardif_neigh;
572
573 return batadv_hardif_neigh_create(hard_iface, neigh_addr);
574}
575
576/**
577 * batadv_hardif_neigh_get - retrieve a hardif neighbour from the list
578 * @hard_iface: the interface where this neighbour is connected to
579 * @neigh_addr: the address of the neighbour
580 *
581 * Looks for and possibly returns a neighbour belonging to this hard interface.
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200582 *
583 * Return: neighbor when found. Othwerwise NULL
Marek Lindnercef63412015-08-04 21:09:55 +0800584 */
585struct batadv_hardif_neigh_node *
586batadv_hardif_neigh_get(const struct batadv_hard_iface *hard_iface,
587 const u8 *neigh_addr)
588{
589 struct batadv_hardif_neigh_node *tmp_hardif_neigh, *hardif_neigh = NULL;
590
591 rcu_read_lock();
592 hlist_for_each_entry_rcu(tmp_hardif_neigh,
593 &hard_iface->neigh_list, list) {
594 if (!batadv_compare_eth(tmp_hardif_neigh->addr, neigh_addr))
595 continue;
596
Sven Eckelmann90f564d2016-01-16 10:29:40 +0100597 if (!kref_get_unless_zero(&tmp_hardif_neigh->refcount))
Marek Lindnercef63412015-08-04 21:09:55 +0800598 continue;
599
600 hardif_neigh = tmp_hardif_neigh;
601 break;
602 }
603 rcu_read_unlock();
604
605 return hardif_neigh;
606}
607
608/**
Marek Lindner6f0a6b52016-05-03 01:52:08 +0800609 * batadv_neigh_node_create - create a neigh node object
Marek Lindner3f32f8a2015-07-26 04:59:15 +0800610 * @orig_node: originator object representing the neighbour
Antonio Quartulli0538f752013-09-02 12:15:01 +0200611 * @hard_iface: the interface where the neighbour is connected to
612 * @neigh_addr: the mac address of the neighbour interface
Antonio Quartulli0538f752013-09-02 12:15:01 +0200613 *
614 * Allocates a new neigh_node object and initialises all the generic fields.
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200615 *
Marek Lindner6f0a6b52016-05-03 01:52:08 +0800616 * Return: the neighbour node if found or created or NULL otherwise.
Antonio Quartulli0538f752013-09-02 12:15:01 +0200617 */
Marek Lindner6f0a6b52016-05-03 01:52:08 +0800618static struct batadv_neigh_node *
619batadv_neigh_node_create(struct batadv_orig_node *orig_node,
620 struct batadv_hard_iface *hard_iface,
621 const u8 *neigh_addr)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000622{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200623 struct batadv_neigh_node *neigh_node;
Marek Lindnercef63412015-08-04 21:09:55 +0800624 struct batadv_hardif_neigh_node *hardif_neigh = NULL;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000625
Linus Lüssinge1237052016-01-07 08:11:12 +0100626 spin_lock_bh(&orig_node->neigh_list_lock);
627
Marek Lindner741aa062015-07-26 04:57:43 +0800628 neigh_node = batadv_neigh_node_get(orig_node, hard_iface, neigh_addr);
629 if (neigh_node)
630 goto out;
631
Marek Lindnercef63412015-08-04 21:09:55 +0800632 hardif_neigh = batadv_hardif_neigh_get_or_create(hard_iface,
633 neigh_addr);
634 if (!hardif_neigh)
635 goto out;
636
Sven Eckelmann704509b2011-05-14 23:14:54 +0200637 neigh_node = kzalloc(sizeof(*neigh_node), GFP_ATOMIC);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000638 if (!neigh_node)
Marek Lindner7ae8b282012-03-01 15:35:21 +0800639 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000640
Marek Lindner9591a792010-12-12 21:57:11 +0000641 INIT_HLIST_NODE(&neigh_node->list);
Simon Wunderlich89652332013-11-13 19:14:46 +0100642 INIT_HLIST_HEAD(&neigh_node->ifinfo_list);
643 spin_lock_init(&neigh_node->ifinfo_lock);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000644
Sven Eckelmann17a86912016-04-11 13:06:40 +0200645 kref_get(&hard_iface->refcount);
Antonio Quartulli8fdd0152014-01-22 00:42:11 +0100646 ether_addr_copy(neigh_node->addr, neigh_addr);
Antonio Quartulli0538f752013-09-02 12:15:01 +0200647 neigh_node->if_incoming = hard_iface;
648 neigh_node->orig_node = orig_node;
Marek Lindnere48474e2016-03-11 16:01:09 +0100649 neigh_node->last_seen = jiffies;
Antonio Quartulli0538f752013-09-02 12:15:01 +0200650
Sven Eckelmannabe59c62016-03-11 16:44:06 +0100651 /* increment unique neighbor refcount */
652 kref_get(&hardif_neigh->refcount);
653 neigh_node->hardif_neigh = hardif_neigh;
654
Marek Lindner1605d0d2011-02-18 12:28:11 +0000655 /* extra reference for return */
Sven Eckelmann77ae32e2016-01-16 10:29:53 +0100656 kref_init(&neigh_node->refcount);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000657
Sven Eckelmann84274452016-07-15 17:39:20 +0200658 kref_get(&neigh_node->refcount);
Marek Lindner741aa062015-07-26 04:57:43 +0800659 hlist_add_head_rcu(&neigh_node->list, &orig_node->neigh_list);
Marek Lindner741aa062015-07-26 04:57:43 +0800660
661 batadv_dbg(BATADV_DBG_BATMAN, orig_node->bat_priv,
662 "Creating new neighbor %pM for orig_node %pM on interface %s\n",
663 neigh_addr, orig_node->orig, hard_iface->net_dev->name);
664
Marek Lindner7ae8b282012-03-01 15:35:21 +0800665out:
Linus Lüssinge1237052016-01-07 08:11:12 +0100666 spin_unlock_bh(&orig_node->neigh_list_lock);
667
Marek Lindnercef63412015-08-04 21:09:55 +0800668 if (hardif_neigh)
Sven Eckelmannaccadc32016-01-17 11:01:14 +0100669 batadv_hardif_neigh_put(hardif_neigh);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000670 return neigh_node;
671}
672
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100673/**
Marek Lindner6f0a6b52016-05-03 01:52:08 +0800674 * batadv_neigh_node_get_or_create - retrieve or create a neigh node object
675 * @orig_node: originator object representing the neighbour
676 * @hard_iface: the interface where the neighbour is connected to
677 * @neigh_addr: the mac address of the neighbour interface
678 *
679 * Return: the neighbour node if found or created or NULL otherwise.
680 */
681struct batadv_neigh_node *
682batadv_neigh_node_get_or_create(struct batadv_orig_node *orig_node,
683 struct batadv_hard_iface *hard_iface,
684 const u8 *neigh_addr)
685{
686 struct batadv_neigh_node *neigh_node = NULL;
687
688 /* first check without locking to avoid the overhead */
689 neigh_node = batadv_neigh_node_get(orig_node, hard_iface, neigh_addr);
690 if (neigh_node)
691 return neigh_node;
692
693 return batadv_neigh_node_create(orig_node, hard_iface, neigh_addr);
694}
695
Sven Eckelmanndc1cbd12016-07-16 09:31:20 +0200696#ifdef CONFIG_BATMAN_ADV_DEBUGFS
Marek Lindner6f0a6b52016-05-03 01:52:08 +0800697/**
Marek Lindner75874052015-08-04 21:09:57 +0800698 * batadv_hardif_neigh_seq_print_text - print the single hop neighbour list
699 * @seq: neighbour table seq_file struct
700 * @offset: not used
701 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200702 * Return: always 0
Marek Lindner75874052015-08-04 21:09:57 +0800703 */
704int batadv_hardif_neigh_seq_print_text(struct seq_file *seq, void *offset)
705{
706 struct net_device *net_dev = (struct net_device *)seq->private;
707 struct batadv_priv *bat_priv = netdev_priv(net_dev);
708 struct batadv_hard_iface *primary_if;
709
710 primary_if = batadv_seq_print_text_primary_if_get(seq);
711 if (!primary_if)
712 return 0;
713
714 seq_printf(seq, "[B.A.T.M.A.N. adv %s, MainIF/MAC: %s/%pM (%s %s)]\n",
715 BATADV_SOURCE_VERSION, primary_if->net_dev->name,
716 primary_if->net_dev->dev_addr, net_dev->name,
Antonio Quartulli29824a52016-05-25 23:27:31 +0800717 bat_priv->algo_ops->name);
Marek Lindner75874052015-08-04 21:09:57 +0800718
Sven Eckelmann82047ad2016-01-17 11:01:10 +0100719 batadv_hardif_put(primary_if);
Marek Lindner75874052015-08-04 21:09:57 +0800720
Antonio Quartulli29824a52016-05-25 23:27:31 +0800721 if (!bat_priv->algo_ops->neigh.print) {
Marek Lindner75874052015-08-04 21:09:57 +0800722 seq_puts(seq,
723 "No printing function for this routing protocol\n");
724 return 0;
725 }
726
Antonio Quartulli29824a52016-05-25 23:27:31 +0800727 bat_priv->algo_ops->neigh.print(bat_priv, seq);
Marek Lindner75874052015-08-04 21:09:57 +0800728 return 0;
729}
Sven Eckelmanndc1cbd12016-07-16 09:31:20 +0200730#endif
Marek Lindner75874052015-08-04 21:09:57 +0800731
732/**
Matthias Schiffer85cf8c82016-07-03 13:31:39 +0200733 * batadv_hardif_neigh_dump - Dump to netlink the neighbor infos for a specific
734 * outgoing interface
735 * @msg: message to dump into
736 * @cb: parameters for the dump
737 *
738 * Return: 0 or error value
739 */
740int batadv_hardif_neigh_dump(struct sk_buff *msg, struct netlink_callback *cb)
741{
742 struct net *net = sock_net(cb->skb->sk);
743 struct net_device *soft_iface;
744 struct net_device *hard_iface = NULL;
745 struct batadv_hard_iface *hardif = BATADV_IF_DEFAULT;
746 struct batadv_priv *bat_priv;
747 struct batadv_hard_iface *primary_if = NULL;
748 int ret;
749 int ifindex, hard_ifindex;
750
751 ifindex = batadv_netlink_get_ifindex(cb->nlh, BATADV_ATTR_MESH_IFINDEX);
752 if (!ifindex)
753 return -EINVAL;
754
755 soft_iface = dev_get_by_index(net, ifindex);
756 if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
757 ret = -ENODEV;
758 goto out;
759 }
760
761 bat_priv = netdev_priv(soft_iface);
762
763 primary_if = batadv_primary_if_get_selected(bat_priv);
764 if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
765 ret = -ENOENT;
766 goto out;
767 }
768
769 hard_ifindex = batadv_netlink_get_ifindex(cb->nlh,
770 BATADV_ATTR_HARD_IFINDEX);
771 if (hard_ifindex) {
772 hard_iface = dev_get_by_index(net, hard_ifindex);
773 if (hard_iface)
774 hardif = batadv_hardif_get_by_netdev(hard_iface);
775
776 if (!hardif) {
777 ret = -ENODEV;
778 goto out;
779 }
780
781 if (hardif->soft_iface != soft_iface) {
782 ret = -ENOENT;
783 goto out;
784 }
785 }
786
787 if (!bat_priv->algo_ops->neigh.dump) {
788 ret = -EOPNOTSUPP;
789 goto out;
790 }
791
792 bat_priv->algo_ops->neigh.dump(msg, cb, bat_priv, hardif);
793
794 ret = msg->len;
795
796 out:
797 if (hardif)
798 batadv_hardif_put(hardif);
799 if (hard_iface)
800 dev_put(hard_iface);
801 if (primary_if)
802 batadv_hardif_put(primary_if);
803 if (soft_iface)
804 dev_put(soft_iface);
805
806 return ret;
807}
808
809/**
Sven Eckelmann2baa7532016-01-05 12:06:22 +0100810 * batadv_orig_ifinfo_release - release orig_ifinfo from lists and queue for
811 * free after rcu grace period
Sven Eckelmanna6ba0d32016-01-16 10:29:52 +0100812 * @ref: kref pointer of the orig_ifinfo
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100813 */
Sven Eckelmanna6ba0d32016-01-16 10:29:52 +0100814static void batadv_orig_ifinfo_release(struct kref *ref)
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100815{
Sven Eckelmanna6ba0d32016-01-16 10:29:52 +0100816 struct batadv_orig_ifinfo *orig_ifinfo;
Simon Wunderlich000c8df2014-03-26 15:46:22 +0100817 struct batadv_neigh_node *router;
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100818
Sven Eckelmanna6ba0d32016-01-16 10:29:52 +0100819 orig_ifinfo = container_of(ref, struct batadv_orig_ifinfo, refcount);
820
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100821 if (orig_ifinfo->if_outgoing != BATADV_IF_DEFAULT)
Sven Eckelmann82047ad2016-01-17 11:01:10 +0100822 batadv_hardif_put(orig_ifinfo->if_outgoing);
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100823
Simon Wunderlich000c8df2014-03-26 15:46:22 +0100824 /* this is the last reference to this object */
825 router = rcu_dereference_protected(orig_ifinfo->router, true);
826 if (router)
Sven Eckelmann25bb2502016-01-17 11:01:11 +0100827 batadv_neigh_node_put(router);
Sven Eckelmann2baa7532016-01-05 12:06:22 +0100828
829 kfree_rcu(orig_ifinfo, rcu);
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100830}
831
832/**
Sven Eckelmann35f94772016-01-17 11:01:13 +0100833 * batadv_orig_ifinfo_put - decrement the refcounter and possibly release
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100834 * the orig_ifinfo
835 * @orig_ifinfo: the orig_ifinfo object to release
836 */
Sven Eckelmann35f94772016-01-17 11:01:13 +0100837void batadv_orig_ifinfo_put(struct batadv_orig_ifinfo *orig_ifinfo)
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100838{
Sven Eckelmanna6ba0d32016-01-16 10:29:52 +0100839 kref_put(&orig_ifinfo->refcount, batadv_orig_ifinfo_release);
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100840}
841
Sven Eckelmanndeed9662016-01-05 12:06:21 +0100842/**
843 * batadv_orig_node_free_rcu - free the orig_node
844 * @rcu: rcu pointer of the orig_node
845 */
Sven Eckelmann03fc7f82012-05-12 18:34:00 +0200846static void batadv_orig_node_free_rcu(struct rcu_head *rcu)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000847{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200848 struct batadv_orig_node *orig_node;
Marek Lindner16b1aba2011-01-19 20:01:42 +0000849
Sven Eckelmann56303d32012-06-05 22:31:31 +0200850 orig_node = container_of(rcu, struct batadv_orig_node, rcu);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000851
Linus Lüssing60432d72014-02-15 17:47:51 +0100852 batadv_mcast_purge_orig(orig_node);
853
Martin Hundebøll610bfc6bc2013-05-23 16:53:02 +0200854 batadv_frag_purge_orig(orig_node, NULL);
855
Antonio Quartulli29824a52016-05-25 23:27:31 +0800856 if (orig_node->bat_priv->algo_ops->orig.free)
857 orig_node->bat_priv->algo_ops->orig.free(orig_node);
Antonio Quartullid0015fd2013-09-03 11:10:23 +0200858
Antonio Quartullia73105b2011-04-27 14:27:44 +0200859 kfree(orig_node->tt_buff);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000860 kfree(orig_node);
861}
862
Linus Lüssing72822222013-04-15 21:43:29 +0800863/**
Sven Eckelmanndeed9662016-01-05 12:06:21 +0100864 * batadv_orig_node_release - release orig_node from lists and queue for
865 * free after rcu grace period
Sven Eckelmann7c124392016-01-16 10:29:56 +0100866 * @ref: kref pointer of the orig_node
Sven Eckelmanndeed9662016-01-05 12:06:21 +0100867 */
Sven Eckelmann7c124392016-01-16 10:29:56 +0100868static void batadv_orig_node_release(struct kref *ref)
Sven Eckelmanndeed9662016-01-05 12:06:21 +0100869{
870 struct hlist_node *node_tmp;
871 struct batadv_neigh_node *neigh_node;
Sven Eckelmann7c124392016-01-16 10:29:56 +0100872 struct batadv_orig_node *orig_node;
Sven Eckelmanndeed9662016-01-05 12:06:21 +0100873 struct batadv_orig_ifinfo *orig_ifinfo;
Sven Eckelmann33fbb1f2016-06-30 20:10:46 +0200874 struct batadv_orig_node_vlan *vlan;
Sven Eckelmanncbef1e12016-06-30 21:41:13 +0200875 struct batadv_orig_ifinfo *last_candidate;
Sven Eckelmanndeed9662016-01-05 12:06:21 +0100876
Sven Eckelmann7c124392016-01-16 10:29:56 +0100877 orig_node = container_of(ref, struct batadv_orig_node, refcount);
878
Sven Eckelmanndeed9662016-01-05 12:06:21 +0100879 spin_lock_bh(&orig_node->neigh_list_lock);
880
881 /* for all neighbors towards this originator ... */
882 hlist_for_each_entry_safe(neigh_node, node_tmp,
883 &orig_node->neigh_list, list) {
884 hlist_del_rcu(&neigh_node->list);
Sven Eckelmann25bb2502016-01-17 11:01:11 +0100885 batadv_neigh_node_put(neigh_node);
Sven Eckelmanndeed9662016-01-05 12:06:21 +0100886 }
887
888 hlist_for_each_entry_safe(orig_ifinfo, node_tmp,
889 &orig_node->ifinfo_list, list) {
890 hlist_del_rcu(&orig_ifinfo->list);
Sven Eckelmann35f94772016-01-17 11:01:13 +0100891 batadv_orig_ifinfo_put(orig_ifinfo);
Sven Eckelmanndeed9662016-01-05 12:06:21 +0100892 }
Sven Eckelmanncbef1e12016-06-30 21:41:13 +0200893
894 last_candidate = orig_node->last_bonding_candidate;
895 orig_node->last_bonding_candidate = NULL;
Sven Eckelmanndeed9662016-01-05 12:06:21 +0100896 spin_unlock_bh(&orig_node->neigh_list_lock);
897
Sven Eckelmanncbef1e12016-06-30 21:41:13 +0200898 if (last_candidate)
899 batadv_orig_ifinfo_put(last_candidate);
900
Sven Eckelmann33fbb1f2016-06-30 20:10:46 +0200901 spin_lock_bh(&orig_node->vlan_list_lock);
902 hlist_for_each_entry_safe(vlan, node_tmp, &orig_node->vlan_list, list) {
903 hlist_del_rcu(&vlan->list);
904 batadv_orig_node_vlan_put(vlan);
905 }
906 spin_unlock_bh(&orig_node->vlan_list_lock);
907
Sven Eckelmanndeed9662016-01-05 12:06:21 +0100908 /* Free nc_nodes */
909 batadv_nc_purge_orig(orig_node->bat_priv, orig_node, NULL);
910
911 call_rcu(&orig_node->rcu, batadv_orig_node_free_rcu);
912}
913
914/**
Sven Eckelmann5d967312016-01-17 11:01:09 +0100915 * batadv_orig_node_put - decrement the orig node refcounter and possibly
Sven Eckelmanndeed9662016-01-05 12:06:21 +0100916 * release it
Linus Lüssing72822222013-04-15 21:43:29 +0800917 * @orig_node: the orig node to free
918 */
Sven Eckelmann5d967312016-01-17 11:01:09 +0100919void batadv_orig_node_put(struct batadv_orig_node *orig_node)
Marek Lindner7b36e8e2011-02-18 12:28:10 +0000920{
Sven Eckelmann7c124392016-01-16 10:29:56 +0100921 kref_put(&orig_node->refcount, batadv_orig_node_release);
Marek Lindner7b36e8e2011-02-18 12:28:10 +0000922}
923
Sven Eckelmann56303d32012-06-05 22:31:31 +0200924void batadv_originator_free(struct batadv_priv *bat_priv)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000925{
Sven Eckelmann5bf74e92012-06-05 22:31:28 +0200926 struct batadv_hashtable *hash = bat_priv->orig_hash;
Sasha Levinb67bfe02013-02-27 17:06:00 -0800927 struct hlist_node *node_tmp;
Marek Lindner16b1aba2011-01-19 20:01:42 +0000928 struct hlist_head *head;
Marek Lindner16b1aba2011-01-19 20:01:42 +0000929 spinlock_t *list_lock; /* spinlock to protect write access */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200930 struct batadv_orig_node *orig_node;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200931 u32 i;
Marek Lindner16b1aba2011-01-19 20:01:42 +0000932
933 if (!hash)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000934 return;
935
936 cancel_delayed_work_sync(&bat_priv->orig_work);
937
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000938 bat_priv->orig_hash = NULL;
Marek Lindner16b1aba2011-01-19 20:01:42 +0000939
940 for (i = 0; i < hash->size; i++) {
941 head = &hash->table[i];
942 list_lock = &hash->list_locks[i];
943
944 spin_lock_bh(list_lock);
Sasha Levinb67bfe02013-02-27 17:06:00 -0800945 hlist_for_each_entry_safe(orig_node, node_tmp,
Marek Lindner7aadf882011-02-18 12:28:09 +0000946 head, hash_entry) {
Sasha Levinb67bfe02013-02-27 17:06:00 -0800947 hlist_del_rcu(&orig_node->hash_entry);
Sven Eckelmann5d967312016-01-17 11:01:09 +0100948 batadv_orig_node_put(orig_node);
Marek Lindner16b1aba2011-01-19 20:01:42 +0000949 }
950 spin_unlock_bh(list_lock);
951 }
952
Sven Eckelmann1a8eaf02012-05-12 02:09:32 +0200953 batadv_hash_destroy(hash);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000954}
955
Antonio Quartullibbad0a52013-09-02 12:15:02 +0200956/**
957 * batadv_orig_node_new - creates a new orig_node
958 * @bat_priv: the bat priv with all the soft interface information
959 * @addr: the mac address of the originator
960 *
961 * Creates a new originator object and initialise all the generic fields.
962 * The new object is not added to the originator list.
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200963 *
964 * Return: the newly created object or NULL on failure.
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +0200965 */
Antonio Quartullibbad0a52013-09-02 12:15:02 +0200966struct batadv_orig_node *batadv_orig_node_new(struct batadv_priv *bat_priv,
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200967 const u8 *addr)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000968{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200969 struct batadv_orig_node *orig_node;
Antonio Quartulli7ea7b4a2013-07-30 22:16:25 +0200970 struct batadv_orig_node_vlan *vlan;
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200971 unsigned long reset_time;
Antonio Quartullibbad0a52013-09-02 12:15:02 +0200972 int i;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000973
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200974 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
975 "Creating new originator: %pM\n", addr);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000976
Sven Eckelmann704509b2011-05-14 23:14:54 +0200977 orig_node = kzalloc(sizeof(*orig_node), GFP_ATOMIC);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000978 if (!orig_node)
979 return NULL;
980
Marek Lindner9591a792010-12-12 21:57:11 +0000981 INIT_HLIST_HEAD(&orig_node->neigh_list);
Marek Lindnerd0fa4f32015-06-22 00:30:22 +0800982 INIT_HLIST_HEAD(&orig_node->vlan_list);
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100983 INIT_HLIST_HEAD(&orig_node->ifinfo_list);
Marek Lindnerf3e00082011-01-25 21:52:11 +0000984 spin_lock_init(&orig_node->bcast_seqno_lock);
Marek Lindnerf987ed62010-12-12 21:57:12 +0000985 spin_lock_init(&orig_node->neigh_list_lock);
Antonio Quartullia73105b2011-04-27 14:27:44 +0200986 spin_lock_init(&orig_node->tt_buff_lock);
Antonio Quartullia70a9aa2013-07-30 22:16:24 +0200987 spin_lock_init(&orig_node->tt_lock);
Antonio Quartulli7ea7b4a2013-07-30 22:16:25 +0200988 spin_lock_init(&orig_node->vlan_list_lock);
Marek Lindner7b36e8e2011-02-18 12:28:10 +0000989
Martin Hundebølld56b1702013-01-25 11:12:39 +0100990 batadv_nc_init_orig(orig_node);
991
Marek Lindner7b36e8e2011-02-18 12:28:10 +0000992 /* extra reference for return */
Sven Eckelmann7c124392016-01-16 10:29:56 +0100993 kref_init(&orig_node->refcount);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000994
Marek Lindner16b1aba2011-01-19 20:01:42 +0000995 orig_node->bat_priv = bat_priv;
Antonio Quartulli8fdd0152014-01-22 00:42:11 +0100996 ether_addr_copy(orig_node->orig, addr);
Antonio Quartulli785ea112011-11-23 11:35:44 +0100997 batadv_dat_init_orig_node_addr(orig_node);
Antonio Quartullic8c991b2011-07-07 01:40:57 +0200998 atomic_set(&orig_node->last_ttvn, 0);
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200999 orig_node->tt_buff = NULL;
Antonio Quartullia73105b2011-04-27 14:27:44 +02001000 orig_node->tt_buff_len = 0;
Linus Lüssing2c667a32014-10-30 06:23:40 +01001001 orig_node->last_seen = jiffies;
Sven Eckelmann42d0b042012-06-03 22:19:17 +02001002 reset_time = jiffies - 1 - msecs_to_jiffies(BATADV_RESET_PROTECTION_MS);
1003 orig_node->bcast_seqno_reset = reset_time;
Linus Lüssing8a4023c2015-06-16 17:10:26 +02001004
Linus Lüssing60432d72014-02-15 17:47:51 +01001005#ifdef CONFIG_BATMAN_ADV_MCAST
1006 orig_node->mcast_flags = BATADV_NO_FLAGS;
Linus Lüssing8a4023c2015-06-16 17:10:26 +02001007 INIT_HLIST_NODE(&orig_node->mcast_want_all_unsnoopables_node);
1008 INIT_HLIST_NODE(&orig_node->mcast_want_all_ipv4_node);
1009 INIT_HLIST_NODE(&orig_node->mcast_want_all_ipv6_node);
1010 spin_lock_init(&orig_node->mcast_handler_lock);
Linus Lüssing60432d72014-02-15 17:47:51 +01001011#endif
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001012
Antonio Quartulli7ea7b4a2013-07-30 22:16:25 +02001013 /* create a vlan object for the "untagged" LAN */
1014 vlan = batadv_orig_node_vlan_new(orig_node, BATADV_NO_FLAGS);
1015 if (!vlan)
1016 goto free_orig_node;
1017 /* batadv_orig_node_vlan_new() increases the refcounter.
1018 * Immediately release vlan since it is not needed anymore in this
1019 * context
1020 */
Sven Eckelmann21754e22016-01-17 11:01:24 +01001021 batadv_orig_node_vlan_put(vlan);
Antonio Quartulli7ea7b4a2013-07-30 22:16:25 +02001022
Martin Hundebøll610bfc6bc2013-05-23 16:53:02 +02001023 for (i = 0; i < BATADV_FRAG_BUFFER_COUNT; i++) {
1024 INIT_HLIST_HEAD(&orig_node->fragments[i].head);
1025 spin_lock_init(&orig_node->fragments[i].lock);
1026 orig_node->fragments[i].size = 0;
1027 }
1028
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001029 return orig_node;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001030free_orig_node:
1031 kfree(orig_node);
1032 return NULL;
1033}
1034
Simon Wunderlich89652332013-11-13 19:14:46 +01001035/**
Simon Wunderlich709de132014-03-26 15:46:24 +01001036 * batadv_purge_neigh_ifinfo - purge obsolete ifinfo entries from neighbor
1037 * @bat_priv: the bat priv with all the soft interface information
1038 * @neigh: orig node which is to be checked
1039 */
1040static void
1041batadv_purge_neigh_ifinfo(struct batadv_priv *bat_priv,
1042 struct batadv_neigh_node *neigh)
1043{
1044 struct batadv_neigh_ifinfo *neigh_ifinfo;
1045 struct batadv_hard_iface *if_outgoing;
1046 struct hlist_node *node_tmp;
1047
1048 spin_lock_bh(&neigh->ifinfo_lock);
1049
1050 /* for all ifinfo objects for this neighinator */
1051 hlist_for_each_entry_safe(neigh_ifinfo, node_tmp,
1052 &neigh->ifinfo_list, list) {
1053 if_outgoing = neigh_ifinfo->if_outgoing;
1054
1055 /* always keep the default interface */
1056 if (if_outgoing == BATADV_IF_DEFAULT)
1057 continue;
1058
1059 /* don't purge if the interface is not (going) down */
1060 if ((if_outgoing->if_status != BATADV_IF_INACTIVE) &&
1061 (if_outgoing->if_status != BATADV_IF_NOT_IN_USE) &&
1062 (if_outgoing->if_status != BATADV_IF_TO_BE_REMOVED))
1063 continue;
1064
1065 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1066 "neighbor/ifinfo purge: neighbor %pM, iface: %s\n",
1067 neigh->addr, if_outgoing->net_dev->name);
1068
1069 hlist_del_rcu(&neigh_ifinfo->list);
Sven Eckelmann044fa3a2016-01-17 11:01:12 +01001070 batadv_neigh_ifinfo_put(neigh_ifinfo);
Simon Wunderlich709de132014-03-26 15:46:24 +01001071 }
1072
1073 spin_unlock_bh(&neigh->ifinfo_lock);
1074}
1075
1076/**
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001077 * batadv_purge_orig_ifinfo - purge obsolete ifinfo entries from originator
1078 * @bat_priv: the bat priv with all the soft interface information
1079 * @orig_node: orig node which is to be checked
1080 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +02001081 * Return: true if any ifinfo entry was purged, false otherwise.
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001082 */
1083static bool
1084batadv_purge_orig_ifinfo(struct batadv_priv *bat_priv,
1085 struct batadv_orig_node *orig_node)
1086{
1087 struct batadv_orig_ifinfo *orig_ifinfo;
1088 struct batadv_hard_iface *if_outgoing;
1089 struct hlist_node *node_tmp;
1090 bool ifinfo_purged = false;
1091
1092 spin_lock_bh(&orig_node->neigh_list_lock);
1093
1094 /* for all ifinfo objects for this originator */
1095 hlist_for_each_entry_safe(orig_ifinfo, node_tmp,
1096 &orig_node->ifinfo_list, list) {
1097 if_outgoing = orig_ifinfo->if_outgoing;
1098
1099 /* always keep the default interface */
1100 if (if_outgoing == BATADV_IF_DEFAULT)
1101 continue;
1102
1103 /* don't purge if the interface is not (going) down */
1104 if ((if_outgoing->if_status != BATADV_IF_INACTIVE) &&
1105 (if_outgoing->if_status != BATADV_IF_NOT_IN_USE) &&
1106 (if_outgoing->if_status != BATADV_IF_TO_BE_REMOVED))
1107 continue;
1108
1109 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1110 "router/ifinfo purge: originator %pM, iface: %s\n",
1111 orig_node->orig, if_outgoing->net_dev->name);
1112
1113 ifinfo_purged = true;
1114
1115 hlist_del_rcu(&orig_ifinfo->list);
Sven Eckelmann35f94772016-01-17 11:01:13 +01001116 batadv_orig_ifinfo_put(orig_ifinfo);
Simon Wunderlichf3b3d902013-11-13 19:14:50 +01001117 if (orig_node->last_bonding_candidate == orig_ifinfo) {
1118 orig_node->last_bonding_candidate = NULL;
Sven Eckelmann35f94772016-01-17 11:01:13 +01001119 batadv_orig_ifinfo_put(orig_ifinfo);
Simon Wunderlichf3b3d902013-11-13 19:14:50 +01001120 }
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001121 }
1122
1123 spin_unlock_bh(&orig_node->neigh_list_lock);
1124
1125 return ifinfo_purged;
1126}
1127
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001128/**
Simon Wunderlich89652332013-11-13 19:14:46 +01001129 * batadv_purge_orig_neighbors - purges neighbors from originator
1130 * @bat_priv: the bat priv with all the soft interface information
1131 * @orig_node: orig node which is to be checked
1132 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +02001133 * Return: true if any neighbor was purged, false otherwise
Simon Wunderlich89652332013-11-13 19:14:46 +01001134 */
Sven Eckelmann56303d32012-06-05 22:31:31 +02001135static bool
1136batadv_purge_orig_neighbors(struct batadv_priv *bat_priv,
Simon Wunderlich89652332013-11-13 19:14:46 +01001137 struct batadv_orig_node *orig_node)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001138{
Sasha Levinb67bfe02013-02-27 17:06:00 -08001139 struct hlist_node *node_tmp;
Sven Eckelmann56303d32012-06-05 22:31:31 +02001140 struct batadv_neigh_node *neigh_node;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001141 bool neigh_purged = false;
Marek Lindner0b0094e2012-03-01 15:35:20 +08001142 unsigned long last_seen;
Sven Eckelmann56303d32012-06-05 22:31:31 +02001143 struct batadv_hard_iface *if_incoming;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001144
Marek Lindnerf987ed62010-12-12 21:57:12 +00001145 spin_lock_bh(&orig_node->neigh_list_lock);
1146
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001147 /* for all neighbors towards this originator ... */
Sasha Levinb67bfe02013-02-27 17:06:00 -08001148 hlist_for_each_entry_safe(neigh_node, node_tmp,
Marek Lindner9591a792010-12-12 21:57:11 +00001149 &orig_node->neigh_list, list) {
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001150 last_seen = neigh_node->last_seen;
1151 if_incoming = neigh_node->if_incoming;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001152
Sven Eckelmann42d0b042012-06-03 22:19:17 +02001153 if ((batadv_has_timed_out(last_seen, BATADV_PURGE_TIMEOUT)) ||
Sven Eckelmanne9a4f292012-06-03 22:19:19 +02001154 (if_incoming->if_status == BATADV_IF_INACTIVE) ||
1155 (if_incoming->if_status == BATADV_IF_NOT_IN_USE) ||
1156 (if_incoming->if_status == BATADV_IF_TO_BE_REMOVED)) {
Sven Eckelmanne9a4f292012-06-03 22:19:19 +02001157 if ((if_incoming->if_status == BATADV_IF_INACTIVE) ||
1158 (if_incoming->if_status == BATADV_IF_NOT_IN_USE) ||
1159 (if_incoming->if_status == BATADV_IF_TO_BE_REMOVED))
Sven Eckelmann39c75a52012-06-03 22:19:22 +02001160 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001161 "neighbor purge: originator %pM, neighbor: %pM, iface: %s\n",
1162 orig_node->orig, neigh_node->addr,
1163 if_incoming->net_dev->name);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001164 else
Sven Eckelmann39c75a52012-06-03 22:19:22 +02001165 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001166 "neighbor timeout: originator %pM, neighbor: %pM, last_seen: %u\n",
1167 orig_node->orig, neigh_node->addr,
1168 jiffies_to_msecs(last_seen));
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001169
1170 neigh_purged = true;
Marek Lindner9591a792010-12-12 21:57:11 +00001171
Marek Lindnerf987ed62010-12-12 21:57:12 +00001172 hlist_del_rcu(&neigh_node->list);
Sven Eckelmann25bb2502016-01-17 11:01:11 +01001173 batadv_neigh_node_put(neigh_node);
Simon Wunderlich709de132014-03-26 15:46:24 +01001174 } else {
1175 /* only necessary if not the whole neighbor is to be
1176 * deleted, but some interface has been removed.
1177 */
1178 batadv_purge_neigh_ifinfo(bat_priv, neigh_node);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001179 }
1180 }
Marek Lindnerf987ed62010-12-12 21:57:12 +00001181
1182 spin_unlock_bh(&orig_node->neigh_list_lock);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001183 return neigh_purged;
1184}
1185
Simon Wunderlich89652332013-11-13 19:14:46 +01001186/**
1187 * batadv_find_best_neighbor - finds the best neighbor after purging
1188 * @bat_priv: the bat priv with all the soft interface information
1189 * @orig_node: orig node which is to be checked
1190 * @if_outgoing: the interface for which the metric should be compared
1191 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +02001192 * Return: the current best neighbor, with refcount increased.
Simon Wunderlich89652332013-11-13 19:14:46 +01001193 */
1194static struct batadv_neigh_node *
1195batadv_find_best_neighbor(struct batadv_priv *bat_priv,
1196 struct batadv_orig_node *orig_node,
1197 struct batadv_hard_iface *if_outgoing)
1198{
1199 struct batadv_neigh_node *best = NULL, *neigh;
Antonio Quartulli29824a52016-05-25 23:27:31 +08001200 struct batadv_algo_ops *bao = bat_priv->algo_ops;
Simon Wunderlich89652332013-11-13 19:14:46 +01001201
1202 rcu_read_lock();
1203 hlist_for_each_entry_rcu(neigh, &orig_node->neigh_list, list) {
Antonio Quartulli29824a52016-05-25 23:27:31 +08001204 if (best && (bao->neigh.cmp(neigh, if_outgoing, best,
1205 if_outgoing) <= 0))
Simon Wunderlich89652332013-11-13 19:14:46 +01001206 continue;
1207
Sven Eckelmann77ae32e2016-01-16 10:29:53 +01001208 if (!kref_get_unless_zero(&neigh->refcount))
Simon Wunderlich89652332013-11-13 19:14:46 +01001209 continue;
1210
1211 if (best)
Sven Eckelmann25bb2502016-01-17 11:01:11 +01001212 batadv_neigh_node_put(best);
Simon Wunderlich89652332013-11-13 19:14:46 +01001213
1214 best = neigh;
1215 }
1216 rcu_read_unlock();
1217
1218 return best;
1219}
1220
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001221/**
1222 * batadv_purge_orig_node - purges obsolete information from an orig_node
1223 * @bat_priv: the bat priv with all the soft interface information
1224 * @orig_node: orig node which is to be checked
1225 *
1226 * This function checks if the orig_node or substructures of it have become
1227 * obsolete, and purges this information if that's the case.
1228 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +02001229 * Return: true if the orig_node is to be removed, false otherwise.
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001230 */
Sven Eckelmann56303d32012-06-05 22:31:31 +02001231static bool batadv_purge_orig_node(struct batadv_priv *bat_priv,
1232 struct batadv_orig_node *orig_node)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001233{
Sven Eckelmann56303d32012-06-05 22:31:31 +02001234 struct batadv_neigh_node *best_neigh_node;
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001235 struct batadv_hard_iface *hard_iface;
Simon Wunderlich7b955a92014-03-26 15:46:23 +01001236 bool changed_ifinfo, changed_neigh;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001237
Sven Eckelmann42d0b042012-06-03 22:19:17 +02001238 if (batadv_has_timed_out(orig_node->last_seen,
1239 2 * BATADV_PURGE_TIMEOUT)) {
Sven Eckelmann39c75a52012-06-03 22:19:22 +02001240 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001241 "Originator timeout: originator %pM, last_seen %u\n",
1242 orig_node->orig,
1243 jiffies_to_msecs(orig_node->last_seen));
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001244 return true;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001245 }
Simon Wunderlich7b955a92014-03-26 15:46:23 +01001246 changed_ifinfo = batadv_purge_orig_ifinfo(bat_priv, orig_node);
1247 changed_neigh = batadv_purge_orig_neighbors(bat_priv, orig_node);
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001248
Simon Wunderlich7b955a92014-03-26 15:46:23 +01001249 if (!changed_ifinfo && !changed_neigh)
Simon Wunderlich89652332013-11-13 19:14:46 +01001250 return false;
1251
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001252 /* first for NULL ... */
Simon Wunderlich89652332013-11-13 19:14:46 +01001253 best_neigh_node = batadv_find_best_neighbor(bat_priv, orig_node,
1254 BATADV_IF_DEFAULT);
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001255 batadv_update_route(bat_priv, orig_node, BATADV_IF_DEFAULT,
1256 best_neigh_node);
Simon Wunderlich89652332013-11-13 19:14:46 +01001257 if (best_neigh_node)
Sven Eckelmann25bb2502016-01-17 11:01:11 +01001258 batadv_neigh_node_put(best_neigh_node);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001259
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001260 /* ... then for all other interfaces. */
1261 rcu_read_lock();
1262 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
1263 if (hard_iface->if_status != BATADV_IF_ACTIVE)
1264 continue;
1265
1266 if (hard_iface->soft_iface != bat_priv->soft_iface)
1267 continue;
1268
Sven Eckelmann27353442016-03-05 16:09:16 +01001269 if (!kref_get_unless_zero(&hard_iface->refcount))
1270 continue;
1271
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001272 best_neigh_node = batadv_find_best_neighbor(bat_priv,
1273 orig_node,
1274 hard_iface);
1275 batadv_update_route(bat_priv, orig_node, hard_iface,
1276 best_neigh_node);
1277 if (best_neigh_node)
Sven Eckelmann25bb2502016-01-17 11:01:11 +01001278 batadv_neigh_node_put(best_neigh_node);
Sven Eckelmann27353442016-03-05 16:09:16 +01001279
1280 batadv_hardif_put(hard_iface);
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001281 }
1282 rcu_read_unlock();
1283
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001284 return false;
1285}
1286
Sven Eckelmann56303d32012-06-05 22:31:31 +02001287static void _batadv_purge_orig(struct batadv_priv *bat_priv)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001288{
Sven Eckelmann5bf74e92012-06-05 22:31:28 +02001289 struct batadv_hashtable *hash = bat_priv->orig_hash;
Sasha Levinb67bfe02013-02-27 17:06:00 -08001290 struct hlist_node *node_tmp;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001291 struct hlist_head *head;
Marek Lindnerfb778ea2011-01-19 20:01:40 +00001292 spinlock_t *list_lock; /* spinlock to protect write access */
Sven Eckelmann56303d32012-06-05 22:31:31 +02001293 struct batadv_orig_node *orig_node;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001294 u32 i;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001295
1296 if (!hash)
1297 return;
1298
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001299 /* for all origins... */
1300 for (i = 0; i < hash->size; i++) {
1301 head = &hash->table[i];
Marek Lindnerfb778ea2011-01-19 20:01:40 +00001302 list_lock = &hash->list_locks[i];
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001303
Marek Lindnerfb778ea2011-01-19 20:01:40 +00001304 spin_lock_bh(list_lock);
Sasha Levinb67bfe02013-02-27 17:06:00 -08001305 hlist_for_each_entry_safe(orig_node, node_tmp,
Marek Lindner7aadf882011-02-18 12:28:09 +00001306 head, hash_entry) {
Sven Eckelmann03fc7f82012-05-12 18:34:00 +02001307 if (batadv_purge_orig_node(bat_priv, orig_node)) {
Marek Lindner414254e2013-04-23 21:39:58 +08001308 batadv_gw_node_delete(bat_priv, orig_node);
Sasha Levinb67bfe02013-02-27 17:06:00 -08001309 hlist_del_rcu(&orig_node->hash_entry);
Linus Lüssing9d31b3c2014-12-13 23:32:15 +01001310 batadv_tt_global_del_orig(orig_node->bat_priv,
1311 orig_node, -1,
1312 "originator timed out");
Sven Eckelmann5d967312016-01-17 11:01:09 +01001313 batadv_orig_node_put(orig_node);
Marek Lindnerfb778ea2011-01-19 20:01:40 +00001314 continue;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001315 }
Martin Hundebøll610bfc6bc2013-05-23 16:53:02 +02001316
1317 batadv_frag_purge_orig(orig_node,
1318 batadv_frag_check_entry);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001319 }
Marek Lindnerfb778ea2011-01-19 20:01:40 +00001320 spin_unlock_bh(list_lock);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001321 }
1322
Sven Eckelmann7cf06bc2012-05-12 02:09:29 +02001323 batadv_gw_election(bat_priv);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001324}
1325
Sven Eckelmann03fc7f82012-05-12 18:34:00 +02001326static void batadv_purge_orig(struct work_struct *work)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001327{
Sven Eckelmann56303d32012-06-05 22:31:31 +02001328 struct delayed_work *delayed_work;
1329 struct batadv_priv *bat_priv;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001330
Geliang Tang4ba4bc02015-12-28 23:43:37 +08001331 delayed_work = to_delayed_work(work);
Sven Eckelmann56303d32012-06-05 22:31:31 +02001332 bat_priv = container_of(delayed_work, struct batadv_priv, orig_work);
Sven Eckelmann03fc7f82012-05-12 18:34:00 +02001333 _batadv_purge_orig(bat_priv);
Antonio Quartulli72414442012-12-25 13:14:37 +01001334 queue_delayed_work(batadv_event_workqueue,
1335 &bat_priv->orig_work,
1336 msecs_to_jiffies(BATADV_ORIG_WORK_PERIOD));
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001337}
1338
Sven Eckelmann56303d32012-06-05 22:31:31 +02001339void batadv_purge_orig_ref(struct batadv_priv *bat_priv)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001340{
Sven Eckelmann03fc7f82012-05-12 18:34:00 +02001341 _batadv_purge_orig(bat_priv);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001342}
1343
Sven Eckelmanndc1cbd12016-07-16 09:31:20 +02001344#ifdef CONFIG_BATMAN_ADV_DEBUGFS
Sven Eckelmann7d211ef2012-05-12 02:09:34 +02001345int batadv_orig_seq_print_text(struct seq_file *seq, void *offset)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001346{
1347 struct net_device *net_dev = (struct net_device *)seq->private;
Sven Eckelmann56303d32012-06-05 22:31:31 +02001348 struct batadv_priv *bat_priv = netdev_priv(net_dev);
Sven Eckelmann56303d32012-06-05 22:31:31 +02001349 struct batadv_hard_iface *primary_if;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001350
Marek Lindner30da63a2012-08-03 17:15:46 +02001351 primary_if = batadv_seq_print_text_primary_if_get(seq);
1352 if (!primary_if)
Antonio Quartulli737a2a222013-09-02 12:15:03 +02001353 return 0;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001354
Antonio Quartulli737a2a222013-09-02 12:15:03 +02001355 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 +02001356 BATADV_SOURCE_VERSION, primary_if->net_dev->name,
Antonio Quartulli737a2a222013-09-02 12:15:03 +02001357 primary_if->net_dev->dev_addr, net_dev->name,
Antonio Quartulli29824a52016-05-25 23:27:31 +08001358 bat_priv->algo_ops->name);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001359
Sven Eckelmann82047ad2016-01-17 11:01:10 +01001360 batadv_hardif_put(primary_if);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001361
Antonio Quartulli29824a52016-05-25 23:27:31 +08001362 if (!bat_priv->algo_ops->orig.print) {
Antonio Quartulli737a2a222013-09-02 12:15:03 +02001363 seq_puts(seq,
1364 "No printing function for this routing protocol\n");
1365 return 0;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001366 }
1367
Antonio Quartulli29824a52016-05-25 23:27:31 +08001368 bat_priv->algo_ops->orig.print(bat_priv, seq, BATADV_IF_DEFAULT);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001369
Marek Lindner30da63a2012-08-03 17:15:46 +02001370 return 0;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001371}
1372
Simon Wunderlichcb1c92e2013-11-21 11:52:16 +01001373/**
1374 * batadv_orig_hardif_seq_print_text - writes originator infos for a specific
1375 * outgoing interface
1376 * @seq: debugfs table seq_file struct
1377 * @offset: not used
1378 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +02001379 * Return: 0
Simon Wunderlichcb1c92e2013-11-21 11:52:16 +01001380 */
1381int batadv_orig_hardif_seq_print_text(struct seq_file *seq, void *offset)
1382{
1383 struct net_device *net_dev = (struct net_device *)seq->private;
1384 struct batadv_hard_iface *hard_iface;
1385 struct batadv_priv *bat_priv;
1386
1387 hard_iface = batadv_hardif_get_by_netdev(net_dev);
1388
1389 if (!hard_iface || !hard_iface->soft_iface) {
1390 seq_puts(seq, "Interface not known to B.A.T.M.A.N.\n");
1391 goto out;
1392 }
1393
1394 bat_priv = netdev_priv(hard_iface->soft_iface);
Antonio Quartulli29824a52016-05-25 23:27:31 +08001395 if (!bat_priv->algo_ops->orig.print) {
Simon Wunderlichcb1c92e2013-11-21 11:52:16 +01001396 seq_puts(seq,
1397 "No printing function for this routing protocol\n");
1398 goto out;
1399 }
1400
1401 if (hard_iface->if_status != BATADV_IF_ACTIVE) {
1402 seq_puts(seq, "Interface not active\n");
1403 goto out;
1404 }
1405
1406 seq_printf(seq, "[B.A.T.M.A.N. adv %s, IF/MAC: %s/%pM (%s %s)]\n",
1407 BATADV_SOURCE_VERSION, hard_iface->net_dev->name,
1408 hard_iface->net_dev->dev_addr,
Antonio Quartulli29824a52016-05-25 23:27:31 +08001409 hard_iface->soft_iface->name, bat_priv->algo_ops->name);
Simon Wunderlichcb1c92e2013-11-21 11:52:16 +01001410
Antonio Quartulli29824a52016-05-25 23:27:31 +08001411 bat_priv->algo_ops->orig.print(bat_priv, seq, hard_iface);
Simon Wunderlichcb1c92e2013-11-21 11:52:16 +01001412
1413out:
Marek Lindner16a41422014-04-24 03:44:25 +08001414 if (hard_iface)
Sven Eckelmann82047ad2016-01-17 11:01:10 +01001415 batadv_hardif_put(hard_iface);
Simon Wunderlichcb1c92e2013-11-21 11:52:16 +01001416 return 0;
1417}
Sven Eckelmanndc1cbd12016-07-16 09:31:20 +02001418#endif
Simon Wunderlichcb1c92e2013-11-21 11:52:16 +01001419
Matthias Schiffer85cf8c82016-07-03 13:31:39 +02001420/**
1421 * batadv_orig_dump - Dump to netlink the originator infos for a specific
1422 * outgoing interface
1423 * @msg: message to dump into
1424 * @cb: parameters for the dump
1425 *
1426 * Return: 0 or error value
1427 */
1428int batadv_orig_dump(struct sk_buff *msg, struct netlink_callback *cb)
1429{
1430 struct net *net = sock_net(cb->skb->sk);
1431 struct net_device *soft_iface;
1432 struct net_device *hard_iface = NULL;
1433 struct batadv_hard_iface *hardif = BATADV_IF_DEFAULT;
1434 struct batadv_priv *bat_priv;
1435 struct batadv_hard_iface *primary_if = NULL;
1436 int ret;
1437 int ifindex, hard_ifindex;
1438
1439 ifindex = batadv_netlink_get_ifindex(cb->nlh, BATADV_ATTR_MESH_IFINDEX);
1440 if (!ifindex)
1441 return -EINVAL;
1442
1443 soft_iface = dev_get_by_index(net, ifindex);
1444 if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
1445 ret = -ENODEV;
1446 goto out;
1447 }
1448
1449 bat_priv = netdev_priv(soft_iface);
1450
1451 primary_if = batadv_primary_if_get_selected(bat_priv);
1452 if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
1453 ret = -ENOENT;
1454 goto out;
1455 }
1456
1457 hard_ifindex = batadv_netlink_get_ifindex(cb->nlh,
1458 BATADV_ATTR_HARD_IFINDEX);
1459 if (hard_ifindex) {
1460 hard_iface = dev_get_by_index(net, hard_ifindex);
1461 if (hard_iface)
1462 hardif = batadv_hardif_get_by_netdev(hard_iface);
1463
1464 if (!hardif) {
1465 ret = -ENODEV;
1466 goto out;
1467 }
1468
1469 if (hardif->soft_iface != soft_iface) {
1470 ret = -ENOENT;
1471 goto out;
1472 }
1473 }
1474
1475 if (!bat_priv->algo_ops->orig.dump) {
1476 ret = -EOPNOTSUPP;
1477 goto out;
1478 }
1479
1480 bat_priv->algo_ops->orig.dump(msg, cb, bat_priv, hardif);
1481
1482 ret = msg->len;
1483
1484 out:
1485 if (hardif)
1486 batadv_hardif_put(hardif);
1487 if (hard_iface)
1488 dev_put(hard_iface);
1489 if (primary_if)
1490 batadv_hardif_put(primary_if);
1491 if (soft_iface)
1492 dev_put(soft_iface);
1493
1494 return ret;
1495}
1496
Sven Eckelmann56303d32012-06-05 22:31:31 +02001497int batadv_orig_hash_add_if(struct batadv_hard_iface *hard_iface,
1498 int max_if_num)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001499{
Sven Eckelmann56303d32012-06-05 22:31:31 +02001500 struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
Antonio Quartulli29824a52016-05-25 23:27:31 +08001501 struct batadv_algo_ops *bao = bat_priv->algo_ops;
Sven Eckelmann5bf74e92012-06-05 22:31:28 +02001502 struct batadv_hashtable *hash = bat_priv->orig_hash;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001503 struct hlist_head *head;
Sven Eckelmann56303d32012-06-05 22:31:31 +02001504 struct batadv_orig_node *orig_node;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001505 u32 i;
Antonio Quartullic90681b2011-10-05 17:05:25 +02001506 int ret;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001507
1508 /* resize all orig nodes because orig_node->bcast_own(_sum) depend on
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +02001509 * if_num
1510 */
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001511 for (i = 0; i < hash->size; i++) {
1512 head = &hash->table[i];
1513
Marek Lindnerfb778ea2011-01-19 20:01:40 +00001514 rcu_read_lock();
Sasha Levinb67bfe02013-02-27 17:06:00 -08001515 hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
Antonio Quartullid0015fd2013-09-03 11:10:23 +02001516 ret = 0;
Antonio Quartulli29824a52016-05-25 23:27:31 +08001517 if (bao->orig.add_if)
1518 ret = bao->orig.add_if(orig_node, max_if_num);
Sven Eckelmann5346c352012-05-05 13:27:28 +02001519 if (ret == -ENOMEM)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001520 goto err;
1521 }
Marek Lindnerfb778ea2011-01-19 20:01:40 +00001522 rcu_read_unlock();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001523 }
1524
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001525 return 0;
1526
1527err:
Marek Lindnerfb778ea2011-01-19 20:01:40 +00001528 rcu_read_unlock();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001529 return -ENOMEM;
1530}
1531
Sven Eckelmann56303d32012-06-05 22:31:31 +02001532int batadv_orig_hash_del_if(struct batadv_hard_iface *hard_iface,
1533 int max_if_num)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001534{
Sven Eckelmann56303d32012-06-05 22:31:31 +02001535 struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
Sven Eckelmann5bf74e92012-06-05 22:31:28 +02001536 struct batadv_hashtable *hash = bat_priv->orig_hash;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001537 struct hlist_head *head;
Sven Eckelmann56303d32012-06-05 22:31:31 +02001538 struct batadv_hard_iface *hard_iface_tmp;
1539 struct batadv_orig_node *orig_node;
Antonio Quartulli29824a52016-05-25 23:27:31 +08001540 struct batadv_algo_ops *bao = bat_priv->algo_ops;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001541 u32 i;
Antonio Quartullic90681b2011-10-05 17:05:25 +02001542 int ret;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001543
1544 /* resize all orig nodes because orig_node->bcast_own(_sum) depend on
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +02001545 * if_num
1546 */
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001547 for (i = 0; i < hash->size; i++) {
1548 head = &hash->table[i];
1549
Marek Lindnerfb778ea2011-01-19 20:01:40 +00001550 rcu_read_lock();
Sasha Levinb67bfe02013-02-27 17:06:00 -08001551 hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
Antonio Quartullid0015fd2013-09-03 11:10:23 +02001552 ret = 0;
Antonio Quartulli29824a52016-05-25 23:27:31 +08001553 if (bao->orig.del_if)
1554 ret = bao->orig.del_if(orig_node, max_if_num,
1555 hard_iface->if_num);
Sven Eckelmann5346c352012-05-05 13:27:28 +02001556 if (ret == -ENOMEM)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001557 goto err;
1558 }
Marek Lindnerfb778ea2011-01-19 20:01:40 +00001559 rcu_read_unlock();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001560 }
1561
1562 /* renumber remaining batman interfaces _inside_ of orig_hash_lock */
1563 rcu_read_lock();
Sven Eckelmann3193e8f2012-05-12 02:09:42 +02001564 list_for_each_entry_rcu(hard_iface_tmp, &batadv_hardif_list, list) {
Sven Eckelmanne9a4f292012-06-03 22:19:19 +02001565 if (hard_iface_tmp->if_status == BATADV_IF_NOT_IN_USE)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001566 continue;
1567
Marek Lindnere6c10f42011-02-18 12:33:20 +00001568 if (hard_iface == hard_iface_tmp)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001569 continue;
1570
Marek Lindnere6c10f42011-02-18 12:33:20 +00001571 if (hard_iface->soft_iface != hard_iface_tmp->soft_iface)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001572 continue;
1573
Marek Lindnere6c10f42011-02-18 12:33:20 +00001574 if (hard_iface_tmp->if_num > hard_iface->if_num)
1575 hard_iface_tmp->if_num--;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001576 }
1577 rcu_read_unlock();
1578
Marek Lindnere6c10f42011-02-18 12:33:20 +00001579 hard_iface->if_num = -1;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001580 return 0;
1581
1582err:
Marek Lindnerfb778ea2011-01-19 20:01:40 +00001583 rcu_read_unlock();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001584 return -ENOMEM;
1585}