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>

11 files changed, 102 insertions, 149 deletions

diff --git a/net/batman-adv/bat_iv_ogm.c b/net/batman-adv/bat_iv_ogm.c
index 72fe1bbf7721..a0b253ecadaf 100644
--- a/net/batman-adv/bat_iv_ogm.c
+++ b/net/batman-adv/bat_iv_ogm.c
@@ -487,7 +487,6 @@ static void batadv_iv_ogm_queue_add(struct batadv_priv *bat_priv,
          */
         struct batadv_forw_packet *forw_packet_aggr = NULL;
         struct batadv_forw_packet *forw_packet_pos = NULL;
-        struct hlist_node *tmp_node;
         struct batadv_ogm_packet *batadv_ogm_packet;
         bool direct_link;
         unsigned long max_aggregation_jiffies;
@@ -500,7 +499,7 @@ static void batadv_iv_ogm_queue_add(struct batadv_priv *bat_priv,
         spin_lock_bh(&bat_priv->forw_bat_list_lock);
         /* own packets are not to be aggregated */
         if ((atomic_read(&bat_priv->aggregated_ogms)) && (!own_packet)) {
-                hlist_for_each_entry(forw_packet_pos, tmp_node,
+                hlist_for_each_entry(forw_packet_pos,
                                      &bat_priv->forw_bat_list, list) {
                         if (batadv_iv_ogm_can_aggregate(batadv_ogm_packet,
                                                         bat_priv, packet_len,
@@ -655,7 +654,6 @@ batadv_iv_ogm_orig_update(struct batadv_priv *bat_priv,
         struct batadv_neigh_node *neigh_node = NULL, *tmp_neigh_node = NULL;
         struct batadv_neigh_node *router = NULL;
         struct batadv_orig_node *orig_node_tmp;
-        struct hlist_node *node;
         int if_num;
         uint8_t sum_orig, sum_neigh;
         uint8_t *neigh_addr;
@@ -665,7 +663,7 @@ batadv_iv_ogm_orig_update(struct batadv_priv *bat_priv,
                    "update_originator(): Searching and updating originator entry of received packet\n");
 
         rcu_read_lock();
-        hlist_for_each_entry_rcu(tmp_neigh_node, node,
+        hlist_for_each_entry_rcu(tmp_neigh_node,
                                  &orig_node->neigh_list, list) {
                 neigh_addr = tmp_neigh_node->addr;
                 if (batadv_compare_eth(neigh_addr, ethhdr->h_source) &&
@@ -801,7 +799,6 @@ static int batadv_iv_ogm_calc_tq(struct batadv_orig_node *orig_node,
 {
         struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
         struct batadv_neigh_node *neigh_node = NULL, *tmp_neigh_node;
-        struct hlist_node *node;
         uint8_t total_count;
         uint8_t orig_eq_count, neigh_rq_count, neigh_rq_inv, tq_own;
         unsigned int neigh_rq_inv_cube, neigh_rq_max_cube;
@@ -810,7 +807,7 @@ static int batadv_iv_ogm_calc_tq(struct batadv_orig_node *orig_node,
 
         /* find corresponding one hop neighbor */
         rcu_read_lock();
-        hlist_for_each_entry_rcu(tmp_neigh_node, node,
+        hlist_for_each_entry_rcu(tmp_neigh_node,
                                  &orig_neigh_node->neigh_list, list) {
                 if (!batadv_compare_eth(tmp_neigh_node->addr,
                                         orig_neigh_node->orig))
@@ -920,7 +917,6 @@ batadv_iv_ogm_update_seqnos(const struct ethhdr *ethhdr,
         struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
         struct batadv_orig_node *orig_node;
         struct batadv_neigh_node *tmp_neigh_node;
-        struct hlist_node *node;
         int is_duplicate = 0;
         int32_t seq_diff;
         int need_update = 0;
@@ -943,7 +939,7 @@ batadv_iv_ogm_update_seqnos(const struct ethhdr *ethhdr,
                 goto out;
 
         rcu_read_lock();
-        hlist_for_each_entry_rcu(tmp_neigh_node, node,
+        hlist_for_each_entry_rcu(tmp_neigh_node,
                                  &orig_node->neigh_list, list) {
                 is_duplicate |= batadv_test_bit(tmp_neigh_node->real_bits,
                                                 orig_node->last_real_seqno,
diff --git a/net/batman-adv/bridge_loop_avoidance.c b/net/batman-adv/bridge_loop_avoidance.c
index 30f46526cbbd..6a4f728680ae 100644
--- a/net/batman-adv/bridge_loop_avoidance.c
+++ b/net/batman-adv/bridge_loop_avoidance.c
@@ -144,7 +144,6 @@ static struct batadv_bla_claim
 {
         struct batadv_hashtable *hash = bat_priv->bla.claim_hash;
         struct hlist_head *head;
-        struct hlist_node *node;
         struct batadv_bla_claim *claim;
         struct batadv_bla_claim *claim_tmp = NULL;
         int index;
@@ -156,7 +155,7 @@ static struct batadv_bla_claim
         head = &hash->table[index];
 
         rcu_read_lock();
-        hlist_for_each_entry_rcu(claim, node, head, hash_entry) {
+        hlist_for_each_entry_rcu(claim, head, hash_entry) {
                 if (!batadv_compare_claim(&claim->hash_entry, data))
                         continue;
 
@@ -185,7 +184,6 @@ batadv_backbone_hash_find(struct batadv_priv *bat_priv,
 {
         struct batadv_hashtable *hash = bat_priv->bla.backbone_hash;
         struct hlist_head *head;
-        struct hlist_node *node;
         struct batadv_bla_backbone_gw search_entry, *backbone_gw;
         struct batadv_bla_backbone_gw *backbone_gw_tmp = NULL;
         int index;
@@ -200,7 +198,7 @@ batadv_backbone_hash_find(struct batadv_priv *bat_priv,
         head = &hash->table[index];
 
         rcu_read_lock();
-        hlist_for_each_entry_rcu(backbone_gw, node, head, hash_entry) {
+        hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
                 if (!batadv_compare_backbone_gw(&backbone_gw->hash_entry,
                                                 &search_entry))
                         continue;
@@ -221,7 +219,7 @@ static void
 batadv_bla_del_backbone_claims(struct batadv_bla_backbone_gw *backbone_gw)
 {
         struct batadv_hashtable *hash;
-        struct hlist_node *node, *node_tmp;
+        struct hlist_node *node_tmp;
         struct hlist_head *head;
         struct batadv_bla_claim *claim;
         int i;
@@ -236,13 +234,13 @@ batadv_bla_del_backbone_claims(struct batadv_bla_backbone_gw *backbone_gw)
                 list_lock = &hash->list_locks[i];
 
                 spin_lock_bh(list_lock);
-                hlist_for_each_entry_safe(claim, node, node_tmp,
+                hlist_for_each_entry_safe(claim, node_tmp,
                                           head, hash_entry) {
                         if (claim->backbone_gw != backbone_gw)
                                 continue;
 
                         batadv_claim_free_ref(claim);
-                        hlist_del_rcu(node);
+                        hlist_del_rcu(&claim->hash_entry);
                 }
                 spin_unlock_bh(list_lock);
         }
@@ -460,7 +458,6 @@ static void batadv_bla_answer_request(struct batadv_priv *bat_priv,
                                       struct batadv_hard_iface *primary_if,
                                       short vid)
 {
-        struct hlist_node *node;
         struct hlist_head *head;
         struct batadv_hashtable *hash;
         struct batadv_bla_claim *claim;
@@ -481,7 +478,7 @@ static void batadv_bla_answer_request(struct batadv_priv *bat_priv,
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(claim, node, head, hash_entry) {
+                hlist_for_each_entry_rcu(claim, head, hash_entry) {
                         /* only own claims are interesting */
                         if (claim->backbone_gw != backbone_gw)
                                 continue;
@@ -958,7 +955,7 @@ static int batadv_bla_process_claim(struct batadv_priv *bat_priv,
 static void batadv_bla_purge_backbone_gw(struct batadv_priv *bat_priv, int now)
 {
         struct batadv_bla_backbone_gw *backbone_gw;
-        struct hlist_node *node, *node_tmp;
+        struct hlist_node *node_tmp;
         struct hlist_head *head;
         struct batadv_hashtable *hash;
         spinlock_t *list_lock;  /* protects write access to the hash lists */
@@ -973,7 +970,7 @@ static void batadv_bla_purge_backbone_gw(struct batadv_priv *bat_priv, int now)
                 list_lock = &hash->list_locks[i];
 
                 spin_lock_bh(list_lock);
-                hlist_for_each_entry_safe(backbone_gw, node, node_tmp,
+                hlist_for_each_entry_safe(backbone_gw, node_tmp,
                                           head, hash_entry) {
                         if (now)
                                 goto purge_now;
@@ -992,7 +989,7 @@ purge_now:
 
                         batadv_bla_del_backbone_claims(backbone_gw);
 
-                        hlist_del_rcu(node);
+                        hlist_del_rcu(&backbone_gw->hash_entry);
                         batadv_backbone_gw_free_ref(backbone_gw);
                 }
                 spin_unlock_bh(list_lock);
@@ -1013,7 +1010,6 @@ static void batadv_bla_purge_claims(struct batadv_priv *bat_priv,
                                     int now)
 {
         struct batadv_bla_claim *claim;
-        struct hlist_node *node;
         struct hlist_head *head;
         struct batadv_hashtable *hash;
         int i;
@@ -1026,7 +1022,7 @@ static void batadv_bla_purge_claims(struct batadv_priv *bat_priv,
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(claim, node, head, hash_entry) {
+                hlist_for_each_entry_rcu(claim, head, hash_entry) {
                         if (now)
                                 goto purge_now;
                         if (!batadv_compare_eth(claim->backbone_gw->orig,
@@ -1062,7 +1058,6 @@ void batadv_bla_update_orig_address(struct batadv_priv *bat_priv,
                                     struct batadv_hard_iface *oldif)
 {
         struct batadv_bla_backbone_gw *backbone_gw;
-        struct hlist_node *node;
         struct hlist_head *head;
         struct batadv_hashtable *hash;
         __be16 group;
@@ -1086,7 +1081,7 @@ void batadv_bla_update_orig_address(struct batadv_priv *bat_priv,
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(backbone_gw, node, head, hash_entry) {
+                hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
                         /* own orig still holds the old value. */
                         if (!batadv_compare_eth(backbone_gw->orig,
                                                 oldif->net_dev->dev_addr))
@@ -1112,7 +1107,6 @@ static void batadv_bla_periodic_work(struct work_struct *work)
         struct delayed_work *delayed_work;
         struct batadv_priv *bat_priv;
         struct batadv_priv_bla *priv_bla;
-        struct hlist_node *node;
         struct hlist_head *head;
         struct batadv_bla_backbone_gw *backbone_gw;
         struct batadv_hashtable *hash;
@@ -1140,7 +1134,7 @@ static void batadv_bla_periodic_work(struct work_struct *work)
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(backbone_gw, node, head, hash_entry) {
+                hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
                         if (!batadv_compare_eth(backbone_gw->orig,
                                                 primary_if->net_dev->dev_addr))
                                 continue;
@@ -1322,7 +1316,6 @@ int batadv_bla_is_backbone_gw_orig(struct batadv_priv *bat_priv, uint8_t *orig)
 {
         struct batadv_hashtable *hash = bat_priv->bla.backbone_hash;
         struct hlist_head *head;
-        struct hlist_node *node;
         struct batadv_bla_backbone_gw *backbone_gw;
         int i;
 
@@ -1336,7 +1329,7 @@ int batadv_bla_is_backbone_gw_orig(struct batadv_priv *bat_priv, uint8_t *orig)
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(backbone_gw, node, head, hash_entry) {
+                hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
                         if (batadv_compare_eth(backbone_gw->orig, orig)) {
                                 rcu_read_unlock();
                                 return 1;
@@ -1607,7 +1600,6 @@ int batadv_bla_claim_table_seq_print_text(struct seq_file *seq, void *offset)
         struct batadv_hashtable *hash = bat_priv->bla.claim_hash;
         struct batadv_bla_claim *claim;
         struct batadv_hard_iface *primary_if;
-        struct hlist_node *node;
         struct hlist_head *head;
         uint32_t i;
         bool is_own;
@@ -1628,7 +1620,7 @@ int batadv_bla_claim_table_seq_print_text(struct seq_file *seq, void *offset)
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(claim, node, head, hash_entry) {
+                hlist_for_each_entry_rcu(claim, head, hash_entry) {
                         is_own = batadv_compare_eth(claim->backbone_gw->orig,
                                                     primary_addr);
                         seq_printf(seq, " * %pM on % 5d by %pM [%c] (%#.4x)\n",
@@ -1652,7 +1644,6 @@ int batadv_bla_backbone_table_seq_print_text(struct seq_file *seq, void *offset)
         struct batadv_hashtable *hash = bat_priv->bla.backbone_hash;
         struct batadv_bla_backbone_gw *backbone_gw;
         struct batadv_hard_iface *primary_if;
-        struct hlist_node *node;
         struct hlist_head *head;
         int secs, msecs;
         uint32_t i;
@@ -1674,7 +1665,7 @@ int batadv_bla_backbone_table_seq_print_text(struct seq_file *seq, void *offset)
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(backbone_gw, node, head, hash_entry) {
+                hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
                         msecs = jiffies_to_msecs(jiffies -
                                                  backbone_gw->lasttime);
                         secs = msecs / 1000;
diff --git a/net/batman-adv/distributed-arp-table.c b/net/batman-adv/distributed-arp-table.c
index 761a59002e34..d54188a112ea 100644
--- a/net/batman-adv/distributed-arp-table.c
+++ b/net/batman-adv/distributed-arp-table.c
@@ -83,7 +83,7 @@ static void __batadv_dat_purge(struct batadv_priv *bat_priv,
 {
         spinlock_t *list_lock; /* protects write access to the hash lists */
         struct batadv_dat_entry *dat_entry;
-        struct hlist_node *node, *node_tmp;
+        struct hlist_node *node_tmp;
         struct hlist_head *head;
         uint32_t i;
 
@@ -95,7 +95,7 @@ static void __batadv_dat_purge(struct batadv_priv *bat_priv,
                 list_lock = &bat_priv->dat.hash->list_locks[i];
 
                 spin_lock_bh(list_lock);
-                hlist_for_each_entry_safe(dat_entry, node, node_tmp, head,
+                hlist_for_each_entry_safe(dat_entry, node_tmp, head,
                                           hash_entry) {
                         /* if an helper function has been passed as parameter,
                          * ask it if the entry has to be purged or not
@@ -103,7 +103,7 @@ static void __batadv_dat_purge(struct batadv_priv *bat_priv,
                         if (to_purge && !to_purge(dat_entry))
                                 continue;
 
-                        hlist_del_rcu(node);
+                        hlist_del_rcu(&dat_entry->hash_entry);
                         batadv_dat_entry_free_ref(dat_entry);
                 }
                 spin_unlock_bh(list_lock);
@@ -235,7 +235,6 @@ static struct batadv_dat_entry *
 batadv_dat_entry_hash_find(struct batadv_priv *bat_priv, __be32 ip)
 {
         struct hlist_head *head;
-        struct hlist_node *node;
         struct batadv_dat_entry *dat_entry, *dat_entry_tmp = NULL;
         struct batadv_hashtable *hash = bat_priv->dat.hash;
         uint32_t index;
@@ -247,7 +246,7 @@ batadv_dat_entry_hash_find(struct batadv_priv *bat_priv, __be32 ip)
         head = &hash->table[index];
 
         rcu_read_lock();
-        hlist_for_each_entry_rcu(dat_entry, node, head, hash_entry) {
+        hlist_for_each_entry_rcu(dat_entry, head, hash_entry) {
                 if (dat_entry->ip != ip)
                         continue;
 
@@ -465,7 +464,6 @@ static void batadv_choose_next_candidate(struct batadv_priv *bat_priv,
         batadv_dat_addr_t max = 0, tmp_max = 0;
         struct batadv_orig_node *orig_node, *max_orig_node = NULL;
         struct batadv_hashtable *hash = bat_priv->orig_hash;
-        struct hlist_node *node;
         struct hlist_head *head;
         int i;
 
@@ -481,7 +479,7 @@ static void batadv_choose_next_candidate(struct batadv_priv *bat_priv,
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
+                hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
                         /* the dht space is a ring and addresses are unsigned */
                         tmp_max = BATADV_DAT_ADDR_MAX - orig_node->dat_addr +
                                   ip_key;
@@ -686,7 +684,6 @@ int batadv_dat_cache_seq_print_text(struct seq_file *seq, void *offset)
         struct batadv_hashtable *hash = bat_priv->dat.hash;
         struct batadv_dat_entry *dat_entry;
         struct batadv_hard_iface *primary_if;
-        struct hlist_node *node;
         struct hlist_head *head;
         unsigned long last_seen_jiffies;
         int last_seen_msecs, last_seen_secs, last_seen_mins;
@@ -704,7 +701,7 @@ int batadv_dat_cache_seq_print_text(struct seq_file *seq, void *offset)
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(dat_entry, node, head, hash_entry) {
+                hlist_for_each_entry_rcu(dat_entry, head, hash_entry) {
                         last_seen_jiffies = jiffies - dat_entry->last_update;
                         last_seen_msecs = jiffies_to_msecs(last_seen_jiffies);
                         last_seen_mins = last_seen_msecs / 60000;
diff --git a/net/batman-adv/gateway_client.c b/net/batman-adv/gateway_client.c
index 074107f2cfaa..34f99a46ec1d 100644
--- a/net/batman-adv/gateway_client.c
+++ b/net/batman-adv/gateway_client.c
@@ -114,7 +114,6 @@ static struct batadv_gw_node *
 batadv_gw_get_best_gw_node(struct batadv_priv *bat_priv)
 {
         struct batadv_neigh_node *router;
-        struct hlist_node *node;
         struct batadv_gw_node *gw_node, *curr_gw = NULL;
         uint32_t max_gw_factor = 0, tmp_gw_factor = 0;
         uint32_t gw_divisor;
@@ -127,7 +126,7 @@ batadv_gw_get_best_gw_node(struct batadv_priv *bat_priv)
         gw_divisor *= 64;
 
         rcu_read_lock();
-        hlist_for_each_entry_rcu(gw_node, node, &bat_priv->gw.list, list) {
+        hlist_for_each_entry_rcu(gw_node, &bat_priv->gw.list, list) {
                 if (gw_node->deleted)
                         continue;
 
@@ -344,7 +343,6 @@ void batadv_gw_node_update(struct batadv_priv *bat_priv,
                            struct batadv_orig_node *orig_node,
                            uint8_t new_gwflags)
 {
-        struct hlist_node *node;
         struct batadv_gw_node *gw_node, *curr_gw;
 
         /* Note: We don't need a NULL check here, since curr_gw never gets
@@ -355,7 +353,7 @@ void batadv_gw_node_update(struct batadv_priv *bat_priv,
         curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
 
         rcu_read_lock();
-        hlist_for_each_entry_rcu(gw_node, node, &bat_priv->gw.list, list) {
+        hlist_for_each_entry_rcu(gw_node, &bat_priv->gw.list, list) {
                 if (gw_node->orig_node != orig_node)
                         continue;
 
@@ -403,7 +401,7 @@ void batadv_gw_node_delete(struct batadv_priv *bat_priv,
 void batadv_gw_node_purge(struct batadv_priv *bat_priv)
 {
         struct batadv_gw_node *gw_node, *curr_gw;
-        struct hlist_node *node, *node_tmp;
+        struct hlist_node *node_tmp;
         unsigned long timeout = msecs_to_jiffies(2 * BATADV_PURGE_TIMEOUT);
         int do_deselect = 0;
 
@@ -411,7 +409,7 @@ void batadv_gw_node_purge(struct batadv_priv *bat_priv)
 
         spin_lock_bh(&bat_priv->gw.list_lock);
 
-        hlist_for_each_entry_safe(gw_node, node, node_tmp,
+        hlist_for_each_entry_safe(gw_node, node_tmp,
                                   &bat_priv->gw.list, list) {
                 if (((!gw_node->deleted) ||
                      (time_before(jiffies, gw_node->deleted + timeout))) &&
@@ -476,7 +474,6 @@ int batadv_gw_client_seq_print_text(struct seq_file *seq, void *offset)
         struct batadv_priv *bat_priv = netdev_priv(net_dev);
         struct batadv_hard_iface *primary_if;
         struct batadv_gw_node *gw_node;
-        struct hlist_node *node;
         int gw_count = 0;
 
         primary_if = batadv_seq_print_text_primary_if_get(seq);
@@ -490,7 +487,7 @@ int batadv_gw_client_seq_print_text(struct seq_file *seq, void *offset)
                    primary_if->net_dev->dev_addr, net_dev->name);
 
         rcu_read_lock();
-        hlist_for_each_entry_rcu(gw_node, node, &bat_priv->gw.list, list) {
+        hlist_for_each_entry_rcu(gw_node, &bat_priv->gw.list, list) {
                 if (gw_node->deleted)
                         continue;
 
diff --git a/net/batman-adv/main.c b/net/batman-adv/main.c
index 21fe6987733b..0488d70c8c35 100644
--- a/net/batman-adv/main.c
+++ b/net/batman-adv/main.c
@@ -345,9 +345,8 @@ void batadv_recv_handler_unregister(uint8_t packet_type)
 static struct batadv_algo_ops *batadv_algo_get(char *name)
 {
         struct batadv_algo_ops *bat_algo_ops = NULL, *bat_algo_ops_tmp;
-        struct hlist_node *node;
 
-        hlist_for_each_entry(bat_algo_ops_tmp, node, &batadv_algo_list, list) {
+        hlist_for_each_entry(bat_algo_ops_tmp, &batadv_algo_list, list) {
                 if (strcmp(bat_algo_ops_tmp->name, name) != 0)
                         continue;
 
@@ -411,11 +410,10 @@ out:
 int batadv_algo_seq_print_text(struct seq_file *seq, void *offset)
 {
         struct batadv_algo_ops *bat_algo_ops;
-        struct hlist_node *node;
 
         seq_printf(seq, "Available routing algorithms:\n");
 
-        hlist_for_each_entry(bat_algo_ops, node, &batadv_algo_list, list) {
+        hlist_for_each_entry(bat_algo_ops, &batadv_algo_list, list) {
                 seq_printf(seq, "%s\n", bat_algo_ops->name);
         }
 
diff --git a/net/batman-adv/originator.c b/net/batman-adv/originator.c
index 457ea445217c..96fb80b724dc 100644
--- a/net/batman-adv/originator.c
+++ b/net/batman-adv/originator.c
@@ -118,7 +118,7 @@ out:
 
 static void batadv_orig_node_free_rcu(struct rcu_head *rcu)
 {
-        struct hlist_node *node, *node_tmp;
+        struct hlist_node *node_tmp;
         struct batadv_neigh_node *neigh_node, *tmp_neigh_node;
         struct batadv_orig_node *orig_node;
 
@@ -134,7 +134,7 @@ static void batadv_orig_node_free_rcu(struct rcu_head *rcu)
         }
 
         /* for all neighbors towards this originator ... */
-        hlist_for_each_entry_safe(neigh_node, node, node_tmp,
+        hlist_for_each_entry_safe(neigh_node, node_tmp,
                                   &orig_node->neigh_list, list) {
                 hlist_del_rcu(&neigh_node->list);
                 batadv_neigh_node_free_ref(neigh_node);
@@ -161,7 +161,7 @@ void batadv_orig_node_free_ref(struct batadv_orig_node *orig_node)
 void batadv_originator_free(struct batadv_priv *bat_priv)
 {
         struct batadv_hashtable *hash = bat_priv->orig_hash;
-        struct hlist_node *node, *node_tmp;
+        struct hlist_node *node_tmp;
         struct hlist_head *head;
         spinlock_t *list_lock; /* spinlock to protect write access */
         struct batadv_orig_node *orig_node;
@@ -179,9 +179,9 @@ void batadv_originator_free(struct batadv_priv *bat_priv)
                 list_lock = &hash->list_locks[i];
 
                 spin_lock_bh(list_lock);
-                hlist_for_each_entry_safe(orig_node, node, node_tmp,
+                hlist_for_each_entry_safe(orig_node, node_tmp,
                                           head, hash_entry) {
-                        hlist_del_rcu(node);
+                        hlist_del_rcu(&orig_node->hash_entry);
                         batadv_orig_node_free_ref(orig_node);
                 }
                 spin_unlock_bh(list_lock);
@@ -274,7 +274,7 @@ batadv_purge_orig_neighbors(struct batadv_priv *bat_priv,
                             struct batadv_orig_node *orig_node,
                             struct batadv_neigh_node **best_neigh_node)
 {
-        struct hlist_node *node, *node_tmp;
+        struct hlist_node *node_tmp;
         struct batadv_neigh_node *neigh_node;
         bool neigh_purged = false;
         unsigned long last_seen;
@@ -285,7 +285,7 @@ batadv_purge_orig_neighbors(struct batadv_priv *bat_priv,
         spin_lock_bh(&orig_node->neigh_list_lock);
 
         /* for all neighbors towards this originator ... */
-        hlist_for_each_entry_safe(neigh_node, node, node_tmp,
+        hlist_for_each_entry_safe(neigh_node, node_tmp,
                                   &orig_node->neigh_list, list) {
                 last_seen = neigh_node->last_seen;
                 if_incoming = neigh_node->if_incoming;
@@ -348,7 +348,7 @@ static bool batadv_purge_orig_node(struct batadv_priv *bat_priv,
 static void _batadv_purge_orig(struct batadv_priv *bat_priv)
 {
         struct batadv_hashtable *hash = bat_priv->orig_hash;
-        struct hlist_node *node, *node_tmp;
+        struct hlist_node *node_tmp;
         struct hlist_head *head;
         spinlock_t *list_lock; /* spinlock to protect write access */
         struct batadv_orig_node *orig_node;
@@ -363,13 +363,13 @@ static void _batadv_purge_orig(struct batadv_priv *bat_priv)
                 list_lock = &hash->list_locks[i];
 
                 spin_lock_bh(list_lock);
-                hlist_for_each_entry_safe(orig_node, node, node_tmp,
+                hlist_for_each_entry_safe(orig_node, node_tmp,
                                           head, hash_entry) {
                         if (batadv_purge_orig_node(bat_priv, orig_node)) {
                                 if (orig_node->gw_flags)
                                         batadv_gw_node_delete(bat_priv,
                                                               orig_node);
-                                hlist_del_rcu(node);
+                                hlist_del_rcu(&orig_node->hash_entry);
                                 batadv_orig_node_free_ref(orig_node);
                                 continue;
                         }
@@ -408,7 +408,6 @@ int batadv_orig_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->orig_hash;
-        struct hlist_node *node, *node_tmp;
         struct hlist_head *head;
         struct batadv_hard_iface *primary_if;
         struct batadv_orig_node *orig_node;
@@ -434,7 +433,7 @@ int batadv_orig_seq_print_text(struct seq_file *seq, void *offset)
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
+                hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
                         neigh_node = batadv_orig_node_get_router(orig_node);
                         if (!neigh_node)
                                 continue;
@@ -453,7 +452,7 @@ int batadv_orig_seq_print_text(struct seq_file *seq, void *offset)
                                    neigh_node->addr,
                                    neigh_node->if_incoming->net_dev->name);
 
-                        hlist_for_each_entry_rcu(neigh_node_tmp, node_tmp,
+                        hlist_for_each_entry_rcu(neigh_node_tmp,
                                                  &orig_node->neigh_list, list) {
                                 seq_printf(seq, " %pM (%3i)",
                                            neigh_node_tmp->addr,
@@ -511,7 +510,6 @@ int batadv_orig_hash_add_if(struct batadv_hard_iface *hard_iface,
 {
         struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
         struct batadv_hashtable *hash = bat_priv->orig_hash;
-        struct hlist_node *node;
         struct hlist_head *head;
         struct batadv_orig_node *orig_node;
         uint32_t i;
@@ -524,7 +522,7 @@ int batadv_orig_hash_add_if(struct batadv_hard_iface *hard_iface,
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
+                hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
                         spin_lock_bh(&orig_node->ogm_cnt_lock);
                         ret = batadv_orig_node_add_if(orig_node, max_if_num);
                         spin_unlock_bh(&orig_node->ogm_cnt_lock);
@@ -595,7 +593,6 @@ int batadv_orig_hash_del_if(struct batadv_hard_iface *hard_iface,
 {
         struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
         struct batadv_hashtable *hash = bat_priv->orig_hash;
-        struct hlist_node *node;
         struct hlist_head *head;
         struct batadv_hard_iface *hard_iface_tmp;
         struct batadv_orig_node *orig_node;
@@ -609,7 +606,7 @@ int batadv_orig_hash_del_if(struct batadv_hard_iface *hard_iface,
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
+                hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
                         spin_lock_bh(&orig_node->ogm_cnt_lock);
                         ret = batadv_orig_node_del_if(orig_node, max_if_num,
                                                       hard_iface->if_num);
diff --git a/net/batman-adv/originator.h b/net/batman-adv/originator.h
index 286bf743e76a..7df48fa7669d 100644
--- a/net/batman-adv/originator.h
+++ b/net/batman-adv/originator.h
@@ -68,7 +68,6 @@ batadv_orig_hash_find(struct batadv_priv *bat_priv, const void *data)
 {
         struct batadv_hashtable *hash = bat_priv->orig_hash;
         struct hlist_head *head;
-        struct hlist_node *node;
         struct batadv_orig_node *orig_node, *orig_node_tmp = NULL;
         int index;
 
@@ -79,7 +78,7 @@ batadv_orig_hash_find(struct batadv_priv *bat_priv, const void *data)
         head = &hash->table[index];
 
         rcu_read_lock();
-        hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
+        hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
                 if (!batadv_compare_eth(orig_node, data))
                         continue;
 
diff --git a/net/batman-adv/routing.c b/net/batman-adv/routing.c
index 60ba03fc8390..5ee21cebbbb0 100644
--- a/net/batman-adv/routing.c
+++ b/net/batman-adv/routing.c
@@ -37,7 +37,6 @@ void batadv_slide_own_bcast_window(struct batadv_hard_iface *hard_iface)
 {
         struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
         struct batadv_hashtable *hash = bat_priv->orig_hash;
-        struct hlist_node *node;
         struct hlist_head *head;
         struct batadv_orig_node *orig_node;
         unsigned long *word;
@@ -49,7 +48,7 @@ void batadv_slide_own_bcast_window(struct batadv_hard_iface *hard_iface)
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
+                hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
                         spin_lock_bh(&orig_node->ogm_cnt_lock);
                         word_index = hard_iface->if_num * BATADV_NUM_WORDS;
                         word = &(orig_node->bcast_own[word_index]);
@@ -146,7 +145,6 @@ out:
 void batadv_bonding_candidate_add(struct batadv_orig_node *orig_node,
                                   struct batadv_neigh_node *neigh_node)
 {
-        struct hlist_node *node;
         struct batadv_neigh_node *tmp_neigh_node, *router = NULL;
         uint8_t interference_candidate = 0;
 
@@ -169,7 +167,7 @@ void batadv_bonding_candidate_add(struct batadv_orig_node *orig_node,
          * interface. If we do, we won't select this candidate because of
          * possible interference.
          */
-        hlist_for_each_entry_rcu(tmp_neigh_node, node,
+        hlist_for_each_entry_rcu(tmp_neigh_node,
                                  &orig_node->neigh_list, list) {
                 if (tmp_neigh_node == neigh_node)
                         continue;
diff --git a/net/batman-adv/send.c b/net/batman-adv/send.c
index 80ca65fc89a1..a67cffde37ae 100644
--- a/net/batman-adv/send.c
+++ b/net/batman-adv/send.c
@@ -316,7 +316,7 @@ batadv_purge_outstanding_packets(struct batadv_priv *bat_priv,
                                  const struct batadv_hard_iface *hard_iface)
 {
         struct batadv_forw_packet *forw_packet;
-        struct hlist_node *tmp_node, *safe_tmp_node;
+        struct hlist_node *safe_tmp_node;
         bool pending;
 
         if (hard_iface)
@@ -329,7 +329,7 @@ batadv_purge_outstanding_packets(struct batadv_priv *bat_priv,
 
         /* free bcast list */
         spin_lock_bh(&bat_priv->forw_bcast_list_lock);
-        hlist_for_each_entry_safe(forw_packet, tmp_node, safe_tmp_node,
+        hlist_for_each_entry_safe(forw_packet, safe_tmp_node,
                                   &bat_priv->forw_bcast_list, list) {
                 /* if purge_outstanding_packets() was called with an argument
                  * we delete only packets belonging to the given interface
@@ -355,7 +355,7 @@ batadv_purge_outstanding_packets(struct batadv_priv *bat_priv,
 
         /* free batman packet list */
         spin_lock_bh(&bat_priv->forw_bat_list_lock);
-        hlist_for_each_entry_safe(forw_packet, tmp_node, safe_tmp_node,
+        hlist_for_each_entry_safe(forw_packet, safe_tmp_node,
                                   &bat_priv->forw_bat_list, list) {
                 /* if purge_outstanding_packets() was called with an argument
                  * we delete only packets belonging to the given interface
diff --git a/net/batman-adv/translation-table.c b/net/batman-adv/translation-table.c
index d44672f4a349..98a66a021a60 100644
--- a/net/batman-adv/translation-table.c
+++ b/net/batman-adv/translation-table.c
@@ -56,7 +56,6 @@ static struct batadv_tt_common_entry *
 batadv_tt_hash_find(struct batadv_hashtable *hash, const void *data)
 {
         struct hlist_head *head;
-        struct hlist_node *node;
         struct batadv_tt_common_entry *tt_common_entry;
         struct batadv_tt_common_entry *tt_common_entry_tmp = NULL;
         uint32_t index;
@@ -68,7 +67,7 @@ batadv_tt_hash_find(struct batadv_hashtable *hash, const void *data)
         head = &hash->table[index];
 
         rcu_read_lock();
-        hlist_for_each_entry_rcu(tt_common_entry, node, head, hash_entry) {
+        hlist_for_each_entry_rcu(tt_common_entry, head, hash_entry) {
                 if (!batadv_compare_eth(tt_common_entry, data))
                         continue;
 
@@ -257,7 +256,6 @@ void batadv_tt_local_add(struct net_device *soft_iface, const uint8_t *addr,
         struct batadv_tt_local_entry *tt_local;
         struct batadv_tt_global_entry *tt_global;
         struct hlist_head *head;
-        struct hlist_node *node;
         struct batadv_tt_orig_list_entry *orig_entry;
         int hash_added;
         bool roamed_back = false;
@@ -339,7 +337,7 @@ check_roaming:
                 /* These node are probably going to update their tt table */
                 head = &tt_global->orig_list;
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(orig_entry, node, head, list) {
+                hlist_for_each_entry_rcu(orig_entry, head, list) {
                         batadv_send_roam_adv(bat_priv, tt_global->common.addr,
                                              orig_entry->orig_node);
                 }
@@ -470,7 +468,6 @@ int batadv_tt_local_seq_print_text(struct seq_file *seq, void *offset)
         struct batadv_tt_common_entry *tt_common_entry;
         struct batadv_tt_local_entry *tt_local;
         struct batadv_hard_iface *primary_if;
-        struct hlist_node *node;
         struct hlist_head *head;
         uint32_t i;
         int last_seen_secs;
@@ -494,7 +491,7 @@ int batadv_tt_local_seq_print_text(struct seq_file *seq, void *offset)
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(tt_common_entry, node,
+                hlist_for_each_entry_rcu(tt_common_entry,
                                          head, hash_entry) {
                         tt_local = container_of(tt_common_entry,
                                                 struct batadv_tt_local_entry,
@@ -605,9 +602,9 @@ static void batadv_tt_local_purge_list(struct batadv_priv *bat_priv,
 {
         struct batadv_tt_local_entry *tt_local_entry;
         struct batadv_tt_common_entry *tt_common_entry;
-        struct hlist_node *node, *node_tmp;
+        struct hlist_node *node_tmp;
 
-        hlist_for_each_entry_safe(tt_common_entry, node, node_tmp, head,
+        hlist_for_each_entry_safe(tt_common_entry, node_tmp, head,
                                   hash_entry) {
                 tt_local_entry = container_of(tt_common_entry,
                                               struct batadv_tt_local_entry,
@@ -651,7 +648,7 @@ static void batadv_tt_local_table_free(struct batadv_priv *bat_priv)
         spinlock_t *list_lock; /* protects write access to the hash lists */
         struct batadv_tt_common_entry *tt_common_entry;
         struct batadv_tt_local_entry *tt_local;
-        struct hlist_node *node, *node_tmp;
+        struct hlist_node *node_tmp;
         struct hlist_head *head;
         uint32_t i;
 
@@ -665,9 +662,9 @@ static void batadv_tt_local_table_free(struct batadv_priv *bat_priv)
                 list_lock = &hash->list_locks[i];
 
                 spin_lock_bh(list_lock);
-                hlist_for_each_entry_safe(tt_common_entry, node, node_tmp,
+                hlist_for_each_entry_safe(tt_common_entry, node_tmp,
                                           head, hash_entry) {
-                        hlist_del_rcu(node);
+                        hlist_del_rcu(&tt_common_entry->hash_entry);
                         tt_local = container_of(tt_common_entry,
                                                 struct batadv_tt_local_entry,
                                                 common);
@@ -724,11 +721,10 @@ batadv_tt_global_orig_entry_find(const struct batadv_tt_global_entry *entry,
 {
         struct batadv_tt_orig_list_entry *tmp_orig_entry, *orig_entry = NULL;
         const struct hlist_head *head;
-        struct hlist_node *node;
 
         rcu_read_lock();
         head = &entry->orig_list;
-        hlist_for_each_entry_rcu(tmp_orig_entry, node, head, list) {
+        hlist_for_each_entry_rcu(tmp_orig_entry, head, list) {
                 if (tmp_orig_entry->orig_node != orig_node)
                         continue;
                 if (!atomic_inc_not_zero(&tmp_orig_entry->refcount))
@@ -940,12 +936,11 @@ batadv_transtable_best_orig(struct batadv_tt_global_entry *tt_global_entry)
 {
         struct batadv_neigh_node *router = NULL;
         struct hlist_head *head;
-        struct hlist_node *node;
         struct batadv_tt_orig_list_entry *orig_entry, *best_entry = NULL;
         int best_tq = 0;
 
         head = &tt_global_entry->orig_list;
-        hlist_for_each_entry_rcu(orig_entry, node, head, list) {
+        hlist_for_each_entry_rcu(orig_entry, head, list) {
                 router = batadv_orig_node_get_router(orig_entry->orig_node);
                 if (!router)
                         continue;
@@ -973,7 +968,6 @@ batadv_tt_global_print_entry(struct batadv_tt_global_entry *tt_global_entry,
                              struct seq_file *seq)
 {
         struct hlist_head *head;
-        struct hlist_node *node;
         struct batadv_tt_orig_list_entry *orig_entry, *best_entry;
         struct batadv_tt_common_entry *tt_common_entry;
         uint16_t flags;
@@ -997,7 +991,7 @@ batadv_tt_global_print_entry(struct batadv_tt_global_entry *tt_global_entry,
 
         head = &tt_global_entry->orig_list;
 
-        hlist_for_each_entry_rcu(orig_entry, node, head, list) {
+        hlist_for_each_entry_rcu(orig_entry, head, list) {
                 if (best_entry == orig_entry)
                         continue;
 
@@ -1020,7 +1014,6 @@ int batadv_tt_global_seq_print_text(struct seq_file *seq, void *offset)
         struct batadv_tt_common_entry *tt_common_entry;
         struct batadv_tt_global_entry *tt_global;
         struct batadv_hard_iface *primary_if;
-        struct hlist_node *node;
         struct hlist_head *head;
         uint32_t i;
 
@@ -1039,7 +1032,7 @@ int batadv_tt_global_seq_print_text(struct seq_file *seq, void *offset)
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(tt_common_entry, node,
+                hlist_for_each_entry_rcu(tt_common_entry,
                                          head, hash_entry) {
                         tt_global = container_of(tt_common_entry,
                                                  struct batadv_tt_global_entry,
@@ -1059,13 +1052,13 @@ static void
 batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry)
 {
         struct hlist_head *head;
-        struct hlist_node *node, *safe;
+        struct hlist_node *safe;
         struct batadv_tt_orig_list_entry *orig_entry;
 
         spin_lock_bh(&tt_global_entry->list_lock);
         head = &tt_global_entry->orig_list;
-        hlist_for_each_entry_safe(orig_entry, node, safe, head, list) {
-                hlist_del_rcu(node);
+        hlist_for_each_entry_safe(orig_entry, safe, head, list) {
+                hlist_del_rcu(&orig_entry->list);
                 batadv_tt_orig_list_entry_free_ref(orig_entry);
         }
         spin_unlock_bh(&tt_global_entry->list_lock);
@@ -1078,18 +1071,18 @@ batadv_tt_global_del_orig_entry(struct batadv_priv *bat_priv,
                                 const char *message)
 {
         struct hlist_head *head;
-        struct hlist_node *node, *safe;
+        struct hlist_node *safe;
         struct batadv_tt_orig_list_entry *orig_entry;
 
         spin_lock_bh(&tt_global_entry->list_lock);
         head = &tt_global_entry->orig_list;
-        hlist_for_each_entry_safe(orig_entry, node, safe, head, list) {
+        hlist_for_each_entry_safe(orig_entry, safe, head, list) {
                 if (orig_entry->orig_node == orig_node) {
                         batadv_dbg(BATADV_DBG_TT, bat_priv,
                                    "Deleting %pM from global tt entry %pM: %s\n",
                                    orig_node->orig,
                                    tt_global_entry->common.addr, message);
-                        hlist_del_rcu(node);
+                        hlist_del_rcu(&orig_entry->list);
                         batadv_tt_orig_list_entry_free_ref(orig_entry);
                 }
         }
@@ -1108,7 +1101,6 @@ batadv_tt_global_del_roaming(struct batadv_priv *bat_priv,
 {
         bool last_entry = true;
         struct hlist_head *head;
-        struct hlist_node *node;
         struct batadv_tt_orig_list_entry *orig_entry;
 
         /* no local entry exists, case 1:
@@ -1117,7 +1109,7 @@ batadv_tt_global_del_roaming(struct batadv_priv *bat_priv,
 
         rcu_read_lock();
         head = &tt_global_entry->orig_list;
-        hlist_for_each_entry_rcu(orig_entry, node, head, list) {
+        hlist_for_each_entry_rcu(orig_entry, head, list) {
                 if (orig_entry->orig_node != orig_node) {
                         last_entry = false;
                         break;
@@ -1202,7 +1194,7 @@ void batadv_tt_global_del_orig(struct batadv_priv *bat_priv,
         struct batadv_tt_common_entry *tt_common_entry;
         uint32_t i;
         struct batadv_hashtable *hash = bat_priv->tt.global_hash;
-        struct hlist_node *node, *safe;
+        struct hlist_node *safe;
         struct hlist_head *head;
         spinlock_t *list_lock; /* protects write access to the hash lists */
 
@@ -1214,7 +1206,7 @@ void batadv_tt_global_del_orig(struct batadv_priv *bat_priv,
                 list_lock = &hash->list_locks[i];
 
                 spin_lock_bh(list_lock);
-                hlist_for_each_entry_safe(tt_common_entry, node, safe,
+                hlist_for_each_entry_safe(tt_common_entry, safe,
                                           head, hash_entry) {
                         tt_global = container_of(tt_common_entry,
                                                  struct batadv_tt_global_entry,
@@ -1227,7 +1219,7 @@ void batadv_tt_global_del_orig(struct batadv_priv *bat_priv,
                                 batadv_dbg(BATADV_DBG_TT, bat_priv,
                                            "Deleting global tt entry %pM: %s\n",
                                            tt_global->common.addr, message);
-                                hlist_del_rcu(node);
+                                hlist_del_rcu(&tt_common_entry->hash_entry);
                                 batadv_tt_global_entry_free_ref(tt_global);
                         }
                 }
@@ -1262,7 +1254,7 @@ static void batadv_tt_global_purge(struct batadv_priv *bat_priv)
 {
         struct batadv_hashtable *hash = bat_priv->tt.global_hash;
         struct hlist_head *head;
-        struct hlist_node *node, *node_tmp;
+        struct hlist_node *node_tmp;
         spinlock_t *list_lock; /* protects write access to the hash lists */
         uint32_t i;
         char *msg = NULL;
@@ -1274,7 +1266,7 @@ static void batadv_tt_global_purge(struct batadv_priv *bat_priv)
                 list_lock = &hash->list_locks[i];
 
                 spin_lock_bh(list_lock);
-                hlist_for_each_entry_safe(tt_common, node, node_tmp, head,
+                hlist_for_each_entry_safe(tt_common, node_tmp, head,
                                           hash_entry) {
                         tt_global = container_of(tt_common,
                                                  struct batadv_tt_global_entry,
@@ -1287,7 +1279,7 @@ static void batadv_tt_global_purge(struct batadv_priv *bat_priv)
                                    "Deleting global tt entry (%pM): %s\n",
                                    tt_global->common.addr, msg);
 
-                        hlist_del_rcu(node);
+                        hlist_del_rcu(&tt_common->hash_entry);
 
                         batadv_tt_global_entry_free_ref(tt_global);
                 }
@@ -1301,7 +1293,7 @@ static void batadv_tt_global_table_free(struct batadv_priv *bat_priv)
         spinlock_t *list_lock; /* protects write access to the hash lists */
         struct batadv_tt_common_entry *tt_common_entry;
         struct batadv_tt_global_entry *tt_global;
-        struct hlist_node *node, *node_tmp;
+        struct hlist_node *node_tmp;
         struct hlist_head *head;
         uint32_t i;
 
@@ -1315,9 +1307,9 @@ static void batadv_tt_global_table_free(struct batadv_priv *bat_priv)
                 list_lock = &hash->list_locks[i];
 
                 spin_lock_bh(list_lock);
-                hlist_for_each_entry_safe(tt_common_entry, node, node_tmp,
+                hlist_for_each_entry_safe(tt_common_entry, node_tmp,
                                           head, hash_entry) {
-                        hlist_del_rcu(node);
+                        hlist_del_rcu(&tt_common_entry->hash_entry);
                         tt_global = container_of(tt_common_entry,
                                                  struct batadv_tt_global_entry,
                                                  common);
@@ -1397,7 +1389,6 @@ static uint16_t batadv_tt_global_crc(struct batadv_priv *bat_priv,
         struct batadv_hashtable *hash = bat_priv->tt.global_hash;
         struct batadv_tt_common_entry *tt_common;
         struct batadv_tt_global_entry *tt_global;
-        struct hlist_node *node;
         struct hlist_head *head;
         uint32_t i;
         int j;
@@ -1406,7 +1397,7 @@ static uint16_t batadv_tt_global_crc(struct batadv_priv *bat_priv,
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(tt_common, node, head, hash_entry) {
+                hlist_for_each_entry_rcu(tt_common, head, hash_entry) {
                         tt_global = container_of(tt_common,
                                                  struct batadv_tt_global_entry,
                                                  common);
@@ -1449,7 +1440,6 @@ static uint16_t batadv_tt_local_crc(struct batadv_priv *bat_priv)
         uint16_t total = 0, total_one;
         struct batadv_hashtable *hash = bat_priv->tt.local_hash;
         struct batadv_tt_common_entry *tt_common;
-        struct hlist_node *node;
         struct hlist_head *head;
         uint32_t i;
         int j;
@@ -1458,7 +1448,7 @@ static uint16_t batadv_tt_local_crc(struct batadv_priv *bat_priv)
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(tt_common, node, head, hash_entry) {
+                hlist_for_each_entry_rcu(tt_common, head, hash_entry) {
                         /* not yet committed clients have not to be taken into
                          * account while computing the CRC
                          */
@@ -1597,7 +1587,6 @@ batadv_tt_response_fill_table(uint16_t tt_len, uint8_t ttvn,
         struct batadv_tt_common_entry *tt_common_entry;
         struct batadv_tt_query_packet *tt_response;
         struct batadv_tt_change *tt_change;
-        struct hlist_node *node;
         struct hlist_head *head;
         struct sk_buff *skb = NULL;
         uint16_t tt_tot, tt_count;
@@ -1627,7 +1616,7 @@ batadv_tt_response_fill_table(uint16_t tt_len, uint8_t ttvn,
         for (i = 0; i < hash->size; i++) {
                 head = &hash->table[i];
 
-                hlist_for_each_entry_rcu(tt_common_entry, node,
+                hlist_for_each_entry_rcu(tt_common_entry,
                                          head, hash_entry) {
                         if (tt_count == tt_tot)
                                 break;
@@ -2307,7 +2296,6 @@ static uint16_t batadv_tt_set_flags(struct batadv_hashtable *hash,
         uint32_t i;
         uint16_t changed_num = 0;
         struct hlist_head *head;
-        struct hlist_node *node;
         struct batadv_tt_common_entry *tt_common_entry;
 
         if (!hash)
@@ -2317,7 +2305,7 @@ static uint16_t batadv_tt_set_flags(struct batadv_hashtable *hash,
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(tt_common_entry, node,
+                hlist_for_each_entry_rcu(tt_common_entry,
                                          head, hash_entry) {
                         if (enable) {
                                 if ((tt_common_entry->flags & flags) == flags)
@@ -2342,7 +2330,7 @@ static void batadv_tt_local_purge_pending_clients(struct batadv_priv *bat_priv)
         struct batadv_hashtable *hash = bat_priv->tt.local_hash;
         struct batadv_tt_common_entry *tt_common;
         struct batadv_tt_local_entry *tt_local;
-        struct hlist_node *node, *node_tmp;
+        struct hlist_node *node_tmp;
         struct hlist_head *head;
         spinlock_t *list_lock; /* protects write access to the hash lists */
         uint32_t i;
@@ -2355,7 +2343,7 @@ static void batadv_tt_local_purge_pending_clients(struct batadv_priv *bat_priv)
                 list_lock = &hash->list_locks[i];
 
                 spin_lock_bh(list_lock);
-                hlist_for_each_entry_safe(tt_common, node, node_tmp, head,
+                hlist_for_each_entry_safe(tt_common, node_tmp, head,
                                           hash_entry) {
                         if (!(tt_common->flags & BATADV_TT_CLIENT_PENDING))
                                 continue;
@@ -2365,7 +2353,7 @@ static void batadv_tt_local_purge_pending_clients(struct batadv_priv *bat_priv)
                                    tt_common->addr);
 
                         atomic_dec(&bat_priv->tt.local_entry_num);
-                        hlist_del_rcu(node);
+                        hlist_del_rcu(&tt_common->hash_entry);
                         tt_local = container_of(tt_common,
                                                 struct batadv_tt_local_entry,
                                                 common);
diff --git a/net/batman-adv/vis.c b/net/batman-adv/vis.c
index 22d2785177d1..c053244b97bd 100644
--- a/net/batman-adv/vis.c
+++ b/net/batman-adv/vis.c
@@ -97,7 +97,6 @@ batadv_vis_hash_find(struct batadv_priv *bat_priv, const void *data)
 {
         struct batadv_hashtable *hash = bat_priv->vis.hash;
         struct hlist_head *head;
-        struct hlist_node *node;
         struct batadv_vis_info *vis_info, *vis_info_tmp = NULL;
         uint32_t index;
 
@@ -108,8 +107,8 @@ batadv_vis_hash_find(struct batadv_priv *bat_priv, const void *data)
         head = &hash->table[index];
 
         rcu_read_lock();
-        hlist_for_each_entry_rcu(vis_info, node, head, hash_entry) {
-                if (!batadv_vis_info_cmp(node, data))
+        hlist_for_each_entry_rcu(vis_info, head, hash_entry) {
+                if (!batadv_vis_info_cmp(&vis_info->hash_entry, data))
                         continue;
 
                 vis_info_tmp = vis_info;
@@ -128,9 +127,8 @@ static void batadv_vis_data_insert_interface(const uint8_t *interface,
                                              bool primary)
 {
         struct batadv_vis_if_list_entry *entry;
-        struct hlist_node *pos;
 
-        hlist_for_each_entry(entry, pos, if_list, list) {
+        hlist_for_each_entry(entry, if_list, list) {
                 if (batadv_compare_eth(entry->addr, interface))
                         return;
         }
@@ -148,9 +146,8 @@ static void batadv_vis_data_read_prim_sec(struct seq_file *seq,
                                           const struct hlist_head *if_list)
 {
         struct batadv_vis_if_list_entry *entry;
-        struct hlist_node *pos;
 
-        hlist_for_each_entry(entry, pos, if_list, list) {
+        hlist_for_each_entry(entry, if_list, list) {
                 if (entry->primary)
                         seq_printf(seq, "PRIMARY, ");
                 else
@@ -198,9 +195,8 @@ static void batadv_vis_data_read_entries(struct seq_file *seq,
 {
         int i;
         struct batadv_vis_if_list_entry *entry;
-        struct hlist_node *pos;
 
-        hlist_for_each_entry(entry, pos, list, list) {
+        hlist_for_each_entry(entry, list, list) {
                 seq_printf(seq, "%pM,", entry->addr);
 
                 for (i = 0; i < packet->entries; i++)
@@ -218,17 +214,16 @@ static void batadv_vis_data_read_entries(struct seq_file *seq,
 static void batadv_vis_seq_print_text_bucket(struct seq_file *seq,
                                              const struct hlist_head *head)
 {
-        struct hlist_node *node;
         struct batadv_vis_info *info;
         struct batadv_vis_packet *packet;
         uint8_t *entries_pos;
         struct batadv_vis_info_entry *entries;
         struct batadv_vis_if_list_entry *entry;
-        struct hlist_node *pos, *n;
+        struct hlist_node *n;
 
         HLIST_HEAD(vis_if_list);
 
-        hlist_for_each_entry_rcu(info, node, head, hash_entry) {
+        hlist_for_each_entry_rcu(info, head, hash_entry) {
                 packet = (struct batadv_vis_packet *)info->skb_packet->data;
                 entries_pos = (uint8_t *)packet + sizeof(*packet);
                 entries = (struct batadv_vis_info_entry *)entries_pos;
@@ -240,7 +235,7 @@ static void batadv_vis_seq_print_text_bucket(struct seq_file *seq,
                 batadv_vis_data_read_entries(seq, &vis_if_list, packet,
                                              entries);
 
-                hlist_for_each_entry_safe(entry, pos, n, &vis_if_list, list) {
+                hlist_for_each_entry_safe(entry, n, &vis_if_list, list) {
                         hlist_del(&entry->list);
                         kfree(entry);
                 }
@@ -519,7 +514,6 @@ static int batadv_find_best_vis_server(struct batadv_priv *bat_priv,
 {
         struct batadv_hashtable *hash = bat_priv->orig_hash;
         struct batadv_neigh_node *router;
-        struct hlist_node *node;
         struct hlist_head *head;
         struct batadv_orig_node *orig_node;
         struct batadv_vis_packet *packet;
@@ -532,7 +526,7 @@ static int batadv_find_best_vis_server(struct batadv_priv *bat_priv,
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
+                hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
                         router = batadv_orig_node_get_router(orig_node);
                         if (!router)
                                 continue;
@@ -571,7 +565,6 @@ static bool batadv_vis_packet_full(const struct batadv_vis_info *info)
 static int batadv_generate_vis_packet(struct batadv_priv *bat_priv)
 {
         struct batadv_hashtable *hash = bat_priv->orig_hash;
-        struct hlist_node *node;
         struct hlist_head *head;
         struct batadv_orig_node *orig_node;
         struct batadv_neigh_node *router;
@@ -605,7 +598,7 @@ static int batadv_generate_vis_packet(struct batadv_priv *bat_priv)
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
+                hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
                         router = batadv_orig_node_get_router(orig_node);
                         if (!router)
                                 continue;
@@ -644,7 +637,7 @@ next:
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(tt_common_entry, node, head,
+                hlist_for_each_entry_rcu(tt_common_entry, head,
                                          hash_entry) {
                         packet_pos = skb_put(info->skb_packet, sizeof(*entry));
                         entry = (struct batadv_vis_info_entry *)packet_pos;
@@ -673,14 +666,14 @@ static void batadv_purge_vis_packets(struct batadv_priv *bat_priv)
 {
         uint32_t i;
         struct batadv_hashtable *hash = bat_priv->vis.hash;
-        struct hlist_node *node, *node_tmp;
+        struct hlist_node *node_tmp;
         struct hlist_head *head;
         struct batadv_vis_info *info;
 
         for (i = 0; i < hash->size; i++) {
                 head = &hash->table[i];
 
-                hlist_for_each_entry_safe(info, node, node_tmp,
+                hlist_for_each_entry_safe(info, node_tmp,
                                           head, hash_entry) {
                         /* never purge own data. */
                         if (info == bat_priv->vis.my_info)
@@ -688,7 +681,7 @@ static void batadv_purge_vis_packets(struct batadv_priv *bat_priv)
 
                         if (batadv_has_timed_out(info->first_seen,
                                                  BATADV_VIS_TIMEOUT)) {
-                                hlist_del(node);
+                                hlist_del(&info->hash_entry);
                                 batadv_send_list_del(info);
                                 kref_put(&info->refcount, batadv_free_info);
                         }
@@ -700,7 +693,6 @@ static void batadv_broadcast_vis_packet(struct batadv_priv *bat_priv,
                                         struct batadv_vis_info *info)
 {
         struct batadv_hashtable *hash = bat_priv->orig_hash;
-        struct hlist_node *node;
         struct hlist_head *head;
         struct batadv_orig_node *orig_node;
         struct batadv_vis_packet *packet;
@@ -715,7 +707,7 @@ static void batadv_broadcast_vis_packet(struct batadv_priv *bat_priv,
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
+                hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
                         /* if it's a vis server and reachable, send it. */
                         if (!(orig_node->flags & BATADV_VIS_SERVER))
                                 continue;