x86: Clean up mtrr/cleanup.c (63f9600f) · Commits · e / devices / android_kernel_fairphone_FP5

arch/x86/kernel/cpu/mtrr/cleanup.c

+176 −174

Original line number	Original line	Diff line number	Diff line
	/* MTRR (Memory Type Range Register) cleanup		/*
			* MTRR (Memory Type Range Register) cleanup
	Copyright (C) 2009 Yinghai Lu		*
			* Copyright (C) 2009 Yinghai Lu
	This library is free software; you can redistribute it and/or		*
	modify it under the terms of the GNU Library General Public		* This library is free software; you can redistribute it and/or
	License as published by the Free Software Foundation; either		* modify it under the terms of the GNU Library General Public
	version 2 of the License, or (at your option) any later version.		* License as published by the Free Software Foundation; either
			* version 2 of the License, or (at your option) any later version.
	This library is distributed in the hope that it will be useful,		*
	but WITHOUT ANY WARRANTY; without even the implied warranty of		* This library is distributed in the hope that it will be useful,
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU		* but WITHOUT ANY WARRANTY; without even the implied warranty of
	Library General Public License for more details.		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
			* Library General Public License for more details.
	You should have received a copy of the GNU Library General Public		*
	License along with this library; if not, write to the Free		* You should have received a copy of the GNU Library General Public
	Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.		* License along with this library; if not, write to the Free
			* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	*/		*/

	#include <linux/module.h>		#include <linux/module.h>
	#include <linux/init.h>		#include <linux/init.h>
	#include <linux/pci.h>		#include <linux/pci.h>
	#include <linux/smp.h>		#include <linux/smp.h>
	#include <linux/cpu.h>		#include <linux/cpu.h>
	#include <linux/mutex.h>
	#include <linux/sort.h>		#include <linux/sort.h>
			#include <linux/mutex.h>
			#include <linux/uaccess.h>
			#include <linux/kvm_para.h>

			#include <asm/processor.h>
	#include <asm/e820.h>		#include <asm/e820.h>
	#include <asm/mtrr.h>		#include <asm/mtrr.h>
	#include <asm/uaccess.h>
	#include <asm/processor.h>
	#include <asm/msr.h>		#include <asm/msr.h>
	#include <asm/kvm_para.h>
	#include "mtrr.h"		#include "mtrr.h"

	/* should be related to MTRR_VAR_RANGES nums */		/* Should be related to MTRR_VAR_RANGES nums */
	#define RANGE_NUM 256		#define RANGE_NUM 256

	struct res_range {		struct res_range {
	@@ -42,10 +43,10 @@ struct res_range {
	};		};

	static int __init		static int __init
	add_range(struct res_range *range, int nr_range, unsigned long start,		add_range(struct res_range *range, int nr_range,
	unsigned long end)		unsigned long start, unsigned long end)
	{		{
	/* out of slots */		/* Out of slots: */
	if (nr_range >= RANGE_NUM)		if (nr_range >= RANGE_NUM)
	return nr_range;		return nr_range;

	@@ -58,12 +59,12 @@ add_range(struct res_range *range, int nr_range, unsigned long start,
	}		}

	static int __init		static int __init
	add_range_with_merge(struct res_range *range, int nr_range, unsigned long start,		add_range_with_merge(struct res_range *range, int nr_range,
	unsigned long end)		unsigned long start, unsigned long end)
	{		{
	int i;		int i;

	/* try to merge it with old one */		/* Try to merge it with old one: */
	for (i = 0; i < nr_range; i++) {		for (i = 0; i < nr_range; i++) {
	unsigned long final_start, final_end;		unsigned long final_start, final_end;
	unsigned long common_start, common_end;		unsigned long common_start, common_end;
	@@ -84,7 +85,7 @@ add_range_with_merge(struct res_range *range, int nr_range, unsigned long start,
	return nr_range;		return nr_range;
	}		}

	/* need to add that */		/* Need to add it: */
	return add_range(range, nr_range, start, end);		return add_range(range, nr_range, start, end);
	}		}

	@@ -117,7 +118,7 @@ subtract_range(struct res_range *range, unsigned long start, unsigned long end)
	}		}

	if (start > range[j].start && end < range[j].end) {		if (start > range[j].start && end < range[j].end) {
	/* find the new spare */		/* Find the new spare: */
	for (i = 0; i < RANGE_NUM; i++) {		for (i = 0; i < RANGE_NUM; i++) {
	if (range[i].end == 0)		if (range[i].end == 0)
	break;		break;
	@@ -153,7 +154,13 @@ struct var_mtrr_range_state {
	};		};

	static struct var_mtrr_range_state __initdata range_state[RANGE_NUM];		static struct var_mtrr_range_state __initdata range_state[RANGE_NUM];

	static int __initdata debug_print;		static int __initdata debug_print;
			#define Dprintk(x...) do { if (debug_print) printk(KERN_DEBUG x); } while (0)


			#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		static int __init
	x86_get_mtrr_mem_range(struct res_range *range, int nr_range,		x86_get_mtrr_mem_range(struct res_range *range, int nr_range,
	@@ -180,7 +187,7 @@ x86_get_mtrr_mem_range(struct res_range *range, int nr_range,
	range[i].start, range[i].end + 1);		range[i].start, range[i].end + 1);
	}		}

	/* take out UC ranges */		/* Take out UC ranges: */
	for (i = 0; i < num_var_ranges; i++) {		for (i = 0; i < num_var_ranges; i++) {
	type = range_state[i].type;		type = range_state[i].type;
	if (type != MTRR_TYPE_UNCACHABLE &&		if (type != MTRR_TYPE_UNCACHABLE &&
	@@ -244,10 +251,9 @@ static int __initdata nr_range;

	static unsigned long __init sum_ranges(struct res_range *range, int nr_range)		static unsigned long __init sum_ranges(struct res_range *range, int nr_range)
	{		{
	unsigned long sum;		unsigned long sum = 0;
	int i;		int i;

	sum = 0;
	for (i = 0; i < nr_range; i++)		for (i = 0; i < nr_range; i++)
	sum += range[i].end + 1 - range[i].start;		sum += range[i].end + 1 - range[i].start;

	@@ -324,8 +330,7 @@ save_var_mtrr(unsigned int reg, unsigned long basek, unsigned long sizek,
	range_state[reg].type = type;		range_state[reg].type = type;
	}		}

	static void __init		static void __init set_var_mtrr_all(unsigned int address_bits)
	set_var_mtrr_all(unsigned int address_bits)
	{		{
	unsigned long basek, sizek;		unsigned long basek, sizek;
	unsigned char type;		unsigned char type;
	@@ -342,11 +347,11 @@ set_var_mtrr_all(unsigned int address_bits)

	static unsigned long to_size_factor(unsigned long sizek, char *factorp)		static unsigned long to_size_factor(unsigned long sizek, char *factorp)
	{		{
	char factor;
	unsigned long base = sizek;		unsigned long base = sizek;
			char factor;

	if (base & ((1<<10) - 1)) {		if (base & ((1<<10) - 1)) {
	/* not MB alignment */		/* Not MB-aligned: */
	factor = 'K';		factor = 'K';
	} else if (base & ((1<<20) - 1)) {		} else if (base & ((1<<20) - 1)) {
	factor = 'M';		factor = 'M';
	@@ -372,11 +377,12 @@ range_to_mtrr(unsigned int reg, unsigned long range_startk,
	unsigned long max_align, align;		unsigned long max_align, align;
	unsigned long sizek;		unsigned long sizek;

	/* Compute the maximum size I can make a range */		/* Compute the maximum size with which we can make a range: */
	if (range_startk)		if (range_startk)
	max_align = ffs(range_startk) - 1;		max_align = ffs(range_startk) - 1;
	else		else
	max_align = 32;		max_align = 32;

	align = fls(range_sizek) - 1;		align = fls(range_sizek) - 1;
	if (align > max_align)		if (align > max_align)
	align = max_align;		align = max_align;
	@@ -386,11 +392,10 @@ range_to_mtrr(unsigned int reg, unsigned long range_startk,
	char start_factor = 'K', size_factor = 'K';		char start_factor = 'K', size_factor = 'K';
	unsigned long start_base, size_base;		unsigned long start_base, size_base;

	start_base = to_size_factor(range_startk,		start_base = to_size_factor(range_startk, &start_factor);
	&start_factor),		size_base = to_size_factor(sizek, &size_factor);
	size_base = to_size_factor(sizek, &size_factor),

	printk(KERN_DEBUG "Setting variable MTRR %d, "		Dprintk("Setting variable MTRR %d, "
	"base: %ld%cB, range: %ld%cB, type %s\n",		"base: %ld%cB, range: %ld%cB, type %s\n",
	reg, start_base, start_factor,		reg, start_base, start_factor,
	size_base, size_factor,		size_base, size_factor,
	@@ -425,10 +430,11 @@ range_to_mtrr_with_hole(struct var_mtrr_state *state, unsigned long basek,
	chunk_sizek = state->chunk_sizek;		chunk_sizek = state->chunk_sizek;
	gran_sizek = state->gran_sizek;		gran_sizek = state->gran_sizek;

	/* align with gran size, prevent small block used up MTRRs */		/* Align with gran size, prevent small block used up MTRRs: */
	range_basek = ALIGN(state->range_startk, gran_sizek);		range_basek = ALIGN(state->range_startk, gran_sizek);
	if ((range_basek > basek) && basek)		if ((range_basek > basek) && basek)
	return second_sizek;		return second_sizek;

	state->range_sizek -= (range_basek - state->range_startk);		state->range_sizek -= (range_basek - state->range_startk);
	range_sizek = ALIGN(state->range_sizek, gran_sizek);		range_sizek = ALIGN(state->range_sizek, gran_sizek);

	@@ -439,14 +445,13 @@ range_to_mtrr_with_hole(struct var_mtrr_state *state, unsigned long basek,
	}		}
	state->range_sizek = range_sizek;		state->range_sizek = range_sizek;

	/* try to append some small hole */		/* Try to append some small hole: */
	range0_basek = state->range_startk;		range0_basek = state->range_startk;
	range0_sizek = ALIGN(state->range_sizek, chunk_sizek);		range0_sizek = ALIGN(state->range_sizek, chunk_sizek);

	/* no increase */		/* No increase: */
	if (range0_sizek == state->range_sizek) {		if (range0_sizek == state->range_sizek) {
	if (debug_print)		Dprintk("rangeX: %016lx - %016lx\n",
	printk(KERN_DEBUG "rangeX: %016lx - %016lx\n",
	range0_basek<<10,		range0_basek<<10,
	(range0_basek + state->range_sizek)<<10);		(range0_basek + state->range_sizek)<<10);
	state->reg = range_to_mtrr(state->reg, range0_basek,		state->reg = range_to_mtrr(state->reg, range0_basek,
	@@ -454,7 +459,7 @@ range_to_mtrr_with_hole(struct var_mtrr_state *state, unsigned long basek,
	return 0;		return 0;
	}		}

	/* only cut back, when it is not the last */		/* Only cut back when it is not the last: */
	if (sizek) {		if (sizek) {
	while (range0_basek + range0_sizek > (basek + sizek)) {		while (range0_basek + range0_sizek > (basek + sizek)) {
	if (range0_sizek >= chunk_sizek)		if (range0_sizek >= chunk_sizek)
	@@ -470,16 +475,16 @@ range_to_mtrr_with_hole(struct var_mtrr_state *state, unsigned long basek,
	second_try:		second_try:
	range_basek = range0_basek + range0_sizek;		range_basek = range0_basek + range0_sizek;

	/* one hole in the middle */		/* One hole in the middle: */
	if (range_basek > basek && range_basek <= (basek + sizek))		if (range_basek > basek && range_basek <= (basek + sizek))
	second_sizek = range_basek - basek;		second_sizek = range_basek - basek;

	if (range0_sizek > state->range_sizek) {		if (range0_sizek > state->range_sizek) {

	/* one hole in middle or at end */		/* One hole in middle or at the end: */
	hole_sizek = range0_sizek - state->range_sizek - second_sizek;		hole_sizek = range0_sizek - state->range_sizek - second_sizek;

	/* hole size should be less than half of range0 size */		/* Hole size should be less than half of range0 size: */
	if (hole_sizek >= (range0_sizek >> 1) &&		if (hole_sizek >= (range0_sizek >> 1) &&
	range0_sizek >= chunk_sizek) {		range0_sizek >= chunk_sizek) {
	range0_sizek -= chunk_sizek;		range0_sizek -= chunk_sizek;
	@@ -491,8 +496,7 @@ range_to_mtrr_with_hole(struct var_mtrr_state *state, unsigned long basek,
	}		}

	if (range0_sizek) {		if (range0_sizek) {
	if (debug_print)		Dprintk("range0: %016lx - %016lx\n",
	printk(KERN_DEBUG "range0: %016lx - %016lx\n",
	range0_basek<<10,		range0_basek<<10,
	(range0_basek + range0_sizek)<<10);		(range0_basek + range0_sizek)<<10);
	state->reg = range_to_mtrr(state->reg, range0_basek,		state->reg = range_to_mtrr(state->reg, range0_basek,
	@@ -500,21 +504,20 @@ range_to_mtrr_with_hole(struct var_mtrr_state *state, unsigned long basek,
	}		}

	if (range0_sizek < state->range_sizek) {		if (range0_sizek < state->range_sizek) {
	/* need to handle left over */		/* Need to handle left over range: */
	range_sizek = state->range_sizek - range0_sizek;		range_sizek = state->range_sizek - range0_sizek;

	if (debug_print)		Dprintk("range: %016lx - %016lx\n",
	printk(KERN_DEBUG "range: %016lx - %016lx\n",
	range_basek<<10,		range_basek<<10,
	(range_basek + range_sizek)<<10);		(range_basek + range_sizek)<<10);

	state->reg = range_to_mtrr(state->reg, range_basek,		state->reg = range_to_mtrr(state->reg, range_basek,
	range_sizek, MTRR_TYPE_WRBACK);		range_sizek, MTRR_TYPE_WRBACK);
	}		}

	if (hole_sizek) {		if (hole_sizek) {
	hole_basek = range_basek - hole_sizek - second_sizek;		hole_basek = range_basek - hole_sizek - second_sizek;
	if (debug_print)		Dprintk("hole: %016lx - %016lx\n",
	printk(KERN_DEBUG "hole: %016lx - %016lx\n",
	hole_basek<<10,		hole_basek<<10,
	(hole_basek + hole_sizek)<<10);		(hole_basek + hole_sizek)<<10);
	state->reg = range_to_mtrr(state->reg, hole_basek,		state->reg = range_to_mtrr(state->reg, hole_basek,
	@@ -537,23 +540,23 @@ set_var_mtrr_range(struct var_mtrr_state *state, unsigned long base_pfn,
	basek = base_pfn << (PAGE_SHIFT - 10);		basek = base_pfn << (PAGE_SHIFT - 10);
	sizek = size_pfn << (PAGE_SHIFT - 10);		sizek = size_pfn << (PAGE_SHIFT - 10);

	/* See if I can merge with the last range */		/* See if I can merge with the last range: */
	if ((basek <= 1024) \|\|		if ((basek <= 1024) \|\|
	(state->range_startk + state->range_sizek == basek)) {		(state->range_startk + state->range_sizek == basek)) {
	unsigned long endk = basek + sizek;		unsigned long endk = basek + sizek;
	state->range_sizek = endk - state->range_startk;		state->range_sizek = endk - state->range_startk;
	return;		return;
	}		}
	/* Write the range mtrrs */		/* Write the range mtrrs: */
	if (state->range_sizek != 0)		if (state->range_sizek != 0)
	second_sizek = range_to_mtrr_with_hole(state, basek, sizek);		second_sizek = range_to_mtrr_with_hole(state, basek, sizek);

	/* Allocate an msr */		/* Allocate an msr: */
	state->range_startk = basek + second_sizek;		state->range_startk = basek + second_sizek;
	state->range_sizek = sizek - second_sizek;		state->range_sizek = sizek - second_sizek;
	}		}

	/* mininum size of mtrr block that can take hole */		/* Mininum size of mtrr block that can take hole: */
	static u64 mtrr_chunk_size __initdata = (256ULL<<20);		static u64 mtrr_chunk_size __initdata = (256ULL<<20);

	static int __init parse_mtrr_chunk_size_opt(char *p)		static int __init parse_mtrr_chunk_size_opt(char *p)
	@@ -565,7 +568,7 @@ static int __init parse_mtrr_chunk_size_opt(char *p)
	}		}
	early_param("mtrr_chunk_size", parse_mtrr_chunk_size_opt);		early_param("mtrr_chunk_size", parse_mtrr_chunk_size_opt);

	/* granity of mtrr of block */		/* Granularity of mtrr of block: */
	static u64 mtrr_gran_size __initdata;		static u64 mtrr_gran_size __initdata;

	static int __init parse_mtrr_gran_size_opt(char *p)		static int __init parse_mtrr_gran_size_opt(char *p)
	@@ -577,7 +580,7 @@ static int __init parse_mtrr_gran_size_opt(char *p)
	}		}
	early_param("mtrr_gran_size", parse_mtrr_gran_size_opt);		early_param("mtrr_gran_size", parse_mtrr_gran_size_opt);

	static int nr_mtrr_spare_reg __initdata =		static unsigned long nr_mtrr_spare_reg __initdata =
	CONFIG_MTRR_SANITIZER_SPARE_REG_NR_DEFAULT;		CONFIG_MTRR_SANITIZER_SPARE_REG_NR_DEFAULT;

	static int __init parse_mtrr_spare_reg(char *arg)		static int __init parse_mtrr_spare_reg(char *arg)
	@@ -586,7 +589,6 @@ static int __init parse_mtrr_spare_reg(char *arg)
	nr_mtrr_spare_reg = simple_strtoul(arg, NULL, 0);		nr_mtrr_spare_reg = simple_strtoul(arg, NULL, 0);
	return 0;		return 0;
	}		}

	early_param("mtrr_spare_reg_nr", parse_mtrr_spare_reg);		early_param("mtrr_spare_reg_nr", parse_mtrr_spare_reg);

	static int __init		static int __init
	@@ -594,8 +596,8 @@ x86_setup_var_mtrrs(struct res_range *range, int nr_range,
	u64 chunk_size, u64 gran_size)		u64 chunk_size, u64 gran_size)
	{		{
	struct var_mtrr_state var_state;		struct var_mtrr_state var_state;
	int i;
	int num_reg;		int num_reg;
			int i;

	var_state.range_startk = 0;		var_state.range_startk = 0;
	var_state.range_sizek = 0;		var_state.range_sizek = 0;
	@@ -605,17 +607,18 @@ x86_setup_var_mtrrs(struct res_range *range, int nr_range,

	memset(range_state, 0, sizeof(range_state));		memset(range_state, 0, sizeof(range_state));

	/* Write the range etc */		/* Write the range: */
	for (i = 0; i < nr_range; i++)		for (i = 0; i < nr_range; i++) {
	set_var_mtrr_range(&var_state, range[i].start,		set_var_mtrr_range(&var_state, range[i].start,
	range[i].end - range[i].start + 1);		range[i].end - range[i].start + 1);
			}

	/* Write the last range */		/* Write the last range: */
	if (var_state.range_sizek != 0)		if (var_state.range_sizek != 0)
	range_to_mtrr_with_hole(&var_state, 0, 0);		range_to_mtrr_with_hole(&var_state, 0, 0);

	num_reg = var_state.reg;		num_reg = var_state.reg;
	/* Clear out the extra MTRR's */		/* Clear out the extra MTRR's: */
	while (var_state.reg < num_var_ranges) {		while (var_state.reg < num_var_ranges) {
	save_var_mtrr(var_state.reg, 0, 0, 0);		save_var_mtrr(var_state.reg, 0, 0, 0);
	var_state.reg++;		var_state.reg++;
	@@ -645,10 +648,10 @@ static unsigned long __initdata min_loss_pfn[RANGE_NUM];

	static void __init print_out_mtrr_range_state(void)		static void __init print_out_mtrr_range_state(void)
	{		{
	int i;
	char start_factor = 'K', size_factor = 'K';		char start_factor = 'K', size_factor = 'K';
	unsigned long start_base, size_base;		unsigned long start_base, size_base;
	mtrr_type type;		mtrr_type type;
			int i;

	for (i = 0; i < num_var_ranges; i++) {		for (i = 0; i < num_var_ranges; i++) {

	@@ -676,10 +679,10 @@ static int __init mtrr_need_cleanup(void)
	int i;		int i;
	mtrr_type type;		mtrr_type type;
	unsigned long size;		unsigned long size;
	/* extra one for all 0 */		/* Extra one for all 0: */
	int num[MTRR_NUM_TYPES + 1];		int num[MTRR_NUM_TYPES + 1];

	/* check entries number */		/* Check entries number: */
	memset(num, 0, sizeof(num));		memset(num, 0, sizeof(num));
	for (i = 0; i < num_var_ranges; i++) {		for (i = 0; i < num_var_ranges; i++) {
	type = range_state[i].type;		type = range_state[i].type;
	@@ -693,11 +696,11 @@ static int __init mtrr_need_cleanup(void)
	num[type]++;		num[type]++;
	}		}

	/* check if we got UC entries */		/* Check if we got UC entries: */
	if (!num[MTRR_TYPE_UNCACHABLE])		if (!num[MTRR_TYPE_UNCACHABLE])
	return 0;		return 0;

	/* check if we only had WB and UC */		/* Check if we only had WB and UC */
	if (num[MTRR_TYPE_WRBACK] + num[MTRR_TYPE_UNCACHABLE] !=		if (num[MTRR_TYPE_WRBACK] + num[MTRR_TYPE_UNCACHABLE] !=
	num_var_ranges - num[MTRR_NUM_TYPES])		num_var_ranges - num[MTRR_NUM_TYPES])
	return 0;		return 0;
	@@ -706,75 +709,73 @@ static int __init mtrr_need_cleanup(void)
	}		}

	static unsigned long __initdata range_sums;		static unsigned long __initdata range_sums;
	static void __init mtrr_calc_range_state(u64 chunk_size, u64 gran_size,
	unsigned long extra_remove_base,		static void __init
	unsigned long extra_remove_size,		mtrr_calc_range_state(u64 chunk_size, u64 gran_size,
	int i)		unsigned long x_remove_base,
			unsigned long x_remove_size, int i)
	{		{
	int num_reg;
	static struct res_range range_new[RANGE_NUM];		static struct res_range range_new[RANGE_NUM];
	static int nr_range_new;
	unsigned long range_sums_new;		unsigned long range_sums_new;
			static int nr_range_new;
			int num_reg;

	/* convert ranges to var ranges state */		/* Convert ranges to var ranges state: */
	num_reg = x86_setup_var_mtrrs(range, nr_range,		num_reg = x86_setup_var_mtrrs(range, nr_range, chunk_size, gran_size);
	chunk_size, gran_size);

	/* we got new setting in range_state, check it */		/* We got new setting in range_state, check it: */
	memset(range_new, 0, sizeof(range_new));		memset(range_new, 0, sizeof(range_new));
	nr_range_new = x86_get_mtrr_mem_range(range_new, 0,		nr_range_new = x86_get_mtrr_mem_range(range_new, 0,
	extra_remove_base, extra_remove_size);		x_remove_base, x_remove_size);
	range_sums_new = sum_ranges(range_new, nr_range_new);		range_sums_new = sum_ranges(range_new, nr_range_new);

	result[i].chunk_sizek = chunk_size >> 10;		result[i].chunk_sizek = chunk_size >> 10;
	result[i].gran_sizek = gran_size >> 10;		result[i].gran_sizek = gran_size >> 10;
	result[i].num_reg = num_reg;		result[i].num_reg = num_reg;

	if (range_sums < range_sums_new) {		if (range_sums < range_sums_new) {
	result[i].lose_cover_sizek =		result[i].lose_cover_sizek = (range_sums_new - range_sums) << PSHIFT;
	(range_sums_new - range_sums) << PSHIFT;
	result[i].bad = 1;		result[i].bad = 1;
	} else		} else {
	result[i].lose_cover_sizek =		result[i].lose_cover_sizek = (range_sums - range_sums_new) << PSHIFT;
	(range_sums - range_sums_new) << PSHIFT;		}

	/* double check it */		/* Double check it: */
	if (!result[i].bad && !result[i].lose_cover_sizek) {		if (!result[i].bad && !result[i].lose_cover_sizek) {
	if (nr_range_new != nr_range \|\|		if (nr_range_new != nr_range \|\| memcmp(range, range_new, sizeof(range)))
	memcmp(range, range_new, sizeof(range)))
	result[i].bad = 1;		result[i].bad = 1;
	}		}

	if (!result[i].bad && (range_sums - range_sums_new <		if (!result[i].bad && (range_sums - range_sums_new < min_loss_pfn[num_reg]))
	min_loss_pfn[num_reg])) {		min_loss_pfn[num_reg] = range_sums - range_sums_new;
	min_loss_pfn[num_reg] =
	range_sums - range_sums_new;
	}
	}		}

	static void __init mtrr_print_out_one_result(int i)		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;		unsigned long gran_base, chunk_base, lose_base;
			char gran_factor, chunk_factor, lose_factor;

	gran_base = to_size_factor(result[i].gran_sizek, &gran_factor),		gran_base = to_size_factor(result[i].gran_sizek, &gran_factor),
	chunk_base = to_size_factor(result[i].chunk_sizek, &chunk_factor),		chunk_base = to_size_factor(result[i].chunk_sizek, &chunk_factor),
	lose_base = to_size_factor(result[i].lose_cover_sizek, &lose_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",
			pr_info("%sgran_size: %ld%c \tchunk_size: %ld%c \t",
	result[i].bad ? "BAD" : " ",		result[i].bad ? "BAD" : " ",
	gran_base, gran_factor, chunk_base, chunk_factor);		gran_base, gran_factor, chunk_base, chunk_factor);
	printk(KERN_CONT "num_reg: %d \tlose cover RAM: %s%ld%c\n",		pr_cont("num_reg: %d \tlose cover RAM: %s%ld%c\n",
	result[i].num_reg, result[i].bad ? "-" : "",		result[i].num_reg, result[i].bad ? "-" : "",
	lose_base, lose_factor);		lose_base, lose_factor);
	}		}

	static int __init mtrr_search_optimal_index(void)		static int __init mtrr_search_optimal_index(void)
	{		{
	int i;
	int num_reg_good;		int num_reg_good;
	int index_good;		int index_good;
			int i;

	if (nr_mtrr_spare_reg >= num_var_ranges)		if (nr_mtrr_spare_reg >= num_var_ranges)
	nr_mtrr_spare_reg = num_var_ranges - 1;		nr_mtrr_spare_reg = num_var_ranges - 1;

	num_reg_good = -1;		num_reg_good = -1;
	for (i = num_var_ranges - nr_mtrr_spare_reg; i > 0; i--) {		for (i = num_var_ranges - nr_mtrr_spare_reg; i > 0; i--) {
	if (!min_loss_pfn[i])		if (!min_loss_pfn[i])
	@@ -796,24 +797,24 @@ static int __init mtrr_search_optimal_index(void)
	return index_good;		return index_good;
	}		}


	int __init mtrr_cleanup(unsigned address_bits)		int __init mtrr_cleanup(unsigned address_bits)
	{		{
	unsigned long extra_remove_base, extra_remove_size;		unsigned long x_remove_base, x_remove_size;
	unsigned long base, size, def, dummy;		unsigned long base, size, def, dummy;
	mtrr_type type;
	u64 chunk_size, gran_size;		u64 chunk_size, gran_size;
			mtrr_type type;
	int index_good;		int index_good;
	int i;		int i;

	if (!is_cpu(INTEL) \|\| enable_mtrr_cleanup < 1)		if (!is_cpu(INTEL) \|\| enable_mtrr_cleanup < 1)
	return 0;		return 0;

	rdmsr(MSR_MTRRdefType, def, dummy);		rdmsr(MSR_MTRRdefType, def, dummy);
	def &= 0xff;		def &= 0xff;
	if (def != MTRR_TYPE_UNCACHABLE)		if (def != MTRR_TYPE_UNCACHABLE)
	return 0;		return 0;

	/* get it and store it aside */		/* Get it and store it aside: */
	memset(range_state, 0, sizeof(range_state));		memset(range_state, 0, sizeof(range_state));
	for (i = 0; i < num_var_ranges; i++) {		for (i = 0; i < num_var_ranges; i++) {
	mtrr_if->get(i, &base, &size, &type);		mtrr_if->get(i, &base, &size, &type);
	@@ -822,29 +823,28 @@ int __init mtrr_cleanup(unsigned address_bits)
	range_state[i].type = type;		range_state[i].type = type;
	}		}

	/* check if we need handle it and can handle it */		/* Check if we need handle it and can handle it: */
	if (!mtrr_need_cleanup())		if (!mtrr_need_cleanup())
	return 0;		return 0;

	/* print original var MTRRs at first, for debugging: */		/* Print original var MTRRs at first, for debugging: */
	printk(KERN_DEBUG "original variable MTRRs\n");		printk(KERN_DEBUG "original variable MTRRs\n");
	print_out_mtrr_range_state();		print_out_mtrr_range_state();

	memset(range, 0, sizeof(range));		memset(range, 0, sizeof(range));
	extra_remove_size = 0;		x_remove_size = 0;
	extra_remove_base = 1 << (32 - PAGE_SHIFT);		x_remove_base = 1 << (32 - PAGE_SHIFT);
	if (mtrr_tom2)		if (mtrr_tom2)
	extra_remove_size =		x_remove_size = (mtrr_tom2 >> PAGE_SHIFT) - x_remove_base;
	(mtrr_tom2 >> PAGE_SHIFT) - extra_remove_base;
	nr_range = x86_get_mtrr_mem_range(range, 0, extra_remove_base,		nr_range = x86_get_mtrr_mem_range(range, 0, x_remove_base, x_remove_size);
	extra_remove_size);
	/*		/*
	* [0, 1M) should always be coverred by var mtrr with WB		* [0, 1M) should always be covered by var mtrr with WB
	* and fixed mtrrs should take effective before var mtrr for it		* 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, nr_range, 0,
	(1ULL<<(20 - PAGE_SHIFT)) - 1);		(1ULL<<(20 - PAGE_SHIFT)) - 1);
	/* sort the ranges */		/* Sort the ranges: */
	sort(range, nr_range, sizeof(struct res_range), cmp_range, NULL);		sort(range, nr_range, sizeof(struct res_range), cmp_range, NULL);

	range_sums = sum_ranges(range, nr_range);		range_sums = sum_ranges(range, nr_range);
	@@ -854,7 +854,7 @@ int __init mtrr_cleanup(unsigned address_bits)
	if (mtrr_chunk_size && mtrr_gran_size) {		if (mtrr_chunk_size && mtrr_gran_size) {
	i = 0;		i = 0;
	mtrr_calc_range_state(mtrr_chunk_size, mtrr_gran_size,		mtrr_calc_range_state(mtrr_chunk_size, mtrr_gran_size,
	extra_remove_base, extra_remove_size, i);		x_remove_base, x_remove_size, i);

	mtrr_print_out_one_result(i);		mtrr_print_out_one_result(i);

	@@ -880,7 +880,7 @@ int __init mtrr_cleanup(unsigned address_bits)
	continue;		continue;

	mtrr_calc_range_state(chunk_size, gran_size,		mtrr_calc_range_state(chunk_size, gran_size,
	extra_remove_base, extra_remove_size, i);		x_remove_base, x_remove_size, i);
	if (debug_print) {		if (debug_print) {
	mtrr_print_out_one_result(i);		mtrr_print_out_one_result(i);
	printk(KERN_INFO "\n");		printk(KERN_INFO "\n");
	@@ -890,7 +890,7 @@ int __init mtrr_cleanup(unsigned address_bits)
	}		}
	}		}

	/* try to find the optimal index */		/* Try to find the optimal index: */
	index_good = mtrr_search_optimal_index();		index_good = mtrr_search_optimal_index();

	if (index_good != -1) {		if (index_good != -1) {
	@@ -898,7 +898,7 @@ int __init mtrr_cleanup(unsigned address_bits)
	i = index_good;		i = index_good;
	mtrr_print_out_one_result(i);		mtrr_print_out_one_result(i);

	/* convert ranges to var ranges state */		/* Convert ranges to var ranges state: */
	chunk_size = result[i].chunk_sizek;		chunk_size = result[i].chunk_sizek;
	chunk_size <<= 10;		chunk_size <<= 10;
	gran_size = result[i].gran_sizek;		gran_size = result[i].gran_sizek;
	@@ -952,7 +952,7 @@ int __init amd_special_default_mtrr(void)
	return 0;		return 0;
	if (boot_cpu_data.x86 < 0xf \|\| boot_cpu_data.x86 > 0x11)		if (boot_cpu_data.x86 < 0xf \|\| boot_cpu_data.x86 > 0x11)
	return 0;		return 0;
	/* In case some hypervisor doesn't pass SYSCFG through */		/* In case some hypervisor doesn't pass SYSCFG through: */
	if (rdmsr_safe(MSR_K8_SYSCFG, &l, &h) < 0)		if (rdmsr_safe(MSR_K8_SYSCFG, &l, &h) < 0)
	return 0;		return 0;
	/*		/*
	@@ -965,19 +965,21 @@ int __init amd_special_default_mtrr(void)
	return 0;		return 0;
	}		}

	static u64 __init real_trim_memory(unsigned long start_pfn,		static u64 __init
	unsigned long limit_pfn)		real_trim_memory(unsigned long start_pfn, unsigned long limit_pfn)
	{		{
	u64 trim_start, trim_size;		u64 trim_start, trim_size;

	trim_start = start_pfn;		trim_start = start_pfn;
	trim_start <<= PAGE_SHIFT;		trim_start <<= PAGE_SHIFT;

	trim_size = limit_pfn;		trim_size = limit_pfn;
	trim_size <<= PAGE_SHIFT;		trim_size <<= PAGE_SHIFT;
	trim_size -= trim_start;		trim_size -= trim_start;

	return e820_update_range(trim_start, trim_size, E820_RAM,		return e820_update_range(trim_start, trim_size, E820_RAM, E820_RESERVED);
	E820_RESERVED);
	}		}

	/**		/**
	* mtrr_trim_uncached_memory - trim RAM not covered by MTRRs		* mtrr_trim_uncached_memory - trim RAM not covered by MTRRs
	* @end_pfn: ending page frame number		* @end_pfn: ending page frame number
	@@ -994,21 +996,22 @@ int __init mtrr_trim_uncached_memory(unsigned long end_pfn)
	unsigned long i, base, size, highest_pfn = 0, def, dummy;		unsigned long i, base, size, highest_pfn = 0, def, dummy;
	mtrr_type type;		mtrr_type type;
	u64 total_trim_size;		u64 total_trim_size;

	/* extra one for all 0 */		/* extra one for all 0 */
	int num[MTRR_NUM_TYPES + 1];		int num[MTRR_NUM_TYPES + 1];

	/*		/*
	* Make sure we only trim uncachable memory on machines that		* Make sure we only trim uncachable memory on machines that
	* support the Intel MTRR architecture:		* support the Intel MTRR architecture:
	*/		*/
	if (!is_cpu(INTEL) \|\| disable_mtrr_trim)		if (!is_cpu(INTEL) \|\| disable_mtrr_trim)
	return 0;		return 0;

	rdmsr(MSR_MTRRdefType, def, dummy);		rdmsr(MSR_MTRRdefType, def, dummy);
	def &= 0xff;		def &= 0xff;
	if (def != MTRR_TYPE_UNCACHABLE)		if (def != MTRR_TYPE_UNCACHABLE)
	return 0;		return 0;

	/* get it and store it aside */		/* Get it and store it aside: */
	memset(range_state, 0, sizeof(range_state));		memset(range_state, 0, sizeof(range_state));
	for (i = 0; i < num_var_ranges; i++) {		for (i = 0; i < num_var_ranges; i++) {
	mtrr_if->get(i, &base, &size, &type);		mtrr_if->get(i, &base, &size, &type);
	@@ -1017,7 +1020,7 @@ int __init mtrr_trim_uncached_memory(unsigned long end_pfn)
	range_state[i].type = type;		range_state[i].type = type;
	}		}

	/* Find highest cached pfn */		/* Find highest cached pfn: */
	for (i = 0; i < num_var_ranges; i++) {		for (i = 0; i < num_var_ranges; i++) {
	type = range_state[i].type;		type = range_state[i].type;
	if (type != MTRR_TYPE_WRBACK)		if (type != MTRR_TYPE_WRBACK)
	@@ -1028,13 +1031,13 @@ int __init mtrr_trim_uncached_memory(unsigned long end_pfn)
	highest_pfn = base + size;		highest_pfn = base + size;
	}		}

	/* kvm/qemu doesn't have mtrr set right, don't trim them all */		/* kvm/qemu doesn't have mtrr set right, don't trim them all: */
	if (!highest_pfn) {		if (!highest_pfn) {
	printk(KERN_INFO "CPU MTRRs all blank - virtualized system.\n");		printk(KERN_INFO "CPU MTRRs all blank - virtualized system.\n");
	return 0;		return 0;
	}		}

	/* check entries number */		/* Check entries number: */
	memset(num, 0, sizeof(num));		memset(num, 0, sizeof(num));
	for (i = 0; i < num_var_ranges; i++) {		for (i = 0; i < num_var_ranges; i++) {
	type = range_state[i].type;		type = range_state[i].type;
	@@ -1046,11 +1049,11 @@ int __init mtrr_trim_uncached_memory(unsigned long end_pfn)
	num[type]++;		num[type]++;
	}		}

	/* no entry for WB? */		/* No entry for WB? */
	if (!num[MTRR_TYPE_WRBACK])		if (!num[MTRR_TYPE_WRBACK])
	return 0;		return 0;

	/* check if we only had WB and UC */		/* Check if we only had WB and UC: */
	if (num[MTRR_TYPE_WRBACK] + num[MTRR_TYPE_UNCACHABLE] !=		if (num[MTRR_TYPE_WRBACK] + num[MTRR_TYPE_UNCACHABLE] !=
	num_var_ranges - num[MTRR_NUM_TYPES])		num_var_ranges - num[MTRR_NUM_TYPES])
	return 0;		return 0;
	@@ -1066,31 +1069,31 @@ int __init mtrr_trim_uncached_memory(unsigned long end_pfn)
	}		}
	nr_range = x86_get_mtrr_mem_range(range, nr_range, 0, 0);		nr_range = x86_get_mtrr_mem_range(range, nr_range, 0, 0);

			/* Check the head: */
	total_trim_size = 0;		total_trim_size = 0;
	/* check the head */
	if (range[0].start)		if (range[0].start)
	total_trim_size += real_trim_memory(0, range[0].start);		total_trim_size += real_trim_memory(0, range[0].start);
	/* check the holes */
			/* Check the holes: */
	for (i = 0; i < nr_range - 1; i++) {		for (i = 0; i < nr_range - 1; i++) {
	if (range[i].end + 1 < range[i+1].start)		if (range[i].end + 1 < range[i+1].start)
	total_trim_size += real_trim_memory(range[i].end + 1,		total_trim_size += real_trim_memory(range[i].end + 1,
	range[i+1].start);		range[i+1].start);
	}		}
	/* check the top */
			/* Check the top: */
	i = nr_range - 1;		i = nr_range - 1;
	if (range[i].end + 1 < end_pfn)		if (range[i].end + 1 < end_pfn)
	total_trim_size += real_trim_memory(range[i].end + 1,		total_trim_size += real_trim_memory(range[i].end + 1,
	end_pfn);		end_pfn);

	if (total_trim_size) {		if (total_trim_size) {
	printk(KERN_WARNING "WARNING: BIOS bug: CPU MTRRs don't cover"		pr_warning("WARNING: BIOS bug: CPU MTRRs don't cover all of memory, losing %lluMB of RAM.\n", total_trim_size >> 20);
	" all of memory, losing %lluMB of RAM.\n",
	total_trim_size >> 20);

	if (!changed_by_mtrr_cleanup)		if (!changed_by_mtrr_cleanup)
	WARN_ON(1);		WARN_ON(1);

	printk(KERN_INFO "update e820 for mtrr\n");		pr_info("update e820 for mtrr\n");
	update_e820();		update_e820();

	return 1;		return 1;
	@@ -1098,4 +1101,3 @@ int __init mtrr_trim_uncached_memory(unsigned long end_pfn)

	return 0;		return 0;
	}		}