mm/memory_hotplug.c: clean up node_states_check_changes_offline()

This patch, as the previous one, gets rid of the wrong if statements.
While at it, I realized that the comments are sometimes very confusing,
to say the least, and wrong.
For example:

___
zone_last = ZONE_MOVABLE;

/*
 * check whether node_states[N_HIGH_MEMORY] will be changed
 * If we try to offline the last present @nr_pages from the node,
 * we can determind we will need to clear the node from
 * node_states[N_HIGH_MEMORY].
 */

for (; zt <= zone_last; zt++)
        present_pages += pgdat->node_zones[zt].present_pages;
if (nr_pages >= present_pages)
        arg->status_change_nid = zone_to_nid(zone);
else
        arg->status_change_nid = -1;
___

In case the node gets empry, it must be removed from N_MEMORY.  We already
check N_HIGH_MEMORY a bit above within the CONFIG_HIGHMEM ifdef code.  Not
to say that status_change_nid is for N_MEMORY, and not for N_HIGH_MEMORY.

So I re-wrote some of the comments to what I think is better.

[osalvador@suse.de: address feedback from Pavel]
Link: http://lkml.kernel.org/r/20180921132634.10103-5-osalvador@techadventures.net
Link: http://lkml.kernel.org/r/20180919100819.25518-6-osalvador@techadventures.net
Signed-off-by: Oscar Salvador <osalvador@suse.de>
Reviewed-by: Pavel Tatashin <pavel.tatashin@microsoft.com>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Dan Williams <dan.j.williams@intel.com>
Cc: David Hildenbrand <david@redhat.com>
Cc: Jonathan Cameron <Jonathan.Cameron@huawei.com>
Cc: <yasu.isimatu@gmail.com>
Cc: Mathieu Malaterre <malat@debian.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c
index eadd149..7e6509a 100644 (file)
--- a/mm/memory_hotplug.c
+++ b/mm/memory_hotplug.c
@@ -1463,75 +1463,53 @@ static void node_states_check_changes_offline(unsigned long nr_pages,
 {
        struct pglist_data *pgdat = zone->zone_pgdat;
        unsigned long present_pages = 0;
-       enum zone_type zt, zone_last = ZONE_NORMAL;
+       enum zone_type zt;
 
-       /*
-        * If we have HIGHMEM or movable node, node_states[N_NORMAL_MEMORY]
-        * contains nodes which have zones of 0...ZONE_NORMAL,
-        * set zone_last to ZONE_NORMAL.
-        *
-        * If we don't have HIGHMEM nor movable node,
-        * node_states[N_NORMAL_MEMORY] contains nodes which have zones of
-        * 0...ZONE_MOVABLE, set zone_last to ZONE_MOVABLE.
-        */
-       if (N_MEMORY == N_NORMAL_MEMORY)
-               zone_last = ZONE_MOVABLE;
+       arg->status_change_nid = -1;
+       arg->status_change_nid_normal = -1;
+       arg->status_change_nid_high = -1;
 
        /*
-        * check whether node_states[N_NORMAL_MEMORY] will be changed.
-        * If the memory to be offline is in a zone of 0...zone_last,
-        * and it is the last present memory, 0...zone_last will
-        * become empty after offline , thus we can determind we will
-        * need to clear the node from node_states[N_NORMAL_MEMORY].
+        * Check whether node_states[N_NORMAL_MEMORY] will be changed.
+        * If the memory to be offline is within the range
+        * [0..ZONE_NORMAL], and it is the last present memory there,
+        * the zones in that range will become empty after the offlining,
+        * thus we can determine that we need to clear the node from
+        * node_states[N_NORMAL_MEMORY].
         */
-       for (zt = 0; zt <= zone_last; zt++)
+       for (zt = 0; zt <= ZONE_NORMAL; zt++)
                present_pages += pgdat->node_zones[zt].present_pages;
-       if (zone_idx(zone) <= zone_last && nr_pages >= present_pages)
+       if (zone_idx(zone) <= ZONE_NORMAL && nr_pages >= present_pages)
                arg->status_change_nid_normal = zone_to_nid(zone);
-       else
-               arg->status_change_nid_normal = -1;
 
 #ifdef CONFIG_HIGHMEM
        /*
-        * If we have movable node, node_states[N_HIGH_MEMORY]
-        * contains nodes which have zones of 0...ZONE_HIGHMEM,
-        * set zone_last to ZONE_HIGHMEM.
-        *
-        * If we don't have movable node, node_states[N_NORMAL_MEMORY]
-        * contains nodes which have zones of 0...ZONE_MOVABLE,
-        * set zone_last to ZONE_MOVABLE.
+        * node_states[N_HIGH_MEMORY] contains nodes which
+        * have normal memory or high memory.
+        * Here we add the present_pages belonging to ZONE_HIGHMEM.
+        * If the zone is within the range of [0..ZONE_HIGHMEM), and
+        * we determine that the zones in that range become empty,
+        * we need to clear the node for N_HIGH_MEMORY.
         */
-       zone_last = ZONE_HIGHMEM;
-       if (N_MEMORY == N_HIGH_MEMORY)
-               zone_last = ZONE_MOVABLE;
-
-       for (; zt <= zone_last; zt++)
-               present_pages += pgdat->node_zones[zt].present_pages;
-       if (zone_idx(zone) <= zone_last && nr_pages >= present_pages)
+       present_pages += pgdat->node_zones[ZONE_HIGHMEM].present_pages;
+       if (zone_idx(zone) <= ZONE_HIGHMEM && nr_pages >= present_pages)
                arg->status_change_nid_high = zone_to_nid(zone);
-       else
-               arg->status_change_nid_high = -1;
-#else
-       arg->status_change_nid_high = arg->status_change_nid_normal;
 #endif
 
        /*
-        * node_states[N_HIGH_MEMORY] contains nodes which have 0...ZONE_MOVABLE
+        * We have accounted the pages from [0..ZONE_NORMAL), and
+        * in case of CONFIG_HIGHMEM the pages from ZONE_HIGHMEM
+        * as well.
+        * Here we count the possible pages from ZONE_MOVABLE.
+        * If after having accounted all the pages, we see that the nr_pages
+        * to be offlined is over or equal to the accounted pages,
+        * we know that the node will become empty, and so, we can clear
+        * it for N_MEMORY as well.
         */
-       zone_last = ZONE_MOVABLE;
+       present_pages += pgdat->node_zones[ZONE_MOVABLE].present_pages;
 
-       /*
-        * check whether node_states[N_HIGH_MEMORY] will be changed
-        * If we try to offline the last present @nr_pages from the node,
-        * we can determind we will need to clear the node from
-        * node_states[N_HIGH_MEMORY].
-        */
-       for (; zt <= zone_last; zt++)
-               present_pages += pgdat->node_zones[zt].present_pages;
        if (nr_pages >= present_pages)
                arg->status_change_nid = zone_to_nid(zone);
-       else
-               arg->status_change_nid = -1;
 }
 
 static void node_states_clear_node(int node, struct memory_notify *arg)