freebsd_loader.c

Go to the documentation of this file.

/* bootinfo */
#define BOOTINFO_VERSION 1
#define NODEV           (-1)    /* non-existent device */
#define PAGE_SHIFT      12              /* LOG2(PAGE_SIZE) */
#define PAGE_SIZE       (1<<PAGE_SHIFT) /* bytes/page */
#define PAGE_MASK       (PAGE_SIZE-1)
#define N_BIOS_GEOM     8

struct bootinfo {
        unsigned int            bi_version;
        const unsigned char     *bi_kernelname;
        struct nfs_diskless     *bi_nfs_diskless;
                                /* End of fields that are always present. */
#define bi_endcommon            bi_n_bios_used
        unsigned int            bi_n_bios_used;
        unsigned long           bi_bios_geom[N_BIOS_GEOM];
        unsigned int            bi_size;
        unsigned char           bi_memsizes_valid;
        unsigned char           bi_pad[3];
        unsigned long           bi_basemem;
        unsigned long           bi_extmem;
        unsigned long           bi_symtab;
        unsigned long           bi_esymtab;
        /* Note that these are in the FreeBSD headers but were not here... */
        unsigned long           bi_kernend;             /* end of kernel space */
        unsigned long           bi_envp;                /* environment */
        unsigned long           bi_modulep;             /* preloaded modules */
};

static struct bootinfo bsdinfo;

#ifdef ELF_IMAGE
static Elf32_Shdr *shdr;        /* To support the FreeBSD kludge! */
static Address symtab_load;
static Address symstr_load;
static int symtabindex;
static int symstrindex;
#endif

static enum {
        Unknown, Tagged, Aout, Elf, Aout_FreeBSD, Elf_FreeBSD,
} image_type = Unknown;

static unsigned int off;


#ifdef ELF_IMAGE
static void elf_freebsd_probe(void)
{
        image_type = Elf;
        if (    (estate.e.elf32.e_entry & 0xf0000000) && 
                (estate.e.elf32.e_type == ET_EXEC))
        {
                image_type = Elf_FreeBSD;
                printf("/FreeBSD");
                off = -(estate.e.elf32.e_entry & 0xff000000);
                estate.e.elf32.e_entry += off;
        }
        /* Make sure we have a null to start with... */
        shdr = 0;
        
        /* Clear the symbol index values... */
        symtabindex = -1;
        symstrindex = -1;
        
        /* ...and the load addresses of the symbols  */
        symtab_load = 0;
        symstr_load = 0;
}

static void elf_freebsd_fixup_segment(void)
{
        if (image_type == Elf_FreeBSD) {
                estate.p.phdr32[estate.segment].p_paddr += off;
        }
}

static void elf_freebsd_find_segment_end(void)
{
        /* Count the bytes read even for the last block
         * as we will need to know where the last block
         * ends in order to load the symbols correctly.
         * (plus it could be useful elsewhere...)
         * Note that we need to count the actual size,
         * not just the end of the disk image size.
         */
        estate.curaddr += 
                (estate.p.phdr32[estate.segment].p_memsz - 
                estate.p.phdr32[estate.segment].p_filesz);
}

static int elf_freebsd_debug_loader(unsigned int offset)
{
        /* No more segments to be loaded - time to start the
         * nasty state machine to support the loading of
         * FreeBSD debug symbols due to the fact that FreeBSD
         * uses/exports the kernel's debug symbols in order
         * to make much of the system work!  Amazing (arg!)
         *
         * We depend on the fact that for the FreeBSD kernel,
         * there is only one section of debug symbols and that
         * the section is after all of the loaded sections in
         * the file.  This assumes a lot but is somewhat required
         * to make this code not be too annoying.  (Where do you
         * load symbols when the code has not loaded yet?)
         * Since this function is actually just a callback from
         * the network data transfer code, we need to be able to
         * work with the data as it comes in.  There is no chance
         * for doing a seek other than forwards.
         *
         * The process we use is to first load the section
         * headers.  Once they are loaded (shdr != 0) we then
         * look for where the symbol table and symbol table
         * strings are and setup some state that we found
         * them and fall into processing the first one (which
         * is the symbol table) and after that has been loaded,
         * we try the symbol strings.  Note that the order is
         * actually required as the memory image depends on
         * the symbol strings being loaded starting at the
         * end of the symbol table.  The kernel assumes this
         * layout of the image.
         *
         * At any point, if we get to the end of the load file
         * or the section requested is earlier in the file than
         * the current file pointer, we just end up falling
         * out of this and booting the kernel without this
         * information.
         */

        /* Make sure that the next address is long aligned... */
        /* Assumes size of long is a power of 2... */
        estate.curaddr = (estate.curaddr + sizeof(long) - 1) & ~(sizeof(long) - 1);
        
        /* If we have not yet gotten the shdr loaded, try that */
        if (shdr == 0)
        {
                estate.toread = estate.e.elf32.e_shnum * estate.e.elf32.e_shentsize;
                estate.skip = estate.e.elf32.e_shoff - (estate.loc + offset);
                if (estate.toread)
                {
#if ELF_DEBUG
                        printf("shdr *, size %lX, curaddr %lX\n", 
                                estate.toread, estate.curaddr);
#endif
                        
                        /* Start reading at the curaddr and make that the shdr */
                        shdr = (Elf32_Shdr *)phys_to_virt(estate.curaddr);
                        
                        /* Start to read... */
                        return 1;
                }
        }
        else
        {
                /* We have the shdr loaded, check if we have found
                 * the indexs where the symbols are supposed to be */
                if ((symtabindex == -1) && (symstrindex == -1))
                {
                        int i;
                        /* Make sure that the address is page aligned... */
                        /* Symbols need to start in their own page(s)... */
                        estate.curaddr = (estate.curaddr + 4095) & ~4095;
                        
                        /* Need to make new indexes... */
                        for (i=0; i < estate.e.elf32.e_shnum; i++)
                        {
                                if (shdr[i].sh_type == SHT_SYMTAB)
                                {
                                        int j;
                                        for (j=0; j < estate.e.elf32.e_phnum; j++)
                                        {
                                                /* Check only for loaded sections */
                                                if ((estate.p.phdr32[j].p_type | 0x80) == (PT_LOAD | 0x80))
                                                {
                                                        /* Only the extra symbols */
                                                        if ((shdr[i].sh_offset >= estate.p.phdr32[j].p_offset) &&
                                                                ((shdr[i].sh_offset + shdr[i].sh_size) <=
                                                                        (estate.p.phdr32[j].p_offset + estate.p.phdr32[j].p_filesz)))
                                                        {
                                                                shdr[i].sh_offset=0;
                                                                shdr[i].sh_size=0;
                                                                break;
                                                        }
                                                }
                                        }
                                        if ((shdr[i].sh_offset != 0) && (shdr[i].sh_size != 0))
                                        {
                                                symtabindex = i;
                                                symstrindex = shdr[i].sh_link;
                                        }
                                }
                        }
                }
                
                /* Check if we have a symbol table index and have not loaded it */
                if ((symtab_load == 0) && (symtabindex >= 0))
                {
                        /* No symbol table yet?  Load it first... */
                        
                        /* This happens to work out in a strange way.
                         * If we are past the point in the file already,
                         * we will skip a *large* number of bytes which
                         * ends up bringing us to the end of the file and
                         * an old (default) boot.  Less code and lets
                         * the state machine work in a cleaner way but this
                         * is a nasty side-effect trick... */
                        estate.skip = shdr[symtabindex].sh_offset - (estate.loc + offset);
                        
                        /* And we need to read this many bytes... */
                        estate.toread = shdr[symtabindex].sh_size;
                        
                        if (estate.toread)
                        {
#if ELF_DEBUG
                                printf("db sym, size %lX, curaddr %lX\n", 
                                        estate.toread, estate.curaddr);
#endif
                                /* Save where we are loading this... */
                                symtab_load = estate.curaddr;
                                
                                *((long *)phys_to_virt(estate.curaddr)) = estate.toread;
                                estate.curaddr += sizeof(long);
                                
                                /* Start to read... */
                                return 1;
                        }
                }
                else if ((symstr_load == 0) && (symstrindex >= 0))
                {
                        /* We have already loaded the symbol table, so
                         * now on to the symbol strings... */
                        
                        
                        /* Same nasty trick as above... */
                        estate.skip = shdr[symstrindex].sh_offset - (estate.loc + offset);
                        
                        /* And we need to read this many bytes... */
                        estate.toread = shdr[symstrindex].sh_size;
                        
                        if (estate.toread)
                        {
#if ELF_DEBUG
                                printf("db str, size %lX, curaddr %lX\n", 
                                        estate.toread, estate.curaddr);
#endif
                                /* Save where we are loading this... */
                                symstr_load = estate.curaddr;
                                
                                *((long *)phys_to_virt(estate.curaddr)) = estate.toread;
                                estate.curaddr += sizeof(long);
                                
                                /* Start to read... */
                                return 1;
                        }
                }
        }
        /* all done */
        return 0;
}

static void elf_freebsd_boot(unsigned long entry) 
{
        if (image_type != Elf_FreeBSD)
                return;

        memset(&bsdinfo, 0, sizeof(bsdinfo));
        bsdinfo.bi_basemem = meminfo.basememsize;
        bsdinfo.bi_extmem = meminfo.memsize;
        bsdinfo.bi_memsizes_valid = 1;
        bsdinfo.bi_version = BOOTINFO_VERSION;
        bsdinfo.bi_kernelname = virt_to_phys(KERNEL_BUF);
        bsdinfo.bi_nfs_diskless = NULL;
        bsdinfo.bi_size = sizeof(bsdinfo);
#define RB_BOOTINFO     0x80000000      /* have `struct bootinfo *' arg */  
        if(freebsd_kernel_env[0] != '\0'){
                freebsd_howto |= RB_BOOTINFO;
                bsdinfo.bi_envp = (unsigned long)freebsd_kernel_env;
        }
        
        /* Check if we have symbols loaded, and if so,
         * made the meta_data needed to pass those to
         * the kernel. */
        if ((symtab_load !=0) && (symstr_load != 0))
        {
                unsigned long *t;
                
                bsdinfo.bi_symtab = symtab_load;
                
                /* End of symbols (long aligned...) */
                /* Assumes size of long is a power of 2... */
                bsdinfo.bi_esymtab = (symstr_load +
                        sizeof(long) +
                        *((long *)phys_to_virt(symstr_load)) +
                        sizeof(long) - 1) & ~(sizeof(long) - 1);
                
                /* Where we will build the meta data... */
                t = phys_to_virt(bsdinfo.bi_esymtab);
                
#if ELF_DEBUG
                printf("Metadata at %lX\n",t);
#endif
                
                /* Set up the pointer to the memory... */
                bsdinfo.bi_modulep = virt_to_phys(t);
                
                /* The metadata structure is an array of 32-bit
                 * words where we store some information about the
                 * system.  This is critical, as FreeBSD now looks
                 * only for the metadata for the extended symbol
                 * information rather than in the bootinfo.
                 */
                /* First, do the kernel name and the kernel type */
                /* Note that this assumed x86 byte order... */
                
                /* 'kernel\0\0' */
                *t++=MODINFO_NAME; *t++= 7; *t++=0x6E72656B; *t++=0x00006C65;
                
                /* 'elf kernel\0\0' */
                *t++=MODINFO_TYPE; *t++=11; *t++=0x20666C65; *t++=0x6E72656B; *t++ = 0x00006C65;
                
                /* Now the symbol start/end - note that they are
                 * here in local/physical address - the Kernel
                 * boot process will relocate the addresses. */
                *t++=MODINFOMD_SSYM | MODINFO_METADATA; *t++=sizeof(*t); *t++=bsdinfo.bi_symtab;
                *t++=MODINFOMD_ESYM | MODINFO_METADATA; *t++=sizeof(*t); *t++=bsdinfo.bi_esymtab;
                
                *t++=MODINFO_END; *t++=0; /* end of metadata */
                
                /* Since we have symbols we need to make
                 * sure that the kernel knows its own end
                 * of memory...  It is not _end but after
                 * the symbols and the metadata... */
                bsdinfo.bi_kernend = virt_to_phys(t);
                
                /* Signal locore.s that we have a valid bootinfo
                 * structure that was completely filled in. */
                freebsd_howto |= 0x80000000;
        }
        
        xstart32(entry, freebsd_howto, NODEV, 0, 0, 0, 
                virt_to_phys(&bsdinfo), 0, 0, 0);
        longjmp(restart_etherboot, -2);
}
#endif

#ifdef AOUT_IMAGE
static void aout_freebsd_probe(void)
{
        image_type = Aout;
        if (((astate.head.a_midmag >> 16) & 0xffff) == 0) {
                /* Some other a.out variants have a different
                 * value, and use other alignments (e.g. 1K),
                 * not the 4K used by FreeBSD.  */
                image_type = Aout_FreeBSD;
                printf("/FreeBSD");
                off = -(astate.head.a_entry & 0xff000000);
                astate.head.a_entry += off;
        }
}

static void aout_freebsd_boot(void)
{
        if (image_type == Aout_FreeBSD) {
                memset(&bsdinfo, 0, sizeof(bsdinfo));
                bsdinfo.bi_basemem = meminfo.basememsize;
                bsdinfo.bi_extmem = meminfo.memsize;
                bsdinfo.bi_memsizes_valid = 1;
                bsdinfo.bi_version = BOOTINFO_VERSION;
                bsdinfo.bi_kernelname = virt_to_phys(KERNEL_BUF);
                bsdinfo.bi_nfs_diskless = NULL;
                bsdinfo.bi_size = sizeof(bsdinfo);
                xstart32(astate.head.a_entry, freebsd_howto, NODEV, 0, 0, 0, 
                        virt_to_phys(&bsdinfo), 0, 0, 0);
                longjmp(restart_etherboot, -2);
        }
}
#endif