2017-11-19 17:05:11 +03:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2018-01-01 02:00:00 +03:00
|
|
|
/* Copyright (C) 2011-2018 B.A.T.M.A.N. contributors:
|
2011-11-23 14:35:44 +04:00
|
|
|
*
|
|
|
|
* Antonio Quartulli
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of version 2 of the GNU General Public
|
|
|
|
* License as published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
2013-11-03 23:40:48 +04:00
|
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
2011-11-23 14:35:44 +04:00
|
|
|
*/
|
|
|
|
|
2015-04-17 20:40:28 +03:00
|
|
|
#include "distributed-arp-table.h"
|
|
|
|
#include "main.h"
|
|
|
|
|
|
|
|
#include <linux/atomic.h>
|
2015-06-16 18:10:22 +03:00
|
|
|
#include <linux/bitops.h>
|
2015-04-17 20:40:28 +03:00
|
|
|
#include <linux/byteorder/generic.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/etherdevice.h>
|
2017-11-19 19:12:02 +03:00
|
|
|
#include <linux/gfp.h>
|
2011-11-23 14:35:44 +04:00
|
|
|
#include <linux/if_arp.h>
|
2015-04-17 20:40:28 +03:00
|
|
|
#include <linux/if_ether.h>
|
2013-06-04 14:11:43 +04:00
|
|
|
#include <linux/if_vlan.h>
|
2015-04-17 20:40:28 +03:00
|
|
|
#include <linux/in.h>
|
|
|
|
#include <linux/jiffies.h>
|
|
|
|
#include <linux/kernel.h>
|
2016-01-16 12:29:47 +03:00
|
|
|
#include <linux/kref.h>
|
2015-04-17 20:40:28 +03:00
|
|
|
#include <linux/list.h>
|
2018-03-13 13:41:12 +03:00
|
|
|
#include <linux/netlink.h>
|
2015-04-17 20:40:28 +03:00
|
|
|
#include <linux/rculist.h>
|
|
|
|
#include <linux/rcupdate.h>
|
|
|
|
#include <linux/seq_file.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/stddef.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/workqueue.h>
|
2011-06-26 05:37:18 +04:00
|
|
|
#include <net/arp.h>
|
2018-03-13 13:41:12 +03:00
|
|
|
#include <net/genetlink.h>
|
|
|
|
#include <net/netlink.h>
|
|
|
|
#include <net/sock.h>
|
|
|
|
#include <uapi/linux/batman_adv.h>
|
2011-11-23 14:35:44 +04:00
|
|
|
|
2016-09-05 14:20:25 +03:00
|
|
|
#include "bridge_loop_avoidance.h"
|
2011-11-23 14:35:44 +04:00
|
|
|
#include "hard-interface.h"
|
2015-04-17 20:40:28 +03:00
|
|
|
#include "hash.h"
|
2016-05-16 00:48:31 +03:00
|
|
|
#include "log.h"
|
2018-03-13 13:41:12 +03:00
|
|
|
#include "netlink.h"
|
2011-11-23 14:35:44 +04:00
|
|
|
#include "originator.h"
|
|
|
|
#include "send.h"
|
2018-03-13 13:41:12 +03:00
|
|
|
#include "soft-interface.h"
|
2011-06-26 05:37:18 +04:00
|
|
|
#include "translation-table.h"
|
2016-05-15 12:07:43 +03:00
|
|
|
#include "tvlv.h"
|
2011-11-23 14:35:44 +04:00
|
|
|
|
2012-06-30 22:01:19 +04:00
|
|
|
static void batadv_dat_purge(struct work_struct *work);
|
|
|
|
|
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_dat_start_timer() - initialise the DAT periodic worker
|
2012-06-30 22:01:19 +04:00
|
|
|
* @bat_priv: the bat priv with all the soft interface information
|
|
|
|
*/
|
|
|
|
static void batadv_dat_start_timer(struct batadv_priv *bat_priv)
|
|
|
|
{
|
|
|
|
INIT_DELAYED_WORK(&bat_priv->dat.work, batadv_dat_purge);
|
|
|
|
queue_delayed_work(batadv_event_workqueue, &bat_priv->dat.work,
|
|
|
|
msecs_to_jiffies(10000));
|
|
|
|
}
|
|
|
|
|
2016-01-16 12:29:47 +03:00
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_dat_entry_release() - release dat_entry from lists and queue for free
|
2016-01-16 12:29:47 +03:00
|
|
|
* after rcu grace period
|
|
|
|
* @ref: kref pointer of the dat_entry
|
|
|
|
*/
|
|
|
|
static void batadv_dat_entry_release(struct kref *ref)
|
|
|
|
{
|
|
|
|
struct batadv_dat_entry *dat_entry;
|
|
|
|
|
|
|
|
dat_entry = container_of(ref, struct batadv_dat_entry, refcount);
|
|
|
|
|
|
|
|
kfree_rcu(dat_entry, rcu);
|
|
|
|
}
|
|
|
|
|
2012-06-30 22:01:19 +04:00
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_dat_entry_put() - decrement the dat_entry refcounter and possibly
|
2016-01-16 12:29:47 +03:00
|
|
|
* release it
|
|
|
|
* @dat_entry: dat_entry to be free'd
|
2012-06-30 22:01:19 +04:00
|
|
|
*/
|
2016-01-17 13:01:17 +03:00
|
|
|
static void batadv_dat_entry_put(struct batadv_dat_entry *dat_entry)
|
2012-06-30 22:01:19 +04:00
|
|
|
{
|
2016-01-16 12:29:47 +03:00
|
|
|
kref_put(&dat_entry->refcount, batadv_dat_entry_release);
|
2012-06-30 22:01:19 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_dat_to_purge() - check whether a dat_entry has to be purged or not
|
2012-06-30 22:01:19 +04:00
|
|
|
* @dat_entry: the entry to check
|
|
|
|
*
|
2015-09-15 20:00:48 +03:00
|
|
|
* Return: true if the entry has to be purged now, false otherwise.
|
2012-06-30 22:01:19 +04:00
|
|
|
*/
|
|
|
|
static bool batadv_dat_to_purge(struct batadv_dat_entry *dat_entry)
|
|
|
|
{
|
|
|
|
return batadv_has_timed_out(dat_entry->last_update,
|
|
|
|
BATADV_DAT_ENTRY_TIMEOUT);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* __batadv_dat_purge() - delete entries from the DAT local storage
|
2012-06-30 22:01:19 +04:00
|
|
|
* @bat_priv: the bat priv with all the soft interface information
|
|
|
|
* @to_purge: function in charge to decide whether an entry has to be purged or
|
|
|
|
* not. This function takes the dat_entry as argument and has to
|
|
|
|
* returns a boolean value: true is the entry has to be deleted,
|
|
|
|
* false otherwise
|
|
|
|
*
|
2013-03-10 15:29:15 +04:00
|
|
|
* Loops over each entry in the DAT local storage and deletes it if and only if
|
|
|
|
* the to_purge function passed as argument returns true.
|
2012-06-30 22:01:19 +04:00
|
|
|
*/
|
|
|
|
static void __batadv_dat_purge(struct batadv_priv *bat_priv,
|
|
|
|
bool (*to_purge)(struct batadv_dat_entry *))
|
|
|
|
{
|
|
|
|
spinlock_t *list_lock; /* protects write access to the hash lists */
|
|
|
|
struct batadv_dat_entry *dat_entry;
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 05:06:00 +04:00
|
|
|
struct hlist_node *node_tmp;
|
2012-06-30 22:01:19 +04:00
|
|
|
struct hlist_head *head;
|
2015-05-26 19:34:26 +03:00
|
|
|
u32 i;
|
2012-06-30 22:01:19 +04:00
|
|
|
|
|
|
|
if (!bat_priv->dat.hash)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < bat_priv->dat.hash->size; i++) {
|
|
|
|
head = &bat_priv->dat.hash->table[i];
|
|
|
|
list_lock = &bat_priv->dat.hash->list_locks[i];
|
|
|
|
|
|
|
|
spin_lock_bh(list_lock);
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 05:06:00 +04:00
|
|
|
hlist_for_each_entry_safe(dat_entry, node_tmp, head,
|
2012-06-30 22:01:19 +04:00
|
|
|
hash_entry) {
|
2013-03-10 15:29:15 +04:00
|
|
|
/* if a helper function has been passed as parameter,
|
2012-06-30 22:01:19 +04:00
|
|
|
* ask it if the entry has to be purged or not
|
|
|
|
*/
|
|
|
|
if (to_purge && !to_purge(dat_entry))
|
|
|
|
continue;
|
|
|
|
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 05:06:00 +04:00
|
|
|
hlist_del_rcu(&dat_entry->hash_entry);
|
2016-01-17 13:01:17 +03:00
|
|
|
batadv_dat_entry_put(dat_entry);
|
2012-06-30 22:01:19 +04:00
|
|
|
}
|
|
|
|
spin_unlock_bh(list_lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_dat_purge() - periodic task that deletes old entries from the local
|
|
|
|
* DAT hash table
|
2012-06-30 22:01:19 +04:00
|
|
|
* @work: kernel work struct
|
|
|
|
*/
|
|
|
|
static void batadv_dat_purge(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct delayed_work *delayed_work;
|
|
|
|
struct batadv_priv_dat *priv_dat;
|
|
|
|
struct batadv_priv *bat_priv;
|
|
|
|
|
2015-12-28 18:43:37 +03:00
|
|
|
delayed_work = to_delayed_work(work);
|
2012-06-30 22:01:19 +04:00
|
|
|
priv_dat = container_of(delayed_work, struct batadv_priv_dat, work);
|
|
|
|
bat_priv = container_of(priv_dat, struct batadv_priv, dat);
|
|
|
|
|
|
|
|
__batadv_dat_purge(bat_priv, batadv_dat_to_purge);
|
|
|
|
batadv_dat_start_timer(bat_priv);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_compare_dat() - comparing function used in the local DAT hash table
|
2012-06-30 22:01:19 +04:00
|
|
|
* @node: node in the local table
|
|
|
|
* @data2: second object to compare the node to
|
|
|
|
*
|
2016-02-22 23:02:39 +03:00
|
|
|
* Return: true if the two entries are the same, false otherwise.
|
2012-06-30 22:01:19 +04:00
|
|
|
*/
|
2016-02-22 23:02:39 +03:00
|
|
|
static bool batadv_compare_dat(const struct hlist_node *node, const void *data2)
|
2012-06-30 22:01:19 +04:00
|
|
|
{
|
|
|
|
const void *data1 = container_of(node, struct batadv_dat_entry,
|
|
|
|
hash_entry);
|
|
|
|
|
2016-02-22 23:02:39 +03:00
|
|
|
return memcmp(data1, data2, sizeof(__be32)) == 0;
|
2012-06-30 22:01:19 +04:00
|
|
|
}
|
|
|
|
|
2011-06-02 14:29:51 +04:00
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_arp_hw_src() - extract the hw_src field from an ARP packet
|
2011-06-02 14:29:51 +04:00
|
|
|
* @skb: ARP packet
|
|
|
|
* @hdr_size: size of the possible header before the ARP packet
|
|
|
|
*
|
2015-09-15 20:00:48 +03:00
|
|
|
* Return: the value of the hw_src field in the ARP packet.
|
2011-06-02 14:29:51 +04:00
|
|
|
*/
|
2015-05-26 19:34:26 +03:00
|
|
|
static u8 *batadv_arp_hw_src(struct sk_buff *skb, int hdr_size)
|
2011-06-02 14:29:51 +04:00
|
|
|
{
|
2015-05-26 19:34:26 +03:00
|
|
|
u8 *addr;
|
2011-06-02 14:29:51 +04:00
|
|
|
|
2015-05-26 19:34:26 +03:00
|
|
|
addr = (u8 *)(skb->data + hdr_size);
|
2011-06-02 14:29:51 +04:00
|
|
|
addr += ETH_HLEN + sizeof(struct arphdr);
|
|
|
|
|
|
|
|
return addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_arp_ip_src() - extract the ip_src field from an ARP packet
|
2011-06-02 14:29:51 +04:00
|
|
|
* @skb: ARP packet
|
|
|
|
* @hdr_size: size of the possible header before the ARP packet
|
|
|
|
*
|
2015-09-15 20:00:48 +03:00
|
|
|
* Return: the value of the ip_src field in the ARP packet.
|
2011-06-02 14:29:51 +04:00
|
|
|
*/
|
|
|
|
static __be32 batadv_arp_ip_src(struct sk_buff *skb, int hdr_size)
|
|
|
|
{
|
|
|
|
return *(__be32 *)(batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_arp_hw_dst() - extract the hw_dst field from an ARP packet
|
2011-06-02 14:29:51 +04:00
|
|
|
* @skb: ARP packet
|
|
|
|
* @hdr_size: size of the possible header before the ARP packet
|
|
|
|
*
|
2015-09-15 20:00:48 +03:00
|
|
|
* Return: the value of the hw_dst field in the ARP packet.
|
2011-06-02 14:29:51 +04:00
|
|
|
*/
|
2015-05-26 19:34:26 +03:00
|
|
|
static u8 *batadv_arp_hw_dst(struct sk_buff *skb, int hdr_size)
|
2011-06-02 14:29:51 +04:00
|
|
|
{
|
|
|
|
return batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN + 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_arp_ip_dst() - extract the ip_dst field from an ARP packet
|
2011-06-02 14:29:51 +04:00
|
|
|
* @skb: ARP packet
|
|
|
|
* @hdr_size: size of the possible header before the ARP packet
|
|
|
|
*
|
2015-09-15 20:00:48 +03:00
|
|
|
* Return: the value of the ip_dst field in the ARP packet.
|
2011-06-02 14:29:51 +04:00
|
|
|
*/
|
|
|
|
static __be32 batadv_arp_ip_dst(struct sk_buff *skb, int hdr_size)
|
|
|
|
{
|
|
|
|
return *(__be32 *)(batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN * 2 + 4);
|
|
|
|
}
|
|
|
|
|
2011-11-23 14:35:44 +04:00
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_hash_dat() - compute the hash value for an IP address
|
2011-11-23 14:35:44 +04:00
|
|
|
* @data: data to hash
|
|
|
|
* @size: size of the hash table
|
|
|
|
*
|
2015-09-15 20:00:48 +03:00
|
|
|
* Return: the selected index in the hash table for the given data.
|
2011-11-23 14:35:44 +04:00
|
|
|
*/
|
2015-05-26 19:34:26 +03:00
|
|
|
static u32 batadv_hash_dat(const void *data, u32 size)
|
2011-11-23 14:35:44 +04:00
|
|
|
{
|
2015-05-26 19:34:26 +03:00
|
|
|
u32 hash = 0;
|
2013-06-04 14:11:43 +04:00
|
|
|
const struct batadv_dat_entry *dat = data;
|
2015-03-01 11:46:18 +03:00
|
|
|
const unsigned char *key;
|
2015-05-26 19:34:26 +03:00
|
|
|
u32 i;
|
2015-03-01 11:46:18 +03:00
|
|
|
|
|
|
|
key = (const unsigned char *)&dat->ip;
|
|
|
|
for (i = 0; i < sizeof(dat->ip); i++) {
|
|
|
|
hash += key[i];
|
|
|
|
hash += (hash << 10);
|
|
|
|
hash ^= (hash >> 6);
|
|
|
|
}
|
2011-11-23 14:35:44 +04:00
|
|
|
|
2015-03-01 11:46:18 +03:00
|
|
|
key = (const unsigned char *)&dat->vid;
|
|
|
|
for (i = 0; i < sizeof(dat->vid); i++) {
|
|
|
|
hash += key[i];
|
|
|
|
hash += (hash << 10);
|
|
|
|
hash ^= (hash >> 6);
|
|
|
|
}
|
2011-11-23 14:35:44 +04:00
|
|
|
|
|
|
|
hash += (hash << 3);
|
|
|
|
hash ^= (hash >> 11);
|
|
|
|
hash += (hash << 15);
|
|
|
|
|
|
|
|
return hash % size;
|
|
|
|
}
|
|
|
|
|
2012-06-30 22:01:19 +04:00
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_dat_entry_hash_find() - look for a given dat_entry in the local hash
|
2012-06-30 22:01:19 +04:00
|
|
|
* table
|
|
|
|
* @bat_priv: the bat priv with all the soft interface information
|
|
|
|
* @ip: search key
|
2013-06-04 14:11:43 +04:00
|
|
|
* @vid: VLAN identifier
|
2012-06-30 22:01:19 +04:00
|
|
|
*
|
2015-09-15 20:00:48 +03:00
|
|
|
* Return: the dat_entry if found, NULL otherwise.
|
2012-06-30 22:01:19 +04:00
|
|
|
*/
|
|
|
|
static struct batadv_dat_entry *
|
2013-06-04 14:11:43 +04:00
|
|
|
batadv_dat_entry_hash_find(struct batadv_priv *bat_priv, __be32 ip,
|
|
|
|
unsigned short vid)
|
2012-06-30 22:01:19 +04:00
|
|
|
{
|
|
|
|
struct hlist_head *head;
|
2013-06-04 14:11:43 +04:00
|
|
|
struct batadv_dat_entry to_find, *dat_entry, *dat_entry_tmp = NULL;
|
2012-06-30 22:01:19 +04:00
|
|
|
struct batadv_hashtable *hash = bat_priv->dat.hash;
|
2015-05-26 19:34:26 +03:00
|
|
|
u32 index;
|
2012-06-30 22:01:19 +04:00
|
|
|
|
|
|
|
if (!hash)
|
|
|
|
return NULL;
|
|
|
|
|
2013-06-04 14:11:43 +04:00
|
|
|
to_find.ip = ip;
|
|
|
|
to_find.vid = vid;
|
|
|
|
|
|
|
|
index = batadv_hash_dat(&to_find, hash->size);
|
2012-06-30 22:01:19 +04:00
|
|
|
head = &hash->table[index];
|
|
|
|
|
|
|
|
rcu_read_lock();
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 05:06:00 +04:00
|
|
|
hlist_for_each_entry_rcu(dat_entry, head, hash_entry) {
|
2012-06-30 22:01:19 +04:00
|
|
|
if (dat_entry->ip != ip)
|
|
|
|
continue;
|
|
|
|
|
2016-01-16 12:29:47 +03:00
|
|
|
if (!kref_get_unless_zero(&dat_entry->refcount))
|
2012-06-30 22:01:19 +04:00
|
|
|
continue;
|
|
|
|
|
|
|
|
dat_entry_tmp = dat_entry;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
return dat_entry_tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_dat_entry_add() - add a new dat entry or update it if already exists
|
2012-06-30 22:01:19 +04:00
|
|
|
* @bat_priv: the bat priv with all the soft interface information
|
|
|
|
* @ip: ipv4 to add/edit
|
|
|
|
* @mac_addr: mac address to assign to the given ipv4
|
2013-06-04 14:11:43 +04:00
|
|
|
* @vid: VLAN identifier
|
2012-06-30 22:01:19 +04:00
|
|
|
*/
|
|
|
|
static void batadv_dat_entry_add(struct batadv_priv *bat_priv, __be32 ip,
|
2015-05-26 19:34:26 +03:00
|
|
|
u8 *mac_addr, unsigned short vid)
|
2012-06-30 22:01:19 +04:00
|
|
|
{
|
|
|
|
struct batadv_dat_entry *dat_entry;
|
|
|
|
int hash_added;
|
|
|
|
|
2013-06-04 14:11:43 +04:00
|
|
|
dat_entry = batadv_dat_entry_hash_find(bat_priv, ip, vid);
|
2012-06-30 22:01:19 +04:00
|
|
|
/* if this entry is already known, just update it */
|
|
|
|
if (dat_entry) {
|
|
|
|
if (!batadv_compare_eth(dat_entry->mac_addr, mac_addr))
|
2014-01-22 03:42:11 +04:00
|
|
|
ether_addr_copy(dat_entry->mac_addr, mac_addr);
|
2012-06-30 22:01:19 +04:00
|
|
|
dat_entry->last_update = jiffies;
|
|
|
|
batadv_dbg(BATADV_DBG_DAT, bat_priv,
|
2013-06-04 14:11:43 +04:00
|
|
|
"Entry updated: %pI4 %pM (vid: %d)\n",
|
|
|
|
&dat_entry->ip, dat_entry->mac_addr,
|
2017-02-22 19:16:42 +03:00
|
|
|
batadv_print_vid(vid));
|
2012-06-30 22:01:19 +04:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
dat_entry = kmalloc(sizeof(*dat_entry), GFP_ATOMIC);
|
|
|
|
if (!dat_entry)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
dat_entry->ip = ip;
|
2013-06-04 14:11:43 +04:00
|
|
|
dat_entry->vid = vid;
|
2014-01-22 03:42:11 +04:00
|
|
|
ether_addr_copy(dat_entry->mac_addr, mac_addr);
|
2012-06-30 22:01:19 +04:00
|
|
|
dat_entry->last_update = jiffies;
|
2016-01-16 12:29:47 +03:00
|
|
|
kref_init(&dat_entry->refcount);
|
2012-06-30 22:01:19 +04:00
|
|
|
|
2016-07-15 18:39:26 +03:00
|
|
|
kref_get(&dat_entry->refcount);
|
2012-06-30 22:01:19 +04:00
|
|
|
hash_added = batadv_hash_add(bat_priv->dat.hash, batadv_compare_dat,
|
2013-06-04 14:11:43 +04:00
|
|
|
batadv_hash_dat, dat_entry,
|
2012-06-30 22:01:19 +04:00
|
|
|
&dat_entry->hash_entry);
|
|
|
|
|
|
|
|
if (unlikely(hash_added != 0)) {
|
|
|
|
/* remove the reference for the hash */
|
2016-01-17 13:01:17 +03:00
|
|
|
batadv_dat_entry_put(dat_entry);
|
2012-06-30 22:01:19 +04:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2013-06-04 14:11:43 +04:00
|
|
|
batadv_dbg(BATADV_DBG_DAT, bat_priv, "New entry added: %pI4 %pM (vid: %d)\n",
|
2017-02-22 19:16:42 +03:00
|
|
|
&dat_entry->ip, dat_entry->mac_addr, batadv_print_vid(vid));
|
2012-06-30 22:01:19 +04:00
|
|
|
|
|
|
|
out:
|
|
|
|
if (dat_entry)
|
2016-01-17 13:01:17 +03:00
|
|
|
batadv_dat_entry_put(dat_entry);
|
2012-06-30 22:01:19 +04:00
|
|
|
}
|
|
|
|
|
2011-06-02 14:29:51 +04:00
|
|
|
#ifdef CONFIG_BATMAN_ADV_DEBUG
|
|
|
|
|
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_dbg_arp() - print a debug message containing all the ARP packet
|
|
|
|
* details
|
2011-06-02 14:29:51 +04:00
|
|
|
* @bat_priv: the bat priv with all the soft interface information
|
|
|
|
* @skb: ARP packet
|
|
|
|
* @hdr_size: size of the possible header before the ARP packet
|
|
|
|
* @msg: message to print together with the debugging information
|
|
|
|
*/
|
|
|
|
static void batadv_dbg_arp(struct batadv_priv *bat_priv, struct sk_buff *skb,
|
2016-09-25 03:46:36 +03:00
|
|
|
int hdr_size, char *msg)
|
2011-06-02 14:29:51 +04:00
|
|
|
{
|
|
|
|
struct batadv_unicast_4addr_packet *unicast_4addr_packet;
|
|
|
|
struct batadv_bcast_packet *bcast_pkt;
|
2015-05-26 19:34:26 +03:00
|
|
|
u8 *orig_addr;
|
2011-06-02 14:29:51 +04:00
|
|
|
__be32 ip_src, ip_dst;
|
|
|
|
|
|
|
|
if (msg)
|
|
|
|
batadv_dbg(BATADV_DBG_DAT, bat_priv, "%s\n", msg);
|
|
|
|
|
|
|
|
ip_src = batadv_arp_ip_src(skb, hdr_size);
|
|
|
|
ip_dst = batadv_arp_ip_dst(skb, hdr_size);
|
|
|
|
batadv_dbg(BATADV_DBG_DAT, bat_priv,
|
|
|
|
"ARP MSG = [src: %pM-%pI4 dst: %pM-%pI4]\n",
|
|
|
|
batadv_arp_hw_src(skb, hdr_size), &ip_src,
|
|
|
|
batadv_arp_hw_dst(skb, hdr_size), &ip_dst);
|
|
|
|
|
2018-03-16 13:29:10 +03:00
|
|
|
if (hdr_size < sizeof(struct batadv_unicast_packet))
|
2011-06-02 14:29:51 +04:00
|
|
|
return;
|
|
|
|
|
|
|
|
unicast_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data;
|
|
|
|
|
2013-12-02 23:38:31 +04:00
|
|
|
switch (unicast_4addr_packet->u.packet_type) {
|
2011-06-02 14:29:51 +04:00
|
|
|
case BATADV_UNICAST:
|
|
|
|
batadv_dbg(BATADV_DBG_DAT, bat_priv,
|
|
|
|
"* encapsulated within a UNICAST packet\n");
|
|
|
|
break;
|
|
|
|
case BATADV_UNICAST_4ADDR:
|
|
|
|
batadv_dbg(BATADV_DBG_DAT, bat_priv,
|
|
|
|
"* encapsulated within a UNICAST_4ADDR packet (src: %pM)\n",
|
|
|
|
unicast_4addr_packet->src);
|
|
|
|
switch (unicast_4addr_packet->subtype) {
|
|
|
|
case BATADV_P_DAT_DHT_PUT:
|
|
|
|
batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DAT_DHT_PUT\n");
|
|
|
|
break;
|
|
|
|
case BATADV_P_DAT_DHT_GET:
|
|
|
|
batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DAT_DHT_GET\n");
|
|
|
|
break;
|
|
|
|
case BATADV_P_DAT_CACHE_REPLY:
|
|
|
|
batadv_dbg(BATADV_DBG_DAT, bat_priv,
|
|
|
|
"* type: DAT_CACHE_REPLY\n");
|
|
|
|
break;
|
|
|
|
case BATADV_P_DATA:
|
|
|
|
batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DATA\n");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: Unknown (%u)!\n",
|
2013-12-02 23:38:31 +04:00
|
|
|
unicast_4addr_packet->u.packet_type);
|
2011-06-02 14:29:51 +04:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case BATADV_BCAST:
|
|
|
|
bcast_pkt = (struct batadv_bcast_packet *)unicast_4addr_packet;
|
|
|
|
orig_addr = bcast_pkt->orig;
|
|
|
|
batadv_dbg(BATADV_DBG_DAT, bat_priv,
|
|
|
|
"* encapsulated within a BCAST packet (src: %pM)\n",
|
|
|
|
orig_addr);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
batadv_dbg(BATADV_DBG_DAT, bat_priv,
|
|
|
|
"* encapsulated within an unknown packet type (0x%x)\n",
|
2013-12-02 23:38:31 +04:00
|
|
|
unicast_4addr_packet->u.packet_type);
|
2011-06-02 14:29:51 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
static void batadv_dbg_arp(struct batadv_priv *bat_priv, struct sk_buff *skb,
|
2016-09-25 03:46:36 +03:00
|
|
|
int hdr_size, char *msg)
|
2011-06-02 14:29:51 +04:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* CONFIG_BATMAN_ADV_DEBUG */
|
|
|
|
|
2011-11-23 14:35:44 +04:00
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_is_orig_node_eligible() - check whether a node can be a DHT candidate
|
2011-11-23 14:35:44 +04:00
|
|
|
* @res: the array with the already selected candidates
|
|
|
|
* @select: number of already selected candidates
|
|
|
|
* @tmp_max: address of the currently evaluated node
|
|
|
|
* @max: current round max address
|
|
|
|
* @last_max: address of the last selected candidate
|
|
|
|
* @candidate: orig_node under evaluation
|
|
|
|
* @max_orig_node: last selected candidate
|
|
|
|
*
|
2015-09-15 20:00:48 +03:00
|
|
|
* Return: true if the node has been elected as next candidate or false
|
2013-03-10 15:29:15 +04:00
|
|
|
* otherwise.
|
2011-11-23 14:35:44 +04:00
|
|
|
*/
|
|
|
|
static bool batadv_is_orig_node_eligible(struct batadv_dat_candidate *res,
|
|
|
|
int select, batadv_dat_addr_t tmp_max,
|
|
|
|
batadv_dat_addr_t max,
|
|
|
|
batadv_dat_addr_t last_max,
|
|
|
|
struct batadv_orig_node *candidate,
|
|
|
|
struct batadv_orig_node *max_orig_node)
|
|
|
|
{
|
|
|
|
bool ret = false;
|
|
|
|
int j;
|
|
|
|
|
2013-04-23 17:39:59 +04:00
|
|
|
/* check if orig node candidate is running DAT */
|
2015-06-16 18:10:22 +03:00
|
|
|
if (!test_bit(BATADV_ORIG_CAPA_HAS_DAT, &candidate->capabilities))
|
2013-04-23 17:39:59 +04:00
|
|
|
goto out;
|
|
|
|
|
2011-11-23 14:35:44 +04:00
|
|
|
/* Check if this node has already been selected... */
|
|
|
|
for (j = 0; j < select; j++)
|
|
|
|
if (res[j].orig_node == candidate)
|
|
|
|
break;
|
|
|
|
/* ..and possibly skip it */
|
|
|
|
if (j < select)
|
|
|
|
goto out;
|
|
|
|
/* sanity check: has it already been selected? This should not happen */
|
|
|
|
if (tmp_max > last_max)
|
|
|
|
goto out;
|
|
|
|
/* check if during this iteration an originator with a closer dht
|
|
|
|
* address has already been found
|
|
|
|
*/
|
|
|
|
if (tmp_max < max)
|
|
|
|
goto out;
|
|
|
|
/* this is an hash collision with the temporary selected node. Choose
|
|
|
|
* the one with the lowest address
|
|
|
|
*/
|
2017-08-23 22:52:13 +03:00
|
|
|
if (tmp_max == max && max_orig_node &&
|
2018-02-20 14:08:10 +03:00
|
|
|
batadv_compare_eth(candidate->orig, max_orig_node->orig))
|
2011-11-23 14:35:44 +04:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = true;
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_choose_next_candidate() - select the next DHT candidate
|
2011-11-23 14:35:44 +04:00
|
|
|
* @bat_priv: the bat priv with all the soft interface information
|
|
|
|
* @cands: candidates array
|
|
|
|
* @select: number of candidates already present in the array
|
|
|
|
* @ip_key: key to look up in the DHT
|
|
|
|
* @last_max: pointer where the address of the selected candidate will be saved
|
|
|
|
*/
|
|
|
|
static void batadv_choose_next_candidate(struct batadv_priv *bat_priv,
|
|
|
|
struct batadv_dat_candidate *cands,
|
|
|
|
int select, batadv_dat_addr_t ip_key,
|
|
|
|
batadv_dat_addr_t *last_max)
|
|
|
|
{
|
2015-06-09 21:50:49 +03:00
|
|
|
batadv_dat_addr_t max = 0;
|
|
|
|
batadv_dat_addr_t tmp_max = 0;
|
2011-11-23 14:35:44 +04:00
|
|
|
struct batadv_orig_node *orig_node, *max_orig_node = NULL;
|
|
|
|
struct batadv_hashtable *hash = bat_priv->orig_hash;
|
|
|
|
struct hlist_head *head;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* if no node is eligible as candidate, leave the candidate type as
|
|
|
|
* NOT_FOUND
|
|
|
|
*/
|
|
|
|
cands[select].type = BATADV_DAT_CANDIDATE_NOT_FOUND;
|
|
|
|
|
2013-03-10 15:29:15 +04:00
|
|
|
/* iterate over the originator list and find the node with the closest
|
2011-11-23 14:35:44 +04:00
|
|
|
* dat_address which has not been selected yet
|
|
|
|
*/
|
|
|
|
for (i = 0; i < hash->size; i++) {
|
|
|
|
head = &hash->table[i];
|
|
|
|
|
|
|
|
rcu_read_lock();
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 05:06:00 +04:00
|
|
|
hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
|
2013-03-10 15:29:15 +04:00
|
|
|
/* the dht space is a ring using unsigned addresses */
|
2011-11-23 14:35:44 +04:00
|
|
|
tmp_max = BATADV_DAT_ADDR_MAX - orig_node->dat_addr +
|
|
|
|
ip_key;
|
|
|
|
|
|
|
|
if (!batadv_is_orig_node_eligible(cands, select,
|
|
|
|
tmp_max, max,
|
|
|
|
*last_max, orig_node,
|
|
|
|
max_orig_node))
|
|
|
|
continue;
|
|
|
|
|
2016-01-16 12:29:56 +03:00
|
|
|
if (!kref_get_unless_zero(&orig_node->refcount))
|
2011-11-23 14:35:44 +04:00
|
|
|
continue;
|
|
|
|
|
|
|
|
max = tmp_max;
|
|
|
|
if (max_orig_node)
|
2016-01-17 13:01:09 +03:00
|
|
|
batadv_orig_node_put(max_orig_node);
|
2011-11-23 14:35:44 +04:00
|
|
|
max_orig_node = orig_node;
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
if (max_orig_node) {
|
|
|
|
cands[select].type = BATADV_DAT_CANDIDATE_ORIG;
|
|
|
|
cands[select].orig_node = max_orig_node;
|
|
|
|
batadv_dbg(BATADV_DBG_DAT, bat_priv,
|
|
|
|
"dat_select_candidates() %d: selected %pM addr=%u dist=%u\n",
|
|
|
|
select, max_orig_node->orig, max_orig_node->dat_addr,
|
|
|
|
max);
|
|
|
|
}
|
|
|
|
*last_max = max;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_dat_select_candidates() - select the nodes which the DHT message has
|
|
|
|
* to be sent to
|
2011-11-23 14:35:44 +04:00
|
|
|
* @bat_priv: the bat priv with all the soft interface information
|
|
|
|
* @ip_dst: ipv4 to look up in the DHT
|
2016-03-12 13:12:59 +03:00
|
|
|
* @vid: VLAN identifier
|
2011-11-23 14:35:44 +04:00
|
|
|
*
|
|
|
|
* An originator O is selected if and only if its DHT_ID value is one of three
|
|
|
|
* closest values (from the LEFT, with wrap around if needed) then the hash
|
|
|
|
* value of the key. ip_dst is the key.
|
|
|
|
*
|
2015-09-15 20:00:48 +03:00
|
|
|
* Return: the candidate array of size BATADV_DAT_CANDIDATE_NUM.
|
2011-11-23 14:35:44 +04:00
|
|
|
*/
|
|
|
|
static struct batadv_dat_candidate *
|
2016-03-12 13:12:59 +03:00
|
|
|
batadv_dat_select_candidates(struct batadv_priv *bat_priv, __be32 ip_dst,
|
|
|
|
unsigned short vid)
|
2011-11-23 14:35:44 +04:00
|
|
|
{
|
|
|
|
int select;
|
|
|
|
batadv_dat_addr_t last_max = BATADV_DAT_ADDR_MAX, ip_key;
|
|
|
|
struct batadv_dat_candidate *res;
|
2015-11-03 12:05:44 +03:00
|
|
|
struct batadv_dat_entry dat;
|
2011-11-23 14:35:44 +04:00
|
|
|
|
|
|
|
if (!bat_priv->orig_hash)
|
|
|
|
return NULL;
|
|
|
|
|
2014-05-24 08:43:47 +04:00
|
|
|
res = kmalloc_array(BATADV_DAT_CANDIDATES_NUM, sizeof(*res),
|
|
|
|
GFP_ATOMIC);
|
2011-11-23 14:35:44 +04:00
|
|
|
if (!res)
|
|
|
|
return NULL;
|
|
|
|
|
2015-11-03 12:05:44 +03:00
|
|
|
dat.ip = ip_dst;
|
2016-03-12 13:12:59 +03:00
|
|
|
dat.vid = vid;
|
2015-11-03 12:05:44 +03:00
|
|
|
ip_key = (batadv_dat_addr_t)batadv_hash_dat(&dat,
|
2011-11-23 14:35:44 +04:00
|
|
|
BATADV_DAT_ADDR_MAX);
|
|
|
|
|
|
|
|
batadv_dbg(BATADV_DBG_DAT, bat_priv,
|
2017-05-19 14:02:00 +03:00
|
|
|
"%s(): IP=%pI4 hash(IP)=%u\n", __func__, &ip_dst,
|
2011-11-23 14:35:44 +04:00
|
|
|
ip_key);
|
|
|
|
|
|
|
|
for (select = 0; select < BATADV_DAT_CANDIDATES_NUM; select++)
|
|
|
|
batadv_choose_next_candidate(bat_priv, res, select, ip_key,
|
|
|
|
&last_max);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_dat_send_data() - send a payload to the selected candidates
|
2011-11-23 14:35:44 +04:00
|
|
|
* @bat_priv: the bat priv with all the soft interface information
|
|
|
|
* @skb: payload to send
|
|
|
|
* @ip: the DHT key
|
2016-03-12 13:12:59 +03:00
|
|
|
* @vid: VLAN identifier
|
2011-11-23 14:35:44 +04:00
|
|
|
* @packet_subtype: unicast4addr packet subtype to use
|
|
|
|
*
|
2013-03-10 15:29:15 +04:00
|
|
|
* This function copies the skb with pskb_copy() and is sent as unicast packet
|
|
|
|
* to each of the selected candidates.
|
2011-11-23 14:35:44 +04:00
|
|
|
*
|
2015-09-15 20:00:48 +03:00
|
|
|
* Return: true if the packet is sent to at least one candidate, false
|
2013-03-10 15:29:15 +04:00
|
|
|
* otherwise.
|
2011-11-23 14:35:44 +04:00
|
|
|
*/
|
|
|
|
static bool batadv_dat_send_data(struct batadv_priv *bat_priv,
|
|
|
|
struct sk_buff *skb, __be32 ip,
|
2016-03-12 13:12:59 +03:00
|
|
|
unsigned short vid, int packet_subtype)
|
2011-11-23 14:35:44 +04:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
bool ret = false;
|
|
|
|
int send_status;
|
|
|
|
struct batadv_neigh_node *neigh_node = NULL;
|
|
|
|
struct sk_buff *tmp_skb;
|
|
|
|
struct batadv_dat_candidate *cand;
|
|
|
|
|
2016-03-12 13:12:59 +03:00
|
|
|
cand = batadv_dat_select_candidates(bat_priv, ip, vid);
|
2011-11-23 14:35:44 +04:00
|
|
|
if (!cand)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
batadv_dbg(BATADV_DBG_DAT, bat_priv, "DHT_SEND for %pI4\n", &ip);
|
|
|
|
|
|
|
|
for (i = 0; i < BATADV_DAT_CANDIDATES_NUM; i++) {
|
|
|
|
if (cand[i].type == BATADV_DAT_CANDIDATE_NOT_FOUND)
|
|
|
|
continue;
|
|
|
|
|
2013-11-13 22:14:47 +04:00
|
|
|
neigh_node = batadv_orig_router_get(cand[i].orig_node,
|
|
|
|
BATADV_IF_DEFAULT);
|
2011-11-23 14:35:44 +04:00
|
|
|
if (!neigh_node)
|
|
|
|
goto free_orig;
|
|
|
|
|
2014-06-12 02:36:26 +04:00
|
|
|
tmp_skb = pskb_copy_for_clone(skb, GFP_ATOMIC);
|
2013-05-23 18:53:01 +04:00
|
|
|
if (!batadv_send_skb_prepare_unicast_4addr(bat_priv, tmp_skb,
|
|
|
|
cand[i].orig_node,
|
|
|
|
packet_subtype)) {
|
2011-11-23 14:35:44 +04:00
|
|
|
kfree_skb(tmp_skb);
|
|
|
|
goto free_neigh;
|
|
|
|
}
|
|
|
|
|
2016-01-16 11:40:15 +03:00
|
|
|
send_status = batadv_send_unicast_skb(tmp_skb, neigh_node);
|
2012-04-20 19:02:45 +04:00
|
|
|
if (send_status == NET_XMIT_SUCCESS) {
|
|
|
|
/* count the sent packet */
|
|
|
|
switch (packet_subtype) {
|
|
|
|
case BATADV_P_DAT_DHT_GET:
|
|
|
|
batadv_inc_counter(bat_priv,
|
|
|
|
BATADV_CNT_DAT_GET_TX);
|
|
|
|
break;
|
|
|
|
case BATADV_P_DAT_DHT_PUT:
|
|
|
|
batadv_inc_counter(bat_priv,
|
|
|
|
BATADV_CNT_DAT_PUT_TX);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-11-23 14:35:44 +04:00
|
|
|
/* packet sent to a candidate: return true */
|
|
|
|
ret = true;
|
2012-04-20 19:02:45 +04:00
|
|
|
}
|
2011-11-23 14:35:44 +04:00
|
|
|
free_neigh:
|
2016-01-17 13:01:11 +03:00
|
|
|
batadv_neigh_node_put(neigh_node);
|
2011-11-23 14:35:44 +04:00
|
|
|
free_orig:
|
2016-01-17 13:01:09 +03:00
|
|
|
batadv_orig_node_put(cand[i].orig_node);
|
2011-11-23 14:35:44 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
kfree(cand);
|
|
|
|
return ret;
|
|
|
|
}
|
2012-06-30 22:01:19 +04:00
|
|
|
|
2013-04-23 17:39:59 +04:00
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_dat_tvlv_container_update() - update the dat tvlv container after dat
|
2013-04-23 17:39:59 +04:00
|
|
|
* setting change
|
|
|
|
* @bat_priv: the bat priv with all the soft interface information
|
|
|
|
*/
|
|
|
|
static void batadv_dat_tvlv_container_update(struct batadv_priv *bat_priv)
|
|
|
|
{
|
|
|
|
char dat_mode;
|
|
|
|
|
|
|
|
dat_mode = atomic_read(&bat_priv->distributed_arp_table);
|
|
|
|
|
|
|
|
switch (dat_mode) {
|
|
|
|
case 0:
|
|
|
|
batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_DAT, 1);
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
batadv_tvlv_container_register(bat_priv, BATADV_TVLV_DAT, 1,
|
|
|
|
NULL, 0);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_dat_status_update() - update the dat tvlv container after dat
|
2013-04-23 17:39:59 +04:00
|
|
|
* setting change
|
|
|
|
* @net_dev: the soft interface net device
|
|
|
|
*/
|
|
|
|
void batadv_dat_status_update(struct net_device *net_dev)
|
|
|
|
{
|
|
|
|
struct batadv_priv *bat_priv = netdev_priv(net_dev);
|
2014-05-10 20:56:37 +04:00
|
|
|
|
2013-04-23 17:39:59 +04:00
|
|
|
batadv_dat_tvlv_container_update(bat_priv);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_dat_tvlv_ogm_handler_v1() - process incoming dat tvlv container
|
2013-04-23 17:39:59 +04:00
|
|
|
* @bat_priv: the bat priv with all the soft interface information
|
|
|
|
* @orig: the orig_node of the ogm
|
|
|
|
* @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags)
|
|
|
|
* @tvlv_value: tvlv buffer containing the gateway data
|
|
|
|
* @tvlv_value_len: tvlv buffer length
|
|
|
|
*/
|
|
|
|
static void batadv_dat_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv,
|
|
|
|
struct batadv_orig_node *orig,
|
2015-05-26 19:34:26 +03:00
|
|
|
u8 flags,
|
|
|
|
void *tvlv_value, u16 tvlv_value_len)
|
2013-04-23 17:39:59 +04:00
|
|
|
{
|
|
|
|
if (flags & BATADV_TVLV_HANDLER_OGM_CIFNOTFND)
|
2015-06-16 18:10:22 +03:00
|
|
|
clear_bit(BATADV_ORIG_CAPA_HAS_DAT, &orig->capabilities);
|
2013-04-23 17:39:59 +04:00
|
|
|
else
|
2015-06-16 18:10:22 +03:00
|
|
|
set_bit(BATADV_ORIG_CAPA_HAS_DAT, &orig->capabilities);
|
2013-04-23 17:39:59 +04:00
|
|
|
}
|
|
|
|
|
2012-06-30 22:01:19 +04:00
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_dat_hash_free() - free the local DAT hash table
|
2012-06-30 22:01:19 +04:00
|
|
|
* @bat_priv: the bat priv with all the soft interface information
|
|
|
|
*/
|
|
|
|
static void batadv_dat_hash_free(struct batadv_priv *bat_priv)
|
|
|
|
{
|
2012-08-08 20:50:57 +04:00
|
|
|
if (!bat_priv->dat.hash)
|
|
|
|
return;
|
|
|
|
|
2012-06-30 22:01:19 +04:00
|
|
|
__batadv_dat_purge(bat_priv, NULL);
|
|
|
|
|
|
|
|
batadv_hash_destroy(bat_priv->dat.hash);
|
|
|
|
|
|
|
|
bat_priv->dat.hash = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_dat_init() - initialise the DAT internals
|
2012-06-30 22:01:19 +04:00
|
|
|
* @bat_priv: the bat priv with all the soft interface information
|
2015-11-17 11:40:51 +03:00
|
|
|
*
|
|
|
|
* Return: 0 in case of success, a negative error code otherwise
|
2012-06-30 22:01:19 +04:00
|
|
|
*/
|
|
|
|
int batadv_dat_init(struct batadv_priv *bat_priv)
|
|
|
|
{
|
|
|
|
if (bat_priv->dat.hash)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
bat_priv->dat.hash = batadv_hash_new(1024);
|
|
|
|
|
|
|
|
if (!bat_priv->dat.hash)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
batadv_dat_start_timer(bat_priv);
|
|
|
|
|
2013-04-23 17:39:59 +04:00
|
|
|
batadv_tvlv_handler_register(bat_priv, batadv_dat_tvlv_ogm_handler_v1,
|
|
|
|
NULL, BATADV_TVLV_DAT, 1,
|
|
|
|
BATADV_TVLV_HANDLER_OGM_CIFNOTFND);
|
|
|
|
batadv_dat_tvlv_container_update(bat_priv);
|
2012-06-30 22:01:19 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_dat_free() - free the DAT internals
|
2012-06-30 22:01:19 +04:00
|
|
|
* @bat_priv: the bat priv with all the soft interface information
|
|
|
|
*/
|
|
|
|
void batadv_dat_free(struct batadv_priv *bat_priv)
|
|
|
|
{
|
2013-04-23 17:39:59 +04:00
|
|
|
batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_DAT, 1);
|
|
|
|
batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_DAT, 1);
|
|
|
|
|
2012-06-30 22:01:19 +04:00
|
|
|
cancel_delayed_work_sync(&bat_priv->dat.work);
|
|
|
|
|
|
|
|
batadv_dat_hash_free(bat_priv);
|
|
|
|
}
|
|
|
|
|
2016-07-16 10:31:20 +03:00
|
|
|
#ifdef CONFIG_BATMAN_ADV_DEBUGFS
|
2012-06-30 22:01:19 +04:00
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_dat_cache_seq_print_text() - print the local DAT hash table
|
2012-06-30 22:01:19 +04:00
|
|
|
* @seq: seq file to print on
|
|
|
|
* @offset: not used
|
2015-11-17 11:40:51 +03:00
|
|
|
*
|
|
|
|
* Return: always 0
|
2012-06-30 22:01:19 +04:00
|
|
|
*/
|
|
|
|
int batadv_dat_cache_seq_print_text(struct seq_file *seq, void *offset)
|
|
|
|
{
|
|
|
|
struct net_device *net_dev = (struct net_device *)seq->private;
|
|
|
|
struct batadv_priv *bat_priv = netdev_priv(net_dev);
|
|
|
|
struct batadv_hashtable *hash = bat_priv->dat.hash;
|
|
|
|
struct batadv_dat_entry *dat_entry;
|
|
|
|
struct batadv_hard_iface *primary_if;
|
|
|
|
struct hlist_head *head;
|
|
|
|
unsigned long last_seen_jiffies;
|
|
|
|
int last_seen_msecs, last_seen_secs, last_seen_mins;
|
2015-05-26 19:34:26 +03:00
|
|
|
u32 i;
|
2012-06-30 22:01:19 +04:00
|
|
|
|
|
|
|
primary_if = batadv_seq_print_text_primary_if_get(seq);
|
|
|
|
if (!primary_if)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
seq_printf(seq, "Distributed ARP Table (%s):\n", net_dev->name);
|
2016-03-12 12:30:18 +03:00
|
|
|
seq_puts(seq,
|
|
|
|
" IPv4 MAC VID last-seen\n");
|
2012-06-30 22:01:19 +04:00
|
|
|
|
|
|
|
for (i = 0; i < hash->size; i++) {
|
|
|
|
head = &hash->table[i];
|
|
|
|
|
|
|
|
rcu_read_lock();
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 05:06:00 +04:00
|
|
|
hlist_for_each_entry_rcu(dat_entry, head, hash_entry) {
|
2012-06-30 22:01:19 +04:00
|
|
|
last_seen_jiffies = jiffies - dat_entry->last_update;
|
|
|
|
last_seen_msecs = jiffies_to_msecs(last_seen_jiffies);
|
|
|
|
last_seen_mins = last_seen_msecs / 60000;
|
|
|
|
last_seen_msecs = last_seen_msecs % 60000;
|
|
|
|
last_seen_secs = last_seen_msecs / 1000;
|
|
|
|
|
2017-06-14 12:33:52 +03:00
|
|
|
seq_printf(seq, " * %15pI4 %pM %4i %6i:%02i\n",
|
2012-06-30 22:01:19 +04:00
|
|
|
&dat_entry->ip, dat_entry->mac_addr,
|
2017-02-22 19:16:42 +03:00
|
|
|
batadv_print_vid(dat_entry->vid),
|
2012-06-30 22:01:19 +04:00
|
|
|
last_seen_mins, last_seen_secs);
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
if (primary_if)
|
2016-01-17 13:01:10 +03:00
|
|
|
batadv_hardif_put(primary_if);
|
2012-06-30 22:01:19 +04:00
|
|
|
return 0;
|
|
|
|
}
|
2016-07-16 10:31:20 +03:00
|
|
|
#endif
|
2011-06-02 14:29:51 +04:00
|
|
|
|
2018-03-13 13:41:12 +03:00
|
|
|
/**
|
|
|
|
* batadv_dat_cache_dump_entry() - dump one entry of the DAT cache table to a
|
|
|
|
* netlink socket
|
|
|
|
* @msg: buffer for the message
|
|
|
|
* @portid: netlink port
|
2018-10-31 00:01:28 +03:00
|
|
|
* @cb: Control block containing additional options
|
2018-03-13 13:41:12 +03:00
|
|
|
* @dat_entry: entry to dump
|
|
|
|
*
|
|
|
|
* Return: 0 or error code.
|
|
|
|
*/
|
|
|
|
static int
|
2018-10-31 00:01:28 +03:00
|
|
|
batadv_dat_cache_dump_entry(struct sk_buff *msg, u32 portid,
|
|
|
|
struct netlink_callback *cb,
|
2018-03-13 13:41:12 +03:00
|
|
|
struct batadv_dat_entry *dat_entry)
|
|
|
|
{
|
|
|
|
int msecs;
|
|
|
|
void *hdr;
|
|
|
|
|
2018-10-31 00:01:28 +03:00
|
|
|
hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq,
|
|
|
|
&batadv_netlink_family, NLM_F_MULTI,
|
|
|
|
BATADV_CMD_GET_DAT_CACHE);
|
2018-03-13 13:41:12 +03:00
|
|
|
if (!hdr)
|
|
|
|
return -ENOBUFS;
|
|
|
|
|
2018-10-31 00:01:28 +03:00
|
|
|
genl_dump_check_consistent(cb, hdr);
|
|
|
|
|
2018-03-13 13:41:12 +03:00
|
|
|
msecs = jiffies_to_msecs(jiffies - dat_entry->last_update);
|
|
|
|
|
|
|
|
if (nla_put_in_addr(msg, BATADV_ATTR_DAT_CACHE_IP4ADDRESS,
|
|
|
|
dat_entry->ip) ||
|
|
|
|
nla_put(msg, BATADV_ATTR_DAT_CACHE_HWADDRESS, ETH_ALEN,
|
|
|
|
dat_entry->mac_addr) ||
|
|
|
|
nla_put_u16(msg, BATADV_ATTR_DAT_CACHE_VID, dat_entry->vid) ||
|
|
|
|
nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS, msecs)) {
|
|
|
|
genlmsg_cancel(msg, hdr);
|
|
|
|
return -EMSGSIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
genlmsg_end(msg, hdr);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* batadv_dat_cache_dump_bucket() - dump one bucket of the DAT cache table to
|
|
|
|
* a netlink socket
|
|
|
|
* @msg: buffer for the message
|
|
|
|
* @portid: netlink port
|
2018-10-31 00:01:28 +03:00
|
|
|
* @cb: Control block containing additional options
|
|
|
|
* @hash: hash to dump
|
|
|
|
* @bucket: bucket index to dump
|
2018-03-13 13:41:12 +03:00
|
|
|
* @idx_skip: How many entries to skip
|
|
|
|
*
|
|
|
|
* Return: 0 or error code.
|
|
|
|
*/
|
|
|
|
static int
|
2018-10-31 00:01:28 +03:00
|
|
|
batadv_dat_cache_dump_bucket(struct sk_buff *msg, u32 portid,
|
|
|
|
struct netlink_callback *cb,
|
|
|
|
struct batadv_hashtable *hash, unsigned int bucket,
|
|
|
|
int *idx_skip)
|
2018-03-13 13:41:12 +03:00
|
|
|
{
|
|
|
|
struct batadv_dat_entry *dat_entry;
|
|
|
|
int idx = 0;
|
|
|
|
|
2018-10-31 00:01:28 +03:00
|
|
|
spin_lock_bh(&hash->list_locks[bucket]);
|
|
|
|
cb->seq = atomic_read(&hash->generation) << 1 | 1;
|
|
|
|
|
|
|
|
hlist_for_each_entry(dat_entry, &hash->table[bucket], hash_entry) {
|
2018-03-13 13:41:12 +03:00
|
|
|
if (idx < *idx_skip)
|
|
|
|
goto skip;
|
|
|
|
|
2018-10-31 00:01:28 +03:00
|
|
|
if (batadv_dat_cache_dump_entry(msg, portid, cb, dat_entry)) {
|
|
|
|
spin_unlock_bh(&hash->list_locks[bucket]);
|
2018-03-13 13:41:12 +03:00
|
|
|
*idx_skip = idx;
|
|
|
|
|
|
|
|
return -EMSGSIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
skip:
|
|
|
|
idx++;
|
|
|
|
}
|
2018-10-31 00:01:28 +03:00
|
|
|
spin_unlock_bh(&hash->list_locks[bucket]);
|
2018-03-13 13:41:12 +03:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* batadv_dat_cache_dump() - dump DAT cache table to a netlink socket
|
|
|
|
* @msg: buffer for the message
|
|
|
|
* @cb: callback structure containing arguments
|
|
|
|
*
|
|
|
|
* Return: message length.
|
|
|
|
*/
|
|
|
|
int batadv_dat_cache_dump(struct sk_buff *msg, struct netlink_callback *cb)
|
|
|
|
{
|
|
|
|
struct batadv_hard_iface *primary_if = NULL;
|
|
|
|
int portid = NETLINK_CB(cb->skb).portid;
|
|
|
|
struct net *net = sock_net(cb->skb->sk);
|
|
|
|
struct net_device *soft_iface;
|
|
|
|
struct batadv_hashtable *hash;
|
|
|
|
struct batadv_priv *bat_priv;
|
|
|
|
int bucket = cb->args[0];
|
|
|
|
int idx = cb->args[1];
|
|
|
|
int ifindex;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
ifindex = batadv_netlink_get_ifindex(cb->nlh,
|
|
|
|
BATADV_ATTR_MESH_IFINDEX);
|
|
|
|
if (!ifindex)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
soft_iface = dev_get_by_index(net, ifindex);
|
|
|
|
if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
|
|
|
|
ret = -ENODEV;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
bat_priv = netdev_priv(soft_iface);
|
|
|
|
hash = bat_priv->dat.hash;
|
|
|
|
|
|
|
|
primary_if = batadv_primary_if_get_selected(bat_priv);
|
|
|
|
if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (bucket < hash->size) {
|
2018-10-31 00:01:28 +03:00
|
|
|
if (batadv_dat_cache_dump_bucket(msg, portid, cb, hash, bucket,
|
2018-03-13 13:41:12 +03:00
|
|
|
&idx))
|
|
|
|
break;
|
|
|
|
|
|
|
|
bucket++;
|
|
|
|
idx = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
cb->args[0] = bucket;
|
|
|
|
cb->args[1] = idx;
|
|
|
|
|
|
|
|
ret = msg->len;
|
|
|
|
|
|
|
|
out:
|
|
|
|
if (primary_if)
|
|
|
|
batadv_hardif_put(primary_if);
|
|
|
|
|
|
|
|
if (soft_iface)
|
|
|
|
dev_put(soft_iface);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-06-02 14:29:51 +04:00
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_arp_get_type() - parse an ARP packet and gets the type
|
2011-06-02 14:29:51 +04:00
|
|
|
* @bat_priv: the bat priv with all the soft interface information
|
|
|
|
* @skb: packet to analyse
|
|
|
|
* @hdr_size: size of the possible header before the ARP packet in the skb
|
|
|
|
*
|
2015-09-15 20:00:48 +03:00
|
|
|
* Return: the ARP type if the skb contains a valid ARP packet, 0 otherwise.
|
2011-06-02 14:29:51 +04:00
|
|
|
*/
|
2015-05-26 19:34:26 +03:00
|
|
|
static u16 batadv_arp_get_type(struct batadv_priv *bat_priv,
|
|
|
|
struct sk_buff *skb, int hdr_size)
|
2011-06-02 14:29:51 +04:00
|
|
|
{
|
|
|
|
struct arphdr *arphdr;
|
|
|
|
struct ethhdr *ethhdr;
|
|
|
|
__be32 ip_src, ip_dst;
|
2015-05-26 19:34:26 +03:00
|
|
|
u8 *hw_src, *hw_dst;
|
|
|
|
u16 type = 0;
|
2011-06-02 14:29:51 +04:00
|
|
|
|
|
|
|
/* pull the ethernet header */
|
|
|
|
if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN)))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ethhdr = (struct ethhdr *)(skb->data + hdr_size);
|
|
|
|
|
|
|
|
if (ethhdr->h_proto != htons(ETH_P_ARP))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* pull the ARP payload */
|
|
|
|
if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN +
|
|
|
|
arp_hdr_len(skb->dev))))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
arphdr = (struct arphdr *)(skb->data + hdr_size + ETH_HLEN);
|
|
|
|
|
2013-03-10 15:29:15 +04:00
|
|
|
/* check whether the ARP packet carries a valid IP information */
|
2011-06-02 14:29:51 +04:00
|
|
|
if (arphdr->ar_hrd != htons(ARPHRD_ETHER))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (arphdr->ar_pro != htons(ETH_P_IP))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (arphdr->ar_hln != ETH_ALEN)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (arphdr->ar_pln != 4)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* Check for bad reply/request. If the ARP message is not sane, DAT
|
|
|
|
* will simply ignore it
|
|
|
|
*/
|
|
|
|
ip_src = batadv_arp_ip_src(skb, hdr_size);
|
|
|
|
ip_dst = batadv_arp_ip_dst(skb, hdr_size);
|
|
|
|
if (ipv4_is_loopback(ip_src) || ipv4_is_multicast(ip_src) ||
|
2013-01-24 21:18:26 +04:00
|
|
|
ipv4_is_loopback(ip_dst) || ipv4_is_multicast(ip_dst) ||
|
|
|
|
ipv4_is_zeronet(ip_src) || ipv4_is_lbcast(ip_src) ||
|
|
|
|
ipv4_is_zeronet(ip_dst) || ipv4_is_lbcast(ip_dst))
|
2011-06-02 14:29:51 +04:00
|
|
|
goto out;
|
|
|
|
|
2013-01-24 21:18:27 +04:00
|
|
|
hw_src = batadv_arp_hw_src(skb, hdr_size);
|
|
|
|
if (is_zero_ether_addr(hw_src) || is_multicast_ether_addr(hw_src))
|
|
|
|
goto out;
|
|
|
|
|
2013-03-10 15:29:15 +04:00
|
|
|
/* don't care about the destination MAC address in ARP requests */
|
2013-01-24 21:18:27 +04:00
|
|
|
if (arphdr->ar_op != htons(ARPOP_REQUEST)) {
|
|
|
|
hw_dst = batadv_arp_hw_dst(skb, hdr_size);
|
|
|
|
if (is_zero_ether_addr(hw_dst) ||
|
|
|
|
is_multicast_ether_addr(hw_dst))
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-06-02 14:29:51 +04:00
|
|
|
type = ntohs(arphdr->ar_op);
|
|
|
|
out:
|
|
|
|
return type;
|
|
|
|
}
|
2011-06-26 05:37:18 +04:00
|
|
|
|
2013-06-04 14:11:43 +04:00
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_dat_get_vid() - extract the VLAN identifier from skb if any
|
2013-06-04 14:11:43 +04:00
|
|
|
* @skb: the buffer containing the packet to extract the VID from
|
|
|
|
* @hdr_size: the size of the batman-adv header encapsulating the packet
|
|
|
|
*
|
2015-09-15 20:00:48 +03:00
|
|
|
* Return: If the packet embedded in the skb is vlan tagged this function
|
|
|
|
* returns the VID with the BATADV_VLAN_HAS_TAG flag. Otherwise BATADV_NO_FLAGS
|
|
|
|
* is returned.
|
2013-06-04 14:11:43 +04:00
|
|
|
*/
|
|
|
|
static unsigned short batadv_dat_get_vid(struct sk_buff *skb, int *hdr_size)
|
|
|
|
{
|
|
|
|
unsigned short vid;
|
|
|
|
|
|
|
|
vid = batadv_get_vid(skb, *hdr_size);
|
|
|
|
|
|
|
|
/* ARP parsing functions jump forward of hdr_size + ETH_HLEN.
|
|
|
|
* If the header contained in the packet is a VLAN one (which is longer)
|
|
|
|
* hdr_size is updated so that the functions will still skip the
|
|
|
|
* correct amount of bytes.
|
|
|
|
*/
|
|
|
|
if (vid & BATADV_VLAN_HAS_TAG)
|
|
|
|
*hdr_size += VLAN_HLEN;
|
|
|
|
|
|
|
|
return vid;
|
|
|
|
}
|
|
|
|
|
2016-07-05 21:01:36 +03:00
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_dat_arp_create_reply() - create an ARP Reply
|
2016-07-05 21:01:36 +03:00
|
|
|
* @bat_priv: the bat priv with all the soft interface information
|
|
|
|
* @ip_src: ARP sender IP
|
|
|
|
* @ip_dst: ARP target IP
|
|
|
|
* @hw_src: Ethernet source and ARP sender MAC
|
|
|
|
* @hw_dst: Ethernet destination and ARP target MAC
|
|
|
|
* @vid: VLAN identifier (optional, set to zero otherwise)
|
|
|
|
*
|
|
|
|
* Creates an ARP Reply from the given values, optionally encapsulated in a
|
|
|
|
* VLAN header.
|
|
|
|
*
|
|
|
|
* Return: An skb containing an ARP Reply.
|
|
|
|
*/
|
|
|
|
static struct sk_buff *
|
|
|
|
batadv_dat_arp_create_reply(struct batadv_priv *bat_priv, __be32 ip_src,
|
|
|
|
__be32 ip_dst, u8 *hw_src, u8 *hw_dst,
|
|
|
|
unsigned short vid)
|
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
|
|
|
skb = arp_create(ARPOP_REPLY, ETH_P_ARP, ip_dst, bat_priv->soft_iface,
|
|
|
|
ip_src, hw_dst, hw_src, hw_dst);
|
|
|
|
if (!skb)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
skb_reset_mac_header(skb);
|
|
|
|
|
|
|
|
if (vid & BATADV_VLAN_HAS_TAG)
|
|
|
|
skb = vlan_insert_tag(skb, htons(ETH_P_8021Q),
|
|
|
|
vid & VLAN_VID_MASK);
|
|
|
|
|
|
|
|
return skb;
|
|
|
|
}
|
|
|
|
|
2011-06-26 05:37:18 +04:00
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_dat_snoop_outgoing_arp_request() - snoop the ARP request and try to
|
2011-06-26 05:37:18 +04:00
|
|
|
* answer using DAT
|
|
|
|
* @bat_priv: the bat priv with all the soft interface information
|
|
|
|
* @skb: packet to check
|
|
|
|
*
|
2015-09-15 20:00:48 +03:00
|
|
|
* Return: true if the message has been sent to the dht candidates, false
|
2013-03-10 15:29:15 +04:00
|
|
|
* otherwise. In case of a positive return value the message has to be enqueued
|
|
|
|
* to permit the fallback.
|
2011-06-26 05:37:18 +04:00
|
|
|
*/
|
|
|
|
bool batadv_dat_snoop_outgoing_arp_request(struct batadv_priv *bat_priv,
|
|
|
|
struct sk_buff *skb)
|
|
|
|
{
|
2015-05-26 19:34:26 +03:00
|
|
|
u16 type = 0;
|
2011-06-26 05:37:18 +04:00
|
|
|
__be32 ip_dst, ip_src;
|
2015-05-26 19:34:26 +03:00
|
|
|
u8 *hw_src;
|
2011-06-26 05:37:18 +04:00
|
|
|
bool ret = false;
|
|
|
|
struct batadv_dat_entry *dat_entry = NULL;
|
|
|
|
struct sk_buff *skb_new;
|
2017-04-05 14:46:31 +03:00
|
|
|
struct net_device *soft_iface = bat_priv->soft_iface;
|
2013-06-04 14:11:43 +04:00
|
|
|
int hdr_size = 0;
|
|
|
|
unsigned short vid;
|
2011-06-26 05:37:18 +04:00
|
|
|
|
2012-08-08 20:50:57 +04:00
|
|
|
if (!atomic_read(&bat_priv->distributed_arp_table))
|
|
|
|
goto out;
|
|
|
|
|
2013-06-04 14:11:43 +04:00
|
|
|
vid = batadv_dat_get_vid(skb, &hdr_size);
|
|
|
|
|
|
|
|
type = batadv_arp_get_type(bat_priv, skb, hdr_size);
|
2011-06-26 05:37:18 +04:00
|
|
|
/* If the node gets an ARP_REQUEST it has to send a DHT_GET unicast
|
|
|
|
* message to the selected DHT candidates
|
|
|
|
*/
|
|
|
|
if (type != ARPOP_REQUEST)
|
|
|
|
goto out;
|
|
|
|
|
2016-09-25 03:46:36 +03:00
|
|
|
batadv_dbg_arp(bat_priv, skb, hdr_size, "Parsing outgoing ARP REQUEST");
|
2011-06-26 05:37:18 +04:00
|
|
|
|
2013-06-04 14:11:43 +04:00
|
|
|
ip_src = batadv_arp_ip_src(skb, hdr_size);
|
|
|
|
hw_src = batadv_arp_hw_src(skb, hdr_size);
|
|
|
|
ip_dst = batadv_arp_ip_dst(skb, hdr_size);
|
2011-06-26 05:37:18 +04:00
|
|
|
|
2013-06-04 14:11:43 +04:00
|
|
|
batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
|
2011-06-26 05:37:18 +04:00
|
|
|
|
2013-06-04 14:11:43 +04:00
|
|
|
dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid);
|
2011-06-26 05:37:18 +04:00
|
|
|
if (dat_entry) {
|
2013-05-09 11:35:45 +04:00
|
|
|
/* If the ARP request is destined for a local client the local
|
|
|
|
* client will answer itself. DAT would only generate a
|
|
|
|
* duplicate packet.
|
|
|
|
*
|
|
|
|
* Moreover, if the soft-interface is enslaved into a bridge, an
|
|
|
|
* additional DAT answer may trigger kernel warnings about
|
|
|
|
* a packet coming from the wrong port.
|
|
|
|
*/
|
2014-03-29 20:27:38 +04:00
|
|
|
if (batadv_is_my_client(bat_priv, dat_entry->mac_addr, vid)) {
|
2013-05-09 11:35:45 +04:00
|
|
|
ret = true;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2016-09-05 14:20:25 +03:00
|
|
|
/* If BLA is enabled, only send ARP replies if we have claimed
|
|
|
|
* the destination for the ARP request or if no one else of
|
|
|
|
* the backbone gws belonging to our backbone has claimed the
|
|
|
|
* destination.
|
|
|
|
*/
|
|
|
|
if (!batadv_bla_check_claim(bat_priv,
|
|
|
|
dat_entry->mac_addr, vid)) {
|
|
|
|
batadv_dbg(BATADV_DBG_DAT, bat_priv,
|
|
|
|
"Device %pM claimed by another backbone gw. Don't send ARP reply!",
|
|
|
|
dat_entry->mac_addr);
|
|
|
|
ret = true;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2016-07-05 21:01:36 +03:00
|
|
|
skb_new = batadv_dat_arp_create_reply(bat_priv, ip_dst, ip_src,
|
|
|
|
dat_entry->mac_addr,
|
|
|
|
hw_src, vid);
|
2011-06-26 05:37:18 +04:00
|
|
|
if (!skb_new)
|
|
|
|
goto out;
|
|
|
|
|
2017-04-05 14:46:31 +03:00
|
|
|
skb_new->protocol = eth_type_trans(skb_new, soft_iface);
|
|
|
|
|
2017-04-05 17:26:17 +03:00
|
|
|
batadv_inc_counter(bat_priv, BATADV_CNT_RX);
|
|
|
|
batadv_add_counter(bat_priv, BATADV_CNT_RX_BYTES,
|
|
|
|
skb->len + ETH_HLEN + hdr_size);
|
2011-06-26 05:37:18 +04:00
|
|
|
|
|
|
|
netif_rx(skb_new);
|
|
|
|
batadv_dbg(BATADV_DBG_DAT, bat_priv, "ARP request replied locally\n");
|
|
|
|
ret = true;
|
|
|
|
} else {
|
2013-03-10 15:29:15 +04:00
|
|
|
/* Send the request to the DHT */
|
2016-03-12 13:12:59 +03:00
|
|
|
ret = batadv_dat_send_data(bat_priv, skb, ip_dst, vid,
|
2011-06-26 05:37:18 +04:00
|
|
|
BATADV_P_DAT_DHT_GET);
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
if (dat_entry)
|
2016-01-17 13:01:17 +03:00
|
|
|
batadv_dat_entry_put(dat_entry);
|
2011-06-26 05:37:18 +04:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_dat_snoop_incoming_arp_request() - snoop the ARP request and try to
|
2011-06-26 05:37:18 +04:00
|
|
|
* answer using the local DAT storage
|
|
|
|
* @bat_priv: the bat priv with all the soft interface information
|
|
|
|
* @skb: packet to check
|
|
|
|
* @hdr_size: size of the encapsulation header
|
|
|
|
*
|
2015-09-15 20:00:48 +03:00
|
|
|
* Return: true if the request has been answered, false otherwise.
|
2011-06-26 05:37:18 +04:00
|
|
|
*/
|
|
|
|
bool batadv_dat_snoop_incoming_arp_request(struct batadv_priv *bat_priv,
|
|
|
|
struct sk_buff *skb, int hdr_size)
|
|
|
|
{
|
2015-05-26 19:34:26 +03:00
|
|
|
u16 type;
|
2011-06-26 05:37:18 +04:00
|
|
|
__be32 ip_src, ip_dst;
|
2015-05-26 19:34:26 +03:00
|
|
|
u8 *hw_src;
|
2011-06-26 05:37:18 +04:00
|
|
|
struct sk_buff *skb_new;
|
|
|
|
struct batadv_dat_entry *dat_entry = NULL;
|
|
|
|
bool ret = false;
|
2013-06-04 14:11:43 +04:00
|
|
|
unsigned short vid;
|
2011-06-26 05:37:18 +04:00
|
|
|
int err;
|
|
|
|
|
2012-08-08 20:50:57 +04:00
|
|
|
if (!atomic_read(&bat_priv->distributed_arp_table))
|
|
|
|
goto out;
|
|
|
|
|
2013-06-04 14:11:43 +04:00
|
|
|
vid = batadv_dat_get_vid(skb, &hdr_size);
|
|
|
|
|
2011-06-26 05:37:18 +04:00
|
|
|
type = batadv_arp_get_type(bat_priv, skb, hdr_size);
|
|
|
|
if (type != ARPOP_REQUEST)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
hw_src = batadv_arp_hw_src(skb, hdr_size);
|
|
|
|
ip_src = batadv_arp_ip_src(skb, hdr_size);
|
|
|
|
ip_dst = batadv_arp_ip_dst(skb, hdr_size);
|
|
|
|
|
2016-09-25 03:46:36 +03:00
|
|
|
batadv_dbg_arp(bat_priv, skb, hdr_size, "Parsing incoming ARP REQUEST");
|
2011-06-26 05:37:18 +04:00
|
|
|
|
2013-06-04 14:11:43 +04:00
|
|
|
batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
|
2011-06-26 05:37:18 +04:00
|
|
|
|
2013-06-04 14:11:43 +04:00
|
|
|
dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid);
|
2011-06-26 05:37:18 +04:00
|
|
|
if (!dat_entry)
|
|
|
|
goto out;
|
|
|
|
|
2016-07-05 21:01:36 +03:00
|
|
|
skb_new = batadv_dat_arp_create_reply(bat_priv, ip_dst, ip_src,
|
|
|
|
dat_entry->mac_addr, hw_src, vid);
|
2011-06-26 05:37:18 +04:00
|
|
|
if (!skb_new)
|
|
|
|
goto out;
|
|
|
|
|
2013-03-10 15:29:15 +04:00
|
|
|
/* To preserve backwards compatibility, the node has choose the outgoing
|
|
|
|
* format based on the incoming request packet type. The assumption is
|
|
|
|
* that a node not using the 4addr packet format doesn't support it.
|
2011-06-26 05:37:18 +04:00
|
|
|
*/
|
|
|
|
if (hdr_size == sizeof(struct batadv_unicast_4addr_packet))
|
2013-07-03 12:40:00 +04:00
|
|
|
err = batadv_send_skb_via_tt_4addr(bat_priv, skb_new,
|
|
|
|
BATADV_P_DAT_CACHE_REPLY,
|
2013-11-05 22:31:08 +04:00
|
|
|
NULL, vid);
|
2011-06-26 05:37:18 +04:00
|
|
|
else
|
2013-11-05 22:31:08 +04:00
|
|
|
err = batadv_send_skb_via_tt(bat_priv, skb_new, NULL, vid);
|
2011-06-26 05:37:18 +04:00
|
|
|
|
2013-07-03 12:40:00 +04:00
|
|
|
if (err != NET_XMIT_DROP) {
|
2012-04-20 19:02:45 +04:00
|
|
|
batadv_inc_counter(bat_priv, BATADV_CNT_DAT_CACHED_REPLY_TX);
|
2011-06-26 05:37:18 +04:00
|
|
|
ret = true;
|
2012-04-20 19:02:45 +04:00
|
|
|
}
|
2011-06-26 05:37:18 +04:00
|
|
|
out:
|
|
|
|
if (dat_entry)
|
2016-01-17 13:01:17 +03:00
|
|
|
batadv_dat_entry_put(dat_entry);
|
2011-06-26 05:37:18 +04:00
|
|
|
if (ret)
|
|
|
|
kfree_skb(skb);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_dat_snoop_outgoing_arp_reply() - snoop the ARP reply and fill the DHT
|
2011-06-26 05:37:18 +04:00
|
|
|
* @bat_priv: the bat priv with all the soft interface information
|
|
|
|
* @skb: packet to check
|
|
|
|
*/
|
|
|
|
void batadv_dat_snoop_outgoing_arp_reply(struct batadv_priv *bat_priv,
|
|
|
|
struct sk_buff *skb)
|
|
|
|
{
|
2015-05-26 19:34:26 +03:00
|
|
|
u16 type;
|
2011-06-26 05:37:18 +04:00
|
|
|
__be32 ip_src, ip_dst;
|
2015-05-26 19:34:26 +03:00
|
|
|
u8 *hw_src, *hw_dst;
|
2013-06-04 14:11:43 +04:00
|
|
|
int hdr_size = 0;
|
|
|
|
unsigned short vid;
|
2011-06-26 05:37:18 +04:00
|
|
|
|
2012-08-08 20:50:57 +04:00
|
|
|
if (!atomic_read(&bat_priv->distributed_arp_table))
|
|
|
|
return;
|
|
|
|
|
2013-06-04 14:11:43 +04:00
|
|
|
vid = batadv_dat_get_vid(skb, &hdr_size);
|
|
|
|
|
|
|
|
type = batadv_arp_get_type(bat_priv, skb, hdr_size);
|
2011-06-26 05:37:18 +04:00
|
|
|
if (type != ARPOP_REPLY)
|
|
|
|
return;
|
|
|
|
|
2016-09-25 03:46:36 +03:00
|
|
|
batadv_dbg_arp(bat_priv, skb, hdr_size, "Parsing outgoing ARP REPLY");
|
2011-06-26 05:37:18 +04:00
|
|
|
|
2013-06-04 14:11:43 +04:00
|
|
|
hw_src = batadv_arp_hw_src(skb, hdr_size);
|
|
|
|
ip_src = batadv_arp_ip_src(skb, hdr_size);
|
|
|
|
hw_dst = batadv_arp_hw_dst(skb, hdr_size);
|
|
|
|
ip_dst = batadv_arp_ip_dst(skb, hdr_size);
|
2011-06-26 05:37:18 +04:00
|
|
|
|
2013-06-04 14:11:43 +04:00
|
|
|
batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
|
|
|
|
batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid);
|
2011-06-26 05:37:18 +04:00
|
|
|
|
|
|
|
/* Send the ARP reply to the candidates for both the IP addresses that
|
2013-03-10 15:29:15 +04:00
|
|
|
* the node obtained from the ARP reply
|
2011-06-26 05:37:18 +04:00
|
|
|
*/
|
2016-03-12 13:12:59 +03:00
|
|
|
batadv_dat_send_data(bat_priv, skb, ip_src, vid, BATADV_P_DAT_DHT_PUT);
|
|
|
|
batadv_dat_send_data(bat_priv, skb, ip_dst, vid, BATADV_P_DAT_DHT_PUT);
|
2011-06-26 05:37:18 +04:00
|
|
|
}
|
2014-09-01 16:37:27 +04:00
|
|
|
|
2011-06-26 05:37:18 +04:00
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_dat_snoop_incoming_arp_reply() - snoop the ARP reply and fill the
|
|
|
|
* local DAT storage only
|
2011-06-26 05:37:18 +04:00
|
|
|
* @bat_priv: the bat priv with all the soft interface information
|
|
|
|
* @skb: packet to check
|
2013-03-10 15:29:15 +04:00
|
|
|
* @hdr_size: size of the encapsulation header
|
2015-06-16 22:06:24 +03:00
|
|
|
*
|
2015-09-15 20:00:48 +03:00
|
|
|
* Return: true if the packet was snooped and consumed by DAT. False if the
|
2015-06-16 22:06:24 +03:00
|
|
|
* packet has to be delivered to the interface
|
2011-06-26 05:37:18 +04:00
|
|
|
*/
|
|
|
|
bool batadv_dat_snoop_incoming_arp_reply(struct batadv_priv *bat_priv,
|
|
|
|
struct sk_buff *skb, int hdr_size)
|
|
|
|
{
|
2016-09-05 14:20:26 +03:00
|
|
|
struct batadv_dat_entry *dat_entry = NULL;
|
2015-05-26 19:34:26 +03:00
|
|
|
u16 type;
|
2011-06-26 05:37:18 +04:00
|
|
|
__be32 ip_src, ip_dst;
|
2015-05-26 19:34:26 +03:00
|
|
|
u8 *hw_src, *hw_dst;
|
2015-06-16 22:06:24 +03:00
|
|
|
bool dropped = false;
|
2013-06-04 14:11:43 +04:00
|
|
|
unsigned short vid;
|
2011-06-26 05:37:18 +04:00
|
|
|
|
2012-08-08 20:50:57 +04:00
|
|
|
if (!atomic_read(&bat_priv->distributed_arp_table))
|
|
|
|
goto out;
|
|
|
|
|
2013-06-04 14:11:43 +04:00
|
|
|
vid = batadv_dat_get_vid(skb, &hdr_size);
|
|
|
|
|
2011-06-26 05:37:18 +04:00
|
|
|
type = batadv_arp_get_type(bat_priv, skb, hdr_size);
|
|
|
|
if (type != ARPOP_REPLY)
|
|
|
|
goto out;
|
|
|
|
|
2016-09-25 03:46:36 +03:00
|
|
|
batadv_dbg_arp(bat_priv, skb, hdr_size, "Parsing incoming ARP REPLY");
|
2011-06-26 05:37:18 +04:00
|
|
|
|
|
|
|
hw_src = batadv_arp_hw_src(skb, hdr_size);
|
|
|
|
ip_src = batadv_arp_ip_src(skb, hdr_size);
|
|
|
|
hw_dst = batadv_arp_hw_dst(skb, hdr_size);
|
|
|
|
ip_dst = batadv_arp_ip_dst(skb, hdr_size);
|
|
|
|
|
2016-09-05 14:20:26 +03:00
|
|
|
/* If ip_dst is already in cache and has the right mac address,
|
|
|
|
* drop this frame if this ARP reply is destined for us because it's
|
|
|
|
* most probably an ARP reply generated by another node of the DHT.
|
|
|
|
* We have most probably received already a reply earlier. Delivering
|
|
|
|
* this frame would lead to doubled receive of an ARP reply.
|
|
|
|
*/
|
|
|
|
dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_src, vid);
|
|
|
|
if (dat_entry && batadv_compare_eth(hw_src, dat_entry->mac_addr)) {
|
|
|
|
batadv_dbg(BATADV_DBG_DAT, bat_priv, "Doubled ARP reply removed: ARP MSG = [src: %pM-%pI4 dst: %pM-%pI4]; dat_entry: %pM-%pI4\n",
|
|
|
|
hw_src, &ip_src, hw_dst, &ip_dst,
|
|
|
|
dat_entry->mac_addr, &dat_entry->ip);
|
|
|
|
dropped = true;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-06-26 05:37:18 +04:00
|
|
|
/* Update our internal cache with both the IP addresses the node got
|
|
|
|
* within the ARP reply
|
|
|
|
*/
|
2013-06-04 14:11:43 +04:00
|
|
|
batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
|
|
|
|
batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid);
|
2011-06-26 05:37:18 +04:00
|
|
|
|
2016-09-05 14:20:26 +03:00
|
|
|
/* If BLA is enabled, only forward ARP replies if we have claimed the
|
|
|
|
* source of the ARP reply or if no one else of the same backbone has
|
|
|
|
* already claimed that client. This prevents that different gateways
|
|
|
|
* to the same backbone all forward the ARP reply leading to multiple
|
|
|
|
* replies in the backbone.
|
|
|
|
*/
|
|
|
|
if (!batadv_bla_check_claim(bat_priv, hw_src, vid)) {
|
|
|
|
batadv_dbg(BATADV_DBG_DAT, bat_priv,
|
|
|
|
"Device %pM claimed by another backbone gw. Drop ARP reply.\n",
|
|
|
|
hw_src);
|
|
|
|
dropped = true;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-06-26 05:37:18 +04:00
|
|
|
/* if this REPLY is directed to a client of mine, let's deliver the
|
|
|
|
* packet to the interface
|
|
|
|
*/
|
2015-06-16 22:06:24 +03:00
|
|
|
dropped = !batadv_is_my_client(bat_priv, hw_dst, vid);
|
|
|
|
|
|
|
|
/* if this REPLY is sent on behalf of a client of mine, let's drop the
|
|
|
|
* packet because the client will reply by itself
|
|
|
|
*/
|
|
|
|
dropped |= batadv_is_my_client(bat_priv, hw_src, vid);
|
2011-06-26 05:37:18 +04:00
|
|
|
out:
|
2015-06-16 22:06:24 +03:00
|
|
|
if (dropped)
|
2013-01-23 21:11:53 +04:00
|
|
|
kfree_skb(skb);
|
2016-09-05 14:20:26 +03:00
|
|
|
if (dat_entry)
|
|
|
|
batadv_dat_entry_put(dat_entry);
|
2015-06-16 22:06:24 +03:00
|
|
|
/* if dropped == false -> deliver to the interface */
|
|
|
|
return dropped;
|
2011-06-26 05:37:18 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-12-02 21:51:47 +03:00
|
|
|
* batadv_dat_drop_broadcast_packet() - check if an ARP request has to be
|
|
|
|
* dropped (because the node has already obtained the reply via DAT) or not
|
2011-06-26 05:37:18 +04:00
|
|
|
* @bat_priv: the bat priv with all the soft interface information
|
|
|
|
* @forw_packet: the broadcast packet
|
|
|
|
*
|
2015-09-15 20:00:48 +03:00
|
|
|
* Return: true if the node can drop the packet, false otherwise.
|
2011-06-26 05:37:18 +04:00
|
|
|
*/
|
|
|
|
bool batadv_dat_drop_broadcast_packet(struct batadv_priv *bat_priv,
|
|
|
|
struct batadv_forw_packet *forw_packet)
|
|
|
|
{
|
2015-05-26 19:34:26 +03:00
|
|
|
u16 type;
|
2011-06-26 05:37:18 +04:00
|
|
|
__be32 ip_dst;
|
|
|
|
struct batadv_dat_entry *dat_entry = NULL;
|
|
|
|
bool ret = false;
|
2013-06-04 14:11:43 +04:00
|
|
|
int hdr_size = sizeof(struct batadv_bcast_packet);
|
|
|
|
unsigned short vid;
|
2011-06-26 05:37:18 +04:00
|
|
|
|
2012-08-08 20:50:57 +04:00
|
|
|
if (!atomic_read(&bat_priv->distributed_arp_table))
|
|
|
|
goto out;
|
|
|
|
|
2011-06-26 05:37:18 +04:00
|
|
|
/* If this packet is an ARP_REQUEST and the node already has the
|
|
|
|
* information that it is going to ask, then the packet can be dropped
|
|
|
|
*/
|
2017-02-17 13:17:07 +03:00
|
|
|
if (batadv_forw_packet_is_rebroadcast(forw_packet))
|
2011-06-26 05:37:18 +04:00
|
|
|
goto out;
|
|
|
|
|
2013-06-04 14:11:43 +04:00
|
|
|
vid = batadv_dat_get_vid(forw_packet->skb, &hdr_size);
|
|
|
|
|
|
|
|
type = batadv_arp_get_type(bat_priv, forw_packet->skb, hdr_size);
|
2011-06-26 05:37:18 +04:00
|
|
|
if (type != ARPOP_REQUEST)
|
|
|
|
goto out;
|
|
|
|
|
2013-06-04 14:11:43 +04:00
|
|
|
ip_dst = batadv_arp_ip_dst(forw_packet->skb, hdr_size);
|
|
|
|
dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid);
|
2011-06-26 05:37:18 +04:00
|
|
|
/* check if the node already got this entry */
|
|
|
|
if (!dat_entry) {
|
|
|
|
batadv_dbg(BATADV_DBG_DAT, bat_priv,
|
|
|
|
"ARP Request for %pI4: fallback\n", &ip_dst);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
batadv_dbg(BATADV_DBG_DAT, bat_priv,
|
|
|
|
"ARP Request for %pI4: fallback prevented\n", &ip_dst);
|
|
|
|
ret = true;
|
|
|
|
|
|
|
|
out:
|
|
|
|
if (dat_entry)
|
2016-01-17 13:01:17 +03:00
|
|
|
batadv_dat_entry_put(dat_entry);
|
2011-06-26 05:37:18 +04:00
|
|
|
return ret;
|
|
|
|
}
|