x86: break up mtrr_cleanup() into several small functions.

Ingo said mtrr_cleanup() is big and ugly. so break it up into more functions and make it more readable. Signed-off-by: Yinghai Lu <yinghai@kernel.org> Signed-off-by: Ingo Molnar <mingo@elte.hu>
author: Yinghai Lu <yinghai@kernel.org> 2008-10-14 21:59:18 -0400
committer: Ingo Molnar <mingo@elte.hu> 2008-10-28 11:30:57 -0400
commit: 30604bb410b53efa9c93ee8f03d7aa7494094faa (patch)
tree: 8345cd64ca91b655e0e81bcc546bac2dfc83bc74 /arch/x86/kernel
parent: 49fdf6785fd660e18a1eb4588928f47e9fa29a9a (diff)
1 files changed, 171 insertions, 175 deletions
diff --git a/arch/x86/kernel/cpu/mtrr/main.c b/arch/x86/kernel/cpu/mtrr/main.c
index c78c04821ea1..1159e269e596 100644
--- a/arch/x86/kernel/cpu/mtrr/main.c
+++ b/arch/x86/kernel/cpu/mtrr/main.c
@@ -803,6 +803,7 @@ x86_get_mtrr_mem_range(struct res_range *range, int nr_range,
 }
 static struct res_range __initdata range[RANGE_NUM];
+static int __initdata nr_range;
 #ifdef CONFIG_MTRR_SANITIZER
@@ -1206,39 +1207,43 @@ struct mtrr_cleanup_result {
 #define PSHIFT          (PAGE_SHIFT - 10)
 static struct mtrr_cleanup_result __initdata result[NUM_RESULT];
-static struct res_range __initdata range_new[RANGE_NUM];
 static unsigned long __initdata min_loss_pfn[RANGE_NUM];
-static int __init mtrr_cleanup(unsigned address_bits)
+static void __init print_out_mtrr_range_state(void)
 {
-        unsigned long extra_remove_base, extra_remove_size;
-        unsigned long base, size, def, dummy;
-        mtrr_type type;
-        int nr_range, nr_range_new;
-        u64 chunk_size, gran_size;
-        unsigned long range_sums, range_sums_new;
-        int index_good;
-        int num_reg_good;
        int i;
+        char start_factor = 'K', size_factor = 'K';
+        unsigned long start_base, size_base;
+        mtrr_type type;
-        /* extra one for all 0 */
+        for (i = 0; i < num_var_ranges; i++) {
-        int num[MTRR_NUM_TYPES + 1];
-        if (!is_cpu(INTEL) || enable_mtrr_cleanup < 1)
+                size_base = range_state[i].size_pfn << (PAGE_SHIFT - 10);
-                return 0;
+                if (!size_base)
-        rdmsr(MTRRdefType_MSR, def, dummy);
+                        continue;
-        def &= 0xff;
-        if (def != MTRR_TYPE_UNCACHABLE)
-                return 0;
-        /* get it and store it aside */
+                size_base = to_size_factor(size_base, &size_factor),
-        memset(range_state, 0, sizeof(range_state));
+                start_base = range_state[i].base_pfn << (PAGE_SHIFT - 10);
-        for (i = 0; i < num_var_ranges; i++) {
+                start_base = to_size_factor(start_base, &start_factor),
-                mtrr_if->get(i, &base, &size, &type);
+                type = range_state[i].type;
-                range_state[i].base_pfn = base;
-                range_state[i].size_pfn = size;
+                printk(KERN_DEBUG "reg %d, base: %ld%cB, range: %ld%cB, type %s\n",
-                range_state[i].type = type;
+                        i, start_base, start_factor,
+                        size_base, size_factor,
+                        (type == MTRR_TYPE_UNCACHABLE) ? "UC" :
+                            ((type == MTRR_TYPE_WRPROT) ? "WP" :
+                             ((type == MTRR_TYPE_WRBACK) ? "WB" : "Other"))
+                        );
        }
+}
+static int __init mtrr_need_cleanup(void)
+{
+        int i;
+        mtrr_type type;
+        unsigned long size;
+        /* extra one for all 0 */
+        int num[MTRR_NUM_TYPES + 1];
        /* check entries number */
        memset(num, 0, sizeof(num));
@@ -1263,29 +1268,133 @@ static int __init mtrr_cleanup(unsigned address_bits)
                num_var_ranges - num[MTRR_NUM_TYPES])
                return 0;
-        /* print original var MTRRs at first, for debugging: */
+        return 1;
-        printk(KERN_DEBUG "original variable MTRRs\n");
+}
-        for (i = 0; i < num_var_ranges; i++) {
-                char start_factor = 'K', size_factor = 'K';
-                unsigned long start_base, size_base;
-                size_base = range_state[i].size_pfn << (PAGE_SHIFT - 10);
+static unsigned long __initdata range_sums;
-                if (!size_base)
+static void __init mtrr_calc_range_state(u64 chunk_size, u64 gran_size,
-                        continue;
+                                         unsigned long extra_remove_base,
+                                         unsigned long extra_remove_size,
+                                         int i)
+{
+        int num_reg;
+        static struct res_range range_new[RANGE_NUM];
+        static int nr_range_new;
+        unsigned long range_sums_new;
+        /* convert ranges to var ranges state */
+        num_reg = x86_setup_var_mtrrs(range, nr_range,
+                                                chunk_size, gran_size);
+        /* we got new setting in range_state, check it */
+        memset(range_new, 0, sizeof(range_new));
+        nr_range_new = x86_get_mtrr_mem_range(range_new, 0,
+                                extra_remove_base, extra_remove_size);
+        range_sums_new = sum_ranges(range_new, nr_range_new);
+        result[i].chunk_sizek = chunk_size >> 10;
+        result[i].gran_sizek = gran_size >> 10;
+        result[i].num_reg = num_reg;
+        if (range_sums < range_sums_new) {
+                result[i].lose_cover_sizek =
+                        (range_sums_new - range_sums) << PSHIFT;
+                result[i].bad = 1;
+        } else
+                result[i].lose_cover_sizek =
+                        (range_sums - range_sums_new) << PSHIFT;
-                size_base = to_size_factor(size_base, &size_factor),
+        /* double check it */
-                start_base = range_state[i].base_pfn << (PAGE_SHIFT - 10);
+        if (!result[i].bad && !result[i].lose_cover_sizek) {
-                start_base = to_size_factor(start_base, &start_factor),
+                if (nr_range_new != nr_range ||
-                type = range_state[i].type;
+                        memcmp(range, range_new, sizeof(range)))
+                                result[i].bad = 1;
+        }
-                printk(KERN_DEBUG "reg %d, base: %ld%cB, range: %ld%cB, type %s\n",
+        if (!result[i].bad && (range_sums - range_sums_new <
-                        i, start_base, start_factor,
+                                min_loss_pfn[num_reg])) {
-                        size_base, size_factor,
+                min_loss_pfn[num_reg] =
-                        (type == MTRR_TYPE_UNCACHABLE) ? "UC" :
+                        range_sums - range_sums_new;
-                            ((type == MTRR_TYPE_WRPROT) ? "WP" :
-                             ((type == MTRR_TYPE_WRBACK) ? "WB" : "Other"))
-                        );
        }
+}
+static void __init mtrr_print_out_one_result(int i)
+{
+        char gran_factor, chunk_factor, lose_factor;
+        unsigned long gran_base, chunk_base, lose_base;
+        gran_base = to_size_factor(result[i].gran_sizek, &gran_factor),
+        chunk_base = to_size_factor(result[i].chunk_sizek, &chunk_factor),
+        lose_base = to_size_factor(result[i].lose_cover_sizek, &lose_factor),
+        printk(KERN_INFO "%sgran_size: %ld%c \tchunk_size: %ld%c \t",
+                        result[i].bad ? "*BAD*" : " ",
+                        gran_base, gran_factor, chunk_base, chunk_factor);
+        printk(KERN_CONT "num_reg: %d  \tlose cover RAM: %s%ld%c\n",
+                        result[i].num_reg, result[i].bad ? "-" : "",
+                        lose_base, lose_factor);
+}
+static int __init mtrr_search_optimal_index(void)
+{
+        int i;
+        int num_reg_good;
+        int index_good;
+        if (nr_mtrr_spare_reg >= num_var_ranges)
+                nr_mtrr_spare_reg = num_var_ranges - 1;
+        num_reg_good = -1;
+        for (i = num_var_ranges - nr_mtrr_spare_reg; i > 0; i--) {
+                if (!min_loss_pfn[i])
+                        num_reg_good = i;
+        }
+        index_good = -1;
+        if (num_reg_good != -1) {
+                for (i = 0; i < NUM_RESULT; i++) {
+                        if (!result[i].bad &&
+                            result[i].num_reg == num_reg_good &&
+                            !result[i].lose_cover_sizek) {
+                                index_good = i;
+                                break;
+                        }
+                }
+        }
+        return index_good;
+}
+static int __init mtrr_cleanup(unsigned address_bits)
+{
+        unsigned long extra_remove_base, extra_remove_size;
+        unsigned long base, size, def, dummy;
+        mtrr_type type;
+        u64 chunk_size, gran_size;
+        int index_good;
+        int i;
+        if (!is_cpu(INTEL) || enable_mtrr_cleanup < 1)
+                return 0;
+        rdmsr(MTRRdefType_MSR, def, dummy);
+        def &= 0xff;
+        if (def != MTRR_TYPE_UNCACHABLE)
+                return 0;
+        /* get it and store it aside */
+        memset(range_state, 0, sizeof(range_state));
+        for (i = 0; i < num_var_ranges; i++) {
+                mtrr_if->get(i, &base, &size, &type);
+                range_state[i].base_pfn = base;
+                range_state[i].size_pfn = size;
+                range_state[i].type = type;
+        }
+        /* check if we need handle it and can handle it */
+        if (!mtrr_need_cleanup())
+                return 0;
+        /* print original var MTRRs at first, for debugging: */
+        printk(KERN_DEBUG "original variable MTRRs\n");
+        print_out_mtrr_range_state();
        memset(range, 0, sizeof(range));
        extra_remove_size = 0;
@@ -1309,176 +1418,64 @@ static int __init mtrr_cleanup(unsigned address_bits)
               range_sums >> (20 - PAGE_SHIFT));
        if (mtrr_chunk_size && mtrr_gran_size) {
-                int num_reg;
+                i = 0;
-                char gran_factor, chunk_factor, lose_factor;
+                mtrr_calc_range_state(mtrr_chunk_size, mtrr_gran_size,
-                unsigned long gran_base, chunk_base, lose_base;
+                                      extra_remove_base, extra_remove_size, i);
-                debug_print++;
-                /* convert ranges to var ranges state */
-                num_reg = x86_setup_var_mtrrs(range, nr_range, mtrr_chunk_size,
-                                              mtrr_gran_size);
-                /* we got new setting in range_state, check it */
+                mtrr_print_out_one_result(i);
-                memset(range_new, 0, sizeof(range_new));
-                nr_range_new = x86_get_mtrr_mem_range(range_new, 0,
-                                                      extra_remove_base,
-                                                      extra_remove_size);
-                range_sums_new = sum_ranges(range_new, nr_range_new);
-                i = 0;
-                result[i].chunk_sizek = mtrr_chunk_size >> 10;
-                result[i].gran_sizek = mtrr_gran_size >> 10;
-                result[i].num_reg = num_reg;
-                if (range_sums < range_sums_new) {
-                        result[i].lose_cover_sizek =
-                                (range_sums_new - range_sums) << PSHIFT;
-                        result[i].bad = 1;
-                } else
-                        result[i].lose_cover_sizek =
-                                (range_sums - range_sums_new) << PSHIFT;
-                gran_base = to_size_factor(result[i].gran_sizek, &gran_factor),
-                chunk_base = to_size_factor(result[i].chunk_sizek, &chunk_factor),
-                lose_base = to_size_factor(result[i].lose_cover_sizek, &lose_factor),
-                printk(KERN_INFO "%sgran_size: %ld%c \tchunk_size: %ld%c \t",
-                         result[i].bad?"*BAD*":" ",
-                         gran_base, gran_factor, chunk_base, chunk_factor);
-                printk(KERN_CONT "num_reg: %d  \tlose cover RAM: %s%ld%c\n",
-                         result[i].num_reg, result[i].bad?"-":"",
-                         lose_base, lose_factor);
                if (!result[i].bad) {
                        set_var_mtrr_all(address_bits);
                        return 1;
                }
                printk(KERN_INFO "invalid mtrr_gran_size or mtrr_chunk_size, "
                       "will find optimal one\n");
-                debug_print--;
-                memset(result, 0, sizeof(result[0]));
        }
        i = 0;
        memset(min_loss_pfn, 0xff, sizeof(min_loss_pfn));
        memset(result, 0, sizeof(result));
        for (gran_size = (1ULL<<16); gran_size < (1ULL<<32); gran_size <<= 1) {
-                char gran_factor;
-                unsigned long gran_base;
-                if (debug_print)
-                        gran_base = to_size_factor(gran_size >> 10, &gran_factor);
                for (chunk_size = gran_size; chunk_size < (1ULL<<32);
                     chunk_size <<= 1) {
-                        int num_reg;
-                        if (debug_print) {
-                                char chunk_factor;
-                                unsigned long chunk_base;
-                                chunk_base = to_size_factor(chunk_size>>10, &chunk_factor),
-                                printk(KERN_INFO "\n");
-                                printk(KERN_INFO "gran_size: %ld%c   chunk_size: %ld%c \n",
-                                       gran_base, gran_factor, chunk_base, chunk_factor);
-                        }
                        if (i >= NUM_RESULT)
                                continue;
-                        /* convert ranges to var ranges state */
+                        mtrr_calc_range_state(chunk_size, gran_size,
-                        num_reg = x86_setup_var_mtrrs(range, nr_range,
+                                      extra_remove_base, extra_remove_size, i);
-                                                         chunk_size, gran_size);
+                        if (debug_print) {
+                                mtrr_print_out_one_result(i);
-                        /* we got new setting in range_state, check it */
+                                printk(KERN_INFO "\n");
-                        memset(range_new, 0, sizeof(range_new));
-                        nr_range_new = x86_get_mtrr_mem_range(range_new, 0,
-                                         extra_remove_base, extra_remove_size);
-                        range_sums_new = sum_ranges(range_new, nr_range_new);
-                        result[i].chunk_sizek = chunk_size >> 10;
-                        result[i].gran_sizek = gran_size >> 10;
-                        result[i].num_reg = num_reg;
-                        if (range_sums < range_sums_new) {
-                                result[i].lose_cover_sizek =
-                                        (range_sums_new - range_sums) << PSHIFT;
-                                result[i].bad = 1;
-                        } else
-                                result[i].lose_cover_sizek =
-                                        (range_sums - range_sums_new) << PSHIFT;
-                        /* double check it */
-                        if (!result[i].bad && !result[i].lose_cover_sizek) {
-                                if (nr_range_new != nr_range ||
-                                        memcmp(range, range_new, sizeof(range)))
-                                                result[i].bad = 1;
                        }
-                        if (!result[i].bad && (range_sums - range_sums_new <
-                                               min_loss_pfn[num_reg])) {
-                                min_loss_pfn[num_reg] =
-                                        range_sums - range_sums_new;
-                        }
                        i++;
                }
        }
-        /* print out all */
-        for (i = 0; i < NUM_RESULT; i++) {
-                char gran_factor, chunk_factor, lose_factor;
-                unsigned long gran_base, chunk_base, lose_base;
-                gran_base = to_size_factor(result[i].gran_sizek, &gran_factor),
-                chunk_base = to_size_factor(result[i].chunk_sizek, &chunk_factor),
-                lose_base = to_size_factor(result[i].lose_cover_sizek, &lose_factor),
-                printk(KERN_INFO "%sgran_size: %ld%c \tchunk_size: %ld%c \t",
-                         result[i].bad?"*BAD*":" ",
-                         gran_base, gran_factor, chunk_base, chunk_factor);
-                printk(KERN_CONT "num_reg: %d  \tlose cover RAM: %s%ld%c\n",
-                         result[i].num_reg, result[i].bad?"-":"",
-                         lose_base, lose_factor);
-        }
        /* try to find the optimal index */
-        if (nr_mtrr_spare_reg >= num_var_ranges)
+        index_good = mtrr_search_optimal_index();
-                nr_mtrr_spare_reg = num_var_ranges - 1;
-        num_reg_good = -1;
-        for (i = num_var_ranges - nr_mtrr_spare_reg; i > 0; i--) {
-                if (!min_loss_pfn[i])
-                        num_reg_good = i;
-        }
-        index_good = -1;
-        if (num_reg_good != -1) {
-                for (i = 0; i < NUM_RESULT; i++) {
-                        if (!result[i].bad &&
-                            result[i].num_reg == num_reg_good &&
-                            !result[i].lose_cover_sizek) {
-                                index_good = i;
-                                break;
-                        }
-                }
-        }
        if (index_good != -1) {
-                char gran_factor, chunk_factor, lose_factor;
-                unsigned long gran_base, chunk_base, lose_base;
                printk(KERN_INFO "Found optimal setting for mtrr clean up\n");
                i = index_good;
-                gran_base = to_size_factor(result[i].gran_sizek, &gran_factor),
+                mtrr_print_out_one_result(i);
-                chunk_base = to_size_factor(result[i].chunk_sizek, &chunk_factor),
-                lose_base = to_size_factor(result[i].lose_cover_sizek, &lose_factor),
-                printk(KERN_INFO "gran_size: %ld%c \tchunk_size: %ld%c \t",
-                         gran_base, gran_factor, chunk_base, chunk_factor);
-                printk(KERN_CONT "num_reg: %d  \tlose RAM: %ld%c\n",
-                         result[i].num_reg, lose_base, lose_factor);
                /* convert ranges to var ranges state */
                chunk_size = result[i].chunk_sizek;
                chunk_size <<= 10;
                gran_size = result[i].gran_sizek;
                gran_size <<= 10;
-                debug_print++;
                x86_setup_var_mtrrs(range, nr_range, chunk_size, gran_size);
-                debug_print--;
                set_var_mtrr_all(address_bits);
+                printk(KERN_DEBUG "New variable MTRRs\n");
+                print_out_mtrr_range_state();
                return 1;
+        } else {
+                /* print out all */
+                for (i = 0; i < NUM_RESULT; i++)
+                        mtrr_print_out_one_result(i);
        }
        printk(KERN_INFO "mtrr_cleanup: can not find optimal value\n");
@@ -1562,7 +1559,6 @@ int __init mtrr_trim_uncached_memory(unsigned long end_pfn)
 {
        unsigned long i, base, size, highest_pfn = 0, def, dummy;
        mtrr_type type;
-        int nr_range;
        u64 total_trim_size;
        /* extra one for all 0 */
author	Yinghai Lu <yinghai@kernel.org>	2008-10-14 21:59:18 -0400
committer	Ingo Molnar <mingo@elte.hu>	2008-10-28 11:30:57 -0400
commit	30604bb410b53efa9c93ee8f03d7aa7494094faa (patch)
tree	8345cd64ca91b655e0e81bcc546bac2dfc83bc74 /arch/x86/kernel
parent	49fdf6785fd660e18a1eb4588928f47e9fa29a9a (diff)

diff --git a/arch/x86/kernel/cpu/mtrr/main.c b/arch/x86/kernel/cpu/mtrr/main.c index c78c04821ea1..1159e269e596 100644 --- a/arch/x86/kernel/cpu/mtrr/main.c +++ b/arch/x86/kernel/cpu/mtrr/main.c
@@ -803,6 +803,7 @@ x86_get_mtrr_mem_range(struct res_range *range, int nr_range,
803	}	803	}
804		804
805	static struct res_range __initdata range[RANGE_NUM];	805	static struct res_range __initdata range[RANGE_NUM];
		806	static int __initdata nr_range;
806		807
807	#ifdef CONFIG_MTRR_SANITIZER	808	#ifdef CONFIG_MTRR_SANITIZER
808		809
@@ -1206,39 +1207,43 @@ struct mtrr_cleanup_result {
1206	#define PSHIFT (PAGE_SHIFT - 10)	1207	#define PSHIFT (PAGE_SHIFT - 10)
1207		1208
1208	static struct mtrr_cleanup_result __initdata result[NUM_RESULT];	1209	static struct mtrr_cleanup_result __initdata result[NUM_RESULT];
1209	static struct res_range __initdata range_new[RANGE_NUM];
1210	static unsigned long __initdata min_loss_pfn[RANGE_NUM];	1210	static unsigned long __initdata min_loss_pfn[RANGE_NUM];
1211		1211
1212	static int __init mtrr_cleanup(unsigned address_bits)	1212	static void __init print_out_mtrr_range_state(void)
1213	{	1213	{
1214	unsigned long extra_remove_base, extra_remove_size;
1215	unsigned long base, size, def, dummy;
1216	mtrr_type type;
1217	int nr_range, nr_range_new;
1218	u64 chunk_size, gran_size;
1219	unsigned long range_sums, range_sums_new;
1220	int index_good;
1221	int num_reg_good;
1222	int i;	1214	int i;
		1215	char start_factor = 'K', size_factor = 'K';
		1216	unsigned long start_base, size_base;
		1217	mtrr_type type;
1223		1218
1224	/* extra one for all 0 */	1219	for (i = 0; i < num_var_ranges; i++) {
1225	int num[MTRR_NUM_TYPES + 1];
1226		1220
1227	if (!is_cpu(INTEL) \|\| enable_mtrr_cleanup < 1)	1221	size_base = range_state[i].size_pfn << (PAGE_SHIFT - 10);
1228	return 0;	1222	if (!size_base)
1229	rdmsr(MTRRdefType_MSR, def, dummy);	1223	continue;
1230	def &= 0xff;
1231	if (def != MTRR_TYPE_UNCACHABLE)
1232	return 0;
1233		1224
1234	/* get it and store it aside */	1225	size_base = to_size_factor(size_base, &size_factor),
1235	memset(range_state, 0, sizeof(range_state));	1226	start_base = range_state[i].base_pfn << (PAGE_SHIFT - 10);
1236	for (i = 0; i < num_var_ranges; i++) {	1227	start_base = to_size_factor(start_base, &start_factor),
1237	mtrr_if->get(i, &base, &size, &type);	1228	type = range_state[i].type;
1238	range_state[i].base_pfn = base;	1229
1239	range_state[i].size_pfn = size;	1230	printk(KERN_DEBUG "reg %d, base: %ld%cB, range: %ld%cB, type %s\n",
1240	range_state[i].type = type;	1231	i, start_base, start_factor,
		1232	size_base, size_factor,
		1233	(type == MTRR_TYPE_UNCACHABLE) ? "UC" :
		1234	((type == MTRR_TYPE_WRPROT) ? "WP" :
		1235	((type == MTRR_TYPE_WRBACK) ? "WB" : "Other"))
		1236	);
1241	}	1237	}
		1238	}
		1239
		1240	static int __init mtrr_need_cleanup(void)
		1241	{
		1242	int i;
		1243	mtrr_type type;
		1244	unsigned long size;
		1245	/* extra one for all 0 */
		1246	int num[MTRR_NUM_TYPES + 1];
1242		1247
1243	/* check entries number */	1248	/* check entries number */
1244	memset(num, 0, sizeof(num));	1249	memset(num, 0, sizeof(num));
@@ -1263,29 +1268,133 @@ static int __init mtrr_cleanup(unsigned address_bits)
1263	num_var_ranges - num[MTRR_NUM_TYPES])	1268	num_var_ranges - num[MTRR_NUM_TYPES])
1264	return 0;	1269	return 0;
1265		1270
1266	/* print original var MTRRs at first, for debugging: */	1271	return 1;
1267	printk(KERN_DEBUG "original variable MTRRs\n");	1272	}
1268	for (i = 0; i < num_var_ranges; i++) {
1269	char start_factor = 'K', size_factor = 'K';
1270	unsigned long start_base, size_base;
1271		1273
1272	size_base = range_state[i].size_pfn << (PAGE_SHIFT - 10);	1274	static unsigned long __initdata range_sums;
1273	if (!size_base)	1275	static void __init mtrr_calc_range_state(u64 chunk_size, u64 gran_size,
1274	continue;	1276	unsigned long extra_remove_base,
		1277	unsigned long extra_remove_size,
		1278	int i)
		1279	{
		1280	int num_reg;
		1281	static struct res_range range_new[RANGE_NUM];
		1282	static int nr_range_new;
		1283	unsigned long range_sums_new;
		1284
		1285	/* convert ranges to var ranges state */
		1286	num_reg = x86_setup_var_mtrrs(range, nr_range,
		1287	chunk_size, gran_size);
		1288
		1289	/* we got new setting in range_state, check it */
		1290	memset(range_new, 0, sizeof(range_new));
		1291	nr_range_new = x86_get_mtrr_mem_range(range_new, 0,
		1292	extra_remove_base, extra_remove_size);
		1293	range_sums_new = sum_ranges(range_new, nr_range_new);
		1294
		1295	result[i].chunk_sizek = chunk_size >> 10;
		1296	result[i].gran_sizek = gran_size >> 10;
		1297	result[i].num_reg = num_reg;
		1298	if (range_sums < range_sums_new) {
		1299	result[i].lose_cover_sizek =
		1300	(range_sums_new - range_sums) << PSHIFT;
		1301	result[i].bad = 1;
		1302	} else
		1303	result[i].lose_cover_sizek =
		1304	(range_sums - range_sums_new) << PSHIFT;
1275		1305
1276	size_base = to_size_factor(size_base, &size_factor),	1306	/* double check it */
1277	start_base = range_state[i].base_pfn << (PAGE_SHIFT - 10);	1307	if (!result[i].bad && !result[i].lose_cover_sizek) {
1278	start_base = to_size_factor(start_base, &start_factor),	1308	if (nr_range_new != nr_range \|\|
1279	type = range_state[i].type;	1309	memcmp(range, range_new, sizeof(range)))
		1310	result[i].bad = 1;
		1311	}
1280		1312
1281	printk(KERN_DEBUG "reg %d, base: %ld%cB, range: %ld%cB, type %s\n",	1313	if (!result[i].bad && (range_sums - range_sums_new <
1282	i, start_base, start_factor,	1314	min_loss_pfn[num_reg])) {
1283	size_base, size_factor,	1315	min_loss_pfn[num_reg] =
1284	(type == MTRR_TYPE_UNCACHABLE) ? "UC" :	1316	range_sums - range_sums_new;
1285	((type == MTRR_TYPE_WRPROT) ? "WP" :
1286	((type == MTRR_TYPE_WRBACK) ? "WB" : "Other"))
1287	);
1288	}	1317	}
		1318	}
		1319
		1320	static void __init mtrr_print_out_one_result(int i)
		1321	{
		1322	char gran_factor, chunk_factor, lose_factor;
		1323	unsigned long gran_base, chunk_base, lose_base;
		1324
		1325	gran_base = to_size_factor(result[i].gran_sizek, &gran_factor),
		1326	chunk_base = to_size_factor(result[i].chunk_sizek, &chunk_factor),
		1327	lose_base = to_size_factor(result[i].lose_cover_sizek, &lose_factor),
		1328	printk(KERN_INFO "%sgran_size: %ld%c \tchunk_size: %ld%c \t",
		1329	result[i].bad ? "BAD" : " ",
		1330	gran_base, gran_factor, chunk_base, chunk_factor);
		1331	printk(KERN_CONT "num_reg: %d \tlose cover RAM: %s%ld%c\n",
		1332	result[i].num_reg, result[i].bad ? "-" : "",
		1333	lose_base, lose_factor);
		1334	}
		1335
		1336	static int __init mtrr_search_optimal_index(void)
		1337	{
		1338	int i;
		1339	int num_reg_good;
		1340	int index_good;
		1341
		1342	if (nr_mtrr_spare_reg >= num_var_ranges)
		1343	nr_mtrr_spare_reg = num_var_ranges - 1;
		1344	num_reg_good = -1;
		1345	for (i = num_var_ranges - nr_mtrr_spare_reg; i > 0; i--) {
		1346	if (!min_loss_pfn[i])
		1347	num_reg_good = i;
		1348	}
		1349
		1350	index_good = -1;
		1351	if (num_reg_good != -1) {
		1352	for (i = 0; i < NUM_RESULT; i++) {
		1353	if (!result[i].bad &&
		1354	result[i].num_reg == num_reg_good &&
		1355	!result[i].lose_cover_sizek) {
		1356	index_good = i;
		1357	break;
		1358	}
		1359	}
		1360	}
		1361
		1362	return index_good;
		1363	}
		1364
		1365
		1366	static int __init mtrr_cleanup(unsigned address_bits)
		1367	{
		1368	unsigned long extra_remove_base, extra_remove_size;
		1369	unsigned long base, size, def, dummy;
		1370	mtrr_type type;
		1371	u64 chunk_size, gran_size;
		1372	int index_good;
		1373	int i;
		1374
		1375	if (!is_cpu(INTEL) \|\| enable_mtrr_cleanup < 1)
		1376	return 0;
		1377	rdmsr(MTRRdefType_MSR, def, dummy);
		1378	def &= 0xff;
		1379	if (def != MTRR_TYPE_UNCACHABLE)
		1380	return 0;
		1381
		1382	/* get it and store it aside */
		1383	memset(range_state, 0, sizeof(range_state));
		1384	for (i = 0; i < num_var_ranges; i++) {
		1385	mtrr_if->get(i, &base, &size, &type);
		1386	range_state[i].base_pfn = base;
		1387	range_state[i].size_pfn = size;
		1388	range_state[i].type = type;
		1389	}
		1390
		1391	/* check if we need handle it and can handle it */
		1392	if (!mtrr_need_cleanup())
		1393	return 0;
		1394
		1395	/* print original var MTRRs at first, for debugging: */
		1396	printk(KERN_DEBUG "original variable MTRRs\n");
		1397	print_out_mtrr_range_state();
1289		1398
1290	memset(range, 0, sizeof(range));	1399	memset(range, 0, sizeof(range));
1291	extra_remove_size = 0;	1400	extra_remove_size = 0;
@@ -1309,176 +1418,64 @@ static int __init mtrr_cleanup(unsigned address_bits)
1309	range_sums >> (20 - PAGE_SHIFT));	1418	range_sums >> (20 - PAGE_SHIFT));
1310		1419
1311	if (mtrr_chunk_size && mtrr_gran_size) {	1420	if (mtrr_chunk_size && mtrr_gran_size) {
1312	int num_reg;	1421	i = 0;
1313	char gran_factor, chunk_factor, lose_factor;	1422	mtrr_calc_range_state(mtrr_chunk_size, mtrr_gran_size,
1314	unsigned long gran_base, chunk_base, lose_base;	1423	extra_remove_base, extra_remove_size, i);
1315
1316	debug_print++;
1317	/* convert ranges to var ranges state */
1318	num_reg = x86_setup_var_mtrrs(range, nr_range, mtrr_chunk_size,
1319	mtrr_gran_size);
1320		1424
1321	/* we got new setting in range_state, check it */	1425	mtrr_print_out_one_result(i);
1322	memset(range_new, 0, sizeof(range_new));
1323	nr_range_new = x86_get_mtrr_mem_range(range_new, 0,
1324	extra_remove_base,
1325	extra_remove_size);
1326	range_sums_new = sum_ranges(range_new, nr_range_new);
1327		1426
1328	i = 0;
1329	result[i].chunk_sizek = mtrr_chunk_size >> 10;
1330	result[i].gran_sizek = mtrr_gran_size >> 10;
1331	result[i].num_reg = num_reg;
1332	if (range_sums < range_sums_new) {
1333	result[i].lose_cover_sizek =
1334	(range_sums_new - range_sums) << PSHIFT;
1335	result[i].bad = 1;
1336	} else
1337	result[i].lose_cover_sizek =
1338	(range_sums - range_sums_new) << PSHIFT;
1339
1340	gran_base = to_size_factor(result[i].gran_sizek, &gran_factor),
1341	chunk_base = to_size_factor(result[i].chunk_sizek, &chunk_factor),
1342	lose_base = to_size_factor(result[i].lose_cover_sizek, &lose_factor),
1343	printk(KERN_INFO "%sgran_size: %ld%c \tchunk_size: %ld%c \t",
1344	result[i].bad?"BAD":" ",
1345	gran_base, gran_factor, chunk_base, chunk_factor);
1346	printk(KERN_CONT "num_reg: %d \tlose cover RAM: %s%ld%c\n",
1347	result[i].num_reg, result[i].bad?"-":"",
1348	lose_base, lose_factor);
1349	if (!result[i].bad) {	1427	if (!result[i].bad) {
1350	set_var_mtrr_all(address_bits);	1428	set_var_mtrr_all(address_bits);
1351	return 1;	1429	return 1;
1352	}	1430	}
1353	printk(KERN_INFO "invalid mtrr_gran_size or mtrr_chunk_size, "	1431	printk(KERN_INFO "invalid mtrr_gran_size or mtrr_chunk_size, "
1354	"will find optimal one\n");	1432	"will find optimal one\n");
1355	debug_print--;
1356	memset(result, 0, sizeof(result[0]));
1357	}	1433	}
1358		1434
1359	i = 0;	1435	i = 0;
1360	memset(min_loss_pfn, 0xff, sizeof(min_loss_pfn));	1436	memset(min_loss_pfn, 0xff, sizeof(min_loss_pfn));
1361	memset(result, 0, sizeof(result));	1437	memset(result, 0, sizeof(result));
1362	for (gran_size = (1ULL<<16); gran_size < (1ULL<<32); gran_size <<= 1) {	1438	for (gran_size = (1ULL<<16); gran_size < (1ULL<<32); gran_size <<= 1) {
1363	char gran_factor;
1364	unsigned long gran_base;
1365
1366	if (debug_print)
1367	gran_base = to_size_factor(gran_size >> 10, &gran_factor);
1368		1439
1369	for (chunk_size = gran_size; chunk_size < (1ULL<<32);	1440	for (chunk_size = gran_size; chunk_size < (1ULL<<32);
1370	chunk_size <<= 1) {	1441	chunk_size <<= 1) {
1371	int num_reg;
1372		1442
1373	if (debug_print) {
1374	char chunk_factor;
1375	unsigned long chunk_base;
1376
1377	chunk_base = to_size_factor(chunk_size>>10, &chunk_factor),
1378	printk(KERN_INFO "\n");
1379	printk(KERN_INFO "gran_size: %ld%c chunk_size: %ld%c \n",
1380	gran_base, gran_factor, chunk_base, chunk_factor);
1381	}
1382	if (i >= NUM_RESULT)	1443	if (i >= NUM_RESULT)
1383	continue;	1444	continue;
1384		1445
1385	/* convert ranges to var ranges state */	1446	mtrr_calc_range_state(chunk_size, gran_size,
1386	num_reg = x86_setup_var_mtrrs(range, nr_range,	1447	extra_remove_base, extra_remove_size, i);
1387	chunk_size, gran_size);	1448	if (debug_print) {
1388		1449	mtrr_print_out_one_result(i);
1389	/* we got new setting in range_state, check it */	1450	printk(KERN_INFO "\n");
1390	memset(range_new, 0, sizeof(range_new));
1391	nr_range_new = x86_get_mtrr_mem_range(range_new, 0,
1392	extra_remove_base, extra_remove_size);
1393	range_sums_new = sum_ranges(range_new, nr_range_new);
1394
1395	result[i].chunk_sizek = chunk_size >> 10;
1396	result[i].gran_sizek = gran_size >> 10;
1397	result[i].num_reg = num_reg;
1398	if (range_sums < range_sums_new) {
1399	result[i].lose_cover_sizek =
1400	(range_sums_new - range_sums) << PSHIFT;
1401	result[i].bad = 1;
1402	} else
1403	result[i].lose_cover_sizek =
1404	(range_sums - range_sums_new) << PSHIFT;
1405
1406	/* double check it */
1407	if (!result[i].bad && !result[i].lose_cover_sizek) {
1408	if (nr_range_new != nr_range \|\|
1409	memcmp(range, range_new, sizeof(range)))
1410	result[i].bad = 1;
1411	}	1451	}
1412		1452
1413	if (!result[i].bad && (range_sums - range_sums_new <
1414	min_loss_pfn[num_reg])) {
1415	min_loss_pfn[num_reg] =
1416	range_sums - range_sums_new;
1417	}
1418	i++;	1453	i++;
1419	}	1454	}
1420	}	1455	}
1421		1456
1422	/* print out all */
1423	for (i = 0; i < NUM_RESULT; i++) {
1424	char gran_factor, chunk_factor, lose_factor;
1425	unsigned long gran_base, chunk_base, lose_base;
1426
1427	gran_base = to_size_factor(result[i].gran_sizek, &gran_factor),
1428	chunk_base = to_size_factor(result[i].chunk_sizek, &chunk_factor),
1429	lose_base = to_size_factor(result[i].lose_cover_sizek, &lose_factor),
1430	printk(KERN_INFO "%sgran_size: %ld%c \tchunk_size: %ld%c \t",
1431	result[i].bad?"BAD":" ",
1432	gran_base, gran_factor, chunk_base, chunk_factor);
1433	printk(KERN_CONT "num_reg: %d \tlose cover RAM: %s%ld%c\n",
1434	result[i].num_reg, result[i].bad?"-":"",
1435	lose_base, lose_factor);
1436	}
1437
1438	/* try to find the optimal index */	1457	/* try to find the optimal index */
1439	if (nr_mtrr_spare_reg >= num_var_ranges)	1458	index_good = mtrr_search_optimal_index();
1440	nr_mtrr_spare_reg = num_var_ranges - 1;
1441	num_reg_good = -1;
1442	for (i = num_var_ranges - nr_mtrr_spare_reg; i > 0; i--) {
1443	if (!min_loss_pfn[i])
1444	num_reg_good = i;
1445	}
1446
1447	index_good = -1;
1448	if (num_reg_good != -1) {
1449	for (i = 0; i < NUM_RESULT; i++) {
1450	if (!result[i].bad &&
1451	result[i].num_reg == num_reg_good &&
1452	!result[i].lose_cover_sizek) {
1453	index_good = i;
1454	break;
1455	}
1456	}
1457	}
1458		1459
1459	if (index_good != -1) {	1460	if (index_good != -1) {
1460	char gran_factor, chunk_factor, lose_factor;
1461	unsigned long gran_base, chunk_base, lose_base;
1462
1463	printk(KERN_INFO "Found optimal setting for mtrr clean up\n");	1461	printk(KERN_INFO "Found optimal setting for mtrr clean up\n");
1464	i = index_good;	1462	i = index_good;
1465	gran_base = to_size_factor(result[i].gran_sizek, &gran_factor),	1463	mtrr_print_out_one_result(i);
1466	chunk_base = to_size_factor(result[i].chunk_sizek, &chunk_factor),	1464
1467	lose_base = to_size_factor(result[i].lose_cover_sizek, &lose_factor),
1468	printk(KERN_INFO "gran_size: %ld%c \tchunk_size: %ld%c \t",
1469	gran_base, gran_factor, chunk_base, chunk_factor);
1470	printk(KERN_CONT "num_reg: %d \tlose RAM: %ld%c\n",
1471	result[i].num_reg, lose_base, lose_factor);
1472	/* convert ranges to var ranges state */	1465	/* convert ranges to var ranges state */
1473	chunk_size = result[i].chunk_sizek;	1466	chunk_size = result[i].chunk_sizek;
1474	chunk_size <<= 10;	1467	chunk_size <<= 10;
1475	gran_size = result[i].gran_sizek;	1468	gran_size = result[i].gran_sizek;
1476	gran_size <<= 10;	1469	gran_size <<= 10;
1477	debug_print++;
1478	x86_setup_var_mtrrs(range, nr_range, chunk_size, gran_size);	1470	x86_setup_var_mtrrs(range, nr_range, chunk_size, gran_size);
1479	debug_print--;
1480	set_var_mtrr_all(address_bits);	1471	set_var_mtrr_all(address_bits);
		1472	printk(KERN_DEBUG "New variable MTRRs\n");
		1473	print_out_mtrr_range_state();
1481	return 1;	1474	return 1;
		1475	} else {
		1476	/* print out all */
		1477	for (i = 0; i < NUM_RESULT; i++)
		1478	mtrr_print_out_one_result(i);
1482	}	1479	}
1483		1480
1484	printk(KERN_INFO "mtrr_cleanup: can not find optimal value\n");	1481	printk(KERN_INFO "mtrr_cleanup: can not find optimal value\n");
@@ -1562,7 +1559,6 @@ int __init mtrr_trim_uncached_memory(unsigned long end_pfn)
1562	{	1559	{
1563	unsigned long i, base, size, highest_pfn = 0, def, dummy;	1560	unsigned long i, base, size, highest_pfn = 0, def, dummy;
1564	mtrr_type type;	1561	mtrr_type type;
1565	int nr_range;
1566	u64 total_trim_size;	1562	u64 total_trim_size;
1567		1563
1568	/* extra one for all 0 */	1564	/* extra one for all 0 */