/* Common code for rcu_idle_exit() and rcu_irq_enter(), see kernel/rcu/tree.c. */ static void rcu_idle_exit_common(long long oldval) { if (oldval) { RCU_TRACE(trace_rcu_dyntick(TPS("++="), oldval, rcu_dynticks_nesting)); return; } RCU_TRACE(trace_rcu_dyntick(TPS("End"), oldval, rcu_dynticks_nesting)); if (IS_ENABLED(CONFIG_RCU_TRACE) && !is_idle_task(current)) { struct task_struct *idle __maybe_unused = idle_task(smp_processor_id()); RCU_TRACE(trace_rcu_dyntick(TPS("Exit error: not idle task"), oldval, rcu_dynticks_nesting)); ftrace_dump(DUMP_ALL); WARN_ONCE(1, "Current pid: %d comm: %s / Idle pid: %d comm: %s", current->pid, current->comm, idle->pid, idle->comm); /* must be idle task! */ } }
/* Common code for rcu_idle_exit() and rcu_irq_enter(), see kernel/rcutree.c. */ static void rcu_idle_exit_common(long long oldval) { if (oldval) { RCU_TRACE(trace_rcu_dyntick("++=", oldval, rcu_dynticks_nesting)); return; } RCU_TRACE(trace_rcu_dyntick("End", oldval, rcu_dynticks_nesting)); if (!is_idle_task(current)) { struct task_struct *idle = idle_task(smp_processor_id()); RCU_TRACE(trace_rcu_dyntick("Error on exit: not idle task", oldval, rcu_dynticks_nesting)); ftrace_dump(DUMP_ALL); WARN_ONCE(1, "Current pid: %d comm: %s / Idle pid: %d comm: %s", current->pid, current->comm, idle->pid, idle->comm); /* must be idle task! */ } }
/* Common code for rcu_idle_enter() and rcu_irq_exit(), see kernel/rcutree.c. */ static void rcu_idle_enter_common(long long oldval) { if (rcu_dynticks_nesting) { RCU_TRACE(trace_rcu_dyntick("--=", oldval, rcu_dynticks_nesting)); return; } RCU_TRACE(trace_rcu_dyntick("Start", oldval, rcu_dynticks_nesting)); if (!is_idle_task(current)) { struct task_struct *idle = idle_task(smp_processor_id()); RCU_TRACE(trace_rcu_dyntick("Error on entry: not idle task", oldval, rcu_dynticks_nesting)); ftrace_dump(DUMP_ALL); WARN_ONCE(1, "Current pid: %d comm: %s / Idle pid: %d comm: %s", current->pid, current->comm, idle->pid, idle->comm); /* must be idle task! */ } rcu_sched_qs(0); /* implies rcu_bh_qsctr_inc(0) */ }
static void rcu_idle_exit_common(struct rcu_dynticks *rdtp, long long oldval) { smp_mb__before_atomic_inc(); atomic_inc(&rdtp->dynticks); smp_mb__after_atomic_inc(); WARN_ON_ONCE(!(atomic_read(&rdtp->dynticks) & 0x1)); rcu_cleanup_after_idle(smp_processor_id()); trace_rcu_dyntick("End", oldval, rdtp->dynticks_nesting); if (!is_idle_task(current)) { struct task_struct *idle = idle_task(smp_processor_id()); trace_rcu_dyntick("Error on exit: not idle task", oldval, rdtp->dynticks_nesting); ftrace_dump(DUMP_ALL); WARN_ONCE(1, "Current pid: %d comm: %s / Idle pid: %d comm: %s", current->pid, current->comm, idle->pid, idle->comm); } }
/* Common code for rcu_idle_enter() and rcu_irq_exit(), see kernel/rcu/tree.c. */ static void rcu_idle_enter_common(long long newval) { if (newval) { RCU_TRACE(trace_rcu_dyntick(TPS("--="), rcu_dynticks_nesting, newval)); rcu_dynticks_nesting = newval; return; } RCU_TRACE(trace_rcu_dyntick(TPS("Start"), rcu_dynticks_nesting, newval)); if (IS_ENABLED(CONFIG_RCU_TRACE) && !is_idle_task(current)) { struct task_struct *idle __maybe_unused = idle_task(smp_processor_id()); RCU_TRACE(trace_rcu_dyntick(TPS("Entry error: not idle task"), rcu_dynticks_nesting, newval)); ftrace_dump(DUMP_ALL); WARN_ONCE(1, "Current pid: %d comm: %s / Idle pid: %d comm: %s", current->pid, current->comm, idle->pid, idle->comm); /* must be idle task! */ } rcu_sched_qs(); /* implies rcu_bh_inc() */ barrier(); rcu_dynticks_nesting = newval; }
static void sysrq_ftrace_dump(int key) { ftrace_dump(DUMP_ALL); }
static void sysrq_ftrace_dump(int key, struct tty_struct *tty) { ftrace_dump(DUMP_ALL); }
static void apanic_mmc_logbuf_dump(void) { struct apanic_data *ctx = &drv_ctx; struct panic_header *hdr = (struct panic_header *) ctx->bounce; int console_offset = 0; int console_len = 0; int threads_offset = 0; int threads_len = 0; int app_threads_offset = 0; int app_threads_len = 0; int rc = 0; struct timespec now; struct timespec uptime; struct rtc_time rtc_timestamp; struct console *con; if (!ctx->hd || !ctx->mmc_panic_ops || !ctx->mmc_panic_ops->panic_probe) return; if (ctx->mmc_panic_ops->panic_probe(ctx->hd, ctx->mmc_panic_ops->type)) { pr_err("apanic: choose to use mmc, " "but eMMC card not detected\n"); return; } console_offset = 1024; if (ctx->curr.magic) { pr_emerg("Crash partition in use!\n"); return; } /* * Add timestamp to displays current UTC time and uptime (in seconds). */ now = current_kernel_time(); rtc_time_to_tm((unsigned long) now.tv_sec, &rtc_timestamp); do_posix_clock_monotonic_gettime(&uptime); bust_spinlocks(1); pr_emerg("Timestamp = %lu.%03lu\n", (unsigned long) now.tv_sec, (unsigned long) (now.tv_nsec / 1000000)); pr_emerg("Current Time = " "%02d-%02d %02d:%02d:%lu.%03lu, " "Uptime = %lu.%03lu seconds\n", rtc_timestamp.tm_mon + 1, rtc_timestamp.tm_mday, rtc_timestamp.tm_hour, rtc_timestamp.tm_min, (unsigned long) rtc_timestamp.tm_sec, (unsigned long) (now.tv_nsec / 1000000), (unsigned long) uptime.tv_sec, (unsigned long) (uptime.tv_nsec / USEC_PER_SEC)); bust_spinlocks(0); if (ctx->annotation) printk(KERN_EMERG "%s\n", ctx->annotation); touch_hw_watchdog(); /* * Write out the console */ console_len = apanic_write_console_mmc(console_offset); if (console_len < 0) { pr_emerg("Error writing console to panic log! (%d)\n", console_len); console_len = 0; } /* * Write out all threads */ app_threads_offset = (ALIGN(console_offset + console_len, 1024) == 0) ? 1024 : ALIGN(console_offset + console_len, 1024); log_buf_clear(); for (con = console_drivers; con; con = con->next) con->flags &= ~CON_ENABLED; ctx->buf_offset = app_threads_offset; ctx->written = app_threads_offset; start_apanic_threads = 1; if (tracing_get_trace_buf_size() < (SZ_512K + 1)) ftrace_dump(1); show_state_thread_filter(0, SHOW_APP_THREADS); ctx->buf_offset = ALIGN(ctx->written, 512); start_apanic_threads = 0; ctx->written += apanic_write_console_mmc(ctx->buf_offset); app_threads_len = ctx->written - app_threads_offset; touch_hw_watchdog(); log_buf_clear(); threads_offset = ALIGN(ctx->written, 512); ctx->buf_offset = threads_offset; ctx->written = threads_offset; start_apanic_threads = 1; show_state_thread_filter(0, SHOW_KTHREADS); start_apanic_threads = 0; ctx->buf_offset = ALIGN(ctx->written, 512); ctx->written += apanic_write_console_mmc(ctx->buf_offset); threads_len = ctx->written - threads_offset + 512; touch_hw_watchdog(); for (con = console_drivers; con; con = con->next) con->flags |= CON_ENABLED; /* * Finally write the panic header */ memset(ctx->bounce, 0, PAGE_SIZE); hdr->magic = PANIC_MAGIC; hdr->version = PHDR_VERSION; hdr->console_offset = console_offset; hdr->console_length = console_len; hdr->app_threads_offset = app_threads_offset; hdr->app_threads_length = app_threads_len; hdr->threads_offset = threads_offset; hdr->threads_length = threads_len; rc = ctx->mmc_panic_ops->panic_write(ctx->hd, ctx->bounce, 0, console_offset); if (rc <= 0) { pr_emerg("apanic: Header write failed (%d)\n", rc); return; } pr_emerg("apanic: Panic dump successfully written\n"); }