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>

4 files changed, 16 insertions, 29 deletions

diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index bfa142e67b1c..e2f7f5aaaafb 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -1906,9 +1906,8 @@ static inline void free_mm_slot(struct mm_slot *mm_slot)
 static struct mm_slot *get_mm_slot(struct mm_struct *mm)
 {
         struct mm_slot *mm_slot;
-        struct hlist_node *node;
 
-        hash_for_each_possible(mm_slots_hash, mm_slot, node, hash, (unsigned long)mm)
+        hash_for_each_possible(mm_slots_hash, mm_slot, hash, (unsigned long)mm)
                 if (mm == mm_slot->mm)
                         return mm_slot;
 
diff --git a/mm/kmemleak.c b/mm/kmemleak.c
index 83dd5fbf5e60..c8d7f3110fd0 100644
--- a/mm/kmemleak.c
+++ b/mm/kmemleak.c
@@ -436,7 +436,7 @@ static int get_object(struct kmemleak_object *object)
  */
 static void free_object_rcu(struct rcu_head *rcu)
 {
-        struct hlist_node *elem, *tmp;
+        struct hlist_node *tmp;
         struct kmemleak_scan_area *area;
         struct kmemleak_object *object =
                 container_of(rcu, struct kmemleak_object, rcu);
@@ -445,8 +445,8 @@ static void free_object_rcu(struct rcu_head *rcu)
          * Once use_count is 0 (guaranteed by put_object), there is no other
          * code accessing this object, hence no need for locking.
          */
-        hlist_for_each_entry_safe(area, elem, tmp, &object->area_list, node) {
-                hlist_del(elem);
+        hlist_for_each_entry_safe(area, tmp, &object->area_list, node) {
+                hlist_del(&area->node);
                 kmem_cache_free(scan_area_cache, area);
         }
         kmem_cache_free(object_cache, object);
@@ -1177,7 +1177,6 @@ static void scan_block(void *_start, void *_end,
 static void scan_object(struct kmemleak_object *object)
 {
         struct kmemleak_scan_area *area;
-        struct hlist_node *elem;
         unsigned long flags;
 
         /*
@@ -1205,7 +1204,7 @@ static void scan_object(struct kmemleak_object *object)
                         spin_lock_irqsave(&object->lock, flags);
                 }
         } else
-                hlist_for_each_entry(area, elem, &object->area_list, node)
+                hlist_for_each_entry(area, &object->area_list, node)
                         scan_block((void *)area->start,
                                    (void *)(area->start + area->size),
                                    object, 0);
diff --git a/mm/ksm.c b/mm/ksm.c
index ab2ba9ad3c59..85bfd4c16346 100644
--- a/mm/ksm.c
+++ b/mm/ksm.c
@@ -320,10 +320,9 @@ static inline void free_mm_slot(struct mm_slot *mm_slot)
 
 static struct mm_slot *get_mm_slot(struct mm_struct *mm)
 {
-        struct hlist_node *node;
         struct mm_slot *slot;
 
-        hash_for_each_possible(mm_slots_hash, slot, node, link, (unsigned long)mm)
+        hash_for_each_possible(mm_slots_hash, slot, link, (unsigned long)mm)
                 if (slot->mm == mm)
                         return slot;
 
@@ -496,9 +495,8 @@ static inline int get_kpfn_nid(unsigned long kpfn)
 static void remove_node_from_stable_tree(struct stable_node *stable_node)
 {
         struct rmap_item *rmap_item;
-        struct hlist_node *hlist;
 
-        hlist_for_each_entry(rmap_item, hlist, &stable_node->hlist, hlist) {
+        hlist_for_each_entry(rmap_item, &stable_node->hlist, hlist) {
                 if (rmap_item->hlist.next)
                         ksm_pages_sharing--;
                 else
@@ -1898,7 +1896,6 @@ int page_referenced_ksm(struct page *page, struct mem_cgroup *memcg,
 {
         struct stable_node *stable_node;
         struct rmap_item *rmap_item;
-        struct hlist_node *hlist;
         unsigned int mapcount = page_mapcount(page);
         int referenced = 0;
         int search_new_forks = 0;
@@ -1910,7 +1907,7 @@ int page_referenced_ksm(struct page *page, struct mem_cgroup *memcg,
         if (!stable_node)
                 return 0;
 again:
-        hlist_for_each_entry(rmap_item, hlist, &stable_node->hlist, hlist) {
+        hlist_for_each_entry(rmap_item, &stable_node->hlist, hlist) {
                 struct anon_vma *anon_vma = rmap_item->anon_vma;
                 struct anon_vma_chain *vmac;
                 struct vm_area_struct *vma;
@@ -1952,7 +1949,6 @@ out:
 int try_to_unmap_ksm(struct page *page, enum ttu_flags flags)
 {
         struct stable_node *stable_node;
-        struct hlist_node *hlist;
         struct rmap_item *rmap_item;
         int ret = SWAP_AGAIN;
         int search_new_forks = 0;
@@ -1964,7 +1960,7 @@ int try_to_unmap_ksm(struct page *page, enum ttu_flags flags)
         if (!stable_node)
                 return SWAP_FAIL;
 again:
-        hlist_for_each_entry(rmap_item, hlist, &stable_node->hlist, hlist) {
+        hlist_for_each_entry(rmap_item, &stable_node->hlist, hlist) {
                 struct anon_vma *anon_vma = rmap_item->anon_vma;
                 struct anon_vma_chain *vmac;
                 struct vm_area_struct *vma;
@@ -2005,7 +2001,6 @@ int rmap_walk_ksm(struct page *page, int (*rmap_one)(struct page *,
                   struct vm_area_struct *, unsigned long, void *), void *arg)
 {
         struct stable_node *stable_node;
-        struct hlist_node *hlist;
         struct rmap_item *rmap_item;
         int ret = SWAP_AGAIN;
         int search_new_forks = 0;
@@ -2017,7 +2012,7 @@ int rmap_walk_ksm(struct page *page, int (*rmap_one)(struct page *,
         if (!stable_node)
                 return ret;
 again:
-        hlist_for_each_entry(rmap_item, hlist, &stable_node->hlist, hlist) {
+        hlist_for_each_entry(rmap_item, &stable_node->hlist, hlist) {
                 struct anon_vma *anon_vma = rmap_item->anon_vma;
                 struct anon_vma_chain *vmac;
                 struct vm_area_struct *vma;
diff --git a/mm/mmu_notifier.c b/mm/mmu_notifier.c
index 2175fb0d501c..be04122fb277 100644
--- a/mm/mmu_notifier.c
+++ b/mm/mmu_notifier.c
@@ -95,11 +95,10 @@ int __mmu_notifier_clear_flush_young(struct mm_struct *mm,
                                         unsigned long address)
 {
         struct mmu_notifier *mn;
-        struct hlist_node *n;
         int young = 0, id;
 
         id = srcu_read_lock(&srcu);
-        hlist_for_each_entry_rcu(mn, n, &mm->mmu_notifier_mm->list, hlist) {
+        hlist_for_each_entry_rcu(mn, &mm->mmu_notifier_mm->list, hlist) {
                 if (mn->ops->clear_flush_young)
                         young |= mn->ops->clear_flush_young(mn, mm, address);
         }
@@ -112,11 +111,10 @@ int __mmu_notifier_test_young(struct mm_struct *mm,
                               unsigned long address)
 {
         struct mmu_notifier *mn;
-        struct hlist_node *n;
         int young = 0, id;
 
         id = srcu_read_lock(&srcu);
-        hlist_for_each_entry_rcu(mn, n, &mm->mmu_notifier_mm->list, hlist) {
+        hlist_for_each_entry_rcu(mn, &mm->mmu_notifier_mm->list, hlist) {
                 if (mn->ops->test_young) {
                         young = mn->ops->test_young(mn, mm, address);
                         if (young)
@@ -132,11 +130,10 @@ void __mmu_notifier_change_pte(struct mm_struct *mm, unsigned long address,
                                pte_t pte)
 {
         struct mmu_notifier *mn;
-        struct hlist_node *n;
         int id;
 
         id = srcu_read_lock(&srcu);
-        hlist_for_each_entry_rcu(mn, n, &mm->mmu_notifier_mm->list, hlist) {
+        hlist_for_each_entry_rcu(mn, &mm->mmu_notifier_mm->list, hlist) {
                 if (mn->ops->change_pte)
                         mn->ops->change_pte(mn, mm, address, pte);
         }
@@ -147,11 +144,10 @@ void __mmu_notifier_invalidate_page(struct mm_struct *mm,
                                           unsigned long address)
 {
         struct mmu_notifier *mn;
-        struct hlist_node *n;
         int id;
 
         id = srcu_read_lock(&srcu);
-        hlist_for_each_entry_rcu(mn, n, &mm->mmu_notifier_mm->list, hlist) {
+        hlist_for_each_entry_rcu(mn, &mm->mmu_notifier_mm->list, hlist) {
                 if (mn->ops->invalidate_page)
                         mn->ops->invalidate_page(mn, mm, address);
         }
@@ -162,11 +158,10 @@ void __mmu_notifier_invalidate_range_start(struct mm_struct *mm,
                                   unsigned long start, unsigned long end)
 {
         struct mmu_notifier *mn;
-        struct hlist_node *n;
         int id;
 
         id = srcu_read_lock(&srcu);
-        hlist_for_each_entry_rcu(mn, n, &mm->mmu_notifier_mm->list, hlist) {
+        hlist_for_each_entry_rcu(mn, &mm->mmu_notifier_mm->list, hlist) {
                 if (mn->ops->invalidate_range_start)
                         mn->ops->invalidate_range_start(mn, mm, start, end);
         }
@@ -178,11 +173,10 @@ void __mmu_notifier_invalidate_range_end(struct mm_struct *mm,
                                   unsigned long start, unsigned long end)
 {
         struct mmu_notifier *mn;
-        struct hlist_node *n;
         int id;
 
         id = srcu_read_lock(&srcu);
-        hlist_for_each_entry_rcu(mn, n, &mm->mmu_notifier_mm->list, hlist) {
+        hlist_for_each_entry_rcu(mn, &mm->mmu_notifier_mm->list, hlist) {
                 if (mn->ops->invalidate_range_end)
                         mn->ops->invalidate_range_end(mn, mm, start, end);
         }