2005-04-17 06:20:36 +08: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 15:07:57 +08:00
|
|
|
#include <linux/mmzone.h>
|
2006-07-10 19:44:13 +08:00
|
|
|
#include <linux/screen_info.h>
|
2005-04-17 06:20:36 +08: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 10:50:41 +08:00
|
|
|
#include <linux/iscsi_ibft.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/nodemask.h>
|
2005-06-26 05:58:01 +08:00
|
|
|
#include <linux/kexec.h>
|
2005-06-26 05:58:20 +08:00
|
|
|
#include <linux/crash_dump.h>
|
2006-01-12 05:43:33 +08:00
|
|
|
#include <linux/dmi.h>
|
2006-03-27 17:16:04 +08:00
|
|
|
#include <linux/pfn.h>
|
2008-01-30 20:30:16 +08:00
|
|
|
#include <linux/pci.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 20:34:11 +08:00
|
|
|
#include <linux/init_ohci1394_dma.h>
|
2008-02-16 03:52:48 +08:00
|
|
|
#include <linux/kvm_para.h>
|
2005-06-26 05:58:01 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <video/edid.h>
|
2005-06-26 05:58:01 +08:00
|
|
|
|
2008-01-30 20:33:32 +08:00
|
|
|
#include <asm/mtrr.h>
|
2005-06-26 05:57:41 +08:00
|
|
|
#include <asm/apic.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <asm/e820.h>
|
|
|
|
#include <asm/mpspec.h>
|
2006-09-26 14:31:03 +08:00
|
|
|
#include <asm/mmzone.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <asm/setup.h>
|
|
|
|
#include <asm/arch_hooks.h>
|
|
|
|
#include <asm/sections.h>
|
2008-06-18 06:41:45 +08:00
|
|
|
#include <asm/dmi.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <asm/io_apic.h>
|
|
|
|
#include <asm/ist.h>
|
|
|
|
#include <asm/io.h>
|
2007-02-13 20:26:21 +08:00
|
|
|
#include <asm/vmi.h>
|
2006-06-25 20:46:50 +08:00
|
|
|
#include <setup_arch.h>
|
2008-03-18 03:08:17 +08:00
|
|
|
#include <asm/bios_ebda.h>
|
2007-10-22 07:42:01 +08:00
|
|
|
#include <asm/cacheflush.h>
|
2008-03-05 02:57:42 +08:00
|
|
|
#include <asm/processor.h>
|
2008-06-02 14:26:21 +08:00
|
|
|
#include <asm/efi.h>
|
2008-06-17 07:11:08 +08:00
|
|
|
#include <asm/bugs.h>
|
2005-04-17 06:20:36 +08: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! */
|
2008-05-30 03:56:36 +08:00
|
|
|
unsigned long init_pg_tables_start __initdata = ~0UL;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned long init_pg_tables_end __initdata = ~0UL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Machine setup..
|
|
|
|
*/
|
2008-01-30 20:30:32 +08: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
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct resource video_ram_resource = {
|
|
|
|
.name = "Video RAM area",
|
|
|
|
.start = 0xa0000,
|
|
|
|
.end = 0xbffff,
|
|
|
|
.flags = IORESOURCE_BUSY | IORESOURCE_MEM
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct resource standard_io_resources[] = { {
|
|
|
|
.name = "dma1",
|
|
|
|
.start = 0x0000,
|
|
|
|
.end = 0x001f,
|
|
|
|
.flags = IORESOURCE_BUSY | IORESOURCE_IO
|
|
|
|
}, {
|
|
|
|
.name = "pic1",
|
|
|
|
.start = 0x0020,
|
|
|
|
.end = 0x0021,
|
|
|
|
.flags = IORESOURCE_BUSY | IORESOURCE_IO
|
|
|
|
}, {
|
|
|
|
.name = "timer0",
|
|
|
|
.start = 0x0040,
|
|
|
|
.end = 0x0043,
|
|
|
|
.flags = IORESOURCE_BUSY | IORESOURCE_IO
|
|
|
|
}, {
|
|
|
|
.name = "timer1",
|
|
|
|
.start = 0x0050,
|
|
|
|
.end = 0x0053,
|
|
|
|
.flags = IORESOURCE_BUSY | IORESOURCE_IO
|
|
|
|
}, {
|
|
|
|
.name = "keyboard",
|
|
|
|
.start = 0x0060,
|
2008-04-29 20:20:40 +08:00
|
|
|
.end = 0x0060,
|
|
|
|
.flags = IORESOURCE_BUSY | IORESOURCE_IO
|
|
|
|
}, {
|
|
|
|
.name = "keyboard",
|
|
|
|
.start = 0x0064,
|
|
|
|
.end = 0x0064,
|
2008-01-30 20:30:32 +08:00
|
|
|
.flags = IORESOURCE_BUSY | IORESOURCE_IO
|
|
|
|
}, {
|
|
|
|
.name = "dma page reg",
|
|
|
|
.start = 0x0080,
|
|
|
|
.end = 0x008f,
|
|
|
|
.flags = IORESOURCE_BUSY | IORESOURCE_IO
|
|
|
|
}, {
|
|
|
|
.name = "pic2",
|
|
|
|
.start = 0x00a0,
|
|
|
|
.end = 0x00a1,
|
|
|
|
.flags = IORESOURCE_BUSY | IORESOURCE_IO
|
|
|
|
}, {
|
|
|
|
.name = "dma2",
|
|
|
|
.start = 0x00c0,
|
|
|
|
.end = 0x00df,
|
|
|
|
.flags = IORESOURCE_BUSY | IORESOURCE_IO
|
|
|
|
}, {
|
|
|
|
.name = "fpu",
|
|
|
|
.start = 0x00f0,
|
|
|
|
.end = 0x00ff,
|
|
|
|
.flags = IORESOURCE_BUSY | IORESOURCE_IO
|
|
|
|
} };
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* cpu data as detected by the assembly code in head.S */
|
2007-01-11 08:52:44 +08:00
|
|
|
struct cpuinfo_x86 new_cpu_data __cpuinitdata = { 0, 0, 0, 0, -1, 1, 0, 0, -1 };
|
2005-04-17 06:20:36 +08:00
|
|
|
/* common cpu data for all cpus */
|
2005-09-07 06:16:33 +08:00
|
|
|
struct cpuinfo_x86 boot_cpu_data __read_mostly = { 0, 0, 0, 0, -1, 1, 0, 0, -1 };
|
2005-06-23 15:08:33 +08:00
|
|
|
EXPORT_SYMBOL(boot_cpu_data);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-03-28 04:55:04 +08:00
|
|
|
unsigned int def_to_bigsmp;
|
|
|
|
|
2008-02-10 06:24:09 +08:00
|
|
|
#ifndef CONFIG_X86_PAE
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned long mmu_cr4_features;
|
2008-02-10 06:24:09 +08:00
|
|
|
#else
|
|
|
|
unsigned long mmu_cr4_features = X86_CR4_PAE;
|
|
|
|
#endif
|
2005-04-17 06:20:36 +08: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;
|
|
|
|
|
|
|
|
/* Boot loader ID as an integer, for the benefit of proc_dointvec */
|
|
|
|
int bootloader_type;
|
|
|
|
|
|
|
|
/* user-defined highmem size */
|
|
|
|
static unsigned int highmem_pages = -1;
|
|
|
|
|
2008-06-18 06:41:45 +08:00
|
|
|
/*
|
|
|
|
* Early DMI memory
|
|
|
|
*/
|
|
|
|
int dmi_alloc_index;
|
|
|
|
char dmi_alloc_data[DMI_MAX_DATA];
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Setup options
|
|
|
|
*/
|
|
|
|
struct screen_info screen_info;
|
2005-06-23 15:08:33 +08:00
|
|
|
EXPORT_SYMBOL(screen_info);
|
2005-04-17 06:20:36 +08:00
|
|
|
struct apm_info apm_info;
|
2005-06-23 15:08:33 +08:00
|
|
|
EXPORT_SYMBOL(apm_info);
|
2005-04-17 06:20:36 +08:00
|
|
|
struct edid_info edid_info;
|
2005-09-10 04:04:34 +08:00
|
|
|
EXPORT_SYMBOL_GPL(edid_info);
|
2005-04-17 06:20:36 +08:00
|
|
|
struct ist_info ist_info;
|
2005-06-23 15:08:33 +08:00
|
|
|
#if defined(CONFIG_X86_SPEEDSTEP_SMI) || \
|
|
|
|
defined(CONFIG_X86_SPEEDSTEP_SMI_MODULE)
|
|
|
|
EXPORT_SYMBOL(ist_info);
|
|
|
|
#endif
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
extern void early_cpu_init(void);
|
|
|
|
extern int root_mountflags;
|
|
|
|
|
2008-04-11 05:28:10 +08:00
|
|
|
unsigned long saved_video_mode;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-01-30 20:32:51 +08:00
|
|
|
#define RAMDISK_IMAGE_START_MASK 0x07FF
|
2005-04-17 06:20:36 +08:00
|
|
|
#define RAMDISK_PROMPT_FLAG 0x8000
|
2008-01-30 20:32:51 +08:00
|
|
|
#define RAMDISK_LOAD_FLAG 0x4000
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-02-12 16:54:11 +08:00
|
|
|
static char __initdata command_line[COMMAND_LINE_SIZE];
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-01-30 20:32:51 +08:00
|
|
|
#ifndef CONFIG_DEBUG_BOOT_PARAMS
|
2007-07-12 03:18:35 +08:00
|
|
|
struct boot_params __initdata boot_params;
|
2008-01-30 20:32:51 +08:00
|
|
|
#else
|
|
|
|
struct boot_params boot_params;
|
|
|
|
#endif
|
2005-04-17 06:20:36 +08: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 08:13:22 +08: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-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void copy_edd(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-09-26 16:52:32 +08:00
|
|
|
#ifdef CONFIG_PROC_VMCORE
|
|
|
|
/* elfcorehdr= specifies the location of elf core header
|
|
|
|
* stored by the crashed kernel.
|
|
|
|
*/
|
|
|
|
static int __init parse_elfcorehdr(char *arg)
|
|
|
|
{
|
|
|
|
if (!arg)
|
|
|
|
return -EINVAL;
|
2005-09-13 00:49:25 +08:00
|
|
|
|
2006-09-26 16:52:32 +08:00
|
|
|
elfcorehdr_addr = memparse(arg, &arg);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
early_param("elfcorehdr", parse_elfcorehdr);
|
|
|
|
#endif /* CONFIG_PROC_VMCORE */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-09-26 16:52:32 +08:00
|
|
|
/*
|
|
|
|
* highmem=size forces highmem to be exactly 'size' bytes.
|
|
|
|
* This works even on boxes that have no highmem otherwise.
|
|
|
|
* This also works to reduce highmem size on bigger boxes.
|
|
|
|
*/
|
|
|
|
static int __init parse_highmem(char *arg)
|
|
|
|
{
|
|
|
|
if (!arg)
|
|
|
|
return -EINVAL;
|
2005-06-26 05:57:41 +08:00
|
|
|
|
2006-09-26 16:52:32 +08:00
|
|
|
highmem_pages = memparse(arg, &arg) >> PAGE_SHIFT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
early_param("highmem", parse_highmem);
|
2005-06-26 05:57:41 +08:00
|
|
|
|
2006-09-26 16:52:32 +08:00
|
|
|
/*
|
|
|
|
* vmalloc=size forces the vmalloc area to be exactly 'size'
|
|
|
|
* bytes. This can be used to increase (or decrease) the
|
|
|
|
* vmalloc area - the default is 128m.
|
|
|
|
*/
|
|
|
|
static int __init parse_vmalloc(char *arg)
|
|
|
|
{
|
|
|
|
if (!arg)
|
|
|
|
return -EINVAL;
|
2005-06-26 05:58:01 +08:00
|
|
|
|
2006-09-26 16:52:32 +08:00
|
|
|
__VMALLOC_RESERVE = memparse(arg, &arg);
|
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2006-09-26 16:52:32 +08:00
|
|
|
early_param("vmalloc", parse_vmalloc);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-09-26 14:32:25 +08:00
|
|
|
/*
|
|
|
|
* reservetop=size reserves a hole at the top of the kernel address space which
|
|
|
|
* a hypervisor can load into later. Needed for dynamically loaded hypervisors,
|
|
|
|
* so relocating the fixmap can be done before paging initialization.
|
|
|
|
*/
|
|
|
|
static int __init parse_reservetop(char *arg)
|
|
|
|
{
|
|
|
|
unsigned long address;
|
|
|
|
|
|
|
|
if (!arg)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
address = memparse(arg, &arg);
|
|
|
|
reserve_top_address(address);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
early_param("reservetop", parse_reservetop);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Determine low and high memory ranges:
|
|
|
|
*/
|
|
|
|
unsigned long __init find_max_low_pfn(void)
|
|
|
|
{
|
|
|
|
unsigned long max_low_pfn;
|
|
|
|
|
|
|
|
max_low_pfn = max_pfn;
|
|
|
|
if (max_low_pfn > MAXMEM_PFN) {
|
|
|
|
if (highmem_pages == -1)
|
|
|
|
highmem_pages = max_pfn - MAXMEM_PFN;
|
|
|
|
if (highmem_pages + MAXMEM_PFN < max_pfn)
|
|
|
|
max_pfn = MAXMEM_PFN + highmem_pages;
|
|
|
|
if (highmem_pages + MAXMEM_PFN > max_pfn) {
|
|
|
|
printk("only %luMB highmem pages available, ignoring highmem size of %uMB.\n", pages_to_mb(max_pfn - MAXMEM_PFN), pages_to_mb(highmem_pages));
|
|
|
|
highmem_pages = 0;
|
|
|
|
}
|
|
|
|
max_low_pfn = MAXMEM_PFN;
|
|
|
|
#ifndef CONFIG_HIGHMEM
|
|
|
|
/* Maximum memory usable is what is directly addressable */
|
|
|
|
printk(KERN_WARNING "Warning only %ldMB will be used.\n",
|
|
|
|
MAXMEM>>20);
|
|
|
|
if (max_pfn > MAX_NONPAE_PFN)
|
2007-07-21 23:11:13 +08:00
|
|
|
printk(KERN_WARNING "Use a HIGHMEM64G enabled kernel.\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
else
|
|
|
|
printk(KERN_WARNING "Use a HIGHMEM enabled kernel.\n");
|
|
|
|
max_pfn = MAXMEM_PFN;
|
|
|
|
#else /* !CONFIG_HIGHMEM */
|
2007-07-21 23:11:13 +08:00
|
|
|
#ifndef CONFIG_HIGHMEM64G
|
2005-04-17 06:20:36 +08:00
|
|
|
if (max_pfn > MAX_NONPAE_PFN) {
|
|
|
|
max_pfn = MAX_NONPAE_PFN;
|
|
|
|
printk(KERN_WARNING "Warning only 4GB will be used.\n");
|
2007-07-21 23:11:13 +08:00
|
|
|
printk(KERN_WARNING "Use a HIGHMEM64G enabled kernel.\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2007-07-21 23:11:13 +08:00
|
|
|
#endif /* !CONFIG_HIGHMEM64G */
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif /* !CONFIG_HIGHMEM */
|
|
|
|
} else {
|
|
|
|
if (highmem_pages == -1)
|
|
|
|
highmem_pages = 0;
|
|
|
|
#ifdef CONFIG_HIGHMEM
|
|
|
|
if (highmem_pages >= max_pfn) {
|
|
|
|
printk(KERN_ERR "highmem size specified (%uMB) is bigger than pages available (%luMB)!.\n", pages_to_mb(highmem_pages), pages_to_mb(max_pfn));
|
|
|
|
highmem_pages = 0;
|
|
|
|
}
|
|
|
|
if (highmem_pages) {
|
|
|
|
if (max_low_pfn-highmem_pages < 64*1024*1024/PAGE_SIZE){
|
|
|
|
printk(KERN_ERR "highmem size %uMB results in smaller than 64MB lowmem, ignoring it.\n", pages_to_mb(highmem_pages));
|
|
|
|
highmem_pages = 0;
|
|
|
|
}
|
|
|
|
max_low_pfn -= highmem_pages;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
if (highmem_pages)
|
|
|
|
printk(KERN_ERR "ignoring highmem size on non-highmem kernel!\n");
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
return max_low_pfn;
|
|
|
|
}
|
|
|
|
|
2005-06-23 15:07:57 +08:00
|
|
|
#ifndef CONFIG_NEED_MULTIPLE_NODES
|
2008-04-23 19:20:56 +08:00
|
|
|
static void __init setup_bootmem_allocator(void);
|
2005-04-17 06:20:36 +08:00
|
|
|
static unsigned long __init setup_memory(void)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* partially used pages are not usable - thus
|
|
|
|
* we are rounding upwards:
|
|
|
|
*/
|
|
|
|
min_low_pfn = PFN_UP(init_pg_tables_end);
|
|
|
|
|
|
|
|
max_low_pfn = find_max_low_pfn();
|
|
|
|
|
|
|
|
#ifdef CONFIG_HIGHMEM
|
|
|
|
highstart_pfn = highend_pfn = max_pfn;
|
|
|
|
if (max_pfn > max_low_pfn) {
|
|
|
|
highstart_pfn = max_low_pfn;
|
|
|
|
}
|
2008-06-04 01:24:49 +08:00
|
|
|
memory_present(0, 0, highend_pfn);
|
2005-04-17 06:20:36 +08:00
|
|
|
printk(KERN_NOTICE "%ldMB HIGHMEM available.\n",
|
|
|
|
pages_to_mb(highend_pfn - highstart_pfn));
|
2006-09-26 16:52:31 +08:00
|
|
|
num_physpages = highend_pfn;
|
|
|
|
high_memory = (void *) __va(highstart_pfn * PAGE_SIZE - 1) + 1;
|
|
|
|
#else
|
2008-06-04 01:24:49 +08:00
|
|
|
memory_present(0, 0, max_low_pfn);
|
2006-09-26 16:52:31 +08:00
|
|
|
num_physpages = max_low_pfn;
|
|
|
|
high_memory = (void *) __va(max_low_pfn * PAGE_SIZE - 1) + 1;
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_FLATMEM
|
|
|
|
max_mapnr = num_physpages;
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
printk(KERN_NOTICE "%ldMB LOWMEM available.\n",
|
|
|
|
pages_to_mb(max_low_pfn));
|
|
|
|
|
|
|
|
setup_bootmem_allocator();
|
|
|
|
|
|
|
|
return max_low_pfn;
|
|
|
|
}
|
|
|
|
|
2008-04-23 19:20:56 +08:00
|
|
|
static void __init zone_sizes_init(void)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-10-11 16:20:39 +08:00
|
|
|
unsigned long max_zone_pfns[MAX_NR_ZONES];
|
|
|
|
memset(max_zone_pfns, 0, sizeof(max_zone_pfns));
|
|
|
|
max_zone_pfns[ZONE_DMA] =
|
|
|
|
virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT;
|
|
|
|
max_zone_pfns[ZONE_NORMAL] = max_low_pfn;
|
2008-06-04 10:35:04 +08:00
|
|
|
remove_all_active_ranges();
|
2005-04-17 06:20:36 +08:00
|
|
|
#ifdef CONFIG_HIGHMEM
|
2006-10-11 16:20:39 +08:00
|
|
|
max_zone_pfns[ZONE_HIGHMEM] = highend_pfn;
|
2008-06-04 10:35:04 +08:00
|
|
|
e820_register_active_regions(0, 0, highend_pfn);
|
2006-09-27 16:49:51 +08:00
|
|
|
#else
|
2008-06-04 10:35:04 +08:00
|
|
|
e820_register_active_regions(0, 0, max_low_pfn);
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
2006-09-27 16:49:51 +08:00
|
|
|
|
|
|
|
free_area_init_nodes(max_zone_pfns);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
#else
|
2005-06-23 15:07:57 +08:00
|
|
|
extern unsigned long __init setup_memory(void);
|
2005-04-17 06:20:36 +08:00
|
|
|
extern void zone_sizes_init(void);
|
2005-06-23 15:07:57 +08:00
|
|
|
#endif /* !CONFIG_NEED_MULTIPLE_NODES */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-01-30 20:32:51 +08:00
|
|
|
#ifdef CONFIG_BLK_DEV_INITRD
|
|
|
|
|
|
|
|
static bool do_relocate_initrd = false;
|
|
|
|
|
|
|
|
static void __init reserve_initrd(void)
|
|
|
|
{
|
2008-05-22 09:40:18 +08:00
|
|
|
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;
|
|
|
|
u64 ramdisk_here;
|
2008-01-30 20:32:51 +08:00
|
|
|
|
|
|
|
if (!boot_params.hdr.type_of_loader ||
|
|
|
|
!ramdisk_image || !ramdisk_size)
|
|
|
|
return; /* No initrd provided by bootloader */
|
|
|
|
|
2008-05-18 16:18:57 +08:00
|
|
|
initrd_start = 0;
|
|
|
|
|
2008-01-30 20:32:51 +08:00
|
|
|
if (ramdisk_size >= end_of_lowmem/2) {
|
2008-05-26 01:00:09 +08:00
|
|
|
free_early(ramdisk_image, ramdisk_end);
|
2008-01-30 20:32:51 +08:00
|
|
|
printk(KERN_ERR "initrd too large to handle, "
|
|
|
|
"disabling initrd\n");
|
|
|
|
return;
|
|
|
|
}
|
2008-05-18 16:18:57 +08:00
|
|
|
|
2008-05-30 03:56:36 +08:00
|
|
|
printk(KERN_INFO "old RAMDISK: %08llx - %08llx\n", ramdisk_image,
|
|
|
|
ramdisk_end);
|
|
|
|
|
|
|
|
|
2008-01-30 20:32:51 +08:00
|
|
|
if (ramdisk_end <= end_of_lowmem) {
|
|
|
|
/* All in lowmem, easy case */
|
2008-05-18 16:18:57 +08:00
|
|
|
/*
|
|
|
|
* don't need to reserve again, already reserved early
|
2008-05-22 09:40:18 +08:00
|
|
|
* in i386_start_kernel
|
2008-05-18 16:18:57 +08:00
|
|
|
*/
|
2008-01-30 20:32:51 +08:00
|
|
|
initrd_start = ramdisk_image + PAGE_OFFSET;
|
|
|
|
initrd_end = initrd_start+ramdisk_size;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We need to move the initrd down into lowmem */
|
2008-05-22 09:40:18 +08:00
|
|
|
ramdisk_here = find_e820_area(min_low_pfn<<PAGE_SHIFT,
|
|
|
|
end_of_lowmem, ramdisk_size,
|
|
|
|
PAGE_SIZE);
|
2008-01-30 20:32:51 +08:00
|
|
|
|
2008-05-26 01:00:09 +08:00
|
|
|
if (ramdisk_here == -1ULL)
|
|
|
|
panic("Cannot find place for new RAMDISK of size %lld\n",
|
|
|
|
ramdisk_size);
|
|
|
|
|
2008-01-30 20:32:51 +08:00
|
|
|
/* Note: this includes all the lowmem currently occupied by
|
|
|
|
the initrd, we rely on that fact to keep the data intact. */
|
2008-05-26 01:00:09 +08:00
|
|
|
reserve_early(ramdisk_here, ramdisk_here + ramdisk_size,
|
2008-05-22 09:40:18 +08:00
|
|
|
"NEW RAMDISK");
|
2008-01-30 20:32:51 +08:00
|
|
|
initrd_start = ramdisk_here + PAGE_OFFSET;
|
|
|
|
initrd_end = initrd_start + ramdisk_size;
|
2008-05-30 03:56:36 +08:00
|
|
|
printk(KERN_INFO "Allocated new RAMDISK: %08llx - %08llx\n",
|
|
|
|
ramdisk_here, ramdisk_here + ramdisk_size);
|
2008-01-30 20:32:51 +08:00
|
|
|
|
|
|
|
do_relocate_initrd = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define MAX_MAP_CHUNK (NR_FIX_BTMAPS << PAGE_SHIFT)
|
|
|
|
|
|
|
|
static void __init relocate_initrd(void)
|
|
|
|
{
|
2008-05-22 09:40:18 +08: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-01-30 20:32:51 +08:00
|
|
|
unsigned long slop, clen, mapaddr;
|
|
|
|
char *p, *q;
|
|
|
|
|
|
|
|
if (!do_relocate_initrd)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ramdisk_here = initrd_start - PAGE_OFFSET;
|
|
|
|
|
|
|
|
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;
|
2008-05-18 16:18:57 +08:00
|
|
|
/* need to free these low pages...*/
|
2008-05-22 09:40:18 +08:00
|
|
|
printk(KERN_INFO "Freeing old partial RAMDISK %08llx-%08llx\n",
|
|
|
|
ramdisk_image, ramdisk_image + clen - 1);
|
2008-05-18 16:18:57 +08:00
|
|
|
free_bootmem(ramdisk_image, clen);
|
2008-01-30 20:32:51 +08:00
|
|
|
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 20:33:44 +08:00
|
|
|
p = early_ioremap(mapaddr, clen+slop);
|
2008-01-30 20:32:51 +08:00
|
|
|
memcpy(q, p+slop, clen);
|
2008-01-30 20:33:44 +08:00
|
|
|
early_iounmap(p, clen+slop);
|
2008-01-30 20:32:51 +08:00
|
|
|
q += clen;
|
|
|
|
ramdisk_image += clen;
|
|
|
|
ramdisk_size -= clen;
|
|
|
|
}
|
2008-05-18 16:18:57 +08:00
|
|
|
/* high pages is not converted by early_res_to_bootmem */
|
2008-05-22 09:40:18 +08:00
|
|
|
ramdisk_image = boot_params.hdr.ramdisk_image;
|
|
|
|
ramdisk_size = boot_params.hdr.ramdisk_size;
|
|
|
|
printk(KERN_INFO "Copied RAMDISK from %016llx - %016llx to %08llx - %08llx\n",
|
|
|
|
ramdisk_image, ramdisk_image + ramdisk_size - 1,
|
|
|
|
ramdisk_here, ramdisk_here + ramdisk_size - 1);
|
2008-06-14 11:07:03 +08:00
|
|
|
|
|
|
|
/* need to free that, otherwise init highmem will reserve it again */
|
|
|
|
free_early(ramdisk_image, ramdisk_image+ramdisk_size);
|
2008-01-30 20:32:51 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* CONFIG_BLK_DEV_INITRD */
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
void __init setup_bootmem_allocator(void)
|
|
|
|
{
|
2008-06-04 10:35:04 +08:00
|
|
|
int i;
|
2008-05-18 16:18:57 +08:00
|
|
|
unsigned long bootmap_size, bootmap;
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Initialize the boot-time allocator (with low memory only):
|
|
|
|
*/
|
2008-05-18 16:18:57 +08:00
|
|
|
bootmap_size = bootmem_bootmap_pages(max_low_pfn)<<PAGE_SHIFT;
|
|
|
|
bootmap = find_e820_area(min_low_pfn<<PAGE_SHIFT,
|
2008-06-02 14:53:50 +08:00
|
|
|
max_pfn_mapped<<PAGE_SHIFT, bootmap_size,
|
2008-05-18 16:18:57 +08:00
|
|
|
PAGE_SIZE);
|
|
|
|
if (bootmap == -1L)
|
|
|
|
panic("Cannot find bootmem map of size %ld\n", bootmap_size);
|
2008-05-26 01:00:09 +08:00
|
|
|
reserve_early(bootmap, bootmap + bootmap_size, "BOOTMAP");
|
2008-05-22 09:40:18 +08:00
|
|
|
#ifdef CONFIG_BLK_DEV_INITRD
|
|
|
|
reserve_initrd();
|
|
|
|
#endif
|
2008-05-18 16:18:57 +08:00
|
|
|
bootmap_size = init_bootmem(bootmap >> PAGE_SHIFT, max_low_pfn);
|
2008-06-02 14:53:50 +08:00
|
|
|
printk(KERN_INFO " mapped low ram: 0 - %08lx\n",
|
|
|
|
max_pfn_mapped<<PAGE_SHIFT);
|
2008-05-22 09:40:18 +08:00
|
|
|
printk(KERN_INFO " low ram: %08lx - %08lx\n",
|
|
|
|
min_low_pfn<<PAGE_SHIFT, max_low_pfn<<PAGE_SHIFT);
|
2008-05-26 01:00:09 +08:00
|
|
|
printk(KERN_INFO " bootmap %08lx - %08lx\n",
|
|
|
|
bootmap, bootmap + bootmap_size);
|
2008-06-04 10:35:04 +08:00
|
|
|
for_each_online_node(i)
|
|
|
|
free_bootmem_with_active_regions(i, max_low_pfn);
|
2008-05-18 16:18:57 +08:00
|
|
|
early_res_to_bootmem(0, max_low_pfn<<PAGE_SHIFT);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The node 0 pgdat is initialized before all of these because
|
|
|
|
* it's needed for bootmem. node>0 pgdats have their virtual
|
|
|
|
* space allocated before the pagetables are in place to access
|
|
|
|
* them, so they can't be cleared then.
|
|
|
|
*
|
|
|
|
* This should all compile down to nothing when NUMA is off.
|
|
|
|
*/
|
2007-07-21 23:10:27 +08:00
|
|
|
static void __init remapped_pgdat_init(void)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int nid;
|
|
|
|
|
|
|
|
for_each_online_node(nid) {
|
|
|
|
if (nid != 0)
|
|
|
|
memset(NODE_DATA(nid), 0, sizeof(struct pglist_data));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_MCA
|
|
|
|
static void set_mca_bus(int x)
|
|
|
|
{
|
|
|
|
MCA_bus = x;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static void set_mca_bus(int x) { }
|
|
|
|
#endif
|
|
|
|
|
2008-06-17 04:03:31 +08:00
|
|
|
static void probe_roms(void);
|
|
|
|
|
2005-04-17 06:20:36 +08: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.
|
|
|
|
*/
|
|
|
|
void __init setup_arch(char **cmdline_p)
|
|
|
|
{
|
2008-06-17 04:03:31 +08:00
|
|
|
int i;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned long max_low_pfn;
|
|
|
|
|
|
|
|
memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
|
|
|
|
pre_setup_arch_hook();
|
|
|
|
early_cpu_init();
|
2008-01-30 20:33:44 +08:00
|
|
|
early_ioremap_init();
|
2008-06-02 14:26:25 +08:00
|
|
|
reserve_setup_data();
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
#ifdef CONFIG_EFI
|
2008-01-30 20:31:19 +08:00
|
|
|
if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
|
2008-06-02 14:26:21 +08:00
|
|
|
"EL32", 4)) {
|
2005-04-17 06:20:36 +08:00
|
|
|
efi_enabled = 1;
|
2008-06-02 14:26:21 +08:00
|
|
|
efi_reserve_early();
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
|
2007-10-16 08:13:22 +08:00
|
|
|
ROOT_DEV = old_decode_dev(boot_params.hdr.root_dev);
|
|
|
|
screen_info = boot_params.screen_info;
|
|
|
|
edid_info = boot_params.edid_info;
|
|
|
|
apm_info.bios = boot_params.apm_bios_info;
|
|
|
|
ist_info = boot_params.ist_info;
|
2008-04-11 05:28:10 +08:00
|
|
|
saved_video_mode = boot_params.hdr.vid_mode;
|
2007-10-16 08:13:22 +08:00
|
|
|
if( boot_params.sys_desc_table.length != 0 ) {
|
|
|
|
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-17 06:20:36 +08:00
|
|
|
}
|
2007-10-16 08:13:22 +08:00
|
|
|
bootloader_type = boot_params.hdr.type_of_loader;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
#ifdef CONFIG_BLK_DEV_RAM
|
2007-10-16 08:13:22 +08: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-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
ARCH_SETUP
|
2008-01-30 20:31:19 +08:00
|
|
|
|
2008-04-23 21:09:05 +08:00
|
|
|
setup_memory_map();
|
2008-01-30 20:31:19 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
copy_edd();
|
|
|
|
|
2007-10-16 08:13:22 +08:00
|
|
|
if (!boot_params.hdr.root_flags)
|
2005-04-17 06:20:36 +08: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;
|
|
|
|
init_mm.brk = init_pg_tables_end + PAGE_OFFSET;
|
|
|
|
|
|
|
|
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-22 07:42:01 +08:00
|
|
|
bss_resource.start = virt_to_phys(&__bss_start);
|
|
|
|
bss_resource.end = virt_to_phys(&__bss_stop)-1;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-06-02 14:26:25 +08:00
|
|
|
parse_setup_data();
|
|
|
|
|
2006-09-26 16:52:32 +08:00
|
|
|
parse_early_param();
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-04-23 21:09:05 +08:00
|
|
|
finish_e820_parsing();
|
2006-09-26 16:52:32 +08:00
|
|
|
|
2008-06-17 04:03:31 +08:00
|
|
|
probe_roms();
|
|
|
|
|
|
|
|
/* 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);
|
|
|
|
|
2007-02-12 16:54:11 +08:00
|
|
|
strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
|
2006-09-26 16:52:32 +08:00
|
|
|
*cmdline_p = command_line;
|
2006-03-23 18:59:41 +08:00
|
|
|
|
2008-01-30 20:32:11 +08:00
|
|
|
if (efi_enabled)
|
|
|
|
efi_init();
|
|
|
|
|
2008-06-17 07:11:08 +08: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-04 10:35:04 +08:00
|
|
|
e820_register_active_regions(0, 0, -1UL);
|
|
|
|
/*
|
|
|
|
* partially used pages are not usable - thus
|
|
|
|
* we are rounding upwards:
|
|
|
|
*/
|
|
|
|
max_pfn = e820_end_of_ram();
|
|
|
|
|
2008-06-09 10:53:26 +08:00
|
|
|
/* preallocate 4k for mptable mpc */
|
|
|
|
early_reserve_e820_mpc_new();
|
2008-01-30 20:33:32 +08:00
|
|
|
/* update e820 for memory not covered by WB MTRRs */
|
|
|
|
mtrr_bp_init();
|
2008-06-04 10:35:04 +08:00
|
|
|
if (mtrr_trim_uncached_memory(max_pfn)) {
|
|
|
|
remove_all_active_ranges();
|
|
|
|
e820_register_active_regions(0, 0, -1UL);
|
|
|
|
max_pfn = e820_end_of_ram();
|
|
|
|
}
|
2008-03-23 15:16:49 +08:00
|
|
|
|
2008-06-18 06:41:45 +08:00
|
|
|
dmi_scan_machine();
|
|
|
|
|
|
|
|
io_delay_init();
|
|
|
|
|
|
|
|
#ifdef CONFIG_ACPI
|
|
|
|
/*
|
|
|
|
* Parse the ACPI tables for possible boot-time SMP configuration.
|
|
|
|
*/
|
|
|
|
acpi_boot_table_init();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_ACPI_NUMA
|
|
|
|
/*
|
|
|
|
* Parse SRAT to discover nodes.
|
|
|
|
*/
|
|
|
|
acpi_numa_init();
|
|
|
|
#endif
|
|
|
|
|
2008-03-23 15:16:49 +08:00
|
|
|
max_low_pfn = setup_memory();
|
2008-01-30 20:33:32 +08:00
|
|
|
|
2008-06-18 01:02:45 +08:00
|
|
|
#ifdef CONFIG_ACPI_SLEEP
|
|
|
|
/*
|
|
|
|
* Reserve low memory region for sleep support.
|
|
|
|
*/
|
|
|
|
acpi_reserve_bootmem();
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_X86_FIND_SMP_CONFIG
|
|
|
|
/*
|
|
|
|
* Find and reserve possible boot-time SMP configuration:
|
|
|
|
*/
|
|
|
|
find_smp_config();
|
|
|
|
#endif
|
|
|
|
reserve_crashkernel();
|
|
|
|
|
|
|
|
reserve_ibft_region();
|
|
|
|
|
2008-02-16 03:52:48 +08:00
|
|
|
#ifdef CONFIG_KVM_CLOCK
|
|
|
|
kvmclock_init();
|
|
|
|
#endif
|
|
|
|
|
2007-02-13 20:26:21 +08:00
|
|
|
#ifdef CONFIG_VMI
|
|
|
|
/*
|
|
|
|
* Must be after max_low_pfn is determined, and before kernel
|
|
|
|
* pagetables are setup.
|
|
|
|
*/
|
|
|
|
vmi_init();
|
|
|
|
#endif
|
2008-02-23 01:21:36 +08:00
|
|
|
kvm_guest_init();
|
2007-02-13 20:26:21 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* NOTE: before this point _nobody_ is allowed to allocate
|
|
|
|
* any memory using the bootmem allocator. Although the
|
2007-10-20 07:13:56 +08:00
|
|
|
* allocator is now initialised only the first 8Mb of the kernel
|
2005-04-17 06:20:36 +08:00
|
|
|
* virtual address space has been mapped. All allocations before
|
|
|
|
* paging_init() has completed must use the alloc_bootmem_low_pages()
|
|
|
|
* variant (which allocates DMA'able memory) and care must be taken
|
|
|
|
* not to exceed the 8Mb limit.
|
|
|
|
*/
|
|
|
|
|
|
|
|
paging_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 20:34:11 +08: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
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* NOTE: at this point the bootmem allocator is fully available.
|
|
|
|
*/
|
|
|
|
|
2008-01-30 20:32:51 +08:00
|
|
|
#ifdef CONFIG_BLK_DEV_INITRD
|
|
|
|
relocate_initrd();
|
|
|
|
#endif
|
|
|
|
|
2008-06-14 11:07:03 +08:00
|
|
|
remapped_pgdat_init();
|
|
|
|
sparse_init();
|
|
|
|
zone_sizes_init();
|
|
|
|
|
2007-07-18 09:37:03 +08:00
|
|
|
paravirt_post_allocator_init();
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#ifdef CONFIG_X86_GENERICARCH
|
2006-09-26 16:52:32 +08:00
|
|
|
generic_apic_probe();
|
2008-01-30 20:32:51 +08:00
|
|
|
#endif
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-10-20 02:35:03 +08:00
|
|
|
early_quirks();
|
2006-06-08 15:43:38 +08:00
|
|
|
|
|
|
|
#ifdef CONFIG_ACPI
|
2005-04-17 06:20:36 +08:00
|
|
|
acpi_boot_init();
|
2008-06-09 09:29:22 +08:00
|
|
|
#endif
|
|
|
|
#if defined(CONFIG_X86_MPPARSE) || defined(CONFIG_X86_VISWS)
|
|
|
|
if (smp_found_config)
|
|
|
|
get_smp_config();
|
|
|
|
#endif
|
2005-09-04 06:56:31 +08:00
|
|
|
#if defined(CONFIG_SMP) && defined(CONFIG_X86_PC)
|
|
|
|
if (def_to_bigsmp)
|
|
|
|
printk(KERN_WARNING "More than 8 CPUs detected and "
|
|
|
|
"CONFIG_X86_PC cannot handle it.\nUse "
|
|
|
|
"CONFIG_X86_GENERICARCH or CONFIG_X86_BIGSMP.\n");
|
|
|
|
#endif
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-06-17 04:03:31 +08:00
|
|
|
e820_reserve_resources();
|
2008-05-21 11:10:58 +08:00
|
|
|
e820_mark_nosave_regions(max_low_pfn);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-06-17 04:03:31 +08:00
|
|
|
request_resource(&iomem_resource, &video_ram_resource);
|
|
|
|
/* 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]);
|
|
|
|
|
|
|
|
e820_setup_gap();
|
|
|
|
|
2005-04-17 06:20:36 +08: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-01-30 20:30:32 +08:00
|
|
|
|
2008-06-17 04:03:31 +08:00
|
|
|
static struct resource system_rom_resource = {
|
|
|
|
.name = "System ROM",
|
|
|
|
.start = 0xf0000,
|
|
|
|
.end = 0xfffff,
|
|
|
|
.flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct resource extension_rom_resource = {
|
|
|
|
.name = "Extension ROM",
|
|
|
|
.start = 0xe0000,
|
|
|
|
.end = 0xeffff,
|
|
|
|
.flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct resource adapter_rom_resources[] = { {
|
|
|
|
.name = "Adapter ROM",
|
|
|
|
.start = 0xc8000,
|
|
|
|
.end = 0,
|
|
|
|
.flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
|
|
|
|
}, {
|
|
|
|
.name = "Adapter ROM",
|
|
|
|
.start = 0,
|
|
|
|
.end = 0,
|
|
|
|
.flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
|
|
|
|
}, {
|
|
|
|
.name = "Adapter ROM",
|
|
|
|
.start = 0,
|
|
|
|
.end = 0,
|
|
|
|
.flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
|
|
|
|
}, {
|
|
|
|
.name = "Adapter ROM",
|
|
|
|
.start = 0,
|
|
|
|
.end = 0,
|
|
|
|
.flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
|
|
|
|
}, {
|
|
|
|
.name = "Adapter ROM",
|
|
|
|
.start = 0,
|
|
|
|
.end = 0,
|
|
|
|
.flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
|
|
|
|
}, {
|
|
|
|
.name = "Adapter ROM",
|
|
|
|
.start = 0,
|
|
|
|
.end = 0,
|
|
|
|
.flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
|
|
|
|
} };
|
|
|
|
|
|
|
|
static struct resource video_rom_resource = {
|
|
|
|
.name = "Video ROM",
|
|
|
|
.start = 0xc0000,
|
|
|
|
.end = 0xc7fff,
|
|
|
|
.flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
|
|
|
|
};
|
|
|
|
|
|
|
|
#define ROMSIGNATURE 0xaa55
|
|
|
|
|
|
|
|
static int __init romsignature(const unsigned char *rom)
|
|
|
|
{
|
|
|
|
const unsigned short * const ptr = (const unsigned short *)rom;
|
|
|
|
unsigned short sig;
|
|
|
|
|
|
|
|
return probe_kernel_address(ptr, sig) == 0 && sig == ROMSIGNATURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init romchecksum(const unsigned char *rom, unsigned long length)
|
|
|
|
{
|
|
|
|
unsigned char sum, c;
|
|
|
|
|
|
|
|
for (sum = 0; length && probe_kernel_address(rom++, c) == 0; length--)
|
|
|
|
sum += c;
|
|
|
|
return !length && !sum;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __init probe_roms(void)
|
2008-01-30 20:30:32 +08:00
|
|
|
{
|
2008-06-17 04:03:31 +08:00
|
|
|
const unsigned char *rom;
|
|
|
|
unsigned long start, length, upper;
|
|
|
|
unsigned char c;
|
2008-01-30 20:30:32 +08:00
|
|
|
int i;
|
|
|
|
|
2008-06-17 04:03:31 +08:00
|
|
|
/* video rom */
|
|
|
|
upper = adapter_rom_resources[0].start;
|
|
|
|
for (start = video_rom_resource.start; start < upper; start += 2048) {
|
|
|
|
rom = isa_bus_to_virt(start);
|
|
|
|
if (!romsignature(rom))
|
|
|
|
continue;
|
2008-01-30 20:30:32 +08:00
|
|
|
|
2008-06-17 04:03:31 +08:00
|
|
|
video_rom_resource.start = start;
|
2008-01-30 20:30:32 +08:00
|
|
|
|
2008-06-17 04:03:31 +08:00
|
|
|
if (probe_kernel_address(rom + 2, c) != 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* 0 < length <= 0x7f * 512, historically */
|
|
|
|
length = c * 512;
|
|
|
|
|
|
|
|
/* if checksum okay, trust length byte */
|
|
|
|
if (length && romchecksum(rom, length))
|
|
|
|
video_rom_resource.end = start + length - 1;
|
|
|
|
|
|
|
|
request_resource(&iomem_resource, &video_rom_resource);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
start = (video_rom_resource.end + 1 + 2047) & ~2047UL;
|
|
|
|
if (start < upper)
|
|
|
|
start = upper;
|
|
|
|
|
|
|
|
/* system rom */
|
|
|
|
request_resource(&iomem_resource, &system_rom_resource);
|
|
|
|
upper = system_rom_resource.start;
|
|
|
|
|
|
|
|
/* check for extension rom (ignore length byte!) */
|
|
|
|
rom = isa_bus_to_virt(extension_rom_resource.start);
|
|
|
|
if (romsignature(rom)) {
|
|
|
|
length = extension_rom_resource.end - extension_rom_resource.start + 1;
|
|
|
|
if (romchecksum(rom, length)) {
|
|
|
|
request_resource(&iomem_resource, &extension_rom_resource);
|
|
|
|
upper = extension_rom_resource.start;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check for adapter roms on 2k boundaries */
|
|
|
|
for (i = 0; i < ARRAY_SIZE(adapter_rom_resources) && start < upper; start += 2048) {
|
|
|
|
rom = isa_bus_to_virt(start);
|
|
|
|
if (!romsignature(rom))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (probe_kernel_address(rom + 2, c) != 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* 0 < length <= 0x7f * 512, historically */
|
|
|
|
length = c * 512;
|
|
|
|
|
|
|
|
/* but accept any length that fits if checksum okay */
|
|
|
|
if (!length || start + length > upper || !romchecksum(rom, length))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
adapter_rom_resources[i].start = start;
|
|
|
|
adapter_rom_resources[i].end = start + length - 1;
|
|
|
|
request_resource(&iomem_resource, &adapter_rom_resources[i]);
|
|
|
|
|
|
|
|
start = adapter_rom_resources[i++].end & ~2047UL;
|
|
|
|
}
|
2008-01-30 20:30:32 +08:00
|
|
|
}
|
|
|
|
|