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