Blame | Last modification | View Log | RSS feed
/****************************************************************************//** A simple program to manipulate flat files** Copyright (C) 2001-2003 SnapGear Inc, davidm@snapgear.com* Copyright (C) 2001 Lineo, davidm@lineo.com** This is Free Software, under the GNU Public Licence v2 or greater.**//****************************************************************************/#include <stdio.h> /* Userland pieces of the ANSI C standard I/O package */#include <unistd.h> /* Userland prototypes of the Unix std system calls */#include <time.h>#include <stdlib.h> /* exit() */#include <string.h> /* strcat(), strcpy() */#include <inttypes.h>#include <assert.h>#include "compress.h"#include <libiberty.h>#include "stubs.h"const char *elf2flt_progname;/* from uClinux-x.x.x/include/linux */#include "flat.h" /* Binary flat header description */#if defined(__MINGW32__)#include <getopt.h>#define mkstemp(p) mktemp(p)#endif#if defined TARGET_bfin# define flat_get_relocate_addr(addr) (addr & 0x03ffffff)#else# define flat_get_relocate_addr(addr) (addr)#endif/****************************************************************************/static int print = 0, print_relocs = 0, docompress = 0, ramload = 0,stacksize = 0, ktrace = 0, l1stack = 0;/****************************************************************************/voidprocess_file(char *ifile, char *ofile){int old_flags, old_stack, new_flags, new_stack;stream ifp, ofp;struct flat_hdr old_hdr, new_hdr;char *tfile, tmpbuf[256];int input_error, output_error;*tmpbuf = '\0';if (fopen_stream_u(&ifp, ifile, "r" BINARY_FILE_OPTS)) {fprintf(stderr, "Cannot open %s\n", ifile);return;}if (fread_stream(&old_hdr, sizeof(old_hdr), 1, &ifp) != 1) {fprintf(stderr, "Cannot read header of %s\n", ifile);fclose_stream(&ifp);return;}if (strncmp(old_hdr.magic, "bFLT", 4) != 0) {fprintf(stderr, "Cannot read header of %s\n", ifile);fclose_stream(&ifp);return;}new_flags = old_flags = ntohl(old_hdr.flags);new_stack = old_stack = ntohl(old_hdr.stack_size);new_hdr = old_hdr;if (docompress == 1) {new_flags |= FLAT_FLAG_GZIP;new_flags &= ~FLAT_FLAG_GZDATA;} else if (docompress == 2) {new_flags |= FLAT_FLAG_GZDATA;new_flags &= ~FLAT_FLAG_GZIP;} else if (docompress < 0)new_flags &= ~(FLAT_FLAG_GZIP|FLAT_FLAG_GZDATA);if (ramload > 0)new_flags |= FLAT_FLAG_RAM;else if (ramload < 0)new_flags &= ~FLAT_FLAG_RAM;if (ktrace > 0)new_flags |= FLAT_FLAG_KTRACE;else if (ktrace < 0)new_flags &= ~FLAT_FLAG_KTRACE;if (l1stack > 0)new_flags |= FLAT_FLAG_L1STK;else if (l1stack < 0)new_flags &= ~FLAT_FLAG_L1STK;if (stacksize)new_stack = stacksize;if (print == 1) {time_t t;uint32_t reloc_count, reloc_start;printf("%s\n", ifile);printf(" Magic: %4.4s\n", old_hdr.magic);printf(" Rev: %d\n", ntohl(old_hdr.rev));t = (time_t) htonl(old_hdr.build_date);printf(" Build Date: %s", t?ctime(&t):"not specified\n");printf(" Entry: 0x%x\n", ntohl(old_hdr.entry));printf(" Data Start: 0x%x\n", ntohl(old_hdr.data_start));printf(" Data End: 0x%x\n", ntohl(old_hdr.data_end));printf(" BSS End: 0x%x\n", ntohl(old_hdr.bss_end));printf(" Stack Size: 0x%x\n", ntohl(old_hdr.stack_size));reloc_start = ntohl(old_hdr.reloc_start);printf(" Reloc Start: 0x%x\n", reloc_start);reloc_count = ntohl(old_hdr.reloc_count);printf(" Reloc Count: 0x%x\n", reloc_count);printf(" Flags: 0x%x ( ", ntohl(old_hdr.flags));if (old_flags) {if (old_flags & FLAT_FLAG_RAM)printf("Load-to-Ram ");if (old_flags & FLAT_FLAG_GOTPIC)printf("Has-PIC-GOT ");if (old_flags & FLAT_FLAG_GZIP)printf("Gzip-Compressed ");if (old_flags & FLAT_FLAG_GZDATA)printf("Gzip-Data-Compressed ");if (old_flags & FLAT_FLAG_KTRACE)printf("Kernel-Traced-Load ");if (old_flags & FLAT_FLAG_L1STK)printf("L1-Scratch-Stack ");printf(")\n");}if (print_relocs) {uint32_t *relocs = xcalloc(reloc_count, sizeof(uint32_t));uint32_t i;unsigned long r;printf(" Relocs:\n");printf(" #\treloc ( address )\tdata\n");if (old_flags & FLAT_FLAG_GZIP)reopen_stream_compressed(&ifp);if (fseek_stream(&ifp, reloc_start, SEEK_SET)) {fprintf(stderr, "Cannot seek to relocs of %s\n", ifile);fclose_stream(&ifp);return;}if (fread_stream(relocs, sizeof(uint32_t), reloc_count, &ifp) == -1) {fprintf(stderr, "Cannot read relocs of %s\n", ifile);fclose_stream(&ifp);return;}for (i = 0; i < reloc_count; ++i) {uint32_t raddr, addr;r = ntohl(relocs[i]);raddr = flat_get_relocate_addr(r);printf(" %u\t0x%08lx (0x%08"PRIx32")\t", i, r, raddr);fseek_stream(&ifp, sizeof(old_hdr) + raddr, SEEK_SET);fread_stream(&addr, sizeof(addr), 1, &ifp);printf("%"PRIx32"\n", addr);}/* reset file position for below */fseek_stream(&ifp, sizeof(old_hdr), SEEK_SET);}} else if (print > 1) {static int first = 1;unsigned int text, data, bss, stk, rel, tot;if (first) {printf("Flag Rev Text Data BSS Stack Relocs RAM Filename\n");printf("-----------------------------------------------------------\n");first = 0;}*tmpbuf = '\0';strcat(tmpbuf, (old_flags & FLAT_FLAG_KTRACE) ? "k" : "");strcat(tmpbuf, (old_flags & FLAT_FLAG_RAM) ? "r" : "");strcat(tmpbuf, (old_flags & FLAT_FLAG_GOTPIC) ? "p" : "");strcat(tmpbuf, (old_flags & FLAT_FLAG_GZIP) ? "z" :((old_flags & FLAT_FLAG_GZDATA) ? "d" : ""));printf("-%-3.3s ", tmpbuf);printf("%3d ", ntohl(old_hdr.rev));printf("%6d ", text=ntohl(old_hdr.data_start)-sizeof(struct flat_hdr));printf("%6d ", data=ntohl(old_hdr.data_end)-ntohl(old_hdr.data_start));printf("%6d ", bss=ntohl(old_hdr.bss_end)-ntohl(old_hdr.data_end));printf("%6d ", stk=ntohl(old_hdr.stack_size));printf("%6d ", rel=ntohl(old_hdr.reloc_count) * 4);/** work out how much RAM is needed per invocation, this* calculation is dependent on the binfmt_flat implementation*/tot = data; /* always need data */if (old_flags & (FLAT_FLAG_RAM|FLAT_FLAG_GZIP))tot += text + sizeof(struct flat_hdr);if (bss + stk > rel) /* which is bigger ? */tot += bss + stk;elsetot += rel;printf("%6d ", tot);/** the total depends on whether the relocs are smaller/bigger than* the BSS*/printf("%s\n", ifile);}/* if there is nothing else to do, leave */if (new_flags == old_flags && new_stack == old_stack) {fclose_stream(&ifp);return;}new_hdr.flags = htonl(new_flags);new_hdr.stack_size = htonl(new_stack);tfile = make_temp_file("flthdr");if (fopen_stream_u(&ofp, tfile, "w" BINARY_FILE_OPTS)) {unlink(tfile);fatal("Failed to open %s for writing\n", tfile);}/* Copy header (always uncompressed). */if (fwrite_stream(&new_hdr, sizeof(new_hdr), 1, &ofp) != 1) {unlink(tfile);fatal("Failed to write to %s\n", tfile);}/* Whole input file (including text) is compressed: start decompressingnow. */if (old_flags & FLAT_FLAG_GZIP)reopen_stream_compressed(&ifp);/* Likewise, output file is compressed. Start compressing now. */if (new_flags & FLAT_FLAG_GZIP) {printf("zflat %s --> %s\n", ifile, ofile);reopen_stream_compressed(&ofp);}transfer(&ifp, &ofp,ntohl(old_hdr.data_start) - sizeof(struct flat_hdr));/* Only data and relocs were compressed in input. Start decompressingfrom here. */if (old_flags & FLAT_FLAG_GZDATA)reopen_stream_compressed(&ifp);/* Only data/relocs to be compressed in output. Start compressingfrom here. */if (new_flags & FLAT_FLAG_GZDATA) {printf("zflat-data %s --> %s\n", ifile, ofile);reopen_stream_compressed(&ofp);}transfer(&ifp, &ofp, -1);input_error = ferror_stream(&ifp);output_error = ferror_stream(&ofp);if (input_error || output_error) {unlink(tfile);fatal("Error on file pointer%s%s\n",input_error ? " input" : "",output_error ? " output" : "");}fclose_stream(&ifp);fclose_stream(&ofp);/* Copy temporary file to output location. */fopen_stream_u(&ifp, tfile, "r" BINARY_FILE_OPTS);fopen_stream_u(&ofp, ofile, "w" BINARY_FILE_OPTS);transfer(&ifp, &ofp, -1);fclose_stream(&ifp);fclose_stream(&ofp);unlink(tfile);free(tfile);}/****************************************************************************/voidusage(char *s){if (s)fprintf(stderr, "%s\n", s);fprintf(stderr, "usage: %s [options] flat-file\n", elf2flt_progname);fprintf(stderr, " Allows you to change an existing flat file\n\n");fprintf(stderr, " -p : print current settings\n");fprintf(stderr, " -P : print relocations\n");fprintf(stderr, " -z : compressed flat file\n");fprintf(stderr, " -d : compressed data-only flat file\n");fprintf(stderr, " -Z : un-compressed flat file\n");fprintf(stderr, " -r : ram load\n");fprintf(stderr, " -R : do not RAM load\n");fprintf(stderr, " -k : kernel traced load (for debug)\n");fprintf(stderr, " -K : normal non-kernel traced load\n");fprintf(stderr, " -u : place stack in L1 scratchpad memory\n");fprintf(stderr, " -U : place stack in normal SDRAM memory\n");fprintf(stderr, " -s size : stack size\n");fprintf(stderr, " -o file : output-file\n"" (default is to modify input file)\n");exit(1);}/****************************************************************************/intmain(int argc, char *argv[]){int c, noargs;char *ofile = NULL, *ifile;elf2flt_progname = argv[0];noargs = 1;while ((c = getopt(argc, argv, "pPdzZrRuUkKs:o:")) != EOF) {switch (c) {case 'p': print = 1; break;case 'P': print_relocs = 1; break;case 'z': docompress = 1; break;case 'd': docompress = 2; break;case 'Z': docompress = -1; break;case 'r': ramload = 1; break;case 'R': ramload = -1; break;case 'k': ktrace = 1; break;case 'K': ktrace = -1; break;case 'u': l1stack = 1; break;case 'U': l1stack = -1; break;case 'o': ofile = optarg; break;case 's':if (sscanf(optarg, "%i", &stacksize) != 1)usage("invalid stack size");break;default:usage("invalid option");break;}noargs = 0;}if (optind >= argc)usage("No input files provided");if (ofile && argc - optind > 1)usage("-o can only be used with a single file");if (!print && noargs) /* no args == print */print = argc - optind; /* greater than 1 is short format */for (c = optind; c < argc; c++) {ifile = argv[c];if (!ofile)ofile = ifile;process_file(ifile, ofile);ofile = NULL;}exit(0);}/****************************************************************************/