Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / hypervisor / src / support / mdlint / mdlint.c

/*
* ========== Copyright Header Begin ==========================================
*
* Hypervisor Software File: mdlint.c
* 
* Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
* 
*  - Do no alter or remove copyright notices
* 
*  - Redistribution and use of this software in source and binary forms, with 
*    or without modification, are permitted provided that the following 
*    conditions are met: 
* 
*  - Redistribution of source code must retain the above copyright notice, 
*    this list of conditions and the following disclaimer.
* 
*  - Redistribution 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 of Sun Microsystems, Inc. or the names of contributors 
* may be used to endorse or promote products derived from this software 
* without specific prior written permission. 
* 
*     This software is provided "AS IS," without a warranty of any kind. 
* ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, 
* INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A 
* PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN 
* MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR 
* ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR 
* DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN 
* OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR 
* FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE 
* DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, 
* ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF 
* SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* 
* You acknowledge that this software is not designed, licensed or
* intended for use in the design, construction, operation or maintenance of
* any nuclear facility. 
* 
* ========== Copyright Header End ============================================
*/
/*
 * Copyright 2007 Sun Microsystems, Inc.	 All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"@(#)mdlint.c	1.3	07/06/07 SMI"

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <malloc.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>

#include <netinet/in.h>
#include <inttypes.h>


#include <assert.h>

#define	ASSERT(_s)	assert(_s)

#include <md/md_impl.h>

#include "basics.h"
#include "allocate.h"
#include "fatal.h"


	/*
	 * NOTE:
	 * Deliberate attempt to not borrow code and
	 * be able to lint the MD based on the spec.
	 * That way when things get broken in other
	 * pieces of code we dont lint them as correct anyway.
	 */

typedef struct {
	int fh;
	int size;
	caddr_t caddr;

	md_header_t *headerp;
	md_element_t *mdep;
	char *namep;
	uint8_t *datap;

	int node_blk_size;
	int name_blk_size;
	int data_blk_size;

	int element_count;
	int node_count;
} md_t;

struct {
	bool_t	textdump;
} option;



md_t *md_init(char *fnamep);
int md_close(md_t *mdp);
int process_options(int argc, char **argv);
void md_lint(md_t *mdp);
void output_text(md_t *mdp, FILE *fp);
void brief_sanity(md_t *mdp, FILE *fp);
void output_text_data(FILE *fp, char *propp, uint8_t *datap, int len);




int
main(int argc, char **argv)
{
	md_t *mdp;
	int i;

	i = process_options(argc, argv);

	if (i != argc-1) fatal("Machine description filename expected");

	mdp = md_init(argv[i]);
	if (mdp == NULL) fatal("Unable to open MD");

	md_lint(mdp);

	return (0);
}




void
usage(char *namep)
{
	fprintf(stderr, "usage: %s [-t|--text] <mdfile>\n", namep);
	exit(1);
}


int
process_options(int argc, char **argv)
{
	int i;

	for (i = 1; i < argc && argv[i][0] == '-'; i++) {
		if (strcmp(argv[i], "-h") == 0 ||
		    strcmp(argv[i], "--help") == 0) {
			usage(argv[0]);
		} else
		if ((strcmp(argv[i], "-t") == 0) ||
		    (strcmp(argv[i], "--text") == 0)) {
			option.textdump = true;
		} else
		fatal("Unrecognised option %s\n", argv[i]);
	}

	return (i);
}




void
md_lint(md_t *mdp)
{
	if (option.textdump) {
		output_text(mdp, stdout);
		fflush(stdout);
	}

	fflush(stderr);

	brief_sanity(mdp, stderr);
}






void
output_text(md_t *mdp, FILE *fp)
{
	int idx;
	int count;
	bool_t done;

	count = 0;
	done = false;

	for (idx = 0; !done; idx++) {
		md_element_t *np;
		uint32_t stro;
		uint64_t nextidx;
		uint64_t val;
		uint32_t offset;
		uint32_t len;

		np = &(mdp->mdep[idx]);
		switch (np->tag) {
		case DT_LIST_END:
			fprintf(fp, "\t\t/* The end @ 0x%x */\n", idx);
			done = true;
			break;

		case DT_NULL:
			fprintf(fp, "\t\t/* NULL */\n");
			break;

		case DT_NODE:
			nextidx = ntoh64(np->d.prop_idx);
			stro = ntoh32(np->name);

			fprintf(fp, "node %s node_0x%x {\t\t\t/* next "
			    "@ 0x%llx */\n",
			    mdp->namep + stro, idx, nextidx);
			count ++;
			break;

		case DT_NODE_END:
			fprintf(fp, "}\t\t\t\t\t/* @ 0x%x */\n", idx);
			break;

		case DT_PROP_ARC:
			nextidx = ntoh64(np->d.prop_idx);
			stro = ntoh32(np->name);

			fprintf(fp, "\t%s -> node_0x%llx;\n",
			    mdp->namep + stro, nextidx);
			break;

		case DT_PROP_VAL:
			val = ntoh64(np->d.prop_val);
			stro = ntoh32(np->name);

			fprintf(fp, "\t%s = 0x%llx;\t\t/* %lld */\n",
			    mdp->namep + stro, val, val);
			break;

		case DT_PROP_STR:
			offset = ntoh32(np->d.prop_data.offset);
			len = ntoh32(np->d.prop_data.len);
			stro = ntoh32(np->name);

			fprintf(fp, "\t%s = \"%s\";\n",
			    mdp->namep + stro, mdp->datap + offset);
			break;

		case DT_PROP_DAT:
			offset = ntoh32(np->d.prop_data.offset);
			len = ntoh32(np->d.prop_data.len);
			stro = ntoh32(np->name);

			output_text_data(fp, mdp->namep + stro,
			    &(mdp->datap[offset]), len);
			break;

		default:
			fatal("At index %d found unexpected node type %d"
			    " (0x%x : '%c') while searching for nodes",
			    idx, np->tag, np->tag, np->tag);
		}
	}
}




	/*
	 * Data properties are a little special since in some cases
	 * we have an array of strings.
	 * First scan the data looking for legal string characters
	 * and ensuring that there are no null strings and the last
	 * string is correctly terminated
	 */

void
output_text_data(FILE *fp, char *propp, uint8_t *datap, int len)
{
	int i;
	int step;
	bool_t new_string;

		/* array of strings check */

	fprintf(fp, "\t%s = {\n", propp);

	new_string = true;

	for (i = 0; i < len; i++) {
		int ch;

		ch = datap[i];
		if (ch != 0 && (ch < ' ' || ch >= 126))
			goto non_sarray;

		if (ch == '\0') {
				/* back-to-back nulls not allowed */
			if (new_string)
				goto non_sarray;
			new_string = true;
		} else {
			new_string = false;
		}
	}
	if (!new_string)
		goto non_sarray;

		/* looks like safe to assume an array of strings */

	for (i = 0; i < len; i += step) {
		char *p;

		p = ((char *)(datap + i));
		step = strlen(p)+1;

		fprintf(fp, "\t\t\"%s\"%s", p, (i+step) == len ? "\n" : ",\n");
	}
	fprintf(fp, "\t}; \n");

	return;

non_sarray:;

	for (i = 0; i < len-1; i++) {
		fprintf(fp, "%s0x%02x,",
		    ((i&7) == 0) ? "\n\t\t" : " ", datap[i]);
	}
	fprintf(fp, " 0x%02x };\n", datap[i]);
}







void
brief_sanity(md_t *mdp, FILE *fp)
{
	int idx;
	int count;
	bool_t done;
	bool_t in_node;
	int nodeidx;

	count = 0;
	done = false;
	in_node = false;
	nodeidx = -1;

	for (idx = 0; !done; idx++) {
		md_element_t *np;
		uint32_t stro;
		bool_t check_name = false;

		np = &(mdp->mdep[idx]);
		switch (np->tag) {
		case DT_LIST_END:
			done = true;
			break;

		case DT_NULL:
			break;

		case DT_NODE:
			stro = ntoh32(np->name);

			if (in_node)
				fatal("Node element @ 0x%x (%s) "
				    "defined within node @ 0x%x (%s)\n",
				    idx, mdp->namep + stro, nodeidx,
				    mdp->namep +
				    ntoh32(mdp->mdep[nodeidx].name));
			in_node = true;
			nodeidx = idx;
			check_name = true;
			count ++;
			break;

		case DT_NODE_END:
			if (!in_node)
				fatal("Node end element @ 0x%x "
				    "defined outside a node\n", idx);
			in_node = false;
			break;

		case DT_PROP_ARC:
			stro = ntoh32(np->name);
			check_name = true;
			break;

		case DT_PROP_VAL:
			stro = ntoh32(np->name);
			check_name = true;
			break;

		case DT_PROP_STR:
			stro = ntoh32(np->name);
			check_name = true;
			break;

		case DT_PROP_DAT:
			stro = ntoh32(np->name);
			check_name = true;

			break;

		default:
			fatal("At index %d found unexpected node type %d"
			    " (0x%x : '%c') while searching for nodes",
			    idx, np->tag, np->tag, np->tag);
		}

		if (check_name) {
			int nlen;

			nlen = strlen((char *)(mdp->namep + stro));
			if (np->namelen != nlen)
				fatal("Element @ 0x%x (%s): "
				    "name length (%d) doesnt match strlen (%d)"
				    " of name in table",
				    idx, mdp->datap + stro, np->namelen, nlen);
		}
	}
}









md_t *
md_init(char *fnamep)
{
	md_t *mdp;
	struct stat sb;
	int idx, count;

	mdp = (md_t *)Xcalloc(1, md_t);
	if (mdp == NULL)
		return (NULL);

	if (stat(fnamep, &sb) < 0)
		return (NULL);

	if ((sb.st_mode & S_IFMT) != S_IFREG ||
	    sb.st_size < sizeof (md_hdr_t)) {
		errno = EIO;
		return (NULL);
	}

	mdp->fh = open(fnamep, O_RDONLY, 0);
	if (mdp->fh < 0)
		return (NULL);

	mdp->caddr = mmap(NULL, sb.st_size, PROT_READ, MAP_PRIVATE, mdp->fh,
	    (off_t)0);
	if (mdp->headerp == MAP_FAILED) {
		int res;
		res = errno;
		close(mdp->fh);
		mdp->fh = -1;
		errno = res;
		return (NULL);
	}

	mdp->size = sb.st_size;

		/* setup internal structures */
	mdp->headerp = (md_hdr_t *)mdp->caddr;

	mdp->node_blk_size = ntoh32(mdp->headerp->node_blk_sz);
	mdp->name_blk_size = ntoh32(mdp->headerp->name_blk_sz);
	mdp->data_blk_size = ntoh32(mdp->headerp->data_blk_sz);

	mdp->mdep = (md_element_t *)(mdp->caddr + sizeof (md_header_t));
	mdp->namep = (char *)(mdp->caddr + sizeof (md_header_t) +
	    mdp->node_blk_size);
	mdp->datap = (uint8_t *)(mdp->caddr + sizeof (md_header_t) +
	    mdp->name_blk_size + mdp->node_blk_size);


		/*
		 * should do a lot more sanity checking here.
		 */

	if (mdp->headerp->transport_version != MD_TRANSPORT_VERSION)
		fatal("Unrecognised transport version");

		/*
		 * One more property we need is the count of nodes in the
		 * DAG, not just the number of elements.
		 */

	idx = 0;
	count = 0;
	do {
		md_element_t *np;

		np = &(mdp->mdep[idx]);
		switch (np->tag) {
		case DT_LIST_END:
			goto the_end;
		case DT_NULL:
			idx++;
			break;
		case DT_NODE:
			idx = ntoh64(np->d.prop_idx);
			count ++;
			break;
		default:
			fatal("At index %d found unexpected node type "
			    "%d (0x%x : '%c') while searching for nodes",
			    idx, np->tag, np->tag, np->tag);
		}
	} while (1);

the_end:
	mdp->element_count = idx+1;	/* include DT_LIST_END */
	mdp->node_count = count;

	ASSERT(mdp->element_count == (mdp->node_blk_size / MD_ELEMENT_SIZE));

	return (mdp);
}




int
md_close(md_t *mdp)
{
	munmap(mdp->caddr, mdp->size);
	close(mdp->fh);

	Xfree(mdp);

	return (0);
}