xref: /qemu/target/mips/tcg/system/mips-semi.c (revision 8a2b516ba2855c4530388051de2b8d17bc780ea8)

/*
 * Unified Hosting Interface syscalls.
 *
 * Copyright (c) 2015 Imagination Technologies
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
 */

#include "qemu/osdep.h"
#include "cpu.h"
#include "qemu/log.h"
#include "gdbstub/syscalls.h"
#include "gdbstub/helpers.h"
#include "semihosting/uaccess.h"
#include "semihosting/semihost.h"
#include "semihosting/console.h"
#include "semihosting/syscalls.h"
#include "internal.h"

typedef enum UHIOp {
    UHI_exit = 1,
    UHI_open = 2,
    UHI_close = 3,
    UHI_read = 4,
    UHI_write = 5,
    UHI_lseek = 6,
    UHI_unlink = 7,
    UHI_fstat = 8,
    UHI_argc = 9,
    UHI_argnlen = 10,
    UHI_argn = 11,
    UHI_plog = 13,
    UHI_assert = 14,
    UHI_pread = 19,
    UHI_pwrite = 20,
    UHI_link = 22
} UHIOp;

typedef struct UHIStat {
    int16_t uhi_st_dev;
    uint16_t uhi_st_ino;
    uint32_t uhi_st_mode;
    uint16_t uhi_st_nlink;
    uint16_t uhi_st_uid;
    uint16_t uhi_st_gid;
    int16_t uhi_st_rdev;
    uint64_t uhi_st_size;
    uint64_t uhi_st_atime;
    uint64_t uhi_st_spare1;
    uint64_t uhi_st_mtime;
    uint64_t uhi_st_spare2;
    uint64_t uhi_st_ctime;
    uint64_t uhi_st_spare3;
    uint64_t uhi_st_blksize;
    uint64_t uhi_st_blocks;
    uint64_t uhi_st_spare4[2];
} UHIStat;

enum UHIOpenFlags {
    UHIOpen_RDONLY = 0x0,
    UHIOpen_WRONLY = 0x1,
    UHIOpen_RDWR   = 0x2,
    UHIOpen_APPEND = 0x8,
    UHIOpen_CREAT  = 0x200,
    UHIOpen_TRUNC  = 0x400,
    UHIOpen_EXCL   = 0x800
};

enum UHIErrno {
    UHI_EACCESS         = 13,
    UHI_EAGAIN          = 11,
    UHI_EBADF           = 9,
    UHI_EBADMSG         = 77,
    UHI_EBUSY           = 16,
    UHI_ECONNRESET      = 104,
    UHI_EEXIST          = 17,
    UHI_EFBIG           = 27,
    UHI_EINTR           = 4,
    UHI_EINVAL          = 22,
    UHI_EIO             = 5,
    UHI_EISDIR          = 21,
    UHI_ELOOP           = 92,
    UHI_EMFILE          = 24,
    UHI_EMLINK          = 31,
    UHI_ENAMETOOLONG    = 91,
    UHI_ENETDOWN        = 115,
    UHI_ENETUNREACH     = 114,
    UHI_ENFILE          = 23,
    UHI_ENOBUFS         = 105,
    UHI_ENOENT          = 2,
    UHI_ENOMEM          = 12,
    UHI_ENOSPC          = 28,
    UHI_ENOSR           = 63,
    UHI_ENOTCONN        = 128,
    UHI_ENOTDIR         = 20,
    UHI_ENXIO           = 6,
    UHI_EOVERFLOW       = 139,
    UHI_EPERM           = 1,
    UHI_EPIPE           = 32,
    UHI_ERANGE          = 34,
    UHI_EROFS           = 30,
    UHI_ESPIPE          = 29,
    UHI_ETIMEDOUT       = 116,
    UHI_ETXTBSY         = 26,
    UHI_EWOULDBLOCK     = 11,
    UHI_EXDEV           = 18,
};

static void report_fault(CPUMIPSState *env)
{
    int op = env->active_tc.gpr[25];
    error_report("Fault during UHI operation %d", op);
    abort();
}

static void uhi_cb(CPUState *cs, uint64_t ret, int err)
{
    CPUMIPSState *env = cpu_env(cs);

#define E(N) case E##N: err = UHI_E##N; break

    switch (err) {
    case 0:
        break;
    E(PERM);
    E(NOENT);
    E(INTR);
    E(BADF);
    E(BUSY);
    E(EXIST);
    E(NOTDIR);
    E(ISDIR);
    E(INVAL);
    E(NFILE);
    E(MFILE);
    E(FBIG);
    E(NOSPC);
    E(SPIPE);
    E(ROFS);
    E(NAMETOOLONG);
    default:
        err = UHI_EINVAL;
        break;
    case EFAULT:
        report_fault(env);
    }

#undef E

    env->active_tc.gpr[2] = ret;
    env->active_tc.gpr[3] = err;
}

static void uhi_fstat_cb(CPUState *cs, uint64_t ret, int err)
{
    QEMU_BUILD_BUG_ON(sizeof(UHIStat) < sizeof(struct gdb_stat));

    if (!err) {
        CPUMIPSState *env = cpu_env(cs);
        bool swap_needed = HOST_BIG_ENDIAN != mips_env_is_bigendian(env);
        target_ulong addr = env->active_tc.gpr[5];
        UHIStat *dst = lock_user(VERIFY_WRITE, addr, sizeof(UHIStat), 1);
        struct gdb_stat s;

        if (!dst) {
            report_fault(env);
        }

        memcpy(&s, dst, sizeof(struct gdb_stat));
        memset(dst, 0, sizeof(UHIStat));

        dst->uhi_st_dev = be32_to_cpu(s.gdb_st_dev);
        dst->uhi_st_ino = be32_to_cpu(s.gdb_st_ino);
        dst->uhi_st_mode = be32_to_cpu(s.gdb_st_mode);
        dst->uhi_st_nlink = be32_to_cpu(s.gdb_st_nlink);
        dst->uhi_st_uid = be32_to_cpu(s.gdb_st_uid);
        dst->uhi_st_gid = be32_to_cpu(s.gdb_st_gid);
        dst->uhi_st_rdev = be32_to_cpu(s.gdb_st_rdev);
        dst->uhi_st_size = be64_to_cpu(s.gdb_st_size);
        dst->uhi_st_atime = be32_to_cpu(s.gdb_st_atime);
        dst->uhi_st_mtime = be32_to_cpu(s.gdb_st_mtime);
        dst->uhi_st_ctime = be32_to_cpu(s.gdb_st_ctime);
        dst->uhi_st_blksize = be64_to_cpu(s.gdb_st_blksize);
        dst->uhi_st_blocks = be64_to_cpu(s.gdb_st_blocks);

        if (swap_needed) {
            dst->uhi_st_dev = bswap16(dst->uhi_st_dev);
            dst->uhi_st_ino = bswap16(dst->uhi_st_ino);
            dst->uhi_st_mode = bswap32(dst->uhi_st_mode);
            dst->uhi_st_nlink = bswap16(dst->uhi_st_nlink);
            dst->uhi_st_uid = bswap16(dst->uhi_st_uid);
            dst->uhi_st_gid = bswap16(dst->uhi_st_gid);
            dst->uhi_st_rdev = bswap16(dst->uhi_st_rdev);
            dst->uhi_st_size = bswap64(dst->uhi_st_size);
            dst->uhi_st_atime = bswap64(dst->uhi_st_atime);
            dst->uhi_st_mtime = bswap64(dst->uhi_st_mtime);
            dst->uhi_st_ctime = bswap64(dst->uhi_st_ctime);
            dst->uhi_st_blksize = bswap64(dst->uhi_st_blksize);
            dst->uhi_st_blocks = bswap64(dst->uhi_st_blocks);
        }

        unlock_user(dst, addr, sizeof(UHIStat));
    }

    uhi_cb(cs, ret, err);
}

void mips_semihosting(CPUMIPSState *env)
{
    CPUState *cs = env_cpu(env);
    target_ulong *gpr = env->active_tc.gpr;
    const UHIOp op = gpr[25];
    char *p;

    switch (op) {
    case UHI_exit:
        gdb_exit(gpr[4]);
        exit(gpr[4]);

    case UHI_open:
        {
            target_ulong fname = gpr[4];
            int ret = -1;

            p = lock_user_string(fname);
            if (!p) {
                report_fault(env);
            }
            if (!strcmp("/dev/stdin", p)) {
                ret = 0;
            } else if (!strcmp("/dev/stdout", p)) {
                ret = 1;
            } else if (!strcmp("/dev/stderr", p)) {
                ret = 2;
            }
            unlock_user(p, fname, 0);

            /* FIXME: reusing a guest fd doesn't seem correct. */
            if (ret >= 0) {
                gpr[2] = ret;
                break;
            }

            semihost_sys_open(cs, uhi_cb, fname, 0, gpr[5], gpr[6]);
        }
        break;

    case UHI_close:
        semihost_sys_close(cs, uhi_cb, gpr[4]);
        break;
    case UHI_read:
        semihost_sys_read(cs, uhi_cb, gpr[4], gpr[5], gpr[6]);
        break;
    case UHI_write:
        semihost_sys_write(cs, uhi_cb, gpr[4], gpr[5], gpr[6]);
        break;
    case UHI_lseek:
        semihost_sys_lseek(cs, uhi_cb, gpr[4], gpr[5], gpr[6]);
        break;
    case UHI_unlink:
        semihost_sys_remove(cs, uhi_cb, gpr[4], 0);
        break;
    case UHI_fstat:
        semihost_sys_fstat(cs, uhi_fstat_cb, gpr[4], gpr[5]);
        break;

    case UHI_argc:
        gpr[2] = semihosting_get_argc();
        break;
    case UHI_argnlen:
        {
            const char *s = semihosting_get_arg(gpr[4]);
            gpr[2] = s ? strlen(s) : -1;
        }
        break;
    case UHI_argn:
        {
            const char *s = semihosting_get_arg(gpr[4]);
            target_ulong addr;
            size_t len;

            if (!s) {
                gpr[2] = -1;
                break;
            }
            len = strlen(s) + 1;
            addr = gpr[5];
            p = lock_user(VERIFY_WRITE, addr, len, 0);
            if (!p) {
                report_fault(env);
            }
            memcpy(p, s, len);
            unlock_user(p, addr, len);
            gpr[2] = 0;
        }
        break;

    case UHI_plog:
        {
            target_ulong addr = gpr[4];
            ssize_t len = target_strlen(addr);
            GString *str;
            char *pct_d;

            if (len < 0) {
                report_fault(env);
            }
            p = lock_user(VERIFY_READ, addr, len, 1);
            if (!p) {
                report_fault(env);
            }

            pct_d = strstr(p, "%d");
            if (!pct_d) {
                unlock_user(p, addr, 0);
                semihost_sys_write(cs, uhi_cb, 2, addr, len);
                break;
            }

            str = g_string_new_len(p, pct_d - p);
            g_string_append_printf(str, "%d%s", (int)gpr[5], pct_d + 2);
            unlock_user(p, addr, 0);

            /*
             * When we're using gdb, we need a guest address, so
             * drop the string onto the stack below the stack pointer.
             */
            if (use_gdb_syscalls()) {
                addr = gpr[29] - str->len;
                p = lock_user(VERIFY_WRITE, addr, str->len, 0);
                if (!p) {
                    report_fault(env);
                }
                memcpy(p, str->str, str->len);
                unlock_user(p, addr, str->len);
                semihost_sys_write(cs, uhi_cb, 2, addr, str->len);
            } else {
                gpr[2] = qemu_semihosting_console_write(str->str, str->len);
            }
            g_string_free(str, true);
        }
        break;

    case UHI_assert:
        {
            const char *msg, *file;

            msg = lock_user_string(gpr[4]);
            if (!msg) {
                msg = "<EFAULT>";
            }
            file = lock_user_string(gpr[5]);
            if (!file) {
                file = "<EFAULT>";
            }

            error_report("UHI assertion \"%s\": file \"%s\", line %d",
                         msg, file, (int)gpr[6]);
            abort();
        }

    default:
        error_report("Unknown UHI operation %d", op);
        abort();
    }
}