path: root/main/common/memtrace.c

/**************************************************************************
 *
 * Copyright (c) 2013 Alcatel-Lucent
 * 
 * Alcatel Lucent licenses this file to You under the Apache License,
 * Version 2.0 (the "License"); you may not use this file except in
 * compliance with the License.  A copy of the License is contained the
 * file LICENSE at the top level of this repository.
 * You may also obtain a copy of the License at:
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **************************************************************************
 *
 * memtrace.c:
 *
 * This file contains CLI and API code to support a simple memory trace
 * capability that allows application developers to call mon_memtrace()
 * with a "printf-like" formatted arglist and the formatted string is
 * put into a circular buffer in some allocated RAM space.
 * The circular buffer is established by "mtrace cfg" command, then all
 * subsequent calls to mon_memtrace() will have the formatted string
 * destined for that buffer.
 *
 * To keep the output formatted clean, the user of mon_memtrace() should
 * not include any line-feeds in the string.  Each time mon_memtrace() is
 * called, a line feed and sequence number is prepended to the string.
 * This allows the dump to simply run through the buffer using putchar().
 *
 * Both the mon_memtrace() API function and the dump facility in the CLI
 * will deal with buffer wrapping.
 *
 * Original author:     Ed Sutter (ed.sutter@alcatel-lucent.com)
 *
 */

#include "config.h"
#include <stdarg.h>
#include "stddefs.h"
#include "genlib.h"
#include "cli.h"

#if INCLUDE_MEMTRACE

#define MINBUFSIZE 512
#define MAXLINSIZE MINBUFSIZE/2

#define MODE_PRINT		(1<<0)		/* mtrace text is output to console */
#define MODE_NOWRAP		(1<<1)		/* when mtrace buffer fills, stop */

/* struct mtInfo:
 *	This structure is at the base of the memory space allocated for
 *	the print buffer.  The control structure is part of the print buffer
 *	because the print buffer is assumed to be outside of the bss area
 *	of the monitor; hence, if a reset occurs and the monitor clears out
 *	its bss space, this structure will still be accessible and contain
 *	the data prior to the reset.
 *	So, to initialize a memory trace buffer use...
 *		 mtrace cfg	BASE SIZE
 *	and to re-establish the trace after a reset, use...
 *		 mtrace mip	BASE
 */
struct mtInfo {
	char *base;		/* Base of ram space allocated for print buffer. */
	char *ptr;		/* Running pointer into circular print buffer. */
	char *end;		/* End of ram space allocated. */
	int	size;		/* Size of space originally allocated for mtrace. */
	int	off;		/* Set if tracing is disabled. */
	int	sno;		/* Sequence number of Mtrace() call. */
	int	wrap;		/* Wrap counter. */
	int	mode;		/* See MODE_XXX bits above. */
	int	reentered;	/* Reentry counter. */
};

static struct mtInfo *Mip;

/* Mtrace():
 * Memory trace... This function can be used to place some trace statements
 * (readable text) in some memory location specified by the
 * setting of mtracebuf.  This was originally written for debugging Xmodem
 * because you can't use printf() since the protocol is using the serial 
 * port.  I have since pulled it out of the Xmodem.c file and placed it in
 * generally accessible space so that it can be made available to the
 * application code and other monitor code.
 */

int
Mtrace(char *fmt,...)
{
	static	int inMtraceNow;
	int len;
	char *eolp;
	va_list argp;
	
	/* Mtrace not configured or disabled, so just return.
	 */
	if (!Mip || Mip->off)
		return(0);

	/* This may be called from interrupt and/or non-interrupt space of
	 * an application, so we must deal with possible reentrancy here.
	 */
	if (inMtraceNow) {
		Mip->reentered++;
		return(0);	
	}

	inMtraceNow = 1;

	Mip->ptr += snprintf(Mip->ptr,MAXLINSIZE,"\n<%04d> ",Mip->sno++);

	va_start(argp,fmt);
	len = vsnprintf(Mip->ptr,MAXLINSIZE,fmt,argp);
	va_end(argp);

	/* Strip all CR/LFs from the incoming string.
	 * The incoming string can have CR/LFs in it; however, they are stripped
	 * so that the format of the dump is stable (one line per Mtrace call).
	 * Notice that the top line of this function inserts a newline ahead
	 * of the sequence number; hence, additional CR/LFs in the text would
	 * just confuse the output.
	 */
	eolp = Mip->ptr;
	while(*eolp) {
		if ((*eolp == '\r') || (*eolp == '\n')) {
			strcpy(eolp,eolp+1);
			len--;
		}
		else
			eolp++;
	}

	/* If print flag is set, then dump to the console...
	 */
	if (Mip->mode & MODE_PRINT) {
		int	i;
		for(i=0;i<len;i++)
			putchar(*Mip->ptr++);
		putchar('\n');
	}
	else
		Mip->ptr += len;

	if (Mip->ptr >= Mip->end) {
		Mip->ptr = Mip->base;
		if (Mip->mode & MODE_NOWRAP)
			Mip->off = 1;
		else
			Mip->wrap++;
	}

	/* Flush the d-cache of the mtrace buffer and Mip structure after each
	 * transfer...
	 * This is important because if this is being accessed from an
	 * application that has d-cache enabled, then the hardware is reset,
	 * there is a chance that the data written was in cache and would be
	 * lost.
	 */
	flushDcache((char *)Mip,sizeof(struct mtInfo));
	flushDcache((char *)Mip->base,Mip->end - Mip->base);

	inMtraceNow = 0;
	return(len);
}

void
MtraceReset(void)
{
	Mip->ptr = Mip->base;
	Mip->sno = 1;
	Mip->wrap = 0;
	Mip->off = 0;
	Mip->mode = 0;
	Mip->reentered = 0;
	memset(Mip->base,0,Mip->size-sizeof(struct mtInfo));
}

void
MtraceInit(char *base, int size)
{
	if (size < MINBUFSIZE)
		return;

	Mip = (struct mtInfo *)base;
	Mip->base = base + sizeof(struct mtInfo);
	Mip->size = size;
	Mip->end = (Mip->base + size - MAXLINSIZE);
	MtraceReset();
}

char *
mDump(char *bp, int more)
{
	int	line;

	line = 0;

	while((bp < Mip->end) && (*bp)) {
		putchar(*bp);
		if (more && (*bp == '\n')) {
			if (++line == 24) {
				line = 0;
				if (!More())
					return(0);
			}
		}
		bp++;
	}
	while(*bp) {
		putchar(*bp);
		if (more && (*bp == '\n')) {
			if (++line == 24) {
				line = 0;
				if (!More())
					return(0);
			}
		}
		bp++;
	}
	return(bp);
}

/* If Mip pointer is configured, return 1; else return zero
 * and print an error message.
 */
static int
MipConfigured(void)
{
	if (Mip)
		return(1);
	printf("Not configured\n");
	return(0);
}

char *MtraceHelp[] = {
	"Configure/Dump memory trace.",
	"-[nm] {cmd} [cmd specific args]",
#if INCLUDE_VERBOSEHELP
	"Options:",
	" -m  enable 'more' flag for dump.",
	" -n  disable wrapping.",
	"Cmd:",
	" on",
	" off",
	" dump",
	" pron",
	" reset",
	" log {msg}",
	" mip {base}",
	" cfg [{base} {size}]",
#endif
	0
};

int
MtraceCmd(int argc,char *argv[])
{
	char	*bp;
	int		more, opt, nowrap;

	more = 0;
	nowrap = 0;
	while((opt=getopt(argc,argv,"nm")) != -1) {
		switch(opt) {
		case 'n':
			nowrap = 1;
			break;
		case 'm':
			more = 1;
			break;
		default:
			return(CMD_PARAM_ERROR);
		}
	}

	if (argc <= optind)
		return(CMD_PARAM_ERROR);

	if (!strcmp(argv[optind],"cfg")) {
		if (argc == optind + 3) {
			MtraceInit((char *)strtoul(argv[optind+1],0,0),
				strtoul(argv[optind+2],0,0));
			if (nowrap)
				Mip->mode |= MODE_NOWRAP;
		}
		else if (argc == optind + 1) {
			if (MipConfigured()) {
				printf("Base: 0x%lx, End: 0x%lx\n",
					(ulong)Mip->base,(ulong)Mip->end);
				printf("Ptr:  0x%lx, Sno: %d\n",(ulong)Mip->ptr,Mip->sno);
				printf("Wrap: %d\n",Mip->wrap);
			}
		}
		else
			return(CMD_PARAM_ERROR);
	}
	else if (!strcmp(argv[optind],"on")) {
		if (MipConfigured()) {
			Mip->mode &= ~MODE_PRINT;
			Mip->off = 0;
		}
	}
	else if (!strcmp(argv[optind],"pron")) {
		if (MipConfigured()) {
			Mip->mode |= MODE_PRINT;
			Mip->off = 0;
		}
	}
	else if (!strcmp(argv[optind],"off")) {
		if (MipConfigured()) 
			Mip->off = 1;
	}
	else if (!strcmp(argv[optind],"reset")) {
		if (MipConfigured())
			MtraceReset();
	}
	else if (!strcmp(argv[optind],"mip")) {
		if (argc != optind + 2)
			return(CMD_PARAM_ERROR);
		Mip = (struct mtInfo *)strtoul(argv[optind+1],0,0);
	}
	else if (!strcmp(argv[optind],"log")) {
		if (argc != optind + 2)
			return(CMD_PARAM_ERROR);
		Mtrace(argv[optind+1]);
	}
	else if (!strcmp(argv[optind],"dump")) {
		if (MipConfigured()) {
			if (Mip->reentered)
				printf("Reentry count: %d\n",Mip->reentered); 
			if (Mip->wrap) {
				printf("Buffer wrapped...\n");
				bp =  Mip->ptr;
				while(bp < Mip->end) {
					if (*bp == '\n') {
						bp = mDump(bp,more);
						break;
					}
					bp++;
				}
				if (bp) {
					bp =  Mip->base;
					while(bp < Mip->ptr)
						putchar(*bp++);
				}
			}
			else {
				bp = mDump(Mip->base,more);
			}
			printf("\n\n");
		}
	}
	else
		return(CMD_PARAM_ERROR);

	return(CMD_SUCCESS);
}

#else

void
MtraceInit(char *base, int size)
{
	printf("Mtrace() facility not built in.\n");
}

int
Mtrace(char *fmt, ...)
{
	return(0);
}

#endif