Return to subr_prof.c CVS log

Up to [Apple XNU] / XNU / bsd / kern

Annotation of XNU/bsd/kern/subr_prof.c, revision 1.1

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

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.