2 * linux/kernel/power/swsusp.c
4 * This file provides code to write suspend image to swap and read it back.
6 * Copyright (C) 1998-2001 Gabor Kuti <seasons@fornax.hu>
7 * Copyright (C) 1998,2001-2005 Pavel Machek <pavel@suse.cz>
9 * This file is released under the GPLv2.
11 * I'd like to thank the following people for their work:
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.
17 * Steve Doddi <dirk@loth.demon.co.uk>:
18 * Support the possibility of hardware state restoring.
20 * Raph <grey.havens@earthling.net>:
21 * Support for preserving states of network devices and virtual console
22 * (including X and svgatextmode)
24 * Kurt Garloff <garloff@suse.de>:
25 * Straightened the critical function in order to prevent compilers from
26 * playing tricks with local variables.
28 * Andreas Mohr <a.mohr@mailto.de>
30 * Alex Badea <vampire@go.ro>:
33 * Rafael J. Wysocki <rjw@sisk.pl>
34 * Reworked the freeing of memory and the handling of swap
36 * More state savers are welcome. Especially for the scsi layer...
38 * For TODOs,FIXMEs also look in Documentation/power/swsusp.txt
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>
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>
58 int in_suspend __nosavedata = 0;
61 * The following functions are used for tracing the allocated
62 * swap pages, so that they can be freed in case of an error.
65 struct swsusp_extent {
71 static struct rb_root swsusp_extents = RB_ROOT;
73 static int swsusp_extents_insert(unsigned long swap_offset)
75 struct rb_node **new = &(swsusp_extents.rb_node);
76 struct rb_node *parent = NULL;
77 struct swsusp_extent *ext;
79 /* Figure out where to put the new node */
81 ext = container_of(*new, struct swsusp_extent, node);
83 if (swap_offset < ext->start) {
85 if (swap_offset == ext->start - 1) {
89 new = &((*new)->rb_left);
90 } else if (swap_offset > ext->end) {
92 if (swap_offset == ext->end + 1) {
96 new = &((*new)->rb_right);
98 /* It already is in the tree */
102 /* Add the new node and rebalance the tree. */
103 ext = kzalloc(sizeof(struct swsusp_extent), GFP_KERNEL);
107 ext->start = swap_offset;
108 ext->end = swap_offset;
109 rb_link_node(&ext->node, parent, new);
110 rb_insert_color(&ext->node, &swsusp_extents);
115 * alloc_swapdev_block - allocate a swap page and register that it has
116 * been allocated, so that it can be freed in case of an error.
119 sector_t alloc_swapdev_block(int swap)
121 unsigned long offset;
123 offset = swp_offset(get_swap_page_of_type(swap));
125 if (swsusp_extents_insert(offset))
126 swap_free(swp_entry(swap, offset));
128 return swapdev_block(swap, offset);
134 * free_all_swap_pages - free swap pages allocated for saving image data.
135 * It also frees the extents used to register which swap entres had been
139 void free_all_swap_pages(int swap)
141 struct rb_node *node;
143 while ((node = swsusp_extents.rb_node)) {
144 struct swsusp_extent *ext;
145 unsigned long offset;
147 ext = container_of(node, struct swsusp_extent, node);
148 rb_erase(node, &swsusp_extents);
149 for (offset = ext->start; offset <= ext->end; offset++)
150 swap_free(swp_entry(swap, offset));
156 int swsusp_swap_in_use(void)
158 return (swsusp_extents.rb_node != NULL);
162 * swsusp_show_speed - print the time elapsed between two events represented by
165 * @nr_pages - number of pages processed between @start and @stop
166 * @msg - introductory message to print
169 void swsusp_show_speed(struct timeval *start, struct timeval *stop,
170 unsigned nr_pages, char *msg)
172 s64 elapsed_centisecs64;
177 elapsed_centisecs64 = timeval_to_ns(stop) - timeval_to_ns(start);
178 do_div(elapsed_centisecs64, NSEC_PER_SEC / 100);
179 centisecs = elapsed_centisecs64;
181 centisecs = 1; /* avoid div-by-zero */
182 k = nr_pages * (PAGE_SIZE / 1024);
183 kps = (k * 100) / centisecs;
184 printk(KERN_INFO "PM: %s %d kbytes in %d.%02d seconds (%d.%02d MB/s)\n",
186 centisecs / 100, centisecs % 100,
187 kps / 1000, (kps % 1000) / 10);
191 * Platforms, like ACPI, may want us to save some memory used by them during
192 * hibernation and to restore the contents of this memory during the subsequent
193 * resume. The code below implements a mechanism allowing us to do that.
197 unsigned long phys_start;
201 struct list_head node;
204 static LIST_HEAD(nvs_list);
207 * hibernate_nvs_register - register platform NVS memory region to save
208 * @start - physical address of the region
209 * @size - size of the region
211 * The NVS region need not be page-aligned (both ends) and we arrange
212 * things so that the data from page-aligned addresses in this region will
213 * be copied into separate RAM pages.
215 int hibernate_nvs_register(unsigned long start, unsigned long size)
217 struct nvs_page *entry, *next;
220 unsigned int nr_bytes;
222 entry = kzalloc(sizeof(struct nvs_page), GFP_KERNEL);
226 list_add_tail(&entry->node, &nvs_list);
227 entry->phys_start = start;
228 nr_bytes = PAGE_SIZE - (start & ~PAGE_MASK);
229 entry->size = (size < nr_bytes) ? size : nr_bytes;
231 start += entry->size;
237 list_for_each_entry_safe(entry, next, &nvs_list, node) {
238 list_del(&entry->node);
245 * hibernate_nvs_free - free data pages allocated for saving NVS regions
247 void hibernate_nvs_free(void)
249 struct nvs_page *entry;
251 list_for_each_entry(entry, &nvs_list, node)
253 free_page((unsigned long)entry->data);
256 iounmap(entry->kaddr);
263 * hibernate_nvs_alloc - allocate memory necessary for saving NVS regions
265 int hibernate_nvs_alloc(void)
267 struct nvs_page *entry;
269 list_for_each_entry(entry, &nvs_list, node) {
270 entry->data = (void *)__get_free_page(GFP_KERNEL);
272 hibernate_nvs_free();
280 * hibernate_nvs_save - save NVS memory regions
282 void hibernate_nvs_save(void)
284 struct nvs_page *entry;
286 printk(KERN_INFO "PM: Saving platform NVS memory\n");
288 list_for_each_entry(entry, &nvs_list, node)
290 entry->kaddr = ioremap(entry->phys_start, entry->size);
291 memcpy(entry->data, entry->kaddr, entry->size);
296 * hibernate_nvs_restore - restore NVS memory regions
298 * This function is going to be called with interrupts disabled, so it
299 * cannot iounmap the virtual addresses used to access the NVS region.
301 void hibernate_nvs_restore(void)
303 struct nvs_page *entry;
305 printk(KERN_INFO "PM: Restoring platform NVS memory\n");
307 list_for_each_entry(entry, &nvs_list, node)
309 memcpy(entry->kaddr, entry->data, entry->size);