[OpenSPARC-T2-SAM] / rst / rstf / rstf.c

/*
* ========== Copyright Header Begin ==========================================
* 
* OpenSPARC T2 Processor File: rstf.c
* Copyright (c) 2006 Sun Microsystems, Inc.  All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES.
* 
* The above named program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public
* License version 2 as published by the Free Software Foundation.
* 
* The above named program is distributed in the hope that it will be 
* useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* General Public License for more details.
* 
* You should have received a copy of the GNU General Public
* License along with this work; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
* 
* ========== Copyright Header End ============================================
*/
#pragma ident "@(#)  rstf.c  1.3: 03/05/03 16:59:47 @(#)"
//
// This is C code, not C++
// 

#include <stdarg.h>		// ??
#include <stdio.h>		// fopen()
#include <string.h>		// strncmp()
#include <stdlib.h>		// putenv()

#include <sys/types.h>		// time_t
#include <sys/stat.h>		// struct stat
#include <time.h>		// time_t

#include "rstf.h"
#include "vercheck.c"

#ifndef true
  #define true 	1
  #define false 0
  typedef int boolean;
#endif

static int numbad = 0;			// number of bad RST recs
// static int dummy = RSTF_ATRACE_NO_PC;

#define print_type_size(out,type) \
	check(out, #type, sizeof(type), want);

static int streq (const char* a, const char* b) {
    return (strcmp(a, b) == 0);
}

static int endsWith (const char* str, const char* suffix) {
    int slen = strlen(str);
    int sufflen = strlen(suffix);
    return (sufflen <= slen) &&
	(strncmp(str+slen-sufflen, suffix, sufflen) == 0);
} /* endsWith */

//
// Version handling code
// 

  // Set of triples (AA,BB,CC), where
  //  Versions in the range [AA,BB) are compatiable.
  //  Versions with the same CC value are considered semi-compatible.
  //  Versions with different CC values are incompatible.
  //  The last entry should have AA = BB = CC = -1 .
  // Thus for this table:
  //   1.00 vs. 1.04 => compatible.
  //   1.04 vs. 1.06 => semi-compatible.
  //   1.07 vs. 1.09 => semi-compatible.
  //   1.10 vs. 2.02 => compatible.
double rst_vequivtab [][3] = {
    { 0.00,   1.00,  0.0 },
    { 1.00,   1.04,  1.0 },
    { 1.04,   1.06,  2.0 },
    { 1.06,   1.08,  2.0 },
    { 1.08,   1.10,  2.0 },
    { 1.10,   2.09,  3.0 },
    {  -1,    -1.0, -1.0 },
};

static double rstver2double (const char * str) {
    int x, y;
    int ni = sscanf(str, "%d.%d", &x, &y);
    double d = x*100 + y;
    return d / 100;
} /* rstver2double */

int rst_verCheck (
  const char* ct_str, const char* rt_str, double vt[][3], const char* modname
) {
    double ct_ver = rstver2double(ct_str);
    double rt_ver = rstver2double(rt_str);
    return ver_check_dbl(ct_ver, rt_ver, vt, modname);
} /* generic_verCheck */

int rstf_version_check_fn (const char* ct_version) {
    const char* rt_str = RSTF_VERSION_STR;
    return rst_verCheck(ct_version, rt_str, rst_vequivtab, "RST");
} /* rstf_version_check_fn */

int rstf_checkheader (const char* compile_time_ver, rstf_headerT *rec) {
    double ct_ver = rstver2double(compile_time_ver);
    if (rec->rtype == RSTHEADER_T) {
	double trace_ver = (100 * rec->majorVer) + rec->minorVer;
	trace_ver /= 100;

	if (rec->percent != '%') {
	    fprintf(stderr, "Non-compliant RST header: compile-on=%% got=%c\n",
		    rec->percent);
	}
	return ver_check_dbl(ct_ver, trace_ver, rst_vequivtab, "RST trace");
    }
    return VERCHECK_ERROR;
} /* rstf_checkheader */

typedef struct {
    FILE * f;
    int isCompressed;
} fileinfo_t;

static int nfileinfo = 0;
static fileinfo_t fileinfo[64];

static void printfi () {
    int i= 0;
    for (i=0; i<nfileinfo; i++) {
	fileinfo_t * pp = & fileinfo[i];
	fprintf(stderr,
		"[%d]->f=0x%0x iscompressed=%d\n", i, pp->f, pp->isCompressed);
    }
} /* printfi */

FILE * openRST (const char* filename) {
    FILE * f = NULL;
    int decompress = 
	endsWith(filename, ".rsz") ||
	endsWith(filename, ".rz.gz") ||
	endsWith(filename, ".rsz.gz") ||
	endsWith(filename, ".rzgz");
    int decompress2 = endsWith(filename, ".rz2.gz");
    if (decompress) {
	char command [2048];
	putenv("PATH=/import/archperf/bin:/usr/bin:/bin");
	sprintf(command, "rstzip -d -gz %s", filename);
	f = popen(command, "r");
    } else if (decompress2) {
	char command [2048];
	putenv("PATH=/import/archperf/bin:/usr/bin:/bin");
	sprintf(command, "rstunzip2 %s", filename);
	f = popen(command, "r");
    } else {
	f = fopen(filename, "r");
    }
    if (f != NULL) {
	fileinfo[nfileinfo].f = f;
	fileinfo[nfileinfo].isCompressed = decompress || decompress2;
	nfileinfo ++;
    }
    return f;
} /* openRST */

void closeRST (FILE* f) {
    int i= 0;
    for (i=0; i<nfileinfo; i++) {
	fileinfo_t * pp = & fileinfo[i];
	if (pp->f == f) {
	    if (pp->isCompressed) {
		pclose(f);
	    } else {
		fclose(f);
	    }
	    pp->f = NULL;
	    f = NULL;		/* we found it */
	    *pp = fileinfo[nfileinfo-1];
	    nfileinfo --;
	    break;
	}
    }
    /* guess the type of the file */
    if (f != NULL) {
	char* ftype = "unknown";
	if (isPipeRST(f)) {
	    pclose(f);
	    ftype = "pipe from popen";
	} else {
	    fclose(f);
	    ftype = "regular file";
	}
	fprintf(stderr, "closeRST(f=%x), guessed f is %s\n", f, ftype);
    }
} /* closeRST */

int isPipeRST (FILE* f) {
    struct stat statbuf;
    int fd = fileno(f);
    fstat(fd, &statbuf);
    return ((statbuf.st_mode & S_IFIFO) == S_IFIFO);
}

int isCompressedRSZ (char * buff, int bufflen) {
    // from running "od -x trace.rz.gz"
    static short want [] = {
	0x1f, 0x8b, 0x08, 0x00, -1, -1, -1, -1
    };
    int i;
    for (i=0; i<sizeof(want)/sizeof(want[0]) ; i++) {
	if (buff[i] != want[i] && want[i] != -1) {
	    return false;
	}
    }
    return true;
} /* isCompressedRSZ */

void check (FILE* out, const char* type, int tsize, int want) {
    fprintf(out, "sizeof(%18s) = %4d\n", type, tsize);
    if (tsize != want) {
	numbad ++;
	fprintf(out, "ERROR on (%s) field.\n", type, sizeof(type));
	fflush(out);
    }
} /* check */

static void initrec (void* ptr, uint8_t rtype) {
  INIT_RST_REC(ptr,rtype);
} /* initrec */

#define INIT_RST_REC_DBG(rstf_ptr,rtype_val) \
    do { \
	rstf_uint64T * p = (rstf_uint64T*) (rstf_ptr); \
	p->arr64[0] = (rtype_val); \
	p->arr64[0] <<= (64-8); \
	p->arr64[1] = 0; \
	p->arr64[2] = 0; \
    } while (0==1)

void testSizes () {
    FILE* out = stdout;
    rstf_protoT rec;
    rstf_protoT * p = &rec;
    int want = sizeof(rstf_unionT);

    print_type_size(out,rstf_unionT);
    print_type_size(out,rstf_protoT);
    print_type_size(out,rstf_whatT);
    print_type_size(out,rstf_instrT);
    print_type_size(out,rstf_tlbT);
    print_type_size(out,rstf_threadT);
    print_type_size(out,rstf_processT);
    print_type_size(out,rstf_pregT);
    print_type_size(out,rstf_trapT);
    print_type_size(out,rstf_cpuT);
    print_type_size(out,rstf_trapT);
    print_type_size(out,rstf_stringT);
    print_type_size(out,rstf_physaddrT);
    print_type_size(out,rstf_pavadiffT);
    print_type_size(out,rstf_memval64T);
    print_type_size(out,rstf_memval128T);
    print_type_size(out,rstf_bustraceT);
    print_type_size(out,rstf_filemarkerT);
    print_type_size(out,rstf_recnumT);
    print_type_size(out,rstf_hwinfoT);
    print_type_size(out,rstf_statusT);
    print_type_size(out,rstf_patchT);
    print_type_size(out,rstf_dmaT);
    printf("================\n");
    print_type_size(out,rstf_uint8T);
    print_type_size(out,rstf_uint16T);
    print_type_size(out,rstf_uint32T);
    print_type_size(out,rstf_uint64T);
    if (numbad == 0) {
	fprintf(out, "Good.  All records in rstf are the same size.\n");
    }

    initrec(&rec, INSTR_T);
    fprintf(out, "OK rtype=%d want=%d\n", rec.rtype, INSTR_T); fflush(out);
    initrec(&rec, TLB_T);
    fprintf(out, "OK rtype=%d want=%d\n", rec.rtype, TLB_T); fflush(out);
//    INIT_RST_REC_DBG( p , INSTR_T);
//    fprintf(out, "OK rtype=%d want=%d\n", rec.rtype, INSTR_T); fflush(out);
    INIT_RST_REC( p , INSTR_T);
    fprintf(out, "OK rtype=%d want=%d\n", rec.rtype, INSTR_T); fflush(out);
}

static void strcopy (char* dest, const char* src, int destsize) {
    strncpy(dest, src, destsize);
    dest[destsize-1] = '\0';
} /* strcopy */

int rstf_strncpy (void * dest_rstp, const char *str) {
    rstf_unionT * up = (rstf_unionT *) dest_rstp;
    rstf_headerT * hp = &(up->header);
    switch (up->string.rtype) {
      case RSTHEADER_T:
	  strncpy(hp->header_str, str, sizeof(hp->header_str));
	  break;
      default:
	  ;
    }
    return 0;
} /* rstf_strncpy */

  // initialize a header record with the current RST major/minor number.
  // The string 
int init_rstf_header (rstf_headerT * hp) {
    char buff[80];
    INIT_RST_REC(hp, RSTHEADER_T);
    hp->majorVer = RSTF_MAJOR_VERSION;
    hp->minorVer = RSTF_MINOR_VERSION;
    hp->percent   = '%';
    sprintf(buff, "%s v%s", RSTF_MAGIC, RSTF_VERSION_STR);
    rstf_strncpy(hp, buff);
    return 0;
}

int init_rstf_traceinfo_level (rstf_traceinfo_levelT * ti, int level) {
    INIT_RST_REC(ti, TRACEINFO_T);
    ti->rtype2 = RSTT2_NLEVEL_T;
    ti->level = level;
    ti->time64 = (uint64_t) time(NULL);
    return 0;
}

int init_rstf_string (rstf_stringT * strp, const char *str) {
    int len = strlen(str) + 1;		// null char adds 1
    int recsize = sizeof(strp->string);
    INIT_RST_REC(strp, STRDESC_T);
    if (recsize >= len) {
	strncpy(strp->string, str, recsize);
    } else {
	strncpy(strp->string, str, recsize-1);
	strp->string[recsize-1] = '\0';
    }
    return 0;
} /* init_rstf_string */

  // get the next string
const char* get_rstf_longstr (const rstf_stringT * p, int nrec, int *nrread) {
    static char buff [2048];
    char* end = buff;		// 
    int nr = 0;
    const int strcontsize = sizeof(p->string);
    while (nr < nrec) {
	const rstf_stringT * strp = & (p[nr]);
	int rem = buff + sizeof(buff) - end;	// remaining room
	if (rem < strcontsize) {
	    break;
	}
	if (strp->rtype == STRCONT_T) {
	    strncpy(end, strp->string, strcontsize);
	    end += strcontsize;
	    nr ++;
	} else if (strp->rtype == STRDESC_T) {
	    strcpy(end, strp->string);
	    end += strlen(strp->string);
	    nr ++;
	    break;
	} else {
	    break;
	}
    }
    if (nrread != NULL) {
	*nrread = nr;
    }
    *end = '\0';
    return buff;
} /* get_rstf_long_string */

#define	min(x,y) ((x)<(y) ? (x) : (y))

  // Initialize upto MAXREC records with the string STR, using
  // STRDESC_T and STRCONT_T records.  Handles strings of any length.
  // Returns the number of RST records used.
int init_rstf_strbuff (rstf_stringT * strp, const char *str, int maxrec) {
    int len = strlen(str) + 1;		// null char adds 1
    int recsize = sizeof(strp->string);
    int nrneeded = ((len) + (recsize-1))/ recsize;
    int canuse = min(maxrec, nrneeded);		// RST records we can use
    const char* ss = str;
    int i;
    for (i=0; i<canuse; i++) {
	if (i == (canuse-1) ) {
	    init_rstf_string( &strp[i], ss );
	} else {
	    strp[i].rtype = STRCONT_T;
	    strncpy(strp[i].string, ss, recsize);
	    ss += recsize;
	}
    }
    return canuse;
} /* init_rstf_strbuff */

  // Convenience fn to generate a RST_STRDESC record.  
int rstf_sprintf (rstf_stringT * strp, const char* fmt, ...) {
  #define BUFFLEN 1024
    char buff[BUFFLEN];
    va_list ap;
    va_start(ap, fmt);
    vsnprintf(buff, BUFFLEN, fmt, ap);
  #undef BUFFLEN
    init_rstf_string(strp, buff);
    va_end(ap);
    return 0;
} /* rst_sprintf */

  // Convenience fn to generate a RST_STRDESC record.  
int rstf_snprintf (rstf_stringT * strp, int maxrec, const char* fmt, ...) {
  #define BUFFLEN 8192
    char buff[BUFFLEN];
    int nr = 0;
    va_list ap;
    va_start(ap, fmt);
    vsnprintf(buff, 8192, fmt, ap);
  #undef BUFFLEN
    nr = init_rstf_strbuff(strp, buff, maxrec);
    va_end(ap);
    return nr;
} /* rst_sprintf */

void printIfBadAddr (uint64_t xaddr) {
    if (RSTF_IS_BADADDR(xaddr)) {
	printf("Addr 0x%08llx is a known bad RST addr\n", xaddr);
    }
}

void checkRSTmacro () {
    uint64_t x = RSTF_ATRACE_NO_PC;

    printIfBadAddr(x);
    x = 0x314159ff;
    printIfBadAddr(x);
    x = 0x314159fe;
    printIfBadAddr(x);
    x = 0x1234567;;
    printIfBadAddr(x);
}
    
#define RCBUFFSIZE 8192
char* unixcommand (const char * command, int nl, int * statusptr) {
    static char charbuff[RCBUFFSIZE];
    FILE *ptr = popen(command, "r");
    char *buf = charbuff;
    char *result = NULL;

    if (ptr != NULL) {
	int status;
	while (fgets(buf, RCBUFFSIZE - (buf-charbuff), ptr) != NULL) {
	    int len = strlen(buf);
	    if (buf[len-1] == '\n') {
		// remove '\n', terminate string, in case last line of input
		buf[len] = '\0';
		result = charbuff;
		if (nl <= 1) {
		    buf[len-1] = '\0';		// discard last newline
		    break;
		}
		nl --;
		buf += len;
	    }
	}
	status = pclose(ptr);
	if (statusptr != NULL) {
	    *statusptr = status;
	}
    }
    return result;
} /* unixcommand */

static void genTestTrace (const char* str) {
    rstf_unionT  uuu[256];
    rstf_stringT * buff = & (uuu[1].string);	// [1] == skip past header
    int nr , nr2;
    char* now = unixcommand("date", 1, NULL);
    char* df = NULL;
    init_rstf_header(& uuu[0].header);
    rstf_sprintf(buff, "BEGIN it is %s", now);
    nr = rstf_snprintf(buff+1, 88, "it is now %s", now);
    df = unixcommand("df -lk", 44, NULL);
    nr2 = rstf_snprintf(buff+1+nr, 88, "Local mounted disks %s", df);
    rstf_sprintf(buff+1+nr+nr2, "END.  argv[0]=(%s)", str);
    fwrite(&uuu, sizeof(buff[0]), 3+nr+nr2, stdout);
    fflush(stdout);
} /* genTestTrace */

#if defined(TEST_RSTF)

static void usage (char* argv0) {
    printf("usage: %s [-tvf]\n", argv0);
    printf("  -f FILE = read 16K recs from FILE openRST(), send to stdout\n");
    printf("  -t = generate a test trace to stdout\n");
    printf("  -v = run version check code\n");
    printf(" Eg.  %s -t | trconv\n", argv0);
} /* usage */

  // check a 
static void checkVer () {
    const char* strArr [] =
	{ "1.00", "1.4", "1.7", "1.8", "1.10", "2.0", "2.02", "4.8" };
    int len = sizeof(strArr) / sizeof(strArr[0]);
    int i = 0;
    for (i=0; i<len; i++) {
	int j;
	const char * ct = strArr[i];
	for (j=i; j<len; j++) {
	    const char * rt = strArr[j];
	    int status = generic_verCheck(ct, rt,  rst_vequivtab, "XYZ");
	    int status2 = rst_verCheck(ct, rt,  rst_vequivtab, "RST");

	    printf("%d = verCheck(%s, %s)\n", status, ct, rt);
	    printf("%d = rst_verCheck(%s, %s)\n", status2, ct, rt);
	}
    }
} /* checkVer */

int main (int argc, char* argv []) {
    if (argc == 1) {
	testSizes();
	checkRSTmacro();
	usage(argv[0]);
    } else {
	int i;
	for (i=1; i<argc; i++) {
	    if ( streq(argv[1], "-f") ) {
		i++;
		if (i<argc) {
		    FILE * f = openRST(argv[i]);
		    if (f != NULL) {
			rstf_unionT ru [128];
			int nr = -1;
			int tot = 0;
			while ((nr=fread(ru, sizeof(ru[0]), 128, f)) > 0) {
			    fwrite(ru, sizeof(ru[0]), nr, stdout);
			    tot += nr;
			    if (tot > 16384) {
				break;
			    }
			}
			closeRST(f);
		    }
		}
	    } else if ( streq(argv[1], "-v") ) {
		checkVer();
	    } else if ( streq(argv[1], "-v") ) {
		checkVer();
	    } else if ( streq(argv[1], "-t") ) {
		genTestTrace(argv[0]);
	    }
	}
    }
}

#endif /* defined() */
Commit	Line	Data
920dae64 AT	1	/*
	2	* ========== Copyright Header Begin ==========================================
	3	*
	4	* OpenSPARC T2 Processor File: rstf.c
	5	* Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
	6	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES.
	7	*
	8	* The above named program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public
	10	* License version 2 as published by the Free Software Foundation.
	11	*
	12	* The above named program is distributed in the hope that it will be
	13	* useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public
	18	* License along with this work; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
	20	*
	21	* ========== Copyright Header End ============================================
	22	*/
	23	#pragma ident "@(#) rstf.c 1.3: 03/05/03 16:59:47 @(#)"
	24	//
	25	// This is C code, not C++
	26	//
	27
	28	#include <stdarg.h> // ??
	29	#include <stdio.h> // fopen()
	30	#include <string.h> // strncmp()
	31	#include <stdlib.h> // putenv()
	32
	33	#include <sys/types.h> // time_t
	34	#include <sys/stat.h> // struct stat
	35	#include <time.h> // time_t
	36
	37	#include "rstf.h"
	38	#include "vercheck.c"
	39
	40	#ifndef true
	41	#define true 1
	42	#define false 0
	43	typedef int boolean;
	44	#endif
	45
	46	static int numbad = 0; // number of bad RST recs
	47	// static int dummy = RSTF_ATRACE_NO_PC;
	48
	49	#define print_type_size(out,type) \
	50	check(out, #type, sizeof(type), want);
	51
	52	static int streq (const char* a, const char* b) {
	53	return (strcmp(a, b) == 0);
	54	}
	55
	56	static int endsWith (const char* str, const char* suffix) {
	57	int slen = strlen(str);
	58	int sufflen = strlen(suffix);
	59	return (sufflen <= slen) &&
	60	(strncmp(str+slen-sufflen, suffix, sufflen) == 0);
	61	} /* endsWith */
	62
	63	//
	64	// Version handling code
65	//
66
67	// Set of triples (AA,BB,CC), where
68	// Versions in the range [AA,BB) are compatiable.
69	// Versions with the same CC value are considered semi-compatible.
70	// Versions with different CC values are incompatible.
71	// The last entry should have AA = BB = CC = -1 .
72	// Thus for this table:
73	// 1.00 vs. 1.04 => compatible.
74	// 1.04 vs. 1.06 => semi-compatible.
75	// 1.07 vs. 1.09 => semi-compatible.
76	// 1.10 vs. 2.02 => compatible.
77	double rst_vequivtab [][3] = {
78	{ 0.00, 1.00, 0.0 },
79	{ 1.00, 1.04, 1.0 },
80	{ 1.04, 1.06, 2.0 },
81	{ 1.06, 1.08, 2.0 },
82	{ 1.08, 1.10, 2.0 },
83	{ 1.10, 2.09, 3.0 },
84	{ -1, -1.0, -1.0 },
85	};
86
87	static double rstver2double (const char * str) {
88	int x, y;
89	int ni = sscanf(str, "%d.%d", &x, &y);
90	double d = x*100 + y;
91	return d / 100;
92	} /* rstver2double */
93
94	int rst_verCheck (
95	const char* ct_str, const char* rt_str, double vt[][3], const char* modname
96	) {
97	double ct_ver = rstver2double(ct_str);
98	double rt_ver = rstver2double(rt_str);
99	return ver_check_dbl(ct_ver, rt_ver, vt, modname);
100	} /* generic_verCheck */
101
102	int rstf_version_check_fn (const char* ct_version) {
103	const char* rt_str = RSTF_VERSION_STR;
104	return rst_verCheck(ct_version, rt_str, rst_vequivtab, "RST");
105	} /* rstf_version_check_fn */
106
107	int rstf_checkheader (const char* compile_time_ver, rstf_headerT *rec) {
108	double ct_ver = rstver2double(compile_time_ver);
109	if (rec->rtype == RSTHEADER_T) {
110	double trace_ver = (100 * rec->majorVer) + rec->minorVer;
111	trace_ver /= 100;
112
113	if (rec->percent != '%') {
114	fprintf(stderr, "Non-compliant RST header: compile-on=%% got=%c\n",
115	rec->percent);
116	}
117	return ver_check_dbl(ct_ver, trace_ver, rst_vequivtab, "RST trace");
118	}
119	return VERCHECK_ERROR;
120	} /* rstf_checkheader */
121
122	typedef struct {
123	FILE * f;
124	int isCompressed;
125	} fileinfo_t;
126
127	static int nfileinfo = 0;
128	static fileinfo_t fileinfo[64];
129
130	static void printfi () {
131	int i= 0;
132	for (i=0; i<nfileinfo; i++) {
133	fileinfo_t * pp = & fileinfo[i];
134	fprintf(stderr,
135	"[%d]->f=0x%0x iscompressed=%d\n", i, pp->f, pp->isCompressed);
136	}
137	} /* printfi */
138
139	FILE * openRST (const char* filename) {
140	FILE * f = NULL;
141	int decompress =
142	endsWith(filename, ".rsz") \|\|
143	endsWith(filename, ".rz.gz") \|\|
144	endsWith(filename, ".rsz.gz") \|\|
145	endsWith(filename, ".rzgz");
146	int decompress2 = endsWith(filename, ".rz2.gz");
147	if (decompress) {
148	char command [2048];
149	putenv("PATH=/import/archperf/bin:/usr/bin:/bin");
150	sprintf(command, "rstzip -d -gz %s", filename);
151	f = popen(command, "r");
152	} else if (decompress2) {
153	char command [2048];
154	putenv("PATH=/import/archperf/bin:/usr/bin:/bin");
155	sprintf(command, "rstunzip2 %s", filename);
156	f = popen(command, "r");
157	} else {
158	f = fopen(filename, "r");
159	}
160	if (f != NULL) {
161	fileinfo[nfileinfo].f = f;
162	fileinfo[nfileinfo].isCompressed = decompress \|\| decompress2;
163	nfileinfo ++;
164	}
165	return f;
166	} /* openRST */
167
168	void closeRST (FILE* f) {
169	int i= 0;
170	for (i=0; i<nfileinfo; i++) {
171	fileinfo_t * pp = & fileinfo[i];
172	if (pp->f == f) {
173	if (pp->isCompressed) {
174	pclose(f);
175	} else {
176	fclose(f);
177	}
178	pp->f = NULL;
179	f = NULL; /* we found it */
180	*pp = fileinfo[nfileinfo-1];
181	nfileinfo --;
182	break;
183	}
184	}
185	/* guess the type of the file */
186	if (f != NULL) {
187	char* ftype = "unknown";
188	if (isPipeRST(f)) {
189	pclose(f);
190	ftype = "pipe from popen";
191	} else {
192	fclose(f);
193	ftype = "regular file";
194	}
195	fprintf(stderr, "closeRST(f=%x), guessed f is %s\n", f, ftype);
196	}
197	} /* closeRST */
198
199	int isPipeRST (FILE* f) {
200	struct stat statbuf;
201	int fd = fileno(f);
202	fstat(fd, &statbuf);
203	return ((statbuf.st_mode & S_IFIFO) == S_IFIFO);
204	}
205
206	int isCompressedRSZ (char * buff, int bufflen) {
207	// from running "od -x trace.rz.gz"
208	static short want [] = {
209	0x1f, 0x8b, 0x08, 0x00, -1, -1, -1, -1
210	};
211	int i;
212	for (i=0; i<sizeof(want)/sizeof(want[0]) ; i++) {
213	if (buff[i] != want[i] && want[i] != -1) {
214	return false;
215	}
216	}
217	return true;
218	} /* isCompressedRSZ */
219
220	void check (FILE* out, const char* type, int tsize, int want) {
221	fprintf(out, "sizeof(%18s) = %4d\n", type, tsize);
222	if (tsize != want) {
223	numbad ++;
224	fprintf(out, "ERROR on (%s) field.\n", type, sizeof(type));
225	fflush(out);
226	}
227	} /* check */
228
229	static void initrec (void* ptr, uint8_t rtype) {
230	INIT_RST_REC(ptr,rtype);
231	} /* initrec */
232
233	#define INIT_RST_REC_DBG(rstf_ptr,rtype_val) \
234	do { \
235	rstf_uint64T * p = (rstf_uint64T*) (rstf_ptr); \
236	p->arr64[0] = (rtype_val); \
237	p->arr64[0] <<= (64-8); \
238	p->arr64[1] = 0; \
239	p->arr64[2] = 0; \
240	} while (0==1)
241
242	void testSizes () {
243	FILE* out = stdout;
244	rstf_protoT rec;
245	rstf_protoT * p = &rec;
246	int want = sizeof(rstf_unionT);
247
248	print_type_size(out,rstf_unionT);
249	print_type_size(out,rstf_protoT);
250	print_type_size(out,rstf_whatT);
251	print_type_size(out,rstf_instrT);
252	print_type_size(out,rstf_tlbT);
253	print_type_size(out,rstf_threadT);
254	print_type_size(out,rstf_processT);
255	print_type_size(out,rstf_pregT);
256	print_type_size(out,rstf_trapT);
257	print_type_size(out,rstf_cpuT);
258	print_type_size(out,rstf_trapT);
259	print_type_size(out,rstf_stringT);
260	print_type_size(out,rstf_physaddrT);
261	print_type_size(out,rstf_pavadiffT);
262	print_type_size(out,rstf_memval64T);
263	print_type_size(out,rstf_memval128T);
264	print_type_size(out,rstf_bustraceT);
265	print_type_size(out,rstf_filemarkerT);
266	print_type_size(out,rstf_recnumT);
267	print_type_size(out,rstf_hwinfoT);
268	print_type_size(out,rstf_statusT);
269	print_type_size(out,rstf_patchT);
270	print_type_size(out,rstf_dmaT);
271	printf("================\n");
272	print_type_size(out,rstf_uint8T);
273	print_type_size(out,rstf_uint16T);
274	print_type_size(out,rstf_uint32T);
275	print_type_size(out,rstf_uint64T);
276	if (numbad == 0) {
277	fprintf(out, "Good. All records in rstf are the same size.\n");
278	}
279
280	initrec(&rec, INSTR_T);
281	fprintf(out, "OK rtype=%d want=%d\n", rec.rtype, INSTR_T); fflush(out);
282	initrec(&rec, TLB_T);
283	fprintf(out, "OK rtype=%d want=%d\n", rec.rtype, TLB_T); fflush(out);
284	// INIT_RST_REC_DBG( p , INSTR_T);
285	// fprintf(out, "OK rtype=%d want=%d\n", rec.rtype, INSTR_T); fflush(out);
286	INIT_RST_REC( p , INSTR_T);
287	fprintf(out, "OK rtype=%d want=%d\n", rec.rtype, INSTR_T); fflush(out);
288	}
289
290	static void strcopy (char* dest, const char* src, int destsize) {
291	strncpy(dest, src, destsize);
292	dest[destsize-1] = '\0';
293	} /* strcopy */
294
295	int rstf_strncpy (void * dest_rstp, const char *str) {
296	rstf_unionT * up = (rstf_unionT *) dest_rstp;
297	rstf_headerT * hp = &(up->header);
298	switch (up->string.rtype) {
299	case RSTHEADER_T:
300	strncpy(hp->header_str, str, sizeof(hp->header_str));
301	break;
302	default:
303	;
304	}
305	return 0;
306	} /* rstf_strncpy */
307
308	// initialize a header record with the current RST major/minor number.
309	// The string
310	int init_rstf_header (rstf_headerT * hp) {
311	char buff[80];
312	INIT_RST_REC(hp, RSTHEADER_T);
313	hp->majorVer = RSTF_MAJOR_VERSION;
314	hp->minorVer = RSTF_MINOR_VERSION;
315	hp->percent = '%';
316	sprintf(buff, "%s v%s", RSTF_MAGIC, RSTF_VERSION_STR);
317	rstf_strncpy(hp, buff);
318	return 0;
319	}
320
321	int init_rstf_traceinfo_level (rstf_traceinfo_levelT * ti, int level) {
322	INIT_RST_REC(ti, TRACEINFO_T);
323	ti->rtype2 = RSTT2_NLEVEL_T;
324	ti->level = level;
325	ti->time64 = (uint64_t) time(NULL);
326	return 0;
327	}
328
329	int init_rstf_string (rstf_stringT * strp, const char *str) {
330	int len = strlen(str) + 1; // null char adds 1
331	int recsize = sizeof(strp->string);
332	INIT_RST_REC(strp, STRDESC_T);
333	if (recsize >= len) {
334	strncpy(strp->string, str, recsize);
335	} else {
336	strncpy(strp->string, str, recsize-1);
337	strp->string[recsize-1] = '\0';
338	}
339	return 0;
340	} /* init_rstf_string */
341
342	// get the next string
343	const char* get_rstf_longstr (const rstf_stringT * p, int nrec, int *nrread) {
344	static char buff [2048];
345	char* end = buff; //
346	int nr = 0;
347	const int strcontsize = sizeof(p->string);
348	while (nr < nrec) {
349	const rstf_stringT * strp = & (p[nr]);
350	int rem = buff + sizeof(buff) - end; // remaining room
351	if (rem < strcontsize) {
352	break;
353	}
354	if (strp->rtype == STRCONT_T) {
355	strncpy(end, strp->string, strcontsize);
356	end += strcontsize;
357	nr ++;
358	} else if (strp->rtype == STRDESC_T) {
359	strcpy(end, strp->string);
360	end += strlen(strp->string);
361	nr ++;
362	break;
363	} else {
364	break;
365	}
366	}
367	if (nrread != NULL) {
368	*nrread = nr;
369	}
370	*end = '\0';
371	return buff;
372	} /* get_rstf_long_string */
373
374	#define min(x,y) ((x)<(y) ? (x) : (y))
375
376	// Initialize upto MAXREC records with the string STR, using
377	// STRDESC_T and STRCONT_T records. Handles strings of any length.
378	// Returns the number of RST records used.
379	int init_rstf_strbuff (rstf_stringT * strp, const char *str, int maxrec) {
380	int len = strlen(str) + 1; // null char adds 1
381	int recsize = sizeof(strp->string);
382	int nrneeded = ((len) + (recsize-1))/ recsize;
383	int canuse = min(maxrec, nrneeded); // RST records we can use
384	const char* ss = str;
385	int i;
386	for (i=0; i<canuse; i++) {
387	if (i == (canuse-1) ) {
388	init_rstf_string( &strp[i], ss );
389	} else {
390	strp[i].rtype = STRCONT_T;
391	strncpy(strp[i].string, ss, recsize);
392	ss += recsize;
393	}
394	}
395	return canuse;
396	} /* init_rstf_strbuff */
397
398	// Convenience fn to generate a RST_STRDESC record.
399	int rstf_sprintf (rstf_stringT * strp, const char* fmt, ...) {
400	#define BUFFLEN 1024
401	char buff[BUFFLEN];
402	va_list ap;
403	va_start(ap, fmt);
404	vsnprintf(buff, BUFFLEN, fmt, ap);
405	#undef BUFFLEN
406	init_rstf_string(strp, buff);
407	va_end(ap);
408	return 0;
409	} /* rst_sprintf */
410
411	// Convenience fn to generate a RST_STRDESC record.
412	int rstf_snprintf (rstf_stringT * strp, int maxrec, const char* fmt, ...) {
413	#define BUFFLEN 8192
414	char buff[BUFFLEN];
415	int nr = 0;
416	va_list ap;
417	va_start(ap, fmt);
418	vsnprintf(buff, 8192, fmt, ap);
419	#undef BUFFLEN
420	nr = init_rstf_strbuff(strp, buff, maxrec);
421	va_end(ap);
422	return nr;
423	} /* rst_sprintf */
424
425	void printIfBadAddr (uint64_t xaddr) {
426	if (RSTF_IS_BADADDR(xaddr)) {
427	printf("Addr 0x%08llx is a known bad RST addr\n", xaddr);
428	}
429	}
430
431	void checkRSTmacro () {
432	uint64_t x = RSTF_ATRACE_NO_PC;
433
434	printIfBadAddr(x);
435	x = 0x314159ff;
436	printIfBadAddr(x);
437	x = 0x314159fe;
438	printIfBadAddr(x);
439	x = 0x1234567;;
440	printIfBadAddr(x);
441	}
442
443	#define RCBUFFSIZE 8192
444	char* unixcommand (const char * command, int nl, int * statusptr) {
445	static char charbuff[RCBUFFSIZE];
446	FILE *ptr = popen(command, "r");
447	char *buf = charbuff;
448	char *result = NULL;
449
450	if (ptr != NULL) {
451	int status;
452	while (fgets(buf, RCBUFFSIZE - (buf-charbuff), ptr) != NULL) {
453	int len = strlen(buf);
454	if (buf[len-1] == '\n') {
455	// remove '\n', terminate string, in case last line of input
456	buf[len] = '\0';
457	result = charbuff;
458	if (nl <= 1) {
459	buf[len-1] = '\0'; // discard last newline
460	break;
461	}
462	nl --;
463	buf += len;
464	}
465	}
466	status = pclose(ptr);
467	if (statusptr != NULL) {
468	*statusptr = status;
469	}
470	}
471	return result;
472	} /* unixcommand */
473
474	static void genTestTrace (const char* str) {
475	rstf_unionT uuu[256];
476	rstf_stringT * buff = & (uuu[1].string); // [1] == skip past header
477	int nr , nr2;
478	char* now = unixcommand("date", 1, NULL);
479	char* df = NULL;
480	init_rstf_header(& uuu[0].header);
481	rstf_sprintf(buff, "BEGIN it is %s", now);
482	nr = rstf_snprintf(buff+1, 88, "it is now %s", now);
483	df = unixcommand("df -lk", 44, NULL);
484	nr2 = rstf_snprintf(buff+1+nr, 88, "Local mounted disks %s", df);
485	rstf_sprintf(buff+1+nr+nr2, "END. argv[0]=(%s)", str);
486	fwrite(&uuu, sizeof(buff[0]), 3+nr+nr2, stdout);
487	fflush(stdout);
488	} /* genTestTrace */
489
490	#if defined(TEST_RSTF)
491
492	static void usage (char* argv0) {
493	printf("usage: %s [-tvf]\n", argv0);
494	printf(" -f FILE = read 16K recs from FILE openRST(), send to stdout\n");
495	printf(" -t = generate a test trace to stdout\n");
496	printf(" -v = run version check code\n");
497	printf(" Eg. %s -t \| trconv\n", argv0);
498	} /* usage */
499
500	// check a
501	static void checkVer () {
502	const char* strArr [] =
503	{ "1.00", "1.4", "1.7", "1.8", "1.10", "2.0", "2.02", "4.8" };
504	int len = sizeof(strArr) / sizeof(strArr[0]);
505	int i = 0;
506	for (i=0; i<len; i++) {
507	int j;
508	const char * ct = strArr[i];
509	for (j=i; j<len; j++) {
510	const char * rt = strArr[j];
511	int status = generic_verCheck(ct, rt, rst_vequivtab, "XYZ");
512	int status2 = rst_verCheck(ct, rt, rst_vequivtab, "RST");
513
514	printf("%d = verCheck(%s, %s)\n", status, ct, rt);
515	printf("%d = rst_verCheck(%s, %s)\n", status2, ct, rt);
516	}
517	}
518	} /* checkVer */
519
520	int main (int argc, char* argv []) {
521	if (argc == 1) {
522	testSizes();
523	checkRSTmacro();
524	usage(argv[0]);
525	} else {
526	int i;
527	for (i=1; i<argc; i++) {
528	if ( streq(argv[1], "-f") ) {
529	i++;
530	if (i<argc) {
531	FILE * f = openRST(argv[i]);
532	if (f != NULL) {
533	rstf_unionT ru [128];
534	int nr = -1;
535	int tot = 0;
536	while ((nr=fread(ru, sizeof(ru[0]), 128, f)) > 0) {
537	fwrite(ru, sizeof(ru[0]), nr, stdout);
538	tot += nr;
539	if (tot > 16384) {
540	break;
541	}
542	}
543	closeRST(f);
544	}
545	}
546	} else if ( streq(argv[1], "-v") ) {
547	checkVer();
548	} else if ( streq(argv[1], "-v") ) {
549	checkVer();
550	} else if ( streq(argv[1], "-t") ) {
551	genTestTrace(argv[0]);
552	}
553	}
554	}
555	}
556
557	#endif /* defined() */