static void mdm_fatal_fn(struct work_struct *work) { int i; int value = gpio_get_value(mdm_drv->mdm2ap_errfatal_gpio); if (value == 1) { for (i = HTC_MDM_ERROR_CONFIRM_TIME_MS; i > 0; i--) { msleep(1); if (gpio_get_value(mdm_drv->mdm2ap_errfatal_gpio) == 0) { pr_info("%s: mdm fatal high %d(ms) confirm failed... Abort!\n", __func__, HTC_MDM_ERROR_CONFIRM_TIME_MS); return; } } } else if (value == 0) { pr_info("%s: mdm fatal high is a false alarm!\n", __func__); return; } dump_mdm_related_gpio(); pr_info("### Show Blocked State in ###\n"); show_state_filter(TASK_UNINTERRUPTIBLE); if (get_restart_level() == RESET_SOC) msm_rtb_disable(); if (get_restart_level() == RESET_SOC) set_mdm2ap_errfatal_restart_flag(1); pr_info("%s: Reseting the mdm due to an errfatal\n", __func__); subsystem_restart(EXTERNAL_MODEM); }
static void mdm_crash_dump_dbg_info(void) { dump_mdm_related_gpio(); printk(KERN_INFO "=== Show qcks stack ===\n"); show_thread_group_state_filter("qcks", 0); printk(KERN_INFO "\n"); printk(KERN_INFO "=== Show efsks stack ===\n"); show_thread_group_state_filter("efsks", 0); printk(KERN_INFO "\n"); printk(KERN_INFO "=== Show ks stack ===\n"); show_thread_group_state_filter("ks", 0); printk(KERN_INFO "\n"); pr_info("### Show Blocked State in ###\n"); show_state_filter(TASK_UNINTERRUPTIBLE); if (get_restart_level() == RESET_SOC) msm_rtb_disable(); if (get_restart_level() == RESET_SOC) set_mdm2ap_errfatal_restart_flag(1); }
/*add power status error judge,avoid red screen*/ void lcd_dcm_pwr_status_handler(unsigned long data) { /*Not in factory mode will report this dsm log*/ if( !is_runmode_factory() ) { /*optimize 20110 report strategy for device monitor.*/ if((lcd_pwr_status.lcd_dcm_pwr_status != LCD_PWR_STAT_GOOD)&&(lcd_pwr_status.lcd_dcm_pwr_status != LCD_PWR_STAT_IS_GOOD)) { dsm_client_record(lcd_dclient, "lcd power status wrong, value :%x\n",lcd_pwr_status.lcd_dcm_pwr_status); dsm_client_record(lcd_dclient, "lcd power status :bit 0 do unblank\n"); dsm_client_record(lcd_dclient, "lcd power status :bit 1 lcd on\n"); dsm_client_record(lcd_dclient, "lcd power status :bit 2 set frame\n"); dsm_client_record(lcd_dclient, "lcd power status :bit 3 set backlgiht\n"); dsm_client_record(lcd_dclient, "lcd power status :if did the operation the bit will be set to 1 or the bit is 0\n"); dsm_client_record(lcd_dclient,"unblank at [%d-%d-%d]%d:%d:%d:%d\n",lcd_pwr_status.tm_unblank.tm_year + 1900,lcd_pwr_status.tm_unblank.tm_mon+1, lcd_pwr_status.tm_unblank.tm_mday,lcd_pwr_status.tm_unblank.tm_hour,lcd_pwr_status.tm_unblank.tm_min,lcd_pwr_status.tm_unblank.tm_sec,lcd_pwr_status.tvl_unblank.tv_usec%1000); dsm_client_record(lcd_dclient,"lcd on at [%d-%d-%d]%d:%d:%d:%d\n",lcd_pwr_status.tm_lcd_on.tm_year + 1900,lcd_pwr_status.tm_lcd_on.tm_mon+1, lcd_pwr_status.tm_lcd_on.tm_mday,lcd_pwr_status.tm_lcd_on.tm_hour,lcd_pwr_status.tm_lcd_on.tm_min,lcd_pwr_status.tm_lcd_on.tm_sec,lcd_pwr_status.tvl_lcd_on.tv_usec%1000); dsm_client_record(lcd_dclient,"set frame at [%d-%d-%d]%d:%d:%d:%d\n",lcd_pwr_status.tm_set_frame.tm_year + 1900,lcd_pwr_status.tm_set_frame.tm_mon+1, lcd_pwr_status.tm_set_frame.tm_mday,lcd_pwr_status.tm_set_frame.tm_hour,lcd_pwr_status.tm_set_frame.tm_min,lcd_pwr_status.tm_set_frame.tm_sec,lcd_pwr_status.tvl_set_frame.tv_usec%1000); dsm_client_record(lcd_dclient,"set backlight at [%d-%d-%d]%d:%d:%d:%d\n",lcd_pwr_status.tm_backlight.tm_year + 1900,lcd_pwr_status.tm_backlight.tm_mon+1, lcd_pwr_status.tm_backlight.tm_mday,lcd_pwr_status.tm_backlight.tm_hour,lcd_pwr_status.tm_backlight.tm_min,lcd_pwr_status.tm_backlight.tm_sec,lcd_pwr_status.tvl_backlight.tv_usec%1000); dsm_client_notify(lcd_dclient, DSM_LCD_POWER_STATUS_ERROR_NO); show_state_filter(TASK_UNINTERRUPTIBLE); } } else { /*in factory mode do not report this dsm log,just print a log for locate*/ LCD_LOG_INFO("[%s] in factory mode ignore log of 20110\n",__func__); } lcd_pwr_status.lcd_dcm_pwr_status = 0; }
static void print_other_cpu_stall(struct rcu_state *rsp) { int cpu; long delta; unsigned long flags; struct rcu_node *rnp = rcu_get_root(rsp); struct rcu_node *rnp_cur = rsp->level[NUM_RCU_LVLS - 1]; struct rcu_node *rnp_end = &rsp->node[NUM_RCU_NODES]; /* Only let one CPU complain about others per time interval. */ spin_lock_irqsave(&rnp->lock, flags); delta = jiffies - rsp->jiffies_stall; if (delta < RCU_STALL_RAT_DELAY || rsp->gpnum == rsp->completed) { spin_unlock_irqrestore(&rnp->lock, flags); return; } rsp->jiffies_stall = jiffies + RCU_SECONDS_TILL_STALL_RECHECK; spin_unlock_irqrestore(&rnp->lock, flags); /* OK, time to rat on our buddy... */ printk(KERN_ERR "INFO: RCU detected CPU stalls:"); for (; rnp_cur < rnp_end; rnp_cur++) { if (rnp_cur->qsmask == 0) continue; for (cpu = 0; cpu <= rnp_cur->grphi - rnp_cur->grplo; cpu++) if (rnp_cur->qsmask & (1UL << cpu)) printk(" %d", rnp_cur->grplo + cpu); } printk(" (detected by %d, t=%ld jiffies)\n", smp_processor_id(), (long)(jiffies - rsp->gp_start)); force_quiescent_state(rsp, 0); /* Kick them all. */ show_state_filter(0); }
void htc_debug_watchdog_check_pet(unsigned long long timestamp) { if (!htc_debug_watchdog_enabled() || !htc_debug_watchdog_last_pet) return; if (timestamp - htc_debug_watchdog_last_pet > (unsigned long long)NSEC_PER_THRESHOLD) { if (timestamp - last_pet_check > (unsigned long long)NSEC_PER_SEC) { last_pet_check = timestamp; /* FIXME: * the value of pet_check_counter is not necessary 'seconds' * also, we could avoid using the variable pet_check_counter */ pr_info("\n%s: MSM watchdog was blocked for more than %d seconds!\n", __func__, pet_check_counter++); pr_info("%s: Prepare to dump stack...\n", __func__); dump_stack(); #if defined(CONFIG_HTC_DEBUG_WORKQUEUE) pr_info("%s: Prepare to dump pending works on global workqueue...\n", __func__); htc_debug_workqueue_show_pending_work_on_gcwq(); #endif /* CONFIG_HTC_DEBUG_WORKQUEUE */ pr_info("\n ### Show Blocked State ###\n"); show_state_filter(TASK_UNINTERRUPTIBLE); } } }
static void mdm_status_fn(struct work_struct *work) { int i; int value = gpio_get_value(mdm_drv->mdm2ap_status_gpio); if (!mdm_drv->mdm_ready) return; if (value == 0) { for (i = HTC_MDM_ERROR_CONFIRM_TIME_MS; i > 0; i--) { msleep(1); if (gpio_get_value(mdm_drv->mdm2ap_status_gpio) == 1) { pr_info("%s: mdm status low %d(ms) confirm failed... Abort!\n", __func__, HTC_MDM_ERROR_CONFIRM_TIME_MS); return; } } } if ( ( get_radio_flag() & RADIO_FLAG_USB_UPLOAD ) ) { if ( value == 0 ) { int val_gpio = 0; msleep(40); val_gpio = gpio_get_value(mdm_drv->mdm2ap_hsic_ready_gpio); pr_info("%s:mdm2ap_hsic_ready_gpio=[%d]\n", __func__, val_gpio); } } mdm_status_change_notified = true; mdm_drv->ops->status_cb(mdm_drv, value); pr_debug("%s: status:%d\n", __func__, value); if (value == 0) { pr_info("%s: unexpected reset external modem\n", __func__); dump_mdm_related_gpio(); pr_info("### Show Blocked State in ###\n"); show_state_filter(TASK_UNINTERRUPTIBLE); if (get_restart_level() == RESET_SOC) msm_rtb_disable(); if (get_restart_level() == RESET_SOC) set_mdm2ap_errfatal_restart_flag(1); subsystem_restart(EXTERNAL_MODEM); } else if (value == 1) { pr_info("%s: status = 1: mdm is now ready\n", __func__); } }
static void do_restart(struct work_struct *unused) { #if defined(CONFIG_POWER_KEY_CLR_RESET) clear_hw_reset(); #endif sys_sync(); KEY_LOGI("[PWR] Show Blocked State -- long press power key\n"); show_state_filter(TASK_UNINTERRUPTIBLE); machine_restart("power-key-force-hard"); }
static void sync_timeout_handler(unsigned long data) { if (sys_sync_done == 0) { pr_info("================ show possible blocking tasks ================"); check_all_hung_task(); pr_info("================ show all blocking tasks ================"); pr_info("sys_sync time is too long(more than 3 seconds)"); show_state_filter(TASK_UNINTERRUPTIBLE); } }
static void sysrq_handle_showstate_blocked(int key) { unsigned long flags; local_save_flags(flags); local_irq_enable(); show_state_filter(TASK_UNINTERRUPTIBLE); local_irq_restore(flags); }
static int wdog_fire_set(const char *val, struct kernel_param *kp) { if (smp_processor_id() != 0) { printk("disable other cpus first\n"); return 0; } local_irq_disable(); show_state_filter(0); while (1) ; }
static void power_key_led_on_work_func(struct work_struct *dummy) { KEY_LOGI("[PWR] %s in (%x)\n", __func__, power_key_led_requested); if (power_key_led_requested == 1) { pre_power_key_led_status = 1; KEY_LOGI("[PWR] change power key led on\n"); pm8xxx_led_current_set_for_key(1); set_hw_reason(HW_RESET_REASON); KEY_LOGI("[PWR] Show Blocked State -- long press power key\n"); show_state_filter(TASK_UNINTERRUPTIBLE); } }
static void vfs_write_timeout(unsigned long data) { struct task_struct* tsk = (struct task_struct*) data; pr_warn("%s: vfs_write timed out after %d seconds! dump call stack:\n", __func__, WRITE_TIMEOUT_VALUE); show_stack(tsk, NULL); pr_warn("### Show Blocked State ###\n"); show_state_filter(TASK_UNINTERRUPTIBLE); pr_warn("### Show System Server State ###\n"); show_thread_group_state_filter("system_server", 0); pr_info("### Show bugreport State ###\n"); show_thread_group_state_filter("bugreport", 0); pr_info("### Show adbd State ###\n"); show_thread_group_state_filter("adbd", 0); }
void msm_watchdog_check_pet(unsigned long long timestamp) { if (!enable || !msm_tmr0_base || !check_WDT_EN_footprint()) return; if (timestamp - last_pet > (unsigned long long)NSEC_PER_THRESHOLD) { if (timestamp - last_pet_check > (unsigned long long)NSEC_PER_SEC) { last_pet_check = timestamp; pr_info("\n%s: MSM watchdog was blocked for more than %d seconds!\n", __func__, pet_check_counter++); pr_info("%s: Prepare to dump stack...\n", __func__); dump_stack(); pr_info("%s: Prepare to dump pending works on global workqueue...\n", __func__); // show_pending_work_on_gcwq(); pr_info("\n ### Show Blocked State ###\n"); show_state_filter(TASK_UNINTERRUPTIBLE); } } }
static void sysrq_handle_showstate_blocked(int key) { show_state_filter(TASK_UNINTERRUPTIBLE); }
static void sysrq_handle_showstate_blocked(int key) { show_state_filter(TASK_UNINTERRUPTIBLE); pr_info("### Show All Tasks in System Server ###\n"); show_thread_group_state_filter("system_server", 0); }
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; struct timespec now; struct timespec uptime; struct rtc_time rtc_timestamp; struct console *con; if (!ctx->mmchd || !ctx->mmc_panic_ops || !ctx->mmc_panic_ops->panic_probe) return; if (ctx->mmc_panic_ops->panic_probe(ctx->mmchd, ctx->mmc_panic_ops->type)) { printk(KERN_ERR "apanic: choose to use mmc, " "but eMMC card not detected\n"); return; } console_offset = 1024; if (ctx->curr.magic) { printk(KERN_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); printk(KERN_EMERG "Timestamp = %lu.%03lu\n", (unsigned long)now.tv_sec, (unsigned long)(now.tv_nsec / 1000000)); printk(KERN_EMERG "Current Time = " "%02d-%02d %02d:%02d:%lu.%03lu UTC, " "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); /* * Write out the console */ console_len = apanic_write_console_mmc(console_offset); if (console_len < 0) { printk(KERN_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; ftrace_dump(1); show_state_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; log_buf_clear(); threads_offset = ALIGN(ctx->written, 512); ctx->buf_offset = threads_offset; ctx->written = threads_offset; start_apanic_threads = 1; show_state_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; 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->mmchd, ctx->bounce, 0, console_offset); if (rc <= 0) { printk(KERN_EMERG "apanic: Header write failed (%d)\n", rc); return; } printk(KERN_EMERG "apanic: Panic dump successfully written\n"); }
static void power_key_restart_work_func(struct work_struct *dummy) { #ifndef CONFIG_POWER_VOLUP_RESET int pocket_mode = (board_mfg_mode() == MFG_MODE_NORMAL) ? power_key_check_in_pocket() : 0; KEY_LOGI( "%s: power_key_check_in_pocket = %d\n", __func__, pocket_mode); if (!pocket_mode && pre_power_key_led_status == 1 && !is_rrm1_mode()) { #else uint8_t gpio_val = 0, i, idx_pwr = 9, idx_vup = 9; struct gpio_event_input_info *local = gis; for (i = 0; i < local->keymap_size; i++) { if (local->keymap[i].code == KEY_POWER) { idx_pwr = i; continue; } if (local->keymap[i].code == KEY_VOLUMEUP) idx_vup = i; } gpio_val = !(gpio_get_value(local->keymap[idx_pwr].gpio) | gpio_get_value(local->keymap[idx_vup].gpio)); if (gpio_val && pre_power_key_led_status == 1 && !is_rrm1_mode()) { KEY_LOGI("%s, (PWR+VOL_UP) reset", __func__); #endif set_hw_reason(0); #if defined(CONFIG_PM8921_BMS) && (CONFIG_HTC_BATT_8960) pm8921_store_hw_reset_reason(1); #endif clear_hw_reset(); set_restart_to_ramdump("Powerkey Hard Reset - SW"); msm_restart(0, NULL); } } static DECLARE_DELAYED_WORK(power_key_restart_work, power_key_restart_work_func); #endif static void power_key_led_on_work_func(struct work_struct *dummy) { KEY_LOGI("[PWR] %s in (%x)\n", __func__, power_key_led_requested); if (power_key_led_requested == 1) { pre_power_key_led_status = 1; #ifdef CONFIG_POWER_KEY_CLR_RESET schedule_delayed_work(&power_key_restart_work, PWRKEYKP_DELAY); #endif KEY_LOGI("[PWR] change power key led on\n"); #ifdef CONFIG_QPNP_PWM #ifdef CONFIG_VK_LED qpnp_led_set_for_key(1); #endif #else pm8xxx_led_current_set_for_key(1); #endif #ifdef CONFIG_POWER_KEY_CLR_RESET if(!is_rrm1_mode()) #endif set_hw_reason(HW_RESET_REASON); KEY_LOGI("[PWR] Show Blocked State -- long press power key\n"); show_state_filter(TASK_UNINTERRUPTIBLE); } }