/*      $NetBSD: exec_sub.c,v 1.6 2009/03/14 21:04:17 dsl Exp $ */

#include <sys/cdefs.h>

#include "execkern.h"
#include <a.out.h>
#include <sys/param.h>

#ifdef BOOT
void B_PRINT(const unsigned char *p);
#endif

static inline void bzero4(void *ptr, size_t siz);
static void xk_aout(struct execkern_arg *xarg, struct exec *hdr);
static void xk_elf(struct execkern_arg *xarg, Elf32_Ehdr *hdr);

#ifdef LOADBSD
static void DPRINT_SEC(const char *ident,
                           const struct execkern_section *sec);
extern int opt_v;
extern const char *kernel_fn;

static void
DPRINT_SEC(const char *ident, const struct execkern_section *sec)
{

       if (opt_v)
               xwarnx("section (%s): img %p, sz %d, pad %d", ident,
                       sec->sec_image, sec->sec_size, sec->sec_pad);
}

#define ERRX(arg)               xerrx arg

#else
#define DPRINT_SEC(ident, sec)  /**/
#define ERRX(arg)               return 1
#endif

/*
* This code is size-hacked version of
*
*      sec->sec_image = (image);
*      sec->sec_size = (size);
*      sec->sec_pad = (pad);
*      DPRINT_SEC((ident), sec);
*      sec++;
*/
#define SECTION(sec, ident, image, size, pad)   \
       do {                                    \
               u_long *wp = (void *) sec;      \
               *(void **)wp++ = (image);       \
               *wp++ = (size);                 \
               *wp++ = (pad);                  \
               DPRINT_SEC((ident), sec);       \
               sec = (void *) wp;              \
       } while (0)

#define SECTION_NOPAD(sec, ident, image, size)  \
               SECTION(sec, (ident), (image), (size), 0)

static inline void
bzero4(void *ptr, size_t siz)
{
       u_long *p;
       u_short s;

       p = ptr;
       s = siz >> 2;

       while (s--)
               *p++ = 0;
}

/*
* fill in loading information from an a.out executable
*/
static void
xk_aout(struct execkern_arg *xarg, struct exec *hdr)
{
       unsigned u;
       char *s;
       struct execkern_section *sec;

       xarg->entry_addr = hdr->a_entry;
       sec = xarg->sec;

       /* text section and padding between data section */
       s = (void *) (hdr + 1);
       SECTION(sec, "text", s, hdr->a_text, -hdr->a_text & (AOUT_LDPGSZ-1));

       /* data and bss sections */
       s += hdr->a_text;
       SECTION(sec, "data/bss", s, hdr->a_data, hdr->a_bss);

       /* size of symbol table */
       SECTION_NOPAD(sec, "symtab size", &sec[1].sec_size, sizeof(u_long));

       /* symbol table section */
       s += hdr->a_data;
       SECTION_NOPAD(sec, "symbol", s, u = hdr->a_syms);

       /* string table section */
       if (u) {
#ifdef LOADBSD
               if (opt_v)
                       xwarnx("symbol table found");
#endif
               s += u;
               SECTION_NOPAD(sec, "string", s, *(u_long *) s);
       }
}

/*
* fill in loading information from an ELF executable
*/
static void
xk_elf(struct execkern_arg *xarg, Elf32_Ehdr *hdr)
{
       char *top = (void *) hdr;
       struct execkern_section *sec;
       Elf32_Phdr *ph;
       Elf32_Shdr *sh, *sym, *str, *stab, *shstr;
       const char *shstrtab, *shname;
       unsigned u, dpos, pd;
       const char *const shstrtab_new = SHSTRTAB_FAKE;

       xarg->entry_addr = hdr->e_entry;

       /*
        * text, data, bss
        */
       ph = (void *) (top + hdr->e_phoff);
       xarg->load_addr = ph->p_vaddr;

       sec = xarg->sec;
       sec->sec_image = top + ph->p_offset;
       sec->sec_size = ph->p_filesz;

       if (hdr->e_phnum != 1) {
               sec->sec_pad = ph[1].p_vaddr - (ph->p_vaddr + ph->p_filesz);
               DPRINT_SEC("program (text)", sec);
               sec++;
               ph++;
               sec->sec_image = top + ph->p_offset;
               sec->sec_size = ph->p_filesz;
       }

       sec->sec_pad = ph->p_memsz - ph->p_filesz;
       DPRINT_SEC("program (data/bss)", sec);
       sec++;

       /*
        * symbol size
        */
       xarg->elfsymsiz = 0;            /* no symbol */
       SECTION_NOPAD(sec, "symtab size", &xarg->elfsymsiz, sizeof(int));

       /*
        * ELF header
        */
       xarg->ehdr = *hdr;
       xarg->ehdr.e_shstrndx = 0;      /* .shstrtab will be the 1st section */
       SECTION_NOPAD(sec, "ELF header", &xarg->ehdr, sizeof(Elf32_Ehdr));

       sh = (void *) (top + hdr->e_shoff);             /* section header */
       shstr = sh + hdr->e_shstrndx;                   /* .shstrtab */
       shstrtab = top + shstr->sh_offset;

       sym = str = stab = 0;
       for (u = 0; sh++, ++u < hdr->e_shnum; ) {
               shname = shstrtab + sh->sh_name;
               if (!strcmp(shname, shstrtab_new + SHNAME_OFF_SYMTAB))
                       sym = sh;                               /* .symtab */
               if (!strcmp(shname, shstrtab_new + SHNAME_OFF_STRTAB))
                       str = sh;                               /* .strtab */
               if (!strcmp(shname, shstrtab_new + SHNAME_OFF_STAB))
                       stab = sh;                              /* .stab */
       }

       if (shstr == 0 || sym == 0 || str == 0)
               xarg->ehdr.e_shnum = 0;         /* no symbol */
       else {
#ifdef LOADBSD
               if (opt_v) {
                       xwarnx("symbol table found");
                       if (stab)
                               xwarnx("debugging information found");
               }
#endif
               xarg->elfsymsiz = 1;            /* has symbol */
               xarg->ehdr.e_shnum = 3;
               xarg->ehdr.e_shoff = sizeof(Elf32_Ehdr);

               SECTION_NOPAD(sec, "section header (shstrtab)",
                               shstr, sizeof(Elf32_Shdr));

               SECTION_NOPAD(sec, "section header (symbol)",
                               sym, sizeof(Elf32_Shdr));

               SECTION_NOPAD(sec, "section header (string)",
                               str, sizeof(Elf32_Shdr));

               dpos = sizeof(Elf32_Ehdr) + sizeof(Elf32_Shdr) * 3;
               u = SIZE_SHSTRTAB_FAKE;

               if (stab) {
                       xarg->ehdr.e_shnum++;
                       SECTION_NOPAD(sec, "section header (stab)",
                                       stab, sizeof(Elf32_Shdr));
                       dpos += sizeof(Elf32_Shdr);
                       u = SIZE_SHSTRTAB_FAKE_WITH_STAB;
               }

               /* new .shstrtab section */
               memcpy(xarg->shstrtab_fake, shstrtab_new, u);
               /*
                * DDB requires symtab be aligned.
                */
               pd = -u & ALIGNBYTES;
               SECTION(sec, "shstrtab", &xarg->shstrtab_fake, u, pd);
               shstr->sh_name = SHNAME_OFF_SHSTRTAB;
               shstr->sh_offset = dpos;
               dpos += u + pd;

               SECTION_NOPAD(sec, "symtab",
                               top + sym->sh_offset, sym->sh_size);
               sym->sh_name = SHNAME_OFF_SYMTAB;
               sym->sh_offset = dpos;
               dpos += sym->sh_size;

               SECTION_NOPAD(sec, "strtab",
                               top + str->sh_offset, str->sh_size);
               str->sh_name = SHNAME_OFF_STRTAB;
               str->sh_offset = dpos;
               dpos += str->sh_size;

               if (stab) {
                       SECTION_NOPAD(sec, "stab",
                                       top + stab->sh_offset, stab->sh_size);
                       stab->sh_name = SHNAME_OFF_STAB;
                       stab->sh_offset = dpos;
               }
       }
}


int
xk_load(struct execkern_arg *xarg, void *buf, u_long loadaddr)
       /* loadaddr:     for a.out */
{
       struct exec *ahdr;
       Elf32_Ehdr *ehdr;
       unsigned u;

       /* Unused section entries should be cleared to zero. */
       bzero4(xarg->sec, sizeof xarg->sec);

       xarg->load_addr = loadaddr;

       /*
        * check exec header
        */
       ahdr = buf;
       ehdr = buf;

       if (N_GETMAGIC(*ahdr) == NMAGIC) {
               /*
                * this is an a.out
                */
#ifdef LOADBSD
               if (opt_v)
                       xwarnx("%s: is an a.out", kernel_fn);
#endif
#ifdef BOOT
B_PRINT("This is an a.out\r\n");
#endif

               if ((u = N_GETMID(*ahdr)) != MID_M68K)
                       ERRX((1, "%s: Wrong architecture (mid %u)",
                                       kernel_fn, u));

               /*
                * fill in loading information
                */
               xk_aout(xarg, ahdr);

       } else {

               /*
                * check ELF header
                */
               if (*(u_int32_t *)&ehdr->e_ident[EI_MAG0] !=
                       (ELFMAG0<<24 | ELFMAG1<<16 | ELFMAG2<<8 | ELFMAG3) ||
                   *(u_int16_t *)&ehdr->e_ident[EI_CLASS] !=
                       (ELFCLASS32 << 8 | ELFDATA2MSB))
                       ERRX((1, "%s: Not an NMAGIC a.out or a 32bit BE ELF",
                                       kernel_fn));

               /*
                * this is an ELF
                */
#ifdef LOADBSD
               if (opt_v)
                       xwarnx("%s: is an ELF", kernel_fn);
#endif
#ifdef BOOT
B_PRINT("This is an ELF\r\n");
#endif

               if (ehdr->e_ident[EI_VERSION] != EV_CURRENT ||
                   ehdr->e_version != EV_CURRENT)
                       ERRX((1, "%s: Unsupported ELF version", kernel_fn));

               if ((u = ehdr->e_machine) != EM_68K)
                       ERRX((1, "%s: Wrong architecture (mid %u)",
                                       kernel_fn, u));
               if (ehdr->e_type != ET_EXEC)
                       ERRX((1, "%s: Not an executable", kernel_fn));
               if ((u = ehdr->e_phnum) != 1 && u != 2)
                       ERRX((1, "%s: Wrong number (%u) of loading sections",
                                       kernel_fn, u));

               /*
                * fill in loading information
                */
               xk_elf(xarg, ehdr);
       }

       return 0;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.