Merge branch 'master' of /usr/src/ntfs-2.6/

1 files changed, 45 insertions, 531 deletions

diff --git a/kernel/power/swsusp.c b/kernel/power/swsusp.c
index 016504ccfccf..12db1d2ad61f 100644
--- a/kernel/power/swsusp.c
+++ b/kernel/power/swsusp.c
@@ -1,11 +1,10 @@
 /*
  * linux/kernel/power/swsusp.c
  *
- * This file is to realize architecture-independent
- * machine suspend feature using pretty near only high-level routines
+ * This file provides code to write suspend image to swap and read it back.
  *
  * Copyright (C) 1998-2001 Gabor Kuti <seasons@fornax.hu>
- * Copyright (C) 1998,2001-2004 Pavel Machek <pavel@suse.cz>
+ * Copyright (C) 1998,2001-2005 Pavel Machek <pavel@suse.cz>
  *
  * This file is released under the GPLv2.
  *
@@ -47,11 +46,7 @@
 #include <linux/utsname.h>
 #include <linux/version.h>
 #include <linux/delay.h>
-#include <linux/reboot.h>
 #include <linux/bitops.h>
-#include <linux/vt_kern.h>
-#include <linux/kbd_kern.h>
-#include <linux/keyboard.h>
 #include <linux/spinlock.h>
 #include <linux/genhd.h>
 #include <linux/kernel.h>
@@ -63,10 +58,8 @@
 #include <linux/swapops.h>
 #include <linux/bootmem.h>
 #include <linux/syscalls.h>
-#include <linux/console.h>
 #include <linux/highmem.h>
 #include <linux/bio.h>
-#include <linux/mount.h>
 
 #include <asm/uaccess.h>
 #include <asm/mmu_context.h>
@@ -84,16 +77,10 @@
 #define MAXKEY 32
 #define MAXIV  32
 
-/* References to section boundaries */
-extern const void __nosave_begin, __nosave_end;
-
-/* Variables to be preserved over suspend */
-static int nr_copy_pages_check;
-
 extern char resume_file[];
 
 /* Local variables that should not be affected by save */
-static unsigned int nr_copy_pages __nosavedata = 0;
+unsigned int nr_copy_pages __nosavedata = 0;
 
 /* Suspend pagedir is allocated before final copy, therefore it
    must be freed after resume
@@ -109,7 +96,7 @@ static unsigned int nr_copy_pages __nosavedata = 0;
    MMU hardware.
  */
 suspend_pagedir_t *pagedir_nosave __nosavedata = NULL;
-static suspend_pagedir_t *pagedir_save;
+suspend_pagedir_t *pagedir_save;
 
 #define SWSUSP_SIG      "S1SUSPEND"
 
@@ -124,12 +111,6 @@ static struct swsusp_header {
 static struct swsusp_info swsusp_info;
 
 /*
- * XXX: We try to keep some more pages free so that I/O operations succeed
- * without paging. Might this be more?
- */
-#define PAGES_FOR_IO    512
-
-/*
  * Saving part...
  */
 
@@ -552,353 +533,6 @@ static int write_suspend_image(void)
         goto Done;
 }
 
-
-#ifdef CONFIG_HIGHMEM
-struct highmem_page {
-        char *data;
-        struct page *page;
-        struct highmem_page *next;
-};
-
-static struct highmem_page *highmem_copy;
-
-static int save_highmem_zone(struct zone *zone)
-{
-        unsigned long zone_pfn;
-        mark_free_pages(zone);
-        for (zone_pfn = 0; zone_pfn < zone->spanned_pages; ++zone_pfn) {
-                struct page *page;
-                struct highmem_page *save;
-                void *kaddr;
-                unsigned long pfn = zone_pfn + zone->zone_start_pfn;
-
-                if (!(pfn%1000))
-                        printk(".");
-                if (!pfn_valid(pfn))
-                        continue;
-                page = pfn_to_page(pfn);
-                /*
-                 * PageReserved results from rvmalloc() sans vmalloc_32()
-                 * and architectural memory reservations.
-                 *
-                 * rvmalloc should not cause this, because all implementations
-                 * appear to always be using vmalloc_32 on architectures with
-                 * highmem. This is a good thing, because we would like to save
-                 * rvmalloc pages.
-                 *
-                 * It appears to be triggered by pages which do not point to
-                 * valid memory (see arch/i386/mm/init.c:one_highpage_init(),
-                 * which sets PageReserved if the page does not point to valid
-                 * RAM.
-                 *
-                 * XXX: must remove usage of PageReserved!
-                 */
-                if (PageReserved(page))
-                        continue;
-                BUG_ON(PageNosave(page));
-                if (PageNosaveFree(page))
-                        continue;
-                save = kmalloc(sizeof(struct highmem_page), GFP_ATOMIC);
-                if (!save)
-                        return -ENOMEM;
-                save->next = highmem_copy;
-                save->page = page;
-                save->data = (void *) get_zeroed_page(GFP_ATOMIC);
-                if (!save->data) {
-                        kfree(save);
-                        return -ENOMEM;
-                }
-                kaddr = kmap_atomic(page, KM_USER0);
-                memcpy(save->data, kaddr, PAGE_SIZE);
-                kunmap_atomic(kaddr, KM_USER0);
-                highmem_copy = save;
-        }
-        return 0;
-}
-#endif /* CONFIG_HIGHMEM */
-
-
-static int save_highmem(void)
-{
-#ifdef CONFIG_HIGHMEM
-        struct zone *zone;
-        int res = 0;
-
-        pr_debug("swsusp: Saving Highmem\n");
-        for_each_zone (zone) {
-                if (is_highmem(zone))
-                        res = save_highmem_zone(zone);
-                if (res)
-                        return res;
-        }
-#endif
-        return 0;
-}
-
-static int restore_highmem(void)
-{
-#ifdef CONFIG_HIGHMEM
-        printk("swsusp: Restoring Highmem\n");
-        while (highmem_copy) {
-                struct highmem_page *save = highmem_copy;
-                void *kaddr;
-                highmem_copy = save->next;
-
-                kaddr = kmap_atomic(save->page, KM_USER0);
-                memcpy(kaddr, save->data, PAGE_SIZE);
-                kunmap_atomic(kaddr, KM_USER0);
-                free_page((long) save->data);
-                kfree(save);
-        }
-#endif
-        return 0;
-}
-
-
-static int pfn_is_nosave(unsigned long pfn)
-{
-        unsigned long nosave_begin_pfn = __pa(&__nosave_begin) >> PAGE_SHIFT;
-        unsigned long nosave_end_pfn = PAGE_ALIGN(__pa(&__nosave_end)) >> PAGE_SHIFT;
-        return (pfn >= nosave_begin_pfn) && (pfn < nosave_end_pfn);
-}
-
-/**
- *      saveable - Determine whether a page should be cloned or not.
- *      @pfn:   The page
- *
- *      We save a page if it's Reserved, and not in the range of pages
- *      statically defined as 'unsaveable', or if it isn't reserved, and
- *      isn't part of a free chunk of pages.
- */
-
-static int saveable(struct zone * zone, unsigned long * zone_pfn)
-{
-        unsigned long pfn = *zone_pfn + zone->zone_start_pfn;
-        struct page * page;
-
-        if (!pfn_valid(pfn))
-                return 0;
-
-        page = pfn_to_page(pfn);
-        if (PageNosave(page))
-                return 0;
-        if (pfn_is_nosave(pfn)) {
-                pr_debug("[nosave pfn 0x%lx]", pfn);
-                return 0;
-        }
-        if (PageNosaveFree(page))
-                return 0;
-
-        return 1;
-}
-
-static void count_data_pages(void)
-{
-        struct zone *zone;
-        unsigned long zone_pfn;
-
-        nr_copy_pages = 0;
-
-        for_each_zone (zone) {
-                if (is_highmem(zone))
-                        continue;
-                mark_free_pages(zone);
-                for (zone_pfn = 0; zone_pfn < zone->spanned_pages; ++zone_pfn)
-                        nr_copy_pages += saveable(zone, &zone_pfn);
-        }
-}
-
-
-static void copy_data_pages(void)
-{
-        struct zone *zone;
-        unsigned long zone_pfn;
-        struct pbe * pbe = pagedir_nosave;
-
-        pr_debug("copy_data_pages(): pages to copy: %d\n", nr_copy_pages);
-        for_each_zone (zone) {
-                if (is_highmem(zone))
-                        continue;
-                mark_free_pages(zone);
-                for (zone_pfn = 0; zone_pfn < zone->spanned_pages; ++zone_pfn) {
-                        if (saveable(zone, &zone_pfn)) {
-                                struct page * page;
-                                page = pfn_to_page(zone_pfn + zone->zone_start_pfn);
-                                BUG_ON(!pbe);
-                                pbe->orig_address = (long) page_address(page);
-                                /* copy_page is not usable for copying task structs. */
-                                memcpy((void *)pbe->address, (void *)pbe->orig_address, PAGE_SIZE);
-                                pbe = pbe->next;
-                        }
-                }
-        }
-        BUG_ON(pbe);
-}
-
-
-/**
- *      calc_nr - Determine the number of pages needed for a pbe list.
- */
-
-static int calc_nr(int nr_copy)
-{
-        return nr_copy + (nr_copy+PBES_PER_PAGE-2)/(PBES_PER_PAGE-1);
-}
-
-/**
- *      free_pagedir - free pages allocated with alloc_pagedir()
- */
-
-static inline void free_pagedir(struct pbe *pblist)
-{
-        struct pbe *pbe;
-
-        while (pblist) {
-                pbe = (pblist + PB_PAGE_SKIP)->next;
-                free_page((unsigned long)pblist);
-                pblist = pbe;
-        }
-}
-
-/**
- *      fill_pb_page - Create a list of PBEs on a given memory page
- */
-
-static inline void fill_pb_page(struct pbe *pbpage)
-{
-        struct pbe *p;
-
-        p = pbpage;
-        pbpage += PB_PAGE_SKIP;
-        do
-                p->next = p + 1;
-        while (++p < pbpage);
-}
-
-/**
- *      create_pbe_list - Create a list of PBEs on top of a given chain
- *      of memory pages allocated with alloc_pagedir()
- */
-
-static void create_pbe_list(struct pbe *pblist, unsigned nr_pages)
-{
-        struct pbe *pbpage, *p;
-        unsigned num = PBES_PER_PAGE;
-
-        for_each_pb_page (pbpage, pblist) {
-                if (num >= nr_pages)
-                        break;
-
-                fill_pb_page(pbpage);
-                num += PBES_PER_PAGE;
-        }
-        if (pbpage) {
-                for (num -= PBES_PER_PAGE - 1, p = pbpage; num < nr_pages; p++, num++)
-                        p->next = p + 1;
-                p->next = NULL;
-        }
-        pr_debug("create_pbe_list(): initialized %d PBEs\n", num);
-}
-
-/**
- *      alloc_pagedir - Allocate the page directory.
- *
- *      First, determine exactly how many pages we need and
- *      allocate them.
- *
- *      We arrange the pages in a chain: each page is an array of PBES_PER_PAGE
- *      struct pbe elements (pbes) and the last element in the page points
- *      to the next page.
- *
- *      On each page we set up a list of struct_pbe elements.
- */
-
-static struct pbe * alloc_pagedir(unsigned nr_pages)
-{
-        unsigned num;
-        struct pbe *pblist, *pbe;
-
-        if (!nr_pages)
-                return NULL;
-
-        pr_debug("alloc_pagedir(): nr_pages = %d\n", nr_pages);
-        pblist = (struct pbe *)get_zeroed_page(GFP_ATOMIC | __GFP_COLD);
-        for (pbe = pblist, num = PBES_PER_PAGE; pbe && num < nr_pages;
-                        pbe = pbe->next, num += PBES_PER_PAGE) {
-                pbe += PB_PAGE_SKIP;
-                pbe->next = (struct pbe *)get_zeroed_page(GFP_ATOMIC | __GFP_COLD);
-        }
-        if (!pbe) { /* get_zeroed_page() failed */
-                free_pagedir(pblist);
-                pblist = NULL;
-        }
-        return pblist;
-}
-
-/**
- *      free_image_pages - Free pages allocated for snapshot
- */
-
-static void free_image_pages(void)
-{
-        struct pbe * p;
-
-        for_each_pbe (p, pagedir_save) {
-                if (p->address) {
-                        ClearPageNosave(virt_to_page(p->address));
-                        free_page(p->address);
-                        p->address = 0;
-                }
-        }
-}
-
-/**
- *      alloc_image_pages - Allocate pages for the snapshot.
- */
-
-static int alloc_image_pages(void)
-{
-        struct pbe * p;
-
-        for_each_pbe (p, pagedir_save) {
-                p->address = get_zeroed_page(GFP_ATOMIC | __GFP_COLD);
-                if (!p->address)
-                        return -ENOMEM;
-                SetPageNosave(virt_to_page(p->address));
-        }
-        return 0;
-}
-
-/* Free pages we allocated for suspend. Suspend pages are alocated
- * before atomic copy, so we need to free them after resume.
- */
-void swsusp_free(void)
-{
-        BUG_ON(PageNosave(virt_to_page(pagedir_save)));
-        BUG_ON(PageNosaveFree(virt_to_page(pagedir_save)));
-        free_image_pages();
-        free_pagedir(pagedir_save);
-}
-
-
-/**
- *      enough_free_mem - Make sure we enough free memory to snapshot.
- *
- *      Returns TRUE or FALSE after checking the number of available
- *      free pages.
- */
-
-static int enough_free_mem(void)
-{
-        if (nr_free_pages() < (nr_copy_pages + PAGES_FOR_IO)) {
-                pr_debug("swsusp: Not enough free pages: Have %d\n",
-                         nr_free_pages());
-                return 0;
-        }
-        return 1;
-}
-
-
 /**
  *      enough_swap - Make sure we have enough swap to save the image.
  *
@@ -909,87 +543,14 @@ static int enough_free_mem(void)
  *      We should only consider resume_device.
  */
 
-static int enough_swap(void)
+int enough_swap(unsigned nr_pages)
 {
         struct sysinfo i;
 
         si_swapinfo(&i);
-        if (i.freeswap < (nr_copy_pages + PAGES_FOR_IO))  {
-                pr_debug("swsusp: Not enough swap. Need %ld\n",i.freeswap);
-                return 0;
-        }
-        return 1;
-}
-
-static int swsusp_alloc(void)
-{
-        int error;
-
-        pagedir_nosave = NULL;
-        nr_copy_pages = calc_nr(nr_copy_pages);
-        nr_copy_pages_check = nr_copy_pages;
-
-        pr_debug("suspend: (pages needed: %d + %d free: %d)\n",
-                 nr_copy_pages, PAGES_FOR_IO, nr_free_pages());
-
-        if (!enough_free_mem())
-                return -ENOMEM;
-
-        if (!enough_swap())
-                return -ENOSPC;
-
-        if (MAX_PBES < nr_copy_pages / PBES_PER_PAGE +
-            !!(nr_copy_pages % PBES_PER_PAGE))
-                return -ENOSPC;
-
-        if (!(pagedir_save = alloc_pagedir(nr_copy_pages))) {
-                printk(KERN_ERR "suspend: Allocating pagedir failed.\n");
-                return -ENOMEM;
-        }
-        create_pbe_list(pagedir_save, nr_copy_pages);
-        pagedir_nosave = pagedir_save;
-        if ((error = alloc_image_pages())) {
-                printk(KERN_ERR "suspend: Allocating image pages failed.\n");
-                swsusp_free();
-                return error;
-        }
-
-        return 0;
-}
-
-static int suspend_prepare_image(void)
-{
-        int error;
-
-        pr_debug("swsusp: critical section: \n");
-        if (save_highmem()) {
-                printk(KERN_CRIT "Suspend machine: Not enough free pages for highmem\n");
-                restore_highmem();
-                return -ENOMEM;
-        }
-
-        drain_local_pages();
-        count_data_pages();
-        printk("swsusp: Need to copy %u pages\n", nr_copy_pages);
-
-        error = swsusp_alloc();
-        if (error)
-                return error;
-
-        /* During allocating of suspend pagedir, new cold pages may appear.
-         * Kill them.
-         */
-        drain_local_pages();
-        copy_data_pages();
-
-        /*
-         * End of critical section. From now on, we can write to memory,
-         * but we should not touch disk. This specially means we must _not_
-         * touch swap space! Except we must write out our image of course.
-         */
-
-        printk("swsusp: critical section/: done (%d pages copied)\n", nr_copy_pages );
-        return 0;
+        pr_debug("swsusp: available swap: %lu pages\n", i.freeswap);
+        return i.freeswap > (nr_pages + PAGES_FOR_IO +
+                (nr_pages + PBES_PER_PAGE - 1) / PBES_PER_PAGE);
 }
 
 
@@ -1001,7 +562,7 @@ static int suspend_prepare_image(void)
 int swsusp_write(void)
 {
         int error;
-        device_resume();
+
         lock_swapdevices();
         error = write_suspend_image();
         /* This will unlock ignored swap devices since writing is finished */
@@ -1011,14 +572,6 @@ int swsusp_write(void)
 }
 
 
-extern asmlinkage int swsusp_arch_suspend(void);
-extern asmlinkage int swsusp_arch_resume(void);
-
-
-asmlinkage int swsusp_save(void)
-{
-        return suspend_prepare_image();
-}
 
 int swsusp_suspend(void)
 {
@@ -1050,7 +603,6 @@ int swsusp_suspend(void)
                 printk(KERN_ERR "Error %d suspending\n", error);
         /* Restore control flow magically appears here */
         restore_processor_state();
-        BUG_ON (nr_copy_pages_check != nr_copy_pages);
         restore_highmem();
         device_power_up();
         local_irq_enable();
@@ -1070,6 +622,11 @@ int swsusp_resume(void)
          * execution continues at place where swsusp_arch_suspend was called
          */
         BUG_ON(!error);
+        /* The only reason why swsusp_arch_resume() can fail is memory being
+         * very tight, so we have to free it as soon as we can to avoid
+         * subsequent failures
+         */
+        swsusp_free();
         restore_processor_state();
         restore_highmem();
         touch_softlockup_watchdog();
@@ -1085,54 +642,28 @@ int swsusp_resume(void)
  *
  *      We don't know which pages are usable until we allocate them.
  *
- *      Allocated but unusable (ie eaten) memory pages are linked together
- *      to create a list, so that we can free them easily
- *
- *      We could have used a type other than (void *)
- *      for this purpose, but ...
+ *      Allocated but unusable (ie eaten) memory pages are marked so that
+ *      swsusp_free() can release them
  */
-static void **eaten_memory = NULL;
-
-static inline void eat_page(void *page)
-{
-        void **c;
-
-        c = eaten_memory;
-        eaten_memory = page;
-        *eaten_memory = c;
-}
 
-unsigned long get_usable_page(gfp_t gfp_mask)
+unsigned long get_safe_page(gfp_t gfp_mask)
 {
         unsigned long m;
 
-        m = get_zeroed_page(gfp_mask);
-        while (!PageNosaveFree(virt_to_page(m))) {
-                eat_page((void *)m);
+        do {
                 m = get_zeroed_page(gfp_mask);
-                if (!m)
-                        break;
+                if (m && PageNosaveFree(virt_to_page(m)))
+                        /* This is for swsusp_free() */
+                        SetPageNosave(virt_to_page(m));
+        } while (m && PageNosaveFree(virt_to_page(m)));
+        if (m) {
+                /* This is for swsusp_free() */
+                SetPageNosave(virt_to_page(m));
+                SetPageNosaveFree(virt_to_page(m));
         }
         return m;
 }
 
-void free_eaten_memory(void)
-{
-        unsigned long m;
-        void **c;
-        int i = 0;
-
-        c = eaten_memory;
-        while (c) {
-                m = (unsigned long)c;
-                c = *c;
-                free_page(m);
-                i++;
-        }
-        eaten_memory = NULL;
-        pr_debug("swsusp: %d unused pages freed\n", i);
-}
-
 /**
  *      check_pagedir - We ensure here that pages that the PBEs point to
  *      won't collide with pages where we're going to restore from the loaded
@@ -1150,7 +681,7 @@ static int check_pagedir(struct pbe *pblist)
                 p->address = 0UL;
 
         for_each_pbe (p, pblist) {
-                p->address = get_usable_page(GFP_ATOMIC);
+                p->address = get_safe_page(GFP_ATOMIC);
                 if (!p->address)
                         return -ENOMEM;
         }
@@ -1169,7 +700,7 @@ static struct pbe * swsusp_pagedir_relocate(struct pbe *pblist)
         unsigned long zone_pfn;
         struct pbe *pbpage, *tail, *p;
         void *m;
-        int rel = 0, error = 0;
+        int rel = 0;
 
         if (!pblist) /* a sanity check */
                 return NULL;
@@ -1177,41 +708,37 @@ static struct pbe * swsusp_pagedir_relocate(struct pbe *pblist)
         pr_debug("swsusp: Relocating pagedir (%lu pages to check)\n",
                         swsusp_info.pagedir_pages);
 
-        /* Set page flags */
+        /* Clear page flags */
 
         for_each_zone (zone) {
                 for (zone_pfn = 0; zone_pfn < zone->spanned_pages; ++zone_pfn)
-                        SetPageNosaveFree(pfn_to_page(zone_pfn +
+                        if (pfn_valid(zone_pfn + zone->zone_start_pfn))
+                                ClearPageNosaveFree(pfn_to_page(zone_pfn +
                                         zone->zone_start_pfn));
         }
 
-        /* Clear orig addresses */
+        /* Mark orig addresses */
 
         for_each_pbe (p, pblist)
-                ClearPageNosaveFree(virt_to_page(p->orig_address));
+                SetPageNosaveFree(virt_to_page(p->orig_address));
 
         tail = pblist + PB_PAGE_SKIP;
 
         /* Relocate colliding pages */
 
         for_each_pb_page (pbpage, pblist) {
-                if (!PageNosaveFree(virt_to_page((unsigned long)pbpage))) {
-                        m = (void *)get_usable_page(GFP_ATOMIC | __GFP_COLD);
-                        if (!m) {
-                                error = -ENOMEM;
-                                break;
-                        }
+                if (PageNosaveFree(virt_to_page((unsigned long)pbpage))) {
+                        m = (void *)get_safe_page(GFP_ATOMIC | __GFP_COLD);
+                        if (!m)
+                                return NULL;
                         memcpy(m, (void *)pbpage, PAGE_SIZE);
                         if (pbpage == pblist)
                                 pblist = (struct pbe *)m;
                         else
                                 tail->next = (struct pbe *)m;
-
-                        eat_page((void *)pbpage);
                         pbpage = (struct pbe *)m;
 
                         /* We have to link the PBEs again */
-
                         for (p = pbpage; p < pbpage + PB_PAGE_SKIP; p++)
                                 if (p->next) /* needed to save the end */
                                         p->next = p + 1;
@@ -1221,15 +748,13 @@ static struct pbe * swsusp_pagedir_relocate(struct pbe *pblist)
                 tail = pbpage + PB_PAGE_SKIP;
         }
 
-        if (error) {
-                printk("\nswsusp: Out of memory\n\n");
-                free_pagedir(pblist);
-                free_eaten_memory();
-                pblist = NULL;
-                /* Is this even worth handling? It should never ever happen, and we
-                   have just lost user's state, anyway... */
-        } else
-                printk("swsusp: Relocated %d pages\n", rel);
+        /* This is for swsusp_free() */
+        for_each_pb_page (pbpage, pblist) {
+                SetPageNosave(virt_to_page(pbpage));
+                SetPageNosaveFree(virt_to_page(pbpage));
+        }
+
+        printk("swsusp: Relocated %d pages\n", rel);
 
         return pblist;
 }
@@ -1447,9 +972,7 @@ static int read_pagedir(struct pbe *pblist)
                         break;
         }
 
-        if (error)
-                free_pagedir(pblist);
-        else
+        if (!error)
                 BUG_ON(i != swsusp_info.pagedir_pages);
 
         return error;
@@ -1492,15 +1015,6 @@ static int read_suspend_image(void)
         if (!error)
                 error = data_read(pagedir_nosave);
 
-        if (error) { /* We fail cleanly */
-                free_eaten_memory();
-                for_each_pbe (p, pagedir_nosave)
-                        if (p->address) {
-                                free_page(p->address);
-                                p->address = 0UL;
-                        }
-                free_pagedir(pagedir_nosave);
-        }
         return error;
 }