mirrors/qemu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

bsd-user mmap and exec branches from gsoc

Browse Source 
This pull request represents the mmap and exec changes from Karim Taha
 for his GSoC project.
 
 They represent all the mmap and exec related system calls and get bsd-user to
 the point that a dynamic hello-world works (at least for armv7).
 
 There are a couple of patch check errors, but they are the lessor evil: I made
 purposely bad style choices to ensure all the commits compiled (and i undid the
 style choices in subsequent commits).
 
 I pushed an earlier version to gitlab, and all but the riscv64 pipelines were
 green.  Since bsd-user doesn't change anything related to ricsv64 (there's no
 support in qemu-project repo, though we do have it in the bsd-user fork: coming
 soon).
 
 I think this is good to go.
 
 https://gitlab.com/bsdimp/qemu.git
 
 Warner
 -----BEGIN PGP SIGNATURE-----
 Comment: GPGTools - https://gpgtools.org
 
 iQIzBAABCgAdFiEEIDX4lLAKo898zeG3bBzRKH2wEQAFAmUcpC4ACgkQbBzRKH2w
 EQDD9xAA3Rg0AnfnFrd+AoWRb/1/gOuO0v+dEGXj50qnGY8OmHeYtg3XecYPArBq
 EicZzL/OG7UZKMl5OfrmGP9tbr32yfeRUTe3AGGHfmnSb11q0yeSaEFZI7felLHj
 9nlq4H/2EDRrY+7EnG1TWqtnuqDJAJf/7M0giiVxIk77XGX+USUNPOSG4NP/yc8E
 D5p2GN23pUsvnI0jBZkyP3gyeXVNCNG5+KobwqJM3r6OjEiTRmLEVBw98YzG12bh
 OY9ekMtVUKHi4Cvsf+2TtkDGRya0wX4uqm4UB1TtV1VUDoCWhYgEKBHp3ozCoVjB
 J+ygbx7/jNfY53cpgEpKUBFH7rnOq1yQQ+ad5Ap5hbp4j6WSvPwdp1N3RCnkZzd/
 L50VIaySd+P6enAgPO5Mbt3kMMVd/eDGhQDWdzNToIjyhXBb5hUNfumg9AgdEwTh
 rW/kKT39YLYWLO123hIJCy2CKU9nvoea9588ExkKb22v0ltrtDcAlWfCbZvZYxNN
 wRzh+MFBt7Cd/bqk7HaJ0J/YyPToqImoUjNuBnBSDPqZQP2H4U8v/FoICQ0mm5kR
 jZCmGLMEP1PiDlusjUjaW0iamHvXiSP8KEzaAbIxx5UUiTWTTkQm4CKY/xPxC9VQ
 0ygJqJVrKHlNrAY9u6ggJAXtorVwmC55z4ZqIVQH6cbzUYFMuJU=
 =WpL4
 -----END PGP SIGNATURE-----

Merge tag 'bsd-user-mmap-pull-request' of https://gitlab.com/bsdimp/qemu into staging

bsd-user mmap and exec branches from gsoc

This pull request represents the mmap and exec changes from Karim Taha
for his GSoC project.

They represent all the mmap and exec related system calls and get bsd-user to
the point that a dynamic hello-world works (at least for armv7).

There are a couple of patch check errors, but they are the lessor evil: I made
purposely bad style choices to ensure all the commits compiled (and i undid the
style choices in subsequent commits).

I pushed an earlier version to gitlab, and all but the riscv64 pipelines were
green.  Since bsd-user doesn't change anything related to ricsv64 (there's no
support in qemu-project repo, though we do have it in the bsd-user fork: coming
soon).

I think this is good to go.

https://gitlab.com/bsdimp/qemu.git

Warner

# -----BEGIN PGP SIGNATURE-----
# Comment: GPGTools - https://gpgtools.org
#
# iQIzBAABCgAdFiEEIDX4lLAKo898zeG3bBzRKH2wEQAFAmUcpC4ACgkQbBzRKH2w
# EQDD9xAA3Rg0AnfnFrd+AoWRb/1/gOuO0v+dEGXj50qnGY8OmHeYtg3XecYPArBq
# EicZzL/OG7UZKMl5OfrmGP9tbr32yfeRUTe3AGGHfmnSb11q0yeSaEFZI7felLHj
# 9nlq4H/2EDRrY+7EnG1TWqtnuqDJAJf/7M0giiVxIk77XGX+USUNPOSG4NP/yc8E
# D5p2GN23pUsvnI0jBZkyP3gyeXVNCNG5+KobwqJM3r6OjEiTRmLEVBw98YzG12bh
# OY9ekMtVUKHi4Cvsf+2TtkDGRya0wX4uqm4UB1TtV1VUDoCWhYgEKBHp3ozCoVjB
# J+ygbx7/jNfY53cpgEpKUBFH7rnOq1yQQ+ad5Ap5hbp4j6WSvPwdp1N3RCnkZzd/
# L50VIaySd+P6enAgPO5Mbt3kMMVd/eDGhQDWdzNToIjyhXBb5hUNfumg9AgdEwTh
# rW/kKT39YLYWLO123hIJCy2CKU9nvoea9588ExkKb22v0ltrtDcAlWfCbZvZYxNN
# wRzh+MFBt7Cd/bqk7HaJ0J/YyPToqImoUjNuBnBSDPqZQP2H4U8v/FoICQ0mm5kR
# jZCmGLMEP1PiDlusjUjaW0iamHvXiSP8KEzaAbIxx5UUiTWTTkQm4CKY/xPxC9VQ
# 0ygJqJVrKHlNrAY9u6ggJAXtorVwmC55z4ZqIVQH6cbzUYFMuJU=
# =WpL4
# -----END PGP SIGNATURE-----
# gpg: Signature made Tue 03 Oct 2023 19:30:54 EDT
# gpg:                using RSA key 2035F894B00AA3CF7CCDE1B76C1CD1287DB01100
# gpg: Good signature from "Warner Losh <wlosh@netflix.com>" [unknown]
# gpg:                 aka "Warner Losh <imp@bsdimp.com>" [unknown]
# gpg:                 aka "Warner Losh <imp@freebsd.org>" [unknown]
# gpg:                 aka "Warner Losh <imp@village.org>" [unknown]
# gpg:                 aka "Warner Losh <wlosh@bsdimp.com>" [unknown]
# gpg: WARNING: This key is not certified with a trusted signature!
# gpg:          There is no indication that the signature belongs to the owner.
# Primary key fingerprint: 2035 F894 B00A A3CF 7CCD  E1B7 6C1C D128 7DB0 1100

* tag 'bsd-user-mmap-pull-request' of https://gitlab.com/bsdimp/qemu: (51 commits)
  bsd-user: Add stubs for vadvise(), sbrk() and sstk()
  bsd-user: Implement shmat(2) and shmdt(2)
  bsd-user: Implement shmctl(2)
  bsd-user: Implement shm_unlink(2) and shmget(2)
  bsd-user: Implement shm_open(2)
  bsd-user: Implement do_obreak function
  bsd-user: Implement mincore(2)
  bsd-user: Implment madvise(2) to match the linux-user implementation.
  bsd-user: Implement mlock(2), munlock(2), mlockall(2), munlockall(2), minherit(2)
  bsd-user: Implement msync(2)
  bsd-user: Implement mprotect(2)
  bsd-user: Implement mmap(2) and munmap(2)
  bsd-user: Introduce bsd-mem.h to the source tree
  bsd-user: Implement shmid_ds conversion between host and target.
  bsd-user: Implement ipc_perm conversion between host and target.
  bsd-user: Implement target_set_brk function in bsd-mem.c instead of os-syscall.c
  bsd-user: Add bsd-mem.c to meson.build
  bsd-user: Implement shm_rename(2) system call
  bsd-user: Implement shm_open2(2) system call
  bsd-user: Introduce freebsd/os-misc.h to the source tree
  ...

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
This commit is contained in:
Stefan Hajnoczi 2023-10-04 12:51:48 -04:00
commit 80dcaf682a
17 changed files with 2428 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
bsd-user/bsd-mem.c Normal file
View File

@ -0,0 +1,104 @@
/*
* 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;
}

452
bsd-user/bsd-mem.h Normal file
View File

@ -0,0 +1,452 @@
/*
* 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 */

145
bsd-user/bsd-proc.c Normal file
View File

@ -0,0 +1,145 @@
/*
* 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;
}

379
bsd-user/bsd-proc.h
View File

@ -22,6 +22,13 @@
#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)
{
@ -35,4 +42,376 @@ 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_ */

1
bsd-user/freebsd/meson.build
View File

@ -1,5 +1,6 @@
bsd_user_ss.add(files(
'os-stat.c',
'os-proc.c',
'os-sys.c',
'os-syscall.c',
))

98
bsd-user/freebsd/os-misc.h Normal file
View File

@ -0,0 +1,98 @@
/*
* 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 */

480
bsd-user/freebsd/os-proc.c Normal file
View File

@ -0,0 +1,480 @@
/*
* 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;
}

293
bsd-user/freebsd/os-proc.h Normal file
View File

@ -0,0 +1,293 @@
/*
* 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 */

313
bsd-user/freebsd/os-syscall.c
View File

@ -33,11 +33,15 @@
#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);
@ -58,9 +62,11 @@ safe_syscall3(ssize_t, writev, int, fd, const struct iovec *, iov, int, iovcnt);
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.
@ -219,10 +225,207 @@ static abi_long freebsd_syscall(void *cpu_env, int num, abi_long arg1,
/*
* 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.
*/
@ -592,6 +795,108 @@ static abi_long freebsd_syscall(void *cpu_env, int num, abi_long arg1,
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}

2
bsd-user/main.c
View File

@ -88,7 +88,7 @@ unsigned long reserved_va = MAX_RESERVED_VA;
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 */

7
bsd-user/meson.build
View File

@ -7,6 +7,8 @@ bsd_user_ss = ss.source_set()
common_user_inc += include_directories('include')
bsd_user_ss.add(files(
'bsd-mem.c',
'bsd-proc.c',
'bsdload.c',
'elfload.c',
'main.c',
@ -16,6 +18,11 @@ bsd_user_ss.add(files(
'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)

2
bsd-user/mmap.c
View File

@ -636,7 +636,7 @@ fail:
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;

58
bsd-user/qemu-bsd.h Normal file
View File

@ -0,0 +1,58 @@
/*
* 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 */

8
bsd-user/qemu.h
View File

@ -111,6 +111,7 @@ typedef struct TaskState {
} __attribute__((aligned(16))) TaskState;
void stop_all_tasks(void);
extern const char *interp_prefix;
extern const char *qemu_uname_release;
/*
@ -232,6 +233,7 @@ abi_long target_mremap(abi_ulong old_addr, abi_ulong old_size,
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);
@ -249,6 +251,12 @@ abi_long get_errno(abi_long ret);
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);

1
bsd-user/signal-common.h
View File

@ -35,6 +35,7 @@ int do_sigaction(int sig, const struct target_sigaction *act,
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);

6
bsd-user/signal.c
View File

@ -311,6 +311,12 @@ static void tswap_siginfo(target_siginfo_t *tinfo, const target_siginfo_t *info)
}
}
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;

89
bsd-user/syscall_defs.h
View File

@ -55,9 +55,48 @@ struct target_iovec {
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 */
@ -130,11 +169,7 @@ struct target_freebsd_timeval {
/*
* 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
@ -390,6 +425,52 @@ struct target_freebsd_flock {
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) \
{ \