sys/dev/hwpmc/hwpmc_powerpc.c

   1 /*-
   2  * Copyright (c) 2011,2013 Justin Hibbits
   3  * Copyright (c) 2005, Joseph Koshy
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/pmc.h>
  34 #include <sys/pmckern.h>
  35 #include <sys/sysent.h>
  36 #include <sys/systm.h>
  37
  38 #include <machine/pmc_mdep.h>
  39 #include <machine/spr.h>
  40 #include <machine/pte.h>
  41 #include <machine/sr.h>
  42 #include <machine/cpu.h>
  43 #include <machine/stack.h>
  44
  45 #include "hwpmc_powerpc.h"
  46
  47 #ifdef __powerpc64__
  48 #define OFFSET 4 /* Account for the TOC reload slot */
  49 #else
  50 #define OFFSET 0
  51 #endif
  52
  53 struct powerpc_cpu **powerpc_pcpu;
  54
  55 int
  56 pmc_save_kernel_callchain(uintptr_t *cc, int maxsamples,
  57     struct trapframe *tf)
  58 {
  59         uintptr_t *osp, *sp;
  60         uintptr_t pc;
  61         int frames = 0;
  62
  63         cc[frames++] = PMC_TRAPFRAME_TO_PC(tf);
  64         sp = (uintptr_t *)PMC_TRAPFRAME_TO_FP(tf);
  65         osp = (uintptr_t *)PAGE_SIZE;
  66
  67         for (; frames < maxsamples; frames++) {
  68                 if (sp <= osp)
  69                         break;
  70             #ifdef __powerpc64__
  71                 pc = sp[2];
  72             #else
  73                 pc = sp[1];
  74             #endif
  75                 if ((pc & 3) || (pc < 0x100))
  76                         break;
  77
  78                 /*
  79                  * trapexit() and asttrapexit() are sentinels
  80                  * for kernel stack tracing.
  81                  * */
  82                 if (pc + OFFSET == (uintptr_t) &trapexit ||
  83                     pc + OFFSET == (uintptr_t) &asttrapexit)
  84                         break;
  85
  86                 cc[frames] = pc;
  87                 osp = sp;
  88                 sp = (uintptr_t *)*sp;
  89         }
  90         return (frames);
  91 }
  92
  93 static int
  94 powerpc_switch_in(struct pmc_cpu *pc, struct pmc_process *pp)
  95 {
  96
  97         return (0);
  98 }
  99
 100 static int
 101 powerpc_switch_out(struct pmc_cpu *pc, struct pmc_process *pp)
 102 {
 103
 104         return (0);
 105 }
 106
 107 int
 108 powerpc_describe(int cpu, int ri, struct pmc_info *pi, struct pmc **ppmc)
 109 {
 110         int error;
 111         struct pmc_hw *phw;
 112         char powerpc_name[PMC_NAME_MAX];
 113
 114         KASSERT(cpu >= 0 && cpu < pmc_cpu_max(),
 115             ("[powerpc,%d], illegal CPU %d", __LINE__, cpu));
 116
 117         phw = &powerpc_pcpu[cpu]->pc_ppcpmcs[ri];
 118         snprintf(powerpc_name, sizeof(powerpc_name), "POWERPC-%d", ri);
 119         if ((error = copystr(powerpc_name, pi->pm_name, PMC_NAME_MAX,
 120             NULL)) != 0)
 121                 return error;
 122         pi->pm_class = powerpc_pcpu[cpu]->pc_class;
 123         if (phw->phw_state & PMC_PHW_FLAG_IS_ENABLED) {
 124                 pi->pm_enabled = TRUE;
 125                 *ppmc          = phw->phw_pmc;
 126         } else {
 127                 pi->pm_enabled = FALSE;
 128                 *ppmc          = NULL;
 129         }
 130
 131         return (0);
 132 }
 133
 134 int
 135 powerpc_get_config(int cpu, int ri, struct pmc **ppm)
 136 {
 137
 138         *ppm = powerpc_pcpu[cpu]->pc_ppcpmcs[ri].phw_pmc;
 139
 140         return (0);
 141 }
 142
 143 struct pmc_mdep *
 144 pmc_md_initialize()
 145 {
 146         struct pmc_mdep *pmc_mdep;
 147         int error;
 148         uint16_t vers;
 149
 150         /*
 151          * Allocate space for pointers to PMC HW descriptors and for
 152          * the MDEP structure used by MI code.
 153          */
 154         powerpc_pcpu = malloc(sizeof(struct powerpc_cpu *) * pmc_cpu_max(), M_PMC,
 155                            M_WAITOK|M_ZERO);
 156
 157         /* Just one class */
 158         pmc_mdep = pmc_mdep_alloc(1);
 159
 160         vers = mfpvr() >> 16;
 161
 162         pmc_mdep->pmd_switch_in  = powerpc_switch_in;
 163         pmc_mdep->pmd_switch_out = powerpc_switch_out;
 164
 165         switch (vers) {
 166         case MPC7447A:
 167         case MPC7448:
 168         case MPC7450:
 169         case MPC7455:
 170         case MPC7457:
 171                 error = pmc_mpc7xxx_initialize(pmc_mdep);
 172                 break;
 173         case IBM970:
 174         case IBM970FX:
 175         case IBM970MP:
 176                 error = pmc_ppc970_initialize(pmc_mdep);
 177                 break;
 178         case FSL_E500v1:
 179         case FSL_E500v2:
 180         case FSL_E500mc:
 181         case FSL_E5500:
 182                 error = pmc_e500_initialize(pmc_mdep);
 183                 break;
 184         default:
 185                 error = -1;
 186                 break;
 187         }
 188
 189         if (error != 0) {
 190                 pmc_mdep_free(pmc_mdep);
 191                 pmc_mdep = NULL;
 192         }
 193
 194         return (pmc_mdep);
 195 }
 196
 197 void
 198 pmc_md_finalize(struct pmc_mdep *md)
 199 {
 200
 201         free(powerpc_pcpu, M_PMC);
 202         powerpc_pcpu = NULL;
 203 }
 204
 205 int
 206 pmc_save_user_callchain(uintptr_t *cc, int maxsamples,
 207     struct trapframe *tf)
 208 {
 209         uintptr_t *osp, *sp;
 210         int frames = 0;
 211
 212         cc[frames++] = PMC_TRAPFRAME_TO_PC(tf);
 213         sp = (uintptr_t *)PMC_TRAPFRAME_TO_FP(tf);
 214         osp = NULL;
 215
 216         for (; frames < maxsamples; frames++) {
 217                 if (sp <= osp)
 218                         break;
 219                 osp = sp;
 220 #ifdef __powerpc64__
 221                 /* Check if 32-bit mode. */
 222                 if (!(tf->srr1 & PSL_SF)) {
 223                         cc[frames] = fuword32((uint32_t *)sp + 1);
 224                         sp = (uintptr_t *)(uintptr_t)fuword32(sp);
 225                 } else {
 226                         cc[frames] = fuword(sp + 2);
 227                         sp = (uintptr_t *)fuword(sp);
 228                 }
 229 #else
 230                 cc[frames] = fuword32((uint32_t *)sp + 1);
 231                 sp = (uintptr_t *)fuword32(sp);
 232 #endif
 233         }
 234
 235         return (frames);
 236 }