diff options
Diffstat (limited to 'util')
| -rw-r--r-- | util/BuildImage.c | 415 | ||||
| -rw-r--r-- | util/Make.mk | 59 | ||||
| -rw-r--r-- | util/Offsets.c | 250 | ||||
| -rw-r--r-- | util/alternatives/Make.mk | 56 | ||||
| -rw-r--r-- | util/alternatives/README | 31 | ||||
| -rw-r--r-- | util/alternatives/kmem.c | 749 | ||||
| -rw-r--r-- | util/alternatives/lib.c | 56 | ||||
| -rw-r--r-- | util/gdbinit.tmpl | 31 | ||||
| -rw-r--r-- | util/listblob.c | 248 | ||||
| -rw-r--r-- | util/mergedep.pl | 86 | ||||
| -rw-r--r-- | util/mkblob.c | 324 |
11 files changed, 2305 insertions, 0 deletions
diff --git a/util/BuildImage.c b/util/BuildImage.c new file mode 100644 index 0000000..2124c9d --- /dev/null +++ b/util/BuildImage.c @@ -0,0 +1,415 @@ +/** +** SCCS ID: @(#)BuildImage.c 2.2 1/16/25 +** +** @file BuildImage.c +** +** @author K. Reek +** @author Jon Coles +** @author Warren R. Carithers +** @author Garrett C. Smith +** +** Modify the bootstrap image to include the information +** on the programs to be loaded, and produce the file +** that contains the concatenation of these programs. +** +*/ + +#define _POSIX_C_SOURCE 200809L + +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <string.h> +#include <errno.h> + +#define TRUE 1 +#define FALSE 0 + +#define DRIVE_FLOPPY 0x00 +#define DRIVE_USB 0x80 + +#define SECT_SIZE 512 + +char *progname; /* invocation name of this program */ +char *bootstrap_filename; /* path of file holding bootstrap program */ +char *output_filename; /* path of disk image file */ +FILE *out; /* output stream for disk image file */ +short drive = DRIVE_USB; /* boot drive */ + +/* +** Array into which program information will be stored, starting at the +** end and moving back toward the front. The array is the same size as +** a sector, which is guaranteed to be larger than the maximum possible +** space available for this stuff in the bootstrap image. Thus, the +** bootstrap image itself (and the amount of space available on the +** device) are the only limiting factors on how many program sections +** can be loaded. +*/ + +#define N_INFO ( SECT_SIZE / sizeof( short ) ) + +short info[ N_INFO ]; +int n_info = N_INFO; + +/** +** quit with an appropriate message +** +** @param msg NULL, or a message to be printed to stderr +** @param call_perror non-zero if perror() should be used; else, +** fprintf() will be used +** +** does not return +*/ +void quit( char *msg, int call_perror ) { + if( msg != NULL ){ + // preserve the error code in case we need it + int err_num = errno; + fprintf( stderr, "%s: ", progname ); + errno = err_num; + if( call_perror ){ + perror( msg ); + } else { + fprintf( stderr, "%s\n", msg ); + } + } + if( output_filename != NULL ){ + unlink( output_filename ); + } + exit( EXIT_FAILURE ); + // NOTREACHED +} + +const char usage_error_msg[] = + "\nUsage: %s [ -d drive ] -b bootfile -o outfile { progfile loadpt } ...\n\n" + "\t'drive' is either 'floppy' or 'usb' (default 'usb')\n\n" + "\tThere must be at least one program file and load point.\n\n" + "\tLoad points may be specified either as 32-bit quantities in hex,\n" + "\tdecimal or octal (e.g. 0x10c00, 68608, 0206000 are all equivalent),\n" + "\tor as an explicit segment:offset pair whose digits are always\n" + "\tinterpreted as hexadecimal values (e.g. 10c0:0000, 1000:0c00 are\n" + "\tboth equivalent to the previous examples).\n\n"; + +/** +** print a usage message and then call quit() +** +** does not return +*/ +void usage_error( void ){ + fprintf( stderr, usage_error_msg, progname ); + quit( NULL, FALSE ); + // NOTREACHED +} + +/** +** copy the contents of a binary file into the output file, padding the +** last sector with NUL bytes +** +** @param in open FILE to be read +** @return the number of sectors copied from the file +*/ +int copy_file( FILE *in ){ + int n_sectors = 0; + char buf[ SECT_SIZE ]; + int n_bytes; + int i; + + /* + ** Copy the file to the output, being careful that the + ** last sector is padded with null bytes out to the + ** sector size. + */ + n_sectors = 0; + while( (n_bytes = fread( buf, 1, sizeof( buf ), in )) > 0 ){ + // pad this sector out to block size + if( n_bytes < sizeof( buf ) ){ + int i; + + for( i = n_bytes; i < sizeof( buf ); i += 1 ){ + buf[ i ] = '\0'; + } + } + if( fwrite( buf, 1, sizeof( buf ), out ) != sizeof( buf ) ){ + quit( "Write failed or was wrong size", FALSE ); + } + n_sectors += 1; + } + return n_sectors; +} + +/** +** process a file whose contents should be at a specific' +** address in memory when the program is loaded +** +** @param name path to the file to be copied +** @param addr string containing the load address +*/ +void process_file( char *name, char *addr ){ + long address; + short segment, offset; + int n_bytes; + + /* + ** Open the input file. + */ + FILE *in = fopen( name, "rb" ); + if( in == NULL ){ + quit( name, TRUE ); + } + + /* + ** Copy the file to the output, being careful that the + ** last block is padded with null bytes. + */ + int n_sectors = copy_file( in ); + fclose( in ); + + /* + ** Decode the address they gave us. We'll accept two forms: + ** "nnnn:nnnn" for a segment:offset value (assumed to be hex), + ** "nnnnnnn" for a decimal, hex, or octal value + */ + int valid_address = FALSE; + char *cp = strchr( addr, ':' ); + if( cp != NULL ){ + // must be in nnnn:nnnn form exactly + if( strlen( addr ) == 9 && cp == addr + 4 ){ + char *ep1, *ep2; + int a1, a2; + + segment = strtol( addr, &ep1, 16 ); + offset = strtol( addr + 5, &ep2, 16 ); + address = ( segment << 4 ) + offset; + valid_address = *ep1 == '\0' && *ep2 == '\0'; + } else { + fprintf( stderr, "Bad address format - '%s'\n", addr ); + quit( NULL, FALSE ); + } + } else { + // just a number, possibly hex or octal + char *ep; + + address = strtol( addr, &ep, 0 ); + segment = (short)( address >> 4 ); + offset = (short)( address & 0xf ); + valid_address = *ep == '\0' && address <= 0x0009ffff; + } + + if( !valid_address ){ + fprintf( stderr, "%s: Invalid address: %s\n", progname, addr ); + quit( NULL, FALSE ); + } + + /* + ** Make sure the program will fit! + */ + if( address + n_sectors * SECT_SIZE > 0x0009ffff ){ + fprintf( stderr, "Program %s too large to start at 0x%08x\n", + name, (unsigned int) address ); + quit( NULL, FALSE ); + } + + if( n_info < 3 ){ + quit( "Too many programs!", FALSE ); + } + + + /* + ** Looks good: report and store the information. + */ + fprintf( stderr, " %s: %d sectors, loaded at 0x%x\n", + name, n_sectors, (unsigned int) address ); + + info[ --n_info ] = n_sectors; + info[ --n_info ] = segment; + info[ --n_info ] = offset; +} + +/* +** Global variables set by getopt() +*/ + +extern int optind, optopt; +extern char *optarg; + +/** +** process the command-line arguments +** +** @param ac the count of entries in av +** @param av the argument vector +*/ +void process_args( int ac, char **av ) { + int c; + + while( (c=getopt(ac,av,":d:o:b:")) != EOF ) { + + switch( c ) { + + case ':': /* missing arg value */ + fprintf( stderr, "missing operand after -%c\n", optopt ); + /* FALL THROUGH */ + + case '?': /* error */ + usage_error(); + /* NOTREACHED */ + + case 'b': /* -b bootstrap_file */ + bootstrap_filename = optarg; + break; + + case 'd': /* -d drive */ + switch( *optarg ) { + case 'f': drive = DRIVE_FLOPPY; break; + case 'u': drive = DRIVE_USB; break; + default: usage_error(); + } + break; + + case 'o': /* -o output_file */ + output_filename = optarg; + break; + + default: + usage_error(); + + } + + } + + if( !bootstrap_filename ) { + fprintf( stderr, "%s: no bootstrap file specified\n", progname ); + exit( 2 ); + } + + if( !output_filename ) { + fprintf( stderr, "%s: no disk image file specified\n", progname ); + exit( 2 ); + } + + /* + ** Must have at least two remaining arguments (file to load, + ** address at which it should be loaded), and must have an + ** even number of remaining arguments. + */ + int remain = ac - optind; + if( remain < 2 || (remain & 1) != 0 ) { + usage_error(); + } + +} + +/** +** build a bootable image file from one or more binary files +** +** usage: +** BuildImage [ -d drive ] -b bootfile -o outfile { binfile1 loadpt1 } ... ] +** +** @param ac command-line argument count +** @param av command-line argument vector +** @return EXIT_SUCCESS or EXIT_FAILURE +*/ +int main( int ac, char **av ) { + FILE *bootimage; + int bootimage_size; + int n_bytes, n_words; + short existing_data[ N_INFO ]; + int i; + + /* + ** Save the program name for error messages + */ + progname = strrchr( av[ 0 ], '/' ); + if( progname != NULL ){ + progname++; + } else { + progname = av[ 0 ]; + } + + /* + ** Process arguments + */ + process_args( ac, av ); + + /* + ** Open the output file + */ + + out = fopen( output_filename, "wb+" ); + if( out == NULL ){ + quit( output_filename, TRUE ); + } + + /* + ** Open the bootstrap file and copy it to the output image. + */ + bootimage = fopen( bootstrap_filename, "rb" ); + if( bootimage == NULL ){ + quit( bootstrap_filename, TRUE ); + } + + /* + ** Remember the size of the bootstrap for later, as we + ** need to patch some things into it + */ + int n_sectors = copy_file( bootimage ); + fclose( bootimage ); + + bootimage_size = n_sectors * SECT_SIZE; + fprintf( stderr, " %s: %d sectors\n", bootstrap_filename, n_sectors ); + + /* + ** Process the programs one by one + */ + ac -= optind; + av += optind; + while( ac >= 2 ){ + process_file( av[ 0 ], av[ 1 ] ); + ac -= 2; av += 2; + } + + /* + ** Check for oddball leftover argument + */ + if( ac > 0 ){ + usage_error(); + } + + /* + ** Seek to where the array of module data must begin and read + ** what's already there. + */ + n_words = ( N_INFO - n_info ); + n_bytes = n_words * sizeof( info[ 0 ] ); + fseek( out, bootimage_size - n_bytes, SEEK_SET ); + if( fread( existing_data, sizeof(info[0]), n_words, out ) != n_words ){ + quit( "Read from boot image failed or was too short", FALSE ); + } + + /* + ** If that space is non-zero, we have a problem + */ + for( i = 0; i < n_words; i += 1 ){ + if( existing_data[ i ] != 0 ){ + quit( "Too many programs to load!", FALSE ); + } + } + + /* + ** We know that we're only overwriting zeros at the end of + ** the bootstrap image, so it is ok to go ahead and do it. + */ + fseek( out, bootimage_size - n_bytes, SEEK_SET ); + if( fwrite( info + n_info, sizeof( info[ 0 ] ), n_words, out ) != n_words ){ + quit( "Write to boot image failed or was too short", FALSE ); + } + + /* + ** Write the drive index to the image. + */ + fseek( out, 508, SEEK_SET ); + fwrite( (void *)&drive, sizeof(drive), 1, out ); + + fclose( out ); + + return EXIT_SUCCESS; + +} diff --git a/util/Make.mk b/util/Make.mk new file mode 100644 index 0000000..0f45625 --- /dev/null +++ b/util/Make.mk @@ -0,0 +1,59 @@ +# +# Makefile fragment for the utility programs +# +# THIS IS NOT A COMPLETE Makefile - run GNU make in the top-level +# directory, and this will be pulled in automatically. +# + +################### +# FILES SECTION # +################### + +UTIL_BIN := BuildImage Offsets mkblob listblob + +################### +# RULES SECTION # +################### + +# how to make everything +util: $(UTIL_BIN) + +# +# Special rules for creating the utility programs. These are required +# because we don't want to use the same options as for the standalone +# binaries - we want these to be compiled as "normal" programs. +# + +BuildImage: util/BuildImage.c + @mkdir -p $(@D) + $(CC) -std=c99 -ggdb -o BuildImage util/BuildImage.c + +mkblob: util/mkblob.c + @mkdir -p $(@D) + $(CC) -std=c99 -ggdb -o mkblob util/mkblob.c + +listblob: util/listblob.c + @mkdir -p $(@D) + $(CC) -std=c99 -ggdb -o listblob util/listblob.c + +# +# Offsets is compiled using -mx32 to force a 32-bit execution environment +# for a program that runs under a 64-bit operating system. This ensures +# that pointers and long ints are 32 bits rather than 64 bits, which is +# critical to correctly determining the size of types and byte offsets for +# fields in structs. We also compile with "-fno-builtin" to avoid signature +# clashes between declarations in our system and function declarations +# built into the C compiler. +# +# If compiled with the CPP macro CREATE_HEADER_FILE defined, Offsets +# accepts a command-line argument "-h". This causes it to write its +# output as a standard C header file into a file named "include/offsets.h" +# where it can be included into other source files (e.g., to provide +# sizes of structs in C and assembly, or to provide byte offsets into +# structures for use in assembly code). +# + +Offsets: util/Offsets.c + @mkdir -p $(@D) + $(CC) -mx32 -std=c99 $(INCLUDES) -fno-builtin \ + -o Offsets util/Offsets.c diff --git a/util/Offsets.c b/util/Offsets.c new file mode 100644 index 0000000..3cf5a46 --- /dev/null +++ b/util/Offsets.c @@ -0,0 +1,250 @@ +/* +** SCCS ID: @(#)Offsets.c 2.2 1/23/25 +** +** @file Offsets.c +** +** @author Warren R. Carithers +** +** Print byte offsets for fields in various structures. +** +** This program exists to simplify life. If/when fields in a structure +** are changed, this can be modified, recompiled and executed to come up with +** byte offsets for use in accessing structure fields from assembly language. +** It makes use of the C 'offsetof' macro (defined since C89). +** +** IMPORTANT NOTE: compiling this on a 64-bit architecture will yield +** incorrect results by default, as 64-bit GCC versions most often use +** the LP64 model (longs and pointers are 64 bits). Add the "-mx32" +** option to the compiler (compile for x86_64, but use 32-bit sizes), +** and make sure you have the 'libc6-dev-i386' package installed (for +** Ubuntu systems). +** +** WATCH FOR clashes with standard system functions; compile with the +** "-fno-builtin" option to avoid warnings about clashes with builtin +** function declarations. +** +** Writes to stdout. Output contains information about type sizes and +** byte offsets for fields within structures. If invoked with the -h +** option, the output takes the form of a standard C header file; +** otherwise, the information is printed in ordinary text form. +** +** If compiled with the CREATE_HEADER_FILE macro defined, when invoked +** with the -h option, writes the data directly into a file named +** "offsets.h". +*/ + +// make sure we get all the kernel stuff +#define KERNEL_SRC + +// include any of our headers that define data structures to be described +#include <common.h> +#include <procs.h> + +// avoid complaints about NULL from stdio.h +#ifdef NULL +#undef NULL +#endif + +#include <stdio.h> +#include <stddef.h> +#include <stdlib.h> +#include <unistd.h> + +/* +** We don't include <time.h> because of conflicts with a time_t data +** type we may be defining; instead, we provide our own prototypes for +** ctime() and time(). +*/ + +extern char *ctime( const __time_t *timep ); +extern __time_t time( __time_t *tloc ); + +/* +** Header comment, including header guard +** +** No newline on the "Creation date" line, because ctime() +** puts a newline at the end of the string it produces. +*/ +char h_prefix[] = "/**\n" +"** @file\toffsets.h\n" +"**\n" +"** GENERATED AUTOMATICALLY - DO NOT EDIT\n" +"**\n" +"** Creation date: %s" +"**\n" +"** This header file contains C Preprocessor macros which expand\n" +"** into the byte offsets needed to reach fields within structs\n" +"** used in the baseline system. Should those struct declarations\n" +"** change, the Offsets program should be modified (if needed),\n" +"** recompiled, and re-run to recreate this file.\n" +"*/\n" +"\n" +"#ifndef OFFSETS_H_\n" +"#define OFFSETS_H_\n"; + +/* +** Header guard suffix +*/ +char h_suffix[] = "\n" +"#endif\n"; + +// are we generating the .h file? +int genheader = 0; + +// header file stream +FILE *hfile; + +// prefix for header file lines + +// produce a report line +void process( const char *sname, const char *field, size_t bytes ) { + if( genheader ) { + char name[64]; + sprintf( name, "%s_%s", sname, field ); + fprintf( hfile, "#define\t%-23s\t%u\n", name, bytes ); + } else { + printf( " %-10s %u\n", field, bytes ); + } +} + +#ifdef CREATE_HEADER_FILE +// dump out the header +void setheader( void ) { + // trigger output into the header file + genheader = 1; + + hfile = fopen( "offsets.h", "w" ); + if( hfile == NULL ) { + perror( "offsets.h" ); + exit( 1 ); + } + + __time_t t; + (void) time( &t ); + + fprintf( hfile, h_prefix, ctime(&t) ); +} +#endif /* CREATE_HEADER_FILE */ + +// introduce an "offsets" section for structs +void hsection( const char *name, const char *typename, size_t size ) { + if( genheader ) { + fprintf( hfile, "\n// %s structure\n\n", typename ); + process( "SZ", name, size ); + fputc( '\n', hfile ); + } else { + printf( "Offsets into %s (%u bytes):\n", typename, size ); + } +} + +// introduce a "sizes" section for types +void tsection( const char *name, const char *typename ) { + if( genheader ) { + fprintf( hfile, "\n// Sizes of %s types\n\n", typename ); + } else { + printf( "Sizes of %s types:\n", typename ); + } +} + +int main( int argc, char *argv[] ) { + + hfile = stdout; + + if( argc > 1 ) { +#ifdef CREATE_HEADER_FILE + // only accept one argument + if( argc == 2 ) { + // -h: produce an offsets.h header file + if( argv[1][0] == '-' && argv[1][1] == '-h' ) { + setheader(); + } + } else { + fprintf( stderr, "usage: %s [-h]\n", argv[0] ); + exit( 1 ); + } +#else + // we accept no arguments + fprintf( stderr, "usage: %s\n", argv[0] ); + exit( 1 ); +#endif /* CREATE_HEADER_FILE */ + } + + /* + ** Basic and simple/opaque types + */ + + tsection( "SZ", "basic" ); + process( "SZ", "char", sizeof(char) ); + process( "SZ", "short", sizeof(short) ); + process( "SZ", "int", sizeof(int) ); + process( "SZ", "long", sizeof(long) ); + process( "SZ", "long_long", sizeof(long long) ); + process( "SZ", "pointer", sizeof(void *) ); + fputc( '\n', hfile ); + + tsection( "SZ", "our" ); + process( "SZ", "int8_t", sizeof(int8_t) ); + process( "SZ", "uint8_t", sizeof(uint8_t) ); + process( "SZ", "int16_t", sizeof(int16_t) ); + process( "SZ", "uint16_t", sizeof(uint16_t) ); + process( "SZ", "int32_t", sizeof(int32_t) ); + process( "SZ", "uint32_t", sizeof(uint32_t) ); + process( "SZ", "int64_t", sizeof(int64_t) ); + process( "SZ", "uint64_t", sizeof(uint64_t) ); + process( "SZ", "bool_t", sizeof(bool_t) ); + fputc( '\n', hfile ); + + /* + ** Structured types whose fields we are describing + */ + + // add entries for each type here, as needed + + hsection( "CTX", "context_t", sizeof(context_t) ); + process( "CTX", "ss", offsetof(context_t,ss) ); + process( "CTX", "gs", offsetof(context_t,gs) ); + process( "CTX", "fs", offsetof(context_t,fs) ); + process( "CTX", "es", offsetof(context_t,es) ); + process( "CTX", "ds", offsetof(context_t,ds) ); + process( "CTX", "edi", offsetof(context_t,edi) ); + process( "CTX", "esi", offsetof(context_t,esi) ); + process( "CTX", "ebp", offsetof(context_t,ebp) ); + process( "CTX", "esp", offsetof(context_t,esp) ); + process( "CTX", "ebx", offsetof(context_t,ebx) ); + process( "CTX", "edx", offsetof(context_t,edx) ); + process( "CTX", "ecx", offsetof(context_t,ecx) ); + process( "CTX", "eax", offsetof(context_t,eax) ); + process( "CTX", "vector", offsetof(context_t,vector) ); + process( "CTX", "code", offsetof(context_t,code) ); + process( "CTX", "eip", offsetof(context_t,eip) ); + process( "CTX", "cs", offsetof(context_t,cs) ); + process( "CTX", "eflags", offsetof(context_t,eflags) ); + fputc( '\n', hfile ); + + hsection( "SCT", "section_t", sizeof(section_t) ); + process( "SCT", "length", offsetof(section_t,length) ); + process( "SCT", "addr", offsetof(section_t,addr) ); + fputc( '\n', hfile ); + + hsection( "PCB", "pcb_t", sizeof(pcb_t) ); + process( "PCB", "context", offsetof(pcb_t,context) ); + process( "PCB", "next", offsetof(pcb_t,next) ); + process( "PCB", "parent", offsetof(pcb_t,parent) ); + process( "PCB", "wakeup", offsetof(pcb_t,wakeup) ); + process( "PCB", "exit_status", offsetof(pcb_t,exit_status) ); + process( "PCB", "pdir", offsetof(pcb_t,pdir) ); + process( "PCB", "sects", offsetof(pcb_t,sects) ); + process( "PCB", "pid", offsetof(pcb_t,pid) ); + process( "PCB", "state", offsetof(pcb_t,state) ); + process( "PCB", "priority", offsetof(pcb_t,priority) ); + process( "PCB", "ticks", offsetof(pcb_t,ticks) ); + fputc( '\n', hfile ); + + // finish up the offsets.h file if we need to + if( genheader ) { + fputs( h_suffix, hfile ); + fclose( hfile ); + } + + return( 0 ); +} diff --git a/util/alternatives/Make.mk b/util/alternatives/Make.mk new file mode 100644 index 0000000..d5703e8 --- /dev/null +++ b/util/alternatives/Make.mk @@ -0,0 +1,56 @@ +# +# Makefile fragment for the utility programs +# +# THIS IS NOT A COMPLETE Makefile - run GNU make in the top-level +# directory, and this will be pulled in automatically. +# + +SUBDIRS += util + +################### +# RULES SECTION # +################### + +# how to make everything +util: $(BUILDDIR)/util/BuildImage $(BUILDDIR)/util/Offsets \ + $(BUILDDIR)/util/mkblob $(BUILDDIR)/util/listblob + +# +# Special rules for creating the utility programs. These are required +# because we don't want to use the same options as for the standalone +# binaries - we want these to be compiled as "normal" programs. +# + +$(BUILDDIR)/util/BuildImage: util/BuildImage.c + @mkdir -p $(@D) + $(CC) -std=c99 -o $(BUILDDIR)/util/BuildImage util/BuildImage.c + +$(BUILDDIR)/util/mkblob: util/mkblob.c + @mkdir -p $(@D) + $(CC) -std=c99 -o $(BUILDDIR)/util/mkblob util/mkblob.c + +$(BUILDDIR)/util/listblob: util/listblob.c + @mkdir -p $(@D) + $(CC) -std=c99 -o $(BUILDDIR)/util/listblob util/listblob.c + +# +# Offsets is compiled using -mx32 to force a 32-bit execution environment +# for a program that runs under a 64-bit operating system. This ensures +# that pointers and long ints are 32 bits rather than 64 bits, which is +# critical to correctly determining the size of types and byte offsets for +# fields in structs. We also compile with "-fno-builtin" to avoid signature +# clashes between declarations in our system and function declarations +# built into the C compiler. +# +# If compiled with the CPP macro CREATE_HEADER_FILE defined, Offsets +# accepts a command-line argument "-h". This causes it to write its +# output as a standard C header file into a file named "include/offsets.h" +# where it can be included into other source files (e.g., to provide +# sizes of structs in C and assembly, or to provide byte offsets into +# structures for use in assembly code). +# + +$(BUILDDIR)/util/Offsets: util/Offsets.c + @mkdir -p $(@D) + $(CC) -mx32 -std=c99 $(INCLUDES) -fno-builtin \ + -o $(BUILDDIR)/util/Offsets util/Offsets.c diff --git a/util/alternatives/README b/util/alternatives/README new file mode 100644 index 0000000..ae4dfbe --- /dev/null +++ b/util/alternatives/README @@ -0,0 +1,31 @@ +This directory contains "alternative" versions of some pieces of the system. + +Things included here: + + Make.mk + This version of the Makefile fragment puts the utility programs + in build/util instead of in the top-level directory. + + kmem.c + A version of the memory allocator that works with blocks of memory + that aren't exactly one page in length. During initialilzation, it + just adds each memory region identified during the boot process by + calls to the BIOS; as pages are requested, they are carved out of + these large blocks. The freelist is ordered by starting block + address, and allocation uses a first-fit strateby. + + The allocation function has this prototype: + + void *km_page_alloc( unsigned int count ); + + This allows the allocation of multiple contiguous pages. As pages + are freed, they are merged back into the freelist, and adjacent + free pages are coalesced into single, larger blocks. + + lib.c + This file pulls in all the individual .c files for the common + library functions in the lib/ directory. It is intended as an + alternative to having the libk.a archive file for the kernel; + instead of linking against that library, the lib.o file can + just be provided to the linker when the kernel is created, + and all the common library functions will be available. diff --git a/util/alternatives/kmem.c b/util/alternatives/kmem.c new file mode 100644 index 0000000..f1abf02 --- /dev/null +++ b/util/alternatives/kmem.c @@ -0,0 +1,749 @@ +/** +** @file kmem.c +** +** @author Warren R. Carithers +** @author Kenneth Reek +** @author 4003-506 class of 20013 +** +** @brief Functions to perform dynamic memory allocation in the OS. +** +** NOTE: these should NOT be called by user processes! +** +** This allocator functions as a simple "slab" allocator; it allows +** allocation of either 4096-byte ("page") or 1024-byte ("slice") +** chunks of memory from the free pool. The free pool is initialized +** using the memory map provided by the BIOS during the boot sequence, +** and contains a series of blocks which are multiples of 4K bytes and +** which are aligned at 4K boundaries; they are held in the free list +** in order by base address. +** +** The "page" allocator allows allocation of one or more 4K blocks +** at a time. Requests are made for a specific number of 4K pages; +** the allocator locates the first free list entry that contains at +** least the requested amount of space. If that entry is the exact +** size requested, it is unlinked and returned; otherwise, the entry +** is split into a chunk of the requested size and the remainder. +** The chunk is returned, and the remainder replaces the original +** block in the free list. On deallocation, the block is inserted +** at the appropriate place in the free list, and physically adjacent +** blocks are coalesced into single, larger blocks. If a multi-page +** block is allocated, it should be deallocated one page at a time, +** because there is no record of the size of the original allocation - +** all we know is that it is N*4K bytes in length, so it's up to the +** requesting code to figure this out. +** +** The "slice" allocator operates by taking blocks from the "page" +** allocator and splitting them into four 1K slices, which it then +** manages. Requests are made for slices one at a time. If the free +** list contains an available slice, it is unlinked and returned; +** otherwise, a page is requested from the page allocator, split into +** slices, and the slices are added to the free list, after which the +** first one is returned. The slice free list is a simple linked list +** of these 1K blocks; because they are all the same size, no ordering +** is done on the free list, and no coalescing is performed. +** +*/ + +#define KERNEL_SRC + +#include <common.h> + +// all other framework includes are next +#include <lib.h> + +#include <x86/arch.h> +#include <x86/bios.h> +#include <bootstrap.h> +#include <cio.h> + +#include <kmem.h> + +/* +** PRIVATE DEFINITIONS +*/ + +// parameters related to word and block sizes + +#define WORD_SIZE sizeof(int) +#define LOG2_OF_WORD_SIZE 2 + +#define LOG2_OF_PAGE_SIZE 12 + +#define LOG2_OF_SLICE_SIZE 10 + +// converters: pages to bytes, bytes to pages + +#define P2B(x) ((x) << LOG2_OF_PAGE_SIZE) +#define B2P(x) ((x) >> LOG2_OF_PAGE_SIZE) + +/* +** Name: adjacent +** +** Arguments: addresses of two blocks +** +** Description: Determines whether the second block immediately +** follows the first one. +*/ +#define adjacent(first,second) \ + ( (void *) (first) + P2B((first)->pages) == (void *) (second) ) + +/* +** PRIVATE DATA TYPES +*/ + +/* +** This structure keeps track of a single block of memory. All blocks +** are multiples of the base size (currently, 4KB). +*/ + +typedef struct block_s { + uint32_t pages; // length of this block, in pages + struct block_s *next; // pointer to the next free block +} block_t; + +/* +** Memory region information returned by the BIOS +** +** This data consists of a 32-bit integer followed +** by an array of region descriptor structures. +*/ + +// a handy union for playing with 64-bit addresses +typedef union b64_u { + uint32_t part[2]; + uint64_t all; +} b64_t; + +// the halves of a 64-bit address +#define LOW part[0] +#define HIGH part[1] + +// memory region descriptor +typedef struct memregion_s { + b64_t base; // base address + b64_t length; // region length + uint32_t type; // type of region + uint32_t acpi; // ACPI 3.0 info +} __attribute__((packed)) region_t; + +/* +** Region types +*/ + +#define REGION_USABLE 1 +#define REGION_RESERVED 2 +#define REGION_ACPI_RECL 3 +#define REGION_ACPI_NVS 4 +#define REGION_BAD 5 + +/* +** ACPI 3.0 bit fields +*/ + +#define REGION_IGNORE 0x01 +#define REGION_NONVOL 0x02 + +/* +** 32-bit and 64-bit address values as 64-bit literals +*/ + +#define ADDR_BIT_32 0x0000000100000000LL +#define ADDR_LOW_HALF 0x00000000ffffffffLL +#define ADDR_HIGH_HALR 0xffffffff00000000LL + +#define ADDR_32_MAX ADDR_LOW_HALF +#define ADDR_64_FIRST ADDR_BIT_32 + +/* +** PRIVATE GLOBAL VARIABLES +*/ + +// freespace pools +static block_t *free_pages; +static block_t *free_slices; + +// initialization status +static int km_initialized = 0; + +/* +** IMPORTED GLOBAL VARIABLES +*/ + +extern int _end; // end of the BSS section - provided by the linker + +/* +** FUNCTIONS +*/ + +/* +** FREE LIST MANAGEMENT +*/ + +/** +** Name: add_block +** +** Add a block to the free list. The contents of the block +** will be modified. +** +** @param[in] base Base address of the block +** @param[in] length Block length, in bytes +*/ +static void add_block( uint32_t base, uint32_t length ) { + block_t *block; + + // don't add it if it isn't at least 4K + if( length < SZ_PAGE ) { + return; + } + + // only want to add multiples of 4K; check the lower bits + if( (length & 0xfff) != 0 ) { + // round it down to 4K + length &= 0xfffff000; + } + + // create the "block" + + block = (block_t *) base; + block->pages = B2P(length); + block->next = NULL; + +#if TRACING_KMEM_FREE + cio_printf( "KM: add(%08x,%u): addr %08x len %u\n", + base, length, (uint32_t)block, block->length ); +#endif + + /* + ** We maintain the free list in order by address, to simplify + ** coalescing adjacent free blocks. + ** + ** Handle the easiest case first. + */ + + if( free_pages == NULL ) { + free_pages = block; + return; + } + + /* + ** Unfortunately, it's not always that easy.... + ** + ** Find the correct insertion spot. + */ + + block_t *prev, *curr; + + prev = NULL; + curr = free_pages; + + while( curr && curr < block ) { + prev = curr; + curr = curr->next; + } + + // the new block always points to its successor + block->next = curr; + + /* + ** If prev is NULL, we're adding at the front; otherwise, + ** we're adding after some other entry (middle or end). + */ + + if( prev == NULL ) { + // sanity check - both pointers can't be NULL + assert( curr ); + // add at the beginning + free_pages = block; + } else { + // inserting in the middle or at the end + prev->next = block; + } +} + +/** +** Name: km_init +** +** Find what memory is present on the system and +** construct the list of free memory blocks. +** +** Dependencies: +** Must be called before any other init routine that uses +** dynamic storage is called. +*/ +void km_init( void ) { + int32_t entries; + region_t *region; + uint64_t cutoff; + +#if TRACING_INIT + // announce that we're starting initialization + cio_puts( " Kmem" ); +#endif + + // initially, nothing in the free lists + free_slices = NULL; + free_pages = NULL; + + /* + ** We ignore all memory below the end of our OS. In theory, + ** we should be able to re-use much of that space; in practice, + ** this is safer. + */ + + // set our cutoff point as the end of the BSS section + cutoff = (uint32_t) &_end; + + // round it up to the next multiple of 4K (0x1000) + if( cutoff & 0xfffLL ) { + cutoff &= 0xfffff000LL; + cutoff += 0x1000LL; + } + + // get the list length + entries = *((int32_t *) MMAP_ADDRESS); + +#if TRACING_KEMEM + cio_printf( "\nKmem: %d regions\n", entries ); +#endif + + // if there are no entries, we have nothing to do! + if( entries < 1 ) { // note: entries == -1 could occur! + return; + } + + // iterate through the entries, adding things to the freelist + + region = ((region_t *) (MMAP_ADDRESS + 4)); + + for( int i = 0; i < entries; ++i, ++region ) { + +#if TRACING_KMEM + // report this region + cio_printf( "%3d: ", i ); + cio_printf( " base %08x%08x", + region->base.HIGH, region->base.LOW ); + cio_printf( " len %08x%08x", + region->length.HIGH, region->length.LOW ); + cio_printf( " type %08x acpi %08x", + region->type, region->acpi ); +#endif + + /* + ** Determine whether or not we should ignore this region. + ** + ** We ignore regions for several reasons: + ** + ** ACPI indicates it should be ignored + ** ACPI indicates it's non-volatile memory + ** Region type isn't "usable" + ** Region is above the 4GB address limit + ** + ** Currently, only "normal" (type 1) regions are considered + ** "usable" for our purposes. We could potentially expand + ** this to include ACPI "reclaimable" memory. + */ + + // first, check the ACPI one-bit flags + + if( ((region->acpi) & REGION_IGNORE) == 0 ) { + cio_puts( " IGN\n" ); + continue; + } + + if( ((region->acpi) & REGION_NONVOL) != 0 ) { + cio_puts( " NVOL\n" ); + continue; // we'll ignore this, too + } + + // next, the region type + + if( (region->type) != REGION_USABLE ) { + cio_puts( " RCLM\n" ); + continue; // we won't attempt to reclaim ACPI memory (yet) + } + + // OK, we have a "normal" memory region - verify that it's usable + + // ignore it if it's above 4GB + if( region->base.HIGH != 0 ) { + cio_puts( " 4GB+\n" ); + continue; + } + + // grab the two 64-bit values to simplify things + uint64_t base = region->base.all; + uint64_t length = region->length.all; + + // see if it's below our arbitrary cutoff point + if( base < cutoff ) { + + // is the whole thing too low, or just part? + if( (base + length) < cutoff ) { + // it's all below the cutoff! + cio_puts( " LOW\n" ); + continue; + } + + // recalculate the length, starting at our cutoff point + uint64_t loss = cutoff - base; + + // reset the length and the base address + length -= loss; + base = cutoff; + } + + // see if it extends beyond the 4GB boundary + + if( (base + length) > ADDR_32_MAX ) { + + // OK, it extends beyond the 32-bit limit; figure out + // how far over it goes, and lop off that portion + + uint64_t loss = (base + length) - ADDR_64_FIRST; + length -= loss; + } + + // we survived the gauntlet - add the new block + + cio_puts( " OK\n" ); + + uint32_t b32 = base & ADDR_LOW_HALF; + uint32_t l32 = length & ADDR_LOW_HALF; + + add_block( b32, l32 ); + } + + // record the initialization + km_initialized = 1; +} + +/** +** Name: km_dump +** +** Dump the current contents of the free list to the console +*/ +void km_dump( void ) { + block_t *block; + + cio_printf( "&_free_pages=%08x\n", &_free_pages ); + + for( block = _free_pages; block != NULL; block = block->next ) { + cio_printf( + "block @ 0x%08x 0x%08x pages (ends at 0x%08x) next @ 0x%08x\n", + block, block->pages, P2B(block->pages) + (uint32_t) block, + block->next ); + } + +} + +/* +** PAGE MANAGEMENT +*/ + +/** +** Name: km_page_alloc +** +** Allocate a page of memory from the free list. +** +** @param[in] count Number of contiguous pages desired +** +** @return a pointer to the beginning of the first allocated page, +** or NULL if no memory is available +*/ +void *km_page_alloc( unsigned int count ) { + + assert( km_initialized ); + + // make sure we actually need to do something! + if( count < 1 ) { + return( NULL ); + } + +#if TRACING_KMEM_FREE + cio_printf( "KM: pg_alloc(%u)", count ); +#endif + + /* + ** Look for the first entry that is large enough. + */ + + // pointer to the current block + block_t *block = free_pages; + + // pointer to where the pointer to the current block is + block_t **pointer = &free_pages; + + while( block != NULL && block->pages < count ){ + pointer = &block->next; + block = *pointer; + } + + // did we find a big enough block? + if( block == NULL ){ + // nope! +#if TRACING_KMEM_FREE + cio_puts( " FAIL\n" ); +#endif + return( NULL ); + } + + // found one! check the length + + if( block->pages == count ) { + + // exactly the right size - unlink it from the list + + *pointer = block->next; + + } else { + + // bigger than we need - carve the amount we need off + // the beginning of this block + + // remember where this chunk begins + block_t *chunk = block; + + // how much space will be left over? + int excess = block->pages - count; + + // find the start of the new fragment + block_t *fragment = (block_t *) ( (uint8_t *) block + P2B(count) ); + + // set the length and link for the new fragment + fragment->pages = excess; + fragment->next = block->next; + + // replace this chunk with the fragment + *pointer = fragment; + + // return this chunk + block = chunk; + } + +#if TRACING_KMEM_FREE + cio_printf( " -> %08x\n", (uint32_t) block ); +#endif + + return( block ); +} + +/** +** Name: km_page_free +** +** Returns a memory block to the list of available blocks, +** combining it with adjacent blocks if they're present. +** +** CRITICAL ASSUMPTION: multi-page blocks will be freed one page +** at a time! +** +** @param[in] block Pointer to the page to be returned to the free list +*/ +void km_page_free( void *block ){ + block_t *used; + block_t *prev; + block_t *curr; + + assert( km_initialized ); + + /* + ** Don't do anything if the address is NULL. + */ + if( block == NULL ){ + return; + } + +#if TRACING_KMEM_FREE + cio_printf( "KM: pg_free(%08x)", (uint32_t) block ); +#endif + + used = (block_t *) block; + + /* + ** CRITICAL ASSUMPTION + ** + ** We assume that any multi-page block that is being freed will + ** be freed one page at a time. We make this assumption because we + ** don't track allocation sizes. We can't use the simple "allocate + ** four extra bytes before the returned pointer" scheme to do this + ** because we're managing pages, and the pointers we return must point + ** to page boundaries, so we would wind up allocating an extra page + ** for each allocation. + ** + ** Alternatively, we could keep an array of addresses and block + ** sizes ourselves, but that feels clunky, and would risk running out + ** of table entries if there are lots of allocations (assuming we use + ** a 4KB page to hold the table, at eight bytes per entry we would have + ** 512 entries per page). + ** + ** IF THIS ASSUMPTION CHANGES, THIS CODE MUST BE FIXED!!! + */ + + used->pages = 1; + + /* + ** Advance through the list until current and previous + ** straddle the place where the new block should be inserted. + */ + prev = NULL; + curr = free_pages; + + while( curr != NULL && curr < used ){ + prev = curr; + curr = curr->next; + } + + /* + ** At this point, we have the following list structure: + ** + ** .... BLOCK BLOCK .... + ** (*prev) ^ (*curr) + ** | + ** "used" goes here + ** + ** We may need to merge the inserted block with either its + ** predecessor or its successor (or both). + */ + + /* + ** If this is not the first block in the resulting list, + ** we may need to merge it with its predecessor. + */ + if( prev != NULL ){ + + // There is a predecessor. Check to see if we need to merge. + if( adjacent( prev, used ) ){ + + // yes - merge them + prev->pages += used->pages; + + // the predecessor becomes the "newly inserted" block, + // because we still need to check to see if we should + // merge with the successor + used = prev; + + } else { + + // Not adjacent - just insert the new block + // between the predecessor and the successor. + used->next = prev->next; + prev->next = used; + + } + + } else { + + // Yes, it is first. Update the list pointer to insert it. + used->next = free_pages; + free_pages = used; + + } + + /* + ** If this is not the last block in the resulting list, + ** we may (also) need to merge it with its successor. + */ + if( curr != NULL ){ + + // No. Check to see if it should be merged with the successor. + if( adjacent( used, curr ) ){ + + // Yes, combine them. + used->next = curr->next; + used->pages += curr->pages; + + } + } +} + +/* +** SLICE MANAGEMENT +*/ + +/* +** Slices are 1024-byte fragments from pages. We maintain a free list of +** slices for those parts of the OS which don't need full 4096-byte chunks +** of space (e.g., the QNode and Queue allocators). +*/ + +/** +** Name: carve_slices +** +** Allocate a page and split it into four slices; If no +** memory is available, we panic. +*/ +static void carve_slices( void ) { + void *page; + + // get a page + page = km_page_alloc( 1 ); + + // allocation failure is a show-stopping problem + assert( page ); + + // we have the page; create the four slices from it + uint8_t *ptr = (uint8_t *) page; + for( int i = 0; i < 4; ++i ) { + km_slice_free( (void *) ptr ); + ptr += SZ_SLICE; + } +} + +/** +** Name: km_slice_alloc +** +** Dynamically allocates a slice (1/4 of a page). If no +** memory is available, we panic. +** +** @return a pointer to the allocated slice +*/ +void *km_slice_alloc( void ) { + block_t *slice; + + assert( km_initialized ); + +#if TRACING_KMEM_FREE + cio_printf( "KM: sl_alloc()\n" ); +#endif + + // if we are out of slices, create a few more + if( free_slices == NULL ) { + carve_slices(); + } + + // take the first one from the free list + slice = free_slices; + assert( slice != NULL ); + + // unlink it + free_slices = slice->next; + + // make it nice and shiny for the caller + memclr( (void *) slice, SZ_SLICE ); + + return( slice ); +} + +/** +** Name: km_slice_free +** +** Returns a slice to the list of available slices. +** +** We make no attempt to merge slices, as they are independent +** blocks of memory (unlike pages). +** +** @param[in] block Pointer to the slice (1/4 page) to be freed +*/ +void km_slice_free( void *block ) { + block_t *slice = (block_t *) block; + + assert( km_initialized ); + +#if TRACING_KMEM_FREE + cio_printf( "KM: sl_free(%08x)\n", (uint32_t) block ); +#endif + + // just add it to the front of the free list + slice->pages = SZ_SLICE; + slice->next = free_slices; + free_slices = slice; +} diff --git a/util/alternatives/lib.c b/util/alternatives/lib.c new file mode 100644 index 0000000..4b7a9ed --- /dev/null +++ b/util/alternatives/lib.c @@ -0,0 +1,56 @@ +/** +** @file lib.c +** +** @author Numerous CSCI-452 classes +** +** @brief C implementations of common library functions +** +** These are callable from either kernel or user code. Care should be taken +** that user code is linked against these separately from kernel code, to +** ensure separation of the address spaces. +** +** This file exists to pull them all in as a single object file. +*/ + +#include <common.h> + +#include <lib.h> + +/* +********************************************** +** MEMORY MANIPULATION FUNCTIONS +********************************************** +*/ + +#include "common/memset.c" +#include "common/memclr.c" +#include "common/memcpy.c" + +/* +********************************************** +** STRING MANIPULATION FUNCTIONS +********************************************** +*/ + +#include "common/str2int.c" +#include "common/strlen.c" +#include "common/strcmp.c" +#include "common/strcpy.c" +#include "common/strcat.c" +#include "common/pad.c" +#include "common/padstr.c" +#include "common/sprint.c" + +/* +********************************************** +** CONVERSION FUNCTIONS +********************************************** +*/ + +#include "common/cvtuns0.c" +#include "common/cvtuns.c" +#include "common/cvtdec0.c" +#include "common/cvtdec.c" +#include "common/cvthex.c" +#include "common/cvtoct.c" +#include "common/bound.c" diff --git a/util/gdbinit.tmpl b/util/gdbinit.tmpl new file mode 100644 index 0000000..d9a981d --- /dev/null +++ b/util/gdbinit.tmpl @@ -0,0 +1,31 @@ +# adapted from the xv6 .gdbinit.tmpl file +set $lastcs = -1 + +define hook-stop + # There doesn't seem to be a good way to detect if we're in 16- or + # 32-bit mode, but we always run with CS == 8 in 32-bit mode. + if $cs == 8 || $cs == 27 + if $lastcs != 8 && $lastcs != 27 + set architecture i386 + end + x/i $pc + else + if $lastcs == -1 || $lastcs == 8 || $lastcs == 27 + set architecture i8086 + end + # Translate the segment:offset into a physical address + printf "[%4x:%4x] ", $cs, $eip + x/i $cs*16+$eip + end + set $lastcs = $cs +end + +echo + target remote localhost:1234\n +target remote localhost:1234 + +# If this fails, it's probably because your GDB doesn't support ELF. +# Look at the tools page at +# http://pdos.csail.mit.edu/6.828/2009/tools.html +# for instructions on building GDB with ELF support. +echo + symbol-file build/kernel/kernel\n +symbol-file build/kernel/kernel diff --git a/util/listblob.c b/util/listblob.c new file mode 100644 index 0000000..07523a6 --- /dev/null +++ b/util/listblob.c @@ -0,0 +1,248 @@ +/** +** @file listblob.c +** +** @author Warren R. Carithers +** +** Examine a binary blob of ELF files. +*/ +#define _DEFAULT_SOURCE +#include <stdio.h> +#include <stdint.h> +#include <stdlib.h> +#include <stdbool.h> +#include <string.h> +#include <unistd.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <elf.h> +#include <ctype.h> + +/* +** Blob file organization +** +** The file begins with a four-byte magic number and a four-byte integer +** indicating the number of ELF files contained in the blob. This is +** followed by an array of 32-byte file entries, and then the contents +** of the ELF files in the order they appear in the program file table. +** +** Bytes Contents +** ----- ---------------------------- +** 0 - 3 File magic number ("BLB\0") +** 4 - 7 Number of ELF files in blob ("n") +** 8 - n*32+8 Program file table +** n*32+9 - ? ELF file contents +** +** Each program file table entry contains the following information: +** +** name File name (up to 19 characters long) +** offset Byte offset to the ELF header for this file +** size Size of this ELF file, in bytes +** flags Flags related to this file +*/ + +// blob header: 8 bytes +typedef struct header_s { + char magic[4]; + uint32_t num; +} header_t; + +// The program table entry is 32 bytes long. To accomplish this, the +// name field is 20 bytes long, which allows file names of 19 characters +// (followed by a trailing NUL byte). +// +// If that field is made longer, it should be incremented in multiples +// of four to avoid the insertion of padding bytes. +#define NAMELEN 20 + +// program descriptor: 32 bytes +typedef struct prog_s { + char name[NAMELEN]; // truncated name (19 chars plus NUL) + uint32_t offset; // offset from the beginning of the blob + uint32_t size; // size of this ELF module + uint32_t flags; // miscellaneous flags +} prog_t; + +// modules must be written as multiples of eight bytes +#define FL_ROUNDUP 0x00000001 + +// mask for mod 8 checking +#define FSIZE_MASK 0x00000007 + +// program list entry +typedef struct node_s { + prog_t *data; + struct node_s *next; +} node_t; + +node_t *progs, *last_prog; // list pointers +uint32_t n_progs; // number of files being copied +uint32_t offset; // current file area offset +bool defs = false; // print CPP #defines? +bool enums = false; // print C enums? + +// header string for the userids.h file +const char header[] = +"/**\n" +"** @file userids.h\n" +"**\n" +"** @author Warren R. Carithers\n" +"**\n" +"** @brief IDs for user-level programs\n" +"**\n" +"** NOTE: this file is automatically generated when the user.img file\n" +"** is created. Do not edit this manually!\n" +"*/\n" +"\n" +"#ifndef USERIDS_H_\n" +"#define USERIDS_H_\n" +"\n" +"#ifndef ASM_SRC\n" +"/*\n" +"** These IDs are used to identify the various user programs.\n" +"** Each call to exec() will provide one of these as the first\n" +"** argument.\n" +"**\n" +"** This list should be updated if/when the collection of\n" +"** user processes changes.\n" +"*/\n" +"enum users_e {" +; + +// trailer string for the userids.h file +const char trailer[] = +"\n\t// sentinel\n\t, N_USERS\n" +"};\n" +"#endif /* !ASM_SRC */\n" +"\n" +"#endif" +; + +/** +** Name: process +** +** Process a program list entry +** +** @param num Program list index +** @param prog Pointer to the program list entry +*/ +void process( uint32_t num, prog_t *prog ) { + + if( defs || enums ) { + + char *slash = strrchr( prog->name, '/' ); + if( slash == NULL ) { + slash = prog->name; + } else { + ++slash; + } + + slash[0] = toupper(slash[0]); + + if( defs ) { + + // just printing #define statements + printf( "#define %-15s %2d\n", prog->name, num ); + + } else { + + // printing a new userids.h file + if( num == 0 ) { + // first one, so print the file header + puts( header ); + putchar( '\t' ); + } else { + // second or later entry; limit to 8 per line + fputs( ((num & 0x7) == 0 ) ? ",\n\t" : ", ", stdout ); + } + printf( "%s", prog->name ); + } + + } else { + + // just printing information + printf( "Entry %2d: ", num ); + printf( "%-s,", prog->name ); + printf( " offset 0x%x, size 0x%x, flags %08x\n", + prog->offset, prog->size, prog->flags ); + } +} + +void usage( char *name ) { + fprintf( stderr, "usage: %s [-d | -e] blob_name\n", name ); +} + +int main( int argc, char *argv[] ) { + + if( argc < 2 || argc > 3) { + usage( argv[0] ); + exit( 1 ); + } + + int nameix = 1; + + // could use getopt() for this, but this is easy enough + if( argc == 3 ) { + if( strcmp(argv[1],"-d") == 0 ) { + defs = true; + } else if( strcmp(argv[1],"-e") == 0 ) { + enums = true; + } else { + usage( argv[0] ); + exit( 1 ); + } + nameix = 2; + } + + char *name = argv[nameix]; + + int fd = open( name, O_RDONLY ); + if( fd < 0 ) { + perror( name ); + exit( 1 ); + } + + header_t hdr; + + int n = read( fd, &hdr, sizeof(header_t) ); + if( n != sizeof(header_t) ) { + fprintf( stderr, "%s: header read returned only %d bytes\n", name, n ); + close( fd ); + exit( 1 ); + } + + if( strcmp(hdr.magic,"BLB") != 0 ) { + fprintf( stderr, "%s: bad magic number\n", name ); + close( fd ); + exit( 1 ); + } + + if( hdr.num < 1 ) { + fprintf( stderr, "%s: no programs in blob?\n", name ); + close( fd ); + exit( 1 ); + } + + prog_t progs[hdr.num]; + + n = read( fd, progs, hdr.num * sizeof(prog_t) ); + if( n != (int) (hdr.num * sizeof(prog_t)) ) { + + fprintf( stderr, "%s: prog table only %d bytes, expected %lu\n", + name, n, hdr.num * sizeof(prog_t) ); + close( fd ); + exit( 1 ); + } + + for( uint32_t i = 0; i < hdr.num; ++i ) { + process( i, &progs[i] ); + } + + if( enums ) { + // print the file trailer + puts( trailer ); + } + + close( fd ); + return 0; + +} diff --git a/util/mergedep.pl b/util/mergedep.pl new file mode 100644 index 0000000..1730d53 --- /dev/null +++ b/util/mergedep.pl @@ -0,0 +1,86 @@ +#!/usr/bin/perl +# Copyright 2003 Bryan Ford +# Distributed under the GNU General Public License. +# +# Usage: mergedep <main-depfile> [<new-depfiles> ...] +# +# This script merges the contents of all <new-depfiles> specified +# on the command line into the single file <main-depfile>, +# which may or may not previously exist. +# Dependencies in the <new-depfiles> will override +# any existing dependencies for the same targets in <main-depfile>. +# The <new-depfiles> are deleted after <main-depfile> is updated. +# +# The <new-depfiles> are typically generated by GCC with the -MD option, +# and the <main-depfile> is typically included from a Makefile, +# as shown here for GNU 'make': +# +# .deps: $(wildcard *.d) +# perl mergedep $@ $^ +# -include .deps +# +# This script properly handles multiple dependencies per <new-depfile>, +# including dependencies having no target, +# so it is compatible with GCC3's -MP option. +# + +sub readdeps { + my $filename = shift; + + open(DEPFILE, $filename) or return 0; + while (<DEPFILE>) { + if (/([^:]*):([^\\:]*)([\\]?)$/) { + my $target = $1; + my $deplines = $2; + my $slash = $3; + while ($slash ne '') { + $_ = <DEPFILE>; + defined($_) or die + "Unterminated dependency in $filename"; + /(^[ \t][^\\]*)([\\]?)$/ or die + "Bad continuation line in $filename"; + $deplines = "$deplines\\\n$1"; + $slash = $2; + } + #print "DEPENDENCY [[$target]]: [[$deplines]]\n"; + $dephash{$target} = $deplines; + } elsif (/^[#]?[ \t]*$/) { + # ignore blank lines and comments + } else { + die "Bad dependency line in $filename: $_"; + } + } + close DEPFILE; + return 1; +} + + +if ($#ARGV < 0) { + print "Usage: mergedep <main-depfile> [<new-depfiles> ..]\n"; + exit(1); +} + +%dephash = (); + +# Read the main dependency file +$maindeps = $ARGV[0]; +readdeps($maindeps); + +# Read and merge in the new dependency files +foreach $i (1 .. $#ARGV) { + readdeps($ARGV[$i]) or die "Can't open $ARGV[$i]"; +} + +# Update the main dependency file +open(DEPFILE, ">$maindeps.tmp") or die "Can't open output file $maindeps.tmp"; +foreach $target (keys %dephash) { + print DEPFILE "$target:$dephash{$target}"; +} +close DEPFILE; +rename("$maindeps.tmp", "$maindeps") or die "Can't overwrite $maindeps"; + +# Finally, delete the new dependency files +foreach $i (1 .. $#ARGV) { + unlink($ARGV[$i]) or print "Error removing $ARGV[$i]\n"; +} + diff --git a/util/mkblob.c b/util/mkblob.c new file mode 100644 index 0000000..32c67dd --- /dev/null +++ b/util/mkblob.c @@ -0,0 +1,324 @@ +/** +** @file mkblob.c +** +** @author Warren R. Carithers +** +** Create a binary blob from a collection of ELF files. +*/ +#define _DEFAULT_SOURCE + +#include <stdio.h> +#include <stdint.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <elf.h> + +/* +** Blob file organization +** +** The file begins with a four-byte magic number and a four-byte integer +** indicating the number of ELF files contained in the blob. This is +** followed by an array of 32-byte file table entries, and then the contents +** of the ELF files in the order they appear in the program file table. +** +** Bytes Contents +** ----- ---------------------------- +** 0 - 3 File magic number ("BLB\0") +** 4 - 7 Number of ELF files in blob ("n") +** 8 - n*32+8 Program file table +** n*32+9 - ? ELF file contents +** +** Each program file table entry contains the following information: +** +** name File name (up to 19 characters long) +** offset Byte offset to the ELF header for this file +** size Size of this ELF file, in bytes +** flags Flags related to this file +*/ + +// blob header +typedef struct header_s { + char magic[4]; + uint32_t num; +} header_t; + +// length of the file name field +#define NAMELEN 20 + +// program descriptor +typedef struct prog_s { + char name[NAMELEN]; // truncated name (15 chars) + uint32_t offset; // offset from the beginning of the blob + uint32_t size; // size of this ELF module + uint32_t flags; // miscellaneous flags +} prog_t; + +// modules must be written as multiples of eight bytes +#define FL_ROUNDUP 0x00000001 + +// mask for mod 8 checking +#define FSIZE_MASK 0x00000007 + +// program list entry +typedef struct node_s { + prog_t *data; + char *fullname; + struct node_s *next; +} node_t; + +node_t *progs, *last_prog; // list pointers +uint32_t n_progs; // number of files being copied +uint32_t offset; // current file area offset + +/** +** Name: process +** +** Do the initial processing for an ELF file +** +** @param name The name of the file +*/ +void process( const char *name ) { + struct stat info; + + // check the name length + if( strlen(name) >= NAMELEN ) { + fprintf( stderr, "%s: name exceeds length limit (%d)\n", + name, NAMELEN-1 ); + return; + } + + // does it exist? + if( stat(name,&info) < 0 ) { + perror( name ); + return; + } + + // is it a regular file? + if( !S_ISREG(info.st_mode) ) { + fprintf( stderr, "%s: not a regular file\n", name ); + return; + } + + // open it and check the file header + int fd = open( name, O_RDONLY ); + if( fd < 0 ) { + perror( name ); + return; + } + + // read and check the ELF header + Elf32_Ehdr hdr; + int n = read( fd, &hdr, sizeof(Elf32_Ehdr) ); + close( fd ); + + if( n != sizeof(Elf32_Ehdr) ) { + fprintf( stderr, "%s: header read was short - only %d\n", name, n ); + return; + } + + if( hdr.e_ident[EI_MAG0] != ELFMAG0 || + hdr.e_ident[EI_MAG1] != ELFMAG1 || + hdr.e_ident[EI_MAG2] != ELFMAG2 || + hdr.e_ident[EI_MAG3] != ELFMAG3 ) { + fprintf( stderr, "%s: bad ELF magic number\n", name ); + return; + } + + // ok, it's a valid ELF file - create the prog list entry + prog_t *new = calloc( 1, sizeof(prog_t) ); + if( new == NULL ) { + fprintf( stderr, "%s: calloc prog returned NULL\n", name ); + return; + } + + node_t *node = calloc( 1, sizeof(node_t) ); + if( node == NULL ) { + free( new ); + fprintf( stderr, "%s: calloc node returned NULL\n", name ); + return; + } + + node->data = new; + node->fullname = strdup( name ); + + // copy in the name + + // only want the last component + const char *slash = strrchr( name, '/' ); + if( slash == NULL ) { + // only the file name + slash = name; + } else { + // skip the slash + ++slash; + } + + strncpy( new->name, slash, sizeof(new->name)-1 ); + new->offset = offset; + new->size = info.st_size; + + // bump our counters + ++n_progs; + offset += info.st_size; + + // make sure it's a multiple of eight bytes long + if( (info.st_size & FSIZE_MASK) != 0 ) { + // nope, so we must round it up when we write it out + new->flags |= FL_ROUNDUP; + // increases the offset to the next file + offset += 8 - (info.st_size & FSIZE_MASK); + } + + // add to the list + if( progs == NULL ) { + // first entry + progs = node; + } else { + // add to the end + if( last_prog == NULL ) { + fprintf( stderr, "%s: progs ! NULL, last_prog is NULL\n", name ); + free( new ); + free( node->fullname ); + free( node ); + return; + } + last_prog->next = node; + } + last_prog = node; +} + +/** +** Name: copy +** +** Copy the contents of a program list entry into the blob +** +** @param ofd The output FILE* to be written +** @param prog Pointer to the program list entry for the file +*/ +void copy( FILE *ofd, node_t *node ) { + + prog_t *prog = node->data; + + // open it so we can copy it + int fd = open( node->fullname, O_RDONLY ); + if( fd < 0 ) { + perror( node->fullname ); + return; + } + + uint8_t buf[512]; + + // copy it block-by-block + do { + int n = read( fd, buf, 512); + // no bytes --> we're done + if( n < 1 ) { + break; + } + // copy it, and verify the copy count + int k = fwrite( buf, 1, n, ofd ); + if( k != n ) { + fprintf( stderr, "%s: write of %d returned %d\n", + prog->name, n, k ); + } + } while( 1 ); + + printf( "%s: copied %d", prog->name, prog->size ); + + // do we need to round up? + if( (prog->flags & FL_ROUNDUP) != 0 ) { + + // we'll fill with NUL bytes + uint64_t filler = 0; + + // how many filler bytes do we need? + int nbytes = 8 - (prog->size & FSIZE_MASK); + + // do it, and check the transfer count to be sure + int n = fwrite( &filler, 1, nbytes, ofd ); + if( n != nbytes ) { + fprintf( stderr, "%s: fill write of %d returned %d\n", + prog->name, nbytes, n ); + } + + // report that we added some filler bytes + printf( "(+%d)", n ); + } + puts( " bytes" ); + + // all done! + close( fd ); +} + +int main( int argc, char *argv[] ) { + + // construct program list + for( int i = 1; i < argc; ++i ) { + process( argv[i] ); + } + + if( n_progs < 1 ) { + fputs( "Nothing to do... exiting.", stderr ); + exit( 0 ); + } + + // create the output file + FILE *ofd; + ofd = fopen( "user.img", "wb" ); + if( ofd == NULL ) { + perror( "user.img" ); + exit( 1 ); + } + + printf( "Processing %d ELF files\n", n_progs ); + + // we need to adjust the offset values so they are relative to the + // start of the blob, not relative to the start of the file area. + // do this by adding the sum of the file header and program entries + // to each offset field. + + uint32_t hlen = sizeof(header_t) + n_progs * sizeof(prog_t); + node_t *curr = progs; + while( curr != NULL ) { + curr->data->offset += hlen; + curr = curr->next; + } + + // write out the blob header + header_t hdr = { "BLB", n_progs }; + if( fwrite(&hdr,sizeof(header_t),1,ofd) != 1 ) { + perror( "blob header" ); + fclose( ofd ); + exit( 1 ); + } + + // next, the program entries + curr = progs; + while( curr != NULL ) { + if( fwrite(curr->data,sizeof(prog_t),1,ofd) != 1 ) { + perror( "blob prog entry write" ); + fclose( ofd ); + exit( 1 ); + } + curr = curr->next; + } + + // finally, copy the files + curr = progs; + while( curr != NULL ) { + prog_t *prog = curr->data; + copy( ofd, curr ); + node_t *tmp = curr; + curr = curr->next; + free( tmp->data ); + free( tmp->fullname ); + free( tmp ); + } + + fclose( ofd ); + + return 0; +} |