/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License, Version 1.0 only

 * (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 2004 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 "synonyms.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