Annotation of sys/kern/subr_prof.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: subr_prof.c,v 1.17 2007/03/15 10:22:30 art Exp $ */
! 2: /* $NetBSD: subr_prof.c,v 1.12 1996/04/22 01:38:50 christos Exp $ */
! 3:
! 4: /*-
! 5: * Copyright (c) 1982, 1986, 1993
! 6: * The Regents of the University of California. All rights reserved.
! 7: *
! 8: * Redistribution and use in source and binary forms, with or without
! 9: * modification, are permitted provided that the following conditions
! 10: * are met:
! 11: * 1. Redistributions of source code must retain the above copyright
! 12: * notice, this list of conditions and the following disclaimer.
! 13: * 2. Redistributions in binary form must reproduce the above copyright
! 14: * notice, this list of conditions and the following disclaimer in the
! 15: * documentation and/or other materials provided with the distribution.
! 16: * 3. Neither the name of the University nor the names of its contributors
! 17: * may be used to endorse or promote products derived from this software
! 18: * without specific prior written permission.
! 19: *
! 20: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 21: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 22: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 23: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 24: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 25: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 26: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 27: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 28: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 29: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 30: * SUCH DAMAGE.
! 31: *
! 32: * @(#)subr_prof.c 8.3 (Berkeley) 9/23/93
! 33: */
! 34:
! 35: #include <sys/param.h>
! 36: #include <sys/systm.h>
! 37: #include <sys/kernel.h>
! 38: #include <sys/proc.h>
! 39: #include <sys/user.h>
! 40: #include <sys/mount.h>
! 41: #include <sys/syscallargs.h>
! 42:
! 43: #include <machine/cpu.h>
! 44:
! 45: #ifdef GPROF
! 46: #include <sys/malloc.h>
! 47: #include <sys/gmon.h>
! 48: #include <uvm/uvm_extern.h>
! 49:
! 50: /*
! 51: * Froms is actually a bunch of unsigned shorts indexing tos
! 52: */
! 53: struct gmonparam _gmonparam = { GMON_PROF_OFF };
! 54:
! 55: extern char etext[];
! 56:
! 57:
! 58: void
! 59: kmstartup(void)
! 60: {
! 61: char *cp;
! 62: struct gmonparam *p = &_gmonparam;
! 63: int size;
! 64:
! 65: /*
! 66: * Round lowpc and highpc to multiples of the density we're using
! 67: * so the rest of the scaling (here and in gprof) stays in ints.
! 68: */
! 69: p->lowpc = ROUNDDOWN(KERNBASE, HISTFRACTION * sizeof(HISTCOUNTER));
! 70: p->highpc = ROUNDUP((u_long)etext, HISTFRACTION * sizeof(HISTCOUNTER));
! 71: p->textsize = p->highpc - p->lowpc;
! 72: printf("Profiling kernel, textsize=%ld [%lx..%lx]\n",
! 73: p->textsize, p->lowpc, p->highpc);
! 74: p->kcountsize = p->textsize / HISTFRACTION;
! 75: p->hashfraction = HASHFRACTION;
! 76: p->fromssize = p->textsize / HASHFRACTION;
! 77: p->tolimit = p->textsize * ARCDENSITY / 100;
! 78: if (p->tolimit < MINARCS)
! 79: p->tolimit = MINARCS;
! 80: else if (p->tolimit > MAXARCS)
! 81: p->tolimit = MAXARCS;
! 82: p->tossize = p->tolimit * sizeof(struct tostruct);
! 83: size = p->kcountsize + p->fromssize + p->tossize;
! 84: cp = (char *)uvm_km_zalloc(kernel_map, round_page(size));
! 85: if (cp == 0) {
! 86: printf("No memory for profiling.\n");
! 87: return;
! 88: }
! 89: p->tos = (struct tostruct *)cp;
! 90: cp += p->tossize;
! 91: p->kcount = (u_short *)cp;
! 92: cp += p->kcountsize;
! 93: p->froms = (u_short *)cp;
! 94: }
! 95:
! 96: /*
! 97: * Return kernel profiling information.
! 98: */
! 99: int
! 100: sysctl_doprof(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
! 101: size_t newlen)
! 102: {
! 103: struct gmonparam *gp = &_gmonparam;
! 104: int error;
! 105:
! 106: /* all sysctl names at this level are terminal */
! 107: if (namelen != 1)
! 108: return (ENOTDIR); /* overloaded */
! 109:
! 110: switch (name[0]) {
! 111: case GPROF_STATE:
! 112: error = sysctl_int(oldp, oldlenp, newp, newlen, &gp->state);
! 113: if (error)
! 114: return (error);
! 115: if (gp->state == GMON_PROF_OFF)
! 116: stopprofclock(&proc0);
! 117: else
! 118: startprofclock(&proc0);
! 119: return (0);
! 120: case GPROF_COUNT:
! 121: return (sysctl_struct(oldp, oldlenp, newp, newlen,
! 122: gp->kcount, gp->kcountsize));
! 123: case GPROF_FROMS:
! 124: return (sysctl_struct(oldp, oldlenp, newp, newlen,
! 125: gp->froms, gp->fromssize));
! 126: case GPROF_TOS:
! 127: return (sysctl_struct(oldp, oldlenp, newp, newlen,
! 128: gp->tos, gp->tossize));
! 129: case GPROF_GMONPARAM:
! 130: return (sysctl_rdstruct(oldp, oldlenp, newp, gp, sizeof *gp));
! 131: default:
! 132: return (EOPNOTSUPP);
! 133: }
! 134: /* NOTREACHED */
! 135: }
! 136: #endif /* GPROF */
! 137:
! 138: /*
! 139: * Profiling system call.
! 140: *
! 141: * The scale factor is a fixed point number with 16 bits of fraction, so that
! 142: * 1.0 is represented as 0x10000. A scale factor of 0 turns off profiling.
! 143: */
! 144: /* ARGSUSED */
! 145: int
! 146: sys_profil(struct proc *p, void *v, register_t *retval)
! 147: {
! 148: struct sys_profil_args /* {
! 149: syscallarg(caddr_t) samples;
! 150: syscallarg(size_t) size;
! 151: syscallarg(u_long) offset;
! 152: syscallarg(u_int) scale;
! 153: } */ *uap = v;
! 154: struct uprof *upp;
! 155: int s;
! 156:
! 157: if (SCARG(uap, scale) > (1 << 16))
! 158: return (EINVAL);
! 159: if (SCARG(uap, scale) == 0) {
! 160: stopprofclock(p);
! 161: return (0);
! 162: }
! 163: upp = &p->p_stats->p_prof;
! 164:
! 165: /* Block profile interrupts while changing state. */
! 166: s = splstatclock();
! 167: upp->pr_off = SCARG(uap, offset);
! 168: upp->pr_scale = SCARG(uap, scale);
! 169: upp->pr_base = (caddr_t)SCARG(uap, samples);
! 170: upp->pr_size = SCARG(uap, size);
! 171: startprofclock(p);
! 172: splx(s);
! 173:
! 174: return (0);
! 175: }
! 176:
! 177: /*
! 178: * Scale is a fixed-point number with the binary point 16 bits
! 179: * into the value, and is <= 1.0. pc is at most 32 bits, so the
! 180: * intermediate result is at most 48 bits.
! 181: */
! 182: #define PC_TO_INDEX(pc, prof) \
! 183: ((int)(((u_quad_t)((pc) - (prof)->pr_off) * \
! 184: (u_quad_t)((prof)->pr_scale)) >> 16) & ~1)
! 185:
! 186: /*
! 187: * Collect user-level profiling statistics; called on a profiling tick,
! 188: * when a process is running in user-mode. This routine may be called
! 189: * from an interrupt context. Schedule an AST that will vector us to
! 190: * trap() with a context in which copyin and copyout will work.
! 191: * Trap will then call addupc_task().
! 192: */
! 193: void
! 194: addupc_intr(struct proc *p, u_long pc)
! 195: {
! 196: struct uprof *prof;
! 197:
! 198: prof = &p->p_stats->p_prof;
! 199: if (pc < prof->pr_off || PC_TO_INDEX(pc, prof) >= prof->pr_size)
! 200: return; /* out of range; ignore */
! 201:
! 202: prof->pr_addr = pc;
! 203: prof->pr_ticks++;
! 204: atomic_setbits_int(&p->p_flag, P_OWEUPC);
! 205: need_proftick(p);
! 206: }
! 207:
! 208:
! 209: /*
! 210: * Much like before, but we can afford to take faults here. If the
! 211: * update fails, we simply turn off profiling.
! 212: */
! 213: void
! 214: addupc_task(struct proc *p, u_long pc, u_int nticks)
! 215: {
! 216: struct uprof *prof;
! 217: caddr_t addr;
! 218: u_int i;
! 219: u_short v;
! 220:
! 221: /* Testing P_PROFIL may be unnecessary, but is certainly safe. */
! 222: if ((p->p_flag & P_PROFIL) == 0 || nticks == 0)
! 223: return;
! 224:
! 225: prof = &p->p_stats->p_prof;
! 226: if (pc < prof->pr_off ||
! 227: (i = PC_TO_INDEX(pc, prof)) >= prof->pr_size)
! 228: return;
! 229:
! 230: addr = prof->pr_base + i;
! 231: if (copyin(addr, (caddr_t)&v, sizeof(v)) == 0) {
! 232: v += nticks;
! 233: if (copyout((caddr_t)&v, addr, sizeof(v)) == 0)
! 234: return;
! 235: }
! 236: stopprofclock(p);
! 237: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to subr_prof.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / kern