From 05db6ce88965eb64e613d30fca27681198c91c14 Mon Sep 17 00:00:00 2001 From: Hosung Kim Date: Mon, 30 Jul 2018 20:18:12 +0900 Subject: [PATCH] [ERD][NEUS7920-76] [COMMON] lib: dss: refactor dbg_snapshot_suspend logging Previously dbg_snapshot_suspend was wrong by logging in notifier function. This patch fixes it and adding various logging when suspending and resuming this system. Now dbg_snapshot_suspend logging is used when analyzing various issues. Change-Id: I024a23bfeb995ccd6f6b1ba2831bc85ee4404afd Signed-off-by: Hosung Kim --- drivers/base/power/main.c | 34 ++++++++++++++++++++++++++++++++++ drivers/base/syscore.c | 6 ++++++ include/linux/debug-snapshot.h | 5 +++-- kernel/cpu.c | 4 ++++ kernel/power/hibernate.c | 4 ++++ kernel/power/main.c | 2 +- kernel/power/process.c | 2 ++ kernel/power/suspend.c | 21 ++++++++++++++++++++- kernel/time/tick-common.c | 4 ++++ lib/debug-snapshot-log.c | 17 ++++++++++++++++- lib/debug-snapshot-log.h | 7 +++++-- 11 files changed, 99 insertions(+), 7 deletions(-) diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c index 885de2e96e61..0e23e78f1324 100644 --- a/drivers/base/power/main.c +++ b/drivers/base/power/main.c @@ -452,7 +452,9 @@ static int dpm_run_callback(pm_callback_t cb, struct device *dev, pm_dev_dbg(dev, state, info); trace_device_pm_callback_start(dev, info, state.event); + dbg_snapshot_suspend((char *)info, cb, dev, state.event, DSS_FLAG_IN); error = cb(dev); + dbg_snapshot_suspend((char *)info, cb, dev, state.event, DSS_FLAG_OUT); trace_device_pm_callback_end(dev, error); suspend_report_result(cb, error); @@ -606,6 +608,8 @@ void dpm_noirq_resume_devices(pm_message_t state) ktime_t starttime = ktime_get(); trace_suspend_resume(TPS("dpm_resume_noirq"), state.event, true); + dbg_snapshot_suspend("dpm_resume_noirq", dpm_noirq_resume_devices, + NULL, state.event, DSS_FLAG_IN); mutex_lock(&dpm_list_mtx); pm_transition = state; @@ -646,6 +650,8 @@ void dpm_noirq_resume_devices(pm_message_t state) mutex_unlock(&dpm_list_mtx); async_synchronize_full(); dpm_show_time(starttime, state, 0, "noirq"); + dbg_snapshot_suspend("dpm_resume_noirq", dpm_noirq_resume_devices, + NULL, state.event, DSS_FLAG_OUT); trace_suspend_resume(TPS("dpm_resume_noirq"), state.event, false); } @@ -746,6 +752,8 @@ void dpm_resume_early(pm_message_t state) ktime_t starttime = ktime_get(); trace_suspend_resume(TPS("dpm_resume_early"), state.event, true); + dbg_snapshot_suspend("dpm_resume_early", dpm_resume_early, + NULL, state.event, DSS_FLAG_IN); mutex_lock(&dpm_list_mtx); pm_transition = state; @@ -785,6 +793,8 @@ void dpm_resume_early(pm_message_t state) mutex_unlock(&dpm_list_mtx); async_synchronize_full(); dpm_show_time(starttime, state, 0, "early"); + dbg_snapshot_suspend("dpm_resume_early", dpm_resume_early, + NULL, state.event, DSS_FLAG_OUT); trace_suspend_resume(TPS("dpm_resume_early"), state.event, false); } @@ -921,6 +931,8 @@ void dpm_resume(pm_message_t state) ktime_t starttime = ktime_get(); trace_suspend_resume(TPS("dpm_resume"), state.event, true); + dbg_snapshot_suspend("dpm_resume", dpm_resume, + NULL, state.event, DSS_FLAG_IN); might_sleep(); mutex_lock(&dpm_list_mtx); @@ -962,6 +974,8 @@ void dpm_resume(pm_message_t state) dpm_show_time(starttime, state, 0, NULL); cpufreq_resume(); + dbg_snapshot_suspend("dpm_resume", dpm_resume, + NULL, state.event, DSS_FLAG_OUT); trace_suspend_resume(TPS("dpm_resume"), state.event, false); } @@ -1021,6 +1035,8 @@ void dpm_complete(pm_message_t state) struct list_head list; trace_suspend_resume(TPS("dpm_complete"), state.event, true); + dbg_snapshot_suspend("dpm_complete", dpm_complete, + NULL, state.event, DSS_FLAG_OUT); might_sleep(); INIT_LIST_HEAD(&list); @@ -1045,6 +1061,8 @@ void dpm_complete(pm_message_t state) /* Allow device probing and trigger re-probing of deferred devices */ device_unblock_probing(); + dbg_snapshot_suspend("dpm_complete", dpm_complete, + NULL, state.event, DSS_FLAG_OUT); trace_suspend_resume(TPS("dpm_complete"), state.event, false); } @@ -1187,6 +1205,8 @@ int dpm_noirq_suspend_devices(pm_message_t state) int error = 0; trace_suspend_resume(TPS("dpm_suspend_noirq"), state.event, true); + dbg_snapshot_suspend("dpm_suspend_noirq", dpm_noirq_suspend_devices, + NULL, state.event, DSS_FLAG_IN); mutex_lock(&dpm_list_mtx); pm_transition = state; async_error = 0; @@ -1223,6 +1243,8 @@ int dpm_noirq_suspend_devices(pm_message_t state) dpm_save_failed_step(SUSPEND_SUSPEND_NOIRQ); } dpm_show_time(starttime, state, error, "noirq"); + dbg_snapshot_suspend("dpm_suspend_noirq", dpm_noirq_suspend_devices, + NULL, state.event, DSS_FLAG_OUT); trace_suspend_resume(TPS("dpm_suspend_noirq"), state.event, false); return error; } @@ -1345,6 +1367,8 @@ int dpm_suspend_late(pm_message_t state) int error = 0; trace_suspend_resume(TPS("dpm_suspend_late"), state.event, true); + dbg_snapshot_suspend("dpm_suspend_late", dpm_suspend_late, + NULL, state.event, DSS_FLAG_IN); mutex_lock(&dpm_list_mtx); pm_transition = state; async_error = 0; @@ -1382,6 +1406,8 @@ int dpm_suspend_late(pm_message_t state) dpm_resume_early(resume_event(state)); } dpm_show_time(starttime, state, error, "late"); + dbg_snapshot_suspend("dpm_suspend_late", dpm_suspend_late, + NULL, state.event, DSS_FLAG_OUT); trace_suspend_resume(TPS("dpm_suspend_late"), state.event, false); return error; } @@ -1621,6 +1647,7 @@ int dpm_suspend(pm_message_t state) int error = 0; trace_suspend_resume(TPS("dpm_suspend"), state.event, true); + dbg_snapshot_suspend("dpm_suspend", dpm_suspend, NULL, state.event, DSS_FLAG_IN); might_sleep(); cpufreq_suspend(); @@ -1658,6 +1685,7 @@ int dpm_suspend(pm_message_t state) dpm_save_failed_step(SUSPEND_SUSPEND); } dpm_show_time(starttime, state, error, NULL); + dbg_snapshot_suspend("dpm_suspend", dpm_suspend, NULL, state.event, DSS_FLAG_OUT); trace_suspend_resume(TPS("dpm_suspend"), state.event, false); return error; } @@ -1707,8 +1735,10 @@ static int device_prepare(struct device *dev, pm_message_t state) if (!callback && dev->driver && dev->driver->pm) callback = dev->driver->pm->prepare; + dbg_snapshot_suspend("device_prepare", callback, dev, state.event, DSS_FLAG_IN); if (callback) ret = callback(dev); + dbg_snapshot_suspend("device_prepare", callback, dev, state.event, DSS_FLAG_OUT); unlock: device_unlock(dev); @@ -1742,6 +1772,8 @@ int dpm_prepare(pm_message_t state) int error = 0; trace_suspend_resume(TPS("dpm_prepare"), state.event, true); + dbg_snapshot_suspend("dpm_prepare", dpm_prepare, + NULL, state.event, DSS_FLAG_IN); might_sleep(); /* @@ -1788,6 +1820,8 @@ int dpm_prepare(pm_message_t state) put_device(dev); } mutex_unlock(&dpm_list_mtx); + dbg_snapshot_suspend("dpm_prepare", dpm_prepare, + NULL, state.event, DSS_FLAG_OUT); trace_suspend_resume(TPS("dpm_prepare"), state.event, false); return error; } diff --git a/drivers/base/syscore.c b/drivers/base/syscore.c index 96c34a95cc62..516f833adc18 100644 --- a/drivers/base/syscore.c +++ b/drivers/base/syscore.c @@ -65,7 +65,9 @@ int syscore_suspend(void) if (ops->suspend) { if (initcall_debug) pr_info("PM: Calling %pF\n", ops->suspend); + dbg_snapshot_suspend("syscore_suspend", ops->suspend, NULL, 0, DSS_FLAG_IN); ret = ops->suspend(); + dbg_snapshot_suspend("syscore_suspend", ops->suspend, NULL, 0, DSS_FLAG_OUT); if (ret) goto err_out; WARN_ONCE(!irqs_disabled(), @@ -105,7 +107,9 @@ void syscore_resume(void) if (ops->resume) { if (initcall_debug) pr_info("PM: Calling %pF\n", ops->resume); + dbg_snapshot_suspend("syscore_resume", ops->resume, NULL, 0, DSS_FLAG_IN); ops->resume(); + dbg_snapshot_suspend("syscore_resume", ops->resume, NULL, 0, DSS_FLAG_OUT); WARN_ONCE(!irqs_disabled(), "Interrupts enabled after %pF\n", ops->resume); } @@ -127,7 +131,9 @@ void syscore_shutdown(void) if (ops->shutdown) { if (initcall_debug) pr_info("PM: Calling %pF\n", ops->shutdown); + dbg_snapshot_suspend("syscore_shutdown", ops->shutdown, NULL, 0, DSS_FLAG_IN); ops->shutdown(); + dbg_snapshot_suspend("syscore_shutdown", ops->shutdown, NULL, 0, DSS_FLAG_OUT); } mutex_unlock(&syscore_ops_lock); diff --git a/include/linux/debug-snapshot.h b/include/linux/debug-snapshot.h index 7605449b1673..2961dca8ed45 100644 --- a/include/linux/debug-snapshot.h +++ b/include/linux/debug-snapshot.h @@ -23,7 +23,7 @@ extern void dbg_snapshot_task(int cpu, void *v_task); extern void dbg_snapshot_work(void *worker, void *v_task, void *fn, int en); extern void dbg_snapshot_cpuidle(char *modes, unsigned state, int diff, int en); -extern void dbg_snapshot_suspend(void *fn, void *dev, int en); +extern void dbg_snapshot_suspend(char *log, void *fn, void *dev, int state, int en); extern void dbg_snapshot_irq(int irq, void *fn, void *val, int en); extern void dbg_snapshot_print_notifier_call(void **nl, unsigned long func, int en); extern int dbg_snapshot_try_enable(const char *name, unsigned long long duration); @@ -191,7 +191,7 @@ extern void dbg_snapshot_binder(struct trace_binder_transaction_base *base, #define dbg_snapshot_work(a,b,c,d) do { } while(0) #define dbg_snapshot_clockevent(a,b,c) do { } while(0) #define dbg_snapshot_cpuidle(a,b,c,d) do { } while(0) -#define dbg_snapshot_suspend(a,b,c) do { } while(0) +#define dbg_snapshot_suspend(a,b,c,d,e) do { } while(0) #define dbg_snapshot_regulator(a,b,c,d,e,f) do { } while(0) #define dbg_snapshot_thermal(a,b,c,d) do { } while(0) #define dbg_snapshot_irq(a,b,c,d) do { } while(0) @@ -259,6 +259,7 @@ static inline void dbg_snapshot_spin_func(void) {do {wfi();} while(1);} extern struct atomic_notifier_head restart_handler_list; extern struct blocking_notifier_head reboot_notifier_list; +extern struct blocking_notifier_head pm_chain_head; #ifdef CONFIG_EXYNOS_ITMON extern struct atomic_notifier_head itmon_notifier_list; diff --git a/kernel/cpu.c b/kernel/cpu.c index 0aa6637bb102..63a28b94b6ac 100644 --- a/kernel/cpu.c +++ b/kernel/cpu.c @@ -1608,7 +1608,9 @@ int freeze_secondary_cpus(int primary) if (cpu == primary) continue; trace_suspend_resume(TPS("CPU_OFF"), cpu, true); + dbg_snapshot_suspend("CPU_OFF", _cpu_down, NULL, cpu, DSS_FLAG_IN); error = _cpu_down(cpu, 1, CPUHP_OFFLINE); + dbg_snapshot_suspend("CPU_OFF", _cpu_down, NULL, cpu, DSS_FLAG_OUT); trace_suspend_resume(TPS("CPU_OFF"), cpu, false); if (!error) cpumask_set_cpu(cpu, frozen_cpus); @@ -1659,7 +1661,9 @@ void enable_nonboot_cpus(void) for_each_cpu(cpu, frozen_cpus) { trace_suspend_resume(TPS("CPU_ON"), cpu, true); + dbg_snapshot_suspend("CPU_ON", _cpu_up, NULL, cpu, DSS_FLAG_IN); error = _cpu_up(cpu, 1, CPUHP_ONLINE); + dbg_snapshot_suspend("CPU_ON", _cpu_up, NULL, cpu, DSS_FLAG_OUT); trace_suspend_resume(TPS("CPU_ON"), cpu, false); if (!error) { pr_info("CPU%d is up\n", cpu); diff --git a/kernel/power/hibernate.c b/kernel/power/hibernate.c index a5c36e9c56a6..90b5ce9be90e 100644 --- a/kernel/power/hibernate.c +++ b/kernel/power/hibernate.c @@ -299,9 +299,13 @@ static int create_image(int platform_mode) in_suspend = 1; save_processor_state(); trace_suspend_resume(TPS("machine_suspend"), PM_EVENT_HIBERNATE, true); + dbg_snapshot_suspend("machine_suspend", swsusp_arch_suspend, + NULL, PM_EVENT_HIBERNATE, DSS_FLAG_IN); error = swsusp_arch_suspend(); /* Restore control flow magically appears here */ restore_processor_state(); + dbg_snapshot_suspend("machine_suspend", swsusp_arch_suspend, + NULL, PM_EVENT_HIBERNATE, DSS_FLAG_OUT); trace_suspend_resume(TPS("machine_suspend"), PM_EVENT_HIBERNATE, false); if (error) pr_err("Error %d creating hibernation image\n", error); diff --git a/kernel/power/main.c b/kernel/power/main.c index 3a2ca9066583..c214e35d0603 100644 --- a/kernel/power/main.c +++ b/kernel/power/main.c @@ -24,7 +24,7 @@ DEFINE_MUTEX(pm_mutex); /* Routines for PM-transition notifications */ -static BLOCKING_NOTIFIER_HEAD(pm_chain_head); +BLOCKING_NOTIFIER_HEAD(pm_chain_head); int register_pm_notifier(struct notifier_block *nb) { diff --git a/kernel/power/process.c b/kernel/power/process.c index c366e3d34a07..5aba86d73715 100644 --- a/kernel/power/process.c +++ b/kernel/power/process.c @@ -202,6 +202,7 @@ void thaw_processes(void) struct task_struct *curr = current; trace_suspend_resume(TPS("thaw_processes"), 0, true); + dbg_snapshot_suspend("thaw_processes", thaw_processes, NULL, 0, DSS_FLAG_IN); if (pm_freezing) atomic_dec(&system_freezing_cnt); pm_freezing = false; @@ -231,6 +232,7 @@ void thaw_processes(void) schedule(); pr_cont("done.\n"); + dbg_snapshot_suspend("thaw_processes", thaw_processes, NULL, 0, DSS_FLAG_OUT); trace_suspend_resume(TPS("thaw_processes"), 0, false); } diff --git a/kernel/power/suspend.c b/kernel/power/suspend.c index 4789ca7e1019..06a118fb6ded 100644 --- a/kernel/power/suspend.c +++ b/kernel/power/suspend.c @@ -78,6 +78,8 @@ static void s2idle_begin(void) static void s2idle_enter(void) { trace_suspend_resume(TPS("machine_suspend"), PM_SUSPEND_TO_IDLE, true); + dbg_snapshot_suspend("machine_suspend", s2idle_enter, NULL, + PM_SUSPEND_TO_IDLE, DSS_FLAG_IN); raw_spin_lock_irq(&s2idle_lock); if (pm_wakeup_pending()) @@ -104,6 +106,8 @@ static void s2idle_enter(void) s2idle_state = S2IDLE_STATE_NONE; raw_spin_unlock_irq(&s2idle_lock); + dbg_snapshot_suspend("machine_suspend", s2idle_enter, NULL, + PM_SUSPEND_TO_IDLE, DSS_FLAG_OUT); trace_suspend_resume(TPS("machine_suspend"), PM_SUSPEND_TO_IDLE, false); } @@ -356,7 +360,11 @@ static int suspend_prepare(suspend_state_t state) } trace_suspend_resume(TPS("freeze_processes"), 0, true); + dbg_snapshot_suspend("freeze_processes", suspend_freeze_processes, + NULL, 0, DSS_FLAG_IN); error = suspend_freeze_processes(); + dbg_snapshot_suspend("freeze_processes", suspend_freeze_processes, + NULL, 0, DSS_FLAG_OUT); trace_suspend_resume(TPS("freeze_processes"), 0, false); if (!error) return 0; @@ -446,7 +454,11 @@ static int suspend_enter(suspend_state_t state, bool *wakeup) if (!(suspend_test(TEST_CORE) || *wakeup)) { trace_suspend_resume(TPS("machine_suspend"), state, true); + dbg_snapshot_suspend("machine_suspend", suspend_ops->enter, + NULL, state, DSS_FLAG_IN); error = suspend_ops->enter(state); + dbg_snapshot_suspend("machine_suspend", suspend_ops->enter, + NULL, state, DSS_FLAG_OUT); trace_suspend_resume(TPS("machine_suspend"), state, false); } else if (*wakeup) { @@ -518,9 +530,12 @@ int suspend_devices_and_enter(suspend_state_t state) dpm_resume_end(PMSG_RESUME); suspend_test_finish("resume devices"); trace_suspend_resume(TPS("resume_console"), state, true); + dbg_snapshot_suspend("resume_console", resume_console, + NULL, state, DSS_FLAG_IN); resume_console(); + dbg_snapshot_suspend("resume_console", resume_console, + NULL, state, DSS_FLAG_OUT); trace_suspend_resume(TPS("resume_console"), state, false); - Close: platform_resume_end(state); pm_suspend_target_state = PM_SUSPEND_ON; @@ -557,6 +572,7 @@ static int enter_state(suspend_state_t state) int error; trace_suspend_resume(TPS("suspend_enter"), state, true); + dbg_snapshot_suspend("suspend_enter", enter_state, NULL, state, DSS_FLAG_IN); if (state == PM_SUSPEND_TO_IDLE) { #ifdef CONFIG_PM_DEBUG if (pm_test_level != TEST_NONE && pm_test_level <= TEST_CPUS) { @@ -575,9 +591,11 @@ static int enter_state(suspend_state_t state) #ifndef CONFIG_SUSPEND_SKIP_SYNC trace_suspend_resume(TPS("sync_filesystems"), 0, true); + dbg_snapshot_suspend("sync_filesystems", sys_sync, NULL, state, DSS_FLAG_IN); pr_info("Syncing filesystems ... "); sys_sync(); pr_cont("done.\n"); + dbg_snapshot_suspend("sync_filesystems", sys_sync, NULL, state, DSS_FLAG_OUT); trace_suspend_resume(TPS("sync_filesystems"), 0, false); #endif @@ -590,6 +608,7 @@ static int enter_state(suspend_state_t state) if (suspend_test(TEST_FREEZER)) goto Finish; + dbg_snapshot_suspend("suspend_enter", enter_state, NULL, state, DSS_FLAG_OUT); trace_suspend_resume(TPS("suspend_enter"), state, false); pm_pr_dbg("Suspending system (%s)\n", mem_sleep_labels[state]); pm_restrict_gfp_mask(); diff --git a/kernel/time/tick-common.c b/kernel/time/tick-common.c index 49edc1c4f3e6..5ee818b2d368 100644 --- a/kernel/time/tick-common.c +++ b/kernel/time/tick-common.c @@ -490,6 +490,8 @@ void tick_freeze(void) if (tick_freeze_depth == num_online_cpus()) { trace_suspend_resume(TPS("timekeeping_freeze"), smp_processor_id(), true); + dbg_snapshot_suspend("timekeeping_freeze", timekeeping_suspend, + NULL, smp_processor_id(), DSS_FLAG_IN); timekeeping_suspend(); } else { tick_suspend_local(); @@ -513,6 +515,8 @@ void tick_unfreeze(void) if (tick_freeze_depth == num_online_cpus()) { timekeeping_resume(); + dbg_snapshot_suspend("timekeeping_freeze", timekeeping_suspend, + NULL, smp_processor_id(), DSS_FLAG_OUT); trace_suspend_resume(TPS("timekeeping_freeze"), smp_processor_id(), false); } else { diff --git a/lib/debug-snapshot-log.c b/lib/debug-snapshot-log.c index 028c2fc48cd1..77838950441b 100644 --- a/lib/debug-snapshot-log.c +++ b/lib/debug-snapshot-log.c @@ -29,6 +29,7 @@ #include #include #include +#include #include #include #include @@ -694,19 +695,30 @@ void dbg_snapshot_cpuidle(char *modes, unsigned state, int diff, int en) } } -void dbg_snapshot_suspend(void *fn, void *dev, int en) +void dbg_snapshot_suspend(char *log, void *fn, void *dev, int state, int en) { struct dbg_snapshot_item *item = &dss_items[dss_desc.kevents_num]; if (unlikely(!dss_base.enabled || !item->entry.enabled)) return; { + int len; int cpu = raw_smp_processor_id(); unsigned long i = atomic_inc_return(&dss_idx.suspend_log_idx) & (ARRAY_SIZE(dss_log->suspend) - 1); dss_log->suspend[i].time = cpu_clock(cpu); dss_log->suspend[i].sp = (unsigned long) current_stack_pointer; + + if (log) { + len = strlen(log); + memcpy(dss_log->suspend[i].log, log, + len < DSS_LOG_GEN_LEN ? + len : DSS_LOG_GEN_LEN - 1); + } else { + memset(dss_log->suspend[i].log, 0, DSS_LOG_GEN_LEN - 1); + } + dss_log->suspend[i].fn = fn; dss_log->suspend[i].dev = (struct device *)dev; dss_log->suspend[i].core = cpu; @@ -1060,6 +1072,9 @@ static struct notifier_block **dss_should_check_nl[] = { (struct notifier_block **)(&panic_notifier_list.head), (struct notifier_block **)(&reboot_notifier_list.head), (struct notifier_block **)(&restart_handler_list.head), +#ifdef CONFIG_PM_SLEEP + (struct notifier_block **)(&pm_chain_head.head), +#endif #ifdef CONFIG_EXYNOS_ITMON (struct notifier_block **)(&itmon_notifier_list.head), #endif diff --git a/lib/debug-snapshot-log.h b/lib/debug-snapshot-log.h index 78104afbf4f0..68bab912ff09 100644 --- a/lib/debug-snapshot-log.h +++ b/lib/debug-snapshot-log.h @@ -36,7 +36,8 @@ #define DSS_SPARE_SZ (DSS_HEADER_SIZE - DSS_HEADER_TOTAL_SZ) /* Length domain */ -#define DSS_LOG_STRING_LENGTH SZ_128 +#define DSS_LOG_STRING_LEN SZ_128 +#define DSS_LOG_GEN_LEN SZ_16 #define DSS_MMU_REG_OFFSET SZ_512 #define DSS_CORE_REG_OFFSET SZ_512 #define DSS_LOG_MAX_NUM SZ_1K @@ -118,6 +119,7 @@ struct dbg_snapshot_log { struct __suspend_log { unsigned long long time; unsigned long sp; + char log[DSS_LOG_GEN_LEN]; void *fn; #ifdef CONFIG_DEBUG_SNAPSHOT_LINUX_BUILD struct device *dev; @@ -125,6 +127,7 @@ struct dbg_snapshot_log { void *dev; #endif int en; + int state; int core; } suspend[DSS_LOG_MAX_NUM * 4]; @@ -354,7 +357,7 @@ struct dbg_snapshot_log { struct __printk_log { unsigned long long time; int cpu; - char log[DSS_LOG_STRING_LENGTH]; + char log[DSS_LOG_STRING_LEN]; void *caller[DSS_CALLSTACK_MAX_NUM]; } printk[DSS_API_MAX_NUM]; #endif -- 2.20.1