10 files changed, 49 insertions, 82 deletions

diff --git a/net/ipv4/devinet.c b/net/ipv4/devinet.c
index 5281314886c1..f678507bc829 100644
--- a/net/ipv4/devinet.c
+++ b/net/ipv4/devinet.c
@@ -139,10 +139,9 @@ struct net_device *__ip_dev_find(struct net *net, __be32 addr, bool devref)
         u32 hash = inet_addr_hash(net, addr);
         struct net_device *result = NULL;
         struct in_ifaddr *ifa;
-        struct hlist_node *node;
 
         rcu_read_lock();
-        hlist_for_each_entry_rcu(ifa, node, &inet_addr_lst[hash], hash) {
+        hlist_for_each_entry_rcu(ifa, &inet_addr_lst[hash], hash) {
                 if (ifa->ifa_local == addr) {
                         struct net_device *dev = ifa->ifa_dev->dev;
 
@@ -588,7 +587,6 @@ static void check_lifetime(struct work_struct *work)
 {
         unsigned long now, next, next_sec, next_sched;
         struct in_ifaddr *ifa;
-        struct hlist_node *node;
         int i;
 
         now = jiffies;
@@ -596,8 +594,7 @@ static void check_lifetime(struct work_struct *work)
 
         rcu_read_lock();
         for (i = 0; i < IN4_ADDR_HSIZE; i++) {
-                hlist_for_each_entry_rcu(ifa, node,
-                                         &inet_addr_lst[i], hash) {
+                hlist_for_each_entry_rcu(ifa, &inet_addr_lst[i], hash) {
                         unsigned long age;
 
                         if (ifa->ifa_flags & IFA_F_PERMANENT)
@@ -1493,7 +1490,6 @@ static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
         struct in_device *in_dev;
         struct in_ifaddr *ifa;
         struct hlist_head *head;
-        struct hlist_node *node;
 
         s_h = cb->args[0];
         s_idx = idx = cb->args[1];
@@ -1503,7 +1499,7 @@ static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
                 idx = 0;
                 head = &net->dev_index_head[h];
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(dev, node, head, index_hlist) {
+                hlist_for_each_entry_rcu(dev, head, index_hlist) {
                         if (idx < s_idx)
                                 goto cont;
                         if (h > s_h || idx > s_idx)
diff --git a/net/ipv4/fib_frontend.c b/net/ipv4/fib_frontend.c
index 99f00d39d10b..eb4bb12b3eb4 100644
--- a/net/ipv4/fib_frontend.c
+++ b/net/ipv4/fib_frontend.c
@@ -112,7 +112,6 @@ struct fib_table *fib_new_table(struct net *net, u32 id)
 struct fib_table *fib_get_table(struct net *net, u32 id)
 {
         struct fib_table *tb;
-        struct hlist_node *node;
         struct hlist_head *head;
         unsigned int h;
 
@@ -122,7 +121,7 @@ struct fib_table *fib_get_table(struct net *net, u32 id)
 
         rcu_read_lock();
         head = &net->ipv4.fib_table_hash[h];
-        hlist_for_each_entry_rcu(tb, node, head, tb_hlist) {
+        hlist_for_each_entry_rcu(tb, head, tb_hlist) {
                 if (tb->tb_id == id) {
                         rcu_read_unlock();
                         return tb;
@@ -137,13 +136,12 @@ static void fib_flush(struct net *net)
 {
         int flushed = 0;
         struct fib_table *tb;
-        struct hlist_node *node;
         struct hlist_head *head;
         unsigned int h;
 
         for (h = 0; h < FIB_TABLE_HASHSZ; h++) {
                 head = &net->ipv4.fib_table_hash[h];
-                hlist_for_each_entry(tb, node, head, tb_hlist)
+                hlist_for_each_entry(tb, head, tb_hlist)
                         flushed += fib_table_flush(tb);
         }
 
@@ -656,7 +654,6 @@ static int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
         unsigned int h, s_h;
         unsigned int e = 0, s_e;
         struct fib_table *tb;
-        struct hlist_node *node;
         struct hlist_head *head;
         int dumped = 0;
 
@@ -670,7 +667,7 @@ static int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
         for (h = s_h; h < FIB_TABLE_HASHSZ; h++, s_e = 0) {
                 e = 0;
                 head = &net->ipv4.fib_table_hash[h];
-                hlist_for_each_entry(tb, node, head, tb_hlist) {
+                hlist_for_each_entry(tb, head, tb_hlist) {
                         if (e < s_e)
                                 goto next;
                         if (dumped)
@@ -1117,11 +1114,11 @@ static void ip_fib_net_exit(struct net *net)
         for (i = 0; i < FIB_TABLE_HASHSZ; i++) {
                 struct fib_table *tb;
                 struct hlist_head *head;
-                struct hlist_node *node, *tmp;
+                struct hlist_node *tmp;
 
                 head = &net->ipv4.fib_table_hash[i];
-                hlist_for_each_entry_safe(tb, node, tmp, head, tb_hlist) {
-                        hlist_del(node);
+                hlist_for_each_entry_safe(tb, tmp, head, tb_hlist) {
+                        hlist_del(&tb->tb_hlist);
                         fib_table_flush(tb);
                         fib_free_table(tb);
                 }
diff --git a/net/ipv4/fib_semantics.c b/net/ipv4/fib_semantics.c
index 4797a800faf8..8f6cb7a87cd6 100644
--- a/net/ipv4/fib_semantics.c
+++ b/net/ipv4/fib_semantics.c
@@ -298,14 +298,13 @@ static inline unsigned int fib_info_hashfn(const struct fib_info *fi)
 static struct fib_info *fib_find_info(const struct fib_info *nfi)
 {
         struct hlist_head *head;
-        struct hlist_node *node;
         struct fib_info *fi;
         unsigned int hash;
 
         hash = fib_info_hashfn(nfi);
         head = &fib_info_hash[hash];
 
-        hlist_for_each_entry(fi, node, head, fib_hash) {
+        hlist_for_each_entry(fi, head, fib_hash) {
                 if (!net_eq(fi->fib_net, nfi->fib_net))
                         continue;
                 if (fi->fib_nhs != nfi->fib_nhs)
@@ -331,7 +330,6 @@ static struct fib_info *fib_find_info(const struct fib_info *nfi)
 int ip_fib_check_default(__be32 gw, struct net_device *dev)
 {
         struct hlist_head *head;
-        struct hlist_node *node;
         struct fib_nh *nh;
         unsigned int hash;
 
@@ -339,7 +337,7 @@ int ip_fib_check_default(__be32 gw, struct net_device *dev)
 
         hash = fib_devindex_hashfn(dev->ifindex);
         head = &fib_info_devhash[hash];
-        hlist_for_each_entry(nh, node, head, nh_hash) {
+        hlist_for_each_entry(nh, head, nh_hash) {
                 if (nh->nh_dev == dev &&
                     nh->nh_gw == gw &&
                     !(nh->nh_flags & RTNH_F_DEAD)) {
@@ -721,10 +719,10 @@ static void fib_info_hash_move(struct hlist_head *new_info_hash,
 
         for (i = 0; i < old_size; i++) {
                 struct hlist_head *head = &fib_info_hash[i];
-                struct hlist_node *node, *n;
+                struct hlist_node *n;
                 struct fib_info *fi;
 
-                hlist_for_each_entry_safe(fi, node, n, head, fib_hash) {
+                hlist_for_each_entry_safe(fi, n, head, fib_hash) {
                         struct hlist_head *dest;
                         unsigned int new_hash;
 
@@ -739,10 +737,10 @@ static void fib_info_hash_move(struct hlist_head *new_info_hash,
 
         for (i = 0; i < old_size; i++) {
                 struct hlist_head *lhead = &fib_info_laddrhash[i];
-                struct hlist_node *node, *n;
+                struct hlist_node *n;
                 struct fib_info *fi;
 
-                hlist_for_each_entry_safe(fi, node, n, lhead, fib_lhash) {
+                hlist_for_each_entry_safe(fi, n, lhead, fib_lhash) {
                         struct hlist_head *ldest;
                         unsigned int new_hash;
 
@@ -1096,13 +1094,12 @@ int fib_sync_down_addr(struct net *net, __be32 local)
         int ret = 0;
         unsigned int hash = fib_laddr_hashfn(local);
         struct hlist_head *head = &fib_info_laddrhash[hash];
-        struct hlist_node *node;
         struct fib_info *fi;
 
         if (fib_info_laddrhash == NULL || local == 0)
                 return 0;
 
-        hlist_for_each_entry(fi, node, head, fib_lhash) {
+        hlist_for_each_entry(fi, head, fib_lhash) {
                 if (!net_eq(fi->fib_net, net))
                         continue;
                 if (fi->fib_prefsrc == local) {
@@ -1120,13 +1117,12 @@ int fib_sync_down_dev(struct net_device *dev, int force)
         struct fib_info *prev_fi = NULL;
         unsigned int hash = fib_devindex_hashfn(dev->ifindex);
         struct hlist_head *head = &fib_info_devhash[hash];
-        struct hlist_node *node;
         struct fib_nh *nh;
 
         if (force)
                 scope = -1;
 
-        hlist_for_each_entry(nh, node, head, nh_hash) {
+        hlist_for_each_entry(nh, head, nh_hash) {
                 struct fib_info *fi = nh->nh_parent;
                 int dead;
 
@@ -1232,7 +1228,6 @@ int fib_sync_up(struct net_device *dev)
         struct fib_info *prev_fi;
         unsigned int hash;
         struct hlist_head *head;
-        struct hlist_node *node;
         struct fib_nh *nh;
         int ret;
 
@@ -1244,7 +1239,7 @@ int fib_sync_up(struct net_device *dev)
         head = &fib_info_devhash[hash];
         ret = 0;
 
-        hlist_for_each_entry(nh, node, head, nh_hash) {
+        hlist_for_each_entry(nh, head, nh_hash) {
                 struct fib_info *fi = nh->nh_parent;
                 int alive;
 
diff --git a/net/ipv4/fib_trie.c b/net/ipv4/fib_trie.c
index 61e03da3e1f5..ff06b7543d9f 100644
--- a/net/ipv4/fib_trie.c
+++ b/net/ipv4/fib_trie.c
@@ -920,10 +920,9 @@ nomem:
 static struct leaf_info *find_leaf_info(struct leaf *l, int plen)
 {
         struct hlist_head *head = &l->list;
-        struct hlist_node *node;
         struct leaf_info *li;
 
-        hlist_for_each_entry_rcu(li, node, head, hlist)
+        hlist_for_each_entry_rcu(li, head, hlist)
                 if (li->plen == plen)
                         return li;
 
@@ -943,12 +942,11 @@ static inline struct list_head *get_fa_head(struct leaf *l, int plen)
 static void insert_leaf_info(struct hlist_head *head, struct leaf_info *new)
 {
         struct leaf_info *li = NULL, *last = NULL;
-        struct hlist_node *node;
 
         if (hlist_empty(head)) {
                 hlist_add_head_rcu(&new->hlist, head);
         } else {
-                hlist_for_each_entry(li, node, head, hlist) {
+                hlist_for_each_entry(li, head, hlist) {
                         if (new->plen > li->plen)
                                 break;
 
@@ -1354,9 +1352,8 @@ static int check_leaf(struct fib_table *tb, struct trie *t, struct leaf *l,
 {
         struct leaf_info *li;
         struct hlist_head *hhead = &l->list;
-        struct hlist_node *node;
 
-        hlist_for_each_entry_rcu(li, node, hhead, hlist) {
+        hlist_for_each_entry_rcu(li, hhead, hlist) {
                 struct fib_alias *fa;
 
                 if (l->key != (key & li->mask_plen))
@@ -1740,10 +1737,10 @@ static int trie_flush_leaf(struct leaf *l)
 {
         int found = 0;
         struct hlist_head *lih = &l->list;
-        struct hlist_node *node, *tmp;
+        struct hlist_node *tmp;
         struct leaf_info *li = NULL;
 
-        hlist_for_each_entry_safe(li, node, tmp, lih, hlist) {
+        hlist_for_each_entry_safe(li, tmp, lih, hlist) {
                 found += trie_flush_list(&li->falh);
 
                 if (list_empty(&li->falh)) {
@@ -1895,14 +1892,13 @@ static int fn_trie_dump_leaf(struct leaf *l, struct fib_table *tb,
                         struct sk_buff *skb, struct netlink_callback *cb)
 {
         struct leaf_info *li;
-        struct hlist_node *node;
         int i, s_i;
 
         s_i = cb->args[4];
         i = 0;
 
         /* rcu_read_lock is hold by caller */
-        hlist_for_each_entry_rcu(li, node, &l->list, hlist) {
+        hlist_for_each_entry_rcu(li, &l->list, hlist) {
                 if (i < s_i) {
                         i++;
                         continue;
@@ -2092,14 +2088,13 @@ static void trie_collect_stats(struct trie *t, struct trie_stat *s)
                 if (IS_LEAF(n)) {
                         struct leaf *l = (struct leaf *)n;
                         struct leaf_info *li;
-                        struct hlist_node *tmp;
 
                         s->leaves++;
                         s->totdepth += iter.depth;
                         if (iter.depth > s->maxdepth)
                                 s->maxdepth = iter.depth;
 
-                        hlist_for_each_entry_rcu(li, tmp, &l->list, hlist)
+                        hlist_for_each_entry_rcu(li, &l->list, hlist)
                                 ++s->prefixes;
                 } else {
                         const struct tnode *tn = (const struct tnode *) n;
@@ -2200,10 +2195,9 @@ static int fib_triestat_seq_show(struct seq_file *seq, void *v)
 
         for (h = 0; h < FIB_TABLE_HASHSZ; h++) {
                 struct hlist_head *head = &net->ipv4.fib_table_hash[h];
-                struct hlist_node *node;
                 struct fib_table *tb;
 
-                hlist_for_each_entry_rcu(tb, node, head, tb_hlist) {
+                hlist_for_each_entry_rcu(tb, head, tb_hlist) {
                         struct trie *t = (struct trie *) tb->tb_data;
                         struct trie_stat stat;
 
@@ -2245,10 +2239,9 @@ static struct rt_trie_node *fib_trie_get_idx(struct seq_file *seq, loff_t pos)
 
         for (h = 0; h < FIB_TABLE_HASHSZ; h++) {
                 struct hlist_head *head = &net->ipv4.fib_table_hash[h];
-                struct hlist_node *node;
                 struct fib_table *tb;
 
-                hlist_for_each_entry_rcu(tb, node, head, tb_hlist) {
+                hlist_for_each_entry_rcu(tb, head, tb_hlist) {
                         struct rt_trie_node *n;
 
                         for (n = fib_trie_get_first(iter,
@@ -2298,7 +2291,7 @@ static void *fib_trie_seq_next(struct seq_file *seq, void *v, loff_t *pos)
         /* new hash chain */
         while (++h < FIB_TABLE_HASHSZ) {
                 struct hlist_head *head = &net->ipv4.fib_table_hash[h];
-                hlist_for_each_entry_rcu(tb, tb_node, head, tb_hlist) {
+                hlist_for_each_entry_rcu(tb, head, tb_hlist) {
                         n = fib_trie_get_first(iter, (struct trie *) tb->tb_data);
                         if (n)
                                 goto found;
@@ -2381,13 +2374,12 @@ static int fib_trie_seq_show(struct seq_file *seq, void *v)
         } else {
                 struct leaf *l = (struct leaf *) n;
                 struct leaf_info *li;
-                struct hlist_node *node;
                 __be32 val = htonl(l->key);
 
                 seq_indent(seq, iter->depth);
                 seq_printf(seq, "  |-- %pI4\n", &val);
 
-                hlist_for_each_entry_rcu(li, node, &l->list, hlist) {
+                hlist_for_each_entry_rcu(li, &l->list, hlist) {
                         struct fib_alias *fa;
 
                         list_for_each_entry_rcu(fa, &li->falh, fa_list) {
@@ -2532,7 +2524,6 @@ static int fib_route_seq_show(struct seq_file *seq, void *v)
 {
         struct leaf *l = v;
         struct leaf_info *li;
-        struct hlist_node *node;
 
         if (v == SEQ_START_TOKEN) {
                 seq_printf(seq, "%-127s\n", "Iface\tDestination\tGateway "
@@ -2541,7 +2532,7 @@ static int fib_route_seq_show(struct seq_file *seq, void *v)
                 return 0;
         }
 
-        hlist_for_each_entry_rcu(li, node, &l->list, hlist) {
+        hlist_for_each_entry_rcu(li, &l->list, hlist) {
                 struct fib_alias *fa;
                 __be32 mask, prefix;
 
diff --git a/net/ipv4/inet_connection_sock.c b/net/ipv4/inet_connection_sock.c
index 11cb4979a465..7d1874be1df3 100644
--- a/net/ipv4/inet_connection_sock.c
+++ b/net/ipv4/inet_connection_sock.c
@@ -57,7 +57,6 @@ int inet_csk_bind_conflict(const struct sock *sk,
                            const struct inet_bind_bucket *tb, bool relax)
 {
         struct sock *sk2;
-        struct hlist_node *node;
         int reuse = sk->sk_reuse;
         int reuseport = sk->sk_reuseport;
         kuid_t uid = sock_i_uid((struct sock *)sk);
@@ -69,7 +68,7 @@ int inet_csk_bind_conflict(const struct sock *sk,
          * one this bucket belongs to.
          */
 
-        sk_for_each_bound(sk2, node, &tb->owners) {
+        sk_for_each_bound(sk2, &tb->owners) {
                 if (sk != sk2 &&
                     !inet_v6_ipv6only(sk2) &&
                     (!sk->sk_bound_dev_if ||
@@ -95,7 +94,7 @@ int inet_csk_bind_conflict(const struct sock *sk,
                         }
                 }
         }
-        return node != NULL;
+        return sk2 != NULL;
 }
 EXPORT_SYMBOL_GPL(inet_csk_bind_conflict);
 
@@ -106,7 +105,6 @@ int inet_csk_get_port(struct sock *sk, unsigned short snum)
 {
         struct inet_hashinfo *hashinfo = sk->sk_prot->h.hashinfo;
         struct inet_bind_hashbucket *head;
-        struct hlist_node *node;
         struct inet_bind_bucket *tb;
         int ret, attempts = 5;
         struct net *net = sock_net(sk);
@@ -129,7 +127,7 @@ again:
                         head = &hashinfo->bhash[inet_bhashfn(net, rover,
                                         hashinfo->bhash_size)];
                         spin_lock(&head->lock);
-                        inet_bind_bucket_for_each(tb, node, &head->chain)
+                        inet_bind_bucket_for_each(tb, &head->chain)
                                 if (net_eq(ib_net(tb), net) && tb->port == rover) {
                                         if (((tb->fastreuse > 0 &&
                                               sk->sk_reuse &&
@@ -183,7 +181,7 @@ have_snum:
                 head = &hashinfo->bhash[inet_bhashfn(net, snum,
                                 hashinfo->bhash_size)];
                 spin_lock(&head->lock);
-                inet_bind_bucket_for_each(tb, node, &head->chain)
+                inet_bind_bucket_for_each(tb, &head->chain)
                         if (net_eq(ib_net(tb), net) && tb->port == snum)
                                 goto tb_found;
         }
diff --git a/net/ipv4/inet_fragment.c b/net/ipv4/inet_fragment.c
index 2e453bde6992..245ae078a07f 100644
--- a/net/ipv4/inet_fragment.c
+++ b/net/ipv4/inet_fragment.c
@@ -33,9 +33,9 @@ static void inet_frag_secret_rebuild(unsigned long dummy)
         get_random_bytes(&f->rnd, sizeof(u32));
         for (i = 0; i < INETFRAGS_HASHSZ; i++) {
                 struct inet_frag_queue *q;
-                struct hlist_node *p, *n;
+                struct hlist_node *n;
 
-                hlist_for_each_entry_safe(q, p, n, &f->hash[i], list) {
+                hlist_for_each_entry_safe(q, n, &f->hash[i], list) {
                         unsigned int hval = f->hashfn(q);
 
                         if (hval != i) {
@@ -203,7 +203,6 @@ static struct inet_frag_queue *inet_frag_intern(struct netns_frags *nf,
 {
         struct inet_frag_queue *qp;
 #ifdef CONFIG_SMP
-        struct hlist_node *n;
 #endif
         unsigned int hash;
 
@@ -219,7 +218,7 @@ static struct inet_frag_queue *inet_frag_intern(struct netns_frags *nf,
          * such entry could be created on other cpu, while we
          * promoted read lock to write lock.
          */
-        hlist_for_each_entry(qp, n, &f->hash[hash], list) {
+        hlist_for_each_entry(qp, &f->hash[hash], list) {
                 if (qp->net == nf && f->match(qp, arg)) {
                         atomic_inc(&qp->refcnt);
                         write_unlock(&f->lock);
@@ -278,9 +277,8 @@ struct inet_frag_queue *inet_frag_find(struct netns_frags *nf,
         __releases(&f->lock)
 {
         struct inet_frag_queue *q;
-        struct hlist_node *n;
 
-        hlist_for_each_entry(q, n, &f->hash[hash], list) {
+        hlist_for_each_entry(q, &f->hash[hash], list) {
                 if (q->net == nf && f->match(q, key)) {
                         atomic_inc(&q->refcnt);
                         read_unlock(&f->lock);
diff --git a/net/ipv4/inet_hashtables.c b/net/ipv4/inet_hashtables.c
index 0ce0595d9861..6af375afeeef 100644
--- a/net/ipv4/inet_hashtables.c
+++ b/net/ipv4/inet_hashtables.c
@@ -120,13 +120,12 @@ int __inet_inherit_port(struct sock *sk, struct sock *child)
                  * that the listener socket's icsk_bind_hash is the same
                  * as that of the child socket. We have to look up or
                  * create a new bind bucket for the child here. */
-                struct hlist_node *node;
-                inet_bind_bucket_for_each(tb, node, &head->chain) {
+                inet_bind_bucket_for_each(tb, &head->chain) {
                         if (net_eq(ib_net(tb), sock_net(sk)) &&
                             tb->port == port)
                                 break;
                 }
-                if (!node) {
+                if (!tb) {
                         tb = inet_bind_bucket_create(table->bind_bucket_cachep,
                                                      sock_net(sk), head, port);
                         if (!tb) {
@@ -493,7 +492,6 @@ int __inet_hash_connect(struct inet_timewait_death_row *death_row,
                 int i, remaining, low, high, port;
                 static u32 hint;
                 u32 offset = hint + port_offset;
-                struct hlist_node *node;
                 struct inet_timewait_sock *tw = NULL;
 
                 inet_get_local_port_range(&low, &high);
@@ -512,7 +510,7 @@ int __inet_hash_connect(struct inet_timewait_death_row *death_row,
                          * because the established check is already
                          * unique enough.
                          */
-                        inet_bind_bucket_for_each(tb, node, &head->chain) {
+                        inet_bind_bucket_for_each(tb, &head->chain) {
                                 if (net_eq(ib_net(tb), net) &&
                                     tb->port == port) {
                                         if (tb->fastreuse >= 0 ||
diff --git a/net/ipv4/inet_timewait_sock.c b/net/ipv4/inet_timewait_sock.c
index 2784db3155fb..1f27c9f4afd0 100644
--- a/net/ipv4/inet_timewait_sock.c
+++ b/net/ipv4/inet_timewait_sock.c
@@ -216,7 +216,6 @@ static int inet_twdr_do_twkill_work(struct inet_timewait_death_row *twdr,
                                     const int slot)
 {
         struct inet_timewait_sock *tw;
-        struct hlist_node *node;
         unsigned int killed;
         int ret;
 
@@ -229,7 +228,7 @@ static int inet_twdr_do_twkill_work(struct inet_timewait_death_row *twdr,
         killed = 0;
         ret = 0;
 rescan:
-        inet_twsk_for_each_inmate(tw, node, &twdr->cells[slot]) {
+        inet_twsk_for_each_inmate(tw, &twdr->cells[slot]) {
                 __inet_twsk_del_dead_node(tw);
                 spin_unlock(&twdr->death_lock);
                 __inet_twsk_kill(tw, twdr->hashinfo);
@@ -438,10 +437,10 @@ void inet_twdr_twcal_tick(unsigned long data)
 
         for (n = 0; n < INET_TWDR_RECYCLE_SLOTS; n++) {
                 if (time_before_eq(j, now)) {
-                        struct hlist_node *node, *safe;
+                        struct hlist_node *safe;
                         struct inet_timewait_sock *tw;
 
-                        inet_twsk_for_each_inmate_safe(tw, node, safe,
+                        inet_twsk_for_each_inmate_safe(tw, safe,
                                                        &twdr->twcal_row[slot]) {
                                 __inet_twsk_del_dead_node(tw);
                                 __inet_twsk_kill(tw, twdr->hashinfo);
diff --git a/net/ipv4/raw.c b/net/ipv4/raw.c
index 53ddebc292b6..dd44e0ab600c 100644
--- a/net/ipv4/raw.c
+++ b/net/ipv4/raw.c
@@ -111,9 +111,7 @@ EXPORT_SYMBOL_GPL(raw_unhash_sk);
 static struct sock *__raw_v4_lookup(struct net *net, struct sock *sk,
                 unsigned short num, __be32 raddr, __be32 laddr, int dif)
 {
-        struct hlist_node *node;
-
-        sk_for_each_from(sk, node) {
+        sk_for_each_from(sk) {
                 struct inet_sock *inet = inet_sk(sk);
 
                 if (net_eq(sock_net(sk), net) && inet->inet_num == num  &&
@@ -914,9 +912,7 @@ static struct sock *raw_get_first(struct seq_file *seq)
 
         for (state->bucket = 0; state->bucket < RAW_HTABLE_SIZE;
                         ++state->bucket) {
-                struct hlist_node *node;
-
-                sk_for_each(sk, node, &state->h->ht[state->bucket])
+                sk_for_each(sk, &state->h->ht[state->bucket])
                         if (sock_net(sk) == seq_file_net(seq))
                                 goto found;
         }
diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index 145d3bf8df86..4a8ec457310f 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -954,7 +954,6 @@ struct tcp_md5sig_key *tcp_md5_do_lookup(struct sock *sk,
 {
         struct tcp_sock *tp = tcp_sk(sk);
         struct tcp_md5sig_key *key;
-        struct hlist_node *pos;
         unsigned int size = sizeof(struct in_addr);
         struct tcp_md5sig_info *md5sig;
 
@@ -968,7 +967,7 @@ struct tcp_md5sig_key *tcp_md5_do_lookup(struct sock *sk,
         if (family == AF_INET6)
                 size = sizeof(struct in6_addr);
 #endif
-        hlist_for_each_entry_rcu(key, pos, &md5sig->head, node) {
+        hlist_for_each_entry_rcu(key, &md5sig->head, node) {
                 if (key->family != family)
                         continue;
                 if (!memcmp(&key->addr, addr, size))
@@ -1069,14 +1068,14 @@ static void tcp_clear_md5_list(struct sock *sk)
 {
         struct tcp_sock *tp = tcp_sk(sk);
         struct tcp_md5sig_key *key;
-        struct hlist_node *pos, *n;
+        struct hlist_node *n;
         struct tcp_md5sig_info *md5sig;
 
         md5sig = rcu_dereference_protected(tp->md5sig_info, 1);
 
         if (!hlist_empty(&md5sig->head))
                 tcp_free_md5sig_pool();
-        hlist_for_each_entry_safe(key, pos, n, &md5sig->head, node) {
+        hlist_for_each_entry_safe(key, n, &md5sig->head, node) {
                 hlist_del_rcu(&key->node);
                 atomic_sub(sizeof(*key), &sk->sk_omem_alloc);
                 kfree_rcu(key, rcu);