8322 nl: misleading-indentation

[unleashed/tickless.git] / usr / src / lib / libc / port / gen / mon.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*      Copyright (c) 1988 AT&T */
/*        All Rights Reserved   */

/*
 * University Copyright- Copyright (c) 1982, 1986, 1988
 * The Regents of the University of California
 * All Rights Reserved
 *
 * University Acknowledgment- Portions of this document are derived from
 * software developed by the University of California, Berkeley, and its
 * contributors.
 */

#pragma ident   "%Z%%M% %I%     %E% SMI"

/*
 *      Environment variable PROFDIR added such that:
 *              If PROFDIR doesn't exist, "mon.out" is produced as before.
 *              If PROFDIR = NULL, no profiling output is produced.
 *              If PROFDIR = string, "string/pid.progname" is produced,
 *                where name consists of argv[0] suitably massaged.
 *
 *
 *      Routines:
 *              (global) monitor        init, cleanup for prof(1)iling
 *              (global) _mcount        function call counter
 *              (global) _mcount_newent call count entry manager
 *              (static) _mnewblock     call count block allocator
 *
 *
 *      Monitor(), coordinating with mcount(), mcount_newent() and mnewblock(),
 *      maintains a series of one or more blocks of prof-profiling
 *      information.  These blocks are added in response to calls to
 *      monitor() (explicitly or via mcrt[01]'s _start) and, via mcount()'s
 *      calls to mcount_newent() thence to mnewblock().
 *      The blocks are tracked via a linked list of block anchors,
 *      which each point to a block.
 *
 *
 *      An anchor points forward, backward and 'down' (to a block).
 *      A block has the profiling information, and consists of
 *      three regions: a header, a function call count array region,
 *      and an optional execution histogram region, as illustrated below.
 *
 *
 *               "anchor"
 *              +========+
 *      prior<--|        |-->next anchor
 *      anchor  |        |
 *              +========+
 *               |
 *               |
 *               V "block"
 *              +-----------+
 *              +  header   +
 *              +-----------+
 *              +           +
 *              + fcn call  +   // data collected by mcount
 *              +  counts   +
 *              +  array    +
 *              +           +
 *              +-----------+
 *              +           +
 *              + execution +   // data collected by system call,
 *              + profile   +   // profil(2) (assumed ALWAYS specified
 *              + histogram +   // by monitor()-caller, even if small;
 *              +           +   // never specified by mnewblock()).
 *              +-----------+
 *
 *      The first time monitor() is called, it sets up the chain
 *      by allocating an anchor and initializing countbase and countlimit
 *      to zero.  Everyone assumes that they start out zeroed.
 *
 *      When a user (or _start from mcrt[01]) calls monitor(), they
 *      register a buffer which contains the third region (either with
 *      a meaningful size, or so short that profil-ing is being shut off).
 *
 *      For each fcn, the first time it calls mcount(), mcount calls
 *      mcount_newent(), which parcels out the fcn call count entries
 *      from the current block, until they are exausted; then it calls
 *      mnewblock().
 *
 *      Mnewbloc() allocates a block Without a third region, and
 *      links in a new associated anchor, adding a new anchor&block pair
 *      to the linked list.  Each new mnewblock() block or user block,
 *      is added to the list as it comes in, FIFO.
 *
 *      When monitor() is called to close up shop, it writes out
 *      a summarizing header, ALL the fcn call counts from ALL
 *      the blocks, and the Last specified execution histogram
 *      (currently there is no neat way to accumulate that info).
 *      This preserves all call count information, even when
 *      new blocks are specified.
 *
 *      NOTE - no block passed to monitor() may be freed, until
 *      it is called to clean up!!!!
 *
 */

#pragma weak _monitor = monitor

#include "lint.h"
#include "mtlib.h"
#include "libc.h"
#include <sys/types.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <mon.h>
#include <fcntl.h>
#include <unistd.h>
#include <thread.h>
#include <synch.h>

#define PROFDIR "PROFDIR"

static mutex_t mon_lock = DEFAULTMUTEX;

char **___Argv = NULL; /* initialized to argv array by mcrt0 (if loaded) */

/*
 * countbase and countlimit are used to parcel out
 * the pc,count cells from the current block one at
 * a time to each profiled function, the first time
 * that function is called.
 * When countbase reaches countlimit, mcount() calls
 * mnewblock() to link in a new block.
 *
 * Only monitor/mcount/mcount_newent/mnewblock() should change these!!
 * Correct that: only these routines are ABLE to change these;
 * countbase/countlimit are now STATIC!
 */
static char *countbase;         /* addr of next pc,count cell to use in block */
static char *countlimit;        /* addr lim for cells (addr after last cell) */

typedef struct anchor   ANCHOR;

struct anchor {
        ANCHOR  *next, *prior;  /* forward, backward ptrs for list */
        struct hdr  *monBuffer; /* 'down' ptr, to block */
        short  flags;           /* indicators - has histogram designation */

        int  histSize;          /* if has region3, this is size. */
};

#define HAS_HISTOGRAM   0x0001          /* this buffer has a histogram */

static ANCHOR   *curAnchor = NULL;      /* addr of anchor for current block */
static ANCHOR    firstAnchor;           /* the first anchor to use */
                                        /* - hopefully the Only one needed */
                                        /* a speedup for most cases. */
static char *mon_out;

static int writeBlocks(void);
static void _mnewblock(void);
struct cnt *_mcount_newent(void);

/*
 * int (*alowpc)(), (*ahighpc)(); boundaries of text to be monitored
 * WORD *buffer;        ptr to space for monitor data(WORDs)
 * size_t bufsize;      size of above space(in WORDs)
 * size_t nfunc;        max no. of functions whose calls are counted
 *                      (default nfunc is 300 on PDP11, 600 on others)
 */
void
monitor(int (*alowpc)(void), int (*ahighpc)(void), WORD *buffer,
        size_t bufsize, size_t nfunc)
{
        uint_t scale;
        long text;
        char *s;
        struct hdr *hdrp;
        ANCHOR  *newanchp;
        size_t  ssiz;
        int error;
        char    *lowpc = (char *)alowpc;
        char    *highpc = (char *)ahighpc;

        lmutex_lock(&mon_lock);

        if (lowpc == NULL) {            /* true only at the end */
                error = 0;
                if (curAnchor != NULL) { /* if anything was collected!.. */
                        profil(NULL, 0, 0, 0);
                        if (writeBlocks() == 0)
                                error = errno;
                }
                lmutex_unlock(&mon_lock);
                if (error) {
                        errno = error;
                        perror(mon_out);
                }
                return;
        }

        /*
         * Ok - they want to submit a block for immediate use, for
         *      function call count consumption, and execution profile
         *      histogram computation.
         * If the block fails sanity tests, just bag it.
         * Next thing - get name to use. If PROFDIR is NULL, let's
         *      get out now - they want No Profiling done.
         *
         * Otherwise:
         * Set the block hdr cells.
         * Get an anchor for the block, and link the anchor+block onto
         *      the end of the chain.
         * Init the grabba-cell externs (countbase/limit) for this block.
         * Finally, call profil and return.
         */

        ssiz = ((sizeof (struct hdr) + nfunc * sizeof (struct cnt)) /
            sizeof (WORD));
        if (ssiz >= bufsize || lowpc >= highpc) {
                lmutex_unlock(&mon_lock);
                return;
        }

        if ((s = getenv(PROFDIR)) == NULL) { /* PROFDIR not in environment */
                mon_out = MON_OUT; /* use default "mon.out" */
        } else if (*s == '\0') { /* value of PROFDIR is NULL */
                lmutex_unlock(&mon_lock);
                return; /* no profiling on this run */
        } else { /* construct "PROFDIR/pid.progname" */
                int n;
                pid_t pid;
                char *name;
                size_t len;

                len = strlen(s);
                /* 15 is space for /pid.mon.out\0, if necessary */
                if ((mon_out = libc_malloc(len + strlen(___Argv[0]) + 15))
                    == NULL) {
                        lmutex_unlock(&mon_lock);
                        perror("");
                        return;
                }
                (void) strcpy(mon_out, s);
                name = mon_out + len;
                *name++ = '/'; /* two slashes won't hurt */

                if ((pid = getpid()) <= 0) /* extra test just in case */
                        pid = 1; /* getpid returns something inappropriate */

                /* suppress leading zeros */
                for (n = 10000; n > pid; n /= 10)
                        ;
                for (; ; n /= 10) {
                        *name++ = pid/n + '0';
                        if (n == 1)
                                break;
                        pid %= n;
                }
                *name++ = '.';

                if (___Argv != NULL) {  /* mcrt0.s executed */
                        if ((s = strrchr(___Argv[0], '/')) != NULL)
                                (void) strcpy(name, s + 1);
                        else
                                (void) strcpy(name, ___Argv[0]);
                } else {
                        (void) strcpy(name, MON_OUT);
                }
        }


        hdrp = (struct hdr *)(uintptr_t)buffer; /* initialize 1st region */
        hdrp->lpc = lowpc;
        hdrp->hpc = highpc;
        hdrp->nfns = nfunc;

        /* get an anchor for the block */
        newanchp = (curAnchor == NULL) ? &firstAnchor :
            (ANCHOR *)libc_malloc(sizeof (ANCHOR));

        if (newanchp == NULL) {
                lmutex_unlock(&mon_lock);
                perror("monitor");
                return;
        }

        /* link anchor+block into chain */
        newanchp->monBuffer = hdrp;             /* new, down. */
        newanchp->next  = NULL;                 /* new, forward to NULL. */
        newanchp->prior = curAnchor;            /* new, backward. */
        if (curAnchor != NULL)
                curAnchor->next = newanchp;     /* old, forward to new. */
        newanchp->flags = HAS_HISTOGRAM;        /* note it has a histgm area */

        /* got it - enable use by mcount() */
        countbase  = (char *)buffer + sizeof (struct hdr);
        countlimit = countbase + (nfunc * sizeof (struct cnt));

        /* (set size of region 3) */
        newanchp->histSize = (int)
            (bufsize * sizeof (WORD) - (countlimit - (char *)buffer));


        /* done w/regions 1 + 2: setup 3  to activate profil processing. */
        buffer += ssiz;                 /* move ptr past 2'nd region */
        bufsize -= ssiz;                /* no. WORDs in third region */
                                        /* no. WORDs of text */
        text = (highpc - lowpc + sizeof (WORD) - 1) / sizeof (WORD);

        /*
         * scale is a 16 bit fixed point fraction with the decimal
         * point at the left
         */
        if (bufsize < text) {
                /* make sure cast is done first! */
                double temp = (double)bufsize;
                scale = (uint_t)((temp * (long)0200000L) / text);
        } else {
                /* scale must be less than 1 */
                scale = 0xffff;
        }
        bufsize *= sizeof (WORD);       /* bufsize into # bytes */
        profil(buffer, bufsize, (ulong_t)lowpc, scale);


        curAnchor = newanchp;   /* make latest addition, the cur anchor */
        lmutex_unlock(&mon_lock);
}

/*
 * writeBlocks() - write accumulated profiling info, std fmt.
 *
 * This routine collects the function call counts, and the
 * last specified profil buffer, and writes out one combined
 * 'pseudo-block', as expected by current and former versions
 * of prof.
 */
static int
writeBlocks(void)
{
        int fd;
        int ok;
        ANCHOR *ap;             /* temp anchor ptr */
        struct hdr sum;         /* summary header (for 'pseudo' block) */
        ANCHOR *histp;          /* anchor with histogram to use */

        if ((fd = creat(mon_out, 0666)) < 0)
                return (0);

        /*
         * this loop (1) computes # funct cts total
         *  (2) finds anchor of last block w / hist(histp)
         */
        histp = NULL;
        for (sum.nfns = 0, ap = &firstAnchor; ap != NULL; ap = ap->next) {
                sum.nfns += ap->monBuffer->nfns; /* accum num of cells */
                if (ap->flags & HAS_HISTOGRAM)
                        histp = ap;      /* remember lastone with a histgm */
        }


        /* copy pc range from effective histgm */
        sum.lpc = histp->monBuffer->lpc;
        sum.hpc = histp->monBuffer->hpc;

        ok = (write(fd, (char *)&sum, sizeof (sum)) == sizeof (sum));

        if (ok) {               /* if the hdr went out ok.. */
                size_t amt;
                char *p;

                /* write out the count arrays (region 2's) */
                for (ap = &firstAnchor; ok && ap != NULL; ap = ap->next) {
                        amt = ap->monBuffer->nfns * sizeof (struct cnt);
                        p = (char *)ap->monBuffer + sizeof (struct hdr);

                        ok = (write(fd, p, amt) == amt);
                }

                /* count arrays out; write out histgm area */
                if (ok) {
                        p = (char *)histp->monBuffer + sizeof (struct hdr) +
                            (histp->monBuffer->nfns * sizeof (struct cnt));
                        amt = histp->histSize;

                        ok = (write(fd, p, amt) == amt);

                }
        }

        (void) close(fd);

        return (ok);    /* indicate success */
}


/*
 * mnewblock()-allocate and link in a new region1&2 block.
 *
 * This routine, called by mcount_newent(), allocates a new block
 * containing only regions 1 & 2 (hdr and fcn call count array),
 * and an associated anchor (see header comments), inits the
 * header (region 1) of the block, links the anchor into the
 * list, and resets the countbase/limit pointers.
 *
 * This routine cannot be called recursively, since (each) mcount
 * has a local lock which prevents recursive calls to mcount_newent.
 * See mcount_newent for more details.
 *
 */

#define THISMANYFCNS    (MPROGS0*2)

/*
 * call libc_malloc() to get an anchor & a regn1&2 block, together
 */
#define GETTHISMUCH     (sizeof (ANCHOR) +      /* get an ANCHOR */  \
                        (sizeof (struct hdr) +  /* get Region 1 */   \
                        THISMANYFCNS * sizeof (struct cnt))) /* Region 2 */  \
                                                /* but No region 3 */


static void
_mnewblock(void)
{
        struct hdr *hdrp;
        ANCHOR  *newanchp;
        ANCHOR  *p;

                                        /* get anchor And block, together */
        p = libc_malloc(GETTHISMUCH);
        if (p == NULL) {
                perror("mcount(mnewblock)");
                return;
        }

        newanchp = p;
        hdrp = (struct hdr *)(p + 1);

                                        /* initialize 1st region to dflts */
        hdrp->lpc = 0;
        hdrp->hpc = 0;
        hdrp->nfns = THISMANYFCNS;

                                        /* link anchor+block into chain */
        newanchp->monBuffer = hdrp;             /* new, down. */
        newanchp->next  = NULL;                 /* new, forward to NULL. */
        newanchp->prior = curAnchor;            /* new, backward. */
        if (curAnchor != NULL)
                curAnchor->next = newanchp;     /* old, forward to new. */
        newanchp->flags = 0;            /* note that it has NO histgm area */

                                        /* got it - enable use by mcount() */
        countbase  = (char *)hdrp + sizeof (struct hdr);
        countlimit = countbase + (THISMANYFCNS * sizeof (struct cnt));

        newanchp->histSize = 0; /* (set size of region 3.. to 0) */


        curAnchor = newanchp;           /* make latest addition, cur anchor */
}

/*
 * mcount_newent() -- call to get a new mcount call count entry.
 *
 * this function is called by _mcount to get a new call count entry
 * (struct cnt, in the region allocated by monitor()), or to return
 * zero if profiling is off.
 *
 * This function acts as a funnel, an access function to make sure
 * that all instances of mcount (the one in the a.out, and any in
 * any shared objects) all get entries from the same array, and
 * all know when profiling is off.
 *
 * NOTE: when mcount calls this function, it sets a private flag
 * so that it does not call again until this function returns,
 * thus preventing recursion.
 *
 * At Worst, the mcount in either a shared object or the a.out
 * could call once, and then the mcount living in the shared object
 * with monitor could call a second time (i.e. libc.so.1, although
 * presently it does not have mcount in it).  This worst case
 * would involve Two active calls to mcount_newent, which it can
 * handle, since the second one would find a already-set value
 * in countbase.
 *
 * The only unfortunate result is that No new call counts
 * will be handed out until this function returns.
 * Thus if libc_malloc or other routines called inductively by
 * this routine have not yet been provided with a call count entry,
 * they will not get one until this function call is completed.
 * Thus a few calls to library routines during the course of
 * profiling setup, may not be counted.
 *
 * NOTE: countbase points at the next available entry, and
 * countlimit points past the last valid entry, in the current
 * function call counts array.
 *
 *
 * if profiling is off          // countbase==0
 *   just return 0
 *
 * else
 *   if need more entries       // because countbase points last valid entry
 *     link in a new block, resetting countbase and countlimit
 *   endif
 *   if Got more entries
 *     return pointer to the next available entry, and
 *     update pointer-to-next-slot before you return.
 *
 *   else                       // failed to get more entries
 *     just return 0
 *
 *   endif
 * endif
 */

struct cnt *
_mcount_newent(void)
{
        if (countbase == 0)
                return (NULL);

        if (countbase >= countlimit)
                _mnewblock();           /* get a new block; set countbase */

        if (countbase != 0) {
                struct cnt *cur_countbase = (struct cnt *)(uintptr_t)countbase;

                countbase += sizeof (struct cnt);
                return (cur_countbase);
        }
        return (NULL);
}