1f263522aSJoseph Koshy /*- 2d0d0192fSJoseph Koshy * Copyright (c) 2005,2008 Joseph Koshy 3d07f36b0SJoseph Koshy * Copyright (c) 2007 The FreeBSD Foundation 4f263522aSJoseph Koshy * All rights reserved. 5f263522aSJoseph Koshy * 6d07f36b0SJoseph Koshy * Portions of this software were developed by A. Joseph Koshy under 7d07f36b0SJoseph Koshy * sponsorship from the FreeBSD Foundation and Google, Inc. 8d07f36b0SJoseph Koshy * 9f263522aSJoseph Koshy * Redistribution and use in source and binary forms, with or without 10f263522aSJoseph Koshy * modification, are permitted provided that the following conditions 11f263522aSJoseph Koshy * are met: 12f263522aSJoseph Koshy * 1. Redistributions of source code must retain the above copyright 13f263522aSJoseph Koshy * notice, this list of conditions and the following disclaimer. 14f263522aSJoseph Koshy * 2. Redistributions in binary form must reproduce the above copyright 15f263522aSJoseph Koshy * notice, this list of conditions and the following disclaimer in the 16f263522aSJoseph Koshy * documentation and/or other materials provided with the distribution. 17f263522aSJoseph Koshy * 18f263522aSJoseph Koshy * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 19f263522aSJoseph Koshy * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20f263522aSJoseph Koshy * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21f263522aSJoseph Koshy * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 22f263522aSJoseph Koshy * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23f263522aSJoseph Koshy * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24f263522aSJoseph Koshy * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25f263522aSJoseph Koshy * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26f263522aSJoseph Koshy * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27f263522aSJoseph Koshy * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28f263522aSJoseph Koshy * SUCH DAMAGE. 29f263522aSJoseph Koshy */ 30f263522aSJoseph Koshy 31f263522aSJoseph Koshy #include <sys/cdefs.h> 32f263522aSJoseph Koshy __FBSDID("$FreeBSD$"); 33f263522aSJoseph Koshy 34f263522aSJoseph Koshy #include <sys/param.h> 35f263522aSJoseph Koshy #include <sys/bus.h> 36f263522aSJoseph Koshy #include <sys/pmc.h> 37d07f36b0SJoseph Koshy #include <sys/proc.h> 38f263522aSJoseph Koshy #include <sys/systm.h> 39f263522aSJoseph Koshy 40d07f36b0SJoseph Koshy #include <machine/cpu.h> 415113aa0aSJung-uk Kim #include <machine/cputypes.h> 4221157ad3SJohn Baldwin #include <machine/intr_machdep.h> 4321157ad3SJohn Baldwin #include <machine/apicvar.h> 44f263522aSJoseph Koshy #include <machine/pmc_mdep.h> 45f263522aSJoseph Koshy #include <machine/md_var.h> 46f263522aSJoseph Koshy 47d07f36b0SJoseph Koshy #include <vm/vm.h> 48d07f36b0SJoseph Koshy #include <vm/vm_param.h> 49d07f36b0SJoseph Koshy #include <vm/pmap.h> 50d07f36b0SJoseph Koshy 51d07f36b0SJoseph Koshy /* 52d07f36b0SJoseph Koshy * Attempt to walk a user call stack using a too-simple algorithm. 53d07f36b0SJoseph Koshy * In the general case we need unwind information associated with 54d07f36b0SJoseph Koshy * the executable to be able to walk the user stack. 55d07f36b0SJoseph Koshy * 56d07f36b0SJoseph Koshy * We are handed a trap frame laid down at the time the PMC interrupt 57d07f36b0SJoseph Koshy * was taken. If the application is using frame pointers, the saved 58d07f36b0SJoseph Koshy * PC value could be: 59d07f36b0SJoseph Koshy * a. at the beginning of a function before the stack frame is laid 60d07f36b0SJoseph Koshy * down, 61d07f36b0SJoseph Koshy * b. just before a 'ret', after the stack frame has been taken off, 62d07f36b0SJoseph Koshy * c. somewhere else in the function with a valid stack frame being 63d07f36b0SJoseph Koshy * present, 64d07f36b0SJoseph Koshy * 65d07f36b0SJoseph Koshy * If the application is not using frame pointers, this algorithm will 66d07f36b0SJoseph Koshy * fail to yield an interesting call chain. 67d07f36b0SJoseph Koshy * 68d07f36b0SJoseph Koshy * TODO: figure out a way to use unwind information. 69d07f36b0SJoseph Koshy */ 70d07f36b0SJoseph Koshy 71d07f36b0SJoseph Koshy int 72d07f36b0SJoseph Koshy pmc_save_user_callchain(uintptr_t *cc, int nframes, struct trapframe *tf) 73d07f36b0SJoseph Koshy { 74d07f36b0SJoseph Koshy int n; 75d07f36b0SJoseph Koshy uint32_t instr; 76d07f36b0SJoseph Koshy uintptr_t fp, oldfp, pc, r, sp; 77d07f36b0SJoseph Koshy 78d07f36b0SJoseph Koshy KASSERT(TRAPF_USERMODE(tf), ("[x86,%d] Not a user trap frame tf=%p", 79d07f36b0SJoseph Koshy __LINE__, (void *) tf)); 80d07f36b0SJoseph Koshy 81d07f36b0SJoseph Koshy pc = PMC_TRAPFRAME_TO_PC(tf); 82d07f36b0SJoseph Koshy oldfp = fp = PMC_TRAPFRAME_TO_FP(tf); 83d0d0192fSJoseph Koshy sp = PMC_TRAPFRAME_TO_USER_SP(tf); 84d07f36b0SJoseph Koshy 85d07f36b0SJoseph Koshy *cc++ = pc; n = 1; 86d07f36b0SJoseph Koshy 87d07f36b0SJoseph Koshy r = fp + sizeof(uintptr_t); /* points to return address */ 88d07f36b0SJoseph Koshy 89d07f36b0SJoseph Koshy if (!PMC_IN_USERSPACE(pc)) 90d07f36b0SJoseph Koshy return (n); 91d07f36b0SJoseph Koshy 92d07f36b0SJoseph Koshy if (copyin((void *) pc, &instr, sizeof(instr)) != 0) 93d07f36b0SJoseph Koshy return (n); 94d07f36b0SJoseph Koshy 95d07f36b0SJoseph Koshy if (PMC_AT_FUNCTION_PROLOGUE_PUSH_BP(instr) || 96d07f36b0SJoseph Koshy PMC_AT_FUNCTION_EPILOGUE_RET(instr)) { /* ret */ 97d07f36b0SJoseph Koshy if (copyin((void *) sp, &pc, sizeof(pc)) != 0) 98d07f36b0SJoseph Koshy return (n); 99d07f36b0SJoseph Koshy } else if (PMC_AT_FUNCTION_PROLOGUE_MOV_SP_BP(instr)) { 100d07f36b0SJoseph Koshy sp += sizeof(uintptr_t); 101d07f36b0SJoseph Koshy if (copyin((void *) sp, &pc, sizeof(pc)) != 0) 102d07f36b0SJoseph Koshy return (n); 103d07f36b0SJoseph Koshy } else if (copyin((void *) r, &pc, sizeof(pc)) != 0 || 1041a12d24bSEd Maste copyin((void *) fp, &fp, sizeof(fp)) != 0) 105d07f36b0SJoseph Koshy return (n); 106d07f36b0SJoseph Koshy 107d07f36b0SJoseph Koshy for (; n < nframes;) { 108d07f36b0SJoseph Koshy if (pc == 0 || !PMC_IN_USERSPACE(pc)) 109d07f36b0SJoseph Koshy break; 110d07f36b0SJoseph Koshy 111d07f36b0SJoseph Koshy *cc++ = pc; n++; 112d07f36b0SJoseph Koshy 113d07f36b0SJoseph Koshy if (fp < oldfp) 114d07f36b0SJoseph Koshy break; 115d07f36b0SJoseph Koshy 116d07f36b0SJoseph Koshy r = fp + sizeof(uintptr_t); /* address of return address */ 117d07f36b0SJoseph Koshy oldfp = fp; 118d07f36b0SJoseph Koshy 119d07f36b0SJoseph Koshy if (copyin((void *) r, &pc, sizeof(pc)) != 0 || 120d07f36b0SJoseph Koshy copyin((void *) fp, &fp, sizeof(fp)) != 0) 121d07f36b0SJoseph Koshy break; 122d07f36b0SJoseph Koshy } 123d07f36b0SJoseph Koshy 124d07f36b0SJoseph Koshy return (n); 125d07f36b0SJoseph Koshy } 126d07f36b0SJoseph Koshy 127d07f36b0SJoseph Koshy /* 128d07f36b0SJoseph Koshy * Walking the kernel call stack. 129d07f36b0SJoseph Koshy * 130d07f36b0SJoseph Koshy * We are handed the trap frame laid down at the time the PMC 131d07f36b0SJoseph Koshy * interrupt was taken. The saved PC could be: 132d07f36b0SJoseph Koshy * a. in the lowlevel trap handler, meaning that there isn't a C stack 133d07f36b0SJoseph Koshy * to traverse, 134d07f36b0SJoseph Koshy * b. at the beginning of a function before the stack frame is laid 135d07f36b0SJoseph Koshy * down, 136d07f36b0SJoseph Koshy * c. just before a 'ret', after the stack frame has been taken off, 137d07f36b0SJoseph Koshy * d. somewhere else in a function with a valid stack frame being 138d07f36b0SJoseph Koshy * present. 139d07f36b0SJoseph Koshy * 140d07f36b0SJoseph Koshy * In case (d), the previous frame pointer is at [%ebp]/[%rbp] and 141d07f36b0SJoseph Koshy * the return address is at [%ebp+4]/[%rbp+8]. 142d07f36b0SJoseph Koshy * 143d07f36b0SJoseph Koshy * For cases (b) and (c), the return address is at [%esp]/[%rsp] and 144d07f36b0SJoseph Koshy * the frame pointer doesn't need to be changed when going up one 145d07f36b0SJoseph Koshy * level in the stack. 146d07f36b0SJoseph Koshy * 147d07f36b0SJoseph Koshy * For case (a), we check if the PC lies in low-level trap handling 148d07f36b0SJoseph Koshy * code, and if so we terminate our trace. 149d07f36b0SJoseph Koshy */ 150d07f36b0SJoseph Koshy 151d07f36b0SJoseph Koshy int 152d07f36b0SJoseph Koshy pmc_save_kernel_callchain(uintptr_t *cc, int nframes, struct trapframe *tf) 153d07f36b0SJoseph Koshy { 154d07f36b0SJoseph Koshy int n; 155d07f36b0SJoseph Koshy uint32_t instr; 156d07f36b0SJoseph Koshy uintptr_t fp, pc, r, sp, stackstart, stackend; 157d07f36b0SJoseph Koshy struct thread *td; 158d07f36b0SJoseph Koshy 159d07f36b0SJoseph Koshy KASSERT(TRAPF_USERMODE(tf) == 0,("[x86,%d] not a kernel backtrace", 160d07f36b0SJoseph Koshy __LINE__)); 161d07f36b0SJoseph Koshy 162d07f36b0SJoseph Koshy pc = PMC_TRAPFRAME_TO_PC(tf); 163d07f36b0SJoseph Koshy fp = PMC_TRAPFRAME_TO_FP(tf); 164d0d0192fSJoseph Koshy sp = PMC_TRAPFRAME_TO_KERNEL_SP(tf); 165d07f36b0SJoseph Koshy 166d07f36b0SJoseph Koshy *cc++ = pc; 167d07f36b0SJoseph Koshy r = fp + sizeof(uintptr_t); /* points to return address */ 168d07f36b0SJoseph Koshy 169d07f36b0SJoseph Koshy if ((td = curthread) == NULL) 170d07f36b0SJoseph Koshy return (1); 171d07f36b0SJoseph Koshy 172d07f36b0SJoseph Koshy if (nframes <= 1) 173d07f36b0SJoseph Koshy return (1); 174d07f36b0SJoseph Koshy 175d07f36b0SJoseph Koshy stackstart = (uintptr_t) td->td_kstack; 176d07f36b0SJoseph Koshy stackend = (uintptr_t) td->td_kstack + td->td_kstack_pages * PAGE_SIZE; 177d07f36b0SJoseph Koshy 178d07f36b0SJoseph Koshy if (PMC_IN_TRAP_HANDLER(pc) || 179d07f36b0SJoseph Koshy !PMC_IN_KERNEL(pc) || !PMC_IN_KERNEL(r) || 180d07f36b0SJoseph Koshy !PMC_IN_KERNEL_STACK(sp, stackstart, stackend) || 181d07f36b0SJoseph Koshy !PMC_IN_KERNEL_STACK(fp, stackstart, stackend)) 182d07f36b0SJoseph Koshy return (1); 183d07f36b0SJoseph Koshy 184d07f36b0SJoseph Koshy instr = *(uint32_t *) pc; 185d07f36b0SJoseph Koshy 186d07f36b0SJoseph Koshy /* 187d07f36b0SJoseph Koshy * Determine whether the interrupted function was in the 188d07f36b0SJoseph Koshy * processing of either laying down its stack frame or taking 189d07f36b0SJoseph Koshy * it off. 190d07f36b0SJoseph Koshy * 191d07f36b0SJoseph Koshy * If we haven't started laying down a stack frame, or are 192d07f36b0SJoseph Koshy * just about to return, then our caller's address is at 193d07f36b0SJoseph Koshy * *sp, and we don't have a frame to unwind. 194d07f36b0SJoseph Koshy */ 195d07f36b0SJoseph Koshy if (PMC_AT_FUNCTION_PROLOGUE_PUSH_BP(instr) || 196d07f36b0SJoseph Koshy PMC_AT_FUNCTION_EPILOGUE_RET(instr)) 197d07f36b0SJoseph Koshy pc = *(uintptr_t *) sp; 198d07f36b0SJoseph Koshy else if (PMC_AT_FUNCTION_PROLOGUE_MOV_SP_BP(instr)) { 199d07f36b0SJoseph Koshy /* 200d07f36b0SJoseph Koshy * The code was midway through laying down a frame. 201d07f36b0SJoseph Koshy * At this point sp[0] has a frame back pointer, 202d07f36b0SJoseph Koshy * and the caller's address is therefore at sp[1]. 203d07f36b0SJoseph Koshy */ 204d07f36b0SJoseph Koshy sp += sizeof(uintptr_t); 205d07f36b0SJoseph Koshy if (!PMC_IN_KERNEL_STACK(sp, stackstart, stackend)) 206d07f36b0SJoseph Koshy return (1); 207d07f36b0SJoseph Koshy pc = *(uintptr_t *) sp; 208d07f36b0SJoseph Koshy } else { 209d07f36b0SJoseph Koshy /* 210d07f36b0SJoseph Koshy * Not in the function prologue or epilogue. 211d07f36b0SJoseph Koshy */ 212d07f36b0SJoseph Koshy pc = *(uintptr_t *) r; 213d07f36b0SJoseph Koshy fp = *(uintptr_t *) fp; 214d07f36b0SJoseph Koshy } 215d07f36b0SJoseph Koshy 216d07f36b0SJoseph Koshy for (n = 1; n < nframes; n++) { 217d07f36b0SJoseph Koshy *cc++ = pc; 218d07f36b0SJoseph Koshy 219d07f36b0SJoseph Koshy if (PMC_IN_TRAP_HANDLER(pc)) 220d07f36b0SJoseph Koshy break; 221d07f36b0SJoseph Koshy 222d07f36b0SJoseph Koshy r = fp + sizeof(uintptr_t); 223d07f36b0SJoseph Koshy if (!PMC_IN_KERNEL_STACK(fp, stackstart, stackend) || 224d07f36b0SJoseph Koshy !PMC_IN_KERNEL(r)) 225d07f36b0SJoseph Koshy break; 226d07f36b0SJoseph Koshy pc = *(uintptr_t *) r; 227d07f36b0SJoseph Koshy fp = *(uintptr_t *) fp; 228d07f36b0SJoseph Koshy } 229d07f36b0SJoseph Koshy 230d07f36b0SJoseph Koshy return (n); 231d07f36b0SJoseph Koshy } 232f263522aSJoseph Koshy 233f263522aSJoseph Koshy /* 234f263522aSJoseph Koshy * Machine dependent initialization for x86 class platforms. 235f263522aSJoseph Koshy */ 236f263522aSJoseph Koshy 237f263522aSJoseph Koshy struct pmc_mdep * 238f263522aSJoseph Koshy pmc_md_initialize() 239f263522aSJoseph Koshy { 240e753fde4SJoseph Koshy int i; 241e753fde4SJoseph Koshy struct pmc_mdep *md; 242e753fde4SJoseph Koshy 243f263522aSJoseph Koshy /* determine the CPU kind */ 2445113aa0aSJung-uk Kim if (cpu_vendor_id == CPU_VENDOR_AMD) 245e753fde4SJoseph Koshy md = pmc_amd_initialize(); 2465113aa0aSJung-uk Kim else if (cpu_vendor_id == CPU_VENDOR_INTEL) 247e753fde4SJoseph Koshy md = pmc_intel_initialize(); 248e829eb6dSJoseph Koshy else 24921157ad3SJohn Baldwin return (NULL); 250e753fde4SJoseph Koshy 251e753fde4SJoseph Koshy /* disallow sampling if we do not have an LAPIC */ 25221157ad3SJohn Baldwin if (!lapic_enable_pmc()) 253e753fde4SJoseph Koshy for (i = 1; i < md->pmd_nclass; i++) 254e829eb6dSJoseph Koshy md->pmd_classdep[i].pcd_caps &= ~PMC_CAP_INTERRUPT; 255e753fde4SJoseph Koshy 256e829eb6dSJoseph Koshy return (md); 257e829eb6dSJoseph Koshy } 258e829eb6dSJoseph Koshy 259e829eb6dSJoseph Koshy void 260e829eb6dSJoseph Koshy pmc_md_finalize(struct pmc_mdep *md) 261e829eb6dSJoseph Koshy { 26221157ad3SJohn Baldwin 26321157ad3SJohn Baldwin lapic_disable_pmc(); 2645113aa0aSJung-uk Kim if (cpu_vendor_id == CPU_VENDOR_AMD) 265e829eb6dSJoseph Koshy pmc_amd_finalize(md); 2665113aa0aSJung-uk Kim else if (cpu_vendor_id == CPU_VENDOR_INTEL) 267e829eb6dSJoseph Koshy pmc_intel_finalize(md); 268e829eb6dSJoseph Koshy else 269e829eb6dSJoseph Koshy KASSERT(0, ("[x86,%d] Unknown vendor", __LINE__)); 270f263522aSJoseph Koshy } 271