Change the kernel config for scenario test
[kvmfornfv.git] / kernel / kernel / power / suspend.c
1 /*
2  * kernel/power/suspend.c - Suspend to RAM and standby functionality.
3  *
4  * Copyright (c) 2003 Patrick Mochel
5  * Copyright (c) 2003 Open Source Development Lab
6  * Copyright (c) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
7  *
8  * This file is released under the GPLv2.
9  */
10
11 #include <linux/string.h>
12 #include <linux/delay.h>
13 #include <linux/errno.h>
14 #include <linux/init.h>
15 #include <linux/console.h>
16 #include <linux/cpu.h>
17 #include <linux/cpuidle.h>
18 #include <linux/syscalls.h>
19 #include <linux/gfp.h>
20 #include <linux/io.h>
21 #include <linux/kernel.h>
22 #include <linux/list.h>
23 #include <linux/mm.h>
24 #include <linux/slab.h>
25 #include <linux/export.h>
26 #include <linux/suspend.h>
27 #include <linux/syscore_ops.h>
28 #include <linux/ftrace.h>
29 #include <trace/events/power.h>
30 #include <linux/compiler.h>
31 #include <linux/moduleparam.h>
32
33 #include "power.h"
34
35 const char *pm_labels[] = { "mem", "standby", "freeze", NULL };
36 const char *pm_states[PM_SUSPEND_MAX];
37
38 unsigned int pm_suspend_global_flags;
39 EXPORT_SYMBOL_GPL(pm_suspend_global_flags);
40
41 static const struct platform_suspend_ops *suspend_ops;
42 static const struct platform_freeze_ops *freeze_ops;
43 static DECLARE_WAIT_QUEUE_HEAD(suspend_freeze_wait_head);
44
45 enum freeze_state __read_mostly suspend_freeze_state;
46 static DEFINE_SPINLOCK(suspend_freeze_lock);
47
48 void freeze_set_ops(const struct platform_freeze_ops *ops)
49 {
50         lock_system_sleep();
51         freeze_ops = ops;
52         unlock_system_sleep();
53 }
54
55 static void freeze_begin(void)
56 {
57         suspend_freeze_state = FREEZE_STATE_NONE;
58 }
59
60 static void freeze_enter(void)
61 {
62         spin_lock_irq(&suspend_freeze_lock);
63         if (pm_wakeup_pending())
64                 goto out;
65
66         suspend_freeze_state = FREEZE_STATE_ENTER;
67         spin_unlock_irq(&suspend_freeze_lock);
68
69         get_online_cpus();
70         cpuidle_resume();
71
72         /* Push all the CPUs into the idle loop. */
73         wake_up_all_idle_cpus();
74         pr_debug("PM: suspend-to-idle\n");
75         /* Make the current CPU wait so it can enter the idle loop too. */
76         wait_event(suspend_freeze_wait_head,
77                    suspend_freeze_state == FREEZE_STATE_WAKE);
78         pr_debug("PM: resume from suspend-to-idle\n");
79
80         cpuidle_pause();
81         put_online_cpus();
82
83         spin_lock_irq(&suspend_freeze_lock);
84
85  out:
86         suspend_freeze_state = FREEZE_STATE_NONE;
87         spin_unlock_irq(&suspend_freeze_lock);
88 }
89
90 void freeze_wake(void)
91 {
92         unsigned long flags;
93
94         spin_lock_irqsave(&suspend_freeze_lock, flags);
95         if (suspend_freeze_state > FREEZE_STATE_NONE) {
96                 suspend_freeze_state = FREEZE_STATE_WAKE;
97                 wake_up(&suspend_freeze_wait_head);
98         }
99         spin_unlock_irqrestore(&suspend_freeze_lock, flags);
100 }
101 EXPORT_SYMBOL_GPL(freeze_wake);
102
103 static bool valid_state(suspend_state_t state)
104 {
105         /*
106          * PM_SUSPEND_STANDBY and PM_SUSPEND_MEM states need low level
107          * support and need to be valid to the low level
108          * implementation, no valid callback implies that none are valid.
109          */
110         return suspend_ops && suspend_ops->valid && suspend_ops->valid(state);
111 }
112
113 /*
114  * If this is set, the "mem" label always corresponds to the deepest sleep state
115  * available, the "standby" label corresponds to the second deepest sleep state
116  * available (if any), and the "freeze" label corresponds to the remaining
117  * available sleep state (if there is one).
118  */
119 static bool relative_states;
120
121 static int __init sleep_states_setup(char *str)
122 {
123         relative_states = !strncmp(str, "1", 1);
124         pm_states[PM_SUSPEND_FREEZE] = pm_labels[relative_states ? 0 : 2];
125         return 1;
126 }
127
128 __setup("relative_sleep_states=", sleep_states_setup);
129
130 /**
131  * suspend_set_ops - Set the global suspend method table.
132  * @ops: Suspend operations to use.
133  */
134 void suspend_set_ops(const struct platform_suspend_ops *ops)
135 {
136         suspend_state_t i;
137         int j = 0;
138
139         lock_system_sleep();
140
141         suspend_ops = ops;
142         for (i = PM_SUSPEND_MEM; i >= PM_SUSPEND_STANDBY; i--)
143                 if (valid_state(i)) {
144                         pm_states[i] = pm_labels[j++];
145                 } else if (!relative_states) {
146                         pm_states[i] = NULL;
147                         j++;
148                 }
149
150         pm_states[PM_SUSPEND_FREEZE] = pm_labels[j];
151
152         unlock_system_sleep();
153 }
154 EXPORT_SYMBOL_GPL(suspend_set_ops);
155
156 /**
157  * suspend_valid_only_mem - Generic memory-only valid callback.
158  *
159  * Platform drivers that implement mem suspend only and only need to check for
160  * that in their .valid() callback can use this instead of rolling their own
161  * .valid() callback.
162  */
163 int suspend_valid_only_mem(suspend_state_t state)
164 {
165         return state == PM_SUSPEND_MEM;
166 }
167 EXPORT_SYMBOL_GPL(suspend_valid_only_mem);
168
169 static bool sleep_state_supported(suspend_state_t state)
170 {
171         return state == PM_SUSPEND_FREEZE || (suspend_ops && suspend_ops->enter);
172 }
173
174 static int platform_suspend_prepare(suspend_state_t state)
175 {
176         return state != PM_SUSPEND_FREEZE && suspend_ops->prepare ?
177                 suspend_ops->prepare() : 0;
178 }
179
180 static int platform_suspend_prepare_late(suspend_state_t state)
181 {
182         return state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->prepare ?
183                 freeze_ops->prepare() : 0;
184 }
185
186 static int platform_suspend_prepare_noirq(suspend_state_t state)
187 {
188         return state != PM_SUSPEND_FREEZE && suspend_ops->prepare_late ?
189                 suspend_ops->prepare_late() : 0;
190 }
191
192 static void platform_resume_noirq(suspend_state_t state)
193 {
194         if (state != PM_SUSPEND_FREEZE && suspend_ops->wake)
195                 suspend_ops->wake();
196 }
197
198 static void platform_resume_early(suspend_state_t state)
199 {
200         if (state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->restore)
201                 freeze_ops->restore();
202 }
203
204 static void platform_resume_finish(suspend_state_t state)
205 {
206         if (state != PM_SUSPEND_FREEZE && suspend_ops->finish)
207                 suspend_ops->finish();
208 }
209
210 static int platform_suspend_begin(suspend_state_t state)
211 {
212         if (state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->begin)
213                 return freeze_ops->begin();
214         else if (suspend_ops->begin)
215                 return suspend_ops->begin(state);
216         else
217                 return 0;
218 }
219
220 static void platform_resume_end(suspend_state_t state)
221 {
222         if (state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->end)
223                 freeze_ops->end();
224         else if (suspend_ops->end)
225                 suspend_ops->end();
226 }
227
228 static void platform_recover(suspend_state_t state)
229 {
230         if (state != PM_SUSPEND_FREEZE && suspend_ops->recover)
231                 suspend_ops->recover();
232 }
233
234 static bool platform_suspend_again(suspend_state_t state)
235 {
236         return state != PM_SUSPEND_FREEZE && suspend_ops->suspend_again ?
237                 suspend_ops->suspend_again() : false;
238 }
239
240 #ifdef CONFIG_PM_DEBUG
241 static unsigned int pm_test_delay = 5;
242 module_param(pm_test_delay, uint, 0644);
243 MODULE_PARM_DESC(pm_test_delay,
244                  "Number of seconds to wait before resuming from suspend test");
245 #endif
246
247 static int suspend_test(int level)
248 {
249 #ifdef CONFIG_PM_DEBUG
250         if (pm_test_level == level) {
251                 printk(KERN_INFO "suspend debug: Waiting for %d second(s).\n",
252                                 pm_test_delay);
253                 mdelay(pm_test_delay * 1000);
254                 return 1;
255         }
256 #endif /* !CONFIG_PM_DEBUG */
257         return 0;
258 }
259
260 /**
261  * suspend_prepare - Prepare for entering system sleep state.
262  *
263  * Common code run for every system sleep state that can be entered (except for
264  * hibernation).  Run suspend notifiers, allocate the "suspend" console and
265  * freeze processes.
266  */
267 static int suspend_prepare(suspend_state_t state)
268 {
269         int error;
270
271         if (!sleep_state_supported(state))
272                 return -EPERM;
273
274         pm_prepare_console();
275
276         error = pm_notifier_call_chain(PM_SUSPEND_PREPARE);
277         if (error)
278                 goto Finish;
279
280         trace_suspend_resume(TPS("freeze_processes"), 0, true);
281         error = suspend_freeze_processes();
282         trace_suspend_resume(TPS("freeze_processes"), 0, false);
283         if (!error)
284                 return 0;
285
286         suspend_stats.failed_freeze++;
287         dpm_save_failed_step(SUSPEND_FREEZE);
288  Finish:
289         pm_notifier_call_chain(PM_POST_SUSPEND);
290         pm_restore_console();
291         return error;
292 }
293
294 /* default implementation */
295 void __weak arch_suspend_disable_irqs(void)
296 {
297         local_irq_disable();
298 }
299
300 /* default implementation */
301 void __weak arch_suspend_enable_irqs(void)
302 {
303         local_irq_enable();
304 }
305
306 /**
307  * suspend_enter - Make the system enter the given sleep state.
308  * @state: System sleep state to enter.
309  * @wakeup: Returns information that the sleep state should not be re-entered.
310  *
311  * This function should be called after devices have been suspended.
312  */
313 static int suspend_enter(suspend_state_t state, bool *wakeup)
314 {
315         int error;
316
317         error = platform_suspend_prepare(state);
318         if (error)
319                 goto Platform_finish;
320
321         error = dpm_suspend_late(PMSG_SUSPEND);
322         if (error) {
323                 printk(KERN_ERR "PM: late suspend of devices failed\n");
324                 goto Platform_finish;
325         }
326         error = platform_suspend_prepare_late(state);
327         if (error)
328                 goto Devices_early_resume;
329
330         error = dpm_suspend_noirq(PMSG_SUSPEND);
331         if (error) {
332                 printk(KERN_ERR "PM: noirq suspend of devices failed\n");
333                 goto Platform_early_resume;
334         }
335         error = platform_suspend_prepare_noirq(state);
336         if (error)
337                 goto Platform_wake;
338
339         if (suspend_test(TEST_PLATFORM))
340                 goto Platform_wake;
341
342         /*
343          * PM_SUSPEND_FREEZE equals
344          * frozen processes + suspended devices + idle processors.
345          * Thus we should invoke freeze_enter() soon after
346          * all the devices are suspended.
347          */
348         if (state == PM_SUSPEND_FREEZE) {
349                 trace_suspend_resume(TPS("machine_suspend"), state, true);
350                 freeze_enter();
351                 trace_suspend_resume(TPS("machine_suspend"), state, false);
352                 goto Platform_wake;
353         }
354
355         error = disable_nonboot_cpus();
356         if (error || suspend_test(TEST_CPUS))
357                 goto Enable_cpus;
358
359         arch_suspend_disable_irqs();
360         BUG_ON(!irqs_disabled());
361
362         system_state = SYSTEM_SUSPEND;
363
364         error = syscore_suspend();
365         if (!error) {
366                 *wakeup = pm_wakeup_pending();
367                 if (!(suspend_test(TEST_CORE) || *wakeup)) {
368                         trace_suspend_resume(TPS("machine_suspend"),
369                                 state, true);
370                         error = suspend_ops->enter(state);
371                         trace_suspend_resume(TPS("machine_suspend"),
372                                 state, false);
373                         events_check_enabled = false;
374                 } else if (*wakeup) {
375                         error = -EBUSY;
376                 }
377                 syscore_resume();
378         }
379
380         system_state = SYSTEM_RUNNING;
381
382         arch_suspend_enable_irqs();
383         BUG_ON(irqs_disabled());
384
385  Enable_cpus:
386         enable_nonboot_cpus();
387
388  Platform_wake:
389         platform_resume_noirq(state);
390         dpm_resume_noirq(PMSG_RESUME);
391
392  Platform_early_resume:
393         platform_resume_early(state);
394
395  Devices_early_resume:
396         dpm_resume_early(PMSG_RESUME);
397
398  Platform_finish:
399         platform_resume_finish(state);
400         return error;
401 }
402
403 /**
404  * suspend_devices_and_enter - Suspend devices and enter system sleep state.
405  * @state: System sleep state to enter.
406  */
407 int suspend_devices_and_enter(suspend_state_t state)
408 {
409         int error;
410         bool wakeup = false;
411
412         if (!sleep_state_supported(state))
413                 return -ENOSYS;
414
415         error = platform_suspend_begin(state);
416         if (error)
417                 goto Close;
418
419         suspend_console();
420         suspend_test_start();
421         error = dpm_suspend_start(PMSG_SUSPEND);
422         if (error) {
423                 pr_err("PM: Some devices failed to suspend, or early wake event detected\n");
424                 goto Recover_platform;
425         }
426         suspend_test_finish("suspend devices");
427         if (suspend_test(TEST_DEVICES))
428                 goto Recover_platform;
429
430         do {
431                 error = suspend_enter(state, &wakeup);
432         } while (!error && !wakeup && platform_suspend_again(state));
433
434  Resume_devices:
435         suspend_test_start();
436         dpm_resume_end(PMSG_RESUME);
437         suspend_test_finish("resume devices");
438         trace_suspend_resume(TPS("resume_console"), state, true);
439         resume_console();
440         trace_suspend_resume(TPS("resume_console"), state, false);
441
442  Close:
443         platform_resume_end(state);
444         return error;
445
446  Recover_platform:
447         platform_recover(state);
448         goto Resume_devices;
449 }
450
451 /**
452  * suspend_finish - Clean up before finishing the suspend sequence.
453  *
454  * Call platform code to clean up, restart processes, and free the console that
455  * we've allocated. This routine is not called for hibernation.
456  */
457 static void suspend_finish(void)
458 {
459         suspend_thaw_processes();
460         pm_notifier_call_chain(PM_POST_SUSPEND);
461         pm_restore_console();
462 }
463
464 /**
465  * enter_state - Do common work needed to enter system sleep state.
466  * @state: System sleep state to enter.
467  *
468  * Make sure that no one else is trying to put the system into a sleep state.
469  * Fail if that's not the case.  Otherwise, prepare for system suspend, make the
470  * system enter the given sleep state and clean up after wakeup.
471  */
472 static int enter_state(suspend_state_t state)
473 {
474         int error;
475
476         trace_suspend_resume(TPS("suspend_enter"), state, true);
477         if (state == PM_SUSPEND_FREEZE) {
478 #ifdef CONFIG_PM_DEBUG
479                 if (pm_test_level != TEST_NONE && pm_test_level <= TEST_CPUS) {
480                         pr_warning("PM: Unsupported test mode for suspend to idle,"
481                                    "please choose none/freezer/devices/platform.\n");
482                         return -EAGAIN;
483                 }
484 #endif
485         } else if (!valid_state(state)) {
486                 return -EINVAL;
487         }
488         if (!mutex_trylock(&pm_mutex))
489                 return -EBUSY;
490
491         if (state == PM_SUSPEND_FREEZE)
492                 freeze_begin();
493
494 #ifndef CONFIG_SUSPEND_SKIP_SYNC
495         trace_suspend_resume(TPS("sync_filesystems"), 0, true);
496         printk(KERN_INFO "PM: Syncing filesystems ... ");
497         sys_sync();
498         printk("done.\n");
499         trace_suspend_resume(TPS("sync_filesystems"), 0, false);
500 #endif
501
502         pr_debug("PM: Preparing system for sleep (%s)\n", pm_states[state]);
503         pm_suspend_clear_flags();
504         error = suspend_prepare(state);
505         if (error)
506                 goto Unlock;
507
508         if (suspend_test(TEST_FREEZER))
509                 goto Finish;
510
511         trace_suspend_resume(TPS("suspend_enter"), state, false);
512         pr_debug("PM: Suspending system (%s)\n", pm_states[state]);
513         pm_restrict_gfp_mask();
514         error = suspend_devices_and_enter(state);
515         pm_restore_gfp_mask();
516
517  Finish:
518         pr_debug("PM: Finishing wakeup.\n");
519         suspend_finish();
520  Unlock:
521         mutex_unlock(&pm_mutex);
522         return error;
523 }
524
525 bool pm_in_action;
526
527 /**
528  * pm_suspend - Externally visible function for suspending the system.
529  * @state: System sleep state to enter.
530  *
531  * Check if the value of @state represents one of the supported states,
532  * execute enter_state() and update system suspend statistics.
533  */
534 int pm_suspend(suspend_state_t state)
535 {
536         int error;
537
538         if (state <= PM_SUSPEND_ON || state >= PM_SUSPEND_MAX)
539                 return -EINVAL;
540
541         pm_in_action = true;
542
543         error = enter_state(state);
544         if (error) {
545                 suspend_stats.fail++;
546                 dpm_save_failed_errno(error);
547         } else {
548                 suspend_stats.success++;
549         }
550         pm_in_action = false;
551         return error;
552 }
553 EXPORT_SYMBOL(pm_suspend);