diff -uNr linux-2.5.7.kexec.generic/arch/i386/Config.help linux-2.5.7.kexec.x86/arch/i386/Config.help --- linux-2.5.7.kexec.generic/arch/i386/Config.help Wed Mar 20 07:18:31 2002 +++ linux-2.5.7.kexec.x86/arch/i386/Config.help Sat Mar 30 17:52:58 2002 @@ -380,6 +380,20 @@ you have use for it; the module is called binfmt_misc.o. If you don't know what to answer at this point, say Y. +CONFIG_KEXEC + kexec is a system call that implements kernel level exec support. + Or the ability to boot linux from linux. The kexec system call + allows you to replace your current kernel with another kernel, + not necessarily linux. + + A known caveat is that for this to be fully useful all of the + devices must be shutdown. One way to impelment this is to build + all devices as modules and remove them before rebooting. + + You will probably want to dig up the elfboottools package as this + has the first implementation of a user client that uses this kernel + interface. + CONFIG_M386 This is the processor type of your CPU. This information is used for optimizing purposes. In order to compile a kernel that can run on diff -uNr linux-2.5.7.kexec.generic/arch/i386/config.in linux-2.5.7.kexec.x86/arch/i386/config.in --- linux-2.5.7.kexec.generic/arch/i386/config.in Wed Mar 20 07:18:31 2002 +++ linux-2.5.7.kexec.x86/arch/i386/config.in Sat Mar 30 17:31:01 2002 @@ -265,6 +265,7 @@ tristate 'Kernel support for a.out binaries' CONFIG_BINFMT_AOUT tristate 'Kernel support for ELF binaries' CONFIG_BINFMT_ELF tristate 'Kernel support for MISC binaries' CONFIG_BINFMT_MISC +bool 'Kernel execing kernel support' CONFIG_KEXEC bool 'Power Management support' CONFIG_PM diff -uNr linux-2.5.7.kexec.generic/arch/i386/kernel/Makefile linux-2.5.7.kexec.x86/arch/i386/kernel/Makefile --- linux-2.5.7.kexec.generic/arch/i386/kernel/Makefile Wed Mar 20 07:18:31 2002 +++ linux-2.5.7.kexec.x86/arch/i386/kernel/Makefile Sat Mar 30 17:31:01 2002 @@ -41,6 +41,7 @@ obj-$(CONFIG_SMP) += smp.o smpboot.o trampoline.o obj-$(CONFIG_X86_LOCAL_APIC) += mpparse.o apic.o nmi.o obj-$(CONFIG_X86_IO_APIC) += io_apic.o +obj-$(CONFIG_KEXEC) += machine_kexec.o relocate_kernel.o ifdef CONFIG_VISWS obj-y += setup-visws.o obj-$(CONFIG_X86_VISWS_APIC) += visws_apic.o diff -uNr linux-2.5.7.kexec.generic/arch/i386/kernel/machine_kexec.c linux-2.5.7.kexec.x86/arch/i386/kernel/machine_kexec.c --- linux-2.5.7.kexec.generic/arch/i386/kernel/machine_kexec.c Wed Dec 31 17:00:00 1969 +++ linux-2.5.7.kexec.x86/arch/i386/kernel/machine_kexec.c Sat Mar 30 17:31:01 2002 @@ -0,0 +1,140 @@ +#include +#include +#include +#include +#include +#include +#include + + +/* + * machine_kexec + * ======================= + */ + + +static void set_idt(void *newidt, __u16 limit) +{ + unsigned char curidt[6]; + + /* ia32 supports unaliged loads & stores */ + (*(__u16 *)(curidt)) = limit; + (*(__u32 *)(curidt +2)) = (unsigned long)(newidt); + + __asm__ __volatile__ ( + "lidt %0\n" + : "=m" (curidt) + ); +}; + + +static void set_gdt(void *newgdt, __u16 limit) +{ + unsigned char curgdt[6]; + + /* ia32 supports unaliged loads & stores */ + (*(__u16 *)(curgdt)) = limit; + (*(__u32 *)(curgdt +2)) = (unsigned long)(newgdt); + + __asm__ __volatile__ ( + "lgdt %0\n" + : "=m" (curgdt) + ); +}; + +static void load_segments(void) +{ +#define __STR(X) #X +#define STR(X) __STR(X) + + __asm__ __volatile__ ( + "\tljmp $"STR(__KERNEL_CS)",$1f\n" + "\t1:\n" + "\tmovl $"STR(__KERNEL_DS)",%eax\n" + "\tmovl %eax,%ds\n" + "\tmovl %eax,%es\n" + "\tmovl %eax,%fs\n" + "\tmovl %eax,%gs\n" + "\tmovl %eax,%ss\n" + ); +#undef STR +#undef __STR +} + +static void identity_map_page(unsigned long address) +{ + /* This code is x86 specific... + * general purpose code must be more carful + * of caches and tlbs... + */ + pgd_t *pgd; + pmd_t *pmd; + struct mm_struct *mm = current->mm; + spin_lock(&mm->page_table_lock); + + pgd = pgd_offset(mm, address); + pmd = pmd_alloc(mm, pgd, address); + + if (pmd) { + pte_t *pte = pte_alloc_map(mm, pmd, address); + if (pte) { + set_pte(pte, + mk_pte(virt_to_page(phys_to_virt(address)), + PAGE_SHARED)); + __flush_tlb_one(address); + } + } + spin_unlock(&mm->page_table_lock); +} + + +typedef void (*relocate_new_kernel_t)( + unsigned long indirection_page, unsigned long reboot_code_buffer, + unsigned long start_address); + +const extern unsigned char relocate_new_kernel[]; +extern void relocate_new_kernel_end(void); +const extern unsigned int relocate_new_kernel_size; + +void machine_kexec(struct kimage *image) +{ + unsigned long *indirection_page; + void *reboot_code_buffer; + relocate_new_kernel_t rnk; + + /* Interrupts aren't acceptable while we reboot */ + cli(); + reboot_code_buffer = image->reboot_code_buffer; + indirection_page = phys_to_virt(image->head & PAGE_MASK); + + identity_map_page(virt_to_phys(reboot_code_buffer)); + + /* copy it out */ + memcpy(reboot_code_buffer, relocate_new_kernel, + relocate_new_kernel_size); + + /* The segment registers are funny things, they are + * automatically loaded from a table, in memory wherever you + * set them to a specific selector, but this table is never + * accessed again you set the segment to a different selector. + * + * The more common model is are caches where the behide + * the scenes work is done, but is also dropped at arbitrary + * times. + * + * I take advantage of this here by force loading the + * segments, before I zap the gdt with an invalid value. + */ + load_segments(); + /* The gdt & idt are now invalid. + * If you want to load them you must set up your own idt & gdt. + */ + set_gdt(phys_to_virt(0),0); + set_idt(phys_to_virt(0),0); + + /* now call it */ + rnk = (relocate_new_kernel_t) virt_to_phys(reboot_code_buffer); + (*rnk)(virt_to_phys(indirection_page), virt_to_phys(reboot_code_buffer), + image->start); +} + diff -uNr linux-2.5.7.kexec.generic/arch/i386/kernel/relocate_kernel.S linux-2.5.7.kexec.x86/arch/i386/kernel/relocate_kernel.S --- linux-2.5.7.kexec.generic/arch/i386/kernel/relocate_kernel.S Wed Dec 31 17:00:00 1969 +++ linux-2.5.7.kexec.x86/arch/i386/kernel/relocate_kernel.S Sat Mar 30 17:31:01 2002 @@ -0,0 +1,82 @@ + #include +#include + + /* Must be relocatable PIC code callable as a C function, that once + * it starts can not use the previous processes stack. + * + */ +ENTRY(relocate_new_kernel) + /* read the arguments and say goodbye to the stack */ + movl 4(%esp), %ebx /* indirection_page */ + movl 8(%esp), %ebp /* reboot_code_buffer */ + movl 12(%esp), %edx /* start address */ + + /* zero out flags */ + pushl $0 + popfl + cli + + /* set a new stack at the bottom of our page... */ + lea 4096(%ebp), %esp + + /* store the parameters back on the stack */ + pushl %edx /* store the start address */ + + /* Turn off paging, leave protection turned on */ + movl %cr0, %eax /* Turn off paging (bit 31 in CR0) */ + andl $0x7FFFFFFF, %eax + movl %eax, %cr0 + jmp 1f +1: + + /* Flush the TLB (needed?) */ + xorl %eax, %eax + movl %eax, %cr3 + + /* Do the copies */ + cld +0: /* top, read another word for the indirection page */ + movl %ebx, %ecx + movl (%ebx), %ecx + addl $4, %ebx + testl $0x1, %ecx /* is it a destination page */ + jz 1f + movl %ecx, %edi + andl $0xfffff000, %edi + jmp 0b +1: + testl $0x2, %ecx /* is it an indirection page */ + jz 1f + movl %ecx, %ebx + andl $0xfffff000, %ebx + jmp 0b +1: + testl $0x4, %ecx /* is it the done indicator */ + jz 1f + jmp 2f +1: + testl $0x8, %ecx /* is it the source indicator */ + jz 0b /* Ignore it otherwise */ + movl %ecx, %esi /* For every source page do a copy */ + andl $0xfffff000, %esi + + movl $1024, %ecx + rep ; movsl + jmp 0b + +2: + /* set all of the registers to known values */ + /* leave %esp alone */ + + xorl %eax, %eax + xorl %ebx, %ebx + xorl %ecx, %ecx + xorl %edx, %edx + xorl %esi, %esi + xorl %edi, %edi + xorl %ebp, %ebp + ret +relocate_new_kernel_end: + +ENTRY(relocate_new_kernel_size) + .long relocate_new_kernel_end - SYMBOL_NAME(relocate_new_kernel) diff -uNr linux-2.5.7.kexec.generic/include/asm-i386/kexec.h linux-2.5.7.kexec.x86/include/asm-i386/kexec.h --- linux-2.5.7.kexec.generic/include/asm-i386/kexec.h Wed Dec 31 17:00:00 1969 +++ linux-2.5.7.kexec.x86/include/asm-i386/kexec.h Sat Mar 30 17:55:22 2002 @@ -0,0 +1,25 @@ +#ifndef _I386_KEXEC_H +#define _I386_KEXEC_H + +#include + +/* + * KEXEC_SOURCE_MEMORY_LIMIT maximum page get_free_page can return. + * I.e. Maximum page that is mapped directly into kernel memory, + * and kmap is not required. + * + * Someone correct me if FIXADDR_START - PAGEOFFSET is not the correct + * calculation for the amount of memory directly mappable into the + * kernel memory space. + */ + +/* Maximum physical address we can use pages from */ +#define KEXEC_SOURCE_MEMORY_LIMIT (FIXADDR_START - PAGE_OFFSET) +/* Maximum address we can reach in physical address mode */ +#define KEXEC_DESTINATION_MEMORY_LIMIT (-1UL) + +#define KEXEC_REBOOT_CODE_SIZE 4096 +#define KEXEC_REBOOT_CODE_ALIGN 0 + + +#endif /* _I386_KEXEC_H */