x86: Clean up mtrr/cleanup.c

/*  MTRR (Memory Type Range Register) cleanup

    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

    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

    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

    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

/*

 * MTRR (Memory Type Range Register) cleanup

 *

 *  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

 * 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

 * 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

 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

 */

#include <linux/module.h>

#include <linux/init.h>

#include <linux/pci.h>

#include <linux/smp.h>

#include <linux/cpu.h>

#include <linux/mutex.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/mtrr.h>

#include <asm/uaccess.h>

#include <asm/processor.h>

#include <asm/msr.h>

#include <asm/kvm_para.h>

#include "mtrr.h"

/* should be related to MTRR_VAR_RANGES nums */

/* Should be related to MTRR_VAR_RANGES nums */

#define RANGE_NUM 256

struct res_range {

};

static int __init

add_range(struct res_range *range, int nr_range, unsigned long start,

			      unsigned long end)

add_range(struct res_range *range, int nr_range,

	  unsigned long start, unsigned long end)

{

	/* out of slots */

	/* Out of slots: */

	if (nr_range >= RANGE_NUM)

		return nr_range;

}

static int __init

add_range_with_merge(struct res_range *range, int nr_range, unsigned long start,

			      unsigned long end)

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 */

	/* 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;

		return nr_range;

	}

	/* need to add that */

	/* Need to add it: */

	return add_range(range, nr_range, start, 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++) {

				if (range[i].end == 0)

					break;

};

static struct var_mtrr_range_state __initdata range_state[RANGE_NUM];

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

x86_get_mtrr_mem_range(struct res_range *range, int nr_range,

				 range[i].start, range[i].end + 1);

	}

	/* take out UC ranges */

	/* Take out UC ranges: */

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

		type = range_state[i].type;

		if (type != MTRR_TYPE_UNCACHABLE &&

static unsigned long __init sum_ranges(struct res_range *range, int nr_range)

{

	unsigned long sum;

	unsigned long sum = 0;

	int i;

	sum = 0;

	for (i = 0; i < nr_range; i++)

		sum += range[i].end + 1 - range[i].start;

	range_state[reg].type = type;

}

static void __init

set_var_mtrr_all(unsigned int address_bits)

static void __init set_var_mtrr_all(unsigned int address_bits)

{

	unsigned long basek, sizek;

	unsigned char type;

static unsigned long to_size_factor(unsigned long sizek, char *factorp)

{

	char factor;

	unsigned long base = sizek;

	char factor;

	if (base & ((1<<10) - 1)) {

		/* not MB alignment */

		/* Not MB-aligned: */

		factor = 'K';

	} else if (base & ((1<<20) - 1)) {

		factor = 'M';

		unsigned long max_align, align;

		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)

			max_align = ffs(range_startk) - 1;

		else

			max_align = 32;

		align = fls(range_sizek) - 1;

		if (align > max_align)

			align = max_align;

			char start_factor = 'K', size_factor = 'K';

			unsigned long start_base, size_base;

			start_base = to_size_factor(range_startk,

							 &start_factor),

			size_base = to_size_factor(sizek, &size_factor),

			start_base = to_size_factor(range_startk, &start_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",

				reg, start_base, start_factor,

				size_base, size_factor,

	chunk_sizek = state->chunk_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);

	if ((range_basek > basek) && basek)

		return second_sizek;

	state->range_sizek -= (range_basek - state->range_startk);

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

	}

	state->range_sizek = range_sizek;

	/* try to append some small hole */

	/* Try to append some small hole: */

	range0_basek = state->range_startk;

	range0_sizek = ALIGN(state->range_sizek, chunk_sizek);

	/* no increase */

	/* No increase: */

	if (range0_sizek == state->range_sizek) {

		if (debug_print)

			printk(KERN_DEBUG "rangeX: %016lx - %016lx\n",

		Dprintk("rangeX: %016lx - %016lx\n",

			range0_basek<<10,

			(range0_basek + state->range_sizek)<<10);

		state->reg = range_to_mtrr(state->reg, range0_basek,

		return 0;

	}

	/* only cut back, when it is not the last */

	/* Only cut back when it is not the last: */

	if (sizek) {

		while (range0_basek + range0_sizek > (basek + sizek)) {

			if (range0_sizek >= chunk_sizek)

second_try:

	range_basek = range0_basek + range0_sizek;

	/* one hole in the middle */

	/* One hole in the middle: */

	if (range_basek > basek && range_basek <= (basek + sizek))

		second_sizek = range_basek - basek;

	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 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) &&

		    range0_sizek >= chunk_sizek) {

			range0_sizek -= chunk_sizek;

	}

	if (range0_sizek) {

		if (debug_print)

			printk(KERN_DEBUG "range0: %016lx - %016lx\n",

		Dprintk("range0: %016lx - %016lx\n",

			range0_basek<<10,

			(range0_basek + range0_sizek)<<10);

		state->reg = range_to_mtrr(state->reg, range0_basek,

	}

	if (range0_sizek < state->range_sizek) {

		/* need to handle left over */

		/* Need to handle left over range: */

		range_sizek = state->range_sizek - range0_sizek;

		if (debug_print)

			printk(KERN_DEBUG "range: %016lx - %016lx\n",

		Dprintk("range: %016lx - %016lx\n",

			 range_basek<<10,

			 (range_basek + range_sizek)<<10);

		state->reg = range_to_mtrr(state->reg, range_basek,

				 range_sizek, MTRR_TYPE_WRBACK);

	}

	if (hole_sizek) {

		hole_basek = range_basek - hole_sizek - second_sizek;

		if (debug_print)

			printk(KERN_DEBUG "hole: %016lx - %016lx\n",

		Dprintk("hole: %016lx - %016lx\n",

			 hole_basek<<10,

			 (hole_basek + hole_sizek)<<10);

		state->reg = range_to_mtrr(state->reg, hole_basek,

	basek = base_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) ||

	    (state->range_startk + state->range_sizek == basek)) {

		unsigned long endk = basek + sizek;

		state->range_sizek = endk - state->range_startk;

		return;

	}

	/* Write the range mtrrs */

	/* Write the range mtrrs: */

	if (state->range_sizek != 0)

		second_sizek = range_to_mtrr_with_hole(state, basek, sizek);

	/* Allocate an msr */

	/* Allocate an msr: */

	state->range_startk = basek + 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 int __init parse_mtrr_chunk_size_opt(char *p)

}

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 int __init parse_mtrr_gran_size_opt(char *p)

}

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;

static int __init parse_mtrr_spare_reg(char *arg)

		nr_mtrr_spare_reg = simple_strtoul(arg, NULL, 0);

	return 0;

}

early_param("mtrr_spare_reg_nr", parse_mtrr_spare_reg);

static int __init

		    u64 chunk_size, u64 gran_size)

{

	struct var_mtrr_state var_state;

	int i;

	int num_reg;

	int i;

	var_state.range_startk	= 0;

	var_state.range_sizek	= 0;

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

	/* Write the range etc */

	for (i = 0; i < nr_range; i++)

	/* Write the range: */

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

		set_var_mtrr_range(&var_state, range[i].start,

				   range[i].end - range[i].start + 1);

	}

	/* Write the last range */

	/* Write the last range: */

	if (var_state.range_sizek != 0)

		range_to_mtrr_with_hole(&var_state, 0, 0);

	num_reg = var_state.reg;

	/* Clear out the extra MTRR's */

	/* Clear out the extra MTRR's: */

	while (var_state.reg < num_var_ranges) {

		save_var_mtrr(var_state.reg, 0, 0, 0);

		var_state.reg++;

static void __init print_out_mtrr_range_state(void)

{

	int i;

	char start_factor = 'K', size_factor = 'K';

	unsigned long start_base, size_base;

	mtrr_type type;

	int i;

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

	int i;

	mtrr_type type;

	unsigned long size;

	/* extra one for all 0 */

	/* Extra one for all 0: */

	int num[MTRR_NUM_TYPES + 1];

	/* check entries number */

	/* Check entries number: */

	memset(num, 0, sizeof(num));

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

		type = range_state[i].type;

		num[type]++;

	}

	/* check if we got UC entries */

	/* Check if we got UC entries: */

	if (!num[MTRR_TYPE_UNCACHABLE])

		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] !=

	    num_var_ranges - num[MTRR_NUM_TYPES])

		return 0;

}

static unsigned long __initdata range_sums;

static void __init mtrr_calc_range_state(u64 chunk_size, u64 gran_size,

					 unsigned long extra_remove_base,

					 unsigned long extra_remove_size,

					 int i)

static void __init

mtrr_calc_range_state(u64 chunk_size, u64 gran_size,

		      unsigned long x_remove_base,

		      unsigned long x_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;

	static int nr_range_new;

	int num_reg;

	/* convert ranges to var ranges state */

	num_reg = x86_setup_var_mtrrs(range, nr_range,

						chunk_size, gran_size);

	/* 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 */

	/* 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);

				x_remove_base, x_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].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;

	} else {

		result[i].lose_cover_sizek = (range_sums - range_sums_new) << PSHIFT;

	}

	/* double check it */

	/* Double check it: */

	if (!result[i].bad && !result[i].lose_cover_sizek) {

		if (nr_range_new != nr_range ||

			memcmp(range, range_new, sizeof(range)))

		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;

	}

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

		min_loss_pfn[num_reg] = range_sums - range_sums_new;

}

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;

	char gran_factor, chunk_factor, lose_factor;

	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",

	pr_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",

	pr_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;

	int i;

	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])

	return index_good;

}

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;

	mtrr_type type;

	u64 chunk_size, gran_size;

	mtrr_type type;

	int index_good;

	int i;

	if (!is_cpu(INTEL) || enable_mtrr_cleanup < 1)

		return 0;

	rdmsr(MSR_MTRRdefType, def, dummy);

	def &= 0xff;

	if (def != MTRR_TYPE_UNCACHABLE)

		return 0;

	/* get it and store it aside */

	/* 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].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())

		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");

	print_out_mtrr_range_state();

	memset(range, 0, sizeof(range));

	extra_remove_size = 0;

	extra_remove_base = 1 << (32 - PAGE_SHIFT);

	x_remove_size = 0;

	x_remove_base = 1 << (32 - PAGE_SHIFT);

	if (mtrr_tom2)

		extra_remove_size =

			(mtrr_tom2 >> PAGE_SHIFT) - extra_remove_base;

	nr_range = x86_get_mtrr_mem_range(range, 0, extra_remove_base,

					  extra_remove_size);

		x_remove_size = (mtrr_tom2 >> PAGE_SHIFT) - x_remove_base;

	nr_range = x86_get_mtrr_mem_range(range, 0, x_remove_base, x_remove_size);

	/*

	 * [0, 1M) should always be coverred by var mtrr with WB

	 * and fixed mtrrs should take effective before var mtrr for it

	 * [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,

					(1ULL<<(20 - PAGE_SHIFT)) - 1);

	/* sort the ranges */

	/* Sort the ranges: */

	sort(range, nr_range, sizeof(struct res_range), cmp_range, NULL);

	range_sums = sum_ranges(range, nr_range);

	if (mtrr_chunk_size && mtrr_gran_size) {

		i = 0;

		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);

				continue;

			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) {

				mtrr_print_out_one_result(i);

				printk(KERN_INFO "\n");

		}

	}

	/* try to find the optimal index */

	/* Try to find the optimal index: */

	index_good = mtrr_search_optimal_index();

	if (index_good != -1) {

		i = index_good;

		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 <<= 10;

		gran_size = result[i].gran_sizek;

		return 0;

	if (boot_cpu_data.x86 < 0xf || boot_cpu_data.x86 > 0x11)

		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)

		return 0;

	/*

	return 0;

}

static u64 __init real_trim_memory(unsigned long start_pfn,

				   unsigned long limit_pfn)

static u64 __init

real_trim_memory(unsigned long start_pfn, unsigned long limit_pfn)

{