kernel/power/swsusp.c

   1 /*
   2  * linux/kernel/power/swsusp.c
   3  *
   4  * This file provides code to write suspend image to swap and read it back.
   5  *
   6  * Copyright (C) 1998-2001 Gabor Kuti <seasons@fornax.hu>
   7  * Copyright (C) 1998,2001-2005 Pavel Machek <pavel@suse.cz>
   8  *
   9  * This file is released under the GPLv2.
  10  *
  11  * I'd like to thank the following people for their work:
  12  *
  13  * Pavel Machek <pavel@ucw.cz>:
  14  * Modifications, defectiveness pointing, being with me at the very beginning,
  15  * suspend to swap space, stop all tasks. Port to 2.4.18-ac and 2.5.17.
  16  *
  17  * Steve Doddi <dirk@loth.demon.co.uk>:
  18  * Support the possibility of hardware state restoring.
  19  *
  20  * Raph <grey.havens@earthling.net>:
  21  * Support for preserving states of network devices and virtual console
  22  * (including X and svgatextmode)
  23  *
  24  * Kurt Garloff <garloff@suse.de>:
  25  * Straightened the critical function in order to prevent compilers from
  26  * playing tricks with local variables.
  27  *
  28  * Andreas Mohr <a.mohr@mailto.de>
  29  *
  30  * Alex Badea <vampire@go.ro>:
  31  * Fixed runaway init
  32  *
  33  * Rafael J. Wysocki <rjw@sisk.pl>
  34  * Reworked the freeing of memory and the handling of swap
  35  *
  36  * More state savers are welcome. Especially for the scsi layer...
  37  *
  38  * For TODOs,FIXMEs also look in Documentation/power/swsusp.txt
  39  */
  40
  41 #include <linux/mm.h>
  42 #include <linux/suspend.h>
  43 #include <linux/spinlock.h>
  44 #include <linux/kernel.h>
  45 #include <linux/major.h>
  46 #include <linux/swap.h>
  47 #include <linux/pm.h>
  48 #include <linux/swapops.h>
  49 #include <linux/bootmem.h>
  50 #include <linux/syscalls.h>
  51 #include <linux/highmem.h>
  52 #include <linux/time.h>
  53 #include <linux/rbtree.h>
  54
  55 #include "power.h"
  56
  57 /*
  58  * Preferred image size in bytes (tunable via /sys/power/image_size).
  59  * When it is set to N, swsusp will do its best to ensure the image
  60  * size will not exceed N bytes, but if that is impossible, it will
  61  * try to create the smallest image possible.
  62  */
  63 unsigned long image_size = 500 * 1024 * 1024;
  64
  65 int in_suspend __nosavedata = 0;
  66
  67 #ifdef CONFIG_HIGHMEM
  68 unsigned int count_highmem_pages(void);
  69 int restore_highmem(void);
  70 #else
  71 static inline int restore_highmem(void) { return 0; }
  72 static inline unsigned int count_highmem_pages(void) { return 0; }
  73 #endif
  74
  75 /**
  76  *      The following functions are used for tracing the allocated
  77  *      swap pages, so that they can be freed in case of an error.
  78  */
  79
  80 struct swsusp_extent {
  81         struct rb_node node;
  82         unsigned long start;
  83         unsigned long end;
  84 };
  85
  86 static struct rb_root swsusp_extents = RB_ROOT;
  87
  88 static int swsusp_extents_insert(unsigned long swap_offset)
  89 {
  90         struct rb_node **new = &(swsusp_extents.rb_node);
  91         struct rb_node *parent = NULL;
  92         struct swsusp_extent *ext;
  93
  94         /* Figure out where to put the new node */
  95         while (*new) {
  96                 ext = container_of(*new, struct swsusp_extent, node);
  97                 parent = *new;
  98                 if (swap_offset < ext->start) {
  99                         /* Try to merge */
 100                         if (swap_offset == ext->start - 1) {
 101                                 ext->start--;
 102                                 return 0;
 103                         }
 104                         new = &((*new)->rb_left);
 105                 } else if (swap_offset > ext->end) {
 106                         /* Try to merge */
 107                         if (swap_offset == ext->end + 1) {
 108                                 ext->end++;
 109                                 return 0;
 110                         }
 111                         new = &((*new)->rb_right);
 112                 } else {
 113                         /* It already is in the tree */
 114                         return -EINVAL;
 115                 }
 116         }
 117         /* Add the new node and rebalance the tree. */
 118         ext = kzalloc(sizeof(struct swsusp_extent), GFP_KERNEL);
 119         if (!ext)
 120                 return -ENOMEM;
 121
 122         ext->start = swap_offset;
 123         ext->end = swap_offset;
 124         rb_link_node(&ext->node, parent, new);
 125         rb_insert_color(&ext->node, &swsusp_extents);
 126         return 0;
 127 }
 128
 129 /**
 130  *      alloc_swapdev_block - allocate a swap page and register that it has
 131  *      been allocated, so that it can be freed in case of an error.
 132  */
 133
 134 sector_t alloc_swapdev_block(int swap)
 135 {
 136         unsigned long offset;
 137
 138         offset = swp_offset(get_swap_page_of_type(swap));
 139         if (offset) {
 140                 if (swsusp_extents_insert(offset))
 141                         swap_free(swp_entry(swap, offset));
 142                 else
 143                         return swapdev_block(swap, offset);
 144         }
 145         return 0;
 146 }
 147
 148 /**
 149  *      free_all_swap_pages - free swap pages allocated for saving image data.
 150  *      It also frees the extents used to register which swap entres had been
 151  *      allocated.
 152  */
 153
 154 void free_all_swap_pages(int swap)
 155 {
 156         struct rb_node *node;
 157
 158         while ((node = swsusp_extents.rb_node)) {
 159                 struct swsusp_extent *ext;
 160                 unsigned long offset;
 161
 162                 ext = container_of(node, struct swsusp_extent, node);
 163                 rb_erase(node, &swsusp_extents);
 164                 for (offset = ext->start; offset <= ext->end; offset++)
 165                         swap_free(swp_entry(swap, offset));
 166
 167                 kfree(ext);
 168         }
 169 }
 170
 171 int swsusp_swap_in_use(void)
 172 {
 173         return (swsusp_extents.rb_node != NULL);
 174 }
 175
 176 /**
 177  *      swsusp_show_speed - print the time elapsed between two events represented by
 178  *      @start and @stop
 179  *
 180  *      @nr_pages -     number of pages processed between @start and @stop
 181  *      @msg -          introductory message to print
 182  */
 183
 184 void swsusp_show_speed(struct timeval *start, struct timeval *stop,
 185                         unsigned nr_pages, char *msg)
 186 {
 187         s64 elapsed_centisecs64;
 188         int centisecs;
 189         int k;
 190         int kps;
 191
 192         elapsed_centisecs64 = timeval_to_ns(stop) - timeval_to_ns(start);
 193         do_div(elapsed_centisecs64, NSEC_PER_SEC / 100);
 194         centisecs = elapsed_centisecs64;
 195         if (centisecs == 0)
 196                 centisecs = 1;  /* avoid div-by-zero */
 197         k = nr_pages * (PAGE_SIZE / 1024);
 198         kps = (k * 100) / centisecs;
 199         printk("%s %d kbytes in %d.%02d seconds (%d.%02d MB/s)\n", msg, k,
 200                         centisecs / 100, centisecs % 100,
 201                         kps / 1000, (kps % 1000) / 10);
 202 }
 203
 204 /**
 205  *      swsusp_shrink_memory -  Try to free as much memory as needed
 206  *
 207  *      ... but do not OOM-kill anyone
 208  *
 209  *      Notice: all userland should be stopped before it is called, or
 210  *      livelock is possible.
 211  */
 212
 213 #define SHRINK_BITE     10000
 214 static inline unsigned long __shrink_memory(long tmp)
 215 {
 216         if (tmp > SHRINK_BITE)
 217                 tmp = SHRINK_BITE;
 218         return shrink_all_memory(tmp);
 219 }
 220
 221 int swsusp_shrink_memory(void)
 222 {
 223         long tmp;
 224         struct zone *zone;
 225         unsigned long pages = 0;
 226         unsigned int i = 0;
 227         char *p = "-\\|/";
 228         struct timeval start, stop;
 229
 230         printk("Shrinking memory...  ");
 231         do_gettimeofday(&start);
 232         do {
 233                 long size, highmem_size;
 234
 235                 highmem_size = count_highmem_pages();
 236                 size = count_data_pages() + PAGES_FOR_IO + SPARE_PAGES;
 237                 tmp = size;
 238                 size += highmem_size;
 239                 for_each_zone (zone)
 240                         if (populated_zone(zone)) {
 241                                 tmp += snapshot_additional_pages(zone);
 242                                 if (is_highmem(zone)) {
 243                                         highmem_size -=
 244                                         zone_page_state(zone, NR_FREE_PAGES);
 245                                 } else {
 246                                         tmp -= zone_page_state(zone, NR_FREE_PAGES);
 247                                         tmp += zone->lowmem_reserve[ZONE_NORMAL];
 248                                 }
 249                         }
 250
 251                 if (highmem_size < 0)
 252                         highmem_size = 0;
 253
 254                 tmp += highmem_size;
 255                 if (tmp > 0) {
 256                         tmp = __shrink_memory(tmp);
 257                         if (!tmp)
 258                                 return -ENOMEM;
 259                         pages += tmp;
 260                 } else if (size > image_size / PAGE_SIZE) {
 261                         tmp = __shrink_memory(size - (image_size / PAGE_SIZE));
 262                         pages += tmp;
 263                 }
 264                 printk("\b%c", p[i++%4]);
 265         } while (tmp > 0);
 266         do_gettimeofday(&stop);
 267         printk("\bdone (%lu pages freed)\n", pages);
 268         swsusp_show_speed(&start, &stop, pages, "Freed");
 269
 270         return 0;
 271 }
 272
 273 int swsusp_resume(void)
 274 {
 275         int error;
 276
 277         local_irq_disable();
 278         /* NOTE:  device_power_down() is just a suspend() with irqs off;
 279          * it has no special "power things down" semantics
 280          */
 281         if (device_power_down(PMSG_PRETHAW))
 282                 printk(KERN_ERR "Some devices failed to power down, very bad\n");
 283         /* We'll ignore saved state, but this gets preempt count (etc) right */
 284         save_processor_state();
 285         error = restore_highmem();
 286         if (!error) {
 287                 error = swsusp_arch_resume();
 288                 /* The code below is only ever reached in case of a failure.
 289                  * Otherwise execution continues at place where
 290                  * swsusp_arch_suspend() was called
 291                  */
 292                 BUG_ON(!error);
 293                 /* This call to restore_highmem() undos the previous one */
 294                 restore_highmem();
 295         }
 296         /* The only reason why swsusp_arch_resume() can fail is memory being
 297          * very tight, so we have to free it as soon as we can to avoid
 298          * subsequent failures
 299          */
 300         swsusp_free();
 301         restore_processor_state();
 302         touch_softlockup_watchdog();
 303         device_power_up();
 304         local_irq_enable();
 305         return error;
 306 }