setup.c 31.3 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
/*
 *  Copyright (C) 1995  Linus Torvalds
 *
 *  Support of BIGMEM added by Gerhard Wichert, Siemens AG, July 1999
 *
 *  Memory region support
 *	David Parsons <orc@pell.chi.il.us>, July-August 1999
 *
 *  Added E820 sanitization routine (removes overlapping memory regions);
 *  Brian Moyle <bmoyle@mvista.com>, February 2001
 *
 * Moved CPU detection code to cpu/${cpu}.c
 *    Patrick Mochel <mochel@osdl.org>, March 2002
 *
 *  Provisions for empty E820 memory regions (reported by certain BIOSes).
 *  Alex Achenbach <xela@slit.de>, December 2002.
 *
 */

/*
 * This file handles the architecture-dependent parts of initialization
 */

#include <linux/sched.h>
#include <linux/mm.h>
26
#include <linux/mmzone.h>
27
#include <linux/screen_info.h>
L
Linus Torvalds 已提交
28 29
#include <linux/ioport.h>
#include <linux/acpi.h>
F
Feng Tang 已提交
30
#include <linux/sfi.h>
L
Linus Torvalds 已提交
31 32 33
#include <linux/apm_bios.h>
#include <linux/initrd.h>
#include <linux/bootmem.h>
34
#include <linux/memblock.h>
L
Linus Torvalds 已提交
35 36 37 38 39 40 41 42
#include <linux/seq_file.h>
#include <linux/console.h>
#include <linux/root_dev.h>
#include <linux/highmem.h>
#include <linux/module.h>
#include <linux/efi.h>
#include <linux/init.h>
#include <linux/edd.h>
43
#include <linux/iscsi_ibft.h>
L
Linus Torvalds 已提交
44
#include <linux/nodemask.h>
45
#include <linux/kexec.h>
46
#include <linux/dmi.h>
D
Dave Hansen 已提交
47
#include <linux/pfn.h>
48
#include <linux/pci.h>
49
#include <asm/pci-direct.h>
50
#include <linux/init_ohci1394_dma.h>
51
#include <linux/kvm_para.h>
52
#include <linux/dma-contiguous.h>
53

54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/stddef.h>
#include <linux/unistd.h>
#include <linux/ptrace.h>
#include <linux/user.h>
#include <linux/delay.h>

#include <linux/kallsyms.h>
#include <linux/cpufreq.h>
#include <linux/dma-mapping.h>
#include <linux/ctype.h>
#include <linux/uaccess.h>

#include <linux/percpu.h>
#include <linux/crash_dump.h>
70
#include <linux/tboot.h>
71
#include <linux/jiffies.h>
72

L
Linus Torvalds 已提交
73
#include <video/edid.h>
74

75
#include <asm/mtrr.h>
76
#include <asm/apic.h>
77
#include <asm/realmode.h>
L
Linus Torvalds 已提交
78 79 80
#include <asm/e820.h>
#include <asm/mpspec.h>
#include <asm/setup.h>
Y
Yinghai Lu 已提交
81
#include <asm/efi.h>
I
Ingo Molnar 已提交
82 83
#include <asm/timer.h>
#include <asm/i8259.h>
L
Linus Torvalds 已提交
84 85 86
#include <asm/sections.h>
#include <asm/io_apic.h>
#include <asm/ist.h>
87
#include <asm/setup_arch.h>
88
#include <asm/bios_ebda.h>
B
Bernhard Walle 已提交
89
#include <asm/cacheflush.h>
90
#include <asm/processor.h>
Y
Yinghai Lu 已提交
91
#include <asm/bugs.h>
L
Linus Torvalds 已提交
92

93
#include <asm/vsyscall.h>
94
#include <asm/cpu.h>
95 96
#include <asm/desc.h>
#include <asm/dma.h>
97
#include <asm/iommu.h>
98
#include <asm/gart.h>
99 100 101 102
#include <asm/mmu_context.h>
#include <asm/proto.h>

#include <asm/paravirt.h>
103
#include <asm/hypervisor.h>
104
#include <asm/olpc_ofw.h>
105 106 107 108

#include <asm/percpu.h>
#include <asm/topology.h>
#include <asm/apicdef.h>
109
#include <asm/amd_nb.h>
110
#include <asm/mce.h>
111
#include <asm/alternative.h>
112
#include <asm/prom.h>
113

114
/*
115 116 117 118 119
 * max_low_pfn_mapped: highest direct mapped pfn under 4GB
 * max_pfn_mapped:     highest direct mapped pfn over 4GB
 *
 * The direct mapping only covers E820_RAM regions, so the ranges and gaps are
 * represented by pfn_mapped
120 121 122 123
 */
unsigned long max_low_pfn_mapped;
unsigned long max_pfn_mapped;

124
#ifdef CONFIG_DMI
125
RESERVE_BRK(dmi_alloc, 65536);
126
#endif
127

I
Ingo Molnar 已提交
128

129 130 131
static __initdata unsigned long _brk_start = (unsigned long)__brk_base;
unsigned long _brk_end = (unsigned long)__brk_base;

I
Ingo Molnar 已提交
132 133 134 135 136 137
#ifdef CONFIG_X86_64
int default_cpu_present_to_apicid(int mps_cpu)
{
	return __default_cpu_present_to_apicid(mps_cpu);
}

T
Thomas Gleixner 已提交
138
int default_check_phys_apicid_present(int phys_apicid)
I
Ingo Molnar 已提交
139
{
T
Thomas Gleixner 已提交
140
	return __default_check_phys_apicid_present(phys_apicid);
I
Ingo Molnar 已提交
141 142 143
}
#endif

144 145
struct boot_params boot_params;

L
Linus Torvalds 已提交
146 147 148
/*
 * Machine setup..
 */
149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
static struct resource data_resource = {
	.name	= "Kernel data",
	.start	= 0,
	.end	= 0,
	.flags	= IORESOURCE_BUSY | IORESOURCE_MEM
};

static struct resource code_resource = {
	.name	= "Kernel code",
	.start	= 0,
	.end	= 0,
	.flags	= IORESOURCE_BUSY | IORESOURCE_MEM
};

static struct resource bss_resource = {
	.name	= "Kernel bss",
	.start	= 0,
	.end	= 0,
	.flags	= IORESOURCE_BUSY | IORESOURCE_MEM
};

170 171

#ifdef CONFIG_X86_32
L
Linus Torvalds 已提交
172
/* cpu data as detected by the assembly code in head.S */
173
struct cpuinfo_x86 new_cpu_data = {
174 175
	.wp_works_ok = -1,
};
L
Linus Torvalds 已提交
176
/* common cpu data for all cpus */
177 178 179
struct cpuinfo_x86 boot_cpu_data __read_mostly = {
	.wp_works_ok = -1,
};
180
EXPORT_SYMBOL(boot_cpu_data);
L
Linus Torvalds 已提交
181

182 183
unsigned int def_to_bigsmp;

L
Linus Torvalds 已提交
184 185 186 187 188
/* for MCA, but anyone else can use it if they want */
unsigned int machine_id;
unsigned int machine_submodel_id;
unsigned int BIOS_revision;

189 190 191 192 193 194 195 196 197 198 199 200
struct apm_info apm_info;
EXPORT_SYMBOL(apm_info);

#if defined(CONFIG_X86_SPEEDSTEP_SMI) || \
	defined(CONFIG_X86_SPEEDSTEP_SMI_MODULE)
struct ist_info ist_info;
EXPORT_SYMBOL(ist_info);
#else
struct ist_info ist_info;
#endif

#else
201 202 203
struct cpuinfo_x86 boot_cpu_data __read_mostly = {
	.x86_phys_bits = MAX_PHYSMEM_BITS,
};
204 205 206 207 208
EXPORT_SYMBOL(boot_cpu_data);
#endif


#if !defined(CONFIG_X86_PAE) || defined(CONFIG_X86_64)
209
__visible unsigned long mmu_cr4_features;
210
#else
211
__visible unsigned long mmu_cr4_features = X86_CR4_PAE;
212 213
#endif

214 215
/* Boot loader ID and version as integers, for the benefit of proc_dointvec */
int bootloader_type, bootloader_version;
L
Linus Torvalds 已提交
216 217 218 219 220

/*
 * Setup options
 */
struct screen_info screen_info;
221
EXPORT_SYMBOL(screen_info);
L
Linus Torvalds 已提交
222
struct edid_info edid_info;
223
EXPORT_SYMBOL_GPL(edid_info);
L
Linus Torvalds 已提交
224 225 226

extern int root_mountflags;

227
unsigned long saved_video_mode;
L
Linus Torvalds 已提交
228

229
#define RAMDISK_IMAGE_START_MASK	0x07FF
L
Linus Torvalds 已提交
230
#define RAMDISK_PROMPT_FLAG		0x8000
231
#define RAMDISK_LOAD_FLAG		0x4000
L
Linus Torvalds 已提交
232

233
static char __initdata command_line[COMMAND_LINE_SIZE];
234 235 236
#ifdef CONFIG_CMDLINE_BOOL
static char __initdata builtin_cmdline[COMMAND_LINE_SIZE] = CONFIG_CMDLINE;
#endif
L
Linus Torvalds 已提交
237 238 239 240 241 242 243 244 245 246 247

#if defined(CONFIG_EDD) || defined(CONFIG_EDD_MODULE)
struct edd edd;
#ifdef CONFIG_EDD_MODULE
EXPORT_SYMBOL(edd);
#endif
/**
 * copy_edd() - Copy the BIOS EDD information
 *              from boot_params into a safe place.
 *
 */
248
static inline void __init copy_edd(void)
L
Linus Torvalds 已提交
249
{
250 251 252 253 254
     memcpy(edd.mbr_signature, boot_params.edd_mbr_sig_buffer,
	    sizeof(edd.mbr_signature));
     memcpy(edd.edd_info, boot_params.eddbuf, sizeof(edd.edd_info));
     edd.mbr_signature_nr = boot_params.edd_mbr_sig_buf_entries;
     edd.edd_info_nr = boot_params.eddbuf_entries;
L
Linus Torvalds 已提交
255 256
}
#else
257
static inline void __init copy_edd(void)
L
Linus Torvalds 已提交
258 259 260 261
{
}
#endif

262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280
void * __init extend_brk(size_t size, size_t align)
{
	size_t mask = align - 1;
	void *ret;

	BUG_ON(_brk_start == 0);
	BUG_ON(align & mask);

	_brk_end = (_brk_end + mask) & ~mask;
	BUG_ON((char *)(_brk_end + size) > __brk_limit);

	ret = (void *)_brk_end;
	_brk_end += size;

	memset(ret, 0, size);

	return ret;
}

281
#ifdef CONFIG_X86_32
282
static void __init cleanup_highmap(void)
283 284
{
}
285 286
#endif

287 288 289
static void __init reserve_brk(void)
{
	if (_brk_end > _brk_start)
290 291
		memblock_reserve(__pa_symbol(_brk_start),
				 _brk_end - _brk_start);
292 293 294 295 296 297

	/* Mark brk area as locked down and no longer taking any
	   new allocations */
	_brk_start = 0;
}

298 299
u64 relocated_ramdisk;

300 301
#ifdef CONFIG_BLK_DEV_INITRD

Y
Yinghai Lu 已提交
302 303 304 305
static u64 __init get_ramdisk_image(void)
{
	u64 ramdisk_image = boot_params.hdr.ramdisk_image;

306 307
	ramdisk_image |= (u64)boot_params.ext_ramdisk_image << 32;

Y
Yinghai Lu 已提交
308 309 310 311 312 313
	return ramdisk_image;
}
static u64 __init get_ramdisk_size(void)
{
	u64 ramdisk_size = boot_params.hdr.ramdisk_size;

314 315
	ramdisk_size |= (u64)boot_params.ext_ramdisk_size << 32;

Y
Yinghai Lu 已提交
316 317 318
	return ramdisk_size;
}

319 320
#define MAX_MAP_CHUNK	(NR_FIX_BTMAPS << PAGE_SHIFT)
static void __init relocate_initrd(void)
321
{
322
	/* Assume only end is not page aligned */
Y
Yinghai Lu 已提交
323 324
	u64 ramdisk_image = get_ramdisk_image();
	u64 ramdisk_size  = get_ramdisk_size();
325
	u64 area_size     = PAGE_ALIGN(ramdisk_size);
326 327
	unsigned long slop, clen, mapaddr;
	char *p, *q;
328

329
	/* We need to move the initrd down into directly mapped mem */
330 331
	relocated_ramdisk = memblock_find_in_range(0, PFN_PHYS(max_pfn_mapped),
						   area_size, PAGE_SIZE);
332

333
	if (!relocated_ramdisk)
334
		panic("Cannot find place for new RAMDISK of size %lld\n",
335
		      ramdisk_size);
336

337
	/* Note: this includes all the mem currently occupied by
338
	   the initrd, we rely on that fact to keep the data intact. */
339 340
	memblock_reserve(relocated_ramdisk, area_size);
	initrd_start = relocated_ramdisk + PAGE_OFFSET;
341
	initrd_end   = initrd_start + ramdisk_size;
342
	printk(KERN_INFO "Allocated new RAMDISK: [mem %#010llx-%#010llx]\n",
343
	       relocated_ramdisk, relocated_ramdisk + ramdisk_size - 1);
344 345 346

	q = (char *)initrd_start;

347
	/* Copy the initrd */
348 349 350 351 352 353
	while (ramdisk_size) {
		slop = ramdisk_image & ~PAGE_MASK;
		clen = ramdisk_size;
		if (clen > MAX_MAP_CHUNK-slop)
			clen = MAX_MAP_CHUNK-slop;
		mapaddr = ramdisk_image & PAGE_MASK;
354
		p = early_memremap(mapaddr, clen+slop);
355
		memcpy(q, p+slop, clen);
356
		early_iounmap(p, clen+slop);
357 358 359 360
		q += clen;
		ramdisk_image += clen;
		ramdisk_size  -= clen;
	}
361

Y
Yinghai Lu 已提交
362 363
	ramdisk_image = get_ramdisk_image();
	ramdisk_size  = get_ramdisk_size();
364 365
	printk(KERN_INFO "Move RAMDISK from [mem %#010llx-%#010llx] to"
		" [mem %#010llx-%#010llx]\n",
366
		ramdisk_image, ramdisk_image + ramdisk_size - 1,
367
		relocated_ramdisk, relocated_ramdisk + ramdisk_size - 1);
368
}
Y
Yinghai Lu 已提交
369

370 371 372
static void __init early_reserve_initrd(void)
{
	/* Assume only end is not page aligned */
Y
Yinghai Lu 已提交
373 374
	u64 ramdisk_image = get_ramdisk_image();
	u64 ramdisk_size  = get_ramdisk_size();
375 376 377 378 379 380 381 382
	u64 ramdisk_end   = PAGE_ALIGN(ramdisk_image + ramdisk_size);

	if (!boot_params.hdr.type_of_loader ||
	    !ramdisk_image || !ramdisk_size)
		return;		/* No initrd provided by bootloader */

	memblock_reserve(ramdisk_image, ramdisk_end - ramdisk_image);
}
383 384
static void __init reserve_initrd(void)
{
385
	/* Assume only end is not page aligned */
Y
Yinghai Lu 已提交
386 387
	u64 ramdisk_image = get_ramdisk_image();
	u64 ramdisk_size  = get_ramdisk_size();
388
	u64 ramdisk_end   = PAGE_ALIGN(ramdisk_image + ramdisk_size);
389
	u64 mapped_size;
390 391 392 393 394 395 396

	if (!boot_params.hdr.type_of_loader ||
	    !ramdisk_image || !ramdisk_size)
		return;		/* No initrd provided by bootloader */

	initrd_start = 0;

Y
Yinghai Lu 已提交
397
	mapped_size = memblock_mem_size(max_pfn_mapped);
398
	if (ramdisk_size >= (mapped_size>>1))
399 400
		panic("initrd too large to handle, "
		       "disabling initrd (%lld needed, %lld available)\n",
401
		       ramdisk_size, mapped_size>>1);
402

403 404
	printk(KERN_INFO "RAMDISK: [mem %#010llx-%#010llx]\n", ramdisk_image,
			ramdisk_end - 1);
405

406
	if (pfn_range_is_mapped(PFN_DOWN(ramdisk_image),
407 408
				PFN_DOWN(ramdisk_end))) {
		/* All are mapped, easy case */
409 410 411 412 413 414
		initrd_start = ramdisk_image + PAGE_OFFSET;
		initrd_end = initrd_start + ramdisk_size;
		return;
	}

	relocate_initrd();
415

416
	memblock_free(ramdisk_image, ramdisk_end - ramdisk_image);
417
}
Y
Yinghai Lu 已提交
418
#else
419 420 421
static void __init early_reserve_initrd(void)
{
}
422
static void __init reserve_initrd(void)
Y
Yinghai Lu 已提交
423 424
{
}
425 426
#endif /* CONFIG_BLK_DEV_INITRD */

427
static void __init parse_setup_data(void)
428 429
{
	struct setup_data *data;
430
	u64 pa_data, pa_next;
431 432 433

	pa_data = boot_params.hdr.setup_data;
	while (pa_data) {
434
		u32 data_len, map_len, data_type;
435 436 437 438 439

		map_len = max(PAGE_SIZE - (pa_data & ~PAGE_MASK),
			      (u64)sizeof(struct setup_data));
		data = early_memremap(pa_data, map_len);
		data_len = data->len + sizeof(struct setup_data);
440 441 442
		data_type = data->type;
		pa_next = data->next;
		early_iounmap(data, map_len);
443

444
		switch (data_type) {
445
		case SETUP_E820_EXT:
446
			parse_e820_ext(pa_data, data_len);
447
			break;
448 449
		case SETUP_DTB:
			add_dtb(pa_data);
450
			break;
451 452 453
		case SETUP_EFI:
			parse_efi_setup(pa_data, data_len);
			break;
454 455 456
		default:
			break;
		}
457
		pa_data = pa_next;
458 459 460
	}
}

461
static void __init e820_reserve_setup_data(void)
462 463 464
{
	struct setup_data *data;
	u64 pa_data;
465
	int found = 0;
466 467 468

	pa_data = boot_params.hdr.setup_data;
	while (pa_data) {
469
		data = early_memremap(pa_data, sizeof(*data));
470 471
		e820_update_range(pa_data, sizeof(*data)+data->len,
			 E820_RAM, E820_RESERVED_KERN);
472
		found = 1;
473 474 475
		pa_data = data->next;
		early_iounmap(data, sizeof(*data));
	}
476 477 478
	if (!found)
		return;

479
	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
480
	memcpy(&e820_saved, &e820, sizeof(struct e820map));
481 482 483 484
	printk(KERN_INFO "extended physical RAM map:\n");
	e820_print_map("reserve setup_data");
}

485
static void __init memblock_x86_reserve_range_setup_data(void)
486 487 488 489 490 491
{
	struct setup_data *data;
	u64 pa_data;

	pa_data = boot_params.hdr.setup_data;
	while (pa_data) {
492
		data = early_memremap(pa_data, sizeof(*data));
493
		memblock_reserve(pa_data, sizeof(*data) + data->len);
494 495 496 497 498
		pa_data = data->next;
		early_iounmap(data, sizeof(*data));
	}
}

499 500 501 502 503
/*
 * --------- Crashkernel reservation ------------------------------
 */

#ifdef CONFIG_KEXEC
504

505 506 507
/*
 * Keep the crash kernel below this limit.  On 32 bits earlier kernels
 * would limit the kernel to the low 512 MiB due to mapping restrictions.
508
 * On 64bit, old kexec-tools need to under 896MiB.
509 510
 */
#ifdef CONFIG_X86_32
511 512
# define CRASH_KERNEL_ADDR_LOW_MAX	(512 << 20)
# define CRASH_KERNEL_ADDR_HIGH_MAX	(512 << 20)
513
#else
514 515
# define CRASH_KERNEL_ADDR_LOW_MAX	(896UL<<20)
# define CRASH_KERNEL_ADDR_HIGH_MAX	MAXMEM
516 517
#endif

518 519 520 521 522 523 524
static void __init reserve_crashkernel_low(void)
{
#ifdef CONFIG_X86_64
	const unsigned long long alignment = 16<<20;	/* 16M */
	unsigned long long low_base = 0, low_size = 0;
	unsigned long total_low_mem;
	unsigned long long base;
525
	bool auto_set = false;
526 527 528
	int ret;

	total_low_mem = memblock_mem_size(1UL<<(32-PAGE_SHIFT));
529
	/* crashkernel=Y,low */
530 531
	ret = parse_crashkernel_low(boot_command_line, total_low_mem,
						&low_size, &base);
532 533 534 535 536 537 538 539 540 541 542
	if (ret != 0) {
		/*
		 * two parts from lib/swiotlb.c:
		 *	swiotlb size: user specified with swiotlb= or default.
		 *	swiotlb overflow buffer: now is hardcoded to 32k.
		 *		We round it to 8M for other buffers that
		 *		may need to stay low too.
		 */
		low_size = swiotlb_size_or_default() + (8UL<<20);
		auto_set = true;
	} else {
543
		/* passed with crashkernel=0,low ? */
544 545 546
		if (!low_size)
			return;
	}
547 548 549 550 551

	low_base = memblock_find_in_range(low_size, (1ULL<<32),
					low_size, alignment);

	if (!low_base) {
552 553
		if (!auto_set)
			pr_info("crashkernel low reservation failed - No suitable area found.\n");
554 555 556 557 558 559 560 561 562 563 564 565

		return;
	}

	memblock_reserve(low_base, low_size);
	pr_info("Reserving %ldMB of low memory at %ldMB for crashkernel (System low RAM: %ldMB)\n",
			(unsigned long)(low_size >> 20),
			(unsigned long)(low_base >> 20),
			(unsigned long)(total_low_mem >> 20));
	crashk_low_res.start = low_base;
	crashk_low_res.end   = low_base + low_size - 1;
	insert_resource(&iomem_resource, &crashk_low_res);
566
#endif
567
}
568

569
static void __init reserve_crashkernel(void)
570
{
571
	const unsigned long long alignment = 16<<20;	/* 16M */
572 573
	unsigned long long total_mem;
	unsigned long long crash_size, crash_base;
574
	bool high = false;
575 576
	int ret;

577
	total_mem = memblock_phys_mem_size();
578

579
	/* crashkernel=XM */
580 581
	ret = parse_crashkernel(boot_command_line, total_mem,
			&crash_size, &crash_base);
582
	if (ret != 0 || crash_size <= 0) {
583
		/* crashkernel=X,high */
584 585 586 587 588 589
		ret = parse_crashkernel_high(boot_command_line, total_mem,
				&crash_size, &crash_base);
		if (ret != 0 || crash_size <= 0)
			return;
		high = true;
	}
590 591 592

	/* 0 means: find the address automatically */
	if (crash_base <= 0) {
593
		/*
594
		 *  kexec want bzImage is below CRASH_KERNEL_ADDR_MAX
595 596
		 */
		crash_base = memblock_find_in_range(alignment,
597 598 599
					high ? CRASH_KERNEL_ADDR_HIGH_MAX :
					       CRASH_KERNEL_ADDR_LOW_MAX,
					crash_size, alignment);
600

T
Tejun Heo 已提交
601
		if (!crash_base) {
602
			pr_info("crashkernel reservation failed - No suitable area found.\n");
603 604
			return;
		}
605

606
	} else {
607 608
		unsigned long long start;

609 610
		start = memblock_find_in_range(crash_base,
				 crash_base + crash_size, crash_size, 1<<20);
611 612
		if (start != crash_base) {
			pr_info("crashkernel reservation failed - memory is in use.\n");
613 614
			return;
		}
615
	}
616
	memblock_reserve(crash_base, crash_size);
617

618 619 620 621 622
	printk(KERN_INFO "Reserving %ldMB of memory at %ldMB "
			"for crashkernel (System RAM: %ldMB)\n",
			(unsigned long)(crash_size >> 20),
			(unsigned long)(crash_base >> 20),
			(unsigned long)(total_mem >> 20));
623

624 625 626
	crashk_res.start = crash_base;
	crashk_res.end   = crash_base + crash_size - 1;
	insert_resource(&iomem_resource, &crashk_res);
627 628 629

	if (crash_base >= (1ULL<<32))
		reserve_crashkernel_low();
630 631
}
#else
632
static void __init reserve_crashkernel(void)
633 634 635 636
{
}
#endif

637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659
static struct resource standard_io_resources[] = {
	{ .name = "dma1", .start = 0x00, .end = 0x1f,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "pic1", .start = 0x20, .end = 0x21,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "timer0", .start = 0x40, .end = 0x43,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "timer1", .start = 0x50, .end = 0x53,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "keyboard", .start = 0x60, .end = 0x60,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "keyboard", .start = 0x64, .end = 0x64,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "dma page reg", .start = 0x80, .end = 0x8f,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "pic2", .start = 0xa0, .end = 0xa1,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "dma2", .start = 0xc0, .end = 0xdf,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "fpu", .start = 0xf0, .end = 0xff,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO }
};

660
void __init reserve_standard_io_resources(void)
661 662 663 664 665 666 667 668 669
{
	int i;

	/* request I/O space for devices used on all i[345]86 PCs */
	for (i = 0; i < ARRAY_SIZE(standard_io_resources); i++)
		request_resource(&ioport_resource, &standard_io_resources[i]);

}

670 671 672 673 674 675 676
static __init void reserve_ibft_region(void)
{
	unsigned long addr, size = 0;

	addr = find_ibft_region(&size);

	if (size)
677
		memblock_reserve(addr, size);
678 679
}

680 681
static bool __init snb_gfx_workaround_needed(void)
{
682
#ifdef CONFIG_PCI
683 684
	int i;
	u16 vendor, devid;
685
	static const __initconst u16 snb_ids[] = {
686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706
		0x0102,
		0x0112,
		0x0122,
		0x0106,
		0x0116,
		0x0126,
		0x010a,
	};

	/* Assume no if something weird is going on with PCI */
	if (!early_pci_allowed())
		return false;

	vendor = read_pci_config_16(0, 2, 0, PCI_VENDOR_ID);
	if (vendor != 0x8086)
		return false;

	devid = read_pci_config_16(0, 2, 0, PCI_DEVICE_ID);
	for (i = 0; i < ARRAY_SIZE(snb_ids); i++)
		if (devid == snb_ids[i])
			return true;
707
#endif
708 709 710 711 712 713 714 715 716 717

	return false;
}

/*
 * Sandy Bridge graphics has trouble with certain ranges, exclude
 * them from allocation.
 */
static void __init trim_snb_memory(void)
{
718
	static const __initconst unsigned long bad_pages[] = {
719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756
		0x20050000,
		0x20110000,
		0x20130000,
		0x20138000,
		0x40004000,
	};
	int i;

	if (!snb_gfx_workaround_needed())
		return;

	printk(KERN_DEBUG "reserving inaccessible SNB gfx pages\n");

	/*
	 * Reserve all memory below the 1 MB mark that has not
	 * already been reserved.
	 */
	memblock_reserve(0, 1<<20);
	
	for (i = 0; i < ARRAY_SIZE(bad_pages); i++) {
		if (memblock_reserve(bad_pages[i], PAGE_SIZE))
			printk(KERN_WARNING "failed to reserve 0x%08lx\n",
			       bad_pages[i]);
	}
}

/*
 * Here we put platform-specific memory range workarounds, i.e.
 * memory known to be corrupt or otherwise in need to be reserved on
 * specific platforms.
 *
 * If this gets used more widely it could use a real dispatch mechanism.
 */
static void __init trim_platform_memory_ranges(void)
{
	trim_snb_memory();
}

757 758 759 760 761 762
static void __init trim_bios_range(void)
{
	/*
	 * A special case is the first 4Kb of memory;
	 * This is a BIOS owned area, not kernel ram, but generally
	 * not listed as such in the E820 table.
763 764 765
	 *
	 * This typically reserves additional memory (64KiB by default)
	 * since some BIOSes are known to corrupt low memory.  See the
766
	 * Kconfig help text for X86_RESERVE_LOW.
767
	 */
768
	e820_update_range(0, PAGE_SIZE, E820_RAM, E820_RESERVED);
769

770 771 772 773 774 775
	/*
	 * special case: Some BIOSen report the PC BIOS
	 * area (640->1Mb) as ram even though it is not.
	 * take them out.
	 */
	e820_remove_range(BIOS_BEGIN, BIOS_END - BIOS_BEGIN, E820_RAM, 1);
776

777 778 779
	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
}

780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800
/* called before trim_bios_range() to spare extra sanitize */
static void __init e820_add_kernel_range(void)
{
	u64 start = __pa_symbol(_text);
	u64 size = __pa_symbol(_end) - start;

	/*
	 * Complain if .text .data and .bss are not marked as E820_RAM and
	 * attempt to fix it by adding the range. We may have a confused BIOS,
	 * or the user may have used memmap=exactmap or memmap=xxM$yyM to
	 * exclude kernel range. If we really are running on top non-RAM,
	 * we will crash later anyways.
	 */
	if (e820_all_mapped(start, start + size, E820_RAM))
		return;

	pr_warn(".text .data .bss are not marked as E820_RAM!\n");
	e820_remove_range(start, size, E820_RAM, 0);
	e820_add_region(start, size, E820_RAM);
}

801 802
static unsigned reserve_low = CONFIG_X86_RESERVE_LOW << 10;

803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824
static int __init parse_reservelow(char *p)
{
	unsigned long long size;

	if (!p)
		return -EINVAL;

	size = memparse(p, &p);

	if (size < 4096)
		size = 4096;

	if (size > 640*1024)
		size = 640*1024;

	reserve_low = size;

	return 0;
}

early_param("reservelow", parse_reservelow);

825 826 827 828 829
static void __init trim_low_memory_range(void)
{
	memblock_reserve(0, ALIGN(reserve_low, PAGE_SIZE));
}
	
830 831 832 833 834 835 836 837 838 839 840 841 842 843
/*
 * Dump out kernel offset information on panic.
 */
static int
dump_kernel_offset(struct notifier_block *self, unsigned long v, void *p)
{
	pr_emerg("Kernel Offset: 0x%lx from 0x%lx "
		 "(relocation range: 0x%lx-0x%lx)\n",
		 (unsigned long)&_text - __START_KERNEL, __START_KERNEL,
		 __START_KERNEL_map, MODULES_VADDR-1);

	return 0;
}

L
Linus Torvalds 已提交
844 845 846 847 848 849 850
/*
 * Determine if we were loaded by an EFI loader.  If so, then we have also been
 * passed the efi memmap, systab, etc., so we should use these data structures
 * for initialization.  Note, the efi init code path is determined by the
 * global efi_enabled. This allows the same kernel image to be used on existing
 * systems (with a traditional BIOS) as well as on EFI systems.
 */
851 852 853 854 855 856
/*
 * setup_arch - architecture-specific boot-time initializations
 *
 * Note: On x86_64, fixmaps are ready for use even before this is called.
 */

L
Linus Torvalds 已提交
857 858
void __init setup_arch(char **cmdline_p)
{
859 860 861
	memblock_reserve(__pa_symbol(_text),
			 (unsigned long)__bss_stop - (unsigned long)_text);

862 863
	early_reserve_initrd();

864 865 866 867 868 869
	/*
	 * At this point everything still needed from the boot loader
	 * or BIOS or kernel text should be early reserved or marked not
	 * RAM in e820. All other memory is free game.
	 */

870
#ifdef CONFIG_X86_32
L
Linus Torvalds 已提交
871
	memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
872 873 874 875 876 877 878 879 880 881

	/*
	 * copy kernel address range established so far and switch
	 * to the proper swapper page table
	 */
	clone_pgd_range(swapper_pg_dir     + KERNEL_PGD_BOUNDARY,
			initial_page_table + KERNEL_PGD_BOUNDARY,
			KERNEL_PGD_PTRS);

	load_cr3(swapper_pg_dir);
882 883 884 885 886 887 888 889 890
	/*
	 * Note: Quark X1000 CPUs advertise PGE incorrectly and require
	 * a cr3 based tlb flush, so the following __flush_tlb_all()
	 * will not flush anything because the cpu quirk which clears
	 * X86_FEATURE_PGE has not been invoked yet. Though due to the
	 * load_cr3() above the TLB has been flushed already. The
	 * quirk is invoked before subsequent calls to __flush_tlb_all()
	 * so proper operation is guaranteed.
	 */
891
	__flush_tlb_all();
892 893 894
#else
	printk(KERN_INFO "Command line: %s\n", boot_command_line);
#endif
L
Linus Torvalds 已提交
895

896 897 898 899
	/*
	 * If we have OLPC OFW, we might end up relocating the fixmap due to
	 * reserve_top(), so do this before touching the ioremap area.
	 */
900 901
	olpc_ofw_detect();

902
	early_trap_init();
903
	early_cpu_init();
904 905
	early_ioremap_init();

906 907
	setup_olpc_ofw_pgd();

908 909 910
	ROOT_DEV = old_decode_dev(boot_params.hdr.root_dev);
	screen_info = boot_params.screen_info;
	edid_info = boot_params.edid_info;
911
#ifdef CONFIG_X86_32
912 913
	apm_info.bios = boot_params.apm_bios_info;
	ist_info = boot_params.ist_info;
914
	if (boot_params.sys_desc_table.length != 0) {
915 916 917
		machine_id = boot_params.sys_desc_table.table[0];
		machine_submodel_id = boot_params.sys_desc_table.table[1];
		BIOS_revision = boot_params.sys_desc_table.table[2];
L
Linus Torvalds 已提交
918
	}
919 920
#endif
	saved_video_mode = boot_params.hdr.vid_mode;
921
	bootloader_type = boot_params.hdr.type_of_loader;
922 923 924 925 926 927
	if ((bootloader_type >> 4) == 0xe) {
		bootloader_type &= 0xf;
		bootloader_type |= (boot_params.hdr.ext_loader_type+0x10) << 4;
	}
	bootloader_version  = bootloader_type & 0xf;
	bootloader_version |= boot_params.hdr.ext_loader_ver << 4;
L
Linus Torvalds 已提交
928 929

#ifdef CONFIG_BLK_DEV_RAM
930 931 932
	rd_image_start = boot_params.hdr.ram_size & RAMDISK_IMAGE_START_MASK;
	rd_prompt = ((boot_params.hdr.ram_size & RAMDISK_PROMPT_FLAG) != 0);
	rd_doload = ((boot_params.hdr.ram_size & RAMDISK_LOAD_FLAG) != 0);
L
Linus Torvalds 已提交
933
#endif
934 935
#ifdef CONFIG_EFI
	if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
936
		     EFI32_LOADER_SIGNATURE, 4)) {
937
		set_bit(EFI_BOOT, &efi.flags);
938
	} else if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
939
		     EFI64_LOADER_SIGNATURE, 4)) {
940 941
		set_bit(EFI_BOOT, &efi.flags);
		set_bit(EFI_64BIT, &efi.flags);
942
	}
943 944 945

	if (efi_enabled(EFI_BOOT))
		efi_memblock_x86_reserve_range();
946 947
#endif

948
	x86_init.oem.arch_setup();
949

950
	iomem_resource.end = (1ULL << boot_cpu_data.x86_phys_bits) - 1;
951
	setup_memory_map();
952 953
	parse_setup_data();

L
Linus Torvalds 已提交
954 955
	copy_edd();

956
	if (!boot_params.hdr.root_flags)
L
Linus Torvalds 已提交
957 958 959 960
		root_mountflags &= ~MS_RDONLY;
	init_mm.start_code = (unsigned long) _text;
	init_mm.end_code = (unsigned long) _etext;
	init_mm.end_data = (unsigned long) _edata;
961
	init_mm.brk = _brk_end;
L
Linus Torvalds 已提交
962

963 964 965 966 967 968
	code_resource.start = __pa_symbol(_text);
	code_resource.end = __pa_symbol(_etext)-1;
	data_resource.start = __pa_symbol(_etext);
	data_resource.end = __pa_symbol(_edata)-1;
	bss_resource.start = __pa_symbol(__bss_start);
	bss_resource.end = __pa_symbol(__bss_stop)-1;
L
Linus Torvalds 已提交
969

970 971 972 973 974 975 976 977 978 979 980 981 982
#ifdef CONFIG_CMDLINE_BOOL
#ifdef CONFIG_CMDLINE_OVERRIDE
	strlcpy(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE);
#else
	if (builtin_cmdline[0]) {
		/* append boot loader cmdline to builtin */
		strlcat(builtin_cmdline, " ", COMMAND_LINE_SIZE);
		strlcat(builtin_cmdline, boot_command_line, COMMAND_LINE_SIZE);
		strlcpy(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE);
	}
#endif
#endif

983 984 985 986
	strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
	*cmdline_p = command_line;

	/*
987 988 989 990 991
	 * x86_configure_nx() is called before parse_early_param() to detect
	 * whether hardware doesn't support NX (so that the early EHCI debug
	 * console setup can safely call set_fixmap()). It may then be called
	 * again from within noexec_setup() during parsing early parameters
	 * to honor the respective command line option.
992
	 */
993
	x86_configure_nx();
994 995 996

	parse_early_param();

997
	x86_report_nx();
998

999
	/* after early param, so could get panic from serial */
1000
	memblock_x86_reserve_range_setup_data();
1001

1002
	if (acpi_mps_check()) {
I
Ingo Molnar 已提交
1003
#ifdef CONFIG_X86_LOCAL_APIC
1004
		disable_apic = 1;
I
Ingo Molnar 已提交
1005
#endif
1006
		setup_clear_cpu_cap(X86_FEATURE_APIC);
1007 1008
	}

1009 1010 1011 1012 1013
#ifdef CONFIG_PCI
	if (pci_early_dump_regs)
		early_dump_pci_devices();
#endif

1014 1015
	/* update the e820_saved too */
	e820_reserve_setup_data();
1016
	finish_e820_parsing();
1017

1018
	if (efi_enabled(EFI_BOOT))
B
Brian Maly 已提交
1019 1020
		efi_init();

1021
	dmi_scan_machine();
1022
	dmi_memdev_walk();
1023
	dmi_set_dump_stack_arch_desc();
1024

1025 1026 1027 1028
	/*
	 * VMware detection requires dmi to be available, so this
	 * needs to be done after dmi_scan_machine, for the BP.
	 */
1029
	init_hypervisor_platform();
1030

1031
	x86_init.resources.probe_roms();
1032 1033 1034 1035 1036 1037

	/* after parse_early_param, so could debug it */
	insert_resource(&iomem_resource, &code_resource);
	insert_resource(&iomem_resource, &data_resource);
	insert_resource(&iomem_resource, &bss_resource);

1038
	e820_add_kernel_range();
1039
	trim_bios_range();
1040
#ifdef CONFIG_X86_32
Y
Yinghai Lu 已提交
1041 1042 1043 1044 1045 1046 1047
	if (ppro_with_ram_bug()) {
		e820_update_range(0x70000000ULL, 0x40000ULL, E820_RAM,
				  E820_RESERVED);
		sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
		printk(KERN_INFO "fixed physical RAM map:\n");
		e820_print_map("bad_ppro");
	}
1048 1049 1050
#else
	early_gart_iommu_check();
#endif
Y
Yinghai Lu 已提交
1051

1052 1053 1054 1055
	/*
	 * partially used pages are not usable - thus
	 * we are rounding upwards:
	 */
1056
	max_pfn = e820_end_of_ram_pfn();
1057

1058 1059
	/* update e820 for memory not covered by WB MTRRs */
	mtrr_bp_init();
1060
	if (mtrr_trim_uncached_memory(max_pfn))
1061
		max_pfn = e820_end_of_ram_pfn();
1062

1063
#ifdef CONFIG_X86_32
1064
	/* max_low_pfn get updated here */
1065
	find_low_pfn_range();
1066
#else
Y
Yinghai Lu 已提交
1067
	check_x2apic();
1068 1069 1070

	/* How many end-of-memory variables you have, grandma! */
	/* need this before calling reserve_initrd */
1071 1072 1073 1074 1075
	if (max_pfn > (1UL<<(32 - PAGE_SHIFT)))
		max_low_pfn = e820_end_of_low_ram_pfn();
	else
		max_low_pfn = max_pfn;

1076
	high_memory = (void *)__va(max_pfn * PAGE_SIZE - 1) + 1;
1077 1078
#endif

1079 1080 1081 1082 1083
	/*
	 * Find and reserve possible boot-time SMP configuration:
	 */
	find_smp_config();

1084 1085
	reserve_ibft_region();

Y
Yinghai Lu 已提交
1086 1087
	early_alloc_pgt_buf();

1088 1089 1090 1091 1092 1093 1094
	/*
	 * Need to conclude brk, before memblock_x86_fill()
	 *  it could use memblock_find_in_range, could overlap with
	 *  brk area.
	 */
	reserve_brk();

1095 1096
	cleanup_highmap();

1097
	memblock_set_current_limit(ISA_END_ADDRESS);
1098 1099
	memblock_x86_fill();

1100 1101 1102 1103
	/*
	 * The EFI specification says that boot service code won't be called
	 * after ExitBootServices(). This is, in fact, a lie.
	 */
1104
	if (efi_enabled(EFI_MEMMAP))
1105 1106
		efi_reserve_boot_services();

1107 1108 1109 1110 1111 1112 1113
	/* preallocate 4k for mptable mpc */
	early_reserve_e820_mpc_new();

#ifdef CONFIG_X86_CHECK_BIOS_CORRUPTION
	setup_bios_corruption_check();
#endif

1114
#ifdef CONFIG_X86_32
1115 1116
	printk(KERN_DEBUG "initial memory mapped: [mem 0x00000000-%#010lx]\n",
			(max_pfn_mapped<<PAGE_SHIFT) - 1);
1117
#endif
1118

1119
	reserve_real_mode();
1120

1121
	trim_platform_memory_ranges();
1122
	trim_low_memory_range();
1123

1124
	init_mem_mapping();
1125

1126
	early_trap_pf_init();
1127

1128
	setup_real_mode();
1129

1130
	memblock_set_current_limit(get_max_mapped());
1131
	dma_contiguous_reserve(max_pfn_mapped << PAGE_SHIFT);
1132

1133 1134 1135 1136 1137 1138 1139 1140
	/*
	 * NOTE: On x86-32, only from this point on, fixmaps are ready for use.
	 */

#ifdef CONFIG_PROVIDE_OHCI1394_DMA_INIT
	if (init_ohci1394_dma_early)
		init_ohci1394_dma_on_all_controllers();
#endif
1141 1142
	/* Allocate bigger log buffer */
	setup_log_buf(1);
1143

1144 1145
	reserve_initrd();

D
David Rientjes 已提交
1146
#if defined(CONFIG_ACPI) && defined(CONFIG_BLK_DEV_INITRD)
1147
	acpi_initrd_override((void *)initrd_start, initrd_end - initrd_start);
D
David Rientjes 已提交
1148
#endif
1149

1150 1151
	vsmp_init();

1152 1153 1154 1155 1156
	io_delay_init();

	/*
	 * Parse the ACPI tables for possible boot-time SMP configuration.
	 */
1157 1158 1159 1160
	acpi_boot_table_init();

	early_acpi_boot_init();

1161
	initmem_init();
1162 1163 1164 1165 1166 1167 1168

	/*
	 * Reserve memory for crash kernel after SRAT is parsed so that it
	 * won't consume hotpluggable memory.
	 */
	reserve_crashkernel();

1169
	memblock_find_dma_reserve();
1170

1171
#ifdef CONFIG_KVM_GUEST
1172 1173 1174
	kvmclock_init();
#endif

1175
	x86_init.paging.pagetable_init();
1176

1177 1178 1179
	if (boot_cpu_data.cpuid_level >= 0) {
		/* A CPU has %cr4 if and only if it has CPUID */
		mmu_cr4_features = read_cr4();
1180 1181
		if (trampoline_cr4_features)
			*trampoline_cr4_features = mmu_cr4_features;
1182 1183
	}

1184 1185 1186 1187 1188 1189
#ifdef CONFIG_X86_32
	/* sync back kernel address range */
	clone_pgd_range(initial_page_table + KERNEL_PGD_BOUNDARY,
			swapper_pg_dir     + KERNEL_PGD_BOUNDARY,
			KERNEL_PGD_PTRS);
#endif
1190

1191 1192
	tboot_probe();

1193 1194 1195 1196
#ifdef CONFIG_X86_64
	map_vsyscall();
#endif

1197
	generic_apic_probe();
L
Linus Torvalds 已提交
1198

1199
	early_quirks();
1200

1201 1202 1203
	/*
	 * Read APIC and some other early information from ACPI tables.
	 */
L
Linus Torvalds 已提交
1204
	acpi_boot_init();
F
Feng Tang 已提交
1205
	sfi_init();
1206
	x86_dtb_init();
1207

1208 1209 1210
	/*
	 * get boot-time SMP configuration:
	 */
1211 1212
	if (smp_found_config)
		get_smp_config();
1213

1214
	prefill_possible_map();
Y
Yinghai Lu 已提交
1215

1216 1217
	init_cpu_to_node();

1218
	init_apic_mappings();
I
Ingo Molnar 已提交
1219 1220
	if (x86_io_apic_ops.init)
		x86_io_apic_ops.init();
1221

1222
	kvm_guest_init();
L
Linus Torvalds 已提交
1223

1224
	e820_reserve_resources();
1225
	e820_mark_nosave_regions(max_low_pfn);
L
Linus Torvalds 已提交
1226

1227
	x86_init.resources.reserve_resources();
1228 1229 1230

	e820_setup_gap();

L
Linus Torvalds 已提交
1231 1232
#ifdef CONFIG_VT
#if defined(CONFIG_VGA_CONSOLE)
1233
	if (!efi_enabled(EFI_BOOT) || (efi_mem_type(0xa0000) != EFI_CONVENTIONAL_MEMORY))
L
Linus Torvalds 已提交
1234 1235 1236 1237 1238
		conswitchp = &vga_con;
#elif defined(CONFIG_DUMMY_CONSOLE)
	conswitchp = &dummy_con;
#endif
#endif
1239
	x86_init.oem.banner();
1240

1241 1242
	x86_init.timers.wallclock_init();

1243
	mcheck_init();
1244

1245
	arch_init_ideal_nops();
1246 1247

	register_refined_jiffies(CLOCK_TICK_RATE);
1248 1249

#ifdef CONFIG_EFI
B
Borislav Petkov 已提交
1250 1251
	if (efi_enabled(EFI_BOOT))
		efi_apply_memmap_quirks();
1252
#endif
L
Linus Torvalds 已提交
1253
}
1254

1255 1256
#ifdef CONFIG_X86_32

1257 1258 1259 1260 1261
static struct resource video_ram_resource = {
	.name	= "Video RAM area",
	.start	= 0xa0000,
	.end	= 0xbffff,
	.flags	= IORESOURCE_BUSY | IORESOURCE_MEM
1262 1263
};

1264
void __init i386_reserve_resources(void)
1265
{
1266 1267
	request_resource(&iomem_resource, &video_ram_resource);
	reserve_standard_io_resources();
1268 1269 1270
}

#endif /* CONFIG_X86_32 */
1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282

static struct notifier_block kernel_offset_notifier = {
	.notifier_call = dump_kernel_offset
};

static int __init register_kernel_offset_dumper(void)
{
	atomic_notifier_chain_register(&panic_notifier_list,
					&kernel_offset_notifier);
	return 0;
}
__initcall(register_kernel_offset_dumper);