PM: sleep: Add device name to suspend_report_result()

Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

kernel os linux

Currently, suspend_report_result() prints only function information.

If any driver uses a common PM function, nobody knows who exactly
called the failing function.

A device pinter is needed to recognize the failing device.

For example:

PM: dpm_run_callback(): pnp_bus_suspend+0x0/0x10 returns 0
PM: dpm_run_callback(): pci_pm_suspend+0x0/0x150 returns 0

become after the change:

serial 00:05: PM: dpm_run_callback(): pnp_bus_suspend+0x0/0x10 returns 0
pci 0000:00:01.3: PM: dpm_run_callback(): pci_pm_suspend+0x0/0x150 returns 0

Signed-off-by: Youngjin Jang <yj84.jang@samsung.com>
[ rjw: Changelog edits ]
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>

authored by

Youngjin Jang and committed by

Rafael J. Wysocki 4 years ago a759de69 7a64ca17

+19 -19

5 changed files

expand all

drivers

base

power

main.c

pci

pci-driver.c

pnp

driver.c

usb

core

hcd-pci.c

include

linux

pm.h

+5 -5

drivers/base/power/main.c

··· 485 485 trace_device_pm_callback_start(dev, info, state.event); 486 486 error = cb(dev); 487 487 trace_device_pm_callback_end(dev, error); 488 - suspend_report_result(cb, error); 488 + suspend_report_result(dev, cb, error); 489 489 490 490 initcall_debug_report(dev, calltime, cb, error); 491 491 ··· 1568 1568 trace_device_pm_callback_start(dev, info, state.event); 1569 1569 error = cb(dev, state); 1570 1570 trace_device_pm_callback_end(dev, error); 1571 - suspend_report_result(cb, error); 1571 + suspend_report_result(dev, cb, error); 1572 1572 1573 1573 initcall_debug_report(dev, calltime, cb, error); 1574 1574 ··· 1855 1855 device_unlock(dev); 1856 1856 1857 1857 if (ret < 0) { 1858 - suspend_report_result(callback, ret); 1858 + suspend_report_result(dev, callback, ret); 1859 1859 pm_runtime_put(dev); 1860 1860 return ret; 1861 1861 } ··· 1960 1960 } 1961 1961 EXPORT_SYMBOL_GPL(dpm_suspend_start); 1962 1962 1963 - void __suspend_report_result(const char *function, void *fn, int ret) 1963 + void __suspend_report_result(const char *function, struct device *dev, void *fn, int ret) 1964 1964 { 1965 1965 if (ret) 1966 - pr_err("%s(): %pS returns %d\n", function, fn, ret); 1966 + dev_err(dev, "%s(): %pS returns %d\n", function, fn, ret); 1967 1967 } 1968 1968 EXPORT_SYMBOL_GPL(__suspend_report_result); 1969 1969

+7 -7

drivers/pci/pci-driver.c

··· 596 596 int error; 597 597 598 598 error = drv->suspend(pci_dev, state); 599 - suspend_report_result(drv->suspend, error); 599 + suspend_report_result(dev, drv->suspend, error); 600 600 if (error) 601 601 return error; 602 602 ··· 775 775 int error; 776 776 777 777 error = pm->suspend(dev); 778 - suspend_report_result(pm->suspend, error); 778 + suspend_report_result(dev, pm->suspend, error); 779 779 if (error) 780 780 return error; 781 781 ··· 821 821 int error; 822 822 823 823 error = pm->suspend_noirq(dev); 824 - suspend_report_result(pm->suspend_noirq, error); 824 + suspend_report_result(dev, pm->suspend_noirq, error); 825 825 if (error) 826 826 return error; 827 827 ··· 1010 1010 int error; 1011 1011 1012 1012 error = pm->freeze(dev); 1013 - suspend_report_result(pm->freeze, error); 1013 + suspend_report_result(dev, pm->freeze, error); 1014 1014 if (error) 1015 1015 return error; 1016 1016 } ··· 1030 1030 int error; 1031 1031 1032 1032 error = pm->freeze_noirq(dev); 1033 - suspend_report_result(pm->freeze_noirq, error); 1033 + suspend_report_result(dev, pm->freeze_noirq, error); 1034 1034 if (error) 1035 1035 return error; 1036 1036 } ··· 1116 1116 int error; 1117 1117 1118 1118 error = pm->poweroff(dev); 1119 - suspend_report_result(pm->poweroff, error); 1119 + suspend_report_result(dev, pm->poweroff, error); 1120 1120 if (error) 1121 1121 return error; 1122 1122 } ··· 1154 1154 int error; 1155 1155 1156 1156 error = pm->poweroff_noirq(dev); 1157 - suspend_report_result(pm->poweroff_noirq, error); 1157 + suspend_report_result(dev, pm->poweroff_noirq, error); 1158 1158 if (error) 1159 1159 return error; 1160 1160 }

+1 -1

drivers/pnp/driver.c

··· 171 171 172 172 if (pnp_drv->driver.pm && pnp_drv->driver.pm->suspend) { 173 173 error = pnp_drv->driver.pm->suspend(dev); 174 - suspend_report_result(pnp_drv->driver.pm->suspend, error); 174 + suspend_report_result(dev, pnp_drv->driver.pm->suspend, error); 175 175 if (error) 176 176 return error; 177 177 }

+2 -2

drivers/usb/core/hcd-pci.c

··· 446 446 HCD_WAKEUP_PENDING(hcd->shared_hcd)) 447 447 return -EBUSY; 448 448 retval = hcd->driver->pci_suspend(hcd, do_wakeup); 449 - suspend_report_result(hcd->driver->pci_suspend, retval); 449 + suspend_report_result(dev, hcd->driver->pci_suspend, retval); 450 450 451 451 /* Check again in case wakeup raced with pci_suspend */ 452 452 if ((retval == 0 && do_wakeup && HCD_WAKEUP_PENDING(hcd)) || ··· 556 556 dev_dbg(dev, "--> PCI %s\n", 557 557 pci_power_name(pci_dev->current_state)); 558 558 } else { 559 - suspend_report_result(pci_prepare_to_sleep, retval); 559 + suspend_report_result(dev, pci_prepare_to_sleep, retval); 560 560 return retval; 561 561 } 562 562

+4 -4

include/linux/pm.h

··· 770 770 extern int dpm_suspend(pm_message_t state); 771 771 extern int dpm_prepare(pm_message_t state); 772 772 773 - extern void __suspend_report_result(const char *function, void *fn, int ret); 773 + extern void __suspend_report_result(const char *function, struct device *dev, void *fn, int ret); 774 774 775 - #define suspend_report_result(fn, ret) \ 775 + #define suspend_report_result(dev, fn, ret) \ 776 776 do { \ 777 - __suspend_report_result(__func__, fn, ret); \ 777 + __suspend_report_result(__func__, dev, fn, ret); \ 778 778 } while (0) 779 779 780 780 extern int device_pm_wait_for_dev(struct device *sub, struct device *dev); ··· 814 814 return 0; 815 815 } 816 816 817 - #define suspend_report_result(fn, ret) do {} while (0) 817 + #define suspend_report_result(dev, fn, ret) do {} while (0) 818 818 819 819 static inline int device_pm_wait_for_dev(struct device *a, struct device *b) 820 820 {