diff -ruNp 800-suspend2.patch-old/include/linux/kernel.h 800-suspend2.patch-new/include/linux/kernel.h --- 800-suspend2.patch-old/include/linux/kernel.h 2005-07-30 15:42:47.000000000 +1000 +++ 800-suspend2.patch-new/include/linux/kernel.h 2005-07-30 21:14:46.000000000 +1000 @@ -103,6 +103,8 @@ extern int vsprintf(char *buf, const cha __attribute__ ((format (printf, 2, 0))); extern int snprintf(char * buf, size_t size, const char * fmt, ...) __attribute__ ((format (printf, 3, 4))); +extern int snprintf_used(char * buffer, int buffer_size, + const char *fmt, ...); extern int vsnprintf(char *buf, size_t size, const char *fmt, va_list args) __attribute__ ((format (printf, 3, 0))); extern int scnprintf(char * buf, size_t size, const char * fmt, ...) diff -ruNp 800-suspend2.patch-old/include/linux/netlink.h 800-suspend2.patch-new/include/linux/netlink.h --- 800-suspend2.patch-old/include/linux/netlink.h 2005-07-30 15:42:48.000000000 +1000 +++ 800-suspend2.patch-new/include/linux/netlink.h 2005-07-30 21:26:04.000000000 +1000 @@ -21,8 +21,9 @@ #define NETLINK_DNRTMSG 14 /* DECnet routing messages */ #define NETLINK_KOBJECT_UEVENT 15 /* Kernel messages to userspace */ #define NETLINK_TAPBASE 16 /* 16 to 31 are ethertap */ +#define NETLINK_SUSPEND2_USERUI 32 /* For suspend2's userui */ -#define MAX_LINKS 32 +#define MAX_LINKS 33 struct sockaddr_nl { diff -ruNp 800-suspend2.patch-old/include/linux/suspend2.h 800-suspend2.patch-new/include/linux/suspend2.h --- 800-suspend2.patch-old/include/linux/suspend2.h 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/include/linux/suspend2.h 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,217 @@ +#ifndef _LINUX_SUSPEND2_H +#define _LINUX_SUSPEND2_H + +#include +#include + +/* arch/i386/mm/init.c */ +extern char __nosave_begin, __nosave_end; + +extern char __nosavedata swsusp_pg_dir[PAGE_SIZE] + __attribute__ ((aligned (PAGE_SIZE))); + +#define SECTOR_SIZE 512 + +/* kernel/power/process.c */ + +/* fs/buffer.c */ +extern unsigned int suspend_task; + +#define SUSPEND_KEY_KEYBOARD 1 +#define SUSPEND_KEY_SERIAL 2 + +/* kernel/power/main.c */ +extern unsigned long suspend_result; + +/* kernel/power/process.c */ +extern unsigned long suspend_debug_state; + +/* arch/i386/power/suspend2.c */ +extern unsigned long suspend_action; +extern int suspend_io_time[2][2]; + +/* Pre and post lowlevel routines */ +//extern void suspend2_suspend_1 (void); +//extern void suspend2_suspend_2 (void); +//extern void suspend2_resume_1 (void); +//extern void suspend2_resume_2 (void); + +extern dyn_pageflags_t pageset1_map; +extern dyn_pageflags_t pageset1_copy_map; + +#ifdef CONFIG_PM_DEBUG +#define test_debug_state(bit) (test_bit(bit, &suspend_debug_state)) +#else +#define test_debug_state(bit) (0) +#endif + +#define test_result_state(bit) (test_bit(bit, &suspend_result)) + +/* + * First status register - this is suspend's return code. + * + * All the rest are in kernel/power/suspend2_common.h + */ +#define SUSPEND_ABORTED 0 + +/* Second status register - ditto */ +#define SUSPEND_RETRY_RESUME 0 + +/* Debug sections - if debugging compiled in */ +enum { + SUSPEND_ANY_SECTION, + SUSPEND_FREEZER, + SUSPEND_EAT_MEMORY, + SUSPEND_PAGESETS, + SUSPEND_IO, + SUSPEND_BMAP, + SUSPEND_HEADER, + SUSPEND_WRITER, + SUSPEND_MEMORY, + SUSPEND_EXTENTS, + SUSPEND_SPINLOCKS, + SUSPEND_MEM_POOL, + SUSPEND_RANGE_PARANOIA, + SUSPEND_NOSAVE, + SUSPEND_INTEGRITY +}; + +/* debugging levels. */ +#define SUSPEND_STATUS 0 +#define SUSPEND_ERROR 2 +#define SUSPEND_LOW 3 +#define SUSPEND_MEDIUM 4 +#define SUSPEND_HIGH 5 +#define SUSPEND_VERBOSE 6 + +extern void __suspend_message(unsigned long section, unsigned long level, int log_normally, + const char *fmt, ...); + +#ifdef CONFIG_PM_DEBUG +#define suspend_message(sn, lev, log, fmt, a...) \ +do { \ + if (test_debug_state(sn)) \ + __suspend_message(sn, lev, log, fmt, ##a); \ +} while(0) +#else /* CONFIG_PM_DEBUG */ +#define suspend_message(sn, lev, log, fmt, a...) \ +do { \ + if (lev == 0) \ + __suspend_message(sn, lev, log, fmt, ##a); \ +} while(0) +#endif /* CONFIG_PM_DEBUG */ + +/* Suspend 2 */ + +enum { + SUSPEND_DISABLED, + SUSPEND_RUNNING, + SUSPEND_RESUME_DEVICE_OK, + SUSPEND_NORESUME_SPECIFIED, /* 0x8 */ + SUSPEND_COMMANDLINE_ERROR, + SUSPEND_IGNORE_IMAGE, + SUSPEND_SANITY_CHECK_PROMPT, + SUSPEND_FREEZER_ON, /* 0x80 */ + SUSPEND_DISABLE_SYNCING, + SUSPEND_BLOCK_PAGE_ALLOCATIONS, + SUSPEND_USE_MEMORY_POOL, + SUSPEND_STAGE2_CONTINUE, /* 0x800 */ + SUSPEND_FREEZE_SMP, + SUSPEND_PAGESET2_NOT_LOADED, + SUSPEND_CONTINUE_REQ, + SUSPEND_RESUMED_BEFORE, /* 0x8000 */ + SUSPEND_RUNNING_INITRD, + SUSPEND_RESUME_NOT_DONE, + SUSPEND_BOOT_TIME, + SUSPEND_NOW_RESUMING, /* 0x80000 */ + SUSPEND_SLAB_ALLOC_FALLBACK, + SUSPEND_IGNORE_LOGLEVEL, + SUSPEND_TIMER_FREEZER_ON, + SUSPEND_ACT_USED, /* 0x800000 */ + SUSPEND_DBG_USED, + SUSPEND_LVL_USED, + SUSPEND_TRYING_TO_RESUME, + SUSPEND_FORK_COPYBACK_THREAD, +}; + +#define test_and_set_suspend_state(bit) \ + (test_and_set_bit(bit, &software_suspend_state)) + +#define get_suspend_state() (software_suspend_state) +#define restore_suspend_state(saved_state) \ + do { software_suspend_state = saved_state; } while(0) + +/* Kernel threads are type 3 */ +#define FREEZER_ALL_THREADS 0 +#define FREEZER_KERNEL_THREADS 3 + +/* --------------------------------------------------------------------- */ +#ifdef CONFIG_SUSPEND2 + +/* Used in init dir files */ +extern unsigned long software_suspend_state; + +extern void suspend2_try_resume(void); +extern int suspend_early_boot_message + (int can_erase_image, int default_answer, char *warning_reason, ...); +extern void suspend_handle_keypress(unsigned int keycode, int source); +extern unsigned long suspend2_update_status (unsigned long value, unsigned long maximum, + const char *fmt, ...); +extern void suspend2_prepare_status (int clearbar, const char *fmt, ...); +extern void suspend2_cleanup_finished_io(void); + +#define test_suspend_state(bit) \ + (test_bit(bit, &software_suspend_state)) + +#define clear_suspend_state(bit) \ + (clear_bit(bit, &software_suspend_state)) + +#define set_suspend_state(bit) \ + (set_bit(bit, &software_suspend_state)) + +#ifdef CONFIG_SMP +void smp_pause(void); +void smp_continue(void); +void smp_suspend(void); +#else +#define smp_pause() do { } while(0) +#define smp_continue() do { } while(0) +#define smp_suspend() do { } while(0) +#endif + +extern inline void suspend2_copyback_low(void); +extern inline void suspend2_copyback_high(void); + +extern void suspend2_try_suspend(void); + +#ifdef CONFIG_DEBUG_PAGEALLOC +int suspend_map_kernel_page(struct page * page, int enable); +#else +static inline int suspend_map_kernel_page(struct page * page, int enable) +{ + return (enable == 1); +} +#endif + +/* --------------------------------------------------------------------- */ +#else +/* --------------------------------------------------------------------- */ + +#define software_suspend_state (0) +#define clear_suspend_state(bit) do { } while (0) +#define test_suspend_state(bit) (0) +#define set_suspend_state(bit) do { } while(0) + +#define suspend2_try_resume() do { } while(0) +static inline int suspend_early_boot_message(int a, int b, char *c, ...) { return 0; } +#define suspend_handle_keypress(a, b) do { } while(0) +static inline unsigned long suspend2_update_status(unsigned long value, unsigned long maximum, + const char *fmt, ...) +{ + return maximum; +} +#define suspend2_cleanup_finished_io() do { } while(0) +#define suspend2_prepare_status(a, ...) do { } while(0) + +#endif /* CONFIG_SUSPEND2 */ +#endif /* _LINUX_SUSPEND2_H */ diff -ruNp 800-suspend2.patch-old/include/linux/suspend.h 800-suspend2.patch-new/include/linux/suspend.h --- 800-suspend2.patch-old/include/linux/suspend.h 2005-07-30 15:42:48.000000000 +1000 +++ 800-suspend2.patch-new/include/linux/suspend.h 2005-07-30 21:14:46.000000000 +1000 @@ -9,6 +9,7 @@ #include #include #include +#include /* page backup entry */ typedef struct pbe { @@ -72,4 +73,5 @@ struct saved_context; void __save_processor_state(struct saved_context *ctxt); void __restore_processor_state(struct saved_context *ctxt); +extern char resume2_file[256]; #endif /* _LINUX_SWSUSP_H */ diff -ruNp 800-suspend2.patch-old/kernel/power/atomic_copy.c 800-suspend2.patch-new/kernel/power/atomic_copy.c --- 800-suspend2.patch-old/kernel/power/atomic_copy.c 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/atomic_copy.c 2005-07-30 21:26:04.000000000 +1000 @@ -0,0 +1,431 @@ +/* + * At the moment, we do nothing about APICs, even though the code is there. + */ + +#include +#include +#include +#include +#include +#include +#include +#include "suspend2_common.h" +#include "io.h" +#include "power_off.h" +#include "version.h" +#include "driver_model.h" +#include "ui.h" +#include "plugins.h" +#include "atomic_copy.h" +#include "suspend2.h" +#include "checksum.h" +#include "pageflags.h" + +volatile static int state1 __nosavedata = 0; +volatile static int state2 __nosavedata = 0; +volatile static int state3 __nosavedata = 0; +volatile static int io_speed_save[2][2] __nosavedata; + +static dyn_pageflags_t __nosavedata origmap; +static dyn_pageflags_t __nosavedata copymap; +static int __nosavedata origoffset; +static int __nosavedata copyoffset; +static int __nosavedata loop; + +__nosavedata char resume_commandline[COMMAND_LINE_SIZE]; + +static atomic_t atomic_copy_hold; +static atomic_t restore_thread_ready; + +suspend2_saved_context_t suspend2_saved_context; /* temporary storage */ +cpumask_t saved_affinity[NR_IRQS]; + +/** + * copyback_prepare + * Functionality : Preparatory steps for copying the original kernel back. + * Called From : do_suspend2_lowlevel + **/ + +static void copyback_prepare(void) +{ + int loop; + + state1 = suspend_action; + state2 = suspend_debug_state; + state3 = console_loglevel; + for (loop = 0; loop < 4; loop++) + io_speed_save[loop/2][loop%2] = + suspend_io_time[loop/2][loop%2]; + + memcpy(resume_commandline, saved_command_line, COMMAND_LINE_SIZE); + + /* Arch specific preparation */ + suspend2_arch_pre_copyback(); + + suspend_message(SUSPEND_ANY_SECTION, SUSPEND_LOW, 1, + name_suspend "About to copy pageset1 back...\n"); + + suspend_drivers_suspend(SUSPEND_DRIVERS_IRQS_ENABLED); + local_irq_disable(); /* irqs might have been re-enabled on us */ + + suspend_drivers_suspend(SUSPEND_DRIVERS_IRQS_DISABLED); + local_irq_enable(); + + suspend2_map_atomic_copy_pages(); + + local_irq_disable(); + + preempt_disable(); + + barrier(); + mb(); +} + +/* + * copyback_post + * Functionality : Steps taken after copying back the original kernel at + * resume. + * Key Assumptions : Will be able to read back secondary pagedir (if + * applicable). + * Called From : do_suspend2_lowlevel + */ + +static void copyback_post(void) +{ + int loop; + + /* Arch specific code */ + suspend2_arch_post_copyback(); + + suspend_action = state1; + suspend_debug_state = state2; + console_loglevel = state3; + + for (loop = 0; loop < 4; loop++) + suspend_io_time[loop/2][loop%2] = + io_speed_save[loop/2][loop%2]; + + set_suspend_state(SUSPEND_NOW_RESUMING); + set_suspend_state(SUSPEND_PAGESET2_NOT_LOADED); + + suspend2_unmap_atomic_copy_pages(); + + preempt_enable(); + + local_irq_disable(); + suspend_drivers_resume(SUSPEND_DRIVERS_IRQS_DISABLED); + local_irq_enable(); + + suspend_drivers_resume(SUSPEND_DRIVERS_IRQS_ENABLED); + + userui_redraw(); + + check_shift_keys(1, "About to reload secondary pagedir."); + + read_pageset2(0); + clear_suspend_state(SUSPEND_PAGESET2_NOT_LOADED); + + suspend2_prepare_status(DONT_CLEAR_BAR, "Cleaning up..."); +} + + +/* + * suspend2_pre_copy + * Functionality : Steps taken prior to saving CPU state and the image + * itself. + * Called From : do_suspend2_lowlevel + */ + +static void suspend2_pre_copy(void) +{ + suspend2_arch_pre_copy(); + + suspend_drivers_suspend(SUSPEND_DRIVERS_IRQS_ENABLED); + + mb(); + barrier(); + + preempt_disable(); + local_irq_disable(); + + suspend_drivers_suspend(SUSPEND_DRIVERS_IRQS_DISABLED); +} + +/* + * suspend2_post_copy + * Functionality : Steps taken after saving CPU state to save the + * image and powerdown/reboot or recover on failure. + * Key Assumptions : save_image returns zero on success; otherwise we need to + * clean up and exit. The state on exiting this routine + * should be essentially the same as if we have suspended, + * resumed and reached the end of copyback_post. + * Called From : do_suspend2_lowlevel + */ +extern void suspend_power_down(void); + +static void suspend2_post_copy(void) +{ + suspend2_arch_post_copy(); + + if (!save_image_part1()) { + suspend_power_down(); + + if (suspend2_powerdown_method == PM_SUSPEND_MEM) { + int temp_result; + + temp_result = read_pageset2(1); + + /* If that failed, we're sunk. Panic! */ + if (temp_result) + panic("Attempt to reload pagedir 2 failed. Try rebooting."); + } + } + + if (!test_result_state(SUSPEND_ABORT_REQUESTED) && + !test_action_state(SUSPEND_TEST_FILTER_SPEED) && + suspend2_powerdown_method != PM_SUSPEND_MEM) + printk(KERN_EMERG name_suspend + "Suspend failed, trying to recover...\n"); + barrier(); + mb(); +} + +/* + * copyback_low + */ + +static inline void copyback_low(void) +{ + unsigned long * origpage; + unsigned long * copypage; + + origmap = pageset1_map; + copymap = pageset1_copy_map; + + origoffset = __get_next_bit_on(origmap, -1); + copyoffset = __get_next_bit_on(copymap, -1); + + while ((origoffset < max_mapnr) && (!PageHighMem(pfn_to_page(origoffset)))) { + origpage = (unsigned long *) __va(origoffset << PAGE_SHIFT); + copypage = (unsigned long *) __va(copyoffset << PAGE_SHIFT); + + loop = (PAGE_SIZE / sizeof(unsigned long)) - 1; + + while (loop >= 0) { + *(origpage + loop) = *(copypage + loop); + loop--; + } + + origoffset = __get_next_bit_on(origmap, origoffset); + copyoffset = __get_next_bit_on(copymap, copyoffset); + } +} + +/* + * copyback_high + */ +void copyback_high(void) +{ + unsigned long * origpage; + unsigned long * copypage; + + while (origoffset < max_mapnr) { + origpage = (unsigned long *) kmap_atomic(pfn_to_page(origoffset), KM_USER1); + copypage = (unsigned long *) (lowmem_page_address(pfn_to_page(copyoffset))); + + memcpy(origpage, copypage, PAGE_SIZE); + + kunmap_atomic(origpage, KM_USER1); + + origoffset = __get_next_bit_on(origmap, origoffset); + copyoffset = __get_next_bit_on(copymap, copyoffset); + } +} + +void do_suspend2_lowlevel(int resume) +{ + if (!resume) { + + suspend2_pre_copy(); + + suspend2_arch_save_processor_context(); /* We need to capture registers and memory at "same time" */ + + suspend2_post_copy(); /* If everything goes okay, this function does not return */ + return; + } + +/* + * Final function for resuming: after copying the pages to their original + * position, it restores the register state. + * + * What about page tables? Writing data pages may toggle + * accessed/dirty bits in our page tables. That should be no problems + * with 4MB page tables. That's why we require have_pse. + * + * Critical section here: noone should touch saved memory after + * do_copyback_prepare. + * + * If we're running with DEBUG_PAGEALLOC, the boot and resume kernels both have + * all the pages we need mapped into kernel space, so we don't need to change + * page protections while doing the copy-back. + */ + + copyback_prepare(); + + copyback_low(); /* 0 = use logical addresses */ + + suspend2_arch_restore_processor_context(); + suspend2_arch_flush_caches(); + + /* Now we are running with our old stack, and with registers copied + * from suspend time. Let's copy back those remaining highmem pages. */ + copyback_high(); + suspend2_arch_flush_caches(); + + copyback_post(); +} + +/* suspend_copy_pageset1 + * + * Description: Make the atomic copy of pageset1. We can't use copy_page (as we + * once did) because we can't be sure what side effects it has. On + * my old Duron, with 3DNOW, kernel_fpu_begin increments preempt + * count, making our preempt count at resume time 4 instead of 3. + * + * We don't want to call kmap_atomic unconditionally because it has + * the side effect of incrementing the preempt count, which will + * leave it one too high post resume (the page containing the + * preempt count will be copied after its incremented. This is + * essentially the same problem. + */ + +void suspend2_copy_pageset1(void) +{ + int i, source_index = -1, dest_index = -1; + + for (i = 0; i < pagedir1.pageset_size; i++) { + unsigned long * origvirt, *copyvirt; + struct page * origpage; + int loop = (PAGE_SIZE / sizeof(unsigned long)) - 1; + + source_index = __get_next_bit_on(pageset1_map, source_index); + dest_index = __get_next_bit_on(pageset1_copy_map, dest_index); + + origpage = pfn_to_page(source_index); + + copyvirt = (unsigned long *) page_address(pfn_to_page(dest_index)); + + if (PageHighMem(origpage)) + origvirt = kmap_atomic(origpage, KM_USER1); + else + origvirt = page_address(origpage); + + while (loop >= 0) { + *(copyvirt + loop) = *(origvirt + loop); + loop--; + } + + + if (PageHighMem(origpage)) + kunmap_atomic(origvirt, KM_USER1); + } +} + +/* + * suspend2_map_atomic_copy_pages + * + * When DEBUG_PAGEALLOC is enabled, we need to map the pages before + * an atomic copy. + */ +#ifdef CONFIG_DEBUG_PAGEALLOC +void suspend2_map_atomic_copy_pages(void) +{ + int i = 0, source_index = -1, dest_index = -1; + + for (i = 0; i < pagedir1.pageset_size; i++) { + int orig_was_mapped = 1, copy_was_mapped = 1; + struct page * origpage, * copypage; + + source_index = __get_next_bit_on(pageset1_map, source_index); + dest_index = __get_next_bit_on(pageset1_copy_map, dest_index); + + origpage = pfn_to_page(source_index); + copypage = pfn_to_page(dest_index); + + if (!PageHighMem(origpage)) { + orig_was_mapped = suspend_map_kernel_page(origpage, 1); + if ((!orig_was_mapped) && + (!test_suspend_state(SUSPEND_NOW_RESUMING))) + SetPageUnmap(origpage); + } + + copy_was_mapped = suspend_map_kernel_page(copypage, 1); + if ((!copy_was_mapped) && + (!test_suspend_state(SUSPEND_NOW_RESUMING))) + SetPageUnmap(copypage); + } +} + +/* + * suspend2_unmap_atomic_copy_pages + * + * We also need to unmap pages when DEBUG_PAGEALLOC is enabled. + */ +void suspend2_unmap_atomic_copy_pages(void) +{ + int i; + for (i = 0; i < max_mapnr; i++) { + struct page * page = pfn_to_page(i); + if (PageUnmap(page)) + suspend_map_kernel_page(page, 0); + } +} +#endif + +int __suspend_atomic_restore(void *data) +{ + BUG_ON(PagePageset1(virt_to_page(current->thread_info))); + + atomic_set(&restore_thread_ready, 1); + + while atomic_read(&atomic_copy_hold) + schedule(); + + suspend2_prepare_status(DONT_CLEAR_BAR, "Freezing processes"); + + /* + * If you're hitting this BUG_ON, you have a process that's + * not freezing which is started prior to this. + */ + BUG_ON(freeze_processes(1)); + + suspend2_prepare_status(DONT_CLEAR_BAR, + "Copying original kernel back"); + + do_suspend2_lowlevel(1); + + BUG(); + + return 0; +} + +void suspend_atomic_restore(void) +{ + disable_nonboot_cpus(); + + set_suspend_state(SUSPEND_FORK_COPYBACK_THREAD); + + /* Now start the new thread */ + BUG_ON((kernel_thread(__suspend_atomic_restore, 0, + CLONE_KERNEL) < 0)); + + while (!atomic_read(&restore_thread_ready)) + schedule(); + + atomic_set(&atomic_copy_hold, 0); + + while(1) { + try_to_freeze(); + schedule(); + } +} diff -ruNp 800-suspend2.patch-old/kernel/power/atomic_copy.h 800-suspend2.patch-new/kernel/power/atomic_copy.h --- 800-suspend2.patch-old/kernel/power/atomic_copy.h 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/atomic_copy.h 2005-07-30 21:26:04.000000000 +1000 @@ -0,0 +1,3 @@ +extern inline void move_stack_to_nonconflicing_area(void); +extern int save_image_part1(void); +extern void suspend_atomic_restore(void); diff -ruNp 800-suspend2.patch-old/kernel/power/block_io.h 800-suspend2.patch-new/kernel/power/block_io.h --- 800-suspend2.patch-old/kernel/power/block_io.h 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/block_io.h 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,57 @@ +/* + * block_io.h + * + * Copyright 2004-2005 Nigel Cunningham + * + * Distributed under GPLv2. + * + * This file contains declarations for functions exported from + * block_io.c, which contains low level io functions. + */ + +#include + +/* + * The maximum amount of I/O we submit at once. + */ +#define MAX_READAHEAD 1024 + +/* Forward Declarations */ + +/* + * submit_params + * + * The structure we use for tracking submitted I/O. + */ +struct submit_params { + swp_entry_t swap_address; + struct page * page; + struct block_device * dev; + sector_t block[MAX_BUF_PER_PAGE]; + int readahead_index; + struct submit_params * next; +}; + + +/* + * Our exported interface so the swapwriter and filewriter don't + * need these functions duplicated. + */ +struct suspend_bio_ops { + int (*set_block_size) (struct block_device * bdev, int size); + int (*get_block_size) (struct block_device * bdev); + int (*submit_io) (int rw, + struct submit_params * submit_info, int syncio); + int (*bdev_page_io) (int rw, struct block_device * bdev, long pos, + struct page * page); + void (*wait_on_readahead) (int readahead_index); + void (*check_io_stats) (void); + void (*reset_io_stats) (void); + void (*finish_all_io) (void); + int (*prepare_readahead) (int index); + void (*cleanup_readahead) (int index); + struct page ** readahead_pages; + int (*readahead_ready) (int readahead_index); +}; + +extern struct suspend_bio_ops suspend_bio_ops; diff -ruNp 800-suspend2.patch-old/kernel/power/compression.c 800-suspend2.patch-new/kernel/power/compression.c --- 800-suspend2.patch-old/kernel/power/compression.c 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/compression.c 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,637 @@ +/* + * kernel/power/suspend2_core/compression.c + * + * Copyright (C) 2003-2005 Nigel Cunningham + * + * This file is released under the GPLv2. + * + * This file contains data compression routines for suspend, + * using LZH compression. + * + */ + +#include +#include +#include +#include +#include + +#include "suspend2.h" +#include "plugins.h" +#include "proc.h" +#include "suspend2_common.h" +#include "io.h" + +#define S2C_WRITE 0 +#define S2C_READ 1 + +static int s2_expected_compression = 0; + +static struct suspend_plugin_ops s2_compression_ops; +static struct suspend_plugin_ops * next_driver; + +static char s2_compressor_name[32]; +static struct crypto_tfm * s2_compressor_transform; + +static u8 *local_buffer = NULL; +static u8 *page_buffer = NULL; +static unsigned int bufofs; + +static int position = 0; + +/* ---- Local buffer management ---- */ + +/* allocate_local_buffer + * + * Description: Allocates a page of memory for buffering output. + * Returns: Int: Zero if successful, -ENONEM otherwise. + */ + +static int allocate_local_buffer(void) +{ + if (!local_buffer) { + local_buffer = (char *) get_zeroed_page(GFP_ATOMIC); + + if (!local_buffer) { + printk(KERN_ERR + "Failed to allocate the local buffer for " + "suspend2 compression driver.\n"); + return -ENOMEM; + } + } + + if (!page_buffer) { + page_buffer = (char *) get_zeroed_page(GFP_ATOMIC); + + if (!page_buffer) { + printk(KERN_ERR + "Failed to allocate the page buffer for " + "suspend2 compression driver.\n"); + return -ENOMEM; + } + } + + return 0; +} + +/* free_local_buffer + * + * Description: Frees memory allocated for buffering output. + */ + +static inline void free_local_buffer(void) +{ + if (local_buffer) + free_page((unsigned long) local_buffer); + + local_buffer = NULL; + + if (page_buffer) + free_page((unsigned long) page_buffer); + + page_buffer = NULL; +} + +/* suspend2_crypto_cleanup + * + * Description: Frees memory allocated for our labours. + */ + +static void suspend2_crypto_cleanup(void) +{ + if (s2_compressor_transform) { + crypto_free_tfm(s2_compressor_transform); + s2_compressor_transform = NULL; + } +} + +/* suspend2_crypto_prepare + * + * Description: Prepare to do some work by allocating buffers and transforms. + * Returns: Int: Zero if successful, -ENONEM otherwise. + */ + +static int s2_compress_crypto_prepare(int mode) +{ + if (!*s2_compressor_name) { + printk("Suspend2: Compression enabled but no compressor name set.\n"); + return 1; + } + + if (!(s2_compressor_transform = crypto_alloc_tfm(s2_compressor_name, 0))) { + printk("Suspend2: Failed to initialise the compression transform.\n"); + return 1; + } + + return 0; +} + +/* ---- Exported functions ---- */ + +/* write_init() + * + * Description: Allocate buffers and prepare to compress data. + * Arguments: Stream_number: Ignored. + * Returns: Zero on success, -ENOMEM if unable to vmalloc. + */ + +static int s2_compress_write_init(int stream_number) +{ + int result; + + next_driver = get_next_filter(&s2_compression_ops); + + if (!next_driver) { + printk("Compression Driver: Argh! No one wants my output!"); + return -ECHILD; + } + + if ((result = s2_compress_crypto_prepare(S2C_WRITE))) { + return result; + } + + if ((result = allocate_local_buffer())) + return result; + + /* Only reset the stats if starting to write an image */ + if (stream_number == 2) + bytes_in = bytes_out = 0; + + bufofs = 0; + + position = 0; + + return 0; +} + +/* s2_compress_write() + * + * Description: Helper function for write_chunk. Write the compressed data. + * Arguments: u8*: Output buffer to be written. + * unsigned int: Length of buffer. + * Return: int: Result to be passed back to caller. + */ + +static int s2_compress_write (u8 *buffer, unsigned int len) +{ + int ret; + + bytes_out += len; + + while (len + bufofs > PAGE_SIZE) { + unsigned int chunk = PAGE_SIZE - bufofs; + memcpy (local_buffer + bufofs, buffer, chunk); + buffer += chunk; + len -= chunk; + bufofs = 0; + if ((ret = next_driver->ops.filter.write_chunk(virt_to_page(local_buffer))) < 0) + return ret; + } + memcpy (local_buffer + bufofs, buffer, len); + bufofs += len; + return 0; +} + +/* s2_compress_write_chunk() + * + * Description: Compress a page of data, buffering output and passing on + * filled pages to the next plugin in the pipeline. + * Arguments: Buffer_page: Pointer to a buffer of size PAGE_SIZE, + * containing data to be compressed. + * Returns: 0 on success. Otherwise the error is that returned by later + * plugins, -ECHILD if we have a broken pipeline or -EIO if + * zlib errs. + */ + +static int s2_compress_write_chunk(struct page * buffer_page) +{ + int ret; + unsigned int len; + u16 len_written; + char * buffer_start; + + if (!s2_compressor_transform) + return next_driver->ops.filter.write_chunk(buffer_page); + + buffer_start = kmap(buffer_page); + + bytes_in += PAGE_SIZE; + + len = PAGE_SIZE; + + ret = crypto_comp_compress(s2_compressor_transform, + buffer_start, PAGE_SIZE, + page_buffer, &len); + + if (ret) { + printk("Compression failed.\n"); + goto failure; + } + + len_written = (u16) len; + + if ((ret = s2_compress_write((u8 *)&len_written, 2)) >= 0) { + if ((ret = s2_compress_write((u8 *) &position, sizeof(position)))) + return -EIO; + if (len < PAGE_SIZE) { // some compression + position += len; + ret = s2_compress_write(page_buffer, len); + } else { + ret = s2_compress_write(buffer_start, PAGE_SIZE); + position += PAGE_SIZE; + } + } + position += 2 + sizeof(int); + + +failure: + kunmap(buffer_page); + return ret; +} + +/* write_cleanup() + * + * Description: Write unflushed data and free workspace. + * Returns: Result of writing last page. + */ + +static int s2_compress_write_cleanup(void) +{ + int ret = 0; + + if (s2_compressor_transform) + ret = next_driver->ops.filter.write_chunk(virt_to_page(local_buffer)); + + suspend2_crypto_cleanup(); + free_local_buffer(); + + return ret; +} + +/* read_init() + * + * Description: Prepare to read a new stream of data. + * Arguments: int: Section of image about to be read. + * Returns: int: Zero on success, error number otherwise. + */ + +static int s2_compress_read_init(int stream_number) +{ + int result; + + next_driver = get_next_filter(&s2_compression_ops); + + if (!next_driver) { + printk("Compression Driver: Argh! No one wants " + "to feed me data!"); + return -ECHILD; + } + + if ((result = s2_compress_crypto_prepare(S2C_READ))) + return result; + + if ((result = allocate_local_buffer())) + return result; + + bufofs = PAGE_SIZE; + + position = 0; + + return 0; +} + +/* s2_compress_read() + * + * Description: Read data into compression buffer. + * Arguments: u8 *: Address of the buffer. + * unsigned int: Length + * Returns: int: Result of reading the image chunk. + */ + +static int s2_compress_read (u8 * buffer, unsigned int len) +{ + int ret; + + while (len + bufofs > PAGE_SIZE) { + unsigned int chunk = PAGE_SIZE - bufofs; + memcpy(buffer, local_buffer + bufofs, chunk); + buffer += chunk; + len -= chunk; + bufofs = 0; + if ((ret = next_driver->ops.filter.read_chunk( + virt_to_page(local_buffer), SUSPEND_SYNC)) < 0) { + return ret; + } + } + memcpy (buffer, local_buffer + bufofs, len); + bufofs += len; + return 0; +} + +/* s2_compress_read_chunk() + * + * Description: Retrieve data from later plugins and decompress it until the + * input buffer is filled. + * Arguments: Buffer_start: Pointer to a buffer of size PAGE_SIZE. + * Sync: Whether the previous plugin (or core) wants its + * data synchronously. + * Returns: Zero if successful. Error condition from me or from downstream + * on failure. + */ + +static int s2_compress_read_chunk(struct page * buffer_page, int sync) +{ + int ret, position_saved; + unsigned int len; + u16 len_written; + char * buffer_start; + + if (!s2_compressor_transform) + return next_driver->ops.filter.read_chunk(buffer_page, SUSPEND_ASYNC); + + /* + * All our reads must be synchronous - we can't decompress + * data that hasn't been read yet. + */ + + buffer_start = kmap(buffer_page); + + if ((ret = s2_compress_read ((u8 *)&len_written, 2)) >= 0) { + len = (unsigned int) len_written; + ret = s2_compress_read((u8 *) &position_saved, sizeof(position_saved)); + if (ret) + return ret; + + if (position != position_saved) { + printk("Position saved (%d) != position I'm at now (%d).\n", + position_saved, position); + BUG_ON(1); + } + if (len >= PAGE_SIZE) { // uncompressed + ret = s2_compress_read(buffer_start, PAGE_SIZE); + if (ret) + return ret; + + position += PAGE_SIZE; + } else { // compressed + if ((ret = s2_compress_read(page_buffer, len)) >= 0) { + int outlen = PAGE_SIZE; + /* Important note. + * + * For Deflate, decompression return values may represent + * errors. Deflate complains when everything is alright, so + * we ignore the errors unless the number of output bytes is + * not PAGE_SIZE. + */ + crypto_comp_decompress(s2_compressor_transform, + page_buffer, len, + buffer_start, &outlen); + if (outlen != PAGE_SIZE) { + printk("Decompression yielded %ld bytes instead of %d.\n", PAGE_SIZE, outlen); + ret = -EIO; + } else + ret = 0; + } + position += len; + } + position += 2 + sizeof(int); + } else + printk("Compress_read returned %d.", ret); + kunmap(buffer_page); + return ret; +} + +/* read_cleanup() + * + * Description: Clean up after reading part or all of a stream of data. + * Returns: int: Always zero. Never fails. + */ + +static int s2_compress_read_cleanup(void) +{ + suspend2_crypto_cleanup(); + free_local_buffer(); + return 0; +} + +/* s2_compress_print_debug_stats + * + * Description: Print information to be recorded for debugging purposes into a + * buffer. + * Arguments: buffer: Pointer to a buffer into which the debug info will be + * printed. + * size: Size of the buffer. + * Returns: Number of characters written to the buffer. + */ + +static int s2_compress_print_debug_stats(char * buffer, int size) +{ + int pages_in = bytes_in >> PAGE_SHIFT, + pages_out = bytes_out >> PAGE_SHIFT; + int len; + + /* Output the compression ratio achieved. */ + len = snprintf_used(buffer, size, "- Compressor %s enabled.\n", + s2_compressor_name); + if (pages_in) + len+= snprintf_used(buffer+len, size - len, + " Compressed %ld bytes into %ld (%d percent compression).\n", + bytes_in, bytes_out, (pages_in - pages_out) * 100 / pages_in); + return len; +} + +/* compression_memory_needed + * + * Description: Tell the caller how much memory we need to operate during + * suspend/resume. + * Returns: Unsigned long. Maximum number of bytes of memory required for + * operation. + */ + +static unsigned long s2_compress_memory_needed(void) +{ + return PAGE_SIZE; +} + +static unsigned long s2_compress_storage_needed(void) +{ + return 2 * sizeof(unsigned long) + sizeof(int); +} + +/* s2_compress_save_config_info + * + * Description: Save informaton needed when reloading the image at resume time. + * Arguments: Buffer: Pointer to a buffer of size PAGE_SIZE. + * Returns: Number of bytes used for saving our data. + */ + +static int s2_compress_save_config_info(char * buffer) +{ + int namelen = strlen(s2_compressor_name) + 1; + int total_len; + + *((unsigned long *) buffer) = bytes_in; + *((unsigned long *) (buffer + sizeof(unsigned long))) = bytes_out; + *((int *) (buffer + 2 * sizeof(unsigned long))) = s2_expected_compression; + *((int *) (buffer + 3 * sizeof(unsigned long))) = namelen; + strncpy(buffer + 4 * sizeof(unsigned long), s2_compressor_name, namelen); + total_len = 2 * sizeof(unsigned long) + 2 * sizeof(int) + namelen; + return total_len; +} + +/* s2_compress_load_config_info + * + * Description: Reload information needed for decompressing the image at + * resume time. + * Arguments: Buffer: Pointer to the start of the data. + * Size: Number of bytes that were saved. + */ + +static void s2_compress_load_config_info(char * buffer, int size) +{ + int namelen; + + bytes_in = *((unsigned long *) buffer); + bytes_out = *((unsigned long *) (buffer + sizeof(unsigned long))); + s2_expected_compression = *((int *) (buffer + 2 * sizeof(unsigned long))); + namelen = *((int *) (buffer + 3 * sizeof(unsigned long))); + strncpy(s2_compressor_name, buffer + 4 * sizeof(unsigned long), namelen); + return; +} + +/* suspend2_expected_compression_ratio + * + * Description: Returns the expected ratio between data passed into this plugin + * and the amount of data output when writing. + * Returns: 100 if the plugin is disabled. Otherwise the value set by the + * user via our proc entry. + */ + +int suspend2_expected_compression_ratio(void) +{ + if (s2_compression_ops.disabled) + return 100; + else + return 100 - s2_expected_compression; +} + +static void s2_compressor_disable_if_empty(void) +{ + s2_compression_ops.disabled = !(*s2_compressor_name); +} + +static int s2_compress_initialise(int starting_cycle) +{ + if (starting_cycle) + s2_compressor_disable_if_empty(); + + return 0; +} +/* + * data for our proc entries. + */ + +static struct suspend_proc_data proc_params[] = { + { + .filename = "expected_compression", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_INTEGER, + .data = { + .integer = { + .variable = &s2_expected_compression, + .minimum = 0, + .maximum = 99, + } + } + }, + + { + .filename = "disable_compression", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_INTEGER, + .data = { + .integer = { + .variable = &s2_compression_ops.disabled, + .minimum = 0, + .maximum = 1, + } + } + }, + + { + .filename = "compressor", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_STRING, + .data = { + .string = { + .variable = s2_compressor_name, + .max_length = 31, + } + }, + .write_proc = &s2_compressor_disable_if_empty, + } +}; + +/* + * Ops structure. + */ + +static struct suspend_plugin_ops s2_compression_ops = { + .type = FILTER_PLUGIN, + .name = "Suspend2 Compressor", + .module = THIS_MODULE, + .memory_needed = s2_compress_memory_needed, + .print_debug_info = s2_compress_print_debug_stats, + .save_config_info = s2_compress_save_config_info, + .load_config_info = s2_compress_load_config_info, + .storage_needed = s2_compress_storage_needed, + + .initialise = s2_compress_initialise, + + .write_init = s2_compress_write_init, + .write_cleanup = s2_compress_write_cleanup, + .read_init = s2_compress_read_init, + .read_cleanup = s2_compress_read_cleanup, + + .ops = { + .filter = { + .write_chunk = s2_compress_write_chunk, + .read_chunk = s2_compress_read_chunk, + } + } +}; + +/* ---- Registration ---- */ + +static __init int s2_compress_load(void) +{ + int result; + int i, numfiles = sizeof(proc_params) / sizeof(struct suspend_proc_data); + + printk("Software Suspend Compression Driver loading.\n"); + if (!(result = suspend_register_plugin(&s2_compression_ops))) { + for (i=0; i< numfiles; i++) + suspend_register_procfile(&proc_params[i]); + } else + printk("Software Suspend Compression Driver unable to register!\n"); + return result; +} + +#ifdef MODULE +static __exit void s2_compress_unload(void) +{ + printk("Software Suspend Compression Driver unloading.\n"); + for (i=0; i< numfiles; i++) + suspend_unregister_procfile(&proc_params[i]); + suspend_unregister_plugin(&s2_compression_ops); +} + + +module_init(s2_compress_load); +module_exit(s2_compress_unload); +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Nigel Cunningham"); +MODULE_DESCRIPTION("Compression Support for Suspend2"); +#else +late_initcall(s2_compress_load); +#endif diff -ruNp 800-suspend2.patch-old/kernel/power/driver_model.c 800-suspend2.patch-new/kernel/power/driver_model.c --- 800-suspend2.patch-old/kernel/power/driver_model.c 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/driver_model.c 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,95 @@ +/* + * kernel/power/suspend2_core/driver_model.c + * + * Copyright (C) 2004-2005 Nigel Cunningham + * + * This file is released under the GPLv2. + * + * Support for the driver model and ACPI sleep states. + */ + +#include +#include "driver_model.h" +#include "power_off.h" + +extern struct pm_ops * pm_ops; +static u32 pm_disk_mode_save; + +#ifdef CONFIG_ACPI +static int suspend_pm_state_used = 0; +extern u32 acpi_leave_sleep_state (u8 sleep_state); +#endif + +/* suspend_drivers_init + * + * Store the original pm ops settings. + */ +int suspend_drivers_init(void) +{ + if (pm_ops) { + pm_disk_mode_save = pm_ops->pm_disk_mode; + pm_ops->pm_disk_mode = PM_DISK_PLATFORM; + } + + return 0; +} + +/* suspend_drivers_cleanup + * + * Restore the original pm disk mode. + */ +void suspend_drivers_cleanup(void) +{ + if (pm_ops) + pm_ops->pm_disk_mode = pm_disk_mode_save; +} + +/* suspend_drivers_suspend + * + * Suspend the drivers after an atomic copy. + */ +int suspend_drivers_suspend(int stage) +{ + int result = 0; + const pm_message_t state = PMSG_FREEZE; + + switch (stage) { + case SUSPEND_DRIVERS_IRQS_DISABLED: + BUG_ON(!irqs_disabled()); + result = device_power_down(state); + BUG_ON(!irqs_disabled()); + break; + + case SUSPEND_DRIVERS_IRQS_ENABLED: + BUG_ON(irqs_disabled()); + result = device_suspend(state); + BUG_ON(irqs_disabled()); + break; + } + return result; +} + +/* suspend_drivers_resume + * + * Resume the drivers after an atomic copy (save or restore) + */ +void suspend_drivers_resume(int stage) +{ + switch (stage) { + case SUSPEND_DRIVERS_IRQS_DISABLED: + BUG_ON(!irqs_disabled()); + device_power_up(); + BUG_ON(!irqs_disabled()); + break; + + case SUSPEND_DRIVERS_IRQS_ENABLED: + BUG_ON(irqs_disabled()); +#ifdef CONFIG_ACPI + if (suspend_pm_state_used) + acpi_leave_sleep_state(suspend_pm_state_used); +#endif + suspend_pm_state_finish(); + BUG_ON(irqs_disabled()); + break; + } +} diff -ruNp 800-suspend2.patch-old/kernel/power/driver_model.h 800-suspend2.patch-new/kernel/power/driver_model.h --- 800-suspend2.patch-old/kernel/power/driver_model.h 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/driver_model.h 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,24 @@ +/* + * kernel/power/driver_model.h + * + * Copyright (C) 2004-2005 Nigel Cunningham + * + * This file is released under the GPLv2. + * + * Support for the driver model. + */ + +/* suspend_drivers_resume + * @stage - One of... + */ + +enum { + SUSPEND_DRIVERS_IRQS_DISABLED, + SUSPEND_DRIVERS_IRQS_ENABLED, +}; + +extern int suspend_drivers_init(void); +extern void suspend_drivers_cleanup(void); + +extern int suspend_drivers_suspend(int stage); +extern void suspend_drivers_resume(int stage); diff -ruNp 800-suspend2.patch-old/kernel/power/encryption.c 800-suspend2.patch-new/kernel/power/encryption.c --- 800-suspend2.patch-old/kernel/power/encryption.c 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/encryption.c 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,597 @@ +/* + * kernel/power/suspend2_core/encryption.c + * + * Copyright (C) 2003-2005 Nigel Cunningham + * + * This file is released under the GPLv2. + * + * This file contains data encryption routines for suspend, + * using cryptoapi transforms. + * + * ToDo: + * - Apply min/max_keysize the cipher changes. + * - Test. + */ + +#include +#include +#include +#include +#include +#include + +#include "suspend2.h" +#include "plugins.h" +#include "proc.h" +#include "suspend2_common.h" +#include "io.h" + +#define S2C_WRITE 0 +#define S2C_READ 1 + +static struct suspend_plugin_ops s2_encryption_ops; +static struct suspend_plugin_ops * next_driver; + +static char s2_encryptor_name[32]; +static struct crypto_tfm * s2_encryptor_transform; +static char s2_encryptor_key[256]; +static int s2_key_len; +static char s2_encryptor_iv[256]; +static int s2_encryptor_mode; +static int s2_encryptor_save_key_and_iv; + +static u8 *page_buffer = NULL; +static unsigned int bufofs; + +static struct scatterlist s2_crypt_sg[PAGE_SIZE/8]; + +/* ---- Local buffer management ---- */ + +/* allocate_local_buffer + * + * Description: Allocates a page of memory for buffering output. + * Returns: Int: Zero if successful, -ENONEM otherwise. + */ + +static int allocate_local_buffer(void) +{ + if (!page_buffer) { + int i; + + page_buffer = (char *) get_zeroed_page(GFP_ATOMIC); + + if (!page_buffer) { + printk(KERN_ERR + "Failed to allocate the page buffer for " + "suspend2 encryption driver.\n"); + return -ENOMEM; + } + + for (i=0; i < (PAGE_SIZE / s2_key_len); i++) { + s2_crypt_sg[i].page = virt_to_page(page_buffer); + s2_crypt_sg[i].offset = s2_key_len * i; + s2_crypt_sg[i].length = s2_key_len; + } + } + + return 0; +} + +/* free_local_buffer + * + * Description: Frees memory allocated for buffering output. + */ + +static inline void free_local_buffer(void) +{ + if (page_buffer) + free_page((unsigned long) page_buffer); + + page_buffer = NULL; +} + +/* suspend2_crypto_cleanup + * + * Description: Frees memory allocated for our labours. + */ + +static void suspend2_crypto_cleanup(void) +{ + if (s2_encryptor_transform) { + crypto_free_tfm(s2_encryptor_transform); + s2_encryptor_transform = NULL; + } +} + +/* suspend2_crypto_prepare + * + * Description: Prepare to do some work by allocating buffers and transforms. + * Returns: Int: Zero if successful, -ENONEM otherwise. + */ + +static int s2_encrypt_crypto_prepare(int mode) +{ + if (!*s2_encryptor_name) { + printk("Suspend2: Encryptor enabled but no name set.\n"); + return 1; + } + + if (!(s2_encryptor_transform = crypto_alloc_tfm(s2_encryptor_name, + 1 << s2_encryptor_mode))) { + printk("Suspend2: Failed to initialise the encryption transform (%s, mode %d).\n", + s2_encryptor_name, s2_encryptor_mode); + return 1; + } + + if (mode) + bufofs = PAGE_SIZE; + else + bufofs = 0; + + s2_key_len = strlen(s2_encryptor_key); + + if (crypto_cipher_setkey(s2_encryptor_transform, s2_encryptor_key, + s2_key_len)) { + printk("%d is an invalid key length for cipher %s.\n", + s2_key_len, + s2_encryptor_name); + return 1; + } + + if (!mode) { + crypto_cipher_set_iv(s2_encryptor_transform, + s2_encryptor_iv, + crypto_tfm_alg_ivsize(s2_encryptor_transform)); + } + + return 0; +} + +/* ---- Exported functions ---- */ + +/* write_init() + * + * Description: Allocate buffers and prepare to encrypt data. + * Arguments: Stream_number: Ignored. + * Returns: Zero on success, -ENOMEM if unable to vmalloc. + */ + +static int s2_encrypt_write_init(int stream_number) +{ + int result; + + next_driver = get_next_filter(&s2_encryption_ops); + + if (!next_driver) { + printk("Encryption Driver: Argh! No one wants my output!"); + return -ECHILD; + } + + if ((result = s2_encrypt_crypto_prepare(S2C_WRITE))) { + set_result_state(SUSPEND_ENCRYPTION_SETUP_FAILED); + suspend2_crypto_cleanup(); + return result; + } + + if ((result = allocate_local_buffer())) + return result; + + /* Only reset the stats if starting to write an image */ + if (stream_number == 2) + bytes_in = bytes_out = 0; + + bufofs = 0; + + return 0; +} + +/* s2_encrypt_write_chunk() + * + * Description: Encrypt a page of data, buffering output and passing on + * filled pages to the next plugin in the pipeline. + * Arguments: Buffer_page: Pointer to a buffer of size PAGE_SIZE, + * containing data to be encrypted. + * Returns: 0 on success. Otherwise the error is that returned by later + * plugins, -ECHILD if we have a broken pipeline or -EIO if + * zlib errs. + */ + +static int s2_encrypt_write_chunk(struct page * buffer_page) +{ + int ret; + unsigned int len; + u16 len_written; + char * buffer_start; + + if (!s2_encryptor_transform) + return next_driver->ops.filter.write_chunk(buffer_page); + + buffer_start = kmap(buffer_page); + memcpy(page_buffer, buffer_start, PAGE_SIZE); + kunmap(buffer_page); + + bytes_in += PAGE_SIZE; + + len = PAGE_SIZE; + + ret = crypto_cipher_encrypt(s2_encryptor_transform, + s2_crypt_sg, s2_crypt_sg, PAGE_SIZE); + + if (ret) { + printk("Encryption failed.\n"); + return -EIO; + } + + len_written = (u16) len; + + ret = next_driver->ops.filter.write_chunk(virt_to_page(page_buffer)); + + return ret; +} + +/* write_cleanup() + * + * Description: Write unflushed data and free workspace. + * Returns: Result of writing last page. + */ + +static int s2_encrypt_write_cleanup(void) +{ + suspend2_crypto_cleanup(); + free_local_buffer(); + + return 0; +} + +/* read_init() + * + * Description: Prepare to read a new stream of data. + * Arguments: int: Section of image about to be read. + * Returns: int: Zero on success, error number otherwise. + */ + +static int s2_encrypt_read_init(int stream_number) +{ + int result; + + next_driver = get_next_filter(&s2_encryption_ops); + + if (!next_driver) { + printk("Encryption Driver: Argh! No one wants " + "to feed me data!"); + return -ECHILD; + } + + if ((result = s2_encrypt_crypto_prepare(S2C_READ))) { + set_result_state(SUSPEND_ENCRYPTION_SETUP_FAILED); + suspend2_crypto_cleanup(); + return result; + } + + if ((result = allocate_local_buffer())) + return result; + + bufofs = PAGE_SIZE; + + return 0; +} + +/* s2_encrypt_read_chunk() + * + * Description: Retrieve data from later plugins and deencrypt it until the + * input buffer is filled. + * Arguments: Buffer_start: Pointer to a buffer of size PAGE_SIZE. + * Sync: Whether the previous plugin (or core) wants its + * data synchronously. + * Returns: Zero if successful. Error condition from me or from downstream + * on failure. + */ + +static int s2_encrypt_read_chunk(struct page * buffer_page, int sync) +{ + int ret; + char * buffer_start; + + if (!s2_encryptor_transform) + return next_driver->ops.filter.read_chunk(buffer_page, sync); + + /* + * All our reads must be synchronous - we can't deencrypt + * data that hasn't been read yet. + */ + + if ((ret = next_driver->ops.filter.read_chunk( + virt_to_page(page_buffer), SUSPEND_SYNC)) < 0) { + printk("Failed to read an encrypted block.\n"); + return ret; + } + + ret = crypto_cipher_decrypt(s2_encryptor_transform, + s2_crypt_sg, s2_crypt_sg, PAGE_SIZE); + + if (ret) + printk("Decrypt function returned %d.\n", ret); + + buffer_start = kmap(buffer_page); + memcpy(buffer_start, page_buffer, PAGE_SIZE); + kunmap(buffer_page); + return ret; +} + +/* read_cleanup() + * + * Description: Clean up after reading part or all of a stream of data. + * Returns: int: Always zero. Never fails. + */ + +static int s2_encrypt_read_cleanup(void) +{ + suspend2_crypto_cleanup(); + free_local_buffer(); + return 0; +} + +/* s2_encrypt_print_debug_stats + * + * Description: Print information to be recorded for debugging purposes into a + * buffer. + * Arguments: buffer: Pointer to a buffer into which the debug info will be + * printed. + * size: Size of the buffer. + * Returns: Number of characters written to the buffer. + */ + +static int s2_encrypt_print_debug_stats(char * buffer, int size) +{ + int len; + + len = snprintf_used(buffer, size, "- Encryptor %s enabled.\n", + s2_encryptor_name); + return len; +} + +/* encryption_memory_needed + * + * Description: Tell the caller how much memory we need to operate during + * suspend/resume. + * Returns: Unsigned long. Maximum number of bytes of memory required for + * operation. + */ + +static unsigned long s2_encrypt_memory_needed(void) +{ + return PAGE_SIZE; +} + +static unsigned long s2_encrypt_storage_needed(void) +{ + return 2 * sizeof(unsigned long) + sizeof(int); +} + +/* s2_encrypt_save_config_info + * + * Description: Save informaton needed when reloading the image at resume time. + * Arguments: Buffer: Pointer to a buffer of size PAGE_SIZE. + * Returns: Number of bytes used for saving our data. + */ + +static int s2_encrypt_save_config_info(char * buffer) +{ + int buf_offset, str_size; + + str_size = strlen(s2_encryptor_name); + *buffer = (char) str_size; + strncpy(buffer + 1, s2_encryptor_name, str_size + 1); + buf_offset = str_size + 2; + + *(buffer + buf_offset) = (char) s2_encryptor_mode; + buf_offset++; + + *(buffer + buf_offset) = (char) s2_encryptor_save_key_and_iv; + buf_offset++; + + if (s2_encryptor_save_key_and_iv) { + + str_size = strlen(s2_encryptor_key); + *(buffer + buf_offset) = (char) str_size; + strncpy(buffer + buf_offset + 1, s2_encryptor_key, str_size + 1); + + buf_offset+= str_size + 2; + + str_size = strlen(s2_encryptor_iv); + *(buffer + buf_offset) = (char) str_size; + strncpy(buffer + buf_offset + 1, s2_encryptor_iv, str_size + 1); + + buf_offset += str_size + 2; + } + + return buf_offset; +} + +/* s2_encrypt_load_config_info + * + * Description: Reload information needed for deencrypting the image at + * resume time. + * Arguments: Buffer: Pointer to the start of the data. + * Size: Number of bytes that were saved. + */ + +static void s2_encrypt_load_config_info(char * buffer, int size) +{ + int buf_offset, str_size; + + str_size = (int) *buffer; + strncpy(s2_encryptor_name, buffer + 1, str_size + 1); + buf_offset = str_size + 2; + + s2_encryptor_mode = (int) *(buffer + buf_offset); + buf_offset++; + + s2_encryptor_save_key_and_iv = (int) *(buffer + buf_offset); + buf_offset++; + + if (s2_encryptor_save_key_and_iv) { + str_size = (int) *(buffer + buf_offset); + strncpy(s2_encryptor_key, buffer + buf_offset + 1, str_size + 1); + + buf_offset+= str_size + 2; + + str_size = (int) *(buffer + buf_offset); + strncpy(s2_encryptor_iv, buffer + buf_offset + 1, str_size + 1); + + buf_offset += str_size + 2; + } else { + *s2_encryptor_key = 0; + *s2_encryptor_iv = 0; + } + + if (buf_offset != size) { + printk("Suspend Encryptor config info size mismatch (%d != %d): settings ignored.\n", + buf_offset, size); + *s2_encryptor_key = 0; + *s2_encryptor_iv = 0; + } + return; +} + +static void s2_encryptor_disable_if_empty(void) +{ + s2_encryption_ops.disabled = !(*s2_encryptor_name); +} + +static int s2_encrypt_initialise(int starting_cycle) +{ + if (starting_cycle) + s2_encryptor_disable_if_empty(); + + return 0; +} +/* + * data for our proc entries. + */ + +static struct suspend_proc_data proc_params[] = { + { + .filename = "encryptor", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_STRING, + .data = { + .string = { + .variable = s2_encryptor_name, + .max_length = 31, + } + }, + .write_proc = s2_encryptor_disable_if_empty, + }, + + { + .filename = "encryption_mode", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_INTEGER, + .data = { + .integer = { + .variable = &s2_encryptor_mode, + .minimum = 0, + .maximum = 3, + } + } + }, + + { + .filename = "encryption_save_key_and_iv", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_INTEGER, + .data = { + .integer = { + .variable = &s2_encryptor_save_key_and_iv, + .minimum = 0, + .maximum = 1, + } + } + }, + + { + .filename = "encryption_key", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_STRING, + .data = { + .string = { + .variable = s2_encryptor_key, + .max_length = 255, + } + } + }, + + { + .filename = "encryption_iv", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_STRING, + .data = { + .string = { + .variable = s2_encryptor_iv, + .max_length = 255, + } + } + }, + + { + .filename = "disable_encryption", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_INTEGER, + .data = { + .integer = { + .variable = &s2_encryption_ops.disabled, + .minimum = 0, + .maximum = 1, + } + } + }, + +}; + +/* + * Ops structure. + */ + +static struct suspend_plugin_ops s2_encryption_ops = { + .type = FILTER_PLUGIN, + .name = "Encryptor", + .module = THIS_MODULE, + .memory_needed = s2_encrypt_memory_needed, + .print_debug_info = s2_encrypt_print_debug_stats, + .save_config_info = s2_encrypt_save_config_info, + .load_config_info = s2_encrypt_load_config_info, + .storage_needed = s2_encrypt_storage_needed, + + .initialise = s2_encrypt_initialise, + + .write_init = s2_encrypt_write_init, + .write_cleanup = s2_encrypt_write_cleanup, + .read_init = s2_encrypt_read_init, + .read_cleanup = s2_encrypt_read_cleanup, + + .ops = { + .filter = { + .write_chunk = s2_encrypt_write_chunk, + .read_chunk = s2_encrypt_read_chunk, + } + } +}; + +/* ---- Registration ---- */ + +static __init int s2_encrypt_load(void) +{ + int result; + int i, numfiles = sizeof(proc_params) / sizeof(struct suspend_proc_data); + + printk("Software Suspend Encryption Driver loading.\n"); + if (!(result = suspend_register_plugin(&s2_encryption_ops))) { + for (i=0; i< numfiles; i++) + suspend_register_procfile(&proc_params[i]); + } else + printk("Software Suspend Encryption Driver unable to register!\n"); + return result; +} + +late_initcall(s2_encrypt_load); diff -ruNp 800-suspend2.patch-old/kernel/power/extent.c 800-suspend2.patch-new/kernel/power/extent.c --- 800-suspend2.patch-old/kernel/power/extent.c 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/extent.c 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,206 @@ +/* + * kernel/power/suspend2_core/extent.c + * + * Suspend2 routines for manipulating extents. + * + * (C) 2003-2005 Nigel Cunningham + * + * Distributed under GPLv2. + * + * These functions encapsulate the manipulation of extents. + * They work like this: + * + * A lot of the data that suspend saves involves continguous extents of memory + * or storage. Let's say that we're storing data on disk in blocks 1-32768 and + * 49152-49848 of a swap partition. Rather than recording 1, 2, 3... in arrays + * pointing to the locations, we simply use: + * + * struct extent { + * unsigned long min; + * unsigned long max; + * struct extent * next; + * } + * + * We can then store 1-32768 and 49152-49848 in 2 struct extents, using 24 bytes + * instead of something like 133,860. This is of course inefficient where a extent + * covers only one or two values, but the benefits gained by the much larger + * extents more than outweigh these instances. + * + * When _all_ the metadata was stored in extents, we used to have fancier code that + * stored them in pages and was optimised for our usage. Nowadays they are only + * used for storage information. We therefore kmalloc them as required, and + * provide a far simpler routine to serialise them in the image header. + */ + +#include +#include +#include "plugins.h" +#include "extent.h" +#include "ui.h" + +int extents_allocated = 0, max_extents_used = 0; + +/* get_extent + * + * Returns a free extent. + * May fail, returning NULL instead. + */ + +static struct extent * get_extent(void) +{ + struct extent * result; + + if (!(result = kmalloc(sizeof(struct extent), GFP_ATOMIC))) + return NULL; + + extents_allocated++; + if (extents_allocated > max_extents_used) + max_extents_used++; + result->minimum = result->maximum = 0; + result->next = NULL; + return result; +} + +/* + * put_extent. + * + * Frees an extent. + * + * Assumes unlinking is done by the caller. + */ +void put_extent(struct extent * extent) +{ + if (!extent) { + printk("Error! put_extent called with NULL extent.\n"); + return; + } + kfree(extent); + extents_allocated--; +} + +/* + * put_extent_chain. + * + * Frees a whole chain of extents. + */ +void put_extent_chain(struct extent_chain * chain) +{ + struct extent * this; + + this = chain->first; + + if (!this) + return; + + while(this) { + struct extent * next = this->next; + kfree(this); + chain->frees++; + extents_allocated --; + this = next; + } + + BUG_ON(chain->frees != chain->allocs); + chain->first = chain->last = NULL; + chain->size = chain->allocs = chain->frees = 0; +} + +/* + * append_extent_to_extent_chain + * + * Used where we know a extent is to be added to the end of the list + * and does not need merging with the current last extent. + */ + +int append_extent_to_extent_chain(struct extent_chain * chain, + unsigned long minimum, unsigned long maximum) +{ + struct extent * newextent = NULL; + + newextent = get_extent(); + if (!newextent) { + printk("Error unable to append a new extent to the chain.\n"); + return 2; + } + + chain->allocs++; + chain->size+= (maximum - minimum + 1); + newextent->minimum = minimum; + newextent->maximum = maximum; + newextent->next = NULL; + + if (chain->last) { + chain->last->next = newextent; + chain->last = newextent; + } else + chain->last = chain->first = newextent; + + /* No need to reset optimisation info since added to end */ + return 0; +} + +/* + * serialise_extent_chain + * + * Write a chain in the image. + */ +int serialise_extent_chain(struct extent_chain * chain) +{ + struct extent * this; + int ret, i = 1; + + if ((ret = active_writer->ops.writer.write_header_chunk((char *) chain, + sizeof(struct extent_chain) - 2 * sizeof(struct extent *)))) { + printk("Write header chunk returned %d - aborting serialising chain.\n", + ret); + return ret; + } + + this = chain->first; + while (this) { + if ((ret = active_writer->ops.writer.write_header_chunk((char *) this, + 2 * sizeof(unsigned long)))) { + printk("Failed to write extent.\n"); + return ret; + } + this = this->next; + i++; + } + return ret; +} + +/* + * load_extent_chain + * + * Read back a chain saved in the image. + */ +int load_extent_chain(struct extent_chain * chain) +{ + struct extent * this, * last = NULL; + int i, ret; + + if (!(ret = active_writer->ops.writer.read_header_chunk((char *) chain, + sizeof(struct extent_chain) - 2 * sizeof(struct extent *)))) { + printk("Read header chunk returned %d - aborting serialising chain.\n", + ret); + return ret; + } + + for (i = 0; i < (chain->allocs - chain->frees); i++) { + this = kmalloc(sizeof(struct extent), GFP_ATOMIC); + BUG_ON(!this); /* Shouldn't run out of memory trying this! */ + this->next = NULL; + if (!(ret = active_writer->ops.writer.read_header_chunk((char *) this, + 2 * sizeof(unsigned long)))) { + printk("Failed to read extent.\n"); + return ret; + } + if (last) + last->next = this; + else + chain->first = this; + last = this; + } + chain->last = last; + return ret; +} diff -ruNp 800-suspend2.patch-old/kernel/power/extent.h 800-suspend2.patch-new/kernel/power/extent.h --- 800-suspend2.patch-old/kernel/power/extent.h 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/extent.h 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,83 @@ +/* + * kernel/power/extent.h + * + * Copyright (C) 2004-2005 Nigel Cunningham + * + * This file is released under the GPLv2. + * + * It contains declarations related to extents. Extents are + * suspend's method of storing some of the metadata for the image. + * See extent.c for more info. + * + */ + +#ifndef EXTENT_H +#define EXTENT_H +struct extent_chain { + int size; /* size of the extent ie sum (max-min+1) */ + int allocs; + int frees; + int debug; + char * name; + struct extent * first; + struct extent * last; +}; + +/* + * We rely on extents not fitting evenly into a page. + * The last four bytes are used to store the number + * of the page, to make saving & reloading pages simpler. + */ +struct extent { + unsigned long minimum; + unsigned long maximum; + struct extent * next; +}; + + +#define extent_for_each(extent_chain, extentpointer, value) \ +if ((extent_chain)->first) \ + for ((extentpointer) = (extent_chain)->first, (value) = \ + (extentpointer)->minimum; \ + ((extentpointer) && ((extentpointer)->next || (value) <= \ + (extentpointer)->maximum)); \ + (((value) == (extentpointer)->maximum) ? \ + ((extentpointer) = (extentpointer)->next, (value) = \ + ((extentpointer) ? (extentpointer)->minimum : 0)) : \ + (value)++)) + +/* + * When using compression and expected_compression > 0, + * we allocate fewer swap entries, so GET_EXTENT_NEXT can + * validly run out of data to return. + */ +#define GET_EXTENT_NEXT(currentextent, currentval) \ +{ \ + if (currentextent) { \ + if ((currentval) == (currentextent)->maximum) { \ + if ((currentextent)->next) { \ + (currentextent) = (currentextent)->next; \ + (currentval) = (currentextent)->minimum; \ + } else { \ + (currentextent) = NULL; \ + (currentval) = 0; \ + } \ + } else \ + currentval++; \ + } \ +} + +extern int max_extents_used, extents_allocated; +void put_extent(struct extent * extent); +void put_extent_chain(struct extent_chain * chain); +int append_extent_to_extent_chain(struct extent_chain * chain, + unsigned long minimum, unsigned long maximum); +int serialise_extent_chain(struct extent_chain * chain); +int load_extent_chain(struct extent_chain * chain); + +/* swap_entry_to_extent_val & extent_val_to_swap_entry: + * We are putting offset in the low bits so consecutive swap entries + * make consecutive extent values */ +#define swap_entry_to_extent_val(swp_entry) (swp_entry.val) +#define extent_val_to_swap_entry(val) (swp_entry_t) { (val) } +#endif diff -ruNp 800-suspend2.patch-old/kernel/power/io.c 800-suspend2.patch-new/kernel/power/io.c --- 800-suspend2.patch-old/kernel/power/io.c 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/io.c 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,980 @@ +/* + * kernel/power/io.c + * + * Copyright (C) 1998-2001 Gabor Kuti + * Copyright (C) 1998,2001,2002 Pavel Machek + * Copyright (C) 2002-2003 Florent Chabaud + * Copyright (C) 2002-2005 Nigel Cunningham + * + * This file is released under the GPLv2. + * + * It contains high level IO routines for suspending. + * + */ + +#include +#include +#include + +#include "version.h" +#include "plugins.h" +#include "pageflags.h" +#include "io.h" +#include "ui.h" +#include "suspend2_common.h" +#include "suspend2.h" + +/* attempt_to_parse_resume_device + * + * Can we suspend, using the current resume2= parameter? + */ +void attempt_to_parse_resume_device(void) +{ + struct list_head *writer; + struct suspend_plugin_ops * this_writer; + int result = 0; + + active_writer = NULL; + clear_suspend_state(SUSPEND_RESUME_DEVICE_OK); + set_suspend_state(SUSPEND_DISABLED); + clear_result_state(SUSPEND_ABORTED); + + if (!num_writers) { + printk(name_suspend "No writers have been registered. Suspending will be disabled.\n"); + return; + } + + if (!resume2_file[0]) { + printk(name_suspend "Resume2 parameter is empty. Suspending will be disabled.\n"); + return; + } + + list_for_each(writer, &suspend_writers) { + this_writer = list_entry(writer, struct suspend_plugin_ops, + ops.writer.writer_list); + + /* + * Not sure why you'd want to disable a writer, but + * we should honour the flag if we're providing it + */ + if (this_writer->disabled) { + printk(name_suspend + "Writer '%s' is disabled. Ignoring it.\n", + this_writer->name); + continue; + } + + result = this_writer->ops.writer.parse_image_location( + resume2_file, (num_writers == 1)); + + switch (result) { + case -EINVAL: + /* + * For this writer, but not a valid + * configuration. Error already printed. + */ + + return; + + case 0: + /* + * For this writer and valid. + */ + + active_writer = this_writer; + + set_suspend_state(SUSPEND_RESUME_DEVICE_OK); + clear_suspend_state(SUSPEND_DISABLED); + printk(name_suspend "Suspending enabled.\n"); + + return; + } + } + printk(name_suspend "No matching enabled writer found. Suspending disabled.\n"); +} + +/* suspend2_cleanup_finished_io + * + * Description: Very simple helper function to save #including all the + * suspend code in fs/buffer.c and anywhere else we might + * want to wait on suspend I/O in future. + */ + +void suspend2_cleanup_finished_io(void) +{ + active_writer->ops.writer.wait_on_io(0); +} + +/* noresume_reset_plugins + * + * Description: When we read the start of an image, plugins (and especially the + * active writer) might need to reset data structures if we decide + * to invalidate the image rather than resuming from it. + */ + +static void noresume_reset_plugins(void) +{ + struct suspend_plugin_ops * this_filter; + + list_for_each_entry(this_filter, &suspend_filters, ops.filter.filter_list) { + if (this_filter->ops.filter.noresume_reset) + this_filter->ops.filter.noresume_reset(); + } + + if (active_writer && active_writer->ops.writer.noresume_reset) + active_writer->ops.writer.noresume_reset(); +} + +/* fill_suspend_header() + * + * Description: Fill the suspend header structure. + * Arguments: struct suspend_header: Header data structure to be filled. + */ + +static void fill_suspend_header(struct suspend_header *sh) +{ + int i; + + memset((char *)sh, 0, sizeof(*sh)); + + sh->version_code = LINUX_VERSION_CODE; + sh->num_physpages = num_physpages; + sh->orig_mem_free = suspend2_orig_mem_free; + strncpy(sh->machine, system_utsname.machine, 65); + strncpy(sh->version, system_utsname.version, 65); + sh->page_size = PAGE_SIZE; + sh->pagedir = pagedir1; + sh->pageset_2_size = pagedir2.pageset_size; + sh->param0 = suspend_result; + sh->param1 = suspend_action; + sh->param2 = suspend_debug_state; + sh->param3 = console_loglevel; + for (i = 0; i < 4; i++) + sh->io_time[i/2][i%2] = + suspend_io_time[i/2][i%2]; +} + +/* write_pageset() + * + * Description: Write a pageset to disk. + * Arguments: pagedir: Pointer to the pagedir to be saved. + * whichtowrite: Controls what debugging output is printed. + * Returns: Zero on success or -1 on failure. + */ + +int write_pageset(struct pagedir * pagedir, int whichtowrite) +{ + int nextupdate = 0, size, ret = 0, i, base = 0; + int barmax = pagedir1.pageset_size + pagedir2.pageset_size; + int start_time, end_time, pc, step = 1; + long error = 0; + struct suspend_plugin_ops * this_plugin, * first_filter = get_next_filter(NULL); + dyn_pageflags_t *pageflags; + int current_page_index = -1; + + size = pagedir->pageset_size; + if (!size) + return 0; + + if (whichtowrite == 1) { + suspend2_prepare_status(DONT_CLEAR_BAR, "Writing kernel & process data..."); + base = pagedir2.pageset_size; + if (test_action_state(SUSPEND_TEST_FILTER_SPEED)) + pageflags = &pageset1_map; + else + pageflags = &pageset1_copy_map; + } else { + suspend2_prepare_status(CLEAR_BAR, "Writing caches..."); + pageflags = &pageset2_map; + bytes_in = bytes_out = 0; + } + + start_time = jiffies; + + /* Initialise page transformers */ + list_for_each_entry(this_plugin, &suspend_filters, ops.filter.filter_list) { + if (this_plugin->disabled) + continue; + if (this_plugin->write_init) + if (this_plugin->write_init(whichtowrite)) { + set_result_state(SUSPEND_ABORTED); + goto write_pageset_free_buffers; + } + } + + /* Initialise writer */ + active_writer->write_init(whichtowrite); + + /* Initialise other plugins */ + list_for_each_entry(this_plugin, &suspend_plugins, plugin_list) { + if (this_plugin->disabled) + continue; + if ((this_plugin->type == FILTER_PLUGIN) || + (this_plugin->type == WRITER_PLUGIN)) + continue; + if (this_plugin->write_init) + if (this_plugin->write_init(whichtowrite)) { + set_result_state(SUSPEND_ABORTED); + goto write_pageset_free_buffers; + } + } + + current_page_index = __get_next_bit_on(*pageflags, -1); + + pc = size / 5; + + /* Write the data */ + for (i=0; i= nextupdate) + nextupdate = suspend2_update_status(i + base, barmax, + " %d/%d MB ", MB(base+i+1), MB(barmax)); + + if ((i + 1) == pc) { + printk("%d%%...", 20 * step); + step++; + pc = size * step / 5; + } + + /* Write */ + was_mapped = suspend_map_kernel_page(page, 1); + ret = first_filter->ops.filter.write_chunk(page); + if (!was_mapped) + suspend_map_kernel_page(page, 0); + + if (ret || test_result_state(SUSPEND_ABORTED)) { + if (ret) { + printk("Write chunk returned %d.\n", ret); + abort_suspend("Failed to write a chunk of the " + "image."); + } + error = -1; + goto write_pageset_free_buffers; + } + + /* Interactivity */ + check_shift_keys(0, NULL); + + /* Prepare next */ + current_page_index = __get_next_bit_on(*pageflags, current_page_index); + } + + printk("done.\n"); + + suspend2_update_status(base+size, barmax, " %d/%d MB ", + MB(base+size), MB(barmax)); + +write_pageset_free_buffers: + + /* Cleanup other plugins */ + list_for_each_entry(this_plugin, &suspend_plugins, plugin_list) { + if (this_plugin->disabled) + continue; + if ((this_plugin->type == FILTER_PLUGIN) || + (this_plugin->type == WRITER_PLUGIN)) + continue; + if (this_plugin->write_cleanup) + this_plugin->write_cleanup(); + } + + /* Flush data and cleanup */ + list_for_each_entry(this_plugin, &suspend_filters, ops.filter.filter_list) { + if (this_plugin->disabled) + continue; + if (this_plugin->write_cleanup) + this_plugin->write_cleanup(); + } + active_writer->write_cleanup(); + + /* Statistics */ + end_time = jiffies; + + if ((end_time - start_time) && (!test_result_state(SUSPEND_ABORTED))) { + suspend_io_time[0][0] += size, + suspend_io_time[0][1] += (end_time - start_time); + } + + return error; +} + +/* read_pageset() + * + * Description: Read a pageset from disk. + * Arguments: pagedir: Pointer to the pagedir to be saved. + * whichtowrite: Controls what debugging output is printed. + * overwrittenpagesonly: Whether to read the whole pageset or + * only part. + * Returns: Zero on success or -1 on failure. + */ + +static int read_pageset(struct pagedir * pagedir, int whichtoread, + int overwrittenpagesonly) +{ + int nextupdate = 0, result = 0, base = 0; + int start_time, end_time, finish_at = pagedir->pageset_size; + int barmax = pagedir1.pageset_size + pagedir2.pageset_size; + int i, pc, step = 1; + struct suspend_plugin_ops * this_plugin, * first_filter = get_next_filter(NULL); + dyn_pageflags_t *pageflags; + int current_page_index; + + if (whichtoread == 1) { + suspend2_prepare_status(CLEAR_BAR, "Reading kernel & process data..."); + pageflags = &pageset1_copy_map; + } else { + suspend2_prepare_status(DONT_CLEAR_BAR, "Reading caches..."); + if (overwrittenpagesonly) + barmax = finish_at = min(pagedir1.pageset_size, + pagedir2.pageset_size); + else { + base = pagedir1.pageset_size; + } + pageflags = &pageset2_map; + } + + start_time = jiffies; + + /* Initialise page transformers */ + list_for_each_entry(this_plugin, &suspend_filters, ops.filter.filter_list) { + if (this_plugin->disabled) + continue; + if (this_plugin->read_init && + this_plugin->read_init(whichtoread)) { + abort_suspend("Failed to initialise a filter."); + result = 1; + goto read_pageset_free_buffers; + } + } + + /* Initialise writer */ + if (active_writer->read_init(whichtoread)) { + abort_suspend("Failed to initialise the writer."); + result = 1; + goto read_pageset_free_buffers; + } + + /* Initialise other plugins */ + list_for_each_entry(this_plugin, &suspend_plugins, plugin_list) { + if (this_plugin->disabled) + continue; + if ((this_plugin->type == FILTER_PLUGIN) || + (this_plugin->type == WRITER_PLUGIN)) + continue; + if (this_plugin->read_init) + if (this_plugin->read_init(whichtoread)) { + set_result_state(SUSPEND_ABORTED); + goto read_pageset_free_buffers; + } + } + + current_page_index = __get_next_bit_on(*pageflags, -1); + + pc = finish_at / 5; + + /* Read the pages */ + for (i=0; i< finish_at; i++) { + int was_mapped = 0; + struct page * page = pfn_to_page(current_page_index); + + /* Status */ + if ((i+base) >= nextupdate) + nextupdate = suspend2_update_status(i+base, barmax, + " %d/%d MB ", MB(base+i+1), MB(barmax)); + + if ((i + 1) == pc) { + printk("%d%%...", 20 * step); + step++; + pc = finish_at * step / 5; + } + + was_mapped = suspend_map_kernel_page(page, 1); + result = first_filter->ops.filter.read_chunk(page, SUSPEND_ASYNC); + if (!was_mapped) + suspend_map_kernel_page(page, 0); + + if (result) { + panic("Failed to read chunk %d/%d of the image. (%d)", + i, finish_at, result); + goto read_pageset_free_buffers; + } + + /* Interactivity*/ + check_shift_keys(0, NULL); + + /* Prepare next */ + current_page_index = __get_next_bit_on(*pageflags, current_page_index); + } + + printk("done.\n"); + + suspend2_update_status(base+finish_at, barmax, " %d/%d MB ", + MB(base+finish_at), MB(barmax)); + +read_pageset_free_buffers: + + /* Cleanup other plugins */ + list_for_each_entry(this_plugin, &suspend_plugins, plugin_list) { + if (this_plugin->disabled) + continue; + if ((this_plugin->type == FILTER_PLUGIN) || + (this_plugin->type == WRITER_PLUGIN)) + continue; + if (this_plugin->read_cleanup) + this_plugin->read_cleanup(); + } + + /* Finish I/O, flush data and cleanup reads. */ + list_for_each_entry(this_plugin, &suspend_filters, ops.filter.filter_list) { + if (this_plugin->disabled) + continue; + if (this_plugin->read_cleanup && + this_plugin->read_cleanup()) { + abort_suspend("Failed to cleanup a filter."); + result = 1; + } + } + + if (active_writer->read_cleanup()) { + abort_suspend("Failed to cleanup the writer."); + result = 1; + } + + /* Statistics */ + end_time=jiffies; + if ((end_time - start_time) && (!test_result_state(SUSPEND_ABORTED))) { + suspend_io_time[1][0] += finish_at, + suspend_io_time[1][1] += (end_time - start_time); + } + + return result; +} + +/* write_plugin_configs() + * + * Description: Store the configuration for each plugin in the image header. + * Returns: Int: Zero on success, Error value otherwise. + */ +static int write_plugin_configs(void) +{ + struct suspend_plugin_ops * this_plugin; + char * buffer = (char *) get_zeroed_page(GFP_ATOMIC); + int len, index = 1; + struct plugin_header plugin_header; + + if (!buffer) { + printk("Failed to allocate a buffer for saving " + "plugin configuration info.\n"); + return -ENOMEM; + } + + /* + * We have to know which data goes with which plugin, so we at + * least write a length of zero for a plugin. Note that we are + * also assuming every plugin's config data takes <= PAGE_SIZE. + */ + + /* For each plugin (in registration order) */ + list_for_each_entry(this_plugin, &suspend_plugins, plugin_list) { + + /* Get the data from the plugin */ + len = 0; + if (this_plugin->save_config_info) + len = this_plugin->save_config_info(buffer); + + /* Save the details of the plugin */ + plugin_header.disabled = this_plugin->disabled; + plugin_header.type = this_plugin->type; + plugin_header.index = index++; + strncpy(plugin_header.name, this_plugin->name, + sizeof(plugin_header.name)); + active_writer->ops.writer.write_header_chunk( + (char *) &plugin_header, + sizeof(plugin_header)); + + /* Save the size of the data and any data returned */ + active_writer->ops.writer.write_header_chunk((char *) &len, + sizeof(int)); + if (len) + active_writer->ops.writer.write_header_chunk( + buffer, len); + } + + /* Write a blank header to terminate the list */ + plugin_header.name[0] = '\0'; + active_writer->ops.writer.write_header_chunk( + (char *) &plugin_header, + sizeof(plugin_header)); + + free_page((unsigned long) buffer); + return 0; +} + +/* read_plugin_configs() + * + * Description: Reload plugin configurations from the image header. + * Returns: Int. Zero on success, error value otherwise. + */ + +static int read_plugin_configs(void) +{ + struct suspend_plugin_ops * this_plugin; + char * buffer = (char *) get_zeroed_page(GFP_ATOMIC); + int len, result = 0; + struct plugin_header plugin_header; + + if (!buffer) { + printk("Failed to allocate a buffer for reloading plugin " + "configuration info.\n"); + return -ENOMEM; + } + + /* All plugins are initially disabled. That way, if we have a plugin + * loaded now that wasn't loaded when we suspended, it won't be used + * in trying to read the data. + */ + list_for_each_entry(this_plugin, &suspend_plugins, plugin_list) + this_plugin->disabled = 1; + + /* Get the first plugin header */ + result = active_writer->ops.writer.read_header_chunk( + (char *) &plugin_header, sizeof(plugin_header)); + if (!result) { + printk("Failed to read the next plugin header.\n"); + free_page((unsigned long) buffer); + return -EINVAL; + } + + /* For each plugin (in registration order) */ + while (plugin_header.name[0]) { + + /* Find the plugin */ + this_plugin = find_plugin_given_name(plugin_header.name); + + if (!this_plugin) { + /* + * Is it used? Only need to worry about filters. The active + * writer must be loaded! + */ + if ((!plugin_header.disabled) && + (plugin_header.type == FILTER_PLUGIN)) { + suspend_early_boot_message(1, SUSPEND_CONTINUE_REQ, + "It looks like we need plugin %s for " + "reading the image but it hasn't been " + "registered.\n", + plugin_header.name); + if (!(test_suspend_state(SUSPEND_CONTINUE_REQ))) { + active_writer->ops.writer.invalidate_image(); + result = -EINVAL; + noresume_reset_plugins(); + free_page((unsigned long) buffer); + return -EINVAL; + } + } else + printk("Plugin %s configuration data found, but the plugin " + "hasn't registered. Looks like it was disabled, so " + "we're ignoring it's data.", + plugin_header.name); + } + + /* Get the length of the data (if any) */ + result = active_writer->ops.writer.read_header_chunk( + (char *) &len, sizeof(int)); + if (!result) { + printk("Failed to read the length of the plugin %s's" + " configuration data.\n", + plugin_header.name); + free_page((unsigned long) buffer); + return -EINVAL; + } + + /* Read any data and pass to the plugin (if we found one) */ + if (len) { + active_writer->ops.writer.read_header_chunk(buffer, len); + if (this_plugin) { + if (!this_plugin->save_config_info) { + printk("Huh? Plugin %s appears to have a " + "save_config_info, but not a " + "load_config_info function!\n", + this_plugin->name); + } else + this_plugin->load_config_info(buffer, len); + } + } + + if (this_plugin) { + /* Now move this plugin to the tail of its lists. This will put it + * in order. Any new plugins will end up at the top of the lists. + * They should have been set to disabled when loaded (people will + * normally not edit an initrd to load a new module and then + * suspend without using it!). + */ + + suspend_move_plugin_tail(this_plugin); + + /* + * We apply the disabled state; plugins don't need to save whether they + * were disabled and if they do, we override them anyway. + */ + this_plugin->disabled = plugin_header.disabled; + } + + /* Get the next plugin header */ + result = active_writer->ops.writer.read_header_chunk( + (char *) &plugin_header, sizeof(plugin_header)); + + if (!result) { + printk("Failed to read the next plugin header.\n"); + free_page((unsigned long) buffer); + return -EINVAL; + } + + } + + free_page((unsigned long) buffer); + return 0; +} + +/* write_image_header() + * + * Description: Write the image header after write the image proper. + * Returns: Int. Zero on success or -1 on failure. + */ + +int write_image_header(void) +{ + int ret; + int total = pagedir1.pageset_size + pagedir2.pageset_size+2; + char * header_buffer = NULL; + + /* Now prepare to write the header */ + if ((ret = active_writer->ops.writer.write_header_init())) { + abort_suspend("Active writer's write_header_init" + " function failed."); + goto write_image_header_abort; + } + + /* Get a buffer */ + header_buffer = (char *) get_zeroed_page(GFP_ATOMIC); + if (!header_buffer) { + abort_suspend("Out of memory when trying to get page " + "for header!"); + goto write_image_header_abort; + } + + /* Write suspend header */ + fill_suspend_header((struct suspend_header *) header_buffer); + active_writer->ops.writer.write_header_chunk(header_buffer, + sizeof(struct suspend_header)); + + free_page((unsigned long) header_buffer); + + /* Write plugin configurations */ + if ((ret = write_plugin_configs())) { + abort_suspend("Failed to write plugin configs."); + goto write_image_header_abort; + } + + save_dyn_pageflags(pageset1_map); + + if ((ret = active_writer->ops.writer.serialise_extents())) { + abort_suspend("Active writer's prepare_save_extents " + "function failed."); + goto write_image_header_abort; + } + + /* Flush data and let writer cleanup */ + if (active_writer->ops.writer.write_header_cleanup()) { + abort_suspend("Failed to cleanup writing header."); + goto write_image_header_abort_no_cleanup; + } + + if (test_result_state(SUSPEND_ABORTED)) + goto write_image_header_abort_no_cleanup; + + suspend_message(SUSPEND_IO, SUSPEND_VERBOSE, 1, "|\n"); + suspend2_update_status(total, total, NULL); + + return 0; + +write_image_header_abort: + active_writer->ops.writer.write_header_cleanup(); +write_image_header_abort_no_cleanup: + return -1; +} + +/* sanity_check() + * + * Description: Perform a few checks, seeking to ensure that the kernel being + * booted matches the one suspended. They need to match so we can + * be _sure_ things will work. It is not absolutely impossible for + * resuming from a different kernel to work, just not assured. + * Arguments: Struct suspend_header. The header which was saved at suspend + * time. + */ +static int sanity_check(struct suspend_header *sh) +{ + if (sh->version_code != LINUX_VERSION_CODE) + return suspend_early_boot_message(1, SUSPEND_CONTINUE_REQ, + "Incorrect kernel version"); + + if (sh->num_physpages != num_physpages) + return suspend_early_boot_message(1, SUSPEND_CONTINUE_REQ, + "Incorrect memory size"); + + if (strncmp(sh->machine, system_utsname.machine, 65)) + return suspend_early_boot_message(1, SUSPEND_CONTINUE_REQ, + "Incorrect machine type"); + + if (strncmp(sh->version, system_utsname.version, 65)) + return suspend_early_boot_message(1, SUSPEND_CONTINUE_REQ, + "Incorrect version"); + + if (sh->page_size != PAGE_SIZE) + return suspend_early_boot_message(1, SUSPEND_CONTINUE_REQ, + "Incorrect PAGE_SIZE"); + + return 0; +} + +/* __read_pageset1 + * + * Description: Test for the existence of an image and attempt to load it. + * Returns: Int. Zero if image found and pageset1 successfully loaded. + * Error if no image found or loaded. + */ +static int __read_pageset1(void) +{ + int i, result = 0; + char * header_buffer = (char *) get_zeroed_page(GFP_ATOMIC); + struct suspend_header * suspend_header; + + if (!header_buffer) + return -ENOMEM; + + /* Check for an image */ + if (!(result = active_writer->ops.writer.image_exists())) { + result = -ENODATA; + noresume_reset_plugins(); + goto out; + } + + /* Check for noresume command line option */ + if (test_suspend_state(SUSPEND_NORESUME_SPECIFIED)) { + active_writer->ops.writer.invalidate_image(); + result = -EINVAL; + noresume_reset_plugins(); + goto out; + } + + /* Check whether we've resumed before */ + if (test_suspend_state(SUSPEND_RESUMED_BEFORE)) { + int resumed_before_default = 0; + if (test_suspend_state(SUSPEND_RETRY_RESUME)) + resumed_before_default = SUSPEND_CONTINUE_REQ; + suspend_early_boot_message(1, resumed_before_default, NULL); + clear_suspend_state(SUSPEND_RETRY_RESUME); + if (!(test_suspend_state(SUSPEND_CONTINUE_REQ))) { + active_writer->ops.writer.invalidate_image(); + result = -EINVAL; + noresume_reset_plugins(); + goto out; + } + } + + clear_suspend_state(SUSPEND_CONTINUE_REQ); + + /* + * Prepare the active writer for reading the image header. The + * activate writer might read its own configuration or set up + * a network connection here. + * + * NB: This call may never return because there might be a signature + * for a different image such that we warn the user and they choose + * to reboot. (If the device ids look erroneous (2.4 vs 2.6) or the + * location of the image might be unavailable if it was stored on a + * network connection. + */ + + if ((result = active_writer->ops.writer.read_header_init())) { + noresume_reset_plugins(); + goto out; + } + + /* Read suspend header */ + if ((result = active_writer->ops.writer.read_header_chunk( + header_buffer, sizeof(struct suspend_header))) < 0) { + noresume_reset_plugins(); + goto out; + } + + suspend_header = (struct suspend_header *) header_buffer; + + /* + * NB: This call may also result in a reboot rather than returning. + */ + + if (sanity_check(suspend_header)) { /* Is this the same machine? */ + active_writer->ops.writer.invalidate_image(); + result = -EINVAL; + noresume_reset_plugins(); + goto out; + } + + /* + * We have an image and it looks like it will load okay. + */ + + /* Get metadata from header. Don't override commandline parameters. + * + * We don't need to save the image size limit because it's not used + * during resume and will be restored with the image anyway. + */ + + suspend2_orig_mem_free = suspend_header->orig_mem_free; + memcpy((char *) &pagedir1, + (char *) &suspend_header->pagedir, sizeof(pagedir1)); + suspend_result = suspend_header->param0; + if (!test_suspend_state(SUSPEND_ACT_USED)) + suspend_action = suspend_header->param1; + if (!test_suspend_state(SUSPEND_DBG_USED)) + suspend_debug_state = suspend_header->param2; + if (!test_suspend_state(SUSPEND_LVL_USED)) + suspend_default_console_level = suspend_header->param3; + clear_suspend_state(SUSPEND_IGNORE_LOGLEVEL); + pagedir2.pageset_size = suspend_header->pageset_2_size; + for (i = 0; i < 4; i++) + suspend_io_time[i/2][i%2] = + suspend_header->io_time[i/2][i%2]; + + set_suspend_state(SUSPEND_NOW_RESUMING); + + /* Read plugin configurations */ + if ((result = read_plugin_configs())) { + noresume_reset_plugins(); + pagedir1.pageset_size = + pagedir2.pageset_size = 0; + goto out; + } + + suspend2_prepare_console(); + + check_shift_keys(1, "About to read original pageset1 locations."); + /* Read original pageset1 locations. These are the addresses we can't use for + * the data to be restored */ + suspend_allocate_dyn_pageflags(&pageset1_map); + load_dyn_pageflags(pageset1_map); + + /* Relocate it so that it's not overwritten while we're using it to + * copy the original contents back */ + relocate_dyn_pageflags(&pageset1_map); + + suspend_allocate_dyn_pageflags(&pageset1_copy_map); + relocate_dyn_pageflags(&pageset1_copy_map); + + /* Read extent pages */ + if ((result = active_writer->ops.writer.load_extents())) { + noresume_reset_plugins(); + abort_suspend("Active writer's load_extents " + "function failed."); + goto out; + } + + /* Clean up after reading the header */ + if ((result = active_writer->ops.writer.read_header_cleanup())) { + noresume_reset_plugins(); + goto out; + } + + check_shift_keys(1, "About to read pagedir."); + + /* + * Get the addresses of pages into which we will load the kernel to + * be copied back + */ + if (suspend2_get_pageset1_load_addresses()) { + result = -ENOMEM; + noresume_reset_plugins(); + goto out; + } + + /* Read the original kernel back */ + check_shift_keys(1, "About to read pageset 1."); + + if (read_pageset(&pagedir1, 1, 0)) { + suspend2_prepare_status(CLEAR_BAR, "Failed to read pageset 1."); + result = -EPERM; + noresume_reset_plugins(); + goto out; + } + + check_shift_keys(1, "About to restore original kernel."); + result = 0; + + if (active_writer->ops.writer.mark_resume_attempted) + active_writer->ops.writer.mark_resume_attempted(); + +out: + free_page((unsigned long) header_buffer); + return result; +} + +/* read_pageset1() + * + * Description: Attempt to read the header and pageset1 of a suspend image. + * Handle the outcome, complaining where appropriate. + */ +int read_pageset1(void) +{ + int error; + + error = __read_pageset1(); + + switch (error) { + case 0: + case -ENODATA: + case -EINVAL: /* non fatal error */ + return error; + case -EIO: + printk(KERN_CRIT name_suspend "I/O error\n"); + break; + case -ENOENT: + printk(KERN_CRIT name_suspend "No such file or directory\n"); + break; + case -EPERM: + printk(KERN_CRIT name_suspend "Sanity check error\n"); + break; + default: + printk(KERN_CRIT name_suspend "Error %d resuming\n", error); + break; + } + abort_suspend("Error %d in read_pageset1",error); + return error; +} + +/* read_pageset2() + * + * Description: Read in part or all of pageset2 of an image, depending upon + * whether we are suspending and have only overwritten a portion + * with pageset1 pages, or are resuming and need to read them + * all. + * Arguments: Int. Boolean. Read only pages which would have been + * overwritten by pageset1? + * Returns: Int. Zero if no error, otherwise the error value. + */ +int read_pageset2(int overwrittenpagesonly) +{ + int result = 0; + + if (!pagedir2.pageset_size) + return 0; + + result = read_pageset(&pagedir2, 2, overwrittenpagesonly); + + suspend2_update_status(100, 100, NULL); + check_shift_keys(1, "Pagedir 2 read."); + + return result; +} diff -ruNp 800-suspend2.patch-old/kernel/power/io.h 800-suspend2.patch-new/kernel/power/io.h --- 800-suspend2.patch-old/kernel/power/io.h 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/io.h 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,37 @@ +/* + * kernel/power/io.h + */ + +#include "pagedir.h" + +/* Non-plugin data saved in our image header */ +struct suspend_header { + u32 version_code; + unsigned long num_physpages; + unsigned long orig_mem_free; + char machine[65]; + char version[65]; + int num_cpus; + int page_size; + int pageset_2_size; + int param0; + int param1; + int param2; + int param3; + int progress0; + int progress1; + int progress2; + int progress3; + int io_time[2][2]; + struct pagedir pagedir; +}; + +extern int write_pageset(struct pagedir * pagedir, int whichtowrite); +extern int write_image_header(void); +extern int read_pageset1(void); +extern int read_pageset2(int overwrittenpagesonly); + +extern void attempt_to_parse_resume_device(void); +extern dev_t name_to_dev_t(char *line); +extern __nosavedata unsigned long bytes_in, bytes_out; + diff -ruNp 800-suspend2.patch-old/kernel/power/pagedir.c 800-suspend2.patch-new/kernel/power/pagedir.c --- 800-suspend2.patch-old/kernel/power/pagedir.c 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/pagedir.c 2005-07-30 21:26:04.000000000 +1000 @@ -0,0 +1,324 @@ +/* + * kernel/power/pagedir.c + * + * Copyright (C) 1998-2001 Gabor Kuti + * Copyright (C) 1998,2001,2002 Pavel Machek + * Copyright (C) 2002-2003 Florent Chabaud + * Copyright (C) 2002-2005 Nigel Cunningham + * + * This file is released under the GPLv2. + * + * Routines for handling pagesets. + * Note that pbes aren't actually stored as such. They're stored as + * bitmaps and extents. + */ + +#include +#include +#include + +#include "pageflags.h" +#include "ui.h" +#include "pagedir.h" + +int extra_pagedir_pages_allocated = 0; + +dyn_pageflags_t conflicting_pages_map; + +/* suspend2_free_pagedir_data + * + * Description: Free a previously pagedir metadata. + */ +void suspend2_free_pagedir_data(void) +{ + int pagenumber; + + free_dyn_pageflags(&pageset1_map); + free_dyn_pageflags(&pageset2_map); + free_dyn_pageflags(&pageset1_copy_map); + + /* Free allocated pages */ + if (allocd_pages_map) { + BITMAP_FOR_EACH_SET(allocd_pages_map, pagenumber) { + struct page * page = pfn_to_page(pagenumber); + ClearPageNosave(page); + __free_page(page); + extra_pagedir_pages_allocated--; + } + free_dyn_pageflags(&allocd_pages_map); + } + + pagedir1.pageset_size = pagedir2.pageset_size = 0; +} + +/* suspend2_allocate_extra_pagedir_memory + * + * Description: Allocate memory for making the atomic copy of pagedir1 in the + * case where it is bigger than pagedir2. + * Arguments: struct pagedir *: The pagedir for which we should + * allocate memory. + * int: Size of pageset 1. + * int: Size of pageset 2. + * Result: int. Zero on success. One if unable to allocate enough memory. + */ +int suspend2_allocate_extra_pagedir_memory(struct pagedir * p, int pageset_size, + int alloc_from) +{ + int num_to_alloc = pageset_size - alloc_from - extra_pagedir_pages_allocated; + int j, order; + + if (num_to_alloc < 1) + num_to_alloc = 0; + + if (num_to_alloc) { + int num_added = 0; + + order = generic_fls(num_to_alloc); + if (order >= MAX_ORDER) + order = MAX_ORDER - 1; + + while (num_added < num_to_alloc) { + struct page * newpage; + unsigned long virt; + + while ((1 << order) > (num_to_alloc - num_added)) + order--; + + virt = __get_free_pages(GFP_ATOMIC | __GFP_NOWARN, order); + while ((!virt) && (order > 0)) { + order--; + virt = __get_free_pages(GFP_ATOMIC | __GFP_NOWARN, order); + } + + if (!virt) { + p->pageset_size += num_added; + return 1; + } + + newpage = virt_to_page(virt); + for (j = 0; j < (1 << order); j++) { + SetPageNosave(newpage + j); + /* Pages will be freed one at a time. */ + set_page_count(newpage + j, 1); + SetPageAllocd(newpage + j); + extra_pagedir_pages_allocated++; + } + num_added+= (1 << order); + } + } + + return 0; +} + +/* + * suspend2_mark_task_as_pageset1 + * Functionality : Marks all the pages belonging to a given process as + * pageset 1 pages. + * Called From : pagedir.c - mark_pages_for_pageset2 + * + */ +void suspend2_mark_task_as_pageset1(struct task_struct *t) +{ + struct vm_area_struct *vma; + struct mm_struct *mm; + + mm = t->active_mm; + + if (!mm || !mm->mmap) return; + + down_read(&mm->mmap_sem); + for (vma = mm->mmap; vma; vma = vma->vm_next) { + unsigned long posn; + + if (!vma->vm_start) + continue; + + for (posn = vma->vm_start; posn < vma->vm_end; posn += PAGE_SIZE) { + struct page *page = follow_page(mm, posn, 0); + if (page) + ClearPagePageset2(page); + } + } + up_read(&mm->mmap_sem); +} + +/* mark_pages_for_pageset2 + * + * Description: Mark unshared pages in processes not needed for suspend as + * being able to be written out in a separate pagedir. + * HighMem pages are simply marked as pageset2. They won't be + * needed during suspend. + */ + +void suspend2_mark_pages_for_pageset2(void) +{ + struct zone * zone; + struct task_struct *p, *g; + unsigned long flags; + int i; + + clear_dyn_pageflags(pageset2_map); + + /* + * Note that we don't clear the map to begin with! + * This is because if we eat memory, we loose track + * of LRU pages that are still in use but taken off + * the LRU. If I can figure out how the VM keeps + * track of them, I might be able to tweak this a + * little further and decrease pageset one's size + * further. + * + * (Memory grabbing clears the pageset2 flag on + * pages that are really freed!). + */ + + /* Add LRU pages */ + for_each_zone(zone) { + spin_lock_irqsave(&zone->lru_lock, flags); + if (zone->nr_inactive) { + struct page * page; + list_for_each_entry(page, &zone->inactive_list, lru) + SetPagePageset2(page); + } + if (zone->nr_active) { + struct page * page; + list_for_each_entry(page, &zone->active_list, lru) + SetPagePageset2(page); + } + spin_unlock_irqrestore(&zone->lru_lock, flags); + } + + /* Now we find all userspace process (with task->mm) marked PF_NOFREEZE + * and move them into pageset1. + */ + read_lock(&tasklist_lock); + do_each_thread(g, p) { + if ((p->mm || p->active_mm) && (p->flags & PF_NOFREEZE)) + suspend2_mark_task_as_pageset1(p); + } while_each_thread(g, p); + read_unlock(&tasklist_lock); + + for (i = 0; i < max_pfn; i++) { + struct page * page = pfn_to_page(i); + BUG_ON(PagePageset2(page) && PageSlab(page)); + } +} + +static inline void SetPageConflicting(struct page * page) +{ + set_bit(PAGEBIT(page), PAGE_UL_PTR(conflicting_pages_map, page)); +} + +/* suspend2_get_nonconflicting_pages + * + * Description: Gets higher-order pages that won't be overwritten + * while copying the original pages. + * + * Note that if only one of the allocated pages overlaps + * with the pages that overlap, another set must be + * tried. Therefore, you shouldn't use this function + * much, and not with high orders. + */ + +unsigned long suspend2_get_nonconflicting_pages(const int order) +{ + struct page * page; + unsigned long new_page; + int more = 0, i; + unsigned long pgcount; + + if (!conflicting_pages_map && allocate_dyn_pageflags(&conflicting_pages_map)) + return -ENOMEM; + + do { + new_page = __get_free_pages(GFP_ATOMIC | __GFP_NOWARN, order); + if (!new_page) + return 0; + more = 0; + for (pgcount = 0; pgcount < (1UL << order); pgcount++) { + page = virt_to_page(new_page + PAGE_SIZE * pgcount); + if (PagePageset1(page)) { + more = 1; + break; + } + } + if (more) { + page = virt_to_page(new_page); + for (i = 0; i < (1UL << order); i++) + SetPageConflicting(page + i); + } + } + while (more); + + memset((void*)new_page, 0, PAGE_SIZE * (1< + * + * This file is released under the GPLv2. + * + * Declarations for routines for handling pagesets. + */ + +/* Pagedir + * + * Contains the metadata for a set of pages saved in the image. + */ + +struct pagedir { + int pageset_size; + int lastpageset_size; +}; + +extern struct pagedir pagedir1, pagedir2; + +extern void suspend2_copy_pageset1(void); + +extern void suspend2_free_pagedir_data(void); + +extern int suspend2_allocate_extra_pagedir_memory(struct pagedir * p, int pageset_size, int alloc_from); + +extern void suspend2_mark_task_as_pageset1 (struct task_struct *t); +extern void suspend2_mark_pages_for_pageset2(void); + +extern void suspend2_release_conflicting_pages(void); +extern void suspend2_relocate_page_if_required(void ** page_pointer_addr); +extern int suspend2_get_pageset1_load_addresses(void); + +extern int extra_pagedir_pages_allocated; + +extern unsigned long suspend2_get_nonconflicting_pages(int order); + +#ifdef CONFIG_DEBUG_PAGEALLOC +/* Returns whether it was already in the requested state */ +extern int suspend2_map_kernel_page(struct page * page, int enable); + +extern void suspend2_map_atomic_copy_pages(void); +extern void suspend2_unmap_atomic_copy_pages(void); +#else +#define suspend2_map_atomic_copy_pages() do { } while(0) +#define suspend2_unmap_atomic_copy_pages() do { } while(0) +static inline int suspend2_map_kernel_page(struct page * page, int enable) +{ + return 1; +} +#endif + diff -ruNp 800-suspend2.patch-old/kernel/power/pageflags.c 800-suspend2.patch-new/kernel/power/pageflags.c --- 800-suspend2.patch-old/kernel/power/pageflags.c 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/pageflags.c 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,133 @@ +/* + * kernel/power/suspend2_core/pageflags.c + * + * Copyright (C) 2004-2005 Nigel Cunningham + * + * This file is released under the GPLv2. + * + * Routines for dynamically allocating and releasing bitmaps + * used as pseudo-pageflags. + * + * Arrays are not contiguous. The first sizeof(void *) bytes are + * the pointer to the next page in the bitmap. This allows us to + * 1) work under low memory conditions where order 0 might be all + * that's available + * 2) save the pages at suspend time, reload and relocate them as + * necessary at resume time without breaking anything (cf + * extent pages). + */ + +#include +#include +#include +#include +#include +#include +#include "pageflags.h" +#include "plugins.h" +#include "pagedir.h" + +/* Maps used in copying the image back are in builtin.c */ +dyn_pageflags_t pageset1_map; +dyn_pageflags_t pageset1_copy_map; +dyn_pageflags_t pageset2_map; +dyn_pageflags_t in_use_map; +dyn_pageflags_t allocd_pages_map; +#ifdef CONFIG_DEBUG_PAGEALLOC +dyn_pageflags_t unmap_map; +#endif + +/* suspend_allocate_dyn_pageflags + * + * Description: Allocate a bitmap for local page flags. + * Arguments: dyn_pageflags_t *: Pointer to the bitmap. + * + * A version of allocate_dyn_pageflags that saves us then having + * to relocate the flags when resuming. + */ +int suspend_allocate_dyn_pageflags(dyn_pageflags_t *pagemap) +{ + int i; + + BUG_ON(*pagemap); + + if (test_suspend_state(SUSPEND_NOW_RESUMING)) { + /* + * We use kfree unconditionally below. That's not a problem + * because we only use this path when reloading pageset1. + */ + *pagemap = (dyn_pageflags_t) suspend2_get_nonconflicting_pages(0); + if (! *pagemap) { + printk("Failed to allocate a non-conflicting page for pageflags.\n"); + return 1; + } + } else + *pagemap = kmalloc(sizeof(void *) * PAGES_PER_BITMAP, GFP_ATOMIC); + + for (i = 0; i < PAGES_PER_BITMAP; i++) { + (*pagemap)[i] = (unsigned long *) get_zeroed_page(GFP_ATOMIC); + if (!(*pagemap)[i]) { + printk("Error. Unable to allocate memory for " + "local page flags."); + free_dyn_pageflags(pagemap); + return 1; + } + } + return 0; +} + +/* save_dyn_pageflags + * + * Description: Save a set of pageflags. + * Arguments: dyn_pageflags_t *: Pointer to the bitmap being saved. + */ + +void save_dyn_pageflags(dyn_pageflags_t pagemap) +{ + int i; + + if (!*pagemap) + return; + + for (i = 0; i < PAGES_PER_BITMAP; i++) + active_writer->ops.writer.write_header_chunk((char *) pagemap[i], PAGE_SIZE); +} + +/* load_dyn_pageflags + * + * Description: Load a set of pageflags. + * Arguments: dyn_pageflags_t *: Pointer to the bitmap being loaded. + * (It must be allocated before calling this routine). + */ + +void load_dyn_pageflags(dyn_pageflags_t pagemap) +{ + int i; + + if (!pagemap) + return; + + for (i = 0; i < PAGES_PER_BITMAP; i++) + active_writer->ops.writer.read_header_chunk((char *) pagemap[i], PAGE_SIZE); +} + +/* relocate_dyn_pageflags + * + * Description: Relocate a set of pageflags to ensure they don't collide with + * pageset 1 data which will get overwritten on copyback. + * Arguments: dyn_pageflags_t *: Pointer to the bitmap being relocated. + */ + +void relocate_dyn_pageflags(dyn_pageflags_t *pagemap) +{ + int i; + LIST_HEAD(rejected_pages); + + if (!*pagemap) + return; + + suspend2_relocate_page_if_required((void *) pagemap); + + for (i = 0; i < PAGES_PER_BITMAP; i++) + suspend2_relocate_page_if_required((void *) &((*pagemap)[i])); +} diff -ruNp 800-suspend2.patch-old/kernel/power/pageflags.h 800-suspend2.patch-new/kernel/power/pageflags.h --- 800-suspend2.patch-old/kernel/power/pageflags.h 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/pageflags.h 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,136 @@ +/* + * kernel/power/pageflags.h + * + * Copyright (C) 2004-2005 Nigel Cunningham + * + * This file is released under the GPLv2. + * + * Suspend2 needs a few pageflags while working that aren't otherwise + * used. To save the struct page pageflags, we dynamically allocate + * a bitmap and use that. These are the only non order-0 allocations + * we do. + * + * NOTE!!! + * We assume that PAGE_SIZE - sizeof(void *) is a multiple of + * sizeof(unsigned long). Is this ever false? + */ + +#include +#include + +extern dyn_pageflags_t in_use_map; +extern dyn_pageflags_t allocd_pages_map; +#ifdef CONFIG_DEBUG_PAGEALLOC +extern dyn_pageflags_t unmap_map; +#endif +extern dyn_pageflags_t pageset2_map; + +/* + * inusemap is used in two ways: + * - During suspend, to tag pages which are not used (to speed up + * count_data_pages); + * - During resume, to tag pages which are in pagedir1. This does not tag + * pagedir2 pages, so !== first use. + */ + +static inline int PageInUse(struct page * page) +{ + return test_bit(PAGEBIT(page), PAGE_UL_PTR(in_use_map, page)); +} + +static inline void SetPageInUse(struct page * page) +{ + set_bit(PAGEBIT(page), PAGE_UL_PTR(in_use_map, page)); +} + +static inline void ClearPageInUse(struct page * page) +{ + clear_bit(PAGEBIT(page), PAGE_UL_PTR(in_use_map, page)); +} + +static inline int PagePageset1(struct page * page) +{ + return (pageset1_map ? test_bit(PAGEBIT(page), PAGE_UL_PTR(pageset1_map, page)): 0); +} + +static inline void SetPagePageset1(struct page * page) +{ + set_bit(PAGEBIT(page), PAGE_UL_PTR(pageset1_map, page)); +} + +static inline void ClearPagePageset1(struct page * page) +{ + clear_bit(PAGEBIT(page), PAGE_UL_PTR(pageset1_map, page)); +} + + +static inline int PagePageset1Copy(struct page * page) +{ + return (pageset1_copy_map ? + test_bit(PAGEBIT(page), PAGE_UL_PTR(pageset1_copy_map, page)): 0); +} + +static inline void SetPagePageset1Copy(struct page * page) +{ + set_bit(PAGEBIT(page), PAGE_UL_PTR(pageset1_copy_map, page)); +} + +static inline void ClearPagePageset1Copy(struct page * page) +{ + clear_bit(PAGEBIT(page), PAGE_UL_PTR(pageset1_copy_map, page)); +} + + +static inline int PagePageset2(struct page * page) +{ + return (pageset2_map ? + test_bit(PAGEBIT(page), PAGE_UL_PTR(pageset2_map, page)): 0); +} + +static inline void SetPagePageset2(struct page * page) +{ + set_bit(PAGEBIT(page), PAGE_UL_PTR(pageset2_map, page)); +} + +static inline void ClearPagePageset2(struct page * page) +{ + clear_bit(PAGEBIT(page), PAGE_UL_PTR(pageset2_map, page)); +} + + +static inline int PageAllocd(struct page * page) +{ + return test_bit(PAGEBIT(page), PAGE_UL_PTR(allocd_pages_map, page)); +} + +static inline void SetPageAllocd(struct page * page) +{ + set_bit(PAGEBIT(page), PAGE_UL_PTR(allocd_pages_map, page)); +} + +static inline void ClearPageAllocd(struct page * page) +{ + clear_bit(PAGEBIT(page), PAGE_UL_PTR(allocd_pages_map, page)); +} + + +#ifdef CONFIG_DEBUG_PAGEALLOC +static inline void SetPageUnmap(struct page * page) +{ + set_bit(PAGEBIT(page), PAGE_UL_PTR(unmap_map, page)); +} + +static inline int PageUnmap(struct page * page) +{ + return test_bit(PAGEBIT(page), PAGE_UL_PTR(unmap_map, page)); +} +#endif + +#define BITMAP_FOR_EACH_SET(bitmap, counter) \ + for (counter = __get_next_bit_on(bitmap, -1); counter < max_mapnr; \ + counter = __get_next_bit_on(bitmap, counter)) + +extern void save_dyn_pageflags(dyn_pageflags_t pagemap); +extern void load_dyn_pageflags(dyn_pageflags_t pagemap); +int suspend_allocate_dyn_pageflags(dyn_pageflags_t *pagemap); +void relocate_dyn_pageflags(dyn_pageflags_t *pagemap); diff -ruNp 800-suspend2.patch-old/kernel/power/plugins.c 800-suspend2.patch-new/kernel/power/plugins.c --- 800-suspend2.patch-old/kernel/power/plugins.c 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/plugins.c 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,319 @@ +/* + * kernel/power/plugins.c + * + * Copyright (C) 2004-2005 Nigel Cunningham + * + */ + +#include +#include +#include "suspend2.h" +#include "plugins.h" + +struct list_head suspend_filters, suspend_writers, suspend_plugins; +struct suspend_plugin_ops * active_writer = NULL; +static int num_filters = 0, num_ui = 0; +int num_writers = 0, num_plugins = 0; + +/* + * header_storage_for_plugins + * + * Returns the amount of space needed to store configuration + * data needed by the plugins prior to copying back the original + * kernel. We can exclude data for pageset2 because it will be + * available anyway once the kernel is copied back. + */ +unsigned long header_storage_for_plugins(void) +{ + struct suspend_plugin_ops * this_plugin; + unsigned long bytes = 0; + + list_for_each_entry(this_plugin, &suspend_plugins, plugin_list) { + if (this_plugin->disabled) + continue; + if (this_plugin->storage_needed) + bytes += this_plugin->storage_needed(); + } + + return bytes; +} + +/* + * memory_for_plugins + * + * Returns the amount of memory requested by plugins for + * doing their work during the cycle. + */ + +unsigned long memory_for_plugins(void) +{ + unsigned long bytes = 0; + struct suspend_plugin_ops * this_plugin; + + list_for_each_entry(this_plugin, &suspend_plugins, plugin_list) { + if (this_plugin->disabled) + continue; + if (this_plugin->memory_needed) + bytes += this_plugin->memory_needed(); + } + + return ((bytes + PAGE_SIZE - 1) >> PAGE_SHIFT); +} + +/* find_plugin_given_name + * Functionality : Return a plugin (if found), given a pointer + * to its name + */ + +struct suspend_plugin_ops * find_plugin_given_name(char * name) +{ + struct suspend_plugin_ops * this_plugin, * found_plugin = NULL; + + list_for_each_entry(this_plugin, &suspend_plugins, plugin_list) { + if (!strcmp(name, this_plugin->name)) { + found_plugin = this_plugin; + break; + } + } + + return found_plugin; +} + +/* + * print_plugin_debug_info + * Functionality : Get debugging info from plugins into a buffer. + */ +int print_plugin_debug_info(char * buffer, int buffer_size) +{ + struct suspend_plugin_ops *this_plugin; + int len = 0; + + list_for_each_entry(this_plugin, &suspend_plugins, plugin_list) { + if (this_plugin->disabled) + continue; + if (this_plugin->print_debug_info) { + int result; + result = this_plugin->print_debug_info(buffer + len, + buffer_size - len); + len += result; + } + } + + return len; +} + +/* + * suspend_register_plugin + * + * Register a plugin. + */ +int suspend_register_plugin(struct suspend_plugin_ops * plugin) +{ + if (find_plugin_given_name(plugin->name)) + return -EBUSY; + + switch (plugin->type) { + case FILTER_PLUGIN: + list_add_tail(&plugin->ops.filter.filter_list, + &suspend_filters); + num_filters++; + break; + + case WRITER_PLUGIN: + list_add_tail(&plugin->ops.writer.writer_list, + &suspend_writers); + num_writers++; + break; + + case MISC_PLUGIN: + break; + + default: + printk("Hmmm. Plugin '%s' has an invalid type." + " It has been ignored.\n", plugin->name); + return -EINVAL; + } + list_add_tail(&plugin->plugin_list, &suspend_plugins); + num_plugins++; + + return 0; +} + +/* + * suspend_unregister_plugin + * + * Remove a plugin. + */ +void suspend_unregister_plugin(struct suspend_plugin_ops * plugin) +{ + switch (plugin->type) { + case FILTER_PLUGIN: + list_del(&plugin->ops.filter.filter_list); + num_filters--; + break; + + case WRITER_PLUGIN: + list_del(&plugin->ops.writer.writer_list); + num_writers--; + if (active_writer == plugin) { + active_writer = NULL; + set_suspend_state(SUSPEND_DISABLED); + } + break; + + case MISC_PLUGIN: + break; + + default: + printk("Hmmm. Plugin '%s' has an invalid type." + " It has been ignored.\n", plugin->name); + return; + } + list_del(&plugin->plugin_list); + num_plugins--; +} + +/* + * suspend_move_plugin_tail + * + * Rearrange plugins when reloading the config. + */ +void suspend_move_plugin_tail(struct suspend_plugin_ops * plugin) +{ + switch (plugin->type) { + case FILTER_PLUGIN: + if (num_filters > 1) + list_move_tail(&plugin->ops.filter.filter_list, + &suspend_filters); + break; + + case WRITER_PLUGIN: + if (num_writers > 1) + list_move_tail(&plugin->ops.writer.writer_list, + &suspend_writers); + break; + + case MISC_PLUGIN: + break; + default: + printk("Hmmm. Plugin '%s' has an invalid type." + " It has been ignored.\n", plugin->name); + return; + } + if ((num_filters + num_writers + num_ui) > 1) + list_move_tail(&plugin->plugin_list, &suspend_plugins); +} + +/* + * suspend2_initialise_plugins + * + * Get ready to do some work! + */ +int suspend2_initialise_plugins(int starting_cycle) +{ + struct suspend_plugin_ops * this_plugin; + int result; + + list_for_each_entry(this_plugin, &suspend_plugins, plugin_list) { + if (this_plugin->disabled) + continue; + if (this_plugin->type == WRITER_PLUGIN && + this_plugin != active_writer) + continue; + if (this_plugin->initialise) { + suspend_message(SUSPEND_MEMORY, SUSPEND_MEDIUM, 1, + "Initialising plugin %s.\n", + this_plugin->name); + if ((result = this_plugin->initialise(starting_cycle))) { + printk("%s didn't initialise okay.\n", + this_plugin->name); + return result; + } + } + } + + return 0; +} + +/* + * suspend2_cleanup_plugins + * + * Tell plugins the work is done. + */ +void suspend2_cleanup_plugins(int finishing_cycle) +{ + struct suspend_plugin_ops * this_plugin; + + list_for_each_entry(this_plugin, &suspend_plugins, plugin_list) { + if (this_plugin->disabled) + continue; + if (this_plugin->type == WRITER_PLUGIN && + this_plugin != active_writer) + continue; + if (this_plugin->cleanup) { + suspend_message(SUSPEND_MEMORY, SUSPEND_MEDIUM, 1, + "Cleaning up plugin %s.\n", + this_plugin->name); + this_plugin->cleanup(finishing_cycle); + } + } +} + +/* + * get_next_filter + * + * Get the next filter in the pipeline. + */ +struct suspend_plugin_ops * +get_next_filter(struct suspend_plugin_ops * filter_sought) +{ + struct suspend_plugin_ops * last_filter = NULL, *this_filter = NULL; + + list_for_each_entry(this_filter, &suspend_filters, ops.filter.filter_list) { + if (this_filter->disabled) + continue; + if ((last_filter == filter_sought) || (!filter_sought)) + return this_filter; + last_filter = this_filter; + } + + return active_writer; +} + +/* suspend2_get_modules + * + * Take a reference to modules so they can't go away under us. + */ + +int suspend2_get_modules(void) +{ + struct suspend_plugin_ops * this_plugin; + + list_for_each_entry(this_plugin, &suspend_plugins, plugin_list) { + if (!try_module_get(this_plugin->module)) { + /* Failed! Reverse gets and return error */ + struct suspend_plugin_ops * this_plugin2; + list_for_each_entry(this_plugin2, &suspend_plugins, plugin_list) { + if (this_plugin == this_plugin2) + return -EINVAL; + module_put(this_plugin2->module); + } + } + } + + return 0; +} + +/* suspend2_put_modules + * + * Release our references to modules we used. + */ + +void suspend2_put_modules(void) +{ + struct suspend_plugin_ops * this_plugin; + + list_for_each_entry(this_plugin, &suspend_plugins, plugin_list) { + module_put(this_plugin->module); + } +} diff -ruNp 800-suspend2.patch-old/kernel/power/plugins.h 800-suspend2.patch-new/kernel/power/plugins.h --- 800-suspend2.patch-old/kernel/power/plugins.h 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/plugins.h 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,179 @@ +/* + * kernel/power/plugin.h + * + * Copyright (C) 2004-2005 Nigel Cunningham + * + * This file is released under the GPLv2. + * + * It contains declarations for plugins. Plugins are additions to + * suspend2 that provide facilities such as image compression or + * encryption, backends for storage of the image and user interfaces. + * + */ + +/* This is the maximum size we store in the image header for a plugin name */ +#define SUSPEND_MAX_PLUGIN_NAME_LENGTH 30 + +/* Per-plugin metadata */ +struct plugin_header { + char name[SUSPEND_MAX_PLUGIN_NAME_LENGTH]; + int disabled; + int type; + int index; + int data_length; + unsigned long signature; +}; + +extern int num_plugins, num_writers; + +enum { + FILTER_PLUGIN, + WRITER_PLUGIN, + MISC_PLUGIN, // Block writer, eg. + CHECKSUM_PLUGIN +}; + +enum { + SUSPEND_ASYNC, + SUSPEND_SYNC +}; + +struct suspend_filter_ops { + /* Writing the image proper */ + int (*write_chunk) (struct page * buffer_page); + + /* Reading the image proper */ + int (*read_chunk) (struct page * buffer_page, int sync); + + /* Reset plugin if image exists but reading aborted */ + void (*noresume_reset) (void); + struct list_head filter_list; +}; + +struct suspend_writer_ops { + + /* Writing the image proper */ + int (*write_chunk) (struct page * buffer_page); + + /* Reading the image proper */ + int (*read_chunk) (struct page * buffer_page, int sync); + + /* Reset plugin if image exists but reading aborted */ + void (*noresume_reset) (void); + + /* Calls for allocating storage */ + + int (*storage_available) (void); // Maximum size of image we can save + // (incl. space already allocated). + + int (*storage_allocated) (void); + // Amount of storage already allocated + int (*release_storage) (void); + + /* + * Header space is allocated separately. Note that allocation + * of space for the header might result in allocated space + * being stolen from the main pool if there is no unallocated + * space. We have to be able to allocate enough space for + * the header. We can eat memory to ensure there is enough + * for the main pool. + */ + int (*allocate_header_space) (int space_requested); + int (*allocate_storage) (int space_requested); + + /* Read and write the metadata */ + int (*write_header_init) (void); + int (*write_header_chunk) (char * buffer_start, int buffer_size); + int (*write_header_cleanup) (void); + + int (*read_header_init) (void); + int (*read_header_chunk) (char * buffer_start, int buffer_size); + int (*read_header_cleanup) (void); + + /* Prepare metadata to be saved (relativise/absolutise extents) */ + int (*serialise_extents) (void); + int (*load_extents) (void); + + /* Attempt to parse an image location */ + int (*parse_image_location) (char * buffer, int only_writer); + + /* Determine whether image exists that we can restore */ + int (*image_exists) (void); + + /* Mark the image as having tried to resume */ + void (*mark_resume_attempted) (void); + + /* Destroy image if one exists */ + int (*invalidate_image) (void); + + /* Wait on I/O */ + int (*wait_on_io) (int flush_all); + + struct list_head writer_list; +}; + +struct suspend_plugin_ops { + /* Functions common to all plugins */ + int type; + char * name; + struct module * module; + int disabled; + struct list_head plugin_list; + + /* Bytes! */ + unsigned long (*memory_needed) (void); + unsigned long (*storage_needed) (void); + + int (*print_debug_info) (char * buffer, int size); + int (*save_config_info) (char * buffer); + void (*load_config_info) (char * buffer, int len); + + /* Initialise & cleanup - general routines called + * at the start and end of a cycle. */ + int (*initialise) (int starting_cycle); + void (*cleanup) (int finishing_cycle); + + int (*write_init) (int stream_number); + int (*write_cleanup) (void); + + int (*read_init) (int stream_number); + int (*read_cleanup) (void); + + union { + struct suspend_filter_ops filter; + struct suspend_writer_ops writer; + } ops; +}; + +extern struct suspend_plugin_ops * active_writer; +extern struct list_head suspend_filters, suspend_writers, suspend_plugins; + +extern void prepare_console_plugins(void); +extern void cleanup_console_plugins(void); + +extern struct suspend_plugin_ops * find_plugin_given_name(char * name); +extern struct suspend_plugin_ops * get_next_filter(struct suspend_plugin_ops *); + +extern int suspend_register_plugin(struct suspend_plugin_ops * plugin); +extern void suspend_move_plugin_tail(struct suspend_plugin_ops * plugin); + +extern unsigned long header_storage_for_plugins(void); +extern unsigned long memory_for_plugins(void); + +extern int print_plugin_debug_info(char * buffer, int buffer_size); +extern int suspend_register_plugin(struct suspend_plugin_ops * plugin); +extern void suspend_unregister_plugin(struct suspend_plugin_ops * plugin); + +extern int suspend2_initialise_plugins(int starting_cycle); +extern void suspend2_cleanup_plugins(int finishing_cycle); + +int suspend2_get_modules(void); +void suspend2_put_modules(void); + +static inline void suspend_initialise_plugin_lists(void) { + INIT_LIST_HEAD(&suspend_filters); + INIT_LIST_HEAD(&suspend_writers); + INIT_LIST_HEAD(&suspend_plugins); +} + +extern int expected_compression_ratio(void); diff -ruNp 800-suspend2.patch-old/kernel/power/power.h 800-suspend2.patch-new/kernel/power/power.h --- 800-suspend2.patch-old/kernel/power/power.h 2005-07-30 21:25:56.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/power.h 2005-07-30 21:14:46.000000000 +1000 @@ -1,6 +1,8 @@ #include #include +#include "suspend.h" + /* With SUSPEND_CONSOLE defined, it suspend looks *really* cool, but we probably do not take enough locks for switching consoles, etc, so bad things might happen. diff -ruNp 800-suspend2.patch-old/kernel/power/power_off.c 800-suspend2.patch-new/kernel/power/power_off.c --- 800-suspend2.patch-old/kernel/power/power_off.c 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/power_off.c 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,148 @@ +/* + * kernel/power/suspend2_core/power_off.c + * + * Copyright (C) 2005 Nigel Cunningham + * + * This file is released under the GPLv2. + * + * Support for powering down. + */ + +#include +#include +#include +#include +#include +#include "suspend2_common.h" +#include "suspend2.h" +#include "ui.h" + +unsigned long suspend2_powerdown_method = PM_SUSPEND_MAX; /* S5 = off */ +static int suspend_pm_state_used = 0; + +extern struct pm_ops * pm_ops; + +#ifdef CONFIG_ACPI +extern u32 acpi_leave_sleep_state (u8 sleep_state); +#endif + +/* suspend_power_off + * + * Power off the machine. + */ +static void suspend_power_off(void) +{ + machine_power_off(); + suspend2_prepare_status(DONT_CLEAR_BAR, "Probably not capable for powerdown."); + while (1) + cpu_relax(); + /* NOTREACHED */ +} + +/* suspend_pm_state_prepare + * + * Prepare to enter the sleep state. + */ +static int suspend_pm_state_prepare(void) +{ + int ret = 0; + + if (suspend2_powerdown_method == PM_SUSPEND_MEM || + suspend2_powerdown_method == PM_SUSPEND_DISK) + if (pm_ops && pm_ops->prepare) + ret = pm_ops->prepare(suspend2_powerdown_method); + + return ret; +} + +/* suspend_pm_sleep_state_enter + * + * Enter the sleep state requested. + */ +static int suspend_pm_state_enter(u32 state) +{ + int ret = 0; + unsigned long flags; + suspend_pm_state_used = state; + + local_irq_save(flags); + device_power_down(PMSG_SUSPEND); + if (pm_ops && pm_ops->enter) + ret = pm_ops->enter(state); + else + printk("Failed to enter state.\n"); + + device_power_up(); + local_irq_restore(flags); + + return ret; +} + +/* suspend_pm_state_finish + * + * Finish the sleep state. + */ +int suspend_pm_state_finish(void) +{ + int ret = 0; + + if (suspend2_powerdown_method == PM_SUSPEND_MEM || + suspend2_powerdown_method == PM_SUSPEND_DISK) + if (pm_ops && pm_ops->finish) + ret = pm_ops->finish(suspend2_powerdown_method); + + device_resume(); + + return ret; +} + +/* + * suspend_power_down + * Functionality : Powers down or reboots the computer once the image + * has been written to disk. + * Key Assumptions : Able to reboot/power down via code called or that + * the warning emitted if the calls fail will be visible + * to the user (ie printk resumes devices). + * Called From : do_suspend2_suspend_2 + */ + +void suspend_power_down(void) +{ + if (test_action_state(SUSPEND_REBOOT)) { + suspend2_prepare_status(DONT_CLEAR_BAR, "Ready to reboot."); + device_shutdown(); + machine_restart(NULL); + } + + if (suspend2_powerdown_method == PM_SUSPEND_MEM || + suspend2_powerdown_method == PM_SUSPEND_DISK) { + suspend2_prepare_status(DONT_CLEAR_BAR, "Seeking to enter ACPI state"); + if (suspend_pm_state_prepare()) { + suspend2_prepare_status(DONT_CLEAR_BAR, "Preparing to enter ACPI state failed. Using normal powerdown."); + goto abort_ACPI_sleep; + } + if (device_suspend(PMSG_SUSPEND)) { + suspend2_prepare_status(DONT_CLEAR_BAR, "Suspending devices failed. Using normal powerdown."); + suspend_pm_state_finish(); + goto abort_ACPI_sleep; + } + if (suspend_pm_state_enter(suspend2_powerdown_method)) { + suspend2_prepare_status(DONT_CLEAR_BAR, "Entering ACPI state failed. Using normal powerdown."); + suspend_pm_state_finish(); + goto abort_ACPI_sleep; + } + suspend_pm_state_finish(); + return; + } else + suspend2_prepare_status(DONT_CLEAR_BAR, "Powering down."); + +abort_ACPI_sleep: + /* + * FIXME: At resume, we'll still think we used S4 if we tried it. + * Does it matter? + */ + suspend_pm_state_used = 0; + device_shutdown(); + suspend_power_off(); +} + diff -ruNp 800-suspend2.patch-old/kernel/power/power_off.h 800-suspend2.patch-new/kernel/power/power_off.h --- 800-suspend2.patch-old/kernel/power/power_off.h 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/power_off.h 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,13 @@ +/* + * kernel/power/suspend2_core/power_off.h + * + * Copyright (C) 2005 Nigel Cunningham + * + * This file is released under the GPLv2. + * + * Support for the powering down. + */ + +int suspend_pm_state_finish(void); +void suspend_power_down(void); +extern unsigned long suspend2_powerdown_method; diff -ruNp 800-suspend2.patch-old/kernel/power/prepare_image.c 800-suspend2.patch-new/kernel/power/prepare_image.c --- 800-suspend2.patch-old/kernel/power/prepare_image.c 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/prepare_image.c 2005-07-30 21:26:04.000000000 +1000 @@ -0,0 +1,585 @@ +/* + * kernel/power/prepare_image.c + * + * Copyright (C) 2003-2005 Nigel Cunningham + * + * This file is released under the GPLv2. + * + * We need to eat memory until we can: + * 1. Perform the save without changing anything (RAM_NEEDED < max_mapnr) + * 2. Fit it all in available space (active_writer->available_space() >= + * storage_needed()) + * 3. Reload the pagedir and pageset1 to places that don't collide with their + * final destinations, not knowing to what extent the resumed kernel will + * overlap with the one loaded at boot time. I think the resumed kernel + * should overlap completely, but I don't want to rely on this as it is + * an unproven assumption. We therefore assume there will be no overlap at + * all (worse case). + * 4. Meet the user's requested limit (if any) on the size of the image. + * The limit is in MB, so pages/256 (assuming 4K pages). + * + * (Final test in save_image doesn't use eaten_enough_memory()) + */ + +#include + +#include "suspend2.h" +#include "pageflags.h" +#include "plugins.h" +#include "suspend2_common.h" +#include "io.h" +#include "ui.h" +#include "extent.h" +#include "prepare_image.h" + +static int are_frozen = 0, num_nosave = 0; +static int header_space_allocated = 0; +static int storage_allocated = 0; +static int storage_available = 0; + +static int num_pcp_pages(void) +{ + struct zone *zone; + int result = 0, i = 0; + + /* PCP lists */ + for_each_zone(zone) { + struct per_cpu_pageset *pset; + int cpu; + + if (!zone->present_pages) + continue; + + for (cpu = 0; cpu < NR_CPUS; cpu++) { + if (!cpu_possible(cpu)) + continue; + + pset = &zone->pageset[cpu]; + + for (i = 0; i < ARRAY_SIZE(pset->pcp); i++) { + struct per_cpu_pages *pcp; + + pcp = &pset->pcp[i]; + result += pcp->count; + } + } + } + return result; +} + +int real_nr_free_pages(void) +{ + return nr_free_pages() + num_pcp_pages(); +} + +static inline int main_storage_needed(int use_ecr) +{ + return ((pagedir1.pageset_size + pagedir2.pageset_size + 100 + + EXTRA_PD1_PAGES_ALLOWANCE) * + (use_ecr ? suspend2_expected_compression_ratio() : 100) / 100); +} + +static inline int header_bytes_needed(void) +{ + return ((extents_allocated * 2 * sizeof(unsigned long)) + + sizeof(struct suspend_header) + + sizeof(struct plugin_header) + + (int) header_storage_for_plugins() + + (PAGES_PER_BITMAP << PAGE_SHIFT) + + num_plugins * + (sizeof(struct plugin_header) + sizeof(int))); +} + +static inline int header_storage_needed(void) +{ + return ((int) ((header_bytes_needed() + (int) PAGE_SIZE - 1) >> PAGE_SHIFT)); +} + +/* generate_free_page_map + * + * Description: This routine generates a bitmap of free pages from the + * lists used by the memory manager. We then use the bitmap + * to quickly calculate which pages to save and in which + * pagesets. + */ +static void generate_free_page_map(void) +{ + int i, order, loop, cpu; + struct page * page; + unsigned long flags; + struct zone *zone; + struct per_cpu_pageset *pset; + + for(i=0; i < max_mapnr; i++) + SetPageInUse(pfn_to_page(i)); + + for_each_zone(zone) { + if (!zone->present_pages) + continue; + spin_lock_irqsave(&zone->lock, flags); + for (order = MAX_ORDER - 1; order >= 0; --order) { + list_for_each_entry(page, &zone->free_area[order].free_list, lru) + for(loop=0; loop < (1 << order); loop++) { + ClearPageInUse(page+loop); + ClearPagePageset2(page+loop); + } + } + + + for (cpu = 0; cpu < NR_CPUS; cpu++) { + if (!cpu_possible(cpu)) + continue; + + pset = &zone->pageset[cpu]; + + for (i = 0; i < ARRAY_SIZE(pset->pcp); i++) { + struct per_cpu_pages *pcp; + struct page * page; + + pcp = &pset->pcp[i]; + list_for_each_entry(page, &pcp->list, lru) { + ClearPageInUse(page); + ClearPagePageset2(page); + } + } + } + + spin_unlock_irqrestore(&zone->lock, flags); + } +} + +/* size_of_free_region + * + * Description: Return the number of pages that are free, beginning with and + * including this one. + */ +static int size_of_free_region(struct page * page) +{ + struct page * posn = page; + + while (((page_to_pfn(posn)) < max_mapnr) && (!PageInUse(posn))) + posn++; + return (posn - page); +} + +/* count_data_pages + * + * This routine generates our lists of pages to be stored in each + * pageset. Since we store the data using extents, and adding new + * extents might allocate a new extent page, this routine may well + * be called more than once. + */ +static struct pageset_sizes_result count_data_pages(void) +{ + int chunk_size, loop, num_free = 0; + int use_pagedir2; + struct pageset_sizes_result result; + + result.size1 = 0; + result.size1low = 0; + result.size2 = 0; + result.size2low = 0; + + num_nosave = 0; + + clear_dyn_pageflags(pageset1_map); + clear_dyn_pageflags(pageset1_copy_map); + + generate_free_page_map(); + + if (test_result_state(SUSPEND_ABORTED)) + return result; + + if (max_mapnr != num_physpages) { + abort_suspend("Max_mapnr is not equal to num_physpages."); + return result; + } + + /* + * Pages not to be saved are marked Nosave irrespective of being reserved + */ + for (loop = 0; loop < max_mapnr; loop++) { + struct page * page = pfn_to_page(loop); + if (PageNosave(page)) { + num_nosave++; + continue; + } + + if (!PageReserved(page)) { + if ((chunk_size=size_of_free_region(page))!=0) { + num_free += chunk_size; + loop += chunk_size - 1; + continue; + } + } else { + if (PageHighMem(page)) { + /* HighMem pages may be marked Reserved. We ignore them. */ + num_nosave++; + continue; + } + }; + + use_pagedir2 = PagePageset2(page); + + if (use_pagedir2) { + result.size2++; + if (!PageHighMem(page)) + result.size2low++; + SetPagePageset1Copy(page); + } else { + result.size1++; + SetPagePageset1(page); + if (!PageHighMem(page)) + result.size1low++; + } + } + + suspend_message(SUSPEND_EAT_MEMORY, SUSPEND_MEDIUM, 0, + "Count data pages: Set1 (%d) + Set2 (%d) + Nosave (%d) + NumFree (%d) = %d.\n", + result.size1, result.size2, num_nosave, num_free, + result.size1 + result.size2 + num_nosave + num_free); + BITMAP_FOR_EACH_SET(allocd_pages_map, loop) + SetPagePageset1Copy(pfn_to_page(loop)); + return result; +} + +/* amount_needed + * + * Calculates the amount by which the image size needs to be reduced to meet + * our constraints. + */ +static int amount_needed(int use_image_size_limit) +{ + + int max1 = max( (int) (ram_to_suspend() - real_nr_free_pages() - + nr_free_highpages()), + ((int) (storage_needed(1) - + storage_available))); + if (use_image_size_limit) + return max( max1, + (image_size_limit > 0) ? + ((int) (storage_needed(1) - (image_size_limit << 8))) : 0); + return max1; +} + +/* suspend2_recalculate_stats + * + * Eaten is the number of pages which have been eaten. + * Pagedirincluded is the number of pages which have been allocated for the pagedir. + */ +struct pageset_sizes_result suspend2_recalculate_stats(void) +{ + struct pageset_sizes_result result; + + suspend2_mark_pages_for_pageset2(); /* Need to call this before getting pageset1_size! */ + result = count_data_pages(); + pageset1_sizelow = result.size1low; + pageset2_sizelow = result.size2low; + pagedir1.lastpageset_size = pagedir1.pageset_size = result.size1; + pagedir2.lastpageset_size = pagedir2.pageset_size = result.size2; + storage_available = active_writer->ops.writer.storage_available(); + return result; +} + +/* update_image + * + * Allocate [more] memory and storage for the image. + */ +static int update_image(void) +{ + struct pageset_sizes_result result; + int result2, param_used; + + result = suspend2_recalculate_stats(); + + /* Include allowance for growth in pagedir1 while writing pagedir 2 */ + if (suspend2_allocate_extra_pagedir_memory(&pagedir1, + pagedir1.pageset_size + EXTRA_PD1_PAGES_ALLOWANCE, + pageset2_sizelow)) { + suspend_message(SUSPEND_EAT_MEMORY, SUSPEND_LOW, 1, + "Still need to get more pages for pagedir 1.\n"); + return 1; + } + + thaw_processes(FREEZER_KERNEL_THREADS); + + param_used = main_storage_needed(1); + if ((result2 = active_writer->ops.writer.allocate_storage(param_used))) { + suspend_message(SUSPEND_EAT_MEMORY, SUSPEND_LOW, 1, + "Still need to get more storage space for the image proper.\n"); + storage_allocated = active_writer->ops.writer.storage_allocated(); + freeze_processes(1); + return 1; + } + + param_used = header_storage_needed(); + if ((result2 = active_writer->ops.writer.allocate_header_space(header_storage_needed()))) { + suspend_message(SUSPEND_EAT_MEMORY, SUSPEND_LOW, 1, + "Still need to get more storage space for header.\n"); + freeze_processes(1); + storage_allocated = active_writer->ops.writer.storage_allocated(); + return 1; + } + + header_space_allocated = header_storage_needed(); + + /* + * Allocate remaining storage space, if possible, up to the + * maximum we know we'll need. It's okay to allocate the + * maximum if the writer is the swapwriter, but + * we don't want to grab all available space on an NFS share. + * We therefore ignore the expected compression ratio here, + * thereby trying to allocate the maximum image size we could + * need (assuming compression doesn't expand the image), but + * don't complain if we can't get the full amount we're after. + */ + + active_writer->ops.writer.allocate_storage( + min(storage_available, + main_storage_needed(0) + 100)); + + storage_allocated = active_writer->ops.writer.storage_allocated(); + + freeze_processes(1); + + suspend2_recalculate_stats(); + + suspend_message(SUSPEND_EAT_MEMORY, SUSPEND_LOW, 1, + "Amount still needed (%d) > 0:%d. Header: %d < %d: %d," + " Storage allocd: %d < %d + %d: %d.\n", + amount_needed(0), + (amount_needed(0) > 0), + header_space_allocated, header_storage_needed(), + header_space_allocated < header_storage_needed(), + storage_allocated, + header_storage_needed(), main_storage_needed(1), + storage_allocated < + (header_storage_needed() + main_storage_needed(1))); + + check_shift_keys(0, NULL); + + return ((amount_needed(0) > 0) || + header_space_allocated < header_storage_needed() || + storage_allocated < + (header_storage_needed() + main_storage_needed(1))); +} + +/* attempt_to_freeze + * + * Try to freeze processes. + */ + +static int attempt_to_freeze(void) +{ + int result; + + /* Stop processes before checking again */ + thaw_processes(FREEZER_ALL_THREADS); + suspend2_prepare_status(CLEAR_BAR, "Freezing processes"); + result = freeze_processes(0); + + if (result) { + set_result_state(SUSPEND_ABORTED); + set_result_state(SUSPEND_FREEZING_FAILED); + } else + are_frozen = 1; + + return result; +} + +static inline int eaten_enough_memory(void) +{ + return (amount_needed(1) < 1); +} + +int storage_needed(int use_ecr) +{ + return (main_storage_needed(use_ecr) + header_storage_needed()); +} + +int ram_to_suspend(void) +{ + return (1 + + max((pagedir1.pageset_size + EXTRA_PD1_PAGES_ALLOWANCE - + pageset2_sizelow), 0) + + MIN_FREE_RAM + memory_for_plugins()); +} + + +/* eat_memory + * + * Try to free some memory, either to meet hard or soft constraints on the image + * characteristics. + * + * Hard constraints: + * - Pageset1 must be < half of memory; + * - We must have enough memory free at resume time to have pageset1 + * be able to be loaded in pages that don't conflict with where it has to + * be restored. + * Soft constraints + * - User specificied image size limit. + */ +static int eat_memory(void) +{ + int orig_memory_still_to_eat, last_amount_needed = 0, times_criteria_met = 0; + int free_flags = 0, did_eat_memory = 0; + + /* + * Note that if we have enough storage space and enough free memory, we may + * exit without eating anything. We give up when the last 10 iterations ate + * no extra pages because we're not going to get much more anyway, but + * the few pages we get will take a lot of time. + * + * We freeze processes before beginning, and then unfreeze them if we + * need to eat memory until we think we have enough. If our attempts + * to freeze fail, we give up and abort. + */ + + /* -- Stage 1: Freeze Processes -- */ + + + suspend2_recalculate_stats(); + + orig_memory_still_to_eat = amount_needed(1); + last_amount_needed = orig_memory_still_to_eat; + + switch (image_size_limit) { + case -1: /* Don't eat any memory */ + if (orig_memory_still_to_eat) { + set_result_state(SUSPEND_ABORTED); + set_result_state(SUSPEND_WOULD_EAT_MEMORY); + } + break; + case -2: /* Free caches only */ + free_flags = GFP_NOIO | __GFP_HIGHMEM; + break; + default: + free_flags = GFP_ATOMIC | __GFP_HIGHMEM; + } + + /* -- Stage 2: Eat memory -- */ + + while (((!eaten_enough_memory()) || (image_size_limit == -2)) && + (!test_result_state(SUSPEND_ABORTED)) && + (times_criteria_met < 10)) { + int amount_freed; + int amount_wanted = orig_memory_still_to_eat - amount_needed(1); + + suspend2_prepare_status(CLEAR_BAR, "Seeking to free %dMB of memory.", MB(amount_needed(1))); + + if (amount_wanted < 1) + amount_wanted = 1; /* image_size_limit == -2 */ + + if (orig_memory_still_to_eat) + suspend2_update_status(orig_memory_still_to_eat - amount_needed(1), + orig_memory_still_to_eat, + " Image size %d ", + MB(storage_needed(1))); + else + suspend2_update_status(0, 1, "Image size %d ", + MB(storage_needed(1))); + + if ((last_amount_needed - amount_needed(1)) < 10) + times_criteria_met++; + else + times_criteria_met = 0; + last_amount_needed = amount_needed(1); + amount_freed = shrink_all_memory(last_amount_needed); + suspend2_recalculate_stats(); + + did_eat_memory = 1; + + check_shift_keys(0, NULL); + } + + if (did_eat_memory) { + unsigned long orig_state = get_suspend_state(); + thaw_processes(FREEZER_KERNEL_THREADS); + /* Freeze_processes will call sys_sync too */ + freeze_processes(1); + restore_suspend_state(orig_state); + suspend2_recalculate_stats(); + } + + /* Blank out image size display */ + suspend2_update_status(100, 100, NULL); + + if (!test_result_state(SUSPEND_ABORTED)) { + /* Include image size limit when checking what to report */ + if (amount_needed(1) > 0) + set_result_state(SUSPEND_UNABLE_TO_FREE_ENOUGH_MEMORY); + + /* But don't include it when deciding whether to abort (soft limit) */ + if ((amount_needed(0) > 0)) { + printk("Unable to free sufficient memory to suspend. Still need %d pages.\n", + amount_needed(1)); + set_result_state(SUSPEND_ABORTED); + } + + check_shift_keys(1, "Memory eating completed."); + } + + return 0; +} + +/* prepare_image + * + * Entry point to the whole image preparation section. + * + * We do four things: + * - Freeze processes; + * - Ensure image size constraints are met; + * - Complete all the preparation for saving the image, + * including allocation of storage. The only memory + * that should be needed when we're finished is that + * for actually storing the image (and we know how + * much is needed for that because the plugins tell + * us). + * - Make sure that all dirty buffers are written out. + */ + +#define MAX_TRIES 4 +int suspend2_prepare_image(void) +{ + int result = 1, size_sought, tries = 0; + + are_frozen = 0; + + header_space_allocated = 0; + + size_sought = 100 + memory_for_plugins(); + + if (attempt_to_freeze()) + return 0; + + storage_available = active_writer->ops.writer.storage_available(); + + if (!storage_available) { + printk(KERN_ERR "You need some storage available to be able to suspend.\n"); + set_result_state(SUSPEND_ABORTED); + set_result_state(SUSPEND_NOSTORAGE_AVAILABLE); + return 0; + } + + do { + suspend2_prepare_status(CLEAR_BAR, "Preparing Image."); + + if (eat_memory() || test_result_state(SUSPEND_ABORTED)) + break; + + result = update_image(); + + check_shift_keys(0, NULL); + + tries++; + + } while ((result) && (tries < MAX_TRIES) && (!test_result_state(SUSPEND_ABORTED)) && + (!test_result_state(SUSPEND_UNABLE_TO_FREE_ENOUGH_MEMORY))); + + if (tries == MAX_TRIES) + abort_suspend("Unable to get sufficient storage for the image.\n"); + + check_shift_keys(1, "Image preparation complete."); + + return !result; +} diff -ruNp 800-suspend2.patch-old/kernel/power/prepare_image.h 800-suspend2.patch-new/kernel/power/prepare_image.h --- 800-suspend2.patch-old/kernel/power/prepare_image.h 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/prepare_image.h 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,33 @@ +/* + * kernel/power/prepare_image.h + */ + +extern int suspend2_prepare_image(void); +extern struct pageset_sizes_result suspend2_recalculate_stats(void); +extern int real_nr_free_pages(void); +extern int image_size_limit; +extern int pageset1_sizelow, pageset2_sizelow; + +struct pageset_sizes_result { + int size1; /* Can't be unsigned - breaks MAX function */ + int size1low; + int size2; + int size2low; + int needmorespace; +}; + +#ifdef CONFIG_CRYPTO +extern int suspend2_expected_compression_ratio(void); +#else +static inline int suspend2_expected_compression_ratio(void) +{ + return 0; +}; +#endif + +#define MIN_FREE_RAM (max_low_pfn >> 7) + +#define EXTRA_PD1_PAGES_ALLOWANCE 100 + +extern int storage_needed(int use_ecr); +extern int ram_to_suspend(void); diff -ruNp 800-suspend2.patch-old/kernel/power/proc.c 800-suspend2.patch-new/kernel/power/proc.c --- 800-suspend2.patch-old/kernel/power/proc.c 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/proc.c 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,336 @@ +/* + * /kernel/power/proc.c + * + * Copyright (C) 2002-2005 Nigel Cunningham + * + * This file is released under the GPLv2. + * + * This file contains support for proc entries for tuning Software Suspend. + * + * We have a generic handler that deals with the most common cases, and + * hooks for special handlers to use. + * + * Versions: + * 1: /proc/sys/kernel/suspend the only tuning interface + * 2: Initial version of this file + * 3: Removed kernel debugger parameter. + * Added checkpage parameter (for checking checksum of a page over time). + * 4: Added entry for maximum granularity in splash screen progress bar. + * (Progress bar is slow, but the right setting will vary with disk & + * processor speed and the user's tastes). + * 5: Added enable_escape to control ability to cancel aborting by pressing + * ESC key. + * 6: Removed checksumming and checkpage parameter. Made all debugging proc + * entries dependant upon debugging being compiled in. + * Meaning of some flags also changed in this version. + * 7: Added header_locations entry to simplify getting the resume= parameter for + * swapfiles easy and swapfile entry for automatically doing swapon/off from + * swapfiles as well as partitions. + * 8: Added option for marking process pages as pageset 2 (processes_pageset2). + * 9: Added option for keep image mode. + * Enumeration patch from Michael Frank applied. + * 10: Various corrections to when options are disabled/enabled; + * Added option for specifying expected compression. + * 11: Added option for freezer testing. Debug only. + * 12: Removed test entries no_async_[read|write], processes_pageset2 and + * NoPageset2. + * 13: Make default_console_level available when debugging disabled, but limited + * to 0 or 1. + * 14: Rewrite to allow for dynamic registration of proc entries and smooth the + * transition to kobjects in 2.6. + * 15: Add setting resume2 parameter without rebooting (still need to run lilo + * though!). Add support for generic string handling and switch resume2 to use + * it. + * 16: Switched to cryptoapi, adding entries for selecting encryptor and compressor. + */ + +#define SUSPEND_PROC_C + +static int suspend_proc_version = 16; +static int suspend_proc_initialised = 0; + +#include +#include +#include + +#include "proc.h" +#include "suspend2.h" + +static struct list_head suspend_proc_entries; +static struct proc_dir_entry *suspend_dir; +static struct suspend_proc_data proc_params[]; + +extern void __suspend2_try_resume(void); +extern void __suspend2_try_suspend(void); + +/* suspend2_read_proc + * + * Generic handling for reading the contents of bits, integers, + * unsigned longs and strings. + */ +static int suspend2_read_proc(char * page, char ** start, off_t off, int count, + int *eof, void *data) +{ + int len = 0; + struct suspend_proc_data * proc_data = (struct suspend_proc_data *) data; + + if (suspend_start_anything(0)) + return -EBUSY; + + switch (proc_data->type) { + case SUSPEND_PROC_DATA_CUSTOM: + if (proc_data->data.special.read_proc) { + read_proc_t * read_proc = proc_data->data.special.read_proc; + len = read_proc(page, start, off, count, eof, data); + } else + len = 0; + break; + case SUSPEND_PROC_DATA_BIT: + len = sprintf(page, "%d\n", + -test_bit(proc_data->data.bit.bit, + proc_data->data.bit.bit_vector)); + break; + case SUSPEND_PROC_DATA_INTEGER: + { + int * variable = proc_data->data.integer.variable; + len = sprintf(page, "%d\n", *variable); + break; + } + case SUSPEND_PROC_DATA_UL: + { + long * variable = proc_data->data.ul.variable; + len = sprintf(page, "%lu\n", *variable); + break; + } + case SUSPEND_PROC_DATA_STRING: + { + char * variable = proc_data->data.string.variable; + len = sprintf(page, "%s\n", variable); + break; + } + } + /* Side effect routine? */ + if (proc_data->read_proc) + proc_data->read_proc(); + if ((proc_data->type != SUSPEND_PROC_DATA_CUSTOM) || (!proc_data->data.special.read_proc)) + *eof = 1; + + suspend_finish_anything(0); + + return len; +} +/* suspend2_write_proc + * + * Generic routine for handling writing to files representing + * bits, integers and unsigned longs. + */ + +static int suspend2_write_proc(struct file *file, const char * buffer, + unsigned long count, void * data) +{ + struct suspend_proc_data * proc_data = (struct suspend_proc_data *) data; + char * my_buf = (char *) get_zeroed_page(GFP_ATOMIC); + int result = count, assigned_temp_buffer = 0; + + if (!my_buf) + return -ENOMEM; + + if (count > PAGE_SIZE) + count = PAGE_SIZE; + + if (copy_from_user(my_buf, buffer, count)) + return -EFAULT; + + if (suspend_start_anything(proc_data == &proc_params[0])) + return -EBUSY; + + my_buf[count] = 0; + + switch (proc_data->type) { + case SUSPEND_PROC_DATA_CUSTOM: + if (proc_data->data.special.write_proc) { + write_proc_t * write_proc = proc_data->data.special.write_proc; + result = write_proc(file, buffer, count, data); + } + break; + case SUSPEND_PROC_DATA_BIT: + { + int value = simple_strtoul(my_buf, NULL, 0); + if (value) + set_bit(proc_data->data.bit.bit, + (proc_data->data.bit.bit_vector)); + else + clear_bit(proc_data->data.bit.bit, + (proc_data->data.bit.bit_vector)); + } + break; + case SUSPEND_PROC_DATA_INTEGER: + { + int * variable = proc_data->data.integer.variable; + int minimum = proc_data->data.integer.minimum; + int maximum = proc_data->data.integer.maximum; + *variable = simple_strtol(my_buf, NULL, 0); + if (((*variable) < minimum)) + *variable = minimum; + + if (((*variable) > maximum)) + *variable = maximum; + break; + } + case SUSPEND_PROC_DATA_UL: + { + unsigned long * variable = proc_data->data.ul.variable; + unsigned long minimum = proc_data->data.ul.minimum; + unsigned long maximum = proc_data->data.ul.maximum; + *variable = simple_strtoul(my_buf, NULL, 0); + + if (minimum && ((*variable) < minimum)) + *variable = minimum; + + if (maximum && ((*variable) > maximum)) + *variable = maximum; + break; + } + break; + case SUSPEND_PROC_DATA_STRING: + { + int copy_len = count; + char * variable = + proc_data->data.string.variable; + + if (proc_data->data.string.max_length && + (copy_len > proc_data->data.string.max_length)) + copy_len = proc_data->data.string.max_length; + + if (!variable) { + proc_data->data.string.variable = + variable = (char *) get_zeroed_page(GFP_ATOMIC); + assigned_temp_buffer = 1; + } + strncpy(variable, my_buf, copy_len); + if ((copy_len) && + (my_buf[copy_len - 1] == '\n')) + variable[count - 1] = 0; + variable[count] = 0; + } + break; + } + free_page((unsigned long) my_buf); + /* Side effect routine? */ + if (proc_data->write_proc) + proc_data->write_proc(); + + /* Free temporary buffers */ + if (assigned_temp_buffer) { + free_page((unsigned long) proc_data->data.string.variable); + proc_data->data.string.variable = NULL; + } + + suspend_finish_anything(proc_data == &proc_params[0]); + + return result; +} + +/* Non-plugin proc entries. + * + * This array contains entries that are automatically registered at + * boot. Plugins and the console code register their own entries separately. + * + * NB: If you move do_suspend, change suspend2_write_proc's test so that + * suspend_start_anything still gets a 1 when the user echos > do_suspend! + */ + +static struct suspend_proc_data proc_params[] = { + { .filename = "do_suspend", + .permissions = PROC_WRITEONLY, + .type = SUSPEND_PROC_DATA_CUSTOM, + .write_proc = __suspend2_try_suspend, + }, + + { .filename = "do_resume", + .permissions = PROC_WRITEONLY, + .type = SUSPEND_PROC_DATA_CUSTOM, + .write_proc = __suspend2_try_resume, + }, + + + { .filename = "interface_version", + .permissions = PROC_READONLY, + .type = SUSPEND_PROC_DATA_INTEGER, + .data = { + .integer = { + .variable = &suspend_proc_version, + } + } + }, +}; + +/* suspend_initialise_proc + * + * Initialise the /proc/software_suspend directory. + */ + +static void suspend_initialise_proc(void) +{ + int i; + int numfiles = sizeof(proc_params) / sizeof(struct suspend_proc_data); + + if (suspend_proc_initialised) + return; + + suspend_dir = proc_mkdir("software_suspend", NULL); + + BUG_ON(!suspend_dir); + + INIT_LIST_HEAD(&suspend_proc_entries); + + suspend_proc_initialised = 1; + + for (i=0; i< numfiles; i++) + suspend_register_procfile(&proc_params[i]); +} + +/* suspend_register_procfile + * + * Helper for registering a new /proc/software_suspend entry. + */ + +struct proc_dir_entry * suspend_register_procfile( + struct suspend_proc_data * suspend_proc_data) +{ + struct proc_dir_entry * new_entry; + + if (!suspend_proc_initialised) + suspend_initialise_proc(); + + new_entry = create_proc_entry( + suspend_proc_data->filename, + suspend_proc_data->permissions, + suspend_dir); + if (new_entry) { + list_add_tail(&suspend_proc_data->proc_data_list, &suspend_proc_entries); + new_entry->read_proc = suspend2_read_proc; + new_entry->write_proc = suspend2_write_proc; + new_entry->data = suspend_proc_data; + } else { + printk("Error! create_proc_entry returned NULL.\n"); + INIT_LIST_HEAD(&suspend_proc_data->proc_data_list); + } + return new_entry; +} + +/* suspend_unregister_procfile + * + * Helper for removing unwanted /proc/software_suspend entries. + * + */ +void suspend_unregister_procfile(struct suspend_proc_data * suspend_proc_data) +{ + if (list_empty(&suspend_proc_data->proc_data_list)) + return; + + remove_proc_entry( + suspend_proc_data->filename, + suspend_dir); + list_del(&suspend_proc_data->proc_data_list); +} diff -ruNp 800-suspend2.patch-old/kernel/power/process.c 800-suspend2.patch-new/kernel/power/process.c --- 800-suspend2.patch-old/kernel/power/process.c 2005-07-30 21:25:56.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/process.c 2005-07-30 21:14:46.000000000 +1000 @@ -127,56 +127,6 @@ void refrigerator(void) } -#ifdef CONFIG_SMP -static void __smp_pause(void * data) -{ - atomic_inc(&suspend_cpu_counter); - while(test_suspend_state(SUSPEND_FREEZE_SMP)) { - cpu_relax(); - barrier(); - } - local_flush_tlb(); - atomic_dec(&suspend_cpu_counter); -} - -void smp_pause(void) -{ - set_suspend_state(SUSPEND_FREEZE_SMP); - smp_call_function(__smp_pause, NULL, 0, 0); - - while (atomic_read(&suspend_cpu_counter) < (num_online_cpus() - 1)) { - cpu_relax(); - barrier(); - } -} - -void smp_continue(void) -{ - clear_suspend_state(SUSPEND_FREEZE_SMP); - - while (atomic_read(&suspend_cpu_counter)) { - cpu_relax(); - barrier(); - } -} - -extern void __smp_suspend_lowlevel(void * info); - -void smp_suspend(void) -{ - set_suspend_state(SUSPEND_FREEZE_SMP); - smp_call_function(__smp_suspend_lowlevel, NULL, 0, 0); - - while (atomic_read(&suspend_cpu_counter) < (num_online_cpus() - 1)) { - cpu_relax(); - barrier(); - } -} -#else -#define smp_pause() do { } while(0) -#define smp_continue() do { } while(0) -#define smp_suspend() do { } while(0) -#endif /* * num_to_be_frozen @@ -239,16 +189,8 @@ static int freeze_threads(int type, int do { int numsignalled = 0; - /* - * Pause the other processors so we can safely - * change threads' flags - */ - smp_pause(); - - if (test_result_state(SUSPEND_ABORTED)) { - smp_continue(); + if (test_result_state(SUSPEND_ABORTED)) return 1; - } preempt_disable(); @@ -290,11 +232,6 @@ static int freeze_threads(int type, int read_unlock(&tasklist_lock); - /* - * Let the processes run. - */ - smp_continue(); - preempt_enable(); local_irq_enable(); @@ -439,13 +376,6 @@ void thaw_processes(int which_threads) clear_suspend_state(SUSPEND_DISABLE_SYNCING); - /* - * Pause the other processors so we can safely - * change threads' flags - */ - - smp_pause(); - preempt_disable(); local_irq_disable(); @@ -464,8 +394,6 @@ void thaw_processes(int which_threads) read_unlock(&tasklist_lock); - smp_continue(); - preempt_enable(); local_irq_enable(); diff -ruNp 800-suspend2.patch-old/kernel/power/proc.h 800-suspend2.patch-new/kernel/power/proc.h --- 800-suspend2.patch-old/kernel/power/proc.h 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/proc.h 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,68 @@ +/* + * kernel/power/proc.h + * + * Copyright (C) 2004-2005 Nigel Cunningham + * + * This file is released under the GPLv2. + * + * It provides declarations for suspend to use in managing + * /proc/software_suspend. When we switch to kobjects, + * this will become redundant. + * + */ + +#include + +struct suspend_proc_data { + char * filename; + int permissions; + int type; + union { + struct { + unsigned long * bit_vector; + int bit; + } bit; + struct { + int * variable; + int minimum; + int maximum; + } integer; + struct { + unsigned long * variable; + unsigned long minimum; + unsigned long maximum; + } ul; + struct { + char * variable; + int max_length; + } string; + struct { + read_proc_t * read_proc; + write_proc_t * write_proc; + void * data; + } special; + } data; + + /* Side effects routines. Used, eg, for reparsing the + * resume2 entry when it changes */ + void (* read_proc) (void); + void (* write_proc) (void); + struct list_head proc_data_list; +}; + +enum { + SUSPEND_PROC_DATA_CUSTOM, + SUSPEND_PROC_DATA_BIT, + SUSPEND_PROC_DATA_INTEGER, + SUSPEND_PROC_DATA_UL, + SUSPEND_PROC_DATA_STRING +}; + +#define PROC_WRITEONLY 0200 +#define PROC_READONLY 0400 +#define PROC_RW 0600 + +struct proc_dir_entry * suspend_register_procfile( + struct suspend_proc_data * suspend_proc_data); +void suspend_unregister_procfile(struct suspend_proc_data * suspend_proc_data); + diff -ruNp 800-suspend2.patch-old/kernel/power/suspend2_common.h 800-suspend2.patch-new/kernel/power/suspend2_common.h --- 800-suspend2.patch-old/kernel/power/suspend2_common.h 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/suspend2_common.h 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,53 @@ +#ifdef CONFIG_PM_DEBUG +#define set_debug_state(bit) (test_and_set_bit(bit, &suspend_debug_state)) +#define clear_debug_state(bit) (test_and_clear_bit(bit, &suspend_debug_state)) +#else +#define set_debug_state(bit) (0) +#define clear_debug_state(bit) (0) +#endif + +#define set_result_state(bit) (test_and_set_bit(bit, &suspend_result)) +#define clear_result_state(bit) (test_and_clear_bit(bit, &suspend_result)) + +enum { + SUSPEND_ABORT_REQUESTED, + SUSPEND_NOSTORAGE_AVAILABLE, + SUSPEND_INSUFFICIENT_STORAGE, + SUSPEND_FREEZING_FAILED, + SUSPEND_UNEXPECTED_ALLOC, + SUSPEND_KEPT_IMAGE, + SUSPEND_WOULD_EAT_MEMORY, + SUSPEND_UNABLE_TO_FREE_ENOUGH_MEMORY, + SUSPEND_ENCRYPTION_SETUP_FAILED +}; + +/* second status register */ +enum { + SUSPEND_REBOOT, + SUSPEND_PAUSE, + SUSPEND_SLOW, + SUSPEND_NOPAGESET2, + SUSPEND_LOGALL, + SUSPEND_CAN_CANCEL, + SUSPEND_KEEP_IMAGE, + SUSPEND_FREEZER_TEST, + SUSPEND_FREEZER_TEST_SHOWALL, + SUSPEND_SINGLESTEP, + SUSPEND_PAUSE_NEAR_PAGESET_END, + SUSPEND_USE_ACPI_S4, + SUSPEND_KEEP_METADATA, + SUSPEND_TEST_FILTER_SPEED, + SUSPEND_FREEZE_TIMERS, + SUSPEND_DISABLE_SYSDEV_SUPPORT, + SUSPEND_VGA_POST +}; + +#define test_action_state(bit) (test_bit(bit, &suspend_action)) +#define set_action_state(bit) (test_and_set_bit(bit, &suspend_action)) +#define clear_action_state(bit) (test_and_clear_bit(bit, &suspend_action)) + +extern int suspend_act_used; +extern int suspend_lvl_used; +extern int suspend_dbg_used; +extern int suspend_default_console_level; +extern unsigned int nr_suspends; diff -ruNp 800-suspend2.patch-old/kernel/power/suspend2.h 800-suspend2.patch-new/kernel/power/suspend2.h --- 800-suspend2.patch-old/kernel/power/suspend2.h 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/suspend2.h 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,24 @@ +/* + * kernel/power/suspend2.h + * + * Copyright (C) 2004-2005 Nigel Cunningham + * + * This file is released under the GPLv2. + * + * It contains declarations used throughout swsusp and suspend2. + * + */ +#ifndef KERNEL_POWER_SUSPEND_CORE_H +#define KERNEL_POWER_SUSPEND_CORE_H + +#include +#include + +extern unsigned long suspend2_orig_mem_free; + +#define KB(x) ((x) << (PAGE_SHIFT - 10)) +#define MB(x) ((x) >> (20 - PAGE_SHIFT)) + +extern int suspend_start_anything(int starting_cycle); +extern void suspend_finish_anything(int finishing_cycle); +#endif diff -ruNp 800-suspend2.patch-old/kernel/power/suspend_block_io.c 800-suspend2.patch-new/kernel/power/suspend_block_io.c --- 800-suspend2.patch-old/kernel/power/suspend_block_io.c 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/suspend_block_io.c 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,817 @@ +/* + * block_io.c + * + * Copyright 2004-2005 Nigel Cunningham + * + * Distributed under GPLv2. + * + * This file contains block io functions for suspend2. These are + * used by the swapwriter and it is planned that they will also + * be used by the NFSwriter. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "suspend2.h" +#include "proc.h" +#include "plugins.h" +#include "prepare_image.h" +#include "block_io.h" + +/* Bits in struct io_info->flags */ +enum { + IO_WRITING, + IO_RESTORE_PAGE_PROT, + IO_AWAITING_READ, + IO_AWAITING_WRITE, + IO_AWAITING_SUBMIT, + IO_AWAITING_CLEANUP, + IO_HANDLE_PAGE_PROT +}; + +#define MAX_OUTSTANDING_IO 1024 + +/* + * + * IO in progress information storage and helpers + * + */ + +struct io_info { + struct bio * sys_struct; + sector_t block[MAX_BUF_PER_PAGE]; + struct page * buffer_page; + struct page * data_page; + unsigned long flags; + struct block_device * dev; + struct list_head list; + int readahead_index; + struct work_struct work; +}; + +/* Locks separated to allow better SMP support. + * An io_struct moves through the lists as follows. + * free -> submit_batch -> busy -> ready_for_cleanup -> free + */ +static LIST_HEAD(ioinfo_free); +static DEFINE_SPINLOCK(ioinfo_free_lock); + +static LIST_HEAD(ioinfo_ready_for_cleanup); +static DEFINE_SPINLOCK(ioinfo_ready_lock); + +static LIST_HEAD(ioinfo_submit_batch); +static DEFINE_SPINLOCK(ioinfo_submit_lock); + +static LIST_HEAD(ioinfo_busy); +static DEFINE_SPINLOCK(ioinfo_busy_lock); + +static atomic_t submit_batch; +static int submit_batch_size = 64; +static int submit_batched(void); + +struct task_struct * suspend_bio_task; + +/* [Max] number of I/O operations pending */ +static atomic_t outstanding_io; +static int max_outstanding_io = 0; +static atomic_t buffer_allocs, buffer_frees; + +/* [Max] number of pages used for above struct */ +static int infopages = 0; +static int maxinfopages = 0; + +static volatile unsigned long suspend_readahead_flags[(MAX_READAHEAD + BITS_PER_LONG - 1) / BITS_PER_LONG]; +static spinlock_t suspend_readahead_flags_lock = SPIN_LOCK_UNLOCKED; +static struct page * suspend_readahead_pages[MAX_READAHEAD]; + +static unsigned long nr_schedule_calls[8]; + +static char * sch_caller[] = { + "get_io_info_struct #1 ", + "get_io_info_struct #2 ", + "get_io_info_struct #3 ", + "suspend_finish_all_io ", + "wait_on_one_page ", + "submit ", + "start_one ", + "suspend_wait_on_readahead", +}; + +static int __suspend_io_cleanup(void * data); + +/* cleanup_some_completed_io + * + * NB: This is designed so that multiple callers can be in here simultaneously. + */ + +static void cleanup_some_completed_io(void) +{ + int num_cleaned = 0; + struct io_info * first; + unsigned long flags; + + spin_lock_irqsave(&ioinfo_ready_lock, flags); + while(!list_empty(&ioinfo_ready_for_cleanup)) { + int result; + first = list_entry(ioinfo_ready_for_cleanup.next, struct io_info, list); + + BUG_ON(!test_and_clear_bit(IO_AWAITING_CLEANUP, &first->flags)); + + list_del_init(&first->list); + + spin_unlock_irqrestore(&ioinfo_ready_lock, flags); + + result = __suspend_io_cleanup((void *) first); + + spin_lock_irqsave(&ioinfo_ready_lock, flags); + if (result) + continue; + num_cleaned++; + if (num_cleaned == submit_batch_size) + break; + } + spin_unlock_irqrestore(&ioinfo_ready_lock, flags); +} + +/* do_bio_wait + * + * Actions taken when we want some I/O to get run. + * + * Submit any I/O that's batched up, unplug queues, schedule + * and clean up whatever we can. + */ +static void do_bio_wait(int caller) +{ + int device; + int num_submitted = 0; + + nr_schedule_calls[caller]++; + + /* Don't want to wait on I/O we haven't submitted! */ + num_submitted = submit_batched(); + + for (device = 0; device < MAX_SWAPFILES; device++) { + struct block_device * bdev = swap_info[device].bdev; + /* Check for a potential oops here */ + if (bdev && bdev->bd_disk) { + request_queue_t * q = bdev_get_queue(bdev); + if (q && q->unplug_fn) + q->unplug_fn(q); + } + /* kblockd_flush(); io_schedule(); */ + } + + schedule(); + + cleanup_some_completed_io(); +} + +/* + * cleanup_one + * + * Description: Clean up after completing I/O on a page. + * Arguments: struct io_info: Data for I/O to be completed. + */ +static inline void cleanup_one(struct io_info * io_info) +{ + struct page * buffer_page; + struct page * data_page; + char *buffer_address, *data_address; + int reading; + + buffer_page = io_info->buffer_page; + data_page = io_info->data_page; + + reading = test_bit(IO_AWAITING_READ, &io_info->flags); + suspend_message(SUSPEND_WRITER, SUSPEND_HIGH, 0, + "Cleanup IO: [%p]\n", + io_info); + + if (reading && io_info->readahead_index == -1) { + /* + * Copy the page we read into the buffer our caller provided. + */ + data_address = (char *) kmap(data_page); + buffer_address = (char *) kmap(buffer_page); + memcpy(data_address, buffer_address, PAGE_SIZE); + flush_dcache_page(data_page); + kunmap(data_page); + kunmap(buffer_page); + + } + + if (!reading || io_info->readahead_index == -1) { + /* Sanity check */ + if (page_count(buffer_page) != 2) + printk(KERN_EMERG "Cleanup IO: Page count on page %p is %d. Not good!\n", + buffer_page, page_count(buffer_page)); + put_page(buffer_page); + __free_page(buffer_page); + atomic_inc(&buffer_frees); + } else + put_page(buffer_page); + + bio_put(io_info->sys_struct); + io_info->sys_struct = NULL; + io_info->flags = 0; +} + +/* + * get_io_info_struct + * + * Description: Get an I/O struct. + * Returns: Pointer to the struct prepared for use. + */ +static struct io_info * get_io_info_struct(void) +{ + unsigned long newpage = 0, flags; + struct io_info * this = NULL; + int remaining = 0; + + do { + while (atomic_read(&outstanding_io) >= MAX_OUTSTANDING_IO) + do_bio_wait(0); + + /* Can start a new I/O. Is there a free one? */ + if (!list_empty(&ioinfo_free)) { + /* Yes. Grab it. */ + spin_lock_irqsave(&ioinfo_free_lock, flags); + break; + } + + /* No. Need to allocate a new page for I/O info structs. */ + newpage = get_zeroed_page(GFP_ATOMIC); + if (!newpage) { + do_bio_wait(1); + continue; + } + + suspend_message(SUSPEND_MEMORY, SUSPEND_VERBOSE, 0, + "[NewIOPage %lx]", newpage); + infopages++; + if (infopages > maxinfopages) + maxinfopages++; + + /* Prepare the new page for use. */ + this = (struct io_info *) newpage; + remaining = PAGE_SIZE; + spin_lock_irqsave(&ioinfo_free_lock, flags); + while (remaining >= (sizeof(struct io_info))) { + list_add_tail(&this->list, &ioinfo_free); + this = (struct io_info *) (((char *) this) + + sizeof(struct io_info)); + remaining -= sizeof(struct io_info); + } + break; + } while (1); + + /* + * We have an I/O info struct. Remove it from the free list. + * It will be added to the submit or busy list later. + */ + this = list_entry(ioinfo_free.next, struct io_info, list); + list_del_init(&this->list); + spin_unlock_irqrestore(&ioinfo_free_lock, flags); + return this; +} + +/* + * suspend_finish_all_io + * + * Description: Finishes all IO and frees all IO info struct pages. + */ +static void suspend_finish_all_io(void) +{ + struct io_info * this, * next = NULL; + unsigned long flags; + + /* Wait for all I/O to complete. */ + while (atomic_read(&outstanding_io)) + do_bio_wait(2); + + spin_lock_irqsave(&ioinfo_free_lock, flags); + + /* + * Two stages, to avoid using freed pages. + * + * First free all io_info structs on a page except the first. + */ + list_for_each_entry_safe(this, next, &ioinfo_free, list) { + if (((unsigned long) this) & ~PAGE_MASK) + list_del(&this->list); + } + + /* + * Now we have only one reference to each page, and can safely + * free pages, knowing we're not going to be trying to access the + * same page after freeing it. + */ + list_for_each_entry_safe(this, next, &ioinfo_free, list) { + list_del(&this->list); + free_page((unsigned long) this); + infopages--; + suspend_message(SUSPEND_MEMORY, SUSPEND_VERBOSE, 0, + "[FreedIOPage %lx]", this); + } + + spin_unlock_irqrestore(&ioinfo_free_lock, flags); +} + +/* + * wait_on_one_page + * + * Description: Wait for a particular I/O to complete. + */ +static void wait_on_one_page(struct io_info * io_info) +{ + do { do_bio_wait(3); } while (io_info->flags); +} + +/* + * suspend_reset_io_stats + * + * Description: Reset all our sanity-checking statistics. + */ +static void suspend_reset_io_stats(void) +{ + int i; + + max_outstanding_io = 0; + maxinfopages = 0; + + for (i = 0; i < 8; i++) + nr_schedule_calls[i] = 0; +} + +/* + * suspend_check_io_stats + * + * Description: Check that our statistics look right and print + * any debugging info wanted. + */ +static void suspend_check_io_stats(void) +{ + int i; + + BUG_ON(atomic_read(&outstanding_io)); + BUG_ON(infopages); + BUG_ON(!list_empty(&ioinfo_submit_batch)); + BUG_ON(!list_empty(&ioinfo_busy)); + BUG_ON(!list_empty(&ioinfo_ready_for_cleanup)); + BUG_ON(!list_empty(&ioinfo_free)); + BUG_ON(atomic_read(&buffer_allocs) != atomic_read(&buffer_frees)); + + if (atomic_read(&outstanding_io)) + suspend_message(SUSPEND_WRITER, SUSPEND_MEDIUM, 0, + "Outstanding_io after writing is %d.\n", + atomic_read(&outstanding_io)); + suspend_message(SUSPEND_WRITER, SUSPEND_LOW, 0, + "Maximum outstanding_io was %d.\n", + max_outstanding_io); + if (infopages) + suspend_message(SUSPEND_WRITER, SUSPEND_MEDIUM, 0, + "Info pages is %d.\n", + infopages); + suspend_message(SUSPEND_WRITER, SUSPEND_LOW, 0, + "Max info pages was %d.\n", + maxinfopages); + if (atomic_read(&buffer_allocs) != atomic_read(&buffer_frees)) + suspend_message(SUSPEND_WRITER, SUSPEND_MEDIUM, 0, + "Buffer allocs (%d) != buffer frees (%d)", + atomic_read(&buffer_allocs), + atomic_read(&buffer_frees)); + for(i = 0; i < 8; i++) + suspend_message(SUSPEND_WRITER, SUSPEND_MEDIUM, 0, + "Nr schedule calls %s: %lu.\n", sch_caller[i], nr_schedule_calls[i]); +} + +/* __suspend_io_cleanup + */ + +static int __suspend_io_cleanup(void * data) +{ + struct io_info * io_info = (struct io_info *) data; + int readahead_index; + unsigned long flags; + + /* + * If this I/O was a readahead, remember its index. + */ + readahead_index = io_info->readahead_index; + + /* + * Add it to the free list. + */ + list_del_init(&io_info->list); + + /* + * Do the cleanup. + */ + cleanup_one(io_info); + + /* + * Record the readahead as done. + */ + if (readahead_index > -1) { + int index = readahead_index/BITS_PER_LONG; + int bit = readahead_index - (index * BITS_PER_LONG); + spin_lock_irqsave(&suspend_readahead_flags_lock, flags); + set_bit(bit, &suspend_readahead_flags[index]); + spin_unlock_irqrestore(&suspend_readahead_flags_lock, flags); + } + + spin_lock_irqsave(&ioinfo_free_lock, flags); + list_add_tail(&io_info->list, &ioinfo_free); + spin_unlock_irqrestore(&ioinfo_free_lock, flags); + + /* Important: Must be last thing we do to avoid a race with + * finish_all_io when using keventd to do the cleanup */ + atomic_dec(&outstanding_io); + + return 0; +} + +/* + * suspend_end_bio + * + * Description: Function called by block driver from interrupt context when I/O + * is completed. This is the reason we use spinlocks in + * manipulating the io_info lists. + * Nearly the fs/buffer.c version, but we want to mark the page as + * done in our own structures too. + */ + +static int suspend_end_bio(struct bio * bio, unsigned int num, int err) +{ + struct io_info *io_info = bio->bi_private; + unsigned long flags; + + spin_lock_irqsave(&ioinfo_busy_lock, flags); + list_del_init(&io_info->list); + spin_unlock_irqrestore(&ioinfo_busy_lock, flags); + + set_bit(IO_AWAITING_CLEANUP, &io_info->flags); + + spin_lock_irqsave(&ioinfo_ready_lock, flags); + list_add_tail(&io_info->list, &ioinfo_ready_for_cleanup); + spin_unlock_irqrestore(&ioinfo_ready_lock, flags); + return 0; +} + +/** + * submit - submit BIO request. + * @rw: READ or WRITE. + * @io_info: IO info structure. + * + * Based on Patrick's pmdisk code from long ago: + * "Straight from the textbook - allocate and initialize the bio. + * If we're writing, make sure the page is marked as dirty. + * Then submit it and carry on." + * + * With a twist, though - we handle block_size != PAGE_SIZE. + * Caller has already checked that our page is not fragmented. + */ + +static int submit(int rw, struct io_info * io_info) +{ + int error = 0; + struct bio * bio = NULL; + unsigned long flags; + + while (!bio) { + bio = bio_alloc(GFP_ATOMIC,1); + if (!bio) + do_bio_wait(4); + } + + bio->bi_bdev = io_info->dev; + bio->bi_sector = io_info->block[0] * (io_info->dev->bd_block_size >> 9); + bio->bi_private = io_info; + bio->bi_end_io = suspend_end_bio; + io_info->sys_struct = bio; + + if (bio_add_page(bio, io_info->buffer_page, PAGE_SIZE, 0) < PAGE_SIZE) { + printk("ERROR: adding page to bio at %ld\n", + io_info->block[0]); + bio_put(bio); + return -EFAULT; + } + + if (rw == WRITE) + bio_set_pages_dirty(bio); + + spin_lock_irqsave(&ioinfo_busy_lock, flags); + list_add_tail(&io_info->list, &ioinfo_busy); + spin_unlock_irqrestore(&ioinfo_busy_lock, flags); + + submit_bio(rw,bio); + + return error; +} + +/* + * suspend_set_block_size + * + * Description: Set the blocksize for a bdev. This is a separate function + * because we have different versions for 2.4 and 2.6. + */ +static int suspend_set_block_size(struct block_device * bdev, int size) +{ + return set_blocksize(bdev, size); +} + +static int suspend_get_block_size(struct block_device * bdev) +{ + return block_size(bdev); +} + +/* + * submit a batch + */ +static int submit_batched(void) +{ + struct io_info * first; + unsigned long flags; + int num_submitted = 0; + + spin_lock_irqsave(&ioinfo_submit_lock, flags); + while(!list_empty(&ioinfo_submit_batch)) { + first = list_entry(ioinfo_submit_batch.next, struct io_info, list); + + BUG_ON(!test_and_clear_bit(IO_AWAITING_SUBMIT, &first->flags)); + + list_del_init(&first->list); + + atomic_dec(&submit_batch); + + spin_unlock_irqrestore(&ioinfo_submit_lock, flags); + + if (test_bit(IO_AWAITING_READ, &first->flags)) + submit(READ, first); + else + submit(WRITE, first); + + spin_lock_irqsave(&ioinfo_submit_lock, flags); + + num_submitted++; + if (num_submitted == submit_batch_size) + break; + } + spin_unlock_irqrestore(&ioinfo_submit_lock, flags); + + return num_submitted; +} +static void add_to_batch(struct io_info * io_info) +{ + unsigned long flags; + + set_bit(IO_AWAITING_SUBMIT, &io_info->flags); + + /* Put our prepared I/O struct on the batch list. */ + spin_lock_irqsave(&ioinfo_submit_lock, flags); + list_add_tail(&io_info->list, &ioinfo_submit_batch); + spin_unlock_irqrestore(&ioinfo_submit_lock, flags); + + atomic_inc(&submit_batch); + + if ((!suspend_bio_task) && (atomic_read(&submit_batch) >= submit_batch_size)) + submit_batched(); +} +/* + * start_one + * + * Description: Prepare and start a read or write operation. + * Note that we use our own buffer for reading or writing. + * This simplifies doing readahead and asynchronous writing. + * We can begin a read without knowing the location into which + * the data will eventually be placed, and the buffer passed + * for a write can be reused immediately (essential for the + * plugins system). + * Failure? What's that? + * Returns: The io_info struct created. + */ +static struct io_info * start_one(int rw, struct submit_params * submit_info) +{ + struct io_info * io_info = get_io_info_struct(); + unsigned long buffer_virt = 0; + char * to, * from; + struct page * buffer_page; + + if (!io_info) + return NULL; + + /* Get our local buffer */ + suspend_message(SUSPEND_WRITER, SUSPEND_HIGH, 1, + "Start_IO: [%p]", io_info); + + /* Copy settings to the io_info struct */ + io_info->data_page = submit_info->page; + io_info->readahead_index = submit_info->readahead_index; + + if (io_info->readahead_index == -1) { + while (!(buffer_virt = get_zeroed_page(GFP_ATOMIC))) + do_bio_wait(5); + + atomic_inc(&buffer_allocs); + suspend_message(SUSPEND_WRITER, SUSPEND_HIGH, 0, + "[ALLOC BUFFER]->%d", + real_nr_free_pages()); + buffer_page = virt_to_page(buffer_virt); + + io_info->buffer_page = buffer_page; + } else { + unsigned long flags; + int index = io_info->readahead_index / BITS_PER_LONG; + int bit = io_info->readahead_index - index * BITS_PER_LONG; + + spin_lock_irqsave(&suspend_readahead_flags_lock, flags); + clear_bit(bit, &suspend_readahead_flags[index]); + spin_unlock_irqrestore(&suspend_readahead_flags_lock, flags); + + io_info->buffer_page = buffer_page = submit_info->page; + } + + /* If writing, copy our data. The data is probably in + * lowmem, but we cannot be certain. If there is no + * compression/encryption, we might be passed the + * actual source page's address. */ + if (rw == WRITE) { + set_bit(IO_WRITING, &io_info->flags); + + to = (char *) buffer_virt; + from = kmap_atomic(io_info->data_page, KM_USER1); + memcpy(to, from, PAGE_SIZE); + flush_dcache_page(io_info->data_page); + flush_dcache_page(buffer_page); + kunmap_atomic(from, KM_USER1); + } + + /* Submit the page */ + get_page(buffer_page); + + io_info->dev = submit_info->dev; + io_info->block[0] = submit_info->block[0]; + + if (rw == READ) + set_bit(IO_AWAITING_READ, &io_info->flags); + else + set_bit(IO_AWAITING_WRITE, &io_info->flags); + + suspend_message(SUSPEND_WRITER, SUSPEND_HIGH, 1, + "-> (PRE BRW) %d\n", + real_nr_free_pages()); + + if (submit_batch_size > 1) + add_to_batch(io_info); + else + submit(rw, io_info); + + atomic_inc(&outstanding_io); + if (atomic_read(&outstanding_io) > max_outstanding_io) + max_outstanding_io++; + + return io_info; +} + +static int suspend_do_io(int rw, + struct submit_params * submit_info, int syncio) +{ + struct io_info * io_info = start_one(rw, submit_info); + if (!io_info) + return 1; + else if (syncio) + wait_on_one_page(io_info); + + /* If we were the only one, clean everything up */ + if (!atomic_read(&outstanding_io)) + suspend_finish_all_io(); + return 0; +} + +/* We used to use bread here, but it doesn't correctly handle + * blocksize != PAGE_SIZE. Now we create a submit_info to get the data we + * want and use our normal routines (synchronously). + */ + +static int suspend_bdev_page_io(int rw, struct block_device * bdev, long pos, + struct page * page) +{ + struct submit_params submit_info; + + submit_info.page = page; + submit_info.dev = bdev; + submit_info.block[0] = pos; + submit_info.readahead_index = -1; + return suspend_do_io(rw, &submit_info, 1); +} + +/* + * wait_on_readahead + * + * Wait until a particular readahead is ready. + */ +static void suspend_wait_on_readahead(int readahead_index) +{ + int index = readahead_index / BITS_PER_LONG; + int bit = readahead_index - index * BITS_PER_LONG; + + /* read_ahead_index is the one we want to return */ + while (!test_bit(bit, &suspend_readahead_flags[index])) + do_bio_wait(6); +} + +/* + * readahead_done + * + * Returns whether the readahead requested is ready. + */ + +static int suspend_readahead_ready(int readahead_index) +{ + int index = readahead_index / BITS_PER_LONG; + int bit = readahead_index - (index * BITS_PER_LONG); + + return test_bit(bit, &suspend_readahead_flags[index]); +} + +/* suspend_readahead_prepare + * Set up for doing readahead on an image */ +static int suspend_prepare_readahead(int index) +{ + unsigned long new_page = get_zeroed_page(GFP_ATOMIC); + + if(!new_page) + return -ENOMEM; + + suspend_bio_ops.readahead_pages[index] = virt_to_page(new_page); + return 0; +} + +/* suspend_readahead_cleanup + * Clean up structures used for readahead */ +static void suspend_cleanup_readahead(int page) +{ + __free_page(suspend_bio_ops.readahead_pages[page]); + suspend_bio_ops.readahead_pages[page] = 0; + return; +} + +static unsigned long suspend_bio_memory_needed(void) +{ + /* We want to have at least enough memory so as to have + * MAX_OUTSTANDING_IO transactions on the fly at once. If we + * can to more, fine. */ + return (MAX_OUTSTANDING_IO * (PAGE_SIZE + sizeof(struct request) + + sizeof(struct bio) + sizeof(struct io_info))); +} + +struct suspend_bio_ops suspend_bio_ops = { + .set_block_size = suspend_set_block_size, + .get_block_size = suspend_get_block_size, + .submit_io = suspend_do_io, + .bdev_page_io = suspend_bdev_page_io, + .prepare_readahead = suspend_prepare_readahead, + .cleanup_readahead = suspend_cleanup_readahead, + .readahead_pages = suspend_readahead_pages, + .wait_on_readahead = suspend_wait_on_readahead, + .check_io_stats = suspend_check_io_stats, + .reset_io_stats = suspend_reset_io_stats, + .finish_all_io = suspend_finish_all_io, + .readahead_ready = suspend_readahead_ready, +}; + +static struct suspend_plugin_ops suspend_blockwriter_ops = +{ + .name = "Block I/O", + .type = MISC_PLUGIN, + .module = THIS_MODULE, + .memory_needed = suspend_bio_memory_needed, +}; + +static __init int suspend_block_io_load(void) +{ + return suspend_register_plugin(&suspend_blockwriter_ops); +} + +#ifdef MODULE +static __exit void suspend_block_io_unload(void) +{ + suspend_unregister_plugin(&suspend_blockwriter_ops); +} + +module_init(suspend_block_io_load); +module_exit(suspend_block_io_unload); +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Nigel Cunningham"); +MODULE_DESCRIPTION("Suspend2 block io functions"); +#else +late_initcall(suspend_block_io_load); +#endif diff -ruNp 800-suspend2.patch-old/kernel/power/suspend.c 800-suspend2.patch-new/kernel/power/suspend.c --- 800-suspend2.patch-old/kernel/power/suspend.c 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/suspend.c 2005-07-30 21:25:43.000000000 +1000 @@ -0,0 +1,1144 @@ +/* + * kernel/power/suspend2.c + */ +/** \mainpage Software Suspend 2. + * + * Suspend2 provides support for saving and restoring an image of + * system memory to an arbitrary storage device, either on the local computer, + * or across some network. The support is entirely OS based, so Suspend2 + * works without requiring BIOS, APM or ACPI support. The vast majority of the + * code is also architecture independant, so it should be very easy to port + * the code to new architectures. Suspend includes support for SMP, 4G HighMem + * and preemption. Initramfses and initrds are also supported. + * + * Suspend2 uses a modular design, in which the method of storing the image is + * completely abstracted from the core code, as are transformations on the data + * such as compression and/or encryption (multiple 'plugins' can be used to + * provide arbitrary combinations of functionality). The user interface is also + * modular, so that arbitrarily simple or complex interfaces can be used to + * provide anything from debugging information through to eye candy. + * + * \section Copyright + * + * Suspend2 is released under the GPLv2. + * + * Copyright (C) 1998-2001 Gabor Kuti
+ * Copyright (C) 1998,2001,2002 Pavel Machek
+ * Copyright (C) 2002-2003 Florent Chabaud
+ * Copyright (C) 2002-2005 Nigel Cunningham
+ * + * \section Credits + * + * Nigel would like to thank the following people for their work: + * + * Pavel Machek
+ * Modifications, defectiveness pointing, being with Gabor at the very beginning, + * suspend to swap space, stop all tasks. Port to 2.4.18-ac and 2.5.17. + * + * Steve Doddi
+ * Support the possibility of hardware state restoring. + * + * Raph
+ * Support for preserving states of network devices and virtual console + * (including X and svgatextmode) + * + * Kurt Garloff
+ * Straightened the critical function in order to prevent compilers from + * playing tricks with local variables. + * + * Andreas Mohr + * + * Alex Badea
+ * Fixed runaway init + * + * Jeff Snyder
+ * ACPI patch + * + * Nathan Friess
+ * Some patches. + * + * Michael Frank
+ * Extensive testing and help with improving stability. Nigel was constantly + * amazed by the quality and quantity of Michael's help. + * + * Bernard Blackham
+ * Web page & Wiki administration, some coding. Another person without whom + * Suspend would not be where it is. + * + * ..and of course the myriads of Suspend2 users who have helped diagnose + * and fix bugs, made suggestions on how to improve the code, proofread + * documentation, and donated time and money. + * + * Thanks also to corporate sponsors: + * + * Cyclades.com. Nigel's employers from Dec 2004, who allow him to work on + * Suspend and PM related issues on company time. + * + * LinuxFund.org. Sponsored Nigel's work on Suspend for four months Oct 2003 + * to Jan 2004. + * + * LAC Linux. Donated P4 hardware that enabled development and ongoing + * maintenance of SMP and Highmem support. + * + * OSDL. Provided access to various hardware configurations, make occasional + * small donations to the project. + */ + +#define SUSPEND_MAIN_C + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "version.h" +#include "suspend2.h" +#include "driver_model.h" +#include "plugins.h" +#include "proc.h" +#include "pageflags.h" +#include "prepare_image.h" +#include "io.h" +#include "ui.h" +#include "suspend2_common.h" +#include "extent.h" +#include "power_off.h" +#include "atomic_copy.h" + +#ifdef CONFIG_X86 +#include /* for kernel_fpu_end */ +#endif + +/* Variables to be preserved over suspend */ +int pageset1_sizelow = 0, pageset2_sizelow = 0, image_size_limit = 0; +unsigned long suspend2_orig_mem_free = 0; + +static dyn_pageflags_t pageset1_check_map; +static dyn_pageflags_t pageset2_check_map; +static char * debug_info_buffer; +static char suspend_core_version[] = SUSPEND_CORE_VERSION; + +extern void do_suspend2_lowlevel(int resume); +extern __nosavedata char resume_commandline[COMMAND_LINE_SIZE]; + +/* + * --- Variables ----- + * + * The following are used by the arch specific low level routines + * and only needed if suspend2 is compiled in. Other variables, + * used by the freezer even if suspend2 is not compiled in, are + * found in process.c + */ + +/*! How long I/O took. */ +int suspend_io_time[2][2]; + +/* Compression ratio */ +__nosavedata unsigned long bytes_in = 0, bytes_out = 0; + +/*! Pageset metadata. */ +struct pagedir pagedir1 = { 0, 0}, pagedir2 = { 0, 0}; + +/* Suspend2 variables used by built-in routines. */ + +/*! The number of suspends we have started (some may have been cancelled) */ +unsigned int nr_suspends = 0; + +/*! The console log level we default to. */ +int suspend_default_console_level = 0; + +/* + * For resume2= kernel option. It's pointless to compile + * suspend2 without any writers, but compilation shouldn't + * fail if you do. + */ + +unsigned long software_suspend_state = ((1 << SUSPEND_DISABLED) | (1 << SUSPEND_BOOT_TIME) | + (1 << SUSPEND_RESUME_NOT_DONE) | (1 << SUSPEND_IGNORE_LOGLEVEL)); + +mm_segment_t oldfs; + +#ifdef CONFIG_SUSPEND2_DEFAULT_RESUME2 +char resume2_file[256] = CONFIG_SUSPEND2_DEFAULT_RESUME2; +#else +char resume2_file[256] +#endif + +static atomic_t actions_running; + +/* + * Basic clean-up routine. + */ +void suspend_finish_anything(int finishing_cycle) +{ + if (atomic_dec_and_test(&actions_running)) { + suspend2_cleanup_plugins(finishing_cycle); + suspend2_put_modules(); + clear_suspend_state(SUSPEND_RUNNING); + } + + set_fs(oldfs); +} + +/* + * Basic set-up routine. + */ +int suspend_start_anything(int starting_cycle) +{ + oldfs = get_fs(); + + if (atomic_add_return(1, &actions_running) == 1) { + set_fs(KERNEL_DS); + + set_suspend_state(SUSPEND_RUNNING); + + if (suspend2_get_modules()) { + printk("Get modules failed!\n"); + clear_suspend_state(SUSPEND_RUNNING); + set_fs(oldfs); + return -EBUSY; + } + + if (suspend2_initialise_plugins(starting_cycle)) { + printk("Initialise plugins failed!\n"); + suspend_finish_anything(starting_cycle); + return -EBUSY; + } + } + + return 0; +} + +/* + * save_image + * Result code (int): Zero on success, non zero on failure. + * Functionality : High level routine which performs the steps necessary + * to prepare and save the image after preparatory steps + * have been taken. + * Key Assumptions : Processes frozen, sufficient memory available, drivers + * suspended. + * Called from : suspend2_suspend_2 + */ + +static int save_image(void) +{ + int temp_result; + + if (ram_to_suspend() > max_mapnr) { + suspend2_prepare_status(CLEAR_BAR, + "Couldn't get enough free pages, on %ld pages short", + ram_to_suspend() - max_mapnr); + return -1; + } + + suspend_message(SUSPEND_ANY_SECTION, SUSPEND_LOW, 1, + " - Final values: %d and %d.\n", + pagedir1.pageset_size, + pagedir2.pageset_size); + + check_shift_keys(1, "About to write pagedir2."); + + temp_result = write_pageset(&pagedir2, 2); + + if (temp_result == -1 || test_result_state(SUSPEND_ABORTED)) + return -1; + + check_shift_keys(1, "About to copy pageset 1."); + + suspend2_prepare_status(DONT_CLEAR_BAR, "Doing atomic copy."); + + do_suspend2_lowlevel(0); + + return 0; +} + +/* + * Save the second part of the image. + */ +int save_image_part1(void) +{ + int temp_result, old_ps1_size = pagedir1.pageset_size; + dyn_pageflags_t temp; + + /* Quick switch: We want to compare the old stats with the new ones. */ + temp = pageset1_map; + pageset1_map = pageset1_check_map; + pageset1_check_map = temp; + + temp = pageset2_map; + pageset2_map = pageset2_check_map; + pageset2_check_map = temp; + + suspend2_recalculate_stats(); + + if ((pagedir1.pageset_size - old_ps1_size) > EXTRA_PD1_PAGES_ALLOWANCE) { + abort_suspend("Pageset1 has grown by %d pages." + " Only %d growth is allowed for!\n", + pagedir1.pageset_size - old_ps1_size, + EXTRA_PD1_PAGES_ALLOWANCE); + return -1; + } + + suspend2_map_atomic_copy_pages(); + + BUG_ON(!irqs_disabled()); + + if (!test_action_state(SUSPEND_TEST_FILTER_SPEED)) + suspend2_copy_pageset1(); + + /* + * ---- FROM HERE ON, NEED TO REREAD PAGESET2 IF ABORTING!!! ----- + * + */ + + suspend2_unmap_atomic_copy_pages(); + +#ifdef CONFIG_X86 + kernel_fpu_end(); +#endif + + preempt_enable_no_resched(); + + suspend_drivers_resume(SUSPEND_DRIVERS_IRQS_DISABLED); + + local_irq_enable(); + + suspend_drivers_resume(SUSPEND_DRIVERS_IRQS_ENABLED); + + suspend2_update_status(pagedir2.pageset_size, + pagedir1.pageset_size + pagedir2.pageset_size, + NULL); + + if (test_result_state(SUSPEND_ABORTED)) + goto abort_reloading_pagedir_two; + + check_shift_keys(1, "About to write pageset1."); + + /* + * End of critical section. + */ + + suspend_message(SUSPEND_ANY_SECTION, SUSPEND_LOW, 1, + "-- Writing pageset1\n"); + + temp_result = write_pageset(&pagedir1, 1); + + /* We didn't overwrite any memory, so no reread needs to be done. */ + if (test_action_state(SUSPEND_TEST_FILTER_SPEED)) + return -1; + + if (temp_result == -1 || test_result_state(SUSPEND_ABORTED)) + goto abort_reloading_pagedir_two; + + check_shift_keys(1, "About to write header."); + + if (test_result_state(SUSPEND_ABORTED)) + goto abort_reloading_pagedir_two; + + temp_result = write_image_header(); + + if (temp_result || (test_result_state(SUSPEND_ABORTED))) + goto abort_reloading_pagedir_two; + + check_shift_keys(1, "About to power down or reboot."); + + return 0; + +abort_reloading_pagedir_two: + temp_result = read_pageset2(1); + + /* If that failed, we're sunk. Panic! */ + if (temp_result) + panic("Attempt to reload pagedir 2 while aborting " + "a suspend failed."); + + return -1; + +} + +#define SNPRINTF(a...) len += snprintf_used(debug_info_buffer + len, \ + PAGE_SIZE - len - 1, ## a) + +static inline int io_MB_per_second(int read_write) +{ + if (!suspend_io_time[read_write][1]) + return 0; + + return MB((unsigned long) suspend_io_time[read_write][0]) * HZ / + suspend_io_time[read_write][1]; +} + +/* get_debug_info + * Functionality: Store debug info in a buffer. + * Called from: suspend_try_suspend. + */ + + +static int get_suspend_debug_info(void) +{ + int len = 0; + if (!debug_info_buffer) { + debug_info_buffer = (char *) get_zeroed_page(GFP_ATOMIC); + if (!debug_info_buffer) { + printk("Error! Unable to allocate buffer for" + "software suspend debug info.\n"); + return 0; + } + } + + SNPRINTF("Please include the following information in bug reports:\n"); + SNPRINTF("- SUSPEND core : %s\n", SUSPEND_CORE_VERSION); + SNPRINTF("- Kernel Version : %s\n", UTS_RELEASE); + SNPRINTF("- Compiler vers. : %d.%d\n", __GNUC__, __GNUC_MINOR__); + SNPRINTF("- Attempt number : %d\n", nr_suspends); + SNPRINTF("- Pageset sizes : %d (%d low) and %d (%d low).\n", + pagedir1.lastpageset_size, + pageset1_sizelow, + pagedir2.lastpageset_size, + pageset2_sizelow); + SNPRINTF("- Parameters : %ld %ld %ld %d %d %ld\n", + suspend_result, + suspend_action, + suspend_debug_state, + suspend_default_console_level, + image_size_limit, + suspend2_powerdown_method); + SNPRINTF("- Calculations : Image size: %lu. " + "Ram to suspend: %ld.\n", + storage_needed(1), ram_to_suspend()); + SNPRINTF("- Limits : %lu pages RAM. Initial boot: %lu.\n", + max_mapnr, suspend2_orig_mem_free); + SNPRINTF("- Overall expected compression percentage: %d.\n", + 100 - suspend2_expected_compression_ratio()); + len+= print_plugin_debug_info(debug_info_buffer + len, + PAGE_SIZE - len - 1); +#ifdef CONFIG_PM_DEBUG + SNPRINTF("- Debugging compiled in.\n"); +#endif +#ifdef CONFIG_PREEMPT + SNPRINTF("- Preemptive kernel.\n"); +#endif +#ifdef CONFIG_SMP + SNPRINTF("- SMP kernel.\n"); +#endif +#ifdef CONFIG_HIGHMEM + SNPRINTF("- Highmem Support.\n"); +#endif + SNPRINTF("- Max extents used: %d\n", + max_extents_used); + if (suspend_io_time[0][1]) { + if ((io_MB_per_second(0) < 5) || (io_MB_per_second(1) < 5)) { + SNPRINTF("- I/O speed: Write %d KB/s", + (KB((unsigned long) suspend_io_time[0][0]) * HZ / + suspend_io_time[0][1])); + if (suspend_io_time[1][1]) + SNPRINTF(", Read %d KB/s", + (KB((unsigned long) suspend_io_time[1][0]) * HZ / + suspend_io_time[1][1])); + } else { + SNPRINTF("- I/O speed: Write %d MB/s", + (MB((unsigned long) suspend_io_time[0][0]) * HZ / + suspend_io_time[0][1])); + if (suspend_io_time[1][1]) + SNPRINTF(", Read %d MB/s", + (MB((unsigned long) suspend_io_time[1][0]) * HZ / + suspend_io_time[1][1])); + } + SNPRINTF(".\n"); + } + else + SNPRINTF("- No I/O speed stats available.\n"); + + return len; +} + +/* + * debuginfo_read_proc + * Functionality : Displays information that may be helpful in debugging + * software suspend. + */ +int debuginfo_read_proc(char * page, char ** start, off_t off, int count, + int *eof, void *data) +{ + int info_len, copy_len; + + info_len = get_suspend_debug_info(); + + copy_len = min(info_len - (int) off, count); + if (copy_len < 0) + copy_len = 0; + + if (copy_len) { + memcpy(page, debug_info_buffer + off, copy_len); + *start = page; + } + + if (copy_len + off == info_len) + *eof = 1; + + free_page((unsigned long) debug_info_buffer); + debug_info_buffer = NULL; + return copy_len; +} + +static int allocate_bitmaps(void) +{ + suspend_message(SUSPEND_MEMORY, SUSPEND_VERBOSE, 1, + "Allocating in_use_map\n"); + if (suspend_allocate_dyn_pageflags(&in_use_map)) + return 1; + + if (suspend_allocate_dyn_pageflags(&pageset1_map)) + return 1; + + if (suspend_allocate_dyn_pageflags(&pageset1_copy_map)) + return 1; + + if (suspend_allocate_dyn_pageflags(&allocd_pages_map)) + return 1; + + if (suspend_allocate_dyn_pageflags(&pageset2_map)) + return 1; + +#ifdef CONFIG_DEBUG_PAGEALLOC + if (suspend_allocate_dyn_pageflags(&unmap_map)) + return 1; + +#endif + + if (suspend_allocate_dyn_pageflags(&pageset1_check_map)) + return 1; + + if (suspend_allocate_dyn_pageflags(&pageset2_check_map)) + return 1; + + return 0; +} + +static void free_metadata(void) +{ + free_dyn_pageflags(&pageset1_map); + + free_dyn_pageflags(&pageset1_copy_map); + + free_dyn_pageflags(&allocd_pages_map); + + free_dyn_pageflags(&pageset2_map); + + free_dyn_pageflags(&in_use_map); + + free_dyn_pageflags(&pageset1_check_map); + free_dyn_pageflags(&pageset2_check_map); +} + +static inline int check_still_keeping_image(void) +{ + if (test_action_state(SUSPEND_KEEP_IMAGE)) { + printk("Image already stored: powering down immediately."); + suspend_power_down(); + return 1; /* Just in case we're using S3 */ + } + + printk("Invalidating previous image.\n"); + active_writer->ops.writer.invalidate_image(); + + return 0; +} + +static inline int suspend2_init(void) +{ + suspend_result = 0; + + printk(name_suspend "Initiating a software suspend cycle.\n"); + + max_extents_used = 0; + nr_suspends++; + clear_suspend_state(SUSPEND_NOW_RESUMING); + + suspend_io_time[0][0] = suspend_io_time[0][1] = + suspend_io_time[1][0] = + suspend_io_time[1][1] = 0; + + suspend2_prepare_console(); + + free_metadata(); /* We might have kept it */ + + attempt_to_parse_resume_device(); + + if (test_suspend_state(SUSPEND_DISABLED)) + return 0; + + if (suspend_drivers_init()) + return 0; + + if (allocate_bitmaps()) + return 0; + + disable_nonboot_cpus(); + + return 1; +} + +void inline suspend2_cleanup(void) +{ + int i; + + i = get_suspend_debug_info(); + + suspend2_free_pagedir_data(); + + thaw_processes(FREEZER_KERNEL_THREADS); + +#ifdef CONFIG_SUSPEND2_KEEP_IMAGE + if (test_action_state(SUSPEND_KEEP_IMAGE) && + !test_result_state(SUSPEND_ABORTED)) { + suspend_message(SUSPEND_ANY_SECTION, SUSPEND_LOW, 1, + name_suspend "Not invalidating the image due " + "to Keep Image being enabled.\n"); + set_result_state(SUSPEND_KEPT_IMAGE); + } else +#endif + if (active_writer) + active_writer->ops.writer.invalidate_image(); + + if (!test_action_state(SUSPEND_KEEP_METADATA)) + free_metadata(); + +#ifdef CONFIG_DEBUG_PAGE_ALLOC + free_dyn_pageflags(&unmap_map); +#endif + + if (debug_info_buffer) { + /* Printk can only handle 1023 bytes, including + * its level mangling. */ + for (i = 0; i < 3; i++) + printk("%s", debug_info_buffer + (1023 * i)); + free_page((unsigned long) debug_info_buffer); + debug_info_buffer = NULL; + } + + suspend_drivers_cleanup(); + + thaw_processes(FREEZER_ALL_THREADS); + + suspend2_cleanup_console(); + + enable_nonboot_cpus(); +} + +/* + * suspend2_main + * Functionality : First level of code for software suspend invocations. + * Stores and restores load averages (to avoid a spike), + * allocates bitmaps, freezes processes and eats memory + * as required before suspending drivers and invoking + * the 'low level' code to save the state to disk. + * By the time we return from do_suspend2_lowlevel, we + * have either failed to save the image or successfully + * suspended and reloaded the image. The difference can + * be discerned by checking SUSPEND_ABORTED. + * Called From : + */ + +void suspend2_main(void) +{ + /* + * If kept image and still keeping image and suspending to RAM, we will + * return 1 after suspending and resuming (provided the power doesn't + * run out. + */ + if (test_result_state(SUSPEND_KEPT_IMAGE) && check_still_keeping_image()) + return; + + if (suspend2_init() && suspend2_prepare_image() && !test_result_state(SUSPEND_ABORTED) && + !test_action_state(SUSPEND_FREEZER_TEST)) + { + if (!test_result_state(SUSPEND_ABORTED)) { + suspend2_prepare_status(DONT_CLEAR_BAR, "Starting to save the image.."); + save_image(); + } + } + + suspend2_cleanup(); +} + +/* image_exists_read + * + * Return 0 or 1, depending on whether an image is found. + */ +static int image_exists_read(char * page, char ** start, off_t off, int count, + int *eof, void *data) +{ + int len = 0; + + attempt_to_parse_resume_device(); + + if (!active_writer) + len = sprintf(page, "-1\n"); + else + len = sprintf(page, "%d\n", active_writer->ops.writer.image_exists()); + + *eof = 1; + return len; +} + +/* image_exists_read + * + * Return 0 or 1, depending on whether an image is found. + */ +static int image_exists_write(struct file *file, const char * buffer, + unsigned long count, void * data) +{ + if (active_writer && active_writer->ops.writer.image_exists()) + active_writer->ops.writer.invalidate_image(); + + return count; +} + +/* + * Core proc entries that aren't built in. + * + * This array contains entries that are automatically registered at + * boot. Plugins and the console code register their own entries separately. + */ +extern int toggle_pid; +void toggle_thread_nofreeze(void); + +static struct suspend_proc_data proc_params[] = { + { .filename = "debug_info", + .permissions = PROC_READONLY, + .type = SUSPEND_PROC_DATA_CUSTOM, + .data = { + .special = { + .read_proc = debuginfo_read_proc, + } + } + }, + + { .filename = "image_exists", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_CUSTOM, + .data = { + .special = { + .read_proc = image_exists_read, + .write_proc = image_exists_write, + } + } + }, + + { .filename = "image_size_limit", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_INTEGER, + .data = { + .integer = { + .variable = &image_size_limit, + .minimum = -2, + .maximum = 32767, + } + } + }, + + { .filename = "last_result", + .permissions = PROC_READONLY, + .type = SUSPEND_PROC_DATA_UL, + .data = { + .ul = { + .variable = &suspend_result, + } + } + }, + + { .filename = "reboot", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_BIT, + .data = { + .bit = { + .bit_vector = &suspend_action, + .bit = SUSPEND_REBOOT, + } + } + }, + + { .filename = "resume2", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_STRING, + .data = { + .string = { + .variable = resume2_file, + .max_length = 255, + } + }, + .write_proc = attempt_to_parse_resume_device, + }, + + { .filename = "resume_commandline", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_STRING, + .data = { + .string = { + .variable = resume_commandline, + .max_length = COMMAND_LINE_SIZE, + } + }, + }, + + + { .filename = "toggle_process_nofreeze", + .permissions = PROC_WRITEONLY, + .type = SUSPEND_PROC_DATA_INTEGER, + .data = { + .integer = { + .variable = &toggle_pid, + .minimum = 2, + .maximum = 32767, + } + }, + .write_proc = toggle_thread_nofreeze, + }, + + { .filename = "version", + .permissions = PROC_READONLY, + .type = SUSPEND_PROC_DATA_STRING, + .data = { + .string = { + .variable = suspend_core_version, + } + } + }, + +#ifdef CONFIG_PM_DEBUG + { .filename = "freezer_test", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_BIT, + .data = { + .bit = { + .bit_vector = &suspend_action, + .bit = SUSPEND_FREEZER_TEST, + } + } + }, + + { .filename = "keep_metadata", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_BIT, + .data = { + .bit = { + .bit_vector = &suspend_action, + .bit = SUSPEND_KEEP_METADATA, + } + } + }, + + { .filename = "test_filter_speed", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_BIT, + .data = { + .bit = { + .bit_vector = &suspend_action, + .bit = SUSPEND_TEST_FILTER_SPEED, + } + } + }, + + { .filename = "slow", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_BIT, + .data = { + .bit = { + .bit_vector = &suspend_action, + .bit = SUSPEND_SLOW, + } + } + }, + +#endif + +#if defined(CONFIG_ACPI) + { .filename = "powerdown_method", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_UL, + .data = { + .ul = { + .variable = &suspend2_powerdown_method, + .minimum = 3, + .maximum = 5, + } + } + }, +#endif + +#ifdef CONFIG_SUSPEND2_KEEP_IMAGE + { .filename = "keep_image", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_BIT, + .data = { + .bit = { + .bit_vector = &suspend_action, + .bit = SUSPEND_KEEP_IMAGE, + } + } + }, +#endif +}; + + +/* + * Called from init kernel_thread. + * We check if we have an image and if so we try to resume. + * We also start ksuspendd if configuration looks right. + */ + +int suspend2_resume(void) +{ + int read_image_result = 0; + + if (sizeof(swp_entry_t) != sizeof(long)) { + printk(KERN_WARNING name_suspend + "The size of swp_entry_t != size of long. " + "Please report this!\n"); + return 1; + } + + if (!resume2_file[0]) + printk(KERN_WARNING name_suspend + "You need to use a resume2= command line parameter to " + "tell Software Suspend 2 where to look for an image.\n"); + + if (!(test_suspend_state(SUSPEND_RESUME_DEVICE_OK))) + attempt_to_parse_resume_device(); + + if (!(test_suspend_state(SUSPEND_RESUME_DEVICE_OK))) { + /* + * Without a usable storage device we can do nothing - + * even if noresume is given + */ + + if (!num_writers) + printk(KERN_ALERT name_suspend + "No writers have been registered.\n"); + else + printk(KERN_ALERT name_suspend + "Missing or invalid storage location " + "(resume2= parameter). Please correct and " + "rerun lilo (or equivalent) before " + "suspending.\n"); + return 1; + } + + /* We enable the possibility of machine suspend */ + suspend2_orig_mem_free = real_nr_free_pages(); + + suspend_task = current->pid; + + read_image_result = read_pageset1(); /* non fatal error ignored */ + + if (test_suspend_state(SUSPEND_NORESUME_SPECIFIED)) + printk(KERN_WARNING name_suspend "Resuming disabled as requested.\n"); + + if (read_image_result) { + suspend_task = 0; + return 1; + } + + suspend_drivers_init(); + + suspend_atomic_restore(); + + BUG(); + + return 0; +} + +extern void request_abort_suspend(void); +extern void suspend2_schedule_message(int message_number); + +static __init int core_load(void) +{ + int i, numfiles = sizeof(proc_params) / sizeof(struct suspend_proc_data); + + printk("Software Suspend Core.\n"); + + suspend_initialise_plugin_lists(); + + for (i=0; i< numfiles; i++) + suspend_register_procfile(&proc_params[i]); + + return 0; +} + +/* -- Functions for kickstarting a suspend or resume --- */ + +static int can_suspend(void) +{ + /* + * Perhaps something has changed such that we can suspend or + * resume when we couldn't before. Check before complaining. + */ + + if (test_suspend_state(SUSPEND_DISABLED)) + attempt_to_parse_resume_device(); + + if (test_suspend_state(SUSPEND_DISABLED)) { + printk(name_suspend "Software suspend is disabled.\n" + "This may be because you haven't put something along the " + "lines of\n\nresume2=swap:/dev/hda1\n\n" + "in lilo.conf or equivalent. (Where /dev/hda1 is your " + "swap partition).\n"); + set_result_state(SUSPEND_ABORTED); + return 0; + } + + return 1; +} + +/* + * Check if we have an image and if so try to resume. + */ + +void __suspend2_try_resume(void) +{ + set_suspend_state(SUSPEND_TRYING_TO_RESUME); + + clear_suspend_state(SUSPEND_RESUME_NOT_DONE); + + suspend2_resume(); + + clear_suspend_state(SUSPEND_IGNORE_LOGLEVEL); + clear_suspend_state(SUSPEND_TRYING_TO_RESUME); +} + +/* Wrapper for when called from init/do_mounts.c */ +void suspend2_try_resume(void) +{ + if (suspend_start_anything(0)) + return; + + __suspend2_try_resume(); + + /* + * For initramfs, we have to clear the boot time + * flag after trying to resume + */ + clear_suspend_state(SUSPEND_BOOT_TIME); + + suspend_finish_anything(0); +} + +/* + * __suspend2_try_suspend + * Functionality : Performs the basic checking as to whether suspend is + * enabled before invoking the high level routine. + * Called From : proc.c, suspend2_try_suspend.c + */ +void __suspend2_try_suspend(void) +{ + if (can_suspend()) + suspend2_main(); +} + +/* + * suspend2_try_suspend + * Functionality : Wrapper around __suspend2_try_suspend. + * Called From : drivers/acpi/sleep/main.c + * kernel/reboot.c + */ + +void suspend2_try_suspend(void) +{ + if (suspend_start_anything(0)) + return; + + __suspend2_try_suspend(); + + suspend_finish_anything(0); +} + +/* -- Commandline Parameter Handling --- + * + * Resume setup: obtain the storage device. + */ + +static int __init resume_setup(char *str) +{ + if (str == NULL) + return 1; + + strncpy(resume2_file, str, 255); + return 0; +} + +/* + * Allow the user to set the action parameter from lilo, prior to resuming. + */ +static int __init suspend_act_setup(char *str) +{ + if(str) + suspend_action=simple_strtol(str,NULL,0); + set_suspend_state(SUSPEND_ACT_USED); + return 0; +} + +/* + * Allow the user to set the debug parameter from lilo, prior to resuming. + */ +/* + * Allow the user to specify that we should ignore any image found and + * invalidate the image if necesssary. This is equivalent to running + * the task queue and a sync and then turning off the power. The same + * precautions should be taken: fsck if you're not journalled. + */ +static int __init noresume_setup(char *str) +{ + set_suspend_state(SUSPEND_NORESUME_SPECIFIED); + /* Message printed later */ + return 0; +} + +static int __init suspend2_retry_resume_setup(char *str) +{ + set_suspend_state(SUSPEND_RETRY_RESUME); + return 0; +} + +__setup("resume2=", resume_setup); +__setup("suspend_act=", suspend_act_setup); + +#ifdef CONFIG_PM_DEBUG + +static int __init suspend_dbg_setup(char *str) +{ + if(str) + suspend_debug_state=simple_strtol(str,NULL,0); + set_suspend_state(SUSPEND_DBG_USED); + return 0; +} + +/* + * Allow the user to set the debug level parameter from lilo, prior to + * resuming. + */ +static int __init suspend_lvl_setup(char *str) +{ + if(str) + console_loglevel = + suspend_default_console_level = + simple_strtol(str,NULL,0); + set_suspend_state(SUSPEND_LVL_USED); + clear_suspend_state(SUSPEND_IGNORE_LOGLEVEL); + return 0; +} + +__setup("suspend_dbg=", suspend_dbg_setup); +__setup("suspend_lvl=", suspend_lvl_setup); +#endif + +__setup("noresume2", noresume_setup); +__setup("suspend_retry_resume", suspend2_retry_resume_setup); + +late_initcall(core_load); +EXPORT_SYMBOL(software_suspend_state); diff -ruNp 800-suspend2.patch-old/kernel/power/suspend_file.c 800-suspend2.patch-new/kernel/power/suspend_file.c --- 800-suspend2.patch-old/kernel/power/suspend_file.c 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/suspend_file.c 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,1613 @@ +/* + * Filewriter.c + * + * Copyright 2005 Nigel Cunningham + * + * Distributed under GPLv2. + * + * This file encapsulates functions for usage of a simple file as a + * backing store. It is based upon the swapwriter, and shares the + * same basic working. Here, though, we have nothing to do with + * swapspace, and only one device to worry about. + * + * The user can just + * + * echo Suspend2 > /path/to/my_file + * + * and + * + * echo /path/to/my_file > /proc/software_suspend/filewriter_target + * + * then put what they find in /proc/software_suspend/resume2 + * as their resume2= parameter in lilo.conf (and rerun lilo if using it). + * + * Having done this, they're ready to suspend and resume. + * + * TODO: + * - File resizing. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "suspend2.h" +#include "suspend2_common.h" +#include "version.h" +#include "proc.h" +#include "plugins.h" +#include "ui.h" +#include "extent.h" +#include "io.h" + +#include "block_io.h" + +/* + * General Declarations. + */ + +static struct suspend_proc_data filewriter_proc_data[]; +static struct suspend_plugin_ops filewriterops; + +/* + * External Declarations + */ + +extern asmlinkage long sys_open(const char __user * filename, int flags, int mode); +extern asmlinkage long sys_close(unsigned int fd); + +/* + * Forward Declarations + */ + +static int filewriter_invalidate_image(void); +static int filewriter_storage_available(void); + +/* + * Details of our target. + */ + +char filewriter_target[256]; +static struct inode * target_inode; +static int target_fd = -1; +static struct block_device * target_bdev; +static int used_devt = 0; +static dev_t target_dev_t = 0; +static sector_t target_firstblock = 0; +static int target_blocksize = PAGE_SIZE; +static int target_storage_available = 0; +static unsigned int target_blkbits; +#define target_blockshift (PAGE_SHIFT - target_blkbits) +#define target_blocksperpage (1 << target_blockshift) + +static int target_type = -1; + +/* +static char * description[7] = { + "Socket", + "Link", + "Regular file", + "Block device", + "Directory", + "Character device", + "Fifo", +}; +*/ + +static char HaveImage[] = "HaveImage\n"; +static char NoImage[] = "Suspend2\n"; +static const int resumed_before_byte = sizeof(HaveImage) + 1; +#define sig_size resumed_before_byte + +/* Header_pages must be big enough for signature */ +static int header_pages, main_pages; + +static unsigned long * header_link = NULL; +#define BYTES_PER_HEADER_PAGE (PAGE_SIZE - sizeof(sector_t)) + +#define target_is_normal_file() (S_ISREG(target_inode->i_mode)) + +/* + * Readahead Variables + */ + +// Higher Level +static int readahead_index = 0, readahead_submit_index = 0; +static int readahead_allocs = 0, readahead_frees = 0; + +static char * filewriter_buffer = NULL; +static int filewriter_buffer_posn = 0; +static int filewriter_page_index = 0; + +/* + * + * Internal Data Structures + * + */ + +/* header_data contains data that is needed to reload pagedir1, and + * is therefore saved in the suspend header. + * + * Pagedir2 data gets stored before pagedir1 (save order), and the first + * page for pagedir1 to use is set when pagedir2 is written (when we know how + * much storage it used). Since this first entry is almost certainly not at the + * start of a extent, the firstoffset variable below tells us where to start in + * the extent. All of this means we don't have to worry about getting different + * compression ratios for the kernel and cache (when compressing the image). + * We can simply allocate one pool of storage (size determined using expected + * compression ratio) and use it without worrying whether one pageset + * compresses better and the other worse (this is what happens). As long as the + * user gets the expected compression right, it will work. + */ + +static struct { + /* Location of start of pagedir 1 */ + struct extent * pd1start_block_extent; + int pd1start_extent_number; + unsigned long pd1start_block_offset; + +} filewriter_header_data; + +/* Extent chain for blocks */ +static struct extent_chain block_chain; + +/* + * + * Current state. + * + */ + +/* Which pagedir are we saving/reloading? Needed so we can know whether to + * remember the last block used at the end of writing pageset2, and + * get that location when saving or reloading pageset1.*/ +static int current_stream = 0; + +/* Pointer to current entry being loaded/saved. */ +static struct extent * currentblockextent = NULL; +static unsigned long currentblockoffset = 0; + +/* Header Page Information */ +static struct submit_params * first_header_submit_info = NULL, + * last_header_submit_info = NULL, * current_header_submit_info = NULL; + +/* + * Helpers. + */ + +/* + * Return the type of target we have, an index into the descriptions + * above. + */ +static int get_target_type(struct inode * inode) +{ + switch (inode->i_mode & S_IFMT) { + case S_IFSOCK: + target_type = 0; + break; + case S_IFLNK: + target_type = 1; + break; + case S_IFREG: + target_type = 2; + break; + case S_IFBLK: + target_type = 3; + break; + case S_IFDIR: + target_type = 4; + break; + case S_IFCHR: + target_type = 5; + break; + case S_IFIFO: + target_type = 6; + break; + } + return target_type; +} + +#define target_is_usable (!(target_type == 1 || target_type == 4)) +#define target_num_sectors (target_inode->i_size >> target_blkbits) + +static int size_ignoring_sparseness(void) +{ + int mappable = 0, i; + + if (target_is_normal_file()) { + int extent_min = -1, extent_max = -1; + + for (i = 0; i <= target_num_sectors; i++) { + sector_t new_sector = bmap(target_inode, i); + if (!new_sector) { + if (i == extent_max + 1) + extent_max++; + else + extent_min = extent_max = i; + } else + mappable++; + } + + return mappable >> (PAGE_SHIFT - target_blkbits); + } else + return filewriter_storage_available(); +} + +static void get_main_pool_phys_params(void) +{ + int i; + + if (block_chain.first) + put_extent_chain(&block_chain); + + if (target_is_normal_file()) { + int header_sectors = (header_pages << target_blockshift); + int extent_min = -1, extent_max = -1, real_sector = 0; + + + for (i = 0; i <= target_num_sectors; i++) { + sector_t new_sector = + bmap(target_inode, header_sectors + i); + + /* + * I'd love to be able to fill in holes and resize + * files, but not yet... + */ + + if (!new_sector) + continue; + + real_sector++; + + if (real_sector < header_sectors) + continue; + + if (new_sector == extent_max + 1) + extent_max++; + else { + if (extent_min > -1) + append_extent_to_extent_chain( + &block_chain, + extent_min, extent_max); + extent_min = extent_max = new_sector; + } + } + if (extent_min > -1) + append_extent_to_extent_chain(&block_chain, + extent_min, extent_max); + } else + if (target_storage_available > 0) { + unsigned long new_start = + last_header_submit_info ? + last_header_submit_info->block[target_blocksperpage -1] + + 1: 0; + + append_extent_to_extent_chain(&block_chain, + new_start, new_start + + (min(main_pages, target_storage_available) << + target_blockshift) - 1); + } +} + +static void get_target_info(void) +{ + if (target_bdev) { + /* + * Don't replace the inode if we got the bdev from opening + * a file. + */ + if (!target_inode) + target_inode = target_bdev->bd_inode; + target_type = get_target_type(target_inode); + target_blkbits = target_bdev->bd_inode->i_blkbits; + target_storage_available = size_ignoring_sparseness(); + } else { + target_type = -1; + target_inode = NULL; + target_blkbits = 0; + target_storage_available = 0; + } +} + +static int set_target_blocksize(void) +{ + if ((suspend_bio_ops.get_block_size(target_bdev) + != target_blocksize) && + (suspend_bio_ops.set_block_size(target_bdev, target_blocksize) + == -EINVAL)) { + printk(KERN_ERR name_suspend "Filewriter: Failed to set the blocksize.\n"); + return 1; + } + + return 0; + +} + +static int try_to_open_target_device(void) +{ + if (!target_dev_t) + return 1; + + if (!target_bdev) { + target_bdev = open_by_devnum(target_dev_t, FMODE_READ); + + if (IS_ERR(target_bdev)) { + target_bdev = NULL; + return 1; + } + used_devt = 1; + + if (set_target_blocksize()) { + blkdev_put(target_bdev); + target_bdev = NULL; + return 1; + } + } + + get_target_info(); + + return 0; +} + +static int try_to_parse_target_dev_t(char * commandline) +{ + struct kstat stat; + int error; + + target_dev_t = name_to_dev_t(commandline); + + if (!target_dev_t) { + error = vfs_stat(commandline, &stat); + if (!error) + target_dev_t = stat.rdev; + } + + if (!target_dev_t) { + if (test_suspend_state(SUSPEND_TRYING_TO_RESUME)) + suspend_early_boot_message(1, SUSPEND_CONTINUE_REQ, + "Failed to translate \"%s\" into a device id.\n", + commandline); + else + printk(name_suspend "Can't translate \"%s\" into a device id yet.\n", + commandline); + return 1; + } + + try_to_open_target_device(); + + if (IS_ERR(target_bdev)) { + printk("Open by devnum returned %p given %x.\n", + target_bdev, target_dev_t); + target_bdev = NULL; + if (test_suspend_state(SUSPEND_BOOT_TIME)) + suspend_early_boot_message(1, SUSPEND_CONTINUE_REQ, + "Failed to get access to the device on which" + " Software Suspend's header should be found."); + else + printk("Failed to get access to the device on which " + "Software Suspend's header should be found.\n"); + return 1; + } + + return 0; +} + +static void filewriter_noresume_reset(void) +{ + /* + * If we have read part of the image, we might have filled header_data with + * data that should be zeroed out. + */ + + memset((char *) &filewriter_header_data, 0, sizeof(filewriter_header_data)); +} + +/* + * + */ + +int parse_signature(char * header, int restore) +{ + int have_image = !memcmp(HaveImage, header, sizeof(HaveImage) - 1); + int non_image_header = !memcmp(NoImage, header, sizeof(NoImage) - 1); + + if (!have_image && !non_image_header) + return -1; + + if (non_image_header) + return 0; + + clear_suspend_state(SUSPEND_RESUMED_BEFORE); + + if (header[resumed_before_byte] & 1) + set_suspend_state(SUSPEND_RESUMED_BEFORE); + + /* Invalidate Image */ + if (restore) + strcpy(header, NoImage); + + return 1; +} + +/* + * prepare_signature + */ + +static int prepare_signature(struct submit_params * header_page_info, + char * current_header) +{ + /* + * Explicitly put the \0 that clears the 'tried to resume from + * this image before' flag. + */ + strncpy(current_header, HaveImage, sizeof(HaveImage)); + current_header[resumed_before_byte] = 0; + return 0; +} + +static void free_header_data(void) +{ + if (!first_header_submit_info) + return; + + while (first_header_submit_info) { + struct submit_params * next = first_header_submit_info->next; + kfree(first_header_submit_info); + first_header_submit_info = next; + } + + suspend_message(SUSPEND_WRITER, SUSPEND_LOW, 1, + " Freed swap pages in free_header_data.\n"); + first_header_submit_info = last_header_submit_info = NULL; + return; +} + +static int filewriter_storage_available(void) +{ + int result = 0; + + if (!target_inode) + return 0; + + switch (target_type) { + case 0: + case 5: + case 6: /* Socket, Char, Fifi */ + return -1; + case 2: /* Regular file: current size - holes + free space on part */ + result = target_storage_available; + break; + case 3: /* Block device */ + if (target_bdev->bd_disk) { + if (target_bdev->bd_part) + result = (unsigned long)target_bdev->bd_part->nr_sects >> (PAGE_SHIFT - 9); + else + result = (unsigned long)target_bdev->bd_disk->capacity >> (PAGE_SHIFT - 9); + } else { + printk("bdev->bd_disk null.\n"); + return 0; + } + } + + return result; +} + +static int filewriter_storage_allocated(void) +{ + int result; + + if (!target_inode) + return 0; + + if (target_is_normal_file()) { + result = (int) target_storage_available; + } else + result = header_pages + main_pages; + + return result; +} + +static int filewriter_initialise(int starting_cycle) +{ + if (!starting_cycle) + return 0; + + target_fd = sys_open(filewriter_target, O_RDWR, 0); + + if (target_fd < 0) { + printk("Open file %s returned %d.\n", filewriter_target, target_fd); + return target_fd; + } + + target_inode = current->files->fd[target_fd]->f_dentry->d_inode; + BUG_ON(target_bdev); + target_bdev = target_inode->i_bdev ? target_inode->i_bdev : target_inode->i_sb->s_bdev; + set_target_blocksize(); + get_target_info(); + + return 0; +} + +static void filewriter_cleanup(int finishing_cycle) +{ + if (target_bdev) { + if (used_devt) { + blkdev_put(target_bdev); + used_devt = 0; + } + target_bdev = NULL; + get_target_info(); + } + + if (!finishing_cycle) + return; + + if (target_fd >= 0) + sys_close(target_fd); + + target_fd = -1; +} + +static int filewriter_release_storage(void) +{ + if ((test_action_state(SUSPEND_KEEP_IMAGE)) && test_suspend_state(SUSPEND_NOW_RESUMING)) + return 0; + + /* Free metadata */ + free_header_data(); + + put_extent_chain(&block_chain); + + header_pages = main_pages = 0; + return 0; +} + +static int filewriter_allocate_header_space(int space_requested) +{ + int i, j, pages_to_get; + int ret = 0; + + /* We only steal pages from the main pool. If it doesn't have any yet... */ + + if (!block_chain.first) + return 0; + + pages_to_get = space_requested - header_pages; + + if (pages_to_get < 1) + return 0; + + for (i= header_pages; i < space_requested; i++) { + struct submit_params * new_submit_param; + + /* Get a submit structure */ + new_submit_param = kmalloc(sizeof(struct submit_params), GFP_ATOMIC); + + if (!new_submit_param) { + printk("Failed to kmalloc a struct submit param.\n"); + ret = -ENOMEM; + goto out; + } + + memset(new_submit_param, 0, sizeof(struct submit_params)); + + if (last_header_submit_info) { + last_header_submit_info->next = new_submit_param; + last_header_submit_info = new_submit_param; + } else + last_header_submit_info = first_header_submit_info = + new_submit_param; + + for (j = 0; j < target_blocksperpage; j++) { + unsigned long newvalue; + + /* + * Steal one from main extent chain. If, as a result, + * it is too small, more storage will be allocated or + * memory eaten. + */ + + if (block_chain.first->minimum < + block_chain.first->maximum) { + newvalue = block_chain.first->minimum; + block_chain.first->minimum++; + } else { + struct extent * oldfirst = + block_chain.first; + block_chain.first = oldfirst->next; + block_chain.frees++; + if (block_chain.last == oldfirst) + block_chain.last = NULL; + newvalue = oldfirst->minimum; + put_extent(oldfirst); + } + + block_chain.size--; + + new_submit_param->block[j] = newvalue; + } + + new_submit_param->dev = target_bdev; + new_submit_param->readahead_index = -1; + + header_pages++; + + suspend_message(SUSPEND_WRITER, SUSPEND_MEDIUM, 0, + " Got header page %d/%d. Dev is %x. Block is %lu. " + "Target block size is %d.\n", + i, space_requested, + new_submit_param->dev, + new_submit_param->block[0], + new_submit_param->dev->bd_block_size); + + if (!block_chain.size) + break; + } +out: + return ret; +} + +static int filewriter_allocate_storage(int space_requested) +{ + int result = 0; + int blocks_to_get = (space_requested << target_blockshift) - block_chain.size; + + /* Only release_storage reduces the size */ + if (blocks_to_get < 1) + return 0; + + main_pages = space_requested; + + get_main_pool_phys_params(); + + suspend_message(SUSPEND_WRITER, SUSPEND_MEDIUM, 0, + "Finished with block_chain.size == %d.\n", + block_chain.size); + + if (block_chain.size < ((header_pages + main_pages) << target_blockshift)) + result = -ENOSPC; + + return result; +} + +static int filewriter_write_header_chunk(char * buffer, int buffer_size); +static int filewriter_write_header_init(void) +{ + char new_sig[sig_size]; + struct extent * extent; + + filewriter_buffer = (char *) get_zeroed_page(GFP_ATOMIC); + header_link = + (unsigned long *) (filewriter_buffer + BYTES_PER_HEADER_PAGE); + filewriter_page_index = 1; + filewriter_buffer_posn = 0; + + current_header_submit_info = first_header_submit_info; + + /* We change it once the whole header is written */ + strcpy(new_sig, NoImage); + filewriter_write_header_chunk(new_sig, sig_size); + + /* Must calculate extent number before writing the header! */ + filewriter_header_data.pd1start_extent_number = 1; + extent = block_chain.first; + + while (extent != filewriter_header_data.pd1start_block_extent) { + filewriter_header_data.pd1start_extent_number++; + extent = extent->next; + } + + /* Info needed to bootstrap goes at the start of the header. + * First we save the 'header_data' struct, including the number + * of header pages. Then we save the structs containing data needed + * for reading the header pages back. + * Note that even if header pages take more than one page, when we + * read back the info, we will have restored the location of the + * next header page by the time we go to use it. + */ + filewriter_write_header_chunk((char *) &filewriter_header_data, + sizeof(filewriter_header_data)); + + return 0; +} + +static int filewriter_write_header_chunk(char * buffer, int buffer_size) +{ + int bytes_left = buffer_size; + + /* + * We buffer the writes until a page is full and to use the last + * sizeof(swp_entry_t) bytes for links between pages. This is + * totally transparent to the caller. + * + * Note also that buffer_size can be > PAGE_SIZE. + */ + + suspend_message(SUSPEND_WRITER, SUSPEND_HIGH, 0, + "\nStart of write_header_chunk loop with %d bytes to store.\n", + buffer_size); + + while (bytes_left) { + char * source_start = buffer + buffer_size - bytes_left; + char * dest_start = filewriter_buffer + filewriter_buffer_posn; + int dest_capacity = BYTES_PER_HEADER_PAGE - filewriter_buffer_posn; + sector_t next_header_page; + if (bytes_left <= dest_capacity) { + memcpy(dest_start, source_start, bytes_left); + filewriter_buffer_posn += bytes_left; + return 0; + } + + /* A page is full */ + memcpy(dest_start, source_start, dest_capacity); + bytes_left -= dest_capacity; + + BUG_ON(!current_header_submit_info); + + if (!current_header_submit_info->next) { + *header_link = 0; + } else { + next_header_page = + current_header_submit_info->next->block[0]; + + *header_link = next_header_page; + } + + suspend_message(SUSPEND_WRITER, SUSPEND_HIGH, 0, + "Writing header page %d. " + "Dev is %x. Block is %lu. Blocksperpage is %d. Bd_block_size is %d.\n", + filewriter_page_index, + current_header_submit_info->dev->bd_dev, + current_header_submit_info->block[0], + target_blocksperpage, + current_header_submit_info->dev->bd_block_size); + + current_header_submit_info->page = + virt_to_page(filewriter_buffer); + check_shift_keys(0, NULL); + suspend_bio_ops.submit_io(WRITE, current_header_submit_info, 0); + + filewriter_buffer_posn = 0; + filewriter_page_index++; + current_header_submit_info = current_header_submit_info->next; + } + + return 0; +} + +static int filewriter_write_header_cleanup(void) +{ + /* Write any unsaved data */ + if (filewriter_buffer_posn) { + *header_link = 0; + + suspend_message(SUSPEND_WRITER, SUSPEND_HIGH, 0, + "Writing header page %d. " + "Dev is %x. Block is %lu. Blocksperpage is %d.\n", + filewriter_page_index, + current_header_submit_info->dev->bd_dev, + current_header_submit_info->block[0], + target_blocksperpage); + + current_header_submit_info->page = + virt_to_page(filewriter_buffer); + suspend_bio_ops.submit_io(WRITE, + current_header_submit_info, 0); + } + + suspend_bio_ops.finish_all_io(); + + /* Adjust image header */ + suspend_bio_ops.bdev_page_io(READ, target_bdev, target_firstblock, + virt_to_page(filewriter_buffer)); + + prepare_signature(first_header_submit_info, filewriter_buffer); + + suspend_bio_ops.bdev_page_io(WRITE, target_bdev, target_firstblock, + virt_to_page(filewriter_buffer)); + + free_page((unsigned long) filewriter_buffer); + filewriter_buffer = NULL; + header_link = NULL; + + suspend_bio_ops.finish_all_io(); + + return 0; +} + +/* HEADER READING */ + +/* + * read_header_init() + * + * Description: + * 1. Attempt to read the device specified with resume2=. + * 2. Check the contents of the swap header for our signature. + * 3. Warn, ignore, reset and/or continue as appropriate. + * 4. If continuing, read the filewriter configuration section + * of the header and set up block device info so we can read + * the rest of the header & image. + * + * Returns: + * May not return if user choose to reboot at a warning. + * -EINVAL if cannot resume at this time. Booting should continue + * normally. + */ + +static int filewriter_read_header_init(void) +{ + filewriter_page_index = 1; + + filewriter_buffer = (char *) get_zeroed_page(GFP_ATOMIC); + filewriter_buffer_posn = sig_size; + + /* Read filewriter configuration */ + suspend_bio_ops.bdev_page_io(READ, target_bdev, target_firstblock, + virt_to_page((unsigned long) filewriter_buffer)); + + suspend_message(SUSPEND_WRITER, SUSPEND_HIGH, 0, + "Retrieving %d bytes from %x:%x to page %d, %p-%p.\n", + target_bdev->bd_dev, target_firstblock, + sizeof(filewriter_header_data), + filewriter_page_index, + filewriter_buffer, filewriter_buffer + sizeof(filewriter_header_data) - 1); + memcpy(&filewriter_header_data, + filewriter_buffer + filewriter_buffer_posn, + sizeof(filewriter_header_data)); + + filewriter_buffer_posn += sizeof(filewriter_header_data); + + return 0; +} + +static int filewriter_read_header_chunk(char * buffer, int buffer_size) +{ + int bytes_left = buffer_size, ret = 0; + + /* Read a chunk of the header */ + while ((bytes_left) && (!ret)) { + sector_t next = + *((sector_t *) (filewriter_buffer + BYTES_PER_HEADER_PAGE)); + char * dest_start = buffer + buffer_size - bytes_left; + char * source_start = + filewriter_buffer + filewriter_buffer_posn; + int source_capacity = + BYTES_PER_HEADER_PAGE - filewriter_buffer_posn; + + if (bytes_left <= source_capacity) { + memcpy(dest_start, source_start, bytes_left); + filewriter_buffer_posn += bytes_left; + return buffer_size; + } + + /* Next to read the next page */ + memcpy(dest_start, source_start, source_capacity); + bytes_left -= source_capacity; + + filewriter_page_index++; + + suspend_bio_ops.bdev_page_io(READ, target_bdev, + next, virt_to_page(filewriter_buffer)); + + filewriter_buffer_posn = 0; + } + + return buffer_size - bytes_left; +} + +static int filewriter_read_header_cleanup(void) +{ + free_page((unsigned long) filewriter_buffer); + return 0; +} + +static int filewriter_serialise_extents(void) +{ + serialise_extent_chain(&block_chain); + return 0; +} + +static int filewriter_load_extents(void) +{ + int i = 1; + struct extent * extent; + + load_extent_chain(&block_chain); + + extent = block_chain.first; + + while (i < filewriter_header_data.pd1start_extent_number) { + extent = extent->next; + i++; + } + + filewriter_header_data.pd1start_block_extent = extent; + + return 0; +} + +static int filewriter_write_init(int stream_number) +{ + if (stream_number == 1) { + currentblockextent = filewriter_header_data.pd1start_block_extent; + currentblockoffset = filewriter_header_data.pd1start_block_offset; + } else { + currentblockextent = block_chain.first; + currentblockoffset = currentblockextent->minimum; + } + + BUG_ON(!currentblockextent); + + filewriter_page_index = 1; + current_stream = stream_number; + + suspend_bio_ops.reset_io_stats(); + + return 0; +} + +static int filewriter_write_chunk(struct page * buffer_page) +{ + int i; + struct submit_params submit_params; + + BUG_ON(!currentblockextent); + submit_params.readahead_index = -1; + submit_params.page = buffer_page; + submit_params.dev = target_bdev; + + /* Get the blocks */ + for (i = 0; i < target_blocksperpage; i++) { + submit_params.block[i] = currentblockoffset; + GET_EXTENT_NEXT(currentblockextent, currentblockoffset); + } + + if(!submit_params.block[0]) + return -EIO; + + if (test_action_state(SUSPEND_TEST_FILTER_SPEED)) + return 0; + + suspend_bio_ops.submit_io(WRITE, &submit_params, 0); + + filewriter_page_index++; + + return 0; +} + +static int filewriter_write_cleanup(void) +{ + if (current_stream == 2) { + filewriter_header_data.pd1start_block_extent = currentblockextent; + filewriter_header_data.pd1start_block_offset = currentblockoffset; + } + + suspend_bio_ops.finish_all_io(); + + suspend_bio_ops.check_io_stats(); + + return 0; +} + +static int filewriter_read_init(int stream_number) +{ + if (stream_number == 1) { + currentblockextent = filewriter_header_data.pd1start_block_extent; + currentblockoffset = filewriter_header_data.pd1start_block_offset; + } else { + currentblockextent = NULL; + currentblockoffset = 0; + currentblockextent = + block_chain.first; + currentblockoffset = currentblockextent->minimum; + } + + BUG_ON(!currentblockextent); + + filewriter_page_index = 1; + + suspend_bio_ops.reset_io_stats(); + + readahead_index = readahead_submit_index = -1; + readahead_allocs = readahead_frees = 0; + + return 0; +} + +static int filewriter_begin_read_chunk(struct page * page, + int readahead_index, int sync) +{ + int i; + struct submit_params submit_params; + + BUG_ON(!currentblockextent); + + submit_params.readahead_index = readahead_index; + submit_params.page = page; + submit_params.dev = target_bdev; + + /* Get the blocks. There is no chance that they span chains. */ + for (i = 0; i < target_blocksperpage; i++) { + submit_params.block[i] = currentblockoffset; + GET_EXTENT_NEXT(currentblockextent, currentblockoffset); + } + + if ((i = suspend_bio_ops.submit_io(READ, &submit_params, sync))) + return -EPERM; + + filewriter_page_index++; + + check_shift_keys(0, NULL); + + return 0; +} + +/* Note that we ignore the sync parameter. We are implementing + * read ahead, and will always wait until our readhead buffer has + * been read before returning. + */ + +static int filewriter_read_chunk(struct page * buffer_page, int sync) +{ + static int last_result; + unsigned long * virt; + + if (sync == SUSPEND_ASYNC) + return filewriter_begin_read_chunk(buffer_page, -1, sync); + + /* Start new readahead while we wait for our page */ + if (readahead_index == -1) { + last_result = 0; + readahead_index = readahead_submit_index = 0; + } + + /* Start a new readahead? */ + if (last_result) { + /* We failed to submit a read, and have cleaned up + * all the readahead previously submitted */ + if (readahead_submit_index == readahead_index) + return -EPERM; + goto wait; + } + + do { + if (suspend_bio_ops.prepare_readahead(readahead_submit_index)) + break; + + readahead_allocs++; + + last_result = filewriter_begin_read_chunk( + suspend_bio_ops.readahead_pages[readahead_submit_index], + readahead_submit_index, SUSPEND_ASYNC); + if (last_result) { + printk("Begin read chunk for page %d returned %d.\n", + readahead_submit_index, last_result); + suspend_bio_ops.cleanup_readahead(readahead_submit_index); + break; + } + + readahead_submit_index++; + + if (readahead_submit_index == MAX_READAHEAD) + readahead_submit_index = 0; + + } while((!last_result) && (readahead_submit_index != readahead_index) && + (!suspend_bio_ops.readahead_ready(readahead_index))); + +wait: + suspend_bio_ops.wait_on_readahead(readahead_index); + + virt = kmap_atomic(buffer_page, KM_USER1); + memcpy(virt, page_address(suspend_bio_ops.readahead_pages[readahead_index]), + PAGE_SIZE); + kunmap_atomic(virt, KM_USER1); + + suspend_bio_ops.cleanup_readahead(readahead_index); + + readahead_frees++; + + readahead_index++; + if (readahead_index == MAX_READAHEAD) + readahead_index = 0; + + return 0; +} + +static int filewriter_read_cleanup(void) +{ + suspend_bio_ops.finish_all_io(); + while (readahead_index != readahead_submit_index) { + suspend_bio_ops.cleanup_readahead(readahead_index); + readahead_frees++; + readahead_index++; + if (readahead_index == MAX_READAHEAD) + readahead_index = 0; + } + suspend_bio_ops.check_io_stats(); + BUG_ON(readahead_allocs != readahead_frees); + return 0; +} + +/* filewriter_invalidate_image + * + */ +static int filewriter_invalidate_image(void) +{ + char * cur; + int result = 0; + + cur = (char *) get_zeroed_page(GFP_ATOMIC); + if (!cur) { + printk("Unable to allocate a page for restoring the image signature.\n"); + return -ENOMEM; + } + + /* + * If nr_suspends == 0, we must be booting, so no swap pages + * will be recorded as used yet. + */ + + if (nr_suspends > 0) + filewriter_release_storage(); + + /* + * We don't do a sanity check here: we want to restore the swap + * whatever version of kernel made the suspend image. + * + * We need to write swap, but swap may not be enabled so + * we write the device directly + */ + + suspend_bio_ops.bdev_page_io(READ, target_bdev, + target_firstblock, virt_to_page(cur)); + + result = parse_signature(cur, 1); + + if (result == -1) + goto out; + + strcpy(cur, NoImage); + cur[resumed_before_byte] = 0; + + suspend_bio_ops.bdev_page_io(WRITE, target_bdev, target_firstblock, + virt_to_page(cur)); + + if (!nr_suspends) + printk(KERN_WARNING name_suspend "Image invalidated.\n"); +out: + suspend_bio_ops.finish_all_io(); + free_page((unsigned long) cur); + return 0; +} + +/* + * workspace_size + * + * Description: + * Returns the number of bytes of RAM needed for this + * code to do its work. (Used when calculating whether + * we have enough memory to be able to suspend & resume). + * + */ +static unsigned long filewriter_memory_needed(void) +{ + return 0; +} + +/* Print debug info + * + * Description: + */ + +static int filewriter_print_debug_stats(char * buffer, int size) +{ + int len = 0; + struct sysinfo sysinfo; + + if (active_writer != &filewriterops) { + len = snprintf_used(buffer, size, "- Filewriter inactive.\n"); + return len; + } + + len = snprintf_used(buffer, size, "- Filewriter active.\n"); + + si_swapinfo(&sysinfo); + + len+= snprintf_used(buffer+len, size-len, " Storage available for image: %ld pages.\n", + sysinfo.freeswap + filewriter_storage_allocated()); + + return len; + return 0; +} + +/* + * Storage needed + * + * Returns amount of space in the image header required + * for the filewriter's data. + * + * We ensure the space is allocated, but actually save the + * data from write_header_init and therefore don't also define a + * save_config_info routine. + */ +static unsigned long filewriter_storage_needed(void) +{ + return strlen(filewriter_target) + 1; +} + +/* + * Image_exists + * + */ + +static int filewriter_image_exists(void) +{ + int signature_found; + char * diskpage; + + if (try_to_open_target_device()) + return 0; + + diskpage = (char *) get_zeroed_page(GFP_ATOMIC); + + /* FIXME: Make sure bdev_page_io handles wrong parameters */ + suspend_bio_ops.bdev_page_io(READ, target_bdev, + target_firstblock, virt_to_page(diskpage)); + suspend_bio_ops.finish_all_io(); + signature_found = parse_signature(diskpage, 0); + free_page((unsigned long) diskpage); + + if (!signature_found) { + return 0; /* non fatal error */ + } else if (signature_found == -1) { + printk(KERN_ERR name_suspend + "Unable to find a signature. Could you have moved " + "the file?\n"); + return 0; + } + + return 1; +} + +/* + * Mark resume attempted. + * + * Record that we tried to resume from this image. + */ + +static void filewriter_mark_resume_attempted(void) +{ + char * diskpage; + int signature_found; + + if (!target_dev_t) { + printk("Not even trying to record attempt at resuming" + " because target_dev_t is not set.\n"); + return; + } + + diskpage = (char *) get_zeroed_page(GFP_ATOMIC); + + /* FIXME: Make sure bdev_page_io handles wrong parameters */ + suspend_bio_ops.bdev_page_io(READ, target_bdev, target_firstblock, virt_to_page(diskpage)); + signature_found = parse_signature(diskpage, 0); + + switch (signature_found) { + case 1: + diskpage[resumed_before_byte] |= 1; + break; + } + + suspend_bio_ops.bdev_page_io(WRITE, target_bdev, target_firstblock, + virt_to_page(diskpage)); + suspend_bio_ops.finish_all_io(); + free_page((unsigned long) diskpage); + return; +} + +/* + * Parse Image Location + * + * Attempt to parse a resume2= parameter. + * Swap Writer accepts: + * resume2=swap:DEVNAME[:FIRSTBLOCK][@BLOCKSIZE] + * + * Where: + * DEVNAME is convertable to a dev_t by name_to_dev_t + * FIRSTBLOCK is the location of the first block in the swap file + * (specifying for a swap partition is nonsensical but not prohibited). + * BLOCKSIZE is the logical blocksize >= SECTOR_SIZE & <= PAGE_SIZE, + * mod SECTOR_SIZE == 0 of the device. + * Data is validated by attempting to read a swap header from the + * location given. Failure will result in filewriter refusing to + * save an image, and a reboot with correct parameters will be + * necessary. + */ + +static int filewriter_parse_image_location(char * commandline, int only_writer) +{ + char *thischar, *devstart = NULL, *colon = NULL, *at_symbol = NULL; + char * diskpage = NULL; + int signature_found, result = -EINVAL, temp_result; + + if (strncmp(commandline, "file:", 5)) { + if (!only_writer) + return 1; + } else + commandline += 5; + + devstart = thischar = commandline; + while ((*thischar != ':') && (*thischar != '@') && + ((thischar - commandline) < 250) && (*thischar)) + thischar++; + + if (*thischar == ':') { + colon = thischar; + *colon = 0; + thischar++; + } + + while ((*thischar != '@') && ((thischar - commandline) < 250) && (*thischar)) + thischar++; + + if (*thischar == '@') { + at_symbol = thischar; + *at_symbol = 0; + } + + if (colon) + target_firstblock = (int) simple_strtoul(colon + 1, NULL, 0); + else + target_firstblock = 0; + + if (at_symbol) { + target_blocksize = (int) simple_strtoul(at_symbol + 1, NULL, 0); + if (target_blocksize & (SECTOR_SIZE - 1)) { + printk("Filewriter: Blocksizes are multiples of %d.\n", SECTOR_SIZE); + return -EINVAL; + } + } else + target_blocksize = 4096; + + temp_result = try_to_parse_target_dev_t(devstart); + + if (colon) + *colon = ':'; + if (at_symbol) + *at_symbol = '@'; + + if (temp_result) + goto out; + + diskpage = (char *) get_zeroed_page(GFP_ATOMIC); + temp_result = suspend_bio_ops.bdev_page_io(READ, target_bdev, target_firstblock, virt_to_page(diskpage)); + + suspend_bio_ops.finish_all_io(); + + if (temp_result) { + printk(KERN_ERR name_suspend "Filewriter: Failed to submit I/O.\n"); + goto out; + } + + signature_found = parse_signature(diskpage, 0); + + if (signature_found != -1) { + printk(name_suspend "Filewriter: File signature found.\n"); + result = 0; + } else + printk(KERN_ERR name_suspend "Filewriter: Sorry. No signature found at specified location.\n"); + +out: + if (diskpage) + free_page((unsigned long) diskpage); + return result; +} + +static void set_filewriter_target(int test_it) +{ + char * buffer = (char *) get_zeroed_page(GFP_ATOMIC); + char * buffer2 = (char *) get_zeroed_page(GFP_ATOMIC); + int offset = 0, fd; + int sector; + + if(target_bdev) + filewriter_cleanup(0); + + fd = sys_open(filewriter_target, O_RDONLY, 0); + + if (fd < 0) { + printk("Filewriter: Unable to open %s.\n", filewriter_target); + goto cleanup1; + } + + *resume2_file = 0; + + target_inode = current->files->fd[fd]->f_dentry->d_inode; + target_type = get_target_type(target_inode); + + if (!target_is_usable) { + printk("Filewriter: %s is a link or directory. You can't suspend to them!\n", + filewriter_target); + goto cleanup2; + } + + target_bdev = target_inode->i_bdev ? target_inode->i_bdev : target_inode->i_sb->s_bdev; + sector = bmap(target_inode, 0); + + if (target_bdev && sector) { + + target_blkbits = target_bdev->bd_inode->i_blkbits; + + suspend_bio_ops.bdev_page_io(READ, target_bdev, sector, + virt_to_page(buffer)); + + bdevname(target_bdev, buffer2); + offset += snprintf(buffer + offset, PAGE_SIZE - offset, + "/dev/%s", buffer2); + + if (sector) + offset += snprintf(buffer + offset, PAGE_SIZE - offset, + ":0x%x", sector); + + if (target_inode->i_sb->s_blocksize != PAGE_SIZE) + offset += snprintf(buffer + offset, PAGE_SIZE - offset, + "@%lu", target_inode->i_sb->s_blocksize); + + } else + offset += snprintf(buffer + offset, PAGE_SIZE - offset, + "%s is not a valid target.", filewriter_target); + + sprintf(resume2_file, "file:%s", buffer); + +cleanup2: + if (test_it) + sys_close(fd); + +cleanup1: + free_page((unsigned long) buffer); + free_page((unsigned long) buffer2); +} + +/* filewriter_save_config_info + * + * Description: Save the target's name, not for resume time, but for all_settings. + * Arguments: Buffer: Pointer to a buffer of size PAGE_SIZE. + * Returns: Number of bytes used for saving our data. + */ + +static int filewriter_save_config_info(char * buffer) +{ + strcpy(buffer, filewriter_target); + return strlen(filewriter_target) + 1; +} + +/* filewriter_load_config_info + * + * Description: Reload target's name. + * Arguments: Buffer: Pointer to the start of the data. + * Size: Number of bytes that were saved. + */ + +static void filewriter_load_config_info(char * buffer, int size) +{ + strcpy(filewriter_target, buffer); +} + +static void test_filewriter_target(void) +{ + set_filewriter_target(1); +} + +extern void attempt_to_parse_resume_device(void); + +static struct suspend_proc_data filewriter_proc_data[] = { + + { + .filename = "filewriter_target", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_STRING, + .data = { + .string = { + .variable = filewriter_target, + .max_length = 256, + } + }, + .write_proc = test_filewriter_target, + }, + + { .filename = "disable_filewriter", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_INTEGER, + .data = { + .integer = { + .variable = &filewriterops.disabled, + .minimum = 0, + .maximum = 1, + } + }, + .write_proc = attempt_to_parse_resume_device, + } +}; + +static struct suspend_plugin_ops filewriterops = { + .type = WRITER_PLUGIN, + .name = "File Writer", + .module = THIS_MODULE, + .memory_needed = filewriter_memory_needed, + .print_debug_info = filewriter_print_debug_stats, + .save_config_info = filewriter_save_config_info, + .load_config_info = filewriter_load_config_info, + .storage_needed = filewriter_storage_needed, + .initialise = filewriter_initialise, + .cleanup = filewriter_cleanup, + + .write_init = filewriter_write_init, + .write_cleanup = filewriter_write_cleanup, + .read_init = filewriter_read_init, + .read_cleanup = filewriter_read_cleanup, + + .ops = { + .writer = { + .write_chunk = filewriter_write_chunk, + .read_chunk = filewriter_read_chunk, + .noresume_reset = filewriter_noresume_reset, + .storage_available = filewriter_storage_available, + .storage_allocated = filewriter_storage_allocated, + .release_storage = filewriter_release_storage, + .allocate_header_space = filewriter_allocate_header_space, + .allocate_storage = filewriter_allocate_storage, + .image_exists = filewriter_image_exists, + .mark_resume_attempted = filewriter_mark_resume_attempted, + .write_header_init = filewriter_write_header_init, + .write_header_chunk = filewriter_write_header_chunk, + .write_header_cleanup = filewriter_write_header_cleanup, + .read_header_init = filewriter_read_header_init, + .read_header_chunk = filewriter_read_header_chunk, + .read_header_cleanup = filewriter_read_header_cleanup, + .serialise_extents = filewriter_serialise_extents, + .load_extents = filewriter_load_extents, + .invalidate_image = filewriter_invalidate_image, + .parse_image_location = filewriter_parse_image_location, + } + } +}; + +/* ---- Registration ---- */ +static __init int filewriter_load(void) +{ + int result; + int i, numfiles = sizeof(filewriter_proc_data) / sizeof(struct suspend_proc_data); + + printk("Software Suspend FileWriter loading.\n"); + + if (!(result = suspend_register_plugin(&filewriterops))) { + for (i=0; i< numfiles; i++) + suspend_register_procfile(&filewriter_proc_data[i]); + } else + printk("Software Suspend FileWriter unable to register!\n"); + return result; +} + +#ifdef MODULE +static __exit void filewriter_unload(void) +{ + int i, numfiles = sizeof(filewriter_proc_data) / sizeof(struct suspend_proc_data); + + printk("Software Suspend FileWriter unloading.\n"); + + for (i=0; i< numfiles; i++) + suspend_unregister_procfile(&filewriter_proc_data[i]); + suspend_unregister_plugin(&filewriterops); +} + +module_init(filewriter_load); +module_exit(filewriter_unload); +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Nigel Cunningham"); +MODULE_DESCRIPTION("Suspend2 filewriter"); +#else +late_initcall(filewriter_load); +#endif diff -ruNp 800-suspend2.patch-old/kernel/power/suspend.h 800-suspend2.patch-new/kernel/power/suspend.h --- 800-suspend2.patch-old/kernel/power/suspend.h 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/suspend.h 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,28 @@ +/* + * kernel/power/suspend.h + * + * Copyright (C) 2004-2005 Nigel Cunningham + * + * This file is released under the GPLv2. + * + * It contains declarations used throughout swsusp. + * + */ + +#ifndef KERNEL_POWER_SUSPEND_H +#define KERNEL_POWER_SUSPEND_H + +#define SUSPEND_PD_PAGES(x) (((x)*sizeof(struct pbe))/PAGE_SIZE+1) + +/* mm/page_alloc.c */ +extern void drain_local_pages(void); + +void save_processor_state(void); +void restore_processor_state(void); +struct saved_context; +void __save_processor_state(struct saved_context *ctxt); +void __restore_processor_state(struct saved_context *ctxt); + +extern suspend_pagedir_t *pagedir_nosave __nosavedata; + +#endif diff -ruNp 800-suspend2.patch-old/kernel/power/suspend_swap.c 800-suspend2.patch-new/kernel/power/suspend_swap.c --- 800-suspend2.patch-old/kernel/power/suspend_swap.c 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/suspend_swap.c 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,1723 @@ +/* + * Swapwriter.c + * + * Copyright 2004-2005 Nigel Cunningham + * + * Distributed under GPLv2. + * + * This file encapsulates functions for usage of swap space as a + * backing store. + */ + +#include +#include +#include +#include + +#include "suspend2.h" +#include "suspend2_common.h" +#include "version.h" +#include "proc.h" +#include "plugins.h" +#include "io.h" +#include "ui.h" +#include "extent.h" + +#include "block_io.h" + +static struct suspend_plugin_ops swapwriterops; + +#define SIGNATURE_VER 6 +#define BYTES_PER_HEADER_PAGE (PAGE_SIZE - sizeof(swp_entry_t)) + +/* --- Struct of pages stored on disk */ + +struct swaplink { + char dummy[BYTES_PER_HEADER_PAGE]; + swp_entry_t next; +}; + +union diskpage { + union swap_header swh; /* swh.magic is the only member used */ + struct swaplink link; + struct suspend_header sh; +}; + +union p_diskpage { + union diskpage *pointer; + char *ptr; + unsigned long address; +}; + +// Higher Level +static int readahead_index, readahead_submit_index; +static int readahead_allocs, readahead_frees; + +static char * swapwriter_buffer; +static int swapwriter_buffer_posn; +static unsigned long * header_link; + +/* + * Internal Data Structures + * + */ + +/* header_data contains data that is needed to reload pagedir1, and + * is therefore saved in the suspend header. + * + * Pagedir2 swap comes before pagedir1 swap (save order), and the first swap + * entry for pagedir1 to use is set when pagedir2 is written (when we know how + * much swap it used). Since this first entry is almost certainly not at the + * start of a extent, the firstoffset variable below tells us where to start in + * the extent. All of this means we don't have to worry about getting different + * compression ratios for the kernel and cache (when compressing the image). + * We can simply allocate one pool of swap (size determined using expected + * compression ratio) and use it without worrying whether one pageset + * compresses better and the other worse (this is what happens). As long as the + * user gets the expected compression right, it will work. + */ + +struct { + /* Extent chains for swap & blocks */ + struct extent_chain swapextents; + struct extent_chain block_chain[MAX_SWAPFILES]; + + /* Location of start of pagedir 1 */ + struct extent * pd1start_block_extent; + int pd1start_chain; + int pd1start_extent_number; + unsigned long pd1start_block_offset; + + /* Devices used for swap */ + dev_t swapdevs[MAX_SWAPFILES]; + char blocksizes[MAX_SWAPFILES]; + +} header_data; + +static dev_t header_device; +static struct block_device * header_block_device; +static int headerblocksize = PAGE_SIZE; +static int headerblock; + +/* For swapfile automatically swapon/off'd. */ +static char swapfilename[SWAP_FILENAME_MAXLENGTH] = ""; +extern asmlinkage long sys_swapon(const char * specialfile, int swap_flags); +extern asmlinkage long sys_swapoff(const char * specialfile); +static int suspend_swapon_status; + +/* + * + * Current state. + * + */ + +/* Which pagedir are we saving/reloading? Needed so we can know whether to + * remember the last swap entry used at the end of writing pageset2, and + * get that location when saving or reloading pageset1.*/ +static int current_stream; + +/* Pointer to current swap entry being loaded/saved. */ +static struct extent * currentblockextent; +static unsigned long currentblockoffset; +static int currentblockchain; +static int currentblocksperpage; + +/* Header Page Information */ +static int header_pages_allocated; +static struct submit_params * first_header_submit_info, + * last_header_submit_info, * current_header_submit_info; + +/* + * + * User Specified Parameters + * + */ + +static int resume_firstblock; +static int resume_firstblocksize = PAGE_SIZE; +static dev_t resume_device; +static struct block_device * resume_block_device; + +struct sysinfo swapinfo; +static int swapwriter_invalidate_image(void); + +static void cleanup_opened_devices(int including_swapdevices) +{ + int i; + + /* Cleanup our open_by_devnums. + * + * Other swap devices, opened when reading pageset1, are + * either cleaned up by noresume_reset + */ + + if (header_block_device && header_block_device != resume_block_device) + blkdev_put(header_block_device); + + if (resume_block_device) + blkdev_put(resume_block_device); + + /* When reading pageset1 header */ + if (including_swapdevices) { + for (i = 0; i < MAX_SWAPFILES; i++) { + struct block_device * this_dev = swap_info[i].bdev; + if (this_dev && this_dev != resume_block_device && + this_dev != header_block_device) { + blkdev_put(swap_info[i].bdev); + swap_info[i].bdev = NULL; + } + } + } + + header_block_device = resume_block_device = NULL; +} +/* Must be silent - might be called from cat /proc/suspend/debug_info + * Returns 0 if was off, -EBUSY if was on, error value otherwise. + */ +static int enable_swapfile(void) +{ + int activateswapresult = -EINVAL; + + if (suspend_swapon_status) + return 0; + + if (swapfilename[0]) { + /* Attempt to swap on with maximum priority */ + activateswapresult = sys_swapon(swapfilename, 0xFFFF); + if ((activateswapresult) && (activateswapresult != -EBUSY)) + printk(name_suspend + "The swapfile/partition specified by " + "/proc/suspend/swapfile (%s) could not" + " be turned on (error %d). Attempting " + "to continue.\n", + swapfilename, activateswapresult); + if (!activateswapresult) + suspend_swapon_status = 1; + } + return activateswapresult; +} + +/* Returns 0 if was on, -EINVAL if was off, error value otherwise */ +static int disable_swapfile(void) +{ + int result = -EINVAL; + + if (!suspend_swapon_status) + return 0; + + if (swapfilename[0]) { + result = sys_swapoff(swapfilename); + if (result == -EINVAL) + return 0; /* Wasn't on */ + if (!result) + suspend_swapon_status = 0; + } + + return result; +} + +static int manage_swapfile(int enable) +{ + static int result; + + if (enable) + result = enable_swapfile(); + else + result = disable_swapfile(); + + return result; +} + +static void get_header_params(struct submit_params * headerpage) +{ + swp_entry_t entry = headerpage->swap_address; + int swapfilenum = swp_type(entry); + unsigned long offset = swp_offset(entry); + struct swap_info_struct * sis = get_swap_info_struct(swapfilenum); + sector_t sector = map_swap_page(sis, offset); + + headerpage->dev = sis->bdev, + headerpage->block[0] = sector; + headerpage->readahead_index = -1; +} + +static inline int get_blocks_per_page(int chain) +{ + int result = PAGE_SIZE / + suspend_bio_ops.get_block_size(swap_info[chain].bdev); + return result; +} + +static int try_to_parse_header_device(void) +{ + header_block_device = open_by_devnum(header_device, FMODE_READ); + + if (IS_ERR(header_block_device) || !header_block_device) { + if (suspend_early_boot_message(1,SUSPEND_CONTINUE_REQ, + "Failed to get access to the " + "resume header device.\nYou could be " + "booting with a 2.6 kernel when you " + "suspended a 2.4 kernel.")) + swapwriter_invalidate_image(); + return -EINVAL; + } + + printk("Setting header block device (%p) size to page size.\n", + header_block_device); + + if (set_blocksize(header_block_device, PAGE_SIZE) < 0) { + if (suspend_early_boot_message(1, SUSPEND_CONTINUE_REQ, + "Failed to set the blocksize for a swap device.")) + do { } while(0); + swapwriter_invalidate_image(); + return -EINVAL; + } + + return 0; +} + +static int try_to_open_resume_device(void) +{ + resume_block_device = open_by_devnum(resume_device, FMODE_READ); + + if (IS_ERR(resume_block_device) || !resume_block_device) + return 1; + + return 0; +} + +static int try_to_parse_resume_device(char * commandline) +{ + struct kstat stat; + int error; + + resume_device = name_to_dev_t(commandline); + + if (!resume_device) { + error = vfs_stat(commandline, &stat); + if (!error) + resume_device = stat.rdev; + } + + if (!resume_device) { + if (test_suspend_state(SUSPEND_TRYING_TO_RESUME)) + suspend_early_boot_message(1, SUSPEND_CONTINUE_REQ, + "Failed to translate \"%s\" into a device id.\n", + commandline); + else + printk(name_suspend "Can't translate \"%s\" into a device id yet.\n", + commandline); + return 1; + } + + if (try_to_open_resume_device()) { + suspend_early_boot_message(1, SUSPEND_CONTINUE_REQ, + "Failed to get access to \"%s\", where" + " the swap header should be found.", + commandline); + return 1; + } + + return 0; +} + +static void open_other_swap_device(int i, dev_t thisdevice) +{ + if ((swap_info[i].bdev = open_by_devnum(thisdevice, FMODE_READ)) && + !IS_ERR(swap_info[i].bdev)) + set_blocksize(swap_info[i].bdev, PAGE_SIZE); + else + printk("Failed to access device %lx (error was %d).\n", + (unsigned long) thisdevice, (int) swap_info[i].bdev); +} + +static inline char * get_path_for_swapfile(int which, char * path_page) +{ + return d_path( swap_info[which].swap_file->f_dentry, + swap_info[which].swap_file->f_vfsmnt, + path_page, + PAGE_SIZE); +} + +/* + * If we have read part of the image, we might have filled header_data with + * data that should be zeroed out. + */ +static void swapwriter_noresume_reset(void) +{ + memset((char *) &header_data, 0, sizeof(header_data)); + cleanup_opened_devices(1); +} + +static int parse_signature(char * header, int restore) +{ + int type = -1; + + if (!memcmp("SWAP-SPACE",header,10)) + return 0; + else if (!memcmp("SWAPSPACE2",header,10)) + return 1; + + else if (!memcmp("pmdisk", header,6)) + type = 2; + + else if (!memcmp("S1SUSP",header,6)) + type = 4; + else if (!memcmp("S2SUSP",header,6)) + type = 5; + + else if (!memcmp("z",header,1)) + type = 12; + else if (!memcmp("Z",header,1)) + type = 13; + + /* + * Put bdev of suspend header in last byte of swap header + * (unsigned short) + */ + if (type > 11) { + dev_t * header_ptr = (dev_t *) &header[1]; + unsigned char * headerblocksize_ptr = + (unsigned char *) &header[5]; + unsigned long * headerblock_ptr = (unsigned long *) &header[6]; + header_device = *header_ptr; + /* + * We are now using the highest bit of the char to indicate + * whether we have attempted to resume from this image before. + */ + clear_suspend_state(SUSPEND_RESUMED_BEFORE); + if (((int) *headerblocksize_ptr) & 0x80) + set_suspend_state(SUSPEND_RESUMED_BEFORE); + headerblocksize = SECTOR_SIZE * (((int) *headerblocksize_ptr) & 0xf); + headerblock = *headerblock_ptr; + } + + if ((restore) && (type > 5)) { + /* We only reset our own signatures */ + if (type & 1) + memcpy(header,"SWAPSPACE2",10); + else + memcpy(header,"SWAP-SPACE",10); + } + + return type; +} + +/* + * prepare_signature + */ + +static int prepare_signature(struct submit_params * header_page_info, + char * current_header) +{ + int current_type = parse_signature(current_header, 0); + dev_t * header_ptr = (dev_t *) (¤t_header[1]); + unsigned char * headerblocksize_ptr = + (unsigned char *) (¤t_header[5]); + unsigned long * headerblock_ptr = + (unsigned long *) (¤t_header[6]); + + if ((current_type > 1) && (current_type < 6)) + return 1; + + if (current_type & 1) + current_header[0] = 'Z'; + else + current_header[0] = 'z'; + *header_ptr = header_page_info->dev->bd_dev; + *headerblocksize_ptr = + (unsigned char) (header_page_info->dev->bd_block_size >> 9); + /* prev is the first/last swap page of the resume area */ + *headerblock_ptr = (unsigned long) header_page_info->block[0]; + return 0; +} + +extern int signature_check(char * header, int fix); + +static int free_swap_pages_for_header(void) +{ + if (!first_header_submit_info) + return 1; + + while (first_header_submit_info) { + struct submit_params * next = first_header_submit_info->next; + if (first_header_submit_info->swap_address.val) + swap_free(first_header_submit_info->swap_address); + kfree(first_header_submit_info); + first_header_submit_info = next; + } + + first_header_submit_info = last_header_submit_info = NULL; + header_pages_allocated = 0; + return 0; +} + +static void get_main_pool_phys_params(void) +{ + struct extent * extentpointer = NULL; + unsigned long address; + int i; + int extent_min = -1, extent_max = -1; + int last_chain = -1; + + for (i = 0; i < MAX_SWAPFILES; i++) + if (header_data.block_chain[i].first) + put_extent_chain(&header_data.block_chain[i]); + + extent_for_each(&header_data.swapextents, extentpointer, address) { + swp_entry_t swap_address = extent_val_to_swap_entry(address); + int swapfilenum = swp_type(swap_address); + unsigned long offset = swp_offset(swap_address); + struct swap_info_struct * sis = get_swap_info_struct(swapfilenum); + sector_t new_sector = map_swap_page(sis, offset); + + if ((new_sector == extent_max + 1) && + (last_chain == swapfilenum)) + extent_max++; + else { + if (extent_min > 0) + append_extent_to_extent_chain( + &header_data.block_chain[last_chain], + extent_min, extent_max); + extent_min = extent_max = new_sector; + last_chain = swapfilenum; + } + } + + if (extent_min > -1) + append_extent_to_extent_chain( + &header_data.block_chain[last_chain], + extent_min, extent_max); +} + +static int swapwriter_storage_allocated(void) +{ + int result; + result = header_data.swapextents.size + header_pages_allocated; + return result; +} + +static int swapwriter_storage_available(void) +{ + int result; + si_swapinfo(&swapinfo); + result = swapinfo.freeswap + swapwriter_storage_allocated(); + return result; +} + +static int swapwriter_initialise(int starting_cycle) +{ + if (starting_cycle) + manage_swapfile(1); + + if (!resume_block_device && try_to_open_resume_device()) + return 1; + + return 0; +} + +static void swapwriter_cleanup(int ending_cycle) +{ + if (ending_cycle) + manage_swapfile(0); + + cleanup_opened_devices(0); +} + +static int swapwriter_release_storage(void) +{ + int i = 0; + + if ((test_action_state(SUSPEND_KEEP_IMAGE)) && test_suspend_state(SUSPEND_NOW_RESUMING)) + return 0; + + free_swap_pages_for_header(); + + if (header_data.swapextents.first) { + /* Free swap entries */ + struct extent * extentpointer; + unsigned long extentvalue; + swp_entry_t entry; + extent_for_each(&header_data.swapextents, extentpointer, + extentvalue) { + entry = extent_val_to_swap_entry(extentvalue); + swap_free(entry); + } + put_extent_chain(&header_data.swapextents); + + for (i = 0; i < MAX_SWAPFILES; i++) + if (header_data.block_chain[i].first) + put_extent_chain(&header_data.block_chain[i]); + } + + return 0; +} + +static int swapwriter_allocate_header_space(int space_really_requested) +{ + /* space_requested was going to be in bytes... not yet */ + int i; + int ret = 0; + long space_requested; + + /* + * Up to here in the process, we haven't taken account of the fact + * that we need an extra four bytes per 4092 bytes written for link + * to the next page on which the header will be written. We factor + * that in here. + */ + space_requested = ((long) space_really_requested) << PAGE_SHIFT; + space_requested = ((space_really_requested + 4091) / 4092); + space_requested = (space_requested * 4 + 4091) / 4092; + space_requested += space_really_requested; + + for (i=(header_pages_allocated+1); i<=space_requested; i++) { + struct submit_params * new_submit_param; + + /* Get a submit structure */ + new_submit_param = kmalloc(sizeof(struct submit_params), GFP_ATOMIC); + + if (!new_submit_param) { + header_pages_allocated = i - 1; + printk("Failed to kmalloc a struct submit param.\n"); + ret = -ENOMEM; + goto out; + } + + memset(new_submit_param, 0, sizeof(struct submit_params)); + + if (last_header_submit_info) { + last_header_submit_info->next = new_submit_param; + last_header_submit_info = new_submit_param; + } else + last_header_submit_info = first_header_submit_info = + new_submit_param; + + /* Get swap entry */ + new_submit_param->swap_address = get_swap_page(); + + if ((!new_submit_param->swap_address.val) && + (header_data.swapextents.first)) { + /* + * Steal one from pageset swap chain. If, as a result, + * it is too small, more swap will be allocated or + * memory eaten. + */ + + new_submit_param->swap_address = + extent_val_to_swap_entry( + header_data.swapextents.first->minimum); + if (header_data.swapextents.first->minimum < + header_data.swapextents.first->maximum) + header_data.swapextents.first->minimum++; + else { + struct extent * oldfirst = + header_data.swapextents.first; + header_data.swapextents.first = oldfirst->next; + header_data.swapextents.frees++; + if (header_data.swapextents.last == oldfirst) + header_data.swapextents.last = NULL; + put_extent(oldfirst); + } + + header_data.swapextents.size--; + + /* + * Recalculate block chains for main pool. + * We don't assume blocks are at start of a chain and + * don't know how many blocks per swap entry. + */ + get_main_pool_phys_params(); + } + if (!new_submit_param->swap_address.val) { + free_swap_pages_for_header(); + printk("Unable to allocate swap page for header.\n"); + ret = -ENOMEM; + goto out; + } + + get_header_params(new_submit_param); + } + header_pages_allocated = space_requested; +out: + return ret; +} + +static int swapwriter_allocate_storage(int space_requested) +{ + int i, result = 0; + int pages_to_get = space_requested - header_data.swapextents.size; + int extent_min = -1, extent_max = -1; + + if (pages_to_get < 1) + return 0; + + for(i=0; i < pages_to_get; i++) { + swp_entry_t entry; + int new_value; + + entry = get_swap_page(); + if (!entry.val) { + result = -ENOSPC; + goto out; + } + + new_value = swap_entry_to_extent_val(entry); + if (new_value == extent_max + 1) + extent_max++; + else { + if (extent_min > -1) + append_extent_to_extent_chain( + &header_data.swapextents, + extent_min, extent_max); + extent_min = extent_max = new_value; + } + } + + if (extent_min > -1) + append_extent_to_extent_chain( + &header_data.swapextents, + extent_min, extent_max); + +out: + get_main_pool_phys_params(); + return result; +} + +static int swapwriter_write_header_chunk(char * buffer, int buffer_size) +{ + int bytes_left = buffer_size; + + /* + * We buffer the writes until a page is full and to use the last + * sizeof(swp_entry_t) bytes for links between pages. This is + * totally transparent to the caller. + * + * Note also that buffer_size can be > PAGE_SIZE. + */ + + while (bytes_left) { + char * source_start = buffer + buffer_size - bytes_left; + char * dest_start = swapwriter_buffer + swapwriter_buffer_posn; + int dest_capacity = BYTES_PER_HEADER_PAGE - swapwriter_buffer_posn; + swp_entry_t next_header_page; + if (bytes_left <= dest_capacity) { + memcpy(dest_start, source_start, bytes_left); + swapwriter_buffer_posn += bytes_left; + return 0; + } + + /* A page is full */ + memcpy(dest_start, source_start, dest_capacity); + bytes_left -= dest_capacity; + + BUG_ON(!current_header_submit_info); + + if (!current_header_submit_info->next) + *header_link = 0; + else { + next_header_page = + swp_entry(swp_type( + current_header_submit_info->next->swap_address), + current_header_submit_info->next->block[0]); + + *header_link = next_header_page.val; + } + + current_header_submit_info->page = + virt_to_page(swapwriter_buffer); + check_shift_keys(0, NULL); + suspend_bio_ops.submit_io(WRITE, current_header_submit_info, 0); + + swapwriter_buffer_posn = 0; + current_header_submit_info = current_header_submit_info->next; + } + + return 0; +} + +static int swapwriter_write_header_init(void) +{ + int i; + struct extent * extent; + + for (i = 0; i < MAX_SWAPFILES; i++) + if (swap_info[i].swap_file) { + header_data.swapdevs[i] = swap_info[i].bdev->bd_dev; + header_data.blocksizes[i] = + block_size(swap_info[i].bdev); + } else { + header_data.swapdevs[i] = (dev_t) 0; + header_data.blocksizes[i] = 0; + } + + swapwriter_buffer = (char *) get_zeroed_page(GFP_ATOMIC); + header_link = + (unsigned long *) (swapwriter_buffer + BYTES_PER_HEADER_PAGE); + + current_header_submit_info = first_header_submit_info; + + header_data.pd1start_extent_number = 1; + extent = header_data.block_chain[header_data.pd1start_chain].first; + + while (extent != header_data.pd1start_block_extent) { + header_data.pd1start_extent_number++; + extent = extent->next; + } + + /* Info needed to bootstrap goes at the start of the header. + * First we save the 'header_data' struct, including the number + * of header pages. Then we save the structs containing data needed + * for reading the header pages back. + * Note that even if header pages take more than one page, when we + * read back the info, we will have restored the location of the + * next header page by the time we go to use it. + */ + return swapwriter_write_header_chunk((char *) &header_data, + sizeof(header_data)); +} + +static int swapwriter_write_header_cleanup(void) +{ + /* Write any unsaved data */ + if (swapwriter_buffer_posn) { + *header_link = 0; + + current_header_submit_info->page = + virt_to_page(swapwriter_buffer); + suspend_bio_ops.submit_io(WRITE, + current_header_submit_info, 0); + } + + /* Adjust swap header */ + suspend_bio_ops.bdev_page_io(READ, resume_block_device, resume_firstblock, + virt_to_page(swapwriter_buffer)); + + prepare_signature(first_header_submit_info, + ((union swap_header *) swapwriter_buffer)->magic.magic); + + suspend_bio_ops.bdev_page_io(WRITE, resume_block_device, resume_firstblock, + virt_to_page(swapwriter_buffer)); + + free_page((unsigned long) swapwriter_buffer); + swapwriter_buffer = NULL; + header_link = NULL; + + suspend_bio_ops.finish_all_io(); + + return 0; +} + +/* ------------------------- HEADER READING ------------------------- */ + +/* + * read_header_init() + * + * Description: + * 1. Attempt to read the device specified with resume2=. + * 2. Check the contents of the swap header for our signature. + * 3. Warn, ignore, reset and/or continue as appropriate. + * 4. If continuing, read the swapwriter configuration section + * of the header and set up block device info so we can read + * the rest of the header & image. + * + * Returns: + * May not return if user choose to reboot at a warning. + * -EINVAL if cannot resume at this time. Booting should continue + * normally. + */ + +static int swapwriter_read_header_init(void) +{ + int i; + + BUG_ON(!resume_block_device); + + swapwriter_buffer = (char *) get_zeroed_page(GFP_ATOMIC); + + if (!header_device) { + printk("read_header_init called when we haven't " + "verified there is an image!\n"); + return -EINVAL; + } + + /* + * If the header is not on the resume_device, get the resume device first. + */ + if (header_device != resume_device) { + int result = try_to_parse_header_device(); + + if (result) + return result; + } else + header_block_device = resume_block_device; + + /* Read swapwriter configuration */ + suspend_bio_ops.bdev_page_io(READ, header_block_device, headerblock, + virt_to_page((unsigned long) swapwriter_buffer)); + + memcpy(&header_data, swapwriter_buffer, sizeof(header_data)); + + /* Restore device info */ + for (i = 0; i < MAX_SWAPFILES; i++) { + dev_t thisdevice = header_data.swapdevs[i]; + + swap_info[i].bdev = NULL; + + if (!thisdevice) + continue; + + if (thisdevice == resume_device) { + swap_info[i].bdev = resume_block_device; + /* Mark as used so the device doesn't get suspended. */ + swap_info[i].swap_file = (struct file *) 0xffffff; + continue; + } + + if (thisdevice == header_device) { + swap_info[i].bdev = header_block_device; + /* Mark as used so the device doesn't get suspended. */ + swap_info[i].swap_file = (struct file *) 0xffffff; + continue; + } + + open_other_swap_device(i, thisdevice); + if (IS_ERR(swap_info[i].bdev)) { + int result = (int) swap_info[i].bdev; + swap_info[i].bdev = NULL; + return result; + } + swap_info[i].swap_file = (struct file *) 0xffffff; + } + + swapwriter_buffer_posn = sizeof(header_data); + + return 0; +} + +static int swapwriter_read_header_chunk(char * buffer, int buffer_size) +{ + int bytes_left = buffer_size, ret = 0; + + check_shift_keys(0, ""); + + /* Read a chunk of the header */ + while ((bytes_left) && (!ret)) { + swp_entry_t next = + ((union p_diskpage) swapwriter_buffer).pointer->link.next; + struct block_device * dev = swap_info[swp_type(next)].bdev; + int pos = swp_offset(next); + char * dest_start = buffer + buffer_size - bytes_left; + char * source_start = + swapwriter_buffer + swapwriter_buffer_posn; + int source_capacity = + BYTES_PER_HEADER_PAGE - swapwriter_buffer_posn; + + if (bytes_left <= source_capacity) { + memcpy(dest_start, source_start, bytes_left); + swapwriter_buffer_posn += bytes_left; + return buffer_size; + } + + /* Next to read the next page */ + memcpy(dest_start, source_start, source_capacity); + bytes_left -= source_capacity; + + suspend_bio_ops.bdev_page_io(READ, dev, pos, virt_to_page(swapwriter_buffer)); + + swapwriter_buffer_posn = 0; + } + + return buffer_size - bytes_left; +} + +static int swapwriter_read_header_cleanup(void) +{ + free_page((unsigned long) swapwriter_buffer); + return 0; +} + +static int swapwriter_serialise_extents(void) +{ + int i; + + serialise_extent_chain(&header_data.swapextents); + + for (i = 0; i < MAX_SWAPFILES; i++) + serialise_extent_chain(&header_data.block_chain[i]); + + return 0; +} + +static int swapwriter_load_extents(void) +{ + int i; + struct extent * extent; + + load_extent_chain(&header_data.swapextents); + + for (i = 0; i < MAX_SWAPFILES; i++) + load_extent_chain(&header_data.block_chain[i]); + + extent = header_data.block_chain[header_data.pd1start_chain].first; + + i = 1; + while (i < header_data.pd1start_extent_number) { + extent = extent->next; + i++; + } + + header_data.pd1start_block_extent = extent; + + return 0; +} + +static int swapwriter_write_init(int stream_number) +{ + current_stream = stream_number; + + if (current_stream == 1) { + currentblockextent = header_data.pd1start_block_extent; + currentblockoffset = header_data.pd1start_block_offset; + currentblockchain = header_data.pd1start_chain; + } else { + for (currentblockchain = 0; currentblockchain < MAX_SWAPFILES; + currentblockchain++) + if (header_data.block_chain[currentblockchain].first) { + currentblockextent = + header_data. + block_chain[currentblockchain].first; + currentblockoffset = currentblockextent->minimum; + break; + } + } + + BUG_ON(!currentblockextent); + + currentblocksperpage = get_blocks_per_page(currentblockchain); + + suspend_bio_ops.reset_io_stats(); + + return 0; +} + +static int swapwriter_write_chunk(struct page * buffer_page) +{ + int i; + struct submit_params submit_params; + + if (test_action_state(SUSPEND_TEST_FILTER_SPEED)) + return 0; + + if (currentblockchain == MAX_SWAPFILES) { + printk("Error! We have run out of blocks for writing data.\n"); + return -ENOSPC; + } + + if (!currentblockextent) { + do { + currentblockchain++; + } while ((currentblockchain < MAX_SWAPFILES) && + (!header_data.block_chain[currentblockchain].first)); + + /* We can validly not have a new blockextent. We + * might be compressing data and the user was + * too optimistic in setting the compression + * ratio or we're just copying the pageset. */ + + if (currentblockchain == MAX_SWAPFILES) { + printk("Argh. Ran out of block chains.\n"); + return -ENOSPC; + } + + currentblockextent = + header_data.block_chain[currentblockchain].first; + currentblockoffset = currentblockextent->minimum; + currentblocksperpage = get_blocks_per_page(currentblockchain); + } + + submit_params.readahead_index = -1; + submit_params.page = buffer_page; + submit_params.dev = swap_info[currentblockchain].bdev; + + /* Get the blocks */ + submit_params.block[0] = currentblockoffset; + for (i = 0; i < currentblocksperpage; i++) + GET_EXTENT_NEXT(currentblockextent, currentblockoffset); + + suspend_bio_ops.submit_io(WRITE, &submit_params, 0); + + check_shift_keys(0, NULL); + + return 0; +} + +static int swapwriter_write_cleanup(void) +{ + if (current_stream == 2) { + header_data.pd1start_block_extent = currentblockextent; + header_data.pd1start_block_offset = currentblockoffset; + header_data.pd1start_chain = currentblockchain; + } + + suspend_bio_ops.finish_all_io(); + + suspend_bio_ops.check_io_stats(); + + return 0; +} + +static int swapwriter_read_init(int stream_number) +{ + current_stream = stream_number; + + if (current_stream == 1) { + currentblockextent = header_data.pd1start_block_extent; + currentblockoffset = header_data.pd1start_block_offset; + currentblockchain = header_data.pd1start_chain; + } else { + currentblockextent = NULL; + currentblockoffset = 0; + currentblockchain = 0; + for (currentblockchain = 0; currentblockchain < MAX_SWAPFILES; + currentblockchain++) + if (header_data.block_chain[currentblockchain].first) { + currentblockextent = + header_data.block_chain[currentblockchain].first; + currentblockoffset = currentblockextent->minimum; + break; + } + + BUG_ON(!currentblockextent); + } + + currentblocksperpage = get_blocks_per_page(currentblockchain); + + suspend_bio_ops.reset_io_stats(); + + readahead_index = readahead_submit_index = -1; + readahead_allocs = readahead_frees = 0; + + return 0; +} + +static int swapwriter_begin_read_chunk(struct page * page, + int readahead_index, int sync) +{ + int i; + struct submit_params submit_params; + + if (currentblockchain == MAX_SWAPFILES) { + /* Readahead might ask us to read too many blocks */ + printk("Currentblockchain == MAX_SWAPFILES. Begin_read_chunk returning -ENODATA.\n"); + return -ENODATA; + } + + if (!currentblockextent) { + do { + currentblockchain++; + } while ((currentblockchain < MAX_SWAPFILES) && + (!header_data.block_chain[currentblockchain].first)); + + /* We can validly not have a new blockextent. We + * might have allocated exactly the right amount + * of swap for the image and be reading the last + * block now. + */ + + /* Readahead might ask us to read too many blocks */ + if (currentblockchain == MAX_SWAPFILES) + return -ENODATA; + + currentblockextent = + header_data.block_chain[currentblockchain].first; + currentblockoffset = currentblockextent->minimum; + currentblocksperpage = get_blocks_per_page(currentblockchain); + } + + submit_params.readahead_index = readahead_index; + submit_params.page = page; + submit_params.dev = swap_info[currentblockchain].bdev; + + /* Get the blocks. There is no chance that they span chains. */ + submit_params.block[0] = currentblockoffset; + for (i = 0; i < currentblocksperpage; i++) + GET_EXTENT_NEXT(currentblockextent, currentblockoffset); + + if ((i = suspend_bio_ops.submit_io(READ, &submit_params, sync))) + return -EPERM; + + check_shift_keys(0, NULL); + + return 0; +} + +/* Note that we ignore the sync parameter. We are implementing + * read ahead, and will always wait until our readhead buffer has + * been read before returning. + */ + +static int swapwriter_read_chunk(struct page * buffer_page, int sync) +{ + static int last_result; + unsigned long * virt; + + /* If we only use readahead when reading synchronously. */ + if (sync == SUSPEND_ASYNC) + return swapwriter_begin_read_chunk(buffer_page, -1, sync); + + /* Start new readahead while we wait for our page */ + if (readahead_index == -1) { + last_result = 0; + readahead_index = readahead_submit_index = 0; + } + + /* Start a new readahead? */ + if (last_result) { + /* We failed to submit a read, and have cleaned up + * all the readahead previously submitted */ + if (readahead_submit_index == readahead_index) + return -EIO; + goto wait; + } + + do { + if (suspend_bio_ops.prepare_readahead(readahead_submit_index)) + break; + + readahead_allocs++; + + last_result = swapwriter_begin_read_chunk( + suspend_bio_ops.readahead_pages[readahead_submit_index], + readahead_submit_index, SUSPEND_ASYNC); + if (last_result) { + suspend_bio_ops.cleanup_readahead(readahead_submit_index); + readahead_frees++; + break; + } + + readahead_submit_index++; + + if (readahead_submit_index == MAX_READAHEAD) + readahead_submit_index = 0; + + } while((!last_result) && (readahead_submit_index != readahead_index) && + (!suspend_bio_ops.readahead_ready(readahead_index))); + +wait: + suspend_bio_ops.wait_on_readahead(readahead_index); + + virt = kmap_atomic(buffer_page, KM_USER1); + + memcpy(virt, page_address(suspend_bio_ops.readahead_pages[readahead_index]), + PAGE_SIZE); + kunmap_atomic(virt, KM_USER1); + + suspend_bio_ops.cleanup_readahead(readahead_index); + + readahead_frees++; + + readahead_index++; + if (readahead_index == MAX_READAHEAD) + readahead_index = 0; + + return 0; +} + +static int swapwriter_read_cleanup(void) +{ + suspend_bio_ops.finish_all_io(); + while (readahead_index != readahead_submit_index) { + suspend_bio_ops.cleanup_readahead(readahead_index); + readahead_frees++; + readahead_index++; + if (readahead_index == MAX_READAHEAD) + readahead_index = 0; + } + suspend_bio_ops.check_io_stats(); + BUG_ON(readahead_allocs != readahead_frees); + + return 0; +} + +/* swapwriter_invalidate_image + * + */ +static int swapwriter_invalidate_image(void) +{ + union p_diskpage cur; + int result = 0; + char newsig[11]; + + cur.address = get_zeroed_page(GFP_ATOMIC); + if (!cur.address) { + printk("Unable to allocate a page for restoring the swap signature.\n"); + return -ENOMEM; + } + + /* + * If nr_suspends == 0, we must be booting, so no swap pages + * will be recorded as used yet. + */ + + if (nr_suspends > 0) + swapwriter_release_storage(); + + /* + * We don't do a sanity check here: we want to restore the swap + * whatever version of kernel made the suspend image. + * + * We need to write swap, but swap may not be enabled so + * we write the device directly + */ + + suspend_bio_ops.bdev_page_io(READ, resume_block_device, + resume_firstblock, virt_to_page(cur.pointer)); + + result = parse_signature(cur.pointer->swh.magic.magic, 1); + + if (result < 4) + goto out; + + strncpy(newsig, cur.pointer->swh.magic.magic, 10); + newsig[10] = 0; + + suspend_bio_ops.bdev_page_io(WRITE, resume_block_device, resume_firstblock, + virt_to_page(cur.pointer)); + + if (!nr_suspends) + printk(KERN_WARNING name_suspend "Image invalidated.\n"); +out: + suspend_bio_ops.finish_all_io(); + free_page(cur.address); + return 0; +} + +/* + * workspace_size + * + * Description: + * Returns the number of bytes of RAM needed for this + * code to do its work. (Used when calculating whether + * we have enough memory to be able to suspend & resume). + * + */ +static unsigned long swapwriter_memory_needed(void) +{ + return 1; +} + +/* Print debug info + * + * Description: + */ + +static int swapwriter_print_debug_stats(char * buffer, int size) +{ + int len = 0; + struct sysinfo sysinfo; + + if (active_writer != &swapwriterops) { + len = snprintf_used(buffer, size, "- Swapwriter inactive.\n"); + return len; + } + + len = snprintf_used(buffer, size, "- Swapwriter active.\n"); + if (swapfilename[0]) + len+= snprintf_used(buffer+len, size-len, + " Attempting to automatically swapon: %s.\n", swapfilename); + + si_swapinfo(&sysinfo); + + len+= snprintf_used(buffer+len, size-len, " Swap available for image: %ld pages.\n", + sysinfo.freeswap + swapwriter_storage_allocated()); + + return len; +} + +/* + * Storage needed + * + * Returns amount of space in the swap header required + * for the swapwriter's data. This ignores the links between + * pages, which we factor in when allocating the space. + * + * We ensure the space is allocated, but actually save the + * data from write_header_init and therefore don't also define a + * save_config_info routine. + */ +static unsigned long swapwriter_storage_needed(void) +{ + return sizeof(header_data); +} + +/* + * Image_exists + * + */ + +static int swapwriter_image_exists(void) +{ + int signature_found; + union p_diskpage diskpage; + + if (!resume_device) { + printk("Not even trying to read header " + "because resume_device is not set.\n"); + return 0; + } + + if (!resume_block_device && !try_to_open_resume_device()) + return 0; + + diskpage.address = get_zeroed_page(GFP_ATOMIC); + + suspend_bio_ops.bdev_page_io(READ, resume_block_device, + resume_firstblock, virt_to_page(diskpage.ptr)); + suspend_bio_ops.finish_all_io(); + + signature_found = parse_signature(diskpage.pointer->swh.magic.magic, 0); + free_page(diskpage.address); + + if (signature_found < 2) { + return 0; /* Normal swap space */ + } else if (signature_found == -1) { + printk(KERN_ERR name_suspend + "Unable to find a signature. Could you have moved " + "a swap file?\n"); + return 0; + } else if (signature_found < 6) { + if ((!(test_suspend_state(SUSPEND_NORESUME_SPECIFIED))) + && suspend_early_boot_message(1, + SUSPEND_CONTINUE_REQ, + "Detected the signature of an alternate " + "implementation.\n")) + set_suspend_state(SUSPEND_NORESUME_SPECIFIED); + return 0; + } else if ((signature_found >> 1) != SIGNATURE_VER) { + if ((!(test_suspend_state(SUSPEND_NORESUME_SPECIFIED))) && + suspend_early_boot_message(1, SUSPEND_CONTINUE_REQ, + "Found a different style suspend image signature.")) + set_suspend_state(SUSPEND_NORESUME_SPECIFIED); + } + + return 1; +} + +/* + * Mark resume attempted. + * + * Record that we tried to resume from this image. + */ + +static void swapwriter_mark_resume_attempted(void) +{ + union p_diskpage diskpage; + int signature_found; + + if (!resume_device) { + printk("Not even trying to record attempt at resuming" + " because resume_device is not set.\n"); + return; + } + + diskpage.address = get_zeroed_page(GFP_ATOMIC); + + /* FIXME: Make sure bdev_page_io handles wrong parameters */ + suspend_bio_ops.bdev_page_io(READ, resume_block_device, resume_firstblock, virt_to_page(diskpage.ptr)); + signature_found = parse_signature(diskpage.pointer->swh.magic.magic, 0); + + switch (signature_found) { + case 12: + case 13: + diskpage.pointer->swh.magic.magic[5] |= 0x80; + break; + } + + suspend_bio_ops.bdev_page_io(WRITE, resume_block_device, resume_firstblock, + virt_to_page(diskpage.ptr)); + suspend_bio_ops.finish_all_io(); + free_page(diskpage.address); + + cleanup_opened_devices(1); + return; +} + +/* + * Parse Image Location + * + * Attempt to parse a resume2= parameter. + * Swap Writer accepts: + * resume2=swap:DEVNAME[:FIRSTBLOCK][@BLOCKSIZE] + * + * Where: + * DEVNAME is convertable to a dev_t by name_to_dev_t + * FIRSTBLOCK is the location of the first block in the swap file + * (specifying for a swap partition is nonsensical but not prohibited). + * BLOCKSIZE is the logical blocksize >= SECTOR_SIZE & <= PAGE_SIZE, + * mod SECTOR_SIZE == 0 of the device. + * Data is validated by attempting to read a swap header from the + * location given. Failure will result in swapwriter refusing to + * save an image, and a reboot with correct parameters will be + * necessary. + */ + +static int swapwriter_parse_image_location(char * commandline, int only_writer) +{ + char *thischar, *devstart = NULL, *colon = NULL, *at_symbol = NULL; + union p_diskpage diskpage; + int signature_found, result = -EINVAL, temp_result; + + if (strncmp(commandline, "swap:", 5)) { + if (!only_writer) + return 1; + } else + commandline += 5; + + devstart = thischar = commandline; + while ((*thischar != ':') && (*thischar != '@') && + ((thischar - commandline) < 250) && (*thischar)) + thischar++; + + if (*thischar == ':') { + colon = thischar; + *colon = 0; + thischar++; + } + + while ((*thischar != '@') && ((thischar - commandline) < 250) && (*thischar)) + thischar++; + + if (*thischar == '@') { + at_symbol = thischar; + *at_symbol = 0; + } + + if (colon) + resume_firstblock = (int) simple_strtoul(colon + 1, NULL, 0); + else + resume_firstblock = 0; + + if (at_symbol) { + resume_firstblocksize = (int) simple_strtoul(at_symbol + 1, NULL, 0); + if (resume_firstblocksize & (SECTOR_SIZE - 1)) { + printk("Swapwriter: Blocksizes are multiples of %d!\n", SECTOR_SIZE); + return -EINVAL; + } + } else + resume_firstblocksize = 4096; + + temp_result = try_to_parse_resume_device(devstart); + + if (colon) + *colon = ':'; + if (at_symbol) + *at_symbol = '@'; + + if (temp_result) + return -EINVAL; + + diskpage.address = get_zeroed_page(GFP_ATOMIC); + if (!diskpage.address) { + printk(KERN_ERR name_suspend "Swapwriter: Failed to allocate a diskpage for I/O.\n"); + return -ENOMEM; + } + + if ((suspend_bio_ops.get_block_size(resume_block_device) + != resume_firstblocksize) && + (suspend_bio_ops.set_block_size(resume_block_device, resume_firstblocksize) + == -EINVAL)) { + printk(KERN_ERR name_suspend "Swapwriter: Failed to set requested block size.\n"); + goto invalid; + } + + temp_result = suspend_bio_ops.bdev_page_io(READ, resume_block_device, resume_firstblock, virt_to_page(diskpage.ptr)); + suspend_bio_ops.finish_all_io(); + + if (temp_result) { + printk(KERN_ERR name_suspend "Swapwriter: Failed to submit I/O.\n"); + goto invalid; + } + + signature_found = parse_signature(diskpage.pointer->swh.magic.magic, 0); + + if (signature_found != -1) { + printk(name_suspend "Swapwriter: Signature found.\n"); + result = 0; + } else + printk(KERN_ERR name_suspend "Swapwriter: No swap signature found at specified location.\n"); +invalid: + free_page((unsigned long) diskpage.address); + return result; + +} + +static int header_locations_read_proc(char * page, char ** start, off_t off, int count, + int *eof, void *data) +{ + int i, printedpartitionsmessage = 0, len = 0, haveswap = 0, device_block_size; + struct inode *swapf = 0; + int zone; + char * path_page = (char *) __get_free_page(GFP_KERNEL); + char * path; + int path_len; + + *eof = 1; + if (!page) + return 0; + + for (i = 0; i < MAX_SWAPFILES; i++) { + if (!swap_info[i].swap_file) + continue; + + if (S_ISBLK(swap_info[i].swap_file->f_dentry->d_inode->i_mode)) { + haveswap = 1; + if (!printedpartitionsmessage) { + len += sprintf(page + len, + "For swap partitions, simply use the format: resume2=swap:/dev/hda1.\n"); + printedpartitionsmessage = 1; + } + } else { + path_len = 0; + + path = get_path_for_swapfile(i, path_page); + path_len = sprintf(path_page, "%-31s ", path); + + haveswap = 1; + swapf = swap_info[i].swap_file->f_dentry->d_inode; + device_block_size = block_size(swap_info[i].bdev); + if (!(zone = bmap(swapf,0))) { + len+= sprintf(page + len, + "Swapfile %-31s has been corrupted. Reuse mkswap on it and try again.\n", + path_page); + } else { + len+= sprintf(page + len, "For swapfile `%s`, use resume2=swap:/dev/:0x%x@%d.\n", + path_page, + zone, device_block_size); + } + + } + } + + if (!haveswap) + len = sprintf(page, "You need to turn on swap partitions before examining this file.\n"); + + free_page((unsigned long) path_page); + return len; +} + +static struct suspend_proc_data swapwriter_proc_data[] = { + { + .filename = "swapfilename", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_STRING, + .data = { + .string = { + .variable = swapfilename, + .max_length = 255, + } + } + }, + + { + .filename = "headerlocations", + .permissions = PROC_READONLY, + .type = SUSPEND_PROC_DATA_CUSTOM, + .data = { + .special = { + .read_proc = header_locations_read_proc, + } + } + }, + + { .filename = "disable_swapwriter", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_INTEGER, + .data = { + .integer = { + .variable = &swapwriterops.disabled, + .minimum = 0, + .maximum = 1, + } + }, + .write_proc = attempt_to_parse_resume_device, + } +}; + +static struct suspend_plugin_ops swapwriterops = { + .type = WRITER_PLUGIN, + .name = "Swap Writer", + .module = THIS_MODULE, + .memory_needed = swapwriter_memory_needed, + .print_debug_info = swapwriter_print_debug_stats, + .storage_needed = swapwriter_storage_needed, + .initialise = swapwriter_initialise, + .cleanup = swapwriter_cleanup, + + .write_init = swapwriter_write_init, + .write_cleanup = swapwriter_write_cleanup, + .read_init = swapwriter_read_init, + .read_cleanup = swapwriter_read_cleanup, + + .ops = { + .writer = { + .write_chunk = swapwriter_write_chunk, + .read_chunk = swapwriter_read_chunk, + .noresume_reset = swapwriter_noresume_reset, + .storage_available = swapwriter_storage_available, + .storage_allocated = swapwriter_storage_allocated, + .release_storage = swapwriter_release_storage, + .allocate_header_space = swapwriter_allocate_header_space, + .allocate_storage = swapwriter_allocate_storage, + .image_exists = swapwriter_image_exists, + .mark_resume_attempted = swapwriter_mark_resume_attempted, + .write_header_init = swapwriter_write_header_init, + .write_header_chunk = swapwriter_write_header_chunk, + .write_header_cleanup = swapwriter_write_header_cleanup, + .read_header_init = swapwriter_read_header_init, + .read_header_chunk = swapwriter_read_header_chunk, + .read_header_cleanup = swapwriter_read_header_cleanup, + .serialise_extents = swapwriter_serialise_extents, + .load_extents = swapwriter_load_extents, + .invalidate_image = swapwriter_invalidate_image, + .parse_image_location = swapwriter_parse_image_location, + } + } +}; + +/* ---- Registration ---- */ +static __init int swapwriter_load(void) +{ + int result; + int i, numfiles = sizeof(swapwriter_proc_data) / sizeof(struct suspend_proc_data); + + printk("Software Suspend Swap Writer loading.\n"); + if (!(result = suspend_register_plugin(&swapwriterops))) { + + for (i=0; i< numfiles; i++) + suspend_register_procfile(&swapwriter_proc_data[i]); + } else + printk("Software Suspend Swap Writer unable to register!\n"); + return result; +} + +#ifdef MODULE +static __exit void swapwriter_unload(void) +{ + int i, numfiles = sizeof(swapwriter_proc_data) / sizeof(struct suspend_proc_data); + + printk("Software Suspend Swap Writer unloading.\n"); + + for (i=0; i< numfiles; i++) + suspend_unregister_procfile(&swapwriter_proc_data[i]); + suspend_unregister_plugin(&swapwriterops); +} + +module_init(swapwriter_load); +module_exit(swapwriter_unload); +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Nigel Cunningham"); +MODULE_DESCRIPTION("Suspend2 swap writer"); +#else +late_initcall(swapwriter_load); +#endif diff -ruNp 800-suspend2.patch-old/kernel/power/swsusp.c 800-suspend2.patch-new/kernel/power/swsusp.c --- 800-suspend2.patch-old/kernel/power/swsusp.c 2005-07-30 15:42:48.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/swsusp.c 2005-07-30 21:14:46.000000000 +1000 @@ -51,9 +51,7 @@ #include #include #include -#include #include -#include #include #include #include @@ -71,10 +69,9 @@ #include #include +#include "swsusp.h" #include "power.h" - -/* References to section boundaries */ -extern const void __nosave_begin, __nosave_end; +#include "suspend.h" /* Variables to be preserved over suspend */ static int nr_copy_pages_check; diff -ruNp 800-suspend2.patch-old/kernel/power/swsusp.h 800-suspend2.patch-new/kernel/power/swsusp.h --- 800-suspend2.patch-old/kernel/power/swsusp.h 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/swsusp.h 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,24 @@ + +struct suspend_header { + u32 version_code; + unsigned long num_physpages; + unsigned long orig_mem_free; + char machine[65]; + char version[65]; + int num_cpus; + int page_size; + int pageset_2_size; + int param0; + int param1; + int param2; + int param3; + int progress0; + int progress1; + int progress2; + int progress3; + int io_time[2][2]; + + suspend_pagedir_t *suspend_pagedir; + unsigned int num_pbes; +}; + diff -ruNp 800-suspend2.patch-old/kernel/power/ui.c 800-suspend2.patch-new/kernel/power/ui.c --- 800-suspend2.patch-old/kernel/power/ui.c 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/ui.c 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,1125 @@ +/* + * kernel/power/ui.c + * + * Copyright (C) 1998-2001 Gabor Kuti + * Copyright (C) 1998,2001,2002 Pavel Machek + * Copyright (C) 2002-2003 Florent Chabaud + * Copyright (C) 2002-2005 Nigel Cunningham + * + * This file is released under the GPLv2. + * + * Routines for Software Suspend's user interface. + * + * The user interface code talks to a userspace program via a + * netlink socket. + * + * The kernel side: + * - starts the userui program; + * - sends text messages and progress bar status; + * + * The user space side: + * - passes messages regarding user requests (abort, toggle reboot etc) + * + */ + +#define __KERNEL_SYSCALLS__ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "proc.h" +#include "plugins.h" +#include "suspend2.h" +#include "suspend2_common.h" +#include "ui.h" +#include "version.h" + +#include "power.h" + +static struct suspend_plugin_ops userui_ops; +static int orig_loglevel; +static int orig_default_message_loglevel; +static int orig_kmsg; + +static char local_printf_buf[1024]; /* Same as printk - should be safe */ +static char lastheader[512]; +static int lastheader_message_len = 0; + +#define NUM_USERUI_SKBS 16 /* Number of preallocated skbs for emergencies */ + +static char userui_program[256] = ""; + +/* Number of distinct progress amounts that userspace can display */ +static int progress_granularity = 50; + +static struct sock *userui_nl; +static u32 userui_sock_seq; +static struct sk_buff *userui_skbs[NUM_USERUI_SKBS]; +static int next_free_userui_skb; +static pid_t userui_pid = -1; + +DECLARE_WAIT_QUEUE_HEAD(userui_wait_for_process); +DECLARE_WAIT_QUEUE_HEAD(userui_wait_for_key); + +/* + * Refill our pool of SKBs for use in emergencies (eg, when eating memory and none + * can be allocated). + */ +static void userui_replenish_skbs(void) +{ + while (next_free_userui_skb+1 < NUM_USERUI_SKBS) { + userui_skbs[next_free_userui_skb+1] = + alloc_skb(NLMSG_SPACE(sizeof(struct userui_msg_params)), GFP_ATOMIC); + if (userui_skbs[next_free_userui_skb+1]) + next_free_userui_skb++; + else + break; + } +} + +/* + * Return a single skbuff either from our pool, or try to allocate one if + * the pool is exhausted. + */ +static struct sk_buff * userui_get_skb(void) +{ + struct sk_buff *skb; + if (next_free_userui_skb == -1) + skb = alloc_skb(NLMSG_SPACE(sizeof(struct userui_msg_params)), GFP_ATOMIC); + else { + skb = userui_skbs[next_free_userui_skb]; + userui_skbs[next_free_userui_skb] = NULL; + next_free_userui_skb--; + } + + userui_replenish_skbs(); + + return skb; +} + +static void userui_notify_userspace(void* data) +{ + struct task_struct *t; + read_lock(&tasklist_lock); + if ((t = find_task_by_pid(userui_pid))) + wake_up_process(t); + read_unlock(&tasklist_lock); +} + +DECLARE_WORK(userui_notify_userspace_work, userui_notify_userspace, NULL); + +static void userui_send_message(int type, void* params, size_t len) +{ + struct sk_buff *skb; + struct nlmsghdr *nlh; + void *dest; + + skb = userui_get_skb(); + if (!skb) { + printk("suspend_userui: Can't allocate skb!\n"); + return; + } + + /* NLMSG_PUT contains a hidden goto nlmsg_failure */ + nlh = NLMSG_PUT(skb, 0, userui_sock_seq, type, len); + userui_sock_seq++; + + dest = NLMSG_DATA(nlh); + if (params && len > 0) + memcpy(dest, params, len); + + netlink_unicast(userui_nl, skb, userui_pid, 0); + + /* We may be in an interrupt context so defer waking up userspace */ + schedule_work(&userui_notify_userspace_work); + + return; + +nlmsg_failure: + if (skb) + kfree_skb(skb); +} + +/* + * Set the PF_NOFREEZE flag on the given process to ensure it can run whilst we + * are suspending. + */ +static int userui_nl_set_nofreeze(int pid) +{ + struct task_struct *t; + userui_pid = pid; + + read_lock(&tasklist_lock); + if ((t = find_task_by_pid(userui_pid)) == NULL) { + read_unlock(&tasklist_lock); + return -EINVAL; + } + + t->flags |= PF_NOFREEZE; + + read_unlock(&tasklist_lock); + + userui_send_message(USERUI_MSG_NOFREEZE_ACK, NULL, 0); + + return 0; +} + +#if CONFIG_PM_DEBUG +static int is_debugging = 1; +#else +static int is_debugging = 0; +#endif + +static void send_whether_debugging(void) +{ + userui_send_message(USERUI_MSG_IS_DEBUGGING, &is_debugging, sizeof(int)); +} + +/* + * Called when the userspace process has informed us that it's ready to roll. + */ +static int userui_nl_ready(int version) +{ + int ret = 0; + if (version != SUSPEND_USERUI_INTERFACE_VERSION) { + printk("suspend_userui: Userspace process using invalid interface version\n"); + set_result_state(SUSPEND_ABORTED); + ret = -EINVAL; + } + + wake_up_interruptible(&userui_wait_for_process); + + return ret; +} + +static void userui_nl_set_state(int n) +{ + /* Only let them change certain settings */ + static const int suspend_action_mask = + (1 << SUSPEND_REBOOT) | (1 << SUSPEND_PAUSE) | (1 << SUSPEND_SLOW) | + (1 << SUSPEND_LOGALL) | (1 << SUSPEND_SINGLESTEP) | + (1 << SUSPEND_PAUSE_NEAR_PAGESET_END); + + suspend_action = (suspend_action & (~suspend_action_mask)) | + (n & suspend_action_mask); +} + +static int userui_user_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh) +{ + int type; + int *data; + int err; + + if (!(nlh->nlmsg_flags & NLM_F_REQUEST)) + return 0; + + type = nlh->nlmsg_type; + + /* A control message: ignore them */ + if (type < USERUI_MSG_BASE) + return 0; + + /* Unknown message: reply with EINVAL */ + if (type >= USERUI_MSG_MAX) + return -EINVAL; + + /* All operations require privileges, even GET */ + if (security_netlink_recv(skb)) + return -EPERM; + + /* Only allow one task to receive NOFREEZE privileges */ + if (type == USERUI_MSG_NOFREEZE_ME && userui_pid != -1) + return -EBUSY; + + data = (int*)NLMSG_DATA(nlh); + + switch (type) { + case USERUI_MSG_NOFREEZE_ME: + if ((err = userui_nl_set_nofreeze(nlh->nlmsg_pid)) != 0) + return err; + break; + case USERUI_MSG_READY: + if (nlh->nlmsg_len < NLMSG_LENGTH(sizeof(int))) + return -EINVAL; + if ((err = userui_nl_ready(*data)) != 0) + return err; + break; + case USERUI_MSG_ABORT: + request_abort_suspend(); + break; + case USERUI_MSG_GET_STATE: + userui_send_message(USERUI_MSG_GET_STATE, &suspend_action, + sizeof(suspend_action)); + break; + case USERUI_MSG_SET_STATE: + if (nlh->nlmsg_len < NLMSG_LENGTH(sizeof(int))) + return -EINVAL; + userui_nl_set_state(*data); + break; + case USERUI_MSG_SPACE: + wake_up_interruptible(&userui_wait_for_key); + break; + case USERUI_MSG_GET_DEBUGGING: + send_whether_debugging(); + break; + } + + return 0; +} + +static void userui_user_rcv_skb(struct sk_buff *skb) +{ + int err; + struct nlmsghdr *nlh; + + while (skb->len >= NLMSG_SPACE(0)) { + u32 rlen; + + nlh = (struct nlmsghdr *) skb->data; + if (nlh->nlmsg_len < sizeof(*nlh) || skb->len < nlh->nlmsg_len) + return; + + rlen = NLMSG_ALIGN(nlh->nlmsg_len); + if (rlen > skb->len) + rlen = skb->len; + + if ((err = userui_user_rcv_msg(skb, nlh)) != 0) + netlink_ack(skb, nlh, err); + else if (nlh->nlmsg_flags & NLM_F_ACK) + netlink_ack(skb, nlh, 0); + skb_pull(skb, rlen); + } +} + +static void userui_netlink_input(struct sock *sk, int len) +{ + do { + struct sk_buff *skb; + while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) { + userui_user_rcv_skb(skb); + kfree_skb(skb); + } + } while (userui_nl && userui_nl->sk_receive_queue.qlen); +} + +static int open_userui_netlink(void) +{ + int i; + + userui_sock_seq = 0x42c0ffee; + userui_nl = netlink_kernel_create(NETLINK_SUSPEND2_USERUI, userui_netlink_input); + if (!userui_nl) { + printk("suspend_userui: Failed to allocate netlink socket.\n"); + return -ENOMEM; + } + + for (i = 0; i < NUM_USERUI_SKBS; i++) + userui_skbs[i] = NULL; + + next_free_userui_skb = -1; + + userui_replenish_skbs(); + + return 0; +} + +static void close_userui_netlink(void) +{ + int i; + + if (userui_nl) { + sock_release(userui_nl->sk_socket); + userui_nl = NULL; + } + + for (i = 0; i < NUM_USERUI_SKBS; i++) + if (userui_skbs[i]) + kfree_skb(userui_skbs[i]); +} + +static int launch_userui_program(void) +{ + int retval; + static char *envp[] = { + "HOME=/", + "TERM=linux", + "PATH=/sbin:/usr/sbin:/bin:/usr/bin", + NULL }; + static char *argv[] = { userui_program, NULL }; + + retval = call_usermodehelper(userui_program, argv, envp, 0); + + if (retval) + printk("suspend_userui: Failed to launch userui program: Error %d\n", retval); + + return retval; +} + +static void wait_for_userui_contact(void) +{ + DECLARE_WAITQUEUE(wait, current); + + add_wait_queue(&userui_wait_for_process, &wait); + set_current_state(TASK_INTERRUPTIBLE); + + /* Wait 2 seconds for the userspace UI process to make contact */ + if (userui_pid == -1 && !test_result_state(SUSPEND_ABORTED)) + interruptible_sleep_on_timeout(&userui_wait_for_process, 2*HZ); + + set_current_state(TASK_RUNNING); + remove_wait_queue(&userui_wait_for_process, &wait); +} + +void userui_redraw(void) +{ + if (userui_pid == -1) + return; + + userui_send_message(USERUI_MSG_REDRAW, NULL, 0); +} + +static unsigned long userui_storage_needed(void) +{ + return sizeof(userui_program); +} + +static int userui_save_config_info(char *buf) +{ + *((int *) buf) = progress_granularity; + memcpy(buf + sizeof(int), userui_program, sizeof(userui_program)); + return sizeof(userui_program) + sizeof(int); +} + +static void userui_load_config_info(char *buf, int size) +{ + /* Don't load the saved path if one has already been set */ + if (userui_program[0]) + return; + + progress_granularity = *((int *) buf); + size -= sizeof(int); + + if (size > sizeof(userui_program)) + size = sizeof(userui_program); + + memcpy(userui_program, buf + sizeof(int), size); + userui_program[sizeof(userui_program)-1] = '\0'; +} + +static unsigned long userui_memory_needed(void) +{ + /* ball park figure of 128 pages */ + return (128 * PAGE_SIZE); +} + +unsigned long userui_update_progress(unsigned long value, unsigned long maximum, + const char *fmt, va_list args) +{ + static int last_step = -1; + struct userui_msg_params msg; + int bitshift; + int this_step; + unsigned long next_update; + + if (userui_pid == -1) + return 0; + + if ((!maximum) || (!progress_granularity)) + return maximum; + + if (value < 0) + value = 0; + + if (value > maximum) + value = maximum; + + /* Try to avoid math problems - we can't do 64 bit math here + * (and shouldn't need it - anyone got screen resolution + * of 65536 pixels or more?) */ + bitshift = generic_fls(maximum) - 16; + if (bitshift > 0) { + unsigned long temp_maximum = maximum >> bitshift; + unsigned long temp_value = value >> bitshift; + this_step = (int) (temp_value * progress_granularity / temp_maximum); + next_update = (((this_step + 1) * temp_maximum / progress_granularity) + 1) << bitshift; + } else { + this_step = (int) (value * progress_granularity / maximum); + next_update = ((this_step + 1) * maximum / progress_granularity) + 1; + } + + if (this_step == last_step) + return next_update; + + memset(&msg, 0, sizeof(msg)); + + msg.a = this_step; + msg.b = progress_granularity; + + if (fmt) { + vsnprintf(msg.text, sizeof(msg.text), fmt, args); + msg.text[sizeof(msg.text)-1] = '\0'; + } + + userui_send_message(USERUI_MSG_PROGRESS, &msg, sizeof(msg)); + last_step = this_step; + + return next_update; +} + +/* __suspend_message. + * + * Description: This function is intended to do the same job as printk, but + * without normally logging what is printed. The point is to be + * able to get debugging info on screen without filling the logs + * with "1/534. ^M 2/534^M. 3/534^M" + * + * It may be called from an interrupt context - can't sleep! + * + * Arguments: int mask: The debugging section(s) this message belongs to. + * int level: The level of verbosity of this message. + * int restartline: Whether to output a \r or \n with this line + * (\n if we're logging all output). + * const char *fmt, ...: Message to be displayed a la printk. + */ +void __suspend_message(unsigned long section, unsigned long level, + int normally_logged, + const char *fmt, ...) +{ + struct userui_msg_params msg; + + va_list args; + + if ((level) && (level > console_loglevel)) + return; + + if (userui_pid == -1) + return; + + memset(&msg, 0, sizeof(msg)); + + msg.a = section; + msg.b = level; + msg.c = normally_logged; + + if (fmt) { + va_start(args, fmt); + vsnprintf(msg.text, sizeof(msg.text), fmt, args); + va_end(args); + msg.text[sizeof(msg.text)-1] = '\0'; + } + + userui_send_message(USERUI_MSG_MESSAGE, &msg, sizeof(msg)); +} + +static void wait_for_key_via_userui(void) +{ + DECLARE_WAITQUEUE(wait, current); + + add_wait_queue(&userui_wait_for_key, &wait); + set_current_state(TASK_INTERRUPTIBLE); + + interruptible_sleep_on(&userui_wait_for_key); + + set_current_state(TASK_RUNNING); + remove_wait_queue(&userui_wait_for_key, &wait); +} + +char suspend_wait_for_keypress(int timeout) +{ + int fd; + char key = '\0'; + struct termios t, t_backup; + + if (userui_pid != -1) { + wait_for_key_via_userui(); + key = ' '; + goto out; + } + + /* We should be guaranteed /dev/console exists after populate_rootfs() in + * init/main.c + */ + if ((fd = sys_open("/dev/console", O_RDONLY, 0)) < 0) + goto out; + + if (sys_ioctl(fd, TCGETS, (long)&t) < 0) + goto out_close; + + memcpy(&t_backup, &t, sizeof(t)); + + t.c_lflag &= ~(ISIG|ICANON|ECHO); + t.c_cc[VMIN] = 0; + if (timeout) + t.c_cc[VTIME] = timeout*10; + + if (sys_ioctl(fd, TCSETS, (long)&t) < 0) + goto out_restore; + + while (1) { + if (sys_read(fd, &key, 1) <= 0) { + key = '\0'; + break; + } + key = tolower(key); + if (test_suspend_state(SUSPEND_SANITY_CHECK_PROMPT)) { + if (key == 'c') { + set_suspend_state(SUSPEND_CONTINUE_REQ); + break; + } else if (key == ' ') + break; + } else + break; + } + +out_restore: + sys_ioctl(fd, TCSETS, (long)&t_backup); + +out_close: + sys_close(fd); +out: + return key; +} + +/* abort_suspend + * + * Description: Begin to abort a cycle. If this wasn't at the user's request + * (and we're displaying output), tell the user why and wait for + * them to acknowledge the message. + * Arguments: A parameterised string (imagine this is printk) to display, + * telling the user why we're aborting. + */ + +void abort_suspend(const char *fmt, ...) +{ + va_list args; + int printed_len = 0; + + if (!test_result_state(SUSPEND_ABORTED)) { + if (!test_result_state(SUSPEND_ABORT_REQUESTED)) { + va_start(args, fmt); + printed_len = vsnprintf(local_printf_buf, + sizeof(local_printf_buf), fmt, args); + va_end(args); + if (userui_pid != -1) + printed_len = sprintf(local_printf_buf + printed_len, + " (Press SPACE to continue)"); + suspend2_prepare_status(CLEAR_BAR, local_printf_buf); + + /* + * Make sure message seen - wait for shift to be + * released if being pressed + */ + if (userui_pid != -1) + suspend_wait_for_keypress(0); + } + /* Turn on aborting flag */ + set_result_state(SUSPEND_ABORTED); + } +} + +/* suspend2_prepare_status + * Description: Prepare the 'nice display', drawing the header and version, + * along with the current action and perhaps also resetting the + * progress bar. + * Arguments: + * int clearbar: Whether to reset the progress bar. + * const char *fmt, ...: The action to be displayed. + */ +void suspend2_prepare_status(int clearbar, const char *fmt, ...) +{ + va_list args; + + if (fmt) { + va_start(args, fmt); + lastheader_message_len = vsnprintf(lastheader, 512, fmt, args); + va_end(args); + } + + if (clearbar) + userui_update_progress(0, 1, NULL, NULL); + + __suspend_message(0, SUSPEND_STATUS, 1, lastheader, NULL); + + if (userui_pid == -1) + printk("%s\n", lastheader); +} + +/* update_status + * + * Description: Update the progress bar and (if on) in-bar message. + * Arguments: UL value, maximum: Current progress percentage (value/max). + * const char *fmt, ...: Message to be displayed in the middle + * of the progress bar. + * Note that a NULL message does not mean that any previous + * message is erased! For that, you need suspend2_prepare_status with + * clearbar on. + * Returns: Unsigned long: The next value where status needs to be updated. + * This is to reduce unnecessary calls to update_status. + */ +unsigned long suspend2_update_status(unsigned long value, unsigned long maximum, + const char *fmt, ...) +{ + unsigned long next_update = maximum; + va_list args; + + if (!maximum) + return maximum; + + if (value < 0) + value = 0; + + if (value > maximum) + value = maximum; + + va_start(args, fmt); + + next_update = userui_update_progress(value, maximum, fmt, args); + + va_end(args); + + return next_update; +} + +static struct waiting_message +{ + int message; + struct waiting_message * next; +} * waiting_messages = NULL; + +/* display_suspend_message + * + * Description: Display a message as a result of the user pressing a key + * and the key being processed in an interrupt handler. + */ + +int display_suspend_messages(void) +{ + int did_work = (waiting_messages != NULL); + + while (waiting_messages) { + struct waiting_message * this_message = waiting_messages; + + switch(waiting_messages->message) { + case 5: + suspend2_prepare_status(CLEAR_BAR, + "--- ESCAPE PRESSED AGAIN :" + " TRYING HARDER TO ABORT ---"); + break; + case 6: + suspend2_prepare_status(CLEAR_BAR, "--- ESCAPE PRESSED :" + " ABORTING PROCESS ---"); + break; + } + + waiting_messages = this_message->next; + kfree(this_message); + } + return did_work; +} + +/* suspend2_schedule_message + * + * Description: + * + */ + +void suspend2_schedule_message(int message_number) +{ + struct waiting_message * new_message = + kmalloc(sizeof(struct waiting_message), GFP_ATOMIC); + + if (!new_message) { + printk("Argh. Unable to allocate memory for " + "scheduling the display of a message.\n"); + return; + } + + new_message->message = message_number; + new_message->next = waiting_messages; + + waiting_messages = new_message; + return; +} + +/* request_abort_suspend + * + * Description: Handle the user requesting the cancellation of a suspend by + * pressing escape. Note that on a second press, we try a little + * harder, attempting to forcefully thaw processes. This shouldn't + * been needed, and may result in an oops (if we've overwritten + * memory), but has been useful on ocassion. + * Callers: Invoked from a netlink packet from userspace when the user presses + * escape. + */ +void request_abort_suspend(void) +{ + if (test_suspend_state(SUSPEND_NOW_RESUMING) || (test_result_state(SUSPEND_ABORT_REQUESTED))) + return; + + if (test_result_state(SUSPEND_ABORTED)) { + suspend2_schedule_message(5); + show_state(); + thaw_processes(FREEZER_ALL_THREADS); + } else { + suspend2_schedule_message(6); + set_result_state(SUSPEND_ABORTED); + set_result_state(SUSPEND_ABORT_REQUESTED); + } +} + +/* check_shift_keys + * + * Description: Potentially pause and wait for the user to tell us to continue. + * We normally only pause when @pause is set. + * Arguments: int pause: Whether we normally pause. + * char * message: The message to display. Not parameterised + * because it's normally a constant. + */ + +void check_shift_keys(int pause, char * message) +{ +#ifdef CONFIG_PM_DEBUG + int displayed_message = 0, last_key = 0; + + display_suspend_messages(); + while (last_key != 32 && + userui_pid != -1 && + ((test_action_state(SUSPEND_PAUSE) && pause) || + (test_action_state(SUSPEND_SINGLESTEP)))) { + if (!displayed_message) { + suspend2_prepare_status(DONT_CLEAR_BAR, + "%s Press SPACE to continue.%s", + message ? message : "", + (test_action_state(SUSPEND_SINGLESTEP)) ? + " Single step on." : ""); + displayed_message = 1; + } + last_key = suspend_wait_for_keypress(0); + display_suspend_messages(); + } +#else + display_suspend_messages(); +#endif + schedule(); +} + +extern asmlinkage long sys_ioctl(unsigned int fd, unsigned int cmd, + unsigned long arg); + +/* suspend2_prepare_console + * + * Description: Prepare a console for use, save current settings. + * Returns: Boolean: Whether an error occured. Errors aren't + * treated as fatal, but a warning is printed. + */ +void suspend2_prepare_console(void) +{ + orig_loglevel = console_loglevel; + orig_default_message_loglevel = default_message_loglevel; + orig_kmsg = kmsg_redirect; + kmsg_redirect = fg_console + 1; + default_message_loglevel = 1; + console_loglevel = suspend_default_console_level; + + userui_pid = -1; + + if (!*userui_program) { + printk("suspend_userui: userui_program not configured. suspend_userui disabled.\n"); + return; + } + + if (open_userui_netlink() < 0) + return; + + if (launch_userui_program() < 0) + goto out_close; + + wait_for_userui_contact(); + + if (userui_pid == -1) { + printk("suspend_userui: Failed to contact userui process. suspend_userui disabled.\n"); + goto out_close; + } + + return; + +out_close: + close_userui_netlink(); + return; +} + +/* suspend2_restore_console + * + * Description: Restore the settings we saved above. + */ + +void suspend2_cleanup_console(void) +{ + if (userui_pid > -1) { + struct task_struct *t; + + userui_send_message(USERUI_MSG_CLEANUP, NULL, 0); + + read_lock(&tasklist_lock); + if ((t = find_task_by_pid(userui_pid))) + t->flags &= ~PF_NOFREEZE; + read_unlock(&tasklist_lock); + + close_userui_netlink(); + + userui_pid = -1; + } + + suspend_default_console_level = console_loglevel; + console_loglevel = orig_loglevel; + kmsg_redirect = orig_kmsg; + default_message_loglevel = orig_default_message_loglevel; +} + +/* suspend_early_boot_message() + * Description: Handle errors early in the process of booting. + * The user may press C to continue booting, perhaps + * invalidating the image, or space to reboot. + * This works from either the serial console or normally + * attached keyboard. + * + * Note that we come in here from init, while the kernel is + * locked. If we want to get events from the serial console, + * we need to temporarily unlock the kernel. + * + * suspend_early_boot_message may also be called post-boot. + * In this case, it simply printks the message and returns. + * + * Arguments: int Whether we are able to erase the image. + * int default_answer. What to do when we timeout. This + * will normally be continue, but the user might + * provide command line options (__setup) to override + * particular cases. + * Char *. Pointer to a string explaining why we're moaning. + */ + +#define say(message, a...) printk(KERN_EMERG message, ##a) +#define message_timeout 25 /* message_timeout * 10 must fit in 8 bits */ + +int suspend_early_boot_message(int can_erase_image, int default_answer, char *warning_reason, ...) +{ + unsigned long orig_state = get_suspend_state(), continue_req = 0; + va_list args; + int printed_len; + + if (warning_reason) { + va_start(args, warning_reason); + printed_len = vsnprintf(local_printf_buf, + sizeof(local_printf_buf), + warning_reason, + args); + va_end(args); + } + + if (!test_suspend_state(SUSPEND_BOOT_TIME)) { + printk(name_suspend "%s", local_printf_buf); + return default_answer; + } + + /* We might be called directly from do_mounts_initrd if the + * user fails to set up their initrd properly. We need to + * enable the keyboard handler by setting the running flag */ + set_suspend_state(SUSPEND_RUNNING); + +#if defined(CONFIG_VT) || defined(CONFIG_SERIAL_CONSOLE) + console_loglevel = 7; + + say("=== Software Suspend ===\n\n"); + if (warning_reason) { + say("BIG FAT WARNING!! %s\n\n", local_printf_buf); + if (can_erase_image) { + say("If you want to use the current suspend image, reboot and try\n"); + say("again with the same kernel that you suspended from. If you want\n"); + say("to forget that image, continue and the image will be erased.\n"); + } else { + say("If you continue booting, note that any image WILL NOT BE REMOVED.\n"); + say("Suspend is unable to do so because the appropriate modules aren't\n"); + say("loaded. You should manually remove the image to avoid any\n"); + say("possibility of corrupting your filesystem(s) later.\n"); + } + say("Press SPACE to reboot or C to continue booting with this kernel\n\n"); + say("Default action if you don't select one in %d seconds is: %s.\n", + message_timeout, + default_answer == SUSPEND_CONTINUE_REQ ? + "continue booting" : "reboot"); + } else { + say("BIG FAT WARNING!!\n\n"); + say("You have tried to resume from this image before.\n"); + say("If it failed once, may well fail again.\n"); + say("Would you like to remove the image and boot normally?\n"); + say("This will be equivalent to entering noresume2 on the\n"); + say("kernel command line.\n\n"); + say("Press SPACE to remove the image or C to continue resuming.\n\n"); + say("Default action if you don't select one in %d seconds is: %s.\n", + message_timeout, + !!default_answer ? + "continue resuming" : "remove the image"); + } + + set_suspend_state(SUSPEND_SANITY_CHECK_PROMPT); + clear_suspend_state(SUSPEND_CONTINUE_REQ); + + if (suspend_wait_for_keypress(message_timeout) == 0) /* We timed out */ + continue_req = !!default_answer; + else + continue_req = test_suspend_state(SUSPEND_CONTINUE_REQ); + + if ((warning_reason) && (!continue_req)) + machine_restart(NULL); + + restore_suspend_state(orig_state); + if (continue_req) + set_suspend_state(SUSPEND_CONTINUE_REQ); + +#endif // CONFIG_VT or CONFIG_SERIAL_CONSOLE + return -EPERM; +} +#undef say + +/* + * User interface specific /proc/suspend entries. + */ + +static struct suspend_proc_data proc_params[] = { +#ifdef CONFIG_PROC_FS + { .filename = "default_console_level", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_INTEGER, + .data = { + .integer = { + .variable = &suspend_default_console_level, + .minimum = 0, +#ifdef CONFIG_PM_DEBUG + .maximum = 7, +#else + .maximum = 1, +#endif + + } + } + }, + + { .filename = "enable_escape", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_BIT, + .data = { + .bit = { + .bit_vector = &suspend_action, + .bit = SUSPEND_CAN_CANCEL, + } + } + }, + +#ifdef CONFIG_PM_DEBUG + { .filename = "debug_sections", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_UL, + .data = { + .ul = { + .variable = &suspend_debug_state, + .minimum = 0, + .maximum = 2 << 30, + } + } + }, + + { .filename = "log_everything", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_BIT, + .data = { + .bit = { + .bit_vector = &suspend_action, + .bit = SUSPEND_LOGALL, + } + } + }, + + { .filename = "pause_between_steps", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_BIT, + .data = { + .bit = { + .bit_vector = &suspend_action, + .bit = SUSPEND_PAUSE, + } + } + }, +#endif + { .filename = "disable_userui_support", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_INTEGER, + .data = { + .integer = { + .variable = &userui_ops.disabled, + .minimum = 0, + .maximum = 1, + } + } + }, + { .filename = "userui_progress_granularity", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_INTEGER, + .data = { + .integer = { + .variable = &progress_granularity, + .minimum = 1, + .maximum = 2048, + } + } + }, + { .filename = "userui_program", + .permissions = PROC_RW, + .type = SUSPEND_PROC_DATA_STRING, + .data = { + .string = { + .variable = userui_program, + .max_length = 255, + } + } + } +#endif +}; + +static struct suspend_plugin_ops userui_ops = { + .type = MISC_PLUGIN, + .name = "Userspace UI Support", + .module = THIS_MODULE, + .storage_needed = userui_storage_needed, + .save_config_info = userui_save_config_info, + .load_config_info = userui_load_config_info, + .memory_needed = userui_memory_needed, +}; + +/* suspend_console_proc_init + * Description: Boot time initialisation for user interface. + */ +static __init int suspend_console_proc_init(void) +{ + int result, i, numfiles = sizeof(proc_params) / sizeof(struct suspend_proc_data); + + if (!(result = suspend_register_plugin(&userui_ops))) + for (i=0; i< numfiles; i++) + suspend_register_procfile(&proc_params[i]); + + userui_nl = NULL; + userui_program[0] = '\0'; + + return result; +} + +late_initcall(suspend_console_proc_init); diff -ruNp 800-suspend2.patch-old/kernel/power/ui.h 800-suspend2.patch-new/kernel/power/ui.h --- 800-suspend2.patch-old/kernel/power/ui.h 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/ui.h 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,54 @@ +/* + * + */ + +extern void suspend2_prepare_console(void); +extern void suspend2_cleanup_console(void); + +extern void check_shift_keys(int pause, char * message); +extern unsigned long suspend2_update_status(unsigned long value, unsigned long maximum, + const char *fmt, ...); + +extern void request_abort_suspend(void); +extern void abort_suspend(const char *fmt, ...); + +extern void suspend2_schedule_message (int message_number); + +extern void userui_redraw(void); + +enum { + DONT_CLEAR_BAR, + CLEAR_BAR +}; + +#define SUSPEND_USERUI_INTERFACE_VERSION 5 + +enum { + USERUI_MSG_BASE = 0x10, + + /* Userspace -> Kernel */ + USERUI_MSG_READY = 0x10, + USERUI_MSG_ABORT = 0x11, + USERUI_MSG_SET_STATE = 0x12, + USERUI_MSG_GET_STATE = 0x13, + USERUI_MSG_NOFREEZE_ME = 0x16, + USERUI_MSG_SET_PROGRESS_GRANULARITY = 0x17, + USERUI_MSG_SPACE = 0x18, + USERUI_MSG_GET_DEBUGGING = 0x19, + + /* Kernel -> Userspace */ + USERUI_MSG_MESSAGE = 0x21, + USERUI_MSG_PROGRESS = 0x22, + USERUI_MSG_CLEANUP = 0x24, + USERUI_MSG_REDRAW = 0x25, + USERUI_MSG_KEYPRESS = 0x26, + USERUI_MSG_NOFREEZE_ACK = 0x27, + USERUI_MSG_IS_DEBUGGING = 0x28, + + USERUI_MSG_MAX, +}; + +struct userui_msg_params { + unsigned long a, b, c, d; + char text[80]; +}; diff -ruNp 800-suspend2.patch-old/kernel/power/userspace-nofreeze.c 800-suspend2.patch-new/kernel/power/userspace-nofreeze.c --- 800-suspend2.patch-old/kernel/power/userspace-nofreeze.c 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/userspace-nofreeze.c 2005-07-30 21:14:46.000000000 +1000 @@ -0,0 +1,68 @@ +/* + * kernel/power/suspend2_core/userspace-nofreeze.c + * + * Mark/unmark userspace processes as PF_NOFREEZE. + * + * This should be used with extreme caution! + * + * Initial purpose: make nbd-client about to be NOFREEZE. + */ + +#include +#include +#include +#include "suspend.h" + +int toggle_pid; + +/* + * toggle_thread_nofreeze + * + * Toggle a thread's PF_NOFREEZE flag + * + * Returns: + * -1: PID not found + * 0: NO_FREEZE cleared. + * 1: NO_FREEZE set. + */ +static int __toggle_thread_nofreeze(int pid) +{ + struct task_struct *p, *g; + int result = -1; + + read_lock(&tasklist_lock); + + do_each_thread(g, p) { + if (p->pid == pid) { + if (!p->mm) + printk("Be very careful! You are toggling NOFREEZE on a real kernel thread!"); + p->flags ^=PF_NOFREEZE; + result = !!(p->flags & PF_NOFREEZE); + } + } while_each_thread(g, p); + + read_unlock(&tasklist_lock); + + return result; +} + +void toggle_thread_nofreeze(void) +{ + int result; + printk("Seeking %d... ", toggle_pid); + + switch ((result = __toggle_thread_nofreeze(toggle_pid))) + { + case -1: + printk("Can't toggle NO_FREEZE for thread - not found.\n"); + break; + case 0: + printk("NO_FREEZE flag cleared.\n"); + break; + case 1: + printk("NO_FREEZE flag set.\n"); + break; + default: + printk("what does %d mean?!", result); + } +} diff -ruNp 800-suspend2.patch-old/kernel/power/version.h 800-suspend2.patch-new/kernel/power/version.h --- 800-suspend2.patch-old/kernel/power/version.h 1970-01-01 10:00:00.000000000 +1000 +++ 800-suspend2.patch-new/kernel/power/version.h 2005-07-30 21:25:49.000000000 +1000 @@ -0,0 +1,5 @@ +#define SUSPEND_CORE_VERSION "2.1.9.11" +#ifndef KERNEL_POWER_SWSUSP_C +#define name_suspend "Software Suspend " SUSPEND_CORE_VERSION ": " +#endif +