1 // SPDX-License-Identifier: GPL-2.0-only <<
2 /* 1 /*
3 * kernel/power/hibernate.c - Hibernation (a.k 2 * kernel/power/hibernate.c - Hibernation (a.k.a suspend-to-disk) support.
4 * 3 *
5 * Copyright (c) 2003 Patrick Mochel 4 * Copyright (c) 2003 Patrick Mochel
6 * Copyright (c) 2003 Open Source Development 5 * Copyright (c) 2003 Open Source Development Lab
7 * Copyright (c) 2004 Pavel Machek <pavel@ucw. !! 6 * Copyright (c) 2004 Pavel Machek <pavel@suse.cz>
8 * Copyright (c) 2009 Rafael J. Wysocki, Novel 7 * Copyright (c) 2009 Rafael J. Wysocki, Novell Inc.
9 * Copyright (C) 2012 Bojan Smojver <bojan@rex !! 8 *
>> 9 * This file is released under the GPLv2.
10 */ 10 */
11 11
12 #define pr_fmt(fmt) "PM: hibernation: " fmt <<
13 <<
14 #include <linux/blkdev.h> <<
15 #include <linux/export.h> <<
16 #include <linux/suspend.h> 12 #include <linux/suspend.h>
>> 13 #include <linux/syscalls.h>
17 #include <linux/reboot.h> 14 #include <linux/reboot.h>
18 #include <linux/string.h> 15 #include <linux/string.h>
19 #include <linux/device.h> 16 #include <linux/device.h>
20 #include <linux/async.h> !! 17 #include <linux/kmod.h>
21 #include <linux/delay.h> 18 #include <linux/delay.h>
22 #include <linux/fs.h> 19 #include <linux/fs.h>
23 #include <linux/mount.h> 20 #include <linux/mount.h>
24 #include <linux/pm.h> 21 #include <linux/pm.h>
25 #include <linux/nmi.h> <<
26 #include <linux/console.h> 22 #include <linux/console.h>
27 #include <linux/cpu.h> 23 #include <linux/cpu.h>
28 #include <linux/freezer.h> 24 #include <linux/freezer.h>
29 #include <linux/gfp.h> !! 25 #include <scsi/scsi_scan.h>
30 #include <linux/syscore_ops.h> !! 26 #include <asm/suspend.h>
31 #include <linux/ctype.h> <<
32 #include <linux/ktime.h> <<
33 #include <linux/security.h> <<
34 #include <linux/secretmem.h> <<
35 #include <trace/events/power.h> <<
36 27
37 #include "power.h" 28 #include "power.h"
38 29
39 30
40 static int nocompress; !! 31 static int noresume = 0;
41 static int noresume; <<
42 static int nohibernate; <<
43 static int resume_wait; <<
44 static unsigned int resume_delay; <<
45 static char resume_file[256] = CONFIG_PM_STD_P 32 static char resume_file[256] = CONFIG_PM_STD_PARTITION;
46 dev_t swsusp_resume_device; 33 dev_t swsusp_resume_device;
47 sector_t swsusp_resume_block; 34 sector_t swsusp_resume_block;
48 __visible int in_suspend __nosavedata; <<
49 <<
50 static char hibernate_compressor[CRYPTO_MAX_AL <<
51 <<
52 /* <<
53 * Compression/decompression algorithm to be u <<
54 * image to/from disk. This would later be use <<
55 * to allocate comp streams. <<
56 */ <<
57 char hib_comp_algo[CRYPTO_MAX_ALG_NAME]; <<
58 35
59 enum { 36 enum {
60 HIBERNATION_INVALID, 37 HIBERNATION_INVALID,
61 HIBERNATION_PLATFORM, 38 HIBERNATION_PLATFORM,
>> 39 HIBERNATION_TEST,
>> 40 HIBERNATION_TESTPROC,
62 HIBERNATION_SHUTDOWN, 41 HIBERNATION_SHUTDOWN,
63 HIBERNATION_REBOOT, 42 HIBERNATION_REBOOT,
64 #ifdef CONFIG_SUSPEND <<
65 HIBERNATION_SUSPEND, <<
66 #endif <<
67 HIBERNATION_TEST_RESUME, <<
68 /* keep last */ 43 /* keep last */
69 __HIBERNATION_AFTER_LAST 44 __HIBERNATION_AFTER_LAST
70 }; 45 };
71 #define HIBERNATION_MAX (__HIBERNATION_AFTER_L 46 #define HIBERNATION_MAX (__HIBERNATION_AFTER_LAST-1)
72 #define HIBERNATION_FIRST (HIBERNATION_INVALID 47 #define HIBERNATION_FIRST (HIBERNATION_INVALID + 1)
73 48
74 static int hibernation_mode = HIBERNATION_SHUT 49 static int hibernation_mode = HIBERNATION_SHUTDOWN;
75 50
76 bool freezer_test_done; !! 51 static struct platform_hibernation_ops *hibernation_ops;
77 <<
78 static const struct platform_hibernation_ops * <<
79 <<
80 static atomic_t hibernate_atomic = ATOMIC_INIT <<
81 <<
82 bool hibernate_acquire(void) <<
83 { <<
84 return atomic_add_unless(&hibernate_at <<
85 } <<
86 <<
87 void hibernate_release(void) <<
88 { <<
89 atomic_inc(&hibernate_atomic); <<
90 } <<
91 <<
92 bool hibernation_available(void) <<
93 { <<
94 return nohibernate == 0 && <<
95 !security_locked_down(LOCKDOWN <<
96 !secretmem_active() && !cxl_me <<
97 } <<
98 52
99 /** 53 /**
100 * hibernation_set_ops - Set the global hibern !! 54 * hibernation_set_ops - set the global hibernate operations
101 * @ops: Hibernation operations to use in subs !! 55 * @ops: the hibernation operations to use in subsequent hibernation transitions
102 */ 56 */
103 void hibernation_set_ops(const struct platform <<
104 { <<
105 unsigned int sleep_flags; <<
106 57
>> 58 void hibernation_set_ops(struct platform_hibernation_ops *ops)
>> 59 {
107 if (ops && !(ops->begin && ops->end && 60 if (ops && !(ops->begin && ops->end && ops->pre_snapshot
108 && ops->prepare && ops->finish && 61 && ops->prepare && ops->finish && ops->enter && ops->pre_restore
109 && ops->restore_cleanup && ops->le !! 62 && ops->restore_cleanup)) {
110 WARN_ON(1); 63 WARN_ON(1);
111 return; 64 return;
112 } 65 }
113 !! 66 mutex_lock(&pm_mutex);
114 sleep_flags = lock_system_sleep(); <<
115 <<
116 hibernation_ops = ops; 67 hibernation_ops = ops;
117 if (ops) 68 if (ops)
118 hibernation_mode = HIBERNATION 69 hibernation_mode = HIBERNATION_PLATFORM;
119 else if (hibernation_mode == HIBERNATI 70 else if (hibernation_mode == HIBERNATION_PLATFORM)
120 hibernation_mode = HIBERNATION 71 hibernation_mode = HIBERNATION_SHUTDOWN;
121 72
122 unlock_system_sleep(sleep_flags); !! 73 mutex_unlock(&pm_mutex);
123 } 74 }
124 EXPORT_SYMBOL_GPL(hibernation_set_ops); <<
125 75
126 static bool entering_platform_hibernation; 76 static bool entering_platform_hibernation;
127 77
128 bool system_entering_hibernation(void) 78 bool system_entering_hibernation(void)
129 { 79 {
130 return entering_platform_hibernation; 80 return entering_platform_hibernation;
131 } 81 }
132 EXPORT_SYMBOL(system_entering_hibernation); 82 EXPORT_SYMBOL(system_entering_hibernation);
133 83
134 #ifdef CONFIG_PM_DEBUG 84 #ifdef CONFIG_PM_DEBUG
135 static void hibernation_debug_sleep(void) 85 static void hibernation_debug_sleep(void)
136 { 86 {
137 pr_info("debug: Waiting for 5 seconds. !! 87 printk(KERN_INFO "hibernation debug: Waiting for 5 seconds.\n");
138 mdelay(5000); 88 mdelay(5000);
139 } 89 }
140 90
>> 91 static int hibernation_testmode(int mode)
>> 92 {
>> 93 if (hibernation_mode == mode) {
>> 94 hibernation_debug_sleep();
>> 95 return 1;
>> 96 }
>> 97 return 0;
>> 98 }
>> 99
141 static int hibernation_test(int level) 100 static int hibernation_test(int level)
142 { 101 {
143 if (pm_test_level == level) { 102 if (pm_test_level == level) {
144 hibernation_debug_sleep(); 103 hibernation_debug_sleep();
145 return 1; 104 return 1;
146 } 105 }
147 return 0; 106 return 0;
148 } 107 }
149 #else /* !CONFIG_PM_DEBUG */ 108 #else /* !CONFIG_PM_DEBUG */
>> 109 static int hibernation_testmode(int mode) { return 0; }
150 static int hibernation_test(int level) { retur 110 static int hibernation_test(int level) { return 0; }
151 #endif /* !CONFIG_PM_DEBUG */ 111 #endif /* !CONFIG_PM_DEBUG */
152 112
153 /** 113 /**
154 * platform_begin - Call platform to start hib !! 114 * platform_begin - tell the platform driver that we're starting
155 * @platform_mode: Whether or not to use the p !! 115 * hibernation
156 */ 116 */
>> 117
157 static int platform_begin(int platform_mode) 118 static int platform_begin(int platform_mode)
158 { 119 {
159 return (platform_mode && hibernation_o 120 return (platform_mode && hibernation_ops) ?
160 hibernation_ops->begin(PMSG_FR !! 121 hibernation_ops->begin() : 0;
161 } 122 }
162 123
163 /** 124 /**
164 * platform_end - Call platform to finish tran !! 125 * platform_end - tell the platform driver that we've entered the
165 * @platform_mode: Whether or not to use the p !! 126 * working state
166 */ 127 */
>> 128
167 static void platform_end(int platform_mode) 129 static void platform_end(int platform_mode)
168 { 130 {
169 if (platform_mode && hibernation_ops) 131 if (platform_mode && hibernation_ops)
170 hibernation_ops->end(); 132 hibernation_ops->end();
171 } 133 }
172 134
173 /** 135 /**
174 * platform_pre_snapshot - Call platform to pr !! 136 * platform_pre_snapshot - prepare the machine for hibernation using the
175 * @platform_mode: Whether or not to use the p !! 137 * platform driver if so configured and return an error code if it fails
176 * <<
177 * Use the platform driver to prepare the syst <<
178 * if so configured, and return an error code <<
179 */ 138 */
180 139
181 static int platform_pre_snapshot(int platform_ 140 static int platform_pre_snapshot(int platform_mode)
182 { 141 {
183 return (platform_mode && hibernation_o 142 return (platform_mode && hibernation_ops) ?
184 hibernation_ops->pre_snapshot( 143 hibernation_ops->pre_snapshot() : 0;
185 } 144 }
186 145
187 /** 146 /**
188 * platform_leave - Call platform to prepare a !! 147 * platform_leave - prepare the machine for switching to the normal mode
189 * @platform_mode: Whether or not to use the p !! 148 * of operation using the platform driver (called with interrupts disabled)
190 * <<
191 * Use the platform driver prepare to prepare <<
192 * normal mode of operation. <<
193 * <<
194 * This routine is called on one CPU with inte <<
195 */ 149 */
>> 150
196 static void platform_leave(int platform_mode) 151 static void platform_leave(int platform_mode)
197 { 152 {
198 if (platform_mode && hibernation_ops) 153 if (platform_mode && hibernation_ops)
199 hibernation_ops->leave(); 154 hibernation_ops->leave();
200 } 155 }
201 156
202 /** 157 /**
203 * platform_finish - Call platform to switch t !! 158 * platform_finish - switch the machine to the normal mode of operation
204 * @platform_mode: Whether or not to use the p !! 159 * using the platform driver (must be called after platform_prepare())
205 * <<
206 * Use the platform driver to switch the machi <<
207 * operation. <<
208 * <<
209 * This routine must be called after platform_ <<
210 */ 160 */
>> 161
211 static void platform_finish(int platform_mode) 162 static void platform_finish(int platform_mode)
212 { 163 {
213 if (platform_mode && hibernation_ops) 164 if (platform_mode && hibernation_ops)
214 hibernation_ops->finish(); 165 hibernation_ops->finish();
215 } 166 }
216 167
217 /** 168 /**
218 * platform_pre_restore - Prepare for hibernat !! 169 * platform_pre_restore - prepare the platform for the restoration from a
219 * @platform_mode: Whether or not to use the p !! 170 * hibernation image. If the restore fails after this function has been
220 * !! 171 * called, platform_restore_cleanup() must be called.
221 * Use the platform driver to prepare the syst <<
222 * image. <<
223 * <<
224 * If the restore fails after this function ha <<
225 * platform_restore_cleanup() must be called. <<
226 */ 172 */
>> 173
227 static int platform_pre_restore(int platform_m 174 static int platform_pre_restore(int platform_mode)
228 { 175 {
229 return (platform_mode && hibernation_o 176 return (platform_mode && hibernation_ops) ?
230 hibernation_ops->pre_restore() 177 hibernation_ops->pre_restore() : 0;
231 } 178 }
232 179
233 /** 180 /**
234 * platform_restore_cleanup - Switch to the wo !! 181 * platform_restore_cleanup - switch the platform to the normal mode of
235 * @platform_mode: Whether or not to use the p !! 182 * operation after a failing restore. If platform_pre_restore() has been
236 * !! 183 * called before the failing restore, this function must be called too,
237 * Use the platform driver to switch the syste !! 184 * regardless of the result of platform_pre_restore().
238 * after a failing restore. <<
239 * <<
240 * If platform_pre_restore() has been called b <<
241 * function must be called too, regardless of <<
242 * platform_pre_restore(). <<
243 */ 185 */
>> 186
244 static void platform_restore_cleanup(int platf 187 static void platform_restore_cleanup(int platform_mode)
245 { 188 {
246 if (platform_mode && hibernation_ops) 189 if (platform_mode && hibernation_ops)
247 hibernation_ops->restore_clean 190 hibernation_ops->restore_cleanup();
248 } 191 }
249 192
250 /** 193 /**
251 * platform_recover - Recover from a failure t !! 194 * platform_recover - recover the platform from a failure to suspend
252 * @platform_mode: Whether or not to use the p !! 195 * devices.
253 */ 196 */
>> 197
254 static void platform_recover(int platform_mode 198 static void platform_recover(int platform_mode)
255 { 199 {
256 if (platform_mode && hibernation_ops & 200 if (platform_mode && hibernation_ops && hibernation_ops->recover)
257 hibernation_ops->recover(); 201 hibernation_ops->recover();
258 } 202 }
259 203
260 /** 204 /**
261 * swsusp_show_speed - Print time elapsed betw !! 205 * create_image - freeze devices that need to be frozen with interrupts
262 * @start: Starting event. !! 206 * off, create the hibernation image and thaw those devices. Control
263 * @stop: Final event. !! 207 * reappears in this routine after a restore.
264 * @nr_pages: Number of memory pages processed <<
265 * @msg: Additional diagnostic message to prin <<
266 */ 208 */
267 void swsusp_show_speed(ktime_t start, ktime_t <<
268 unsigned nr_pages, char <<
269 { <<
270 ktime_t diff; <<
271 u64 elapsed_centisecs64; <<
272 unsigned int centisecs; <<
273 unsigned int k; <<
274 unsigned int kps; <<
275 <<
276 diff = ktime_sub(stop, start); <<
277 elapsed_centisecs64 = ktime_divns(diff <<
278 centisecs = elapsed_centisecs64; <<
279 if (centisecs == 0) <<
280 centisecs = 1; /* avoid div-b <<
281 k = nr_pages * (PAGE_SIZE / 1024); <<
282 kps = (k * 100) / centisecs; <<
283 pr_info("%s %u kbytes in %u.%02u secon <<
284 msg, k, centisecs / 100, centi <<
285 (kps % 1000) / 10); <<
286 } <<
287 <<
288 __weak int arch_resume_nosmt(void) <<
289 { <<
290 return 0; <<
291 } <<
292 209
293 /** <<
294 * create_image - Create a hibernation image. <<
295 * @platform_mode: Whether or not to use the p <<
296 * <<
297 * Execute device drivers' "late" and "noirq" <<
298 * hibernation image and run the drivers' "noi <<
299 * <<
300 * Control reappears in this routine after the <<
301 */ <<
302 static int create_image(int platform_mode) 210 static int create_image(int platform_mode)
303 { 211 {
304 int error; 212 int error;
305 213
306 error = dpm_suspend_end(PMSG_FREEZE); !! 214 error = arch_prepare_suspend();
>> 215 if (error)
>> 216 return error;
>> 217
>> 218 /* At this point, dpm_suspend_start() has been called, but *not*
>> 219 * dpm_suspend_noirq(). We *must* call dpm_suspend_noirq() now.
>> 220 * Otherwise, drivers for some devices (e.g. interrupt controllers)
>> 221 * become desynchronized with the actual state of the hardware
>> 222 * at resume time, and evil weirdness ensues.
>> 223 */
>> 224 error = dpm_suspend_noirq(PMSG_FREEZE);
307 if (error) { 225 if (error) {
308 pr_err("Some devices failed to !! 226 printk(KERN_ERR "PM: Some devices failed to power down, "
>> 227 "aborting hibernation\n");
309 return error; 228 return error;
310 } 229 }
311 230
312 error = platform_pre_snapshot(platform 231 error = platform_pre_snapshot(platform_mode);
313 if (error || hibernation_test(TEST_PLA 232 if (error || hibernation_test(TEST_PLATFORM))
314 goto Platform_finish; 233 goto Platform_finish;
315 234
316 error = pm_sleep_disable_secondary_cpu !! 235 error = disable_nonboot_cpus();
317 if (error || hibernation_test(TEST_CPU !! 236 if (error || hibernation_test(TEST_CPUS)
>> 237 || hibernation_testmode(HIBERNATION_TEST))
318 goto Enable_cpus; 238 goto Enable_cpus;
319 239
320 local_irq_disable(); 240 local_irq_disable();
321 241
322 system_state = SYSTEM_SUSPEND; !! 242 error = sysdev_suspend(PMSG_FREEZE);
323 <<
324 error = syscore_suspend(); <<
325 if (error) { 243 if (error) {
326 pr_err("Some system devices fa !! 244 printk(KERN_ERR "PM: Some system devices failed to power down, "
>> 245 "aborting hibernation\n");
327 goto Enable_irqs; 246 goto Enable_irqs;
328 } 247 }
329 248
330 if (hibernation_test(TEST_CORE) || pm_ !! 249 if (hibernation_test(TEST_CORE))
331 goto Power_up; 250 goto Power_up;
332 251
333 in_suspend = 1; 252 in_suspend = 1;
334 save_processor_state(); 253 save_processor_state();
335 trace_suspend_resume(TPS("machine_susp <<
336 error = swsusp_arch_suspend(); 254 error = swsusp_arch_suspend();
>> 255 if (error)
>> 256 printk(KERN_ERR "PM: Error %d creating hibernation image\n",
>> 257 error);
337 /* Restore control flow magically appe 258 /* Restore control flow magically appears here */
338 restore_processor_state(); 259 restore_processor_state();
339 trace_suspend_resume(TPS("machine_susp !! 260 if (!in_suspend)
340 if (error) !! 261 platform_leave(platform_mode);
341 pr_err("Error %d creating imag <<
342 <<
343 if (!in_suspend) { <<
344 events_check_enabled = false; <<
345 clear_or_poison_free_pages(); <<
346 } <<
347 <<
348 platform_leave(platform_mode); <<
349 262
350 Power_up: 263 Power_up:
351 syscore_resume(); !! 264 sysdev_resume();
>> 265 /* NOTE: dpm_resume_noirq() is just a resume() for devices
>> 266 * that suspended with irqs off ... no overall powerup.
>> 267 */
352 268
353 Enable_irqs: 269 Enable_irqs:
354 system_state = SYSTEM_RUNNING; <<
355 local_irq_enable(); 270 local_irq_enable();
356 271
357 Enable_cpus: 272 Enable_cpus:
358 pm_sleep_enable_secondary_cpus(); !! 273 enable_nonboot_cpus();
359 <<
360 /* Allow architectures to do nosmt-spe <<
361 if (!in_suspend) <<
362 error = arch_resume_nosmt(); <<
363 274
364 Platform_finish: 275 Platform_finish:
365 platform_finish(platform_mode); 276 platform_finish(platform_mode);
366 277
367 dpm_resume_start(in_suspend ? !! 278 dpm_resume_noirq(in_suspend ?
368 (error ? PMSG_RECOVER : PMSG_T 279 (error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE);
369 280
370 return error; 281 return error;
371 } 282 }
372 283
373 /** 284 /**
374 * hibernation_snapshot - Quiesce devices and !! 285 * hibernation_snapshot - quiesce devices and create the hibernation
375 * @platform_mode: If set, use platform driver !! 286 * snapshot image.
>> 287 * @platform_mode - if set, use the platform driver, if available, to
>> 288 * prepare the platform firmware for the power transition.
376 * 289 *
377 * This routine must be called with system_tra !! 290 * Must be called with pm_mutex held
378 */ 291 */
>> 292
379 int hibernation_snapshot(int platform_mode) 293 int hibernation_snapshot(int platform_mode)
380 { 294 {
381 pm_message_t msg; <<
382 int error; 295 int error;
383 296
384 pm_suspend_clear_flags(); <<
385 error = platform_begin(platform_mode); 297 error = platform_begin(platform_mode);
386 if (error) 298 if (error)
387 goto Close; !! 299 return error;
388 300
389 /* Preallocate image memory before shu 301 /* Preallocate image memory before shutting down devices. */
390 error = hibernate_preallocate_memory() 302 error = hibernate_preallocate_memory();
391 if (error) 303 if (error)
392 goto Close; 304 goto Close;
393 305
394 error = freeze_kernel_threads(); <<
395 if (error) <<
396 goto Cleanup; <<
397 <<
398 if (hibernation_test(TEST_FREEZER)) { <<
399 <<
400 /* <<
401 * Indicate to the caller that <<
402 * successful freezer test. <<
403 */ <<
404 freezer_test_done = true; <<
405 goto Thaw; <<
406 } <<
407 <<
408 error = dpm_prepare(PMSG_FREEZE); <<
409 if (error) { <<
410 dpm_complete(PMSG_RECOVER); <<
411 goto Thaw; <<
412 } <<
413 <<
414 suspend_console(); 306 suspend_console();
415 pm_restrict_gfp_mask(); !! 307 error = dpm_suspend_start(PMSG_FREEZE);
416 !! 308 if (error)
417 error = dpm_suspend(PMSG_FREEZE); !! 309 goto Recover_platform;
418 310
419 if (error || hibernation_test(TEST_DEV !! 311 if (hibernation_test(TEST_DEVICES))
420 platform_recover(platform_mode !! 312 goto Recover_platform;
421 else <<
422 error = create_image(platform_ <<
423 313
424 /* !! 314 error = create_image(platform_mode);
425 * In the case that we call create_ima !! 315 /* Control returns here after successful restore */
426 * returns here (1) after the image ha <<
427 * image creation has failed and (2) a <<
428 */ <<
429 316
>> 317 Resume_devices:
430 /* We may need to release the prealloc 318 /* We may need to release the preallocated image pages here. */
431 if (error || !in_suspend) 319 if (error || !in_suspend)
432 swsusp_free(); 320 swsusp_free();
433 321
434 msg = in_suspend ? (error ? PMSG_RECOV !! 322 dpm_resume_end(in_suspend ?
435 dpm_resume(msg); !! 323 (error ? PMSG_RECOVER : PMSG_THAW) : PMSG_RESTORE);
436 <<
437 if (error || !in_suspend) <<
438 pm_restore_gfp_mask(); <<
439 <<
440 resume_console(); 324 resume_console();
441 dpm_complete(msg); <<
442 <<
443 Close: 325 Close:
444 platform_end(platform_mode); 326 platform_end(platform_mode);
445 return error; 327 return error;
446 328
447 Thaw: !! 329 Recover_platform:
448 thaw_kernel_threads(); !! 330 platform_recover(platform_mode);
449 Cleanup: !! 331 goto Resume_devices;
450 swsusp_free(); <<
451 goto Close; <<
452 } <<
453 <<
454 int __weak hibernate_resume_nonboot_cpu_disabl <<
455 { <<
456 return suspend_disable_secondary_cpus( <<
457 } 332 }
458 333
459 /** 334 /**
460 * resume_target_kernel - Restore system state !! 335 * resume_target_kernel - prepare devices that need to be suspended with
461 * @platform_mode: Whether or not to use the p !! 336 * interrupts off, restore the contents of highmem that have not been
462 * !! 337 * restored yet from the image and run the low level code that will restore
463 * Execute device drivers' "noirq" and "late" !! 338 * the remaining contents of memory and switch to the just restored target
464 * contents of highmem that have not been rest !! 339 * kernel.
465 * the low-level code that will restore the re <<
466 * switch to the just restored target kernel. <<
467 */ 340 */
>> 341
468 static int resume_target_kernel(bool platform_ 342 static int resume_target_kernel(bool platform_mode)
469 { 343 {
470 int error; 344 int error;
471 345
472 error = dpm_suspend_end(PMSG_QUIESCE); !! 346 error = dpm_suspend_noirq(PMSG_QUIESCE);
473 if (error) { 347 if (error) {
474 pr_err("Some devices failed to !! 348 printk(KERN_ERR "PM: Some devices failed to power down, "
>> 349 "aborting resume\n");
475 return error; 350 return error;
476 } 351 }
477 352
478 error = platform_pre_restore(platform_ 353 error = platform_pre_restore(platform_mode);
479 if (error) 354 if (error)
480 goto Cleanup; 355 goto Cleanup;
481 356
482 cpuidle_pause(); !! 357 error = disable_nonboot_cpus();
483 <<
484 error = hibernate_resume_nonboot_cpu_d <<
485 if (error) 358 if (error)
486 goto Enable_cpus; 359 goto Enable_cpus;
487 360
488 local_irq_disable(); 361 local_irq_disable();
489 system_state = SYSTEM_SUSPEND; <<
490 362
491 error = syscore_suspend(); !! 363 error = sysdev_suspend(PMSG_QUIESCE);
492 if (error) 364 if (error)
493 goto Enable_irqs; 365 goto Enable_irqs;
494 366
>> 367 /* We'll ignore saved state, but this gets preempt count (etc) right */
495 save_processor_state(); 368 save_processor_state();
496 error = restore_highmem(); 369 error = restore_highmem();
497 if (!error) { 370 if (!error) {
498 error = swsusp_arch_resume(); 371 error = swsusp_arch_resume();
499 /* 372 /*
500 * The code below is only ever 373 * The code below is only ever reached in case of a failure.
501 * Otherwise, execution contin !! 374 * Otherwise execution continues at place where
502 * swsusp_arch_suspend() was c !! 375 * swsusp_arch_suspend() was called
503 */ 376 */
504 BUG_ON(!error); 377 BUG_ON(!error);
505 /* !! 378 /* This call to restore_highmem() undos the previous one */
506 * This call to restore_highme <<
507 * the previous one. <<
508 */ <<
509 restore_highmem(); 379 restore_highmem();
510 } 380 }
511 /* 381 /*
512 * The only reason why swsusp_arch_res 382 * The only reason why swsusp_arch_resume() can fail is memory being
513 * very tight, so we have to free it a 383 * very tight, so we have to free it as soon as we can to avoid
514 * subsequent failures. !! 384 * subsequent failures
515 */ 385 */
516 swsusp_free(); 386 swsusp_free();
517 restore_processor_state(); 387 restore_processor_state();
518 touch_softlockup_watchdog(); 388 touch_softlockup_watchdog();
519 389
520 syscore_resume(); !! 390 sysdev_resume();
521 391
522 Enable_irqs: 392 Enable_irqs:
523 system_state = SYSTEM_RUNNING; <<
524 local_irq_enable(); 393 local_irq_enable();
525 394
526 Enable_cpus: 395 Enable_cpus:
527 pm_sleep_enable_secondary_cpus(); !! 396 enable_nonboot_cpus();
528 397
529 Cleanup: 398 Cleanup:
530 platform_restore_cleanup(platform_mode 399 platform_restore_cleanup(platform_mode);
531 400
532 dpm_resume_start(PMSG_RECOVER); !! 401 dpm_resume_noirq(PMSG_RECOVER);
533 402
534 return error; 403 return error;
535 } 404 }
536 405
537 /** 406 /**
538 * hibernation_restore - Quiesce devices and r !! 407 * hibernation_restore - quiesce devices and restore the hibernation
539 * @platform_mode: If set, use platform driver !! 408 * snapshot image. If successful, control returns in hibernation_snaphot()
>> 409 * @platform_mode - if set, use the platform driver, if available, to
>> 410 * prepare the platform firmware for the transition.
540 * 411 *
541 * This routine must be called with system_tra !! 412 * Must be called with pm_mutex held
542 * successful, control reappears in the restor <<
543 * hibernation_snapshot(). <<
544 */ 413 */
>> 414
545 int hibernation_restore(int platform_mode) 415 int hibernation_restore(int platform_mode)
546 { 416 {
547 int error; 417 int error;
548 418
549 pm_prepare_console(); 419 pm_prepare_console();
550 suspend_console(); 420 suspend_console();
551 pm_restrict_gfp_mask(); <<
552 error = dpm_suspend_start(PMSG_QUIESCE 421 error = dpm_suspend_start(PMSG_QUIESCE);
553 if (!error) { 422 if (!error) {
554 error = resume_target_kernel(p 423 error = resume_target_kernel(platform_mode);
555 /* !! 424 dpm_resume_end(PMSG_RECOVER);
556 * The above should either suc <<
557 * or return with an error. Ot <<
558 * undefined, so let's be para <<
559 */ <<
560 BUG_ON(!error); <<
561 } 425 }
562 dpm_resume_end(PMSG_RECOVER); <<
563 pm_restore_gfp_mask(); <<
564 resume_console(); 426 resume_console();
565 pm_restore_console(); 427 pm_restore_console();
566 return error; 428 return error;
567 } 429 }
568 430
569 /** 431 /**
570 * hibernation_platform_enter - Power off the !! 432 * hibernation_platform_enter - enter the hibernation state using the
>> 433 * platform driver (if available)
571 */ 434 */
>> 435
572 int hibernation_platform_enter(void) 436 int hibernation_platform_enter(void)
573 { 437 {
574 int error; 438 int error;
575 439
576 if (!hibernation_ops) 440 if (!hibernation_ops)
577 return -ENOSYS; 441 return -ENOSYS;
578 442
579 /* 443 /*
580 * We have cancelled the power transit 444 * We have cancelled the power transition by running
581 * hibernation_ops->finish() before sa 445 * hibernation_ops->finish() before saving the image, so we should let
582 * the firmware know that we're going 446 * the firmware know that we're going to enter the sleep state after all
583 */ 447 */
584 error = hibernation_ops->begin(PMSG_HI !! 448 error = hibernation_ops->begin();
585 if (error) 449 if (error)
586 goto Close; 450 goto Close;
587 451
588 entering_platform_hibernation = true; 452 entering_platform_hibernation = true;
589 suspend_console(); 453 suspend_console();
590 error = dpm_suspend_start(PMSG_HIBERNA 454 error = dpm_suspend_start(PMSG_HIBERNATE);
591 if (error) { 455 if (error) {
592 if (hibernation_ops->recover) 456 if (hibernation_ops->recover)
593 hibernation_ops->recov 457 hibernation_ops->recover();
594 goto Resume_devices; 458 goto Resume_devices;
595 } 459 }
596 460
597 error = dpm_suspend_end(PMSG_HIBERNATE !! 461 error = dpm_suspend_noirq(PMSG_HIBERNATE);
598 if (error) 462 if (error)
599 goto Resume_devices; 463 goto Resume_devices;
600 464
601 error = hibernation_ops->prepare(); 465 error = hibernation_ops->prepare();
602 if (error) 466 if (error)
603 goto Platform_finish; 467 goto Platform_finish;
604 468
605 error = pm_sleep_disable_secondary_cpu !! 469 error = disable_nonboot_cpus();
606 if (error) 470 if (error)
607 goto Enable_cpus; !! 471 goto Platform_finish;
608 472
609 local_irq_disable(); 473 local_irq_disable();
610 system_state = SYSTEM_SUSPEND; !! 474 sysdev_suspend(PMSG_HIBERNATE);
611 syscore_suspend(); <<
612 if (pm_wakeup_pending()) { <<
613 error = -EAGAIN; <<
614 goto Power_up; <<
615 } <<
616 <<
617 hibernation_ops->enter(); 475 hibernation_ops->enter();
618 /* We should never get here */ 476 /* We should never get here */
619 while (1); 477 while (1);
620 478
621 Power_up: !! 479 /*
622 syscore_resume(); !! 480 * We don't need to reenable the nonboot CPUs or resume consoles, since
623 system_state = SYSTEM_RUNNING; !! 481 * the system is going to be halted anyway.
624 local_irq_enable(); !! 482 */
625 <<
626 Enable_cpus: <<
627 pm_sleep_enable_secondary_cpus(); <<
628 <<
629 Platform_finish: 483 Platform_finish:
630 hibernation_ops->finish(); 484 hibernation_ops->finish();
631 485
632 dpm_resume_start(PMSG_RESTORE); !! 486 dpm_suspend_noirq(PMSG_RESTORE);
633 487
634 Resume_devices: 488 Resume_devices:
635 entering_platform_hibernation = false; 489 entering_platform_hibernation = false;
636 dpm_resume_end(PMSG_RESTORE); 490 dpm_resume_end(PMSG_RESTORE);
637 resume_console(); 491 resume_console();
638 492
639 Close: 493 Close:
640 hibernation_ops->end(); 494 hibernation_ops->end();
641 495
642 return error; 496 return error;
643 } 497 }
644 498
645 /** 499 /**
646 * power_down - Shut the machine down for hibe !! 500 * power_down - Shut the machine down for hibernation.
647 * 501 *
648 * Use the platform driver, if configured, to !! 502 * Use the platform driver, if configured so; otherwise try
649 * state corresponding to hibernation, or try !! 503 * to power off or reboot.
650 * depending on the value of hibernation_mode. <<
651 */ 504 */
>> 505
652 static void power_down(void) 506 static void power_down(void)
653 { 507 {
654 int error; <<
655 <<
656 #ifdef CONFIG_SUSPEND <<
657 if (hibernation_mode == HIBERNATION_SU <<
658 error = suspend_devices_and_en <<
659 if (error) { <<
660 hibernation_mode = hib <<
661 <<
662 <<
663 } else { <<
664 /* Restore swap signat <<
665 error = swsusp_unmark( <<
666 if (error) <<
667 pr_err("Swap w <<
668 <<
669 return; <<
670 } <<
671 } <<
672 #endif <<
673 <<
674 switch (hibernation_mode) { 508 switch (hibernation_mode) {
>> 509 case HIBERNATION_TEST:
>> 510 case HIBERNATION_TESTPROC:
>> 511 break;
675 case HIBERNATION_REBOOT: 512 case HIBERNATION_REBOOT:
676 kernel_restart(NULL); 513 kernel_restart(NULL);
677 break; 514 break;
678 case HIBERNATION_PLATFORM: 515 case HIBERNATION_PLATFORM:
679 error = hibernation_platform_e !! 516 hibernation_platform_enter();
680 if (error == -EAGAIN || error <<
681 swsusp_unmark(); <<
682 events_check_enabled = <<
683 pr_info("Wakeup event <<
684 return; <<
685 } <<
686 fallthrough; <<
687 case HIBERNATION_SHUTDOWN: 517 case HIBERNATION_SHUTDOWN:
688 if (kernel_can_power_off()) !! 518 kernel_power_off();
689 kernel_power_off(); <<
690 break; 519 break;
691 } 520 }
692 kernel_halt(); 521 kernel_halt();
693 /* 522 /*
694 * Valid image is on the disk, if we c 523 * Valid image is on the disk, if we continue we risk serious data
695 * corruption after resume. 524 * corruption after resume.
696 */ 525 */
697 pr_crit("Power down manually\n"); !! 526 printk(KERN_CRIT "PM: Please power down manually\n");
698 while (1) !! 527 while(1);
699 cpu_relax(); <<
700 } 528 }
701 529
702 static int load_image_and_restore(void) !! 530 static int prepare_processes(void)
703 { 531 {
704 int error; !! 532 int error = 0;
705 unsigned int flags; <<
706 <<
707 pm_pr_dbg("Loading hibernation image.\ <<
708 533
709 lock_device_hotplug(); !! 534 if (freeze_processes()) {
710 error = create_basic_memory_bitmaps(); !! 535 error = -EBUSY;
711 if (error) { !! 536 thaw_processes();
712 swsusp_close(); <<
713 goto Unlock; <<
714 } 537 }
715 <<
716 error = swsusp_read(&flags); <<
717 swsusp_close(); <<
718 if (!error) <<
719 error = hibernation_restore(fl <<
720 <<
721 pr_err("Failed to load image, recoveri <<
722 swsusp_free(); <<
723 free_basic_memory_bitmaps(); <<
724 Unlock: <<
725 unlock_device_hotplug(); <<
726 <<
727 return error; 538 return error;
728 } 539 }
729 540
730 #define COMPRESSION_ALGO_LZO "lzo" <<
731 #define COMPRESSION_ALGO_LZ4 "lz4" <<
732 <<
733 /** 541 /**
734 * hibernate - Carry out system hibernation, i !! 542 * hibernate - The granpappy of the built-in hibernation management
735 */ 543 */
>> 544
736 int hibernate(void) 545 int hibernate(void)
737 { 546 {
738 bool snapshot_test = false; <<
739 unsigned int sleep_flags; <<
740 int error; 547 int error;
741 548
742 if (!hibernation_available()) { !! 549 mutex_lock(&pm_mutex);
743 pm_pr_dbg("Hibernation not ava <<
744 return -EPERM; <<
745 } <<
746 <<
747 /* <<
748 * Query for the compression algorithm <<
749 */ <<
750 if (!nocompress) { <<
751 strscpy(hib_comp_algo, hiberna <<
752 if (crypto_has_comp(hib_comp_a <<
753 pr_err("%s compression <<
754 return -EOPNOTSUPP; <<
755 } <<
756 } <<
757 <<
758 sleep_flags = lock_system_sleep(); <<
759 /* The snapshot device should not be o 550 /* The snapshot device should not be opened while we're running */
760 if (!hibernate_acquire()) { !! 551 if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {
761 error = -EBUSY; 552 error = -EBUSY;
762 goto Unlock; 553 goto Unlock;
763 } 554 }
764 555
765 pr_info("hibernation entry\n"); <<
766 pm_prepare_console(); 556 pm_prepare_console();
767 error = pm_notifier_call_chain_robust( !! 557 error = pm_notifier_call_chain(PM_HIBERNATION_PREPARE);
768 if (error) 558 if (error)
769 goto Restore; !! 559 goto Exit;
770 <<
771 ksys_sync_helper(); <<
772 560
773 error = freeze_processes(); !! 561 error = usermodehelper_disable();
774 if (error) 562 if (error)
775 goto Exit; 563 goto Exit;
776 564
777 lock_device_hotplug(); <<
778 /* Allocate memory management structur 565 /* Allocate memory management structures */
779 error = create_basic_memory_bitmaps(); 566 error = create_basic_memory_bitmaps();
780 if (error) 567 if (error)
>> 568 goto Exit;
>> 569
>> 570 printk(KERN_INFO "PM: Syncing filesystems ... ");
>> 571 sys_sync();
>> 572 printk("done.\n");
>> 573
>> 574 error = prepare_processes();
>> 575 if (error)
>> 576 goto Finish;
>> 577
>> 578 if (hibernation_test(TEST_FREEZER))
>> 579 goto Thaw;
>> 580
>> 581 if (hibernation_testmode(HIBERNATION_TESTPROC))
781 goto Thaw; 582 goto Thaw;
782 583
783 error = hibernation_snapshot(hibernati 584 error = hibernation_snapshot(hibernation_mode == HIBERNATION_PLATFORM);
784 if (error || freezer_test_done) !! 585 if (error)
785 goto Free_bitmaps; !! 586 goto Thaw;
786 587
787 if (in_suspend) { 588 if (in_suspend) {
788 unsigned int flags = 0; 589 unsigned int flags = 0;
789 590
790 if (hibernation_mode == HIBERN 591 if (hibernation_mode == HIBERNATION_PLATFORM)
791 flags |= SF_PLATFORM_M 592 flags |= SF_PLATFORM_MODE;
792 if (nocompress) { !! 593 pr_debug("PM: writing image.\n");
793 flags |= SF_NOCOMPRESS <<
794 } else { <<
795 flags |= SF_CRC32_MODE <<
796 <<
797 /* <<
798 * By default, LZO com <<
799 * to override this be <<
800 * <<
801 * Refer kernel/power/ <<
802 */ <<
803 <<
804 if (!strcmp(hib_comp_a <<
805 flags |= SF_CO <<
806 else <<
807 flags |= SF_CO <<
808 } <<
809 <<
810 pm_pr_dbg("Writing hibernation <<
811 error = swsusp_write(flags); 594 error = swsusp_write(flags);
812 swsusp_free(); 595 swsusp_free();
813 if (!error) { !! 596 if (!error)
814 if (hibernation_mode = !! 597 power_down();
815 snapshot_test <<
816 else <<
817 power_down(); <<
818 } <<
819 in_suspend = 0; <<
820 pm_restore_gfp_mask(); <<
821 } else { 598 } else {
822 pm_pr_dbg("Hibernation image r !! 599 pr_debug("PM: Image restored successfully.\n");
823 } 600 }
824 601
825 Free_bitmaps: <<
826 free_basic_memory_bitmaps(); <<
827 Thaw: 602 Thaw:
828 unlock_device_hotplug(); <<
829 if (snapshot_test) { <<
830 pm_pr_dbg("Checking hibernatio <<
831 error = swsusp_check(false); <<
832 if (!error) <<
833 error = load_image_and <<
834 } <<
835 thaw_processes(); 603 thaw_processes();
836 !! 604 Finish:
837 /* Don't bother checking whether freez !! 605 free_basic_memory_bitmaps();
838 freezer_test_done = false; !! 606 usermodehelper_enable();
839 Exit: 607 Exit:
840 pm_notifier_call_chain(PM_POST_HIBERNA 608 pm_notifier_call_chain(PM_POST_HIBERNATION);
841 Restore: <<
842 pm_restore_console(); 609 pm_restore_console();
843 hibernate_release(); !! 610 atomic_inc(&snapshot_device_available);
844 Unlock: 611 Unlock:
845 unlock_system_sleep(sleep_flags); !! 612 mutex_unlock(&pm_mutex);
846 pr_info("hibernation exit\n"); <<
847 <<
848 return error; 613 return error;
849 } 614 }
850 615
>> 616
851 /** 617 /**
852 * hibernate_quiet_exec - Execute a function w !! 618 * software_resume - Resume from a saved image.
853 * @func: Function to execute. !! 619 *
854 * @data: Data pointer to pass to @func. !! 620 * Called as a late_initcall (so all devices are discovered and
>> 621 * initialized), we call swsusp to see if we have a saved image or not.
>> 622 * If so, we quiesce devices, the restore the saved image. We will
>> 623 * return above (in hibernate() ) if everything goes well.
>> 624 * Otherwise, we fail gracefully and return to the normally
>> 625 * scheduled program.
855 * 626 *
856 * Return the @func return value or an error c <<
857 */ 627 */
858 int hibernate_quiet_exec(int (*func)(void *dat !! 628
>> 629 static int software_resume(void)
859 { 630 {
860 unsigned int sleep_flags; <<
861 int error; 631 int error;
>> 632 unsigned int flags;
862 633
863 sleep_flags = lock_system_sleep(); !! 634 /*
864 !! 635 * If the user said "noresume".. bail out early.
865 if (!hibernate_acquire()) { !! 636 */
866 error = -EBUSY; !! 637 if (noresume)
867 goto unlock; !! 638 return 0;
868 } <<
869 <<
870 pm_prepare_console(); <<
871 <<
872 error = pm_notifier_call_chain_robust( <<
873 if (error) <<
874 goto restore; <<
875 <<
876 error = freeze_processes(); <<
877 if (error) <<
878 goto exit; <<
879 <<
880 lock_device_hotplug(); <<
881 <<
882 pm_suspend_clear_flags(); <<
883 <<
884 error = platform_begin(true); <<
885 if (error) <<
886 goto thaw; <<
887 <<
888 error = freeze_kernel_threads(); <<
889 if (error) <<
890 goto thaw; <<
891 <<
892 error = dpm_prepare(PMSG_FREEZE); <<
893 if (error) <<
894 goto dpm_complete; <<
895 <<
896 suspend_console(); <<
897 <<
898 error = dpm_suspend(PMSG_FREEZE); <<
899 if (error) <<
900 goto dpm_resume; <<
901 <<
902 error = dpm_suspend_end(PMSG_FREEZE); <<
903 if (error) <<
904 goto dpm_resume; <<
905 <<
906 error = platform_pre_snapshot(true); <<
907 if (error) <<
908 goto skip; <<
909 <<
910 error = func(data); <<
911 <<
912 skip: <<
913 platform_finish(true); <<
914 <<
915 dpm_resume_start(PMSG_THAW); <<
916 <<
917 dpm_resume: <<
918 dpm_resume(PMSG_THAW); <<
919 <<
920 resume_console(); <<
921 <<
922 dpm_complete: <<
923 dpm_complete(PMSG_THAW); <<
924 <<
925 thaw_kernel_threads(); <<
926 <<
927 thaw: <<
928 platform_end(true); <<
929 <<
930 unlock_device_hotplug(); <<
931 <<
932 thaw_processes(); <<
933 <<
934 exit: <<
935 pm_notifier_call_chain(PM_POST_HIBERNA <<
936 <<
937 restore: <<
938 pm_restore_console(); <<
939 <<
940 hibernate_release(); <<
941 <<
942 unlock: <<
943 unlock_system_sleep(sleep_flags); <<
944 <<
945 return error; <<
946 } <<
947 EXPORT_SYMBOL_GPL(hibernate_quiet_exec); <<
948 639
949 static int __init find_resume_device(void) !! 640 /*
950 { !! 641 * name_to_dev_t() below takes a sysfs buffer mutex when sysfs
951 if (!strlen(resume_file)) !! 642 * is configured into the kernel. Since the regular hibernate
952 return -ENOENT; !! 643 * trigger path is via sysfs which takes a buffer mutex before
>> 644 * calling hibernate functions (which take pm_mutex) this can
>> 645 * cause lockdep to complain about a possible ABBA deadlock
>> 646 * which cannot happen since we're in the boot code here and
>> 647 * sysfs can't be invoked yet. Therefore, we use a subclass
>> 648 * here to avoid lockdep complaining.
>> 649 */
>> 650 mutex_lock_nested(&pm_mutex, SINGLE_DEPTH_NESTING);
953 651
954 pm_pr_dbg("Checking hibernation image !! 652 if (swsusp_resume_device)
>> 653 goto Check_image;
955 654
956 if (resume_delay) { !! 655 if (!strlen(resume_file)) {
957 pr_info("Waiting %dsec before !! 656 error = -ENOENT;
958 resume_delay); !! 657 goto Unlock;
959 ssleep(resume_delay); <<
960 } 658 }
961 659
>> 660 pr_debug("PM: Checking image partition %s\n", resume_file);
>> 661
962 /* Check if the device is there */ 662 /* Check if the device is there */
963 if (!early_lookup_bdev(resume_file, &s !! 663 swsusp_resume_device = name_to_dev_t(resume_file);
964 return 0; !! 664 if (!swsusp_resume_device) {
>> 665 /*
>> 666 * Some device discovery might still be in progress; we need
>> 667 * to wait for this to finish.
>> 668 */
>> 669 wait_for_device_probe();
>> 670 /*
>> 671 * We can't depend on SCSI devices being available after loading
>> 672 * one of their modules until scsi_complete_async_scans() is
>> 673 * called and the resume device usually is a SCSI one.
>> 674 */
>> 675 scsi_complete_async_scans();
965 676
966 /* !! 677 swsusp_resume_device = name_to_dev_t(resume_file);
967 * Some device discovery might still b !! 678 if (!swsusp_resume_device) {
968 * this to finish. !! 679 error = -ENODEV;
969 */ !! 680 goto Unlock;
970 wait_for_device_probe(); !! 681 }
971 if (resume_wait) { <<
972 while (early_lookup_bdev(resum <<
973 msleep(10); <<
974 async_synchronize_full(); <<
975 } 682 }
976 683
977 return early_lookup_bdev(resume_file, !! 684 Check_image:
978 } !! 685 pr_debug("PM: Resume from partition %d:%d\n",
979 <<
980 static int software_resume(void) <<
981 { <<
982 int error; <<
983 <<
984 pm_pr_dbg("Hibernation image partition <<
985 MAJOR(swsusp_resume_device), M 686 MAJOR(swsusp_resume_device), MINOR(swsusp_resume_device));
986 687
987 pm_pr_dbg("Looking for hibernation ima !! 688 pr_debug("PM: Checking hibernation image.\n");
988 !! 689 error = swsusp_check();
989 mutex_lock(&system_transition_mutex); <<
990 error = swsusp_check(true); <<
991 if (error) 690 if (error)
992 goto Unlock; 691 goto Unlock;
993 692
994 /* <<
995 * Check if the hibernation image is c <<
996 * the algorithm support. <<
997 */ <<
998 if (!(swsusp_header_flags & SF_NOCOMPR <<
999 if (swsusp_header_flags & SF_C <<
1000 strscpy(hib_comp_algo <<
1001 else <<
1002 strscpy(hib_comp_algo <<
1003 if (crypto_has_comp(hib_comp_ <<
1004 pr_err("%s compressio <<
1005 error = -EOPNOTSUPP; <<
1006 goto Unlock; <<
1007 } <<
1008 } <<
1009 <<
1010 /* The snapshot device should not be 693 /* The snapshot device should not be opened while we're running */
1011 if (!hibernate_acquire()) { !! 694 if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {
1012 error = -EBUSY; 695 error = -EBUSY;
1013 swsusp_close(); !! 696 swsusp_close(FMODE_READ);
1014 goto Unlock; 697 goto Unlock;
1015 } 698 }
1016 699
1017 pr_info("resume from hibernation\n"); <<
1018 pm_prepare_console(); 700 pm_prepare_console();
1019 error = pm_notifier_call_chain_robust !! 701 error = pm_notifier_call_chain(PM_RESTORE_PREPARE);
>> 702 if (error)
>> 703 goto close_finish;
>> 704
>> 705 error = usermodehelper_disable();
1020 if (error) 706 if (error)
1021 goto Restore; !! 707 goto close_finish;
1022 708
1023 pm_pr_dbg("Preparing processes for hi !! 709 error = create_basic_memory_bitmaps();
1024 error = freeze_processes(); <<
1025 if (error) 710 if (error)
1026 goto Close_Finish; !! 711 goto close_finish;
1027 712
1028 error = freeze_kernel_threads(); !! 713 pr_debug("PM: Preparing processes for restore.\n");
>> 714 error = prepare_processes();
1029 if (error) { 715 if (error) {
1030 thaw_processes(); !! 716 swsusp_close(FMODE_READ);
1031 goto Close_Finish; !! 717 goto Done;
1032 } 718 }
1033 719
1034 error = load_image_and_restore(); !! 720 pr_debug("PM: Reading hibernation image.\n");
>> 721
>> 722 error = swsusp_read(&flags);
>> 723 swsusp_close(FMODE_READ);
>> 724 if (!error)
>> 725 hibernation_restore(flags & SF_PLATFORM_MODE);
>> 726
>> 727 printk(KERN_ERR "PM: Restore failed, recovering.\n");
>> 728 swsusp_free();
1035 thaw_processes(); 729 thaw_processes();
>> 730 Done:
>> 731 free_basic_memory_bitmaps();
>> 732 usermodehelper_enable();
1036 Finish: 733 Finish:
1037 pm_notifier_call_chain(PM_POST_RESTOR 734 pm_notifier_call_chain(PM_POST_RESTORE);
1038 Restore: <<
1039 pm_restore_console(); 735 pm_restore_console();
1040 pr_info("resume failed (%d)\n", error !! 736 atomic_inc(&snapshot_device_available);
1041 hibernate_release(); <<
1042 /* For success case, the suspend path 737 /* For success case, the suspend path will release the lock */
1043 Unlock: 738 Unlock:
1044 mutex_unlock(&system_transition_mutex !! 739 mutex_unlock(&pm_mutex);
1045 pm_pr_dbg("Hibernation image not pres !! 740 pr_debug("PM: Resume from disk failed.\n");
1046 return error; 741 return error;
1047 Close_Finish: !! 742 close_finish:
1048 swsusp_close(); !! 743 swsusp_close(FMODE_READ);
1049 goto Finish; 744 goto Finish;
1050 } 745 }
1051 746
1052 /** !! 747 late_initcall(software_resume);
1053 * software_resume_initcall - Resume from a s <<
1054 * <<
1055 * This routine is called as a late initcall, <<
1056 * discovered and initialized already. <<
1057 * <<
1058 * The image reading code is called to see if <<
1059 * available for reading. If that is the cas <<
1060 * contents of memory is restored from the sa <<
1061 * <<
1062 * If this is successful, control reappears i <<
1063 * hibernation_snapshot() which returns to hi <<
1064 * attempts to recover gracefully and make th <<
1065 * of operation. <<
1066 */ <<
1067 static int __init software_resume_initcall(vo <<
1068 { <<
1069 /* <<
1070 * If the user said "noresume".. bail <<
1071 */ <<
1072 if (noresume || !hibernation_availabl <<
1073 return 0; <<
1074 <<
1075 if (!swsusp_resume_device) { <<
1076 int error = find_resume_devic <<
1077 <<
1078 if (error) <<
1079 return error; <<
1080 } <<
1081 <<
1082 return software_resume(); <<
1083 } <<
1084 late_initcall_sync(software_resume_initcall); <<
1085 748
1086 749
1087 static const char * const hibernation_modes[] 750 static const char * const hibernation_modes[] = {
1088 [HIBERNATION_PLATFORM] = "platform", 751 [HIBERNATION_PLATFORM] = "platform",
1089 [HIBERNATION_SHUTDOWN] = "shutdown", 752 [HIBERNATION_SHUTDOWN] = "shutdown",
1090 [HIBERNATION_REBOOT] = "reboot", 753 [HIBERNATION_REBOOT] = "reboot",
1091 #ifdef CONFIG_SUSPEND !! 754 [HIBERNATION_TEST] = "test",
1092 [HIBERNATION_SUSPEND] = "suspend", !! 755 [HIBERNATION_TESTPROC] = "testproc",
1093 #endif <<
1094 [HIBERNATION_TEST_RESUME] = "te <<
1095 }; 756 };
1096 757
1097 /* !! 758 /**
1098 * /sys/power/disk - Control hibernation mode !! 759 * disk - Control hibernation mode
1099 * 760 *
1100 * Hibernation can be handled in several ways !! 761 * Suspend-to-disk can be handled in several ways. We have a few options
1101 * to put the system into the sleep state: us !! 762 * for putting the system to sleep - using the platform driver (e.g. ACPI
1102 * or other hibernation_ops), powering it off !! 763 * or other hibernation_ops), powering off the system or rebooting the
1103 * mostly). !! 764 * system (for testing) as well as the two test modes.
>> 765 *
>> 766 * The system can support 'platform', and that is known a priori (and
>> 767 * encoded by the presence of hibernation_ops). However, the user may
>> 768 * choose 'shutdown' or 'reboot' as alternatives, as well as one fo the
>> 769 * test modes, 'test' or 'testproc'.
1104 * 770 *
1105 * The sysfs file /sys/power/disk provides an !! 771 * show() will display what the mode is currently set to.
1106 * hibernation mode to use. Reading from thi !! 772 * store() will accept one of
1107 * to be printed. There are 3 modes that can <<
1108 * 773 *
1109 * 'platform' 774 * 'platform'
1110 * 'shutdown' 775 * 'shutdown'
1111 * 'reboot' 776 * 'reboot'
>> 777 * 'test'
>> 778 * 'testproc'
1112 * 779 *
1113 * If a platform hibernation driver is in use !! 780 * It will only change to 'platform' if the system
1114 * and will be used by default. Otherwise, ' !! 781 * supports it (as determined by having hibernation_ops).
1115 * The selected option (i.e. the one correspo <<
1116 * hibernation_mode) is enclosed by a square <<
1117 * <<
1118 * To select a given hibernation mode it is n <<
1119 * string representation (as returned by read <<
1120 * into /sys/power/disk. <<
1121 */ 782 */
1122 783
1123 static ssize_t disk_show(struct kobject *kobj 784 static ssize_t disk_show(struct kobject *kobj, struct kobj_attribute *attr,
1124 char *buf) 785 char *buf)
1125 { 786 {
1126 ssize_t count = 0; <<
1127 int i; 787 int i;
1128 !! 788 char *start = buf;
1129 if (!hibernation_available()) <<
1130 return sysfs_emit(buf, "[disa <<
1131 789
1132 for (i = HIBERNATION_FIRST; i <= HIBE 790 for (i = HIBERNATION_FIRST; i <= HIBERNATION_MAX; i++) {
1133 if (!hibernation_modes[i]) 791 if (!hibernation_modes[i])
1134 continue; 792 continue;
1135 switch (i) { 793 switch (i) {
1136 case HIBERNATION_SHUTDOWN: 794 case HIBERNATION_SHUTDOWN:
1137 case HIBERNATION_REBOOT: 795 case HIBERNATION_REBOOT:
1138 #ifdef CONFIG_SUSPEND !! 796 case HIBERNATION_TEST:
1139 case HIBERNATION_SUSPEND: !! 797 case HIBERNATION_TESTPROC:
1140 #endif <<
1141 case HIBERNATION_TEST_RESUME: <<
1142 break; 798 break;
1143 case HIBERNATION_PLATFORM: 799 case HIBERNATION_PLATFORM:
1144 if (hibernation_ops) 800 if (hibernation_ops)
1145 break; 801 break;
1146 /* not a valid mode, 802 /* not a valid mode, continue with loop */
1147 continue; 803 continue;
1148 } 804 }
1149 if (i == hibernation_mode) 805 if (i == hibernation_mode)
1150 count += sysfs_emit_a !! 806 buf += sprintf(buf, "[%s] ", hibernation_modes[i]);
1151 else 807 else
1152 count += sysfs_emit_a !! 808 buf += sprintf(buf, "%s ", hibernation_modes[i]);
1153 } 809 }
1154 !! 810 buf += sprintf(buf, "\n");
1155 /* Convert the last space to a newlin !! 811 return buf-start;
1156 if (count > 0) <<
1157 buf[count - 1] = '\n'; <<
1158 <<
1159 return count; <<
1160 } 812 }
1161 813
>> 814
1162 static ssize_t disk_store(struct kobject *kob 815 static ssize_t disk_store(struct kobject *kobj, struct kobj_attribute *attr,
1163 const char *buf, si 816 const char *buf, size_t n)
1164 { 817 {
1165 int mode = HIBERNATION_INVALID; <<
1166 unsigned int sleep_flags; <<
1167 int error = 0; 818 int error = 0;
>> 819 int i;
1168 int len; 820 int len;
1169 char *p; 821 char *p;
1170 int i; !! 822 int mode = HIBERNATION_INVALID;
1171 <<
1172 if (!hibernation_available()) <<
1173 return -EPERM; <<
1174 823
1175 p = memchr(buf, '\n', n); 824 p = memchr(buf, '\n', n);
1176 len = p ? p - buf : n; 825 len = p ? p - buf : n;
1177 826
1178 sleep_flags = lock_system_sleep(); !! 827 mutex_lock(&pm_mutex);
1179 for (i = HIBERNATION_FIRST; i <= HIBE 828 for (i = HIBERNATION_FIRST; i <= HIBERNATION_MAX; i++) {
1180 if (len == strlen(hibernation 829 if (len == strlen(hibernation_modes[i])
1181 && !strncmp(buf, hibernat 830 && !strncmp(buf, hibernation_modes[i], len)) {
1182 mode = i; 831 mode = i;
1183 break; 832 break;
1184 } 833 }
1185 } 834 }
1186 if (mode != HIBERNATION_INVALID) { 835 if (mode != HIBERNATION_INVALID) {
1187 switch (mode) { 836 switch (mode) {
1188 case HIBERNATION_SHUTDOWN: 837 case HIBERNATION_SHUTDOWN:
1189 case HIBERNATION_REBOOT: 838 case HIBERNATION_REBOOT:
1190 #ifdef CONFIG_SUSPEND !! 839 case HIBERNATION_TEST:
1191 case HIBERNATION_SUSPEND: !! 840 case HIBERNATION_TESTPROC:
1192 #endif <<
1193 case HIBERNATION_TEST_RESUME: <<
1194 hibernation_mode = mo 841 hibernation_mode = mode;
1195 break; 842 break;
1196 case HIBERNATION_PLATFORM: 843 case HIBERNATION_PLATFORM:
1197 if (hibernation_ops) 844 if (hibernation_ops)
1198 hibernation_m 845 hibernation_mode = mode;
1199 else 846 else
1200 error = -EINV 847 error = -EINVAL;
1201 } 848 }
1202 } else 849 } else
1203 error = -EINVAL; 850 error = -EINVAL;
1204 851
1205 if (!error) 852 if (!error)
1206 pm_pr_dbg("Hibernation mode s !! 853 pr_debug("PM: Hibernation mode set to '%s'\n",
1207 hibernation_mo !! 854 hibernation_modes[mode]);
1208 unlock_system_sleep(sleep_flags); !! 855 mutex_unlock(&pm_mutex);
1209 return error ? error : n; 856 return error ? error : n;
1210 } 857 }
1211 858
1212 power_attr(disk); 859 power_attr(disk);
1213 860
1214 static ssize_t resume_show(struct kobject *ko 861 static ssize_t resume_show(struct kobject *kobj, struct kobj_attribute *attr,
1215 char *buf) 862 char *buf)
1216 { 863 {
1217 return sysfs_emit(buf, "%d:%d\n", MAJ !! 864 return sprintf(buf,"%d:%d\n", MAJOR(swsusp_resume_device),
1218 MINOR(swsusp_resume !! 865 MINOR(swsusp_resume_device));
1219 } 866 }
1220 867
1221 static ssize_t resume_store(struct kobject *k 868 static ssize_t resume_store(struct kobject *kobj, struct kobj_attribute *attr,
1222 const char *buf, 869 const char *buf, size_t n)
1223 { 870 {
1224 unsigned int sleep_flags; !! 871 unsigned int maj, min;
1225 int len = n; !! 872 dev_t res;
1226 char *name; !! 873 int ret = -EINVAL;
1227 dev_t dev; !! 874
1228 int error; !! 875 if (sscanf(buf, "%u:%u", &maj, &min) != 2)
1229 !! 876 goto out;
1230 if (!hibernation_available()) !! 877
1231 return n; !! 878 res = MKDEV(maj,min);
1232 !! 879 if (maj != MAJOR(res) || min != MINOR(res))
1233 if (len && buf[len-1] == '\n') !! 880 goto out;
1234 len--; !! 881
1235 name = kstrndup(buf, len, GFP_KERNEL) !! 882 mutex_lock(&pm_mutex);
1236 if (!name) !! 883 swsusp_resume_device = res;
1237 return -ENOMEM; !! 884 mutex_unlock(&pm_mutex);
1238 !! 885 printk(KERN_INFO "PM: Starting manual resume from disk\n");
1239 error = lookup_bdev(name, &dev); <<
1240 if (error) { <<
1241 unsigned maj, min, offset; <<
1242 char *p, dummy; <<
1243 <<
1244 error = 0; <<
1245 if (sscanf(name, "%u:%u%c", & <<
1246 sscanf(name, "%u:%u:%u:%c <<
1247 &dummy) == 3) <<
1248 dev = MKDEV(maj, min) <<
1249 if (maj != MAJOR(dev) <<
1250 error = -EINV <<
1251 } else { <<
1252 dev = new_decode_dev( <<
1253 if (*p) <<
1254 error = -EINV <<
1255 } <<
1256 } <<
1257 kfree(name); <<
1258 if (error) <<
1259 return error; <<
1260 <<
1261 sleep_flags = lock_system_sleep(); <<
1262 swsusp_resume_device = dev; <<
1263 unlock_system_sleep(sleep_flags); <<
1264 <<
1265 pm_pr_dbg("Configured hibernation res <<
1266 swsusp_resume_device); <<
1267 noresume = 0; 886 noresume = 0;
1268 software_resume(); 887 software_resume();
1269 return n; !! 888 ret = n;
>> 889 out:
>> 890 return ret;
1270 } 891 }
1271 892
1272 power_attr(resume); 893 power_attr(resume);
1273 894
1274 static ssize_t resume_offset_show(struct kobj <<
1275 struct kobj <<
1276 { <<
1277 return sysfs_emit(buf, "%llu\n", (uns <<
1278 } <<
1279 <<
1280 static ssize_t resume_offset_store(struct kob <<
1281 struct kob <<
1282 size_t n) <<
1283 { <<
1284 unsigned long long offset; <<
1285 int rc; <<
1286 <<
1287 rc = kstrtoull(buf, 0, &offset); <<
1288 if (rc) <<
1289 return rc; <<
1290 swsusp_resume_block = offset; <<
1291 <<
1292 return n; <<
1293 } <<
1294 <<
1295 power_attr(resume_offset); <<
1296 <<
1297 static ssize_t image_size_show(struct kobject 895 static ssize_t image_size_show(struct kobject *kobj, struct kobj_attribute *attr,
1298 char *buf) 896 char *buf)
1299 { 897 {
1300 return sysfs_emit(buf, "%lu\n", image !! 898 return sprintf(buf, "%lu\n", image_size);
1301 } 899 }
1302 900
1303 static ssize_t image_size_store(struct kobjec 901 static ssize_t image_size_store(struct kobject *kobj, struct kobj_attribute *attr,
1304 const char *b 902 const char *buf, size_t n)
1305 { 903 {
1306 unsigned long size; 904 unsigned long size;
1307 905
1308 if (sscanf(buf, "%lu", &size) == 1) { 906 if (sscanf(buf, "%lu", &size) == 1) {
1309 image_size = size; 907 image_size = size;
1310 return n; 908 return n;
1311 } 909 }
1312 910
1313 return -EINVAL; 911 return -EINVAL;
1314 } 912 }
1315 913
1316 power_attr(image_size); 914 power_attr(image_size);
1317 915
1318 static ssize_t reserved_size_show(struct kobj !! 916 static struct attribute * g[] = {
1319 struct kobj <<
1320 { <<
1321 return sysfs_emit(buf, "%lu\n", reser <<
1322 } <<
1323 <<
1324 static ssize_t reserved_size_store(struct kob <<
1325 struct kob <<
1326 const char <<
1327 { <<
1328 unsigned long size; <<
1329 <<
1330 if (sscanf(buf, "%lu", &size) == 1) { <<
1331 reserved_size = size; <<
1332 return n; <<
1333 } <<
1334 <<
1335 return -EINVAL; <<
1336 } <<
1337 <<
1338 power_attr(reserved_size); <<
1339 <<
1340 static struct attribute *g[] = { <<
1341 &disk_attr.attr, 917 &disk_attr.attr,
1342 &resume_offset_attr.attr, <<
1343 &resume_attr.attr, 918 &resume_attr.attr,
1344 &image_size_attr.attr, 919 &image_size_attr.attr,
1345 &reserved_size_attr.attr, <<
1346 NULL, 920 NULL,
1347 }; 921 };
1348 922
1349 923
1350 static const struct attribute_group attr_grou !! 924 static struct attribute_group attr_group = {
1351 .attrs = g, 925 .attrs = g,
1352 }; 926 };
1353 927
1354 928
1355 static int __init pm_disk_init(void) 929 static int __init pm_disk_init(void)
1356 { 930 {
1357 return sysfs_create_group(power_kobj, 931 return sysfs_create_group(power_kobj, &attr_group);
1358 } 932 }
1359 933
1360 core_initcall(pm_disk_init); 934 core_initcall(pm_disk_init);
1361 935
1362 936
1363 static int __init resume_setup(char *str) 937 static int __init resume_setup(char *str)
1364 { 938 {
1365 if (noresume) 939 if (noresume)
1366 return 1; 940 return 1;
1367 941
1368 strscpy(resume_file, str); !! 942 strncpy( resume_file, str, 255 );
1369 return 1; 943 return 1;
1370 } 944 }
1371 945
1372 static int __init resume_offset_setup(char *s 946 static int __init resume_offset_setup(char *str)
1373 { 947 {
1374 unsigned long long offset; 948 unsigned long long offset;
1375 949
1376 if (noresume) 950 if (noresume)
1377 return 1; 951 return 1;
1378 952
1379 if (sscanf(str, "%llu", &offset) == 1 953 if (sscanf(str, "%llu", &offset) == 1)
1380 swsusp_resume_block = offset; 954 swsusp_resume_block = offset;
1381 955
1382 return 1; 956 return 1;
1383 } 957 }
1384 958
1385 static int __init hibernate_setup(char *str) <<
1386 { <<
1387 if (!strncmp(str, "noresume", 8)) { <<
1388 noresume = 1; <<
1389 } else if (!strncmp(str, "nocompress" <<
1390 nocompress = 1; <<
1391 } else if (!strncmp(str, "no", 2)) { <<
1392 noresume = 1; <<
1393 nohibernate = 1; <<
1394 } else if (IS_ENABLED(CONFIG_STRICT_K <<
1395 && !strncmp(str, "protect_ <<
1396 enable_restore_image_protecti <<
1397 } <<
1398 return 1; <<
1399 } <<
1400 <<
1401 static int __init noresume_setup(char *str) 959 static int __init noresume_setup(char *str)
1402 { 960 {
1403 noresume = 1; 961 noresume = 1;
1404 return 1; 962 return 1;
1405 } 963 }
1406 964
1407 static int __init resumewait_setup(char *str) <<
1408 { <<
1409 resume_wait = 1; <<
1410 return 1; <<
1411 } <<
1412 <<
1413 static int __init resumedelay_setup(char *str <<
1414 { <<
1415 int rc = kstrtouint(str, 0, &resume_d <<
1416 <<
1417 if (rc) <<
1418 pr_warn("resumedelay: bad opt <<
1419 return 1; <<
1420 } <<
1421 <<
1422 static int __init nohibernate_setup(char *str <<
1423 { <<
1424 noresume = 1; <<
1425 nohibernate = 1; <<
1426 return 1; <<
1427 } <<
1428 <<
1429 static const char * const comp_alg_enabled[] <<
1430 #if IS_ENABLED(CONFIG_CRYPTO_LZO) <<
1431 COMPRESSION_ALGO_LZO, <<
1432 #endif <<
1433 #if IS_ENABLED(CONFIG_CRYPTO_LZ4) <<
1434 COMPRESSION_ALGO_LZ4, <<
1435 #endif <<
1436 }; <<
1437 <<
1438 static int hibernate_compressor_param_set(con <<
1439 const struct kernel_param *kp <<
1440 { <<
1441 unsigned int sleep_flags; <<
1442 int index, ret; <<
1443 <<
1444 sleep_flags = lock_system_sleep(); <<
1445 <<
1446 index = sysfs_match_string(comp_alg_e <<
1447 if (index >= 0) { <<
1448 ret = param_set_copystring(co <<
1449 if (!ret) <<
1450 strscpy(hib_comp_algo <<
1451 sizeof(hib_co <<
1452 } else { <<
1453 ret = index; <<
1454 } <<
1455 <<
1456 unlock_system_sleep(sleep_flags); <<
1457 <<
1458 if (ret) <<
1459 pr_debug("Cannot set specifie <<
1460 compressor); <<
1461 <<
1462 return ret; <<
1463 } <<
1464 <<
1465 static const struct kernel_param_ops hibernat <<
1466 .set = hibernate_compressor_param_ <<
1467 .get = param_get_string, <<
1468 }; <<
1469 <<
1470 static struct kparam_string hibernate_compres <<
1471 .maxlen = sizeof(hibernate_compressor <<
1472 .string = hibernate_compressor, <<
1473 }; <<
1474 <<
1475 module_param_cb(compressor, &hibernate_compre <<
1476 &hibernate_compressor_param_s <<
1477 MODULE_PARM_DESC(compressor, <<
1478 "Compression algorithm to be <<
1479 <<
1480 __setup("noresume", noresume_setup); 965 __setup("noresume", noresume_setup);
1481 __setup("resume_offset=", resume_offset_setup 966 __setup("resume_offset=", resume_offset_setup);
1482 __setup("resume=", resume_setup); 967 __setup("resume=", resume_setup);
1483 __setup("hibernate=", hibernate_setup); <<
1484 __setup("resumewait", resumewait_setup); <<
1485 __setup("resumedelay=", resumedelay_setup); <<
1486 __setup("nohibernate", nohibernate_setup); <<
1487 968
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.