[thirdparty/linux.git] / arch / x86 / mm / memtest.c

#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/types.h>
#include <linux/mm.h>
#include <linux/smp.h>
#include <linux/init.h>
#include <linux/pfn.h>

#include <asm/e820.h>

static u64 patterns[] __initdata = {
	0,
	0xffffffffffffffffULL,
	0x5555555555555555ULL,
	0xaaaaaaaaaaaaaaaaULL,
};

static void __init memtest(unsigned long start_phys, unsigned long size,
			   u64 pattern)
{
	unsigned long i;
	u64 *start;
	unsigned long start_bad;
	unsigned long last_bad;
	unsigned long start_phys_aligned;
	unsigned long count;
	unsigned long incr;

	incr = sizeof(pattern);
	start_phys_aligned = ALIGN(start_phys, incr);
	count = (size - (start_phys_aligned - start_phys))/incr;
	start = __va(start_phys_aligned);
	start_bad = 0;
	last_bad = 0;

	for (i = 0; i < count; i++)
		start[i] = pattern;
	for (i = 0; i < count; i++, start++, start_phys_aligned += incr) {
		if (*start != pattern) {
			if (start_phys_aligned == last_bad + incr) {
				last_bad += incr;
			} else {
				if (start_bad) {
					printk(KERN_CONT "\n  %016llx bad mem addr %010lx - %010lx reserved",
					       (unsigned long long) pattern,
					       start_bad, last_bad + incr);
					reserve_early(start_bad, last_bad + incr, "BAD RAM");
				}
				start_bad = last_bad = start_phys_aligned;
			}
		}
	}
	if (start_bad) {
		printk(KERN_CONT "\n  %016llx bad mem addr %010lx - %010lx reserved",
		       (unsigned long long) pattern, start_bad,
		       last_bad + incr);
		reserve_early(start_bad, last_bad + incr, "BAD RAM");
	}
}

/* default is disabled */
static int memtest_pattern __initdata;

static int __init parse_memtest(char *arg)
{
	if (arg)
		memtest_pattern = simple_strtoul(arg, NULL, 0);
	return 0;
}

early_param("memtest", parse_memtest);

void __init early_memtest(unsigned long start, unsigned long end)
{
	u64 t_start, t_size;
	unsigned int i;
	u64 pattern;

	if (!memtest_pattern)
		return;

	printk(KERN_INFO "early_memtest: pattern num %d", memtest_pattern);
	for (i = 0; i < memtest_pattern; i++) {
		unsigned int idx = i % ARRAY_SIZE(patterns);
		pattern = patterns[idx];
		t_start = start;
		t_size = 0;
		while (t_start < end) {
			t_start = find_e820_area_size(t_start, &t_size, 1);

			/* done ? */
			if (t_start >= end)
				break;
			if (t_start + t_size > end)
				t_size = end - t_start;

			printk(KERN_CONT "\n  %010llx - %010llx pattern %d",
			       (unsigned long long)t_start,
			       (unsigned long long)t_start + t_size, idx);

			memtest(t_start, t_size, pattern);

			t_start += t_size;
		}
	}
	printk(KERN_CONT "\n");
}
Commit	Line	Data
1f067167 YL	1	#include <linux/kernel.h>
	2	#include <linux/errno.h>
	3	#include <linux/string.h>
	4	#include <linux/types.h>
	5	#include <linux/mm.h>
	6	#include <linux/smp.h>
	7	#include <linux/init.h>
	8	#include <linux/pfn.h>
	9
	10	#include <asm/e820.h>
	11
6d74171b AH	12	static u64 patterns[] __initdata = {
	13	0,
	14	0xffffffffffffffffULL,
	15	0x5555555555555555ULL,
	16	0xaaaaaaaaaaaaaaaaULL,
	17	};
40823f73	18
1f067167	19	static void __init memtest(unsigned long start_phys, unsigned long size,
6d74171b	20	u64 pattern)
1f067167 YL	21	{
1f067167 YL	22	unsigned long i;
6d74171b	23	u64 *start;
1f067167 YL	24	unsigned long start_bad;
1f067167 YL	25	unsigned long last_bad;
1f067167 YL	26	unsigned long start_phys_aligned;
	27	unsigned long count;
	28	unsigned long incr;
	29
6d74171b	30	incr = sizeof(pattern);
1f067167 YL	31	start_phys_aligned = ALIGN(start_phys, incr);
	32	count = (size - (start_phys_aligned - start_phys))/incr;
	33	start = __va(start_phys_aligned);
	34	start_bad = 0;
	35	last_bad = 0;
	36
	37	for (i = 0; i < count; i++)
6d74171b	38	start[i] = pattern;
1f067167	39	for (i = 0; i < count; i++, start++, start_phys_aligned += incr) {
6d74171b	40	if (*start != pattern) {
1f067167 YL	41	if (start_phys_aligned == last_bad + incr) {
	42	last_bad += incr;
	43	} else {
	44	if (start_bad) {
6d74171b AH	45	printk(KERN_CONT "\n %016llx bad mem addr %010lx - %010lx reserved",
	46	(unsigned long long) pattern,
	47	start_bad, last_bad + incr);
2cb0ebee	48	reserve_early(start_bad, last_bad + incr, "BAD RAM");
1f067167 YL	49	}
	50	start_bad = last_bad = start_phys_aligned;
	51	}
	52	}
	53	}
	54	if (start_bad) {
6d74171b AH	55	printk(KERN_CONT "\n %016llx bad mem addr %010lx - %010lx reserved",
	56	(unsigned long long) pattern, start_bad,
	57	last_bad + incr);
2cb0ebee	58	reserve_early(start_bad, last_bad + incr, "BAD RAM");
1f067167	59	}
1f067167 YL	60	}
	61
	62	/* default is disabled */
	63	static int memtest_pattern __initdata;
	64
	65	static int __init parse_memtest(char *arg)
	66	{
	67	if (arg)
	68	memtest_pattern = simple_strtoul(arg, NULL, 0);
	69	return 0;
	70	}
	71
	72	early_param("memtest", parse_memtest);
	73
	74	void __init early_memtest(unsigned long start, unsigned long end)
	75	{
	76	u64 t_start, t_size;
6d74171b AH	77	unsigned int i;
6d74171b AH	78	u64 pattern;
1f067167 YL	79
	80	if (!memtest_pattern)
	81	return;
	82
	83	printk(KERN_INFO "early_memtest: pattern num %d", memtest_pattern);
6d74171b AH	84	for (i = 0; i < memtest_pattern; i++) {
	85	unsigned int idx = i % ARRAY_SIZE(patterns);
	86	pattern = patterns[idx];
1f067167 YL	87	t_start = start;
	88	t_size = 0;
	89	while (t_start < end) {
	90	t_start = find_e820_area_size(t_start, &t_size, 1);
	91
	92	/* done ? */
	93	if (t_start >= end)
	94	break;
	95	if (t_start + t_size > end)
	96	t_size = end - t_start;
	97
	98	printk(KERN_CONT "\n %010llx - %010llx pattern %d",
40823f73	99	(unsigned long long)t_start,
6d74171b	100	(unsigned long long)t_start + t_size, idx);
1f067167 YL	101
	102	memtest(t_start, t_size, pattern);
	103
	104	t_start += t_size;
	105	}
	106	}
	107	printk(KERN_CONT "\n");
	108	}