2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* 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>
|
2005-06-23 07:07:57 +00:00
|
|
|
#include <linux/mmzone.h>
|
2006-07-10 11:44:13 +00:00
|
|
|
#include <linux/screen_info.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/ioport.h>
|
|
|
|
#include <linux/acpi.h>
|
|
|
|
#include <linux/apm_bios.h>
|
|
|
|
#include <linux/initrd.h>
|
|
|
|
#include <linux/bootmem.h>
|
|
|
|
#include <linux/seq_file.h>
|
|
|
|
#include <linux/console.h>
|
|
|
|
#include <linux/mca.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>
|
2008-04-10 02:50:41 +00:00
|
|
|
#include <linux/iscsi_ibft.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/nodemask.h>
|
2005-06-25 21:58:01 +00:00
|
|
|
#include <linux/kexec.h>
|
2006-01-11 21:43:33 +00:00
|
|
|
#include <linux/dmi.h>
|
2006-03-27 09:16:04 +00:00
|
|
|
#include <linux/pfn.h>
|
2008-01-30 12:30:16 +00:00
|
|
|
#include <linux/pci.h>
|
2008-06-26 00:51:29 +00:00
|
|
|
#include <asm/pci-direct.h>
|
x86: early boot debugging via FireWire (ohci1394_dma=early)
This patch adds a new configuration option, which adds support for a new
early_param which gets checked in arch/x86/kernel/setup_{32,64}.c:setup_arch()
to decide wether OHCI-1394 FireWire controllers should be initialized and
enabled for physical DMA access to allow remote debugging of early problems
like issues ACPI or other subsystems which are executed very early.
If the config option is not enabled, no code is changed, and if the boot
paramenter is not given, no new code is executed, and independent of that,
all new code is freed after boot, so the config option can be even enabled
in standard, non-debug kernels.
With specialized tools, it is then possible to get debugging information
from machines which have no serial ports (notebooks) such as the printk
buffer contents, or any data which can be referenced from global pointers,
if it is stored below the 4GB limit and even memory dumps of of the physical
RAM region below the 4GB limit can be taken without any cooperation from the
CPU of the host, so the machine can be crashed early, it does not matter.
In the extreme, even kernel debuggers can be accessed in this way. I wrote
a small kgdb module and an accompanying gdb stub for FireWire which allows
to gdb to talk to kgdb using remote remory reads and writes over FireWire.
An version of the gdb stub fore FireWire is able to read all global data
from a system which is running a a normal kernel without any kernel debugger,
without any interruption or support of the system's CPU. That way, e.g. the
task struct and so on can be read and even manipulated when the physical DMA
access is granted.
A HOWTO is included in this patch, in Documentation/debugging-via-ohci1394.txt
and I've put a copy online at
ftp://ftp.suse.de/private/bk/firewire/docs/debugging-via-ohci1394.txt
It also has links to all the tools which are available to make use of it
another copy of it is online at:
ftp://ftp.suse.de/private/bk/firewire/kernel/ohci1394_dma_early-v2.diff
Signed-Off-By: Bernhard Kaindl <bk@suse.de>
Tested-By: Thomas Renninger <trenn@suse.de>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-01-30 12:34:11 +00:00
|
|
|
#include <linux/init_ohci1394_dma.h>
|
2008-02-15 19:52:48 +00:00
|
|
|
#include <linux/kvm_para.h>
|
2005-06-25 21:58:01 +00:00
|
|
|
|
2008-06-26 00:51:29 +00:00
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/stddef.h>
|
|
|
|
#include <linux/unistd.h>
|
|
|
|
#include <linux/ptrace.h>
|
|
|
|
#include <linux/slab.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>
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <video/edid.h>
|
2005-06-25 21:58:01 +00:00
|
|
|
|
2008-01-30 12:33:32 +00:00
|
|
|
#include <asm/mtrr.h>
|
2005-06-25 21:57:41 +00:00
|
|
|
#include <asm/apic.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/e820.h>
|
|
|
|
#include <asm/mpspec.h>
|
|
|
|
#include <asm/setup.h>
|
|
|
|
#include <asm/arch_hooks.h>
|
2008-06-26 00:54:23 +00:00
|
|
|
#include <asm/efi.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/sections.h>
|
2008-06-17 22:41:45 +00:00
|
|
|
#include <asm/dmi.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/io_apic.h>
|
|
|
|
#include <asm/ist.h>
|
2007-02-13 12:26:21 +00:00
|
|
|
#include <asm/vmi.h>
|
2006-06-25 12:46:50 +00:00
|
|
|
#include <setup_arch.h>
|
2008-03-17 19:08:17 +00:00
|
|
|
#include <asm/bios_ebda.h>
|
2007-10-21 23:42:01 +00:00
|
|
|
#include <asm/cacheflush.h>
|
2008-03-04 18:57:42 +00:00
|
|
|
#include <asm/processor.h>
|
2008-06-16 23:11:08 +00:00
|
|
|
#include <asm/bugs.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-06-26 00:51:29 +00:00
|
|
|
#include <asm/system.h>
|
|
|
|
#include <asm/vsyscall.h>
|
|
|
|
#include <asm/smp.h>
|
|
|
|
#include <asm/desc.h>
|
|
|
|
#include <asm/dma.h>
|
2008-07-11 01:23:42 +00:00
|
|
|
#include <asm/iommu.h>
|
2008-06-26 00:51:29 +00:00
|
|
|
#include <asm/mmu_context.h>
|
|
|
|
#include <asm/proto.h>
|
|
|
|
|
|
|
|
#include <mach_apic.h>
|
|
|
|
#include <asm/paravirt.h>
|
|
|
|
|
|
|
|
#include <asm/percpu.h>
|
|
|
|
#include <asm/topology.h>
|
|
|
|
#include <asm/apicdef.h>
|
2008-06-26 00:54:23 +00:00
|
|
|
#ifdef CONFIG_X86_64
|
|
|
|
#include <asm/numa_64.h>
|
|
|
|
#endif
|
2008-06-26 00:51:29 +00:00
|
|
|
|
2008-06-26 02:52:15 +00:00
|
|
|
#ifndef ARCH_SETUP
|
|
|
|
#define ARCH_SETUP
|
|
|
|
#endif
|
|
|
|
|
2008-06-26 00:55:20 +00:00
|
|
|
#ifndef CONFIG_DEBUG_BOOT_PARAMS
|
|
|
|
struct boot_params __initdata boot_params;
|
|
|
|
#else
|
|
|
|
struct boot_params boot_params;
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Machine setup..
|
|
|
|
*/
|
2008-01-30 12:30:32 +00:00
|
|
|
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
|
|
|
|
};
|
|
|
|
|
2008-06-26 00:50:06 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_X86_32
|
2008-06-26 01:02:06 +00:00
|
|
|
/* This value is set up by the early boot code to point to the value
|
|
|
|
immediately after the boot time page tables. It contains a *physical*
|
|
|
|
address, and must not be in the .bss segment! */
|
|
|
|
unsigned long init_pg_tables_start __initdata = ~0UL;
|
|
|
|
unsigned long init_pg_tables_end __initdata = ~0UL;
|
|
|
|
|
2008-01-30 12:30:32 +00:00
|
|
|
static struct resource video_ram_resource = {
|
|
|
|
.name = "Video RAM area",
|
|
|
|
.start = 0xa0000,
|
|
|
|
.end = 0xbffff,
|
|
|
|
.flags = IORESOURCE_BUSY | IORESOURCE_MEM
|
|
|
|
};
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* cpu data as detected by the assembly code in head.S */
|
2008-06-26 00:50:06 +00:00
|
|
|
struct cpuinfo_x86 new_cpu_data __cpuinitdata = {0, 0, 0, 0, -1, 1, 0, 0, -1};
|
2005-04-16 22:20:36 +00:00
|
|
|
/* common cpu data for all cpus */
|
2008-06-26 00:50:06 +00:00
|
|
|
struct cpuinfo_x86 boot_cpu_data __read_mostly = {0, 0, 0, 0, -1, 1, 0, 0, -1};
|
2005-06-23 07:08:33 +00:00
|
|
|
EXPORT_SYMBOL(boot_cpu_data);
|
2008-06-26 00:50:06 +00:00
|
|
|
static void set_mca_bus(int x)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_MCA
|
|
|
|
MCA_bus = x;
|
|
|
|
#endif
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-03-27 20:55:04 +00:00
|
|
|
unsigned int def_to_bigsmp;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* for MCA, but anyone else can use it if they want */
|
|
|
|
unsigned int machine_id;
|
|
|
|
unsigned int machine_submodel_id;
|
|
|
|
unsigned int BIOS_revision;
|
|
|
|
|
2008-06-26 00:50:06 +00:00
|
|
|
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
|
|
|
|
struct cpuinfo_x86 boot_cpu_data __read_mostly;
|
|
|
|
EXPORT_SYMBOL(boot_cpu_data);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#if !defined(CONFIG_X86_PAE) || defined(CONFIG_X86_64)
|
|
|
|
unsigned long mmu_cr4_features;
|
|
|
|
#else
|
|
|
|
unsigned long mmu_cr4_features = X86_CR4_PAE;
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Boot loader ID as an integer, for the benefit of proc_dointvec */
|
|
|
|
int bootloader_type;
|
|
|
|
|
2008-06-17 22:41:45 +00:00
|
|
|
/*
|
|
|
|
* Early DMI memory
|
|
|
|
*/
|
|
|
|
int dmi_alloc_index;
|
|
|
|
char dmi_alloc_data[DMI_MAX_DATA];
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Setup options
|
|
|
|
*/
|
|
|
|
struct screen_info screen_info;
|
2005-06-23 07:08:33 +00:00
|
|
|
EXPORT_SYMBOL(screen_info);
|
2005-04-16 22:20:36 +00:00
|
|
|
struct edid_info edid_info;
|
2005-09-09 20:04:34 +00:00
|
|
|
EXPORT_SYMBOL_GPL(edid_info);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
extern int root_mountflags;
|
|
|
|
|
2008-04-10 21:28:10 +00:00
|
|
|
unsigned long saved_video_mode;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-01-30 12:32:51 +00:00
|
|
|
#define RAMDISK_IMAGE_START_MASK 0x07FF
|
2005-04-16 22:20:36 +00:00
|
|
|
#define RAMDISK_PROMPT_FLAG 0x8000
|
2008-01-30 12:32:51 +00:00
|
|
|
#define RAMDISK_LOAD_FLAG 0x4000
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-02-12 08:54:11 +00:00
|
|
|
static char __initdata command_line[COMMAND_LINE_SIZE];
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static inline void copy_edd(void)
|
|
|
|
{
|
2007-10-16 00:13:22 +00:00
|
|
|
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;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void copy_edd(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-01-30 12:32:51 +00:00
|
|
|
#ifdef CONFIG_BLK_DEV_INITRD
|
|
|
|
|
2008-06-26 00:49:26 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
2008-01-30 12:32:51 +00:00
|
|
|
|
2008-06-26 00:49:26 +00:00
|
|
|
#define MAX_MAP_CHUNK (NR_FIX_BTMAPS << PAGE_SHIFT)
|
|
|
|
static void __init relocate_initrd(void)
|
2008-01-30 12:32:51 +00:00
|
|
|
{
|
2008-06-26 00:49:26 +00:00
|
|
|
|
2008-05-22 01:40:18 +00:00
|
|
|
u64 ramdisk_image = boot_params.hdr.ramdisk_image;
|
|
|
|
u64 ramdisk_size = boot_params.hdr.ramdisk_size;
|
|
|
|
u64 end_of_lowmem = max_low_pfn << PAGE_SHIFT;
|
|
|
|
u64 ramdisk_here;
|
2008-06-26 00:49:26 +00:00
|
|
|
unsigned long slop, clen, mapaddr;
|
|
|
|
char *p, *q;
|
2008-01-30 12:32:51 +00:00
|
|
|
|
|
|
|
/* We need to move the initrd down into lowmem */
|
2008-06-24 19:18:14 +00:00
|
|
|
ramdisk_here = find_e820_area(0, end_of_lowmem, ramdisk_size,
|
|
|
|
PAGE_SIZE);
|
2008-01-30 12:32:51 +00:00
|
|
|
|
2008-05-25 17:00:09 +00:00
|
|
|
if (ramdisk_here == -1ULL)
|
|
|
|
panic("Cannot find place for new RAMDISK of size %lld\n",
|
|
|
|
ramdisk_size);
|
|
|
|
|
2008-01-30 12:32:51 +00:00
|
|
|
/* Note: this includes all the lowmem currently occupied by
|
|
|
|
the initrd, we rely on that fact to keep the data intact. */
|
2008-05-25 17:00:09 +00:00
|
|
|
reserve_early(ramdisk_here, ramdisk_here + ramdisk_size,
|
2008-05-22 01:40:18 +00:00
|
|
|
"NEW RAMDISK");
|
2008-01-30 12:32:51 +00:00
|
|
|
initrd_start = ramdisk_here + PAGE_OFFSET;
|
|
|
|
initrd_end = initrd_start + ramdisk_size;
|
2008-05-29 19:56:36 +00:00
|
|
|
printk(KERN_INFO "Allocated new RAMDISK: %08llx - %08llx\n",
|
|
|
|
ramdisk_here, ramdisk_here + ramdisk_size);
|
2008-01-30 12:32:51 +00:00
|
|
|
|
|
|
|
q = (char *)initrd_start;
|
|
|
|
|
|
|
|
/* Copy any lowmem portion of the initrd */
|
|
|
|
if (ramdisk_image < end_of_lowmem) {
|
|
|
|
clen = end_of_lowmem - ramdisk_image;
|
|
|
|
p = (char *)__va(ramdisk_image);
|
|
|
|
memcpy(q, p, clen);
|
|
|
|
q += clen;
|
|
|
|
ramdisk_image += clen;
|
|
|
|
ramdisk_size -= clen;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Copy the highmem portion of the initrd */
|
|
|
|
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;
|
2008-01-30 12:33:44 +00:00
|
|
|
p = early_ioremap(mapaddr, clen+slop);
|
2008-01-30 12:32:51 +00:00
|
|
|
memcpy(q, p+slop, clen);
|
2008-01-30 12:33:44 +00:00
|
|
|
early_iounmap(p, clen+slop);
|
2008-01-30 12:32:51 +00:00
|
|
|
q += clen;
|
|
|
|
ramdisk_image += clen;
|
|
|
|
ramdisk_size -= clen;
|
|
|
|
}
|
2008-05-18 08:18:57 +00:00
|
|
|
/* high pages is not converted by early_res_to_bootmem */
|
2008-05-22 01:40:18 +00:00
|
|
|
ramdisk_image = boot_params.hdr.ramdisk_image;
|
|
|
|
ramdisk_size = boot_params.hdr.ramdisk_size;
|
2008-06-26 00:49:26 +00:00
|
|
|
printk(KERN_INFO "Move RAMDISK from %016llx - %016llx to"
|
|
|
|
" %08llx - %08llx\n",
|
2008-05-22 01:40:18 +00:00
|
|
|
ramdisk_image, ramdisk_image + ramdisk_size - 1,
|
|
|
|
ramdisk_here, ramdisk_here + ramdisk_size - 1);
|
2008-06-26 00:49:26 +00:00
|
|
|
}
|
|
|
|
#endif
|
2008-06-14 03:07:03 +00:00
|
|
|
|
2008-06-26 00:49:26 +00:00
|
|
|
static void __init reserve_initrd(void)
|
|
|
|
{
|
|
|
|
u64 ramdisk_image = boot_params.hdr.ramdisk_image;
|
|
|
|
u64 ramdisk_size = boot_params.hdr.ramdisk_size;
|
|
|
|
u64 ramdisk_end = ramdisk_image + ramdisk_size;
|
|
|
|
u64 end_of_lowmem = max_low_pfn << PAGE_SHIFT;
|
|
|
|
|
|
|
|
if (!boot_params.hdr.type_of_loader ||
|
|
|
|
!ramdisk_image || !ramdisk_size)
|
|
|
|
return; /* No initrd provided by bootloader */
|
|
|
|
|
|
|
|
initrd_start = 0;
|
|
|
|
|
|
|
|
if (ramdisk_size >= (end_of_lowmem>>1)) {
|
|
|
|
free_early(ramdisk_image, ramdisk_end);
|
|
|
|
printk(KERN_ERR "initrd too large to handle, "
|
|
|
|
"disabling initrd\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
printk(KERN_INFO "RAMDISK: %08llx - %08llx\n", ramdisk_image,
|
|
|
|
ramdisk_end);
|
|
|
|
|
|
|
|
|
|
|
|
if (ramdisk_end <= end_of_lowmem) {
|
|
|
|
/* All in lowmem, easy case */
|
|
|
|
/*
|
|
|
|
* don't need to reserve again, already reserved early
|
|
|
|
* in i386_start_kernel
|
|
|
|
*/
|
|
|
|
initrd_start = ramdisk_image + PAGE_OFFSET;
|
|
|
|
initrd_end = initrd_start + ramdisk_size;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_X86_32
|
|
|
|
relocate_initrd();
|
|
|
|
#else
|
|
|
|
printk(KERN_ERR "initrd extends beyond end of memory "
|
|
|
|
"(0x%08llx > 0x%08llx)\ndisabling initrd\n",
|
|
|
|
ramdisk_end, end_of_lowmem);
|
|
|
|
initrd_start = 0;
|
|
|
|
#endif
|
|
|
|
free_early(ramdisk_image, ramdisk_end);
|
2008-01-30 12:32:51 +00:00
|
|
|
}
|
2008-06-22 09:46:58 +00:00
|
|
|
#else
|
2008-06-26 00:49:26 +00:00
|
|
|
static void __init reserve_initrd(void)
|
2008-06-22 09:46:58 +00:00
|
|
|
{
|
|
|
|
}
|
2008-01-30 12:32:51 +00:00
|
|
|
#endif /* CONFIG_BLK_DEV_INITRD */
|
|
|
|
|
2008-06-26 01:00:22 +00:00
|
|
|
static void __init parse_setup_data(void)
|
2008-06-26 00:56:22 +00:00
|
|
|
{
|
|
|
|
struct setup_data *data;
|
|
|
|
u64 pa_data;
|
|
|
|
|
|
|
|
if (boot_params.hdr.version < 0x0209)
|
|
|
|
return;
|
|
|
|
pa_data = boot_params.hdr.setup_data;
|
|
|
|
while (pa_data) {
|
|
|
|
data = early_ioremap(pa_data, PAGE_SIZE);
|
|
|
|
switch (data->type) {
|
|
|
|
case SETUP_E820_EXT:
|
|
|
|
parse_e820_ext(data, pa_data);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
pa_data = data->next;
|
|
|
|
early_iounmap(data, PAGE_SIZE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-03 18:37:13 +00:00
|
|
|
static void __init e820_reserve_setup_data(void)
|
2008-06-30 23:20:54 +00:00
|
|
|
{
|
|
|
|
struct setup_data *data;
|
|
|
|
u64 pa_data;
|
2008-07-02 03:04:10 +00:00
|
|
|
int found = 0;
|
2008-06-30 23:20:54 +00:00
|
|
|
|
|
|
|
if (boot_params.hdr.version < 0x0209)
|
|
|
|
return;
|
|
|
|
pa_data = boot_params.hdr.setup_data;
|
|
|
|
while (pa_data) {
|
|
|
|
data = early_ioremap(pa_data, sizeof(*data));
|
|
|
|
e820_update_range(pa_data, sizeof(*data)+data->len,
|
|
|
|
E820_RAM, E820_RESERVED_KERN);
|
2008-07-02 03:04:10 +00:00
|
|
|
found = 1;
|
2008-06-30 23:20:54 +00:00
|
|
|
pa_data = data->next;
|
|
|
|
early_iounmap(data, sizeof(*data));
|
|
|
|
}
|
2008-07-02 03:04:10 +00:00
|
|
|
if (!found)
|
|
|
|
return;
|
|
|
|
|
2008-06-30 23:20:54 +00:00
|
|
|
sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
|
2008-07-03 18:37:13 +00:00
|
|
|
memcpy(&e820_saved, &e820, sizeof(struct e820map));
|
2008-06-30 23:20:54 +00:00
|
|
|
printk(KERN_INFO "extended physical RAM map:\n");
|
|
|
|
e820_print_map("reserve setup_data");
|
|
|
|
}
|
|
|
|
|
2008-07-03 18:37:13 +00:00
|
|
|
static void __init reserve_early_setup_data(void)
|
|
|
|
{
|
|
|
|
struct setup_data *data;
|
|
|
|
u64 pa_data;
|
|
|
|
char buf[32];
|
|
|
|
|
|
|
|
if (boot_params.hdr.version < 0x0209)
|
|
|
|
return;
|
|
|
|
pa_data = boot_params.hdr.setup_data;
|
|
|
|
while (pa_data) {
|
|
|
|
data = early_ioremap(pa_data, sizeof(*data));
|
|
|
|
sprintf(buf, "setup data %x", data->type);
|
|
|
|
reserve_early(pa_data, pa_data+sizeof(*data)+data->len, buf);
|
|
|
|
pa_data = data->next;
|
|
|
|
early_iounmap(data, sizeof(*data));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-06-26 00:57:13 +00:00
|
|
|
/*
|
|
|
|
* --------- Crashkernel reservation ------------------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef CONFIG_KEXEC
|
2008-06-26 19:54:08 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Reserve @size bytes of crashkernel memory at any suitable offset.
|
|
|
|
*
|
|
|
|
* @size: Size of the crashkernel memory to reserve.
|
|
|
|
* Returns the base address on success, and -1ULL on failure.
|
|
|
|
*/
|
2008-08-12 21:23:05 +00:00
|
|
|
unsigned long long __init find_and_reserve_crashkernel(unsigned long long size)
|
2008-06-26 19:54:08 +00:00
|
|
|
{
|
|
|
|
const unsigned long long alignment = 16<<20; /* 16M */
|
|
|
|
unsigned long long start = 0LL;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
start = find_e820_area(start, ULONG_MAX, size, alignment);
|
|
|
|
if (start == -1ULL)
|
|
|
|
return start;
|
|
|
|
|
|
|
|
/* try to reserve it */
|
|
|
|
ret = reserve_bootmem_generic(start, size, BOOTMEM_EXCLUSIVE);
|
|
|
|
if (ret >= 0)
|
|
|
|
return start;
|
|
|
|
|
|
|
|
start += alignment;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-06-26 00:57:13 +00:00
|
|
|
static inline unsigned long long get_total_mem(void)
|
|
|
|
{
|
|
|
|
unsigned long long total;
|
|
|
|
|
|
|
|
total = max_low_pfn - min_low_pfn;
|
|
|
|
#ifdef CONFIG_HIGHMEM
|
|
|
|
total += highend_pfn - highstart_pfn;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return total << PAGE_SHIFT;
|
|
|
|
}
|
|
|
|
|
2008-06-26 01:00:22 +00:00
|
|
|
static void __init reserve_crashkernel(void)
|
2008-06-26 00:57:13 +00:00
|
|
|
{
|
|
|
|
unsigned long long total_mem;
|
|
|
|
unsigned long long crash_size, crash_base;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
total_mem = get_total_mem();
|
|
|
|
|
|
|
|
ret = parse_crashkernel(boot_command_line, total_mem,
|
|
|
|
&crash_size, &crash_base);
|
2008-06-26 19:54:08 +00:00
|
|
|
if (ret != 0 || crash_size <= 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* 0 means: find the address automatically */
|
|
|
|
if (crash_base <= 0) {
|
|
|
|
crash_base = find_and_reserve_crashkernel(crash_size);
|
|
|
|
if (crash_base == -1ULL) {
|
|
|
|
pr_info("crashkernel reservation failed. "
|
|
|
|
"No suitable area found.\n");
|
2008-06-26 00:57:13 +00:00
|
|
|
return;
|
|
|
|
}
|
2008-06-26 19:54:08 +00:00
|
|
|
} else {
|
|
|
|
ret = reserve_bootmem_generic(crash_base, crash_size,
|
|
|
|
BOOTMEM_EXCLUSIVE);
|
|
|
|
if (ret < 0) {
|
|
|
|
pr_info("crashkernel reservation failed - "
|
|
|
|
"memory is in use\n");
|
2008-06-26 00:57:13 +00:00
|
|
|
return;
|
|
|
|
}
|
2008-06-26 19:54:08 +00:00
|
|
|
}
|
2008-06-26 00:57:13 +00:00
|
|
|
|
2008-06-26 19:54:08 +00:00
|
|
|
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));
|
2008-06-26 00:57:13 +00:00
|
|
|
|
2008-06-26 19:54:08 +00:00
|
|
|
crashk_res.start = crash_base;
|
|
|
|
crashk_res.end = crash_base + crash_size - 1;
|
|
|
|
insert_resource(&iomem_resource, &crashk_res);
|
2008-06-26 00:57:13 +00:00
|
|
|
}
|
|
|
|
#else
|
2008-06-26 01:00:22 +00:00
|
|
|
static void __init reserve_crashkernel(void)
|
2008-06-26 00:57:13 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-06-26 00:58:02 +00:00
|
|
|
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 }
|
|
|
|
};
|
|
|
|
|
2008-06-26 01:00:22 +00:00
|
|
|
static void __init reserve_standard_io_resources(void)
|
2008-06-26 00:58:02 +00:00
|
|
|
{
|
|
|
|
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]);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2008-06-26 00:58:55 +00:00
|
|
|
#ifdef CONFIG_PROC_VMCORE
|
|
|
|
/* elfcorehdr= specifies the location of elf core header
|
|
|
|
* stored by the crashed kernel. This option will be passed
|
|
|
|
* by kexec loader to the capture kernel.
|
|
|
|
*/
|
|
|
|
static int __init setup_elfcorehdr(char *arg)
|
|
|
|
{
|
|
|
|
char *end;
|
|
|
|
if (!arg)
|
|
|
|
return -EINVAL;
|
|
|
|
elfcorehdr_addr = memparse(arg, &end);
|
|
|
|
return end > arg ? 0 : -EINVAL;
|
|
|
|
}
|
|
|
|
early_param("elfcorehdr", setup_elfcorehdr);
|
|
|
|
#endif
|
|
|
|
|
2008-07-19 09:07:25 +00:00
|
|
|
static struct x86_quirks default_x86_quirks __initdata;
|
|
|
|
|
|
|
|
struct x86_quirks *x86_quirks __initdata = &default_x86_quirks;
|
|
|
|
|
2008-09-07 08:51:32 +00:00
|
|
|
/*
|
|
|
|
* Some BIOSes seem to corrupt the low 64k of memory during events
|
|
|
|
* like suspend/resume and unplugging an HDMI cable. Reserve all
|
|
|
|
* remaining free memory in that area and fill it with a distinct
|
|
|
|
* pattern.
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_X86_CHECK_BIOS_CORRUPTION
|
|
|
|
#define MAX_SCAN_AREAS 8
|
2008-09-07 08:51:34 +00:00
|
|
|
|
2008-09-07 09:37:32 +00:00
|
|
|
static int __read_mostly memory_corruption_check = -1;
|
|
|
|
|
2008-09-07 08:51:34 +00:00
|
|
|
static unsigned __read_mostly corruption_check_size = 64*1024;
|
|
|
|
static unsigned __read_mostly corruption_check_period = 60; /* seconds */
|
|
|
|
|
2008-09-07 08:51:32 +00:00
|
|
|
static struct e820entry scan_areas[MAX_SCAN_AREAS];
|
|
|
|
static int num_scan_areas;
|
|
|
|
|
2008-09-07 08:51:34 +00:00
|
|
|
|
|
|
|
static int set_corruption_check(char *arg)
|
|
|
|
{
|
|
|
|
char *end;
|
|
|
|
|
|
|
|
memory_corruption_check = simple_strtol(arg, &end, 10);
|
|
|
|
|
|
|
|
return (*end == 0) ? 0 : -EINVAL;
|
|
|
|
}
|
|
|
|
early_param("memory_corruption_check", set_corruption_check);
|
|
|
|
|
|
|
|
static int set_corruption_check_period(char *arg)
|
|
|
|
{
|
|
|
|
char *end;
|
|
|
|
|
|
|
|
corruption_check_period = simple_strtoul(arg, &end, 10);
|
|
|
|
|
|
|
|
return (*end == 0) ? 0 : -EINVAL;
|
|
|
|
}
|
|
|
|
early_param("memory_corruption_check_period", set_corruption_check_period);
|
|
|
|
|
|
|
|
static int set_corruption_check_size(char *arg)
|
|
|
|
{
|
|
|
|
char *end;
|
|
|
|
unsigned size;
|
|
|
|
|
|
|
|
size = memparse(arg, &end);
|
|
|
|
|
|
|
|
if (*end == '\0')
|
|
|
|
corruption_check_size = size;
|
|
|
|
|
|
|
|
return (size == corruption_check_size) ? 0 : -EINVAL;
|
|
|
|
}
|
|
|
|
early_param("memory_corruption_check_size", set_corruption_check_size);
|
|
|
|
|
|
|
|
|
2008-09-07 08:51:32 +00:00
|
|
|
static void __init setup_bios_corruption_check(void)
|
|
|
|
{
|
|
|
|
u64 addr = PAGE_SIZE; /* assume first page is reserved anyway */
|
|
|
|
|
2008-09-07 09:37:32 +00:00
|
|
|
if (memory_corruption_check == -1) {
|
|
|
|
memory_corruption_check =
|
|
|
|
#ifdef CONFIG_X86_BOOTPARAM_MEMORY_CORRUPTION_CHECK
|
|
|
|
1
|
|
|
|
#else
|
|
|
|
0
|
|
|
|
#endif
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
2008-09-07 08:51:34 +00:00
|
|
|
if (corruption_check_size == 0)
|
|
|
|
memory_corruption_check = 0;
|
|
|
|
|
|
|
|
if (!memory_corruption_check)
|
|
|
|
return;
|
|
|
|
|
|
|
|
corruption_check_size = round_up(corruption_check_size, PAGE_SIZE);
|
|
|
|
|
|
|
|
while(addr < corruption_check_size && num_scan_areas < MAX_SCAN_AREAS) {
|
2008-09-07 08:51:32 +00:00
|
|
|
u64 size;
|
|
|
|
addr = find_e820_area_size(addr, &size, PAGE_SIZE);
|
|
|
|
|
|
|
|
if (addr == 0)
|
|
|
|
break;
|
|
|
|
|
2008-09-07 08:51:34 +00:00
|
|
|
if ((addr + size) > corruption_check_size)
|
|
|
|
size = corruption_check_size - addr;
|
2008-09-07 08:51:32 +00:00
|
|
|
|
|
|
|
if (size == 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
e820_update_range(addr, size, E820_RAM, E820_RESERVED);
|
|
|
|
scan_areas[num_scan_areas].addr = addr;
|
|
|
|
scan_areas[num_scan_areas].size = size;
|
|
|
|
num_scan_areas++;
|
|
|
|
|
|
|
|
/* Assume we've already mapped this early memory */
|
|
|
|
memset(__va(addr), 0, size);
|
|
|
|
|
|
|
|
addr += size;
|
|
|
|
}
|
|
|
|
|
2008-09-07 08:51:34 +00:00
|
|
|
printk(KERN_INFO "Scanning %d areas for low memory corruption\n",
|
2008-09-07 08:51:32 +00:00
|
|
|
num_scan_areas);
|
|
|
|
update_e820();
|
|
|
|
}
|
|
|
|
|
2008-09-07 08:51:33 +00:00
|
|
|
static struct timer_list periodic_check_timer;
|
2008-09-07 08:51:32 +00:00
|
|
|
|
|
|
|
void check_for_bios_corruption(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int corruption = 0;
|
|
|
|
|
2008-09-07 08:51:34 +00:00
|
|
|
if (!memory_corruption_check)
|
2008-09-07 08:51:32 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
for(i = 0; i < num_scan_areas; i++) {
|
|
|
|
unsigned long *addr = __va(scan_areas[i].addr);
|
|
|
|
unsigned long size = scan_areas[i].size;
|
|
|
|
|
|
|
|
for(; size; addr++, size -= sizeof(unsigned long)) {
|
|
|
|
if (!*addr)
|
|
|
|
continue;
|
|
|
|
printk(KERN_ERR "Corrupted low memory at %p (%lx phys) = %08lx\n",
|
|
|
|
addr, __pa(addr), *addr);
|
|
|
|
corruption = 1;
|
|
|
|
*addr = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-09-07 08:51:34 +00:00
|
|
|
WARN(corruption, KERN_ERR "Memory corruption detected in low memory\n");
|
2008-09-07 08:51:32 +00:00
|
|
|
}
|
|
|
|
|
2008-09-07 08:51:33 +00:00
|
|
|
static void periodic_check_for_corruption(unsigned long data)
|
|
|
|
{
|
|
|
|
check_for_bios_corruption();
|
2008-09-07 08:51:34 +00:00
|
|
|
mod_timer(&periodic_check_timer, jiffies + corruption_check_period*HZ);
|
2008-09-07 08:51:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void start_periodic_check_for_corruption(void)
|
|
|
|
{
|
2008-09-07 08:51:34 +00:00
|
|
|
if (!memory_corruption_check || corruption_check_period == 0)
|
2008-09-07 08:51:33 +00:00
|
|
|
return;
|
|
|
|
|
2008-09-07 08:51:34 +00:00
|
|
|
printk(KERN_INFO "Scanning for low memory corruption every %d seconds\n",
|
|
|
|
corruption_check_period);
|
|
|
|
|
2008-09-07 08:51:33 +00:00
|
|
|
init_timer(&periodic_check_timer);
|
|
|
|
periodic_check_timer.function = &periodic_check_for_corruption;
|
|
|
|
periodic_check_for_corruption(0);
|
|
|
|
}
|
2008-09-07 08:51:32 +00:00
|
|
|
#endif
|
|
|
|
|
2008-09-16 07:29:09 +00:00
|
|
|
static int __init dmi_low_memory_corruption(const struct dmi_system_id *d)
|
|
|
|
{
|
|
|
|
printk(KERN_NOTICE
|
2008-09-16 07:58:02 +00:00
|
|
|
"%s detected: BIOS may corrupt low RAM, working it around.\n",
|
2008-09-16 07:29:09 +00:00
|
|
|
d->ident);
|
|
|
|
|
2008-09-16 08:07:34 +00:00
|
|
|
reserve_early_overlap_ok(0x0, 0x10000, "BIOS quirk");
|
2008-09-16 07:29:09 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* List of systems that have known low memory corruption BIOS problems */
|
|
|
|
static struct dmi_system_id __initdata bad_bios_dmi_table[] = {
|
2008-09-16 08:07:34 +00:00
|
|
|
#ifdef CONFIG_X86_RESERVE_LOW_64K
|
2008-09-16 07:29:09 +00:00
|
|
|
{
|
|
|
|
.callback = dmi_low_memory_corruption,
|
|
|
|
.ident = "AMI BIOS",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_BIOS_VENDOR, "American Megatrends Inc."),
|
|
|
|
},
|
|
|
|
},
|
2008-09-16 07:58:02 +00:00
|
|
|
{
|
|
|
|
.callback = dmi_low_memory_corruption,
|
|
|
|
.ident = "Phoenix BIOS",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies, LTD"),
|
|
|
|
},
|
|
|
|
},
|
2008-09-16 07:29:09 +00:00
|
|
|
{}
|
2008-09-16 08:07:34 +00:00
|
|
|
#endif
|
2008-09-16 07:29:09 +00:00
|
|
|
};
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2008-06-26 00:52:35 +00:00
|
|
|
/*
|
|
|
|
* setup_arch - architecture-specific boot-time initializations
|
|
|
|
*
|
|
|
|
* Note: On x86_64, fixmaps are ready for use even before this is called.
|
|
|
|
*/
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
void __init setup_arch(char **cmdline_p)
|
|
|
|
{
|
2008-06-26 00:52:35 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
2005-04-16 22:20:36 +00:00
|
|
|
memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
|
2008-07-10 15:30:40 +00:00
|
|
|
visws_early_detect();
|
2005-04-16 22:20:36 +00:00
|
|
|
pre_setup_arch_hook();
|
2008-06-26 00:52:35 +00:00
|
|
|
#else
|
|
|
|
printk(KERN_INFO "Command line: %s\n", boot_command_line);
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-09-16 07:29:09 +00:00
|
|
|
dmi_check_system(bad_bios_dmi_table);
|
|
|
|
|
2008-07-21 23:49:54 +00:00
|
|
|
early_cpu_init();
|
2008-06-30 03:02:44 +00:00
|
|
|
early_ioremap_init();
|
|
|
|
|
2007-10-16 00:13:22 +00:00
|
|
|
ROOT_DEV = old_decode_dev(boot_params.hdr.root_dev);
|
|
|
|
screen_info = boot_params.screen_info;
|
|
|
|
edid_info = boot_params.edid_info;
|
2008-06-26 00:52:35 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
2007-10-16 00:13:22 +00:00
|
|
|
apm_info.bios = boot_params.apm_bios_info;
|
|
|
|
ist_info = boot_params.ist_info;
|
2008-06-26 00:52:35 +00:00
|
|
|
if (boot_params.sys_desc_table.length != 0) {
|
2007-10-16 00:13:22 +00:00
|
|
|
set_mca_bus(boot_params.sys_desc_table.table[3] & 0x2);
|
|
|
|
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];
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-06-26 00:52:35 +00:00
|
|
|
#endif
|
|
|
|
saved_video_mode = boot_params.hdr.vid_mode;
|
2007-10-16 00:13:22 +00:00
|
|
|
bootloader_type = boot_params.hdr.type_of_loader;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_BLK_DEV_RAM
|
2007-10-16 00:13:22 +00:00
|
|
|
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);
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
2008-06-24 02:53:33 +00:00
|
|
|
#ifdef CONFIG_EFI
|
|
|
|
if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
|
2008-06-26 00:52:35 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
|
|
|
"EL32",
|
|
|
|
#else
|
|
|
|
"EL64",
|
|
|
|
#endif
|
|
|
|
4)) {
|
2008-06-24 02:53:33 +00:00
|
|
|
efi_enabled = 1;
|
|
|
|
efi_reserve_early();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
ARCH_SETUP
|
2008-01-30 12:31:19 +00:00
|
|
|
|
2008-04-23 13:09:05 +00:00
|
|
|
setup_memory_map();
|
2008-06-30 23:20:54 +00:00
|
|
|
parse_setup_data();
|
2008-07-03 18:37:13 +00:00
|
|
|
/* update the e820_saved too */
|
|
|
|
e820_reserve_setup_data();
|
2008-06-30 23:20:54 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
copy_edd();
|
|
|
|
|
2007-10-16 00:13:22 +00:00
|
|
|
if (!boot_params.hdr.root_flags)
|
2005-04-16 22:20:36 +00:00
|
|
|
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;
|
2008-06-26 00:52:35 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
2005-04-16 22:20:36 +00:00
|
|
|
init_mm.brk = init_pg_tables_end + PAGE_OFFSET;
|
2008-06-26 00:52:35 +00:00
|
|
|
#else
|
|
|
|
init_mm.brk = (unsigned long) &_end;
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
code_resource.start = virt_to_phys(_text);
|
|
|
|
code_resource.end = virt_to_phys(_etext)-1;
|
|
|
|
data_resource.start = virt_to_phys(_etext);
|
|
|
|
data_resource.end = virt_to_phys(_edata)-1;
|
2007-10-21 23:42:01 +00:00
|
|
|
bss_resource.start = virt_to_phys(&__bss_start);
|
|
|
|
bss_resource.end = virt_to_phys(&__bss_stop)-1;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-06-24 02:54:23 +00:00
|
|
|
strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
|
|
|
|
*cmdline_p = command_line;
|
|
|
|
|
2006-09-26 08:52:32 +00:00
|
|
|
parse_early_param();
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-08-21 18:32:26 +00:00
|
|
|
#if defined(CONFIG_VMI) && defined(CONFIG_X86_32)
|
|
|
|
/*
|
|
|
|
* Must be before kernel pagetables are setup
|
|
|
|
* or fixmap area is touched.
|
|
|
|
*/
|
|
|
|
vmi_init();
|
|
|
|
#endif
|
|
|
|
|
2008-06-30 23:20:54 +00:00
|
|
|
/* after early param, so could get panic from serial */
|
2008-07-03 18:37:13 +00:00
|
|
|
reserve_early_setup_data();
|
2008-06-30 23:20:54 +00:00
|
|
|
|
2008-06-26 00:52:35 +00:00
|
|
|
if (acpi_mps_check()) {
|
2008-06-23 20:19:22 +00:00
|
|
|
#ifdef CONFIG_X86_LOCAL_APIC
|
2008-06-26 00:52:35 +00:00
|
|
|
disable_apic = 1;
|
2008-06-23 20:19:22 +00:00
|
|
|
#endif
|
2008-07-21 18:21:43 +00:00
|
|
|
setup_clear_cpu_cap(X86_FEATURE_APIC);
|
2008-06-20 23:11:20 +00:00
|
|
|
}
|
|
|
|
|
2008-07-17 00:25:46 +00:00
|
|
|
#ifdef CONFIG_PCI
|
|
|
|
if (pci_early_dump_regs)
|
|
|
|
early_dump_pci_devices();
|
|
|
|
#endif
|
|
|
|
|
2008-04-23 13:09:05 +00:00
|
|
|
finish_e820_parsing();
|
2006-09-26 08:52:32 +00:00
|
|
|
|
2008-06-26 00:52:35 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
2008-06-16 20:03:31 +00:00
|
|
|
probe_roms();
|
2008-06-26 00:52:35 +00:00
|
|
|
#endif
|
2008-06-16 20:03:31 +00:00
|
|
|
|
|
|
|
/* 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);
|
|
|
|
|
2008-01-30 12:32:11 +00:00
|
|
|
if (efi_enabled)
|
|
|
|
efi_init();
|
|
|
|
|
2008-06-26 00:52:35 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
2008-06-16 23:11:08 +00:00
|
|
|
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");
|
|
|
|
}
|
2008-06-26 00:52:35 +00:00
|
|
|
#else
|
|
|
|
early_gart_iommu_check();
|
|
|
|
#endif
|
2008-06-16 23:11:08 +00:00
|
|
|
|
2008-06-04 02:35:04 +00:00
|
|
|
/*
|
|
|
|
* partially used pages are not usable - thus
|
|
|
|
* we are rounding upwards:
|
|
|
|
*/
|
2008-07-11 03:38:26 +00:00
|
|
|
max_pfn = e820_end_of_ram_pfn();
|
2008-06-04 02:35:04 +00:00
|
|
|
|
2008-06-09 02:53:26 +00:00
|
|
|
/* preallocate 4k for mptable mpc */
|
|
|
|
early_reserve_e820_mpc_new();
|
2008-01-30 12:33:32 +00:00
|
|
|
/* update e820 for memory not covered by WB MTRRs */
|
|
|
|
mtrr_bp_init();
|
2008-07-09 01:56:38 +00:00
|
|
|
if (mtrr_trim_uncached_memory(max_pfn))
|
2008-07-11 03:38:26 +00:00
|
|
|
max_pfn = e820_end_of_ram_pfn();
|
2008-03-23 07:16:49 +00:00
|
|
|
|
2008-06-26 00:52:35 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
2008-06-24 19:18:14 +00:00
|
|
|
/* max_low_pfn get updated here */
|
2008-06-23 10:05:30 +00:00
|
|
|
find_low_pfn_range();
|
2008-06-26 00:52:35 +00:00
|
|
|
#else
|
|
|
|
num_physpages = max_pfn;
|
|
|
|
|
|
|
|
check_efer();
|
|
|
|
|
|
|
|
/* How many end-of-memory variables you have, grandma! */
|
|
|
|
/* need this before calling reserve_initrd */
|
2008-07-11 03:38:26 +00:00
|
|
|
if (max_pfn > (1UL<<(32 - PAGE_SHIFT)))
|
|
|
|
max_low_pfn = e820_end_of_low_ram_pfn();
|
|
|
|
else
|
|
|
|
max_low_pfn = max_pfn;
|
|
|
|
|
2008-06-26 00:52:35 +00:00
|
|
|
high_memory = (void *)__va(max_pfn * PAGE_SIZE - 1) + 1;
|
|
|
|
#endif
|
2008-06-23 10:05:30 +00:00
|
|
|
|
2008-09-07 08:51:32 +00:00
|
|
|
#ifdef CONFIG_X86_CHECK_BIOS_CORRUPTION
|
|
|
|
setup_bios_corruption_check();
|
|
|
|
#endif
|
|
|
|
|
2008-06-24 19:18:14 +00:00
|
|
|
/* max_pfn_mapped is updated here */
|
2008-07-11 03:38:26 +00:00
|
|
|
max_low_pfn_mapped = init_memory_mapping(0, max_low_pfn<<PAGE_SHIFT);
|
|
|
|
max_pfn_mapped = max_low_pfn_mapped;
|
|
|
|
|
|
|
|
#ifdef CONFIG_X86_64
|
|
|
|
if (max_pfn > max_low_pfn) {
|
|
|
|
max_pfn_mapped = init_memory_mapping(1UL<<32,
|
|
|
|
max_pfn<<PAGE_SHIFT);
|
|
|
|
/* can we preseve max_low_pfn ?*/
|
|
|
|
max_low_pfn = max_pfn;
|
|
|
|
}
|
|
|
|
#endif
|
2008-06-24 19:18:14 +00:00
|
|
|
|
2008-06-26 04:51:28 +00:00
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
|
2008-06-23 10:05:30 +00:00
|
|
|
reserve_initrd();
|
|
|
|
|
2008-06-26 00:52:35 +00:00
|
|
|
#ifdef CONFIG_X86_64
|
|
|
|
vsmp_init();
|
|
|
|
#endif
|
|
|
|
|
2008-06-17 22:41:45 +00:00
|
|
|
dmi_scan_machine();
|
|
|
|
|
|
|
|
io_delay_init();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Parse the ACPI tables for possible boot-time SMP configuration.
|
|
|
|
*/
|
|
|
|
acpi_boot_table_init();
|
|
|
|
|
|
|
|
#ifdef CONFIG_ACPI_NUMA
|
2008-06-26 00:53:22 +00:00
|
|
|
/*
|
|
|
|
* Parse SRAT to discover nodes.
|
|
|
|
*/
|
|
|
|
acpi_numa_init();
|
2008-06-17 22:41:45 +00:00
|
|
|
#endif
|
|
|
|
|
2008-06-23 10:05:30 +00:00
|
|
|
initmem_init(0, max_pfn);
|
2008-01-30 12:33:32 +00:00
|
|
|
|
2008-06-17 17:02:45 +00:00
|
|
|
#ifdef CONFIG_ACPI_SLEEP
|
|
|
|
/*
|
|
|
|
* Reserve low memory region for sleep support.
|
|
|
|
*/
|
|
|
|
acpi_reserve_bootmem();
|
|
|
|
#endif
|
2008-06-26 00:59:41 +00:00
|
|
|
#ifdef CONFIG_X86_FIND_SMP_CONFIG
|
2008-06-17 17:02:45 +00:00
|
|
|
/*
|
|
|
|
* Find and reserve possible boot-time SMP configuration:
|
|
|
|
*/
|
|
|
|
find_smp_config();
|
|
|
|
#endif
|
|
|
|
reserve_crashkernel();
|
|
|
|
|
2008-07-18 17:07:53 +00:00
|
|
|
#ifdef CONFIG_X86_64
|
|
|
|
/*
|
|
|
|
* dma32_reserve_bootmem() allocates bootmem which may conflict
|
|
|
|
* with the crashkernel command line, so do that after
|
|
|
|
* reserve_crashkernel()
|
|
|
|
*/
|
|
|
|
dma32_reserve_bootmem();
|
|
|
|
#endif
|
|
|
|
|
2008-06-17 17:02:45 +00:00
|
|
|
reserve_ibft_region();
|
|
|
|
|
2008-02-15 19:52:48 +00:00
|
|
|
#ifdef CONFIG_KVM_CLOCK
|
|
|
|
kvmclock_init();
|
|
|
|
#endif
|
|
|
|
|
2008-07-08 22:06:23 +00:00
|
|
|
paravirt_pagetable_setup_start(swapper_pg_dir);
|
2005-04-16 22:20:36 +00:00
|
|
|
paging_init();
|
2008-07-08 22:06:23 +00:00
|
|
|
paravirt_pagetable_setup_done(swapper_pg_dir);
|
2008-07-08 22:06:24 +00:00
|
|
|
paravirt_post_allocator_init();
|
x86: early boot debugging via FireWire (ohci1394_dma=early)
This patch adds a new configuration option, which adds support for a new
early_param which gets checked in arch/x86/kernel/setup_{32,64}.c:setup_arch()
to decide wether OHCI-1394 FireWire controllers should be initialized and
enabled for physical DMA access to allow remote debugging of early problems
like issues ACPI or other subsystems which are executed very early.
If the config option is not enabled, no code is changed, and if the boot
paramenter is not given, no new code is executed, and independent of that,
all new code is freed after boot, so the config option can be even enabled
in standard, non-debug kernels.
With specialized tools, it is then possible to get debugging information
from machines which have no serial ports (notebooks) such as the printk
buffer contents, or any data which can be referenced from global pointers,
if it is stored below the 4GB limit and even memory dumps of of the physical
RAM region below the 4GB limit can be taken without any cooperation from the
CPU of the host, so the machine can be crashed early, it does not matter.
In the extreme, even kernel debuggers can be accessed in this way. I wrote
a small kgdb module and an accompanying gdb stub for FireWire which allows
to gdb to talk to kgdb using remote remory reads and writes over FireWire.
An version of the gdb stub fore FireWire is able to read all global data
from a system which is running a a normal kernel without any kernel debugger,
without any interruption or support of the system's CPU. That way, e.g. the
task struct and so on can be read and even manipulated when the physical DMA
access is granted.
A HOWTO is included in this patch, in Documentation/debugging-via-ohci1394.txt
and I've put a copy online at
ftp://ftp.suse.de/private/bk/firewire/docs/debugging-via-ohci1394.txt
It also has links to all the tools which are available to make use of it
another copy of it is online at:
ftp://ftp.suse.de/private/bk/firewire/kernel/ohci1394_dma_early-v2.diff
Signed-Off-By: Bernhard Kaindl <bk@suse.de>
Tested-By: Thomas Renninger <trenn@suse.de>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-01-30 12:34:11 +00:00
|
|
|
|
2008-06-26 00:52:35 +00:00
|
|
|
#ifdef CONFIG_X86_64
|
|
|
|
map_vsyscall();
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifdef CONFIG_X86_GENERICARCH
|
2006-09-26 08:52:32 +00:00
|
|
|
generic_apic_probe();
|
2008-01-30 12:32:51 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-10-19 18:35:03 +00:00
|
|
|
early_quirks();
|
2006-06-08 07:43:38 +00:00
|
|
|
|
2008-06-24 02:55:05 +00:00
|
|
|
/*
|
|
|
|
* Read APIC and some other early information from ACPI tables.
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
acpi_boot_init();
|
2008-06-21 08:38:41 +00:00
|
|
|
|
2008-06-09 01:29:22 +00:00
|
|
|
#if defined(CONFIG_X86_MPPARSE) || defined(CONFIG_X86_VISWS)
|
2008-06-24 02:55:05 +00:00
|
|
|
/*
|
|
|
|
* get boot-time SMP configuration:
|
|
|
|
*/
|
2008-06-09 01:29:22 +00:00
|
|
|
if (smp_found_config)
|
|
|
|
get_smp_config();
|
|
|
|
#endif
|
2008-06-26 00:52:35 +00:00
|
|
|
|
2008-07-03 01:54:40 +00:00
|
|
|
prefill_possible_map();
|
2008-07-03 01:53:44 +00:00
|
|
|
#ifdef CONFIG_X86_64
|
|
|
|
init_cpu_to_node();
|
|
|
|
#endif
|
|
|
|
|
2008-06-26 00:52:35 +00:00
|
|
|
init_apic_mappings();
|
|
|
|
ioapic_init_mappings();
|
2008-06-27 08:41:56 +00:00
|
|
|
|
2008-06-24 02:55:05 +00:00
|
|
|
kvm_guest_init();
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-06-16 20:03:31 +00:00
|
|
|
e820_reserve_resources();
|
2008-05-21 03:10:58 +00:00
|
|
|
e820_mark_nosave_regions(max_low_pfn);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-06-26 00:52:35 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
2008-06-16 20:03:31 +00:00
|
|
|
request_resource(&iomem_resource, &video_ram_resource);
|
2008-06-26 00:52:35 +00:00
|
|
|
#endif
|
2008-06-22 03:22:09 +00:00
|
|
|
reserve_standard_io_resources();
|
2008-06-16 20:03:31 +00:00
|
|
|
|
|
|
|
e820_setup_gap();
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifdef CONFIG_VT
|
|
|
|
#if defined(CONFIG_VGA_CONSOLE)
|
|
|
|
if (!efi_enabled || (efi_mem_type(0xa0000) != EFI_CONVENTIONAL_MEMORY))
|
|
|
|
conswitchp = &vga_con;
|
|
|
|
#elif defined(CONFIG_DUMMY_CONSOLE)
|
|
|
|
conswitchp = &dummy_con;
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
}
|
2008-09-16 07:29:09 +00:00
|
|
|
|
|
|
|
|