bsd/kern/subr_prof.c

   1 /*
   2  * Copyright (c) 2000-2008 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28 /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
  29 /*-
  30  * Copyright (c) 1982, 1986, 1993
  31  *      The Regents of the University of California.  All rights reserved.
  32  *
  33  * Redistribution and use in source and binary forms, with or without
  34  * modification, are permitted provided that the following conditions
  35  * are met:
  36  * 1. Redistributions of source code must retain the above copyright
  37  *    notice, this list of conditions and the following disclaimer.
  38  * 2. Redistributions in binary form must reproduce the above copyright
  39  *    notice, this list of conditions and the following disclaimer in the
  40  *    documentation and/or other materials provided with the distribution.
  41  * 3. All advertising materials mentioning features or use of this software
  42  *    must display the following acknowledgement:
  43  *      This product includes software developed by the University of
  44  *      California, Berkeley and its contributors.
  45  * 4. Neither the name of the University nor the names of its contributors
  46  *    may be used to endorse or promote products derived from this software
  47  *    without specific prior written permission.
  48  *
  49  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  50  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  51  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  52  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  53  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  54  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  55  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  56  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  57  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  58  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  59  * SUCH DAMAGE.
  60  *
  61  *      @(#)subr_prof.c 8.3 (Berkeley) 9/23/93
  62  */
  63
  64 #ifdef GPROF
  65 #include <libkern/kernel_mach_header.h>
  66 #endif
  67
  68 #include <sys/param.h>
  69 #include <sys/systm.h>
  70 #include <sys/kernel.h>
  71 #include <sys/proc_internal.h>
  72 #include <sys/user.h>
  73 #include <machine/machine_routines.h>
  74
  75 #include <sys/mount_internal.h>
  76 #include <sys/sysproto.h>
  77
  78 #include <mach/mach_types.h>
  79 #include <kern/kern_types.h>
  80 #include <kern/cpu_number.h>
  81 #include <kern/kalloc.h>
  82
  83 #ifdef GPROF
  84 #include <sys/malloc.h>
  85 #include <sys/gmon.h>
  86
  87 extern int sysctl_doprof(int *, u_int, user_addr_t, size_t *,
  88                 user_addr_t, size_t newlen);
  89 extern int sysctl_struct(user_addr_t, size_t *,
  90                 user_addr_t, size_t, void *, int);
  91
  92 lck_spin_t * mcount_lock;
  93 lck_grp_t * mcount_lock_grp;
  94 lck_attr_t * mcount_lock_attr;
  95
  96 /*
  97  * Froms is actually a bunch of unsigned shorts indexing tos
  98  */
  99 struct gmonparam _gmonparam = { .state = GMON_PROF_OFF };
 100
 101 /*
 102  * This code uses 32 bit mach object segment information from the currently
 103  * running kernel.
 104  */
 105 void
 106 kmstartup(void)
 107 {
 108         tostruct_t *cp;
 109         kernel_segment_command_t        *sgp;   /* 32 bit mach object file segment */
 110         struct gmonparam *p = &_gmonparam;
 111
 112         sgp = getsegbyname("__TEXT");
 113         p->lowpc = (u_int32_t)sgp->vmaddr;
 114         p->highpc = (u_int32_t)(sgp->vmaddr + sgp->vmsize);
 115
 116         /*
 117          * Round lowpc and highpc to multiples of the density we're using
 118          * so the rest of the scaling (here and in gprof) stays in ints.
 119          */
 120         p->lowpc = ROUNDDOWN(p->lowpc, HISTFRACTION * sizeof(HISTCOUNTER));
 121         p->highpc = ROUNDUP(p->highpc, HISTFRACTION * sizeof(HISTCOUNTER));
 122         p->textsize = p->highpc - p->lowpc;
 123         printf("Profiling kernel, textsize=%lu [0x%016lx..0x%016lx]\n",
 124                p->textsize, p->lowpc, p->highpc);
 125         p->kcountsize = p->textsize / HISTFRACTION;
 126         p->hashfraction = HASHFRACTION;
 127         p->fromssize = p->textsize / HASHFRACTION;
 128         p->tolimit = p->textsize * ARCDENSITY / 100;
 129         if (p->tolimit < MINARCS)
 130                 p->tolimit = MINARCS;
 131         else if (p->tolimit > MAXARCS)
 132                 p->tolimit = MAXARCS;
 133         p->tossize = p->tolimit * sizeof(tostruct_t);
 134         /* Why not use MALLOC with M_GPROF ? */
 135         cp = (tostruct_t *)kalloc(p->kcountsize + p->fromssize + p->tossize);
 136         if (cp == 0) {
 137                 printf("No memory for profiling.\n");
 138                 return;
 139         }
 140         bzero(cp, p->kcountsize + p->tossize + p->fromssize);
 141         p->tos = cp;
 142         cp = (tostruct_t *)((vm_offset_t)cp + p->tossize);
 143         p->kcount = (u_short *)cp;
 144         cp = (tostruct_t *)((vm_offset_t)cp + p->kcountsize);
 145         p->froms = (u_short *)cp;
 146
 147         mcount_lock_grp = lck_grp_alloc_init("MCOUNT", LCK_GRP_ATTR_NULL);
 148         mcount_lock_attr = lck_attr_alloc_init();
 149         mcount_lock = lck_spin_alloc_init(mcount_lock_grp, mcount_lock_attr);
 150
 151 }
 152
 153 /*
 154  * XXX          These should be broken out into per-argument OID values,
 155  * XXX          since there are no sub-OID parameter values, but unfortunately
 156  * XXX          there is barely enough time for an initial conversion.
 157  *
 158  * Note:        These items appear to be read/write.
 159  */
 160 STATIC int
 161 sysctl_doprofhandle SYSCTL_HANDLER_ARGS
 162 {
 163 sysctl_doprof(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp,
 164               user_addr_t newp, size_t newlen)
 165 {
 166         __unused int cmd = oidp->oid_arg2;      /* subcommand*/
 167         int *name = arg1;               /* oid element argument vector */
 168         int namelen = arg2;             /* number of oid element arguments */
 169         user_addr_t oldp = req->oldptr; /* user buffer copy out address */
 170         size_t *oldlenp = req->oldlen;  /* user buffer copy out size */
 171         user_addr_t newp = req->newptr; /* user buffer copy in address */
 172         size_t newlen = req->newlen;    /* user buffer copy in size */
 173
 174         struct gmonparam *gp = &_gmonparam;
 175         int error = 0;
 176
 177         /* all sysctl names at this level are terminal */
 178         if (namelen != 1)
 179                 return (ENOTDIR);               /* overloaded */
 180
 181         switch (name[0]) {
 182         case GPROF_STATE:
 183                 error = sysctl_int(oldp, oldlenp, newp, newlen, &gp->state);
 184                 if (error)
 185                         break;
 186                 if (gp->state == GMON_PROF_OFF)
 187                         stopprofclock(kernproc);
 188                 else
 189                         startprofclock(kernproc);
 190                 break;
 191         case GPROF_COUNT:
 192                 error = sysctl_struct(oldp, oldlenp, newp, newlen,
 193                                       gp->kcount, gp->kcountsize);
 194                 break;
 195         case GPROF_FROMS:
 196                 error = sysctl_struct(oldp, oldlenp, newp, newlen,
 197                                       gp->froms, gp->fromssize);
 198                 break;
 199         case GPROF_TOS:
 200                 error = sysctl_struct(oldp, oldlenp, newp, newlen,
 201                                       gp->tos, gp->tossize);
 202                 break;
 203         case GPROF_GMONPARAM:
 204                 error = sysctl_rdstruct(oldp, oldlenp, newp, gp, sizeof *gp);
 205                 break;
 206         default:
 207                 error = ENOTSUP;
 208                 break;
 209         }
 210
 211         /* adjust index so we return the right required/consumed amount */
 212         if (!error)
 213                 req->oldidx += req->oldlen;
 214
 215         return(error);
 216 }
 217 SYSCTL_PROC(_kern, KERN_PROF, prof, STLFLAG_NODE|CTLFLAG_RW | CTLFLAG_LOCKED,
 218         0,                      /* Pointer argument (arg1) */
 219         0,                      /* Integer argument (arg2) */
 220         sysctl_doprofhandle,    /* Handler function */
 221         NULL,                   /* No explicit data */
 222         "");
 223
 224
 225 /*
 226  * mcount() called with interrupts disabled.
 227  */
 228 void
 229 mcount(
 230     uintptr_t frompc,
 231     uintptr_t selfpc
 232 )
 233 {
 234     unsigned short *frompcindex;
 235         tostruct_t *top, *prevtop;
 236         struct gmonparam *p = &_gmonparam;
 237         long toindex;
 238
 239     /*
 240      * check that we are profiling
 241      * and that we aren't recursively invoked.
 242      */
 243     if (p->state != GMON_PROF_ON)
 244         return;
 245
 246         lck_spin_lock(mcount_lock);
 247
 248         /*
 249          *      check that frompcindex is a reasonable pc value.
 250          *      for example:    signal catchers get called from the stack,
 251          *                      not from text space.  too bad.
 252          */
 253         frompc -= p->lowpc;
 254         if (frompc > p->textsize)
 255                 goto done;
 256
 257         frompcindex = &p->froms[frompc / (p->hashfraction * sizeof(*p->froms))];
 258         toindex = *frompcindex;
 259         if (toindex == 0) {
 260                 /*
 261                  *      first time traversing this arc
 262                  */
 263                 toindex = ++p->tos[0].link;
 264                 if (toindex >= p->tolimit) {
 265             /* halt further profiling */
 266                         goto overflow;
 267                 }
 268                 *frompcindex = toindex;
 269                 top = &p->tos[toindex];
 270                 top->selfpc = selfpc;
 271                 top->count = 1;
 272                 top->link = 0;
 273                 goto done;
 274         }
 275         top = &p->tos[toindex];
 276         if (top->selfpc == selfpc) {
 277                 /*
 278                  *      arc at front of chain; usual case.
 279                  */
 280                 top->count++;
 281                 goto done;
 282         }
 283         /*
 284          *      have to go looking down chain for it.
 285          *      top points to what we are looking at,
 286          *      prevtop points to previous top.
 287          *      we know it is not at the head of the chain.
 288          */
 289         for (; /* goto done */; ) {
 290                 if (top->link == 0) {
 291                         /*
 292                          *      top is end of the chain and none of the chain
 293                          *      had top->selfpc == selfpc.
 294                          *      so we allocate a new tostruct
 295                          *      and link it to the head of the chain.
 296                          */
 297                         toindex = ++p->tos[0].link;
 298                         if (toindex >= p->tolimit) {
 299                                 goto overflow;
 300                         }
 301                         top = &p->tos[toindex];
 302                         top->selfpc = selfpc;
 303                         top->count = 1;
 304                         top->link = *frompcindex;
 305                         *frompcindex = toindex;
 306                         goto done;
 307                 }
 308                 /*
 309                  *      otherwise, check the next arc on the chain.
 310                  */
 311                 prevtop = top;
 312                 top = &p->tos[top->link];
 313                 if (top->selfpc == selfpc) {
 314                         /*
 315                          *      there it is.
 316                          *      increment its count
 317                          *      move it to the head of the chain.
 318                          */
 319                         top->count++;
 320                         toindex = prevtop->link;
 321                         prevtop->link = top->link;
 322                         top->link = *frompcindex;
 323                         *frompcindex = toindex;
 324                         goto done;
 325                 }
 326
 327         }
 328 done:
 329         lck_spin_unlock(mcount_lock);
 330         return;
 331
 332 overflow:
 333     p->state = GMON_PROF_ERROR;
 334         lck_spin_unlock(mcount_lock);
 335         printf("mcount: tos overflow\n");
 336         return;
 337 }
 338
 339 #endif /* GPROF */
 340
 341 #define PROFILE_LOCK(x)
 342 #define PROFILE_UNLOCK(x)
 343
 344
 345 /*
 346  * Scale is a fixed-point number with the binary point 16 bits
 347  * into the value, and is <= 1.0.  pc is at most 32 bits, so the
 348  * intermediate result is at most 48 bits.
 349  */
 350 //K64todo - this doesn't fit into 64 bit any more, it needs 64+16
 351 #define PC_TO_INDEX(pc, prof) \
 352         ((user_addr_t)(((u_quad_t)((pc) - (prof)->pr_off) * \
 353                         (u_quad_t)((prof)->pr_scale)) >> 16) & ~1)
 354
 355 /*
 356  * Collect user-level profiling statistics; called on a profiling tick,
 357  * when a process is running in user-mode. We use
 358  * an AST that will vector us to trap() with a context in which copyin
 359  * and copyout will work.  Trap will then call addupc_task().
 360  *
 361  * Note that we may (rarely) not get around to the AST soon enough, and
 362  * lose profile ticks when the next tick overwrites this one, but in this
 363  * case the system is overloaded and the profile is probably already
 364  * inaccurate.
 365  *
 366  * We can afford to take faults here.  If the
 367  * update fails, we simply turn off profiling.
 368  */
 369 void
 370 addupc_task(struct proc *p, user_addr_t pc, u_int ticks)
 371 {
 372         user_addr_t off;
 373         u_short count;
 374
 375         /* Testing P_PROFIL may be unnecessary, but is certainly safe. */
 376         if ((p->p_flag & P_PROFIL) == 0 || ticks == 0)
 377                 return;
 378
 379         if (proc_is64bit(p)) {
 380         struct user_uprof *prof;
 381         user_addr_t cell;
 382
 383         for (prof = &p->p_stats->user_p_prof; prof; prof = prof->pr_next) {
 384             off = PC_TO_INDEX(pc, prof);
 385             cell = (prof->pr_base + off);
 386             if (cell >= prof->pr_base &&
 387                 cell < (prof->pr_size + prof->pr_base)) {
 388                 if (copyin(cell, (caddr_t) &count, sizeof(count)) == 0) {
 389                     count += ticks;
 390                     if(copyout((caddr_t) &count, cell, sizeof(count)) == 0)
 391                         return;
 392                 }
 393                 p->p_stats->user_p_prof.pr_scale = 0;
 394                 stopprofclock(p);
 395                 break;
 396             }
 397         }
 398         }
 399         else {
 400         struct uprof *prof;
 401         short *cell;
 402
 403         for (prof = &p->p_stats->p_prof; prof; prof = prof->pr_next) {
 404             off = PC_TO_INDEX(pc,prof);
 405             cell = (short *)(prof->pr_base + off);
 406             if (cell >= (short *)prof->pr_base &&
 407                 cell < (short*)(prof->pr_size + prof->pr_base)) {
 408                 if (copyin(CAST_USER_ADDR_T(cell), (caddr_t) &count, sizeof(count)) == 0) {
 409                     count += ticks;
 410                     if(copyout((caddr_t) &count, CAST_USER_ADDR_T(cell), sizeof(count)) == 0)
 411                         return;
 412                 }
 413                 p->p_stats->p_prof.pr_scale = 0;
 414                 stopprofclock(p);
 415                 break;
 416             }
 417         }
 418         }
 419 }