1 files changed, 0 insertions, 1080 deletions

diff --git a/kernel/power/tuxonice_prepare_image.c b/kernel/power/tuxonice_prepare_image.c
deleted file mode 100644
index e0593252f..000000000
--- a/kernel/power/tuxonice_prepare_image.c
+++ /dev/null
@@ -1,1080 +0,0 @@
-/*
- * kernel/power/tuxonice_prepare_image.c
- *
- * Copyright (C) 2003-2015 Nigel Cunningham (nigel at nigelcunningham com au)
- *
- * This file is released under the GPLv2.
- *
- * We need to eat memory until we can:
- * 1. Perform the save without changing anything (RAM_NEEDED < #pages)
- * 2. Fit it all in available space (toiActiveAllocator->available_space() >=
- *    main_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).
- *
- */
-
-#include <linux/highmem.h>
-#include <linux/freezer.h>
-#include <linux/hardirq.h>
-#include <linux/mmzone.h>
-#include <linux/console.h>
-#include <linux/tuxonice.h>
-
-#include "tuxonice_pageflags.h"
-#include "tuxonice_modules.h"
-#include "tuxonice_io.h"
-#include "tuxonice_ui.h"
-#include "tuxonice_prepare_image.h"
-#include "tuxonice.h"
-#include "tuxonice_extent.h"
-#include "tuxonice_checksum.h"
-#include "tuxonice_sysfs.h"
-#include "tuxonice_alloc.h"
-#include "tuxonice_atomic_copy.h"
-#include "tuxonice_builtin.h"
-
-static unsigned long num_nosave, main_storage_allocated, storage_limit,
-	    header_storage_needed;
-unsigned long extra_pd1_pages_allowance =
-	CONFIG_TOI_DEFAULT_EXTRA_PAGES_ALLOWANCE;
-long image_size_limit = CONFIG_TOI_DEFAULT_IMAGE_SIZE_LIMIT;
-static int no_ps2_needed;
-
-struct attention_list {
-	struct task_struct *task;
-	struct attention_list *next;
-};
-
-static struct attention_list *attention_list;
-
-#define PAGESET1 0
-#define PAGESET2 1
-
-void free_attention_list(void)
-{
-	struct attention_list *last = NULL;
-
-	while (attention_list) {
-		last = attention_list;
-		attention_list = attention_list->next;
-		toi_kfree(6, last, sizeof(*last));
-	}
-}
-
-static int build_attention_list(void)
-{
-	int i, task_count = 0;
-	struct task_struct *p;
-	struct attention_list *next;
-
-	/*
-	 * Count all userspace process (with task->mm) marked PF_NOFREEZE.
-	 */
-	toi_read_lock_tasklist();
-	for_each_process(p)
-		if ((p->flags & PF_NOFREEZE) || p == current)
-			task_count++;
-	toi_read_unlock_tasklist();
-
-	/*
-	 * Allocate attention list structs.
-	 */
-	for (i = 0; i < task_count; i++) {
-		struct attention_list *this =
-			toi_kzalloc(6, sizeof(struct attention_list),
-					TOI_WAIT_GFP);
-		if (!this) {
-			printk(KERN_INFO "Failed to allocate slab for "
-					"attention list.\n");
-			free_attention_list();
-			return 1;
-		}
-		this->next = NULL;
-		if (attention_list)
-			this->next = attention_list;
-		attention_list = this;
-	}
-
-	next = attention_list;
-	toi_read_lock_tasklist();
-	for_each_process(p)
-		if ((p->flags & PF_NOFREEZE) || p == current) {
-			next->task = p;
-			next = next->next;
-		}
-	toi_read_unlock_tasklist();
-	return 0;
-}
-
-static void pageset2_full(void)
-{
-	struct zone *zone;
-	struct page *page;
-	unsigned long flags;
-	int i;
-
-        toi_trace_index++;
-
-	for_each_populated_zone(zone) {
-		spin_lock_irqsave(&zone->lru_lock, flags);
-		for_each_lru(i) {
-			if (!zone_page_state(zone, NR_LRU_BASE + i))
-				continue;
-
-			list_for_each_entry(page, &zone->lruvec.lists[i], lru) {
-				struct address_space *mapping;
-
-				mapping = page_mapping(page);
-				if (!mapping || !mapping->host ||
-				    !(mapping->host->i_flags & S_ATOMIC_COPY)) {
-                                    if (PageTOI_RO(page) && test_result_state(TOI_KEPT_IMAGE)) {
-                                        TOI_TRACE_DEBUG(page_to_pfn(page), "_Pageset2 unmodified.");
-                                    } else {
-                                        TOI_TRACE_DEBUG(page_to_pfn(page), "_Pageset2 pageset2_full.");
-                                        SetPagePageset2(page);
-                                    }
-                                }
-			}
-		}
-		spin_unlock_irqrestore(&zone->lru_lock, flags);
-	}
-}
-
-/*
- * toi_mark_task_as_pageset
- * Functionality   : Marks all the saveable pages belonging to a given process
- * 		     as belonging to a particular pageset.
- */
-
-static void toi_mark_task_as_pageset(struct task_struct *t, int pageset2)
-{
-	struct vm_area_struct *vma;
-	struct mm_struct *mm;
-
-	mm = t->active_mm;
-
-	if (!mm || !mm->mmap)
-		return;
-
-        toi_trace_index++;
-
-	if (!irqs_disabled())
-		down_read(&mm->mmap_sem);
-
-	for (vma = mm->mmap; vma; vma = vma->vm_next) {
-		unsigned long posn;
-
-		if (!vma->vm_start ||
-		    vma->vm_flags & VM_PFNMAP)
-			continue;
-
-		for (posn = vma->vm_start; posn < vma->vm_end;
-				posn += PAGE_SIZE) {
-			struct page *page = follow_page(vma, posn, 0);
-			struct address_space *mapping;
-
-			if (!page || !pfn_valid(page_to_pfn(page)))
-				continue;
-
-			mapping = page_mapping(page);
-			if (mapping && mapping->host &&
-			    mapping->host->i_flags & S_ATOMIC_COPY && pageset2)
-				continue;
-
-                        if (PageTOI_RO(page) && test_result_state(TOI_KEPT_IMAGE)) {
-                                TOI_TRACE_DEBUG(page_to_pfn(page), "_Unmodified %d", pageset2 ? 1 : 2);
-                                continue;
-                        }
-
-			if (pageset2) {
-                                TOI_TRACE_DEBUG(page_to_pfn(page), "_MarkTaskAsPageset 1");
-				SetPagePageset2(page);
-                        } else {
-                                TOI_TRACE_DEBUG(page_to_pfn(page), "_MarkTaskAsPageset 2");
-				ClearPagePageset2(page);
-				SetPagePageset1(page);
-			}
-		}
-	}
-
-	if (!irqs_disabled())
-		up_read(&mm->mmap_sem);
-}
-
-static void mark_tasks(int pageset)
-{
-	struct task_struct *p;
-
-	toi_read_lock_tasklist();
-	for_each_process(p) {
-		if (!p->mm)
-			continue;
-
-		if (p->flags & PF_KTHREAD)
-			continue;
-
-		toi_mark_task_as_pageset(p, pageset);
-	}
-	toi_read_unlock_tasklist();
-
-}
-
-/* mark_pages_for_pageset2
- *
- * Description:	Mark unshared pages in processes not needed for hibernate as
- * 		being able to be written out in a separate pagedir.
- * 		HighMem pages are simply marked as pageset2. They won't be
- * 		needed during hibernate.
- */
-
-static void toi_mark_pages_for_pageset2(void)
-{
-	struct attention_list *this = attention_list;
-
-	memory_bm_clear(pageset2_map);
-
-	if (test_action_state(TOI_NO_PAGESET2) || no_ps2_needed)
-		return;
-
-	if (test_action_state(TOI_PAGESET2_FULL))
-		pageset2_full();
-	else
-		mark_tasks(PAGESET2);
-
-	/*
-	 * Because the tasks in attention_list are ones related to hibernating,
-	 * we know that they won't go away under us.
-	 */
-
-	while (this) {
-		if (!test_result_state(TOI_ABORTED))
-			toi_mark_task_as_pageset(this->task, PAGESET1);
-		this = this->next;
-	}
-}
-
-/*
- * The atomic copy of pageset1 is stored in pageset2 pages.
- * But if pageset1 is larger (normally only just after boot),
- * we need to allocate extra pages to store the atomic copy.
- * The following data struct and functions are used to handle
- * the allocation and freeing of that memory.
- */
-
-static unsigned long extra_pages_allocated;
-
-struct extras {
-	struct page *page;
-	int order;
-	struct extras *next;
-};
-
-static struct extras *extras_list;
-
-/* toi_free_extra_pagedir_memory
- *
- * Description:	Free previously allocated extra pagedir memory.
- */
-void toi_free_extra_pagedir_memory(void)
-{
-	/* Free allocated pages */
-	while (extras_list) {
-		struct extras *this = extras_list;
-		int i;
-
-		extras_list = this->next;
-
-		for (i = 0; i < (1 << this->order); i++)
-			ClearPageNosave(this->page + i);
-
-		toi_free_pages(9, this->page, this->order);
-		toi_kfree(7, this, sizeof(*this));
-	}
-
-	extra_pages_allocated = 0;
-}
-
-/* toi_allocate_extra_pagedir_memory
- *
- * Description:	Allocate memory for making the atomic copy of pagedir1 in the
- * 		case where it is bigger than pagedir2.
- * Arguments:	int	num_to_alloc: Number of extra pages needed.
- * Result:	int. 	Number of extra pages we now have allocated.
- */
-static int toi_allocate_extra_pagedir_memory(int extra_pages_needed)
-{
-	int j, order, num_to_alloc = extra_pages_needed - extra_pages_allocated;
-	gfp_t flags = TOI_ATOMIC_GFP;
-
-	if (num_to_alloc < 1)
-		return 0;
-
-	order = fls(num_to_alloc);
-	if (order >= MAX_ORDER)
-		order = MAX_ORDER - 1;
-
-	while (num_to_alloc) {
-		struct page *newpage;
-		unsigned long virt;
-		struct extras *extras_entry;
-
-		while ((1 << order) > num_to_alloc)
-			order--;
-
-		extras_entry = (struct extras *) toi_kzalloc(7,
-			sizeof(struct extras), TOI_ATOMIC_GFP);
-
-		if (!extras_entry)
-			return extra_pages_allocated;
-
-		virt = toi_get_free_pages(9, flags, order);
-		while (!virt && order) {
-			order--;
-			virt = toi_get_free_pages(9, flags, order);
-		}
-
-		if (!virt) {
-			toi_kfree(7, extras_entry, sizeof(*extras_entry));
-			return extra_pages_allocated;
-		}
-
-		newpage = virt_to_page(virt);
-
-		extras_entry->page = newpage;
-		extras_entry->order = order;
-		extras_entry->next = extras_list;
-
-		extras_list = extras_entry;
-
-		for (j = 0; j < (1 << order); j++) {
-			SetPageNosave(newpage + j);
-			SetPagePageset1Copy(newpage + j);
-		}
-
-		extra_pages_allocated += (1 << order);
-		num_to_alloc -= (1 << order);
-	}
-
-	return extra_pages_allocated;
-}
-
-/*
- * real_nr_free_pages: Count pcp pages for a zone type or all zones
- * (-1 for all, otherwise zone_idx() result desired).
- */
-unsigned long real_nr_free_pages(unsigned long zone_idx_mask)
-{
-	struct zone *zone;
-	int result = 0, cpu;
-
-	/* PCP lists */
-	for_each_populated_zone(zone) {
-		if (!(zone_idx_mask & (1 << zone_idx(zone))))
-			continue;
-
-		for_each_online_cpu(cpu) {
-			struct per_cpu_pageset *pset =
-				per_cpu_ptr(zone->pageset, cpu);
-			struct per_cpu_pages *pcp = &pset->pcp;
-			result += pcp->count;
-		}
-
-		result += zone_page_state(zone, NR_FREE_PAGES);
-	}
-	return result;
-}
-
-/*
- * Discover how much extra memory will be required by the drivers
- * when they're asked to hibernate. We can then ensure that amount
- * of memory is available when we really want it.
- */
-static void get_extra_pd1_allowance(void)
-{
-	unsigned long orig_num_free = real_nr_free_pages(all_zones_mask), final;
-
-	toi_prepare_status(CLEAR_BAR, "Finding allowance for drivers.");
-
-	if (toi_go_atomic(PMSG_FREEZE, 1))
-		return;
-
-	final = real_nr_free_pages(all_zones_mask);
-	toi_end_atomic(ATOMIC_ALL_STEPS, 1, 0);
-
-	extra_pd1_pages_allowance = (orig_num_free > final) ?
-		orig_num_free - final + MIN_EXTRA_PAGES_ALLOWANCE :
-		MIN_EXTRA_PAGES_ALLOWANCE;
-}
-
-/*
- * Amount of storage needed, possibly taking into account the
- * expected compression ratio and possibly also ignoring our
- * allowance for extra pages.
- */
-static unsigned long main_storage_needed(int use_ecr,
-		int ignore_extra_pd1_allow)
-{
-	return (pagedir1.size + pagedir2.size +
-	  (ignore_extra_pd1_allow ? 0 : extra_pd1_pages_allowance)) *
-	 (use_ecr ? toi_expected_compression_ratio() : 100) / 100;
-}
-
-/*
- * Storage needed for the image header, in bytes until the return.
- */
-unsigned long get_header_storage_needed(void)
-{
-	unsigned long bytes = sizeof(struct toi_header) +
-			toi_header_storage_for_modules() +
-			toi_pageflags_space_needed() +
-			fs_info_space_needed();
-
-	return DIV_ROUND_UP(bytes, PAGE_SIZE);
-}
-
-/*
- * When freeing memory, pages from either pageset might be freed.
- *
- * When seeking to free memory to be able to hibernate, for every ps1 page
- * freed, we need 2 less pages for the atomic copy because there is one less
- * page to copy and one more page into which data can be copied.
- *
- * Freeing ps2 pages saves us nothing directly. No more memory is available
- * for the atomic copy. Indirectly, a ps1 page might be freed (slab?), but
- * that's too much work to figure out.
- *
- * => ps1_to_free functions
- *
- * Of course if we just want to reduce the image size, because of storage
- * limitations or an image size limit either ps will do.
- *
- * => any_to_free function
- */
-
-static unsigned long lowpages_usable_for_highmem_copy(void)
-{
-	unsigned long needed = get_lowmem_size(pagedir1) +
-			extra_pd1_pages_allowance + MIN_FREE_RAM +
-			toi_memory_for_modules(0),
-		available = get_lowmem_size(pagedir2) +
-			 real_nr_free_low_pages() + extra_pages_allocated;
-
-	return available > needed ? available - needed : 0;
-}
-
-static unsigned long highpages_ps1_to_free(void)
-{
-	unsigned long need = get_highmem_size(pagedir1),
-		      available = get_highmem_size(pagedir2) +
-			      real_nr_free_high_pages() +
-			      lowpages_usable_for_highmem_copy();
-
-	return need > available ? DIV_ROUND_UP(need - available, 2) : 0;
-}
-
-static unsigned long lowpages_ps1_to_free(void)
-{
-	unsigned long needed = get_lowmem_size(pagedir1) +
-			extra_pd1_pages_allowance + MIN_FREE_RAM +
-			toi_memory_for_modules(0),
-		available = get_lowmem_size(pagedir2) +
-			 real_nr_free_low_pages() + extra_pages_allocated;
-
-	return needed > available ? DIV_ROUND_UP(needed - available, 2) : 0;
-}
-
-static unsigned long current_image_size(void)
-{
-	return pagedir1.size + pagedir2.size + header_storage_needed;
-}
-
-static unsigned long storage_still_required(void)
-{
-	unsigned long needed = main_storage_needed(1, 1);
-	return needed > storage_limit ? needed - storage_limit : 0;
-}
-
-static unsigned long ram_still_required(void)
-{
-	unsigned long needed = MIN_FREE_RAM + toi_memory_for_modules(0) +
-		2 * extra_pd1_pages_allowance,
-		  available = real_nr_free_low_pages() + extra_pages_allocated;
-	return needed > available ? needed - available : 0;
-}
-
-unsigned long any_to_free(int use_image_size_limit)
-{
-	int use_soft_limit = use_image_size_limit && image_size_limit > 0;
-	unsigned long current_size = current_image_size(),
-		      soft_limit = use_soft_limit ? (image_size_limit << 8) : 0,
-		      to_free = use_soft_limit ? (current_size > soft_limit ?
-				      current_size - soft_limit : 0) : 0,
-		      storage_limit = storage_still_required(),
-		      ram_limit = ram_still_required(),
-		      first_max = max(to_free, storage_limit);
-
-	return max(first_max, ram_limit);
-}
-
-static int need_pageset2(void)
-{
-	return (real_nr_free_low_pages() + extra_pages_allocated -
-		2 * extra_pd1_pages_allowance - MIN_FREE_RAM -
-		 toi_memory_for_modules(0) - pagedir1.size) < pagedir2.size;
-}
-
-/* amount_needed
- *
- * Calculates the amount by which the image size needs to be reduced to meet
- * our constraints.
- */
-static unsigned long amount_needed(int use_image_size_limit)
-{
-	return max(highpages_ps1_to_free() + lowpages_ps1_to_free(),
-			any_to_free(use_image_size_limit));
-}
-
-static int image_not_ready(int use_image_size_limit)
-{
-	toi_message(TOI_EAT_MEMORY, TOI_LOW, 1,
-		"Amount still needed (%lu) > 0:%u,"
-		" Storage allocd: %lu < %lu: %u.\n",
-			amount_needed(use_image_size_limit),
-			(amount_needed(use_image_size_limit) > 0),
-			main_storage_allocated,
-			main_storage_needed(1, 1),
-			main_storage_allocated < main_storage_needed(1, 1));
-
-	toi_cond_pause(0, NULL);
-
-	return (amount_needed(use_image_size_limit) > 0) ||
-		 main_storage_allocated < main_storage_needed(1, 1);
-}
-
-static void display_failure_reason(int tries_exceeded)
-{
-	unsigned long storage_required = storage_still_required(),
-	    ram_required = ram_still_required(),
-	    high_ps1 = highpages_ps1_to_free(),
-	    low_ps1 = lowpages_ps1_to_free();
-
-	printk(KERN_INFO "Failed to prepare the image because...\n");
-
-	if (!storage_limit) {
-		printk(KERN_INFO "- You need some storage available to be "
-				"able to hibernate.\n");
-		return;
-	}
-
-	if (tries_exceeded)
-		printk(KERN_INFO "- The maximum number of iterations was "
-				"reached without successfully preparing the "
-				"image.\n");
-
-	if (storage_required) {
-		printk(KERN_INFO " - We need at least %lu pages of storage "
-				"(ignoring the header), but only have %lu.\n",
-				main_storage_needed(1, 1),
-				main_storage_allocated);
-		set_abort_result(TOI_INSUFFICIENT_STORAGE);
-	}
-
-	if (ram_required) {
-		printk(KERN_INFO " - We need %lu more free pages of low "
-				"memory.\n", ram_required);
-		printk(KERN_INFO "     Minimum free     : %8d\n", MIN_FREE_RAM);
-		printk(KERN_INFO "   + Reqd. by modules : %8lu\n",
-				toi_memory_for_modules(0));
-		printk(KERN_INFO "   + 2 * extra allow  : %8lu\n",
-				2 * extra_pd1_pages_allowance);
-		printk(KERN_INFO "   - Currently free   : %8lu\n",
-				real_nr_free_low_pages());
-		printk(KERN_INFO "   - Pages allocd     : %8lu\n",
-				extra_pages_allocated);
-		printk(KERN_INFO "                      : ========\n");
-		printk(KERN_INFO "     Still needed     : %8lu\n",
-				ram_required);
-
-		/* Print breakdown of memory needed for modules */
-		toi_memory_for_modules(1);
-		set_abort_result(TOI_UNABLE_TO_FREE_ENOUGH_MEMORY);
-	}
-
-	if (high_ps1) {
-		printk(KERN_INFO "- We need to free %lu highmem pageset 1 "
-				"pages.\n", high_ps1);
-		set_abort_result(TOI_UNABLE_TO_FREE_ENOUGH_MEMORY);
-	}
-
-	if (low_ps1) {
-		printk(KERN_INFO " - We need to free %ld lowmem pageset 1 "
-				"pages.\n", low_ps1);
-		set_abort_result(TOI_UNABLE_TO_FREE_ENOUGH_MEMORY);
-	}
-}
-
-static void display_stats(int always, int sub_extra_pd1_allow)
-{
-	char buffer[255];
-	snprintf(buffer, 254,
-		"Free:%lu(%lu). Sets:%lu(%lu),%lu(%lu). "
-		"Nosave:%lu-%lu=%lu. Storage:%lu/%lu(%lu=>%lu). "
-		"Needed:%lu,%lu,%lu(%u,%lu,%lu,%ld) (PS2:%s)\n",
-
-		/* Free */
-		real_nr_free_pages(all_zones_mask),
-		real_nr_free_low_pages(),
-
-		/* Sets */
-		pagedir1.size, pagedir1.size - get_highmem_size(pagedir1),
-		pagedir2.size, pagedir2.size - get_highmem_size(pagedir2),
-
-		/* Nosave */
-		num_nosave, extra_pages_allocated,
-		num_nosave - extra_pages_allocated,
-
-		/* Storage */
-		main_storage_allocated,
-		storage_limit,
-		main_storage_needed(1, sub_extra_pd1_allow),
-		main_storage_needed(1, 1),
-
-		/* Needed */
-		lowpages_ps1_to_free(), highpages_ps1_to_free(),
-		any_to_free(1),
-		MIN_FREE_RAM, toi_memory_for_modules(0),
-		extra_pd1_pages_allowance,
-		image_size_limit,
-
-		need_pageset2() ? "yes" : "no");
-
-	if (always)
-		printk("%s", buffer);
-	else
-		toi_message(TOI_EAT_MEMORY, TOI_MEDIUM, 1, buffer);
-}
-
-/* flag_image_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 void flag_image_pages(int atomic_copy)
-{
-	int num_free = 0, num_unmodified = 0;
-	unsigned long loop;
-	struct zone *zone;
-
-	pagedir1.size = 0;
-	pagedir2.size = 0;
-
-	set_highmem_size(pagedir1, 0);
-	set_highmem_size(pagedir2, 0);
-
-	num_nosave = 0;
-        toi_trace_index++;
-
-	memory_bm_clear(pageset1_map);
-
-	toi_generate_free_page_map();
-
-	/*
-	 * Pages not to be saved are marked Nosave irrespective of being
-	 * reserved.
-	 */
-	for_each_populated_zone(zone) {
-		int highmem = is_highmem(zone);
-
-		for (loop = 0; loop < zone->spanned_pages; loop++) {
-			unsigned long pfn = zone->zone_start_pfn + loop;
-			struct page *page;
-			int chunk_size;
-
-			if (!pfn_valid(pfn)) {
-                            TOI_TRACE_DEBUG(pfn, "_Flag Invalid");
-                            continue;
-                        }
-
-			chunk_size = toi_size_of_free_region(zone, pfn);
-			if (chunk_size) {
-                            unsigned long y;
-                            for (y = pfn; y < pfn + chunk_size; y++) {
-                                page = pfn_to_page(y);
-                                TOI_TRACE_DEBUG(y, "_Flag Free");
-                                ClearPagePageset1(page);
-                                ClearPagePageset2(page);
-                            }
-				num_free += chunk_size;
-				loop += chunk_size - 1;
-				continue;
-			}
-
-			page = pfn_to_page(pfn);
-
-			if (PageNosave(page)) {
-                            char *desc = PagePageset1Copy(page) ? "Pageset1Copy" : "NoSave";
-                            TOI_TRACE_DEBUG(pfn, "_Flag %s", desc);
-                            num_nosave++;
-                            continue;
-                        }
-
-			page = highmem ? saveable_highmem_page(zone, pfn) :
-				saveable_page(zone, pfn);
-
-			if (!page) {
-                                TOI_TRACE_DEBUG(pfn, "_Flag Nosave2");
-				num_nosave++;
-				continue;
-			}
-
-                        if (PageTOI_RO(page) && test_result_state(TOI_KEPT_IMAGE)) {
-                            TOI_TRACE_DEBUG(pfn, "_Unmodified");
-                            num_unmodified++;
-                            continue;
-                        }
-
-			if (PagePageset2(page)) {
-				pagedir2.size++;
-                                TOI_TRACE_DEBUG(pfn, "_Flag PS2");
-				if (PageHighMem(page))
-					inc_highmem_size(pagedir2);
-				else
-					SetPagePageset1Copy(page);
-				if (PageResave(page)) {
-					SetPagePageset1(page);
-					ClearPagePageset1Copy(page);
-					pagedir1.size++;
-					if (PageHighMem(page))
-						inc_highmem_size(pagedir1);
-				}
-			} else {
-				pagedir1.size++;
-                                TOI_TRACE_DEBUG(pfn, "_Flag PS1");
-				SetPagePageset1(page);
-				if (PageHighMem(page))
-					inc_highmem_size(pagedir1);
-			}
-		}
-	}
-
-	if (!atomic_copy)
-		toi_message(TOI_EAT_MEMORY, TOI_MEDIUM, 0,
-			"Count data pages: Set1 (%d) + Set2 (%d) + Nosave (%ld)"
-				    " + Unmodified (%d) + NumFree (%d) = %d.\n",
-			pagedir1.size, pagedir2.size, num_nosave, num_unmodified,
-                        num_free, pagedir1.size + pagedir2.size + num_nosave + num_free);
-}
-
-void toi_recalculate_image_contents(int atomic_copy)
-{
-	memory_bm_clear(pageset1_map);
-	if (!atomic_copy) {
-		unsigned long pfn;
-		memory_bm_position_reset(pageset2_map);
-		for (pfn = memory_bm_next_pfn(pageset2_map, 0);
-				pfn != BM_END_OF_MAP;
-				pfn = memory_bm_next_pfn(pageset2_map, 0))
-			ClearPagePageset1Copy(pfn_to_page(pfn));
-		/* Need to call this before getting pageset1_size! */
-		toi_mark_pages_for_pageset2();
-	}
-        memory_bm_position_reset(pageset2_map);
-	flag_image_pages(atomic_copy);
-
-	if (!atomic_copy) {
-		storage_limit = toiActiveAllocator->storage_available();
-		display_stats(0, 0);
-	}
-}
-
-int try_allocate_extra_memory(void)
-{
-	unsigned long wanted = pagedir1.size +  extra_pd1_pages_allowance -
-		get_lowmem_size(pagedir2);
-	if (wanted > extra_pages_allocated) {
-		unsigned long got = toi_allocate_extra_pagedir_memory(wanted);
-		if (wanted < got) {
-			toi_message(TOI_EAT_MEMORY, TOI_LOW, 1,
-				"Want %d extra pages for pageset1, got %d.\n",
-				wanted, got);
-			return 1;
-		}
-	}
-	return 0;
-}
-
-/* update_image
- *
- * Allocate [more] memory and storage for the image.
- */
-static void update_image(int ps2_recalc)
-{
-	int old_header_req;
-	unsigned long seek;
-
-	if (try_allocate_extra_memory())
-		return;
-
-	if (ps2_recalc)
-		goto recalc;
-
-	thaw_kernel_threads();
-
-	/*
-	 * 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.
-	 */
-
-	do {
-		int result;
-
-		old_header_req = header_storage_needed;
-		toiActiveAllocator->reserve_header_space(header_storage_needed);
-
-		/* How much storage is free with the reservation applied? */
-		storage_limit = toiActiveAllocator->storage_available();
-		seek = min(storage_limit, main_storage_needed(0, 0));
-
-		result = toiActiveAllocator->allocate_storage(seek);
-		if (result)
-			printk("Failed to allocate storage (%d).\n", result);
-
-		main_storage_allocated =
-			toiActiveAllocator->storage_allocated();
-
-		/* Need more header because more storage allocated? */
-		header_storage_needed = get_header_storage_needed();
-
-	} while (header_storage_needed > old_header_req);
-
-	if (freeze_kernel_threads())
-		set_abort_result(TOI_FREEZING_FAILED);
-
-recalc:
-	toi_recalculate_image_contents(0);
-}
-
-/* attempt_to_freeze
- *
- * Try to freeze processes.
- */
-
-static int attempt_to_freeze(void)
-{
-	int result;
-
-	/* Stop processes before checking again */
-	toi_prepare_status(CLEAR_BAR, "Freezing processes & syncing "
-			"filesystems.");
-	result = freeze_processes();
-
-	if (result)
-		set_abort_result(TOI_FREEZING_FAILED);
-
-	result = freeze_kernel_threads();
-
-	if (result)
-		set_abort_result(TOI_FREEZING_FAILED);
-
-	return result;
-}
-
-/* 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 void eat_memory(void)
-{
-	unsigned long amount_wanted = 0;
-	int 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.
-	 */
-
-	amount_wanted = amount_needed(1);
-
-	switch (image_size_limit) {
-	case -1: /* Don't eat any memory */
-		if (amount_wanted > 0) {
-			set_abort_result(TOI_WOULD_EAT_MEMORY);
-			return;
-		}
-		break;
-	case -2:  /* Free caches only */
-		drop_pagecache();
-		toi_recalculate_image_contents(0);
-		amount_wanted = amount_needed(1);
-		break;
-	default:
-		break;
-	}
-
-	if (amount_wanted > 0 && !test_result_state(TOI_ABORTED) &&
-			image_size_limit != -1) {
-		unsigned long request = amount_wanted;
-		unsigned long high_req = max(highpages_ps1_to_free(),
-				any_to_free(1));
-		unsigned long low_req = lowpages_ps1_to_free();
-		unsigned long got = 0;
-
-		toi_prepare_status(CLEAR_BAR,
-				"Seeking to free %ldMB of memory.",
-				MB(amount_wanted));
-
-		thaw_kernel_threads();
-
-		/*
-		 * Ask for too many because shrink_memory_mask doesn't
-		 * currently return enough most of the time.
-		 */
-		
-		if (low_req)
-			got = shrink_memory_mask(low_req, GFP_KERNEL);
-		if (high_req)
-			shrink_memory_mask(high_req - got, GFP_HIGHUSER);
-
-		did_eat_memory = 1;
-
-		toi_recalculate_image_contents(0);
-
-		amount_wanted = amount_needed(1);
-
-		printk(KERN_DEBUG "Asked shrink_memory_mask for %ld low pages &"
-				" %ld pages from anywhere, got %ld.\n",
-				high_req, low_req,
-				request - amount_wanted);
-
-		toi_cond_pause(0, NULL);
-
-		if (freeze_kernel_threads())
-			set_abort_result(TOI_FREEZING_FAILED);
-	}
-
-	if (did_eat_memory)
-		toi_recalculate_image_contents(0);
-}
-
-/* toi_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 modules tell
- *   us).
- * - Make sure that all dirty buffers are written out.
- */
-#define MAX_TRIES 2
-int toi_prepare_image(void)
-{
-	int result = 1, tries = 1;
-
-	main_storage_allocated = 0;
-	no_ps2_needed = 0;
-
-	if (attempt_to_freeze())
-		return 1;
-
-	lock_device_hotplug();
-	set_toi_state(TOI_DEVICE_HOTPLUG_LOCKED);
-
-	if (!extra_pd1_pages_allowance)
-		get_extra_pd1_allowance();
-
-	storage_limit = toiActiveAllocator->storage_available();
-
-	if (!storage_limit) {
-		printk(KERN_INFO "No storage available. Didn't try to prepare "
-				"an image.\n");
-		display_failure_reason(0);
-		set_abort_result(TOI_NOSTORAGE_AVAILABLE);
-		return 1;
-	}
-
-	if (build_attention_list()) {
-		abort_hibernate(TOI_UNABLE_TO_PREPARE_IMAGE,
-				"Unable to successfully prepare the image.\n");
-		return 1;
-	}
-
-	toi_recalculate_image_contents(0);
-
-	do {
-		toi_prepare_status(CLEAR_BAR,
-				"Preparing Image. Try %d.", tries);
-
-		eat_memory();
-
-		if (test_result_state(TOI_ABORTED))
-			break;
-
-		update_image(0);
-
-		tries++;
-
-	} while (image_not_ready(1) && tries <= MAX_TRIES &&
-			!test_result_state(TOI_ABORTED));
-
-	result = image_not_ready(0);
-
-        /* TODO: Handle case where need to remove existing image and resave
-         * instead of adding to incremental image. */
-
-	if (!test_result_state(TOI_ABORTED)) {
-		if (result) {
-			display_stats(1, 0);
-			display_failure_reason(tries > MAX_TRIES);
-			abort_hibernate(TOI_UNABLE_TO_PREPARE_IMAGE,
-				"Unable to successfully prepare the image.\n");
-		} else {
-			/* Pageset 2 needed? */
-			if (!need_pageset2() &&
-				  test_action_state(TOI_NO_PS2_IF_UNNEEDED)) {
-				no_ps2_needed = 1;
-				toi_recalculate_image_contents(0);
-				update_image(1);
-			}
-
-			toi_cond_pause(1, "Image preparation complete.");
-		}
-	}
-
-	return result ? result : allocate_checksum_pages();
-}