PM/Hibernate: Fix waiting for image device to appear on resume
[linux-2.6.git] / 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 #include <linux/io.h>
55
56 #include "power.h"
57
58 /*
59  * Preferred image size in bytes (tunable via /sys/power/image_size).
60  * When it is set to N, swsusp will do its best to ensure the image
61  * size will not exceed N bytes, but if that is impossible, it will
62  * try to create the smallest image possible.
63  */
64 unsigned long image_size = 500 * 1024 * 1024;
65
66 int in_suspend __nosavedata = 0;
67
68 /**
69  *      The following functions are used for tracing the allocated
70  *      swap pages, so that they can be freed in case of an error.
71  */
72
73 struct swsusp_extent {
74         struct rb_node node;
75         unsigned long start;
76         unsigned long end;
77 };
78
79 static struct rb_root swsusp_extents = RB_ROOT;
80
81 static int swsusp_extents_insert(unsigned long swap_offset)
82 {
83         struct rb_node **new = &(swsusp_extents.rb_node);
84         struct rb_node *parent = NULL;
85         struct swsusp_extent *ext;
86
87         /* Figure out where to put the new node */
88         while (*new) {
89                 ext = container_of(*new, struct swsusp_extent, node);
90                 parent = *new;
91                 if (swap_offset < ext->start) {
92                         /* Try to merge */
93                         if (swap_offset == ext->start - 1) {
94                                 ext->start--;
95                                 return 0;
96                         }
97                         new = &((*new)->rb_left);
98                 } else if (swap_offset > ext->end) {
99                         /* Try to merge */
100                         if (swap_offset == ext->end + 1) {
101                                 ext->end++;
102                                 return 0;
103                         }
104                         new = &((*new)->rb_right);
105                 } else {
106                         /* It already is in the tree */
107                         return -EINVAL;
108                 }
109         }
110         /* Add the new node and rebalance the tree. */
111         ext = kzalloc(sizeof(struct swsusp_extent), GFP_KERNEL);
112         if (!ext)
113                 return -ENOMEM;
114
115         ext->start = swap_offset;
116         ext->end = swap_offset;
117         rb_link_node(&ext->node, parent, new);
118         rb_insert_color(&ext->node, &swsusp_extents);
119         return 0;
120 }
121
122 /**
123  *      alloc_swapdev_block - allocate a swap page and register that it has
124  *      been allocated, so that it can be freed in case of an error.
125  */
126
127 sector_t alloc_swapdev_block(int swap)
128 {
129         unsigned long offset;
130
131         offset = swp_offset(get_swap_page_of_type(swap));
132         if (offset) {
133                 if (swsusp_extents_insert(offset))
134                         swap_free(swp_entry(swap, offset));
135                 else
136                         return swapdev_block(swap, offset);
137         }
138         return 0;
139 }
140
141 /**
142  *      free_all_swap_pages - free swap pages allocated for saving image data.
143  *      It also frees the extents used to register which swap entres had been
144  *      allocated.
145  */
146
147 void free_all_swap_pages(int swap)
148 {
149         struct rb_node *node;
150
151         while ((node = swsusp_extents.rb_node)) {
152                 struct swsusp_extent *ext;
153                 unsigned long offset;
154
155                 ext = container_of(node, struct swsusp_extent, node);
156                 rb_erase(node, &swsusp_extents);
157                 for (offset = ext->start; offset <= ext->end; offset++)
158                         swap_free(swp_entry(swap, offset));
159
160                 kfree(ext);
161         }
162 }
163
164 int swsusp_swap_in_use(void)
165 {
166         return (swsusp_extents.rb_node != NULL);
167 }
168
169 /**
170  *      swsusp_show_speed - print the time elapsed between two events represented by
171  *      @start and @stop
172  *
173  *      @nr_pages -     number of pages processed between @start and @stop
174  *      @msg -          introductory message to print
175  */
176
177 void swsusp_show_speed(struct timeval *start, struct timeval *stop,
178                         unsigned nr_pages, char *msg)
179 {
180         s64 elapsed_centisecs64;
181         int centisecs;
182         int k;
183         int kps;
184
185         elapsed_centisecs64 = timeval_to_ns(stop) - timeval_to_ns(start);
186         do_div(elapsed_centisecs64, NSEC_PER_SEC / 100);
187         centisecs = elapsed_centisecs64;
188         if (centisecs == 0)
189                 centisecs = 1;  /* avoid div-by-zero */
190         k = nr_pages * (PAGE_SIZE / 1024);
191         kps = (k * 100) / centisecs;
192         printk(KERN_INFO "PM: %s %d kbytes in %d.%02d seconds (%d.%02d MB/s)\n",
193                         msg, k,
194                         centisecs / 100, centisecs % 100,
195                         kps / 1000, (kps % 1000) / 10);
196 }
197
198 /**
199  *      swsusp_shrink_memory -  Try to free as much memory as needed
200  *
201  *      ... but do not OOM-kill anyone
202  *
203  *      Notice: all userland should be stopped before it is called, or
204  *      livelock is possible.
205  */
206
207 #define SHRINK_BITE     10000
208 static inline unsigned long __shrink_memory(long tmp)
209 {
210         if (tmp > SHRINK_BITE)
211                 tmp = SHRINK_BITE;
212         return shrink_all_memory(tmp);
213 }
214
215 int swsusp_shrink_memory(void)
216 {
217         long tmp;
218         struct zone *zone;
219         unsigned long pages = 0;
220         unsigned int i = 0;
221         char *p = "-\\|/";
222         struct timeval start, stop;
223
224         printk(KERN_INFO "PM: Shrinking memory...  ");
225         do_gettimeofday(&start);
226         do {
227                 long size, highmem_size;
228
229                 highmem_size = count_highmem_pages();
230                 size = count_data_pages() + PAGES_FOR_IO + SPARE_PAGES;
231                 tmp = size;
232                 size += highmem_size;
233                 for_each_populated_zone(zone) {
234                         tmp += snapshot_additional_pages(zone);
235                         if (is_highmem(zone)) {
236                                 highmem_size -=
237                                         zone_page_state(zone, NR_FREE_PAGES);
238                         } else {
239                                 tmp -= zone_page_state(zone, NR_FREE_PAGES);
240                                 tmp += zone->lowmem_reserve[ZONE_NORMAL];
241                         }
242                 }
243
244                 if (highmem_size < 0)
245                         highmem_size = 0;
246
247                 tmp += highmem_size;
248                 if (tmp > 0) {
249                         tmp = __shrink_memory(tmp);
250                         if (!tmp)
251                                 return -ENOMEM;
252                         pages += tmp;
253                 } else if (size > image_size / PAGE_SIZE) {
254                         tmp = __shrink_memory(size - (image_size / PAGE_SIZE));
255                         pages += tmp;
256                 }
257                 printk("\b%c", p[i++%4]);
258         } while (tmp > 0);
259         do_gettimeofday(&stop);
260         printk("\bdone (%lu pages freed)\n", pages);
261         swsusp_show_speed(&start, &stop, pages, "Freed");
262
263         return 0;
264 }
265
266 /*
267  * Platforms, like ACPI, may want us to save some memory used by them during
268  * hibernation and to restore the contents of this memory during the subsequent
269  * resume.  The code below implements a mechanism allowing us to do that.
270  */
271
272 struct nvs_page {
273         unsigned long phys_start;
274         unsigned int size;
275         void *kaddr;
276         void *data;
277         struct list_head node;
278 };
279
280 static LIST_HEAD(nvs_list);
281
282 /**
283  *      hibernate_nvs_register - register platform NVS memory region to save
284  *      @start - physical address of the region
285  *      @size - size of the region
286  *
287  *      The NVS region need not be page-aligned (both ends) and we arrange
288  *      things so that the data from page-aligned addresses in this region will
289  *      be copied into separate RAM pages.
290  */
291 int hibernate_nvs_register(unsigned long start, unsigned long size)
292 {
293         struct nvs_page *entry, *next;
294
295         while (size > 0) {
296                 unsigned int nr_bytes;
297
298                 entry = kzalloc(sizeof(struct nvs_page), GFP_KERNEL);
299                 if (!entry)
300                         goto Error;
301
302                 list_add_tail(&entry->node, &nvs_list);
303                 entry->phys_start = start;
304                 nr_bytes = PAGE_SIZE - (start & ~PAGE_MASK);
305                 entry->size = (size < nr_bytes) ? size : nr_bytes;
306
307                 start += entry->size;
308                 size -= entry->size;
309         }
310         return 0;
311
312  Error:
313         list_for_each_entry_safe(entry, next, &nvs_list, node) {
314                 list_del(&entry->node);
315                 kfree(entry);
316         }
317         return -ENOMEM;
318 }
319
320 /**
321  *      hibernate_nvs_free - free data pages allocated for saving NVS regions
322  */
323 void hibernate_nvs_free(void)
324 {
325         struct nvs_page *entry;
326
327         list_for_each_entry(entry, &nvs_list, node)
328                 if (entry->data) {
329                         free_page((unsigned long)entry->data);
330                         entry->data = NULL;
331                         if (entry->kaddr) {
332                                 iounmap(entry->kaddr);
333                                 entry->kaddr = NULL;
334                         }
335                 }
336 }
337
338 /**
339  *      hibernate_nvs_alloc - allocate memory necessary for saving NVS regions
340  */
341 int hibernate_nvs_alloc(void)
342 {
343         struct nvs_page *entry;
344
345         list_for_each_entry(entry, &nvs_list, node) {
346                 entry->data = (void *)__get_free_page(GFP_KERNEL);
347                 if (!entry->data) {
348                         hibernate_nvs_free();
349                         return -ENOMEM;
350                 }
351         }
352         return 0;
353 }
354
355 /**
356  *      hibernate_nvs_save - save NVS memory regions
357  */
358 void hibernate_nvs_save(void)
359 {
360         struct nvs_page *entry;
361
362         printk(KERN_INFO "PM: Saving platform NVS memory\n");
363
364         list_for_each_entry(entry, &nvs_list, node)
365                 if (entry->data) {
366                         entry->kaddr = ioremap(entry->phys_start, entry->size);
367                         memcpy(entry->data, entry->kaddr, entry->size);
368                 }
369 }
370
371 /**
372  *      hibernate_nvs_restore - restore NVS memory regions
373  *
374  *      This function is going to be called with interrupts disabled, so it
375  *      cannot iounmap the virtual addresses used to access the NVS region.
376  */
377 void hibernate_nvs_restore(void)
378 {
379         struct nvs_page *entry;
380
381         printk(KERN_INFO "PM: Restoring platform NVS memory\n");
382
383         list_for_each_entry(entry, &nvs_list, node)
384                 if (entry->data)
385                         memcpy(entry->kaddr, entry->data, entry->size);
386 }