--- /dev/null
+/*
+ * memory management system conversion routines
+ *
+ * Copyright (c) 2013 Stacey D. Son
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+#include "qemu/osdep.h"
+#include "qemu.h"
+#include "qemu-bsd.h"
+
+struct bsd_shm_regions bsd_shm_regions[N_BSD_SHM_REGIONS];
+
+abi_ulong target_brk;
+abi_ulong initial_target_brk;
+
+void target_set_brk(abi_ulong new_brk)
+{
+ target_brk = TARGET_PAGE_ALIGN(new_brk);
+ initial_target_brk = target_brk;
+}
+
+void target_to_host_ipc_perm__locked(struct ipc_perm *host_ip,
+ struct target_ipc_perm *target_ip)
+{
+ __get_user(host_ip->cuid, &target_ip->cuid);
+ __get_user(host_ip->cgid, &target_ip->cgid);
+ __get_user(host_ip->uid, &target_ip->uid);
+ __get_user(host_ip->gid, &target_ip->gid);
+ __get_user(host_ip->mode, &target_ip->mode);
+ __get_user(host_ip->seq, &target_ip->seq);
+ __get_user(host_ip->key, &target_ip->key);
+}
+
+abi_long target_to_host_shmid_ds(struct shmid_ds *host_sd,
+ abi_ulong target_addr)
+{
+ struct target_shmid_ds *target_sd;
+
+ if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1)) {
+ return -TARGET_EFAULT;
+ }
+
+ target_to_host_ipc_perm__locked(&(host_sd->shm_perm),
+ &(target_sd->shm_perm));
+
+ __get_user(host_sd->shm_segsz, &target_sd->shm_segsz);
+ __get_user(host_sd->shm_lpid, &target_sd->shm_lpid);
+ __get_user(host_sd->shm_cpid, &target_sd->shm_cpid);
+ __get_user(host_sd->shm_nattch, &target_sd->shm_nattch);
+ __get_user(host_sd->shm_atime, &target_sd->shm_atime);
+ __get_user(host_sd->shm_dtime, &target_sd->shm_dtime);
+ __get_user(host_sd->shm_ctime, &target_sd->shm_ctime);
+ unlock_user_struct(target_sd, target_addr, 0);
+
+ return 0;
+}
+
+void host_to_target_ipc_perm__locked(struct target_ipc_perm *target_ip,
+ struct ipc_perm *host_ip)
+{
+ __put_user(host_ip->cuid, &target_ip->cuid);
+ __put_user(host_ip->cgid, &target_ip->cgid);
+ __put_user(host_ip->uid, &target_ip->uid);
+ __put_user(host_ip->gid, &target_ip->gid);
+ __put_user(host_ip->mode, &target_ip->mode);
+ __put_user(host_ip->seq, &target_ip->seq);
+ __put_user(host_ip->key, &target_ip->key);
+}
+
+abi_long host_to_target_shmid_ds(abi_ulong target_addr,
+ struct shmid_ds *host_sd)
+{
+ struct target_shmid_ds *target_sd;
+
+ if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0)) {
+ return -TARGET_EFAULT;
+ }
+
+ host_to_target_ipc_perm__locked(&(target_sd->shm_perm),
+ &(host_sd->shm_perm));
+
+ __put_user(host_sd->shm_segsz, &target_sd->shm_segsz);
+ __put_user(host_sd->shm_lpid, &target_sd->shm_lpid);
+ __put_user(host_sd->shm_cpid, &target_sd->shm_cpid);
+ __put_user(host_sd->shm_nattch, &target_sd->shm_nattch);
+ __put_user(host_sd->shm_atime, &target_sd->shm_atime);
+ __put_user(host_sd->shm_dtime, &target_sd->shm_dtime);
+ __put_user(host_sd->shm_ctime, &target_sd->shm_ctime);
+ unlock_user_struct(target_sd, target_addr, 1);
+
+ return 0;
+}
--- /dev/null
+/*
+ * memory management system call shims and definitions
+ *
+ * Copyright (c) 2013-15 Stacey D. Son
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * Copyright (c) 1982, 1986, 1993
+ * The Regents of the University of California. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef BSD_USER_BSD_MEM_H
+#define BSD_USER_BSD_MEM_H
+
+#include <sys/types.h>
+#include <sys/ipc.h>
+#include <sys/mman.h>
+#include <sys/shm.h>
+#include <fcntl.h>
+
+#include "qemu-bsd.h"
+
+extern struct bsd_shm_regions bsd_shm_regions[];
+extern abi_ulong target_brk;
+extern abi_ulong initial_target_brk;
+
+/* mmap(2) */
+static inline abi_long do_bsd_mmap(void *cpu_env, abi_long arg1, abi_long arg2,
+ abi_long arg3, abi_long arg4, abi_long arg5, abi_long arg6, abi_long arg7,
+ abi_long arg8)
+{
+ if (regpairs_aligned(cpu_env) != 0) {
+ arg6 = arg7;
+ arg7 = arg8;
+ }
+ return get_errno(target_mmap(arg1, arg2, arg3,
+ target_to_host_bitmask(arg4, mmap_flags_tbl),
+ arg5, target_arg64(arg6, arg7)));
+}
+
+/* munmap(2) */
+static inline abi_long do_bsd_munmap(abi_long arg1, abi_long arg2)
+{
+ return get_errno(target_munmap(arg1, arg2));
+}
+
+/* mprotect(2) */
+static inline abi_long do_bsd_mprotect(abi_long arg1, abi_long arg2,
+ abi_long arg3)
+{
+ return get_errno(target_mprotect(arg1, arg2, arg3));
+}
+
+/* msync(2) */
+static inline abi_long do_bsd_msync(abi_long addr, abi_long len, abi_long flags)
+{
+ if (!guest_range_valid_untagged(addr, len)) {
+ /* It seems odd, but POSIX wants this to be ENOMEM */
+ return -TARGET_ENOMEM;
+ }
+
+ return get_errno(msync(g2h_untagged(addr), len, flags));
+}
+
+/* mlock(2) */
+static inline abi_long do_bsd_mlock(abi_long arg1, abi_long arg2)
+{
+ if (!guest_range_valid_untagged(arg1, arg2)) {
+ return -TARGET_EINVAL;
+ }
+ return get_errno(mlock(g2h_untagged(arg1), arg2));
+}
+
+/* munlock(2) */
+static inline abi_long do_bsd_munlock(abi_long arg1, abi_long arg2)
+{
+ if (!guest_range_valid_untagged(arg1, arg2)) {
+ return -TARGET_EINVAL;
+ }
+ return get_errno(munlock(g2h_untagged(arg1), arg2));
+}
+
+/* mlockall(2) */
+static inline abi_long do_bsd_mlockall(abi_long arg1)
+{
+ return get_errno(mlockall(arg1));
+}
+
+/* munlockall(2) */
+static inline abi_long do_bsd_munlockall(void)
+{
+ return get_errno(munlockall());
+}
+
+/* madvise(2) */
+static inline abi_long do_bsd_madvise(abi_long arg1, abi_long arg2,
+ abi_long arg3)
+{
+ abi_ulong len;
+ int ret = 0;
+ abi_long start = arg1;
+ abi_long len_in = arg2;
+ abi_long advice = arg3;
+
+ if (start & ~TARGET_PAGE_MASK) {
+ return -TARGET_EINVAL;
+ }
+ if (len_in == 0) {
+ return 0;
+ }
+ len = TARGET_PAGE_ALIGN(len_in);
+ if (len == 0 || !guest_range_valid_untagged(start, len)) {
+ return -TARGET_EINVAL;
+ }
+
+ /*
+ * Most advice values are hints, so ignoring and returning success is ok.
+ *
+ * However, some advice values such as MADV_DONTNEED, are not hints and
+ * need to be emulated.
+ *
+ * A straight passthrough for those may not be safe because qemu sometimes
+ * turns private file-backed mappings into anonymous mappings.
+ * If all guest pages have PAGE_PASSTHROUGH set, mappings have the
+ * same semantics for the host as for the guest.
+ *
+ * MADV_DONTNEED is passed through, if possible.
+ * If passthrough isn't possible, we nevertheless (wrongly!) return
+ * success, which is broken but some userspace programs fail to work
+ * otherwise. Completely implementing such emulation is quite complicated
+ * though.
+ */
+ mmap_lock();
+ switch (advice) {
+ case MADV_DONTNEED:
+ if (page_check_range(start, len, PAGE_PASSTHROUGH)) {
+ ret = get_errno(madvise(g2h_untagged(start), len, advice));
+ if (ret == 0) {
+ page_reset_target_data(start, start + len - 1);
+ }
+ }
+ }
+ mmap_unlock();
+
+ return ret;
+}
+
+/* minherit(2) */
+static inline abi_long do_bsd_minherit(abi_long addr, abi_long len,
+ abi_long inherit)
+{
+ return get_errno(minherit(g2h_untagged(addr), len, inherit));
+}
+
+/* mincore(2) */
+static inline abi_long do_bsd_mincore(abi_ulong target_addr, abi_ulong len,
+ abi_ulong target_vec)
+{
+ abi_long ret;
+ void *p;
+ abi_ulong vec_len = DIV_ROUND_UP(len, TARGET_PAGE_SIZE);
+
+ if (!guest_range_valid_untagged(target_addr, len)
+ || !page_check_range(target_addr, len, PAGE_VALID)) {
+ return -TARGET_EFAULT;
+ }
+
+ p = lock_user(VERIFY_WRITE, target_vec, vec_len, 0);
+ if (p == NULL) {
+ return -TARGET_EFAULT;
+ }
+ ret = get_errno(mincore(g2h_untagged(target_addr), len, p));
+ unlock_user(p, target_vec, vec_len);
+
+ return ret;
+}
+
+/* do_brk() must return target values and target errnos. */
+static inline abi_long do_obreak(abi_ulong brk_val)
+{
+ abi_long mapped_addr;
+ abi_ulong new_brk;
+ abi_ulong old_brk;
+
+ /* brk pointers are always untagged */
+
+ /* do not allow to shrink below initial brk value */
+ if (brk_val < initial_target_brk) {
+ return target_brk;
+ }
+
+ new_brk = TARGET_PAGE_ALIGN(brk_val);
+ old_brk = TARGET_PAGE_ALIGN(target_brk);
+
+ /* new and old target_brk might be on the same page */
+ if (new_brk == old_brk) {
+ target_brk = brk_val;
+ return target_brk;
+ }
+
+ /* Release heap if necesary */
+ if (new_brk < old_brk) {
+ target_munmap(new_brk, old_brk - new_brk);
+
+ target_brk = brk_val;
+ return target_brk;
+ }
+
+ mapped_addr = target_mmap(old_brk, new_brk - old_brk,
+ PROT_READ | PROT_WRITE,
+ MAP_FIXED | MAP_EXCL | MAP_ANON | MAP_PRIVATE,
+ -1, 0);
+
+ if (mapped_addr == old_brk) {
+ target_brk = brk_val;
+ return target_brk;
+ }
+
+ /* For everything else, return the previous break. */
+ return target_brk;
+}
+
+/* shm_open(2) */
+static inline abi_long do_bsd_shm_open(abi_ulong arg1, abi_long arg2,
+ abi_long arg3)
+{
+ int ret;
+ void *p;
+
+ if (arg1 == (uintptr_t)SHM_ANON) {
+ p = SHM_ANON;
+ } else {
+ p = lock_user_string(arg1);
+ if (p == NULL) {
+ return -TARGET_EFAULT;
+ }
+ }
+ ret = get_errno(shm_open(p, target_to_host_bitmask(arg2, fcntl_flags_tbl),
+ arg3));
+
+ if (p != SHM_ANON) {
+ unlock_user(p, arg1, 0);
+ }
+
+ return ret;
+}
+
+/* shm_unlink(2) */
+static inline abi_long do_bsd_shm_unlink(abi_ulong arg1)
+{
+ int ret;
+ void *p;
+
+ p = lock_user_string(arg1);
+ if (p == NULL) {
+ return -TARGET_EFAULT;
+ }
+ ret = get_errno(shm_unlink(p)); /* XXX path(p)? */
+ unlock_user(p, arg1, 0);
+
+ return ret;
+}
+
+/* shmget(2) */
+static inline abi_long do_bsd_shmget(abi_long arg1, abi_ulong arg2,
+ abi_long arg3)
+{
+ return get_errno(shmget(arg1, arg2, arg3));
+}
+
+/* shmctl(2) */
+static inline abi_long do_bsd_shmctl(abi_long shmid, abi_long cmd,
+ abi_ulong buff)
+{
+ struct shmid_ds dsarg;
+ abi_long ret = -TARGET_EINVAL;
+
+ cmd &= 0xff;
+
+ switch (cmd) {
+ case IPC_STAT:
+ if (target_to_host_shmid_ds(&dsarg, buff)) {
+ return -TARGET_EFAULT;
+ }
+ ret = get_errno(shmctl(shmid, cmd, &dsarg));
+ if (host_to_target_shmid_ds(buff, &dsarg)) {
+ return -TARGET_EFAULT;
+ }
+ break;
+
+ case IPC_SET:
+ if (target_to_host_shmid_ds(&dsarg, buff)) {
+ return -TARGET_EFAULT;
+ }
+ ret = get_errno(shmctl(shmid, cmd, &dsarg));
+ break;
+
+ case IPC_RMID:
+ ret = get_errno(shmctl(shmid, cmd, NULL));
+ break;
+
+ default:
+ ret = -TARGET_EINVAL;
+ break;
+ }
+
+ return ret;
+}
+
+/* shmat(2) */
+static inline abi_long do_bsd_shmat(int shmid, abi_ulong shmaddr, int shmflg)
+{
+ abi_ulong raddr;
+ abi_long ret;
+ struct shmid_ds shm_info;
+
+ /* Find out the length of the shared memory segment. */
+ ret = get_errno(shmctl(shmid, IPC_STAT, &shm_info));
+ if (is_error(ret)) {
+ /* Can't get the length */
+ return ret;
+ }
+
+ if (!guest_range_valid_untagged(shmaddr, shm_info.shm_segsz)) {
+ return -TARGET_EINVAL;
+ }
+
+ WITH_MMAP_LOCK_GUARD() {
+ void *host_raddr;
+
+ if (shmaddr) {
+ host_raddr = shmat(shmid, (void *)g2h_untagged(shmaddr), shmflg);
+ } else {
+ abi_ulong mmap_start;
+
+ mmap_start = mmap_find_vma(0, shm_info.shm_segsz);
+
+ if (mmap_start == -1) {
+ return -TARGET_ENOMEM;
+ }
+ host_raddr = shmat(shmid, g2h_untagged(mmap_start),
+ shmflg | SHM_REMAP);
+ }
+
+ if (host_raddr == (void *)-1) {
+ return get_errno(-1);
+ }
+ raddr = h2g(host_raddr);
+
+ page_set_flags(raddr, raddr + shm_info.shm_segsz - 1,
+ PAGE_VALID | PAGE_RESET | PAGE_READ |
+ (shmflg & SHM_RDONLY ? 0 : PAGE_WRITE));
+
+ for (int i = 0; i < N_BSD_SHM_REGIONS; i++) {
+ if (bsd_shm_regions[i].start == 0) {
+ bsd_shm_regions[i].start = raddr;
+ bsd_shm_regions[i].size = shm_info.shm_segsz;
+ break;
+ }
+ }
+ }
+
+ return raddr;
+}
+
+/* shmdt(2) */
+static inline abi_long do_bsd_shmdt(abi_ulong shmaddr)
+{
+ abi_long ret;
+
+ WITH_MMAP_LOCK_GUARD() {
+ int i;
+
+ for (i = 0; i < N_BSD_SHM_REGIONS; ++i) {
+ if (bsd_shm_regions[i].start == shmaddr) {
+ break;
+ }
+ }
+
+ if (i == N_BSD_SHM_REGIONS) {
+ return -TARGET_EINVAL;
+ }
+
+ ret = get_errno(shmdt(g2h_untagged(shmaddr)));
+ if (ret == 0) {
+ abi_ulong size = bsd_shm_regions[i].size;
+
+ bsd_shm_regions[i].start = 0;
+ page_set_flags(shmaddr, shmaddr + size - 1, 0);
+ mmap_reserve(shmaddr, size);
+ }
+ }
+
+ return ret;
+}
+
+static inline abi_long do_bsd_vadvise(void)
+{
+ /* See sys_ovadvise() in vm_unix.c */
+ return -TARGET_EINVAL;
+}
+
+static inline abi_long do_bsd_sbrk(void)
+{
+ /* see sys_sbrk() in vm_mmap.c */
+ return -TARGET_EOPNOTSUPP;
+}
+
+static inline abi_long do_bsd_sstk(void)
+{
+ /* see sys_sstk() in vm_mmap.c */
+ return -TARGET_EOPNOTSUPP;
+}
+
+#endif /* BSD_USER_BSD_MEM_H */
--- /dev/null
+/*
+ * BSD process related system call helpers
+ *
+ * Copyright (c) 2013-14 Stacey D. Son
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+#include "qemu/osdep.h"
+
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/cpuset.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+
+#include "qemu.h"
+#include "qemu-bsd.h"
+#include "signal-common.h"
+
+#include "bsd-proc.h"
+
+/*
+ * resource/rusage conversion
+ */
+int target_to_host_resource(int code)
+{
+ return code;
+}
+
+rlim_t target_to_host_rlim(abi_llong target_rlim)
+{
+ return tswap64(target_rlim);
+}
+
+abi_llong host_to_target_rlim(rlim_t rlim)
+{
+ return tswap64(rlim);
+}
+
+void h2g_rusage(const struct rusage *rusage,
+ struct target_freebsd_rusage *target_rusage)
+{
+ __put_user(rusage->ru_utime.tv_sec, &target_rusage->ru_utime.tv_sec);
+ __put_user(rusage->ru_utime.tv_usec, &target_rusage->ru_utime.tv_usec);
+
+ __put_user(rusage->ru_stime.tv_sec, &target_rusage->ru_stime.tv_sec);
+ __put_user(rusage->ru_stime.tv_usec, &target_rusage->ru_stime.tv_usec);
+
+ __put_user(rusage->ru_maxrss, &target_rusage->ru_maxrss);
+ __put_user(rusage->ru_idrss, &target_rusage->ru_idrss);
+ __put_user(rusage->ru_idrss, &target_rusage->ru_idrss);
+ __put_user(rusage->ru_isrss, &target_rusage->ru_isrss);
+ __put_user(rusage->ru_minflt, &target_rusage->ru_minflt);
+ __put_user(rusage->ru_majflt, &target_rusage->ru_majflt);
+ __put_user(rusage->ru_nswap, &target_rusage->ru_nswap);
+ __put_user(rusage->ru_inblock, &target_rusage->ru_inblock);
+ __put_user(rusage->ru_oublock, &target_rusage->ru_oublock);
+ __put_user(rusage->ru_msgsnd, &target_rusage->ru_msgsnd);
+ __put_user(rusage->ru_msgrcv, &target_rusage->ru_msgrcv);
+ __put_user(rusage->ru_nsignals, &target_rusage->ru_nsignals);
+ __put_user(rusage->ru_nvcsw, &target_rusage->ru_nvcsw);
+ __put_user(rusage->ru_nivcsw, &target_rusage->ru_nivcsw);
+}
+
+abi_long host_to_target_rusage(abi_ulong target_addr,
+ const struct rusage *rusage)
+{
+ struct target_freebsd_rusage *target_rusage;
+
+ if (!lock_user_struct(VERIFY_WRITE, target_rusage, target_addr, 0)) {
+ return -TARGET_EFAULT;
+ }
+ h2g_rusage(rusage, target_rusage);
+ unlock_user_struct(target_rusage, target_addr, 1);
+
+ return 0;
+}
+
+abi_long host_to_target_wrusage(abi_ulong target_addr,
+ const struct __wrusage *wrusage)
+{
+ struct target_freebsd__wrusage *target_wrusage;
+
+ if (!lock_user_struct(VERIFY_WRITE, target_wrusage, target_addr, 0)) {
+ return -TARGET_EFAULT;
+ }
+ h2g_rusage(&wrusage->wru_self, &target_wrusage->wru_self);
+ h2g_rusage(&wrusage->wru_children, &target_wrusage->wru_children);
+ unlock_user_struct(target_wrusage, target_addr, 1);
+
+ return 0;
+}
+
+/*
+ * wait status conversion.
+ *
+ * Map host to target signal numbers for the wait family of syscalls.
+ * Assume all other status bits are the same.
+ */
+int host_to_target_waitstatus(int status)
+{
+ if (WIFSIGNALED(status)) {
+ return host_to_target_signal(WTERMSIG(status)) | (status & ~0x7f);
+ }
+ if (WIFSTOPPED(status)) {
+ return (host_to_target_signal(WSTOPSIG(status)) << 8) | (status & 0xff);
+ }
+ return status;
+}
+
+int bsd_get_ncpu(void)
+{
+ int ncpu = -1;
+ cpuset_t mask;
+
+ CPU_ZERO(&mask);
+
+ if (cpuset_getaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID, -1, sizeof(mask),
+ &mask) == 0) {
+ ncpu = CPU_COUNT(&mask);
+ }
+
+ if (ncpu == -1) {
+ ncpu = sysconf(_SC_NPROCESSORS_ONLN);
+ }
+
+ if (ncpu == -1) {
+ gemu_log("XXX Missing bsd_get_ncpu() implementation\n");
+ ncpu = 1;
+ }
+
+ return ncpu;
+}
+
#include <sys/resource.h>
+#include "qemu-bsd.h"
+#include "gdbstub/syscalls.h"
+#include "qemu/plugin.h"
+
+extern int _getlogin(char*, int);
+int bsd_get_ncpu(void);
+
/* exit(2) */
static inline abi_long do_bsd_exit(void *cpu_env, abi_long arg1)
{
return 0;
}
+/* getgroups(2) */
+static inline abi_long do_bsd_getgroups(abi_long gidsetsize, abi_long arg2)
+{
+ abi_long ret;
+ uint32_t *target_grouplist;
+ g_autofree gid_t *grouplist;
+ int i;
+
+ grouplist = g_try_new(gid_t, gidsetsize);
+ ret = get_errno(getgroups(gidsetsize, grouplist));
+ if (gidsetsize != 0) {
+ if (!is_error(ret)) {
+ target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 2, 0);
+ if (!target_grouplist) {
+ return -TARGET_EFAULT;
+ }
+ for (i = 0; i < ret; i++) {
+ target_grouplist[i] = tswap32(grouplist[i]);
+ }
+ unlock_user(target_grouplist, arg2, gidsetsize * 2);
+ }
+ }
+ return ret;
+}
+
+/* setgroups(2) */
+static inline abi_long do_bsd_setgroups(abi_long gidsetsize, abi_long arg2)
+{
+ uint32_t *target_grouplist;
+ g_autofree gid_t *grouplist;
+ int i;
+
+ grouplist = g_try_new(gid_t, gidsetsize);
+ target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 2, 1);
+ if (!target_grouplist) {
+ return -TARGET_EFAULT;
+ }
+ for (i = 0; i < gidsetsize; i++) {
+ grouplist[i] = tswap32(target_grouplist[i]);
+ }
+ unlock_user(target_grouplist, arg2, 0);
+ return get_errno(setgroups(gidsetsize, grouplist));
+}
+
+/* umask(2) */
+static inline abi_long do_bsd_umask(abi_long arg1)
+{
+ return get_errno(umask(arg1));
+}
+
+/* setlogin(2) */
+static inline abi_long do_bsd_setlogin(abi_long arg1)
+{
+ abi_long ret;
+ void *p;
+
+ p = lock_user_string(arg1);
+ if (p == NULL) {
+ return -TARGET_EFAULT;
+ }
+ ret = get_errno(setlogin(p));
+ unlock_user(p, arg1, 0);
+
+ return ret;
+}
+
+/* getlogin(2) */
+static inline abi_long do_bsd_getlogin(abi_long arg1, abi_long arg2)
+{
+ abi_long ret;
+ void *p;
+
+ p = lock_user(VERIFY_WRITE, arg1, arg2, 0);
+ if (p == NULL) {
+ return -TARGET_EFAULT;
+ }
+ ret = get_errno(_getlogin(p, arg2));
+ unlock_user(p, arg1, arg2);
+
+ return ret;
+}
+
+/* getrusage(2) */
+static inline abi_long do_bsd_getrusage(abi_long who, abi_ulong target_addr)
+{
+ abi_long ret;
+ struct rusage rusage;
+
+ ret = get_errno(getrusage(who, &rusage));
+ if (!is_error(ret)) {
+ host_to_target_rusage(target_addr, &rusage);
+ }
+ return ret;
+}
+
+/* getrlimit(2) */
+static inline abi_long do_bsd_getrlimit(abi_long arg1, abi_ulong arg2)
+{
+ abi_long ret;
+ int resource = target_to_host_resource(arg1);
+ struct target_rlimit *target_rlim;
+ struct rlimit rlim;
+
+ switch (resource) {
+ case RLIMIT_STACK:
+ rlim.rlim_cur = target_dflssiz;
+ rlim.rlim_max = target_maxssiz;
+ ret = 0;
+ break;
+
+ case RLIMIT_DATA:
+ rlim.rlim_cur = target_dfldsiz;
+ rlim.rlim_max = target_maxdsiz;
+ ret = 0;
+ break;
+
+ default:
+ ret = get_errno(getrlimit(resource, &rlim));
+ break;
+ }
+ if (!is_error(ret)) {
+ if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0)) {
+ return -TARGET_EFAULT;
+ }
+ target_rlim->rlim_cur = host_to_target_rlim(rlim.rlim_cur);
+ target_rlim->rlim_max = host_to_target_rlim(rlim.rlim_max);
+ unlock_user_struct(target_rlim, arg2, 1);
+ }
+ return ret;
+}
+
+/* setrlimit(2) */
+static inline abi_long do_bsd_setrlimit(abi_long arg1, abi_ulong arg2)
+{
+ abi_long ret;
+ int resource = target_to_host_resource(arg1);
+ struct target_rlimit *target_rlim;
+ struct rlimit rlim;
+
+ if (RLIMIT_STACK == resource) {
+ /* XXX We should, maybe, allow the stack size to shrink */
+ ret = -TARGET_EPERM;
+ } else {
+ if (!lock_user_struct(VERIFY_READ, target_rlim, arg2, 1)) {
+ return -TARGET_EFAULT;
+ }
+ rlim.rlim_cur = target_to_host_rlim(target_rlim->rlim_cur);
+ rlim.rlim_max = target_to_host_rlim(target_rlim->rlim_max);
+ unlock_user_struct(target_rlim, arg2, 0);
+ ret = get_errno(setrlimit(resource, &rlim));
+ }
+ return ret;
+}
+
+/* getpid(2) */
+static inline abi_long do_bsd_getpid(void)
+{
+ return get_errno(getpid());
+}
+
+/* getppid(2) */
+static inline abi_long do_bsd_getppid(void)
+{
+ return get_errno(getppid());
+}
+
+/* getuid(2) */
+static inline abi_long do_bsd_getuid(void)
+{
+ return get_errno(getuid());
+}
+
+/* geteuid(2) */
+static inline abi_long do_bsd_geteuid(void)
+{
+ return get_errno(geteuid());
+}
+
+/* getgid(2) */
+static inline abi_long do_bsd_getgid(void)
+{
+ return get_errno(getgid());
+}
+
+/* getegid(2) */
+static inline abi_long do_bsd_getegid(void)
+{
+ return get_errno(getegid());
+}
+
+/* setuid(2) */
+static inline abi_long do_bsd_setuid(abi_long arg1)
+{
+ return get_errno(setuid(arg1));
+}
+
+/* seteuid(2) */
+static inline abi_long do_bsd_seteuid(abi_long arg1)
+{
+ return get_errno(seteuid(arg1));
+}
+
+/* setgid(2) */
+static inline abi_long do_bsd_setgid(abi_long arg1)
+{
+ return get_errno(setgid(arg1));
+}
+
+/* setegid(2) */
+static inline abi_long do_bsd_setegid(abi_long arg1)
+{
+ return get_errno(setegid(arg1));
+}
+
+/* getpgid(2) */
+static inline abi_long do_bsd_getpgid(pid_t pid)
+{
+ return get_errno(getpgid(pid));
+}
+
+/* setpgid(2) */
+static inline abi_long do_bsd_setpgid(int pid, int pgrp)
+{
+ return get_errno(setpgid(pid, pgrp));
+}
+
+/* getpgrp(2) */
+static inline abi_long do_bsd_getpgrp(void)
+{
+ return get_errno(getpgrp());
+}
+
+/* setreuid(2) */
+static inline abi_long do_bsd_setreuid(abi_long arg1, abi_long arg2)
+{
+ return get_errno(setreuid(arg1, arg2));
+}
+
+/* setregid(2) */
+static inline abi_long do_bsd_setregid(abi_long arg1, abi_long arg2)
+{
+ return get_errno(setregid(arg1, arg2));
+}
+
+/* setresgid(2) */
+static inline abi_long do_bsd_setresgid(gid_t rgid, gid_t egid, gid_t sgid)
+{
+ return get_errno(setresgid(rgid, egid, sgid));
+}
+
+/* setresuid(2) */
+static inline abi_long do_bsd_setresuid(uid_t ruid, uid_t euid, uid_t suid)
+{
+ return get_errno(setresuid(ruid, euid, suid));
+}
+
+/* getresuid(2) */
+static inline abi_long do_bsd_getresuid(abi_ulong arg1, abi_ulong arg2,
+ abi_ulong arg3)
+{
+ abi_long ret;
+ uid_t ruid, euid, suid;
+
+ ret = get_errno(getresuid(&ruid, &euid, &suid));
+ if (is_error(ret)) {
+ return ret;
+ }
+ if (put_user_s32(ruid, arg1)) {
+ return -TARGET_EFAULT;
+ }
+ if (put_user_s32(euid, arg2)) {
+ return -TARGET_EFAULT;
+ }
+ if (put_user_s32(suid, arg3)) {
+ return -TARGET_EFAULT;
+ }
+ return ret;
+}
+
+/* getresgid(2) */
+static inline abi_long do_bsd_getresgid(abi_ulong arg1, abi_ulong arg2,
+ abi_ulong arg3)
+{
+ abi_long ret;
+ uid_t ruid, euid, suid;
+
+ ret = get_errno(getresgid(&ruid, &euid, &suid));
+ if (is_error(ret)) {
+ return ret;
+ }
+ if (put_user_s32(ruid, arg1)) {
+ return -TARGET_EFAULT;
+ }
+ if (put_user_s32(euid, arg2)) {
+ return -TARGET_EFAULT;
+ }
+ if (put_user_s32(suid, arg3)) {
+ return -TARGET_EFAULT;
+ }
+ return ret;
+}
+
+/* getsid(2) */
+static inline abi_long do_bsd_getsid(abi_long arg1)
+{
+ return get_errno(getsid(arg1));
+}
+
+/* setsid(2) */
+static inline abi_long do_bsd_setsid(void)
+{
+ return get_errno(setsid());
+}
+
+/* issetugid(2) */
+static inline abi_long do_bsd_issetugid(void)
+{
+ return get_errno(issetugid());
+}
+
+/* profil(2) */
+static inline abi_long do_bsd_profil(abi_long arg1, abi_long arg2,
+ abi_long arg3, abi_long arg4)
+{
+ return -TARGET_ENOSYS;
+}
+
+/* ktrace(2) */
+static inline abi_long do_bsd_ktrace(abi_long arg1, abi_long arg2,
+ abi_long arg3, abi_long arg4)
+{
+ return -TARGET_ENOSYS;
+}
+
+/* utrace(2) */
+static inline abi_long do_bsd_utrace(abi_long arg1, abi_long arg2)
+{
+ return -TARGET_ENOSYS;
+}
+
+
+/* ptrace(2) */
+static inline abi_long do_bsd_ptrace(abi_long arg1, abi_long arg2,
+ abi_long arg3, abi_long arg4)
+{
+ return -TARGET_ENOSYS;
+}
+
+/* getpriority(2) */
+static inline abi_long do_bsd_getpriority(abi_long which, abi_long who)
+{
+ abi_long ret;
+ /*
+ * Note that negative values are valid for getpriority, so we must
+ * differentiate based on errno settings.
+ */
+ errno = 0;
+ ret = getpriority(which, who);
+ if (ret == -1 && errno != 0) {
+ return -host_to_target_errno(errno);
+ }
+
+ return ret;
+}
+
+/* setpriority(2) */
+static inline abi_long do_bsd_setpriority(abi_long which, abi_long who,
+ abi_long prio)
+{
+ return get_errno(setpriority(which, who, prio));
+}
+
#endif /* !BSD_PROC_H_ */
bsd_user_ss.add(files(
'os-stat.c',
+ 'os-proc.c',
'os-sys.c',
'os-syscall.c',
))
--- /dev/null
+/*
+ * miscellaneous FreeBSD system call shims
+ *
+ * Copyright (c) 2013-14 Stacey D. Son
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef OS_MISC_H
+#define OS_MISC_H
+
+#include <sys/cpuset.h>
+#include <sys/random.h>
+#include <sched.h>
+
+/*
+ * shm_open2 isn't exported, but the __sys_ alias is. We can use either for the
+ * static version, but to dynamically link we have to use the sys version.
+ */
+int __sys_shm_open2(const char *path, int flags, mode_t mode, int shmflags,
+ const char *);
+
+#if defined(__FreeBSD_version) && __FreeBSD_version >= 1300048
+/* shm_open2(2) */
+static inline abi_long do_freebsd_shm_open2(abi_ulong pathptr, abi_ulong flags,
+ abi_long mode, abi_ulong shmflags, abi_ulong nameptr)
+{
+ int ret;
+ void *uname, *upath;
+
+ if (pathptr == (uintptr_t)SHM_ANON) {
+ upath = SHM_ANON;
+ } else {
+ upath = lock_user_string(pathptr);
+ if (upath == NULL) {
+ return -TARGET_EFAULT;
+ }
+ }
+
+ uname = NULL;
+ if (nameptr != 0) {
+ uname = lock_user_string(nameptr);
+ if (uname == NULL) {
+ unlock_user(upath, pathptr, 0);
+ return -TARGET_EFAULT;
+ }
+ }
+ ret = get_errno(__sys_shm_open2(upath,
+ target_to_host_bitmask(flags, fcntl_flags_tbl), mode,
+ target_to_host_bitmask(shmflags, shmflag_flags_tbl), uname));
+
+ if (upath != SHM_ANON) {
+ unlock_user(upath, pathptr, 0);
+ }
+ if (uname != NULL) {
+ unlock_user(uname, nameptr, 0);
+ }
+ return ret;
+}
+#endif /* __FreeBSD_version >= 1300048 */
+
+#if defined(__FreeBSD_version) && __FreeBSD_version >= 1300049
+/* shm_rename(2) */
+static inline abi_long do_freebsd_shm_rename(abi_ulong fromptr, abi_ulong toptr,
+ abi_ulong flags)
+{
+ int ret;
+ void *ufrom, *uto;
+
+ ufrom = lock_user_string(fromptr);
+ if (ufrom == NULL) {
+ return -TARGET_EFAULT;
+ }
+ uto = lock_user_string(toptr);
+ if (uto == NULL) {
+ unlock_user(ufrom, fromptr, 0);
+ return -TARGET_EFAULT;
+ }
+ ret = get_errno(shm_rename(ufrom, uto, flags));
+ unlock_user(ufrom, fromptr, 0);
+ unlock_user(uto, toptr, 0);
+
+ return ret;
+}
+#endif /* __FreeBSD_version >= 1300049 */
+
+#endif /* OS_MISC_H */
--- /dev/null
+/*
+ * FreeBSD process related emulation code
+ *
+ * Copyright (c) 2013-15 Stacey D. Son
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+#include "qemu/osdep.h"
+
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/sysctl.h>
+struct kinfo_proc;
+#include <libprocstat.h>
+
+#include "qemu.h"
+
+/*
+ * Get the filename for the given file descriptor.
+ * Note that this may return NULL (fail) if no longer cached in the kernel.
+ */
+static char *
+get_filename_from_fd(pid_t pid, int fd, char *filename, size_t len)
+{
+ char *ret = NULL;
+ unsigned int cnt;
+ struct procstat *procstat = NULL;
+ struct kinfo_proc *kp = NULL;
+ struct filestat_list *head = NULL;
+ struct filestat *fst;
+
+ procstat = procstat_open_sysctl();
+ if (procstat == NULL) {
+ goto out;
+ }
+
+ kp = procstat_getprocs(procstat, KERN_PROC_PID, pid, &cnt);
+ if (kp == NULL) {
+ goto out;
+ }
+
+ head = procstat_getfiles(procstat, kp, 0);
+ if (head == NULL) {
+ goto out;
+ }
+
+ STAILQ_FOREACH(fst, head, next) {
+ if (fd == fst->fs_fd) {
+ if (fst->fs_path != NULL) {
+ (void)strlcpy(filename, fst->fs_path, len);
+ ret = filename;
+ }
+ break;
+ }
+ }
+
+out:
+ if (head != NULL) {
+ procstat_freefiles(procstat, head);
+ }
+ if (kp != NULL) {
+ procstat_freeprocs(procstat, kp);
+ }
+ if (procstat != NULL) {
+ procstat_close(procstat);
+ }
+ return ret;
+}
+
+/*
+ * execve/fexecve
+ */
+abi_long freebsd_exec_common(abi_ulong path_or_fd, abi_ulong guest_argp,
+ abi_ulong guest_envp, int do_fexec)
+{
+ char **argp, **envp, **qargp, **qarg1, **qarg0, **qargend;
+ int argc, envc;
+ abi_ulong gp;
+ abi_ulong addr;
+ char **q;
+ int total_size = 0;
+ void *p;
+ abi_long ret;
+
+ argc = 0;
+ for (gp = guest_argp; gp; gp += sizeof(abi_ulong)) {
+ if (get_user_ual(addr, gp)) {
+ return -TARGET_EFAULT;
+ }
+ if (!addr) {
+ break;
+ }
+ argc++;
+ }
+ envc = 0;
+ for (gp = guest_envp; gp; gp += sizeof(abi_ulong)) {
+ if (get_user_ual(addr, gp)) {
+ return -TARGET_EFAULT;
+ }
+ if (!addr) {
+ break;
+ }
+ envc++;
+ }
+
+ qarg0 = argp = g_new0(char *, argc + 9);
+ /* save the first agrument for the emulator */
+ *argp++ = (char *)getprogname();
+ qargp = argp;
+ *argp++ = (char *)getprogname();
+ qarg1 = argp;
+ envp = g_new0(char *, envc + 1);
+ for (gp = guest_argp, q = argp; gp; gp += sizeof(abi_ulong), q++) {
+ if (get_user_ual(addr, gp)) {
+ ret = -TARGET_EFAULT;
+ goto execve_end;
+ }
+ if (!addr) {
+ break;
+ }
+ *q = lock_user_string(addr);
+ if (*q == NULL) {
+ ret = -TARGET_EFAULT;
+ goto execve_end;
+ }
+ total_size += strlen(*q) + 1;
+ }
+ *q++ = NULL;
+ qargend = q;
+
+ for (gp = guest_envp, q = envp; gp; gp += sizeof(abi_ulong), q++) {
+ if (get_user_ual(addr, gp)) {
+ ret = -TARGET_EFAULT;
+ goto execve_end;
+ }
+ if (!addr) {
+ break;
+ }
+ *q = lock_user_string(addr);
+ if (*q == NULL) {
+ ret = -TARGET_EFAULT;
+ goto execve_end;
+ }
+ total_size += strlen(*q) + 1;
+ }
+ *q = NULL;
+
+ /*
+ * This case will not be caught by the host's execve() if its
+ * page size is bigger than the target's.
+ */
+ if (total_size > MAX_ARG_PAGES * TARGET_PAGE_SIZE) {
+ ret = -TARGET_E2BIG;
+ goto execve_end;
+ }
+
+ if (do_fexec) {
+ if (((int)path_or_fd > 0 &&
+ is_target_elf_binary((int)path_or_fd)) == 1) {
+ char execpath[PATH_MAX];
+
+ /*
+ * The executable is an elf binary for the target
+ * arch. execve() it using the emulator if we can
+ * determine the filename path from the fd.
+ */
+ if (get_filename_from_fd(getpid(), (int)path_or_fd, execpath,
+ sizeof(execpath)) != NULL) {
+ memmove(qarg1 + 2, qarg1, (qargend - qarg1) * sizeof(*qarg1));
+ qarg1[1] = qarg1[0];
+ qarg1[0] = (char *)"-0";
+ qarg1 += 2;
+ qargend += 2;
+ *qarg1 = execpath;
+#ifndef DONT_INHERIT_INTERP_PREFIX
+ memmove(qarg1 + 2, qarg1, (qargend - qarg1) * sizeof(*qarg1));
+ *qarg1++ = (char *)"-L";
+ *qarg1++ = (char *)interp_prefix;
+#endif
+ ret = get_errno(execve(qemu_proc_pathname, qargp, envp));
+ } else {
+ /* Getting the filename path failed. */
+ ret = -TARGET_EBADF;
+ goto execve_end;
+ }
+ } else {
+ ret = get_errno(fexecve((int)path_or_fd, argp, envp));
+ }
+ } else {
+ int fd;
+
+ p = lock_user_string(path_or_fd);
+ if (p == NULL) {
+ ret = -TARGET_EFAULT;
+ goto execve_end;
+ }
+
+ /*
+ * Check the header and see if it a target elf binary. If so
+ * then execute using qemu user mode emulator.
+ */
+ fd = open(p, O_RDONLY | O_CLOEXEC);
+ if (fd > 0 && is_target_elf_binary(fd) == 1) {
+ close(fd);
+ /* execve() as a target binary using emulator. */
+ memmove(qarg1 + 2, qarg1, (qargend - qarg1) * sizeof(*qarg1));
+ qarg1[1] = qarg1[0];
+ qarg1[0] = (char *)"-0";
+ qarg1 += 2;
+ qargend += 2;
+ *qarg1 = (char *)p;
+#ifndef DONT_INHERIT_INTERP_PREFIX
+ memmove(qarg1 + 2, qarg1, (qargend - qarg1) * sizeof(*qarg1));
+ *qarg1++ = (char *)"-L";
+ *qarg1++ = (char *)interp_prefix;
+#endif
+ ret = get_errno(execve(qemu_proc_pathname, qargp, envp));
+ } else {
+ close(fd);
+ /* Execve() as a host native binary. */
+ ret = get_errno(execve(p, argp, envp));
+ }
+ unlock_user(p, path_or_fd, 0);
+ }
+
+execve_end:
+ for (gp = guest_argp, q = argp; *q; gp += sizeof(abi_ulong), q++) {
+ if (get_user_ual(addr, gp) || !addr) {
+ break;
+ }
+ unlock_user(*q, addr, 0);
+ }
+
+ for (gp = guest_envp, q = envp; *q; gp += sizeof(abi_ulong), q++) {
+ if (get_user_ual(addr, gp) || !addr) {
+ break;
+ }
+ unlock_user(*q, addr, 0);
+ }
+
+ g_free(qarg0);
+ g_free(envp);
+
+ return ret;
+}
+
+#include <sys/procctl.h>
+
+static abi_long
+t2h_procctl_cmd(int target_cmd, int *host_cmd)
+{
+ switch (target_cmd) {
+ case TARGET_PROC_SPROTECT:
+ *host_cmd = PROC_SPROTECT;
+ break;
+
+ case TARGET_PROC_REAP_ACQUIRE:
+ *host_cmd = PROC_REAP_ACQUIRE;
+ break;
+
+ case TARGET_PROC_REAP_RELEASE:
+ *host_cmd = PROC_REAP_RELEASE;
+ break;
+
+ case TARGET_PROC_REAP_STATUS:
+ *host_cmd = PROC_REAP_STATUS;
+ break;
+
+ case TARGET_PROC_REAP_KILL:
+ *host_cmd = PROC_REAP_KILL;
+ break;
+
+ default:
+ return -TARGET_EINVAL;
+ }
+
+ return 0;
+}
+
+static abi_long
+h2t_reaper_status(struct procctl_reaper_status *host_rs,
+ abi_ulong target_rs_addr)
+{
+ struct target_procctl_reaper_status *target_rs;
+
+ if (!lock_user_struct(VERIFY_WRITE, target_rs, target_rs_addr, 0)) {
+ return -TARGET_EFAULT;
+ }
+ __put_user(host_rs->rs_flags, &target_rs->rs_flags);
+ __put_user(host_rs->rs_children, &target_rs->rs_children);
+ __put_user(host_rs->rs_descendants, &target_rs->rs_descendants);
+ __put_user(host_rs->rs_reaper, &target_rs->rs_reaper);
+ __put_user(host_rs->rs_pid, &target_rs->rs_pid);
+ unlock_user_struct(target_rs, target_rs_addr, 1);
+
+ return 0;
+}
+
+static abi_long
+t2h_reaper_kill(abi_ulong target_rk_addr, struct procctl_reaper_kill *host_rk)
+{
+ struct target_procctl_reaper_kill *target_rk;
+
+ if (!lock_user_struct(VERIFY_READ, target_rk, target_rk_addr, 1)) {
+ return -TARGET_EFAULT;
+ }
+ __get_user(host_rk->rk_sig, &target_rk->rk_sig);
+ __get_user(host_rk->rk_flags, &target_rk->rk_flags);
+ __get_user(host_rk->rk_subtree, &target_rk->rk_subtree);
+ __get_user(host_rk->rk_killed, &target_rk->rk_killed);
+ __get_user(host_rk->rk_fpid, &target_rk->rk_fpid);
+ unlock_user_struct(target_rk, target_rk_addr, 0);
+
+ return 0;
+}
+
+static abi_long
+h2t_reaper_kill(struct procctl_reaper_kill *host_rk, abi_ulong target_rk_addr)
+{
+ struct target_procctl_reaper_kill *target_rk;
+
+ if (!lock_user_struct(VERIFY_WRITE, target_rk, target_rk_addr, 0)) {
+ return -TARGET_EFAULT;
+ }
+ __put_user(host_rk->rk_sig, &target_rk->rk_sig);
+ __put_user(host_rk->rk_flags, &target_rk->rk_flags);
+ __put_user(host_rk->rk_subtree, &target_rk->rk_subtree);
+ __put_user(host_rk->rk_killed, &target_rk->rk_killed);
+ __put_user(host_rk->rk_fpid, &target_rk->rk_fpid);
+ unlock_user_struct(target_rk, target_rk_addr, 1);
+
+ return 0;
+}
+
+static abi_long
+h2t_procctl_reaper_pidinfo(struct procctl_reaper_pidinfo *host_pi,
+ abi_ulong target_pi_addr)
+{
+ struct target_procctl_reaper_pidinfo *target_pi;
+
+ if (!lock_user_struct(VERIFY_WRITE, target_pi, target_pi_addr, 0)) {
+ return -TARGET_EFAULT;
+ }
+ __put_user(host_pi->pi_pid, &target_pi->pi_pid);
+ __put_user(host_pi->pi_subtree, &target_pi->pi_subtree);
+ __put_user(host_pi->pi_flags, &target_pi->pi_flags);
+ unlock_user_struct(target_pi, target_pi_addr, 1);
+
+ return 0;
+}
+
+abi_long
+do_freebsd_procctl(void *cpu_env, int idtype, abi_ulong arg2, abi_ulong arg3,
+ abi_ulong arg4, abi_ulong arg5, abi_ulong arg6)
+{
+ abi_long error = 0, target_rp_pids;
+ void *data;
+ int host_cmd, flags;
+ uint32_t u, target_rp_count;
+ g_autofree union {
+ struct procctl_reaper_status rs;
+ struct procctl_reaper_pids rp;
+ struct procctl_reaper_kill rk;
+ } host;
+ struct target_procctl_reaper_pids *target_rp;
+ id_t id; /* 64-bit */
+ int target_cmd;
+ abi_ulong target_arg;
+
+#if TARGET_ABI_BITS == 32
+ /* See if we need to align the register pairs. */
+ if (regpairs_aligned(cpu_env)) {
+ id = (id_t)target_arg64(arg3, arg4);
+ target_cmd = (int)arg5;
+ target_arg = arg6;
+ } else {
+ id = (id_t)target_arg64(arg2, arg3);
+ target_cmd = (int)arg4;
+ target_arg = arg5;
+ }
+#else
+ id = (id_t)arg2;
+ target_cmd = (int)arg3;
+ target_arg = arg4;
+#endif
+
+ error = t2h_procctl_cmd(target_cmd, &host_cmd);
+ if (error) {
+ return error;
+ }
+ switch (host_cmd) {
+ case PROC_SPROTECT:
+ data = &flags;
+ break;
+
+ case PROC_REAP_ACQUIRE:
+ case PROC_REAP_RELEASE:
+ if (target_arg == 0) {
+ data = NULL;
+ } else {
+ error = -TARGET_EINVAL;
+ }
+ break;
+
+ case PROC_REAP_STATUS:
+ data = &host.rs;
+ break;
+
+ case PROC_REAP_GETPIDS:
+ if (!lock_user_struct(VERIFY_READ, target_rp, target_arg, 1)) {
+ return -TARGET_EFAULT;
+ }
+ __get_user(target_rp_count, &target_rp->rp_count);
+ __get_user(target_rp_pids, &target_rp->rp_pids);
+ unlock_user_struct(target_rp, target_arg, 0);
+ host.rp.rp_count = target_rp_count;
+ host.rp.rp_pids = g_try_new(struct procctl_reaper_pidinfo,
+ target_rp_count);
+
+ if (host.rp.rp_pids == NULL) {
+ error = -TARGET_ENOMEM;
+ } else {
+ data = &host.rp;
+ }
+ break;
+
+ case PROC_REAP_KILL:
+ error = t2h_reaper_kill(target_arg, &host.rk);
+ break;
+ }
+
+ if (error) {
+ return error;
+ }
+ error = get_errno(procctl(idtype, id, host_cmd, data));
+
+ if (error) {
+ return error;
+ }
+ switch (host_cmd) {
+ case PROC_SPROTECT:
+ if (put_user_s32(flags, target_arg)) {
+ return -TARGET_EFAULT;
+ }
+ break;
+
+ case PROC_REAP_STATUS:
+ error = h2t_reaper_status(&host.rs, target_arg);
+ break;
+
+ case PROC_REAP_GETPIDS:
+ /* copyout reaper pidinfo */
+ for (u = 0; u < target_rp_count; u++) {
+ error = h2t_procctl_reaper_pidinfo(&host.rp.rp_pids[u],
+ target_rp_pids +
+ (u * sizeof(struct target_procctl_reaper_pidinfo)));
+ if (error) {
+ break;
+ }
+ }
+ break;
+
+ case PROC_REAP_KILL:
+ error = h2t_reaper_kill(&host.rk, target_arg);
+ break;
+ }
+
+ return error;
+}
--- /dev/null
+/*
+ * process related system call shims and definitions
+ *
+ * Copyright (c) 2013-14 Stacey D. Son
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef BSD_USER_FREEBSD_OS_PROC_H
+#define BSD_USER_FREEBSD_OS_PROC_H
+
+#include <sys/param.h>
+#include <sys/procctl.h>
+#include <sys/signal.h>
+#include <sys/types.h>
+#include <sys/procdesc.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include "target_arch_cpu.h"
+
+pid_t safe_wait4(pid_t wpid, int *status, int options, struct rusage *rusage);
+pid_t safe_wait6(idtype_t idtype, id_t id, int *status, int options,
+ struct __wrusage *wrusage, siginfo_t *infop);
+
+extern int __setugid(int flag);
+
+/* execve(2) */
+static inline abi_long do_freebsd_execve(abi_ulong path_or_fd, abi_ulong argp,
+ abi_ulong envp)
+{
+
+ return freebsd_exec_common(path_or_fd, argp, envp, 0);
+}
+
+/* fexecve(2) */
+static inline abi_long do_freebsd_fexecve(abi_ulong path_or_fd, abi_ulong argp,
+ abi_ulong envp)
+{
+
+ return freebsd_exec_common(path_or_fd, argp, envp, 1);
+}
+
+/* wait4(2) */
+static inline abi_long do_freebsd_wait4(abi_long arg1, abi_ulong target_status,
+ abi_long arg3, abi_ulong target_rusage)
+{
+ abi_long ret;
+ int status;
+ struct rusage rusage, *rusage_ptr = NULL;
+
+ if (target_rusage) {
+ rusage_ptr = &rusage;
+ }
+ ret = get_errno(safe_wait4(arg1, &status, arg3, rusage_ptr));
+
+ if (ret < 0) {
+ return ret;
+ }
+ if (target_status != 0) {
+ status = host_to_target_waitstatus(status);
+ if (put_user_s32(status, target_status) != 0) {
+ return -TARGET_EFAULT;
+ }
+ }
+ if (target_rusage != 0) {
+ host_to_target_rusage(target_rusage, &rusage);
+ }
+ return ret;
+}
+
+/* wait6(2) */
+static inline abi_long do_freebsd_wait6(void *cpu_env, abi_long idtype,
+ abi_long id1, abi_long id2,
+ abi_ulong target_status, abi_long options, abi_ulong target_wrusage,
+ abi_ulong target_infop, abi_ulong pad1)
+{
+ abi_long ret;
+ int status;
+ struct __wrusage wrusage, *wrusage_ptr = NULL;
+ siginfo_t info;
+ void *p;
+
+ if (regpairs_aligned(cpu_env) != 0) {
+ /* printf("shifting args\n"); */
+ /* 64-bit id is aligned, so shift all the arguments over by one */
+ id1 = id2;
+ id2 = target_status;
+ target_status = options;
+ options = target_wrusage;
+ target_wrusage = target_infop;
+ target_infop = pad1;
+ }
+
+ if (target_wrusage) {
+ wrusage_ptr = &wrusage;
+ }
+ ret = get_errno(safe_wait6(idtype, target_arg64(id1, id2),
+ &status, options, wrusage_ptr, &info));
+
+ if (ret < 0) {
+ return ret;
+ }
+ if (target_status != 0) {
+ status = host_to_target_waitstatus(status);
+ if (put_user_s32(status, target_status) != 0) {
+ return -TARGET_EFAULT;
+ }
+ }
+ if (target_wrusage != 0) {
+ host_to_target_wrusage(target_wrusage, &wrusage);
+ }
+ if (target_infop != 0) {
+ p = lock_user(VERIFY_WRITE, target_infop, sizeof(target_siginfo_t), 0);
+ if (p == NULL) {
+ return -TARGET_EFAULT;
+ }
+ host_to_target_siginfo(p, &info);
+ unlock_user(p, target_infop, sizeof(target_siginfo_t));
+ }
+ return ret;
+}
+
+/* setloginclass(2) */
+static inline abi_long do_freebsd_setloginclass(abi_ulong arg1)
+{
+ abi_long ret;
+ void *p;
+
+ p = lock_user_string(arg1);
+ if (p == NULL) {
+ return -TARGET_EFAULT;
+ }
+ ret = get_errno(setloginclass(p));
+ unlock_user(p, arg1, 0);
+
+ return ret;
+}
+
+/* getloginclass(2) */
+static inline abi_long do_freebsd_getloginclass(abi_ulong arg1, abi_ulong arg2)
+{
+ abi_long ret;
+ void *p;
+
+ p = lock_user(VERIFY_WRITE, arg1, arg2, 0);
+ if (p == NULL) {
+ return -TARGET_EFAULT;
+ }
+ ret = get_errno(getloginclass(p, arg2));
+ unlock_user(p, arg1, arg2);
+
+ return ret;
+}
+
+/* pdgetpid(2) */
+static inline abi_long do_freebsd_pdgetpid(abi_long fd, abi_ulong target_pidp)
+{
+ abi_long ret;
+ pid_t pid;
+
+ ret = get_errno(pdgetpid(fd, &pid));
+ if (!is_error(ret)) {
+ if (put_user_u32(pid, target_pidp)) {
+ return -TARGET_EFAULT;
+ }
+ }
+ return ret;
+}
+
+/* undocumented __setugid */
+static inline abi_long do_freebsd___setugid(abi_long arg1)
+{
+ return -TARGET_ENOSYS;
+}
+
+/* fork(2) */
+static inline abi_long do_freebsd_fork(void *cpu_env)
+{
+ abi_long ret;
+ abi_ulong child_flag;
+
+ fork_start();
+ ret = fork();
+ if (ret == 0) {
+ /* child */
+ child_flag = 1;
+ target_cpu_clone_regs(cpu_env, 0);
+ } else {
+ /* parent */
+ child_flag = 0;
+ }
+
+ /*
+ * The fork system call sets a child flag in the second return
+ * value: 0 for parent process, 1 for child process.
+ */
+ set_second_rval(cpu_env, child_flag);
+
+ fork_end(child_flag);
+
+ return ret;
+}
+
+/* vfork(2) */
+static inline abi_long do_freebsd_vfork(void *cpu_env)
+{
+ return do_freebsd_fork(cpu_env);
+}
+
+/* rfork(2) */
+static inline abi_long do_freebsd_rfork(void *cpu_env, abi_long flags)
+{
+ abi_long ret;
+ abi_ulong child_flag;
+
+ /*
+ * XXX We need to handle RFMEM here, as well. Neither are safe to execute
+ * as-is on x86 hosts because they'll split memory but not the stack,
+ * wreaking havoc on host architectures that use the stack to store the
+ * return address as both threads try to pop it off. Rejecting RFSPAWN
+ * entirely for now is ok, the only consumer at the moment is posix_spawn
+ * and it will fall back to classic vfork(2) if we return EINVAL.
+ */
+ if ((flags & TARGET_RFSPAWN) != 0) {
+ return -TARGET_EINVAL;
+ }
+ fork_start();
+ ret = rfork(flags);
+ if (ret == 0) {
+ /* child */
+ child_flag = 1;
+ target_cpu_clone_regs(cpu_env, 0);
+ } else {
+ /* parent */
+ child_flag = 0;
+ }
+
+ /*
+ * The fork system call sets a child flag in the second return
+ * value: 0 for parent process, 1 for child process.
+ */
+ set_second_rval(cpu_env, child_flag);
+ fork_end(child_flag);
+
+ return ret;
+
+}
+
+/* pdfork(2) */
+static inline abi_long do_freebsd_pdfork(void *cpu_env, abi_ulong target_fdp,
+ abi_long flags)
+{
+ abi_long ret;
+ abi_ulong child_flag;
+ int fd;
+
+ fork_start();
+ ret = pdfork(&fd, flags);
+ if (ret == 0) {
+ /* child */
+ child_flag = 1;
+ target_cpu_clone_regs(cpu_env, 0);
+ } else {
+ /* parent */
+ child_flag = 0;
+ if (put_user_s32(fd, target_fdp)) {
+ return -TARGET_EFAULT;
+ }
+ }
+
+ /*
+ * The fork system call sets a child flag in the second return
+ * value: 0 for parent process, 1 for child process.
+ */
+ set_second_rval(cpu_env, child_flag);
+ fork_end(child_flag);
+
+ return ret;
+}
+
+#endif /* BSD_USER_FREEBSD_OS_PROC_H */
#include "signal-common.h"
#include "user/syscall-trace.h"
+/* BSD independent syscall shims */
#include "bsd-file.h"
+#include "bsd-mem.h"
#include "bsd-proc.h"
-/* *BSD dependent syscall shims */
+/* BSD dependent syscall shims */
#include "os-stat.h"
+#include "os-proc.h"
+#include "os-misc.h"
/* I/O */
safe_syscall3(int, open, const char *, path, int, flags, mode_t, mode);
safe_syscall4(ssize_t, pwritev, int, fd, const struct iovec *, iov, int, iovcnt,
off_t, offset);
-void target_set_brk(abi_ulong new_brk)
-{
-}
+/* used in os-proc */
+safe_syscall4(pid_t, wait4, pid_t, wpid, int *, status, int, options,
+ struct rusage *, rusage);
+safe_syscall6(pid_t, wait6, idtype_t, idtype, id_t, id, int *, status, int,
+ options, struct __wrusage *, wrusage, siginfo_t *, infop);
/*
* errno conversion.
/*
* process system calls
*/
+ case TARGET_FREEBSD_NR_fork: /* fork(2) */
+ ret = do_freebsd_fork(cpu_env);
+ break;
+
+ case TARGET_FREEBSD_NR_vfork: /* vfork(2) */
+ ret = do_freebsd_vfork(cpu_env);
+ break;
+
+ case TARGET_FREEBSD_NR_rfork: /* rfork(2) */
+ ret = do_freebsd_rfork(cpu_env, arg1);
+ break;
+
+ case TARGET_FREEBSD_NR_pdfork: /* pdfork(2) */
+ ret = do_freebsd_pdfork(cpu_env, arg1, arg2);
+ break;
+
+ case TARGET_FREEBSD_NR_execve: /* execve(2) */
+ ret = do_freebsd_execve(arg1, arg2, arg3);
+ break;
+
+ case TARGET_FREEBSD_NR_fexecve: /* fexecve(2) */
+ ret = do_freebsd_fexecve(arg1, arg2, arg3);
+ break;
+
+ case TARGET_FREEBSD_NR_wait4: /* wait4(2) */
+ ret = do_freebsd_wait4(arg1, arg2, arg3, arg4);
+ break;
+
+ case TARGET_FREEBSD_NR_wait6: /* wait6(2) */
+ ret = do_freebsd_wait6(cpu_env, arg1, arg2, arg3,
+ arg4, arg5, arg6, arg7, arg8);
+ break;
+
case TARGET_FREEBSD_NR_exit: /* exit(2) */
ret = do_bsd_exit(cpu_env, arg1);
break;
+ case TARGET_FREEBSD_NR_getgroups: /* getgroups(2) */
+ ret = do_bsd_getgroups(arg1, arg2);
+ break;
+
+ case TARGET_FREEBSD_NR_setgroups: /* setgroups(2) */
+ ret = do_bsd_setgroups(arg1, arg2);
+ break;
+
+ case TARGET_FREEBSD_NR_umask: /* umask(2) */
+ ret = do_bsd_umask(arg1);
+ break;
+
+ case TARGET_FREEBSD_NR_setlogin: /* setlogin(2) */
+ ret = do_bsd_setlogin(arg1);
+ break;
+
+ case TARGET_FREEBSD_NR_getlogin: /* getlogin(2) */
+ ret = do_bsd_getlogin(arg1, arg2);
+ break;
+
+ case TARGET_FREEBSD_NR_getrusage: /* getrusage(2) */
+ ret = do_bsd_getrusage(arg1, arg2);
+ break;
+
+ case TARGET_FREEBSD_NR_getrlimit: /* getrlimit(2) */
+ ret = do_bsd_getrlimit(arg1, arg2);
+ break;
+
+ case TARGET_FREEBSD_NR_setrlimit: /* setrlimit(2) */
+ ret = do_bsd_setrlimit(arg1, arg2);
+ break;
+
+ case TARGET_FREEBSD_NR_getpid: /* getpid(2) */
+ ret = do_bsd_getpid();
+ break;
+
+ case TARGET_FREEBSD_NR_getppid: /* getppid(2) */
+ ret = do_bsd_getppid();
+ break;
+
+ case TARGET_FREEBSD_NR_getuid: /* getuid(2) */
+ ret = do_bsd_getuid();
+ break;
+
+ case TARGET_FREEBSD_NR_geteuid: /* geteuid(2) */
+ ret = do_bsd_geteuid();
+ break;
+
+ case TARGET_FREEBSD_NR_getgid: /* getgid(2) */
+ ret = do_bsd_getgid();
+ break;
+
+ case TARGET_FREEBSD_NR_getegid: /* getegid(2) */
+ ret = do_bsd_getegid();
+ break;
+
+ case TARGET_FREEBSD_NR_setuid: /* setuid(2) */
+ ret = do_bsd_setuid(arg1);
+ break;
+
+ case TARGET_FREEBSD_NR_seteuid: /* seteuid(2) */
+ ret = do_bsd_seteuid(arg1);
+ break;
+
+ case TARGET_FREEBSD_NR_setgid: /* setgid(2) */
+ ret = do_bsd_setgid(arg1);
+ break;
+
+ case TARGET_FREEBSD_NR_setegid: /* setegid(2) */
+ ret = do_bsd_setegid(arg1);
+ break;
+
+ case TARGET_FREEBSD_NR_getpgrp: /* getpgrp(2) */
+ ret = do_bsd_getpgrp();
+ break;
+
+ case TARGET_FREEBSD_NR_getpgid: /* getpgid(2) */
+ ret = do_bsd_getpgid(arg1);
+ break;
+
+ case TARGET_FREEBSD_NR_setpgid: /* setpgid(2) */
+ ret = do_bsd_setpgid(arg1, arg2);
+ break;
+
+ case TARGET_FREEBSD_NR_setreuid: /* setreuid(2) */
+ ret = do_bsd_setreuid(arg1, arg2);
+ break;
+
+ case TARGET_FREEBSD_NR_setregid: /* setregid(2) */
+ ret = do_bsd_setregid(arg1, arg2);
+ break;
+
+ case TARGET_FREEBSD_NR_getresuid: /* getresuid(2) */
+ ret = do_bsd_getresuid(arg1, arg2, arg3);
+ break;
+
+ case TARGET_FREEBSD_NR_getresgid: /* getresgid(2) */
+ ret = do_bsd_getresgid(arg1, arg2, arg3);
+ break;
+
+ case TARGET_FREEBSD_NR_setresuid: /* setresuid(2) */
+ ret = do_bsd_setresuid(arg1, arg2, arg3);
+ break;
+
+ case TARGET_FREEBSD_NR_setresgid: /* setresgid(2) */
+ ret = do_bsd_setresgid(arg1, arg2, arg3);
+ break;
+
+ case TARGET_FREEBSD_NR_getsid: /* getsid(2) */
+ ret = do_bsd_getsid(arg1);
+ break;
+
+ case TARGET_FREEBSD_NR_setsid: /* setsid(2) */
+ ret = do_bsd_setsid();
+ break;
+
+ case TARGET_FREEBSD_NR_issetugid: /* issetugid(2) */
+ ret = do_bsd_issetugid();
+ break;
+
+ case TARGET_FREEBSD_NR_profil: /* profil(2) */
+ ret = do_bsd_profil(arg1, arg2, arg3, arg4);
+ break;
+
+ case TARGET_FREEBSD_NR_ktrace: /* ktrace(2) */
+ ret = do_bsd_ktrace(arg1, arg2, arg3, arg4);
+ break;
+
+ case TARGET_FREEBSD_NR_setloginclass: /* setloginclass(2) */
+ ret = do_freebsd_setloginclass(arg1);
+ break;
+
+ case TARGET_FREEBSD_NR_getloginclass: /* getloginclass(2) */
+ ret = do_freebsd_getloginclass(arg1, arg2);
+ break;
+
+ case TARGET_FREEBSD_NR_pdgetpid: /* pdgetpid(2) */
+ ret = do_freebsd_pdgetpid(arg1, arg2);
+ break;
+
+ case TARGET_FREEBSD_NR___setugid: /* undocumented */
+ ret = do_freebsd___setugid(arg1);
+ break;
+
+ case TARGET_FREEBSD_NR_utrace: /* utrace(2) */
+ ret = do_bsd_utrace(arg1, arg2);
+ break;
+
+ case TARGET_FREEBSD_NR_ptrace: /* ptrace(2) */
+ ret = do_bsd_ptrace(arg1, arg2, arg3, arg4);
+ break;
+
+ case TARGET_FREEBSD_NR_getpriority: /* getpriority(2) */
+ ret = do_bsd_getpriority(arg1, arg2);
+ break;
+
+ case TARGET_FREEBSD_NR_setpriority: /* setpriority(2) */
+ ret = do_bsd_setpriority(arg1, arg2, arg3);
+ break;
+
+ case TARGET_FREEBSD_NR_procctl: /* procctl(2) */
+ ret = do_freebsd_procctl(cpu_env, arg1, arg2, arg3, arg4, arg5, arg6);
+ break;
+
/*
* File system calls.
*/
ret = do_freebsd_fcntl(arg1, arg2, arg3);
break;
+ /*
+ * Memory management system calls.
+ */
+ case TARGET_FREEBSD_NR_mmap: /* mmap(2) */
+ ret = do_bsd_mmap(cpu_env, arg1, arg2, arg3, arg4, arg5, arg6, arg7,
+ arg8);
+ break;
+
+ case TARGET_FREEBSD_NR_munmap: /* munmap(2) */
+ ret = do_bsd_munmap(arg1, arg2);
+ break;
+
+ case TARGET_FREEBSD_NR_mprotect: /* mprotect(2) */
+ ret = do_bsd_mprotect(arg1, arg2, arg3);
+ break;
+
+ case TARGET_FREEBSD_NR_msync: /* msync(2) */
+ ret = do_bsd_msync(arg1, arg2, arg3);
+ break;
+
+ case TARGET_FREEBSD_NR_mlock: /* mlock(2) */
+ ret = do_bsd_mlock(arg1, arg2);
+ break;
+
+ case TARGET_FREEBSD_NR_munlock: /* munlock(2) */
+ ret = do_bsd_munlock(arg1, arg2);
+ break;
+
+ case TARGET_FREEBSD_NR_mlockall: /* mlockall(2) */
+ ret = do_bsd_mlockall(arg1);
+ break;
+
+ case TARGET_FREEBSD_NR_munlockall: /* munlockall(2) */
+ ret = do_bsd_munlockall();
+ break;
+
+ case TARGET_FREEBSD_NR_madvise: /* madvise(2) */
+ ret = do_bsd_madvise(arg1, arg2, arg3);
+ break;
+
+ case TARGET_FREEBSD_NR_minherit: /* minherit(2) */
+ ret = do_bsd_minherit(arg1, arg2, arg3);
+ break;
+
+ case TARGET_FREEBSD_NR_mincore: /* mincore(2) */
+ ret = do_bsd_mincore(arg1, arg2, arg3);
+ break;
+
+ case TARGET_FREEBSD_NR_freebsd12_shm_open: /* shm_open(2) */
+ ret = do_bsd_shm_open(arg1, arg2, arg3);
+ break;
+
+#if defined(__FreeBSD_version) && __FreeBSD_version >= 1300048
+ case TARGET_FREEBSD_NR_shm_open2: /* shm_open2(2) */
+ ret = do_freebsd_shm_open2(arg1, arg2, arg3, arg4, arg5);
+ break;
+#endif
+
+#if defined(__FreeBSD_version) && __FreeBSD_version >= 1300049
+ case TARGET_FREEBSD_NR_shm_rename: /* shm_rename(2) */
+ ret = do_freebsd_shm_rename(arg1, arg2, arg3);
+ break;
+#endif
+
+ case TARGET_FREEBSD_NR_shm_unlink: /* shm_unlink(2) */
+ ret = do_bsd_shm_unlink(arg1);
+ break;
+
+ case TARGET_FREEBSD_NR_shmget: /* shmget(2) */
+ ret = do_bsd_shmget(arg1, arg2, arg3);
+ break;
+
+ case TARGET_FREEBSD_NR_shmctl: /* shmctl(2) */
+ ret = do_bsd_shmctl(arg1, arg2, arg3);
+ break;
+
+ case TARGET_FREEBSD_NR_shmat: /* shmat(2) */
+ ret = do_bsd_shmat(arg1, arg2, arg3);
+ break;
+
+ case TARGET_FREEBSD_NR_shmdt: /* shmdt(2) */
+ ret = do_bsd_shmdt(arg1);
+ break;
+
+ case TARGET_FREEBSD_NR_freebsd11_vadvise:
+ ret = do_bsd_vadvise();
+ break;
+
+ case TARGET_FREEBSD_NR_sbrk:
+ ret = do_bsd_sbrk();
+ break;
+
+ case TARGET_FREEBSD_NR_sstk:
+ ret = do_bsd_sstk();
+ break;
+
+ /*
+ * Misc
+ */
+ case TARGET_FREEBSD_NR_break:
+ ret = do_obreak(arg1);
+ break;
/*
* sys{ctl, arch, call}
unsigned long reserved_va;
#endif
-static const char *interp_prefix = CONFIG_QEMU_INTERP_PREFIX;
+const char *interp_prefix = CONFIG_QEMU_INTERP_PREFIX;
const char *qemu_uname_release;
char qemu_proc_pathname[PATH_MAX]; /* full path to exeutable */
common_user_inc += include_directories('include')
bsd_user_ss.add(files(
+ 'bsd-mem.c',
+ 'bsd-proc.c',
'bsdload.c',
'elfload.c',
'main.c',
'uaccess.c',
))
+elf = cc.find_library('elf', required: true)
+procstat = cc.find_library('procstat', required: true)
+kvm = cc.find_library('kvm', required: true)
+bsd_user_ss.add(elf, procstat, kvm)
+
# Pull in the OS-specific build glue, if any
subdir(targetos)
return -1;
}
-static void mmap_reserve(abi_ulong start, abi_ulong size)
+void mmap_reserve(abi_ulong start, abi_ulong size)
{
abi_ulong real_start;
abi_ulong real_end;
--- /dev/null
+/*
+ * BSD conversion extern declarations
+ *
+ * Copyright (c) 2013 Stacey D. Son
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef QEMU_BSD_H
+#define QEMU_BSD_H
+
+#include <sys/types.h>
+#include <sys/resource.h>
+#include <sys/ipc.h>
+#include <sys/msg.h>
+#include <sys/resource.h>
+#include <sys/sem.h>
+#include <sys/shm.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/uuid.h>
+#include <sys/wait.h>
+#include <netinet/in.h>
+
+/* bsd-proc.c */
+int target_to_host_resource(int code);
+rlim_t target_to_host_rlim(abi_llong target_rlim);
+abi_llong host_to_target_rlim(rlim_t rlim);
+abi_long host_to_target_rusage(abi_ulong target_addr,
+ const struct rusage *rusage);
+abi_long host_to_target_wrusage(abi_ulong target_addr,
+ const struct __wrusage *wrusage);
+int host_to_target_waitstatus(int status);
+void h2g_rusage(const struct rusage *rusage,
+ struct target_freebsd_rusage *target_rusage);
+
+/* bsd-mem.c */
+void target_to_host_ipc_perm__locked(struct ipc_perm *host_ip,
+ struct target_ipc_perm *target_ip);
+void host_to_target_ipc_perm__locked(struct target_ipc_perm *target_ip,
+ struct ipc_perm *host_ip);
+abi_long target_to_host_shmid_ds(struct shmid_ds *host_sd,
+ abi_ulong target_addr);
+abi_long host_to_target_shmid_ds(abi_ulong target_addr,
+ struct shmid_ds *host_sd);
+
+#endif /* QEMU_BSD_H */
} __attribute__((aligned(16))) TaskState;
void stop_all_tasks(void);
+extern const char *interp_prefix;
extern const char *qemu_uname_release;
/*
int target_msync(abi_ulong start, abi_ulong len, int flags);
extern abi_ulong mmap_next_start;
abi_ulong mmap_find_vma(abi_ulong start, abi_ulong size);
+void mmap_reserve(abi_ulong start, abi_ulong size);
void TSA_NO_TSA mmap_fork_start(void);
void TSA_NO_TSA mmap_fork_end(int child);
bool is_error(abi_long ret);
int host_to_target_errno(int err);
+/* os-proc.c */
+abi_long freebsd_exec_common(abi_ulong path_or_fd, abi_ulong guest_argp,
+ abi_ulong guest_envp, int do_fexec);
+abi_long do_freebsd_procctl(void *cpu_env, int idtype, abi_ulong arg2,
+ abi_ulong arg3, abi_ulong arg4, abi_ulong arg5, abi_ulong arg6);
+
/* os-sys.c */
abi_long do_freebsd_sysctl(CPUArchState *env, abi_ulong namep, int32_t namelen,
abi_ulong oldp, abi_ulong oldlenp, abi_ulong newp, abi_ulong newlen);
abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp);
long do_sigreturn(CPUArchState *env, abi_ulong addr);
void force_sig_fault(int sig, int code, abi_ulong addr);
+void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info);
int host_to_target_signal(int sig);
void host_to_target_sigset(target_sigset_t *d, const sigset_t *s);
void process_pending_signals(CPUArchState *env);
}
}
+void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info)
+{
+ host_to_target_siginfo_noswap(tinfo, info);
+ tswap_siginfo(tinfo, tinfo);
+}
+
int block_signals(void)
{
TaskState *ts = (TaskState *)thread_cpu->opaque;
abi_long iov_len; /* Number of bytes */
};
+/*
+ * sys/ipc.h
+ */
+struct target_ipc_perm {
+ uint32_t cuid; /* creator user id */
+ uint32_t cgid; /* creator group id */
+ uint32_t uid; /* user id */
+ uint32_t gid; /* group id */
+ uint16_t mode; /* r/w permission */
+ uint16_t seq; /* sequence # */
+ abi_long key; /* user specified msg/sem/shm key */
+};
+
+#define TARGET_IPC_RMID 0 /* remove identifier */
+#define TARGET_IPC_SET 1 /* set options */
+#define TARGET_IPC_STAT 2 /* get options */
+
+/*
+ * sys/shm.h
+ */
+struct target_shmid_ds {
+ struct target_ipc_perm shm_perm; /* peration permission structure */
+ abi_ulong shm_segsz; /* size of segment in bytes */
+ int32_t shm_lpid; /* process ID of last shared memory op */
+ int32_t shm_cpid; /* process ID of creator */
+ int32_t shm_nattch; /* number of current attaches */
+ target_time_t shm_atime; /* time of last shmat() */
+ target_time_t shm_dtime; /* time of last shmdt() */
+ target_time_t shm_ctime; /* time of last change by shmctl() */
+};
+
+#define N_BSD_SHM_REGIONS 32
+struct bsd_shm_regions {
+ abi_long start;
+ abi_long size;
+};
+
/*
* sys/mman.h
*/
+#define TARGET_MADV_DONTNEED 4 /* dont need these pages */
+
#define TARGET_FREEBSD_MAP_RESERVED0080 0x0080 /* previously misimplemented */
/* MAP_INHERIT */
#define TARGET_FREEBSD_MAP_RESERVED0100 0x0100 /* previously unimplemented */
/*
* sys/resource.h
*/
-#if defined(__FreeBSD__)
#define TARGET_RLIM_INFINITY RLIM_INFINITY
-#else
-#define TARGET_RLIM_INFINITY ((abi_ulong)-1)
-#endif
#define TARGET_RLIMIT_CPU 0
#define TARGET_RLIMIT_FSIZE 1
int32_t l_sysid;
} QEMU_PACKED;
+/* sys/unistd.h */
+/* user: vfork(2) semantics, clear signals */
+#define TARGET_RFSPAWN (1U << 31)
+
+/*
+ * from sys/procctl.h
+ */
+#define TARGET_PROC_SPROTECT 1
+#define TARGET_PROC_REAP_ACQUIRE 2
+#define TARGET_PROC_REAP_RELEASE 3
+#define TARGET_PROC_REAP_STATUS 4
+#define TARGET_PROC_REAP_GETPIDS 5
+#define TARGET_PROC_REAP_KILL 6
+
+struct target_procctl_reaper_status {
+ uint32_t rs_flags;
+ uint32_t rs_children;
+ uint32_t rs_descendants;
+ uint32_t rs_reaper;
+ uint32_t rs_pid;
+ uint32_t rs_pad0[15];
+};
+
+struct target_procctl_reaper_pidinfo {
+ uint32_t pi_pid;
+ uint32_t pi_subtree;
+ uint32_t pi_flags;
+ uint32_t pi_pad0[15];
+};
+
+struct target_procctl_reaper_pids {
+ uint32_t rp_count;
+ uint32_t rp_pad0[15];
+ abi_ulong rp_pids;
+};
+
+struct target_procctl_reaper_kill {
+ int32_t rk_sig;
+ uint32_t rk_flags;
+ uint32_t rk_subtree;
+ uint32_t rk_killed;
+ uint32_t rk_fpid;
+ uint32_t rk_pad0[15];
+};
+
+
#define safe_syscall0(type, name) \
type safe_##name(void) \
{ \
projects / mirror_qemu.git / commitdiff