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 */ 63unsigned long image_size = 500 * 1024 * 1024; 64 65int in_suspend __nosavedata = 0; 66 67#ifdef CONFIG_HIGHMEM 68unsigned int count_highmem_pages(void); 69int restore_highmem(void); 70#else 71static inline int restore_highmem(void) { return 0; } 72static 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 80struct swsusp_extent { 81 struct rb_node node; 82 unsigned long start; 83 unsigned long end; 84}; 85 86static struct rb_root swsusp_extents = RB_ROOT; 87 88static 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 134sector_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 154void 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 171int 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 184void 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 214static 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 221int 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 273int swsusp_suspend(void) 274{ 275 int error; 276 277 if ((error = arch_prepare_suspend())) 278 return error; 279 280 local_irq_disable(); 281 /* At this point, device_suspend() has been called, but *not* 282 * device_power_down(). We *must* device_power_down() now. 283 * Otherwise, drivers for some devices (e.g. interrupt controllers) 284 * become desynchronized with the actual state of the hardware 285 * at resume time, and evil weirdness ensues. 286 */ 287 if ((error = device_power_down(PMSG_FREEZE))) { 288 printk(KERN_ERR "Some devices failed to power down, aborting suspend\n"); 289 goto Enable_irqs; 290 } 291 292 save_processor_state(); 293 if ((error = swsusp_arch_suspend())) 294 printk(KERN_ERR "Error %d suspending\n", error); 295 /* Restore control flow magically appears here */ 296 restore_processor_state(); 297 /* NOTE: device_power_up() is just a resume() for devices 298 * that suspended with irqs off ... no overall powerup. 299 */ 300 device_power_up(); 301 Enable_irqs: 302 local_irq_enable(); 303 return error; 304} 305 306int swsusp_resume(void) 307{ 308 int error; 309 310 local_irq_disable(); 311 /* NOTE: device_power_down() is just a suspend() with irqs off; 312 * it has no special "power things down" semantics 313 */ 314 if (device_power_down(PMSG_PRETHAW)) 315 printk(KERN_ERR "Some devices failed to power down, very bad\n"); 316 /* We'll ignore saved state, but this gets preempt count (etc) right */ 317 save_processor_state(); 318 error = restore_highmem(); 319 if (!error) { 320 error = swsusp_arch_resume(); 321 /* The code below is only ever reached in case of a failure. 322 * Otherwise execution continues at place where 323 * swsusp_arch_suspend() was called 324 */ 325 BUG_ON(!error); 326 /* This call to restore_highmem() undos the previous one */ 327 restore_highmem(); 328 } 329 /* The only reason why swsusp_arch_resume() can fail is memory being 330 * very tight, so we have to free it as soon as we can to avoid 331 * subsequent failures 332 */ 333 swsusp_free(); 334 restore_processor_state(); 335 touch_softlockup_watchdog(); 336 device_power_up(); 337 local_irq_enable(); 338 return error; 339} 340