Archipelago » qemu

/*

 *  Linux syscalls

 *  Copyright (c) 2003 Fabrice Bellard

 *

 *  This program is free software; you can redistribute it and/or modify

        return target_brk;

    if (new_brk < target_original_brk)

        return -ENOMEM;

    brk_page = HOST_PAGE_ALIGN(target_brk);

    /* If the new brk is less than this, set it and we're done... */

    /* We need to allocate more memory after the brk... */

    new_alloc_size = HOST_PAGE_ALIGN(new_brk - brk_page + 1);

                                        PROT_READ|PROT_WRITE,

                                        MAP_ANON|MAP_FIXED|MAP_PRIVATE, 0, 0));

    if (is_error(mapped_addr)) {

    }

}

                                         target_long *target_fds, int n)

{

#if !defined(BSWAP_NEEDED) && !defined(WORDS_BIGENDIAN)

#endif

}

                                      fd_set *fds, int n)

{

#if !defined(BSWAP_NEEDED) && !defined(WORDS_BIGENDIAN)

}

                      target_ulong efd_p, target_ulong target_tv)

{

    fd_set rfds, wfds, efds;

        target_efds = NULL;

        efds_ptr = NULL;

    }

    if (target_tv) {

        target_to_host_timeval(&tv, target_tv);

        tv_ptr = &tv;

        void *data = CMSG_DATA(cmsg);

        void *target_data = TARGET_CMSG_DATA(target_cmsg);

                  - TARGET_CMSG_ALIGN(sizeof (struct target_cmsghdr));

        space += CMSG_SPACE(len);

    msgh->msg_controllen = tswapl(space);

}

                          target_ulong optval, socklen_t optlen)

{

    int val, ret;

    switch(level) {

    case SOL_TCP:

        /* TCP options all take an 'int' value.  */

        if (optlen < sizeof(uint32_t))

            return -EINVAL;

        val = tget32(optval);

        ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val)));

        break;

    return ret;

}

                          target_ulong optval, target_ulong optlen)

{

    int len, lv, val, ret;

                    socklen_t addrlen)

{

    void *addr = alloca(addrlen);

    target_to_host_sockaddr(addr, target_addr, addrlen);

    return get_errno(bind(sockfd, addr, addrlen));

}

                    socklen_t addrlen)

{

    void *addr = alloca(addrlen);

    target_to_host_sockaddr(addr, target_addr, addrlen);

    return get_errno(connect(sockfd, addr, addrlen));

}

    msg.msg_controllen = 2 * tswapl(msgp->msg_controllen);

    msg.msg_control = alloca(msg.msg_controllen);

    msg.msg_flags = tswap32(msgp->msg_flags);

    count = tswapl(msgp->msg_iovlen);

    vec = alloca(count * sizeof(struct iovec));

    target_vec = tswapl(msgp->msg_iov);

    lock_iovec(vec, target_vec, count, send);

    msg.msg_iovlen = count;

    msg.msg_iov = vec;

    if (send) {

        target_to_host_cmsg(&msg, msgp);

        ret = get_errno(sendmsg(fd, &msg, flags));

            target_msg = tgetl(vptr + n);

            flags = tgetl(vptr + 2 * n);

                                 (num == SOCKOP_sendmsg));

        }

        break;

            break;

        raddr = ret;

	/* find out the length of the shared memory segment */

        ret = get_errno(shmctl(first, IPC_STAT, &shm_info));

        if (is_error(ret)) {

            /* can't get length, bail out */

{

    struct host_termios *host = dst;

    const struct target_termios *target = src;

        target_to_host_bitmask(tswap32(target->c_iflag), iflag_tbl);

        target_to_host_bitmask(tswap32(target->c_oflag), oflag_tbl);

        target_to_host_bitmask(tswap32(target->c_cflag), cflag_tbl);

        target_to_host_bitmask(tswap32(target->c_lflag), lflag_tbl);

    host->c_line = target->c_line;

}

static void host_to_target_termios (void *dst, const void *src)

{

    struct target_termios *target = dst;

    const struct host_termios *host = src;

        tswap32(host_to_target_bitmask(host->c_iflag, iflag_tbl));

        tswap32(host_to_target_bitmask(host->c_oflag, oflag_tbl));

        tswap32(host_to_target_bitmask(host->c_cflag, cflag_tbl));

        tswap32(host_to_target_bitmask(host->c_lflag, lflag_tbl));

    target->c_line = host->c_line;

    target->c_cc[TARGET_VINTR] = host->c_cc[VINTR];

    target->c_cc[TARGET_VQUIT] = host->c_cc[VQUIT];

    target->c_cc[TARGET_VERASE] = host->c_cc[VERASE];

}

/* XXX: add locking support */

                     target_ulong ptr, unsigned long bytecount, int oldmode)

{

    struct target_modify_ldt_ldt_s ldt_info;

    ldt_info.limit = tswap32(target_ldt_info->limit);

    ldt_info.flags = tswap32(target_ldt_info->flags);

    unlock_user_struct(target_ldt_info, ptr, 0);

    if (ldt_info.entry_number >= TARGET_LDT_ENTRIES)

        return -EINVAL;

    seg_32bit = ldt_info.flags & 1;

            goto install;

        }

    }

    entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) |

        (ldt_info.limit & 0x0ffff);

    entry_2 = (ldt_info.base_addr & 0xff000000) |

int do_modify_ldt(CPUX86State *env, int func, target_ulong ptr, unsigned long bytecount)

{

    int ret = -ENOSYS;

    switch (func) {

    case 0:

        ret = read_ldt(ptr, bytecount);

    TaskState *ts;

    uint8_t *new_stack;

    CPUState *new_env;

    if (flags & CLONE_VM) {

        ts = malloc(sizeof(TaskState) + NEW_STACK_SIZE);

        memset(ts, 0, sizeof(TaskState));

        if (!newsp)

            newsp = env->gpr[1];

        new_env->gpr[1] = newsp;

            int i;

            for (i = 7; i < 32; i++)

                new_env->gpr[i] = 0;

            unlock_user_struct(target_fl, arg, 1);

        }

        break;

    case TARGET_F_SETLK:

    case TARGET_F_SETLKW:

        lock_user_struct(target_fl, arg, 1);

        unlock_user_struct(target_fl, arg, 0);

        ret = fcntl(fd, cmd, &fl);

        break;

    case TARGET_F_GETLK64:

        lock_user_struct(target_fl64, arg, 1);

        fl64.l_type = tswap16(target_fl64->l_type) >> 1;

    const argtype *arg_type;

    int size;

#include "syscall_types.h"

#undef STRUCT

#undef STRUCT_SPECIAL

            TARGET_IOC_SIZEMASK) {

            arg_type = ie->arg_type;

            if (arg_type[0] != TYPE_PTR) {

                        ie->target_cmd);

                exit(1);

            }

            arg_type++;

            size = thunk_type_size(arg_type, 0);

                              ~(TARGET_IOC_SIZEMASK << TARGET_IOC_SIZESHIFT)) |

                (size << TARGET_IOC_SIZESHIFT);

        }

        /* automatic consistency check if same arch */

#if defined(__i386__) && defined(TARGET_I386)

        if (ie->target_cmd != ie->host_cmd) {

                    ie->target_cmd, ie->host_cmd);

        }

#endif

    unlock_user_struct(target_ts, target_addr, 1);

}

                long arg4, long arg5, long arg6)

{

    long ret;

    struct stat st;

    struct statfs stfs;

    void *p;

#ifdef DEBUG

    gemu_log("syscall %d", num);

#endif

        {

            int how = arg1;

            sigset_t set, oldset, *set_ptr;

            if (arg2) {

                switch(how) {

                case TARGET_SIG_BLOCK:

        {

            int how = arg1;

            sigset_t set, oldset, *set_ptr;

            if (arg2) {

                switch(how) {

                case TARGET_SIG_BLOCK:

            sigset_t set;

            struct timespec uts, *puts;

            siginfo_t uinfo;

            p = lock_user(arg1, sizeof(target_sigset_t), 1);

            target_to_host_sigset(&set, p);

            unlock_user(p, arg1, 0);

            int resource = arg1;

            struct target_rlimit *target_rlim;

            struct rlimit rlim;

            ret = get_errno(getrlimit(resource, &rlim));

            if (!is_error(ret)) {

                lock_user_struct(target_rlim, arg2, 0);

            v5 = tswapl(v[4]);

            v6 = tswapl(v[5]);

            unlock_user(v, arg1, 0);

                                        target_to_host_bitmask(v4, mmap_flags_tbl),

                                        v5, v6));

        }

#else

                                    arg5,

                                    arg6));

#endif

#else

#define MMAP_SHIFT TARGET_PAGE_BITS

#endif

                                    arg5,

                                    arg6 << MMAP_SHIFT));

        break;

    convert_statfs:

        if (!is_error(ret)) {

            struct target_statfs *target_stfs;

            lock_user_struct(target_stfs, arg2, 0);

            /* ??? put_user is probably wrong.  */

            put_user(stfs.f_type, &target_stfs->f_type);

    convert_statfs64:

        if (!is_error(ret)) {

            struct target_statfs64 *target_stfs;

            lock_user_struct(target_stfs, arg3, 0);

            /* ??? put_user is probably wrong.  */

            put_user(stfs.f_type, &target_stfs->f_type);

            if (arg2) {

                pvalue = &value;

                                       arg2);

                                       arg2 + sizeof(struct target_timeval));

            } else {

                pvalue = NULL;

    case TARGET_NR_getitimer:

        {

            struct itimerval value;

            ret = get_errno(getitimer(arg1, &value));

            if (!is_error(ret) && arg2) {

                host_to_target_timeval(arg2,

        /* no need to transcode because we use the linux syscall */

        {

            struct new_utsname * buf;

            lock_user_struct(buf, arg1, 0);

            ret = get_errno(sys_uname(buf));

            if (!is_error(ret)) {

	    dirp = malloc(count);

	    if (!dirp)

                return -ENOMEM;

            ret = get_errno(sys_getdents(arg1, dirp, count));

            if (!is_error(ret)) {

                struct dirent *de;

        break;

#ifdef TARGET_NR_setresuid

    case TARGET_NR_setresuid:

                                  low2highuid(arg3)));

        break;

#endif

#endif

#ifdef TARGET_NR_getresgid

    case TARGET_NR_setresgid:

                                  low2highgid(arg3)));

        break;

#endif

            uint32_t *target_grouplist;

            gid_t *grouplist;

            int i;

            grouplist = alloca(gidsetsize * sizeof(gid_t));

            target_grouplist = lock_user(arg2, gidsetsize * 4, 1);

            for(i = 0;i < gidsetsize; i++)