void htc_pm_monitor_init(void)
{
if (htc_pm_monitor_wq == NULL)
return;
queue_delayed_work(htc_pm_monitor_wq, &htc_pm_delayed_work, msecs_to_jiffies(msm_htc_util_delay_time));
spin_lock_init(&lock);
prev_proc_stat = vmalloc(sizeof(int) * MAX_PID);
curr_proc_delta = vmalloc(sizeof(int) * MAX_PID);
task_ptr_array = vmalloc(sizeof(int) * MAX_PID);
memset(prev_proc_stat, 0, sizeof(int) * MAX_PID);
memset(curr_proc_delta, 0, sizeof(int) * MAX_PID);
memset(task_ptr_array, 0, sizeof(int) * MAX_PID);
get_all_cpu_stat(&new_cpu_stat);
get_all_cpu_stat(&old_cpu_stat);
}
void htc_watchdog_monitor_init(void)
{
spin_lock_init(&lock);
prev_proc_stat = vmalloc(sizeof(int) * MAX_PID);
curr_proc_delta = vmalloc(sizeof(int) * MAX_PID);
task_ptr_array = vmalloc(sizeof(int) * MAX_PID);
if (prev_proc_stat)
memset(prev_proc_stat, 0, sizeof(int) * MAX_PID);
if (curr_proc_delta)
memset(curr_proc_delta, 0, sizeof(int) * MAX_PID);
if (task_ptr_array)
memset(task_ptr_array, 0, sizeof(int) * MAX_PID);
get_all_cpu_stat(&old_cpu_stat);
}
/*
* Record the proc cpu statistic when petting watchdog
*/
void htc_watchdog_pet_cpu_record(void)
{
struct task_struct *p;
ulong flags;
struct task_cputime cputime;
if (prev_proc_stat == NULL)
return;
spin_lock_irqsave(&lock, flags);
get_all_cpu_stat(&old_cpu_stat);
/* calculate the cpu time of each process */
for_each_process(p) {
if (p->pid < MAX_PID) {
thread_group_cputime(p, &cputime);
prev_proc_stat[p->pid] = cputime.stime + cputime.utime;
}
}
spin_unlock_irqrestore(&lock, flags);
}
void htc_kernel_top(void)
{
struct task_struct *p;
int top_loading[NUM_BUSY_THREAD_CHECK], i;
unsigned long user_time, system_time, io_time;
unsigned long irq_time, idle_time, delta_time;
ulong flags;
struct task_cputime cputime;
int dump_top_stack = 0;
if (task_ptr_array == NULL ||
curr_proc_delta == NULL ||
prev_proc_stat == NULL)
return;
spin_lock_irqsave(&lock, flags);
get_all_cpu_stat(&new_cpu_stat);
/* calculate the cpu time of each process */
for_each_process(p) {
thread_group_cputime(p, &cputime);
if (p->pid < MAX_PID) {
curr_proc_delta[p->pid] =
(cputime.utime + cputime.stime)
- (prev_proc_stat[p->pid]);
task_ptr_array[p->pid] = p;
}
}
/* sorting to get the top cpu consumers */
sorting(curr_proc_delta, top_loading);
/* calculate the total delta time */
user_time = (unsigned long)((new_cpu_stat.user + new_cpu_stat.nice)
- (old_cpu_stat.user + old_cpu_stat.nice));
system_time = (unsigned long)(new_cpu_stat.system - old_cpu_stat.system);
io_time = (unsigned long)(new_cpu_stat.iowait - old_cpu_stat.iowait);
irq_time = (unsigned long)((new_cpu_stat.irq + new_cpu_stat.softirq)
- (old_cpu_stat.irq + old_cpu_stat.softirq));
idle_time = (unsigned long)
((new_cpu_stat.idle + new_cpu_stat.steal + new_cpu_stat.guest)
- (old_cpu_stat.idle + old_cpu_stat.steal + old_cpu_stat.guest));
delta_time = user_time + system_time + io_time + irq_time + idle_time;
/*
* Check if we need to dump the call stack of top CPU consumers
* If CPU usage keeps 100% for 90 secs
*/
if ((full_loading_counter >= 9) && (full_loading_counter % 3 == 0))
dump_top_stack = 1;
/* print most time consuming processes */
printk("[K] CPU Usage\t\tPID\t\tName\n");
for (i = 0 ; i < NUM_BUSY_THREAD_CHECK ; i++) {
printk("[K] %lu%%\t\t%d\t\t%s\t\t\t%d\n",
curr_proc_delta[top_loading[i]] * 100 / delta_time,
top_loading[i],
task_ptr_array[top_loading[i]]->comm,
curr_proc_delta[top_loading[i]]);
}
/* check if dump busy thread stack */
if (dump_top_stack) {
struct task_struct *t;
for (i = 0 ; i < NUM_BUSY_THREAD_CHECK ; i++) {
if (task_ptr_array[top_loading[i]] != NULL && task_ptr_array[top_loading[i]]->stime > 0) {
t = task_ptr_array[top_loading[i]];
/* dump all the thread stack of this process */
do {
printk("\n[K] ###pid:%d name:%s state:%lu ppid:%d stime:%lu utime:%lu\n",
t->pid, t->comm, t->state, t->real_parent->pid, t->stime, t->utime);
show_stack(t, t->stack);
t = next_thread(t);
} while (t != task_ptr_array[top_loading[i]]);
}
}
}
/* save old values */
for_each_process(p) {
if (p->pid < MAX_PID) {
thread_group_cputime(p, &cputime);
prev_proc_stat[p->pid] = cputime.stime + cputime.utime;
}
}
old_cpu_stat = new_cpu_stat;
memset(curr_proc_delta, 0, sizeof(int) * MAX_PID);
memset(task_ptr_array, 0, sizeof(int) * MAX_PID);
spin_unlock_irqrestore(&lock, flags);
}
void htc_kernel_top(void)
{
struct task_struct *p;
int top_loading[NUM_BUSY_THREAD_CHECK], i;
unsigned long user_time, system_time, io_time;
unsigned long irq_time, idle_time, delta_time;
ulong flags;
struct task_cputime cputime;
int dump_top_stack = 0;
if (task_ptr_array == NULL ||
curr_proc_delta == NULL ||
prev_proc_stat == NULL)
return;
spin_lock_irqsave(&lock, flags);
get_all_cpu_stat(&new_cpu_stat);
for_each_process(p) {
thread_group_cputime(p, &cputime);
if (p->pid < MAX_PID) {
curr_proc_delta[p->pid] =
(cputime.utime + cputime.stime)
- (prev_proc_stat[p->pid]);
task_ptr_array[p->pid] = p;
}
}
sorting(curr_proc_delta, top_loading);
user_time = (unsigned long)((new_cpu_stat.cpustat[CPUTIME_USER] + new_cpu_stat.cpustat[CPUTIME_NICE])
- (old_cpu_stat.cpustat[CPUTIME_USER] + old_cpu_stat.cpustat[CPUTIME_NICE]));
system_time = (unsigned long)(new_cpu_stat.cpustat[CPUTIME_SYSTEM] - old_cpu_stat.cpustat[CPUTIME_SYSTEM]);
io_time = (unsigned long)(new_cpu_stat.cpustat[CPUTIME_IOWAIT] - old_cpu_stat.cpustat[CPUTIME_IOWAIT]);
irq_time = (unsigned long)((new_cpu_stat.cpustat[CPUTIME_IRQ] + new_cpu_stat.cpustat[CPUTIME_SOFTIRQ])
- (old_cpu_stat.cpustat[CPUTIME_IRQ] + old_cpu_stat.cpustat[CPUTIME_SOFTIRQ]));
idle_time = (unsigned long)
((new_cpu_stat.cpustat[CPUTIME_IDLE] + new_cpu_stat.cpustat[CPUTIME_STEAL] + new_cpu_stat.cpustat[CPUTIME_GUEST])
- (old_cpu_stat.cpustat[CPUTIME_IDLE] + old_cpu_stat.cpustat[CPUTIME_STEAL] + old_cpu_stat.cpustat[CPUTIME_GUEST]));
delta_time = user_time + system_time + io_time + irq_time + idle_time;
if ((full_loading_counter >= 9) && (full_loading_counter % 3 == 0))
dump_top_stack = 1;
printk(KERN_INFO "[K] CPU Usage\t\tPID\t\tName\n");
for (i = 0 ; i < NUM_BUSY_THREAD_CHECK ; i++) {
printk(KERN_INFO "[K] %8lu%%\t\t%d\t\t%s\t\t%d\n",
curr_proc_delta[top_loading[i]] * 100 / delta_time,
top_loading[i],
task_ptr_array[top_loading[i]]->comm,
curr_proc_delta[top_loading[i]]);
}
if (dump_top_stack) {
struct task_struct *t;
for (i = 0 ; i < NUM_BUSY_THREAD_CHECK ; i++) {
if (task_ptr_array[top_loading[i]] != NULL && task_ptr_array[top_loading[i]]->stime > 0) {
t = task_ptr_array[top_loading[i]];
do {
printk(KERN_INFO "\n[K] ###pid:%d name:%s state:%lu ppid:%d stime:%lu utime:%lu\n",
t->pid, t->comm, t->state, t->real_parent->pid, t->stime, t->utime);
show_stack(t, t->stack);
t = next_thread(t);
} while (t != task_ptr_array[top_loading[i]]);
}
}
}
for_each_process(p) {
if (p->pid < MAX_PID) {
thread_group_cputime(p, &cputime);
prev_proc_stat[p->pid] = cputime.stime + cputime.utime;
}
}
old_cpu_stat = new_cpu_stat;
memset(curr_proc_delta, 0, sizeof(int) * MAX_PID);
memset(task_ptr_array, 0, sizeof(int) * MAX_PID);
spin_unlock_irqrestore(&lock, flags);
}
/*
* When watchdog bark, print the cpu statistic
*/
void htc_watchdog_top_stat(void)
{
struct task_struct *p;
int top_loading[NUM_BUSY_THREAD_CHECK], i;
unsigned long user_time, system_time, io_time;
unsigned long irq_time, idle_time, delta_time;
ulong flags;
struct task_cputime cputime;
struct cpu_usage_stat new_cpu_stat;
if (task_ptr_array == NULL ||
curr_proc_delta == NULL ||
prev_proc_stat == NULL)
return;
memset(curr_proc_delta, 0, sizeof(int) * MAX_PID);
memset(task_ptr_array, 0, sizeof(int) * MAX_PID);
printk(KERN_ERR"\n\n[K][%s] Start to dump:\n", __func__);
spin_lock_irqsave(&lock, flags);
get_all_cpu_stat(&new_cpu_stat);
/* calculate the cpu time of each process */
for_each_process(p) {
thread_group_cputime(p, &cputime);
if (p->pid < MAX_PID) {
curr_proc_delta[p->pid] =
(cputime.utime + cputime.stime)
- (prev_proc_stat[p->pid]);
task_ptr_array[p->pid] = p;
}
}
/* sorting to get the top cpu consumers */
sorting(curr_proc_delta, top_loading);
/* calculate the total delta time */
user_time = (unsigned long)((new_cpu_stat.user + new_cpu_stat.nice)
- (old_cpu_stat.user + old_cpu_stat.nice));
system_time = (unsigned long)(new_cpu_stat.system - old_cpu_stat.system);
io_time = (unsigned long)(new_cpu_stat.iowait - old_cpu_stat.iowait);
irq_time = (unsigned long)((new_cpu_stat.irq + new_cpu_stat.softirq)
- (old_cpu_stat.irq + old_cpu_stat.softirq));
idle_time = (unsigned long)
((new_cpu_stat.idle + new_cpu_stat.steal + new_cpu_stat.guest)
- (old_cpu_stat.idle + old_cpu_stat.steal + old_cpu_stat.guest));
delta_time = user_time + system_time + io_time + irq_time + idle_time;
/* print most time consuming processes */
printk(KERN_ERR"[K] CPU\t\tPID\t\tName\n");
for (i = 0; i < NUM_BUSY_THREAD_CHECK; i++) {
printk(KERN_ERR "[K] %lu%%\t\t%d\t\t%s\n",
curr_proc_delta[top_loading[i]] * 100 / delta_time,
top_loading[i],
task_ptr_array[top_loading[i]]->comm);
}
spin_unlock_irqrestore(&lock, flags);
printk(KERN_ERR "\n");
}
