* [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target() @ 2016-07-15 2:47 ` Xishi Qiu 0 siblings, 0 replies; 22+ messages in thread From: Xishi Qiu @ 2016-07-15 2:47 UTC (permalink / raw) To: David Rientjes, Andrew Morton, Vlastimil Babka, Joonsoo Kim, Naoya Horiguchi Cc: Linux MM, LKML alloc_migrate_target() is called from migrate_pages(), and the page is always from user space, so we can add __GFP_HIGHMEM directly. Signed-off-by: Xishi Qiu <qiuxishi@huawei.com> --- mm/page_isolation.c | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/mm/page_isolation.c b/mm/page_isolation.c index 612122b..4f32c9f 100644 --- a/mm/page_isolation.c +++ b/mm/page_isolation.c @@ -282,8 +282,6 @@ int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn, struct page *alloc_migrate_target(struct page *page, unsigned long private, int **resultp) { - gfp_t gfp_mask = GFP_USER | __GFP_MOVABLE; - /* * TODO: allocate a destination hugepage from a nearest neighbor node, * accordance with memory policy of the user process if possible. For @@ -293,9 +291,6 @@ struct page *alloc_migrate_target(struct page *page, unsigned long private, return alloc_huge_page_node(page_hstate(compound_head(page)), next_node_in(page_to_nid(page), node_online_map)); - - if (PageHighMem(page)) - gfp_mask |= __GFP_HIGHMEM; - - return alloc_page(gfp_mask); + else + return alloc_page(GFP_HIGHUSER_MOVABLE); } -- 1.8.3.1 ^ permalink raw reply related [flat|nested] 22+ messages in thread
* [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target() @ 2016-07-15 2:47 ` Xishi Qiu 0 siblings, 0 replies; 22+ messages in thread From: Xishi Qiu @ 2016-07-15 2:47 UTC (permalink / raw) To: David Rientjes, Andrew Morton, Vlastimil Babka, Joonsoo Kim, Naoya Horiguchi Cc: Linux MM, LKML alloc_migrate_target() is called from migrate_pages(), and the page is always from user space, so we can add __GFP_HIGHMEM directly. Signed-off-by: Xishi Qiu <qiuxishi@huawei.com> --- mm/page_isolation.c | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/mm/page_isolation.c b/mm/page_isolation.c index 612122b..4f32c9f 100644 --- a/mm/page_isolation.c +++ b/mm/page_isolation.c @@ -282,8 +282,6 @@ int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn, struct page *alloc_migrate_target(struct page *page, unsigned long private, int **resultp) { - gfp_t gfp_mask = GFP_USER | __GFP_MOVABLE; - /* * TODO: allocate a destination hugepage from a nearest neighbor node, * accordance with memory policy of the user process if possible. For @@ -293,9 +291,6 @@ struct page *alloc_migrate_target(struct page *page, unsigned long private, return alloc_huge_page_node(page_hstate(compound_head(page)), next_node_in(page_to_nid(page), node_online_map)); - - if (PageHighMem(page)) - gfp_mask |= __GFP_HIGHMEM; - - return alloc_page(gfp_mask); + else + return alloc_page(GFP_HIGHUSER_MOVABLE); } -- 1.8.3.1 -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to majordomo@kvack.org. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a> ^ permalink raw reply related [flat|nested] 22+ messages in thread
* [PATCH 2/2] mem-hotplug: use different mempolicy in alloc_migrate_target() 2016-07-15 2:47 ` Xishi Qiu @ 2016-07-15 2:51 ` Xishi Qiu -1 siblings, 0 replies; 22+ messages in thread From: Xishi Qiu @ 2016-07-15 2:51 UTC (permalink / raw) To: David Rientjes, Andrew Morton, Vlastimil Babka, Joonsoo Kim, Naoya Horiguchi Cc: Linux MM, LKML When we offline a node, the new page should alloced from other nodes instead of the current node, because re-migrate is a waste of time. So use prefer mempolicy for hotplug, use default mempolicy for cma. Signed-off-by: Xishi Qiu <qiuxishi@huawei.com> --- include/linux/page-isolation.h | 2 +- mm/memory_hotplug.c | 5 ++++- mm/page_alloc.c | 2 +- mm/page_isolation.c | 8 +++++--- 4 files changed, 11 insertions(+), 6 deletions(-) diff --git a/include/linux/page-isolation.h b/include/linux/page-isolation.h index 047d647..c163de3 100644 --- a/include/linux/page-isolation.h +++ b/include/linux/page-isolation.h @@ -65,7 +65,7 @@ undo_isolate_page_range(unsigned long start_pfn, unsigned long end_pfn, int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn, bool skip_hwpoisoned_pages); -struct page *alloc_migrate_target(struct page *page, unsigned long private, +struct page *alloc_migrate_target(struct page *page, unsigned long nid, int **resultp); #endif diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c index e3cbdca..b5963bf 100644 --- a/mm/memory_hotplug.c +++ b/mm/memory_hotplug.c @@ -1510,12 +1510,15 @@ do_migrate_range(unsigned long start_pfn, unsigned long end_pfn) int move_pages = NR_OFFLINE_AT_ONCE_PAGES; int not_managed = 0; int ret = 0; + int nid = NUMA_NO_NODE; LIST_HEAD(source); for (pfn = start_pfn; pfn < end_pfn && move_pages > 0; pfn++) { if (!pfn_valid(pfn)) continue; page = pfn_to_page(pfn); + if (nid == NUMA_NO_NODE) + nid = next_node_in(page_to_nid(page), node_online_map); if (PageHuge(page)) { struct page *head = compound_head(page); @@ -1568,7 +1571,7 @@ do_migrate_range(unsigned long start_pfn, unsigned long end_pfn) * alloc_migrate_target should be improooooved!! * migrate_pages returns # of failed pages. */ - ret = migrate_pages(&source, alloc_migrate_target, NULL, 0, + ret = migrate_pages(&source, alloc_migrate_target, NULL, nid, MIGRATE_SYNC, MR_MEMORY_HOTPLUG); if (ret) putback_movable_pages(&source); diff --git a/mm/page_alloc.c b/mm/page_alloc.c index 6903b69..b99f1c2 100644 --- a/mm/page_alloc.c +++ b/mm/page_alloc.c @@ -7322,7 +7322,7 @@ static int __alloc_contig_migrate_range(struct compact_control *cc, cc->nr_migratepages -= nr_reclaimed; ret = migrate_pages(&cc->migratepages, alloc_migrate_target, - NULL, 0, cc->mode, MR_CMA); + NULL, NUMA_NO_NODE, cc->mode, MR_CMA); } if (ret < 0) { putback_movable_pages(&cc->migratepages); diff --git a/mm/page_isolation.c b/mm/page_isolation.c index 4f32c9f..f471be6 100644 --- a/mm/page_isolation.c +++ b/mm/page_isolation.c @@ -279,18 +279,20 @@ int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn, return pfn < end_pfn ? -EBUSY : 0; } -struct page *alloc_migrate_target(struct page *page, unsigned long private, +struct page *alloc_migrate_target(struct page *page, unsigned long nid, int **resultp) { /* - * TODO: allocate a destination hugepage from a nearest neighbor node, + * hugeTLB: allocate a destination page from a nearest neighbor node, * accordance with memory policy of the user process if possible. For * now as a simple work-around, we use the next node for destination. + * Normal page: use prefer mempolicy for destination if called by + * hotplug, use default mempolicy for destination if called by cma. */ if (PageHuge(page)) return alloc_huge_page_node(page_hstate(compound_head(page)), next_node_in(page_to_nid(page), node_online_map)); else - return alloc_page(GFP_HIGHUSER_MOVABLE); + return alloc_pages_node(nid, GFP_HIGHUSER_MOVABLE, 0); } -- 1.8.3.1 ^ permalink raw reply related [flat|nested] 22+ messages in thread
* [PATCH 2/2] mem-hotplug: use different mempolicy in alloc_migrate_target() @ 2016-07-15 2:51 ` Xishi Qiu 0 siblings, 0 replies; 22+ messages in thread From: Xishi Qiu @ 2016-07-15 2:51 UTC (permalink / raw) To: David Rientjes, Andrew Morton, Vlastimil Babka, Joonsoo Kim, Naoya Horiguchi Cc: Linux MM, LKML When we offline a node, the new page should alloced from other nodes instead of the current node, because re-migrate is a waste of time. So use prefer mempolicy for hotplug, use default mempolicy for cma. Signed-off-by: Xishi Qiu <qiuxishi@huawei.com> --- include/linux/page-isolation.h | 2 +- mm/memory_hotplug.c | 5 ++++- mm/page_alloc.c | 2 +- mm/page_isolation.c | 8 +++++--- 4 files changed, 11 insertions(+), 6 deletions(-) diff --git a/include/linux/page-isolation.h b/include/linux/page-isolation.h index 047d647..c163de3 100644 --- a/include/linux/page-isolation.h +++ b/include/linux/page-isolation.h @@ -65,7 +65,7 @@ undo_isolate_page_range(unsigned long start_pfn, unsigned long end_pfn, int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn, bool skip_hwpoisoned_pages); -struct page *alloc_migrate_target(struct page *page, unsigned long private, +struct page *alloc_migrate_target(struct page *page, unsigned long nid, int **resultp); #endif diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c index e3cbdca..b5963bf 100644 --- a/mm/memory_hotplug.c +++ b/mm/memory_hotplug.c @@ -1510,12 +1510,15 @@ do_migrate_range(unsigned long start_pfn, unsigned long end_pfn) int move_pages = NR_OFFLINE_AT_ONCE_PAGES; int not_managed = 0; int ret = 0; + int nid = NUMA_NO_NODE; LIST_HEAD(source); for (pfn = start_pfn; pfn < end_pfn && move_pages > 0; pfn++) { if (!pfn_valid(pfn)) continue; page = pfn_to_page(pfn); + if (nid == NUMA_NO_NODE) + nid = next_node_in(page_to_nid(page), node_online_map); if (PageHuge(page)) { struct page *head = compound_head(page); @@ -1568,7 +1571,7 @@ do_migrate_range(unsigned long start_pfn, unsigned long end_pfn) * alloc_migrate_target should be improooooved!! * migrate_pages returns # of failed pages. */ - ret = migrate_pages(&source, alloc_migrate_target, NULL, 0, + ret = migrate_pages(&source, alloc_migrate_target, NULL, nid, MIGRATE_SYNC, MR_MEMORY_HOTPLUG); if (ret) putback_movable_pages(&source); diff --git a/mm/page_alloc.c b/mm/page_alloc.c index 6903b69..b99f1c2 100644 --- a/mm/page_alloc.c +++ b/mm/page_alloc.c @@ -7322,7 +7322,7 @@ static int __alloc_contig_migrate_range(struct compact_control *cc, cc->nr_migratepages -= nr_reclaimed; ret = migrate_pages(&cc->migratepages, alloc_migrate_target, - NULL, 0, cc->mode, MR_CMA); + NULL, NUMA_NO_NODE, cc->mode, MR_CMA); } if (ret < 0) { putback_movable_pages(&cc->migratepages); diff --git a/mm/page_isolation.c b/mm/page_isolation.c index 4f32c9f..f471be6 100644 --- a/mm/page_isolation.c +++ b/mm/page_isolation.c @@ -279,18 +279,20 @@ int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn, return pfn < end_pfn ? -EBUSY : 0; } -struct page *alloc_migrate_target(struct page *page, unsigned long private, +struct page *alloc_migrate_target(struct page *page, unsigned long nid, int **resultp) { /* - * TODO: allocate a destination hugepage from a nearest neighbor node, + * hugeTLB: allocate a destination page from a nearest neighbor node, * accordance with memory policy of the user process if possible. For * now as a simple work-around, we use the next node for destination. + * Normal page: use prefer mempolicy for destination if called by + * hotplug, use default mempolicy for destination if called by cma. */ if (PageHuge(page)) return alloc_huge_page_node(page_hstate(compound_head(page)), next_node_in(page_to_nid(page), node_online_map)); else - return alloc_page(GFP_HIGHUSER_MOVABLE); + return alloc_pages_node(nid, GFP_HIGHUSER_MOVABLE, 0); } -- 1.8.3.1 -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to majordomo@kvack.org. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a> ^ permalink raw reply related [flat|nested] 22+ messages in thread
* Re: [PATCH 2/2] mem-hotplug: use different mempolicy in alloc_migrate_target() 2016-07-15 2:51 ` Xishi Qiu @ 2016-07-18 8:00 ` Vlastimil Babka -1 siblings, 0 replies; 22+ messages in thread From: Vlastimil Babka @ 2016-07-18 8:00 UTC (permalink / raw) To: Xishi Qiu, David Rientjes, Andrew Morton, Joonsoo Kim, Naoya Horiguchi Cc: Linux MM, LKML, Minchan Kim On 07/15/2016 04:51 AM, Xishi Qiu wrote: > When we offline a node, the new page should alloced from other > nodes instead of the current node, because re-migrate is a waste of > time. Ugh, I'm surprised that it's not the case already. Maybe the allocation from same node is already prevented indirectly somehow? > So use prefer mempolicy for hotplug, use default mempolicy for cma. IMHO CMA should prefer the same node as the migrated page, if anything. Current task's mempolicy shouldn't restrict it (it's likely migrating pages of somebody else) or even guide its preferences. Ideally it would keep the original page's mempolicy, but we can't afford to track that... > Signed-off-by: Xishi Qiu <qiuxishi@huawei.com> > --- > include/linux/page-isolation.h | 2 +- > mm/memory_hotplug.c | 5 ++++- > mm/page_alloc.c | 2 +- > mm/page_isolation.c | 8 +++++--- > 4 files changed, 11 insertions(+), 6 deletions(-) > > diff --git a/include/linux/page-isolation.h b/include/linux/page-isolation.h > index 047d647..c163de3 100644 > --- a/include/linux/page-isolation.h > +++ b/include/linux/page-isolation.h > @@ -65,7 +65,7 @@ undo_isolate_page_range(unsigned long start_pfn, unsigned long end_pfn, > int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn, > bool skip_hwpoisoned_pages); > > -struct page *alloc_migrate_target(struct page *page, unsigned long private, > +struct page *alloc_migrate_target(struct page *page, unsigned long nid, > int **resultp); > > #endif > diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c > index e3cbdca..b5963bf 100644 > --- a/mm/memory_hotplug.c > +++ b/mm/memory_hotplug.c > @@ -1510,12 +1510,15 @@ do_migrate_range(unsigned long start_pfn, unsigned long end_pfn) > int move_pages = NR_OFFLINE_AT_ONCE_PAGES; > int not_managed = 0; > int ret = 0; > + int nid = NUMA_NO_NODE; > LIST_HEAD(source); > > for (pfn = start_pfn; pfn < end_pfn && move_pages > 0; pfn++) { > if (!pfn_valid(pfn)) > continue; > page = pfn_to_page(pfn); > + if (nid == NUMA_NO_NODE) > + nid = next_node_in(page_to_nid(page), node_online_map); > > if (PageHuge(page)) { > struct page *head = compound_head(page); > @@ -1568,7 +1571,7 @@ do_migrate_range(unsigned long start_pfn, unsigned long end_pfn) > * alloc_migrate_target should be improooooved!! So, is this patch improooooving it enough that we can delete the comment? If not, could the patch be improooooved? :) > * migrate_pages returns # of failed pages. > */ > - ret = migrate_pages(&source, alloc_migrate_target, NULL, 0, > + ret = migrate_pages(&source, alloc_migrate_target, NULL, nid, > MIGRATE_SYNC, MR_MEMORY_HOTPLUG); > if (ret) > putback_movable_pages(&source); > diff --git a/mm/page_alloc.c b/mm/page_alloc.c > index 6903b69..b99f1c2 100644 > --- a/mm/page_alloc.c > +++ b/mm/page_alloc.c > @@ -7322,7 +7322,7 @@ static int __alloc_contig_migrate_range(struct compact_control *cc, > cc->nr_migratepages -= nr_reclaimed; > > ret = migrate_pages(&cc->migratepages, alloc_migrate_target, > - NULL, 0, cc->mode, MR_CMA); > + NULL, NUMA_NO_NODE, cc->mode, MR_CMA); > } > if (ret < 0) { > putback_movable_pages(&cc->migratepages); > diff --git a/mm/page_isolation.c b/mm/page_isolation.c > index 4f32c9f..f471be6 100644 > --- a/mm/page_isolation.c > +++ b/mm/page_isolation.c > @@ -279,18 +279,20 @@ int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn, > return pfn < end_pfn ? -EBUSY : 0; > } > > -struct page *alloc_migrate_target(struct page *page, unsigned long private, > +struct page *alloc_migrate_target(struct page *page, unsigned long nid, > int **resultp) > { > /* > - * TODO: allocate a destination hugepage from a nearest neighbor node, > + * hugeTLB: allocate a destination page from a nearest neighbor node, for hugeTLB it's still a TODO, by removing the word the rest of comment doesn't make much sense > * accordance with memory policy of the user process if possible. For > * now as a simple work-around, we use the next node for destination. > + * Normal page: use prefer mempolicy for destination if called by > + * hotplug, use default mempolicy for destination if called by cma. > */ > if (PageHuge(page)) > return alloc_huge_page_node(page_hstate(compound_head(page)), > next_node_in(page_to_nid(page), > node_online_map)); > else > - return alloc_page(GFP_HIGHUSER_MOVABLE); > + return alloc_pages_node(nid, GFP_HIGHUSER_MOVABLE, 0); > } > ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [PATCH 2/2] mem-hotplug: use different mempolicy in alloc_migrate_target() @ 2016-07-18 8:00 ` Vlastimil Babka 0 siblings, 0 replies; 22+ messages in thread From: Vlastimil Babka @ 2016-07-18 8:00 UTC (permalink / raw) To: Xishi Qiu, David Rientjes, Andrew Morton, Joonsoo Kim, Naoya Horiguchi Cc: Linux MM, LKML, Minchan Kim On 07/15/2016 04:51 AM, Xishi Qiu wrote: > When we offline a node, the new page should alloced from other > nodes instead of the current node, because re-migrate is a waste of > time. Ugh, I'm surprised that it's not the case already. Maybe the allocation from same node is already prevented indirectly somehow? > So use prefer mempolicy for hotplug, use default mempolicy for cma. IMHO CMA should prefer the same node as the migrated page, if anything. Current task's mempolicy shouldn't restrict it (it's likely migrating pages of somebody else) or even guide its preferences. Ideally it would keep the original page's mempolicy, but we can't afford to track that... > Signed-off-by: Xishi Qiu <qiuxishi@huawei.com> > --- > include/linux/page-isolation.h | 2 +- > mm/memory_hotplug.c | 5 ++++- > mm/page_alloc.c | 2 +- > mm/page_isolation.c | 8 +++++--- > 4 files changed, 11 insertions(+), 6 deletions(-) > > diff --git a/include/linux/page-isolation.h b/include/linux/page-isolation.h > index 047d647..c163de3 100644 > --- a/include/linux/page-isolation.h > +++ b/include/linux/page-isolation.h > @@ -65,7 +65,7 @@ undo_isolate_page_range(unsigned long start_pfn, unsigned long end_pfn, > int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn, > bool skip_hwpoisoned_pages); > > -struct page *alloc_migrate_target(struct page *page, unsigned long private, > +struct page *alloc_migrate_target(struct page *page, unsigned long nid, > int **resultp); > > #endif > diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c > index e3cbdca..b5963bf 100644 > --- a/mm/memory_hotplug.c > +++ b/mm/memory_hotplug.c > @@ -1510,12 +1510,15 @@ do_migrate_range(unsigned long start_pfn, unsigned long end_pfn) > int move_pages = NR_OFFLINE_AT_ONCE_PAGES; > int not_managed = 0; > int ret = 0; > + int nid = NUMA_NO_NODE; > LIST_HEAD(source); > > for (pfn = start_pfn; pfn < end_pfn && move_pages > 0; pfn++) { > if (!pfn_valid(pfn)) > continue; > page = pfn_to_page(pfn); > + if (nid == NUMA_NO_NODE) > + nid = next_node_in(page_to_nid(page), node_online_map); > > if (PageHuge(page)) { > struct page *head = compound_head(page); > @@ -1568,7 +1571,7 @@ do_migrate_range(unsigned long start_pfn, unsigned long end_pfn) > * alloc_migrate_target should be improooooved!! So, is this patch improooooving it enough that we can delete the comment? If not, could the patch be improooooved? :) > * migrate_pages returns # of failed pages. > */ > - ret = migrate_pages(&source, alloc_migrate_target, NULL, 0, > + ret = migrate_pages(&source, alloc_migrate_target, NULL, nid, > MIGRATE_SYNC, MR_MEMORY_HOTPLUG); > if (ret) > putback_movable_pages(&source); > diff --git a/mm/page_alloc.c b/mm/page_alloc.c > index 6903b69..b99f1c2 100644 > --- a/mm/page_alloc.c > +++ b/mm/page_alloc.c > @@ -7322,7 +7322,7 @@ static int __alloc_contig_migrate_range(struct compact_control *cc, > cc->nr_migratepages -= nr_reclaimed; > > ret = migrate_pages(&cc->migratepages, alloc_migrate_target, > - NULL, 0, cc->mode, MR_CMA); > + NULL, NUMA_NO_NODE, cc->mode, MR_CMA); > } > if (ret < 0) { > putback_movable_pages(&cc->migratepages); > diff --git a/mm/page_isolation.c b/mm/page_isolation.c > index 4f32c9f..f471be6 100644 > --- a/mm/page_isolation.c > +++ b/mm/page_isolation.c > @@ -279,18 +279,20 @@ int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn, > return pfn < end_pfn ? -EBUSY : 0; > } > > -struct page *alloc_migrate_target(struct page *page, unsigned long private, > +struct page *alloc_migrate_target(struct page *page, unsigned long nid, > int **resultp) > { > /* > - * TODO: allocate a destination hugepage from a nearest neighbor node, > + * hugeTLB: allocate a destination page from a nearest neighbor node, for hugeTLB it's still a TODO, by removing the word the rest of comment doesn't make much sense > * accordance with memory policy of the user process if possible. For > * now as a simple work-around, we use the next node for destination. > + * Normal page: use prefer mempolicy for destination if called by > + * hotplug, use default mempolicy for destination if called by cma. > */ > if (PageHuge(page)) > return alloc_huge_page_node(page_hstate(compound_head(page)), > next_node_in(page_to_nid(page), > node_online_map)); > else > - return alloc_page(GFP_HIGHUSER_MOVABLE); > + return alloc_pages_node(nid, GFP_HIGHUSER_MOVABLE, 0); > } > -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to majordomo@kvack.org. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a> ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target() 2016-07-15 2:47 ` Xishi Qiu @ 2016-07-18 5:51 ` Joonsoo Kim -1 siblings, 0 replies; 22+ messages in thread From: Joonsoo Kim @ 2016-07-18 5:51 UTC (permalink / raw) To: Xishi Qiu Cc: David Rientjes, Andrew Morton, Vlastimil Babka, Naoya Horiguchi, Linux MM, LKML On Fri, Jul 15, 2016 at 10:47:06AM +0800, Xishi Qiu wrote: > alloc_migrate_target() is called from migrate_pages(), and the page > is always from user space, so we can add __GFP_HIGHMEM directly. No, all migratable pages are not from user space. For example, blockdev file cache has __GFP_MOVABLE and migratable but it has no __GFP_HIGHMEM and __GFP_USER. And, zram's memory isn't GFP_HIGHUSER_MOVABLE but has __GFP_MOVABLE. Thanks. ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target() @ 2016-07-18 5:51 ` Joonsoo Kim 0 siblings, 0 replies; 22+ messages in thread From: Joonsoo Kim @ 2016-07-18 5:51 UTC (permalink / raw) To: Xishi Qiu Cc: David Rientjes, Andrew Morton, Vlastimil Babka, Naoya Horiguchi, Linux MM, LKML On Fri, Jul 15, 2016 at 10:47:06AM +0800, Xishi Qiu wrote: > alloc_migrate_target() is called from migrate_pages(), and the page > is always from user space, so we can add __GFP_HIGHMEM directly. No, all migratable pages are not from user space. For example, blockdev file cache has __GFP_MOVABLE and migratable but it has no __GFP_HIGHMEM and __GFP_USER. And, zram's memory isn't GFP_HIGHUSER_MOVABLE but has __GFP_MOVABLE. Thanks. -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to majordomo@kvack.org. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a> ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target() 2016-07-18 5:51 ` Joonsoo Kim @ 2016-07-18 7:45 ` Vlastimil Babka -1 siblings, 0 replies; 22+ messages in thread From: Vlastimil Babka @ 2016-07-18 7:45 UTC (permalink / raw) To: Joonsoo Kim, Xishi Qiu Cc: David Rientjes, Andrew Morton, Naoya Horiguchi, Linux MM, LKML On 07/18/2016 07:51 AM, Joonsoo Kim wrote: > On Fri, Jul 15, 2016 at 10:47:06AM +0800, Xishi Qiu wrote: >> alloc_migrate_target() is called from migrate_pages(), and the page >> is always from user space, so we can add __GFP_HIGHMEM directly. > > No, all migratable pages are not from user space. For example, > blockdev file cache has __GFP_MOVABLE and migratable but it has no > __GFP_HIGHMEM and __GFP_USER. > > And, zram's memory isn't GFP_HIGHUSER_MOVABLE but has __GFP_MOVABLE. Right, and there's also Minchan's series for arbitrary driver page migration... > Thanks. > ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target() @ 2016-07-18 7:45 ` Vlastimil Babka 0 siblings, 0 replies; 22+ messages in thread From: Vlastimil Babka @ 2016-07-18 7:45 UTC (permalink / raw) To: Joonsoo Kim, Xishi Qiu Cc: David Rientjes, Andrew Morton, Naoya Horiguchi, Linux MM, LKML On 07/18/2016 07:51 AM, Joonsoo Kim wrote: > On Fri, Jul 15, 2016 at 10:47:06AM +0800, Xishi Qiu wrote: >> alloc_migrate_target() is called from migrate_pages(), and the page >> is always from user space, so we can add __GFP_HIGHMEM directly. > > No, all migratable pages are not from user space. For example, > blockdev file cache has __GFP_MOVABLE and migratable but it has no > __GFP_HIGHMEM and __GFP_USER. > > And, zram's memory isn't GFP_HIGHUSER_MOVABLE but has __GFP_MOVABLE. Right, and there's also Minchan's series for arbitrary driver page migration... > Thanks. > -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to majordomo@kvack.org. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a> ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target() 2016-07-18 5:51 ` Joonsoo Kim @ 2016-07-18 8:00 ` Xishi Qiu -1 siblings, 0 replies; 22+ messages in thread From: Xishi Qiu @ 2016-07-18 8:00 UTC (permalink / raw) To: Joonsoo Kim Cc: David Rientjes, Andrew Morton, Vlastimil Babka, Naoya Horiguchi, Linux MM, LKML On 2016/7/18 13:51, Joonsoo Kim wrote: > On Fri, Jul 15, 2016 at 10:47:06AM +0800, Xishi Qiu wrote: >> alloc_migrate_target() is called from migrate_pages(), and the page >> is always from user space, so we can add __GFP_HIGHMEM directly. > > No, all migratable pages are not from user space. For example, > blockdev file cache has __GFP_MOVABLE and migratable but it has no > __GFP_HIGHMEM and __GFP_USER. > Hi Joonsoo, So the original code "gfp_t gfp_mask = GFP_USER | __GFP_MOVABLE;" is not correct? > And, zram's memory isn't GFP_HIGHUSER_MOVABLE but has __GFP_MOVABLE. > Can we distinguish __GFP_MOVABLE or GFP_HIGHUSER_MOVABLE when doing mem-hotplug? Thanks, Xishi Qiu > Thanks. > > > . > ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target() @ 2016-07-18 8:00 ` Xishi Qiu 0 siblings, 0 replies; 22+ messages in thread From: Xishi Qiu @ 2016-07-18 8:00 UTC (permalink / raw) To: Joonsoo Kim Cc: David Rientjes, Andrew Morton, Vlastimil Babka, Naoya Horiguchi, Linux MM, LKML On 2016/7/18 13:51, Joonsoo Kim wrote: > On Fri, Jul 15, 2016 at 10:47:06AM +0800, Xishi Qiu wrote: >> alloc_migrate_target() is called from migrate_pages(), and the page >> is always from user space, so we can add __GFP_HIGHMEM directly. > > No, all migratable pages are not from user space. For example, > blockdev file cache has __GFP_MOVABLE and migratable but it has no > __GFP_HIGHMEM and __GFP_USER. > Hi Joonsoo, So the original code "gfp_t gfp_mask = GFP_USER | __GFP_MOVABLE;" is not correct? > And, zram's memory isn't GFP_HIGHUSER_MOVABLE but has __GFP_MOVABLE. > Can we distinguish __GFP_MOVABLE or GFP_HIGHUSER_MOVABLE when doing mem-hotplug? Thanks, Xishi Qiu > Thanks. > > > . > -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to majordomo@kvack.org. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a> ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target() 2016-07-18 8:00 ` Xishi Qiu @ 2016-07-18 8:05 ` Vlastimil Babka -1 siblings, 0 replies; 22+ messages in thread From: Vlastimil Babka @ 2016-07-18 8:05 UTC (permalink / raw) To: Xishi Qiu, Joonsoo Kim Cc: David Rientjes, Andrew Morton, Naoya Horiguchi, Linux MM, LKML On 07/18/2016 10:00 AM, Xishi Qiu wrote: > On 2016/7/18 13:51, Joonsoo Kim wrote: > >> On Fri, Jul 15, 2016 at 10:47:06AM +0800, Xishi Qiu wrote: >>> alloc_migrate_target() is called from migrate_pages(), and the page >>> is always from user space, so we can add __GFP_HIGHMEM directly. >> >> No, all migratable pages are not from user space. For example, >> blockdev file cache has __GFP_MOVABLE and migratable but it has no >> __GFP_HIGHMEM and __GFP_USER. >> > > Hi Joonsoo, > > So the original code "gfp_t gfp_mask = GFP_USER | __GFP_MOVABLE;" > is not correct? It's not incorrect. GFP_USER just specifies some reclaim flags, and may perhaps restrict allocation through __GFP_HARDWALL, where the original page could have been allocated without the restriction. But it doesn't put the place in an unexpected address range, as placing a non-highmem page into highmem could. __GFP_MOVABLE then just controls a heuristic for placement within a zone. >> And, zram's memory isn't GFP_HIGHUSER_MOVABLE but has __GFP_MOVABLE. >> > > Can we distinguish __GFP_MOVABLE or GFP_HIGHUSER_MOVABLE when doing > mem-hotplug? I don't understand the question here, can you rephrase with more detail? Thanks. > Thanks, > Xishi Qiu > >> Thanks. >> >> >> . >> > > > ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target() @ 2016-07-18 8:05 ` Vlastimil Babka 0 siblings, 0 replies; 22+ messages in thread From: Vlastimil Babka @ 2016-07-18 8:05 UTC (permalink / raw) To: Xishi Qiu, Joonsoo Kim Cc: David Rientjes, Andrew Morton, Naoya Horiguchi, Linux MM, LKML On 07/18/2016 10:00 AM, Xishi Qiu wrote: > On 2016/7/18 13:51, Joonsoo Kim wrote: > >> On Fri, Jul 15, 2016 at 10:47:06AM +0800, Xishi Qiu wrote: >>> alloc_migrate_target() is called from migrate_pages(), and the page >>> is always from user space, so we can add __GFP_HIGHMEM directly. >> >> No, all migratable pages are not from user space. For example, >> blockdev file cache has __GFP_MOVABLE and migratable but it has no >> __GFP_HIGHMEM and __GFP_USER. >> > > Hi Joonsoo, > > So the original code "gfp_t gfp_mask = GFP_USER | __GFP_MOVABLE;" > is not correct? It's not incorrect. GFP_USER just specifies some reclaim flags, and may perhaps restrict allocation through __GFP_HARDWALL, where the original page could have been allocated without the restriction. But it doesn't put the place in an unexpected address range, as placing a non-highmem page into highmem could. __GFP_MOVABLE then just controls a heuristic for placement within a zone. >> And, zram's memory isn't GFP_HIGHUSER_MOVABLE but has __GFP_MOVABLE. >> > > Can we distinguish __GFP_MOVABLE or GFP_HIGHUSER_MOVABLE when doing > mem-hotplug? I don't understand the question here, can you rephrase with more detail? Thanks. > Thanks, > Xishi Qiu > >> Thanks. >> >> >> . >> > > > -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to majordomo@kvack.org. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a> ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target() 2016-07-18 8:05 ` Vlastimil Babka @ 2016-07-18 8:31 ` Xishi Qiu -1 siblings, 0 replies; 22+ messages in thread From: Xishi Qiu @ 2016-07-18 8:31 UTC (permalink / raw) To: Vlastimil Babka Cc: Joonsoo Kim, David Rientjes, Andrew Morton, Naoya Horiguchi, Linux MM, LKML On 2016/7/18 16:05, Vlastimil Babka wrote: > On 07/18/2016 10:00 AM, Xishi Qiu wrote: >> On 2016/7/18 13:51, Joonsoo Kim wrote: >> >>> On Fri, Jul 15, 2016 at 10:47:06AM +0800, Xishi Qiu wrote: >>>> alloc_migrate_target() is called from migrate_pages(), and the page >>>> is always from user space, so we can add __GFP_HIGHMEM directly. >>> >>> No, all migratable pages are not from user space. For example, >>> blockdev file cache has __GFP_MOVABLE and migratable but it has no >>> __GFP_HIGHMEM and __GFP_USER. >>> >> >> Hi Joonsoo, >> >> So the original code "gfp_t gfp_mask = GFP_USER | __GFP_MOVABLE;" >> is not correct? > > It's not incorrect. GFP_USER just specifies some reclaim flags, and may perhaps restrict allocation through __GFP_HARDWALL, where the original > page could have been allocated without the restriction. But it doesn't put the place in an unexpected address range, as placing a non-highmem page into highmem could. __GFP_MOVABLE then just controls a heuristic for placement within a zone. > >>> And, zram's memory isn't GFP_HIGHUSER_MOVABLE but has __GFP_MOVABLE. >>> >> >> Can we distinguish __GFP_MOVABLE or GFP_HIGHUSER_MOVABLE when doing >> mem-hotplug? > > I don't understand the question here, can you rephrase with more detail? Thanks. > Hi Joonsoo, When we do memory offline, and the zone is movable zone, can we use "alloc_pages_node(nid, GFP_HIGHUSER_MOVABLE, 0);" to alloc a new page? the nid is the next node. Thanks, Xishi Qiu >> Thanks, >> Xishi Qiu >> >>> Thanks. >>> >>> >>> . >>> >> >> >> > > > . > ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target() @ 2016-07-18 8:31 ` Xishi Qiu 0 siblings, 0 replies; 22+ messages in thread From: Xishi Qiu @ 2016-07-18 8:31 UTC (permalink / raw) To: Vlastimil Babka Cc: Joonsoo Kim, David Rientjes, Andrew Morton, Naoya Horiguchi, Linux MM, LKML On 2016/7/18 16:05, Vlastimil Babka wrote: > On 07/18/2016 10:00 AM, Xishi Qiu wrote: >> On 2016/7/18 13:51, Joonsoo Kim wrote: >> >>> On Fri, Jul 15, 2016 at 10:47:06AM +0800, Xishi Qiu wrote: >>>> alloc_migrate_target() is called from migrate_pages(), and the page >>>> is always from user space, so we can add __GFP_HIGHMEM directly. >>> >>> No, all migratable pages are not from user space. For example, >>> blockdev file cache has __GFP_MOVABLE and migratable but it has no >>> __GFP_HIGHMEM and __GFP_USER. >>> >> >> Hi Joonsoo, >> >> So the original code "gfp_t gfp_mask = GFP_USER | __GFP_MOVABLE;" >> is not correct? > > It's not incorrect. GFP_USER just specifies some reclaim flags, and may perhaps restrict allocation through __GFP_HARDWALL, where the original > page could have been allocated without the restriction. But it doesn't put the place in an unexpected address range, as placing a non-highmem page into highmem could. __GFP_MOVABLE then just controls a heuristic for placement within a zone. > >>> And, zram's memory isn't GFP_HIGHUSER_MOVABLE but has __GFP_MOVABLE. >>> >> >> Can we distinguish __GFP_MOVABLE or GFP_HIGHUSER_MOVABLE when doing >> mem-hotplug? > > I don't understand the question here, can you rephrase with more detail? Thanks. > Hi Joonsoo, When we do memory offline, and the zone is movable zone, can we use "alloc_pages_node(nid, GFP_HIGHUSER_MOVABLE, 0);" to alloc a new page? the nid is the next node. Thanks, Xishi Qiu >> Thanks, >> Xishi Qiu >> >>> Thanks. >>> >>> >>> . >>> >> >> >> > > > . > -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to majordomo@kvack.org. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a> ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target() 2016-07-18 8:31 ` Xishi Qiu @ 2016-07-19 6:50 ` Joonsoo Kim -1 siblings, 0 replies; 22+ messages in thread From: Joonsoo Kim @ 2016-07-19 6:50 UTC (permalink / raw) To: Xishi Qiu Cc: Vlastimil Babka, David Rientjes, Andrew Morton, Naoya Horiguchi, Linux MM, LKML On Mon, Jul 18, 2016 at 04:31:11PM +0800, Xishi Qiu wrote: > On 2016/7/18 16:05, Vlastimil Babka wrote: > > > On 07/18/2016 10:00 AM, Xishi Qiu wrote: > >> On 2016/7/18 13:51, Joonsoo Kim wrote: > >> > >>> On Fri, Jul 15, 2016 at 10:47:06AM +0800, Xishi Qiu wrote: > >>>> alloc_migrate_target() is called from migrate_pages(), and the page > >>>> is always from user space, so we can add __GFP_HIGHMEM directly. > >>> > >>> No, all migratable pages are not from user space. For example, > >>> blockdev file cache has __GFP_MOVABLE and migratable but it has no > >>> __GFP_HIGHMEM and __GFP_USER. > >>> > >> > >> Hi Joonsoo, > >> > >> So the original code "gfp_t gfp_mask = GFP_USER | __GFP_MOVABLE;" > >> is not correct? > > > > It's not incorrect. GFP_USER just specifies some reclaim flags, and may perhaps restrict allocation through __GFP_HARDWALL, where the original > > page could have been allocated without the restriction. But it doesn't put the place in an unexpected address range, as placing a non-highmem page into highmem could. __GFP_MOVABLE then just controls a heuristic for placement within a zone. > > > >>> And, zram's memory isn't GFP_HIGHUSER_MOVABLE but has __GFP_MOVABLE. > >>> > >> > >> Can we distinguish __GFP_MOVABLE or GFP_HIGHUSER_MOVABLE when doing > >> mem-hotplug? > > > > I don't understand the question here, can you rephrase with more detail? Thanks. > > > > Hi Joonsoo, Above is answered by Vlastimil. :) > When we do memory offline, and the zone is movable zone, > can we use "alloc_pages_node(nid, GFP_HIGHUSER_MOVABLE, 0);" to alloc a > new page? the nid is the next node. I don't know much about memory offline, but, AFAIK, memory offline could happen on non-movable zone like as ZONE_NORMAL. Perhaps, you can add "if zone of the page is movable zone then alloc with GFP_HIGHUSER_MOVABLE". Thanks. ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target() @ 2016-07-19 6:50 ` Joonsoo Kim 0 siblings, 0 replies; 22+ messages in thread From: Joonsoo Kim @ 2016-07-19 6:50 UTC (permalink / raw) To: Xishi Qiu Cc: Vlastimil Babka, David Rientjes, Andrew Morton, Naoya Horiguchi, Linux MM, LKML On Mon, Jul 18, 2016 at 04:31:11PM +0800, Xishi Qiu wrote: > On 2016/7/18 16:05, Vlastimil Babka wrote: > > > On 07/18/2016 10:00 AM, Xishi Qiu wrote: > >> On 2016/7/18 13:51, Joonsoo Kim wrote: > >> > >>> On Fri, Jul 15, 2016 at 10:47:06AM +0800, Xishi Qiu wrote: > >>>> alloc_migrate_target() is called from migrate_pages(), and the page > >>>> is always from user space, so we can add __GFP_HIGHMEM directly. > >>> > >>> No, all migratable pages are not from user space. For example, > >>> blockdev file cache has __GFP_MOVABLE and migratable but it has no > >>> __GFP_HIGHMEM and __GFP_USER. > >>> > >> > >> Hi Joonsoo, > >> > >> So the original code "gfp_t gfp_mask = GFP_USER | __GFP_MOVABLE;" > >> is not correct? > > > > It's not incorrect. GFP_USER just specifies some reclaim flags, and may perhaps restrict allocation through __GFP_HARDWALL, where the original > > page could have been allocated without the restriction. But it doesn't put the place in an unexpected address range, as placing a non-highmem page into highmem could. __GFP_MOVABLE then just controls a heuristic for placement within a zone. > > > >>> And, zram's memory isn't GFP_HIGHUSER_MOVABLE but has __GFP_MOVABLE. > >>> > >> > >> Can we distinguish __GFP_MOVABLE or GFP_HIGHUSER_MOVABLE when doing > >> mem-hotplug? > > > > I don't understand the question here, can you rephrase with more detail? Thanks. > > > > Hi Joonsoo, Above is answered by Vlastimil. :) > When we do memory offline, and the zone is movable zone, > can we use "alloc_pages_node(nid, GFP_HIGHUSER_MOVABLE, 0);" to alloc a > new page? the nid is the next node. I don't know much about memory offline, but, AFAIK, memory offline could happen on non-movable zone like as ZONE_NORMAL. Perhaps, you can add "if zone of the page is movable zone then alloc with GFP_HIGHUSER_MOVABLE". Thanks. -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to majordomo@kvack.org. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a> ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target() 2016-07-19 6:50 ` Joonsoo Kim @ 2016-07-19 7:18 ` Xishi Qiu -1 siblings, 0 replies; 22+ messages in thread From: Xishi Qiu @ 2016-07-19 7:18 UTC (permalink / raw) To: Joonsoo Kim, Vlastimil Babka Cc: David Rientjes, Andrew Morton, Naoya Horiguchi, Linux MM, LKML On 2016/7/19 14:50, Joonsoo Kim wrote: > On Mon, Jul 18, 2016 at 04:31:11PM +0800, Xishi Qiu wrote: >> On 2016/7/18 16:05, Vlastimil Babka wrote: >> >>> On 07/18/2016 10:00 AM, Xishi Qiu wrote: >>>> On 2016/7/18 13:51, Joonsoo Kim wrote: >>>> >>>>> On Fri, Jul 15, 2016 at 10:47:06AM +0800, Xishi Qiu wrote: >>>>>> alloc_migrate_target() is called from migrate_pages(), and the page >>>>>> is always from user space, so we can add __GFP_HIGHMEM directly. >>>>> >>>>> No, all migratable pages are not from user space. For example, >>>>> blockdev file cache has __GFP_MOVABLE and migratable but it has no >>>>> __GFP_HIGHMEM and __GFP_USER. >>>>> >>>> >>>> Hi Joonsoo, >>>> >>>> So the original code "gfp_t gfp_mask = GFP_USER | __GFP_MOVABLE;" >>>> is not correct? >>> >>> It's not incorrect. GFP_USER just specifies some reclaim flags, and may perhaps restrict allocation through __GFP_HARDWALL, where the original >>> page could have been allocated without the restriction. But it doesn't put the place in an unexpected address range, as placing a non-highmem page into highmem could. __GFP_MOVABLE then just controls a heuristic for placement within a zone. >>> >>>>> And, zram's memory isn't GFP_HIGHUSER_MOVABLE but has __GFP_MOVABLE. >>>>> >>>> >>>> Can we distinguish __GFP_MOVABLE or GFP_HIGHUSER_MOVABLE when doing >>>> mem-hotplug? >>> >>> I don't understand the question here, can you rephrase with more detail? Thanks. >>> >> >> Hi Joonsoo, > > Above is answered by Vlastimil. :) > >> When we do memory offline, and the zone is movable zone, >> can we use "alloc_pages_node(nid, GFP_HIGHUSER_MOVABLE, 0);" to alloc a >> new page? the nid is the next node. > > I don't know much about memory offline, but, AFAIK, memory offline > could happen on non-movable zone like as ZONE_NORMAL. Perhaps, you can add > "if zone of the page is movable zone then alloc with GFP_HIGHUSER_MOVABLE". > > Thanks. > Hi Joonsoo and Vlastimil, Memory offline could happen on both movable zone and non-movable zone, and we can offline the whole node if the zone is movable_zone(the node only has one movable_zone), and if the zone is normal_zone, we cannot offline the whole node, because some kernel memory can't be migrated. So how about change alloc_migrate_target() to alloc memory from the next node with GFP_HIGHUSER_MOVABLE, if the offline zone is movable_zone. And if the offline zone is normal_zone, we don't change anything, that means the new page may be from the same node. Thanks, Xishi Qiu > . > ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target() @ 2016-07-19 7:18 ` Xishi Qiu 0 siblings, 0 replies; 22+ messages in thread From: Xishi Qiu @ 2016-07-19 7:18 UTC (permalink / raw) To: Joonsoo Kim, Vlastimil Babka Cc: David Rientjes, Andrew Morton, Naoya Horiguchi, Linux MM, LKML On 2016/7/19 14:50, Joonsoo Kim wrote: > On Mon, Jul 18, 2016 at 04:31:11PM +0800, Xishi Qiu wrote: >> On 2016/7/18 16:05, Vlastimil Babka wrote: >> >>> On 07/18/2016 10:00 AM, Xishi Qiu wrote: >>>> On 2016/7/18 13:51, Joonsoo Kim wrote: >>>> >>>>> On Fri, Jul 15, 2016 at 10:47:06AM +0800, Xishi Qiu wrote: >>>>>> alloc_migrate_target() is called from migrate_pages(), and the page >>>>>> is always from user space, so we can add __GFP_HIGHMEM directly. >>>>> >>>>> No, all migratable pages are not from user space. For example, >>>>> blockdev file cache has __GFP_MOVABLE and migratable but it has no >>>>> __GFP_HIGHMEM and __GFP_USER. >>>>> >>>> >>>> Hi Joonsoo, >>>> >>>> So the original code "gfp_t gfp_mask = GFP_USER | __GFP_MOVABLE;" >>>> is not correct? >>> >>> It's not incorrect. GFP_USER just specifies some reclaim flags, and may perhaps restrict allocation through __GFP_HARDWALL, where the original >>> page could have been allocated without the restriction. But it doesn't put the place in an unexpected address range, as placing a non-highmem page into highmem could. __GFP_MOVABLE then just controls a heuristic for placement within a zone. >>> >>>>> And, zram's memory isn't GFP_HIGHUSER_MOVABLE but has __GFP_MOVABLE. >>>>> >>>> >>>> Can we distinguish __GFP_MOVABLE or GFP_HIGHUSER_MOVABLE when doing >>>> mem-hotplug? >>> >>> I don't understand the question here, can you rephrase with more detail? Thanks. >>> >> >> Hi Joonsoo, > > Above is answered by Vlastimil. :) > >> When we do memory offline, and the zone is movable zone, >> can we use "alloc_pages_node(nid, GFP_HIGHUSER_MOVABLE, 0);" to alloc a >> new page? the nid is the next node. > > I don't know much about memory offline, but, AFAIK, memory offline > could happen on non-movable zone like as ZONE_NORMAL. Perhaps, you can add > "if zone of the page is movable zone then alloc with GFP_HIGHUSER_MOVABLE". > > Thanks. > Hi Joonsoo and Vlastimil, Memory offline could happen on both movable zone and non-movable zone, and we can offline the whole node if the zone is movable_zone(the node only has one movable_zone), and if the zone is normal_zone, we cannot offline the whole node, because some kernel memory can't be migrated. So how about change alloc_migrate_target() to alloc memory from the next node with GFP_HIGHUSER_MOVABLE, if the offline zone is movable_zone. And if the offline zone is normal_zone, we don't change anything, that means the new page may be from the same node. Thanks, Xishi Qiu > . > -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to majordomo@kvack.org. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a> ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target() 2016-07-19 7:18 ` Xishi Qiu @ 2016-07-19 19:05 ` David Rientjes -1 siblings, 0 replies; 22+ messages in thread From: David Rientjes @ 2016-07-19 19:05 UTC (permalink / raw) To: Xishi Qiu Cc: Joonsoo Kim, Vlastimil Babka, Andrew Morton, Naoya Horiguchi, Linux MM, LKML On Tue, 19 Jul 2016, Xishi Qiu wrote: > Memory offline could happen on both movable zone and non-movable zone, and we > can offline the whole node if the zone is movable_zone(the node only has one > movable_zone), and if the zone is normal_zone, we cannot offline the whole node, > because some kernel memory can't be migrated. > > So how about change alloc_migrate_target() to alloc memory from the next node > with GFP_HIGHUSER_MOVABLE, if the offline zone is movable_zone. > I think sharing alloc_migrate_target as a migration callback may not be worth it; CMA and memory offline are distinct usecases and probably deserve their own callbacks. ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target() @ 2016-07-19 19:05 ` David Rientjes 0 siblings, 0 replies; 22+ messages in thread From: David Rientjes @ 2016-07-19 19:05 UTC (permalink / raw) To: Xishi Qiu Cc: Joonsoo Kim, Vlastimil Babka, Andrew Morton, Naoya Horiguchi, Linux MM, LKML On Tue, 19 Jul 2016, Xishi Qiu wrote: > Memory offline could happen on both movable zone and non-movable zone, and we > can offline the whole node if the zone is movable_zone(the node only has one > movable_zone), and if the zone is normal_zone, we cannot offline the whole node, > because some kernel memory can't be migrated. > > So how about change alloc_migrate_target() to alloc memory from the next node > with GFP_HIGHUSER_MOVABLE, if the offline zone is movable_zone. > I think sharing alloc_migrate_target as a migration callback may not be worth it; CMA and memory offline are distinct usecases and probably deserve their own callbacks. -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to majordomo@kvack.org. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a> ^ permalink raw reply [flat|nested] 22+ messages in thread
end of thread, other threads:[~2016-07-19 19:05 UTC | newest] Thread overview: 22+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2016-07-15 2:47 [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target() Xishi Qiu 2016-07-15 2:47 ` Xishi Qiu 2016-07-15 2:51 ` [PATCH 2/2] mem-hotplug: use different mempolicy in alloc_migrate_target() Xishi Qiu 2016-07-15 2:51 ` Xishi Qiu 2016-07-18 8:00 ` Vlastimil Babka 2016-07-18 8:00 ` Vlastimil Babka 2016-07-18 5:51 ` [PATCH 1/2] mem-hotplug: use GFP_HIGHUSER_MOVABLE in, alloc_migrate_target() Joonsoo Kim 2016-07-18 5:51 ` Joonsoo Kim 2016-07-18 7:45 ` Vlastimil Babka 2016-07-18 7:45 ` Vlastimil Babka 2016-07-18 8:00 ` Xishi Qiu 2016-07-18 8:00 ` Xishi Qiu 2016-07-18 8:05 ` Vlastimil Babka 2016-07-18 8:05 ` Vlastimil Babka 2016-07-18 8:31 ` Xishi Qiu 2016-07-18 8:31 ` Xishi Qiu 2016-07-19 6:50 ` Joonsoo Kim 2016-07-19 6:50 ` Joonsoo Kim 2016-07-19 7:18 ` Xishi Qiu 2016-07-19 7:18 ` Xishi Qiu 2016-07-19 19:05 ` David Rientjes 2016-07-19 19:05 ` David Rientjes
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.