diff -uNr linux-2.5.7.kexec.reboot/include/linux/kexec.h linux-2.5.7.kexec.generic/include/linux/kexec.h --- linux-2.5.7.kexec.reboot/include/linux/kexec.h Wed Dec 31 17:00:00 1969 +++ linux-2.5.7.kexec.generic/include/linux/kexec.h Sat Mar 30 17:16:38 2002 @@ -0,0 +1,49 @@ +#ifndef LINUX_KEXEC_H +#define LINUX_KEXEC_H + +#if CONFIG_KEXEC +#include +#include + +/* + * This structure is used to hold the arguments that are used when loading + * kernel binaries. + */ + +typedef unsigned long kimage_entry_t; +#define IND_DESTINATION 0x1 +#define IND_INDIRECTION 0x2 +#define IND_DONE 0x4 +#define IND_SOURCE 0x8 + +struct kimage { + kimage_entry_t head; + kimage_entry_t *entry; + kimage_entry_t *last_entry; + + unsigned long destination; + unsigned long offset; + + unsigned long start; + void *reboot_code_buffer; +}; + +/* kexec helper functions */ +void kimage_init(struct kimage *image); +void kimage_free(struct kimage *image); + +struct kexec_segment { + void *buf; + size_t bufsz; + void *mem; + size_t memsz; +}; + +/* kexec interface functions */ +extern void machine_kexec(struct kimage *image); +extern int do_kexec(unsigned long entry, int nr_segments, + struct kexec_segment *segments, struct kimage *image); +extern int load_elf_kernel(struct kimage *image, struct file *file); +#endif +#endif /* LINUX_KEXEC_H */ + diff -uNr linux-2.5.7.kexec.reboot/include/linux/reboot.h linux-2.5.7.kexec.generic/include/linux/reboot.h --- linux-2.5.7.kexec.reboot/include/linux/reboot.h Fri Feb 9 15:46:13 2001 +++ linux-2.5.7.kexec.generic/include/linux/reboot.h Sat Mar 30 17:10:28 2002 @@ -28,7 +28,14 @@ #define LINUX_REBOOT_CMD_CAD_OFF 0x00000000 #define LINUX_REBOOT_CMD_POWER_OFF 0x4321FEDC #define LINUX_REBOOT_CMD_RESTART2 0xA1B2C3D4 +#define LINUX_REBOOT_CMD_KEXEC 0x18263645 +struct kexec_segment; +struct kexec_args { + unsigned long entry; + int nr_segments; + struct kexec_segment *segments; +}; #ifdef __KERNEL__ diff -uNr linux-2.5.7.kexec.reboot/kernel/Makefile linux-2.5.7.kexec.generic/kernel/Makefile --- linux-2.5.7.kexec.reboot/kernel/Makefile Wed Mar 20 07:18:49 2002 +++ linux-2.5.7.kexec.generic/kernel/Makefile Sat Mar 30 17:10:28 2002 @@ -30,4 +30,6 @@ CFLAGS_sched.o := $(PROFILING) -fno-omit-frame-pointer endif +obj-$(CONFIG_KEXEC) += kexec.o + include $(TOPDIR)/Rules.make diff -uNr linux-2.5.7.kexec.reboot/kernel/kexec.c linux-2.5.7.kexec.generic/kernel/kexec.c --- linux-2.5.7.kexec.reboot/kernel/kexec.c Wed Dec 31 17:00:00 1969 +++ linux-2.5.7.kexec.generic/kernel/kexec.c Sat Mar 30 17:10:28 2002 @@ -0,0 +1,630 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define DEBUG 0 + +/* As designed kexec can only use the memory that you don't + * need to use kmap to access. Memory that you can use virt_to_phys() + * on an call get_free_page to allocate. + * + * In the best case you need one page for the transition from + * virtual to physical memory. And this page must be identity + * mapped. Which pretty much leaves you with pages < PAGE_OFFSET + * as you can only mess with user pages. + * + * As the only subset of memory that it is easy to restrict allocation + * to is the physical memory mapped into the kernel, I do that + * with get_free_page and hope it is enough. + * + * I don't know of a good way to do this calcuate which pages get_free_page + * will return independent of architecture so I depend on + * to properly set + * KEXEC_SOURCE_MEMORY_LIMIT and KEXEC_DESTINATION_MEMORY_LIMIT + * + */ + +void kimage_init(struct kimage *image) +{ + memset(image, 0, sizeof(*image)); + image->head = 0; + image->entry = &image->head; + image->last_entry = &image->head; +} +static int kimage_add_entry(struct kimage *image, kimage_entry_t entry) +{ + if (image->offset != 0) { + image->entry++; + } + if (image->entry == image->last_entry) { + kimage_entry_t *ind_page; + ind_page = (void *)get_free_page(GFP_KERNEL); + if (!ind_page) { + return -ENOMEM; + } + *image->entry = virt_to_phys(ind_page) | IND_INDIRECTION; + image->entry = ind_page; + image->last_entry = + ind_page + ((PAGE_SIZE/sizeof(kimage_entry_t)) - 1); + } + *image->entry = entry; + image->entry++; + image->offset = 0; + return 0; +} + +static int kimage_verify_destination(unsigned long destination) +{ + int result; + + /* Assume the page is bad unless we pass the checks */ + result = -EADDRNOTAVAIL; + + if (destination >= KEXEC_DESTINATION_MEMORY_LIMIT) { + goto out; + } + + /* FIXME: + * add checking to ensure the new image doesn't go into + * invalid or reserved areas of RAM. + */ + result = 0; +out: + return result; +} + +static int kimage_set_destination( + struct kimage *image, unsigned long destination) +{ + int result; + destination &= PAGE_MASK; + result = kimage_verify_destination(destination); + if (result) { + return result; + } + result = kimage_add_entry(image, destination | IND_DESTINATION); + if (result == 0) { + image->destination = destination; + } + return result; +} + + +static int kimage_add_page(struct kimage *image, unsigned long page) +{ + int result; + page &= PAGE_MASK; + result = kimage_verify_destination(image->destination); + if (result) { + return result; + } + result = kimage_add_entry(image, page | IND_SOURCE); + if (result == 0) { + image->destination += PAGE_SIZE; + } + return result; +} + + +static int kimage_terminate(struct kimage *image) +{ + int result; + result = kimage_add_entry(image, IND_DONE); + if (result == 0) { + /* Point at the terminating element */ + image->entry--; + } + return result; +} + +#define for_each_kimage_entry(image, ptr, entry) \ + for (ptr = &image->head; (entry = *ptr) && !(entry & IND_DONE); \ + ptr = (entry & IND_INDIRECTION)? \ + phys_to_virt((entry & PAGE_MASK)): ptr +1) + +void kimage_free(struct kimage *image) +{ + kimage_entry_t *ptr, entry; + kimage_entry_t ind = 0; + for_each_kimage_entry(image, ptr, entry) { + if (entry & IND_INDIRECTION) { + /* Free the previous indirection page */ + if (ind & IND_INDIRECTION) { + free_page((unsigned long)phys_to_virt(ind & PAGE_MASK)); + } + /* Save this indirection page until we are + * done with it. + */ + ind = entry; + } + else if (entry & IND_SOURCE) { + free_page((unsigned long)phys_to_virt(entry & PAGE_MASK)); + } + } +} + +#if DEBUG +static void kimage_print_image(struct kimage *image) +{ + kimage_entry_t *ptr, entry; + int i; + printk(KERN_EMERG "kimage_print_image\n"); + i = 0; + for_each_kimage_entry(image, ptr, entry) { + if (entry & IND_DESTINATION) { + printk(KERN_EMERG "%5d DEST\n", i); + } + else if (entry & IND_INDIRECTION) { + printk(KERN_EMERG "%5d IND\n", i); + } + else if (entry & IND_SOURCE) { + printk(KERN_EMERG "%5d SOURCE\n", i); + } + else if (entry & IND_DONE) { + printk(KERN_EMERG "%5d DONE\n", i); + } + else { + printk(KERN_EMERG "%5d ?\n", i); + } + i++; + } + printk(KERN_EMERG "kimage_print_image: %5d\n", i); +} +#endif +static int kimage_is_destination_page( + struct kimage *image, unsigned long page) +{ + kimage_entry_t *ptr, entry; + unsigned long destination; + destination = 0; + page &= PAGE_MASK; + for_each_kimage_entry(image, ptr, entry) { + if (entry & IND_DESTINATION) { + destination = entry & PAGE_MASK; + } + else if (entry & IND_SOURCE) { + if (page == destination) { + return 1; + } + destination += PAGE_SIZE; + } + } + return 0; +} + +static int kimage_get_unused_area( + struct kimage *image, unsigned long size, unsigned long align, + unsigned long *area) +{ + /* Walk through mem_map and find the first chunk of + * ununsed memory that is at least size bytes long. + */ + /* Since the kernel plays with Page_Reseved mem_map is less + * than ideal for this purpose, but it will give us a correct + * conservative estimate of what we need to do. + */ + /* For now we take advantage of the fact that all kernel pages + * are marked with PG_resereved to allocate a large + * contiguous area for the reboot code buffer. + */ + unsigned long addr; + unsigned long start, end; + unsigned long mask; + mask = ((1 << align) -1); + start = end = PAGE_SIZE; + for(addr = PAGE_SIZE; addr < KEXEC_SOURCE_MEMORY_LIMIT; addr += PAGE_SIZE) { + struct page *page; + unsigned long aligned_start; + page = virt_to_page(phys_to_virt(addr)); + if (PageReserved(page) || PageSkip(page) || + kimage_is_destination_page(image, addr)) { + /* The current page is reserved so the start & + * end of the next area must be atleast at the + * next page. + */ + start = end = addr + PAGE_SIZE; + } + else { + /* O.k. The current page isn't reserved + * so push up the end of the area. + */ + end = addr; + } + aligned_start = (start + mask) & ~mask; + if (aligned_start > start) { + continue; + } + if (aligned_start > end) { + continue; + } + if (end - aligned_start >= size) { + *area = aligned_start; + return 0; + } + } + *area = 0; + return -ENOSPC; +} + +static kimage_entry_t *kimage_dst_conflict( + struct kimage *image, unsigned long page, kimage_entry_t *limit) +{ + kimage_entry_t *ptr, entry; + unsigned long destination = 0; + for_each_kimage_entry(image, ptr, entry) { + if (ptr == limit) { + return 0; + } + else if (entry & IND_DESTINATION) { + destination = entry & PAGE_MASK; + } + else if (entry & IND_SOURCE) { + if (page == destination) { + return ptr; + } + destination += PAGE_SIZE; + } + } + return 0; +} + +static kimage_entry_t *kimage_src_conflict( + struct kimage *image, unsigned long destination, kimage_entry_t *limit) +{ + kimage_entry_t *ptr, entry; + for_each_kimage_entry(image, ptr, entry) { + unsigned long page; + if (ptr == limit) { + return 0; + } + else if (entry & IND_DESTINATION) { + /* nop */ + } + else if (entry & IND_DONE) { + /* nop */ + } + else { + /* SOURCE & INDIRECTION */ + page = entry & PAGE_MASK; + if (page == destination) { + return ptr; + } + } + } + return 0; +} + +static int kimage_get_off_destination_pages(struct kimage *image) +{ + kimage_entry_t *ptr, *cptr, entry; + unsigned long buffer, page; + unsigned long destination = 0; + + /* Here we implement safe guards to insure that + * a source page is not copied to it's destination + * page before the data on the destination page is + * no longer useful. + * + * To make it work we actually wind up with a + * stronger condition. For every page considered + * it is either it's own destination page or it is + * not a destination page of any page considered. + * + * Invariants + * 1. buffer is not a destination of a previous page. + * 2. page is not a destination of a previous page. + * 3. destination is not a previous source page. + * + * Result: Either a source page and a destination page + * are the same or the page is not a destination page. + * + * These checks could be done when we allocate the pages, + * but doing it as a final pass allows us more freedom + * on how we allocate pages. + * + * Also while the checks are necessary, in practice nothing + * happens. The destination kernel wants to sit in the + * same physical addresses as the current kernel so we never + * actually allocate a destination page. + * + * BUGS: This is a O(N^2) algorithm. + */ + + + buffer = __get_free_page(GFP_KERNEL); + if (!buffer) { + return -ENOMEM; + } + buffer = virt_to_phys((void *)buffer); + for_each_kimage_entry(image, ptr, entry) { + /* Here we check to see if an allocated page */ + kimage_entry_t *limit; + if (entry & IND_DESTINATION) { + destination = entry & PAGE_MASK; + } + else if (entry & IND_INDIRECTION) { + /* Indirection pages must include all of their + * contents in limit checking. + */ + limit = phys_to_virt(page + PAGE_SIZE - sizeof(*limit)); + } + if (!((entry & IND_SOURCE) | (entry & IND_INDIRECTION))) { + continue; + } + page = entry & PAGE_MASK; + limit = ptr; + + /* See if a previous page has the current page as it's + * destination. + * i.e. invariant 2 + */ + cptr = kimage_dst_conflict(image, page, limit); + if (cptr) { + unsigned long cpage; + kimage_entry_t centry; + centry = *cptr; + cpage = centry & PAGE_MASK; + memcpy(phys_to_virt(buffer), phys_to_virt(page), PAGE_SIZE); + memcpy(phys_to_virt(page), phys_to_virt(cpage), PAGE_SIZE); + *cptr = page | (centry & ~PAGE_MASK); + *ptr = buffer | (entry & ~PAGE_MASK); + buffer = cpage; + } + if (!(entry & IND_SOURCE)) { + continue; + } + + /* See if a previous page is our destination page. + * If so claim it now. + * i.e. invariant 3 + */ + cptr = kimage_src_conflict(image, destination, limit); + if (cptr) { + unsigned long cpage; + kimage_entry_t centry; + centry = *cptr; + cpage = centry & PAGE_MASK; + memcpy(phys_to_virt(buffer), phys_to_virt(cpage), PAGE_SIZE); + memcpy(phys_to_virt(cpage), phys_to_virt(page), PAGE_SIZE); + *cptr = buffer | (centry & ~PAGE_MASK); + *ptr = cpage | ( entry & ~PAGE_MASK); + buffer = page; + } + /* If the buffer is my destination page do the copy now + * i.e. invariant 3 & 1 + */ + if (buffer == destination) { + memcpy(phys_to_virt(buffer), phys_to_virt(page), PAGE_SIZE); + *ptr = buffer | (entry & ~PAGE_MASK); + buffer = page; + } + } + free_page((unsigned long)phys_to_virt(buffer)); + return 0; +} + +static int kimage_add_empty_pages(struct kimage *image, + unsigned long len) +{ + unsigned long pos; + int result; + for(pos = 0; pos < len; pos += PAGE_SIZE) { + char *page; + result = -ENOMEM; + page = (void *)get_free_page(GFP_KERNEL); + if (!page) { + goto out; + } + result = kimage_add_page(image, virt_to_phys(page)); + if (result) { + goto out; + } + } + result = 0; + out: + return result; +} + + +static int kimage_load_segment(struct kimage *image, + struct kexec_segment *segment) +{ + unsigned long buf_start, buf_end; + unsigned long mstart; + int result; + unsigned long offset; + unsigned long offset_end; + unsigned char *buf; + + result = 0; + buf = segment->buf; + mstart = (unsigned long)segment->mem; + + offset_end = segment->memsz; + + result = kimage_set_destination(image, mstart); + if (result < 0) { + goto out; + } + for(offset = 0; offset < segment->memsz; offset += PAGE_SIZE) { + char *page; + size_t size, leader; + page = (char *)__get_free_page(GFP_KERNEL); + if (page == 0) { + result = -ENOMEM; + goto out; + } + result = kimage_add_page(image, virt_to_phys(page)); + if (result < 0) { + goto out; + } + if (segment->bufsz < offset) { + /* We are past the end zero the whole page */ + memset(page, 0, PAGE_SIZE); + continue; + } + size = PAGE_SIZE; + leader = 0; + if ((offset == 0)) { + leader = mstart & ~PAGE_MASK; + } + if (leader) { + /* We are on the first page zero the unused portion */ + memset(page, 0, leader); + size -= leader; + page += leader; + } + if (size > (segment->bufsz - offset)) { + size = segment->bufsz - offset; + } + result = copy_from_user(page, buf + offset, size); + if (result) { + result = (result < 0)?result : -EIO; + goto out; + } + if (size < (PAGE_SIZE - leader)) { + /* zero the trailing part of the page */ + memset(page + size, 0, (PAGE_SIZE - leader) - size); + } + } + out: + return result; +} + + +/* do_kexec executes a new kernel + */ +int do_kexec(unsigned long start, int nr_segments, + struct kexec_segment *arg_segments, struct kimage *image) +{ + struct kexec_segment *segments; + size_t segment_bytes; + int i; + + int result; + unsigned long reboot_code_buffer; + kimage_entry_t *end; + + /* Initialize variables */ + segments = 0; + + /* We only trust the superuser with rebooting the system. */ + if (!capable(CAP_SYS_BOOT)) { + result = -EPERM; + goto out; + } + + if (nr_segments <= 0) { + result = -EINVAL; + goto out; + } + segment_bytes = nr_segments * sizeof(*segments); + segments = kmalloc(GFP_KERNEL, segment_bytes); + if (segments == 0) { + result = -ENOMEM; + goto out; + } + result = copy_from_user(segments, arg_segments, segment_bytes); + if (result) { + goto out; + } +#if DEBUG + for(i = 0; i < nr_segments; i++) { + printk(KERN_EMERG "k_segment[%d].buf = %p\n", i, segments[i].buf); + printk(KERN_EMERG "k_segment[%d].bufsz = 0x%x\n", i, segments[i].bufsz); + printk(KERN_EMERG "k_segment[%d].mem = %p\n", i, segments[i].mem); + printk(KERN_EMERG "k_segment[%d].memsz = 0x%x\n", i, segments[i].memsz); + } + printk(KERN_EMERG "k_entry = 0x%08lx\n", start); + printk(KERN_EMERG "k_nr_segments = %d\n", nr_segments); + printk(KERN_EMERG "k_segments = %p\n", segments); +#endif + + /* Read in the data from user space */ + image->start = start; + for(i = 0; i < nr_segments; i++) { + result = kimage_load_segment(image, &segments[i]); + if (result) { + goto out; + } + } + + /* Terminate early so I can get a place holder. */ + result = kimage_terminate(image); + if (result) + goto out; + end = image->entry; + + /* Usage of the reboot code buffer is sublte. We first + * find a continguous area of ram, that is not one + * of our destination pages. We do not allocate the ram. + * + * The algorithm to make certain we do not have address + * conflicts requires each destination region to have some + * backing store so we allocate abitrary source pages. + * + * Later in machine_kexec when we copy data to the + * reboot_code_buffer it still may be allocated for other + * purposes, but we do know there are no source or destination + * pages in that area. And since the rest of the kernel + * is already shutdown those pages are free for use, + * regardless of their page->count values. + */ + result = kimage_get_unused_area( + image, KEXEC_REBOOT_CODE_SIZE, KEXEC_REBOOT_CODE_ALIGN, + &reboot_code_buffer); + if (result) + goto out; + + /* Allocating pages we should never need is silly but the + * code won't work correctly unless we have dummy pages to + * work with. + */ + result = kimage_set_destination(image, reboot_code_buffer); + if (result) + goto out; + result = kimage_add_empty_pages(image, KEXEC_REBOOT_CODE_SIZE); + if (result) + goto out; + image->reboot_code_buffer = phys_to_virt(reboot_code_buffer); + + result = kimage_terminate(image); + if (result) + goto out; + + result = kimage_get_off_destination_pages(image); + if (result) + goto out; + +#if DEBUG + kimage_print_image(image); +#endif + + /* Now hide the extra source pages for the reboot code buffer + * What is the logic with the reboot code buffer, should it + * be mapped 1-1 by this point FIXME verify this? + */ + image->entry = end; + result = kimage_terminate(image); + if (result) + goto out; + +#if DEBUG + kimage_print_image(image); +#endif + + result = 0; + out: + /* cleanup and exit */ + if (segments) kfree(segments); + return result; +} + diff -uNr linux-2.5.7.kexec.reboot/kernel/sys.c linux-2.5.7.kexec.generic/kernel/sys.c --- linux-2.5.7.kexec.reboot/kernel/sys.c Wed Mar 20 07:18:49 2002 +++ linux-2.5.7.kexec.generic/kernel/sys.c Sat Mar 30 17:10:28 2002 @@ -15,6 +15,7 @@ #include #include #include +#include #include #include @@ -323,6 +324,38 @@ printk(KERN_EMERG "Restarting system with command '%s'.\n", buffer); machine_restart(buffer); break; + +#if CONFIG_KEXEC + case LINUX_REBOOT_CMD_KEXEC: + { + /* Am I using to much stack space here? */ + struct kexec_args args; + struct kimage image; + int result; + + result = copy_from_user(&args, arg, sizeof(args)); + if (result) { + unlock_kernel(); + return result; + } + kimage_init(&image); + result = do_kexec(args.entry, args.nr_segments, args.segments, &image); + if (result) { + kimage_free(&image); + unlock_kernel(); + return result; + } + + /* The point of no return is here... */ + notifier_call_chain(&reboot_notifier_list, SYS_RESTART, NULL); + + machine_kexec(&image); + /* We never get here but... */ + kimage_free(&image); + unlock_kernel(); + break; + } +#endif /* CONFIG_KEXEC */ default: unlock_kernel();