memory hotplug prep: kill local_mapnr
Subsystems (8)
RFC PATCH 1/12 memory hotplug prep: kill local_mapnr
This is unused, except for in an alpha header. Keep the alpha one, kill the rest.
---
memhotplug-dave/include/asm-i386/mmzone.h | 6 ------ memhotplug-dave/include/asm-m32r/mmzone.h | 6 ------ memhotplug-dave/include/asm-parisc/mmzone.h | 6 ------ memhotplug-dave/include/asm-ppc64/mmzone.h | 3 --- memhotplug-dave/include/asm-x86_64/mmzone.h | 2 -- 5 files changed, 23 deletions(-)
include/asm-x86_64/mmzone.h renamed from include/asm-x86_64/mmzone.h~C0-kill-local_mapnr +0 -2
@@ -38,8 +38,6 @@ static inline __attribute__((pure)) int#ifdef CONFIG_DISCONTIGMEM -#define pfn_to_nid (pfn) phys_to_nid((unsigned long)(pfn) << PAGE_SHIFT) -#define kvaddr_to_nid (kaddr) phys_to_nid(__pa(kaddr))/* AK: this currently doesn't deal with invalid addresses. We'll see if the 2.5 kernel doesn't pass them
include/asm-parisc/mmzone.h renamed from include/asm-parisc/mmzone.h~C0-kill-local_mapnr +0 -6
@@ -27,12 +27,6 @@ extern struct node_map_data node_data[]; })#define node_localnr (pfn, nid) ((pfn) - node_start_pfn(nid)) -#define local_mapnr (kvaddr) \ -({ \ - unsigned long __pfn = __pa(kvaddr) >> PAGE_SHIFT; \ - (__pfn - node_start_pfn(pfn_to_nid(__pfn))); \ -}) -#define pfn_to_page (pfn) \ ({ \ unsigned long __pfn = (pfn); \
include/asm-ppc64/mmzone.h renamed from include/asm-ppc64/mmzone.h~C0-kill-local_mapnr +0 -3
@@ -67,9 +67,6 @@ static inline int pa_to_nid(unsigned lon#define node_start_pfn (nid) (NODE_DATA(nid)->node_start_pfn)#define node_end_pfn (nid) (NODE_DATA(nid)->node_end_pfn) -#define local_mapnr (kvaddr) \ - ( (__pa(kvaddr) >> PAGE_SHIFT) - node_start_pfn(kvaddr_to_nid(kvaddr)) -#ifdef CONFIG_DISCONTIGMEM /*
diff -puN include/asm-alpha/mmzone.h~C0-kill-local_mapnr include/asm-alpha/mmzone.h
include/asm-i386/mmzone.h renamed from include/asm-i386/mmzone.h~C0-kill-local_mapnr +0 -6
@@ -88,12 +88,6 @@ static inline int pfn_to_nid(unsigned lo __pgdat->node_start_pfn + __pgdat->node_spanned_pages; \ }) -#define local_mapnr (kvaddr) \ -({ \ - unsigned long __pfn = __pa(kvaddr) >> PAGE_SHIFT; \ - (__pfn - node_start_pfn(pfn_to_nid(__pfn))); \ -}) -/* XXX: FIXME -- wli */ #define kern_addr_valid (kaddr) (0)
include/asm-m32r/mmzone.h renamed from include/asm-m32r/mmzone.h~C0-kill-local_mapnr +0 -6
@@ -21,12 +21,6 @@ extern struct pglist_data *node_data[]; __pgdat->node_start_pfn + __pgdat->node_spanned_pages -1 ; \ }) -#define local_mapnr (kvaddr) \ -({ \ - unsigned long __pfn = __pa(kvaddr) >> PAGE_SHIFT; \ - (__pfn - node_start_pfn(pfn_to_nid(__pfn))); \ -}) -#define pfn_to_page (pfn) \ ({ \ unsigned long __pfn = pfn; \
_
RFC PATCH 2/12 memory hotplug prep: break out zone initialization
If a zone is empty at boot-time and then hot-added to later, it needs to run the same init code that would have been run on it at boot.
This patch breaks out zone table and per-cpu-pages functions for use by the hotplug code. You can almost see all of the free_area_init_core() function on one page now. :)
---
memhotplug-dave/mm/page_alloc.c | 98 +++++++++++++++++++++++----------------- 1 files changed, 58 insertions(+), 40 deletions(-)
mm/page_alloc.c renamed from mm/page_alloc.c~C1-pcp_zone_init +58 -40
@@ -1850,6 +1850,60 @@ void __init setup_per_cpu_pageset()#endif +static __devinit +void zone_wait_table_init (struct zone *zone,unsigned long zone_size_pages) +{ +int i; + +/* +* The per-page waitqueue mechanism uses hashed waitqueues +* per zone. +*/ + zone->wait_table_size =wait_table_size (zone_size_pages); + zone->wait_table_bits =wait_table_bits (zone->wait_table_size); + zone->wait_table = (wait_queue_head_t *) +alloc_bootmem_node (pgdat, zone->wait_table_size + *sizeof (wait_queue_head_t)); + +for (i =0 ; i < zone->wait_table_size; ++i) +init_waitqueue_head (zone->wait_table + i); +} + +static __devinit void zone_pcp_init (struct zone *zone) +{ +int cpu; +unsigned long batch =zone_batchsize (zone); + +for (cpu =0 ; cpu <NR_CPUS ; cpu++) { +#ifdef CONFIG_NUMA +/* Early boot. Slab allocator not functional yet */ + zone->pageset[cpu] = &boot_pageset[cpu]; +setup_pageset (&boot_pageset[cpu],0 ); +#else +setup_pageset (zone_pcp (zone,cpu), batch); +#endif + } +printk (KERN_DEBUG " %s zone: %lu pages, LIFO batch:%lu\n" , + zone->name, zone->present_pages, batch); +} + +static void init_currently_empty_zone (struct zone *zone, +unsigned long zone_start_pfn,unsigned long size) +{ +struct pglist_data *pgdat = zone->zone_pgdat; + +zone_wait_table_init (zone, size); + pgdat->nr_zones =zone_idx (zone) +1 ; + + zone->zone_mem_map =pfn_to_page (zone_start_pfn); + zone->zone_start_pfn = zone_start_pfn; + +memmap_init (size, pgdat->node_id,zone_idx (zone), zone_start_pfn); + +zone_init_free_lists (pgdat, zone, zone->spanned_pages); +} + +/* * Set up the zone data structures: * - mark all pages reserved
@@ -1859,8 +1913,8 @@ void __init setup_per_cpu_pageset()static void __init free_area_init_core (struct pglist_data *pgdat,unsigned long *zones_size,unsigned long *zholes_size) { -unsigned long i, j; -int cpu, nid = pgdat->node_id; +unsigned long j; +int nid = pgdat->node_id;unsigned long zone_start_pfn = pgdat->node_start_pfn; pgdat->nr_zones =0 ;
@@ -1870,7 +1924,6 @@ static void __init free_area_init_core(sfor (j =0 ; j <MAX_NR_ZONES ; j++) {struct zone *zone = pgdat->node_zones + j;unsigned long size, realsize; -unsigned long batch; realsize = size = zones_size[j];if (zholes_size)
@@ -1890,19 +1943,7 @@ static void __init free_area_init_core(s zone->temp_priority = zone->prev_priority =DEF_PRIORITY ; - batch =zone_batchsize (zone); - -for (cpu =0 ; cpu <NR_CPUS ; cpu++) { -#ifdef CONFIG_NUMA -/* Early boot. Slab allocator not functional yet */ - zone->pageset[cpu] = &boot_pageset[cpu]; -setup_pageset (&boot_pageset[cpu],0 ); -#else -setup_pageset (zone_pcp (zone,cpu), batch); -#endif - } -printk (KERN_DEBUG " %s zone: %lu pages, LIFO batch:%lu\n" , - zone_names[j], realsize, batch); +zone_pcp_init (zone);INIT_LIST_HEAD (&zone->active_list);INIT_LIST_HEAD (&zone->inactive_list); zone->nr_scan_active =0 ;
@@ -1913,32 +1954,9 @@ static void __init free_area_init_core(sif (!size)continue ; -/* -* The per-page waitqueue mechanism uses hashed waitqueues -* per zone. -*/ - zone->wait_table_size =wait_table_size (size); - zone->wait_table_bits = -wait_table_bits (zone->wait_table_size); - zone->wait_table = (wait_queue_head_t *) -alloc_bootmem_node (pgdat, zone->wait_table_size - *sizeof (wait_queue_head_t)); - -for (i =0 ; i < zone->wait_table_size; ++i) -init_waitqueue_head (zone->wait_table + i); - - pgdat->nr_zones = j+1 ; - - zone->zone_mem_map =pfn_to_page (zone_start_pfn); - zone->zone_start_pfn = zone_start_pfn; - -memmap_init (size, nid, j, zone_start_pfn); -zonetable_add (zone, nid, j, zone_start_pfn, size); - +init_currently_empty_zone (zone, zone_start_pfn, size); zone_start_pfn += size; - -zone_init_free_lists (pgdat, zone, zone->spanned_pages); } }
diff -L ser -puN /dev/null /dev/null
_
RFC PATCH 3/12 memory hotplug prep: zone wait table at runtime
In reply to Dave HansenAdd an if() to the wait-table init code to allow runtime allocations to call kmalloc() instead of using the bootmem allocator
---
./arch/sparc64/kernel/dtlb_base.S | 0 memhotplug-dave/mm/page_alloc.c | 10 +++++++--- 2 files changed, 7 insertions(+), 3 deletions(-)
diff -puN mm/sparse.c~C2-kmalloc-zone_wait_table-at-runtime mm/sparse.c diff -L mm/memory_hotplug.c -puN /dev/null /dev/null
diff -L drivers/base/memory.c -puN /dev/null /dev/null
mm/page_alloc.c renamed from mm/page_alloc.c~C2-kmalloc-zone_wait_table-at-runtime +7 -3
@@ -1854,6 +1854,7 @@ static __devinitvoid zone_wait_table_init (struct zone *zone,unsigned long zone_size_pages) {int i; +unsigned long size_bytes;/* * The per-page waitqueue mechanism uses hashed waitqueues
@@ -1861,9 +1862,12 @@ void zone_wait_table_init(struct zone *z*/ zone->wait_table_size =wait_table_size (zone_size_pages); zone->wait_table_bits =wait_table_bits (zone->wait_table_size); - zone->wait_table = (wait_queue_head_t *) -alloc_bootmem_node (pgdat, zone->wait_table_size - *sizeof (wait_queue_head_t)); + size_bytes = zone->wait_table_size *sizeof (wait_queue_head_t); +if (system_state >=SYSTEM_RUNNING ) + zone->wait_table =kmalloc (size_bytes,GFP_KERNEL ); +else + zone->wait_table =alloc_bootmem_node (zone->zone_pgdat, + size_bytes);for (i =0 ; i < zone->wait_table_size; ++i)init_waitqueue_head (zone->wait_table + i);
diff -L serq -puN /dev/null /dev/null
diff -puN ./arch/sparc64/kernel/dtlb_base.S~C2-kmalloc-zone_wait_table-at-runtime ./arch/sparc64/kernel/dtlb_base.S _
RFC PATCH 4/12 memory hotplug prep: __section_nr helper
In reply to Dave HansenA little helper that we use in the hotplug code.
---
memhotplug-dave/include/linux/mmzone.h | 26 ++++++++++++++++++++++++++ mm/sparse.c | 0 2 files changed, 26 insertions(+)
include/linux/mmzone.h renamed from include/linux/mmzone.h~C3-__section_nr +26 -0
@@ -511,6 +511,31 @@ static inline struct mem_section *__nr_t }/* +* Although written for the SPARSEMEM_EXTREME case, this happens +* to also work for the flat array case becase +* NR_SECTION_ROOTS==NR_MEM_SECTIONS. +*/ +static inline int __section_nr (struct mem_section * ms) +{ +unsigned long root_nr; +struct mem_section * root; + +for (root_nr =0 ; + root_nr <NR_MEM_SECTIONS ; + root_nr +=SECTIONS_PER_ROOT ) { + root =__nr_to_section (root_nr); + +if (!root) +continue ; + +if ((ms >= root) && (ms < (root +SECTIONS_PER_ROOT ))) +break ; + } + +return (root_nr *SECTIONS_PER_ROOT ) + (ms - root); +} + +/* * We use the lower bits of the mem_map pointer to store * a little bit of information. There should be at least * 3 bits here due to 32-bit alignment.
@@ -606,3 +631,4 @@ unsigned long __init node_memmap_size_by#endif /* !__ASSEMBLY__ */ #endif /* __KERNEL__ */ #endif /* _LINUX_MMZONE_H */ +
diff -puN mm/sparse.c~C3-__section_nr mm/sparse.c
_
RFC PATCH 5/12 memory hotplug prep: fixup bad_range()
In reply to Dave HansenWhen doing memory hotplug operations, the size of existing zones can obviously change. This means that zone->zone_{start_pfn,spanned_pages} can change.
There are currently no locks that protect these structure members. However, they are rarely accessed at runtime. Outside of swsusp, the only place that I can find is bad_range().
So, split bad_range() up into two pieces: one that needs to be locked and anther that doesn't.
---
memhotplug-dave/mm/page_alloc.c | 26 +++++++++++++++++++++----- 1 files changed, 21 insertions(+), 5 deletions(-)
mm/page_alloc.c renamed from mm/page_alloc.c~C5.1-bad_range-rework +21 -5
@@ -77,21 +77,37 @@ int min_free_kbytes = 1024;unsigned long __initdata nr_kernel_pages;unsigned long __initdata nr_all_pages; -/* -* Temporary debugging check for pages not lying within a given zone. -*/ -static int bad_range (struct zone *zone,struct page *page) +static int page_outside_zone_boundaries (struct zone *zone,struct page *page) {if (page_to_pfn (page) >= zone->zone_start_pfn + zone->spanned_pages)return 1 ;if (page_to_pfn (page) < zone->zone_start_pfn)return 1 ; + +return 0 ; +} + +static int page_is_consistent (struct zone *zone,struct page *page) +{#ifdef CONFIG_HOLES_IN_ZONE if (!pfn_valid (page_to_pfn (page))) -return 1 ; +return 0 ;#endif if (zone !=page_zone (page)) +return 0 ; + +return 1 ; +} +/* +* Temporary debugging check for pages not lying within a given zone. +*/ +static int bad_range (struct zone *zone,struct page *page) +{ +if (page_outside_zone_boundaries (zone, page))return 1 ; +if (!page_is_consistent (zone, page)) +return 1 ; +return 0 ; }
_
RFC PATCH 6/12 memory hotplug locking: node_size_lock
In reply to Dave Hansenpgdat->node_size_lock is basically only neeeded in one place in the normal code: show_mem(), which is the arch-specific sysrq-m printing function.
This lock is also held in the sparsemem code during a memory removal, as sections are invalidated. This is the place there pfn_valid() is made false for a memory area that's being removed. The lock is only required when doing pfn_valid() operations on memory which the user does not already have a reference on the page, such as in show_mem().
---
memhotplug-dave/arch/alpha/mm/numa.c | 3 ++ memhotplug-dave/arch/i386/mm/pgtable.c | 3 ++ memhotplug-dave/arch/ia64/mm/discontig.c | 7 ++++- memhotplug-dave/arch/m32r/mm/init.c | 9 +++++- memhotplug-dave/arch/parisc/mm/init.c | 3 ++ memhotplug-dave/arch/ppc64/mm/init.c | 6 ++++ memhotplug-dave/include/linux/memory_hotplug.h | 34 +++++++++++++++++++++++++ memhotplug-dave/include/linux/mmzone.h | 12 ++++++++ memhotplug-dave/mm/page_alloc.c | 1 9 files changed, 76 insertions(+), 2 deletions(-)
include/linux/mmzone.h renamed from include/linux/mmzone.h~C5.2-pgdat_size_lock +12 -0
@@ -273,6 +273,16 @@ typedef struct pglist_data {struct page *node_mem_map;#endif struct bootmem_data *bdata; +#ifdef CONFIG_MEMORY_HOTPLUG +/* +* Must be held any time you expect node_start_pfn, node_present_pages +* or node_spanned_pages stay constant. Holding this will also +* guarantee that any pfn_valid() stays that way. +* +* Nests above zone->lock and zone->size_seqlock. +*/ +spinlock_t node_size_lock; +#endif unsigned long node_start_pfn;unsigned long node_present_pages;/* total number of physical pages */ unsigned long node_spanned_pages;/* total size of physical page
@@ -293,6 +303,8 @@ typedef struct pglist_data {#endif #define nid_page_nr (nid, pagenr) pgdat_page_nr(NODE_DATA(nid),(pagenr)) +#include <linux/memory_hotplug.h> +extern struct pglist_data *pgdat_list; void __get_zone_counts(unsigned long *active, unsigned long *inactive,
mm/page_alloc.c renamed from mm/page_alloc.c~C5.2-pgdat_size_lock +1 -0
@@ -1937,6 +1937,7 @@ static void __init free_area_init_core(sint nid = pgdat->node_id;unsigned long zone_start_pfn = pgdat->node_start_pfn; +pgdat_resize_init (pgdat); pgdat->nr_zones =0 ;init_waitqueue_head (&pgdat->kswapd_wait); pgdat->kswapd_max_order =0 ;
arch/alpha/mm/numa.c renamed from arch/alpha/mm/numa.c~C5.2-pgdat_size_lock +3 -0
@@ -371,6 +371,8 @@ show_mem(void)show_free_areas ();printk ("Free swap: %6ldkB\n" , nr_swap_pages<<(PAGE_SHIFT -10 ));for_each_online_node (nid) { +unsigned long flags; +pgdat_resize_lock (NODE_DATA (nid), &flags); i =node_spanned_pages (nid);while (i-- >0 ) {struct page *page =nid_page_nr (nid, i);
@@ -384,6 +386,7 @@ show_mem(void)else shared +=page_count (page) -1 ; } +pgdat_resize_unlock (NODE_DATA (nid), &flags); }printk ("%ld pages of RAM\n" ,total);printk ("%ld free pages\n" ,free);
arch/i386/mm/pgtable.c renamed from arch/i386/mm/pgtable.c~C5.2-pgdat_size_lock +3 -0
@@ -31,11 +31,13 @@ void show_mem(void)pg_data_t *pgdat;unsigned long i;struct page_state ps; +unsigned long flags;printk (KERN_INFO "Mem-info:\n" );show_free_areas ();printk (KERN_INFO "Free swap: %6ldkB\n" , nr_swap_pages<<(PAGE_SHIFT -10 ));for_each_pgdat (pgdat) { +pgdat_resize_lock (pgdat, &flags);for (i =0 ; i < pgdat->node_spanned_pages; ++i) { page =pgdat_page_nr (pgdat, i); total++;
@@ -48,6 +50,7 @@ void show_mem(void)else if (page_count (page)) shared +=page_count (page) -1 ; } +pgdat_resize_unlock (pgdat, &flags); }printk (KERN_INFO "%d pages of RAM\n" , total);printk (KERN_INFO "%d pages of HIGHMEM\n" , highmem);
arch/ia64/mm/discontig.c renamed from arch/ia64/mm/discontig.c~C5.2-pgdat_size_lock +6 -1
@@ -524,9 +524,13 @@ void show_mem(void)show_free_areas ();printk ("Free swap: %6ldkB\n" , nr_swap_pages<<(PAGE_SHIFT -10 ));for_each_pgdat (pgdat) { -unsigned long present = pgdat->node_present_pages; +unsigned long present; +unsigned long flags;int shared =0 , cached =0 , reserved =0 ; +printk ("Node ID: %d\n" , pgdat->node_id); +pgdat_resize_lock (pgdat, &flags); + present = pgdat->node_present_pages;for (i =0 ; i < pgdat->node_spanned_pages; i++) {struct page *page =pgdat_page_nr (pgdat, i);if (!ia64_pfn_valid (pgdat->node_start_pfn+i))
@@ -538,6 +542,7 @@ void show_mem(void)else if (page_count (page)) shared +=page_count (page)-1 ; } +pgdat_resize_unlock (pgdat, &flags); total_present += present; total_reserved += reserved; total_cached += cached;
diff -puN include/asm-x86_64/mmzone.h~C5.2-pgdat_size_lock include/asm-x86_64/mmzone.h diff -puN include/asm-parisc/mmzone.h~C5.2-pgdat_size_lock include/asm-parisc/mmzone.h diff -puN include/asm-ppc64/mmzone.h~C5.2-pgdat_size_lock include/asm-ppc64/mmzone.h diff -puN include/asm-alpha/mmzone.h~C5.2-pgdat_size_lock include/asm-alpha/mmzone.h diff -puN include/asm-i386/mmzone.h~C5.2-pgdat_size_lock include/asm-i386/mmzone.h diff -puN include/asm-m32r/mmzone.h~C5.2-pgdat_size_lock include/asm-m32r/mmzone.h
arch/m32r/mm/init.c renamed from arch/m32r/mm/init.c~C5.2-pgdat_size_lock +8 -1
@@ -48,6 +48,8 @@ void show_mem(void)show_free_areas ();printk ("Free swap: %6ldkB\n" ,nr_swap_pages<<(PAGE_SHIFT -10 ));for_each_pgdat (pgdat) { +unsigned long flags; +pgdat_resize_lock (pgdat, &flags);for (i =0 ; i < pgdat->node_spanned_pages; ++i) { page =pgdat_page_nr (pgdat, i); total++;
@@ -60,6 +62,7 @@ void show_mem(void)else if (page_count (page)) shared +=page_count (page) -1 ; } +pgdat_resize_unlock (pgdat, &flags); }printk ("%d pages of RAM\n" , total);printk ("%d pages of HIGHMEM\n" ,highmem);
@@ -150,10 +153,14 @@ int __init reservedpages_count(void)int reservedpages, nid, i; reservedpages =0 ; -for_each_online_node (nid) +for_each_online_node (nid) { +unsigned long flags; +pgdat_resize_lock (NODE_DATA (nid), &flags);for (i =0 ; i <MAX_LOW_PFN (nid) -START_PFN (nid) ; i++)if (PageReserved (nid_page_nr (nid, i))) reservedpages++; +pgdat_resize_unlock (NODE_DATA (nid), &flags); + }return reservedpages; }
arch/ppc64/mm/init.c renamed from arch/ppc64/mm/init.c~C5.2-pgdat_size_lock +6 -0
@@ -97,6 +97,8 @@ void show_mem(void)show_free_areas ();printk ("Free swap: %6ldkB\n" , nr_swap_pages<<(PAGE_SHIFT -10 ));for_each_pgdat (pgdat) { +unsigned long flags; +pgdat_resize_lock (pgdat, &flags);for (i =0 ; i < pgdat->node_spanned_pages; i++) { page =pgdat_page_nr (pgdat, i); total++;
@@ -107,6 +109,7 @@ void show_mem(void)else if (page_count (page)) shared +=page_count (page) -1 ; } +pgdat_resize_unlock (pgdat, &flags); }printk ("%ld pages of RAM\n" , total);printk ("%ld reserved pages\n" , reserved);
@@ -662,11 +665,14 @@ void __init mem_init(void)#endif for_each_pgdat (pgdat) { +unsigned long flags; +pgdat_resize_lock (pgdat, &flags);for (i =0 ; i < pgdat->node_spanned_pages; i++) { page =pgdat_page_nr (pgdat, i);if (PageReserved (page)) reservedpages++; } +pgdat_resize_unlock (pgdat, &flags); } codesize = (unsigned long )&_etext - (unsigned long )&_stext;
arch/parisc/mm/init.c renamed from arch/parisc/mm/init.c~C5.2-pgdat_size_lock +3 -0
@@ -505,7 +505,9 @@ void show_mem(void)for (j =node_start_pfn (i); j <node_end_pfn (i); j++) {struct page *p; +unsigned long flags; +pgdat_resize_lock (NODE_DATA (i), &flags); p =nid_page_nr (i, j) -node_start_pfn (i); total++;
@@ -517,6 +519,7 @@ void show_mem(void) free++; else shared += page_count(p) - 1; + pgdat_resize_unlock(NODE_DATA(i), &flags); } }#endif
include/linux/memory_hotplug.h new file +34 -0
@@ -0,0 +1,34 @@ +#ifndef __LINUX_MEMORY_HOTPLUG_H +#define __LINUX_MEMORY_HOTPLUG_H + +#include <linux/mmzone.h> +#include <linux/spinlock.h> + +#ifdef CONFIG_MEMORY_HOTPLUG +/* +* pgdat resizing functions +*/ +static inline +void pgdat_resize_lock (struct pglist_data *pgdat,unsigned long *flags) +{ +spin_lock_irqsave (&pgdat->node_size_lock, *flags); +} +static inline +void pgdat_resize_unlock (struct pglist_data *pgdat,unsigned long *flags) +{ +spin_lock_irqrestore (&pgdat->node_size_lock, *flags); +} +static inline +void pgdat_resize_init (struct pglist_data *pgdat) +{ +spin_lock_init (&pgdat->node_size_lock); +} +#else /* ! CONFIG_MEMORY_HOTPLUG */ +/* +* Stub functions for when hotplug is off +*/ +static inline void pgdat_resize_lock (struct pglist_data *p,unsigned long *f) {} +static inline void pgdat_resize_unlock (struct pglist_data *p,unsigned long *f) {} +static inline void pgdat_resize_init (struct pglist_data *pgdat) {} +#endif +#endif /* __LINUX_MEMORY_HOTPLUG_H */
_
RFC PATCH 7/12 memory hotplug locking: zone span seqlock
In reply to Dave HansenSee the "fixup bad_range()" patch for more information, but this actually creates a the lock to protect things making assumptions about a zone's size staying constant at runtime.
---
memhotplug-dave/include/linux/memory_hotplug.h | 39 +++++++++++++++++++++++-- memhotplug-dave/include/linux/mmzone.h | 15 +++++++++ memhotplug-dave/mm/page_alloc.c | 19 ++++++++---- txt | 0 4 files changed, 66 insertions(+), 7 deletions(-)
diff -puN kernel/power/swsusp.c~C6-zone-span_seqlock kernel/power/swsusp.c
include/linux/mmzone.h renamed from include/linux/mmzone.h~C6-zone-span_seqlock +15 -0
@@ -12,6 +12,7 @@#include <linux/threads.h> #include <linux/numa.h> #include <linux/init.h> +#include <linux/seqlock.h> #include <asm/atomic.h> /* Free memory management - zoned buddy allocator. */
@@ -137,6 +138,10 @@ struct zone {* free areas of different sizes */ spinlock_t lock; +#ifdef CONFIG_MEMORY_HOTPLUG +/* see spanned/present_pages for more description */ +seqlock_t span_seqlock; +#endif struct free_area free_area[MAX_ORDER ];
@@ -220,6 +225,16 @@ struct zone {/* zone_start_pfn == zone_start_paddr >> PAGE_SHIFT */ unsigned long zone_start_pfn; +/* +* zone_start_pfn, spanned_pages and present_pages are all +* protected by span_seqlock. It is a seqlock because it has +* to be read outside of zone->lock, and it is done in the main +* allocator path. But, it is written quite infrequently. +* +* The lock is declared along with zone->lock because it is +* frequently read in proximity to zone->lock. It's good to +* give them a chance of being in the same cacheline. +*/ unsigned long spanned_pages;/* total size, including holes */ unsigned long present_pages;/* amount of memory (excluding holes) */
mm/page_alloc.c renamed from mm/page_alloc.c~C6-zone-span_seqlock +14 -5
@@ -32,6 +32,7 @@#include <linux/sysctl.h> #include <linux/cpu.h> #include <linux/cpuset.h> +#include <linux/memory_hotplug.h> #include <linux/nodemask.h> #include <linux/vmalloc.h>
@@ -79,12 +80,19 @@ unsigned long __initdata nr_all_pages;static int page_outside_zone_boundaries (struct zone *zone,struct page *page) { -if (page_to_pfn (page) >= zone->zone_start_pfn + zone->spanned_pages) -return 1 ; -if (page_to_pfn (page) < zone->zone_start_pfn) -return 1 ; +int ret =0 ; +unsigned seq; +unsigned long pfn =page_to_pfn (page); -return 0 ; +do { + seq =zone_span_seqbegin (zone); +if (pfn >= zone->zone_start_pfn + zone->spanned_pages) + ret =1 ; +else if (pfn < zone->zone_start_pfn) + ret =1 ; + }while (zone_span_seqretry (zone, seq)); + +return ret; }static int page_is_consistent (struct zone *zone,struct page *page)
@@ -1959,6 +1967,7 @@ static void __init free_area_init_core(s zone->name = zone_names[j];spin_lock_init (&zone->lock);spin_lock_init (&zone->lru_lock); +zone_seqlock_init (zone); zone->zone_pgdat = pgdat; zone->free_pages =0 ;
include/linux/memory_hotplug.h renamed from include/linux/memory_hotplug.h~C6-zone-span_seqlock +37 -2
@@ -16,13 +16,36 @@ void pgdat_resize_lock(struct pglist_datstatic inline void pgdat_resize_unlock (struct pglist_data *pgdat,unsigned long *flags) { -spin_lock_irqrestore (&pgdat->node_size_lock, *flags); +spin_unlock_irqrestore (&pgdat->node_size_lock, *flags); }static inline void pgdat_resize_init (struct pglist_data *pgdat) {spin_lock_init (&pgdat->node_size_lock); } +/* +* Zone resizing functions +*/ +static inline unsigned zone_span_seqbegin (struct zone *zone) +{ +return read_seqbegin (&zone->span_seqlock); +} +static inline int zone_span_seqretry (struct zone *zone,unsigned iv) +{ +return read_seqretry (&zone->span_seqlock, iv); +} +static inline void zone_span_writelock (struct zone *zone) +{ +write_seqlock (&zone->span_seqlock); +} +static inline void zone_span_writeunlock (struct zone *zone) +{ +write_sequnlock (&zone->span_seqlock); +} +static inline void zone_seqlock_init (struct zone *zone) +{ +seqlock_init (&zone->span_seqlock); +}#else /* ! CONFIG_MEMORY_HOTPLUG */ /* * Stub functions for when hotplug is off
@@ -30,5 +53,17 @@ void pgdat_resize_init(struct pglist_datstatic inline void pgdat_resize_lock (struct pglist_data *p,unsigned long *f) {}static inline void pgdat_resize_unlock (struct pglist_data *p,unsigned long *f) {}static inline void pgdat_resize_init (struct pglist_data *pgdat) {} -#endif + +static inline unsigned zone_span_seqbegin (struct zone *zone) +{ +return 0 ; +} +static inline int zone_span_seqretry (struct zone *zone,unsigned iv) +{ +return 0 ; +} +static inline void zone_span_writelock (struct zone *zone) {} +static inline void zone_span_writeunlock (struct zone *zone) {} +static inline void zone_seqlock_init (struct zone *zone) {} +#endif /* ! CONFIG_MEMORY_HOTPLUG */ #endif /* __LINUX_MEMORY_HOTPLUG_H */
diff -puN /dev/null txt
_
RFC PATCH 8/12 memory hotplug: sysfs and add/remove functions
In reply to Dave HansenThis adds generic memory add/remove and supporting functions for memory hotplug into a new file as well as a memory hotplug kernel config option.
Individual architecture patches will follow.
For now, disable memory hotplug when swsusp is enabled. There's a lot of churn there right now. We'll fix it up properly once it calms down.
---
memhotplug-dave/drivers/base/Makefile | 1 memhotplug-dave/drivers/base/init.c | 2 memhotplug-dave/drivers/base/memory.c | 455 +++++++++++++++++++++++++ memhotplug-dave/include/linux/memory.h | 94 +++++ memhotplug-dave/include/linux/memory_hotplug.h | 35 + memhotplug-dave/include/linux/mm.h | 1 memhotplug-dave/mm/Kconfig | 8 memhotplug-dave/mm/Makefile | 2 memhotplug-dave/mm/memory_hotplug.c | 178 +++++++++ memhotplug-dave/mm/page_alloc.c | 4 mm/sparse.c | 0 11 files changed, 777 insertions(+), 3 deletions(-)
drivers/base/Makefile renamed from drivers/base/Makefile~D0-sysfs-memory-class +1 -0
@@ -7,6 +7,7 @@ obj-y := core.o sys.o bus.o dd.o \ obj-y += power/ obj-$(CONFIG_FW_LOADER) += firmware_class.o obj-$(CONFIG_NUMA) += node.o +obj-$(CONFIG_MEMORY_HOTPLUG) += memory.o ifeq ($(CONFIG_DEBUG_DRIVER),y) EXTRA_CFLAGS += -DDEBUG
drivers/base/init.c renamed from drivers/base/init.c~D0-sysfs-memory-class +2 -0
@@ -9,6 +9,7 @@#include <linux/device.h> #include <linux/init.h> +#include <linux/memory.h> extern int devices_init (void );extern int buses_init (void );
@@ -39,5 +40,6 @@ void __init driver_init(void)platform_bus_init ();system_bus_init ();cpu_dev_init (); +memory_dev_init ();attribute_container_init (); }
drivers/base/memory.c new file +455 -0
455 lines not on this page · raw message
diff -puN include/asm-i386/highmem.h~D0-sysfs-memory-class include/asm-i386/highmem.h
include/linux/memory.h new file +94 -0
94 lines not on this page · raw message
include/linux/memory_hotplug.h renamed from include/linux/memory_hotplug.h~D0-sysfs-memory-class +35 -0
@@ -3,6 +3,8 @@#include <linux/mmzone.h> #include <linux/spinlock.h> +#include <linux/mmzone.h> +#include <linux/notifier.h> #ifdef CONFIG_MEMORY_HOTPLUG /*
@@ -46,6 +48,19 @@ static inline void zone_seqlock_init(str {seqlock_init (&zone->span_seqlock); } +extern int zone_grow_free_lists (struct zone *zone,unsigned long new_nr_pages); +extern int zone_grow_waitqueues (struct zone *zone,unsigned long nr_pages); +extern int add_one_highpage (struct page *page,int pfn,int bad_ppro); +/* need some defines for these for archs that don't support it */ +extern void online_page (struct page *page); +/* VM interface that may be used by firmware interface */ +extern int add_memory (u64 start,u64 size); +extern int remove_memory (u64 start,u64 size); +extern int online_pages (unsigned long ,unsigned long ); + +/* reasonably generic interface to expand the physical pages in a zone */ +extern int __add_pages (struct zone *zone,unsigned long start_pfn, +unsigned long nr_pages);#else /* ! CONFIG_MEMORY_HOTPLUG */ /* * Stub functions for when hotplug is off
@@ -65,5 +80,25 @@ static inline int zone_span_seqretry(strstatic inline void zone_span_writelock (struct zone *zone) {}static inline void zone_span_writeunlock (struct zone *zone) {}static inline void zone_seqlock_init (struct zone *zone) {} + +static inline int mhp_notimplemented (const char *func) +{ +printk (KERN_WARNING "%s() called, with CONFIG_MEMORY_HOTPLUG disabled\n" , func); +dump_stack (); +return -ENOSYS ; +} + +static inline int __add_pages (struct zone *zone,unsigned long start_pfn, +unsigned long nr_pages) +{ +return mhp_notimplemented (__FUNCTION__); +}#endif /* ! CONFIG_MEMORY_HOTPLUG */ +static inline int __remove_pages (struct zone *zone,unsigned long start_pfn, +unsigned long nr_pages) +{ +printk (KERN_WARNING "%s() called, not yet supported\n" , __FUNCTION__); +dump_stack (); +return -ENOSYS ; +}#endif /* __LINUX_MEMORY_HOTPLUG_H */
mm/Kconfig renamed from mm/Kconfig~D0-sysfs-memory-class +8 -0
@@ -111,3 +111,11 @@ config SPARSEMEM_STATIC config SPARSEMEM_EXTREME def_bool y depends on SPARSEMEM && !SPARSEMEM_STATIC + +# eventually, we can have this option just 'select SPARSEMEM' +config MEMORY_HOTPLUG + bool "Allow for memory hot-add" + depends on SPARSEMEM && HOTPLUG && !SOFTWARE_SUSPEND + +comment "Memory hotplug is currently incompatible with Software Suspend" + depends on SPARSEMEM && HOTPLUG && SOFTWARE_SUSPEND
mm/Makefile renamed from mm/Makefile~D0-sysfs-memory-class +1 -1
@@ -18,5 +18,5 @@ obj-$(CONFIG_NUMA) += mempolicy.o obj-$(CONFIG_SPARSEMEM) += sparse.o obj-$(CONFIG_SHMEM) += shmem.o obj-$(CONFIG_TINY_SHMEM) += tiny-shmem.o - +obj-$(CONFIG_MEMORY_HOTPLUG) += memory_hotplug.o obj-$(CONFIG_FS_XIP) += filemap_xip.o
mm/memory_hotplug.c new file +178 -0
178 lines not on this page · raw message
mm/page_alloc.c renamed from mm/page_alloc.c~D0-sysfs-memory-class +2 -2
@@ -1663,7 +1663,7 @@ static void __init calculate_zone_totalp* up by free_all_bootmem() once the early boot process is * done. Non-atomic initialization, single-pass. */ -void __init memmap_init_zone (unsigned long size,int nid,unsigned long zone, +void __devinit memmap_init_zone (unsigned long size,int nid,unsigned long zone,unsigned long start_pfn) {struct page *page;
@@ -2386,7 +2386,7 @@ static void setup_per_zone_lowmem_reserv* that the pages_{min,low,high} values for each zone are set correctly * with respect to min_free_kbytes. */ -static void setup_per_zone_pages_min (void ) +void setup_per_zone_pages_min (void ) {unsigned long pages_min = min_free_kbytes >> (PAGE_SHIFT -10 );unsigned long lowmem_pages =0 ;
include/linux/mm.h renamed from include/linux/mm.h~D0-sysfs-memory-class +1 -0
@@ -791,6 +791,7 @@ extern void free_area_init_node(int nid, unsigned long * zones_size, unsigned long zone_start_pfn, unsigned long *zholes_size);extern void memmap_init_zone (unsigned long ,int ,unsigned long ,unsigned long ); +extern void setup_per_zone_pages_min (void );extern void mem_init (void );extern void show_mem (void );extern void si_meminfo (struct sysinfo * val);
diff -puN mm/sparse.c~D0-sysfs-memory-class mm/sparse.c _
RFC PATCH 9/12 memory hotplug: move section_mem_map alloc to sparse.c
In reply to Dave HansenThis basically keeps up from having to extern __kmalloc_section_memmap().
The vaddr_in_vmalloc_area() helper could go in a vmalloc header, but that header gets hard to work with, because it needs some arch-specific macros. Just stick it in here for now, instead of creating another header.
---
memhotplug-dave/mm/memory_hotplug.c | 43 -------------------- memhotplug-dave/mm/sparse.c | 74 +++++++++++++++++++++++++++++++++--- 2 files changed, 70 insertions(+), 47 deletions(-)
mm/sparse.c renamed from mm/sparse.c~D0.6-move_memmap_kmalloc_to_sparse.c +69 -5
@@ -5,8 +5,10 @@#include <linux/mm.h> #include <linux/mmzone.h> #include <linux/bootmem.h> +#include <linux/highmem.h> #include <linux/module.h> #include <linux/spinlock.h> +#include <linux/vmalloc.h> #include <asm/dma.h> /*
@@ -164,6 +166,45 @@ static struct page *sparse_early_mem_mapreturn NULL ; } +static struct page *__kmalloc_section_memmap (unsigned long nr_pages) +{ +struct page *page, *ret; +unsigned long memmap_size =sizeof (struct page ) * nr_pages; + + page =alloc_pages (GFP_KERNEL ,get_order (memmap_size)); +if (page) + goto got_map_page; + + ret =vmalloc (memmap_size); +if (ret) + goto got_map_ptr; + +return NULL ; +got_map_page: + ret = (struct page *)pfn_to_kaddr (page_to_pfn (page)); +got_map_ptr: +memset (ret,0 , memmap_size); + +return ret; +} + +static int vaddr_in_vmalloc_area (void *addr) +{ +if (addr >= (void *)VMALLOC_START && + addr < (void *)VMALLOC_END ) +return 1 ; +return 0 ; +} + +static void __kfree_section_memmap (struct page *memmap,unsigned long nr_pages) +{ +if (vaddr_in_vmalloc_area (memmap)) +vfree (memmap); +else +free_pages ((unsigned long )memmap, +get_order (sizeof (struct page ) * nr_pages)); +} +/* * Allocate the accumulated non-linear sections, allocate a mem_map * for each and record the physical to section mapping.
@@ -189,14 +230,37 @@ void sparse_init(void)* set. If this is <=0, then that means that the passed-in * map was not consumed and must be freed. */ -int sparse_add_one_section (unsigned long start_pfn,int nr_pages,struct page *map) +int sparse_add_one_section (struct zone *zone,unsigned long start_pfn, +int nr_pages) { -struct mem_section *ms =__pfn_to_section (start_pfn); +unsigned long section_nr =pfn_to_section_nr (start_pfn); +struct pglist_data *pgdat = zone->zone_pgdat; +struct mem_section *ms; +struct page *memmap; +unsigned long flags; +int ret; + +/* +* no locking for this, because it does its own +* plus, it does a kmalloc +*/ +sparse_index_init (section_nr, pgdat->node_id); + memmap =__kmalloc_section_memmap (nr_pages); -if (ms->section_mem_map &SECTION_MARKED_PRESENT ) -return -EEXIST ; +pgdat_resize_lock (pgdat, &flags); + ms =__pfn_to_section (start_pfn); +if (ms->section_mem_map &SECTION_MARKED_PRESENT ) { + ret = -EEXIST ; + goto out; + } ms->section_mem_map |=SECTION_MARKED_PRESENT ; -return sparse_init_one_section (ms,pfn_to_section_nr (start_pfn), map); + ret =sparse_init_one_section (ms, section_nr, memmap); + +if (ret <=0 ) +__kfree_section_memmap (memmap, nr_pages); +out: +pgdat_resize_unlock (pgdat, &flags); +return ret; }
mm/memory_hotplug.c renamed from mm/memory_hotplug.c~D0.6-move_memmap_kmalloc_to_sparse.c +1 -42
62 lines not on this page · raw message
_
RFC PATCH 10/12 memory hotplug: call setup_per_zone_pages_min after hotplug
In reply to Dave HansenFrom: IWAMOTO Toshihiro <[email protected]>
Quoted 6 lines
I found the tests does not work well with Dave's patchset. I've found the followings:
-
setup_per_zone_pages_min()calls should be added incapture_page_range()andonline_pages()
-lru_add_drain()should be called beforetry_to_migrate_pages()
The following patch deals with the first item.
---
memhotplug-dave/mm/memory_hotplug.c | 2 ++ mm/page_alloc.c | 0 2 files changed, 2 insertions(+)
diff -puN include/linux/mmzone.h~D0.7-call_setup_per_zone_pages_min_after_memory_size_change include/linux/mmzone.h
mm/memory_hotplug.c renamed from mm/memory_hotplug.c~D0.7-call_setup_per_zone_pages_min_after_memory_size_change +2 -0
@@ -133,5 +133,7 @@ int online_pages(unsigned long pfn, unsi } zone->present_pages += onlined_pages; +setup_per_zone_pages_min (); +return 0 ; }
diff -puN mm/page_alloc.c~D0.7-call_setup_per_zone_pages_min_after_memory_size_change mm/page_alloc.c _
RFC PATCH 11/12 memory hotplug: i386 addition functions
In reply to Dave HansenAdds the necessary for non-NUMA hot-add of highmem to an existing zone on i386.
---
memhotplug-dave/arch/i386/mm/discontig.c | 4 +- memhotplug-dave/arch/i386/mm/init.c | 61 ++++++++++++++++++++++++++++--- mm/highmem.c | 0 3 files changed, 58 insertions(+), 7 deletions(-)
arch/i386/mm/init.c renamed from arch/i386/mm/init.c~D1-i386-hotplug-functions +56 -5
@@ -27,6 +27,7 @@#include <linux/slab.h> #include <linux/proc_fs.h> #include <linux/efi.h> +#include <linux/memory_hotplug.h> #include <asm/processor.h> #include <asm/system.h>
@@ -265,17 +266,45 @@ static void __init permanent_kmaps_init( pkmap_page_table = pte; } -void __init one_highpage_init (struct page *page,int pfn,int bad_ppro) +void __devinit free_new_highpage (struct page *page) +{ +set_page_count (page,1 ); +__free_page (page); + totalhigh_pages++; +} + +void __init add_one_highpage_init (struct page *page,int pfn,int bad_ppro) {if (page_is_ram (pfn) && !(bad_ppro &&page_kills_ppro (pfn))) {ClearPageReserved (page); -set_page_count (page,1 ); -__free_page (page); - totalhigh_pages++; }else SetPageReserved (page); } +int add_one_highpage_hotplug (struct page *page,int pfn) +{ +free_new_highpage (page); + totalram_pages++; +#ifdef CONFIG_FLATMEM + max_mapnr =max (pfn, max_mapnr); +#endif + num_physpages++; +return 0 ; +} + +/* +* Not currently handling the NUMA case. +* Assuming single node and all memory that +* has been added dynamically that would be +* onlined here is in HIGHMEM +*/ +void online_page (struct page *page) +{ +ClearPageReserved (page); +add_one_highpage_hotplug (page,page_to_pfn (page)); +} + +#ifdef CONFIG_NUMA extern void set_highmem_pages_init (int );#else
@@ -283,7 +312,7 @@ static void __init set_highmem_pages_ini {int pfn;for (pfn = highstart_pfn; pfn < highend_pfn; pfn++) -one_highpage_init (pfn_to_page (pfn), pfn, bad_ppro); +add_one_highpage_init (pfn_to_page (pfn), pfn, bad_ppro); totalram_pages += totalhigh_pages; }#endif /* CONFIG_FLATMEM */
@@ -614,6 +643,28 @@ void __init mem_init(void)#endif } +/* +* this is for the non-NUMA, single node SMP system case. +* Specifically, in the case of x86, we will always add +* memory to the highmem for now. +*/ +#ifndef CONFIG_NEED_MULTIPLE_NODES +int add_memory (u64 start,u64 size) +{ +struct pglist_data *pgdata = &contig_page_data; +struct zone *zone = pgdata->node_zones +MAX_NR_ZONES -1 ; +unsigned long start_pfn = start >>PAGE_SHIFT ; +unsigned long nr_pages = size >>PAGE_SHIFT ; + +return __add_pages (zone, start_pfn, nr_pages); +} + +int remove_memory (u64 start,u64 size) +{ +return -EINVAL ; +} +#endif +kmem_cache_t *pgd_cache;kmem_cache_t *pmd_cache;
diff -puN arch/i386/Kconfig~D1-i386-hotplug-functions arch/i386/Kconfig
arch/i386/mm/discontig.c renamed from arch/i386/mm/discontig.c~D1-i386-hotplug-functions +2 -2
@@ -98,7 +98,7 @@ unsigned long node_memmap_size_bytes(intextern unsigned long find_max_low_pfn (void );extern void find_max_pfn (void ); -extern void one_highpage_init (struct page *,int ,int ); +extern void add_one_highpage_init (struct page *,int ,int );extern struct e820map e820;extern unsigned long init_pg_tables_end;
@@ -427,7 +427,7 @@ void __init set_highmem_pages_init(int bif (!pfn_valid (node_pfn))continue ; page =pfn_to_page (node_pfn); -one_highpage_init (page, node_pfn, bad_ppro); +add_one_highpage_init (page, node_pfn, bad_ppro); } } totalram_pages += totalhigh_pages;
diff -puN mm/highmem.c~D1-i386-hotplug-functions mm/highmem.c _
RFC PATCH 12/12 memory hotplug: ppc64 specific hot-add functions
In reply to Dave HansenHere is a set of ppc64 specific patches that at least allow compilation/booting with the following configurations:
FLATMEM
SPARSEMEN
SPARSEMEM + MEMORY_HOTPLUG
---
include/asm-ppc64/mmzone.h | 0 memhotplug-dave/arch/ppc64/mm/init.c | 77 +++++++++++++++++++++++++++ memhotplug-dave/include/asm-ppc64/abs_addr.h | 2 3 files changed, 79 insertions(+)
arch/ppc64/mm/init.c renamed from arch/ppc64/mm/init.c~D2-ppc64-hotplug-functions +77 -0
@@ -870,3 +870,80 @@ pgprot_t phys_mem_access_prot(struct filreturn vma_prot; }EXPORT_SYMBOL (phys_mem_access_prot); + +#ifdef CONFIG_MEMORY_HOTPLUG + +void online_page (struct page *page) +{ +ClearPageReserved (page); +free_cold_page (page); + totalram_pages++; + num_physpages++; +} + +/* +* This works only for the non-NUMA case. Later, we'll need a lookup +* to convert from real physical addresses to nid, that doesn't use +* pfn_to_nid(). +*/ +int __devinit add_memory (u64 start,u64 size) +{ +struct pglist_data *pgdata =NODE_DATA (0 ); +struct zone *zone; +unsigned long start_pfn = start >>PAGE_SHIFT ; +unsigned long nr_pages = size >>PAGE_SHIFT ; + +/* this should work for most non-highmem platforms */ + zone = pgdata->node_zones; + +return __add_pages (zone, start_pfn, nr_pages); + +return 0 ; +} + +/* +* First pass at this code will check to determine if the remove +* request is within the RMO. Do not allow removal within the RMO. +*/ +int __devinit remove_memory (u64 start,u64 size) +{ +struct zone *zone; +unsigned long start_pfn, end_pfn, nr_pages; + + start_pfn = start >>PAGE_SHIFT ; + nr_pages = size >>PAGE_SHIFT ; + end_pfn = start_pfn + nr_pages; + +printk ("%s(): Attempting to remove memoy in range " +"%lx to %lx\n" , __func__, start, start+size); +/* +* check for range within RMO +*/ + zone =page_zone (pfn_to_page (start_pfn)); + +printk ("%s(): memory will be removed from " +"the %s zone\n" , __func__, zone->name); + +/* +* not handling removing memory ranges that +* overlap multiple zones yet +*/ +if (end_pfn > (zone->zone_start_pfn + zone->spanned_pages)) + goto overlap; + +/* make sure it is NOT in RMO */ +if ((start < lmb.rmo_size) || ((start+size) < lmb.rmo_size)) { +printk ("%s(): range to be removed must NOT be in RMO!\n" , + __func__); + goto in_rmo; + } + +return __remove_pages (zone, start_pfn, nr_pages); + +overlap: +printk ("%s(): memory range to be removed overlaps " +"multiple zones!!!\n" , __func__); +in_rmo: +return -1 ; +} +#endif /* CONFIG_MEMORY_HOTPLUG */
include/asm-ppc64/abs_addr.h renamed from include/asm-ppc64/abs_addr.h~D2-ppc64-hotplug-functions +2 -0
@@ -104,5 +104,7 @@ physRpn_to_absRpn(unsigned long rpn)/* Convenience macros */ #define virt_to_abs (va) phys_to_abs(__pa(va))#define abs_to_virt (aa) __va(abs_to_phys(aa)) +#define boot_virt_to_abs (va) phys_to_abs(__boot_pa(va)) +#define boot_abs_to_virt (aa) __boot_va(abs_to_phys(aa))#endif /* _ABS_ADDR_H */
diff -puN include/asm-ppc64/mmzone.h~D2-ppc64-hotplug-functions include/asm-ppc64/mmzone.h _