Version:  2.0.40 2.2.26 2.4.37 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8

Linux/kernel/power/main.c

  1 /*
  2  * kernel/power/main.c - PM subsystem core functionality.
  3  *
  4  * Copyright (c) 2003 Patrick Mochel
  5  * Copyright (c) 2003 Open Source Development Lab
  6  *
  7  * This file is released under the GPLv2
  8  *
  9  */
 10 
 11 #include <linux/export.h>
 12 #include <linux/kobject.h>
 13 #include <linux/string.h>
 14 #include <linux/pm-trace.h>
 15 #include <linux/workqueue.h>
 16 #include <linux/debugfs.h>
 17 #include <linux/seq_file.h>
 18 
 19 #include "power.h"
 20 
 21 DEFINE_MUTEX(pm_mutex);
 22 
 23 #ifdef CONFIG_PM_SLEEP
 24 
 25 /* Routines for PM-transition notifications */
 26 
 27 static BLOCKING_NOTIFIER_HEAD(pm_chain_head);
 28 
 29 int register_pm_notifier(struct notifier_block *nb)
 30 {
 31         return blocking_notifier_chain_register(&pm_chain_head, nb);
 32 }
 33 EXPORT_SYMBOL_GPL(register_pm_notifier);
 34 
 35 int unregister_pm_notifier(struct notifier_block *nb)
 36 {
 37         return blocking_notifier_chain_unregister(&pm_chain_head, nb);
 38 }
 39 EXPORT_SYMBOL_GPL(unregister_pm_notifier);
 40 
 41 int __pm_notifier_call_chain(unsigned long val, int nr_to_call, int *nr_calls)
 42 {
 43         int ret;
 44 
 45         ret = __blocking_notifier_call_chain(&pm_chain_head, val, NULL,
 46                                                 nr_to_call, nr_calls);
 47 
 48         return notifier_to_errno(ret);
 49 }
 50 int pm_notifier_call_chain(unsigned long val)
 51 {
 52         return __pm_notifier_call_chain(val, -1, NULL);
 53 }
 54 
 55 /* If set, devices may be suspended and resumed asynchronously. */
 56 int pm_async_enabled = 1;
 57 
 58 static ssize_t pm_async_show(struct kobject *kobj, struct kobj_attribute *attr,
 59                              char *buf)
 60 {
 61         return sprintf(buf, "%d\n", pm_async_enabled);
 62 }
 63 
 64 static ssize_t pm_async_store(struct kobject *kobj, struct kobj_attribute *attr,
 65                               const char *buf, size_t n)
 66 {
 67         unsigned long val;
 68 
 69         if (kstrtoul(buf, 10, &val))
 70                 return -EINVAL;
 71 
 72         if (val > 1)
 73                 return -EINVAL;
 74 
 75         pm_async_enabled = val;
 76         return n;
 77 }
 78 
 79 power_attr(pm_async);
 80 
 81 #ifdef CONFIG_PM_DEBUG
 82 int pm_test_level = TEST_NONE;
 83 
 84 static const char * const pm_tests[__TEST_AFTER_LAST] = {
 85         [TEST_NONE] = "none",
 86         [TEST_CORE] = "core",
 87         [TEST_CPUS] = "processors",
 88         [TEST_PLATFORM] = "platform",
 89         [TEST_DEVICES] = "devices",
 90         [TEST_FREEZER] = "freezer",
 91 };
 92 
 93 static ssize_t pm_test_show(struct kobject *kobj, struct kobj_attribute *attr,
 94                                 char *buf)
 95 {
 96         char *s = buf;
 97         int level;
 98 
 99         for (level = TEST_FIRST; level <= TEST_MAX; level++)
100                 if (pm_tests[level]) {
101                         if (level == pm_test_level)
102                                 s += sprintf(s, "[%s] ", pm_tests[level]);
103                         else
104                                 s += sprintf(s, "%s ", pm_tests[level]);
105                 }
106 
107         if (s != buf)
108                 /* convert the last space to a newline */
109                 *(s-1) = '\n';
110 
111         return (s - buf);
112 }
113 
114 static ssize_t pm_test_store(struct kobject *kobj, struct kobj_attribute *attr,
115                                 const char *buf, size_t n)
116 {
117         const char * const *s;
118         int level;
119         char *p;
120         int len;
121         int error = -EINVAL;
122 
123         p = memchr(buf, '\n', n);
124         len = p ? p - buf : n;
125 
126         lock_system_sleep();
127 
128         level = TEST_FIRST;
129         for (s = &pm_tests[level]; level <= TEST_MAX; s++, level++)
130                 if (*s && len == strlen(*s) && !strncmp(buf, *s, len)) {
131                         pm_test_level = level;
132                         error = 0;
133                         break;
134                 }
135 
136         unlock_system_sleep();
137 
138         return error ? error : n;
139 }
140 
141 power_attr(pm_test);
142 #endif /* CONFIG_PM_DEBUG */
143 
144 #ifdef CONFIG_DEBUG_FS
145 static char *suspend_step_name(enum suspend_stat_step step)
146 {
147         switch (step) {
148         case SUSPEND_FREEZE:
149                 return "freeze";
150         case SUSPEND_PREPARE:
151                 return "prepare";
152         case SUSPEND_SUSPEND:
153                 return "suspend";
154         case SUSPEND_SUSPEND_NOIRQ:
155                 return "suspend_noirq";
156         case SUSPEND_RESUME_NOIRQ:
157                 return "resume_noirq";
158         case SUSPEND_RESUME:
159                 return "resume";
160         default:
161                 return "";
162         }
163 }
164 
165 static int suspend_stats_show(struct seq_file *s, void *unused)
166 {
167         int i, index, last_dev, last_errno, last_step;
168 
169         last_dev = suspend_stats.last_failed_dev + REC_FAILED_NUM - 1;
170         last_dev %= REC_FAILED_NUM;
171         last_errno = suspend_stats.last_failed_errno + REC_FAILED_NUM - 1;
172         last_errno %= REC_FAILED_NUM;
173         last_step = suspend_stats.last_failed_step + REC_FAILED_NUM - 1;
174         last_step %= REC_FAILED_NUM;
175         seq_printf(s, "%s: %d\n%s: %d\n%s: %d\n%s: %d\n%s: %d\n"
176                         "%s: %d\n%s: %d\n%s: %d\n%s: %d\n%s: %d\n",
177                         "success", suspend_stats.success,
178                         "fail", suspend_stats.fail,
179                         "failed_freeze", suspend_stats.failed_freeze,
180                         "failed_prepare", suspend_stats.failed_prepare,
181                         "failed_suspend", suspend_stats.failed_suspend,
182                         "failed_suspend_late",
183                                 suspend_stats.failed_suspend_late,
184                         "failed_suspend_noirq",
185                                 suspend_stats.failed_suspend_noirq,
186                         "failed_resume", suspend_stats.failed_resume,
187                         "failed_resume_early",
188                                 suspend_stats.failed_resume_early,
189                         "failed_resume_noirq",
190                                 suspend_stats.failed_resume_noirq);
191         seq_printf(s,   "failures:\n  last_failed_dev:\t%-s\n",
192                         suspend_stats.failed_devs[last_dev]);
193         for (i = 1; i < REC_FAILED_NUM; i++) {
194                 index = last_dev + REC_FAILED_NUM - i;
195                 index %= REC_FAILED_NUM;
196                 seq_printf(s, "\t\t\t%-s\n",
197                         suspend_stats.failed_devs[index]);
198         }
199         seq_printf(s,   "  last_failed_errno:\t%-d\n",
200                         suspend_stats.errno[last_errno]);
201         for (i = 1; i < REC_FAILED_NUM; i++) {
202                 index = last_errno + REC_FAILED_NUM - i;
203                 index %= REC_FAILED_NUM;
204                 seq_printf(s, "\t\t\t%-d\n",
205                         suspend_stats.errno[index]);
206         }
207         seq_printf(s,   "  last_failed_step:\t%-s\n",
208                         suspend_step_name(
209                                 suspend_stats.failed_steps[last_step]));
210         for (i = 1; i < REC_FAILED_NUM; i++) {
211                 index = last_step + REC_FAILED_NUM - i;
212                 index %= REC_FAILED_NUM;
213                 seq_printf(s, "\t\t\t%-s\n",
214                         suspend_step_name(
215                                 suspend_stats.failed_steps[index]));
216         }
217 
218         return 0;
219 }
220 
221 static int suspend_stats_open(struct inode *inode, struct file *file)
222 {
223         return single_open(file, suspend_stats_show, NULL);
224 }
225 
226 static const struct file_operations suspend_stats_operations = {
227         .open           = suspend_stats_open,
228         .read           = seq_read,
229         .llseek         = seq_lseek,
230         .release        = single_release,
231 };
232 
233 static int __init pm_debugfs_init(void)
234 {
235         debugfs_create_file("suspend_stats", S_IFREG | S_IRUGO,
236                         NULL, NULL, &suspend_stats_operations);
237         return 0;
238 }
239 
240 late_initcall(pm_debugfs_init);
241 #endif /* CONFIG_DEBUG_FS */
242 
243 #endif /* CONFIG_PM_SLEEP */
244 
245 #ifdef CONFIG_PM_SLEEP_DEBUG
246 /*
247  * pm_print_times: print time taken by devices to suspend and resume.
248  *
249  * show() returns whether printing of suspend and resume times is enabled.
250  * store() accepts 0 or 1.  0 disables printing and 1 enables it.
251  */
252 bool pm_print_times_enabled;
253 
254 static ssize_t pm_print_times_show(struct kobject *kobj,
255                                    struct kobj_attribute *attr, char *buf)
256 {
257         return sprintf(buf, "%d\n", pm_print_times_enabled);
258 }
259 
260 static ssize_t pm_print_times_store(struct kobject *kobj,
261                                     struct kobj_attribute *attr,
262                                     const char *buf, size_t n)
263 {
264         unsigned long val;
265 
266         if (kstrtoul(buf, 10, &val))
267                 return -EINVAL;
268 
269         if (val > 1)
270                 return -EINVAL;
271 
272         pm_print_times_enabled = !!val;
273         return n;
274 }
275 
276 power_attr(pm_print_times);
277 
278 static inline void pm_print_times_init(void)
279 {
280         pm_print_times_enabled = !!initcall_debug;
281 }
282 
283 static ssize_t pm_wakeup_irq_show(struct kobject *kobj,
284                                         struct kobj_attribute *attr,
285                                         char *buf)
286 {
287         return pm_wakeup_irq ? sprintf(buf, "%u\n", pm_wakeup_irq) : -ENODATA;
288 }
289 
290 power_attr_ro(pm_wakeup_irq);
291 
292 #else /* !CONFIG_PM_SLEEP_DEBUG */
293 static inline void pm_print_times_init(void) {}
294 #endif /* CONFIG_PM_SLEEP_DEBUG */
295 
296 struct kobject *power_kobj;
297 
298 /**
299  * state - control system sleep states.
300  *
301  * show() returns available sleep state labels, which may be "mem", "standby",
302  * "freeze" and "disk" (hibernation).  See Documentation/power/states.txt for a
303  * description of what they mean.
304  *
305  * store() accepts one of those strings, translates it into the proper
306  * enumerated value, and initiates a suspend transition.
307  */
308 static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr,
309                           char *buf)
310 {
311         char *s = buf;
312 #ifdef CONFIG_SUSPEND
313         suspend_state_t i;
314 
315         for (i = PM_SUSPEND_MIN; i < PM_SUSPEND_MAX; i++)
316                 if (pm_states[i])
317                         s += sprintf(s,"%s ", pm_states[i]);
318 
319 #endif
320         if (hibernation_available())
321                 s += sprintf(s, "disk ");
322         if (s != buf)
323                 /* convert the last space to a newline */
324                 *(s-1) = '\n';
325         return (s - buf);
326 }
327 
328 static suspend_state_t decode_state(const char *buf, size_t n)
329 {
330 #ifdef CONFIG_SUSPEND
331         suspend_state_t state;
332 #endif
333         char *p;
334         int len;
335 
336         p = memchr(buf, '\n', n);
337         len = p ? p - buf : n;
338 
339         /* Check hibernation first. */
340         if (len == 4 && !strncmp(buf, "disk", len))
341                 return PM_SUSPEND_MAX;
342 
343 #ifdef CONFIG_SUSPEND
344         for (state = PM_SUSPEND_MIN; state < PM_SUSPEND_MAX; state++) {
345                 const char *label = pm_states[state];
346 
347                 if (label && len == strlen(label) && !strncmp(buf, label, len))
348                         return state;
349         }
350 #endif
351 
352         return PM_SUSPEND_ON;
353 }
354 
355 static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
356                            const char *buf, size_t n)
357 {
358         suspend_state_t state;
359         int error;
360 
361         error = pm_autosleep_lock();
362         if (error)
363                 return error;
364 
365         if (pm_autosleep_state() > PM_SUSPEND_ON) {
366                 error = -EBUSY;
367                 goto out;
368         }
369 
370         state = decode_state(buf, n);
371         if (state < PM_SUSPEND_MAX)
372                 error = pm_suspend(state);
373         else if (state == PM_SUSPEND_MAX)
374                 error = hibernate();
375         else
376                 error = -EINVAL;
377 
378  out:
379         pm_autosleep_unlock();
380         return error ? error : n;
381 }
382 
383 power_attr(state);
384 
385 #ifdef CONFIG_PM_SLEEP
386 /*
387  * The 'wakeup_count' attribute, along with the functions defined in
388  * drivers/base/power/wakeup.c, provides a means by which wakeup events can be
389  * handled in a non-racy way.
390  *
391  * If a wakeup event occurs when the system is in a sleep state, it simply is
392  * woken up.  In turn, if an event that would wake the system up from a sleep
393  * state occurs when it is undergoing a transition to that sleep state, the
394  * transition should be aborted.  Moreover, if such an event occurs when the
395  * system is in the working state, an attempt to start a transition to the
396  * given sleep state should fail during certain period after the detection of
397  * the event.  Using the 'state' attribute alone is not sufficient to satisfy
398  * these requirements, because a wakeup event may occur exactly when 'state'
399  * is being written to and may be delivered to user space right before it is
400  * frozen, so the event will remain only partially processed until the system is
401  * woken up by another event.  In particular, it won't cause the transition to
402  * a sleep state to be aborted.
403  *
404  * This difficulty may be overcome if user space uses 'wakeup_count' before
405  * writing to 'state'.  It first should read from 'wakeup_count' and store
406  * the read value.  Then, after carrying out its own preparations for the system
407  * transition to a sleep state, it should write the stored value to
408  * 'wakeup_count'.  If that fails, at least one wakeup event has occurred since
409  * 'wakeup_count' was read and 'state' should not be written to.  Otherwise, it
410  * is allowed to write to 'state', but the transition will be aborted if there
411  * are any wakeup events detected after 'wakeup_count' was written to.
412  */
413 
414 static ssize_t wakeup_count_show(struct kobject *kobj,
415                                 struct kobj_attribute *attr,
416                                 char *buf)
417 {
418         unsigned int val;
419 
420         return pm_get_wakeup_count(&val, true) ?
421                 sprintf(buf, "%u\n", val) : -EINTR;
422 }
423 
424 static ssize_t wakeup_count_store(struct kobject *kobj,
425                                 struct kobj_attribute *attr,
426                                 const char *buf, size_t n)
427 {
428         unsigned int val;
429         int error;
430 
431         error = pm_autosleep_lock();
432         if (error)
433                 return error;
434 
435         if (pm_autosleep_state() > PM_SUSPEND_ON) {
436                 error = -EBUSY;
437                 goto out;
438         }
439 
440         error = -EINVAL;
441         if (sscanf(buf, "%u", &val) == 1) {
442                 if (pm_save_wakeup_count(val))
443                         error = n;
444                 else
445                         pm_print_active_wakeup_sources();
446         }
447 
448  out:
449         pm_autosleep_unlock();
450         return error;
451 }
452 
453 power_attr(wakeup_count);
454 
455 #ifdef CONFIG_PM_AUTOSLEEP
456 static ssize_t autosleep_show(struct kobject *kobj,
457                               struct kobj_attribute *attr,
458                               char *buf)
459 {
460         suspend_state_t state = pm_autosleep_state();
461 
462         if (state == PM_SUSPEND_ON)
463                 return sprintf(buf, "off\n");
464 
465 #ifdef CONFIG_SUSPEND
466         if (state < PM_SUSPEND_MAX)
467                 return sprintf(buf, "%s\n", pm_states[state] ?
468                                         pm_states[state] : "error");
469 #endif
470 #ifdef CONFIG_HIBERNATION
471         return sprintf(buf, "disk\n");
472 #else
473         return sprintf(buf, "error");
474 #endif
475 }
476 
477 static ssize_t autosleep_store(struct kobject *kobj,
478                                struct kobj_attribute *attr,
479                                const char *buf, size_t n)
480 {
481         suspend_state_t state = decode_state(buf, n);
482         int error;
483 
484         if (state == PM_SUSPEND_ON
485             && strcmp(buf, "off") && strcmp(buf, "off\n"))
486                 return -EINVAL;
487 
488         error = pm_autosleep_set_state(state);
489         return error ? error : n;
490 }
491 
492 power_attr(autosleep);
493 #endif /* CONFIG_PM_AUTOSLEEP */
494 
495 #ifdef CONFIG_PM_WAKELOCKS
496 static ssize_t wake_lock_show(struct kobject *kobj,
497                               struct kobj_attribute *attr,
498                               char *buf)
499 {
500         return pm_show_wakelocks(buf, true);
501 }
502 
503 static ssize_t wake_lock_store(struct kobject *kobj,
504                                struct kobj_attribute *attr,
505                                const char *buf, size_t n)
506 {
507         int error = pm_wake_lock(buf);
508         return error ? error : n;
509 }
510 
511 power_attr(wake_lock);
512 
513 static ssize_t wake_unlock_show(struct kobject *kobj,
514                                 struct kobj_attribute *attr,
515                                 char *buf)
516 {
517         return pm_show_wakelocks(buf, false);
518 }
519 
520 static ssize_t wake_unlock_store(struct kobject *kobj,
521                                  struct kobj_attribute *attr,
522                                  const char *buf, size_t n)
523 {
524         int error = pm_wake_unlock(buf);
525         return error ? error : n;
526 }
527 
528 power_attr(wake_unlock);
529 
530 #endif /* CONFIG_PM_WAKELOCKS */
531 #endif /* CONFIG_PM_SLEEP */
532 
533 #ifdef CONFIG_PM_TRACE
534 int pm_trace_enabled;
535 
536 static ssize_t pm_trace_show(struct kobject *kobj, struct kobj_attribute *attr,
537                              char *buf)
538 {
539         return sprintf(buf, "%d\n", pm_trace_enabled);
540 }
541 
542 static ssize_t
543 pm_trace_store(struct kobject *kobj, struct kobj_attribute *attr,
544                const char *buf, size_t n)
545 {
546         int val;
547 
548         if (sscanf(buf, "%d", &val) == 1) {
549                 pm_trace_enabled = !!val;
550                 if (pm_trace_enabled) {
551                         pr_warn("PM: Enabling pm_trace changes system date and time during resume.\n"
552                                 "PM: Correct system time has to be restored manually after resume.\n");
553                 }
554                 return n;
555         }
556         return -EINVAL;
557 }
558 
559 power_attr(pm_trace);
560 
561 static ssize_t pm_trace_dev_match_show(struct kobject *kobj,
562                                        struct kobj_attribute *attr,
563                                        char *buf)
564 {
565         return show_trace_dev_match(buf, PAGE_SIZE);
566 }
567 
568 power_attr_ro(pm_trace_dev_match);
569 
570 #endif /* CONFIG_PM_TRACE */
571 
572 #ifdef CONFIG_FREEZER
573 static ssize_t pm_freeze_timeout_show(struct kobject *kobj,
574                                       struct kobj_attribute *attr, char *buf)
575 {
576         return sprintf(buf, "%u\n", freeze_timeout_msecs);
577 }
578 
579 static ssize_t pm_freeze_timeout_store(struct kobject *kobj,
580                                        struct kobj_attribute *attr,
581                                        const char *buf, size_t n)
582 {
583         unsigned long val;
584 
585         if (kstrtoul(buf, 10, &val))
586                 return -EINVAL;
587 
588         freeze_timeout_msecs = val;
589         return n;
590 }
591 
592 power_attr(pm_freeze_timeout);
593 
594 #endif  /* CONFIG_FREEZER*/
595 
596 static struct attribute * g[] = {
597         &state_attr.attr,
598 #ifdef CONFIG_PM_TRACE
599         &pm_trace_attr.attr,
600         &pm_trace_dev_match_attr.attr,
601 #endif
602 #ifdef CONFIG_PM_SLEEP
603         &pm_async_attr.attr,
604         &wakeup_count_attr.attr,
605 #ifdef CONFIG_PM_AUTOSLEEP
606         &autosleep_attr.attr,
607 #endif
608 #ifdef CONFIG_PM_WAKELOCKS
609         &wake_lock_attr.attr,
610         &wake_unlock_attr.attr,
611 #endif
612 #ifdef CONFIG_PM_DEBUG
613         &pm_test_attr.attr,
614 #endif
615 #ifdef CONFIG_PM_SLEEP_DEBUG
616         &pm_print_times_attr.attr,
617         &pm_wakeup_irq_attr.attr,
618 #endif
619 #endif
620 #ifdef CONFIG_FREEZER
621         &pm_freeze_timeout_attr.attr,
622 #endif
623         NULL,
624 };
625 
626 static struct attribute_group attr_group = {
627         .attrs = g,
628 };
629 
630 struct workqueue_struct *pm_wq;
631 EXPORT_SYMBOL_GPL(pm_wq);
632 
633 static int __init pm_start_workqueue(void)
634 {
635         pm_wq = alloc_workqueue("pm", WQ_FREEZABLE, 0);
636 
637         return pm_wq ? 0 : -ENOMEM;
638 }
639 
640 static int __init pm_init(void)
641 {
642         int error = pm_start_workqueue();
643         if (error)
644                 return error;
645         hibernate_image_size_init();
646         hibernate_reserved_size_init();
647         power_kobj = kobject_create_and_add("power", NULL);
648         if (!power_kobj)
649                 return -ENOMEM;
650         error = sysfs_create_group(power_kobj, &attr_group);
651         if (error)
652                 return error;
653         pm_print_times_init();
654         return pm_autosleep_init();
655 }
656 
657 core_initcall(pm_init);
658 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us