xref: /system/wlan/ti/wilink_6_1/platforms/os/common/src/tracebuf.c

/*
 * tracebuf.c
 *
 * Copyright(c) 1998 - 2009 Texas Instruments. All rights reserved.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *  * Neither the name Texas Instruments nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * Benchmark tracing utility
 */

#include "osApi.h"
#include "tracebuf.h"
#include "tracebuf_api.h"
#include "report.h"

typedef struct {
      unsigned long loc;/* trace entry identification */
      unsigned long ts;/* Timestamp */
      unsigned long p1; /* Parameter 1 */
      unsigned long p2; /* Parameter 2 */
      char msg[MAX_TB_MSG];
} tb_entry_t;

typedef struct {
      int pos;
      int count;
      int print_pos;
      int nusers;
      unsigned long self_delay;
      unsigned long options;
      tb_entry_t entry[1]; /* Array of entries */
} tb_control_t;

static tb_control_t *tb_control;

static  int tb_control_size(void)
{
   return TI_FIELD_OFFSET(tb_control_t, entry) + sizeof(tb_entry_t)*TB_NUM_ENTRIES;
}


/* Initialization */
int tb_init(unsigned long options)
{
   if (tb_control)
   {
      ++tb_control->nusers;
      return 0;
   }
   tb_control = (tb_control_t *)TB_MALLOC(tb_control_size());
   if (!tb_control)
      return -1;
   memset(tb_control, 0, tb_control_size());
   tb_control->nusers = 1;

   /* Measure self-delay */
   tb_trace(0, 0, 0);
   tb_trace(0, 0, 0);
   tb_control->self_delay = tb_control->entry[1].ts - tb_control->entry[0].ts;
   tb_control->pos = tb_control->count = 0;
   tb_control->options = options;
   return 0;
}

/* De-initialization */
void tb_destroy(void)
{
   if (--tb_control->nusers)
      return;
   TB_FREE(tb_control );
}

static int tb_next(void)
{
    int pos;
    if (!tb_control || tb_control->print_pos)
       return -1;
    pos = tb_control->pos;
    tb_control->pos = (pos+1) % TB_NUM_ENTRIES;
    ++tb_control->count;

    tb_control->entry[tb_control->pos].ts =
    tb_control->entry[tb_control->pos].loc=
    tb_control->entry[tb_control->pos].p1 =
    tb_control->entry[tb_control->pos].p2 = 0xffffffff;

    return pos;
}
static void tb_autoprint(void)
{
    if ((tb_control->pos == 0) && (tb_control->count))
    {
        if (tb_control->options & TB_OPTION_PRINTONCE)
        {
            tb_printf();
            tb_reset_option(TB_OPTION_PRINTONCE);
        }
        else if (tb_control->options & TB_OPTION_AUTOPRINT)
        {
            tb_printf();
        }
    }
}

/* Add trace entry. not safe, but will do */
int tb_trace(int loc, unsigned long p1, unsigned long p2)
{
   int pos;

   if ((tb_control->options & TB_OPTION_STOP) || ((pos = tb_next()) < 0))
   {
       return -1;
   }
   tb_control->entry[pos].ts = os_timeStampUs(NULL);
   tb_control->entry[pos].loc= loc;
   tb_control->entry[pos].p1 = p1;
   tb_control->entry[pos].p2 = p2;

   return pos;
}
void tb_dump(void)
{
	int j, pos;

	WLAN_OS_REPORT(("Trace Dump:\n"));
	WLAN_OS_REPORT(("===========\n\n"));
    if (tb_control->count < TB_NUM_ENTRIES)
    {
        pos = 0;
    }
    else
    {
        pos = (tb_control->pos + 1) % TB_NUM_ENTRIES;
    }
	for (j=0; (unsigned int)j < tb_min((unsigned int)TB_NUM_ENTRIES,(unsigned int)tb_control->count); j++)
	{
		WLAN_OS_REPORT(("%4i %08x %08x %08x %08x\n", j,
			(int)tb_control->entry[pos].ts,
			(int)tb_control->entry[pos].loc,
			(int)tb_control->entry[pos].p1,
			(int)tb_control->entry[pos].p2));
		pos = (pos+1) % TB_NUM_ENTRIES;
	}

}

int tb_sprintf(const char *format ,...)
{

	va_list ap;
    int pos;

    if ((tb_control->options & TB_OPTION_STOP) || ((pos = tb_next()) < 0))
    {
        return -1;
    }
    tb_control->entry[pos].loc = TB_ID;
	va_start(ap,format);
	vsprintf(&tb_control->entry[pos].msg[0], format, ap);
    tb_autoprint();
    return pos;
}

void tb_printf(void)
{
	int j, pos;
    unsigned long saved_options=tb_control->options;

    tb_set_option(TB_OPTION_STOP);
	WLAN_OS_REPORT(("Trace Dump:\n"));
	WLAN_OS_REPORT(("===========\n\n"));
    if (tb_control->count < TB_NUM_ENTRIES)
    {
        pos = 0;
    }
    else
    {
        pos = (tb_control->pos + 1) % TB_NUM_ENTRIES;
    }
	for (j=0; (unsigned int)j < tb_min((unsigned int)TB_NUM_ENTRIES,(unsigned int)tb_control->count); j++)
	{
		WLAN_OS_REPORT(("%4i id=0x%8x %s \n", j,
tb_control->entry[pos].loc, tb_control->entry[pos].msg));
		pos = (pos+1) % TB_NUM_ENTRIES;
	}
    tb_control->options = saved_options;
}
void tb_set_option(unsigned long option)
{
    tb_control->options |= option;
}

void tb_reset_option(unsigned long option)
{
    tb_control->options &= ~option;
}

void tb_scan(void)
{

  int j,k, Size, nAllocs=0, nFrees=0;
  unsigned long address, Allocs=0, Frees=0;

  for (j=0; j < TB_NUM_ENTRIES; j++)
  {
    Size = (int)tb_control->entry[j].p2;
    if (Size > 0) /* Alloc */
    {
      nAllocs += 1;
      Allocs  += Size;
      address = tb_control->entry[j].p1;
      for (k=j+1; k < TB_NUM_ENTRIES; k++)
      {
	if (address == tb_control->entry[k].p1)
	{
	  if (tb_control->entry[k].p2 != -Size)
	  {
	    TB_PRINTF("Bad free size at 0x%lx address = 0x%lx Size = %ld Allocated = %d\n",
		   tb_control->entry[k].loc, tb_control->entry[k].p1, (long)tb_control->entry[k].p2, Size);
	  }
	  Frees  += tb_control->entry[k].p2;
	  nFrees += 1;
	  break;
	}
      }
      if (k == TB_NUM_ENTRIES)
      {
	TB_PRINTF("Memory leak at 0x%lx address = 0x%lx Size = %d\n",
	       tb_control->entry[j].loc, address, Size);
      }
    }
  }
  TB_PRINTF("tb_scan() Allocs = %ld nAllocs = %d Frees = %ld nFrees = %d\n", Allocs, nAllocs, Frees, nFrees);
}