sys/dev/hwpmc/hwpmc_x86.c

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