openbios/openboot/tools/makedi.c

• Show log

  Commit

• Hash : 1a08f436
  Author :
  Date : 2010-08-25T09:23:17
  

  change to well-formed svn directory structure. git-svn-id: svn://coreboot.org/openboot/trunk@2 4486e004-3823-0410-90c7-fb508cc143bb

Download

• tools/makedi.c

• /*
  * ========== Copyright Header Begin ==========================================
  *
  * Hypervisor Software File: makedi.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 ============================================
  */
  /*
   * id: @(#)makedi.c 1.12 06/02/16
   * purpose:
   * copyright: Copyright 2006 Sun Microsystems, Inc.  All Rights Reserved.
   * copyright: Use is subject to license terms.
   */
  
  #include <sys/types.h>
  #include <sys/stat.h>
  #include <fcntl.h>
  #include <string.h>
  #include <stdio.h>
  #include <stdlib.h>
  #include <unistd.h>
  
  #include <sys/dropins.h>
  
  #define	MAX_DI		(4*1048*1024)
  
  static int compress = 0;
  static int verbose = 0;
  static int list = 0;
  static int group_mode = 0;
  
  static uchar_t *prom;
  
  int comp(unsigned char *src, int size, unsigned char *dest);
  
  static void
  usage(char *name)
  {
  	char *msg =
  	    "%s: [-c] [-v] input1 name1 .. inputn namen\n"
  	    "   -g   : group mode using src,dropin-name pairs\n"
  	    "   -a   : create level2 using existing dropins\n"
  	    "   -c   : compress dropins\n"
  	    "   -v   : verbose mode\n"
  	    "   -t   : list targets\n"
  	    "   -s   : list sources\n"
  	    "   -d   : list dependancies\n"
  	    "   -o   : create a dropin from data\n"
  	    "   -O   : overwrite any existing header\n"
  	    "\n"
  	    "for compress mode, each input will produce a file input.di\n"
  	    "group mode changes the format of the args a little\n"
  	    "-g <output> name input0 name0 .. intputn namen\n"
  	    "-a <output> name input0 input1 .. inputn\n"
  	    "-o <output> <srcfile> <diname>\n";
  
  	fprintf(stderr, msg, name);
  	exit(1);
  }
  
  static int
  make_dropin(char *name, unsigned char *prom, unsigned char *buffer, int size)
  {
  	int crc, i, clen, dlen, compressed;
  	unsigned char *pptr;
  	obmd_t *di = (obmd_t *)prom;
  	unsigned char *dataptr = prom+OBMD_HDR;
  
  	memset((void *) prom, 0, OBMD_HDR);
  	compressed = compress;
  	if (compress) {
  		compresshdr *chdr = (compresshdr *) dataptr;
  		/* The magic number is always COMP */
  		chdr->magic		= COMP_MAGIC;
  		/*
  		 * This is the compression type
  		 * currently COMP for compress
  		 */
  		chdr->type		= COMP_MAGIC;
  		chdr->decomp_size	= size;
  
  		clen = comp(buffer, size, dataptr+sizeof (compresshdr));
  
  		/* Now adjust the data size */
  		clen += sizeof (compresshdr);
  		chdr->comp_size = clen;
  
  		if (clen >= size) {
  			/*
  			 * Compression didn't help this and in fact
  			 * has added some bytes, so we undo the compression.
  			 */
  			compressed = 0;
  			clen = size;
  			memcpy((void *) dataptr, (void *) buffer, size);
  		}
  	} else {
  		clen = size;
  		memcpy((void *) dataptr, (void *) buffer, size);
  	}
  
  	strncpy(di->magic, "OBMD", 4);
  	di->size  = clen;
  	di->res0  = 0;
  	di->res1  = 0;
  	di->chksum = 0;
  	if (strlen(name) > 15) {
  		fprintf(stderr, "Error: dropin name > 15 characters\n");
  		fprintf(stderr, "Error: -> %s\n", name);
  		exit(1);
  	}
  	memset(di->name, 0, 16);
  	strncpy(di->name, name, 15);
  	crc = checksum((ushort_t *)di, clen+OBMD_HDR);
  	di->chksum = crc;
  
  	if (verbose) {
  		printf(" Name: %s size = %lx", di->name, di->size);
  		if (compressed)
  			printf(" (-%d%%)", ((size-clen)*100)/size);
  		printf(" checksum = %x ", di->chksum);
  	}
  	dlen = OBMD_HDR+clen;
  	pptr = prom+dlen;
  	if (dlen&3) {
  		if (verbose) printf("(+%d)", (dlen&3));
  
  		for (i = (3-(dlen&3)); i >= 0; i--, dlen++) *(pptr+i) = 1;
  	}
  	if (verbose) printf("\n");
  	return (dlen);
  }
  
  char *
  make_dropin_name(char *name)
  {
  	static char outname[40];
  	char *dot;
  
  	dot = strrchr(name, '/');
  	if (dot)
  		strcpy(outname, dot+1);
  	else
  		strcpy(outname, name);
  	dot = strrchr(outname, '.');
  	if (dot) *dot = 0;
  	strcat(outname, ".di");
  	return (outname);
  }
  
  
  void
  write_dropin(char *argv[], char *name, unsigned char *prom, int dlen)
  {
  	int ofd;
  
  	ofd = open(name, O_CREAT|O_TRUNC|O_RDWR, 0666);
  	if (ofd < 0) {
  		fprintf(stderr, "%s: Can't open output file %s\n",
  		    argv[0], name);
  		exit(1);
  	} else {
  		if (dlen > MAX_DI) {
  			fprintf(stderr, "%s: Output %s exceeds %d bytes\n",
  				argv[0], name, MAX_DI);
  			exit(1);
  		}
  		if (write(ofd, prom, dlen) != dlen) {
  			fprintf(stderr, "%s: Short write on %s\n",
  				argv[0], name);
  			exit(1);
  		}
  		close(ofd);
  	}
  }
  
  /*
   * makedi [-c] <source> <dropin-name> [<source> <dropin-name>]
   */
  
  void
  main(int argc, char **argv)
  {
  	int ifd, ofd;
  	int i;
  	int pad = 512;
  	struct stat statbuf;
  	int c;
  	char *group_name;
  	char *group_file, *outfile = NULL;
  	uchar_t *holding, *insert_pt;
  	extern char *optarg;
  	extern int optind;
  	obmd_t *di;
  	int arg_step = 2;
  	int append_mode = 0;
  	int overwrite = 0;
  	int diupdate = 1;
  
  	while ((c = getopt(argc, argv, "acCOvstdgGo:")) != EOF)
  		switch (c) {
  		case 'a':
  			append_mode = 1;
  			arg_step = 1;
  			break;
  
  		case 's':
  			list = 's';
  			break;
  
  		case 't':
  			list = 't';
  			break;
  
  		case 'd':
  			list = 'd';
  			break;
  
  		case 'v':
  			verbose++;
  			break;
  
  		case 'c':
  			group_mode = 0;
  			compress = 1;
  			break;
  
  		case 'C':
  			group_mode = 0;
  			compress = 0;
  			break;
  
  		case 'O':
  			overwrite = 1;
  			break;
  
  		case 'g':
  			compress = 0;
  			group_mode = 1;
  			break;
  
  		case 'o':
  			outfile = optarg;
  			diupdate = 0;
  			break;
  
  		default:
  			usage(argv[0]);
  		}
  
  	if (list) compress = 0, verbose = 0;
  	if (append_mode) {
  		if (list) list = 'd';
  	}
  
  	insert_pt = prom = (uchar_t *)malloc(MAX_DI);
  	if (prom == NULL) {
  		fprintf(stderr, "Malloc failed for dropin image\n");
  		exit(1);
  	}
  
  	holding = (uchar_t *)malloc(MAX_DI);
  	if (holding == NULL) {
  		fprintf(stderr, "Malloc failed for holding buffer\n");
  		exit(1);
  	}
  
  	/* Fill with FF */
  	memset((void *) prom, 0xff, MAX_DI);
  	if (group_mode || append_mode) {
  		if (argv[optind] == NULL) {
  			fprintf(stderr, "%s: Missing group name\n", argv[0]);
  			exit(1);
  		}
  		group_file = strdup(make_dropin_name(argv[optind]));
  		group_name = argv[optind+1];
  		if (argv[optind+1] == NULL) {
  			fprintf(stderr, "%s: Missing dropin name for %s\n",
  			    argv[0], argv[optind]);
  			exit(1);
  		}
  		optind += 2;
  		/*
  		 * reserve space for the dropin header and marker
  		 */
  		insert_pt += sizeof (obme_t);
  	}
  
  	di = (obmd_t *)holding;
  	for (i = optind; i < argc; i += arg_step) {
  		int dlen, len, tmp;
  		char *outname;
  
  		if ((!append_mode) && (argv[i+1] == NULL)) {
  			fprintf(stderr, "%s: Missing dropin name for %s\n",
  			    argv[0], argv[i]);
  			exit(1);
  		}
  
  		if (outfile == NULL) {
  		    outname = make_dropin_name(argv[i]);
  		} else {
  		    outname = outfile;
  		}
  
  		if (list) {
  			switch (list) {
  			case 't':
  				if (group_mode) {
  					static int once = 0;
  					if (!once++)
  						printf("%s ", group_file);
  				} else {
  					printf("%s ", outname);
  				}
  				break;
  
  			case 's':
  				printf("%s ", argv[i]);
  				break;
  
  			case 'd':
  				if (group_mode || append_mode)
  					printf("%s: %s\n",
  					    group_file, argv[i]);
  				else
  					printf("%s: %s\n", outname, argv[i]);
  				break;
  			}
  			continue;
  		}
  
  		if (verbose > 1) printf("Loading: %s\n", argv[i]);
  		ifd = open(argv[i], O_RDONLY);
  		if (ifd < 0) {
  			fprintf(stderr,
  			    "%s: Can't open input file %s\n",
  			    argv[0], argv[i]);
  			exit(1);
  		}
  		fstat(ifd, &statbuf);
  		len = statbuf.st_size;
  		if (len > MAX_DI) {
  			fprintf(stderr, "%s: Input %s exceeds %d bytes\n",
  				argv[0], argv[i], MAX_DI);
  			exit(1);
  		}
  		memset((void *) holding, 0xff, MAX_DI);
  		tmp = read(ifd, holding, len);
  		if (tmp != len) {
  			fprintf(stderr, "%s: Short read on %s\n",
  				argv[0], argv[i]);
  			exit(1);
  		}
  		close(ifd);
  		if (verbose) {
  			if (group_mode || append_mode)
  				printf("Including: %s,", argv[i]);
  			else
  				printf("Writing: %s,", outname);
  		}
  
  		if (diupdate && (strncmp(di->magic, "OBMD", 4) == 0)) {
  			unsigned int *dataptr;
  
  			dataptr = (uint_t *)((uchar_t *)di + sizeof (obmd_t));
  
  			if ((dataptr[0] == COMP_MAGIC) &&
  			    (dataptr[1] == di->size)) {
  				/*
  				 * We can do nothing with dropins that are
  				 * already compressed
  				 */
  				dlen = len;
  				if (verbose) {
  					printf(" Name: %s size = %lx (COMP)",
  					    di->name, di->size);
  					printf(" checksum = %x\n", di->chksum);
  				}
  				if ((group_mode) || (append_mode)) {
  					memcpy((void *) insert_pt,
  						(void *) holding, len);
  				}
  			} else {
  				char *diname;
  
  				/*
  				 * Strip the dropin header off to leave the
  				 * raw data and then compress it
  				 */
  				len -= OBMD_HDR;
  				if (append_mode)
  					diname = strdup(di->name);
  				else
  					diname = argv[i+1];
  				memcpy((void *) holding,
  				    (void *) (holding+OBMD_HDR),
  				    len);
  				dlen = make_dropin(diname,
  				    insert_pt, holding, len);
  			}
  		} else {
  			if (append_mode) {
  				fprintf(stderr,
  				    "%s: append_mode requires you to provide"
  				    " a dropin list (%s)\n",
  				    argv[0], argv[optind]);
  				exit(1);
  			} else {
  				if (overwrite) {
  					dlen = make_dropin(argv[i+1],
  					    insert_pt, (holding + OBMD_HDR),
  					    (len - OBMD_HDR));
  				} else {
  					dlen = make_dropin(argv[i+1],
  					    insert_pt, holding, len);
  				}
  			}
  		}
  
  		if (group_mode || append_mode) {
  			insert_pt += (dlen + 3) & ~3;
  		} else {
  			write_dropin(argv, outname, prom, dlen);
  		}
  	}
  	if (group_mode || append_mode) {
  		int flen;
  		char *outname;
  		int bytes;
  
  		bytes = insert_pt - prom;
  		if (bytes&3) {
  			for (i = (4-(bytes&3)); i > 0; i--, bytes++)
  				*insert_pt++ = 1;
  		}
  		for (i = 4; i > 0; i--, bytes++) *insert_pt++ = 0xff;
  		if (verbose) printf("Writing: %s,", group_file);
  		strncpy((char *)prom, "OBME", 4);
  		memcpy((void *)holding, (void *)prom, bytes);
  		flen = make_dropin(group_name, prom, holding, bytes);
  		write_dropin(argv, group_file, prom, flen);
  	}
  	free(holding);
  	free(prom);
  	exit(0);
  }
  

Download