LXR qemu/bsd-user/bsdload.c

   1/* Code for loading BSD executables.  Mostly linux kernel code.  */
   2
   3#include "qemu/osdep.h"
   4
   5#include "qemu.h"
   6
   7#define TARGET_NGROUPS 32
   8
   9/* ??? This should really be somewhere else.  */
  10abi_long memcpy_to_target(abi_ulong dest, const void *src,
  11                          unsigned long len)
  12{
  13    void *host_ptr;
  14
  15    host_ptr = lock_user(VERIFY_WRITE, dest, len, 0);
  16    if (!host_ptr) {
  17        return -TARGET_EFAULT;
  18    }
  19    memcpy(host_ptr, src, len);
  20    unlock_user(host_ptr, dest, 1);
  21    return 0;
  22}
  23
  24static int count(char **vec)
  25{
  26    int         i;
  27
  28    for (i = 0; *vec; i++) {
  29        vec++;
  30    }
  31
  32    return i;
  33}
  34
  35static int prepare_binprm(struct bsd_binprm *bprm)
  36{
  37    struct stat         st;
  38    int mode;
  39    int retval;
  40
  41    if (fstat(bprm->fd, &st) < 0) {
  42        return -errno;
  43    }
  44
  45    mode = st.st_mode;
  46    if (!S_ISREG(mode)) {        /* Must be regular file */
  47        return -EACCES;
  48    }
  49    if (!(mode & 0111)) {        /* Must have at least one execute bit set */
  50        return -EACCES;
  51    }
  52
  53    bprm->e_uid = geteuid();
  54    bprm->e_gid = getegid();
  55
  56    /* Set-uid? */
  57    if (mode & S_ISUID) {
  58        bprm->e_uid = st.st_uid;
  59    }
  60
  61    /* Set-gid? */
  62    /*
  63     * If setgid is set but no group execute bit then this
  64     * is a candidate for mandatory locking, not a setgid
  65     * executable.
  66     */
  67    if ((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP)) {
  68        bprm->e_gid = st.st_gid;
  69    }
  70
  71    memset(bprm->buf, 0, sizeof(bprm->buf));
  72    retval = lseek(bprm->fd, 0L, SEEK_SET);
  73    if (retval >= 0) {
  74        retval = read(bprm->fd, bprm->buf, 128);
  75    }
  76    if (retval < 0) {
  77        perror("prepare_binprm");
  78        exit(-1);
  79    } else {
  80        return retval;
  81    }
  82}
  83
  84/* Construct the envp and argv tables on the target stack.  */
  85abi_ulong loader_build_argptr(int envc, int argc, abi_ulong sp,
  86                              abi_ulong stringp, int push_ptr)
  87{
  88    int n = sizeof(abi_ulong);
  89    abi_ulong envp;
  90    abi_ulong argv;
  91
  92    sp -= (envc + 1) * n;
  93    envp = sp;
  94    sp -= (argc + 1) * n;
  95    argv = sp;
  96    if (push_ptr) {
  97        /* FIXME - handle put_user() failures */
  98        sp -= n;
  99        put_user_ual(envp, sp);
 100        sp -= n;
 101        put_user_ual(argv, sp);
 102    }
 103    sp -= n;
 104    /* FIXME - handle put_user() failures */
 105    put_user_ual(argc, sp);
 106
 107    while (argc-- > 0) {
 108        /* FIXME - handle put_user() failures */
 109        put_user_ual(stringp, argv);
 110        argv += n;
 111        stringp += target_strlen(stringp) + 1;
 112    }
 113    /* FIXME - handle put_user() failures */
 114    put_user_ual(0, argv);
 115    while (envc-- > 0) {
 116        /* FIXME - handle put_user() failures */
 117        put_user_ual(stringp, envp);
 118        envp += n;
 119        stringp += target_strlen(stringp) + 1;
 120    }
 121    /* FIXME - handle put_user() failures */
 122    put_user_ual(0, envp);
 123
 124    return sp;
 125}
 126
 127int loader_exec(const char *filename, char **argv, char **envp,
 128             struct target_pt_regs *regs, struct image_info *infop)
 129{
 130    struct bsd_binprm bprm;
 131    int retval;
 132    int i;
 133
 134    bprm.p = TARGET_PAGE_SIZE * MAX_ARG_PAGES - sizeof(unsigned int);
 135    for (i = 0 ; i < MAX_ARG_PAGES ; i++) {     /* clear page-table */
 136            bprm.page[i] = NULL;
 137    }
 138    retval = open(filename, O_RDONLY);
 139    if (retval < 0) {
 140        return retval;
 141    }
 142    bprm.fd = retval;
 143    bprm.filename = (char *)filename;
 144    bprm.argc = count(argv);
 145    bprm.argv = argv;
 146    bprm.envc = count(envp);
 147    bprm.envp = envp;
 148
 149    retval = prepare_binprm(&bprm);
 150
 151    if (retval >= 0) {
 152        if (bprm.buf[0] == 0x7f
 153                && bprm.buf[1] == 'E'
 154                && bprm.buf[2] == 'L'
 155                && bprm.buf[3] == 'F') {
 156            retval = load_elf_binary(&bprm, regs, infop);
 157        } else {
 158            fprintf(stderr, "Unknown binary format\n");
 159            return -1;
 160        }
 161    }
 162
 163    if (retval >= 0) {
 164        /* success.  Initialize important registers */
 165        do_init_thread(regs, infop);
 166        return retval;
 167    }
 168
 169    /* Something went wrong, return the inode and free the argument pages*/
 170    for (i = 0 ; i < MAX_ARG_PAGES ; i++) {
 171        g_free(bprm.page[i]);
 172    }
 173    return retval;
 174}
 175