x86: move range related operation to one file
Subsystems (8)
PATCH 1/9 x86: move range related operation to one file
In reply to a message not in the archive--- arch/x86/kernel/cpu/mtrr/cleanup.c | 180 +++---------------------------------- arch/x86/kernel/mmconf-fam10h_64.c | 7 - arch/x86/pci/amd_bus.c | 70 ++------------ include/linux/range.h | 22 ++++ kernel/Makefile | 2 kernel/range.c | 154 +++++++++++++++++++++++++++++++ 6 files changed, 205 insertions(+), 230 deletions(-)
arch/x86/kernel/cpu/mtrr/cleanup.c +15 -165
@@ -22,10 +22,10 @@#include <linux/pci.h> #include <linux/smp.h> #include <linux/cpu.h> -#include <linux/sort.h> #include <linux/mutex.h> #include <linux/uaccess.h> #include <linux/kvm_para.h> +#include <linux/range.h> #include <asm/processor.h> #include <asm/e820.h>
@@ -34,11 +34,6 @@#include "mtrr.h" -struct res_range { -unsigned long start; -unsigned long end; -}; -struct var_mtrr_range_state {unsigned long base_pfn;unsigned long size_pfn;
@@ -56,7 +51,7 @@ struct var_mtrr_state {/* Should be related to MTRR_VAR_RANGES nums */ #define RANGE_NUM 256 -static struct res_range __initdata range[RANGE_NUM ]; +static struct range __initdata range[RANGE_NUM ];static int __initdata nr_range;static struct var_mtrr_range_state __initdata range_state[RANGE_NUM ];
@@ -64,152 +59,11 @@ static struct var_mtrr_range_state __inistatic int __initdata debug_print; #define Dprintk(x...) do { if (debug_print) printk(KERN_DEBUG x); } while (0) - -static int __init -add_range (struct res_range *range,int nr_range, -unsigned long start,unsigned long end) -{ -/* Out of slots: */ -if (nr_range >=RANGE_NUM ) -return nr_range; - - range[nr_range].start = start; - range[nr_range].end = end; - - nr_range++; - -return nr_range; -} - -static int __init -add_range_with_merge (struct res_range *range,int nr_range, -unsigned long start,unsigned long end) -{ -int i; - -/* Try to merge it with old one: */ -for (i =0 ; i < nr_range; i++) { -unsigned long final_start, final_end; -unsigned long common_start, common_end; - -if (!range[i].end) -continue ; - - common_start =max (range[i].start, start); - common_end =min (range[i].end, end); -if (common_start > common_end +1 ) -continue ; - - final_start =min (range[i].start, start); - final_end =max (range[i].end, end); - - range[i].start = final_start; - range[i].end = final_end; -return nr_range; - } - -/* Need to add it: */ -return add_range (range, nr_range, start, end); -} - -static void __init -subtract_range (struct res_range *range,unsigned long start,unsigned long end) -{ -int i, j; - -for (j =0 ; j <RANGE_NUM ; j++) { -if (!range[j].end) -continue ; - -if (start <= range[j].start && end >= range[j].end) { - range[j].start =0 ; - range[j].end =0 ; -continue ; - } - -if (start <= range[j].start && end < range[j].end && - range[j].start < end +1 ) { - range[j].start = end +1 ; -continue ; - } - - -if (start > range[j].start && end >= range[j].end && - range[j].end > start -1 ) { - range[j].end = start -1 ; -continue ; - } - -if (start > range[j].start && end < range[j].end) { -/* Find the new spare: */ -for (i =0 ; i <RANGE_NUM ; i++) { -if (range[i].end ==0 ) -break ; - } -if (i <RANGE_NUM ) { - range[i].end = range[j].end; - range[i].start = end +1 ; - }else { -printk (KERN_ERR "run of slot in ranges\n" ); - } - range[j].end = start -1 ; -continue ; - } - } -} - -static int __init cmp_range (const void *x1,const void *x2) -{ -const struct res_range *r1 = x1; -const struct res_range *r2 = x2; -long start1, start2; - - start1 = r1->start; - start2 = r2->start; - -return start1 - start2; -} - -static int __init clean_sort_range (struct res_range *range,int az) -{ -int i, j, k = az -1 , nr_range =0 ; - -for (i =0 ; i < k; i++) { -if (range[i].end) -continue ; -for (j = k; j > i; j--) { -if (range[j].end) { - k = j; -break ; - } - } -if (j == i) -break ; - range[i].start = range[k].start; - range[i].end = range[k].end; - range[k].start =0 ; - range[k].end =0 ; - k--; - } -/* count it */ -for (i =0 ; i < az; i++) { -if (!range[i].end) { - nr_range = i; -break ; - } - } - -/* sort them */ -sort (range, nr_range,sizeof (struct res_range ), cmp_range,NULL ); - -return nr_range; -} -#define BIOS_BUG_MSG KERN_WARNING \ "WARNING: BIOS bug: VAR MTRR %d contains strange UC entry under 1M, check with your system vendor!\n"static int __init -x86_get_mtrr_mem_range (struct res_range *range,int nr_range, +x86_get_mtrr_mem_range (struct range *range,int nr_range,unsigned long extra_remove_base,unsigned long extra_remove_size) {
@@ -223,13 +77,13 @@ x86_get_mtrr_mem_range(struct res_rangecontinue ; base = range_state[i].base_pfn; size = range_state[i].size_pfn; - nr_range =add_range_with_merge (range, nr_range, base, - base + size -1 ); + nr_range =add_range_with_merge (range,RANGE_NUM , nr_range, + base, base + size -1 ); }if (debug_print) {printk (KERN_DEBUG "After WB checking\n" );for (i =0 ; i < nr_range; i++) -printk (KERN_DEBUG "MTRR MAP PFN: %016lx - %016lx\n" , +printk (KERN_DEBUG "MTRR MAP PFN: %016llx - %016llx\n" , range[i].start, range[i].end +1 ); }
@@ -252,10 +106,10 @@ x86_get_mtrr_mem_range(struct res_range size -= (1 <<(20 -PAGE_SHIFT )) - base; base =1 <<(20 -PAGE_SHIFT ); } -subtract_range (range, base, base + size -1 ); +subtract_range (range,RANGE_NUM , base, base + size -1 ); }if (extra_remove_size) -subtract_range (range, extra_remove_base, +subtract_range (range,RANGE_NUM , extra_remove_base, extra_remove_base + extra_remove_size -1 );if (debug_print) {
@@ -263,7 +117,7 @@ x86_get_mtrr_mem_range(struct res_rangefor (i =0 ; i <RANGE_NUM ; i++) {if (!range[i].end)continue ; -printk (KERN_DEBUG "MTRR MAP PFN: %016lx - %016lx\n" , +printk (KERN_DEBUG "MTRR MAP PFN: %016llx - %016llx\n" , range[i].start, range[i].end +1 ); } }
@@ -273,20 +127,16 @@ x86_get_mtrr_mem_range(struct res_rangeif (debug_print) {printk (KERN_DEBUG "After sorting\n" );for (i =0 ; i < nr_range; i++) -printk (KERN_DEBUG "MTRR MAP PFN: %016lx - %016lx\n" , +printk (KERN_DEBUG "MTRR MAP PFN: %016llx - %016llx\n" , range[i].start, range[i].end +1 ); } -/* clear those is not used */ -for (i = nr_range; i <RANGE_NUM ; i++) -memset (&range[i],0 ,sizeof (range[i])); -return nr_range; }#ifdef CONFIG_MTRR_SANITIZER -static unsigned long __init sum_ranges (struct res_range *range,int nr_range) +static unsigned long __init sum_ranges (struct range *range,int nr_range) {unsigned long sum =0 ;int i;
@@ -621,7 +471,7 @@ static int __init parse_mtrr_spare_reg(cearly_param ("mtrr_spare_reg_nr" , parse_mtrr_spare_reg);static int __init -x86_setup_var_mtrrs (struct res_range *range,int nr_range, +x86_setup_var_mtrrs (struct range *range,int nr_range,u64 chunk_size,u64 gran_size) {struct var_mtrr_state var_state;
@@ -742,7 +592,7 @@ mtrr_calc_range_state(u64 chunk_size, u6unsigned long x_remove_base, unsigned long x_remove_size, int i) { - static struct res_range range_new[RANGE_NUM]; + static struct range range_new[RANGE_NUM];unsigned long range_sums_new;static int nr_range_new;int num_reg;
@@ -869,10 +719,10 @@ int __init mtrr_cleanup(unsigned address* [0, 1M) should always be covered by var mtrr with WB * and fixed mtrrs should take effect before var mtrr for it: */ - nr_range =add_range_with_merge (range, nr_range,0 , + nr_range =add_range_with_merge (range,RANGE_NUM , nr_range,0 , (1ULL <<(20 -PAGE_SHIFT )) -1 );/* Sort the ranges: */ -sort (range, nr_range,sizeof (struct res_range ), cmp_range,NULL ); +sort_range (range, nr_range); range_sums =sum_ranges (range, nr_range); printk(KERN_INFO "total RAM covered: %ldM\n",
include/linux/range.h new file +22 -0
@@ -0,0 +1,22 @@ +#ifndef _LINUX_RANGE_H +#define _LINUX_RANGE_H + +struct range { +u64 start; +u64 end; +}; + +int add_range (struct range *range,int az,int nr_range, +u64 start,u64 end); + + +int add_range_with_merge (struct range *range,int az,int nr_range, +u64 start,u64 end); + +void subtract_range (struct range *range,int az,u64 start,u64 end); + +int clean_sort_range (struct range *range,int az); + +void sort_range (struct range *range,int nr_range); + +#endif
kernel/Makefile +1 -1
@@ -10,7 +10,7 @@ obj-y = sched.o fork.o exec_domain.o kthread.o wait.o kfifo.o sys_ni.o posix-cpu-timers.o mutex.o \ hrtimer.o rwsem.o nsproxy.o srcu.o semaphore.o \ notifier.o ksysfs.o pm_qos_params.o sched_clock.o cred.o \ - async.o + async.o range.o obj-y += groups.o ifdef CONFIG_FUNCTION_TRACER
kernel/range.c new file +154 -0
154 lines not on this page · raw message
arch/x86/kernel/mmconf-fam10h_64.c +2 -5
@@ -7,6 +7,8 @@#include <linux/string.h> #include <linux/pci.h> #include <linux/dmi.h> +#include <linux/range.h> +#include <asm/pci-direct.h> #include <linux/sort.h> #include <asm/io.h>
@@ -30,11 +32,6 @@ static struct pci_hostbridge_probe pci_p { 0xff, 0, PCI_VENDOR_ID_AMD, 0x1200 }, }; -struct range { -u64 start; -u64 end; -}; -static int __cpuinit cmp_range (const void *x1,const void *x2) {const struct range *r1 = x1;
arch/x86/pci/amd_bus.c +11 -59
130 lines not on this page · raw message
PATCH 2/9 x86: check range in update range
In reply to a message not in the archivefend off wrong range
--- kernel/range.c | 9 +++++++++ 1 file changed, 9 insertions(+)
kernel/range.c +9 -0
@@ -13,6 +13,9 @@int add_range (struct range *range,int az,int nr_range,u64 start,u64 end) { +if (start > end) +return nr_range; +/* Out of slots: */ if (nr_range >= az)return nr_range;
@@ -30,6 +33,9 @@ int add_range_with_merge(struct range *r {int i; +if (start > end) +return nr_range; +/* Try to merge it with old one: */ for (i =0 ; i < nr_range; i++) {u64 final_start, final_end;
@@ -59,6 +65,9 @@ void subtract_range(struct range *range, {int i, j; +if (start > end) +return ; +for (j =0 ; j < az; j++) {if (!range[j].end)continue ;
PATCH 3/9 x86: call early_res_to_bootmem one time
In reply to a message not in the archivesimplify setup_node_mem, do use bootmem from other node. instead just find_e820_area in early_node_mem.
so we can keep the boundary between early_res and boot mem more clear. and only call civertion one time instead of for all nodes.
--- arch/x86/kernel/setup.c | 1 arch/x86/mm/init_32.c | 1 arch/x86/mm/init_64.c | 3 -- arch/x86/mm/numa_64.c | 62 +++++++++++++++--------------------------------- 4 files changed, 22 insertions(+), 45 deletions(-)
arch/x86/kernel/setup.c +1 -0
@@ -942,6 +942,7 @@ void __init setup_arch(char **cmdline_p)#endif initmem_init (0 , max_pfn, acpi, k8); +early_res_to_bootmem (0 , max_low_pfn<<PAGE_SHIFT );#ifdef CONFIG_X86_64 /*
arch/x86/mm/init_32.c +0 -1
@@ -764,7 +764,6 @@ static unsigned long __init setup_node_bprintk (KERN_INFO " node %d bootmap %08lx - %08lx\n" , nodeid, bootmap, bootmap + bootmap_size);free_bootmem_with_active_regions (nodeid, end_pfn); -early_res_to_bootmem (start_pfn<<PAGE_SHIFT , end_pfn<<PAGE_SHIFT );return bootmap + bootmap_size; }
arch/x86/mm/init_64.c +1 -2
@@ -578,13 +578,12 @@ void __init initmem_init(unsigned long s PAGE_SIZE);if (bootmap ==-1L )panic ("Cannot find bootmem map of size %ld\n" , bootmap_size); +reserve_early (bootmap, bootmap + bootmap_size,"BOOTMAP" );/* don't touch min_low_pfn */ bootmap_size =init_bootmem_node (NODE_DATA (0 ), bootmap >>PAGE_SHIFT ,0 , end_pfn);e820_register_active_regions (0 , start_pfn, end_pfn); free_bootmem_with_active_regions(0, end_pfn); -early_res_to_bootmem (0 , end_pfn<<PAGE_SHIFT ); - reserve_bootmem(bootmap, bootmap_size, BOOTMEM_DEFAULT); }#endif
arch/x86/mm/numa_64.c +20 -42
106 lines not on this page · raw message
PATCH 4/9 x86: introduce max_early_res and early_res_count
In reply to a message not in the archiveto prepare allocate early res array from fine_e820_area
--- arch/x86/kernel/e820.c | 47 ++++++++++++++++++++++++++++++++--------------- 1 file changed, 32 insertions(+), 15 deletions(-)
arch/x86/kernel/e820.c +32 -15
@@ -724,14 +724,18 @@ core_initcall(e820_mark_nvs_memory);/* * Early reserved memory areas. */ -#define MAX_EARLY_RES 32 +/* +* need to make sure this one is bigger enough before +* find_e820_area could be used +*/ +#define MAX_EARLY_RES_X 32struct early_res {u64 start, end; -char name[16 ]; +char name[15 ];char overlap_ok; }; -static struct early_res early_res[MAX_EARLY_RES ]__initdata = { +static struct early_res early_res_x[MAX_EARLY_RES_X ]__initdata = { {0 ,PAGE_SIZE ,"BIOS data page" ,1 },/* BIOS data page */ #ifdef CONFIG_X86_32/*
@@ -745,12 +749,22 @@ static struct early_res early_res[MAX_EA {} }; +static int max_early_res__initdata =MAX_EARLY_RES_X ; +static struct early_res *early_res__initdata = &early_res_x[0 ]; +static int early_res_count __initdata = +#ifdef CONFIG_X86_32 + 2 +#else + 1 +#endif + ; +static int __init find_overlapped_early (u64 start,u64 end) {int i;struct early_res *r; -for (i =0 ; i <MAX_EARLY_RES && early_res[i].end; i++) { +for (i =0 ; i < max_early_res && early_res[i].end; i++) { r = &early_res[i];if (end > r->start && start < r->end)break ;
@@ -768,13 +782,14 @@ static void __init drop_range(int i) {int j; -for (j = i +1 ; j <MAX_EARLY_RES && early_res[j].end; j++) +for (j = i +1 ; j < max_early_res && early_res[j].end; j++) ;memmove (&early_res[i], &early_res[i +1 ], (j -1 - i) *sizeof (struct early_res )); early_res[j -1 ].end =0 ; + early_res_count--; }/*
@@ -793,9 +808,9 @@ static void __init drop_overlaps_that_arstruct early_res *r;u64 lower_start, lower_end;u64 upper_start, upper_end; -char name[16 ]; +char name[15 ]; -for (i =0 ; i <MAX_EARLY_RES && early_res[i].end; i++) { +for (i =0 ; i < max_early_res && early_res[i].end; i++) { r = &early_res[i];/* Continue past non-overlapping ranges */
@@ -851,7 +866,7 @@ static void __init __reserve_early(u64 sstruct early_res *r; i =find_overlapped_early (start, end); -if (i >=MAX_EARLY_RES ) +if (i >= max_early_res)panic ("Too many early reservations" ); r = &early_res[i];if (r->end)
@@ -864,6 +879,7 @@ static void __init __reserve_early(u64 s r->overlap_ok = overlap_ok;if (name)strncpy (r->name, name,sizeof (r->name) -1 ); + early_res_count++; }/*
@@ -916,7 +932,7 @@ void __init free_early(u64 start, u64 en i =find_overlapped_early (start, end); r = &early_res[i]; -if (i >=MAX_EARLY_RES || r->end != end || r->start != start) +if (i >= max_early_res || r->end != end || r->start != start)panic ("free_early on not reserved area: %llx-%llx!" , start, end -1 );
@@ -927,14 +943,15 @@ void __init early_res_to_bootmem(u64 sta {int i, count;u64 final_start, final_end; +int idx =0 ; count =0 ; -for (i =0 ; i <MAX_EARLY_RES && early_res[i].end; i++) +for (i =0 ; i < max_early_res && early_res[i].end; i++) count++; -printk (KERN_INFO "(%d early reservations) ==> bootmem [%010llx - %010llx]\n" , - count, start, end); -for (i =0 ; i < count; i++) { +printk (KERN_INFO "(%d/%d early reservations) ==> bootmem [%010llx - %010llx]\n" , + count - idx, max_early_res, start, end); +for (i = idx; i < count; i++) {struct early_res *r = &early_res[i];printk (KERN_INFO " #%d [%010llx - %010llx] %16s" , i, r->start, r->end, r->name);
@@ -961,7 +978,7 @@ static inline int __init bad_addr(u64 *a again: i =find_overlapped_early (addr, addr + size); r = &early_res[i]; -if (i <MAX_EARLY_RES && r->end) { +if (i < max_early_res && r->end) { *addrp = addr =round_up (r->end, align); changed =1 ; goto again;
@@ -978,7 +995,7 @@ static inline int __init bad_addr_size(uint changed =0 ; again: last = addr + size; -for (i =0 ; i <MAX_EARLY_RES && early_res[i].end; i++) { +for (i =0 ; i < max_early_res && early_res[i].end; i++) {struct early_res *r = &early_res[i];if (last > r->start && addr < r->start) { size = r->start - addr;
PATCH 5/9 x86: dynamic increase early_res array size -v2
In reply to a message not in the archiveuse early_res_count to track the num, and use find_e820 to get new buffer. and copy from old to new one.
also clear early_res to prevent later invalid using
-v2 _check_and_double_early_res should take new start
--- arch/x86/kernel/e820.c | 53 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 53 insertions(+)
arch/x86/kernel/e820.c +53 -0
@@ -908,6 +908,48 @@ void __init reserve_early_overlap_ok(u64__reserve_early (start, end, name,1 ); } +static void __init __check_and_double_early_res (u64 start) +{ +u64 end, size, mem; +struct early_res *new; + +/* do we have enough slots left ? */ +if ((max_early_res - early_res_count) >max (max_early_res/8 ,2 )) +return ; + +/* double it */ + end = max_pfn_mapped <<PAGE_SHIFT ; + size =sizeof (struct early_res ) * max_early_res *2 ; + mem =find_e820_area (start, end, size,sizeof (struct early_res )); + +if (mem ==-1ULL ) +panic ("can not find more space for early_res array" ); + + new =__va (mem); +/* save the first one for own */ + new[0 ].start = mem; + new[0 ].end = mem + size; + new[0 ].overlap_ok =0 ; +/* copy old to new */ +if (early_res == early_res_x) { +memcpy (&new[1 ], &early_res[0 ], +sizeof (struct early_res ) * max_early_res); +memset (&new[max_early_res+1 ],0 , +sizeof (struct early_res ) * (max_early_res -1 )); + early_res_count++; + }else { +memcpy (&new[1 ], &early_res[1 ], +sizeof (struct early_res ) * (max_early_res -1 )); +memset (&new[max_early_res],0 , +sizeof (struct early_res ) * max_early_res); + } +memset (&early_res[0 ],0 ,sizeof (struct early_res ) * max_early_res); + early_res = new; + max_early_res *=2 ; +printk (KERN_DEBUG "early_res array is doubled to %d at [%llx - %llx]\n" , + max_early_res, mem, mem + size -1 ); +} +/* * Most early reservations come here. *
@@ -921,6 +963,8 @@ void __init reserve_early(u64 start, u64if (start >= end)return ; +__check_and_double_early_res (end); +drop_overlaps_that_are_ok (start, end);__reserve_early (start, end, name,0 ); }
@@ -949,6 +993,10 @@ void __init early_res_to_bootmem(u64 stafor (i =0 ; i < max_early_res && early_res[i].end; i++) count++; +/* need to skip first one ?*/ +if (early_res != early_res_x) + idx =1 ; +printk (KERN_INFO "(%d/%d early reservations) ==> bootmem [%010llx - %010llx]\n" , count - idx, max_early_res, start, end);for (i = idx; i < count; i++) {
@@ -966,6 +1014,11 @@ void __init early_res_to_bootmem(u64 stareserve_bootmem_generic (final_start, final_end - final_start,BOOTMEM_DEFAULT ); } +/* clear them */ +memset (&early_res[0 ],0 ,sizeof (struct early_res ) * max_early_res); + early_res =NULL ; + max_early_res =0 ; + early_res_count =0 ; }/* Check for already reserved areas */
PATCH 6/9 x86: print bootmem free before pci_iommu_alloc and free_all_bootmem -v2
In reply to a message not in the archiveso we could double check if we have enough low pages later
-v2: fix errors checkpatch.pl reported
--- arch/x86/mm/init_64.c | 2 + include/linux/bootmem.h | 2 + mm/bootmem.c | 92 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 96 insertions(+)
mm/bootmem.c +92 -0
@@ -267,6 +267,98 @@ static void __init __free(bootmem_data_tBUG (); } +static void __init print_all_bootmem_free_core (bootmem_data_t *bdata) +{ +int aligned; +unsigned long *map; +unsigned long start, end, count =0 ; +unsigned long free_start =-1UL , free_end =0 ; + +if (!bdata->node_bootmem_map) +return ; + + start = bdata->node_min_pfn; + end = bdata->node_low_pfn; + +/* +* If the start is aligned to the machines wordsize, we might +* be able to count it in bulks of that order. +*/ + aligned = !(start & (BITS_PER_LONG -1 )); + +printk (KERN_DEBUG "nid=%td start=0x%010lx end=0x%010lx aligned=%d\n" , + bdata - bootmem_node_data, start, end, aligned); + map = bdata->node_bootmem_map; + +while (start < end) { +unsigned long idx, vec; + + idx = start - bdata->node_min_pfn; + vec = ~map[idx /BITS_PER_LONG ]; + +if (aligned && vec == ~0UL && start +BITS_PER_LONG < end) { +if (free_start ==-1UL ) { + free_start = idx; + free_end = free_start +BITS_PER_LONG ; + }else { +if (free_end == idx) { + free_end +=BITS_PER_LONG ; + }else { +/* there is gap, print old */ +printk (KERN_DEBUG " free [0x%010lx - 0x%010lx]\n" , + free_start + bdata->node_min_pfn, + free_end + bdata->node_min_pfn); + free_start = idx; + free_end = idx +BITS_PER_LONG ; + } + } + count +=BITS_PER_LONG ; + }else { +unsigned long off =0 ; + +while (vec && off <BITS_PER_LONG ) { +if (vec &1 ) { +if (free_start ==-1UL ) { + free_start = idx + off; + free_end = free_start +1 ; + }else { +if (free_end == (idx + off)) { + free_end++; + }else { +/* there is gap, print old */ +printk (KERN_DEBUG " free [0x%010lx - 0x%010lx]\n" , + free_start + bdata->node_min_pfn, + free_end + bdata->node_min_pfn); + free_start = idx + off; + free_end = free_start +1 ; + } + } + count++; + } + vec >>=1 ; + off++; + } + } + start +=BITS_PER_LONG ; + } + +/* last one */ +if (free_start !=-1UL ) +printk (KERN_DEBUG " free [0x%010lx - 0x%010lx]\n" , + free_start + bdata->node_min_pfn, + free_end + bdata->node_min_pfn); +printk (KERN_DEBUG " total free 0x%010lx\n" , count); +} + +void __init print_bootmem_free (void ) +{ +bootmem_data_t *bdata; + +list_for_each_entry (bdata, &bdata_list, list) { +print_all_bootmem_free_core (bdata); + } +} +static int __init __reserve (bootmem_data_t *bdata,unsigned long sidx,unsigned long eidx,int flags) {
arch/x86/mm/init_64.c +2 -0
@@ -654,6 +654,8 @@ void __init mem_init(void)long codesize, reservedpages, datasize, initsize;unsigned long absent_pages; +print_bootmem_free (); +pci_iommu_alloc ();/* clear_bss() already clear the empty_zero_page */
include/linux/bootmem.h +2 -0
@@ -55,6 +55,8 @@ extern void free_bootmem_node(pg_data_textern void free_bootmem (unsigned long addr,unsigned long size);extern void free_bootmem_late (unsigned long addr,unsigned long size); +void print_bootmem_free (void ); +/* * Flags for reserve_bootmem (also if CONFIG_HAVE_ARCH_BOOTMEM_NODE, * the architecture-specific code should honor this).
PATCH 8/9 x86: only call dma32_reserve_bootmem 64bit !CONFIG_NUMA
In reply to a message not in the archive64bit NUMA already make enough space under 4G with new early_node_mem
--- arch/x86/include/asm/pci.h | 2 ++ arch/x86/include/asm/pci_64.h | 2 -- arch/x86/kernel/pci-dma.c | 13 ++++++++++--- arch/x86/kernel/setup.c | 7 ------- 4 files changed, 12 insertions(+), 12 deletions(-)
arch/x86/kernel/pci-dma.c +10 -3
@@ -65,7 +65,7 @@ int dma_set_mask(struct device *dev, u64 }EXPORT_SYMBOL (dma_set_mask); -#ifdef CONFIG_X86_64 +#if defined(CONFIG_X86_64 ) && !defined(CONFIG_NUMA )static __initdata void *dma32_bootmem_ptr;static unsigned long dma32_bootmem_size__initdata = (128ULL <<20 );
@@ -116,14 +116,21 @@ static void __init dma32_free_bootmem(vo dma32_bootmem_ptr =NULL ; dma32_bootmem_size = 0; } +#else +void __init dma32_reserve_bootmem (void ) +{ +} +static void __init dma32_free_bootmem (void ) +{ +} +#endif void __init pci_iommu_alloc (void ) { -#ifdef CONFIG_X86_64 /* free the range so iommu could get some range less than 4G */ dma32_free_bootmem (); -#endif +if (pci_swiotlb_detect ()) goto out;
arch/x86/kernel/setup.c +0 -7
@@ -944,14 +944,7 @@ void __init setup_arch(char **cmdline_p)initmem_init (0 , max_pfn, acpi, k8);early_res_to_bootmem (0 , max_low_pfn<<PAGE_SHIFT ); -#ifdef CONFIG_X86_64 -/* -* dma32_reserve_bootmem() allocates bootmem which may conflict -* with the crashkernel command line, so do that after -* reserve_crashkernel() -*/ dma32_reserve_bootmem (); -#endif reserve_ibft_region ();
arch/x86/include/asm/pci.h +2 -0
@@ -124,6 +124,8 @@ extern void pci_iommu_alloc(void);#include "pci_64.h" #endif +void dma32_reserve_bootmem (void ); +/* implement the pci_ DMA API in terms of the generic device dma_ one */ #include <asm-generic/pci-dma-compat.h>
arch/x86/include/asm/pci_64.h +0 -2
@@ -22,8 +22,6 @@ extern int (*pci_config_read)(int seg, iextern int (*pci_config_write)(int seg,int bus,int dev,int fn,int reg,int len,u32 value); -extern void dma32_reserve_bootmem (void ); -#endif /* __KERNEL__ */ #endif /* _ASM_X86_PCI_64_H */
PATCH 7/9 x86: make early_node_mem get mem > 4g if possible -v2
In reply to a message not in the archiveso we could put pgdata for the node high, and later sparse vmmap will get the section nr that need.
with this patch will make <4g ram will not use sparse vmmap
before this patch, will get, before swiotlb try get bootmem
[ 0.000000] nid=1 start=0 end=2080000 aligned=1 [ 0.000000] free [10 - 96] [ 0.000000] free [b12 - 1000] [ 0.000000] free [359f - 38a3] [ 0.000000] free [38b5 - 3a00] [ 0.000000] free [41e01 - 42000] [ 0.000000] free [73dde - 73e00] [ 0.000000] free [73fdd - 74000] [ 0.000000] free [741dd - 74200] [ 0.000000] free [743dd - 74400] [ 0.000000] free [745dd - 74600] [ 0.000000] free [747dd - 74800] [ 0.000000] free [749dd - 74a00] [ 0.000000] free [74bdd - 74c00] [ 0.000000] free [74ddd - 74e00] [ 0.000000] free [74fdd - 75000] [ 0.000000] free [751dd - 75200] [ 0.000000] free [753dd - 75400] [ 0.000000] free [755dd - 75600] [ 0.000000] free [757dd - 75800] [ 0.000000] free [759dd - 75a00] [ 0.000000] free [75bdd - 7bf5f] [ 0.000000] free [7f730 - 7f750] [ 0.000000] free [100000 - 2080000] [ 0.000000] total free 1f87170 [ 93.301474] Placing 64MB software IO TLB between ffff880075bdd000 - ffff880079bdd000 [ 93.311814] software IO TLB at phys 0x75bdd000 - 0x79bdd000
with this patch will get: before swiotlb try get bootmem
[ 0.000000] nid=1 start=0 end=2080000 aligned=1 [ 0.000000] free [a - 96] [ 0.000000] free [702 - 1000] [ 0.000000] free [359f - 3600] [ 0.000000] free [37de - 3800] [ 0.000000] free [39dd - 3a00] [ 0.000000] free [3bdd - 3c00] [ 0.000000] free [3ddd - 3e00] [ 0.000000] free [3fdd - 4000] [ 0.000000] free [41dd - 4200] [ 0.000000] free [43dd - 4400] [ 0.000000] free [45dd - 4600] [ 0.000000] free [47dd - 4800] [ 0.000000] free [49dd - 4a00] [ 0.000000] free [4bdd - 4c00] [ 0.000000] free [4ddd - 4e00] [ 0.000000] free [4fdd - 5000] [ 0.000000] free [51dd - 5200] [ 0.000000] free [53dd - 5400] [ 0.000000] free [55dd - 7bf5f] [ 0.000000] free [7f730 - 7f750] [ 0.000000] free [100428 - 100600] [ 0.000000] free [13ea01 - 13ec00] [ 0.000000] free [170800 - 2080000] [ 0.000000] total free 1f87170
[ 92.689485] PCI-DMA: Using software bounce buffering for IO (SWIOTLB) [ 92.699799] Placing 64MB software IO TLB between ffff8800055dd000 - ffff8800095dd000 [ 92.710916] software IO TLB at phys 0x55dd000 - 0x95dd000
so will get enough space below 4G, aka pfn 0x100000
--- arch/x86/mm/numa_64.c | 21 +++++++++++++++++---- 1 file changed, 17 insertions(+), 4 deletions(-)
arch/x86/mm/numa_64.c +17 -4
@@ -163,14 +163,27 @@ static void * __init early_node_mem(int unsigned long end, unsigned long size, unsigned long align) { - unsigned long mem = find_e820_area(start, end, size, align); + unsigned long mem; +/* +* put it on high as possible +* something will go with NODE_DATA +*/ +if (start < (MAX_DMA_PFN <<PAGE_SHIFT )) + start =MAX_DMA_PFN <<PAGE_SHIFT ; +if (start < (MAX_DMA32_PFN <<PAGE_SHIFT ) && + end > (MAX_DMA32_PFN <<PAGE_SHIFT )) + start =MAX_DMA32_PFN <<PAGE_SHIFT ; + mem =find_e820_area (start, end, size, align);if (mem !=-1L )return __va (mem); - - start =__pa (MAX_DMA_ADDRESS ); - end = max_low_pfn_mapped <<PAGE_SHIFT ; +/* extend the search scope */ + end = max_pfn_mapped <<PAGE_SHIFT ; +if (end > (MAX_DMA32_PFN <<PAGE_SHIFT )) + start =MAX_DMA32_PFN <<PAGE_SHIFT ; +else + start =MAX_DMA_PFN <<PAGE_SHIFT ; mem =find_e820_area (start, end, size, align);if (mem !=-1L )return __va (mem);
PATCH 9/9 x86: make 64 bit use early_res instead of bootmem before slab
In reply to a message not in the archiveuse CONFIG_NO_BOOTMEM to control it.
--- arch/x86/Kconfig | 7 + arch/x86/include/asm/e820.h | 6 + arch/x86/kernel/e820.c | 144 +++++++++++++++++++++++++++++++--- arch/x86/kernel/setup.c | 2 arch/x86/mm/init_64.c | 7 + arch/x86/mm/numa_64.c | 20 +++- include/linux/bootmem.h | 7 + include/linux/mm.h | 5 + include/linux/mmzone.h | 2 mm/bootmem.c | 182 +++++++++++++++++++++++++++++++++++++++++++- mm/page_alloc.c | 53 ++++++++++++ mm/percpu.c | 3 mm/sparse-vmemmap.c | 2 13 files changed, 416 insertions(+), 24 deletions(-)
arch/x86/Kconfig +7 -0
@@ -565,6 +565,13 @@ config PARAVIRT_DEBUG Enable to debug paravirt_ops internals. Specifically, BUG if a paravirt_op is missing when it is called. +config NO_BOOTMEM + default y + bool "Disable Bootmem code" + depends on X86_64 + ---help--- + use early_res directly instead of bootmem before slab is ready. + config MEMTEST bool "Memtest" ---help---
arch/x86/include/asm/e820.h +6 -0
@@ -117,6 +117,12 @@ extern void free_early(u64 start, u64 enextern void early_res_to_bootmem (u64 start,u64 end);extern u64 early_reserve_e820 (u64 startt,u64 sizet,u64 align); +void reserve_early_without_check (u64 start,u64 end,char *name); +u64 find_early_area (u64 ei_start,u64 ei_last,u64 start,u64 end, +u64 size,u64 align); +#include <linux/range.h> +int get_free_all_memory_range (struct range **rangep,int nodeid); +extern unsigned long e820_end_of_ram_pfn (void );extern unsigned long e820_end_of_low_ram_pfn (void ); extern int e820_find_active_region(const struct e820entry *ei,
arch/x86/kernel/e820.c +131 -13
179 lines not on this page · raw message
arch/x86/kernel/setup.c +2 -0
@@ -942,7 +942,9 @@ void __init setup_arch(char **cmdline_p)#endif initmem_init (0 , max_pfn, acpi, k8); +#ifndef CONFIG_NO_BOOTMEM early_res_to_bootmem (0 , max_low_pfn<<PAGE_SHIFT ); +#endif dma32_reserve_bootmem ();
arch/x86/mm/init_64.c +6 -1
@@ -571,6 +571,7 @@ kernel_physical_mapping_init(unsigned lovoid __init initmem_init (unsigned long start_pfn,unsigned long end_pfn,int acpi,int k8) { +#ifndef CONFIG_NO_BOOTMEM unsigned long bootmap_size, bootmap; bootmap_size =bootmem_bootmap_pages (end_pfn)<<PAGE_SHIFT ;
@@ -582,8 +583,10 @@ void __init initmem_init(unsigned long s/* don't touch min_low_pfn */ bootmap_size =init_bootmem_node (NODE_DATA (0 ), bootmap >>PAGE_SHIFT ,0 , end_pfn); -e820_register_active_regions (0 , start_pfn, end_pfn);free_bootmem_with_active_regions (0 , end_pfn); +#else +e820_register_active_regions (0 , start_pfn, end_pfn); +#endif }#endif
@@ -654,7 +657,9 @@ void __init mem_init(void)long codesize, reservedpages, datasize, initsize;unsigned long absent_pages; +#ifndef CONFIG_NO_BOOTMEM print_bootmem_free (); +#endif pci_iommu_alloc ();
arch/x86/mm/numa_64.c +15 -5
@@ -198,11 +198,13 @@ static void * __init early_node_mem(intvoid __init setup_node_bootmem (int nodeid,unsigned long start,unsigned long end) { -unsigned long start_pfn, last_pfn, bootmap_pages, bootmap_size; +unsigned long start_pfn, last_pfn, nodedata_phys;const int pgdat_size =roundup (sizeof (pg_data_t),PAGE_SIZE ); -unsigned long bootmap_start, nodedata_phys; -void *bootmap;int nid; +#ifndef CONFIG_NO_BOOTMEM +unsigned long bootmap_start, bootmap_pages, bootmap_size; +void *bootmap; +#endif if (!end)return ;
@@ -216,7 +218,7 @@ setup_node_bootmem(int nodeid, unsigned start =roundup (start,ZONE_ALIGN ); -printk (KERN_INFO "Bootmem setup node %d %016lx-%016lx\n" , nodeid, +printk (KERN_INFO "Initmem setup node %d %016lx-%016lx\n" , nodeid, start, end); start_pfn = start >>PAGE_SHIFT ;
@@ -235,10 +237,13 @@ setup_node_bootmem(int nodeid, unsignedprintk (KERN_INFO " NODE_DATA(%d) on node %d\n" , nodeid, nid);memset (NODE_DATA (nodeid),0 ,sizeof (pg_data_t)); -NODE_DATA (nodeid)->bdata = &bootmem_node_data[nodeid]; +NODE_DATA (nodeid)->node_id = nodeid;NODE_DATA (nodeid)->node_start_pfn = start_pfn;NODE_DATA (nodeid)->node_spanned_pages = last_pfn - start_pfn; +#ifndef CONFIG_NO_BOOTMEM +NODE_DATA (nodeid)->bdata = &bootmem_node_data[nodeid]; +/* * Find a place for the bootmem map * nodedata_phys could be on other nodes by alloc_bootmem,
@@ -275,6 +280,7 @@ setup_node_bootmem(int nodeid, unsignedprintk (KERN_INFO " bootmap(%d) on node %d\n" , nodeid, nid);free_bootmem_with_active_regions (nodeid, end); +#endif node_set_online (nodeid); }
@@ -733,6 +739,10 @@ unsigned long __init numa_free_all_bootmfor_each_online_node (i) pages +=free_all_bootmem_node (NODE_DATA (i)); +#ifdef CONFIG_NO_BOOTMEM + pages +=free_all_memory_core_early (MAX_NUMNODES ); +#endif +return pages; }
include/linux/bootmem.h +7 -0
@@ -23,6 +23,7 @@ extern unsigned long max_pfn;extern unsigned long saved_max_pfn;#endif +#ifndef CONFIG_NO_BOOTMEM /* * node_bootmem_map is a map pointer - the bits represent all physical * memory pages (including holes) on the node.
@@ -37,6 +38,7 @@ typedef struct bootmem_data { } bootmem_data_t;extern bootmem_data_t bootmem_node_data[]; +#endif extern unsigned long bootmem_bootmap_pages (unsigned long );
@@ -46,6 +48,7 @@ extern unsigned long init_bootmem_node(p unsigned long endpfn);extern unsigned long init_bootmem (unsigned long addr,unsigned long memend); +unsigned long free_all_memory_core_early (int nodeid);extern unsigned long free_all_bootmem_node (pg_data_t *pgdat);extern unsigned long free_all_bootmem (void );
@@ -86,6 +89,10 @@ extern void *__alloc_bootmem_node(pg_datunsigned long size, unsigned long align, unsigned long goal); +void *__alloc_bootmem_node_high (pg_data_t *pgdat, +unsigned long size, +unsigned long align, +unsigned long goal); extern void *__alloc_bootmem_node_nopanic(pg_data_t *pgdat, unsigned long size, unsigned long align,
include/linux/mm.h +5 -0
@@ -12,6 +12,7 @@#include <linux/prio_tree.h> #include <linux/debug_locks.h> #include <linux/mm_types.h> +#include <linux/range.h> struct mempolicy ;struct anon_vma ;
@@ -1047,6 +1048,10 @@ extern void get_pfn_range_for_nid(unsignextern unsigned long find_min_pfn_with_active_regions (void );extern void free_bootmem_with_active_regions (int nid,unsigned long max_low_pfn); +int add_from_early_node_map (struct range *range,int az, +int nr_range,int nid); +void *__alloc_memory_core_early (int nodeid,u64 size,u64 align, +u64 goal,u64 limit);typedef int (*work_fn_t )(unsigned long ,unsigned long ,void *);extern void work_with_active_regions (int nid,work_fn_t work_fn,void *data);extern void sparse_memory_present_with_active_regions (int nid);
include/linux/mmzone.h +2 -0
@@ -620,7 +620,9 @@ typedef struct pglist_data {struct page_cgroup *node_page_cgroup;#endif #endif +#ifndef CONFIG_NO_BOOTMEM struct bootmem_data *bdata; +#endif #ifdef CONFIG_MEMORY_HOTPLUG /* * Must be held any time you expect node_start_pfn, node_present_pages
mm/bootmem.c +179 -3
358 lines not on this page · raw message
mm/page_alloc.c +52 -1
65 lines not on this page · raw message
mm/percpu.c +3 -0
@@ -1927,7 +1927,10 @@ int __init pcpu_embed_first_chunk(size_t }/* copy and return the unused part */ memcpy (ptr, __per_cpu_load, ai->static_size); +#ifndef CONFIG_NO_BOOTMEM +/* fix partial free ! */ free_fn (ptr + size_sum, ai->unit_size - size_sum); +#endif } }
mm/sparse-vmemmap.c +1 -1
@@ -40,7 +40,7 @@ static void * __init_refok __earlyonly_bunsigned long align, unsigned long goal) { - return __alloc_bootmem_node(NODE_DATA(node), size, align, goal); + return __alloc_bootmem_node_high(NODE_DATA(node), size, align, goal); }
Re: [PATCH 2/9] x86: check range in update range
In reply to Yinghai LuQuoted 5 lines · On Fri, 18 Dec 2009 01:46:59 -0800 Yinghai Lu <[email protected]> wrote:
fend off wrong range
Signed-off-by Yinghai Lu <[email protected]>
This could be merged with the previous patch.
Signature · 1 line
Jesse Barnes, Intel Open Source Technology Center
Re: [PATCH 2/9] x86: check range in update range
Quoted 9 lines · Jesse Barnes
Quoted 4 lines · On Fri, 18 Dec 2009 01:46:59 -0800 Yinghai Lu <[email protected]> wrote:
fend off wrong range
Signed-off-by Yinghai Lu <[email protected]>This could be merged with the previous patch.
yes, but first one just have moving and changing name etc.
YH
H. Peter Anvin
reviewerinclude/linux/range.h line 7
Quoted 5 lines · Yinghai Lu
include/linux/range.h new file +5
-0+ +struct range { +u64 start; +u64 end; +};
Okay, this does bring up two things that I have long griped about.
Firstly, I don't think this is the proper data structure. Even worse, the range operations take *inclusive* ranges (e.g. 0x0000 to 0xffff is 64K, not 0x0000 to 0x10000). It would be one thing if it only affected the internal representation, but as written, this is exposed through the interfaces, too.
As far as the choice of data structures, I have used in other places, with very good success, a data structure which looks like:
struct {
u64 start;
u32 attr;
};Note that there is no end: the end is always given by an end token. The "attr" here was an e820 attribute (or 0 for no attribute), but the payload can be almost anything -- for a simple include/exclude it can just be boolean.
This data structures doesn't permit things like out-of-order ranges, overlapping ranges, and so on, and that's a good thing; it means the data structure itself can never be ambiguous, and the interfaces clean out most errors inherently.
http://git.kernel.org/?p=boot/syslinux/syslinux.git;a=blob;f=com32/lib/syslinux/zonelist.c;hb=HEAD
... contains an implementation of this data structure using linked lists for internal storage, and
http://git.kernel.org/?p=boot/syslinux/syslinux.git;a=blob;f=memdisk/e820func.c;hb=HEAD
... contains one based on arrays. I'm not saying these should be applied directly, but I think the equivalent concept might be worthwhile, not just for this but also for the e820 memrange code.
-hpa
Quoted 28 lines · H. Peter Anvin
include/linux/range.h line 7
Quoted 5 lines · Yinghai Lu
include/linux/range.h new file +5
-0+ +struct range { +u64 start; +u64 end; +};Okay, this does bring up two things that I have long griped about.
Firstly, I don't think this is the proper data structure. Even worse, the range operations take *inclusive* ranges (e.g.
0x0000to0xffffis 64K, not0x0000to0x10000). It would be one thing if it only affected the internal representation, but as written, this is exposed through the interfaces, too.As far as the choice of data structures, I have used in other places, with very good success, a data structure which looks like:
struct { u64 start; u32 attr; };Note that there is no end: the end is always given by an end token. The "attr" here was an e820 attribute (or 0 for no attribute), but the payload can be almost anything -- for a simple
include/excludeit can just be boolean.
Quoted 4 lines
This data structures doesn't permit things like out-of-order ranges, overlapping ranges, and so on, and that's a good thing; it means the data structure itself can never be ambiguous, and the interfaces clean out most errors inherently.
yes here is we have [start, end] instead of [start, end)
those range operation is used for one purpose:
add several ranges, and subtract some other ranges, it will take out overlap between those two sets. and leave out the range that could be used.
and it is array based...for early stage.
YH
H. Peter Anvin
reviewerQuoted 9 lines · Yinghai Lu
yes here is we have [start, end] instead of [start, end)
those range operation is used for one purpose:
add several ranges, and subtract some other ranges, it will take out overlap between those two sets. and leave out the range that could be used.and it is array based...for early stage.
Yes. We should be able to use the *exact same code* for the e820 ranges, using the e820 attribute as the attribute parameters, and a simple boolean for the case where all you want is inclusion/exclusion. And yes, I agree array based is the right thing to do for the early code.
Note that my array-based version only had an insert operation, no delete operation -- that is because the delete operation is simply an insert operation of attribute 0.
-hpa
Quoted 7 lines · H. Peter Anvin
Quoted 6 lines · Yinghai Lu
yes here is we have [start, end] instead of [start, end)
those range operation is used for one purpose:
add several ranges, and subtract some other ranges, it will take out overlap between those two sets. and leave out the range that could be used.
Quoted 7 lines
Quoted 2 lines
and it is array based...for early stage.
Yes. We should be able to use the *exact same code* for the e820 ranges, using the e820 attribute as the attribute parameters, and a simple boolean for the case where all you want is inclusion/exclusion. And yes, I agree array based is the right thing to do for the early code.
i could try to merge range handling to to early_res handling code. first step is change the end in range to be consistent to the one in early_res.
later could move them into kernel/range.c or kernel/early_res.c after we convert all bootmem to early_res.
YH
H. Peter Anvin
reviewerQuoted 6 lines · Yinghai Lu
i could try to merge range handling to to
early_reshandling code. first step is change the end in range to be consistent to the one inearly_res.later could move them into
kernel/range.corkernel/early_res.cafter we convert all bootmem toearly_res.
Seems reasonable, I guess.
-hpa
Quoted 9 lines · H. Peter Anvin
Quoted 5 lines · Yinghai Lu
i could try to merge range handling to to
early_reshandling code. first step is change the end in range to be consistent to the one inearly_res.later could move them into
kernel/range.corkernel/early_res.cafter we convert all bootmem toearly_res.Seems reasonable, I guess.
can you put current 9 patches into tip? i will submit following patch that merge range and early_res
Thanks
Yinghai
H. Peter Anvin
reviewerQuoted 3 lines · Yinghai Lu
can you put current 9 patches into tip? i will submit following patch that merge range and
early_res
I still have to review them (I had to spend the day deal with non-kernel job duties that had been old hold for the merge window.) I will look at it probably Monday or Tuesday.
Sorry,
-hpa
PATCH 1/2 sparsemem: put usemap for one node together
In reply to Yinghai Lucould save some buf instead of applying one by one
could help that system that is going to use early_res instead of bootmem less entries in early_res make search more faster on system with more memory.
--- mm/sparse.c | 84 +++++++++++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 66 insertions(+), 18 deletions(-)
mm/sparse.c +66 -18
@@ -271,7 +271,8 @@ static unsigned long *__kmalloc_section_#ifdef CONFIG_MEMORY_HOTREMOVE static unsigned long *__init -sparse_early_usemap_alloc_pgdat_section (struct pglist_data *pgdat) +sparse_early_usemaps_alloc_pgdat_section (struct pglist_data *pgdat, +unsigned long count) {unsigned long section_nr;
@@ -286,7 +287,7 @@ sparse_early_usemap_alloc_pgdat_section(* this problem. */ section_nr =pfn_to_section_nr (__pa (pgdat) >>PAGE_SHIFT ); -return alloc_bootmem_section (usemap_size (), section_nr); +return alloc_bootmem_section (usemap_size () * count, section_nr); }static void __init check_usemap_section_nr (int nid,unsigned long *usemap)
@@ -329,7 +330,8 @@ static void __init check_usemap_section_ }#else static unsigned long *__init -sparse_early_usemap_alloc_pgdat_section (struct pglist_data *pgdat) +sparse_early_usemaps_alloc_pgdat_section (struct pglist_data *pgdat, +unsigned long count) {return NULL ; }
@@ -339,27 +341,40 @@ static void __init check_usemap_section_ }#endif /* CONFIG_MEMORY_HOTREMOVE */ -static unsigned long *__init sparse_early_usemap_alloc (unsigned long pnum) +static void __init sparse_early_usemaps_alloc_node (unsigned long **usemap_map, +unsigned long pnum_begin, +unsigned long pnum_end, +unsigned long usemap_count,int nodeid) { -unsigned long *usemap; -struct mem_section *ms =__nr_to_section (pnum); -int nid =sparse_early_nid (ms); - - usemap =sparse_early_usemap_alloc_pgdat_section (NODE_DATA (nid)); -if (usemap) -return usemap; +void *usemap; +unsigned long pnum; +int size =usemap_size (); - usemap =alloc_bootmem_node (NODE_DATA (nid),usemap_size ()); + usemap =sparse_early_usemaps_alloc_pgdat_section (NODE_DATA (nodeid), + usemap_count);if (usemap) { -check_usemap_section_nr (nid, usemap); -return usemap; +for (pnum = pnum_begin; pnum < pnum_end; pnum++) { +if (!present_section_nr (pnum)) +continue ; + usemap_map[pnum] = usemap; + usemap += size; + } +return ; } -/* Stupid: suppress gcc warning for SPARSEMEM && !NUMA */ - nid =0 ; + usemap =alloc_bootmem_node (NODE_DATA (nodeid), size * usemap_count); +if (usemap) { +for (pnum = pnum_begin; pnum < pnum_end; pnum++) { +if (!present_section_nr (pnum)) +continue ; + usemap_map[pnum] = usemap; + usemap += size; +check_usemap_section_nr (nodeid, usemap_map[pnum]); + } +return ; + }printk (KERN_WARNING "%s: allocation failed\n" , __func__); -return NULL ; }#ifndef CONFIG_SPARSEMEM_VMEMMAP
@@ -396,6 +411,7 @@ static struct page __init *sparse_early_void __attribute__((weak))__meminit vmemmap_populate_print_last (void ) { } +/* * Allocate the accumulated non-linear sections, allocate a mem_map * for each and record the physical to section mapping.
@@ -407,6 +423,9 @@ void __init sparse_init(void)unsigned long *usemap;unsigned long **usemap_map;int size; +int nodeid_begin =0 ; +unsigned long pnum_begin =0 ; +unsigned long usemap_count;/* * map is using big page (aka 2M in x86 64 bit)
@@ -425,10 +444,39 @@ void __init sparse_init(void)panic ("can not allocate usemap_map\n" );for (pnum =0 ; pnum <NR_MEM_SECTIONS ; pnum++) { +struct mem_section *ms; + +if (!present_section_nr (pnum)) +continue ; + ms =__nr_to_section (pnum); + nodeid_begin =sparse_early_nid (ms); + pnum_begin = pnum; +break ; + } + usemap_count =1 ; +for (pnum = pnum_begin +1 ; pnum <NR_MEM_SECTIONS ; pnum++) { +struct mem_section *ms; +int nodeid; +if (!present_section_nr (pnum))continue ; - usemap_map[pnum] =sparse_early_usemap_alloc (pnum); + ms =__nr_to_section (pnum); + nodeid =sparse_early_nid (ms); +if (nodeid == nodeid_begin) { + usemap_count++; +continue ; + } +/* ok, we need to take cake of from pnum_begin to pnum - 1*/ +sparse_early_usemaps_alloc_node (usemap_map, pnum_begin, pnum, + usemap_count, nodeid_begin); +/* new start, update count etc*/ + nodeid_begin = nodeid; + pnum_begin = pnum; + usemap_count =1 ; } +/* ok, last chunk */ +sparse_early_usemaps_alloc_node (usemap_map, pnum_begin,NR_MEM_SECTIONS , + usemap_count, nodeid_begin);for (pnum =0 ; pnum <NR_MEM_SECTIONS ; pnum++) {if (!present_section_nr (pnum))
PATCH 2/2 sparsemem: put mem map for one node together.
In reply to Yinghai Luadd vmemmap_alloc_block_buf for mem map only.
it will fallback old wayif can not get that big.
it will help system with more memory that use early_res instead of bootmem that can not handle too many entries
--- arch/x86/mm/init_64.c | 2 include/linux/mm.h | 7 +++ mm/sparse-vmemmap.c | 70 +++++++++++++++++++++++++++++++ mm/sparse.c | 111 +++++++++++++++++++++++++++++++++++++++++++++++++- 4 files changed, 187 insertions(+), 3 deletions(-)
arch/x86/mm/init_64.c +1 -1
@@ -961,7 +961,7 @@ vmemmap_populate(struct page *start_pageif (pmd_none (*pmd)) {pte_t entry; - p =vmemmap_alloc_block (PMD_SIZE , node); + p =vmemmap_alloc_block_buf (PMD_SIZE , node);if (!p)return -ENOMEM ;
include/linux/mm.h +7 -0
@@ -1323,12 +1323,19 @@ extern int randomize_va_space;const char *arch_vma_name (struct vm_area_struct *vma);void print_vma_addr (char *prefix,unsigned long rip); +void sparse_mem_maps_populate_node (struct page **map_map, +unsigned long pnum_begin, +unsigned long pnum_end, +unsigned long map_count, +int nodeid); +struct page *sparse_mem_map_populate (unsigned long pnum,int nid);pgd_t *vmemmap_pgd_populate (unsigned long addr,int node);pud_t *vmemmap_pud_populate (pgd_t *pgd,unsigned long addr,int node);pmd_t *vmemmap_pmd_populate (pud_t *pud,unsigned long addr,int node);pte_t *vmemmap_pte_populate (pmd_t *pmd,unsigned long addr,int node);void *vmemmap_alloc_block (unsigned long size,int node); +void *vmemmap_alloc_block_buf (unsigned long size,int node);void vmemmap_verify (pte_t *,int ,unsigned long ,unsigned long );int vmemmap_populate_basepages (struct page *start_page,unsigned long pages,int node);
mm/sparse-vmemmap.c +69 -1
91 lines not on this page · raw message
mm/sparse.c +110 -1
155 lines not on this page · raw message
Re: [PATCH 2/2] sparsemem: put mem map for one node together.
Quoted 19 lines · Yinghai Lu
add
vmemmap_alloc_block_buffor mem map only.it will fallback old wayif can not get that big.
it will help system with more memory that use
early_resinstead of bootmem that can not handle too many entriesSigned-off-by Yinghai Lu <[email protected]>--- arch/x86/mm/init_64.c | 2 include/linux/mm.h | 7 +++ mm/sparse-vmemmap.c | 70 +++++++++++++++++++++++++++++++ mm/sparse.c | 111 +++++++++++++++++++++++++++++++++++++++++++++++++- 4 files changed, 187 insertions(+), 3 deletions(-)+++
linux-2.6/mm/sparse-vmemmap.c
mm/sparse-vmemmap.c static void * __init_refok __earlyonly_b · line 47
Quoted 5 lines
mm/sparse-vmemmap.c +2
-0@@ -43,6 +43,8 @@ static void * __init_refok __earlyonly_breturn __alloc_bootmem_node_high (NODE_DATA (node), size, align, goal); } +static void *buf; +static void *buf_end;
there's so many buf's in the kernel - this naming isnt very intuitive. Also, they should perhaps be __initdata-ish?
Quoted 6 lines
mm/sparse-vmemmap.c +0
-0void *__meminit vmemmap_alloc_block (unsigned long size,int node) {@@ -64,6 +66,24 @@ void * __meminit vmemmap_alloc_block(uns __pa(MAX_DMA_ADDRESS)); }
mm/sparse-vmemmap.c void * __meminit vmemmap_alloc_block(uns · line 78
Quoted 10 lines
mm/sparse-vmemmap.c +10
-0+/* need to make sure size is all the same during early stage */ +void *__meminit vmemmap_alloc_block_buf (unsigned long size,int node) +{ +void *ptr; + +if (!buf) +return vmemmap_alloc_block (size, node); + +/* take the from buf */ + ptr = (void *)ALIGN ((unsigned long )buf, size);
Hm, two type cast in the same line.
these kinds of x86-64-isms:
Review void * __meminit vmemmap_alloc_block(uns · line 87
Quoted 9 lines
(quoted diff) +8
-0+++ linux-2.6/mm/sparse.c +#ifndef CONFIG_X86_64 +#ifdef CONFIG_X86_64 +#ifdef CONFIG_X86_64 +#else +#endif +#ifdef CONFIG_X86_64 +#endif
are not particularly welcome constructs in core MM files. Appropriately structured Kconfig helper bools, selected by arch's, are cleaner.
These patches need more work.
Ingo