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 51*f5f9340bSFabien Thomas #include "hwpmc_soft.h" 52*f5f9340bSFabien Thomas 53d07f36b0SJoseph Koshy /* 54d07f36b0SJoseph Koshy * Attempt to walk a user call stack using a too-simple algorithm. 55d07f36b0SJoseph Koshy * In the general case we need unwind information associated with 56d07f36b0SJoseph Koshy * the executable to be able to walk the user stack. 57d07f36b0SJoseph Koshy * 58d07f36b0SJoseph Koshy * We are handed a trap frame laid down at the time the PMC interrupt 59d07f36b0SJoseph Koshy * was taken. If the application is using frame pointers, the saved 60d07f36b0SJoseph Koshy * PC value could be: 61d07f36b0SJoseph Koshy * a. at the beginning of a function before the stack frame is laid 62d07f36b0SJoseph Koshy * down, 63d07f36b0SJoseph Koshy * b. just before a 'ret', after the stack frame has been taken off, 64d07f36b0SJoseph Koshy * c. somewhere else in the function with a valid stack frame being 65d07f36b0SJoseph Koshy * present, 66d07f36b0SJoseph Koshy * 67d07f36b0SJoseph Koshy * If the application is not using frame pointers, this algorithm will 68d07f36b0SJoseph Koshy * fail to yield an interesting call chain. 69d07f36b0SJoseph Koshy * 70d07f36b0SJoseph Koshy * TODO: figure out a way to use unwind information. 71d07f36b0SJoseph Koshy */ 72d07f36b0SJoseph Koshy 73d07f36b0SJoseph Koshy int 74d07f36b0SJoseph Koshy pmc_save_user_callchain(uintptr_t *cc, int nframes, struct trapframe *tf) 75d07f36b0SJoseph Koshy { 76d07f36b0SJoseph Koshy int n; 77d07f36b0SJoseph Koshy uint32_t instr; 78d07f36b0SJoseph Koshy uintptr_t fp, oldfp, pc, r, sp; 79d07f36b0SJoseph Koshy 80d07f36b0SJoseph Koshy KASSERT(TRAPF_USERMODE(tf), ("[x86,%d] Not a user trap frame tf=%p", 81d07f36b0SJoseph Koshy __LINE__, (void *) tf)); 82d07f36b0SJoseph Koshy 83d07f36b0SJoseph Koshy pc = PMC_TRAPFRAME_TO_PC(tf); 84d07f36b0SJoseph Koshy oldfp = fp = PMC_TRAPFRAME_TO_FP(tf); 85d0d0192fSJoseph Koshy sp = PMC_TRAPFRAME_TO_USER_SP(tf); 86d07f36b0SJoseph Koshy 87d07f36b0SJoseph Koshy *cc++ = pc; n = 1; 88d07f36b0SJoseph Koshy 89d07f36b0SJoseph Koshy r = fp + sizeof(uintptr_t); /* points to return address */ 90d07f36b0SJoseph Koshy 91d07f36b0SJoseph Koshy if (!PMC_IN_USERSPACE(pc)) 92d07f36b0SJoseph Koshy return (n); 93d07f36b0SJoseph Koshy 94d07f36b0SJoseph Koshy if (copyin((void *) pc, &instr, sizeof(instr)) != 0) 95d07f36b0SJoseph Koshy return (n); 96d07f36b0SJoseph Koshy 97d07f36b0SJoseph Koshy if (PMC_AT_FUNCTION_PROLOGUE_PUSH_BP(instr) || 98d07f36b0SJoseph Koshy PMC_AT_FUNCTION_EPILOGUE_RET(instr)) { /* ret */ 99d07f36b0SJoseph Koshy if (copyin((void *) sp, &pc, sizeof(pc)) != 0) 100d07f36b0SJoseph Koshy return (n); 101d07f36b0SJoseph Koshy } else if (PMC_AT_FUNCTION_PROLOGUE_MOV_SP_BP(instr)) { 102d07f36b0SJoseph Koshy sp += sizeof(uintptr_t); 103d07f36b0SJoseph Koshy if (copyin((void *) sp, &pc, sizeof(pc)) != 0) 104d07f36b0SJoseph Koshy return (n); 105d07f36b0SJoseph Koshy } else if (copyin((void *) r, &pc, sizeof(pc)) != 0 || 1061a12d24bSEd Maste copyin((void *) fp, &fp, sizeof(fp)) != 0) 107d07f36b0SJoseph Koshy return (n); 108d07f36b0SJoseph Koshy 109d07f36b0SJoseph Koshy for (; n < nframes;) { 110d07f36b0SJoseph Koshy if (pc == 0 || !PMC_IN_USERSPACE(pc)) 111d07f36b0SJoseph Koshy break; 112d07f36b0SJoseph Koshy 113d07f36b0SJoseph Koshy *cc++ = pc; n++; 114d07f36b0SJoseph Koshy 115d07f36b0SJoseph Koshy if (fp < oldfp) 116d07f36b0SJoseph Koshy break; 117d07f36b0SJoseph Koshy 118d07f36b0SJoseph Koshy r = fp + sizeof(uintptr_t); /* address of return address */ 119d07f36b0SJoseph Koshy oldfp = fp; 120d07f36b0SJoseph Koshy 121d07f36b0SJoseph Koshy if (copyin((void *) r, &pc, sizeof(pc)) != 0 || 122d07f36b0SJoseph Koshy copyin((void *) fp, &fp, sizeof(fp)) != 0) 123d07f36b0SJoseph Koshy break; 124d07f36b0SJoseph Koshy } 125d07f36b0SJoseph Koshy 126d07f36b0SJoseph Koshy return (n); 127d07f36b0SJoseph Koshy } 128d07f36b0SJoseph Koshy 129d07f36b0SJoseph Koshy /* 130d07f36b0SJoseph Koshy * Walking the kernel call stack. 131d07f36b0SJoseph Koshy * 132d07f36b0SJoseph Koshy * We are handed the trap frame laid down at the time the PMC 133d07f36b0SJoseph Koshy * interrupt was taken. The saved PC could be: 134d07f36b0SJoseph Koshy * a. in the lowlevel trap handler, meaning that there isn't a C stack 135d07f36b0SJoseph Koshy * to traverse, 136d07f36b0SJoseph Koshy * b. at the beginning of a function before the stack frame is laid 137d07f36b0SJoseph Koshy * down, 138d07f36b0SJoseph Koshy * c. just before a 'ret', after the stack frame has been taken off, 139d07f36b0SJoseph Koshy * d. somewhere else in a function with a valid stack frame being 140d07f36b0SJoseph Koshy * present. 141d07f36b0SJoseph Koshy * 142d07f36b0SJoseph Koshy * In case (d), the previous frame pointer is at [%ebp]/[%rbp] and 143d07f36b0SJoseph Koshy * the return address is at [%ebp+4]/[%rbp+8]. 144d07f36b0SJoseph Koshy * 145d07f36b0SJoseph Koshy * For cases (b) and (c), the return address is at [%esp]/[%rsp] and 146d07f36b0SJoseph Koshy * the frame pointer doesn't need to be changed when going up one 147d07f36b0SJoseph Koshy * level in the stack. 148d07f36b0SJoseph Koshy * 149d07f36b0SJoseph Koshy * For case (a), we check if the PC lies in low-level trap handling 150d07f36b0SJoseph Koshy * code, and if so we terminate our trace. 151d07f36b0SJoseph Koshy */ 152d07f36b0SJoseph Koshy 153d07f36b0SJoseph Koshy int 154d07f36b0SJoseph Koshy pmc_save_kernel_callchain(uintptr_t *cc, int nframes, struct trapframe *tf) 155d07f36b0SJoseph Koshy { 156d07f36b0SJoseph Koshy int n; 157d07f36b0SJoseph Koshy uint32_t instr; 158d07f36b0SJoseph Koshy uintptr_t fp, pc, r, sp, stackstart, stackend; 159d07f36b0SJoseph Koshy struct thread *td; 160d07f36b0SJoseph Koshy 161d07f36b0SJoseph Koshy KASSERT(TRAPF_USERMODE(tf) == 0,("[x86,%d] not a kernel backtrace", 162d07f36b0SJoseph Koshy __LINE__)); 163d07f36b0SJoseph Koshy 164d07f36b0SJoseph Koshy pc = PMC_TRAPFRAME_TO_PC(tf); 165d07f36b0SJoseph Koshy fp = PMC_TRAPFRAME_TO_FP(tf); 166d0d0192fSJoseph Koshy sp = PMC_TRAPFRAME_TO_KERNEL_SP(tf); 167d07f36b0SJoseph Koshy 168d07f36b0SJoseph Koshy *cc++ = pc; 169d07f36b0SJoseph Koshy r = fp + sizeof(uintptr_t); /* points to return address */ 170d07f36b0SJoseph Koshy 171d07f36b0SJoseph Koshy if ((td = curthread) == NULL) 172d07f36b0SJoseph Koshy return (1); 173d07f36b0SJoseph Koshy 174d07f36b0SJoseph Koshy if (nframes <= 1) 175d07f36b0SJoseph Koshy return (1); 176d07f36b0SJoseph Koshy 177d07f36b0SJoseph Koshy stackstart = (uintptr_t) td->td_kstack; 178d07f36b0SJoseph Koshy stackend = (uintptr_t) td->td_kstack + td->td_kstack_pages * PAGE_SIZE; 179d07f36b0SJoseph Koshy 180d07f36b0SJoseph Koshy if (PMC_IN_TRAP_HANDLER(pc) || 181c66e06a2SJoseph Koshy !PMC_IN_KERNEL(pc) || 182c66e06a2SJoseph Koshy !PMC_IN_KERNEL_STACK(r, stackstart, stackend) || 183d07f36b0SJoseph Koshy !PMC_IN_KERNEL_STACK(sp, stackstart, stackend) || 184d07f36b0SJoseph Koshy !PMC_IN_KERNEL_STACK(fp, stackstart, stackend)) 185d07f36b0SJoseph Koshy return (1); 186d07f36b0SJoseph Koshy 187d07f36b0SJoseph Koshy instr = *(uint32_t *) pc; 188d07f36b0SJoseph Koshy 189d07f36b0SJoseph Koshy /* 190d07f36b0SJoseph Koshy * Determine whether the interrupted function was in the 191d07f36b0SJoseph Koshy * processing of either laying down its stack frame or taking 192d07f36b0SJoseph Koshy * it off. 193d07f36b0SJoseph Koshy * 194d07f36b0SJoseph Koshy * If we haven't started laying down a stack frame, or are 195d07f36b0SJoseph Koshy * just about to return, then our caller's address is at 196d07f36b0SJoseph Koshy * *sp, and we don't have a frame to unwind. 197d07f36b0SJoseph Koshy */ 198d07f36b0SJoseph Koshy if (PMC_AT_FUNCTION_PROLOGUE_PUSH_BP(instr) || 199d07f36b0SJoseph Koshy PMC_AT_FUNCTION_EPILOGUE_RET(instr)) 200d07f36b0SJoseph Koshy pc = *(uintptr_t *) sp; 201d07f36b0SJoseph Koshy else if (PMC_AT_FUNCTION_PROLOGUE_MOV_SP_BP(instr)) { 202d07f36b0SJoseph Koshy /* 203d07f36b0SJoseph Koshy * The code was midway through laying down a frame. 204d07f36b0SJoseph Koshy * At this point sp[0] has a frame back pointer, 205d07f36b0SJoseph Koshy * and the caller's address is therefore at sp[1]. 206d07f36b0SJoseph Koshy */ 207d07f36b0SJoseph Koshy sp += sizeof(uintptr_t); 208d07f36b0SJoseph Koshy if (!PMC_IN_KERNEL_STACK(sp, stackstart, stackend)) 209d07f36b0SJoseph Koshy return (1); 210d07f36b0SJoseph Koshy pc = *(uintptr_t *) sp; 211d07f36b0SJoseph Koshy } else { 212d07f36b0SJoseph Koshy /* 213d07f36b0SJoseph Koshy * Not in the function prologue or epilogue. 214d07f36b0SJoseph Koshy */ 215d07f36b0SJoseph Koshy pc = *(uintptr_t *) r; 216d07f36b0SJoseph Koshy fp = *(uintptr_t *) fp; 217d07f36b0SJoseph Koshy } 218d07f36b0SJoseph Koshy 219d07f36b0SJoseph Koshy for (n = 1; n < nframes; n++) { 220d07f36b0SJoseph Koshy *cc++ = pc; 221d07f36b0SJoseph Koshy 222d07f36b0SJoseph Koshy if (PMC_IN_TRAP_HANDLER(pc)) 223d07f36b0SJoseph Koshy break; 224d07f36b0SJoseph Koshy 225d07f36b0SJoseph Koshy r = fp + sizeof(uintptr_t); 226d07f36b0SJoseph Koshy if (!PMC_IN_KERNEL_STACK(fp, stackstart, stackend) || 227c66e06a2SJoseph Koshy !PMC_IN_KERNEL_STACK(r, stackstart, stackend)) 228d07f36b0SJoseph Koshy break; 229d07f36b0SJoseph Koshy pc = *(uintptr_t *) r; 230d07f36b0SJoseph Koshy fp = *(uintptr_t *) fp; 231d07f36b0SJoseph Koshy } 232d07f36b0SJoseph Koshy 233d07f36b0SJoseph Koshy return (n); 234d07f36b0SJoseph Koshy } 235f263522aSJoseph Koshy 236f263522aSJoseph Koshy /* 237f263522aSJoseph Koshy * Machine dependent initialization for x86 class platforms. 238f263522aSJoseph Koshy */ 239f263522aSJoseph Koshy 240f263522aSJoseph Koshy struct pmc_mdep * 241f263522aSJoseph Koshy pmc_md_initialize() 242f263522aSJoseph Koshy { 243e753fde4SJoseph Koshy int i; 244e753fde4SJoseph Koshy struct pmc_mdep *md; 245e753fde4SJoseph Koshy 246f263522aSJoseph Koshy /* determine the CPU kind */ 2475113aa0aSJung-uk Kim if (cpu_vendor_id == CPU_VENDOR_AMD) 248e753fde4SJoseph Koshy md = pmc_amd_initialize(); 2495113aa0aSJung-uk Kim else if (cpu_vendor_id == CPU_VENDOR_INTEL) 250e753fde4SJoseph Koshy md = pmc_intel_initialize(); 251e829eb6dSJoseph Koshy else 25221157ad3SJohn Baldwin return (NULL); 253e753fde4SJoseph Koshy 254e753fde4SJoseph Koshy /* disallow sampling if we do not have an LAPIC */ 255158c4475SEd Maste if (md != NULL && !lapic_enable_pmc()) 256*f5f9340bSFabien Thomas for (i = 0; i < md->pmd_nclass; i++) { 257*f5f9340bSFabien Thomas if (i == PMC_CLASS_INDEX_SOFT) 258*f5f9340bSFabien Thomas continue; 259e829eb6dSJoseph Koshy md->pmd_classdep[i].pcd_caps &= ~PMC_CAP_INTERRUPT; 260*f5f9340bSFabien Thomas } 261e753fde4SJoseph Koshy 262e829eb6dSJoseph Koshy return (md); 263e829eb6dSJoseph Koshy } 264e829eb6dSJoseph Koshy 265e829eb6dSJoseph Koshy void 266e829eb6dSJoseph Koshy pmc_md_finalize(struct pmc_mdep *md) 267e829eb6dSJoseph Koshy { 26821157ad3SJohn Baldwin 26921157ad3SJohn Baldwin lapic_disable_pmc(); 2705113aa0aSJung-uk Kim if (cpu_vendor_id == CPU_VENDOR_AMD) 271e829eb6dSJoseph Koshy pmc_amd_finalize(md); 2725113aa0aSJung-uk Kim else if (cpu_vendor_id == CPU_VENDOR_INTEL) 273e829eb6dSJoseph Koshy pmc_intel_finalize(md); 274e829eb6dSJoseph Koshy else 275e829eb6dSJoseph Koshy KASSERT(0, ("[x86,%d] Unknown vendor", __LINE__)); 276f263522aSJoseph Koshy } 277