| /* |
| * Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com) |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 as |
| * published by the Free Software Foundation. |
| * |
| * vineetg Jan 2009 |
| * -Converted strcpy to strncpy |
| * |
| * vineetg: Feb 2008 |
| * |
| * Event capturing Framework |
| * |
| * -Captures the event-id and other iformation in circular log buffer |
| * -Event can be Interrupts, Traps, Sys-Calls, or arbitrary function call |
| * |
| * -USAGE: |
| * Events are defined in API file, include/asm-arc/event-log.h |
| * To log the event, "C" code calls API |
| * take_snap(event-id, event-specific-info) |
| * To log the event, ASM caller calls a "asm" macho |
| * TAKE_SNAP_ASM reg-x, reg-y, event-id |
| * To stop the capture and sort the log buffer, |
| * sort_snaps(halt-after-sort) |
| * |
| * -The reason for 2 APIs is that in low level handlers |
| * which we are interested in capturing, often dont have |
| * stack switched, thus a "C" cpi wont work. Also there |
| * is a very strict requirment of which registers are usable |
| * hence the 2 regs |
| * |
| * -Done primarily to chase the Random Segmentation Faults |
| * when we switched from gcc3.4 to gcc4.2 |
| */ |
| |
| #include <linux/sort.h> |
| #include <linux/sched.h> |
| #include <linux/interrupt.h> |
| #include <asm/current.h> |
| #include <asm/event-log.h> |
| #include <linux/module.h> |
| #include <linux/reboot.h> |
| |
| #ifdef CONFIG_ARC_DBG_EVENT_TIMELINE |
| |
| /* current on ARC is a register variable "r25" setup on entry to kernel and |
| restored back to user value on return. |
| However if the event snap hostting return is called very late from |
| ISR/EXception return code, r25 might already have been restored to user |
| value, hence would no longer point to current task. This can cause weird |
| de-referencing crashes. Safest option is to undef it and instead define |
| it in terms of current_thread_info() which is derived from SP |
| */ |
| #undef current |
| #define current (current_thread_info()->task) |
| |
| /* Log buffer which stores the event info |
| * |
| * There is race condition when the counter goes 1 more than |
| * max-value (if intr sneaks in in the lgging routine. Since |
| * we dont want to do fancy intr-enable-disable etc, |
| * we keep 1 extar element in log buffer |
| */ |
| timeline_log_t timeline_log[MAX_SNAPS+1]; |
| |
| /* counter in log bugger for next entry */ |
| int timeline_ctr; |
| |
| /* Used in the low level asm handler to free up a reg */ |
| int tmp_save_reg, tmp_save_reg2; |
| int l2_ctr; |
| |
| /* Event capture API */ |
| void take_snap(int event, unsigned int arg1, unsigned int arg2) |
| { |
| timeline_log[timeline_ctr].time = read_new_aux_reg(ARC_REG_TIMER1_CNT); |
| timeline_log[timeline_ctr].task = current->pid; |
| timeline_log[timeline_ctr].event = event; |
| timeline_log[timeline_ctr].extra2 = read_new_aux_reg(0xa); //status32 |
| |
| timeline_log[timeline_ctr].cause = read_new_aux_reg(0x403); //ecr |
| timeline_log[timeline_ctr].fault_addr = read_new_aux_reg(0x404); // efa |
| |
| timeline_log[timeline_ctr].extra = arg1; |
| timeline_log[timeline_ctr].sp = arg2; |
| |
| timeline_log[timeline_ctr].extra3 = |
| (unsigned int)__builtin_return_address(0); |
| |
| if ( timeline_ctr == (MAX_SNAPS - 1) ) timeline_ctr=0; |
| else timeline_ctr++; |
| |
| } |
| |
| void take_snap2(int event) |
| { |
| unsigned long x, flags=0, stat32; |
| |
| stat32 = read_new_aux_reg(0xa); //status32 |
| |
| /* In case this is for Level 1 ISR, disable further Interrupts |
| * so that timeline_ctr is not clobbered |
| */ |
| if (event == SNAP_INTR_IN ) |
| local_irq_save(flags); |
| |
| timeline_log[timeline_ctr].time = read_new_aux_reg(ARC_REG_TIMER1_CNT); |
| timeline_log[timeline_ctr].task = current->pid; |
| timeline_log[timeline_ctr].event = event; |
| timeline_log[timeline_ctr].extra2 = stat32; |
| |
| timeline_log[timeline_ctr].sp = current_thread_info()->preempt_count; |
| |
| if (event == SNAP_INTR_IN2 ) { |
| timeline_log[timeline_ctr].cause = read_new_aux_reg(0x40B); //icause2 |
| timeline_log[timeline_ctr].extra = read_new_aux_reg(0x0C); // statsu32_l2 |
| __asm__ __volatile__( |
| "mov %0, ilink2 \r\n" |
| :"=r" (x)); |
| timeline_log[timeline_ctr].fault_addr = x; |
| } |
| else if (event == SNAP_INTR_IN ) { |
| timeline_log[timeline_ctr].cause = read_new_aux_reg(0x40A); //icause1 |
| timeline_log[timeline_ctr].extra = read_new_aux_reg(0x0B); // statsu32_l1 |
| __asm__ __volatile__( |
| "mov %0, ilink1 \r\n" |
| :"=r" (x)); |
| timeline_log[timeline_ctr].fault_addr = x; |
| } |
| |
| if ( timeline_ctr == (MAX_SNAPS - 1) ) timeline_ctr=0; |
| else timeline_ctr++; |
| |
| if (current_thread_info()->preempt_count == 0xFFFFFFFF) |
| sort_snaps(1); |
| |
| if (event == SNAP_INTR_IN ) |
| local_irq_restore(flags); |
| } |
| |
| /* CMP routine called by event sort |
| * When comparing the click time entries of @a to @b: |
| * gt: returns 1 |
| * lt: -1 |
| * eq: returns 0 |
| */ |
| static int snap_cmp(const void *a, const void *b) |
| { |
| timeline_log_t *click_a, *click_b; |
| |
| click_a = (timeline_log_t *)a; |
| click_b = (timeline_log_t *)b; |
| |
| if ( click_a->time == click_b->time ) return 0; |
| else if ( click_a->time < click_b->time ) return -1; |
| |
| return 1; |
| } |
| |
| /* Event Sort API, so that counter Rollover is not visibel to user */ |
| void sort_snaps(int halt_after_sort) |
| { |
| int i; |
| unsigned int flags, tmp; |
| |
| /* TODO SMP */ |
| local_irq_save(flags); |
| |
| take_snap(SNAP_SENTINEL, 0, 0); |
| |
| sort(timeline_log, MAX_SNAPS, sizeof(timeline_log_t), snap_cmp, NULL |
| //click_swap |
| ); |
| |
| for ( i = 0; i < MAX_SNAPS; i++) { |
| memset(timeline_log[i].nm, 0, 16); |
| |
| switch(timeline_log[i].event) |
| { |
| case SNAP_TLB_FLUSH_ALL: |
| strcpy(timeline_log[i].nm, "TLB FLUSH ALL"); |
| break; |
| case 85: |
| strcpy(timeline_log[i].nm, "FORK"); |
| break; |
| case 86: |
| strcpy(timeline_log[i].nm, "EXEC"); |
| break; |
| case 99: |
| strcpy(timeline_log[i].nm, "Slow-TLB-Write"); |
| break; |
| case SNAP_EXCP_IN: |
| switch (timeline_log[i].cause>>16) { |
| case 0x21: |
| strcpy(timeline_log[i].nm, "I-TLB"); |
| break; |
| case 0x22: |
| strcpy(timeline_log[i].nm, "D-TLB"); |
| break; |
| case 0x23: |
| strcpy(timeline_log[i].nm, "PROT-V-TLB"); |
| break; |
| default: |
| strcpy(timeline_log[i].nm, "?#?"); |
| break; |
| } |
| break; |
| case SNAP_EXCP_OUT_FAST: |
| strcpy(timeline_log[i].nm, "TLB Refill"); |
| break; |
| case SNAP_EXCP_OUT: |
| strcpy(timeline_log[i].nm, "Excp-RET"); |
| break; |
| case SNAP_TRAP_IN: |
| strcpy(timeline_log[i].nm, "SyCall :"); |
| switch (timeline_log[i].cause) { |
| case 1: |
| strcat(timeline_log[i].nm, "Exit"); |
| break; |
| case 2: |
| strcat(timeline_log[i].nm, "fork"); |
| break; |
| case 114: |
| strcat(timeline_log[i].nm, "wait4"); |
| break; |
| default: |
| strcat(timeline_log[i].nm, "???"); |
| } |
| break; |
| case SNAP_TRAP_OUT: |
| strcpy(timeline_log[i].nm, "SyCall-RET"); |
| break; |
| case SNAP_PRE_CTXSW_2_U: |
| strcpy(timeline_log[i].nm, "2-U-Ctx-sw"); |
| break; |
| case SNAP_SENTINEL: |
| memset(&timeline_log[i], 0, sizeof(timeline_log[i])); |
| strcpy(timeline_log[i].nm, "----------"); |
| break; |
| case SNAP_PRE_CTXSW_2_K: |
| strcpy(timeline_log[i].nm, "2-K-Ctx-sw"); |
| break; |
| case SNAP_INTR_OUT: |
| strcpy(timeline_log[i].nm, "IRQ-OUT"); |
| break; |
| case SNAP_INTR_OUT2: |
| strcpy(timeline_log[i].nm, "IRQ(2)-OUT"); |
| break; |
| case SNAP_INTR_IN: |
| strcpy(timeline_log[i].nm, "IRQ-in"); |
| break; |
| case SNAP_INTR_IN2: |
| strcpy(timeline_log[i].nm, "IRQ(2)-in"); |
| break; |
| case SNAP_DO_PF_EXIT: |
| strcpy(timeline_log[i].nm, "PF-RET"); |
| break; |
| case SNAP_PREEMPT_SCH_IRQ: |
| strcpy(timeline_log[i].nm, "Prem-Sch IRQ"); |
| break; |
| case SNAP_PREEMPT_SCH: |
| strcpy(timeline_log[i].nm, "Prem-Sch"); |
| break; |
| case SNAP_DO_PF_ENTER: |
| tmp = timeline_log[i].cause >> 16; |
| switch (tmp) { |
| case 0x21: |
| strcpy(timeline_log[i].nm, "PF-in:I-TLB"); |
| break; |
| case 0x22: |
| strcpy(timeline_log[i].nm, "PF-in:D-TLB"); |
| break; |
| case 0x23: |
| strcpy(timeline_log[i].nm, "PF-in:PROTV"); |
| break; |
| default: |
| strcpy(timeline_log[i].nm, "PF-in:???"); |
| break; |
| } |
| break; |
| case SNAP_SIGRETURN: |
| strcpy(timeline_log[i].nm, "sigreturn"); |
| break; |
| case SNAP_BEFORE_SIG: |
| strcpy(timeline_log[i].nm, "before sig"); |
| break; |
| } |
| |
| } |
| |
| #if 0 |
| printk("\n##### Last Few System Events ####\n"); |
| for ( i= MAX_SNAPS-10; i< MAX_SNAPS ;i++) |
| printk("%s [%d], PID %d, ECR 0x%x, EFA 0x%x, Extra 0x%x SP 0x%x\n", |
| timeline_log[i].nm, timeline_log[i].event, timeline_log[i].task, |
| timeline_log[i].cause, timeline_log[i].fault_addr, |
| timeline_log[i].extra, timeline_log[i].sp); |
| #endif |
| |
| if (halt_after_sort) |
| __asm__("flag 1"); |
| else |
| local_irq_restore(flags); |
| |
| } |
| |
| EXPORT_SYMBOL(take_snap); |
| EXPORT_SYMBOL(sort_snaps); |
| |
| #endif |
| |
| /*###################################################################### |
| * |
| * |
| * Process fork/exec Profiling |
| * |
| * |
| *#####################################################################*/ |
| |
| |
| #ifdef CONFIG_DEBUG_ARC_PID |
| |
| #define VINEET_MAX 1024 |
| |
| typedef struct { |
| char type; |
| int parentpid; |
| int mypid; |
| char nm[16]; |
| struct task_struct *task; |
| } my_pid_list_t; |
| |
| static my_pid_list_t my_pid_list[VINEET_MAX] = |
| { |
| { .task = &init_task } |
| }; |
| |
| static atomic_t myctr; |
| |
| void fork_exec_log(struct task_struct *p, char fork_or_exec) |
| { |
| atomic_inc(&myctr); |
| if ( myctr.counter == VINEET_MAX ) |
| myctr.counter= 64; |
| |
| memcpy( my_pid_list[myctr.counter].nm, current->comm, 16); |
| my_pid_list[myctr.counter].mypid = p->tgid; |
| my_pid_list[myctr.counter].task = p; |
| my_pid_list[myctr.counter].type = fork_or_exec; |
| |
| if ( fork_or_exec == 'f') |
| my_pid_list[myctr.counter].parentpid = current->pid; |
| else |
| my_pid_list[myctr.counter].parentpid = -1; |
| |
| } |
| |
| #endif |
