/**************************************************************************
*
* 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
