xref: /netbsd/sys/arch/shark/shark/profile.c (revision bf9ec67e)

/*	$NetBSD: profile.c,v 1.1 2002/02/10 01:58:08 thorpej Exp $	*/

/*
 * Copyright 1997
 * Digital Equipment Corporation. All rights reserved.
 *
 * This software is furnished under license and may be used and
 * copied only in accordance with the following terms and conditions.
 * Subject to these conditions, you may download, copy, install,
 * use, modify and distribute this software in source and/or binary
 * form. No title or ownership is transferred hereby.
 *
 * 1) Any source code used, modified or distributed must reproduce
 *    and retain this copyright notice and list of conditions as
 *    they appear in the source file.
 *
 * 2) No right is granted to use any trade name, trademark, or logo of
 *    Digital Equipment Corporation. Neither the "Digital Equipment
 *    Corporation" name nor any trademark or logo of Digital Equipment
 *    Corporation may be used to endorse or promote products derived
 *    from this software without the prior written permission of
 *    Digital Equipment Corporation.
 *
 * 3) This software is provided "AS-IS" and any express or implied
 *    warranties, including but not limited to, any implied warranties
 *    of merchantability, fitness for a particular purpose, or
 *    non-infringement are disclaimed. In no event shall DIGITAL be
 *    liable for any damages whatsoever, and in particular, DIGITAL
 *    shall not be liable for special, indirect, consequential, or
 *    incidental damages or damages for lost profits, loss of
 *    revenue or loss of use, whether such damages arise in contract,
 *    negligence, tort, under statute, in equity, at law or otherwise,
 *    even if advised of the possibility of such damage.
 */

/*
 * The fiq based profiler.
 */

#include "profiler.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/buf.h>
#include <sys/time.h>
#include <sys/proc.h>
#include <sys/user.h>
#include <sys/ioctl.h>
#include <sys/map.h>
#include <sys/conf.h>
#include <sys/errno.h>
#include <sys/fcntl.h>
#include <sys/uio.h>
#include <sys/malloc.h>
#include <sys/proc.h>

#include <shark/shark/hat.h>
#include <machine/profileio.h>
#include <dev/ic/i8253reg.h>

#define PROFILER_DEBUG 1

#define countPerTick 500 /* TIMER_FREQ/10000   10 kHz timer */

/* Processor Status Defines */
#define STATUS_MODE_MASK 0x1f
#define USER_MODE        0x10
#define FIQ_MODE         0x11
#define IRQ_MODE         0x12
#define SVC_MODE         0x13
#define ABORT_MODE       0x17
#define UNDEF_MODE       0x1b
#define SYS_MODE         0x1f

/* software controller
 */
struct profiler_sc
{
    int state;
#define PROF_OPEN 0x01
#define PROF_PROFILING 0x02
} prof_sc;

/*
 * GLOBAL DATA
 */

/* I need my own stack space for the hat */
#define HATSTACKSIZE 1024       /* size of stack used during a FIQ */
static unsigned char hatStack[HATSTACKSIZE]; /* actual stack used
					      * during a FIQ
					      */
/* Pointer to the list of hash tables.
 * A backup table is created for every table malloced, this
 * is used so that we don't miss samples while copying the
 * data out. Thus the actual number of tables in the array is twice
 * what nhashTables says.
 */
struct profHashTable *profTable;
struct profHashTable *phashTables[2];
int nhashTables;

/*
 * FORWARD DECLARATIONS
 */
static void profFiq(int  x);
static void profHatWedge(int nFIQs);
void profStop(void);
void profStart(struct profStartInfo *);
static void profEnter(struct profHashTable * , unsigned int);
void displayTable(struct profHashTable * );


void
profilerattach(n)
    int n;
{
    /* reset the profiler state */
    prof_sc.state = 0;
}

/*
 * Open the profiling devicee.
 * Returns
 *       ENXIO for illegal minor device
 *             ie. if the minor device number is not 0.
 *       EBUSY if file is open by another process.
 *       EROFS if attempt to open in write mode.
 */
int
profopen(dev, flag, mode, p)
    dev_t dev;
    int flag;
    int mode;
    struct proc *p;
{

    /* check that the minor number is correct. */
    if (minor(dev) >= NPROFILER)
    {
	return ENXIO;
    }

    /* check that the device is not already open. */
    if (prof_sc.state && PROF_OPEN)
    {
	return EBUSY;
    }

    /* check that the flag is set to read only. */
    if (!(flag && FWRITE))
    {
	return EROFS;
    }
    /* flag the device as open. */
    prof_sc.state |= PROF_OPEN;
    nhashTables = 0;
    phashTables[0] = phashTables[1] = NULL;
    return 0;
}

/*
 * Close the descriptor.
 *
 */
int
profclose(dev, flag, mode, p)
    dev_t dev;
    int flag;
    int mode;
    struct proc *p;
{
    /* clear the state, and stop profiling if
     * it is happening.
     */
    profStop();
    prof_sc.state &= ~PROF_OPEN;
    return 0;
}

int
profread(dev, uio, flags)
	dev_t dev;
	struct uio *uio;
	int flags;
{
    int error;
    int real, backup;

    /* must be profiling to read */
    if (!(prof_sc.state & PROF_PROFILING))
    {
	error = EINVAL;
    }
    else
    {
	if (uio->uio_resid != sizeof(struct profHashHeader) +
	    profTable->hdr.tableSize * sizeof(struct profHashEntry))
	{
	    printf("profile read size is incorrect!");
	    error = EINVAL;
	}
	else
	{
	    /* first work out which table is currently being used.
	     */
	    if (profTable == phashTables[0])
	    {
		real = 0;
		backup = 1;
	    }
	    else
	    {
		if (profTable == phashTables[1])
		{
		    real = 1;
		    backup = 0;
		}
		else
		{
		    panic("profiler lost buffer\n");
		}
	    }
	    /* now initialise the backup copy before switching over.
	     */
	    memset(phashTables[backup]->entries, 0,
		  profTable->hdr.tableSize * sizeof(struct profHashEntry));


	    /* now initialise the header */
	    phashTables[backup]->hdr.tableSize = phashTables[real]->hdr.tableSize;
	    phashTables[backup]->hdr.entries = phashTables[backup]->hdr.last
		= phashTables[real]->hdr.entries;
	    phashTables[backup]->hdr.samples = 0;
	    phashTables[backup]->hdr.missed = 0;
	    phashTables[backup]->hdr.fiqs = 0;
	    phashTables[backup]->hdr.pid = phashTables[real]->hdr.pid;
	    phashTables[backup]->hdr.mode = phashTables[real]->hdr.mode;

	    /* ok now swap over.
	     * I don't worry about locking the fiq while I change
	     * this, at this point it won't matter which table the
	     * fiq reads.
	     */
	    profTable = phashTables[backup];

	    /* don't want to send the pointer,
	     * make assumption that table follows the header.
	     */
	    if ( (error = uiomove(phashTables[real],
				  sizeof(struct profHashHeader), uio))
		!= 0)
	    {
		printf("uiomove failed error is %d\n", error);
	    }
	    else
	    {
		if ( (error = uiomove(phashTables[real]->entries,
				      phashTables[real]->hdr.tableSize *
				      sizeof(struct profHashEntry), uio))
		    != 0)
		{
		    printf("uiomove failed error is %d\n", error);
		}
	    }
	}
    }
    return error;
}

/*
 *  PROFIOSTART	  Start Profiling
 *  PROFIOSTOP	  Stop Profiling
 */
static int profcount = 0;
static int ints = 0;
int
profioctl(dev, cmd, data, flag, p)
	dev_t dev;
	u_long cmd;
	caddr_t data;
	int flag;
	struct proc *p;
{
    int error = 0;
    struct profStartInfo *info = (struct profStartInfo *) data;

    switch (cmd)
    {
	case PROFIOSTART :
	    profStart(info);
	    break;
	case PROFIOSTOP :
	    profStop();
	    break;
	default :
	    error = EINVAL;
	    break;
    }
    return error;
}

/* start profiling, returning status information in the
 * profStartInfo structure.
 *
 * presumes pid is running, does no checks here.
 */
void
profStart(struct profStartInfo *info)
{
    unsigned int savedInts;
    char *buffer;

    /* can't already be sampling */
    if ( prof_sc.state & PROF_PROFILING )
    {
	info->status = ALREADY_SAMPLING;
	return ;
    }

    /* sanity check that the table sizes are logical */
    if (info->entries > info->tableSize)
    {
	info->status = BAD_TABLE_SIZE;
	return ;
    }

    /* now sanity check that we are sampling either the
     * kernel or a pid or both.
     */
    if ( !(info->mode & SAMPLE_MODE_MASK) )
    {
	info->status = ILLEGAL_COMMAND;
	return ;
    }

    /* alloc two hash tables. */
    buffer  = malloc(sizeof(struct profHashTable) +
		     info->tableSize * sizeof(struct profHashEntry),
		     M_DEVBUF, M_NOWAIT);
    if ( (buffer == NULL) )
    {
	info->status = NO_MEMORY;
	return;
    }
    phashTables[0] = (struct profHashTable *) buffer;
    phashTables[0]->entries = (struct profHashEntry *)
	( buffer + sizeof(struct profHashTable));

    buffer  = malloc(sizeof(struct profHashTable) +
		     info->tableSize * sizeof(struct profHashEntry),
		     M_DEVBUF, M_NOWAIT);
    if ( (buffer == NULL) )
    {
	free(phashTables[0], M_DEVBUF);
	info->status = NO_MEMORY;
	return;
    }
    phashTables[1] = (struct profHashTable *) buffer;
    phashTables[1]->entries = (struct profHashEntry *)
	( buffer + sizeof(struct profHashTable));

    memset(phashTables[0]->entries, 0,
	  info->tableSize * sizeof(struct profHashEntry));
    memset(phashTables[1]->entries, 0,
	  info->tableSize * sizeof(struct profHashEntry));

    /* now initialise the header */
    profTable = phashTables[0];
    profTable->hdr.tableSize = info->tableSize;
    profTable->hdr.entries = profTable->hdr.last = info->entries;
    profTable->hdr.samples = 0;
    profTable->hdr.missed = 0;
    profTable->hdr.fiqs = 0;
    profTable->hdr.pid = info->pid;
    profTable->hdr.mode = info->mode;

    /* now let the pigeons loose. */
    savedInts = disable_interrupts(I32_bit | F32_bit);
    prof_sc.state |= PROF_PROFILING;
    hatClkOn(countPerTick,
	     profFiq,
	     (int)&prof_sc,
	     hatStack + HATSTACKSIZE - sizeof(unsigned),
	     profHatWedge);
    restore_interrupts(savedInts);
}

void
profStop(void)
{
    unsigned int savedInts;
    int spl;

    savedInts = disable_interrupts(I32_bit | F32_bit);
    hatClkOff();
    restore_interrupts(savedInts);

    spl = splbio();
    /* only free the buffer's if we were profiling,
     * who cares if we were not, won't alert any one.
     */
    if (prof_sc.state & PROF_PROFILING)
    {
	/* now free both buffers. */
	free(phashTables[0], M_DEVBUF);
	free(phashTables[1], M_DEVBUF);
    }
    phashTables[0] = phashTables[1] = NULL;
    prof_sc.state &= ~PROF_PROFILING;
    splx(spl);

}

/*
**++
**  FUNCTIONAL DESCRIPTION:
**
**      profFiq
**
**      This is what the HAT clock calls.   This call drives
**      the timeout queues, which in turn drive the state machines
**
**      Be very carefully when calling a timeout as the function
**      that is called may in turn do timeout/untimeout calls
**      before returning
**
**  FORMAL PARAMETERS:
**
**      int x       - not used
**
**  IMPLICIT INPUTS:
**
**      nill
**
**  IMPLICIT OUTPUTS:
**
**      nill
**
**  FUNCTION VALUE:
**
**      nill
**
**  SIDE EFFECTS:
**
**      a timeout may be called if it is due
**--
*/
static void
profFiq(int  x)
{
    int i;
    int *ip;           /* the fiq stack pointer */
    unsigned int spsr, stacklr;   /* the link register, off the stack. */


    /* get the link register and see where we came from.
     * We do this by getting the stack pointer using,
     * an inline assembler instruction and then going 9
     * words up to get the return address from the fiq.
     *
     * NOTE: the stack will change if more local variables
     * are added so beware of modifications to this
     * function.
     * the fiq.S handler puts the following on the stack
     *          stmfd	sp!, {r0-r3, lr}
     * then this function does
     *          mov     ip, sp
     *          stmfd	sp!, {r4, fp, ip, lr, pc}
     * or some variant of this.
     *
     * instead of using sp we can use ip, the saved stack pointer
     * and be done with the chance of sp changing around on us.
     *
     * so by the time we get here we have a stack that looks like.
     * (see pg 4-23, ARM programming Techniques doco for description
     * on stm instructions.)
     *         lr-fiq  (we want this one).
     *         r3-fiq
     *         r2-fiq
     *         r1-fiq
     * ip-->   r0-fiq
     *         pc-prof
     *         lr-prof
     *         ip-prof
     *         fp-prof
     * sp-->   r4-prof
     * the sp by the time we get to it will point to r4 at the
     * bottom of the stack. So we go 9 up to get the lr we want.
     * or even better we have ip pointing to r0 and we can go 4 up
     * to get the saved link register.
     *
     * We are safer this way because fiq.S is coded assembler, we are
     * at the mercy of the assembler for our stack.
     *
     */
    asm("mov %0, ip" : "=r" (ip) : );
    stacklr = *(ip+4);

    /* get the spsr register
     */
    asm("mrs %0, spsr" : "=r" (spsr) : );

    /* now check whether we want this sample.
     * NB. We place kernel and user level samples in the
     * same table.
     */
    if ( (profTable->hdr.mode & SAMPLE_PROC) &&
	((spsr & STATUS_MODE_MASK) == USER_MODE) )
    {
	if ( curproc->p_pid == profTable->hdr.pid )
	{
	    profEnter(profTable, stacklr-4);
	}
    }

    if ( profTable->hdr.mode & SAMPLE_KERN )
    {
	if ( ((spsr & STATUS_MODE_MASK) == SVC_MODE)/* ||
	    ((spsr & STATUS_MODE_MASK) == IRQ_MODE)*/ )
	{
	    /* Note: the link register will be two instructions,
	     * ahead of the "blamed" instruction. This is actually
	     * a most likely case and might not actually highlight the
	     * exact cause of problems, some post processing intelligence
	     * will be required to make use of this data.
	     */
	    profEnter(profTable, stacklr-4);
	}
    }
    /* increment the samples counter */
    profTable->hdr.fiqs++;
}

/*
**++
**  FUNCTIONAL DESCRIPTION:
**
**      profHatWedge
**
**      Called if the HAT timer becomes clogged/wedged.  Not
**      used by this driver, we let upper layers recover
**      from this condition
**
**  FORMAL PARAMETERS:
**
**      int nFIQs - not used
**
**  IMPLICIT INPUTS:
**
**      nill
**
**  IMPLICIT OUTPUTS:
**
**      nill
**
**  FUNCTION VALUE:
**
**      nill
**
**  SIDE EFFECTS:
**
**      nill
**--
*/
static void
profHatWedge(int nFIQs)
{
    #ifdef PROFILER_DEBUG
        printf("profHatWedge: nFIQ = %d\n",nFIQs);
    #endif
}

/* Enter the data in the table.
 *
 * To reduce the time taken to find samples with time
 * an eviction algorithm is implemented.
 * When a new entry in the overflow area is required
 * the first entry in the hash table is copied there
 * and the new entry placed as the hash table entry. The
 * displaced entry will then be the first entry accessed in
 * the table.
 */
static void
profEnter(struct profHashTable *table, unsigned int lr)
{
    unsigned int entries, hashShift, index, count;
    struct profHashEntry *sample;
    struct profHashEntry *first;
    struct profHashEntry *prev;
    struct profHashEntry tmpEntry;
    int tmpIndex;

    /* work out how many bits
     * are required to hash the given size.
     */
    entries = table->hdr.entries - 1;
    hashShift = 0;
    do
    {
	entries = entries << 1;
	hashShift ++;
    } while (!(entries & 0x80000000));

    /* enter the pc in the table. */
    /* remove redundant bits.
     * and save the count offset bits
     */
    lr = lr >> REDUNDANT_BITS;
    count = lr & COUNT_BIT_MASK;
    lr = lr >> COUNT_BITS;

    /* this is easier than working out how
     * many bits to or, based on the hashShift.
     * maybe it would be better to work out at
     * the start and save time during the fiq.
     */
    index = (lr << hashShift) >> hashShift;

    first = sample = &table->entries[index];
    /* now loop until we either find the entry
     * or the next free space.
     */
    while ( (sample->pc != lr) && (table->hdr.last < table->hdr.tableSize) )
    {
	if (sample->pc == 0)
	{
	    /* go ahead and stick it in */
	    sample->pc = lr;
	}
	else
	{
	    if (sample->next != 0)
	    {
		/* move along and continue */
		prev = sample;
		sample = &table->entries[sample->next];
	    }
	    else
	    {
		/* create a new entry if available */
		if (table->hdr.last < table->hdr.tableSize)
		{
		    sample = &table->entries[table->hdr.last];
		    /* copy the first sample into the new
		     * field.
		     */
		    memcpy(sample, first, sizeof(struct profHashEntry));
		    /* now update the new entry in the first position.
		     */
		    first->pc = lr;
		    first->next = table->hdr.last;
		    first->counts[0] = 0;
		    first->counts[1] = 0;
		    first->counts[2] = 0;
		    first->counts[3] = 0;
		    table->hdr.last++;
		    /* update the sample pointer so that we
		     * can insert the count.
		     */
		    sample = first;
		}
	    }
	}
    }

    /* check if we need to do an eviction. */
    if (sample != first)
    {
	/* copy the sample out of the table. */
	memcpy(&tmpEntry, sample, sizeof(struct profHashEntry));
	/* remove the sample from the chain. */
	tmpIndex = prev->next;
	prev->next = sample->next;
	/* now insert it at the beginning. */
	memcpy(sample, first, sizeof(struct profHashEntry));
	memcpy(first, &tmpEntry, sizeof(struct profHashEntry));
	/* now make the new first entry point to the old
	 * first entry.
	 */
	first->next = tmpIndex;
    }

    /* must now check the lr
     * to see if the table is full.
     */
    if (sample->pc == lr)
    {
	/* update the count */
	sample->counts[count]++;
	table->hdr.samples++;
    }
    else
    {
	table->hdr.missed++;
    }
}

void
displayTable(struct profHashTable *table)
{
    int i;
    struct profHashEntry *sample;
    char buff[100] = ".............................................\n";

    for (i=0; i < table->hdr.tableSize; i++)
    {
	sample = &table->entries[i];
	if ((i * table->hdr.tableSize) >= table->hdr.entries)
	{
	    printf("%s", buff);
	    buff[0] = '\0';
	}
	printf("i = %d, pc = 0x%x, next = %d, counts %d %d %d %d\n",
	       i, sample->pc, sample->next, sample->counts[0],
	       sample->counts[1], sample->counts[2], sample->counts[3]);
    }
    return;
}