bsd-user/freebsd/os-syscall.c

   1 /*
   2  *  BSD syscalls
   3  *
   4  *  Copyright (c) 2003-2008 Fabrice Bellard
   5  *  Copyright (c) 2013-2014 Stacey D. Son
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 /*
  22  * We need the FreeBSD "legacy" definitions. Rust needs the FreeBSD 11 system
  23  * calls since it doesn't use libc at all, so we have to emulate that despite
  24  * FreeBSD 11 being EOL'd.
  25  */
  26 #define _WANT_FREEBSD11_STAT
  27 #define _WANT_FREEBSD11_STATFS
  28 #define _WANT_FREEBSD11_DIRENT
  29 #define _WANT_KERNEL_ERRNO
  30 #define _WANT_SEMUN
  31 #include "qemu/osdep.h"
  32 #include "qemu/cutils.h"
  33 #include "qemu/path.h"
  34 #include <sys/syscall.h>
  35 #include <sys/param.h>
  36 #include <sys/sysctl.h>
  37 #include <utime.h>
  38
  39 #include "qemu.h"
  40 #include "signal-common.h"
  41 #include "user/syscall-trace.h"
  42
  43 #include "bsd-file.h"
  44
  45 void target_set_brk(abi_ulong new_brk)
  46 {
  47 }
  48
  49 /*
  50  * errno conversion.
  51  */
  52 abi_long get_errno(abi_long ret)
  53 {
  54     if (ret == -1) {
  55         return -host_to_target_errno(errno);
  56     } else {
  57         return ret;
  58     }
  59 }
  60
  61 int host_to_target_errno(int err)
  62 {
  63     /*
  64      * All the BSDs have the property that the error numbers are uniform across
  65      * all architectures for a given BSD, though they may vary between different
  66      * BSDs.
  67      */
  68     return err;
  69 }
  70
  71 bool is_error(abi_long ret)
  72 {
  73     return (abi_ulong)ret >= (abi_ulong)(-4096);
  74 }
  75
  76 /*
  77  * Unlocks a iovec. Unlike unlock_iovec, it assumes the tvec array itself is
  78  * already locked from target_addr. It will be unlocked as well as all the iovec
  79  * elements.
  80  */
  81 static void helper_unlock_iovec(struct target_iovec *target_vec,
  82                                 abi_ulong target_addr, struct iovec *vec,
  83                                 int count, int copy)
  84 {
  85     for (int i = 0; i < count; i++) {
  86         abi_ulong base = tswapal(target_vec[i].iov_base);
  87
  88         if (vec[i].iov_base) {
  89             unlock_user(vec[i].iov_base, base, copy ? vec[i].iov_len : 0);
  90         }
  91     }
  92     unlock_user(target_vec, target_addr, 0);
  93 }
  94
  95 struct iovec *lock_iovec(int type, abi_ulong target_addr,
  96         int count, int copy)
  97 {
  98     struct target_iovec *target_vec;
  99     struct iovec *vec;
 100     abi_ulong total_len, max_len;
 101     int i;
 102     int err = 0;
 103
 104     if (count == 0) {
 105         errno = 0;
 106         return NULL;
 107     }
 108     if (count < 0 || count > IOV_MAX) {
 109         errno = EINVAL;
 110         return NULL;
 111     }
 112
 113     vec = g_try_new0(struct iovec, count);
 114     if (vec == NULL) {
 115         errno = ENOMEM;
 116         return NULL;
 117     }
 118
 119     target_vec = lock_user(VERIFY_READ, target_addr,
 120                            count * sizeof(struct target_iovec), 1);
 121     if (target_vec == NULL) {
 122         err = EFAULT;
 123         goto fail2;
 124     }
 125
 126     max_len = 0x7fffffff & MIN(TARGET_PAGE_MASK, PAGE_MASK);
 127     total_len = 0;
 128
 129     for (i = 0; i < count; i++) {
 130         abi_ulong base = tswapal(target_vec[i].iov_base);
 131         abi_long len = tswapal(target_vec[i].iov_len);
 132
 133         if (len < 0) {
 134             err = EINVAL;
 135             goto fail;
 136         } else if (len == 0) {
 137             /* Zero length pointer is ignored. */
 138             vec[i].iov_base = 0;
 139         } else {
 140             vec[i].iov_base = lock_user(type, base, len, copy);
 141             /*
 142              * If the first buffer pointer is bad, this is a fault.  But
 143              * subsequent bad buffers will result in a partial write; this is
 144              * realized by filling the vector with null pointers and zero
 145              * lengths.
 146              */
 147             if (!vec[i].iov_base) {
 148                 if (i == 0) {
 149                     err = EFAULT;
 150                     goto fail;
 151                 } else {
 152                     /*
 153                      * Fail all the subsequent addresses, they are already
 154                      * zero'd.
 155                      */
 156                     goto out;
 157                 }
 158             }
 159             if (len > max_len - total_len) {
 160                 len = max_len - total_len;
 161             }
 162         }
 163         vec[i].iov_len = len;
 164         total_len += len;
 165     }
 166 out:
 167     unlock_user(target_vec, target_addr, 0);
 168     return vec;
 169
 170 fail:
 171     helper_unlock_iovec(target_vec, target_addr, vec, i, copy);
 172 fail2:
 173     g_free(vec);
 174     errno = err;
 175     return NULL;
 176 }
 177
 178 /*
 179  * do_syscall() should always have a single exit point at the end so that
 180  * actions, such as logging of syscall results, can be performed.  All errnos
 181  * that do_syscall() returns must be -TARGET_<errcode>.
 182  */
 183 abi_long do_freebsd_syscall(void *cpu_env, int num, abi_long arg1,
 184                             abi_long arg2, abi_long arg3, abi_long arg4,
 185                             abi_long arg5, abi_long arg6, abi_long arg7,
 186                             abi_long arg8)
 187 {
 188     return 0;
 189 }
 190
 191 void syscall_init(void)
 192 {
 193 }