]> Git Repo - qemu.git/blame - linux-user/syscall.c
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
linux-user: Fix target_semid_ds structure definition
[qemu.git] / linux-user / syscall.c
CommitLineData
31e31b8a
FB		 1/*
2 * Linux syscalls
5fafdf24 3 *
31e31b8a
FB		 4 * Copyright (c) 2003 Fabrice Bellard
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
8167ee88 17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
31e31b8a 18 */
d5b3a9b6 19#define _ATFILE_SOURCE
d39594e9 20#include "qemu/osdep.h"
f348b6d1
VB		 21#include "qemu/cutils.h"
22#include "qemu/path.h"
31e31b8a
FB		 23#include <elf.h>
24#include <endian.h>
c56dc774 25#include <grp.h>
d08d3bb8
TS		 26#include <sys/ipc.h>
27#include <sys/msg.h>
31e31b8a 28#include <sys/wait.h>
31e31b8a 29#include <sys/mount.h>
586b0bef
JS		 30#include <sys/file.h>
31#include <sys/fsuid.h>
32#include <sys/personality.h>
39b9aae1 33#include <sys/prctl.h>
31e31b8a 34#include <sys/resource.h>
31e31b8a 35#include <sys/swap.h>
e0eb210e 36#include <linux/capability.h>
31e31b8a 37#include <sched.h>
60e99246
AJ		 38#ifdef __ia64__
39int __clone2(int (*fn)(void *), void *child_stack_base,
40 size_t stack_size, int flags, void *arg, ...);
41#endif
31e31b8a 42#include <sys/socket.h>
607175e0 43#include <sys/un.h>
31e31b8a 44#include <sys/uio.h>
9de5e440 45#include <sys/poll.h>
32f36bce 46#include <sys/times.h>
8853f86e 47#include <sys/shm.h>
fa294816 48#include <sys/sem.h>
56c8f68f 49#include <sys/statfs.h>
ebc05488 50#include <utime.h>
a5448a7d 51#include <sys/sysinfo.h>
e36800c9 52#include <sys/signalfd.h>
72f03900 53//#include <sys/user.h>
8853f86e 54#include <netinet/ip.h>
7854b056 55#include <netinet/tcp.h>
86fcd946 56#include <linux/wireless.h>
920394db 57#include <linux/icmp.h>
5a61cb60 58#include "qemu-common.h"
d80a1905
RV		 59#ifdef CONFIG_TIMERFD
60#include <sys/timerfd.h>
61#endif
9788c9ca 62#ifdef TARGET_GPROF
6d946cda
AJ		 63#include <sys/gmon.h>
64#endif
c2882b96
RV		 65#ifdef CONFIG_EVENTFD
66#include <sys/eventfd.h>
67#endif
3b6edd16
PM		 68#ifdef CONFIG_EPOLL
69#include <sys/epoll.h>
70#endif
a790ae38 71#ifdef CONFIG_ATTR
1de7afc9 72#include "qemu/xattr.h"
a790ae38 73#endif
a8fd1aba
PM		 74#ifdef CONFIG_SENDFILE
75#include <sys/sendfile.h>
76#endif
31e31b8a
FB		 77
78#define termios host_termios
79#define winsize host_winsize
80#define termio host_termio
04369ff2
FB		 81#define sgttyb host_sgttyb /* same as target */
82#define tchars host_tchars /* same as target */
83#define ltchars host_ltchars /* same as target */
31e31b8a
FB		 84
85#include <linux/termios.h>
86#include <linux/unistd.h>
31e31b8a
FB		 87#include <linux/cdrom.h>
88#include <linux/hdreg.h>
89#include <linux/soundcard.h>
19b84f3c 90#include <linux/kd.h>
8fbd6b52 91#include <linux/mtio.h>
350d1779 92#include <linux/fs.h>
dace20dc 93#if defined(CONFIG_FIEMAP)
285da2b9 94#include <linux/fiemap.h>
dace20dc 95#endif
f7680a55
UH		 96#include <linux/fb.h>
97#include <linux/vt.h>
56e904ec 98#include <linux/dm-ioctl.h>
c07ecc68 99#include <linux/reboot.h>
7ff7b666 100#include <linux/route.h>
f57d4192 101#include <linux/filter.h>
fff8c539 102#include <linux/blkpg.h>
a82ea939 103#include <netpacket/packet.h>
6c5b5645 104#include <linux/netlink.h>
575b22b1 105#ifdef CONFIG_RTNETLINK
6c5b5645 106#include <linux/rtnetlink.h>
c5dff280 107#include <linux/if_bridge.h>
575b22b1 108#endif
5ce9bb59 109#include <linux/audit.h>
d7e4036e 110#include "linux_loop.h"
18cb0088 111#include "uname.h"
31e31b8a 112
3ef693a0 113#include "qemu.h"
31e31b8a 114
d865bab5
PB		 115#define CLONE_NPTL_FLAGS2 (CLONE_SETTLS | \
116 CLONE_PARENT_SETTID | CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID)
30813cea 117
72f03900 118//#define DEBUG
71a8f7fe
TB		 119/* Define DEBUG_ERESTARTSYS to force every syscall to be restarted
120 * once. This exercises the codepaths for restart.
121 */
122//#define DEBUG_ERESTARTSYS
31e31b8a 123
1a9353d2 124//#include <linux/msdos_fs.h>
6556a833
AJ		 125#define VFAT_IOCTL_READDIR_BOTH _IOR('r', 1, struct linux_dirent [2])
126#define VFAT_IOCTL_READDIR_SHORT _IOR('r', 2, struct linux_dirent [2])
1a9353d2 127
70a194b9
FB		 128#undef _syscall0
129#undef _syscall1
130#undef _syscall2
131#undef _syscall3
132#undef _syscall4
133#undef _syscall5
83fcb515 134#undef _syscall6
70a194b9 135
83fcb515 136#define _syscall0(type,name) \
8fcd3692 137static type name (void) \
83fcb515
FB		 138{ \
139 return syscall(__NR_##name); \
140}
70a194b9 141
83fcb515 142#define _syscall1(type,name,type1,arg1) \
8fcd3692 143static type name (type1 arg1) \
83fcb515
FB		 144{ \
145 return syscall(__NR_##name, arg1); \
70a194b9
FB		 146}
147
83fcb515 148#define _syscall2(type,name,type1,arg1,type2,arg2) \
8fcd3692 149static type name (type1 arg1,type2 arg2) \
83fcb515
FB		 150{ \
151 return syscall(__NR_##name, arg1, arg2); \
70a194b9
FB		 152}
153
83fcb515 154#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
8fcd3692 155static type name (type1 arg1,type2 arg2,type3 arg3) \
83fcb515
FB		 156{ \
157 return syscall(__NR_##name, arg1, arg2, arg3); \
70a194b9
FB		 158}
159
83fcb515 160#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
8fcd3692 161static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4) \
83fcb515
FB		 162{ \
163 return syscall(__NR_##name, arg1, arg2, arg3, arg4); \
70a194b9
FB		 164}
165
83fcb515
FB		 166#define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
167 type5,arg5) \
8fcd3692 168static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
83fcb515
FB		 169{ \
170 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \
70a194b9
FB		 171}
172
83fcb515
FB		 173
174#define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
175 type5,arg5,type6,arg6) \
8fcd3692
BS		 176static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5, \
177 type6 arg6) \
83fcb515
FB		 178{ \
179 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
70a194b9 180}
83fcb515 181
70a194b9 182
31e31b8a 183#define __NR_sys_uname __NR_uname
72f03900 184#define __NR_sys_getcwd1 __NR_getcwd
72f03900 185#define __NR_sys_getdents __NR_getdents
dab2ed99 186#define __NR_sys_getdents64 __NR_getdents64
c6cda17a 187#define __NR_sys_getpriority __NR_getpriority
66fb9763 188#define __NR_sys_rt_sigqueueinfo __NR_rt_sigqueueinfo
7494b0f9 189#define __NR_sys_syslog __NR_syslog
bd0c5661 190#define __NR_sys_futex __NR_futex
39b59763
AJ		 191#define __NR_sys_inotify_init __NR_inotify_init
192#define __NR_sys_inotify_add_watch __NR_inotify_add_watch
193#define __NR_sys_inotify_rm_watch __NR_inotify_rm_watch
31e31b8a 194
42a39fbe
AG		 195#if defined(__alpha__) || defined (__ia64__) || defined(__x86_64__) || \
196 defined(__s390x__)
9af9eaaa
FB		 197#define __NR__llseek __NR_lseek
198#endif
199
a29e5ba2
JH		 200/* Newer kernel ports have llseek() instead of _llseek() */
201#if defined(TARGET_NR_llseek) && !defined(TARGET_NR__llseek)
202#define TARGET_NR__llseek TARGET_NR_llseek
203#endif
204
72f03900 205#ifdef __NR_gettid
31e31b8a 206_syscall0(int, gettid)
72f03900 207#else
0da46a6e
TS		 208/* This is a replacement for the host gettid() and must return a host
209 errno. */
72f03900
FB		 210static int gettid(void) {
211 return -ENOSYS;
212}
213#endif
704eff6c 214#if defined(TARGET_NR_getdents) && defined(__NR_getdents)
3b3f24ad 215_syscall3(int, sys_getdents, uint, fd, struct linux_dirent *, dirp, uint, count);
3307e236
PM		 216#endif
217#if !defined(__NR_getdents) || \
218 (defined(TARGET_NR_getdents64) && defined(__NR_getdents64))
3b3f24ad
AJ		 219_syscall3(int, sys_getdents64, uint, fd, struct linux_dirent64 *, dirp, uint, count);
220#endif
d35b261c 221#if defined(TARGET_NR__llseek) && defined(__NR_llseek)
3b3f24ad
AJ		 222_syscall5(int, _llseek, uint, fd, ulong, hi, ulong, lo,
223 loff_t *, res, uint, wh);
224#endif
225_syscall3(int,sys_rt_sigqueueinfo,int,pid,int,sig,siginfo_t *,uinfo)
226_syscall3(int,sys_syslog,int,type,char*,bufp,int,len)
3b3f24ad
AJ		 227#ifdef __NR_exit_group
228_syscall1(int,exit_group,int,error_code)
229#endif
230#if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
231_syscall1(int,set_tid_address,int *,tidptr)
232#endif
3b3f24ad
AJ		 233#if defined(TARGET_NR_futex) && defined(__NR_futex)
234_syscall6(int,sys_futex,int *,uaddr,int,op,int,val,
235 const struct timespec *,timeout,int *,uaddr2,int,val3)
236#endif
737de1d1
MF		 237#define __NR_sys_sched_getaffinity __NR_sched_getaffinity
238_syscall3(int, sys_sched_getaffinity, pid_t, pid, unsigned int, len,
239 unsigned long *, user_mask_ptr);
240#define __NR_sys_sched_setaffinity __NR_sched_setaffinity
241_syscall3(int, sys_sched_setaffinity, pid_t, pid, unsigned int, len,
242 unsigned long *, user_mask_ptr);
0f6b4d21
AG		 243_syscall4(int, reboot, int, magic1, int, magic2, unsigned int, cmd,
244 void *, arg);
e0eb210e
PM		 245_syscall2(int, capget, struct __user_cap_header_struct *, header,
246 struct __user_cap_data_struct *, data);
247_syscall2(int, capset, struct __user_cap_header_struct *, header,
248 struct __user_cap_data_struct *, data);
ab31cda3
PB		 249#if defined(TARGET_NR_ioprio_get) && defined(__NR_ioprio_get)
250_syscall2(int, ioprio_get, int, which, int, who)
251#endif
252#if defined(TARGET_NR_ioprio_set) && defined(__NR_ioprio_set)
253_syscall3(int, ioprio_set, int, which, int, who, int, ioprio)
254#endif
f894efd1
LV		 255#if defined(TARGET_NR_getrandom) && defined(__NR_getrandom)
256_syscall3(int, getrandom, void *, buf, size_t, buflen, unsigned int, flags)
257#endif
3b3f24ad
AJ		 258
259static bitmask_transtbl fcntl_flags_tbl[] = {
260 { TARGET_O_ACCMODE, TARGET_O_WRONLY, O_ACCMODE, O_WRONLY, },
261 { TARGET_O_ACCMODE, TARGET_O_RDWR, O_ACCMODE, O_RDWR, },
262 { TARGET_O_CREAT, TARGET_O_CREAT, O_CREAT, O_CREAT, },
263 { TARGET_O_EXCL, TARGET_O_EXCL, O_EXCL, O_EXCL, },
264 { TARGET_O_NOCTTY, TARGET_O_NOCTTY, O_NOCTTY, O_NOCTTY, },
265 { TARGET_O_TRUNC, TARGET_O_TRUNC, O_TRUNC, O_TRUNC, },
266 { TARGET_O_APPEND, TARGET_O_APPEND, O_APPEND, O_APPEND, },
267 { TARGET_O_NONBLOCK, TARGET_O_NONBLOCK, O_NONBLOCK, O_NONBLOCK, },
afc8763f 268 { TARGET_O_SYNC, TARGET_O_DSYNC, O_SYNC, O_DSYNC, },
3b3f24ad
AJ		 269 { TARGET_O_SYNC, TARGET_O_SYNC, O_SYNC, O_SYNC, },
270 { TARGET_FASYNC, TARGET_FASYNC, FASYNC, FASYNC, },
271 { TARGET_O_DIRECTORY, TARGET_O_DIRECTORY, O_DIRECTORY, O_DIRECTORY, },
272 { TARGET_O_NOFOLLOW, TARGET_O_NOFOLLOW, O_NOFOLLOW, O_NOFOLLOW, },
3b3f24ad
AJ		 273#if defined(O_DIRECT)
274 { TARGET_O_DIRECT, TARGET_O_DIRECT, O_DIRECT, O_DIRECT, },
afc8763f
RH		 275#endif
276#if defined(O_NOATIME)
277 { TARGET_O_NOATIME, TARGET_O_NOATIME, O_NOATIME, O_NOATIME },
278#endif
279#if defined(O_CLOEXEC)
280 { TARGET_O_CLOEXEC, TARGET_O_CLOEXEC, O_CLOEXEC, O_CLOEXEC },
281#endif
282#if defined(O_PATH)
283 { TARGET_O_PATH, TARGET_O_PATH, O_PATH, O_PATH },
284#endif
285 /* Don't terminate the list prematurely on 64-bit host+guest. */
286#if TARGET_O_LARGEFILE != 0 || O_LARGEFILE != 0
287 { TARGET_O_LARGEFILE, TARGET_O_LARGEFILE, O_LARGEFILE, O_LARGEFILE, },
3b3f24ad
AJ		 288#endif
289 { 0, 0, 0, 0 }
290};
291
5d4d3665 292typedef abi_long (*TargetFdDataFunc)(void *, size_t);
7b36f782 293typedef abi_long (*TargetFdAddrFunc)(void *, abi_ulong, socklen_t);
e36800c9 294typedef struct TargetFdTrans {
5d4d3665
LV		 295 TargetFdDataFunc host_to_target_data;
296 TargetFdDataFunc target_to_host_data;
7b36f782 297 TargetFdAddrFunc target_to_host_addr;
e36800c9
LV		 298} TargetFdTrans;
299
300static TargetFdTrans **target_fd_trans;
301
302static unsigned int target_fd_max;
303
6c5b5645
LV		 304static TargetFdDataFunc fd_trans_target_to_host_data(int fd)
305{
306 if (fd >= 0 && fd < target_fd_max && target_fd_trans[fd]) {
307 return target_fd_trans[fd]->target_to_host_data;
308 }
309 return NULL;
310}
311
5d4d3665 312static TargetFdDataFunc fd_trans_host_to_target_data(int fd)
e36800c9 313{
861d72cd 314 if (fd >= 0 && fd < target_fd_max && target_fd_trans[fd]) {
5d4d3665 315 return target_fd_trans[fd]->host_to_target_data;
e36800c9
LV		 316 }
317 return NULL;
318}
319
7b36f782
LV		 320static TargetFdAddrFunc fd_trans_target_to_host_addr(int fd)
321{
861d72cd 322 if (fd >= 0 && fd < target_fd_max && target_fd_trans[fd]) {
7b36f782
LV		 323 return target_fd_trans[fd]->target_to_host_addr;
324 }
325 return NULL;
326}
327
e36800c9
LV		 328static void fd_trans_register(int fd, TargetFdTrans *trans)
329{
330 unsigned int oldmax;
331
332 if (fd >= target_fd_max) {
333 oldmax = target_fd_max;
334 target_fd_max = ((fd >> 6) + 1) << 6; /* by slice of 64 entries */
5089c7ce
LV		 335 target_fd_trans = g_renew(TargetFdTrans *,
336 target_fd_trans, target_fd_max);
e36800c9
LV		 337 memset((void *)(target_fd_trans + oldmax), 0,
338 (target_fd_max - oldmax) * sizeof(TargetFdTrans *));
339 }
340 target_fd_trans[fd] = trans;
341}
342
343static void fd_trans_unregister(int fd)
344{
345 if (fd >= 0 && fd < target_fd_max) {
346 target_fd_trans[fd] = NULL;
347 }
348}
349
350static void fd_trans_dup(int oldfd, int newfd)
351{
352 fd_trans_unregister(newfd);
353 if (oldfd < target_fd_max && target_fd_trans[oldfd]) {
354 fd_trans_register(newfd, target_fd_trans[oldfd]);
355 }
356}
357
3b3f24ad
AJ		 358static int sys_getcwd1(char *buf, size_t size)
359{
360 if (getcwd(buf, size) == NULL) {
361 /* getcwd() sets errno */
362 return (-1);
363 }
aaf4ad39 364 return strlen(buf)+1;
3b3f24ad
AJ		 365}
366
1acae9f2 367#ifdef TARGET_NR_utimensat
ebc996f3
RV		 368#ifdef CONFIG_UTIMENSAT
369static int sys_utimensat(int dirfd, const char *pathname,
370 const struct timespec times[2], int flags)
371{
372 if (pathname == NULL)
373 return futimens(dirfd, times);
374 else
375 return utimensat(dirfd, pathname, times, flags);
376}
1acae9f2
PM		 377#elif defined(__NR_utimensat)
378#define __NR_sys_utimensat __NR_utimensat
9007f0ef
TS		 379_syscall4(int,sys_utimensat,int,dirfd,const char *,pathname,
380 const struct timespec *,tsp,int,flags)
1acae9f2
PM		 381#else
382static int sys_utimensat(int dirfd, const char *pathname,
383 const struct timespec times[2], int flags)
384{
385 errno = ENOSYS;
386 return -1;
387}
9007f0ef 388#endif
1acae9f2 389#endif /* TARGET_NR_utimensat */
3b3f24ad
AJ		 390
391#ifdef CONFIG_INOTIFY
8690e420 392#include <sys/inotify.h>
3b3f24ad 393
39b59763 394#if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
3b3f24ad
AJ		 395static int sys_inotify_init(void)
396{
397 return (inotify_init());
398}
39b59763
AJ		 399#endif
400#if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)
3b3f24ad
AJ		 401static int sys_inotify_add_watch(int fd,const char *pathname, int32_t mask)
402{
403 return (inotify_add_watch(fd, pathname, mask));
404}
39b59763
AJ		 405#endif
406#if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)
3b3f24ad
AJ		 407static int sys_inotify_rm_watch(int fd, int32_t wd)
408{
8690e420 409 return (inotify_rm_watch(fd, wd));
3b3f24ad 410}
bd0c5661 411#endif
c05c7a73
RV		 412#ifdef CONFIG_INOTIFY1
413#if defined(TARGET_NR_inotify_init1) && defined(__NR_inotify_init1)
414static int sys_inotify_init1(int flags)
415{
416 return (inotify_init1(flags));
417}
418#endif
419#endif
3b3f24ad
AJ		 420#else
421/* Userspace can usually survive runtime without inotify */
422#undef TARGET_NR_inotify_init
c05c7a73 423#undef TARGET_NR_inotify_init1
3b3f24ad
AJ		 424#undef TARGET_NR_inotify_add_watch
425#undef TARGET_NR_inotify_rm_watch
426#endif /* CONFIG_INOTIFY */
427
163a05a8
PM		 428#if defined(TARGET_NR_prlimit64)
429#ifndef __NR_prlimit64
430# define __NR_prlimit64 -1
431#endif
432#define __NR_sys_prlimit64 __NR_prlimit64
433/* The glibc rlimit structure may not be that used by the underlying syscall */
434struct host_rlimit64 {
435 uint64_t rlim_cur;
436 uint64_t rlim_max;
437};
438_syscall4(int, sys_prlimit64, pid_t, pid, int, resource,
439 const struct host_rlimit64 *, new_limit,
440 struct host_rlimit64 *, old_limit)
441#endif
442
f4f1e10a
ECL		 443
444#if defined(TARGET_NR_timer_create)
445/* Maxiumum of 32 active POSIX timers allowed at any one time. */
446static timer_t g_posix_timers[32] = { 0, } ;
447
448static inline int next_free_host_timer(void)
449{
450 int k ;
451 /* FIXME: Does finding the next free slot require a lock? */
452 for (k = 0; k < ARRAY_SIZE(g_posix_timers); k++) {
453 if (g_posix_timers[k] == 0) {
454 g_posix_timers[k] = (timer_t) 1;
455 return k;
456 }
457 }
458 return -1;
459}
460#endif
461
48e515d4 462/* ARM EABI and MIPS expect 64bit types aligned even on pairs or registers */
4a1def4e 463#ifdef TARGET_ARM
48e515d4
RV		 464static inline int regpairs_aligned(void *cpu_env) {
465 return ((((CPUARMState *)cpu_env)->eabi) == 1) ;
466}
467#elif defined(TARGET_MIPS)
468static inline int regpairs_aligned(void *cpu_env) { return 1; }
4a1def4e
AG		 469#elif defined(TARGET_PPC) && !defined(TARGET_PPC64)
470/* SysV AVI for PPC32 expects 64bit parameters to be passed on odd/even pairs
471 * of registers which translates to the same as ARM/MIPS, because we start with
472 * r3 as arg1 */
473static inline int regpairs_aligned(void *cpu_env) { return 1; }
48e515d4
RV		 474#else
475static inline int regpairs_aligned(void *cpu_env) { return 0; }
476#endif
477
b92c47c1
TS		 478#define ERRNO_TABLE_SIZE 1200
479
480/* target_to_host_errno_table[] is initialized from
481 * host_to_target_errno_table[] in syscall_init(). */
482static uint16_t target_to_host_errno_table[ERRNO_TABLE_SIZE] = {
483};
484
637947f1 485/*
fe8f096b 486 * This list is the union of errno values overridden in asm-<arch>/errno.h
637947f1
TS		 487 * minus the errnos that are not actually generic to all archs.
488 */
b92c47c1 489static uint16_t host_to_target_errno_table[ERRNO_TABLE_SIZE] = {
08703b9f 490 [EAGAIN] = TARGET_EAGAIN,
637947f1
TS		 491 [EIDRM] = TARGET_EIDRM,
492 [ECHRNG] = TARGET_ECHRNG,
493 [EL2NSYNC] = TARGET_EL2NSYNC,
494 [EL3HLT] = TARGET_EL3HLT,
495 [EL3RST] = TARGET_EL3RST,
496 [ELNRNG] = TARGET_ELNRNG,
497 [EUNATCH] = TARGET_EUNATCH,
498 [ENOCSI] = TARGET_ENOCSI,
499 [EL2HLT] = TARGET_EL2HLT,
500 [EDEADLK] = TARGET_EDEADLK,
501 [ENOLCK] = TARGET_ENOLCK,
502 [EBADE] = TARGET_EBADE,
503 [EBADR] = TARGET_EBADR,
504 [EXFULL] = TARGET_EXFULL,
505 [ENOANO] = TARGET_ENOANO,
506 [EBADRQC] = TARGET_EBADRQC,
507 [EBADSLT] = TARGET_EBADSLT,
508 [EBFONT] = TARGET_EBFONT,
509 [ENOSTR] = TARGET_ENOSTR,
510 [ENODATA] = TARGET_ENODATA,
511 [ETIME] = TARGET_ETIME,
512 [ENOSR] = TARGET_ENOSR,
513 [ENONET] = TARGET_ENONET,
514 [ENOPKG] = TARGET_ENOPKG,
515 [EREMOTE] = TARGET_EREMOTE,
516 [ENOLINK] = TARGET_ENOLINK,
517 [EADV] = TARGET_EADV,
518 [ESRMNT] = TARGET_ESRMNT,
519 [ECOMM] = TARGET_ECOMM,
520 [EPROTO] = TARGET_EPROTO,
521 [EDOTDOT] = TARGET_EDOTDOT,
522 [EMULTIHOP] = TARGET_EMULTIHOP,
523 [EBADMSG] = TARGET_EBADMSG,
524 [ENAMETOOLONG] = TARGET_ENAMETOOLONG,
525 [EOVERFLOW] = TARGET_EOVERFLOW,
526 [ENOTUNIQ] = TARGET_ENOTUNIQ,
527 [EBADFD] = TARGET_EBADFD,
528 [EREMCHG] = TARGET_EREMCHG,
529 [ELIBACC] = TARGET_ELIBACC,
530 [ELIBBAD] = TARGET_ELIBBAD,
531 [ELIBSCN] = TARGET_ELIBSCN,
532 [ELIBMAX] = TARGET_ELIBMAX,
533 [ELIBEXEC] = TARGET_ELIBEXEC,
534 [EILSEQ] = TARGET_EILSEQ,
535 [ENOSYS] = TARGET_ENOSYS,
536 [ELOOP] = TARGET_ELOOP,
537 [ERESTART] = TARGET_ERESTART,
538 [ESTRPIPE] = TARGET_ESTRPIPE,
539 [ENOTEMPTY] = TARGET_ENOTEMPTY,
540 [EUSERS] = TARGET_EUSERS,
541 [ENOTSOCK] = TARGET_ENOTSOCK,
542 [EDESTADDRREQ] = TARGET_EDESTADDRREQ,
543 [EMSGSIZE] = TARGET_EMSGSIZE,
544 [EPROTOTYPE] = TARGET_EPROTOTYPE,
545 [ENOPROTOOPT] = TARGET_ENOPROTOOPT,
546 [EPROTONOSUPPORT] = TARGET_EPROTONOSUPPORT,
547 [ESOCKTNOSUPPORT] = TARGET_ESOCKTNOSUPPORT,
548 [EOPNOTSUPP] = TARGET_EOPNOTSUPP,
549 [EPFNOSUPPORT] = TARGET_EPFNOSUPPORT,
550 [EAFNOSUPPORT] = TARGET_EAFNOSUPPORT,
551 [EADDRINUSE] = TARGET_EADDRINUSE,
552 [EADDRNOTAVAIL] = TARGET_EADDRNOTAVAIL,
553 [ENETDOWN] = TARGET_ENETDOWN,
554 [ENETUNREACH] = TARGET_ENETUNREACH,
555 [ENETRESET] = TARGET_ENETRESET,
556 [ECONNABORTED] = TARGET_ECONNABORTED,
557 [ECONNRESET] = TARGET_ECONNRESET,
558 [ENOBUFS] = TARGET_ENOBUFS,
559 [EISCONN] = TARGET_EISCONN,
560 [ENOTCONN] = TARGET_ENOTCONN,
561 [EUCLEAN] = TARGET_EUCLEAN,
562 [ENOTNAM] = TARGET_ENOTNAM,
563 [ENAVAIL] = TARGET_ENAVAIL,
564 [EISNAM] = TARGET_EISNAM,
565 [EREMOTEIO] = TARGET_EREMOTEIO,
566 [ESHUTDOWN] = TARGET_ESHUTDOWN,
567 [ETOOMANYREFS] = TARGET_ETOOMANYREFS,
568 [ETIMEDOUT] = TARGET_ETIMEDOUT,
569 [ECONNREFUSED] = TARGET_ECONNREFUSED,
570 [EHOSTDOWN] = TARGET_EHOSTDOWN,
571 [EHOSTUNREACH] = TARGET_EHOSTUNREACH,
572 [EALREADY] = TARGET_EALREADY,
573 [EINPROGRESS] = TARGET_EINPROGRESS,
574 [ESTALE] = TARGET_ESTALE,
575 [ECANCELED] = TARGET_ECANCELED,
576 [ENOMEDIUM] = TARGET_ENOMEDIUM,
577 [EMEDIUMTYPE] = TARGET_EMEDIUMTYPE,
b7fe5db7 578#ifdef ENOKEY
637947f1 579 [ENOKEY] = TARGET_ENOKEY,
b7fe5db7
TS		 580#endif
581#ifdef EKEYEXPIRED
637947f1 582 [EKEYEXPIRED] = TARGET_EKEYEXPIRED,
b7fe5db7
TS		 583#endif
584#ifdef EKEYREVOKED
637947f1 585 [EKEYREVOKED] = TARGET_EKEYREVOKED,
b7fe5db7
TS		 586#endif
587#ifdef EKEYREJECTED
637947f1 588 [EKEYREJECTED] = TARGET_EKEYREJECTED,
b7fe5db7
TS		 589#endif
590#ifdef EOWNERDEAD
637947f1 591 [EOWNERDEAD] = TARGET_EOWNERDEAD,
b7fe5db7
TS		 592#endif
593#ifdef ENOTRECOVERABLE
637947f1 594 [ENOTRECOVERABLE] = TARGET_ENOTRECOVERABLE,
b7fe5db7 595#endif
b92c47c1 596};
637947f1
TS		 597
598static inline int host_to_target_errno(int err)
599{
2466119c
TB		 600 if (err >= 0 && err < ERRNO_TABLE_SIZE &&
601 host_to_target_errno_table[err]) {
637947f1 602 return host_to_target_errno_table[err];
2466119c 603 }
637947f1
TS		 604 return err;
605}
606
b92c47c1
TS		 607static inline int target_to_host_errno(int err)
608{
2466119c
TB		 609 if (err >= 0 && err < ERRNO_TABLE_SIZE &&
610 target_to_host_errno_table[err]) {
b92c47c1 611 return target_to_host_errno_table[err];
2466119c 612 }
b92c47c1
TS		 613 return err;
614}
615
992f48a0 616static inline abi_long get_errno(abi_long ret)
31e31b8a
FB		 617{
618 if (ret == -1)
637947f1 619 return -host_to_target_errno(errno);
31e31b8a
FB		 620 else
621 return ret;
622}
623
992f48a0 624static inline int is_error(abi_long ret)
31e31b8a 625{
992f48a0 626 return (abi_ulong)ret >= (abi_ulong)(-4096);
31e31b8a
FB		 627}
628
7dcdaeaf 629const char *target_strerror(int err)
b92c47c1 630{
da2a34f7
PM		 631 if (err == TARGET_ERESTARTSYS) {
632 return "To be restarted";
633 }
634 if (err == TARGET_QEMU_ESIGRETURN) {
635 return "Successful exit from sigreturn";
636 }
637
962b289e
AG		 638 if ((err >= ERRNO_TABLE_SIZE) || (err < 0)) {
639 return NULL;
640 }
b92c47c1
TS		 641 return strerror(target_to_host_errno(err));
642}
643
4d330cee
TB		 644#define safe_syscall0(type, name) \
645static type safe_##name(void) \
646{ \
647 return safe_syscall(__NR_##name); \
648}
649
650#define safe_syscall1(type, name, type1, arg1) \
651static type safe_##name(type1 arg1) \
652{ \
653 return safe_syscall(__NR_##name, arg1); \
654}
655
656#define safe_syscall2(type, name, type1, arg1, type2, arg2) \
657static type safe_##name(type1 arg1, type2 arg2) \
658{ \
659 return safe_syscall(__NR_##name, arg1, arg2); \
660}
661
662#define safe_syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \
663static type safe_##name(type1 arg1, type2 arg2, type3 arg3) \
664{ \
665 return safe_syscall(__NR_##name, arg1, arg2, arg3); \
666}
667
668#define safe_syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \
669 type4, arg4) \
670static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
671{ \
672 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4); \
673}
674
675#define safe_syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \
676 type4, arg4, type5, arg5) \
677static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
678 type5 arg5) \
679{ \
680 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \
681}
682
683#define safe_syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \
684 type4, arg4, type5, arg5, type6, arg6) \
685static type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
686 type5 arg5, type6 arg6) \
687{ \
688 return safe_syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
689}
690
50afd02b
TB		 691safe_syscall3(ssize_t, read, int, fd, void *, buff, size_t, count)
692safe_syscall3(ssize_t, write, int, fd, const void *, buff, size_t, count)
c10a0738
TB		 693safe_syscall4(int, openat, int, dirfd, const char *, pathname, \
694 int, flags, mode_t, mode)
4af80a37
TB		 695safe_syscall4(pid_t, wait4, pid_t, pid, int *, status, int, options, \
696 struct rusage *, rusage)
697safe_syscall5(int, waitid, idtype_t, idtype, id_t, id, siginfo_t *, infop, \
698 int, options, struct rusage *, rusage)
ffdcbe22 699safe_syscall3(int, execve, const char *, filename, char **, argv, char **, envp)
6df9d38d
PM		 700safe_syscall6(int, pselect6, int, nfds, fd_set *, readfds, fd_set *, writefds, \
701 fd_set *, exceptfds, struct timespec *, timeout, void *, sig)
a6130237
PM		 702safe_syscall5(int, ppoll, struct pollfd *, ufds, unsigned int, nfds,
703 struct timespec *, tsp, const sigset_t *, sigmask,
704 size_t, sigsetsize)
227f0214
PM		 705safe_syscall6(int, epoll_pwait, int, epfd, struct epoll_event *, events,
706 int, maxevents, int, timeout, const sigset_t *, sigmask,
707 size_t, sigsetsize)
d509eeb1
PM		 708safe_syscall6(int,futex,int *,uaddr,int,op,int,val, \
709 const struct timespec *,timeout,int *,uaddr2,int,val3)
2fe4fba1 710safe_syscall2(int, rt_sigsuspend, sigset_t *, newset, size_t, sigsetsize)
bef653d9
PM		 711safe_syscall2(int, kill, pid_t, pid, int, sig)
712safe_syscall2(int, tkill, int, tid, int, sig)
713safe_syscall3(int, tgkill, int, tgid, int, pid, int, sig)
918c03ed
PM		 714safe_syscall3(ssize_t, readv, int, fd, const struct iovec *, iov, int, iovcnt)
715safe_syscall3(ssize_t, writev, int, fd, const struct iovec *, iov, int, iovcnt)
2a3c7619
PM		 716safe_syscall3(int, connect, int, fd, const struct sockaddr *, addr,
717 socklen_t, addrlen)
66687530
PM		 718safe_syscall6(ssize_t, sendto, int, fd, const void *, buf, size_t, len,
719 int, flags, const struct sockaddr *, addr, socklen_t, addrlen)
720safe_syscall6(ssize_t, recvfrom, int, fd, void *, buf, size_t, len,
721 int, flags, struct sockaddr *, addr, socklen_t *, addrlen)
722safe_syscall3(ssize_t, sendmsg, int, fd, const struct msghdr *, msg, int, flags)
723safe_syscall3(ssize_t, recvmsg, int, fd, struct msghdr *, msg, int, flags)
2a845989 724safe_syscall2(int, flock, int, fd, int, operation)
b3f82330
PM		 725safe_syscall4(int, rt_sigtimedwait, const sigset_t *, these, siginfo_t *, uinfo,
726 const struct timespec *, uts, size_t, sigsetsize)
ff6dc130
PM		 727safe_syscall4(int, accept4, int, fd, struct sockaddr *, addr, socklen_t *, len,
728 int, flags)
9e518226
PM		 729safe_syscall2(int, nanosleep, const struct timespec *, req,
730 struct timespec *, rem)
731#ifdef TARGET_NR_clock_nanosleep
732safe_syscall4(int, clock_nanosleep, const clockid_t, clock, int, flags,
733 const struct timespec *, req, struct timespec *, rem)
734#endif
89f9fe44
PM		 735#ifdef __NR_msgsnd
736safe_syscall4(int, msgsnd, int, msgid, const void *, msgp, size_t, sz,
737 int, flags)
738safe_syscall5(int, msgrcv, int, msgid, void *, msgp, size_t, sz,
739 long, msgtype, int, flags)
ffb7ee79
PM		 740safe_syscall4(int, semtimedop, int, semid, struct sembuf *, tsops,
741 unsigned, nsops, const struct timespec *, timeout)
89f9fe44
PM		 742#else
743/* This host kernel architecture uses a single ipc syscall; fake up
744 * wrappers for the sub-operations to hide this implementation detail.
745 * Annoyingly we can't include linux/ipc.h to get the constant definitions
746 * for the call parameter because some structs in there conflict with the
747 * sys/ipc.h ones. So we just define them here, and rely on them being
748 * the same for all host architectures.
749 */
ffb7ee79 750#define Q_SEMTIMEDOP 4
89f9fe44
PM		 751#define Q_MSGSND 11
752#define Q_MSGRCV 12
753#define Q_IPCCALL(VERSION, OP) ((VERSION) << 16 | (OP))
754
755safe_syscall6(int, ipc, int, call, long, first, long, second, long, third,
756 void *, ptr, long, fifth)
757static int safe_msgsnd(int msgid, const void *msgp, size_t sz, int flags)
758{
759 return safe_ipc(Q_IPCCALL(0, Q_MSGSND), msgid, sz, flags, (void *)msgp, 0);
760}
761static int safe_msgrcv(int msgid, void *msgp, size_t sz, long type, int flags)
762{
763 return safe_ipc(Q_IPCCALL(1, Q_MSGRCV), msgid, sz, flags, msgp, type);
764}
ffb7ee79
PM		 765static int safe_semtimedop(int semid, struct sembuf *tsops, unsigned nsops,
766 const struct timespec *timeout)
767{
768 return safe_ipc(Q_IPCCALL(0, Q_SEMTIMEDOP), semid, nsops, 0, tsops,
769 (long)timeout);
770}
89f9fe44 771#endif
d40ecd66
PM		 772#if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
773safe_syscall5(int, mq_timedsend, int, mqdes, const char *, msg_ptr,
774 size_t, len, unsigned, prio, const struct timespec *, timeout)
775safe_syscall5(int, mq_timedreceive, int, mqdes, char *, msg_ptr,
776 size_t, len, unsigned *, prio, const struct timespec *, timeout)
777#endif
49ca6f3e
PM		 778/* We do ioctl like this rather than via safe_syscall3 to preserve the
779 * "third argument might be integer or pointer or not present" behaviour of
780 * the libc function.
781 */
782#define safe_ioctl(...) safe_syscall(__NR_ioctl, __VA_ARGS__)
435da5e7
PM		 783/* Similarly for fcntl. Note that callers must always:
784 * pass the F_GETLK64 etc constants rather than the unsuffixed F_GETLK
785 * use the flock64 struct rather than unsuffixed flock
786 * This will then work and use a 64-bit offset for both 32-bit and 64-bit hosts.
787 */
788#ifdef __NR_fcntl64
789#define safe_fcntl(...) safe_syscall(__NR_fcntl64, __VA_ARGS__)
790#else
791#define safe_fcntl(...) safe_syscall(__NR_fcntl, __VA_ARGS__)
792#endif
50afd02b 793
8289d112
PB		 794static inline int host_to_target_sock_type(int host_type)
795{
796 int target_type;
797
798 switch (host_type & 0xf /* SOCK_TYPE_MASK */) {
799 case SOCK_DGRAM:
800 target_type = TARGET_SOCK_DGRAM;
801 break;
802 case SOCK_STREAM:
803 target_type = TARGET_SOCK_STREAM;
804 break;
805 default:
806 target_type = host_type & 0xf /* SOCK_TYPE_MASK */;
807 break;
808 }
809
810#if defined(SOCK_CLOEXEC)
811 if (host_type & SOCK_CLOEXEC) {
812 target_type |= TARGET_SOCK_CLOEXEC;
813 }
814#endif
815
816#if defined(SOCK_NONBLOCK)
817 if (host_type & SOCK_NONBLOCK) {
818 target_type |= TARGET_SOCK_NONBLOCK;
819 }
820#endif
821
822 return target_type;
823}
824
992f48a0
BS		 825static abi_ulong target_brk;
826static abi_ulong target_original_brk;
4d1de87c 827static abi_ulong brk_page;
31e31b8a 828
992f48a0 829void target_set_brk(abi_ulong new_brk)
31e31b8a 830{
4c1de73d 831 target_original_brk = target_brk = HOST_PAGE_ALIGN(new_brk);
4d1de87c 832 brk_page = HOST_PAGE_ALIGN(target_brk);
31e31b8a
FB		 833}
834
4d1de87c
CV		 835//#define DEBUGF_BRK(message, args...) do { fprintf(stderr, (message), ## args); } while (0)
836#define DEBUGF_BRK(message, args...)
837
0da46a6e 838/* do_brk() must return target values and target errnos. */
992f48a0 839abi_long do_brk(abi_ulong new_brk)
31e31b8a 840{
992f48a0 841 abi_long mapped_addr;
31e31b8a
FB		 842 int new_alloc_size;
843
3a0c6c4a 844 DEBUGF_BRK("do_brk(" TARGET_ABI_FMT_lx ") -> ", new_brk);
4d1de87c
CV		 845
846 if (!new_brk) {
3a0c6c4a 847 DEBUGF_BRK(TARGET_ABI_FMT_lx " (!new_brk)\n", target_brk);
53a5960a 848 return target_brk;
4d1de87c
CV		 849 }
850 if (new_brk < target_original_brk) {
3a0c6c4a
PB		 851 DEBUGF_BRK(TARGET_ABI_FMT_lx " (new_brk < target_original_brk)\n",
852 target_brk);
7ab240ad 853 return target_brk;
4d1de87c 854 }
3b46e624 855
4d1de87c
CV		 856 /* If the new brk is less than the highest page reserved to the
857 * target heap allocation, set it and we're almost done... */
858 if (new_brk <= brk_page) {
859 /* Heap contents are initialized to zero, as for anonymous
860 * mapped pages. */
861 if (new_brk > target_brk) {
862 memset(g2h(target_brk), 0, new_brk - target_brk);
863 }
31e31b8a 864 target_brk = new_brk;
3a0c6c4a 865 DEBUGF_BRK(TARGET_ABI_FMT_lx " (new_brk <= brk_page)\n", target_brk);
53a5960a 866 return target_brk;
31e31b8a
FB		 867 }
868
00faf08c
PM		 869 /* We need to allocate more memory after the brk... Note that
870 * we don't use MAP_FIXED because that will map over the top of
871 * any existing mapping (like the one with the host libc or qemu
872 * itself); instead we treat "mapped but at wrong address" as
873 * a failure and unmap again.
874 */
4d1de87c 875 new_alloc_size = HOST_PAGE_ALIGN(new_brk - brk_page);
5fafdf24 876 mapped_addr = get_errno(target_mmap(brk_page, new_alloc_size,
54936004 877 PROT_READ|PROT_WRITE,
00faf08c
PM		 878 MAP_ANON|MAP_PRIVATE, 0, 0));
879
880 if (mapped_addr == brk_page) {
70afc343
CV		 881 /* Heap contents are initialized to zero, as for anonymous
882 * mapped pages. Technically the new pages are already
883 * initialized to zero since they *are* anonymous mapped
884 * pages, however we have to take care with the contents that
885 * come from the remaining part of the previous page: it may
886 * contains garbage data due to a previous heap usage (grown
887 * then shrunken). */
888 memset(g2h(target_brk), 0, brk_page - target_brk);
889
00faf08c 890 target_brk = new_brk;
4d1de87c 891 brk_page = HOST_PAGE_ALIGN(target_brk);
3a0c6c4a
PB		 892 DEBUGF_BRK(TARGET_ABI_FMT_lx " (mapped_addr == brk_page)\n",
893 target_brk);
00faf08c
PM		 894 return target_brk;
895 } else if (mapped_addr != -1) {
896 /* Mapped but at wrong address, meaning there wasn't actually
897 * enough space for this brk.
898 */
899 target_munmap(mapped_addr, new_alloc_size);
900 mapped_addr = -1;
3a0c6c4a 901 DEBUGF_BRK(TARGET_ABI_FMT_lx " (mapped_addr != -1)\n", target_brk);
4d1de87c
CV		 902 }
903 else {
3a0c6c4a 904 DEBUGF_BRK(TARGET_ABI_FMT_lx " (otherwise)\n", target_brk);
00faf08c 905 }
7ab240ad 906
7dd46c02
RH		 907#if defined(TARGET_ALPHA)
908 /* We (partially) emulate OSF/1 on Alpha, which requires we
909 return a proper errno, not an unchanged brk value. */
00faf08c 910 return -TARGET_ENOMEM;
7dd46c02 911#endif
00faf08c 912 /* For everything else, return the previous break. */
7ab240ad 913 return target_brk;
31e31b8a
FB		 914}
915
26edcf41
TS		 916static inline abi_long copy_from_user_fdset(fd_set *fds,
917 abi_ulong target_fds_addr,
918 int n)
31e31b8a 919{
26edcf41
TS		 920 int i, nw, j, k;
921 abi_ulong b, *target_fds;
922
b1b2db29 923 nw = DIV_ROUND_UP(n, TARGET_ABI_BITS);
26edcf41
TS		 924 if (!(target_fds = lock_user(VERIFY_READ,
925 target_fds_addr,
926 sizeof(abi_ulong) * nw,
927 1)))
928 return -TARGET_EFAULT;
929
930 FD_ZERO(fds);
931 k = 0;
932 for (i = 0; i < nw; i++) {
933 /* grab the abi_ulong */
934 __get_user(b, &target_fds[i]);
935 for (j = 0; j < TARGET_ABI_BITS; j++) {
936 /* check the bit inside the abi_ulong */
937 if ((b >> j) & 1)
938 FD_SET(k, fds);
939 k++;
31e31b8a 940 }
31e31b8a 941 }
26edcf41
TS		 942
943 unlock_user(target_fds, target_fds_addr, 0);
944
945 return 0;
31e31b8a
FB		 946}
947
055e0906
MF		 948static inline abi_ulong copy_from_user_fdset_ptr(fd_set *fds, fd_set **fds_ptr,
949 abi_ulong target_fds_addr,
950 int n)
951{
952 if (target_fds_addr) {
953 if (copy_from_user_fdset(fds, target_fds_addr, n))
954 return -TARGET_EFAULT;
955 *fds_ptr = fds;
956 } else {
957 *fds_ptr = NULL;
958 }
959 return 0;
960}
961
26edcf41
TS		 962static inline abi_long copy_to_user_fdset(abi_ulong target_fds_addr,
963 const fd_set *fds,
964 int n)
31e31b8a 965{
31e31b8a 966 int i, nw, j, k;
992f48a0 967 abi_long v;
26edcf41 968 abi_ulong *target_fds;
31e31b8a 969
b1b2db29 970 nw = DIV_ROUND_UP(n, TARGET_ABI_BITS);
26edcf41
TS		 971 if (!(target_fds = lock_user(VERIFY_WRITE,
972 target_fds_addr,
973 sizeof(abi_ulong) * nw,
974 0)))
975 return -TARGET_EFAULT;
976
977 k = 0;
978 for (i = 0; i < nw; i++) {
979 v = 0;
980 for (j = 0; j < TARGET_ABI_BITS; j++) {
9ab709be 981 v |= ((abi_ulong)(FD_ISSET(k, fds) != 0) << j);
26edcf41 982 k++;
31e31b8a 983 }
26edcf41 984 __put_user(v, &target_fds[i]);
31e31b8a 985 }
26edcf41
TS		 986
987 unlock_user(target_fds, target_fds_addr, sizeof(abi_ulong) * nw);
988
989 return 0;
31e31b8a
FB		 990}
991
c596ed17
FB		 992#if defined(__alpha__)
993#define HOST_HZ 1024
994#else
995#define HOST_HZ 100
996#endif
997
992f48a0 998static inline abi_long host_to_target_clock_t(long ticks)
c596ed17
FB		 999{
1000#if HOST_HZ == TARGET_HZ
1001 return ticks;
1002#else
1003 return ((int64_t)ticks * TARGET_HZ) / HOST_HZ;
1004#endif
1005}
1006
579a97f7
FB		 1007static inline abi_long host_to_target_rusage(abi_ulong target_addr,
1008 const struct rusage *rusage)
b409186b 1009{
53a5960a
PB		 1010 struct target_rusage *target_rusage;
1011
579a97f7
FB		 1012 if (!lock_user_struct(VERIFY_WRITE, target_rusage, target_addr, 0))
1013 return -TARGET_EFAULT;
cbb21eed
MB		 1014 target_rusage->ru_utime.tv_sec = tswapal(rusage->ru_utime.tv_sec);
1015 target_rusage->ru_utime.tv_usec = tswapal(rusage->ru_utime.tv_usec);
1016 target_rusage->ru_stime.tv_sec = tswapal(rusage->ru_stime.tv_sec);
1017 target_rusage->ru_stime.tv_usec = tswapal(rusage->ru_stime.tv_usec);
1018 target_rusage->ru_maxrss = tswapal(rusage->ru_maxrss);
1019 target_rusage->ru_ixrss = tswapal(rusage->ru_ixrss);
1020 target_rusage->ru_idrss = tswapal(rusage->ru_idrss);
1021 target_rusage->ru_isrss = tswapal(rusage->ru_isrss);
1022 target_rusage->ru_minflt = tswapal(rusage->ru_minflt);
1023 target_rusage->ru_majflt = tswapal(rusage->ru_majflt);
1024 target_rusage->ru_nswap = tswapal(rusage->ru_nswap);
1025 target_rusage->ru_inblock = tswapal(rusage->ru_inblock);
1026 target_rusage->ru_oublock = tswapal(rusage->ru_oublock);
1027 target_rusage->ru_msgsnd = tswapal(rusage->ru_msgsnd);
1028 target_rusage->ru_msgrcv = tswapal(rusage->ru_msgrcv);
1029 target_rusage->ru_nsignals = tswapal(rusage->ru_nsignals);
1030 target_rusage->ru_nvcsw = tswapal(rusage->ru_nvcsw);
1031 target_rusage->ru_nivcsw = tswapal(rusage->ru_nivcsw);
53a5960a 1032 unlock_user_struct(target_rusage, target_addr, 1);
579a97f7
FB		 1033
1034 return 0;
b409186b
FB		 1035}
1036
cbb21eed 1037static inline rlim_t target_to_host_rlim(abi_ulong target_rlim)
81bbe906 1038{
cbb21eed 1039 abi_ulong target_rlim_swap;
95b33b2f
WT		 1040 rlim_t result;
1041
cbb21eed
MB		 1042 target_rlim_swap = tswapal(target_rlim);
1043 if (target_rlim_swap == TARGET_RLIM_INFINITY)
1044 return RLIM_INFINITY;
1045
1046 result = target_rlim_swap;
1047 if (target_rlim_swap != (rlim_t)result)
1048 return RLIM_INFINITY;
95b33b2f
WT		 1049
1050 return result;
81bbe906
TY		 1051}
1052
cbb21eed 1053static inline abi_ulong host_to_target_rlim(rlim_t rlim)
81bbe906 1054{
cbb21eed
MB		 1055 abi_ulong target_rlim_swap;
1056 abi_ulong result;
95b33b2f 1057
cbb21eed 1058 if (rlim == RLIM_INFINITY || rlim != (abi_long)rlim)
95b33b2f 1059 target_rlim_swap = TARGET_RLIM_INFINITY;
81bbe906 1060 else
95b33b2f 1061 target_rlim_swap = rlim;
cbb21eed 1062 result = tswapal(target_rlim_swap);
95b33b2f
WT		 1063
1064 return result;
81bbe906
TY		 1065}
1066
e22b7015
WT		 1067static inline int target_to_host_resource(int code)
1068{
1069 switch (code) {
1070 case TARGET_RLIMIT_AS:
1071 return RLIMIT_AS;
1072 case TARGET_RLIMIT_CORE:
1073 return RLIMIT_CORE;
1074 case TARGET_RLIMIT_CPU:
1075 return RLIMIT_CPU;
1076 case TARGET_RLIMIT_DATA:
1077 return RLIMIT_DATA;
1078 case TARGET_RLIMIT_FSIZE:
1079 return RLIMIT_FSIZE;
1080 case TARGET_RLIMIT_LOCKS:
1081 return RLIMIT_LOCKS;
1082 case TARGET_RLIMIT_MEMLOCK:
1083 return RLIMIT_MEMLOCK;
1084 case TARGET_RLIMIT_MSGQUEUE:
1085 return RLIMIT_MSGQUEUE;
1086 case TARGET_RLIMIT_NICE:
1087 return RLIMIT_NICE;
1088 case TARGET_RLIMIT_NOFILE:
1089 return RLIMIT_NOFILE;
1090 case TARGET_RLIMIT_NPROC:
1091 return RLIMIT_NPROC;
1092 case TARGET_RLIMIT_RSS:
1093 return RLIMIT_RSS;
1094 case TARGET_RLIMIT_RTPRIO:
1095 return RLIMIT_RTPRIO;
1096 case TARGET_RLIMIT_SIGPENDING:
1097 return RLIMIT_SIGPENDING;
1098 case TARGET_RLIMIT_STACK:
1099 return RLIMIT_STACK;
1100 default:
1101 return code;
1102 }
1103}
1104
788f5ec4
TS		 1105static inline abi_long copy_from_user_timeval(struct timeval *tv,
1106 abi_ulong target_tv_addr)
31e31b8a 1107{
53a5960a
PB		 1108 struct target_timeval *target_tv;
1109
788f5ec4 1110 if (!lock_user_struct(VERIFY_READ, target_tv, target_tv_addr, 1))
579a97f7 1111 return -TARGET_EFAULT;
788f5ec4
TS		 1112
1113 __get_user(tv->tv_sec, &target_tv->tv_sec);
1114 __get_user(tv->tv_usec, &target_tv->tv_usec);
1115
1116 unlock_user_struct(target_tv, target_tv_addr, 0);
579a97f7
FB		 1117
1118 return 0;
31e31b8a
FB		 1119}
1120
788f5ec4
TS		 1121static inline abi_long copy_to_user_timeval(abi_ulong target_tv_addr,
1122 const struct timeval *tv)
31e31b8a 1123{
53a5960a
PB		 1124 struct target_timeval *target_tv;
1125
788f5ec4 1126 if (!lock_user_struct(VERIFY_WRITE, target_tv, target_tv_addr, 0))
579a97f7 1127 return -TARGET_EFAULT;
788f5ec4
TS		 1128
1129 __put_user(tv->tv_sec, &target_tv->tv_sec);
1130 __put_user(tv->tv_usec, &target_tv->tv_usec);
1131
1132 unlock_user_struct(target_tv, target_tv_addr, 1);
579a97f7
FB		 1133
1134 return 0;
31e31b8a
FB		 1135}
1136
ef4467e9
PB		 1137static inline abi_long copy_from_user_timezone(struct timezone *tz,
1138 abi_ulong target_tz_addr)
1139{
1140 struct target_timezone *target_tz;
1141
1142 if (!lock_user_struct(VERIFY_READ, target_tz, target_tz_addr, 1)) {
1143 return -TARGET_EFAULT;
1144 }
1145
1146 __get_user(tz->tz_minuteswest, &target_tz->tz_minuteswest);
1147 __get_user(tz->tz_dsttime, &target_tz->tz_dsttime);
1148
1149 unlock_user_struct(target_tz, target_tz_addr, 0);
1150
1151 return 0;
1152}
1153
8ec9cf89
NF		 1154#if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
1155#include <mqueue.h>
1156
24e1003a
AJ		 1157static inline abi_long copy_from_user_mq_attr(struct mq_attr *attr,
1158 abi_ulong target_mq_attr_addr)
1159{
1160 struct target_mq_attr *target_mq_attr;
1161
1162 if (!lock_user_struct(VERIFY_READ, target_mq_attr,
1163 target_mq_attr_addr, 1))
1164 return -TARGET_EFAULT;
1165
1166 __get_user(attr->mq_flags, &target_mq_attr->mq_flags);
1167 __get_user(attr->mq_maxmsg, &target_mq_attr->mq_maxmsg);
1168 __get_user(attr->mq_msgsize, &target_mq_attr->mq_msgsize);
1169 __get_user(attr->mq_curmsgs, &target_mq_attr->mq_curmsgs);
1170
1171 unlock_user_struct(target_mq_attr, target_mq_attr_addr, 0);
1172
1173 return 0;
1174}
1175
1176static inline abi_long copy_to_user_mq_attr(abi_ulong target_mq_attr_addr,
1177 const struct mq_attr *attr)
1178{
1179 struct target_mq_attr *target_mq_attr;
1180
1181 if (!lock_user_struct(VERIFY_WRITE, target_mq_attr,
1182 target_mq_attr_addr, 0))
1183 return -TARGET_EFAULT;
1184
1185 __put_user(attr->mq_flags, &target_mq_attr->mq_flags);
1186 __put_user(attr->mq_maxmsg, &target_mq_attr->mq_maxmsg);
1187 __put_user(attr->mq_msgsize, &target_mq_attr->mq_msgsize);
1188 __put_user(attr->mq_curmsgs, &target_mq_attr->mq_curmsgs);
1189
1190 unlock_user_struct(target_mq_attr, target_mq_attr_addr, 1);
1191
1192 return 0;
1193}
8ec9cf89 1194#endif
31e31b8a 1195
055e0906 1196#if defined(TARGET_NR_select) || defined(TARGET_NR__newselect)
0da46a6e 1197/* do_select() must return target values and target errnos. */
992f48a0 1198static abi_long do_select(int n,
26edcf41
TS		 1199 abi_ulong rfd_addr, abi_ulong wfd_addr,
1200 abi_ulong efd_addr, abi_ulong target_tv_addr)
31e31b8a
FB		 1201{
1202 fd_set rfds, wfds, efds;
1203 fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
6df9d38d
PM		 1204 struct timeval tv;
1205 struct timespec ts, *ts_ptr;
992f48a0 1206 abi_long ret;
31e31b8a 1207
055e0906
MF		 1208 ret = copy_from_user_fdset_ptr(&rfds, &rfds_ptr, rfd_addr, n);
1209 if (ret) {
1210 return ret;
53a5960a 1211 }
055e0906
MF		 1212 ret = copy_from_user_fdset_ptr(&wfds, &wfds_ptr, wfd_addr, n);
1213 if (ret) {
1214 return ret;
53a5960a 1215 }
055e0906
MF		 1216 ret = copy_from_user_fdset_ptr(&efds, &efds_ptr, efd_addr, n);
1217 if (ret) {
1218 return ret;
53a5960a 1219 }
3b46e624 1220
26edcf41 1221 if (target_tv_addr) {
788f5ec4
TS		 1222 if (copy_from_user_timeval(&tv, target_tv_addr))
1223 return -TARGET_EFAULT;
6df9d38d
PM		 1224 ts.tv_sec = tv.tv_sec;
1225 ts.tv_nsec = tv.tv_usec * 1000;
1226 ts_ptr = &ts;
31e31b8a 1227 } else {
6df9d38d 1228 ts_ptr = NULL;
31e31b8a 1229 }
26edcf41 1230
6df9d38d
PM		 1231 ret = get_errno(safe_pselect6(n, rfds_ptr, wfds_ptr, efds_ptr,
1232 ts_ptr, NULL));
53a5960a 1233
26edcf41
TS		 1234 if (!is_error(ret)) {
1235 if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n))
1236 return -TARGET_EFAULT;
1237 if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n))
1238 return -TARGET_EFAULT;
1239 if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n))
1240 return -TARGET_EFAULT;
31e31b8a 1241
6df9d38d
PM		 1242 if (target_tv_addr) {
1243 tv.tv_sec = ts.tv_sec;
1244 tv.tv_usec = ts.tv_nsec / 1000;
1245 if (copy_to_user_timeval(target_tv_addr, &tv)) {
1246 return -TARGET_EFAULT;
1247 }
1248 }
31e31b8a 1249 }
579a97f7 1250
31e31b8a
FB		 1251 return ret;
1252}
055e0906 1253#endif
31e31b8a 1254
099d6b0f
RV		 1255static abi_long do_pipe2(int host_pipe[], int flags)
1256{
1257#ifdef CONFIG_PIPE2
1258 return pipe2(host_pipe, flags);
1259#else
1260 return -ENOSYS;
1261#endif
1262}
1263
fb41a66e
RH		 1264static abi_long do_pipe(void *cpu_env, abi_ulong pipedes,
1265 int flags, int is_pipe2)
099d6b0f
RV		 1266{
1267 int host_pipe[2];
1268 abi_long ret;
1269 ret = flags ? do_pipe2(host_pipe, flags) : pipe(host_pipe);
1270
1271 if (is_error(ret))
1272 return get_errno(ret);
fb41a66e
RH		 1273
1274 /* Several targets have special calling conventions for the original
1275 pipe syscall, but didn't replicate this into the pipe2 syscall. */
1276 if (!is_pipe2) {
1277#if defined(TARGET_ALPHA)
1278 ((CPUAlphaState *)cpu_env)->ir[IR_A4] = host_pipe[1];
1279 return host_pipe[0];
1280#elif defined(TARGET_MIPS)
1281 ((CPUMIPSState*)cpu_env)->active_tc.gpr[3] = host_pipe[1];
1282 return host_pipe[0];
1283#elif defined(TARGET_SH4)
597c0212 1284 ((CPUSH4State*)cpu_env)->gregs[1] = host_pipe[1];
fb41a66e 1285 return host_pipe[0];
82f05b69
PM		 1286#elif defined(TARGET_SPARC)
1287 ((CPUSPARCState*)cpu_env)->regwptr[1] = host_pipe[1];
1288 return host_pipe[0];
597c0212 1289#endif
fb41a66e
RH		 1290 }
1291
099d6b0f
RV		 1292 if (put_user_s32(host_pipe[0], pipedes)
1293 || put_user_s32(host_pipe[1], pipedes + sizeof(host_pipe[0])))
1294 return -TARGET_EFAULT;
099d6b0f
RV		 1295 return get_errno(ret);
1296}
1297
b975b83b
LL		 1298static inline abi_long target_to_host_ip_mreq(struct ip_mreqn *mreqn,
1299 abi_ulong target_addr,
1300 socklen_t len)
1301{
1302 struct target_ip_mreqn *target_smreqn;
1303
1304 target_smreqn = lock_user(VERIFY_READ, target_addr, len, 1);
1305 if (!target_smreqn)
1306 return -TARGET_EFAULT;
1307 mreqn->imr_multiaddr.s_addr = target_smreqn->imr_multiaddr.s_addr;
1308 mreqn->imr_address.s_addr = target_smreqn->imr_address.s_addr;
1309 if (len == sizeof(struct target_ip_mreqn))
cbb21eed 1310 mreqn->imr_ifindex = tswapal(target_smreqn->imr_ifindex);
b975b83b
LL		 1311 unlock_user(target_smreqn, target_addr, 0);
1312
1313 return 0;
1314}
1315
7b36f782 1316static inline abi_long target_to_host_sockaddr(int fd, struct sockaddr *addr,
579a97f7
FB		 1317 abi_ulong target_addr,
1318 socklen_t len)
7854b056 1319{
607175e0
AJ		 1320 const socklen_t unix_maxlen = sizeof (struct sockaddr_un);
1321 sa_family_t sa_family;
53a5960a
PB		 1322 struct target_sockaddr *target_saddr;
1323
7b36f782
LV		 1324 if (fd_trans_target_to_host_addr(fd)) {
1325 return fd_trans_target_to_host_addr(fd)(addr, target_addr, len);
1326 }
1327
579a97f7
FB		 1328 target_saddr = lock_user(VERIFY_READ, target_addr, len, 1);
1329 if (!target_saddr)
1330 return -TARGET_EFAULT;
607175e0
AJ		 1331
1332 sa_family = tswap16(target_saddr->sa_family);
1333
1334 /* Oops. The caller might send a incomplete sun_path; sun_path
1335 * must be terminated by \0 (see the manual page), but
1336 * unfortunately it is quite common to specify sockaddr_un
1337 * length as "strlen(x->sun_path)" while it should be
1338 * "strlen(...) + 1". We'll fix that here if needed.
1339 * Linux kernel has a similar feature.
1340 */
1341
1342 if (sa_family == AF_UNIX) {
1343 if (len < unix_maxlen && len > 0) {
1344 char *cp = (char*)target_saddr;
1345
1346 if ( cp[len-1] && !cp[len] )
1347 len++;
1348 }
1349 if (len > unix_maxlen)
1350 len = unix_maxlen;
1351 }
1352
53a5960a 1353 memcpy(addr, target_saddr, len);
607175e0 1354 addr->sa_family = sa_family;
6c5b5645
LV		 1355 if (sa_family == AF_NETLINK) {
1356 struct sockaddr_nl *nladdr;
1357
1358 nladdr = (struct sockaddr_nl *)addr;
1359 nladdr->nl_pid = tswap32(nladdr->nl_pid);
1360 nladdr->nl_groups = tswap32(nladdr->nl_groups);
1361 } else if (sa_family == AF_PACKET) {
33a29b51
JT		 1362 struct target_sockaddr_ll *lladdr;
1363
1364 lladdr = (struct target_sockaddr_ll *)addr;
1365 lladdr->sll_ifindex = tswap32(lladdr->sll_ifindex);
1366 lladdr->sll_hatype = tswap16(lladdr->sll_hatype);
1367 }
53a5960a 1368 unlock_user(target_saddr, target_addr, 0);
579a97f7
FB		 1369
1370 return 0;
7854b056
FB		 1371}
1372
579a97f7
FB		 1373static inline abi_long host_to_target_sockaddr(abi_ulong target_addr,
1374 struct sockaddr *addr,
1375 socklen_t len)
7854b056 1376{
53a5960a
PB		 1377 struct target_sockaddr *target_saddr;
1378
a1e22192
PM		 1379 if (len == 0) {
1380 return 0;
1381 }
1382
579a97f7
FB		 1383 target_saddr = lock_user(VERIFY_WRITE, target_addr, len, 0);
1384 if (!target_saddr)
1385 return -TARGET_EFAULT;
53a5960a 1386 memcpy(target_saddr, addr, len);
a1e22192
PM		 1387 if (len >= offsetof(struct target_sockaddr, sa_family) +
1388 sizeof(target_saddr->sa_family)) {
1389 target_saddr->sa_family = tswap16(addr->sa_family);
1390 }
1391 if (addr->sa_family == AF_NETLINK && len >= sizeof(struct sockaddr_nl)) {
6c5b5645
LV		 1392 struct sockaddr_nl *target_nl = (struct sockaddr_nl *)target_saddr;
1393 target_nl->nl_pid = tswap32(target_nl->nl_pid);
1394 target_nl->nl_groups = tswap32(target_nl->nl_groups);
a82ea939
LV		 1395 } else if (addr->sa_family == AF_PACKET) {
1396 struct sockaddr_ll *target_ll = (struct sockaddr_ll *)target_saddr;
1397 target_ll->sll_ifindex = tswap32(target_ll->sll_ifindex);
1398 target_ll->sll_hatype = tswap16(target_ll->sll_hatype);
6c5b5645 1399 }
53a5960a 1400 unlock_user(target_saddr, target_addr, len);
579a97f7
FB		 1401
1402 return 0;
7854b056
FB		 1403}
1404
5a4a898d
FB		 1405static inline abi_long target_to_host_cmsg(struct msghdr *msgh,
1406 struct target_msghdr *target_msgh)
7854b056
FB		 1407{
1408 struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh);
5a4a898d
FB		 1409 abi_long msg_controllen;
1410 abi_ulong target_cmsg_addr;
ee104587 1411 struct target_cmsghdr *target_cmsg, *target_cmsg_start;
7854b056 1412 socklen_t space = 0;
5a4a898d 1413
cbb21eed 1414 msg_controllen = tswapal(target_msgh->msg_controllen);
5a4a898d
FB		 1415 if (msg_controllen < sizeof (struct target_cmsghdr))
1416 goto the_end;
cbb21eed 1417 target_cmsg_addr = tswapal(target_msgh->msg_control);
5a4a898d 1418 target_cmsg = lock_user(VERIFY_READ, target_cmsg_addr, msg_controllen, 1);
ee104587 1419 target_cmsg_start = target_cmsg;
5a4a898d
FB		 1420 if (!target_cmsg)
1421 return -TARGET_EFAULT;
7854b056
FB		 1422
1423 while (cmsg && target_cmsg) {
1424 void *data = CMSG_DATA(cmsg);
1425 void *target_data = TARGET_CMSG_DATA(target_cmsg);
1426
cbb21eed 1427 int len = tswapal(target_cmsg->cmsg_len)
7854b056
FB		 1428 - TARGET_CMSG_ALIGN(sizeof (struct target_cmsghdr));
1429
1430 space += CMSG_SPACE(len);
1431 if (space > msgh->msg_controllen) {
1432 space -= CMSG_SPACE(len);
c2aeb258
PM		 1433 /* This is a QEMU bug, since we allocated the payload
1434 * area ourselves (unlike overflow in host-to-target
1435 * conversion, which is just the guest giving us a buffer
1436 * that's too small). It can't happen for the payload types
1437 * we currently support; if it becomes an issue in future
1438 * we would need to improve our allocation strategy to
1439 * something more intelligent than "twice the size of the
1440 * target buffer we're reading from".
1441 */
31febb71 1442 gemu_log("Host cmsg overflow\n");
7854b056
FB		 1443 break;
1444 }
1445
dbf4f796
PJ		 1446 if (tswap32(target_cmsg->cmsg_level) == TARGET_SOL_SOCKET) {
1447 cmsg->cmsg_level = SOL_SOCKET;
1448 } else {
1449 cmsg->cmsg_level = tswap32(target_cmsg->cmsg_level);
1450 }
7854b056
FB		 1451 cmsg->cmsg_type = tswap32(target_cmsg->cmsg_type);
1452 cmsg->cmsg_len = CMSG_LEN(len);
1453
30b8b68e 1454 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
7854b056
FB		 1455 int *fd = (int *)data;
1456 int *target_fd = (int *)target_data;
1457 int i, numfds = len / sizeof(int);
1458
876e23cb
PM		 1459 for (i = 0; i < numfds; i++) {
1460 __get_user(fd[i], target_fd + i);
1461 }
30b8b68e
AS		 1462 } else if (cmsg->cmsg_level == SOL_SOCKET
1463 && cmsg->cmsg_type == SCM_CREDENTIALS) {
1464 struct ucred *cred = (struct ucred *)data;
1465 struct target_ucred *target_cred =
1466 (struct target_ucred *)target_data;
1467
876e23cb
PM		 1468 __get_user(cred->pid, &target_cred->pid);
1469 __get_user(cred->uid, &target_cred->uid);
1470 __get_user(cred->gid, &target_cred->gid);
30b8b68e
AS		 1471 } else {
1472 gemu_log("Unsupported ancillary data: %d/%d\n",
1473 cmsg->cmsg_level, cmsg->cmsg_type);
1474 memcpy(data, target_data, len);
7854b056
FB		 1475 }
1476
1477 cmsg = CMSG_NXTHDR(msgh, cmsg);
ee104587
JN		 1478 target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg,
1479 target_cmsg_start);
7854b056 1480 }
5a4a898d
FB		 1481 unlock_user(target_cmsg, target_cmsg_addr, 0);
1482 the_end:
7854b056 1483 msgh->msg_controllen = space;
5a4a898d 1484 return 0;
7854b056
FB		 1485}
1486
5a4a898d
FB		 1487static inline abi_long host_to_target_cmsg(struct target_msghdr *target_msgh,
1488 struct msghdr *msgh)
7854b056
FB		 1489{
1490 struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh);
5a4a898d
FB		 1491 abi_long msg_controllen;
1492 abi_ulong target_cmsg_addr;
ee104587 1493 struct target_cmsghdr *target_cmsg, *target_cmsg_start;
7854b056
FB		 1494 socklen_t space = 0;
1495
cbb21eed 1496 msg_controllen = tswapal(target_msgh->msg_controllen);
5a4a898d
FB		 1497 if (msg_controllen < sizeof (struct target_cmsghdr))
1498 goto the_end;
cbb21eed 1499 target_cmsg_addr = tswapal(target_msgh->msg_control);
5a4a898d 1500 target_cmsg = lock_user(VERIFY_WRITE, target_cmsg_addr, msg_controllen, 0);
ee104587 1501 target_cmsg_start = target_cmsg;
5a4a898d
FB		 1502 if (!target_cmsg)
1503 return -TARGET_EFAULT;
1504
7854b056
FB		 1505 while (cmsg && target_cmsg) {
1506 void *data = CMSG_DATA(cmsg);
1507 void *target_data = TARGET_CMSG_DATA(target_cmsg);
1508
1509 int len = cmsg->cmsg_len - CMSG_ALIGN(sizeof (struct cmsghdr));
c2aeb258 1510 int tgt_len, tgt_space;
7854b056 1511
c2aeb258
PM		 1512 /* We never copy a half-header but may copy half-data;
1513 * this is Linux's behaviour in put_cmsg(). Note that
1514 * truncation here is a guest problem (which we report
1515 * to the guest via the CTRUNC bit), unlike truncation
1516 * in target_to_host_cmsg, which is a QEMU bug.
1517 */
1518 if (msg_controllen < sizeof(struct cmsghdr)) {
1519 target_msgh->msg_flags |= tswap32(MSG_CTRUNC);
7854b056
FB		 1520 break;
1521 }
1522
dbf4f796
PJ		 1523 if (cmsg->cmsg_level == SOL_SOCKET) {
1524 target_cmsg->cmsg_level = tswap32(TARGET_SOL_SOCKET);
1525 } else {
1526 target_cmsg->cmsg_level = tswap32(cmsg->cmsg_level);
1527 }
7854b056 1528 target_cmsg->cmsg_type = tswap32(cmsg->cmsg_type);
7854b056 1529
c2aeb258
PM		 1530 tgt_len = TARGET_CMSG_LEN(len);
1531
1532 /* Payload types which need a different size of payload on
1533 * the target must adjust tgt_len here.
1534 */
1535 switch (cmsg->cmsg_level) {
1536 case SOL_SOCKET:
1537 switch (cmsg->cmsg_type) {
1538 case SO_TIMESTAMP:
1539 tgt_len = sizeof(struct target_timeval);
1540 break;
1541 default:
1542 break;
1543 }
1544 default:
1545 break;
1546 }
1547
1548 if (msg_controllen < tgt_len) {
1549 target_msgh->msg_flags |= tswap32(MSG_CTRUNC);
1550 tgt_len = msg_controllen;
1551 }
1552
1553 /* We must now copy-and-convert len bytes of payload
1554 * into tgt_len bytes of destination space. Bear in mind
1555 * that in both source and destination we may be dealing
1556 * with a truncated value!
1557 */
52b65494
HD		 1558 switch (cmsg->cmsg_level) {
1559 case SOL_SOCKET:
1560 switch (cmsg->cmsg_type) {
1561 case SCM_RIGHTS:
1562 {
1563 int *fd = (int *)data;
1564 int *target_fd = (int *)target_data;
c2aeb258 1565 int i, numfds = tgt_len / sizeof(int);
52b65494 1566
876e23cb
PM		 1567 for (i = 0; i < numfds; i++) {
1568 __put_user(fd[i], target_fd + i);
1569 }
52b65494
HD		 1570 break;
1571 }
1572 case SO_TIMESTAMP:
1573 {
1574 struct timeval *tv = (struct timeval *)data;
1575 struct target_timeval *target_tv =
1576 (struct target_timeval *)target_data;
1577
c2aeb258
PM		 1578 if (len != sizeof(struct timeval) ||
1579 tgt_len != sizeof(struct target_timeval)) {
52b65494 1580 goto unimplemented;
c2aeb258 1581 }
52b65494
HD		 1582
1583 /* copy struct timeval to target */
876e23cb
PM		 1584 __put_user(tv->tv_sec, &target_tv->tv_sec);
1585 __put_user(tv->tv_usec, &target_tv->tv_usec);
52b65494
HD		 1586 break;
1587 }
4bc29756
HD		 1588 case SCM_CREDENTIALS:
1589 {
1590 struct ucred *cred = (struct ucred *)data;
1591 struct target_ucred *target_cred =
1592 (struct target_ucred *)target_data;
1593
1594 __put_user(cred->pid, &target_cred->pid);
1595 __put_user(cred->uid, &target_cred->uid);
1596 __put_user(cred->gid, &target_cred->gid);
1597 break;
1598 }
52b65494
HD		 1599 default:
1600 goto unimplemented;
1601 }
1602 break;
7854b056 1603
52b65494
HD		 1604 default:
1605 unimplemented:
aebf5bc7
JH		 1606 gemu_log("Unsupported ancillary data: %d/%d\n",
1607 cmsg->cmsg_level, cmsg->cmsg_type);
c2aeb258
PM		 1608 memcpy(target_data, data, MIN(len, tgt_len));
1609 if (tgt_len > len) {
1610 memset(target_data + len, 0, tgt_len - len);
1611 }
7854b056
FB		 1612 }
1613
c2aeb258 1614 target_cmsg->cmsg_len = tswapal(tgt_len);
ee104587 1615 tgt_space = TARGET_CMSG_SPACE(len);
c2aeb258
PM		 1616 if (msg_controllen < tgt_space) {
1617 tgt_space = msg_controllen;
1618 }
1619 msg_controllen -= tgt_space;
1620 space += tgt_space;
7854b056 1621 cmsg = CMSG_NXTHDR(msgh, cmsg);
ee104587
JN		 1622 target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg,
1623 target_cmsg_start);
7854b056 1624 }
5a4a898d
FB		 1625 unlock_user(target_cmsg, target_cmsg_addr, space);
1626 the_end:
cbb21eed 1627 target_msgh->msg_controllen = tswapal(space);
5a4a898d 1628 return 0;
7854b056
FB		 1629}
1630
6c5b5645
LV		 1631static void tswap_nlmsghdr(struct nlmsghdr *nlh)
1632{
1633 nlh->nlmsg_len = tswap32(nlh->nlmsg_len);
1634 nlh->nlmsg_type = tswap16(nlh->nlmsg_type);
1635 nlh->nlmsg_flags = tswap16(nlh->nlmsg_flags);
1636 nlh->nlmsg_seq = tswap32(nlh->nlmsg_seq);
1637 nlh->nlmsg_pid = tswap32(nlh->nlmsg_pid);
1638}
1639
1640static abi_long host_to_target_for_each_nlmsg(struct nlmsghdr *nlh,
1641 size_t len,
1642 abi_long (*host_to_target_nlmsg)
1643 (struct nlmsghdr *))
1644{
1645 uint32_t nlmsg_len;
1646 abi_long ret;
1647
1648 while (len > sizeof(struct nlmsghdr)) {
1649
1650 nlmsg_len = nlh->nlmsg_len;
1651 if (nlmsg_len < sizeof(struct nlmsghdr) ||
1652 nlmsg_len > len) {
1653 break;
1654 }
1655
1656 switch (nlh->nlmsg_type) {
1657 case NLMSG_DONE:
1658 tswap_nlmsghdr(nlh);
1659 return 0;
1660 case NLMSG_NOOP:
1661 break;
1662 case NLMSG_ERROR:
1663 {
1664 struct nlmsgerr *e = NLMSG_DATA(nlh);
1665 e->error = tswap32(e->error);
1666 tswap_nlmsghdr(&e->msg);
1667 tswap_nlmsghdr(nlh);
1668 return 0;
1669 }
1670 default:
1671 ret = host_to_target_nlmsg(nlh);
1672 if (ret < 0) {
1673 tswap_nlmsghdr(nlh);
1674 return ret;
1675 }
1676 break;
1677 }
1678 tswap_nlmsghdr(nlh);
1679 len -= NLMSG_ALIGN(nlmsg_len);
1680 nlh = (struct nlmsghdr *)(((char*)nlh) + NLMSG_ALIGN(nlmsg_len));
1681 }
1682 return 0;
1683}
1684
1685static abi_long target_to_host_for_each_nlmsg(struct nlmsghdr *nlh,
1686 size_t len,
1687 abi_long (*target_to_host_nlmsg)
1688 (struct nlmsghdr *))
1689{
1690 int ret;
1691
1692 while (len > sizeof(struct nlmsghdr)) {
1693 if (tswap32(nlh->nlmsg_len) < sizeof(struct nlmsghdr) ||
1694 tswap32(nlh->nlmsg_len) > len) {
1695 break;
1696 }
1697 tswap_nlmsghdr(nlh);
1698 switch (nlh->nlmsg_type) {
1699 case NLMSG_DONE:
1700 return 0;
1701 case NLMSG_NOOP:
1702 break;
1703 case NLMSG_ERROR:
1704 {
1705 struct nlmsgerr *e = NLMSG_DATA(nlh);
1706 e->error = tswap32(e->error);
1707 tswap_nlmsghdr(&e->msg);
84f34b00 1708 return 0;
6c5b5645
LV		 1709 }
1710 default:
1711 ret = target_to_host_nlmsg(nlh);
1712 if (ret < 0) {
1713 return ret;
1714 }
1715 }
1716 len -= NLMSG_ALIGN(nlh->nlmsg_len);
1717 nlh = (struct nlmsghdr *)(((char *)nlh) + NLMSG_ALIGN(nlh->nlmsg_len));
1718 }
1719 return 0;
1720}
1721
575b22b1 1722#ifdef CONFIG_RTNETLINK
c5dff280
LV		 1723static abi_long host_to_target_for_each_nlattr(struct nlattr *nlattr,
1724 size_t len, void *context,
1725 abi_long (*host_to_target_nlattr)
1726 (struct nlattr *,
1727 void *context))
1728{
1729 unsigned short nla_len;
1730 abi_long ret;
1731
1732 while (len > sizeof(struct nlattr)) {
1733 nla_len = nlattr->nla_len;
1734 if (nla_len < sizeof(struct nlattr) ||
1735 nla_len > len) {
1736 break;
1737 }
1738 ret = host_to_target_nlattr(nlattr, context);
1739 nlattr->nla_len = tswap16(nlattr->nla_len);
1740 nlattr->nla_type = tswap16(nlattr->nla_type);
1741 if (ret < 0) {
1742 return ret;
1743 }
1744 len -= NLA_ALIGN(nla_len);
1745 nlattr = (struct nlattr *)(((char *)nlattr) + NLA_ALIGN(nla_len));
1746 }
1747 return 0;
1748}
1749
6c5b5645
LV		 1750static abi_long host_to_target_for_each_rtattr(struct rtattr *rtattr,
1751 size_t len,
1752 abi_long (*host_to_target_rtattr)
1753 (struct rtattr *))
1754{
1755 unsigned short rta_len;
1756 abi_long ret;
1757
1758 while (len > sizeof(struct rtattr)) {
1759 rta_len = rtattr->rta_len;
1760 if (rta_len < sizeof(struct rtattr) ||
1761 rta_len > len) {
1762 break;
1763 }
1764 ret = host_to_target_rtattr(rtattr);
1765 rtattr->rta_len = tswap16(rtattr->rta_len);
1766 rtattr->rta_type = tswap16(rtattr->rta_type);
1767 if (ret < 0) {
1768 return ret;
1769 }
1770 len -= RTA_ALIGN(rta_len);
1771 rtattr = (struct rtattr *)(((char *)rtattr) + RTA_ALIGN(rta_len));
1772 }
1773 return 0;
1774}
1775
c5dff280
LV		 1776#define NLA_DATA(nla) ((void *)((char *)(nla)) + NLA_HDRLEN)
1777
1778static abi_long host_to_target_data_bridge_nlattr(struct nlattr *nlattr,
1779 void *context)
1780{
1781 uint16_t *u16;
1782 uint32_t *u32;
1783 uint64_t *u64;
1784
1785 switch (nlattr->nla_type) {
1786 /* no data */
1787 case IFLA_BR_FDB_FLUSH:
1788 break;
1789 /* binary */
1790 case IFLA_BR_GROUP_ADDR:
1791 break;
1792 /* uint8_t */
1793 case IFLA_BR_VLAN_FILTERING:
1794 case IFLA_BR_TOPOLOGY_CHANGE:
1795 case IFLA_BR_TOPOLOGY_CHANGE_DETECTED:
1796 case IFLA_BR_MCAST_ROUTER:
1797 case IFLA_BR_MCAST_SNOOPING:
1798 case IFLA_BR_MCAST_QUERY_USE_IFADDR:
1799 case IFLA_BR_MCAST_QUERIER:
1800 case IFLA_BR_NF_CALL_IPTABLES:
1801 case IFLA_BR_NF_CALL_IP6TABLES:
1802 case IFLA_BR_NF_CALL_ARPTABLES:
1803 break;
1804 /* uint16_t */
1805 case IFLA_BR_PRIORITY:
1806 case IFLA_BR_VLAN_PROTOCOL:
1807 case IFLA_BR_GROUP_FWD_MASK:
1808 case IFLA_BR_ROOT_PORT:
1809 case IFLA_BR_VLAN_DEFAULT_PVID:
1810 u16 = NLA_DATA(nlattr);
1811 *u16 = tswap16(*u16);
1812 break;
1813 /* uint32_t */
1814 case IFLA_BR_FORWARD_DELAY:
1815 case IFLA_BR_HELLO_TIME:
1816 case IFLA_BR_MAX_AGE:
1817 case IFLA_BR_AGEING_TIME:
1818 case IFLA_BR_STP_STATE:
1819 case IFLA_BR_ROOT_PATH_COST:
1820 case IFLA_BR_MCAST_HASH_ELASTICITY:
1821 case IFLA_BR_MCAST_HASH_MAX:
1822 case IFLA_BR_MCAST_LAST_MEMBER_CNT:
1823 case IFLA_BR_MCAST_STARTUP_QUERY_CNT:
1824 u32 = NLA_DATA(nlattr);
1825 *u32 = tswap32(*u32);
1826 break;
1827 /* uint64_t */
1828 case IFLA_BR_HELLO_TIMER:
1829 case IFLA_BR_TCN_TIMER:
1830 case IFLA_BR_GC_TIMER:
1831 case IFLA_BR_TOPOLOGY_CHANGE_TIMER:
1832 case IFLA_BR_MCAST_LAST_MEMBER_INTVL:
1833 case IFLA_BR_MCAST_MEMBERSHIP_INTVL:
1834 case IFLA_BR_MCAST_QUERIER_INTVL:
1835 case IFLA_BR_MCAST_QUERY_INTVL:
1836 case IFLA_BR_MCAST_QUERY_RESPONSE_INTVL:
1837 case IFLA_BR_MCAST_STARTUP_QUERY_INTVL:
1838 u64 = NLA_DATA(nlattr);
1839 *u64 = tswap64(*u64);
1840 break;
1841 /* ifla_bridge_id: uin8_t[] */
1842 case IFLA_BR_ROOT_ID:
1843 case IFLA_BR_BRIDGE_ID:
1844 break;
1845 default:
1846 gemu_log("Unknown IFLA_BR type %d\n", nlattr->nla_type);
1847 break;
1848 }
1849 return 0;
1850}
1851
1852static abi_long host_to_target_slave_data_bridge_nlattr(struct nlattr *nlattr,
1853 void *context)
1854{
1855 uint16_t *u16;
1856 uint32_t *u32;
1857 uint64_t *u64;
1858
1859 switch (nlattr->nla_type) {
1860 /* uint8_t */
1861 case IFLA_BRPORT_STATE:
1862 case IFLA_BRPORT_MODE:
1863 case IFLA_BRPORT_GUARD:
1864 case IFLA_BRPORT_PROTECT:
1865 case IFLA_BRPORT_FAST_LEAVE:
1866 case IFLA_BRPORT_LEARNING:
1867 case IFLA_BRPORT_UNICAST_FLOOD:
1868 case IFLA_BRPORT_PROXYARP:
1869 case IFLA_BRPORT_LEARNING_SYNC:
1870 case IFLA_BRPORT_PROXYARP_WIFI:
1871 case IFLA_BRPORT_TOPOLOGY_CHANGE_ACK:
1872 case IFLA_BRPORT_CONFIG_PENDING:
1873 case IFLA_BRPORT_MULTICAST_ROUTER:
1874 break;
1875 /* uint16_t */
1876 case IFLA_BRPORT_PRIORITY:
1877 case IFLA_BRPORT_DESIGNATED_PORT:
1878 case IFLA_BRPORT_DESIGNATED_COST:
1879 case IFLA_BRPORT_ID:
1880 case IFLA_BRPORT_NO:
1881 u16 = NLA_DATA(nlattr);
1882 *u16 = tswap16(*u16);
1883 break;
1884 /* uin32_t */
1885 case IFLA_BRPORT_COST:
1886 u32 = NLA_DATA(nlattr);
1887 *u32 = tswap32(*u32);
1888 break;
1889 /* uint64_t */
1890 case IFLA_BRPORT_MESSAGE_AGE_TIMER:
1891 case IFLA_BRPORT_FORWARD_DELAY_TIMER:
1892 case IFLA_BRPORT_HOLD_TIMER:
1893 u64 = NLA_DATA(nlattr);
1894 *u64 = tswap64(*u64);
1895 break;
1896 /* ifla_bridge_id: uint8_t[] */
1897 case IFLA_BRPORT_ROOT_ID:
1898 case IFLA_BRPORT_BRIDGE_ID:
1899 break;
1900 default:
1901 gemu_log("Unknown IFLA_BRPORT type %d\n", nlattr->nla_type);
1902 break;
1903 }
1904 return 0;
1905}
1906
1907struct linkinfo_context {
1908 int len;
1909 char *name;
1910 int slave_len;
1911 char *slave_name;
1912};
1913
1914static abi_long host_to_target_data_linkinfo_nlattr(struct nlattr *nlattr,
1915 void *context)
1916{
1917 struct linkinfo_context *li_context = context;
1918
1919 switch (nlattr->nla_type) {
1920 /* string */
1921 case IFLA_INFO_KIND:
1922 li_context->name = NLA_DATA(nlattr);
1923 li_context->len = nlattr->nla_len - NLA_HDRLEN;
1924 break;
1925 case IFLA_INFO_SLAVE_KIND:
1926 li_context->slave_name = NLA_DATA(nlattr);
1927 li_context->slave_len = nlattr->nla_len - NLA_HDRLEN;
1928 break;
1929 /* stats */
1930 case IFLA_INFO_XSTATS:
1931 /* FIXME: only used by CAN */
1932 break;
1933 /* nested */
1934 case IFLA_INFO_DATA:
1935 if (strncmp(li_context->name, "bridge",
1936 li_context->len) == 0) {
1937 return host_to_target_for_each_nlattr(NLA_DATA(nlattr),
1938 nlattr->nla_len,
1939 NULL,
1940 host_to_target_data_bridge_nlattr);
1941 } else {
1942 gemu_log("Unknown IFLA_INFO_KIND %s\n", li_context->name);
1943 }
1944 break;
1945 case IFLA_INFO_SLAVE_DATA:
1946 if (strncmp(li_context->slave_name, "bridge",
1947 li_context->slave_len) == 0) {
1948 return host_to_target_for_each_nlattr(NLA_DATA(nlattr),
1949 nlattr->nla_len,
1950 NULL,
1951 host_to_target_slave_data_bridge_nlattr);
1952 } else {
1953 gemu_log("Unknown IFLA_INFO_SLAVE_KIND %s\n",
1954 li_context->slave_name);
1955 }
1956 break;
1957 default:
1958 gemu_log("Unknown host IFLA_INFO type: %d\n", nlattr->nla_type);
1959 break;
1960 }
1961
1962 return 0;
1963}
1964
1965static abi_long host_to_target_data_inet_nlattr(struct nlattr *nlattr,
1966 void *context)
1967{
1968 uint32_t *u32;
1969 int i;
1970
1971 switch (nlattr->nla_type) {
1972 case IFLA_INET_CONF:
1973 u32 = NLA_DATA(nlattr);
1974 for (i = 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u32);
1975 i++) {
1976 u32[i] = tswap32(u32[i]);
1977 }
1978 break;
1979 default:
1980 gemu_log("Unknown host AF_INET type: %d\n", nlattr->nla_type);
1981 }
1982 return 0;
1983}
1984
1985static abi_long host_to_target_data_inet6_nlattr(struct nlattr *nlattr,
1986 void *context)
1987{
1988 uint32_t *u32;
1989 uint64_t *u64;
1990 struct ifla_cacheinfo *ci;
1991 int i;
1992
1993 switch (nlattr->nla_type) {
1994 /* binaries */
1995 case IFLA_INET6_TOKEN:
1996 break;
1997 /* uint8_t */
1998 case IFLA_INET6_ADDR_GEN_MODE:
1999 break;
2000 /* uint32_t */
2001 case IFLA_INET6_FLAGS:
2002 u32 = NLA_DATA(nlattr);
2003 *u32 = tswap32(*u32);
2004 break;
2005 /* uint32_t[] */
2006 case IFLA_INET6_CONF:
2007 u32 = NLA_DATA(nlattr);
2008 for (i = 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u32);
2009 i++) {
2010 u32[i] = tswap32(u32[i]);
2011 }
2012 break;
2013 /* ifla_cacheinfo */
2014 case IFLA_INET6_CACHEINFO:
2015 ci = NLA_DATA(nlattr);
2016 ci->max_reasm_len = tswap32(ci->max_reasm_len);
2017 ci->tstamp = tswap32(ci->tstamp);
2018 ci->reachable_time = tswap32(ci->reachable_time);
2019 ci->retrans_time = tswap32(ci->retrans_time);
2020 break;
2021 /* uint64_t[] */
2022 case IFLA_INET6_STATS:
2023 case IFLA_INET6_ICMP6STATS:
2024 u64 = NLA_DATA(nlattr);
2025 for (i = 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u64);
2026 i++) {
2027 u64[i] = tswap64(u64[i]);
2028 }
2029 break;
2030 default:
2031 gemu_log("Unknown host AF_INET6 type: %d\n", nlattr->nla_type);
2032 }
2033 return 0;
2034}
2035
2036static abi_long host_to_target_data_spec_nlattr(struct nlattr *nlattr,
2037 void *context)
2038{
2039 switch (nlattr->nla_type) {
2040 case AF_INET:
2041 return host_to_target_for_each_nlattr(NLA_DATA(nlattr), nlattr->nla_len,
2042 NULL,
2043 host_to_target_data_inet_nlattr);
2044 case AF_INET6:
2045 return host_to_target_for_each_nlattr(NLA_DATA(nlattr), nlattr->nla_len,
2046 NULL,
2047 host_to_target_data_inet6_nlattr);
2048 default:
2049 gemu_log("Unknown host AF_SPEC type: %d\n", nlattr->nla_type);
2050 break;
2051 }
2052 return 0;
2053}
2054
6c5b5645
LV		 2055static abi_long host_to_target_data_link_rtattr(struct rtattr *rtattr)
2056{
2057 uint32_t *u32;
2058 struct rtnl_link_stats *st;
2059 struct rtnl_link_stats64 *st64;
2060 struct rtnl_link_ifmap *map;
c5dff280 2061 struct linkinfo_context li_context;
6c5b5645
LV		 2062
2063 switch (rtattr->rta_type) {
2064 /* binary stream */
2065 case IFLA_ADDRESS:
2066 case IFLA_BROADCAST:
2067 /* string */
2068 case IFLA_IFNAME:
2069 case IFLA_QDISC:
2070 break;
2071 /* uin8_t */
2072 case IFLA_OPERSTATE:
2073 case IFLA_LINKMODE:
2074 case IFLA_CARRIER:
2075 case IFLA_PROTO_DOWN:
2076 break;
2077 /* uint32_t */
2078 case IFLA_MTU:
2079 case IFLA_LINK:
2080 case IFLA_WEIGHT:
2081 case IFLA_TXQLEN:
2082 case IFLA_CARRIER_CHANGES:
2083 case IFLA_NUM_RX_QUEUES:
2084 case IFLA_NUM_TX_QUEUES:
2085 case IFLA_PROMISCUITY:
2086 case IFLA_EXT_MASK:
2087 case IFLA_LINK_NETNSID:
2088 case IFLA_GROUP:
2089 case IFLA_MASTER:
2090 case IFLA_NUM_VF:
2091 u32 = RTA_DATA(rtattr);
2092 *u32 = tswap32(*u32);
2093 break;
2094 /* struct rtnl_link_stats */
2095 case IFLA_STATS:
2096 st = RTA_DATA(rtattr);
2097 st->rx_packets = tswap32(st->rx_packets);
2098 st->tx_packets = tswap32(st->tx_packets);
2099 st->rx_bytes = tswap32(st->rx_bytes);
2100 st->tx_bytes = tswap32(st->tx_bytes);
2101 st->rx_errors = tswap32(st->rx_errors);
2102 st->tx_errors = tswap32(st->tx_errors);
2103 st->rx_dropped = tswap32(st->rx_dropped);
2104 st->tx_dropped = tswap32(st->tx_dropped);
2105 st->multicast = tswap32(st->multicast);
2106 st->collisions = tswap32(st->collisions);
2107
2108 /* detailed rx_errors: */
2109 st->rx_length_errors = tswap32(st->rx_length_errors);
2110 st->rx_over_errors = tswap32(st->rx_over_errors);
2111 st->rx_crc_errors = tswap32(st->rx_crc_errors);
2112 st->rx_frame_errors = tswap32(st->rx_frame_errors);
2113 st->rx_fifo_errors = tswap32(st->rx_fifo_errors);
2114 st->rx_missed_errors = tswap32(st->rx_missed_errors);
2115
2116 /* detailed tx_errors */
2117 st->tx_aborted_errors = tswap32(st->tx_aborted_errors);
2118 st->tx_carrier_errors = tswap32(st->tx_carrier_errors);
2119 st->tx_fifo_errors = tswap32(st->tx_fifo_errors);
2120 st->tx_heartbeat_errors = tswap32(st->tx_heartbeat_errors);
2121 st->tx_window_errors = tswap32(st->tx_window_errors);
2122
2123 /* for cslip etc */
2124 st->rx_compressed = tswap32(st->rx_compressed);
2125 st->tx_compressed = tswap32(st->tx_compressed);
2126 break;
2127 /* struct rtnl_link_stats64 */
2128 case IFLA_STATS64:
2129 st64 = RTA_DATA(rtattr);
2130 st64->rx_packets = tswap64(st64->rx_packets);
2131 st64->tx_packets = tswap64(st64->tx_packets);
2132 st64->rx_bytes = tswap64(st64->rx_bytes);
2133 st64->tx_bytes = tswap64(st64->tx_bytes);
2134 st64->rx_errors = tswap64(st64->rx_errors);
2135 st64->tx_errors = tswap64(st64->tx_errors);
2136 st64->rx_dropped = tswap64(st64->rx_dropped);
2137 st64->tx_dropped = tswap64(st64->tx_dropped);
2138 st64->multicast = tswap64(st64->multicast);
2139 st64->collisions = tswap64(st64->collisions);
2140
2141 /* detailed rx_errors: */
2142 st64->rx_length_errors = tswap64(st64->rx_length_errors);
2143 st64->rx_over_errors = tswap64(st64->rx_over_errors);
2144 st64->rx_crc_errors = tswap64(st64->rx_crc_errors);
2145 st64->rx_frame_errors = tswap64(st64->rx_frame_errors);
2146 st64->rx_fifo_errors = tswap64(st64->rx_fifo_errors);
2147 st64->rx_missed_errors = tswap64(st64->rx_missed_errors);
2148
2149 /* detailed tx_errors */
2150 st64->tx_aborted_errors = tswap64(st64->tx_aborted_errors);
2151 st64->tx_carrier_errors = tswap64(st64->tx_carrier_errors);
2152 st64->tx_fifo_errors = tswap64(st64->tx_fifo_errors);
2153 st64->tx_heartbeat_errors = tswap64(st64->tx_heartbeat_errors);
2154 st64->tx_window_errors = tswap64(st64->tx_window_errors);
2155
2156 /* for cslip etc */
2157 st64->rx_compressed = tswap64(st64->rx_compressed);
2158 st64->tx_compressed = tswap64(st64->tx_compressed);
2159 break;
2160 /* struct rtnl_link_ifmap */
2161 case IFLA_MAP:
2162 map = RTA_DATA(rtattr);
2163 map->mem_start = tswap64(map->mem_start);
2164 map->mem_end = tswap64(map->mem_end);
2165 map->base_addr = tswap64(map->base_addr);
2166 map->irq = tswap16(map->irq);
2167 break;
2168 /* nested */
6c5b5645 2169 case IFLA_LINKINFO:
c5dff280
LV		 2170 memset(&li_context, 0, sizeof(li_context));
2171 return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rta_len,
2172 &li_context,
2173 host_to_target_data_linkinfo_nlattr);
2174 case IFLA_AF_SPEC:
2175 return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rta_len,
2176 NULL,
2177 host_to_target_data_spec_nlattr);
6c5b5645
LV		 2178 default:
2179 gemu_log("Unknown host IFLA type: %d\n", rtattr->rta_type);
2180 break;
2181 }
2182 return 0;
2183}
2184
2185static abi_long host_to_target_data_addr_rtattr(struct rtattr *rtattr)
2186{
2187 uint32_t *u32;
2188 struct ifa_cacheinfo *ci;
2189
2190 switch (rtattr->rta_type) {
2191 /* binary: depends on family type */
2192 case IFA_ADDRESS:
2193 case IFA_LOCAL:
2194 break;
2195 /* string */
2196 case IFA_LABEL:
2197 break;
2198 /* u32 */
2199 case IFA_FLAGS:
2200 case IFA_BROADCAST:
2201 u32 = RTA_DATA(rtattr);
2202 *u32 = tswap32(*u32);
2203 break;
2204 /* struct ifa_cacheinfo */
2205 case IFA_CACHEINFO:
2206 ci = RTA_DATA(rtattr);
2207 ci->ifa_prefered = tswap32(ci->ifa_prefered);
2208 ci->ifa_valid = tswap32(ci->ifa_valid);
2209 ci->cstamp = tswap32(ci->cstamp);
2210 ci->tstamp = tswap32(ci->tstamp);
2211 break;
2212 default:
2213 gemu_log("Unknown host IFA type: %d\n", rtattr->rta_type);
2214 break;
2215 }
2216 return 0;
2217}
2218
2219static abi_long host_to_target_data_route_rtattr(struct rtattr *rtattr)
2220{
2221 uint32_t *u32;
2222 switch (rtattr->rta_type) {
2223 /* binary: depends on family type */
2224 case RTA_GATEWAY:
2225 case RTA_DST:
2226 case RTA_PREFSRC:
2227 break;
2228 /* u32 */
2229 case RTA_PRIORITY:
2230 case RTA_TABLE:
2231 case RTA_OIF:
2232 u32 = RTA_DATA(rtattr);
2233 *u32 = tswap32(*u32);
2234 break;
2235 default:
2236 gemu_log("Unknown host RTA type: %d\n", rtattr->rta_type);
2237 break;
2238 }
2239 return 0;
2240}
2241
2242static abi_long host_to_target_link_rtattr(struct rtattr *rtattr,
2243 uint32_t rtattr_len)
2244{
2245 return host_to_target_for_each_rtattr(rtattr, rtattr_len,
2246 host_to_target_data_link_rtattr);
2247}
2248
2249static abi_long host_to_target_addr_rtattr(struct rtattr *rtattr,
2250 uint32_t rtattr_len)
2251{
2252 return host_to_target_for_each_rtattr(rtattr, rtattr_len,
2253 host_to_target_data_addr_rtattr);
2254}
2255
2256static abi_long host_to_target_route_rtattr(struct rtattr *rtattr,
2257 uint32_t rtattr_len)
2258{
2259 return host_to_target_for_each_rtattr(rtattr, rtattr_len,
2260 host_to_target_data_route_rtattr);
2261}
2262
2263static abi_long host_to_target_data_route(struct nlmsghdr *nlh)
2264{
2265 uint32_t nlmsg_len;
2266 struct ifinfomsg *ifi;
2267 struct ifaddrmsg *ifa;
2268 struct rtmsg *rtm;
2269
2270 nlmsg_len = nlh->nlmsg_len;
2271 switch (nlh->nlmsg_type) {
2272 case RTM_NEWLINK:
2273 case RTM_DELLINK:
2274 case RTM_GETLINK:
b9403979
LV		 2275 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifi))) {
2276 ifi = NLMSG_DATA(nlh);
2277 ifi->ifi_type = tswap16(ifi->ifi_type);
2278 ifi->ifi_index = tswap32(ifi->ifi_index);
2279 ifi->ifi_flags = tswap32(ifi->ifi_flags);
2280 ifi->ifi_change = tswap32(ifi->ifi_change);
2281 host_to_target_link_rtattr(IFLA_RTA(ifi),
2282 nlmsg_len - NLMSG_LENGTH(sizeof(*ifi)));
2283 }
6c5b5645
LV		 2284 break;
2285 case RTM_NEWADDR:
2286 case RTM_DELADDR:
2287 case RTM_GETADDR:
b9403979
LV		 2288 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifa))) {
2289 ifa = NLMSG_DATA(nlh);
2290 ifa->ifa_index = tswap32(ifa->ifa_index);
2291 host_to_target_addr_rtattr(IFA_RTA(ifa),
2292 nlmsg_len - NLMSG_LENGTH(sizeof(*ifa)));
2293 }
6c5b5645
LV		 2294 break;
2295 case RTM_NEWROUTE:
2296 case RTM_DELROUTE:
2297 case RTM_GETROUTE:
b9403979
LV		 2298 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*rtm))) {
2299 rtm = NLMSG_DATA(nlh);
2300 rtm->rtm_flags = tswap32(rtm->rtm_flags);
2301 host_to_target_route_rtattr(RTM_RTA(rtm),
2302 nlmsg_len - NLMSG_LENGTH(sizeof(*rtm)));
2303 }
6c5b5645
LV		 2304 break;
2305 default:
2306 return -TARGET_EINVAL;
2307 }
2308 return 0;
2309}
2310
2311static inline abi_long host_to_target_nlmsg_route(struct nlmsghdr *nlh,
2312 size_t len)
2313{
2314 return host_to_target_for_each_nlmsg(nlh, len, host_to_target_data_route);
2315}
2316
2317static abi_long target_to_host_for_each_rtattr(struct rtattr *rtattr,
2318 size_t len,
2319 abi_long (*target_to_host_rtattr)
2320 (struct rtattr *))
2321{
2322 abi_long ret;
2323
2324 while (len >= sizeof(struct rtattr)) {
2325 if (tswap16(rtattr->rta_len) < sizeof(struct rtattr) ||
2326 tswap16(rtattr->rta_len) > len) {
2327 break;
2328 }
2329 rtattr->rta_len = tswap16(rtattr->rta_len);
2330 rtattr->rta_type = tswap16(rtattr->rta_type);
2331 ret = target_to_host_rtattr(rtattr);
2332 if (ret < 0) {
2333 return ret;
2334 }
2335 len -= RTA_ALIGN(rtattr->rta_len);
2336 rtattr = (struct rtattr *)(((char *)rtattr) +
2337 RTA_ALIGN(rtattr->rta_len));
2338 }
2339 return 0;
2340}
2341
2342static abi_long target_to_host_data_link_rtattr(struct rtattr *rtattr)
2343{
2344 switch (rtattr->rta_type) {
2345 default:
2346 gemu_log("Unknown target IFLA type: %d\n", rtattr->rta_type);
2347 break;
2348 }
2349 return 0;
2350}
2351
2352static abi_long target_to_host_data_addr_rtattr(struct rtattr *rtattr)
2353{
2354 switch (rtattr->rta_type) {
2355 /* binary: depends on family type */
2356 case IFA_LOCAL:
2357 case IFA_ADDRESS:
2358 break;
2359 default:
2360 gemu_log("Unknown target IFA type: %d\n", rtattr->rta_type);
2361 break;
2362 }
2363 return 0;
2364}
2365
2366static abi_long target_to_host_data_route_rtattr(struct rtattr *rtattr)
2367{
2368 uint32_t *u32;
2369 switch (rtattr->rta_type) {
2370 /* binary: depends on family type */
2371 case RTA_DST:
2372 case RTA_SRC:
2373 case RTA_GATEWAY:
2374 break;
2375 /* u32 */
2376 case RTA_OIF:
2377 u32 = RTA_DATA(rtattr);
2378 *u32 = tswap32(*u32);
2379 break;
2380 default:
2381 gemu_log("Unknown target RTA type: %d\n", rtattr->rta_type);
2382 break;
2383 }
2384 return 0;
2385}
2386
2387static void target_to_host_link_rtattr(struct rtattr *rtattr,
2388 uint32_t rtattr_len)
2389{
2390 target_to_host_for_each_rtattr(rtattr, rtattr_len,
2391 target_to_host_data_link_rtattr);
2392}
2393
2394static void target_to_host_addr_rtattr(struct rtattr *rtattr,
2395 uint32_t rtattr_len)
2396{
2397 target_to_host_for_each_rtattr(rtattr, rtattr_len,
2398 target_to_host_data_addr_rtattr);
2399}
2400
2401static void target_to_host_route_rtattr(struct rtattr *rtattr,
2402 uint32_t rtattr_len)
2403{
2404 target_to_host_for_each_rtattr(rtattr, rtattr_len,
2405 target_to_host_data_route_rtattr);
2406}
2407
2408static abi_long target_to_host_data_route(struct nlmsghdr *nlh)
2409{
2410 struct ifinfomsg *ifi;
2411 struct ifaddrmsg *ifa;
2412 struct rtmsg *rtm;
2413
2414 switch (nlh->nlmsg_type) {
2415 case RTM_GETLINK:
2416 break;
2417 case RTM_NEWLINK:
2418 case RTM_DELLINK:
b9403979
LV		 2419 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifi))) {
2420 ifi = NLMSG_DATA(nlh);
2421 ifi->ifi_type = tswap16(ifi->ifi_type);
2422 ifi->ifi_index = tswap32(ifi->ifi_index);
2423 ifi->ifi_flags = tswap32(ifi->ifi_flags);
2424 ifi->ifi_change = tswap32(ifi->ifi_change);
2425 target_to_host_link_rtattr(IFLA_RTA(ifi), nlh->nlmsg_len -
2426 NLMSG_LENGTH(sizeof(*ifi)));
2427 }
6c5b5645
LV		 2428 break;
2429 case RTM_GETADDR:
2430 case RTM_NEWADDR:
2431 case RTM_DELADDR:
b9403979
LV		 2432 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifa))) {
2433 ifa = NLMSG_DATA(nlh);
2434 ifa->ifa_index = tswap32(ifa->ifa_index);
2435 target_to_host_addr_rtattr(IFA_RTA(ifa), nlh->nlmsg_len -
2436 NLMSG_LENGTH(sizeof(*ifa)));
2437 }
6c5b5645
LV		 2438 break;
2439 case RTM_GETROUTE:
2440 break;
2441 case RTM_NEWROUTE:
2442 case RTM_DELROUTE:
b9403979
LV		 2443 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*rtm))) {
2444 rtm = NLMSG_DATA(nlh);
2445 rtm->rtm_flags = tswap32(rtm->rtm_flags);
2446 target_to_host_route_rtattr(RTM_RTA(rtm), nlh->nlmsg_len -
2447 NLMSG_LENGTH(sizeof(*rtm)));
2448 }
6c5b5645
LV		 2449 break;
2450 default:
2451 return -TARGET_EOPNOTSUPP;
2452 }
2453 return 0;
2454}
2455
2456static abi_long target_to_host_nlmsg_route(struct nlmsghdr *nlh, size_t len)
2457{
2458 return target_to_host_for_each_nlmsg(nlh, len, target_to_host_data_route);
2459}
575b22b1 2460#endif /* CONFIG_RTNETLINK */
6c5b5645 2461
5ce9bb59
LV		 2462static abi_long host_to_target_data_audit(struct nlmsghdr *nlh)
2463{
2464 switch (nlh->nlmsg_type) {
2465 default:
2466 gemu_log("Unknown host audit message type %d\n",
2467 nlh->nlmsg_type);
2468 return -TARGET_EINVAL;
2469 }
2470 return 0;
2471}
2472
2473static inline abi_long host_to_target_nlmsg_audit(struct nlmsghdr *nlh,
2474 size_t len)
2475{
2476 return host_to_target_for_each_nlmsg(nlh, len, host_to_target_data_audit);
2477}
2478
2479static abi_long target_to_host_data_audit(struct nlmsghdr *nlh)
2480{
2481 switch (nlh->nlmsg_type) {
2482 case AUDIT_USER:
2483 case AUDIT_FIRST_USER_MSG ... AUDIT_LAST_USER_MSG:
2484 case AUDIT_FIRST_USER_MSG2 ... AUDIT_LAST_USER_MSG2:
2485 break;
2486 default:
2487 gemu_log("Unknown target audit message type %d\n",
2488 nlh->nlmsg_type);
2489 return -TARGET_EINVAL;
2490 }
2491
2492 return 0;
2493}
2494
2495static abi_long target_to_host_nlmsg_audit(struct nlmsghdr *nlh, size_t len)
2496{
2497 return target_to_host_for_each_nlmsg(nlh, len, target_to_host_data_audit);
2498}
2499
0da46a6e 2500/* do_setsockopt() Must return target values and target errnos. */
992f48a0 2501static abi_long do_setsockopt(int sockfd, int level, int optname,
2f619698 2502 abi_ulong optval_addr, socklen_t optlen)
7854b056 2503{
992f48a0 2504 abi_long ret;
32407103 2505 int val;
b975b83b 2506 struct ip_mreqn *ip_mreq;
6e3cb58f 2507 struct ip_mreq_source *ip_mreq_source;
3b46e624 2508
8853f86e
FB		 2509 switch(level) {
2510 case SOL_TCP:
7854b056 2511 /* TCP options all take an 'int' value. */
7854b056 2512 if (optlen < sizeof(uint32_t))
0da46a6e 2513 return -TARGET_EINVAL;
3b46e624 2514
2f619698
FB		 2515 if (get_user_u32(val, optval_addr))
2516 return -TARGET_EFAULT;
8853f86e
FB		 2517 ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val)));
2518 break;
2519 case SOL_IP:
2520 switch(optname) {
2efbe911
FB		 2521 case IP_TOS:
2522 case IP_TTL:
8853f86e 2523 case IP_HDRINCL:
2efbe911
FB		 2524 case IP_ROUTER_ALERT:
2525 case IP_RECVOPTS:
2526 case IP_RETOPTS:
2527 case IP_PKTINFO:
2528 case IP_MTU_DISCOVER:
2529 case IP_RECVERR:
2530 case IP_RECVTOS:
2531#ifdef IP_FREEBIND
2532 case IP_FREEBIND:
2533#endif
2534 case IP_MULTICAST_TTL:
2535 case IP_MULTICAST_LOOP:
8853f86e
FB		 2536 val = 0;
2537 if (optlen >= sizeof(uint32_t)) {
2f619698
FB		 2538 if (get_user_u32(val, optval_addr))
2539 return -TARGET_EFAULT;
8853f86e 2540 } else if (optlen >= 1) {
2f619698
FB		 2541 if (get_user_u8(val, optval_addr))
2542 return -TARGET_EFAULT;
8853f86e
FB		 2543 }
2544 ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val)));
2545 break;
b975b83b
LL		 2546 case IP_ADD_MEMBERSHIP:
2547 case IP_DROP_MEMBERSHIP:
2548 if (optlen < sizeof (struct target_ip_mreq) ||
2549 optlen > sizeof (struct target_ip_mreqn))
2550 return -TARGET_EINVAL;
2551
2552 ip_mreq = (struct ip_mreqn *) alloca(optlen);
2553 target_to_host_ip_mreq(ip_mreq, optval_addr, optlen);
2554 ret = get_errno(setsockopt(sockfd, level, optname, ip_mreq, optlen));
2555 break;
2556
6e3cb58f
LL		 2557 case IP_BLOCK_SOURCE:
2558 case IP_UNBLOCK_SOURCE:
2559 case IP_ADD_SOURCE_MEMBERSHIP:
2560 case IP_DROP_SOURCE_MEMBERSHIP:
2561 if (optlen != sizeof (struct target_ip_mreq_source))
2562 return -TARGET_EINVAL;
2563
2564 ip_mreq_source = lock_user(VERIFY_READ, optval_addr, optlen, 1);
2565 ret = get_errno(setsockopt(sockfd, level, optname, ip_mreq_source, optlen));
2566 unlock_user (ip_mreq_source, optval_addr, 0);
2567 break;
2568
920394db
JH		 2569 default:
2570 goto unimplemented;
2571 }
2572 break;
0d78b3b5
LV		 2573 case SOL_IPV6:
2574 switch (optname) {
2575 case IPV6_MTU_DISCOVER:
2576 case IPV6_MTU:
2577 case IPV6_V6ONLY:
2578 case IPV6_RECVPKTINFO:
2579 val = 0;
2580 if (optlen < sizeof(uint32_t)) {
2581 return -TARGET_EINVAL;
2582 }
2583 if (get_user_u32(val, optval_addr)) {
2584 return -TARGET_EFAULT;
2585 }
2586 ret = get_errno(setsockopt(sockfd, level, optname,
2587 &val, sizeof(val)));
2588 break;
2589 default:
2590 goto unimplemented;
2591 }
2592 break;
920394db
JH		 2593 case SOL_RAW:
2594 switch (optname) {
2595 case ICMP_FILTER:
2596 /* struct icmp_filter takes an u32 value */
2597 if (optlen < sizeof(uint32_t)) {
2598 return -TARGET_EINVAL;
2599 }
2600
2601 if (get_user_u32(val, optval_addr)) {
2602 return -TARGET_EFAULT;
2603 }
2604 ret = get_errno(setsockopt(sockfd, level, optname,
2605 &val, sizeof(val)));
2606 break;
2607
8853f86e
FB		 2608 default:
2609 goto unimplemented;
2610 }
2611 break;
3532fa74 2612 case TARGET_SOL_SOCKET:
8853f86e 2613 switch (optname) {
1b09aeb9
LV		 2614 case TARGET_SO_RCVTIMEO:
2615 {
2616 struct timeval tv;
2617
2618 optname = SO_RCVTIMEO;
2619
2620set_timeout:
2621 if (optlen != sizeof(struct target_timeval)) {
2622 return -TARGET_EINVAL;
2623 }
2624
2625 if (copy_from_user_timeval(&tv, optval_addr)) {
2626 return -TARGET_EFAULT;
2627 }
2628
2629 ret = get_errno(setsockopt(sockfd, SOL_SOCKET, optname,
2630 &tv, sizeof(tv)));
2631 return ret;
2632 }
2633 case TARGET_SO_SNDTIMEO:
2634 optname = SO_SNDTIMEO;
2635 goto set_timeout;
f57d4192
LV		 2636 case TARGET_SO_ATTACH_FILTER:
2637 {
2638 struct target_sock_fprog *tfprog;
2639 struct target_sock_filter *tfilter;
2640 struct sock_fprog fprog;
2641 struct sock_filter *filter;
2642 int i;
2643
2644 if (optlen != sizeof(*tfprog)) {
2645 return -TARGET_EINVAL;
2646 }
2647 if (!lock_user_struct(VERIFY_READ, tfprog, optval_addr, 0)) {
2648 return -TARGET_EFAULT;
2649 }
2650 if (!lock_user_struct(VERIFY_READ, tfilter,
2651 tswapal(tfprog->filter), 0)) {
2652 unlock_user_struct(tfprog, optval_addr, 1);
2653 return -TARGET_EFAULT;
2654 }
2655
2656 fprog.len = tswap16(tfprog->len);
0e173b24 2657 filter = g_try_new(struct sock_filter, fprog.len);
f57d4192
LV		 2658 if (filter == NULL) {
2659 unlock_user_struct(tfilter, tfprog->filter, 1);
2660 unlock_user_struct(tfprog, optval_addr, 1);
2661 return -TARGET_ENOMEM;
2662 }
2663 for (i = 0; i < fprog.len; i++) {
2664 filter[i].code = tswap16(tfilter[i].code);
2665 filter[i].jt = tfilter[i].jt;
2666 filter[i].jf = tfilter[i].jf;
2667 filter[i].k = tswap32(tfilter[i].k);
2668 }
2669 fprog.filter = filter;
2670
2671 ret = get_errno(setsockopt(sockfd, SOL_SOCKET,
2672 SO_ATTACH_FILTER, &fprog, sizeof(fprog)));
0e173b24 2673 g_free(filter);
f57d4192
LV		 2674
2675 unlock_user_struct(tfilter, tfprog->filter, 1);
2676 unlock_user_struct(tfprog, optval_addr, 1);
2677 return ret;
2678 }
451aaf68
JT		 2679 case TARGET_SO_BINDTODEVICE:
2680 {
2681 char *dev_ifname, *addr_ifname;
2682
2683 if (optlen > IFNAMSIZ - 1) {
2684 optlen = IFNAMSIZ - 1;
2685 }
2686 dev_ifname = lock_user(VERIFY_READ, optval_addr, optlen, 1);
2687 if (!dev_ifname) {
2688 return -TARGET_EFAULT;
2689 }
2690 optname = SO_BINDTODEVICE;
2691 addr_ifname = alloca(IFNAMSIZ);
2692 memcpy(addr_ifname, dev_ifname, optlen);
2693 addr_ifname[optlen] = 0;
fad6c58a
CG		 2694 ret = get_errno(setsockopt(sockfd, SOL_SOCKET, optname,
2695 addr_ifname, optlen));
451aaf68
JT		 2696 unlock_user (dev_ifname, optval_addr, 0);
2697 return ret;
2698 }
8853f86e 2699 /* Options with 'int' argument. */
3532fa74
FB		 2700 case TARGET_SO_DEBUG:
2701 optname = SO_DEBUG;
2702 break;
2703 case TARGET_SO_REUSEADDR:
2704 optname = SO_REUSEADDR;
2705 break;
2706 case TARGET_SO_TYPE:
2707 optname = SO_TYPE;
2708 break;
2709 case TARGET_SO_ERROR:
2710 optname = SO_ERROR;
2711 break;
2712 case TARGET_SO_DONTROUTE:
2713 optname = SO_DONTROUTE;
2714 break;
2715 case TARGET_SO_BROADCAST:
2716 optname = SO_BROADCAST;
2717 break;
2718 case TARGET_SO_SNDBUF:
2719 optname = SO_SNDBUF;
2720 break;
d79b6cc4
PB		 2721 case TARGET_SO_SNDBUFFORCE:
2722 optname = SO_SNDBUFFORCE;
2723 break;
3532fa74
FB		 2724 case TARGET_SO_RCVBUF:
2725 optname = SO_RCVBUF;
2726 break;
d79b6cc4
PB		 2727 case TARGET_SO_RCVBUFFORCE:
2728 optname = SO_RCVBUFFORCE;
2729 break;
3532fa74
FB		 2730 case TARGET_SO_KEEPALIVE:
2731 optname = SO_KEEPALIVE;
2732 break;
2733 case TARGET_SO_OOBINLINE:
2734 optname = SO_OOBINLINE;
2735 break;
2736 case TARGET_SO_NO_CHECK:
2737 optname = SO_NO_CHECK;
2738 break;
2739 case TARGET_SO_PRIORITY:
2740 optname = SO_PRIORITY;
2741 break;
5e83e8e3 2742#ifdef SO_BSDCOMPAT
3532fa74
FB		 2743 case TARGET_SO_BSDCOMPAT:
2744 optname = SO_BSDCOMPAT;
2745 break;
5e83e8e3 2746#endif
3532fa74
FB		 2747 case TARGET_SO_PASSCRED:
2748 optname = SO_PASSCRED;
2749 break;
82d0fe6b
PB		 2750 case TARGET_SO_PASSSEC:
2751 optname = SO_PASSSEC;
2752 break;
3532fa74
FB		 2753 case TARGET_SO_TIMESTAMP:
2754 optname = SO_TIMESTAMP;
2755 break;
2756 case TARGET_SO_RCVLOWAT:
2757 optname = SO_RCVLOWAT;
2758 break;
8853f86e
FB		 2759 break;
2760 default:
2761 goto unimplemented;
2762 }
3532fa74 2763 if (optlen < sizeof(uint32_t))
2f619698 2764 return -TARGET_EINVAL;
3532fa74 2765
2f619698
FB		 2766 if (get_user_u32(val, optval_addr))
2767 return -TARGET_EFAULT;
3532fa74 2768 ret = get_errno(setsockopt(sockfd, SOL_SOCKET, optname, &val, sizeof(val)));
8853f86e 2769 break;
7854b056 2770 default:
8853f86e 2771 unimplemented:
b2bedb21 2772 gemu_log("Unsupported setsockopt level=%d optname=%d\n", level, optname);
6fa13c17 2773 ret = -TARGET_ENOPROTOOPT;
7854b056 2774 }
8853f86e 2775 return ret;
7854b056
FB		 2776}
2777
0da46a6e 2778/* do_getsockopt() Must return target values and target errnos. */
992f48a0 2779static abi_long do_getsockopt(int sockfd, int level, int optname,
2f619698 2780 abi_ulong optval_addr, abi_ulong optlen)
7854b056 2781{
992f48a0 2782 abi_long ret;
b55266b5
BS		 2783 int len, val;
2784 socklen_t lv;
8853f86e
FB		 2785
2786 switch(level) {
3532fa74 2787 case TARGET_SOL_SOCKET:
f3b974cd
JL		 2788 level = SOL_SOCKET;
2789 switch (optname) {
2790 /* These don't just return a single integer */
2791 case TARGET_SO_LINGER:
2792 case TARGET_SO_RCVTIMEO:
2793 case TARGET_SO_SNDTIMEO:
f3b974cd
JL		 2794 case TARGET_SO_PEERNAME:
2795 goto unimplemented;
583359a6
AP		 2796 case TARGET_SO_PEERCRED: {
2797 struct ucred cr;
2798 socklen_t crlen;
2799 struct target_ucred *tcr;
2800
2801 if (get_user_u32(len, optlen)) {
2802 return -TARGET_EFAULT;
2803 }
2804 if (len < 0) {
2805 return -TARGET_EINVAL;
2806 }
2807
2808 crlen = sizeof(cr);
2809 ret = get_errno(getsockopt(sockfd, level, SO_PEERCRED,
2810 &cr, &crlen));
2811 if (ret < 0) {
2812 return ret;
2813 }
2814 if (len > crlen) {
2815 len = crlen;
2816 }
2817 if (!lock_user_struct(VERIFY_WRITE, tcr, optval_addr, 0)) {
2818 return -TARGET_EFAULT;
2819 }
2820 __put_user(cr.pid, &tcr->pid);
2821 __put_user(cr.uid, &tcr->uid);
2822 __put_user(cr.gid, &tcr->gid);
2823 unlock_user_struct(tcr, optval_addr, 1);
2824 if (put_user_u32(len, optlen)) {
2825 return -TARGET_EFAULT;
2826 }
2827 break;
2828 }
f3b974cd
JL		 2829 /* Options with 'int' argument. */
2830 case TARGET_SO_DEBUG:
2831 optname = SO_DEBUG;
2832 goto int_case;
2833 case TARGET_SO_REUSEADDR:
2834 optname = SO_REUSEADDR;
2835 goto int_case;
2836 case TARGET_SO_TYPE:
2837 optname = SO_TYPE;
2838 goto int_case;
2839 case TARGET_SO_ERROR:
2840 optname = SO_ERROR;
2841 goto int_case;
2842 case TARGET_SO_DONTROUTE:
2843 optname = SO_DONTROUTE;
2844 goto int_case;
2845 case TARGET_SO_BROADCAST:
2846 optname = SO_BROADCAST;
2847 goto int_case;
2848 case TARGET_SO_SNDBUF:
2849 optname = SO_SNDBUF;
2850 goto int_case;
2851 case TARGET_SO_RCVBUF:
2852 optname = SO_RCVBUF;
2853 goto int_case;
2854 case TARGET_SO_KEEPALIVE:
2855 optname = SO_KEEPALIVE;
2856 goto int_case;
2857 case TARGET_SO_OOBINLINE:
2858 optname = SO_OOBINLINE;
2859 goto int_case;
2860 case TARGET_SO_NO_CHECK:
2861 optname = SO_NO_CHECK;
2862 goto int_case;
2863 case TARGET_SO_PRIORITY:
2864 optname = SO_PRIORITY;
2865 goto int_case;
2866#ifdef SO_BSDCOMPAT
2867 case TARGET_SO_BSDCOMPAT:
2868 optname = SO_BSDCOMPAT;
2869 goto int_case;
2870#endif
2871 case TARGET_SO_PASSCRED:
2872 optname = SO_PASSCRED;
2873 goto int_case;
2874 case TARGET_SO_TIMESTAMP:
2875 optname = SO_TIMESTAMP;
2876 goto int_case;
2877 case TARGET_SO_RCVLOWAT:
2878 optname = SO_RCVLOWAT;
2879 goto int_case;
aec1ca41
PB		 2880 case TARGET_SO_ACCEPTCONN:
2881 optname = SO_ACCEPTCONN;
2882 goto int_case;
8853f86e 2883 default:
2efbe911
FB		 2884 goto int_case;
2885 }
2886 break;
2887 case SOL_TCP:
2888 /* TCP options all take an 'int' value. */
2889 int_case:
2f619698
FB		 2890 if (get_user_u32(len, optlen))
2891 return -TARGET_EFAULT;
2efbe911 2892 if (len < 0)
0da46a6e 2893 return -TARGET_EINVAL;
73160d95 2894 lv = sizeof(lv);
2efbe911
FB		 2895 ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
2896 if (ret < 0)
2897 return ret;
8289d112
PB		 2898 if (optname == SO_TYPE) {
2899 val = host_to_target_sock_type(val);
2900 }
2efbe911
FB		 2901 if (len > lv)
2902 len = lv;
2f619698
FB		 2903 if (len == 4) {
2904 if (put_user_u32(val, optval_addr))
2905 return -TARGET_EFAULT;
2906 } else {
2907 if (put_user_u8(val, optval_addr))
2908 return -TARGET_EFAULT;
f3b974cd 2909 }
2f619698
FB		 2910 if (put_user_u32(len, optlen))
2911 return -TARGET_EFAULT;
2efbe911
FB		 2912 break;
2913 case SOL_IP:
2914 switch(optname) {
2915 case IP_TOS:
2916 case IP_TTL:
2917 case IP_HDRINCL:
2918 case IP_ROUTER_ALERT:
2919 case IP_RECVOPTS:
2920 case IP_RETOPTS:
2921 case IP_PKTINFO:
2922 case IP_MTU_DISCOVER:
2923 case IP_RECVERR:
2924 case IP_RECVTOS:
2925#ifdef IP_FREEBIND
2926 case IP_FREEBIND:
2927#endif
2928 case IP_MULTICAST_TTL:
2929 case IP_MULTICAST_LOOP:
2f619698
FB		 2930 if (get_user_u32(len, optlen))
2931 return -TARGET_EFAULT;
8853f86e 2932 if (len < 0)
0da46a6e 2933 return -TARGET_EINVAL;
73160d95 2934 lv = sizeof(lv);
8853f86e
FB		 2935 ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
2936 if (ret < 0)
2937 return ret;
2efbe911 2938 if (len < sizeof(int) && len > 0 && val >= 0 && val < 255) {
2efbe911 2939 len = 1;
2f619698
FB		 2940 if (put_user_u32(len, optlen)
2941 || put_user_u8(val, optval_addr))
2942 return -TARGET_EFAULT;
2efbe911 2943 } else {
2efbe911
FB		 2944 if (len > sizeof(int))
2945 len = sizeof(int);
2f619698
FB		 2946 if (put_user_u32(len, optlen)
2947 || put_user_u32(val, optval_addr))
2948 return -TARGET_EFAULT;
2efbe911 2949 }
8853f86e 2950 break;
2efbe911 2951 default:
c02f499e
TS		 2952 ret = -TARGET_ENOPROTOOPT;
2953 break;
8853f86e
FB		 2954 }
2955 break;
2956 default:
2957 unimplemented:
2958 gemu_log("getsockopt level=%d optname=%d not yet supported\n",
2959 level, optname);
c02f499e 2960 ret = -TARGET_EOPNOTSUPP;
8853f86e
FB		 2961 break;
2962 }
2963 return ret;
7854b056
FB		 2964}
2965
f287b2c2
RH		 2966static struct iovec *lock_iovec(int type, abi_ulong target_addr,
2967 int count, int copy)
53a5960a
PB		 2968{
2969 struct target_iovec *target_vec;
f287b2c2
RH		 2970 struct iovec *vec;
2971 abi_ulong total_len, max_len;
d732dcb4 2972 int i;
501bb4b0 2973 int err = 0;
29560a6c 2974 bool bad_address = false;
53a5960a 2975
f287b2c2
RH		 2976 if (count == 0) {
2977 errno = 0;
2978 return NULL;
2979 }
dfae8e00 2980 if (count < 0 || count > IOV_MAX) {
f287b2c2
RH		 2981 errno = EINVAL;
2982 return NULL;
2983 }
2984
0e173b24 2985 vec = g_try_new0(struct iovec, count);
f287b2c2
RH		 2986 if (vec == NULL) {
2987 errno = ENOMEM;
2988 return NULL;
2989 }
2990
2991 target_vec = lock_user(VERIFY_READ, target_addr,
2992 count * sizeof(struct target_iovec), 1);
2993 if (target_vec == NULL) {
501bb4b0 2994 err = EFAULT;
f287b2c2
RH		 2995 goto fail2;
2996 }
2997
2998 /* ??? If host page size > target page size, this will result in a
2999 value larger than what we can actually support. */
3000 max_len = 0x7fffffff & TARGET_PAGE_MASK;
3001 total_len = 0;
3002
3003 for (i = 0; i < count; i++) {
3004 abi_ulong base = tswapal(target_vec[i].iov_base);
3005 abi_long len = tswapal(target_vec[i].iov_len);
3006
3007 if (len < 0) {
501bb4b0 3008 err = EINVAL;
f287b2c2
RH		 3009 goto fail;
3010 } else if (len == 0) {
3011 /* Zero length pointer is ignored. */
3012 vec[i].iov_base = 0;
41df8411 3013 } else {
f287b2c2 3014 vec[i].iov_base = lock_user(type, base, len, copy);
29560a6c
TM		 3015 /* If the first buffer pointer is bad, this is a fault. But
3016 * subsequent bad buffers will result in a partial write; this
3017 * is realized by filling the vector with null pointers and
3018 * zero lengths. */
f287b2c2 3019 if (!vec[i].iov_base) {
29560a6c
TM		 3020 if (i == 0) {
3021 err = EFAULT;
3022 goto fail;
3023 } else {
3024 bad_address = true;
3025 }
3026 }
3027 if (bad_address) {
3028 len = 0;
f287b2c2
RH		 3029 }
3030 if (len > max_len - total_len) {
3031 len = max_len - total_len;
3032 }
41df8411 3033 }
f287b2c2
RH		 3034 vec[i].iov_len = len;
3035 total_len += len;
579a97f7 3036 }
f287b2c2
RH		 3037
3038 unlock_user(target_vec, target_addr, 0);
3039 return vec;
3040
3041 fail:
7eff518b
CG		 3042 while (--i >= 0) {
3043 if (tswapal(target_vec[i].iov_len) > 0) {
3044 unlock_user(vec[i].iov_base, tswapal(target_vec[i].iov_base), 0);
3045 }
3046 }
f287b2c2 3047 unlock_user(target_vec, target_addr, 0);
501bb4b0 3048 fail2:
0e173b24 3049 g_free(vec);
501bb4b0 3050 errno = err;
f287b2c2 3051 return NULL;
53a5960a
PB		 3052}
3053
f287b2c2
RH		 3054static void unlock_iovec(struct iovec *vec, abi_ulong target_addr,
3055 int count, int copy)
53a5960a
PB		 3056{
3057 struct target_iovec *target_vec;
53a5960a
PB		 3058 int i;
3059
f287b2c2
RH		 3060 target_vec = lock_user(VERIFY_READ, target_addr,
3061 count * sizeof(struct target_iovec), 1);
3062 if (target_vec) {
3063 for (i = 0; i < count; i++) {
3064 abi_ulong base = tswapal(target_vec[i].iov_base);
71ec7cef 3065 abi_long len = tswapal(target_vec[i].iov_len);
f287b2c2
RH		 3066 if (len < 0) {
3067 break;
3068 }
d732dcb4
AZ		 3069 unlock_user(vec[i].iov_base, base, copy ? vec[i].iov_len : 0);
3070 }
f287b2c2 3071 unlock_user(target_vec, target_addr, 0);
53a5960a 3072 }
579a97f7 3073
0e173b24 3074 g_free(vec);
53a5960a
PB		 3075}
3076
53d09b76 3077static inline int target_to_host_sock_type(int *type)
3532fa74 3078{
f651e6ae
PJ		 3079 int host_type = 0;
3080 int target_type = *type;
3081
3082 switch (target_type & TARGET_SOCK_TYPE_MASK) {
3532fa74 3083 case TARGET_SOCK_DGRAM:
f651e6ae 3084 host_type = SOCK_DGRAM;
3532fa74
FB		 3085 break;
3086 case TARGET_SOCK_STREAM:
f651e6ae 3087 host_type = SOCK_STREAM;
3532fa74 3088 break;
f651e6ae
PJ		 3089 default:
3090 host_type = target_type & TARGET_SOCK_TYPE_MASK;
3532fa74
FB		 3091 break;
3092 }
f651e6ae 3093 if (target_type & TARGET_SOCK_CLOEXEC) {
53d09b76 3094#if defined(SOCK_CLOEXEC)
f651e6ae 3095 host_type |= SOCK_CLOEXEC;
53d09b76
EI		 3096#else
3097 return -TARGET_EINVAL;
3098#endif
f651e6ae
PJ		 3099 }
3100 if (target_type & TARGET_SOCK_NONBLOCK) {
53d09b76 3101#if defined(SOCK_NONBLOCK)
f651e6ae 3102 host_type |= SOCK_NONBLOCK;
53d09b76
EI		 3103#elif !defined(O_NONBLOCK)
3104 return -TARGET_EINVAL;
3105#endif
f651e6ae
PJ		 3106 }
3107 *type = host_type;
53d09b76
EI		 3108 return 0;
3109}
3110
3111/* Try to emulate socket type flags after socket creation. */
3112static int sock_flags_fixup(int fd, int target_type)
3113{
3114#if !defined(SOCK_NONBLOCK) && defined(O_NONBLOCK)
3115 if (target_type & TARGET_SOCK_NONBLOCK) {
3116 int flags = fcntl(fd, F_GETFL);
3117 if (fcntl(fd, F_SETFL, O_NONBLOCK | flags) == -1) {
3118 close(fd);
3119 return -TARGET_EINVAL;
3120 }
3121 }
3122#endif
3123 return fd;
f651e6ae
PJ		 3124}
3125
0cf22722
LV		 3126static abi_long packet_target_to_host_sockaddr(void *host_addr,
3127 abi_ulong target_addr,
3128 socklen_t len)
3129{
3130 struct sockaddr *addr = host_addr;
3131 struct target_sockaddr *target_saddr;
3132
3133 target_saddr = lock_user(VERIFY_READ, target_addr, len, 1);
3134 if (!target_saddr) {
3135 return -TARGET_EFAULT;
3136 }
3137
3138 memcpy(addr, target_saddr, len);
3139 addr->sa_family = tswap16(target_saddr->sa_family);
3140 /* spkt_protocol is big-endian */
3141
3142 unlock_user(target_saddr, target_addr, 0);
3143 return 0;
3144}
3145
3146static TargetFdTrans target_packet_trans = {
3147 .target_to_host_addr = packet_target_to_host_sockaddr,
3148};
3149
575b22b1 3150#ifdef CONFIG_RTNETLINK
6c5b5645
LV		 3151static abi_long netlink_route_target_to_host(void *buf, size_t len)
3152{
ef759f6f
LV		 3153 abi_long ret;
3154
3155 ret = target_to_host_nlmsg_route(buf, len);
3156 if (ret < 0) {
3157 return ret;
3158 }
3159
3160 return len;
6c5b5645
LV		 3161}
3162
3163static abi_long netlink_route_host_to_target(void *buf, size_t len)
3164{
ef759f6f
LV		 3165 abi_long ret;
3166
3167 ret = host_to_target_nlmsg_route(buf, len);
3168 if (ret < 0) {
3169 return ret;
3170 }
3171
3172 return len;
6c5b5645
LV		 3173}
3174
3175static TargetFdTrans target_netlink_route_trans = {
3176 .target_to_host_data = netlink_route_target_to_host,
3177 .host_to_target_data = netlink_route_host_to_target,
3178};
575b22b1 3179#endif /* CONFIG_RTNETLINK */
6c5b5645 3180
5ce9bb59
LV		 3181static abi_long netlink_audit_target_to_host(void *buf, size_t len)
3182{
ef759f6f
LV		 3183 abi_long ret;
3184
3185 ret = target_to_host_nlmsg_audit(buf, len);
3186 if (ret < 0) {
3187 return ret;
3188 }
3189
3190 return len;
5ce9bb59
LV		 3191}
3192
3193static abi_long netlink_audit_host_to_target(void *buf, size_t len)
3194{
ef759f6f
LV		 3195 abi_long ret;
3196
3197 ret = host_to_target_nlmsg_audit(buf, len);
3198 if (ret < 0) {
3199 return ret;
3200 }
3201
3202 return len;
5ce9bb59
LV		 3203}
3204
3205static TargetFdTrans target_netlink_audit_trans = {
3206 .target_to_host_data = netlink_audit_target_to_host,
3207 .host_to_target_data = netlink_audit_host_to_target,
3208};
3209
f651e6ae
PJ		 3210/* do_socket() Must return target values and target errnos. */
3211static abi_long do_socket(int domain, int type, int protocol)
3212{
53d09b76
EI		 3213 int target_type = type;
3214 int ret;
3215
3216 ret = target_to_host_sock_type(&type);
3217 if (ret) {
3218 return ret;
3219 }
f651e6ae 3220
575b22b1
LV		 3221 if (domain == PF_NETLINK && !(
3222#ifdef CONFIG_RTNETLINK
3223 protocol == NETLINK_ROUTE ||
3224#endif
3225 protocol == NETLINK_KOBJECT_UEVENT ||
3226 protocol == NETLINK_AUDIT)) {
6c5b5645
LV		 3227 return -EPFNOSUPPORT;
3228 }
ff626f2d
LV		 3229
3230 if (domain == AF_PACKET ||
3231 (domain == AF_INET && type == SOCK_PACKET)) {
3232 protocol = tswap16(protocol);
3233 }
3234
53d09b76
EI		 3235 ret = get_errno(socket(domain, type, protocol));
3236 if (ret >= 0) {
3237 ret = sock_flags_fixup(ret, target_type);
0cf22722
LV		 3238 if (type == SOCK_PACKET) {
3239 /* Manage an obsolete case :
3240 * if socket type is SOCK_PACKET, bind by name
3241 */
3242 fd_trans_register(ret, &target_packet_trans);
6c5b5645
LV		 3243 } else if (domain == PF_NETLINK) {
3244 switch (protocol) {
575b22b1 3245#ifdef CONFIG_RTNETLINK
6c5b5645
LV		 3246 case NETLINK_ROUTE:
3247 fd_trans_register(ret, &target_netlink_route_trans);
3248 break;
575b22b1 3249#endif
b265620b
LV		 3250 case NETLINK_KOBJECT_UEVENT:
3251 /* nothing to do: messages are strings */
3252 break;
5ce9bb59
LV		 3253 case NETLINK_AUDIT:
3254 fd_trans_register(ret, &target_netlink_audit_trans);
3255 break;
6c5b5645
LV		 3256 default:
3257 g_assert_not_reached();
3258 }
0cf22722 3259 }
53d09b76
EI		 3260 }
3261 return ret;
3532fa74
FB		 3262}
3263
0da46a6e 3264/* do_bind() Must return target values and target errnos. */
992f48a0
BS		 3265static abi_long do_bind(int sockfd, abi_ulong target_addr,
3266 socklen_t addrlen)
3532fa74 3267{
8f7aeaf6 3268 void *addr;
917507b0 3269 abi_long ret;
8f7aeaf6 3270
38724253 3271 if ((int)addrlen < 0) {
8f7aeaf6 3272 return -TARGET_EINVAL;
38724253 3273 }
8f7aeaf6 3274
607175e0 3275 addr = alloca(addrlen+1);
3b46e624 3276
7b36f782 3277 ret = target_to_host_sockaddr(sockfd, addr, target_addr, addrlen);
917507b0
AP		 3278 if (ret)
3279 return ret;
3280
3532fa74
FB		 3281 return get_errno(bind(sockfd, addr, addrlen));
3282}
3283
0da46a6e 3284/* do_connect() Must return target values and target errnos. */
992f48a0
BS		 3285static abi_long do_connect(int sockfd, abi_ulong target_addr,
3286 socklen_t addrlen)
3532fa74 3287{
8f7aeaf6 3288 void *addr;
917507b0 3289 abi_long ret;
8f7aeaf6 3290
38724253 3291 if ((int)addrlen < 0) {
8f7aeaf6 3292 return -TARGET_EINVAL;
38724253 3293 }
8f7aeaf6 3294
2dd08dfd 3295 addr = alloca(addrlen+1);
3b46e624 3296
7b36f782 3297 ret = target_to_host_sockaddr(sockfd, addr, target_addr, addrlen);
917507b0
AP		 3298 if (ret)
3299 return ret;
3300
2a3c7619 3301 return get_errno(safe_connect(sockfd, addr, addrlen));
3532fa74
FB		 3302}
3303
f19e00d7
AG		 3304/* do_sendrecvmsg_locked() Must return target values and target errnos. */
3305static abi_long do_sendrecvmsg_locked(int fd, struct target_msghdr *msgp,
3306 int flags, int send)
3532fa74 3307{
6de645c7 3308 abi_long ret, len;
3532fa74
FB		 3309 struct msghdr msg;
3310 int count;
3311 struct iovec *vec;
992f48a0 3312 abi_ulong target_vec;
3532fa74 3313
3532fa74
FB		 3314 if (msgp->msg_name) {
3315 msg.msg_namelen = tswap32(msgp->msg_namelen);
2dd08dfd 3316 msg.msg_name = alloca(msg.msg_namelen+1);
7b36f782
LV		 3317 ret = target_to_host_sockaddr(fd, msg.msg_name,
3318 tswapal(msgp->msg_name),
3319 msg.msg_namelen);
917507b0 3320 if (ret) {
f287b2c2 3321 goto out2;
917507b0 3322 }
3532fa74
FB		 3323 } else {
3324 msg.msg_name = NULL;
3325 msg.msg_namelen = 0;
3326 }
cbb21eed 3327 msg.msg_controllen = 2 * tswapal(msgp->msg_controllen);
3532fa74
FB		 3328 msg.msg_control = alloca(msg.msg_controllen);
3329 msg.msg_flags = tswap32(msgp->msg_flags);
3b46e624 3330
cbb21eed 3331 count = tswapal(msgp->msg_iovlen);
cbb21eed 3332 target_vec = tswapal(msgp->msg_iov);
f287b2c2
RH		 3333 vec = lock_iovec(send ? VERIFY_READ : VERIFY_WRITE,
3334 target_vec, count, send);
3335 if (vec == NULL) {
3336 ret = -host_to_target_errno(errno);
3337 goto out2;
3338 }
3532fa74
FB		 3339 msg.msg_iovlen = count;
3340 msg.msg_iov = vec;
3b46e624 3341
3532fa74 3342 if (send) {
6c5b5645 3343 if (fd_trans_target_to_host_data(fd)) {
7d61d892
LV		 3344 void *host_msg;
3345
3346 host_msg = g_malloc(msg.msg_iov->iov_len);
3347 memcpy(host_msg, msg.msg_iov->iov_base, msg.msg_iov->iov_len);
3348 ret = fd_trans_target_to_host_data(fd)(host_msg,
6c5b5645 3349 msg.msg_iov->iov_len);
7d61d892
LV		 3350 if (ret >= 0) {
3351 msg.msg_iov->iov_base = host_msg;
3352 ret = get_errno(safe_sendmsg(fd, &msg, flags));
3353 }
3354 g_free(host_msg);
6c5b5645
LV		 3355 } else {
3356 ret = target_to_host_cmsg(&msg, msgp);
7d61d892
LV		 3357 if (ret == 0) {
3358 ret = get_errno(safe_sendmsg(fd, &msg, flags));
3359 }
6c5b5645 3360 }
3532fa74 3361 } else {
66687530 3362 ret = get_errno(safe_recvmsg(fd, &msg, flags));
6de645c7
AZ		 3363 if (!is_error(ret)) {
3364 len = ret;
6c5b5645
LV		 3365 if (fd_trans_host_to_target_data(fd)) {
3366 ret = fd_trans_host_to_target_data(fd)(msg.msg_iov->iov_base,
48dc0f2c 3367 len);
6c5b5645
LV		 3368 } else {
3369 ret = host_to_target_cmsg(msgp, &msg);
3370 }
ca619067
JH		 3371 if (!is_error(ret)) {
3372 msgp->msg_namelen = tswap32(msg.msg_namelen);
3373 if (msg.msg_name != NULL) {
3374 ret = host_to_target_sockaddr(tswapal(msgp->msg_name),
3375 msg.msg_name, msg.msg_namelen);
3376 if (ret) {
3377 goto out;
3378 }
3379 }
3380
6de645c7 3381 ret = len;
ca619067 3382 }
6de645c7 3383 }
3532fa74 3384 }
ca619067
JH		 3385
3386out:
3532fa74 3387 unlock_iovec(vec, target_vec, count, !send);
f287b2c2 3388out2:
f19e00d7
AG		 3389 return ret;
3390}
3391
3392static abi_long do_sendrecvmsg(int fd, abi_ulong target_msg,
3393 int flags, int send)
3394{
3395 abi_long ret;
3396 struct target_msghdr *msgp;
3397
3398 if (!lock_user_struct(send ? VERIFY_READ : VERIFY_WRITE,
3399 msgp,
3400 target_msg,
3401 send ? 1 : 0)) {
3402 return -TARGET_EFAULT;
3403 }
3404 ret = do_sendrecvmsg_locked(fd, msgp, flags, send);
579a97f7 3405 unlock_user_struct(msgp, target_msg, send ? 0 : 1);
3532fa74
FB		 3406 return ret;
3407}
3408
f19e00d7
AG		 3409/* We don't rely on the C library to have sendmmsg/recvmmsg support,
3410 * so it might not have this *mmsg-specific flag either.
3411 */
3412#ifndef MSG_WAITFORONE
3413#define MSG_WAITFORONE 0x10000
3414#endif
3415
3416static abi_long do_sendrecvmmsg(int fd, abi_ulong target_msgvec,
3417 unsigned int vlen, unsigned int flags,
3418 int send)
3419{
3420 struct target_mmsghdr *mmsgp;
3421 abi_long ret = 0;
3422 int i;
3423
3424 if (vlen > UIO_MAXIOV) {
3425 vlen = UIO_MAXIOV;
3426 }
3427
3428 mmsgp = lock_user(VERIFY_WRITE, target_msgvec, sizeof(*mmsgp) * vlen, 1);
3429 if (!mmsgp) {
3430 return -TARGET_EFAULT;
3431 }
3432
3433 for (i = 0; i < vlen; i++) {
3434 ret = do_sendrecvmsg_locked(fd, &mmsgp[i].msg_hdr, flags, send);
3435 if (is_error(ret)) {
3436 break;
3437 }
3438 mmsgp[i].msg_len = tswap32(ret);
3439 /* MSG_WAITFORONE turns on MSG_DONTWAIT after one packet */
3440 if (flags & MSG_WAITFORONE) {
3441 flags |= MSG_DONTWAIT;
3442 }
3443 }
3444
3445 unlock_user(mmsgp, target_msgvec, sizeof(*mmsgp) * i);
3446
3447 /* Return number of datagrams sent if we sent any at all;
3448 * otherwise return the error.
3449 */
3450 if (i) {
3451 return i;
3452 }
3453 return ret;
3454}
f19e00d7 3455
a94b4987
PM		 3456/* do_accept4() Must return target values and target errnos. */
3457static abi_long do_accept4(int fd, abi_ulong target_addr,
3458 abi_ulong target_addrlen_addr, int flags)
1be9e1dc 3459{
2f619698
FB		 3460 socklen_t addrlen;
3461 void *addr;
992f48a0 3462 abi_long ret;
d25295d4
PJ		 3463 int host_flags;
3464
3465 host_flags = target_to_host_bitmask(flags, fcntl_flags_tbl);
1be9e1dc 3466
a94b4987 3467 if (target_addr == 0) {
ff6dc130 3468 return get_errno(safe_accept4(fd, NULL, NULL, host_flags));
a94b4987 3469 }
917507b0
AP		 3470
3471 /* linux returns EINVAL if addrlen pointer is invalid */
2f619698 3472 if (get_user_u32(addrlen, target_addrlen_addr))
917507b0 3473 return -TARGET_EINVAL;
2f619698 3474
38724253 3475 if ((int)addrlen < 0) {
8f7aeaf6 3476 return -TARGET_EINVAL;
38724253 3477 }
8f7aeaf6 3478
917507b0
AP		 3479 if (!access_ok(VERIFY_WRITE, target_addr, addrlen))
3480 return -TARGET_EINVAL;
3481
2f619698
FB		 3482 addr = alloca(addrlen);
3483
ff6dc130 3484 ret = get_errno(safe_accept4(fd, addr, &addrlen, host_flags));
1be9e1dc
PB		 3485 if (!is_error(ret)) {
3486 host_to_target_sockaddr(target_addr, addr, addrlen);
2f619698
FB		 3487 if (put_user_u32(addrlen, target_addrlen_addr))
3488 ret = -TARGET_EFAULT;
1be9e1dc
PB		 3489 }
3490 return ret;
3491}
3492
0da46a6e 3493/* do_getpeername() Must return target values and target errnos. */
992f48a0 3494static abi_long do_getpeername(int fd, abi_ulong target_addr,
2f619698 3495 abi_ulong target_addrlen_addr)
1be9e1dc 3496{
2f619698
FB		 3497 socklen_t addrlen;
3498 void *addr;
992f48a0 3499 abi_long ret;
1be9e1dc 3500
2f619698
FB		 3501 if (get_user_u32(addrlen, target_addrlen_addr))
3502 return -TARGET_EFAULT;
3503
38724253 3504 if ((int)addrlen < 0) {
8f7aeaf6 3505 return -TARGET_EINVAL;
38724253 3506 }
8f7aeaf6 3507
917507b0
AP		 3508 if (!access_ok(VERIFY_WRITE, target_addr, addrlen))
3509 return -TARGET_EFAULT;
3510
2f619698
FB		 3511 addr = alloca(addrlen);
3512
1be9e1dc
PB		 3513 ret = get_errno(getpeername(fd, addr, &addrlen));
3514 if (!is_error(ret)) {
3515 host_to_target_sockaddr(target_addr, addr, addrlen);
2f619698
FB		 3516 if (put_user_u32(addrlen, target_addrlen_addr))
3517 ret = -TARGET_EFAULT;
1be9e1dc
PB		 3518 }
3519 return ret;
3520}
3521
0da46a6e 3522/* do_getsockname() Must return target values and target errnos. */
992f48a0 3523static abi_long do_getsockname(int fd, abi_ulong target_addr,
2f619698 3524 abi_ulong target_addrlen_addr)
1be9e1dc 3525{
2f619698
FB		 3526 socklen_t addrlen;
3527 void *addr;
992f48a0 3528 abi_long ret;
1be9e1dc 3529
2f619698
FB		 3530 if (get_user_u32(addrlen, target_addrlen_addr))
3531 return -TARGET_EFAULT;
3532
38724253 3533 if ((int)addrlen < 0) {
8f7aeaf6 3534 return -TARGET_EINVAL;
38724253 3535 }
8f7aeaf6 3536
917507b0
AP		 3537 if (!access_ok(VERIFY_WRITE, target_addr, addrlen))
3538 return -TARGET_EFAULT;
3539
2f619698
FB		 3540 addr = alloca(addrlen);
3541
1be9e1dc
PB		 3542 ret = get_errno(getsockname(fd, addr, &addrlen));
3543 if (!is_error(ret)) {
3544 host_to_target_sockaddr(target_addr, addr, addrlen);
2f619698
FB		 3545 if (put_user_u32(addrlen, target_addrlen_addr))
3546 ret = -TARGET_EFAULT;
1be9e1dc
PB		 3547 }
3548 return ret;
3549}
3550
0da46a6e 3551/* do_socketpair() Must return target values and target errnos. */
992f48a0 3552static abi_long do_socketpair(int domain, int type, int protocol,
2f619698 3553 abi_ulong target_tab_addr)
1be9e1dc
PB		 3554{
3555 int tab[2];
992f48a0 3556 abi_long ret;
1be9e1dc 3557
f651e6ae
PJ		 3558 target_to_host_sock_type(&type);
3559
1be9e1dc
PB		 3560 ret = get_errno(socketpair(domain, type, protocol, tab));
3561 if (!is_error(ret)) {
2f619698
FB		 3562 if (put_user_s32(tab[0], target_tab_addr)
3563 || put_user_s32(tab[1], target_tab_addr + sizeof(tab[0])))
3564 ret = -TARGET_EFAULT;
1be9e1dc
PB		 3565 }
3566 return ret;
3567}
3568
0da46a6e 3569/* do_sendto() Must return target values and target errnos. */
992f48a0
BS		 3570static abi_long do_sendto(int fd, abi_ulong msg, size_t len, int flags,
3571 abi_ulong target_addr, socklen_t addrlen)
1be9e1dc
PB		 3572{
3573 void *addr;
3574 void *host_msg;
7d61d892 3575 void *copy_msg = NULL;
992f48a0 3576 abi_long ret;
1be9e1dc 3577
38724253 3578 if ((int)addrlen < 0) {
8f7aeaf6 3579 return -TARGET_EINVAL;
38724253 3580 }
8f7aeaf6 3581
579a97f7
FB		 3582 host_msg = lock_user(VERIFY_READ, msg, len, 1);
3583 if (!host_msg)
3584 return -TARGET_EFAULT;
6c5b5645 3585 if (fd_trans_target_to_host_data(fd)) {
7d61d892
LV		 3586 copy_msg = host_msg;
3587 host_msg = g_malloc(len);
3588 memcpy(host_msg, copy_msg, len);
6c5b5645
LV		 3589 ret = fd_trans_target_to_host_data(fd)(host_msg, len);
3590 if (ret < 0) {
7d61d892 3591 goto fail;
6c5b5645
LV		 3592 }
3593 }
1be9e1dc 3594 if (target_addr) {
2dd08dfd 3595 addr = alloca(addrlen+1);
7b36f782 3596 ret = target_to_host_sockaddr(fd, addr, target_addr, addrlen);
917507b0 3597 if (ret) {
7d61d892 3598 goto fail;
917507b0 3599 }
66687530 3600 ret = get_errno(safe_sendto(fd, host_msg, len, flags, addr, addrlen));
1be9e1dc 3601 } else {
66687530 3602 ret = get_errno(safe_sendto(fd, host_msg, len, flags, NULL, 0));
1be9e1dc 3603 }
7d61d892
LV		 3604fail:
3605 if (copy_msg) {
3606 g_free(host_msg);
3607 host_msg = copy_msg;
3608 }
1be9e1dc
PB		 3609 unlock_user(host_msg, msg, 0);
3610 return ret;
3611}
3612
0da46a6e 3613/* do_recvfrom() Must return target values and target errnos. */
992f48a0
BS		 3614static abi_long do_recvfrom(int fd, abi_ulong msg, size_t len, int flags,
3615 abi_ulong target_addr,
3616 abi_ulong target_addrlen)
1be9e1dc
PB		 3617{
3618 socklen_t addrlen;
3619 void *addr;
3620 void *host_msg;
992f48a0 3621 abi_long ret;
1be9e1dc 3622
579a97f7
FB		 3623 host_msg = lock_user(VERIFY_WRITE, msg, len, 0);
3624 if (!host_msg)
3625 return -TARGET_EFAULT;
1be9e1dc 3626 if (target_addr) {
2f619698
FB		 3627 if (get_user_u32(addrlen, target_addrlen)) {
3628 ret = -TARGET_EFAULT;
3629 goto fail;
3630 }
38724253 3631 if ((int)addrlen < 0) {
8f7aeaf6
AJ		 3632 ret = -TARGET_EINVAL;
3633 goto fail;
3634 }
1be9e1dc 3635 addr = alloca(addrlen);
66687530
PM		 3636 ret = get_errno(safe_recvfrom(fd, host_msg, len, flags,
3637 addr, &addrlen));
1be9e1dc
PB		 3638 } else {
3639 addr = NULL; /* To keep compiler quiet. */
66687530 3640 ret = get_errno(safe_recvfrom(fd, host_msg, len, flags, NULL, 0));
1be9e1dc
PB		 3641 }
3642 if (!is_error(ret)) {
c35e1f9c
LV		 3643 if (fd_trans_host_to_target_data(fd)) {
3644 ret = fd_trans_host_to_target_data(fd)(host_msg, ret);
3645 }
1be9e1dc
PB		 3646 if (target_addr) {
3647 host_to_target_sockaddr(target_addr, addr, addrlen);
2f619698
FB		 3648 if (put_user_u32(addrlen, target_addrlen)) {
3649 ret = -TARGET_EFAULT;
3650 goto fail;
3651 }
1be9e1dc
PB		 3652 }
3653 unlock_user(host_msg, msg, len);
3654 } else {
2f619698 3655fail:
1be9e1dc
PB		 3656 unlock_user(host_msg, msg, 0);
3657 }
3658 return ret;
3659}
3660
32407103 3661#ifdef TARGET_NR_socketcall
0da46a6e 3662/* do_socketcall() Must return target values and target errnos. */
992f48a0 3663static abi_long do_socketcall(int num, abi_ulong vptr)
31e31b8a 3664{
62dc90c6
MT		 3665 static const unsigned ac[] = { /* number of arguments per call */
3666 [SOCKOP_socket] = 3, /* domain, type, protocol */
3667 [SOCKOP_bind] = 3, /* sockfd, addr, addrlen */
3668 [SOCKOP_connect] = 3, /* sockfd, addr, addrlen */
3669 [SOCKOP_listen] = 2, /* sockfd, backlog */
3670 [SOCKOP_accept] = 3, /* sockfd, addr, addrlen */
3671 [SOCKOP_accept4] = 4, /* sockfd, addr, addrlen, flags */
3672 [SOCKOP_getsockname] = 3, /* sockfd, addr, addrlen */
3673 [SOCKOP_getpeername] = 3, /* sockfd, addr, addrlen */
3674 [SOCKOP_socketpair] = 4, /* domain, type, protocol, tab */
3675 [SOCKOP_send] = 4, /* sockfd, msg, len, flags */
3676 [SOCKOP_recv] = 4, /* sockfd, msg, len, flags */
3677 [SOCKOP_sendto] = 6, /* sockfd, msg, len, flags, addr, addrlen */
3678 [SOCKOP_recvfrom] = 6, /* sockfd, msg, len, flags, addr, addrlen */
3679 [SOCKOP_shutdown] = 2, /* sockfd, how */
3680 [SOCKOP_sendmsg] = 3, /* sockfd, msg, flags */
3681 [SOCKOP_recvmsg] = 3, /* sockfd, msg, flags */
5a53dc50
JPAG		 3682 [SOCKOP_sendmmsg] = 4, /* sockfd, msgvec, vlen, flags */
3683 [SOCKOP_recvmmsg] = 4, /* sockfd, msgvec, vlen, flags */
62dc90c6
MT		 3684 [SOCKOP_setsockopt] = 5, /* sockfd, level, optname, optval, optlen */
3685 [SOCKOP_getsockopt] = 5, /* sockfd, level, optname, optval, optlen */
3686 };
3687 abi_long a[6]; /* max 6 args */
3688
3689 /* first, collect the arguments in a[] according to ac[] */
3690 if (num >= 0 && num < ARRAY_SIZE(ac)) {
3691 unsigned i;
3692 assert(ARRAY_SIZE(a) >= ac[num]); /* ensure we have space for args */
3693 for (i = 0; i < ac[num]; ++i) {
3694 if (get_user_ual(a[i], vptr + i * sizeof(abi_long)) != 0) {
b9d36eb2
AH		 3695 return -TARGET_EFAULT;
3696 }
31e31b8a 3697 }
62dc90c6 3698 }
7854b056 3699
62dc90c6
MT		 3700 /* now when we have the args, actually handle the call */
3701 switch (num) {
3702 case SOCKOP_socket: /* domain, type, protocol */
3703 return do_socket(a[0], a[1], a[2]);
3704 case SOCKOP_bind: /* sockfd, addr, addrlen */
3705 return do_bind(a[0], a[1], a[2]);
3706 case SOCKOP_connect: /* sockfd, addr, addrlen */
3707 return do_connect(a[0], a[1], a[2]);
3708 case SOCKOP_listen: /* sockfd, backlog */
3709 return get_errno(listen(a[0], a[1]));
3710 case SOCKOP_accept: /* sockfd, addr, addrlen */
3711 return do_accept4(a[0], a[1], a[2], 0);
3712 case SOCKOP_accept4: /* sockfd, addr, addrlen, flags */
3713 return do_accept4(a[0], a[1], a[2], a[3]);
3714 case SOCKOP_getsockname: /* sockfd, addr, addrlen */
3715 return do_getsockname(a[0], a[1], a[2]);
3716 case SOCKOP_getpeername: /* sockfd, addr, addrlen */
3717 return do_getpeername(a[0], a[1], a[2]);
3718 case SOCKOP_socketpair: /* domain, type, protocol, tab */
3719 return do_socketpair(a[0], a[1], a[2], a[3]);
3720 case SOCKOP_send: /* sockfd, msg, len, flags */
3721 return do_sendto(a[0], a[1], a[2], a[3], 0, 0);
3722 case SOCKOP_recv: /* sockfd, msg, len, flags */
3723 return do_recvfrom(a[0], a[1], a[2], a[3], 0, 0);
3724 case SOCKOP_sendto: /* sockfd, msg, len, flags, addr, addrlen */
3725 return do_sendto(a[0], a[1], a[2], a[3], a[4], a[5]);
3726 case SOCKOP_recvfrom: /* sockfd, msg, len, flags, addr, addrlen */
3727 return do_recvfrom(a[0], a[1], a[2], a[3], a[4], a[5]);
3728 case SOCKOP_shutdown: /* sockfd, how */
3729 return get_errno(shutdown(a[0], a[1]));
3730 case SOCKOP_sendmsg: /* sockfd, msg, flags */
3731 return do_sendrecvmsg(a[0], a[1], a[2], 1);
3732 case SOCKOP_recvmsg: /* sockfd, msg, flags */
3733 return do_sendrecvmsg(a[0], a[1], a[2], 0);
5a53dc50
JPAG		 3734 case SOCKOP_sendmmsg: /* sockfd, msgvec, vlen, flags */
3735 return do_sendrecvmmsg(a[0], a[1], a[2], a[3], 1);
3736 case SOCKOP_recvmmsg: /* sockfd, msgvec, vlen, flags */
3737 return do_sendrecvmmsg(a[0], a[1], a[2], a[3], 0);
62dc90c6
MT		 3738 case SOCKOP_setsockopt: /* sockfd, level, optname, optval, optlen */
3739 return do_setsockopt(a[0], a[1], a[2], a[3], a[4]);
3740 case SOCKOP_getsockopt: /* sockfd, level, optname, optval, optlen */
3741 return do_getsockopt(a[0], a[1], a[2], a[3], a[4]);
31e31b8a
FB		 3742 default:
3743 gemu_log("Unsupported socketcall: %d\n", num);
62dc90c6 3744 return -TARGET_ENOSYS;
31e31b8a 3745 }
31e31b8a 3746}
32407103 3747#endif
31e31b8a 3748
8853f86e
FB		 3749#define N_SHM_REGIONS 32
3750
3751static struct shm_region {
b6e17875
PM		 3752 abi_ulong start;
3753 abi_ulong size;
3754 bool in_use;
8853f86e
FB		 3755} shm_regions[N_SHM_REGIONS];
3756
005eb2ae
PM		 3757#ifndef TARGET_SEMID64_DS
3758/* asm-generic version of this struct */
3759struct target_semid64_ds
3eb6b044
TS		 3760{
3761 struct target_ipc_perm sem_perm;
992f48a0 3762 abi_ulong sem_otime;
005eb2ae 3763#if TARGET_ABI_BITS == 32
992f48a0 3764 abi_ulong __unused1;
03527344 3765#endif
992f48a0 3766 abi_ulong sem_ctime;
005eb2ae 3767#if TARGET_ABI_BITS == 32
992f48a0 3768 abi_ulong __unused2;
03527344 3769#endif
992f48a0
BS		 3770 abi_ulong sem_nsems;
3771 abi_ulong __unused3;
3772 abi_ulong __unused4;
3eb6b044 3773};
005eb2ae 3774#endif
3eb6b044 3775
579a97f7
FB		 3776static inline abi_long target_to_host_ipc_perm(struct ipc_perm *host_ip,
3777 abi_ulong target_addr)
3eb6b044
TS		 3778{
3779 struct target_ipc_perm *target_ip;
005eb2ae 3780 struct target_semid64_ds *target_sd;
3eb6b044 3781
579a97f7
FB		 3782 if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1))
3783 return -TARGET_EFAULT;
e8bbe36c 3784 target_ip = &(target_sd->sem_perm);
55a2b163
PJ		 3785 host_ip->__key = tswap32(target_ip->__key);
3786 host_ip->uid = tswap32(target_ip->uid);
3787 host_ip->gid = tswap32(target_ip->gid);
3788 host_ip->cuid = tswap32(target_ip->cuid);
3789 host_ip->cgid = tswap32(target_ip->cgid);
3790#if defined(TARGET_ALPHA) || defined(TARGET_MIPS) || defined(TARGET_PPC)
3791 host_ip->mode = tswap32(target_ip->mode);
3792#else
cbb21eed 3793 host_ip->mode = tswap16(target_ip->mode);
55a2b163
PJ		 3794#endif
3795#if defined(TARGET_PPC)
3796 host_ip->__seq = tswap32(target_ip->__seq);
3797#else
3798 host_ip->__seq = tswap16(target_ip->__seq);
3799#endif
3eb6b044 3800 unlock_user_struct(target_sd, target_addr, 0);
579a97f7 3801 return 0;
3eb6b044
TS		 3802}
3803
579a97f7
FB		 3804static inline abi_long host_to_target_ipc_perm(abi_ulong target_addr,
3805 struct ipc_perm *host_ip)
3eb6b044
TS		 3806{
3807 struct target_ipc_perm *target_ip;
005eb2ae 3808 struct target_semid64_ds *target_sd;
3eb6b044 3809
579a97f7
FB		 3810 if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0))
3811 return -TARGET_EFAULT;
3eb6b044 3812 target_ip = &(target_sd->sem_perm);
55a2b163
PJ		 3813 target_ip->__key = tswap32(host_ip->__key);
3814 target_ip->uid = tswap32(host_ip->uid);
3815 target_ip->gid = tswap32(host_ip->gid);
3816 target_ip->cuid = tswap32(host_ip->cuid);
3817 target_ip->cgid = tswap32(host_ip->cgid);
3818#if defined(TARGET_ALPHA) || defined(TARGET_MIPS) || defined(TARGET_PPC)
3819 target_ip->mode = tswap32(host_ip->mode);
3820#else
cbb21eed 3821 target_ip->mode = tswap16(host_ip->mode);
55a2b163
PJ		 3822#endif
3823#if defined(TARGET_PPC)
3824 target_ip->__seq = tswap32(host_ip->__seq);
3825#else
3826 target_ip->__seq = tswap16(host_ip->__seq);
3827#endif
3eb6b044 3828 unlock_user_struct(target_sd, target_addr, 1);
579a97f7 3829 return 0;
3eb6b044
TS		 3830}
3831
579a97f7
FB		 3832static inline abi_long target_to_host_semid_ds(struct semid_ds *host_sd,
3833 abi_ulong target_addr)
3eb6b044 3834{
005eb2ae 3835 struct target_semid64_ds *target_sd;
3eb6b044 3836
579a97f7
FB		 3837 if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1))
3838 return -TARGET_EFAULT;
e5289087
AJ		 3839 if (target_to_host_ipc_perm(&(host_sd->sem_perm),target_addr))
3840 return -TARGET_EFAULT;
cbb21eed
MB		 3841 host_sd->sem_nsems = tswapal(target_sd->sem_nsems);
3842 host_sd->sem_otime = tswapal(target_sd->sem_otime);
3843 host_sd->sem_ctime = tswapal(target_sd->sem_ctime);
3eb6b044 3844 unlock_user_struct(target_sd, target_addr, 0);
579a97f7 3845 return 0;
3eb6b044
TS		 3846}
3847
579a97f7
FB		 3848static inline abi_long host_to_target_semid_ds(abi_ulong target_addr,
3849 struct semid_ds *host_sd)
3eb6b044 3850{
005eb2ae 3851 struct target_semid64_ds *target_sd;
3eb6b044 3852
579a97f7
FB		 3853 if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0))
3854 return -TARGET_EFAULT;
e5289087 3855 if (host_to_target_ipc_perm(target_addr,&(host_sd->sem_perm)))
3a93113a 3856 return -TARGET_EFAULT;
cbb21eed
MB		 3857 target_sd->sem_nsems = tswapal(host_sd->sem_nsems);
3858 target_sd->sem_otime = tswapal(host_sd->sem_otime);
3859 target_sd->sem_ctime = tswapal(host_sd->sem_ctime);
3eb6b044 3860 unlock_user_struct(target_sd, target_addr, 1);
579a97f7 3861 return 0;
3eb6b044
TS		 3862}
3863
e5289087
AJ		 3864struct target_seminfo {
3865 int semmap;
3866 int semmni;
3867 int semmns;
3868 int semmnu;
3869 int semmsl;
3870 int semopm;
3871 int semume;
3872 int semusz;
3873 int semvmx;
3874 int semaem;
3875};
3876
3877static inline abi_long host_to_target_seminfo(abi_ulong target_addr,
3878 struct seminfo *host_seminfo)
3879{
3880 struct target_seminfo *target_seminfo;
3881 if (!lock_user_struct(VERIFY_WRITE, target_seminfo, target_addr, 0))
3882 return -TARGET_EFAULT;
3883 __put_user(host_seminfo->semmap, &target_seminfo->semmap);
3884 __put_user(host_seminfo->semmni, &target_seminfo->semmni);
3885 __put_user(host_seminfo->semmns, &target_seminfo->semmns);
3886 __put_user(host_seminfo->semmnu, &target_seminfo->semmnu);
3887 __put_user(host_seminfo->semmsl, &target_seminfo->semmsl);
3888 __put_user(host_seminfo->semopm, &target_seminfo->semopm);
3889 __put_user(host_seminfo->semume, &target_seminfo->semume);
3890 __put_user(host_seminfo->semusz, &target_seminfo->semusz);
3891 __put_user(host_seminfo->semvmx, &target_seminfo->semvmx);
3892 __put_user(host_seminfo->semaem, &target_seminfo->semaem);
3893 unlock_user_struct(target_seminfo, target_addr, 1);
3894 return 0;
3895}
3896
fa294816
TS		 3897union semun {
3898 int val;
3eb6b044 3899 struct semid_ds *buf;
fa294816 3900 unsigned short *array;
e5289087 3901 struct seminfo *__buf;
fa294816
TS		 3902};
3903
3eb6b044
TS		 3904union target_semun {
3905 int val;
e5289087
AJ		 3906 abi_ulong buf;
3907 abi_ulong array;
3908 abi_ulong __buf;
3eb6b044
TS		 3909};
3910
e5289087
AJ		 3911static inline abi_long target_to_host_semarray(int semid, unsigned short **host_array,
3912 abi_ulong target_addr)
3eb6b044 3913{
e5289087
AJ		 3914 int nsems;
3915 unsigned short *array;
3916 union semun semun;
3917 struct semid_ds semid_ds;
3918 int i, ret;
3eb6b044 3919
e5289087
AJ		 3920 semun.buf = &semid_ds;
3921
3922 ret = semctl(semid, 0, IPC_STAT, semun);
3923 if (ret == -1)
3924 return get_errno(ret);
3925
3926 nsems = semid_ds.sem_nsems;
3927
0e173b24 3928 *host_array = g_try_new(unsigned short, nsems);
69d4c703
PM		 3929 if (!*host_array) {
3930 return -TARGET_ENOMEM;
3931 }
e5289087
AJ		 3932 array = lock_user(VERIFY_READ, target_addr,
3933 nsems*sizeof(unsigned short), 1);
69d4c703 3934 if (!array) {
0e173b24 3935 g_free(*host_array);
e5289087 3936 return -TARGET_EFAULT;
69d4c703 3937 }
e5289087
AJ		 3938
3939 for(i=0; i<nsems; i++) {
3940 __get_user((*host_array)[i], &array[i]);
3eb6b044 3941 }
e5289087
AJ		 3942 unlock_user(array, target_addr, 0);
3943
579a97f7 3944 return 0;
3eb6b044
TS		 3945}
3946
e5289087
AJ		 3947static inline abi_long host_to_target_semarray(int semid, abi_ulong target_addr,
3948 unsigned short **host_array)
3eb6b044 3949{
e5289087
AJ		 3950 int nsems;
3951 unsigned short *array;
3952 union semun semun;
3953 struct semid_ds semid_ds;
3954 int i, ret;
3eb6b044 3955
e5289087
AJ		 3956 semun.buf = &semid_ds;
3957
3958 ret = semctl(semid, 0, IPC_STAT, semun);
3959 if (ret == -1)
3960 return get_errno(ret);
3961
3962 nsems = semid_ds.sem_nsems;
3963
3964 array = lock_user(VERIFY_WRITE, target_addr,
3965 nsems*sizeof(unsigned short), 0);
3966 if (!array)
3967 return -TARGET_EFAULT;
3968
3969 for(i=0; i<nsems; i++) {
3970 __put_user((*host_array)[i], &array[i]);
3eb6b044 3971 }
0e173b24 3972 g_free(*host_array);
e5289087
AJ		 3973 unlock_user(array, target_addr, 1);
3974
579a97f7 3975 return 0;
3eb6b044
TS		 3976}
3977
e5289087 3978static inline abi_long do_semctl(int semid, int semnum, int cmd,
d1c002b6 3979 abi_ulong target_arg)
3eb6b044 3980{
d1c002b6 3981 union target_semun target_su = { .buf = target_arg };
3eb6b044
TS		 3982 union semun arg;
3983 struct semid_ds dsarg;
7b8118e8 3984 unsigned short *array = NULL;
e5289087
AJ		 3985 struct seminfo seminfo;
3986 abi_long ret = -TARGET_EINVAL;
3987 abi_long err;
3988 cmd &= 0xff;
3eb6b044
TS		 3989
3990 switch( cmd ) {
3991 case GETVAL:
3eb6b044 3992 case SETVAL:
5464baec
TM		 3993 /* In 64 bit cross-endian situations, we will erroneously pick up
3994 * the wrong half of the union for the "val" element. To rectify
3995 * this, the entire 8-byte structure is byteswapped, followed by
3996 * a swap of the 4 byte val field. In other cases, the data is
3997 * already in proper host byte order. */
3998 if (sizeof(target_su.val) != (sizeof(target_su.buf))) {
3999 target_su.buf = tswapal(target_su.buf);
4000 arg.val = tswap32(target_su.val);
4001 } else {
4002 arg.val = target_su.val;
4003 }
e5289087 4004 ret = get_errno(semctl(semid, semnum, cmd, arg));
3eb6b044
TS		 4005 break;
4006 case GETALL:
3eb6b044 4007 case SETALL:
e5289087
AJ		 4008 err = target_to_host_semarray(semid, &array, target_su.array);
4009 if (err)
4010 return err;
4011 arg.array = array;
4012 ret = get_errno(semctl(semid, semnum, cmd, arg));
4013 err = host_to_target_semarray(semid, target_su.array, &array);
4014 if (err)
4015 return err;
3eb6b044
TS		 4016 break;
4017 case IPC_STAT:
3eb6b044 4018 case IPC_SET:
e5289087
AJ		 4019 case SEM_STAT:
4020 err = target_to_host_semid_ds(&dsarg, target_su.buf);
4021 if (err)
4022 return err;
4023 arg.buf = &dsarg;
4024 ret = get_errno(semctl(semid, semnum, cmd, arg));
4025 err = host_to_target_semid_ds(target_su.buf, &dsarg);
4026 if (err)
4027 return err;
4028 break;
4029 case IPC_INFO:
4030 case SEM_INFO:
4031 arg.__buf = &seminfo;
4032 ret = get_errno(semctl(semid, semnum, cmd, arg));
4033 err = host_to_target_seminfo(target_su.__buf, &seminfo);
4034 if (err)
4035 return err;
4036 break;
4037 case IPC_RMID:
4038 case GETPID:
4039 case GETNCNT:
4040 case GETZCNT:
4041 ret = get_errno(semctl(semid, semnum, cmd, NULL));
3eb6b044 4042 break;
3eb6b044
TS		 4043 }
4044
4045 return ret;
4046}
4047
e5289087
AJ		 4048struct target_sembuf {
4049 unsigned short sem_num;
4050 short sem_op;
4051 short sem_flg;
4052};
4053
4054static inline abi_long target_to_host_sembuf(struct sembuf *host_sembuf,
4055 abi_ulong target_addr,
4056 unsigned nsops)
4057{
4058 struct target_sembuf *target_sembuf;
4059 int i;
4060
4061 target_sembuf = lock_user(VERIFY_READ, target_addr,
4062 nsops*sizeof(struct target_sembuf), 1);
4063 if (!target_sembuf)
4064 return -TARGET_EFAULT;
4065
4066 for(i=0; i<nsops; i++) {
4067 __get_user(host_sembuf[i].sem_num, &target_sembuf[i].sem_num);
4068 __get_user(host_sembuf[i].sem_op, &target_sembuf[i].sem_op);
4069 __get_user(host_sembuf[i].sem_flg, &target_sembuf[i].sem_flg);
4070 }
4071
4072 unlock_user(target_sembuf, target_addr, 0);
4073
4074 return 0;
4075}
4076
4077static inline abi_long do_semop(int semid, abi_long ptr, unsigned nsops)
4078{
4079 struct sembuf sops[nsops];
4080
4081 if (target_to_host_sembuf(sops, ptr, nsops))
4082 return -TARGET_EFAULT;
4083
ffb7ee79 4084 return get_errno(safe_semtimedop(semid, sops, nsops, NULL));
e5289087
AJ		 4085}
4086
1bc012f6
TS		 4087struct target_msqid_ds
4088{
1c54ff97
AJ		 4089 struct target_ipc_perm msg_perm;
4090 abi_ulong msg_stime;
4091#if TARGET_ABI_BITS == 32
4092 abi_ulong __unused1;
4093#endif
4094 abi_ulong msg_rtime;
4095#if TARGET_ABI_BITS == 32
4096 abi_ulong __unused2;
4097#endif
4098 abi_ulong msg_ctime;
4099#if TARGET_ABI_BITS == 32
4100 abi_ulong __unused3;
4101#endif
4102 abi_ulong __msg_cbytes;
4103 abi_ulong msg_qnum;
4104 abi_ulong msg_qbytes;
4105 abi_ulong msg_lspid;
4106 abi_ulong msg_lrpid;
4107 abi_ulong __unused4;
4108 abi_ulong __unused5;
1bc012f6
TS		 4109};
4110
579a97f7
FB		 4111static inline abi_long target_to_host_msqid_ds(struct msqid_ds *host_md,
4112 abi_ulong target_addr)
1bc012f6
TS		 4113{
4114 struct target_msqid_ds *target_md;
4115
579a97f7
FB		 4116 if (!lock_user_struct(VERIFY_READ, target_md, target_addr, 1))
4117 return -TARGET_EFAULT;
1c54ff97
AJ		 4118 if (target_to_host_ipc_perm(&(host_md->msg_perm),target_addr))
4119 return -TARGET_EFAULT;
cbb21eed
MB		 4120 host_md->msg_stime = tswapal(target_md->msg_stime);
4121 host_md->msg_rtime = tswapal(target_md->msg_rtime);
4122 host_md->msg_ctime = tswapal(target_md->msg_ctime);
4123 host_md->__msg_cbytes = tswapal(target_md->__msg_cbytes);
4124 host_md->msg_qnum = tswapal(target_md->msg_qnum);
4125 host_md->msg_qbytes = tswapal(target_md->msg_qbytes);
4126 host_md->msg_lspid = tswapal(target_md->msg_lspid);
4127 host_md->msg_lrpid = tswapal(target_md->msg_lrpid);
1bc012f6 4128 unlock_user_struct(target_md, target_addr, 0);
579a97f7 4129 return 0;
1bc012f6
TS		 4130}
4131
579a97f7
FB		 4132static inline abi_long host_to_target_msqid_ds(abi_ulong target_addr,
4133 struct msqid_ds *host_md)
1bc012f6
TS		 4134{
4135 struct target_msqid_ds *target_md;
4136
579a97f7
FB		 4137 if (!lock_user_struct(VERIFY_WRITE, target_md, target_addr, 0))
4138 return -TARGET_EFAULT;
1c54ff97
AJ		 4139 if (host_to_target_ipc_perm(target_addr,&(host_md->msg_perm)))
4140 return -TARGET_EFAULT;
cbb21eed
MB		 4141 target_md->msg_stime = tswapal(host_md->msg_stime);
4142 target_md->msg_rtime = tswapal(host_md->msg_rtime);
4143 target_md->msg_ctime = tswapal(host_md->msg_ctime);
4144 target_md->__msg_cbytes = tswapal(host_md->__msg_cbytes);
4145 target_md->msg_qnum = tswapal(host_md->msg_qnum);
4146 target_md->msg_qbytes = tswapal(host_md->msg_qbytes);
4147 target_md->msg_lspid = tswapal(host_md->msg_lspid);
4148 target_md->msg_lrpid = tswapal(host_md->msg_lrpid);
1bc012f6 4149 unlock_user_struct(target_md, target_addr, 1);
579a97f7 4150 return 0;
1bc012f6
TS		 4151}
4152
1c54ff97
AJ		 4153struct target_msginfo {
4154 int msgpool;
4155 int msgmap;
4156 int msgmax;
4157 int msgmnb;
4158 int msgmni;
4159 int msgssz;
4160 int msgtql;
4161 unsigned short int msgseg;
4162};
4163
4164static inline abi_long host_to_target_msginfo(abi_ulong target_addr,
4165 struct msginfo *host_msginfo)
4166{
4167 struct target_msginfo *target_msginfo;
4168 if (!lock_user_struct(VERIFY_WRITE, target_msginfo, target_addr, 0))
4169 return -TARGET_EFAULT;
4170 __put_user(host_msginfo->msgpool, &target_msginfo->msgpool);
4171 __put_user(host_msginfo->msgmap, &target_msginfo->msgmap);
4172 __put_user(host_msginfo->msgmax, &target_msginfo->msgmax);
4173 __put_user(host_msginfo->msgmnb, &target_msginfo->msgmnb);
4174 __put_user(host_msginfo->msgmni, &target_msginfo->msgmni);
4175 __put_user(host_msginfo->msgssz, &target_msginfo->msgssz);
4176 __put_user(host_msginfo->msgtql, &target_msginfo->msgtql);
4177 __put_user(host_msginfo->msgseg, &target_msginfo->msgseg);
4178 unlock_user_struct(target_msginfo, target_addr, 1);
00b229ac 4179 return 0;
1c54ff97
AJ		 4180}
4181
4182static inline abi_long do_msgctl(int msgid, int cmd, abi_long ptr)
1bc012f6
TS		 4183{
4184 struct msqid_ds dsarg;
1c54ff97
AJ		 4185 struct msginfo msginfo;
4186 abi_long ret = -TARGET_EINVAL;
4187
4188 cmd &= 0xff;
4189
4190 switch (cmd) {
1bc012f6
TS		 4191 case IPC_STAT:
4192 case IPC_SET:
1c54ff97
AJ		 4193 case MSG_STAT:
4194 if (target_to_host_msqid_ds(&dsarg,ptr))
4195 return -TARGET_EFAULT;
4196 ret = get_errno(msgctl(msgid, cmd, &dsarg));
4197 if (host_to_target_msqid_ds(ptr,&dsarg))
4198 return -TARGET_EFAULT;
4199 break;
4200 case IPC_RMID:
4201 ret = get_errno(msgctl(msgid, cmd, NULL));
4202 break;
4203 case IPC_INFO:
4204 case MSG_INFO:
4205 ret = get_errno(msgctl(msgid, cmd, (struct msqid_ds *)&msginfo));
4206 if (host_to_target_msginfo(ptr, &msginfo))
4207 return -TARGET_EFAULT;
4208 break;
1bc012f6 4209 }
1c54ff97 4210
1bc012f6
TS		 4211 return ret;
4212}
4213
4214struct target_msgbuf {
1c54ff97
AJ		 4215 abi_long mtype;
4216 char mtext[1];
1bc012f6
TS		 4217};
4218
992f48a0 4219static inline abi_long do_msgsnd(int msqid, abi_long msgp,
edcc5f9d 4220 ssize_t msgsz, int msgflg)
1bc012f6
TS		 4221{
4222 struct target_msgbuf *target_mb;
4223 struct msgbuf *host_mb;
992f48a0 4224 abi_long ret = 0;
1bc012f6 4225
edcc5f9d
TM		 4226 if (msgsz < 0) {
4227 return -TARGET_EINVAL;
4228 }
4229
579a97f7
FB		 4230 if (!lock_user_struct(VERIFY_READ, target_mb, msgp, 0))
4231 return -TARGET_EFAULT;
0e173b24 4232 host_mb = g_try_malloc(msgsz + sizeof(long));
29e03fcb
HZ		 4233 if (!host_mb) {
4234 unlock_user_struct(target_mb, msgp, 0);
4235 return -TARGET_ENOMEM;
4236 }
cbb21eed 4237 host_mb->mtype = (abi_long) tswapal(target_mb->mtype);
1c54ff97 4238 memcpy(host_mb->mtext, target_mb->mtext, msgsz);
89f9fe44 4239 ret = get_errno(safe_msgsnd(msqid, host_mb, msgsz, msgflg));
0e173b24 4240 g_free(host_mb);
1bc012f6
TS		 4241 unlock_user_struct(target_mb, msgp, 0);
4242
4243 return ret;
4244}
4245
992f48a0 4246static inline abi_long do_msgrcv(int msqid, abi_long msgp,
99874f65 4247 ssize_t msgsz, abi_long msgtyp,
992f48a0 4248 int msgflg)
1bc012f6
TS		 4249{
4250 struct target_msgbuf *target_mb;
579a97f7 4251 char *target_mtext;
1bc012f6 4252 struct msgbuf *host_mb;
992f48a0 4253 abi_long ret = 0;
1bc012f6 4254
99874f65
PM		 4255 if (msgsz < 0) {
4256 return -TARGET_EINVAL;
4257 }
4258
579a97f7
FB		 4259 if (!lock_user_struct(VERIFY_WRITE, target_mb, msgp, 0))
4260 return -TARGET_EFAULT;
1c54ff97 4261
415d8471
PM		 4262 host_mb = g_try_malloc(msgsz + sizeof(long));
4263 if (!host_mb) {
4264 ret = -TARGET_ENOMEM;
4265 goto end;
4266 }
89f9fe44 4267 ret = get_errno(safe_msgrcv(msqid, host_mb, msgsz, msgtyp, msgflg));
1c54ff97 4268
579a97f7
FB		 4269 if (ret > 0) {
4270 abi_ulong target_mtext_addr = msgp + sizeof(abi_ulong);
4271 target_mtext = lock_user(VERIFY_WRITE, target_mtext_addr, ret, 0);
4272 if (!target_mtext) {
4273 ret = -TARGET_EFAULT;
4274 goto end;
4275 }
1c54ff97 4276 memcpy(target_mb->mtext, host_mb->mtext, ret);
579a97f7
FB		 4277 unlock_user(target_mtext, target_mtext_addr, ret);
4278 }
1c54ff97 4279
cbb21eed 4280 target_mb->mtype = tswapal(host_mb->mtype);
1bc012f6 4281
579a97f7
FB		 4282end:
4283 if (target_mb)
4284 unlock_user_struct(target_mb, msgp, 1);
0d07fe47 4285 g_free(host_mb);
1bc012f6
TS		 4286 return ret;
4287}
4288
88a8c984
RV		 4289static inline abi_long target_to_host_shmid_ds(struct shmid_ds *host_sd,
4290 abi_ulong target_addr)
4291{
4292 struct target_shmid_ds *target_sd;
4293
4294 if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1))
4295 return -TARGET_EFAULT;
4296 if (target_to_host_ipc_perm(&(host_sd->shm_perm), target_addr))
4297 return -TARGET_EFAULT;
4298 __get_user(host_sd->shm_segsz, &target_sd->shm_segsz);
4299 __get_user(host_sd->shm_atime, &target_sd->shm_atime);
4300 __get_user(host_sd->shm_dtime, &target_sd->shm_dtime);
4301 __get_user(host_sd->shm_ctime, &target_sd->shm_ctime);
4302 __get_user(host_sd->shm_cpid, &target_sd->shm_cpid);
4303 __get_user(host_sd->shm_lpid, &target_sd->shm_lpid);
4304 __get_user(host_sd->shm_nattch, &target_sd->shm_nattch);
4305 unlock_user_struct(target_sd, target_addr, 0);
4306 return 0;
4307}
4308
4309static inline abi_long host_to_target_shmid_ds(abi_ulong target_addr,
4310 struct shmid_ds *host_sd)
4311{
4312 struct target_shmid_ds *target_sd;
4313
4314 if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0))
4315 return -TARGET_EFAULT;
4316 if (host_to_target_ipc_perm(target_addr, &(host_sd->shm_perm)))
4317 return -TARGET_EFAULT;
4318 __put_user(host_sd->shm_segsz, &target_sd->shm_segsz);
4319 __put_user(host_sd->shm_atime, &target_sd->shm_atime);
4320 __put_user(host_sd->shm_dtime, &target_sd->shm_dtime);
4321 __put_user(host_sd->shm_ctime, &target_sd->shm_ctime);
4322 __put_user(host_sd->shm_cpid, &target_sd->shm_cpid);
4323 __put_user(host_sd->shm_lpid, &target_sd->shm_lpid);
4324 __put_user(host_sd->shm_nattch, &target_sd->shm_nattch);
4325 unlock_user_struct(target_sd, target_addr, 1);
4326 return 0;
4327}
4328
4329struct target_shminfo {
4330 abi_ulong shmmax;
4331 abi_ulong shmmin;
4332 abi_ulong shmmni;
4333 abi_ulong shmseg;
4334 abi_ulong shmall;
4335};
4336
4337static inline abi_long host_to_target_shminfo(abi_ulong target_addr,
4338 struct shminfo *host_shminfo)
4339{
4340 struct target_shminfo *target_shminfo;
4341 if (!lock_user_struct(VERIFY_WRITE, target_shminfo, target_addr, 0))
4342 return -TARGET_EFAULT;
4343 __put_user(host_shminfo->shmmax, &target_shminfo->shmmax);
4344 __put_user(host_shminfo->shmmin, &target_shminfo->shmmin);
4345 __put_user(host_shminfo->shmmni, &target_shminfo->shmmni);
4346 __put_user(host_shminfo->shmseg, &target_shminfo->shmseg);
4347 __put_user(host_shminfo->shmall, &target_shminfo->shmall);
4348 unlock_user_struct(target_shminfo, target_addr, 1);
4349 return 0;
4350}
4351
4352struct target_shm_info {
4353 int used_ids;
4354 abi_ulong shm_tot;
4355 abi_ulong shm_rss;
4356 abi_ulong shm_swp;
4357 abi_ulong swap_attempts;
4358 abi_ulong swap_successes;
4359};
4360
4361static inline abi_long host_to_target_shm_info(abi_ulong target_addr,
4362 struct shm_info *host_shm_info)
4363{
4364 struct target_shm_info *target_shm_info;
4365 if (!lock_user_struct(VERIFY_WRITE, target_shm_info, target_addr, 0))
4366 return -TARGET_EFAULT;
4367 __put_user(host_shm_info->used_ids, &target_shm_info->used_ids);
4368 __put_user(host_shm_info->shm_tot, &target_shm_info->shm_tot);
4369 __put_user(host_shm_info->shm_rss, &target_shm_info->shm_rss);
4370 __put_user(host_shm_info->shm_swp, &target_shm_info->shm_swp);
4371 __put_user(host_shm_info->swap_attempts, &target_shm_info->swap_attempts);
4372 __put_user(host_shm_info->swap_successes, &target_shm_info->swap_successes);
4373 unlock_user_struct(target_shm_info, target_addr, 1);
4374 return 0;
4375}
4376
4377static inline abi_long do_shmctl(int shmid, int cmd, abi_long buf)
4378{
4379 struct shmid_ds dsarg;
4380 struct shminfo shminfo;
4381 struct shm_info shm_info;
4382 abi_long ret = -TARGET_EINVAL;
4383
4384 cmd &= 0xff;
4385
4386 switch(cmd) {
4387 case IPC_STAT:
4388 case IPC_SET:
4389 case SHM_STAT:
4390 if (target_to_host_shmid_ds(&dsarg, buf))
4391 return -TARGET_EFAULT;
4392 ret = get_errno(shmctl(shmid, cmd, &dsarg));
4393 if (host_to_target_shmid_ds(buf, &dsarg))
4394 return -TARGET_EFAULT;
4395 break;
4396 case IPC_INFO:
4397 ret = get_errno(shmctl(shmid, cmd, (struct shmid_ds *)&shminfo));
4398 if (host_to_target_shminfo(buf, &shminfo))
4399 return -TARGET_EFAULT;
4400 break;
4401 case SHM_INFO:
4402 ret = get_errno(shmctl(shmid, cmd, (struct shmid_ds *)&shm_info));
4403 if (host_to_target_shm_info(buf, &shm_info))
4404 return -TARGET_EFAULT;
4405 break;
4406 case IPC_RMID:
4407 case SHM_LOCK:
4408 case SHM_UNLOCK:
4409 ret = get_errno(shmctl(shmid, cmd, NULL));
4410 break;
4411 }
4412
4413 return ret;
4414}
4415
4416static inline abi_ulong do_shmat(int shmid, abi_ulong shmaddr, int shmflg)
4417{
4418 abi_long raddr;
4419 void *host_raddr;
4420 struct shmid_ds shm_info;
4421 int i,ret;
4422
4423 /* find out the length of the shared memory segment */
4424 ret = get_errno(shmctl(shmid, IPC_STAT, &shm_info));
4425 if (is_error(ret)) {
4426 /* can't get length, bail out */
4427 return ret;
4428 }
4429
4430 mmap_lock();
4431
4432 if (shmaddr)
4433 host_raddr = shmat(shmid, (void *)g2h(shmaddr), shmflg);
4434 else {
4435 abi_ulong mmap_start;
4436
4437 mmap_start = mmap_find_vma(0, shm_info.shm_segsz);
4438
4439 if (mmap_start == -1) {
4440 errno = ENOMEM;
4441 host_raddr = (void *)-1;
4442 } else
4443 host_raddr = shmat(shmid, g2h(mmap_start), shmflg | SHM_REMAP);
4444 }
4445
4446 if (host_raddr == (void *)-1) {
4447 mmap_unlock();
4448 return get_errno((long)host_raddr);
4449 }
4450 raddr=h2g((unsigned long)host_raddr);
4451
4452 page_set_flags(raddr, raddr + shm_info.shm_segsz,
4453 PAGE_VALID | PAGE_READ |
4454 ((shmflg & SHM_RDONLY)? 0 : PAGE_WRITE));
4455
4456 for (i = 0; i < N_SHM_REGIONS; i++) {
b6e17875
PM		 4457 if (!shm_regions[i].in_use) {
4458 shm_regions[i].in_use = true;
88a8c984
RV		 4459 shm_regions[i].start = raddr;
4460 shm_regions[i].size = shm_info.shm_segsz;
4461 break;
4462 }
4463 }
4464
4465 mmap_unlock();
4466 return raddr;
4467
4468}
4469
4470static inline abi_long do_shmdt(abi_ulong shmaddr)
4471{
4472 int i;
4473
4474 for (i = 0; i < N_SHM_REGIONS; ++i) {
b6e17875
PM		 4475 if (shm_regions[i].in_use && shm_regions[i].start == shmaddr) {
4476 shm_regions[i].in_use = false;
e00ac249 4477 page_set_flags(shmaddr, shmaddr + shm_regions[i].size, 0);
88a8c984
RV		 4478 break;
4479 }
4480 }
4481
4482 return get_errno(shmdt(g2h(shmaddr)));
4483}
4484
1c54ff97 4485#ifdef TARGET_NR_ipc
53a5960a 4486/* ??? This only works with linear mappings. */
0da46a6e 4487/* do_ipc() must return target values and target errnos. */
37ed0956
TM		 4488static abi_long do_ipc(unsigned int call, abi_long first,
4489 abi_long second, abi_long third,
992f48a0 4490 abi_long ptr, abi_long fifth)
8853f86e
FB		 4491{
4492 int version;
992f48a0 4493 abi_long ret = 0;
8853f86e
FB		 4494
4495 version = call >> 16;
4496 call &= 0xffff;
4497
4498 switch (call) {
fa294816 4499 case IPCOP_semop:
e5289087 4500 ret = do_semop(first, ptr, second);
fa294816
TS		 4501 break;
4502
4503 case IPCOP_semget:
4504 ret = get_errno(semget(first, second, third));
4505 break;
4506
5d2fa8eb
TM		 4507 case IPCOP_semctl: {
4508 /* The semun argument to semctl is passed by value, so dereference the
4509 * ptr argument. */
4510 abi_ulong atptr;
37ed0956 4511 get_user_ual(atptr, ptr);
d1c002b6 4512 ret = do_semctl(first, second, third, atptr);
fa294816 4513 break;
5d2fa8eb 4514 }
d96372ef 4515
1c54ff97
AJ		 4516 case IPCOP_msgget:
4517 ret = get_errno(msgget(first, second));
4518 break;
d96372ef 4519
1c54ff97
AJ		 4520 case IPCOP_msgsnd:
4521 ret = do_msgsnd(first, ptr, second, third);
4522 break;
d96372ef 4523
1c54ff97
AJ		 4524 case IPCOP_msgctl:
4525 ret = do_msgctl(first, second, ptr);
4526 break;
d96372ef 4527
1c54ff97
AJ		 4528 case IPCOP_msgrcv:
4529 switch (version) {
4530 case 0:
4531 {
4532 struct target_ipc_kludge {
4533 abi_long msgp;
4534 abi_long msgtyp;
4535 } *tmp;
4536
4537 if (!lock_user_struct(VERIFY_READ, tmp, ptr, 1)) {
4538 ret = -TARGET_EFAULT;
4539 break;
4540 }
d96372ef 4541
79dd77de 4542 ret = do_msgrcv(first, tswapal(tmp->msgp), second, tswapal(tmp->msgtyp), third);
d96372ef 4543
1c54ff97
AJ		 4544 unlock_user_struct(tmp, ptr, 0);
4545 break;
4546 }
4547 default:
4548 ret = do_msgrcv(first, ptr, second, fifth, third);
4549 }
4550 break;
d96372ef 4551
8853f86e 4552 case IPCOP_shmat:
88a8c984
RV		 4553 switch (version) {
4554 default:
5a4a898d
FB		 4555 {
4556 abi_ulong raddr;
88a8c984
RV		 4557 raddr = do_shmat(first, ptr, second);
4558 if (is_error(raddr))
4559 return get_errno(raddr);
2f619698 4560 if (put_user_ual(raddr, third))
5a4a898d 4561 return -TARGET_EFAULT;
88a8c984
RV		 4562 break;
4563 }
4564 case 1:
4565 ret = -TARGET_EINVAL;
4566 break;
5a4a898d 4567 }
8853f86e
FB		 4568 break;
4569 case IPCOP_shmdt:
88a8c984 4570 ret = do_shmdt(ptr);
8853f86e
FB		 4571 break;
4572
4573 case IPCOP_shmget:
4574 /* IPC_* flag values are the same on all linux platforms */
4575 ret = get_errno(shmget(first, second, third));
4576 break;
4577
4578 /* IPC_* and SHM_* command values are the same on all linux platforms */
4579 case IPCOP_shmctl:
a2926784 4580 ret = do_shmctl(first, second, ptr);
8853f86e
FB		 4581 break;
4582 default:
32407103 4583 gemu_log("Unsupported ipc call: %d (version %d)\n", call, version);
0da46a6e 4584 ret = -TARGET_ENOSYS;
8853f86e
FB		 4585 break;
4586 }
4587 return ret;
4588}
32407103 4589#endif
8853f86e 4590
31e31b8a 4591/* kernel structure types definitions */
31e31b8a 4592
001faf32 4593#define STRUCT(name, ...) STRUCT_ ## name,
31e31b8a
FB		 4594#define STRUCT_SPECIAL(name) STRUCT_ ## name,
4595enum {
4596#include "syscall_types.h"
8be656b8 4597STRUCT_MAX
31e31b8a
FB		 4598};
4599#undef STRUCT
4600#undef STRUCT_SPECIAL
4601
001faf32 4602#define STRUCT(name, ...) static const argtype struct_ ## name ## _def[] = { __VA_ARGS__, TYPE_NULL };
31e31b8a
FB		 4603#define STRUCT_SPECIAL(name)
4604#include "syscall_types.h"
4605#undef STRUCT
4606#undef STRUCT_SPECIAL
4607
d2ef05bb
PM		 4608typedef struct IOCTLEntry IOCTLEntry;
4609
4610typedef abi_long do_ioctl_fn(const IOCTLEntry *ie, uint8_t *buf_temp,
45c874eb 4611 int fd, int cmd, abi_long arg);
d2ef05bb
PM		 4612
4613struct IOCTLEntry {
9c6bf9c7 4614 int target_cmd;
2ab83ea7 4615 unsigned int host_cmd;
31e31b8a
FB		 4616 const char *name;
4617 int access;
d2ef05bb 4618 do_ioctl_fn *do_ioctl;
1a9353d2 4619 const argtype arg_type[5];
d2ef05bb 4620};
31e31b8a
FB		 4621
4622#define IOC_R 0x0001
4623#define IOC_W 0x0002
4624#define IOC_RW (IOC_R | IOC_W)
4625
4626#define MAX_STRUCT_SIZE 4096
4627
dace20dc 4628#ifdef CONFIG_FIEMAP
285da2b9
PM		 4629/* So fiemap access checks don't overflow on 32 bit systems.
4630 * This is very slightly smaller than the limit imposed by
4631 * the underlying kernel.
4632 */
4633#define FIEMAP_MAX_EXTENTS ((UINT_MAX - sizeof(struct fiemap)) \
4634 / sizeof(struct fiemap_extent))
4635
4636static abi_long do_ioctl_fs_ioc_fiemap(const IOCTLEntry *ie, uint8_t *buf_temp,
45c874eb 4637 int fd, int cmd, abi_long arg)
285da2b9
PM		 4638{
4639 /* The parameter for this ioctl is a struct fiemap followed
4640 * by an array of struct fiemap_extent whose size is set
4641 * in fiemap->fm_extent_count. The array is filled in by the
4642 * ioctl.
4643 */
4644 int target_size_in, target_size_out;
4645 struct fiemap *fm;
4646 const argtype *arg_type = ie->arg_type;
4647 const argtype extent_arg_type[] = { MK_STRUCT(STRUCT_fiemap_extent) };
4648 void *argptr, *p;
4649 abi_long ret;
4650 int i, extent_size = thunk_type_size(extent_arg_type, 0);
4651 uint32_t outbufsz;
4652 int free_fm = 0;
4653
4654 assert(arg_type[0] == TYPE_PTR);
4655 assert(ie->access == IOC_RW);
4656 arg_type++;
4657 target_size_in = thunk_type_size(arg_type, 0);
4658 argptr = lock_user(VERIFY_READ, arg, target_size_in, 1);
4659 if (!argptr) {
4660 return -TARGET_EFAULT;
4661 }
4662 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
4663 unlock_user(argptr, arg, 0);
4664 fm = (struct fiemap *)buf_temp;
4665 if (fm->fm_extent_count > FIEMAP_MAX_EXTENTS) {
4666 return -TARGET_EINVAL;
4667 }
4668
4669 outbufsz = sizeof (*fm) +
4670 (sizeof(struct fiemap_extent) * fm->fm_extent_count);
4671
4672 if (outbufsz > MAX_STRUCT_SIZE) {
4673 /* We can't fit all the extents into the fixed size buffer.
4674 * Allocate one that is large enough and use it instead.
4675 */
0e173b24 4676 fm = g_try_malloc(outbufsz);
285da2b9
PM		 4677 if (!fm) {
4678 return -TARGET_ENOMEM;
4679 }
4680 memcpy(fm, buf_temp, sizeof(struct fiemap));
4681 free_fm = 1;
4682 }
49ca6f3e 4683 ret = get_errno(safe_ioctl(fd, ie->host_cmd, fm));
285da2b9
PM		 4684 if (!is_error(ret)) {
4685 target_size_out = target_size_in;
4686 /* An extent_count of 0 means we were only counting the extents
4687 * so there are no structs to copy
4688 */
4689 if (fm->fm_extent_count != 0) {
4690 target_size_out += fm->fm_mapped_extents * extent_size;
4691 }
4692 argptr = lock_user(VERIFY_WRITE, arg, target_size_out, 0);
4693 if (!argptr) {
4694 ret = -TARGET_EFAULT;
4695 } else {
4696 /* Convert the struct fiemap */
4697 thunk_convert(argptr, fm, arg_type, THUNK_TARGET);
4698 if (fm->fm_extent_count != 0) {
4699 p = argptr + target_size_in;
4700 /* ...and then all the struct fiemap_extents */
4701 for (i = 0; i < fm->fm_mapped_extents; i++) {
4702 thunk_convert(p, &fm->fm_extents[i], extent_arg_type,
4703 THUNK_TARGET);
4704 p += extent_size;
4705 }
4706 }
4707 unlock_user(argptr, arg, target_size_out);
4708 }
4709 }
4710 if (free_fm) {
0e173b24 4711 g_free(fm);
285da2b9
PM		 4712 }
4713 return ret;
4714}
dace20dc 4715#endif
285da2b9 4716
059c2f2c 4717static abi_long do_ioctl_ifconf(const IOCTLEntry *ie, uint8_t *buf_temp,
45c874eb 4718 int fd, int cmd, abi_long arg)
059c2f2c
LV		 4719{
4720 const argtype *arg_type = ie->arg_type;
4721 int target_size;
4722 void *argptr;
4723 int ret;
4724 struct ifconf *host_ifconf;
4725 uint32_t outbufsz;
4726 const argtype ifreq_arg_type[] = { MK_STRUCT(STRUCT_sockaddr_ifreq) };
4727 int target_ifreq_size;
4728 int nb_ifreq;
4729 int free_buf = 0;
4730 int i;
4731 int target_ifc_len;
4732 abi_long target_ifc_buf;
4733 int host_ifc_len;
4734 char *host_ifc_buf;
4735
4736 assert(arg_type[0] == TYPE_PTR);
4737 assert(ie->access == IOC_RW);
4738
4739 arg_type++;
4740 target_size = thunk_type_size(arg_type, 0);
4741
4742 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
4743 if (!argptr)
4744 return -TARGET_EFAULT;
4745 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
4746 unlock_user(argptr, arg, 0);
4747
4748 host_ifconf = (struct ifconf *)(unsigned long)buf_temp;
4749 target_ifc_len = host_ifconf->ifc_len;
4750 target_ifc_buf = (abi_long)(unsigned long)host_ifconf->ifc_buf;
4751
4752 target_ifreq_size = thunk_type_size(ifreq_arg_type, 0);
4753 nb_ifreq = target_ifc_len / target_ifreq_size;
4754 host_ifc_len = nb_ifreq * sizeof(struct ifreq);
4755
4756 outbufsz = sizeof(*host_ifconf) + host_ifc_len;
4757 if (outbufsz > MAX_STRUCT_SIZE) {
4758 /* We can't fit all the extents into the fixed size buffer.
4759 * Allocate one that is large enough and use it instead.
4760 */
4761 host_ifconf = malloc(outbufsz);
4762 if (!host_ifconf) {
4763 return -TARGET_ENOMEM;
4764 }
4765 memcpy(host_ifconf, buf_temp, sizeof(*host_ifconf));
4766 free_buf = 1;
4767 }
4768 host_ifc_buf = (char*)host_ifconf + sizeof(*host_ifconf);
4769
4770 host_ifconf->ifc_len = host_ifc_len;
4771 host_ifconf->ifc_buf = host_ifc_buf;
4772
49ca6f3e 4773 ret = get_errno(safe_ioctl(fd, ie->host_cmd, host_ifconf));
059c2f2c
LV		 4774 if (!is_error(ret)) {
4775 /* convert host ifc_len to target ifc_len */
4776
4777 nb_ifreq = host_ifconf->ifc_len / sizeof(struct ifreq);
4778 target_ifc_len = nb_ifreq * target_ifreq_size;
4779 host_ifconf->ifc_len = target_ifc_len;
4780
4781 /* restore target ifc_buf */
4782
4783 host_ifconf->ifc_buf = (char *)(unsigned long)target_ifc_buf;
4784
4785 /* copy struct ifconf to target user */
4786
4787 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
4788 if (!argptr)
4789 return -TARGET_EFAULT;
4790 thunk_convert(argptr, host_ifconf, arg_type, THUNK_TARGET);
4791 unlock_user(argptr, arg, target_size);
4792
4793 /* copy ifreq[] to target user */
4794
4795 argptr = lock_user(VERIFY_WRITE, target_ifc_buf, target_ifc_len, 0);
4796 for (i = 0; i < nb_ifreq ; i++) {
4797 thunk_convert(argptr + i * target_ifreq_size,
4798 host_ifc_buf + i * sizeof(struct ifreq),
4799 ifreq_arg_type, THUNK_TARGET);
4800 }
4801 unlock_user(argptr, target_ifc_buf, target_ifc_len);
4802 }
4803
4804 if (free_buf) {
4805 free(host_ifconf);
4806 }
4807
4808 return ret;
4809}
4810
56e904ec 4811static abi_long do_ioctl_dm(const IOCTLEntry *ie, uint8_t *buf_temp, int fd,
45c874eb 4812 int cmd, abi_long arg)
56e904ec
AG		 4813{
4814 void *argptr;
4815 struct dm_ioctl *host_dm;
4816 abi_long guest_data;
4817 uint32_t guest_data_size;
4818 int target_size;
4819 const argtype *arg_type = ie->arg_type;
4820 abi_long ret;
4821 void *big_buf = NULL;
4822 char *host_data;
4823
4824 arg_type++;
4825 target_size = thunk_type_size(arg_type, 0);
4826 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
4827 if (!argptr) {
4828 ret = -TARGET_EFAULT;
4829 goto out;
4830 }
4831 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
4832 unlock_user(argptr, arg, 0);
4833
4834 /* buf_temp is too small, so fetch things into a bigger buffer */
4835 big_buf = g_malloc0(((struct dm_ioctl*)buf_temp)->data_size * 2);
4836 memcpy(big_buf, buf_temp, target_size);
4837 buf_temp = big_buf;
4838 host_dm = big_buf;
4839
4840 guest_data = arg + host_dm->data_start;
4841 if ((guest_data - arg) < 0) {
4842 ret = -EINVAL;
4843 goto out;
4844 }
4845 guest_data_size = host_dm->data_size - host_dm->data_start;
4846 host_data = (char*)host_dm + host_dm->data_start;
4847
4848 argptr = lock_user(VERIFY_READ, guest_data, guest_data_size, 1);
4849 switch (ie->host_cmd) {
4850 case DM_REMOVE_ALL:
4851 case DM_LIST_DEVICES:
4852 case DM_DEV_CREATE:
4853 case DM_DEV_REMOVE:
4854 case DM_DEV_SUSPEND:
4855 case DM_DEV_STATUS:
4856 case DM_DEV_WAIT:
4857 case DM_TABLE_STATUS:
4858 case DM_TABLE_CLEAR:
4859 case DM_TABLE_DEPS:
4860 case DM_LIST_VERSIONS:
4861 /* no input data */
4862 break;
4863 case DM_DEV_RENAME:
4864 case DM_DEV_SET_GEOMETRY:
4865 /* data contains only strings */
4866 memcpy(host_data, argptr, guest_data_size);
4867 break;
4868 case DM_TARGET_MSG:
4869 memcpy(host_data, argptr, guest_data_size);
4870 *(uint64_t*)host_data = tswap64(*(uint64_t*)argptr);
4871 break;
4872 case DM_TABLE_LOAD:
4873 {
4874 void *gspec = argptr;
4875 void *cur_data = host_data;
4876 const argtype arg_type[] = { MK_STRUCT(STRUCT_dm_target_spec) };
4877 int spec_size = thunk_type_size(arg_type, 0);
4878 int i;
4879
4880 for (i = 0; i < host_dm->target_count; i++) {
4881 struct dm_target_spec *spec = cur_data;
4882 uint32_t next;
4883 int slen;
4884
4885 thunk_convert(spec, gspec, arg_type, THUNK_HOST);
4886 slen = strlen((char*)gspec + spec_size) + 1;
4887 next = spec->next;
4888 spec->next = sizeof(*spec) + slen;
4889 strcpy((char*)&spec[1], gspec + spec_size);
4890 gspec += next;
4891 cur_data += spec->next;
4892 }
4893 break;
4894 }
4895 default:
4896 ret = -TARGET_EINVAL;
dec0473d 4897 unlock_user(argptr, guest_data, 0);
56e904ec
AG		 4898 goto out;
4899 }
4900 unlock_user(argptr, guest_data, 0);
4901
49ca6f3e 4902 ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp));
56e904ec
AG		 4903 if (!is_error(ret)) {
4904 guest_data = arg + host_dm->data_start;
4905 guest_data_size = host_dm->data_size - host_dm->data_start;
4906 argptr = lock_user(VERIFY_WRITE, guest_data, guest_data_size, 0);
4907 switch (ie->host_cmd) {
4908 case DM_REMOVE_ALL:
4909 case DM_DEV_CREATE:
4910 case DM_DEV_REMOVE:
4911 case DM_DEV_RENAME:
4912 case DM_DEV_SUSPEND:
4913 case DM_DEV_STATUS:
4914 case DM_TABLE_LOAD:
4915 case DM_TABLE_CLEAR:
4916 case DM_TARGET_MSG:
4917 case DM_DEV_SET_GEOMETRY:
4918 /* no return data */
4919 break;
4920 case DM_LIST_DEVICES:
4921 {
4922 struct dm_name_list *nl = (void*)host_dm + host_dm->data_start;
4923 uint32_t remaining_data = guest_data_size;
4924 void *cur_data = argptr;
4925 const argtype arg_type[] = { MK_STRUCT(STRUCT_dm_name_list) };
4926 int nl_size = 12; /* can't use thunk_size due to alignment */
4927
4928 while (1) {
4929 uint32_t next = nl->next;
4930 if (next) {
4931 nl->next = nl_size + (strlen(nl->name) + 1);
4932 }
4933 if (remaining_data < nl->next) {
4934 host_dm->flags |= DM_BUFFER_FULL_FLAG;
4935 break;
4936 }
4937 thunk_convert(cur_data, nl, arg_type, THUNK_TARGET);
4938 strcpy(cur_data + nl_size, nl->name);
4939 cur_data += nl->next;
4940 remaining_data -= nl->next;
4941 if (!next) {
4942 break;
4943 }
4944 nl = (void*)nl + next;
4945 }
4946 break;
4947 }
4948 case DM_DEV_WAIT:
4949 case DM_TABLE_STATUS:
4950 {
4951 struct dm_target_spec *spec = (void*)host_dm + host_dm->data_start;
4952 void *cur_data = argptr;
4953 const argtype arg_type[] = { MK_STRUCT(STRUCT_dm_target_spec) };
4954 int spec_size = thunk_type_size(arg_type, 0);
4955 int i;
4956
4957 for (i = 0; i < host_dm->target_count; i++) {
4958 uint32_t next = spec->next;
4959 int slen = strlen((char*)&spec[1]) + 1;
4960 spec->next = (cur_data - argptr) + spec_size + slen;
4961 if (guest_data_size < spec->next) {
4962 host_dm->flags |= DM_BUFFER_FULL_FLAG;
4963 break;
4964 }
4965 thunk_convert(cur_data, spec, arg_type, THUNK_TARGET);
4966 strcpy(cur_data + spec_size, (char*)&spec[1]);
4967 cur_data = argptr + spec->next;
4968 spec = (void*)host_dm + host_dm->data_start + next;
4969 }
4970 break;
4971 }
4972 case DM_TABLE_DEPS:
4973 {
4974 void *hdata = (void*)host_dm + host_dm->data_start;
4975 int count = *(uint32_t*)hdata;
4976 uint64_t *hdev = hdata + 8;
4977 uint64_t *gdev = argptr + 8;
4978 int i;
4979
4980 *(uint32_t*)argptr = tswap32(count);
4981 for (i = 0; i < count; i++) {
4982 *gdev = tswap64(*hdev);
4983 gdev++;
4984 hdev++;
4985 }
4986 break;
4987 }
4988 case DM_LIST_VERSIONS:
4989 {
4990 struct dm_target_versions *vers = (void*)host_dm + host_dm->data_start;
4991 uint32_t remaining_data = guest_data_size;
4992 void *cur_data = argptr;
4993 const argtype arg_type[] = { MK_STRUCT(STRUCT_dm_target_versions) };
4994 int vers_size = thunk_type_size(arg_type, 0);
4995
4996 while (1) {
4997 uint32_t next = vers->next;
4998 if (next) {
4999 vers->next = vers_size + (strlen(vers->name) + 1);
5000 }
5001 if (remaining_data < vers->next) {
5002 host_dm->flags |= DM_BUFFER_FULL_FLAG;
5003 break;
5004 }
5005 thunk_convert(cur_data, vers, arg_type, THUNK_TARGET);
5006 strcpy(cur_data + vers_size, vers->name);
5007 cur_data += vers->next;
5008 remaining_data -= vers->next;
5009 if (!next) {
5010 break;
5011 }
5012 vers = (void*)vers + next;
5013 }
5014 break;
5015 }
5016 default:
dec0473d 5017 unlock_user(argptr, guest_data, 0);
56e904ec
AG		 5018 ret = -TARGET_EINVAL;
5019 goto out;
5020 }
5021 unlock_user(argptr, guest_data, guest_data_size);
5022
5023 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
5024 if (!argptr) {
5025 ret = -TARGET_EFAULT;
5026 goto out;
5027 }
5028 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
5029 unlock_user(argptr, arg, target_size);
5030 }
5031out:
ad11ad77 5032 g_free(big_buf);
56e904ec
AG		 5033 return ret;
5034}
5035
a59b5e35 5036static abi_long do_ioctl_blkpg(const IOCTLEntry *ie, uint8_t *buf_temp, int fd,
45c874eb 5037 int cmd, abi_long arg)
a59b5e35
AG		 5038{
5039 void *argptr;
5040 int target_size;
5041 const argtype *arg_type = ie->arg_type;
5042 const argtype part_arg_type[] = { MK_STRUCT(STRUCT_blkpg_partition) };
5043 abi_long ret;
5044
5045 struct blkpg_ioctl_arg *host_blkpg = (void*)buf_temp;
5046 struct blkpg_partition host_part;
5047
5048 /* Read and convert blkpg */
5049 arg_type++;
5050 target_size = thunk_type_size(arg_type, 0);
5051 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
5052 if (!argptr) {
5053 ret = -TARGET_EFAULT;
5054 goto out;
5055 }
5056 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
5057 unlock_user(argptr, arg, 0);
5058
5059 switch (host_blkpg->op) {
5060 case BLKPG_ADD_PARTITION:
5061 case BLKPG_DEL_PARTITION:
5062 /* payload is struct blkpg_partition */
5063 break;
5064 default:
5065 /* Unknown opcode */
5066 ret = -TARGET_EINVAL;
5067 goto out;
5068 }
5069
5070 /* Read and convert blkpg->data */
5071 arg = (abi_long)(uintptr_t)host_blkpg->data;
5072 target_size = thunk_type_size(part_arg_type, 0);
5073 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
5074 if (!argptr) {
5075 ret = -TARGET_EFAULT;
5076 goto out;
5077 }
5078 thunk_convert(&host_part, argptr, part_arg_type, THUNK_HOST);
5079 unlock_user(argptr, arg, 0);
5080
5081 /* Swizzle the data pointer to our local copy and call! */
5082 host_blkpg->data = &host_part;
49ca6f3e 5083 ret = get_errno(safe_ioctl(fd, ie->host_cmd, host_blkpg));
a59b5e35
AG		 5084
5085out:
5086 return ret;
5087}
5088
7ff7b666 5089static abi_long do_ioctl_rt(const IOCTLEntry *ie, uint8_t *buf_temp,
45c874eb 5090 int fd, int cmd, abi_long arg)
7ff7b666
LV		 5091{
5092 const argtype *arg_type = ie->arg_type;
5093 const StructEntry *se;
5094 const argtype *field_types;
5095 const int *dst_offsets, *src_offsets;
5096 int target_size;
5097 void *argptr;
5098 abi_ulong *target_rt_dev_ptr;
5099 unsigned long *host_rt_dev_ptr;
5100 abi_long ret;
5101 int i;
5102
5103 assert(ie->access == IOC_W);
5104 assert(*arg_type == TYPE_PTR);
5105 arg_type++;
5106 assert(*arg_type == TYPE_STRUCT);
5107 target_size = thunk_type_size(arg_type, 0);
5108 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
5109 if (!argptr) {
5110 return -TARGET_EFAULT;
5111 }
5112 arg_type++;
5113 assert(*arg_type == (int)STRUCT_rtentry);
5114 se = struct_entries + *arg_type++;
5115 assert(se->convert[0] == NULL);
5116 /* convert struct here to be able to catch rt_dev string */
5117 field_types = se->field_types;
5118 dst_offsets = se->field_offsets[THUNK_HOST];
5119 src_offsets = se->field_offsets[THUNK_TARGET];
5120 for (i = 0; i < se->nb_fields; i++) {
5121 if (dst_offsets[i] == offsetof(struct rtentry, rt_dev)) {
5122 assert(*field_types == TYPE_PTRVOID);
5123 target_rt_dev_ptr = (abi_ulong *)(argptr + src_offsets[i]);
5124 host_rt_dev_ptr = (unsigned long *)(buf_temp + dst_offsets[i]);
5125 if (*target_rt_dev_ptr != 0) {
5126 *host_rt_dev_ptr = (unsigned long)lock_user_string(
5127 tswapal(*target_rt_dev_ptr));
5128 if (!*host_rt_dev_ptr) {
5129 unlock_user(argptr, arg, 0);
5130 return -TARGET_EFAULT;
5131 }
5132 } else {
5133 *host_rt_dev_ptr = 0;
5134 }
5135 field_types++;
5136 continue;
5137 }
5138 field_types = thunk_convert(buf_temp + dst_offsets[i],
5139 argptr + src_offsets[i],
5140 field_types, THUNK_HOST);
5141 }
5142 unlock_user(argptr, arg, 0);
5143
49ca6f3e 5144 ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp));
7ff7b666
LV		 5145 if (*host_rt_dev_ptr != 0) {
5146 unlock_user((void *)*host_rt_dev_ptr,
5147 *target_rt_dev_ptr, 0);
5148 }
5149 return ret;
5150}
5151
ca56f5b5 5152static abi_long do_ioctl_kdsigaccept(const IOCTLEntry *ie, uint8_t *buf_temp,
45c874eb 5153 int fd, int cmd, abi_long arg)
ca56f5b5
PB		 5154{
5155 int sig = target_to_host_signal(arg);
49ca6f3e 5156 return get_errno(safe_ioctl(fd, ie->host_cmd, sig));
ca56f5b5
PB		 5157}
5158
9f106a75 5159static IOCTLEntry ioctl_entries[] = {
001faf32 5160#define IOCTL(cmd, access, ...) \
d2ef05bb
PM		 5161 { TARGET_ ## cmd, cmd, #cmd, access, 0, { __VA_ARGS__ } },
5162#define IOCTL_SPECIAL(cmd, access, dofn, ...) \
5163 { TARGET_ ## cmd, cmd, #cmd, access, dofn, { __VA_ARGS__ } },
31e31b8a
FB		 5164#include "ioctls.h"
5165 { 0, 0, },
5166};
5167
53a5960a 5168/* ??? Implement proper locking for ioctls. */
0da46a6e 5169/* do_ioctl() Must return target values and target errnos. */
45c874eb 5170static abi_long do_ioctl(int fd, int cmd, abi_long arg)
31e31b8a
FB		 5171{
5172 const IOCTLEntry *ie;
5173 const argtype *arg_type;
992f48a0 5174 abi_long ret;
31e31b8a 5175 uint8_t buf_temp[MAX_STRUCT_SIZE];
53a5960a
PB		 5176 int target_size;
5177 void *argptr;
31e31b8a
FB		 5178
5179 ie = ioctl_entries;
5180 for(;;) {
5181 if (ie->target_cmd == 0) {
32407103 5182 gemu_log("Unsupported ioctl: cmd=0x%04lx\n", (long)cmd);
0da46a6e 5183 return -TARGET_ENOSYS;
31e31b8a
FB		 5184 }
5185 if (ie->target_cmd == cmd)
5186 break;
5187 ie++;
5188 }
5189 arg_type = ie->arg_type;
9de5e440 5190#if defined(DEBUG)
32407103 5191 gemu_log("ioctl: cmd=0x%04lx (%s)\n", (long)cmd, ie->name);
72f03900 5192#endif
d2ef05bb
PM		 5193 if (ie->do_ioctl) {
5194 return ie->do_ioctl(ie, buf_temp, fd, cmd, arg);
5195 }
5196
31e31b8a
FB		 5197 switch(arg_type[0]) {
5198 case TYPE_NULL:
5199 /* no argument */
49ca6f3e 5200 ret = get_errno(safe_ioctl(fd, ie->host_cmd));
31e31b8a
FB		 5201 break;
5202 case TYPE_PTRVOID:
5203 case TYPE_INT:
49ca6f3e 5204 ret = get_errno(safe_ioctl(fd, ie->host_cmd, arg));
31e31b8a
FB		 5205 break;
5206 case TYPE_PTR:
5207 arg_type++;
53a5960a 5208 target_size = thunk_type_size(arg_type, 0);
31e31b8a
FB		 5209 switch(ie->access) {
5210 case IOC_R:
49ca6f3e 5211 ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp));
31e31b8a 5212 if (!is_error(ret)) {
579a97f7
FB		 5213 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
5214 if (!argptr)
5215 return -TARGET_EFAULT;
53a5960a
PB		 5216 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
5217 unlock_user(argptr, arg, target_size);
31e31b8a
FB		 5218 }
5219 break;
5220 case IOC_W:
579a97f7
FB		 5221 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
5222 if (!argptr)
5223 return -TARGET_EFAULT;
53a5960a
PB		 5224 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
5225 unlock_user(argptr, arg, 0);
49ca6f3e 5226 ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp));
31e31b8a
FB		 5227 break;
5228 default:
5229 case IOC_RW:
579a97f7
FB		 5230 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
5231 if (!argptr)
5232 return -TARGET_EFAULT;
53a5960a
PB		 5233 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
5234 unlock_user(argptr, arg, 0);
49ca6f3e 5235 ret = get_errno(safe_ioctl(fd, ie->host_cmd, buf_temp));
31e31b8a 5236 if (!is_error(ret)) {
579a97f7
FB		 5237 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
5238 if (!argptr)
5239 return -TARGET_EFAULT;
53a5960a
PB		 5240 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
5241 unlock_user(argptr, arg, target_size);
31e31b8a
FB		 5242 }
5243 break;
5244 }
5245 break;
5246 default:
32407103
JM		 5247 gemu_log("Unsupported ioctl type: cmd=0x%04lx type=%d\n",
5248 (long)cmd, arg_type[0]);
0da46a6e 5249 ret = -TARGET_ENOSYS;
31e31b8a
FB		 5250 break;
5251 }
5252 return ret;
5253}
5254
b39bc503 5255static const bitmask_transtbl iflag_tbl[] = {
31e31b8a
FB		 5256 { TARGET_IGNBRK, TARGET_IGNBRK, IGNBRK, IGNBRK },
5257 { TARGET_BRKINT, TARGET_BRKINT, BRKINT, BRKINT },
5258 { TARGET_IGNPAR, TARGET_IGNPAR, IGNPAR, IGNPAR },
5259 { TARGET_PARMRK, TARGET_PARMRK, PARMRK, PARMRK },
5260 { TARGET_INPCK, TARGET_INPCK, INPCK, INPCK },
5261 { TARGET_ISTRIP, TARGET_ISTRIP, ISTRIP, ISTRIP },
5262 { TARGET_INLCR, TARGET_INLCR, INLCR, INLCR },
5263 { TARGET_IGNCR, TARGET_IGNCR, IGNCR, IGNCR },
5264 { TARGET_ICRNL, TARGET_ICRNL, ICRNL, ICRNL },
5265 { TARGET_IUCLC, TARGET_IUCLC, IUCLC, IUCLC },
5266 { TARGET_IXON, TARGET_IXON, IXON, IXON },
5267 { TARGET_IXANY, TARGET_IXANY, IXANY, IXANY },
5268 { TARGET_IXOFF, TARGET_IXOFF, IXOFF, IXOFF },
5269 { TARGET_IMAXBEL, TARGET_IMAXBEL, IMAXBEL, IMAXBEL },
5270 { 0, 0, 0, 0 }
5271};
5272
b39bc503 5273static const bitmask_transtbl oflag_tbl[] = {
31e31b8a
FB		 5274 { TARGET_OPOST, TARGET_OPOST, OPOST, OPOST },
5275 { TARGET_OLCUC, TARGET_OLCUC, OLCUC, OLCUC },
5276 { TARGET_ONLCR, TARGET_ONLCR, ONLCR, ONLCR },
5277 { TARGET_OCRNL, TARGET_OCRNL, OCRNL, OCRNL },
5278 { TARGET_ONOCR, TARGET_ONOCR, ONOCR, ONOCR },
5279 { TARGET_ONLRET, TARGET_ONLRET, ONLRET, ONLRET },
5280 { TARGET_OFILL, TARGET_OFILL, OFILL, OFILL },
5281 { TARGET_OFDEL, TARGET_OFDEL, OFDEL, OFDEL },
5282 { TARGET_NLDLY, TARGET_NL0, NLDLY, NL0 },
5283 { TARGET_NLDLY, TARGET_NL1, NLDLY, NL1 },
5284 { TARGET_CRDLY, TARGET_CR0, CRDLY, CR0 },
5285 { TARGET_CRDLY, TARGET_CR1, CRDLY, CR1 },
5286 { TARGET_CRDLY, TARGET_CR2, CRDLY, CR2 },
5287 { TARGET_CRDLY, TARGET_CR3, CRDLY, CR3 },
5288 { TARGET_TABDLY, TARGET_TAB0, TABDLY, TAB0 },
5289 { TARGET_TABDLY, TARGET_TAB1, TABDLY, TAB1 },
5290 { TARGET_TABDLY, TARGET_TAB2, TABDLY, TAB2 },
5291 { TARGET_TABDLY, TARGET_TAB3, TABDLY, TAB3 },
5292 { TARGET_BSDLY, TARGET_BS0, BSDLY, BS0 },
5293 { TARGET_BSDLY, TARGET_BS1, BSDLY, BS1 },
5294 { TARGET_VTDLY, TARGET_VT0, VTDLY, VT0 },
5295 { TARGET_VTDLY, TARGET_VT1, VTDLY, VT1 },
5296 { TARGET_FFDLY, TARGET_FF0, FFDLY, FF0 },
5297 { TARGET_FFDLY, TARGET_FF1, FFDLY, FF1 },
5298 { 0, 0, 0, 0 }
5299};
5300
b39bc503 5301static const bitmask_transtbl cflag_tbl[] = {
31e31b8a
FB		 5302 { TARGET_CBAUD, TARGET_B0, CBAUD, B0 },
5303 { TARGET_CBAUD, TARGET_B50, CBAUD, B50 },
5304 { TARGET_CBAUD, TARGET_B75, CBAUD, B75 },
5305 { TARGET_CBAUD, TARGET_B110, CBAUD, B110 },
5306 { TARGET_CBAUD, TARGET_B134, CBAUD, B134 },
5307 { TARGET_CBAUD, TARGET_B150, CBAUD, B150 },
5308 { TARGET_CBAUD, TARGET_B200, CBAUD, B200 },
5309 { TARGET_CBAUD, TARGET_B300, CBAUD, B300 },
5310 { TARGET_CBAUD, TARGET_B600, CBAUD, B600 },
5311 { TARGET_CBAUD, TARGET_B1200, CBAUD, B1200 },
5312 { TARGET_CBAUD, TARGET_B1800, CBAUD, B1800 },
5313 { TARGET_CBAUD, TARGET_B2400, CBAUD, B2400 },
5314 { TARGET_CBAUD, TARGET_B4800, CBAUD, B4800 },
5315 { TARGET_CBAUD, TARGET_B9600, CBAUD, B9600 },
5316 { TARGET_CBAUD, TARGET_B19200, CBAUD, B19200 },
5317 { TARGET_CBAUD, TARGET_B38400, CBAUD, B38400 },
5318 { TARGET_CBAUD, TARGET_B57600, CBAUD, B57600 },
5319 { TARGET_CBAUD, TARGET_B115200, CBAUD, B115200 },
5320 { TARGET_CBAUD, TARGET_B230400, CBAUD, B230400 },
5321 { TARGET_CBAUD, TARGET_B460800, CBAUD, B460800 },
5322 { TARGET_CSIZE, TARGET_CS5, CSIZE, CS5 },
5323 { TARGET_CSIZE, TARGET_CS6, CSIZE, CS6 },
5324 { TARGET_CSIZE, TARGET_CS7, CSIZE, CS7 },
5325 { TARGET_CSIZE, TARGET_CS8, CSIZE, CS8 },
5326 { TARGET_CSTOPB, TARGET_CSTOPB, CSTOPB, CSTOPB },
5327 { TARGET_CREAD, TARGET_CREAD, CREAD, CREAD },
5328 { TARGET_PARENB, TARGET_PARENB, PARENB, PARENB },
5329 { TARGET_PARODD, TARGET_PARODD, PARODD, PARODD },
5330 { TARGET_HUPCL, TARGET_HUPCL, HUPCL, HUPCL },
5331 { TARGET_CLOCAL, TARGET_CLOCAL, CLOCAL, CLOCAL },
5332 { TARGET_CRTSCTS, TARGET_CRTSCTS, CRTSCTS, CRTSCTS },
5333 { 0, 0, 0, 0 }
5334};
5335
b39bc503 5336static const bitmask_transtbl lflag_tbl[] = {
31e31b8a
FB		 5337 { TARGET_ISIG, TARGET_ISIG, ISIG, ISIG },
5338 { TARGET_ICANON, TARGET_ICANON, ICANON, ICANON },
5339 { TARGET_XCASE, TARGET_XCASE, XCASE, XCASE },
5340 { TARGET_ECHO, TARGET_ECHO, ECHO, ECHO },
5341 { TARGET_ECHOE, TARGET_ECHOE, ECHOE, ECHOE },
5342 { TARGET_ECHOK, TARGET_ECHOK, ECHOK, ECHOK },
5343 { TARGET_ECHONL, TARGET_ECHONL, ECHONL, ECHONL },
5344 { TARGET_NOFLSH, TARGET_NOFLSH, NOFLSH, NOFLSH },
5345 { TARGET_TOSTOP, TARGET_TOSTOP, TOSTOP, TOSTOP },
5346 { TARGET_ECHOCTL, TARGET_ECHOCTL, ECHOCTL, ECHOCTL },
5347 { TARGET_ECHOPRT, TARGET_ECHOPRT, ECHOPRT, ECHOPRT },
5348 { TARGET_ECHOKE, TARGET_ECHOKE, ECHOKE, ECHOKE },
5349 { TARGET_FLUSHO, TARGET_FLUSHO, FLUSHO, FLUSHO },
5350 { TARGET_PENDIN, TARGET_PENDIN, PENDIN, PENDIN },
5351 { TARGET_IEXTEN, TARGET_IEXTEN, IEXTEN, IEXTEN },
5352 { 0, 0, 0, 0 }
5353};
5354
5355static void target_to_host_termios (void *dst, const void *src)
5356{
5357 struct host_termios *host = dst;
5358 const struct target_termios *target = src;
3b46e624 5359
5fafdf24 5360 host->c_iflag =
31e31b8a 5361 target_to_host_bitmask(tswap32(target->c_iflag), iflag_tbl);
5fafdf24 5362 host->c_oflag =
31e31b8a 5363 target_to_host_bitmask(tswap32(target->c_oflag), oflag_tbl);
5fafdf24 5364 host->c_cflag =
31e31b8a 5365 target_to_host_bitmask(tswap32(target->c_cflag), cflag_tbl);
5fafdf24 5366 host->c_lflag =
31e31b8a
FB		 5367 target_to_host_bitmask(tswap32(target->c_lflag), lflag_tbl);
5368 host->c_line = target->c_line;
3b46e624 5369
44607123 5370 memset(host->c_cc, 0, sizeof(host->c_cc));
5fafdf24
TS		 5371 host->c_cc[VINTR] = target->c_cc[TARGET_VINTR];
5372 host->c_cc[VQUIT] = target->c_cc[TARGET_VQUIT];
3b46e624 5373 host->c_cc[VERASE] = target->c_cc[TARGET_VERASE];
5fafdf24 5374 host->c_cc[VKILL] = target->c_cc[TARGET_VKILL];
3b46e624 5375 host->c_cc[VEOF] = target->c_cc[TARGET_VEOF];
5fafdf24 5376 host->c_cc[VTIME] = target->c_cc[TARGET_VTIME];
3b46e624 5377 host->c_cc[VMIN] = target->c_cc[TARGET_VMIN];
5fafdf24 5378 host->c_cc[VSWTC] = target->c_cc[TARGET_VSWTC];
3b46e624 5379 host->c_cc[VSTART] = target->c_cc[TARGET_VSTART];
5fafdf24
TS		 5380 host->c_cc[VSTOP] = target->c_cc[TARGET_VSTOP];
5381 host->c_cc[VSUSP] = target->c_cc[TARGET_VSUSP];
3b46e624
TS		 5382 host->c_cc[VEOL] = target->c_cc[TARGET_VEOL];
5383 host->c_cc[VREPRINT] = target->c_cc[TARGET_VREPRINT];
5384 host->c_cc[VDISCARD] = target->c_cc[TARGET_VDISCARD];
5385 host->c_cc[VWERASE] = target->c_cc[TARGET_VWERASE];
5386 host->c_cc[VLNEXT] = target->c_cc[TARGET_VLNEXT];
5fafdf24 5387 host->c_cc[VEOL2] = target->c_cc[TARGET_VEOL2];
31e31b8a 5388}
3b46e624 5389
31e31b8a
FB		 5390static void host_to_target_termios (void *dst, const void *src)
5391{
5392 struct target_termios *target = dst;
5393 const struct host_termios *host = src;
5394
5fafdf24 5395 target->c_iflag =
31e31b8a 5396 tswap32(host_to_target_bitmask(host->c_iflag, iflag_tbl));
5fafdf24 5397 target->c_oflag =
31e31b8a 5398 tswap32(host_to_target_bitmask(host->c_oflag, oflag_tbl));
5fafdf24 5399 target->c_cflag =
31e31b8a 5400 tswap32(host_to_target_bitmask(host->c_cflag, cflag_tbl));
5fafdf24 5401 target->c_lflag =
31e31b8a
FB		 5402 tswap32(host_to_target_bitmask(host->c_lflag, lflag_tbl));
5403 target->c_line = host->c_line;
3b46e624 5404
44607123 5405 memset(target->c_cc, 0, sizeof(target->c_cc));
31e31b8a
FB		 5406 target->c_cc[TARGET_VINTR] = host->c_cc[VINTR];
5407 target->c_cc[TARGET_VQUIT] = host->c_cc[VQUIT];
5408 target->c_cc[TARGET_VERASE] = host->c_cc[VERASE];
5409 target->c_cc[TARGET_VKILL] = host->c_cc[VKILL];
5410 target->c_cc[TARGET_VEOF] = host->c_cc[VEOF];
5411 target->c_cc[TARGET_VTIME] = host->c_cc[VTIME];
5412 target->c_cc[TARGET_VMIN] = host->c_cc[VMIN];
5413 target->c_cc[TARGET_VSWTC] = host->c_cc[VSWTC];
5414 target->c_cc[TARGET_VSTART] = host->c_cc[VSTART];
5415 target->c_cc[TARGET_VSTOP] = host->c_cc[VSTOP];
5416 target->c_cc[TARGET_VSUSP] = host->c_cc[VSUSP];
5417 target->c_cc[TARGET_VEOL] = host->c_cc[VEOL];
5418 target->c_cc[TARGET_VREPRINT] = host->c_cc[VREPRINT];
5419 target->c_cc[TARGET_VDISCARD] = host->c_cc[VDISCARD];
5420 target->c_cc[TARGET_VWERASE] = host->c_cc[VWERASE];
5421 target->c_cc[TARGET_VLNEXT] = host->c_cc[VLNEXT];
5422 target->c_cc[TARGET_VEOL2] = host->c_cc[VEOL2];
5423}
5424
8e853dc7 5425static const StructEntry struct_termios_def = {
31e31b8a
FB		 5426 .convert = { host_to_target_termios, target_to_host_termios },
5427 .size = { sizeof(struct target_termios), sizeof(struct host_termios) },
5428 .align = { __alignof__(struct target_termios), __alignof__(struct host_termios) },
5429};
5430
5286db75
FB		 5431static bitmask_transtbl mmap_flags_tbl[] = {
5432 { TARGET_MAP_SHARED, TARGET_MAP_SHARED, MAP_SHARED, MAP_SHARED },
5433 { TARGET_MAP_PRIVATE, TARGET_MAP_PRIVATE, MAP_PRIVATE, MAP_PRIVATE },
5434 { TARGET_MAP_FIXED, TARGET_MAP_FIXED, MAP_FIXED, MAP_FIXED },
5435 { TARGET_MAP_ANONYMOUS, TARGET_MAP_ANONYMOUS, MAP_ANONYMOUS, MAP_ANONYMOUS },
5436 { TARGET_MAP_GROWSDOWN, TARGET_MAP_GROWSDOWN, MAP_GROWSDOWN, MAP_GROWSDOWN },
5437 { TARGET_MAP_DENYWRITE, TARGET_MAP_DENYWRITE, MAP_DENYWRITE, MAP_DENYWRITE },
5438 { TARGET_MAP_EXECUTABLE, TARGET_MAP_EXECUTABLE, MAP_EXECUTABLE, MAP_EXECUTABLE },
5439 { TARGET_MAP_LOCKED, TARGET_MAP_LOCKED, MAP_LOCKED, MAP_LOCKED },
e8efd8e7
CL		 5440 { TARGET_MAP_NORESERVE, TARGET_MAP_NORESERVE, MAP_NORESERVE,
5441 MAP_NORESERVE },
5286db75
FB		 5442 { 0, 0, 0, 0 }
5443};
5444
2ab83ea7 5445#if defined(TARGET_I386)
6dbad63e
FB		 5446
5447/* NOTE: there is really one LDT for all the threads */
b1d8e52e 5448static uint8_t *ldt_table;
6dbad63e 5449
03acab66 5450static abi_long read_ldt(abi_ulong ptr, unsigned long bytecount)
6dbad63e
FB		 5451{
5452 int size;
53a5960a 5453 void *p;
6dbad63e
FB		 5454
5455 if (!ldt_table)
5456 return 0;
5457 size = TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE;
5458 if (size > bytecount)
5459 size = bytecount;
579a97f7
FB		 5460 p = lock_user(VERIFY_WRITE, ptr, size, 0);
5461 if (!p)
03acab66 5462 return -TARGET_EFAULT;
579a97f7 5463 /* ??? Should this by byteswapped? */
53a5960a
PB		 5464 memcpy(p, ldt_table, size);
5465 unlock_user(p, ptr, size);
6dbad63e
FB		 5466 return size;
5467}
5468
5469/* XXX: add locking support */
03acab66
FB		 5470static abi_long write_ldt(CPUX86State *env,
5471 abi_ulong ptr, unsigned long bytecount, int oldmode)
6dbad63e
FB		 5472{
5473 struct target_modify_ldt_ldt_s ldt_info;
53a5960a 5474 struct target_modify_ldt_ldt_s *target_ldt_info;
6dbad63e 5475 int seg_32bit, contents, read_exec_only, limit_in_pages;
8d18e893 5476 int seg_not_present, useable, lm;
6dbad63e
FB		 5477 uint32_t *lp, entry_1, entry_2;
5478
5479 if (bytecount != sizeof(ldt_info))
03acab66 5480 return -TARGET_EINVAL;
579a97f7 5481 if (!lock_user_struct(VERIFY_READ, target_ldt_info, ptr, 1))
03acab66 5482 return -TARGET_EFAULT;
53a5960a 5483 ldt_info.entry_number = tswap32(target_ldt_info->entry_number);
cbb21eed 5484 ldt_info.base_addr = tswapal(target_ldt_info->base_addr);
53a5960a
PB		 5485 ldt_info.limit = tswap32(target_ldt_info->limit);
5486 ldt_info.flags = tswap32(target_ldt_info->flags);
5487 unlock_user_struct(target_ldt_info, ptr, 0);
3b46e624 5488
6dbad63e 5489 if (ldt_info.entry_number >= TARGET_LDT_ENTRIES)
03acab66 5490 return -TARGET_EINVAL;
6dbad63e
FB		 5491 seg_32bit = ldt_info.flags & 1;
5492 contents = (ldt_info.flags >> 1) & 3;
5493 read_exec_only = (ldt_info.flags >> 3) & 1;
5494 limit_in_pages = (ldt_info.flags >> 4) & 1;
5495 seg_not_present = (ldt_info.flags >> 5) & 1;
5496 useable = (ldt_info.flags >> 6) & 1;
8d18e893
FB		 5497#ifdef TARGET_ABI32
5498 lm = 0;
5499#else
5500 lm = (ldt_info.flags >> 7) & 1;
5501#endif
6dbad63e
FB		 5502 if (contents == 3) {
5503 if (oldmode)
03acab66 5504 return -TARGET_EINVAL;
6dbad63e 5505 if (seg_not_present == 0)
03acab66 5506 return -TARGET_EINVAL;
6dbad63e
FB		 5507 }
5508 /* allocate the LDT */
5509 if (!ldt_table) {
e441570f
AZ		 5510 env->ldt.base = target_mmap(0,
5511 TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE,
5512 PROT_READ|PROT_WRITE,
5513 MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
5514 if (env->ldt.base == -1)
03acab66 5515 return -TARGET_ENOMEM;
e441570f
AZ		 5516 memset(g2h(env->ldt.base), 0,
5517 TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE);
6dbad63e 5518 env->ldt.limit = 0xffff;
e441570f 5519 ldt_table = g2h(env->ldt.base);
6dbad63e
FB		 5520 }
5521
5522 /* NOTE: same code as Linux kernel */
5523 /* Allow LDTs to be cleared by the user. */
5524 if (ldt_info.base_addr == 0 && ldt_info.limit == 0) {
5525 if (oldmode ||
5526 (contents == 0 &&
5527 read_exec_only == 1 &&
5528 seg_32bit == 0 &&
5529 limit_in_pages == 0 &&
5530 seg_not_present == 1 &&
5531 useable == 0 )) {
5532 entry_1 = 0;
5533 entry_2 = 0;
5534 goto install;
5535 }
5536 }
3b46e624 5537
6dbad63e
FB		 5538 entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) |
5539 (ldt_info.limit & 0x0ffff);
5540 entry_2 = (ldt_info.base_addr & 0xff000000) |
5541 ((ldt_info.base_addr & 0x00ff0000) >> 16) |
5542 (ldt_info.limit & 0xf0000) |
5543 ((read_exec_only ^ 1) << 9) |
5544 (contents << 10) |
5545 ((seg_not_present ^ 1) << 15) |
5546 (seg_32bit << 22) |
5547 (limit_in_pages << 23) |
8d18e893 5548 (lm << 21) |
6dbad63e
FB		 5549 0x7000;
5550 if (!oldmode)
5551 entry_2 |= (useable << 20);
14ae3ba7 5552
6dbad63e
FB		 5553 /* Install the new entry ... */
5554install:
5555 lp = (uint32_t *)(ldt_table + (ldt_info.entry_number << 3));
5556 lp[0] = tswap32(entry_1);
5557 lp[1] = tswap32(entry_2);
5558 return 0;
5559}
5560
5561/* specific and weird i386 syscalls */
8fcd3692
BS		 5562static abi_long do_modify_ldt(CPUX86State *env, int func, abi_ulong ptr,
5563 unsigned long bytecount)
6dbad63e 5564{
03acab66 5565 abi_long ret;
3b46e624 5566
6dbad63e
FB		 5567 switch (func) {
5568 case 0:
5569 ret = read_ldt(ptr, bytecount);
5570 break;
5571 case 1:
5572 ret = write_ldt(env, ptr, bytecount, 1);
5573 break;
5574 case 0x11:
5575 ret = write_ldt(env, ptr, bytecount, 0);
5576 break;
03acab66
FB		 5577 default:
5578 ret = -TARGET_ENOSYS;
5579 break;
6dbad63e
FB		 5580 }
5581 return ret;
5582}
1b6b029e 5583
4583f589 5584#if defined(TARGET_I386) && defined(TARGET_ABI32)
bc22eb44 5585abi_long do_set_thread_area(CPUX86State *env, abi_ulong ptr)
8d18e893
FB		 5586{
5587 uint64_t *gdt_table = g2h(env->gdt.base);
5588 struct target_modify_ldt_ldt_s ldt_info;
5589 struct target_modify_ldt_ldt_s *target_ldt_info;
5590 int seg_32bit, contents, read_exec_only, limit_in_pages;
5591 int seg_not_present, useable, lm;
5592 uint32_t *lp, entry_1, entry_2;
5593 int i;
5594
5595 lock_user_struct(VERIFY_WRITE, target_ldt_info, ptr, 1);
5596 if (!target_ldt_info)
5597 return -TARGET_EFAULT;
5598 ldt_info.entry_number = tswap32(target_ldt_info->entry_number);
cbb21eed 5599 ldt_info.base_addr = tswapal(target_ldt_info->base_addr);
8d18e893
FB		 5600 ldt_info.limit = tswap32(target_ldt_info->limit);
5601 ldt_info.flags = tswap32(target_ldt_info->flags);
5602 if (ldt_info.entry_number == -1) {
5603 for (i=TARGET_GDT_ENTRY_TLS_MIN; i<=TARGET_GDT_ENTRY_TLS_MAX; i++) {
5604 if (gdt_table[i] == 0) {
5605 ldt_info.entry_number = i;
5606 target_ldt_info->entry_number = tswap32(i);
5607 break;
5608 }
5609 }
5610 }
5611 unlock_user_struct(target_ldt_info, ptr, 1);
5612
5613 if (ldt_info.entry_number < TARGET_GDT_ENTRY_TLS_MIN ||
5614 ldt_info.entry_number > TARGET_GDT_ENTRY_TLS_MAX)
5615 return -TARGET_EINVAL;
5616 seg_32bit = ldt_info.flags & 1;
5617 contents = (ldt_info.flags >> 1) & 3;
5618 read_exec_only = (ldt_info.flags >> 3) & 1;
5619 limit_in_pages = (ldt_info.flags >> 4) & 1;
5620 seg_not_present = (ldt_info.flags >> 5) & 1;
5621 useable = (ldt_info.flags >> 6) & 1;
5622#ifdef TARGET_ABI32
5623 lm = 0;
5624#else
5625 lm = (ldt_info.flags >> 7) & 1;
5626#endif
5627
5628 if (contents == 3) {
5629 if (seg_not_present == 0)
5630 return -TARGET_EINVAL;
5631 }
5632
5633 /* NOTE: same code as Linux kernel */
5634 /* Allow LDTs to be cleared by the user. */
5635 if (ldt_info.base_addr == 0 && ldt_info.limit == 0) {
5636 if ((contents == 0 &&
5637 read_exec_only == 1 &&
5638 seg_32bit == 0 &&
5639 limit_in_pages == 0 &&
5640 seg_not_present == 1 &&
5641 useable == 0 )) {
5642 entry_1 = 0;
5643 entry_2 = 0;
5644 goto install;
5645 }
5646 }
5647
5648 entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) |
5649 (ldt_info.limit & 0x0ffff);
5650 entry_2 = (ldt_info.base_addr & 0xff000000) |
5651 ((ldt_info.base_addr & 0x00ff0000) >> 16) |
5652 (ldt_info.limit & 0xf0000) |
5653 ((read_exec_only ^ 1) << 9) |
5654 (contents << 10) |
5655 ((seg_not_present ^ 1) << 15) |
5656 (seg_32bit << 22) |
5657 (limit_in_pages << 23) |
5658 (useable << 20) |
5659 (lm << 21) |
5660 0x7000;
5661
5662 /* Install the new entry ... */
5663install:
5664 lp = (uint32_t *)(gdt_table + ldt_info.entry_number);
5665 lp[0] = tswap32(entry_1);
5666 lp[1] = tswap32(entry_2);
5667 return 0;
5668}
5669
8fcd3692 5670static abi_long do_get_thread_area(CPUX86State *env, abi_ulong ptr)
8d18e893
FB		 5671{
5672 struct target_modify_ldt_ldt_s *target_ldt_info;
5673 uint64_t *gdt_table = g2h(env->gdt.base);
5674 uint32_t base_addr, limit, flags;
5675 int seg_32bit, contents, read_exec_only, limit_in_pages, idx;
5676 int seg_not_present, useable, lm;
5677 uint32_t *lp, entry_1, entry_2;
5678
5679 lock_user_struct(VERIFY_WRITE, target_ldt_info, ptr, 1);
5680 if (!target_ldt_info)
5681 return -TARGET_EFAULT;
5682 idx = tswap32(target_ldt_info->entry_number);
5683 if (idx < TARGET_GDT_ENTRY_TLS_MIN ||
5684 idx > TARGET_GDT_ENTRY_TLS_MAX) {
5685 unlock_user_struct(target_ldt_info, ptr, 1);
5686 return -TARGET_EINVAL;
5687 }
5688 lp = (uint32_t *)(gdt_table + idx);
5689 entry_1 = tswap32(lp[0]);
5690 entry_2 = tswap32(lp[1]);
5691
5692 read_exec_only = ((entry_2 >> 9) & 1) ^ 1;
5693 contents = (entry_2 >> 10) & 3;
5694 seg_not_present = ((entry_2 >> 15) & 1) ^ 1;
5695 seg_32bit = (entry_2 >> 22) & 1;
5696 limit_in_pages = (entry_2 >> 23) & 1;
5697 useable = (entry_2 >> 20) & 1;
5698#ifdef TARGET_ABI32
5699 lm = 0;
5700#else
5701 lm = (entry_2 >> 21) & 1;
5702#endif
5703 flags = (seg_32bit << 0) | (contents << 1) |
5704 (read_exec_only << 3) | (limit_in_pages << 4) |
5705 (seg_not_present << 5) | (useable << 6) | (lm << 7);
5706 limit = (entry_1 & 0xffff) | (entry_2 & 0xf0000);
5707 base_addr = (entry_1 >> 16) |
5708 (entry_2 & 0xff000000) |
5709 ((entry_2 & 0xff) << 16);
cbb21eed 5710 target_ldt_info->base_addr = tswapal(base_addr);
8d18e893
FB		 5711 target_ldt_info->limit = tswap32(limit);
5712 target_ldt_info->flags = tswap32(flags);
5713 unlock_user_struct(target_ldt_info, ptr, 1);
5714 return 0;
5715}
4583f589 5716#endif /* TARGET_I386 && TARGET_ABI32 */
8d18e893 5717
d2fd1af7 5718#ifndef TARGET_ABI32
2667e71c 5719abi_long do_arch_prctl(CPUX86State *env, int code, abi_ulong addr)
d2fd1af7 5720{
1add8698 5721 abi_long ret = 0;
d2fd1af7
FB		 5722 abi_ulong val;
5723 int idx;
1add8698 5724
d2fd1af7
FB		 5725 switch(code) {
5726 case TARGET_ARCH_SET_GS:
5727 case TARGET_ARCH_SET_FS:
5728 if (code == TARGET_ARCH_SET_GS)
5729 idx = R_GS;
5730 else
5731 idx = R_FS;
5732 cpu_x86_load_seg(env, idx, 0);
5733 env->segs[idx].base = addr;
5734 break;
5735 case TARGET_ARCH_GET_GS:
5736 case TARGET_ARCH_GET_FS:
5737 if (code == TARGET_ARCH_GET_GS)
5738 idx = R_GS;
5739 else
5740 idx = R_FS;
5741 val = env->segs[idx].base;
5742 if (put_user(val, addr, abi_ulong))
1add8698 5743 ret = -TARGET_EFAULT;
d2fd1af7
FB		 5744 break;
5745 default:
5746 ret = -TARGET_EINVAL;
5747 break;
5748 }
1add8698 5749 return ret;
d2fd1af7
FB		 5750}
5751#endif
5752
2ab83ea7
FB		 5753#endif /* defined(TARGET_I386) */
5754
05098a93 5755#define NEW_STACK_SIZE 0x40000
d865bab5 5756
d865bab5
PB		 5757
5758static pthread_mutex_t clone_lock = PTHREAD_MUTEX_INITIALIZER;
5759typedef struct {
9349b4f9 5760 CPUArchState *env;
d865bab5
PB		 5761 pthread_mutex_t mutex;
5762 pthread_cond_t cond;
5763 pthread_t thread;
5764 uint32_t tid;
5765 abi_ulong child_tidptr;
5766 abi_ulong parent_tidptr;
5767 sigset_t sigmask;
5768} new_thread_info;
5769
5770static void *clone_func(void *arg)
5771{
5772 new_thread_info *info = arg;
9349b4f9 5773 CPUArchState *env;
0d34282f 5774 CPUState *cpu;
edf8e2af 5775 TaskState *ts;
d865bab5 5776
70903763 5777 rcu_register_thread();
d865bab5 5778 env = info->env;
0d34282f 5779 cpu = ENV_GET_CPU(env);
a2247f8e 5780 thread_cpu = cpu;
0429a971 5781 ts = (TaskState *)cpu->opaque;
d865bab5 5782 info->tid = gettid();
0d34282f 5783 cpu->host_tid = info->tid;
edf8e2af 5784 task_settid(ts);
d865bab5
PB		 5785 if (info->child_tidptr)
5786 put_user_u32(info->tid, info->child_tidptr);
5787 if (info->parent_tidptr)
5788 put_user_u32(info->tid, info->parent_tidptr);
5789 /* Enable signals. */
5790 sigprocmask(SIG_SETMASK, &info->sigmask, NULL);
5791 /* Signal to the parent that we're ready. */
5792 pthread_mutex_lock(&info->mutex);
5793 pthread_cond_broadcast(&info->cond);
5794 pthread_mutex_unlock(&info->mutex);
5795 /* Wait until the parent has finshed initializing the tls state. */
5796 pthread_mutex_lock(&clone_lock);
5797 pthread_mutex_unlock(&clone_lock);
5798 cpu_loop(env);
5799 /* never exits */
5800 return NULL;
5801}
1b6b029e 5802
0da46a6e
TS		 5803/* do_fork() Must return host values and target errnos (unlike most
5804 do_*() functions). */
9349b4f9 5805static int do_fork(CPUArchState *env, unsigned int flags, abi_ulong newsp,
d865bab5
PB		 5806 abi_ulong parent_tidptr, target_ulong newtls,
5807 abi_ulong child_tidptr)
1b6b029e 5808{
0429a971 5809 CPUState *cpu = ENV_GET_CPU(env);
1b6b029e 5810 int ret;
5cd4393b 5811 TaskState *ts;
0429a971 5812 CPUState *new_cpu;
9349b4f9 5813 CPUArchState *new_env;
d865bab5
PB		 5814 unsigned int nptl_flags;
5815 sigset_t sigmask;
3b46e624 5816
436d124b
AZ		 5817 /* Emulate vfork() with fork() */
5818 if (flags & CLONE_VFORK)
5819 flags &= ~(CLONE_VFORK | CLONE_VM);
5820
1b6b029e 5821 if (flags & CLONE_VM) {
0429a971 5822 TaskState *parent_ts = (TaskState *)cpu->opaque;
d865bab5
PB		 5823 new_thread_info info;
5824 pthread_attr_t attr;
24cb36a6 5825
c78d65e8 5826 ts = g_new0(TaskState, 1);
624f7979 5827 init_task_state(ts);
1b6b029e 5828 /* we create a new CPU instance. */
c5be9f08 5829 new_env = cpu_copy(env);
6e68e076
PB		 5830 /* Init regs that differ from the parent. */
5831 cpu_clone_regs(new_env, newsp);
0429a971
AF		 5832 new_cpu = ENV_GET_CPU(new_env);
5833 new_cpu->opaque = ts;
edf8e2af
MW		 5834 ts->bprm = parent_ts->bprm;
5835 ts->info = parent_ts->info;
3d3efba0 5836 ts->signal_mask = parent_ts->signal_mask;
d865bab5
PB		 5837 nptl_flags = flags;
5838 flags &= ~CLONE_NPTL_FLAGS2;
5839
c2764719
PB		 5840 if (nptl_flags & CLONE_CHILD_CLEARTID) {
5841 ts->child_tidptr = child_tidptr;
5842 }
5843
d865bab5
PB		 5844 if (nptl_flags & CLONE_SETTLS)
5845 cpu_set_tls (new_env, newtls);
5846
5847 /* Grab a mutex so that thread setup appears atomic. */
5848 pthread_mutex_lock(&clone_lock);
5849
5850 memset(&info, 0, sizeof(info));
5851 pthread_mutex_init(&info.mutex, NULL);
5852 pthread_mutex_lock(&info.mutex);
5853 pthread_cond_init(&info.cond, NULL);
5854 info.env = new_env;
5855 if (nptl_flags & CLONE_CHILD_SETTID)
5856 info.child_tidptr = child_tidptr;
5857 if (nptl_flags & CLONE_PARENT_SETTID)
5858 info.parent_tidptr = parent_tidptr;
5859
5860 ret = pthread_attr_init(&attr);
48e15fc2
NF		 5861 ret = pthread_attr_setstacksize(&attr, NEW_STACK_SIZE);
5862 ret = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
d865bab5
PB		 5863 /* It is not safe to deliver signals until the child has finished
5864 initializing, so temporarily block all signals. */
5865 sigfillset(&sigmask);
5866 sigprocmask(SIG_BLOCK, &sigmask, &info.sigmask);
5867
5868 ret = pthread_create(&info.thread, &attr, clone_func, &info);
c2764719 5869 /* TODO: Free new CPU state if thread creation failed. */
d865bab5
PB		 5870
5871 sigprocmask(SIG_SETMASK, &info.sigmask, NULL);
5872 pthread_attr_destroy(&attr);
5873 if (ret == 0) {
5874 /* Wait for the child to initialize. */
5875 pthread_cond_wait(&info.cond, &info.mutex);
5876 ret = info.tid;
5877 if (flags & CLONE_PARENT_SETTID)
5878 put_user_u32(ret, parent_tidptr);
5879 } else {
5880 ret = -1;
5881 }
5882 pthread_mutex_unlock(&info.mutex);
5883 pthread_cond_destroy(&info.cond);
5884 pthread_mutex_destroy(&info.mutex);
5885 pthread_mutex_unlock(&clone_lock);
1b6b029e
FB		 5886 } else {
5887 /* if no CLONE_VM, we consider it is a fork */
93b4eff8
TB		 5888 if ((flags & ~(CSIGNAL | CLONE_NPTL_FLAGS2)) != 0) {
5889 return -TARGET_EINVAL;
5890 }
7d92d34e
TB		 5891
5892 if (block_signals()) {
5893 return -TARGET_ERESTARTSYS;
5894 }
5895
d865bab5 5896 fork_start();
1b6b029e 5897 ret = fork();
d865bab5 5898 if (ret == 0) {
2b1319c8 5899 /* Child Process. */
a59629fc 5900 rcu_after_fork();
d865bab5
PB		 5901 cpu_clone_regs(env, newsp);
5902 fork_end(1);
2b1319c8
AJ		 5903 /* There is a race condition here. The parent process could
5904 theoretically read the TID in the child process before the child
5905 tid is set. This would require using either ptrace
5906 (not implemented) or having *_tidptr to point at a shared memory
5907 mapping. We can't repeat the spinlock hack used above because
5908 the child process gets its own copy of the lock. */
d865bab5
PB		 5909 if (flags & CLONE_CHILD_SETTID)
5910 put_user_u32(gettid(), child_tidptr);
5911 if (flags & CLONE_PARENT_SETTID)
5912 put_user_u32(gettid(), parent_tidptr);
0429a971 5913 ts = (TaskState *)cpu->opaque;
d865bab5
PB		 5914 if (flags & CLONE_SETTLS)
5915 cpu_set_tls (env, newtls);
c2764719
PB		 5916 if (flags & CLONE_CHILD_CLEARTID)
5917 ts->child_tidptr = child_tidptr;
d865bab5
PB		 5918 } else {
5919 fork_end(0);
5920 }
1b6b029e
FB		 5921 }
5922 return ret;
5923}
5924
5f106811
APR		 5925/* warning : doesn't handle linux specific flags... */
5926static int target_to_host_fcntl_cmd(int cmd)
5927{
5928 switch(cmd) {
5929 case TARGET_F_DUPFD:
5930 case TARGET_F_GETFD:
5931 case TARGET_F_SETFD:
5932 case TARGET_F_GETFL:
5933 case TARGET_F_SETFL:
5934 return cmd;
5935 case TARGET_F_GETLK:
213d3e9e
PM		 5936 return F_GETLK64;
5937 case TARGET_F_SETLK:
5938 return F_SETLK64;
5939 case TARGET_F_SETLKW:
5940 return F_SETLKW64;
5f106811
APR		 5941 case TARGET_F_GETOWN:
5942 return F_GETOWN;
5943 case TARGET_F_SETOWN:
5944 return F_SETOWN;
5945 case TARGET_F_GETSIG:
5946 return F_GETSIG;
5947 case TARGET_F_SETSIG:
5948 return F_SETSIG;
5949#if TARGET_ABI_BITS == 32
5950 case TARGET_F_GETLK64:
5951 return F_GETLK64;
5952 case TARGET_F_SETLK64:
5953 return F_SETLK64;
5954 case TARGET_F_SETLKW64:
5955 return F_SETLKW64;
5956#endif
7e22e546
UH		 5957 case TARGET_F_SETLEASE:
5958 return F_SETLEASE;
5959 case TARGET_F_GETLEASE:
5960 return F_GETLEASE;
fbd5de9b 5961#ifdef F_DUPFD_CLOEXEC
7e22e546
UH		 5962 case TARGET_F_DUPFD_CLOEXEC:
5963 return F_DUPFD_CLOEXEC;
fbd5de9b 5964#endif
7e22e546
UH		 5965 case TARGET_F_NOTIFY:
5966 return F_NOTIFY;
8d5d3004
AS		 5967#ifdef F_GETOWN_EX
5968 case TARGET_F_GETOWN_EX:
5969 return F_GETOWN_EX;
5970#endif
5971#ifdef F_SETOWN_EX
5972 case TARGET_F_SETOWN_EX:
5973 return F_SETOWN_EX;
5974#endif
ddf31aa8 5975#ifdef F_SETPIPE_SZ
7e3b92ec
PM		 5976 case TARGET_F_SETPIPE_SZ:
5977 return F_SETPIPE_SZ;
5978 case TARGET_F_GETPIPE_SZ:
5979 return F_GETPIPE_SZ;
ddf31aa8 5980#endif
5f106811
APR		 5981 default:
5982 return -TARGET_EINVAL;
5983 }
5984 return -TARGET_EINVAL;
5985}
5986
2ba7f730
LV		 5987#define TRANSTBL_CONVERT(a) { -1, TARGET_##a, -1, a }
5988static const bitmask_transtbl flock_tbl[] = {
5989 TRANSTBL_CONVERT(F_RDLCK),
5990 TRANSTBL_CONVERT(F_WRLCK),
5991 TRANSTBL_CONVERT(F_UNLCK),
5992 TRANSTBL_CONVERT(F_EXLCK),
5993 TRANSTBL_CONVERT(F_SHLCK),
5994 { 0, 0, 0, 0 }
5995};
5996
213d3e9e
PM		 5997static inline abi_long copy_from_user_flock(struct flock64 *fl,
5998 abi_ulong target_flock_addr)
7775e9ec 5999{
53a5960a 6000 struct target_flock *target_fl;
213d3e9e
PM		 6001 short l_type;
6002
6003 if (!lock_user_struct(VERIFY_READ, target_fl, target_flock_addr, 1)) {
6004 return -TARGET_EFAULT;
6005 }
6006
6007 __get_user(l_type, &target_fl->l_type);
6008 fl->l_type = target_to_host_bitmask(l_type, flock_tbl);
6009 __get_user(fl->l_whence, &target_fl->l_whence);
6010 __get_user(fl->l_start, &target_fl->l_start);
6011 __get_user(fl->l_len, &target_fl->l_len);
6012 __get_user(fl->l_pid, &target_fl->l_pid);
6013 unlock_user_struct(target_fl, target_flock_addr, 0);
6014 return 0;
6015}
6016
6017static inline abi_long copy_to_user_flock(abi_ulong target_flock_addr,
6018 const struct flock64 *fl)
6019{
6020 struct target_flock *target_fl;
6021 short l_type;
6022
6023 if (!lock_user_struct(VERIFY_WRITE, target_fl, target_flock_addr, 0)) {
6024 return -TARGET_EFAULT;
6025 }
6026
6027 l_type = host_to_target_bitmask(fl->l_type, flock_tbl);
6028 __put_user(l_type, &target_fl->l_type);
6029 __put_user(fl->l_whence, &target_fl->l_whence);
6030 __put_user(fl->l_start, &target_fl->l_start);
6031 __put_user(fl->l_len, &target_fl->l_len);
6032 __put_user(fl->l_pid, &target_fl->l_pid);
6033 unlock_user_struct(target_fl, target_flock_addr, 1);
6034 return 0;
6035}
6036
6037typedef abi_long from_flock64_fn(struct flock64 *fl, abi_ulong target_addr);
6038typedef abi_long to_flock64_fn(abi_ulong target_addr, const struct flock64 *fl);
6039
6040#if defined(TARGET_ARM) && TARGET_ABI_BITS == 32
6041static inline abi_long copy_from_user_eabi_flock64(struct flock64 *fl,
6042 abi_ulong target_flock_addr)
6043{
6044 struct target_eabi_flock64 *target_fl;
6045 short l_type;
6046
6047 if (!lock_user_struct(VERIFY_READ, target_fl, target_flock_addr, 1)) {
6048 return -TARGET_EFAULT;
6049 }
6050
6051 __get_user(l_type, &target_fl->l_type);
6052 fl->l_type = target_to_host_bitmask(l_type, flock_tbl);
6053 __get_user(fl->l_whence, &target_fl->l_whence);
6054 __get_user(fl->l_start, &target_fl->l_start);
6055 __get_user(fl->l_len, &target_fl->l_len);
6056 __get_user(fl->l_pid, &target_fl->l_pid);
6057 unlock_user_struct(target_fl, target_flock_addr, 0);
6058 return 0;
6059}
6060
6061static inline abi_long copy_to_user_eabi_flock64(abi_ulong target_flock_addr,
6062 const struct flock64 *fl)
6063{
6064 struct target_eabi_flock64 *target_fl;
6065 short l_type;
6066
6067 if (!lock_user_struct(VERIFY_WRITE, target_fl, target_flock_addr, 0)) {
6068 return -TARGET_EFAULT;
6069 }
6070
6071 l_type = host_to_target_bitmask(fl->l_type, flock_tbl);
6072 __put_user(l_type, &target_fl->l_type);
6073 __put_user(fl->l_whence, &target_fl->l_whence);
6074 __put_user(fl->l_start, &target_fl->l_start);
6075 __put_user(fl->l_len, &target_fl->l_len);
6076 __put_user(fl->l_pid, &target_fl->l_pid);
6077 unlock_user_struct(target_fl, target_flock_addr, 1);
6078 return 0;
6079}
6080#endif
6081
6082static inline abi_long copy_from_user_flock64(struct flock64 *fl,
6083 abi_ulong target_flock_addr)
6084{
6085 struct target_flock64 *target_fl;
6086 short l_type;
6087
6088 if (!lock_user_struct(VERIFY_READ, target_fl, target_flock_addr, 1)) {
6089 return -TARGET_EFAULT;
6090 }
6091
6092 __get_user(l_type, &target_fl->l_type);
6093 fl->l_type = target_to_host_bitmask(l_type, flock_tbl);
6094 __get_user(fl->l_whence, &target_fl->l_whence);
6095 __get_user(fl->l_start, &target_fl->l_start);
6096 __get_user(fl->l_len, &target_fl->l_len);
6097 __get_user(fl->l_pid, &target_fl->l_pid);
6098 unlock_user_struct(target_fl, target_flock_addr, 0);
6099 return 0;
6100}
6101
6102static inline abi_long copy_to_user_flock64(abi_ulong target_flock_addr,
6103 const struct flock64 *fl)
6104{
6105 struct target_flock64 *target_fl;
6106 short l_type;
6107
6108 if (!lock_user_struct(VERIFY_WRITE, target_fl, target_flock_addr, 0)) {
6109 return -TARGET_EFAULT;
6110 }
6111
6112 l_type = host_to_target_bitmask(fl->l_type, flock_tbl);
6113 __put_user(l_type, &target_fl->l_type);
6114 __put_user(fl->l_whence, &target_fl->l_whence);
6115 __put_user(fl->l_start, &target_fl->l_start);
6116 __put_user(fl->l_len, &target_fl->l_len);
6117 __put_user(fl->l_pid, &target_fl->l_pid);
6118 unlock_user_struct(target_fl, target_flock_addr, 1);
6119 return 0;
6120}
6121
6122static abi_long do_fcntl(int fd, int cmd, abi_ulong arg)
6123{
43f238d7 6124 struct flock64 fl64;
8d5d3004
AS		 6125#ifdef F_GETOWN_EX
6126 struct f_owner_ex fox;
6127 struct target_f_owner_ex *target_fox;
6128#endif
992f48a0 6129 abi_long ret;
5f106811
APR		 6130 int host_cmd = target_to_host_fcntl_cmd(cmd);
6131
6132 if (host_cmd == -TARGET_EINVAL)
6133 return host_cmd;
53a5960a 6134
7775e9ec
FB		 6135 switch(cmd) {
6136 case TARGET_F_GETLK:
213d3e9e
PM		 6137 ret = copy_from_user_flock(&fl64, arg);
6138 if (ret) {
6139 return ret;
6140 }
435da5e7 6141 ret = get_errno(safe_fcntl(fd, host_cmd, &fl64));
7775e9ec 6142 if (ret == 0) {
213d3e9e 6143 ret = copy_to_user_flock(arg, &fl64);
7775e9ec
FB		 6144 }
6145 break;
3b46e624 6146
7775e9ec
FB		 6147 case TARGET_F_SETLK:
6148 case TARGET_F_SETLKW:
213d3e9e
PM		 6149 ret = copy_from_user_flock(&fl64, arg);
6150 if (ret) {
6151 return ret;
6152 }
435da5e7 6153 ret = get_errno(safe_fcntl(fd, host_cmd, &fl64));
7775e9ec 6154 break;
3b46e624 6155
7775e9ec 6156 case TARGET_F_GETLK64:
213d3e9e
PM		 6157 ret = copy_from_user_flock64(&fl64, arg);
6158 if (ret) {
6159 return ret;
6160 }
435da5e7 6161 ret = get_errno(safe_fcntl(fd, host_cmd, &fl64));
43f238d7 6162 if (ret == 0) {
213d3e9e 6163 ret = copy_to_user_flock64(arg, &fl64);
43f238d7 6164 }
9ee1fa2c 6165 break;
7775e9ec
FB		 6166 case TARGET_F_SETLK64:
6167 case TARGET_F_SETLKW64:
213d3e9e
PM		 6168 ret = copy_from_user_flock64(&fl64, arg);
6169 if (ret) {
6170 return ret;
6171 }
435da5e7 6172 ret = get_errno(safe_fcntl(fd, host_cmd, &fl64));
7775e9ec
FB		 6173 break;
6174
5f106811 6175 case TARGET_F_GETFL:
435da5e7 6176 ret = get_errno(safe_fcntl(fd, host_cmd, arg));
9ee1fa2c
FB		 6177 if (ret >= 0) {
6178 ret = host_to_target_bitmask(ret, fcntl_flags_tbl);
6179 }
ffa65c3b
FB		 6180 break;
6181
5f106811 6182 case TARGET_F_SETFL:
435da5e7
PM		 6183 ret = get_errno(safe_fcntl(fd, host_cmd,
6184 target_to_host_bitmask(arg,
6185 fcntl_flags_tbl)));
5f106811
APR		 6186 break;
6187
8d5d3004
AS		 6188#ifdef F_GETOWN_EX
6189 case TARGET_F_GETOWN_EX:
435da5e7 6190 ret = get_errno(safe_fcntl(fd, host_cmd, &fox));
8d5d3004
AS		 6191 if (ret >= 0) {
6192 if (!lock_user_struct(VERIFY_WRITE, target_fox, arg, 0))
6193 return -TARGET_EFAULT;
6194 target_fox->type = tswap32(fox.type);
6195 target_fox->pid = tswap32(fox.pid);
6196 unlock_user_struct(target_fox, arg, 1);
6197 }
6198 break;
6199#endif
6200
6201#ifdef F_SETOWN_EX
6202 case TARGET_F_SETOWN_EX:
6203 if (!lock_user_struct(VERIFY_READ, target_fox, arg, 1))
6204 return -TARGET_EFAULT;
6205 fox.type = tswap32(target_fox->type);
6206 fox.pid = tswap32(target_fox->pid);
6207 unlock_user_struct(target_fox, arg, 0);
435da5e7 6208 ret = get_errno(safe_fcntl(fd, host_cmd, &fox));
8d5d3004
AS		 6209 break;
6210#endif
6211
5f106811
APR		 6212 case TARGET_F_SETOWN:
6213 case TARGET_F_GETOWN:
6214 case TARGET_F_SETSIG:
6215 case TARGET_F_GETSIG:
7e22e546
UH		 6216 case TARGET_F_SETLEASE:
6217 case TARGET_F_GETLEASE:
7e3b92ec
PM		 6218 case TARGET_F_SETPIPE_SZ:
6219 case TARGET_F_GETPIPE_SZ:
435da5e7 6220 ret = get_errno(safe_fcntl(fd, host_cmd, arg));
ffa65c3b
FB		 6221 break;
6222
7775e9ec 6223 default:
435da5e7 6224 ret = get_errno(safe_fcntl(fd, cmd, arg));
7775e9ec
FB		 6225 break;
6226 }
6227 return ret;
6228}
6229
67867308 6230#ifdef USE_UID16
7775e9ec 6231
67867308
FB		 6232static inline int high2lowuid(int uid)
6233{
6234 if (uid > 65535)
6235 return 65534;
6236 else
6237 return uid;
6238}
6239
6240static inline int high2lowgid(int gid)
6241{
6242 if (gid > 65535)
6243 return 65534;
6244 else
6245 return gid;
6246}
6247
6248static inline int low2highuid(int uid)
6249{
6250 if ((int16_t)uid == -1)
6251 return -1;
6252 else
6253 return uid;
6254}
6255
6256static inline int low2highgid(int gid)
6257{
6258 if ((int16_t)gid == -1)
6259 return -1;
6260 else
6261 return gid;
6262}
0c866a7e
RV		 6263static inline int tswapid(int id)
6264{
6265 return tswap16(id);
6266}
76ca310a
PM		 6267
6268#define put_user_id(x, gaddr) put_user_u16(x, gaddr)
6269
0c866a7e
RV		 6270#else /* !USE_UID16 */
6271static inline int high2lowuid(int uid)
6272{
6273 return uid;
6274}
6275static inline int high2lowgid(int gid)
6276{
6277 return gid;
6278}
6279static inline int low2highuid(int uid)
6280{
6281 return uid;
6282}
6283static inline int low2highgid(int gid)
6284{
6285 return gid;
6286}
6287static inline int tswapid(int id)
6288{
6289 return tswap32(id);
6290}
76ca310a
PM		 6291
6292#define put_user_id(x, gaddr) put_user_u32(x, gaddr)
6293
67867308 6294#endif /* USE_UID16 */
1b6b029e 6295
fd6f7798
PM		 6296/* We must do direct syscalls for setting UID/GID, because we want to
6297 * implement the Linux system call semantics of "change only for this thread",
6298 * not the libc/POSIX semantics of "change for all threads in process".
6299 * (See http://ewontfix.com/17/ for more details.)
6300 * We use the 32-bit version of the syscalls if present; if it is not
6301 * then either the host architecture supports 32-bit UIDs natively with
6302 * the standard syscall, or the 16-bit UID is the best we can do.
6303 */
6304#ifdef __NR_setuid32
6305#define __NR_sys_setuid __NR_setuid32
6306#else
6307#define __NR_sys_setuid __NR_setuid
6308#endif
6309#ifdef __NR_setgid32
6310#define __NR_sys_setgid __NR_setgid32
6311#else
6312#define __NR_sys_setgid __NR_setgid
6313#endif
6314#ifdef __NR_setresuid32
6315#define __NR_sys_setresuid __NR_setresuid32
6316#else
6317#define __NR_sys_setresuid __NR_setresuid
6318#endif
6319#ifdef __NR_setresgid32
6320#define __NR_sys_setresgid __NR_setresgid32
6321#else
6322#define __NR_sys_setresgid __NR_setresgid
6323#endif
6324
6325_syscall1(int, sys_setuid, uid_t, uid)
6326_syscall1(int, sys_setgid, gid_t, gid)
6327_syscall3(int, sys_setresuid, uid_t, ruid, uid_t, euid, uid_t, suid)
6328_syscall3(int, sys_setresgid, gid_t, rgid, gid_t, egid, gid_t, sgid)
6329
31e31b8a
FB		 6330void syscall_init(void)
6331{
2ab83ea7
FB		 6332 IOCTLEntry *ie;
6333 const argtype *arg_type;
6334 int size;
b92c47c1 6335 int i;
2ab83ea7 6336
8be656b8
AG		 6337 thunk_init(STRUCT_MAX);
6338
001faf32 6339#define STRUCT(name, ...) thunk_register_struct(STRUCT_ ## name, #name, struct_ ## name ## _def);
5fafdf24 6340#define STRUCT_SPECIAL(name) thunk_register_struct_direct(STRUCT_ ## name, #name, &struct_ ## name ## _def);
31e31b8a
FB		 6341#include "syscall_types.h"
6342#undef STRUCT
6343#undef STRUCT_SPECIAL
2ab83ea7 6344
dd6e957a
PM		 6345 /* Build target_to_host_errno_table[] table from
6346 * host_to_target_errno_table[]. */
6347 for (i = 0; i < ERRNO_TABLE_SIZE; i++) {
6348 target_to_host_errno_table[host_to_target_errno_table[i]] = i;
6349 }
6350
2ab83ea7
FB		 6351 /* we patch the ioctl size if necessary. We rely on the fact that
6352 no ioctl has all the bits at '1' in the size field */
6353 ie = ioctl_entries;
6354 while (ie->target_cmd != 0) {
6355 if (((ie->target_cmd >> TARGET_IOC_SIZESHIFT) & TARGET_IOC_SIZEMASK) ==
6356 TARGET_IOC_SIZEMASK) {
6357 arg_type = ie->arg_type;
6358 if (arg_type[0] != TYPE_PTR) {
5fafdf24 6359 fprintf(stderr, "cannot patch size for ioctl 0x%x\n",
2ab83ea7
FB		 6360 ie->target_cmd);
6361 exit(1);
6362 }
6363 arg_type++;
6364 size = thunk_type_size(arg_type, 0);
5fafdf24 6365 ie->target_cmd = (ie->target_cmd &
2ab83ea7
FB		 6366 ~(TARGET_IOC_SIZEMASK << TARGET_IOC_SIZESHIFT)) |
6367 (size << TARGET_IOC_SIZESHIFT);
6368 }
b92c47c1 6369
2ab83ea7 6370 /* automatic consistency check if same arch */
872ea0c0
AZ		 6371#if (defined(__i386__) && defined(TARGET_I386) && defined(TARGET_ABI32)) || \
6372 (defined(__x86_64__) && defined(TARGET_X86_64))
6373 if (unlikely(ie->target_cmd != ie->host_cmd)) {
6374 fprintf(stderr, "ERROR: ioctl(%s): target=0x%x host=0x%x\n",
6375 ie->name, ie->target_cmd, ie->host_cmd);
2ab83ea7
FB		 6376 }
6377#endif
6378 ie++;
6379 }
31e31b8a 6380}
c573ff67 6381
992f48a0 6382#if TARGET_ABI_BITS == 32
ce4defa0
PB		 6383static inline uint64_t target_offset64(uint32_t word0, uint32_t word1)
6384{
af325d36 6385#ifdef TARGET_WORDS_BIGENDIAN
ce4defa0
PB		 6386 return ((uint64_t)word0 << 32) | word1;
6387#else
6388 return ((uint64_t)word1 << 32) | word0;
6389#endif
6390}
992f48a0 6391#else /* TARGET_ABI_BITS == 32 */
32407103
JM		 6392static inline uint64_t target_offset64(uint64_t word0, uint64_t word1)
6393{
6394 return word0;
6395}
992f48a0 6396#endif /* TARGET_ABI_BITS != 32 */
ce4defa0
PB		 6397
6398#ifdef TARGET_NR_truncate64
992f48a0
BS		 6399static inline abi_long target_truncate64(void *cpu_env, const char *arg1,
6400 abi_long arg2,
6401 abi_long arg3,
6402 abi_long arg4)
ce4defa0 6403{
48e515d4 6404 if (regpairs_aligned(cpu_env)) {
ce4defa0
PB		 6405 arg2 = arg3;
6406 arg3 = arg4;
48e515d4 6407 }
ce4defa0
PB		 6408 return get_errno(truncate64(arg1, target_offset64(arg2, arg3)));
6409}
6410#endif
6411
6412#ifdef TARGET_NR_ftruncate64
992f48a0
BS		 6413static inline abi_long target_ftruncate64(void *cpu_env, abi_long arg1,
6414 abi_long arg2,
6415 abi_long arg3,
6416 abi_long arg4)
ce4defa0 6417{
48e515d4 6418 if (regpairs_aligned(cpu_env)) {
ce4defa0
PB		 6419 arg2 = arg3;
6420 arg3 = arg4;
48e515d4 6421 }
ce4defa0
PB		 6422 return get_errno(ftruncate64(arg1, target_offset64(arg2, arg3)));
6423}
6424#endif
6425
579a97f7
FB		 6426static inline abi_long target_to_host_timespec(struct timespec *host_ts,
6427 abi_ulong target_addr)
53a5960a
PB		 6428{
6429 struct target_timespec *target_ts;
6430
579a97f7
FB		 6431 if (!lock_user_struct(VERIFY_READ, target_ts, target_addr, 1))
6432 return -TARGET_EFAULT;
c7e35da3
PM		 6433 __get_user(host_ts->tv_sec, &target_ts->tv_sec);
6434 __get_user(host_ts->tv_nsec, &target_ts->tv_nsec);
53a5960a 6435 unlock_user_struct(target_ts, target_addr, 0);
b255bfa8 6436 return 0;
53a5960a
PB		 6437}
6438
579a97f7
FB		 6439static inline abi_long host_to_target_timespec(abi_ulong target_addr,
6440 struct timespec *host_ts)
53a5960a
PB		 6441{
6442 struct target_timespec *target_ts;
6443
579a97f7
FB		 6444 if (!lock_user_struct(VERIFY_WRITE, target_ts, target_addr, 0))
6445 return -TARGET_EFAULT;
c7e35da3
PM		 6446 __put_user(host_ts->tv_sec, &target_ts->tv_sec);
6447 __put_user(host_ts->tv_nsec, &target_ts->tv_nsec);
53a5960a 6448 unlock_user_struct(target_ts, target_addr, 1);
b255bfa8 6449 return 0;
53a5960a
PB		 6450}
6451
f4f1e10a
ECL		 6452static inline abi_long target_to_host_itimerspec(struct itimerspec *host_itspec,
6453 abi_ulong target_addr)
6454{
6455 struct target_itimerspec *target_itspec;
6456
6457 if (!lock_user_struct(VERIFY_READ, target_itspec, target_addr, 1)) {
6458 return -TARGET_EFAULT;
6459 }
6460
6461 host_itspec->it_interval.tv_sec =
6462 tswapal(target_itspec->it_interval.tv_sec);
6463 host_itspec->it_interval.tv_nsec =
6464 tswapal(target_itspec->it_interval.tv_nsec);
6465 host_itspec->it_value.tv_sec = tswapal(target_itspec->it_value.tv_sec);
6466 host_itspec->it_value.tv_nsec = tswapal(target_itspec->it_value.tv_nsec);
6467
6468 unlock_user_struct(target_itspec, target_addr, 1);
6469 return 0;
6470}
6471
6472static inline abi_long host_to_target_itimerspec(abi_ulong target_addr,
6473 struct itimerspec *host_its)
6474{
6475 struct target_itimerspec *target_itspec;
6476
6477 if (!lock_user_struct(VERIFY_WRITE, target_itspec, target_addr, 0)) {
6478 return -TARGET_EFAULT;
6479 }
6480
6481 target_itspec->it_interval.tv_sec = tswapal(host_its->it_interval.tv_sec);
6482 target_itspec->it_interval.tv_nsec = tswapal(host_its->it_interval.tv_nsec);
6483
6484 target_itspec->it_value.tv_sec = tswapal(host_its->it_value.tv_sec);
6485 target_itspec->it_value.tv_nsec = tswapal(host_its->it_value.tv_nsec);
6486
6487 unlock_user_struct(target_itspec, target_addr, 0);
6488 return 0;
6489}
6490
c065976f
PM		 6491static inline abi_long target_to_host_sigevent(struct sigevent *host_sevp,
6492 abi_ulong target_addr)
6493{
6494 struct target_sigevent *target_sevp;
6495
6496 if (!lock_user_struct(VERIFY_READ, target_sevp, target_addr, 1)) {
6497 return -TARGET_EFAULT;
6498 }
6499
6500 /* This union is awkward on 64 bit systems because it has a 32 bit
6501 * integer and a pointer in it; we follow the conversion approach
6502 * used for handling sigval types in signal.c so the guest should get
6503 * the correct value back even if we did a 64 bit byteswap and it's
6504 * using the 32 bit integer.
6505 */
6506 host_sevp->sigev_value.sival_ptr =
6507 (void *)(uintptr_t)tswapal(target_sevp->sigev_value.sival_ptr);
6508 host_sevp->sigev_signo =
6509 target_to_host_signal(tswap32(target_sevp->sigev_signo));
6510 host_sevp->sigev_notify = tswap32(target_sevp->sigev_notify);
6511 host_sevp->_sigev_un._tid = tswap32(target_sevp->_sigev_un._tid);
6512
6513 unlock_user_struct(target_sevp, target_addr, 1);
6514 return 0;
6515}
6516
6f6a4032
TM		 6517#if defined(TARGET_NR_mlockall)
6518static inline int target_to_host_mlockall_arg(int arg)
6519{
6520 int result = 0;
6521
6522 if (arg & TARGET_MLOCKALL_MCL_CURRENT) {
6523 result |= MCL_CURRENT;
6524 }
6525 if (arg & TARGET_MLOCKALL_MCL_FUTURE) {
6526 result |= MCL_FUTURE;
6527 }
6528 return result;
6529}
6530#endif
6531
6a24a778
AZ		 6532static inline abi_long host_to_target_stat64(void *cpu_env,
6533 abi_ulong target_addr,
6534 struct stat *host_st)
6535{
09701199 6536#if defined(TARGET_ARM) && defined(TARGET_ABI32)
6a24a778
AZ		 6537 if (((CPUARMState *)cpu_env)->eabi) {
6538 struct target_eabi_stat64 *target_st;
6539
6540 if (!lock_user_struct(VERIFY_WRITE, target_st, target_addr, 0))
6541 return -TARGET_EFAULT;
6542 memset(target_st, 0, sizeof(struct target_eabi_stat64));
6543 __put_user(host_st->st_dev, &target_st->st_dev);
6544 __put_user(host_st->st_ino, &target_st->st_ino);
6545#ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
6546 __put_user(host_st->st_ino, &target_st->__st_ino);
6547#endif
6548 __put_user(host_st->st_mode, &target_st->st_mode);
6549 __put_user(host_st->st_nlink, &target_st->st_nlink);
6550 __put_user(host_st->st_uid, &target_st->st_uid);
6551 __put_user(host_st->st_gid, &target_st->st_gid);
6552 __put_user(host_st->st_rdev, &target_st->st_rdev);
6553 __put_user(host_st->st_size, &target_st->st_size);
6554 __put_user(host_st->st_blksize, &target_st->st_blksize);
6555 __put_user(host_st->st_blocks, &target_st->st_blocks);
6556 __put_user(host_st->st_atime, &target_st->target_st_atime);
6557 __put_user(host_st->st_mtime, &target_st->target_st_mtime);
6558 __put_user(host_st->st_ctime, &target_st->target_st_ctime);
6559 unlock_user_struct(target_st, target_addr, 1);
6560 } else
6561#endif
6562 {
20d155bc 6563#if defined(TARGET_HAS_STRUCT_STAT64)
6a24a778 6564 struct target_stat64 *target_st;
20d155bc
SW		 6565#else
6566 struct target_stat *target_st;
9d33b76b 6567#endif
6a24a778
AZ		 6568
6569 if (!lock_user_struct(VERIFY_WRITE, target_st, target_addr, 0))
6570 return -TARGET_EFAULT;
9d33b76b 6571 memset(target_st, 0, sizeof(*target_st));
6a24a778
AZ		 6572 __put_user(host_st->st_dev, &target_st->st_dev);
6573 __put_user(host_st->st_ino, &target_st->st_ino);
6574#ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
6575 __put_user(host_st->st_ino, &target_st->__st_ino);
6576#endif
6577 __put_user(host_st->st_mode, &target_st->st_mode);
6578 __put_user(host_st->st_nlink, &target_st->st_nlink);
6579 __put_user(host_st->st_uid, &target_st->st_uid);
6580 __put_user(host_st->st_gid, &target_st->st_gid);
6581 __put_user(host_st->st_rdev, &target_st->st_rdev);
6582 /* XXX: better use of kernel struct */
6583 __put_user(host_st->st_size, &target_st->st_size);
6584 __put_user(host_st->st_blksize, &target_st->st_blksize);
6585 __put_user(host_st->st_blocks, &target_st->st_blocks);
6586 __put_user(host_st->st_atime, &target_st->target_st_atime);
6587 __put_user(host_st->st_mtime, &target_st->target_st_mtime);
6588 __put_user(host_st->st_ctime, &target_st->target_st_ctime);
6589 unlock_user_struct(target_st, target_addr, 1);
6590 }
6591
6592 return 0;
6593}
6a24a778 6594
bd0c5661
PB		 6595/* ??? Using host futex calls even when target atomic operations
6596 are not really atomic probably breaks things. However implementing
6597 futexes locally would make futexes shared between multiple processes
6598 tricky. However they're probably useless because guest atomic
6599 operations won't work either. */
8fcd3692
BS		 6600static int do_futex(target_ulong uaddr, int op, int val, target_ulong timeout,
6601 target_ulong uaddr2, int val3)
bd0c5661
PB		 6602{
6603 struct timespec ts, *pts;
a16aae0c 6604 int base_op;
bd0c5661
PB		 6605
6606 /* ??? We assume FUTEX_* constants are the same on both host
6607 and target. */
a29ccd63 6608#ifdef FUTEX_CMD_MASK
a16aae0c 6609 base_op = op & FUTEX_CMD_MASK;
a29ccd63 6610#else
a16aae0c 6611 base_op = op;
a29ccd63 6612#endif
a16aae0c 6613 switch (base_op) {
bd0c5661 6614 case FUTEX_WAIT:
cce246e0 6615 case FUTEX_WAIT_BITSET:
bd0c5661
PB		 6616 if (timeout) {
6617 pts = &ts;
6618 target_to_host_timespec(pts, timeout);
6619 } else {
6620 pts = NULL;
6621 }
d509eeb1 6622 return get_errno(safe_futex(g2h(uaddr), op, tswap32(val),
cce246e0 6623 pts, NULL, val3));
bd0c5661 6624 case FUTEX_WAKE:
d509eeb1 6625 return get_errno(safe_futex(g2h(uaddr), op, val, NULL, NULL, 0));
bd0c5661 6626 case FUTEX_FD:
d509eeb1 6627 return get_errno(safe_futex(g2h(uaddr), op, val, NULL, NULL, 0));
bd0c5661 6628 case FUTEX_REQUEUE:
bd0c5661 6629 case FUTEX_CMP_REQUEUE:
a16aae0c
NF		 6630 case FUTEX_WAKE_OP:
6631 /* For FUTEX_REQUEUE, FUTEX_CMP_REQUEUE, and FUTEX_WAKE_OP, the
6632 TIMEOUT parameter is interpreted as a uint32_t by the kernel.
6633 But the prototype takes a `struct timespec *'; insert casts
6634 to satisfy the compiler. We do not need to tswap TIMEOUT
6635 since it's not compared to guest memory. */
6636 pts = (struct timespec *)(uintptr_t) timeout;
d509eeb1
PM		 6637 return get_errno(safe_futex(g2h(uaddr), op, val, pts,
6638 g2h(uaddr2),
6639 (base_op == FUTEX_CMP_REQUEUE
6640 ? tswap32(val3)
6641 : val3)));
bd0c5661
PB		 6642 default:
6643 return -TARGET_ENOSYS;
6644 }
6645}
0f0426f3
LV		 6646#if defined(TARGET_NR_name_to_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
6647static abi_long do_name_to_handle_at(abi_long dirfd, abi_long pathname,
6648 abi_long handle, abi_long mount_id,
6649 abi_long flags)
6650{
6651 struct file_handle *target_fh;
6652 struct file_handle *fh;
6653 int mid = 0;
6654 abi_long ret;
6655 char *name;
6656 unsigned int size, total_size;
6657
6658 if (get_user_s32(size, handle)) {
6659 return -TARGET_EFAULT;
6660 }
6661
6662 name = lock_user_string(pathname);
6663 if (!name) {
6664 return -TARGET_EFAULT;
6665 }
6666
6667 total_size = sizeof(struct file_handle) + size;
6668 target_fh = lock_user(VERIFY_WRITE, handle, total_size, 0);
6669 if (!target_fh) {
6670 unlock_user(name, pathname, 0);
6671 return -TARGET_EFAULT;
6672 }
6673
6674 fh = g_malloc0(total_size);
6675 fh->handle_bytes = size;
6676
6677 ret = get_errno(name_to_handle_at(dirfd, path(name), fh, &mid, flags));
6678 unlock_user(name, pathname, 0);
6679
6680 /* man name_to_handle_at(2):
6681 * Other than the use of the handle_bytes field, the caller should treat
6682 * the file_handle structure as an opaque data type
6683 */
6684
6685 memcpy(target_fh, fh, total_size);
6686 target_fh->handle_bytes = tswap32(fh->handle_bytes);
6687 target_fh->handle_type = tswap32(fh->handle_type);
6688 g_free(fh);
6689 unlock_user(target_fh, handle, total_size);
6690
6691 if (put_user_s32(mid, mount_id)) {
6692 return -TARGET_EFAULT;
6693 }
6694
6695 return ret;
6696
6697}
6698#endif
6699
6700#if defined(TARGET_NR_open_by_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
6701static abi_long do_open_by_handle_at(abi_long mount_fd, abi_long handle,
6702 abi_long flags)
6703{
6704 struct file_handle *target_fh;
6705 struct file_handle *fh;
6706 unsigned int size, total_size;
6707 abi_long ret;
6708
6709 if (get_user_s32(size, handle)) {
6710 return -TARGET_EFAULT;
6711 }
6712
6713 total_size = sizeof(struct file_handle) + size;
6714 target_fh = lock_user(VERIFY_READ, handle, total_size, 1);
6715 if (!target_fh) {
6716 return -TARGET_EFAULT;
6717 }
6718
e9d49d51 6719 fh = g_memdup(target_fh, total_size);
0f0426f3
LV		 6720 fh->handle_bytes = size;
6721 fh->handle_type = tswap32(target_fh->handle_type);
6722
6723 ret = get_errno(open_by_handle_at(mount_fd, fh,
6724 target_to_host_bitmask(flags, fcntl_flags_tbl)));
6725
6726 g_free(fh);
6727
6728 unlock_user(target_fh, handle, total_size);
6729
6730 return ret;
6731}
6732#endif
bd0c5661 6733
e36800c9
LV		 6734#if defined(TARGET_NR_signalfd) || defined(TARGET_NR_signalfd4)
6735
6736/* signalfd siginfo conversion */
6737
6738static void
6739host_to_target_signalfd_siginfo(struct signalfd_siginfo *tinfo,
6740 const struct signalfd_siginfo *info)
6741{
6742 int sig = host_to_target_signal(info->ssi_signo);
6743
6744 /* linux/signalfd.h defines a ssi_addr_lsb
6745 * not defined in sys/signalfd.h but used by some kernels
6746 */
6747
6748#ifdef BUS_MCEERR_AO
6749 if (tinfo->ssi_signo == SIGBUS &&
6750 (tinfo->ssi_code == BUS_MCEERR_AR ||
6751 tinfo->ssi_code == BUS_MCEERR_AO)) {
6752 uint16_t *ssi_addr_lsb = (uint16_t *)(&info->ssi_addr + 1);
6753 uint16_t *tssi_addr_lsb = (uint16_t *)(&tinfo->ssi_addr + 1);
6754 *tssi_addr_lsb = tswap16(*ssi_addr_lsb);
6755 }
6756#endif
6757
6758 tinfo->ssi_signo = tswap32(sig);
6759 tinfo->ssi_errno = tswap32(tinfo->ssi_errno);
6760 tinfo->ssi_code = tswap32(info->ssi_code);
6761 tinfo->ssi_pid = tswap32(info->ssi_pid);
6762 tinfo->ssi_uid = tswap32(info->ssi_uid);
6763 tinfo->ssi_fd = tswap32(info->ssi_fd);
6764 tinfo->ssi_tid = tswap32(info->ssi_tid);
6765 tinfo->ssi_band = tswap32(info->ssi_band);
6766 tinfo->ssi_overrun = tswap32(info->ssi_overrun);
6767 tinfo->ssi_trapno = tswap32(info->ssi_trapno);
6768 tinfo->ssi_status = tswap32(info->ssi_status);
6769 tinfo->ssi_int = tswap32(info->ssi_int);
6770 tinfo->ssi_ptr = tswap64(info->ssi_ptr);
6771 tinfo->ssi_utime = tswap64(info->ssi_utime);
6772 tinfo->ssi_stime = tswap64(info->ssi_stime);
6773 tinfo->ssi_addr = tswap64(info->ssi_addr);
6774}
6775
5d4d3665 6776static abi_long host_to_target_data_signalfd(void *buf, size_t len)
e36800c9
LV		 6777{
6778 int i;
6779
6780 for (i = 0; i < len; i += sizeof(struct signalfd_siginfo)) {
6781 host_to_target_signalfd_siginfo(buf + i, buf + i);
6782 }
6783
6784 return len;
6785}
6786
6787static TargetFdTrans target_signalfd_trans = {
5d4d3665 6788 .host_to_target_data = host_to_target_data_signalfd,
e36800c9
LV		 6789};
6790
6791static abi_long do_signalfd4(int fd, abi_long mask, int flags)
6792{
6793 int host_flags;
6794 target_sigset_t *target_mask;
6795 sigset_t host_mask;
6796 abi_long ret;
6797
6798 if (flags & ~(TARGET_O_NONBLOCK | TARGET_O_CLOEXEC)) {
6799 return -TARGET_EINVAL;
6800 }
6801 if (!lock_user_struct(VERIFY_READ, target_mask, mask, 1)) {
6802 return -TARGET_EFAULT;
6803 }
6804
6805 target_to_host_sigset(&host_mask, target_mask);
6806
6807 host_flags = target_to_host_bitmask(flags, fcntl_flags_tbl);
6808
6809 ret = get_errno(signalfd(fd, &host_mask, host_flags));
6810 if (ret >= 0) {
6811 fd_trans_register(ret, &target_signalfd_trans);
6812 }
6813
6814 unlock_user_struct(target_mask, mask, 0);
6815
6816 return ret;
6817}
6818#endif
6819
1d9d8b55
PB		 6820/* Map host to target signal numbers for the wait family of syscalls.
6821 Assume all other status bits are the same. */
a05c6409 6822int host_to_target_waitstatus(int status)
1d9d8b55
PB		 6823{
6824 if (WIFSIGNALED(status)) {
6825 return host_to_target_signal(WTERMSIG(status)) | (status & ~0x7f);
6826 }
6827 if (WIFSTOPPED(status)) {
6828 return (host_to_target_signal(WSTOPSIG(status)) << 8)
6829 | (status & 0xff);
6830 }
6831 return status;
6832}
6833
76b94245
WVS		 6834static int open_self_cmdline(void *cpu_env, int fd)
6835{
6836 int fd_orig = -1;
6837 bool word_skipped = false;
6838
6839 fd_orig = open("/proc/self/cmdline", O_RDONLY);
6840 if (fd_orig < 0) {
6841 return fd_orig;
6842 }
6843
6844 while (true) {
6845 ssize_t nb_read;
6846 char buf[128];
6847 char *cp_buf = buf;
6848
6849 nb_read = read(fd_orig, buf, sizeof(buf));
6850 if (nb_read < 0) {
a3ca7bb2 6851 int e = errno;
76b94245 6852 fd_orig = close(fd_orig);
a3ca7bb2 6853 errno = e;
76b94245
WVS		 6854 return -1;
6855 } else if (nb_read == 0) {
6856 break;
6857 }
6858
6859 if (!word_skipped) {
6860 /* Skip the first string, which is the path to qemu-*-static
6861 instead of the actual command. */
ba4b3f66 6862 cp_buf = memchr(buf, 0, nb_read);
76b94245
WVS		 6863 if (cp_buf) {
6864 /* Null byte found, skip one string */
6865 cp_buf++;
6866 nb_read -= cp_buf - buf;
6867 word_skipped = true;
6868 }
6869 }
6870
6871 if (word_skipped) {
6872 if (write(fd, cp_buf, nb_read) != nb_read) {
a3ca7bb2 6873 int e = errno;
680dfde9 6874 close(fd_orig);
a3ca7bb2 6875 errno = e;
76b94245
WVS		 6876 return -1;
6877 }
6878 }
6879 }
6880
6881 return close(fd_orig);
6882}
6883
36c08d49
AG		 6884static int open_self_maps(void *cpu_env, int fd)
6885{
0429a971
AF		 6886 CPUState *cpu = ENV_GET_CPU((CPUArchState *)cpu_env);
6887 TaskState *ts = cpu->opaque;
1a49ef2a
AG		 6888 FILE *fp;
6889 char *line = NULL;
6890 size_t len = 0;
6891 ssize_t read;
6892
6893 fp = fopen("/proc/self/maps", "r");
6894 if (fp == NULL) {
a3ca7bb2 6895 return -1;
1a49ef2a 6896 }
36c08d49 6897
1a49ef2a
AG		 6898 while ((read = getline(&line, &len, fp)) != -1) {
6899 int fields, dev_maj, dev_min, inode;
6900 uint64_t min, max, offset;
6901 char flag_r, flag_w, flag_x, flag_p;
6902 char path[512] = "";
6903 fields = sscanf(line, "%"PRIx64"-%"PRIx64" %c%c%c%c %"PRIx64" %x:%x %d"
6904 " %512s", &min, &max, &flag_r, &flag_w, &flag_x,
6905 &flag_p, &offset, &dev_maj, &dev_min, &inode, path);
6906
6907 if ((fields < 10) || (fields > 11)) {
6908 continue;
6909 }
d67f4aaa
MI		 6910 if (h2g_valid(min)) {
6911 int flags = page_get_flags(h2g(min));
6912 max = h2g_valid(max - 1) ? max : (uintptr_t)g2h(GUEST_ADDR_MAX);
6913 if (page_check_range(h2g(min), max - min, flags) == -1) {
6914 continue;
6915 }
6916 if (h2g(min) == ts->info->stack_limit) {
6917 pstrcpy(path, sizeof(path), " [stack]");
6918 }
1a49ef2a 6919 dprintf(fd, TARGET_ABI_FMT_lx "-" TARGET_ABI_FMT_lx
e24fed4e 6920 " %c%c%c%c %08" PRIx64 " %02x:%02x %d %s%s\n",
d67f4aaa 6921 h2g(min), h2g(max - 1) + 1, flag_r, flag_w,
1a49ef2a 6922 flag_x, flag_p, offset, dev_maj, dev_min, inode,
e24fed4e 6923 path[0] ? " " : "", path);
1a49ef2a
AG		 6924 }
6925 }
6926
6927 free(line);
6928 fclose(fp);
6929
36c08d49
AG		 6930 return 0;
6931}
6932
480b8e7d
AG		 6933static int open_self_stat(void *cpu_env, int fd)
6934{
0429a971
AF		 6935 CPUState *cpu = ENV_GET_CPU((CPUArchState *)cpu_env);
6936 TaskState *ts = cpu->opaque;
480b8e7d
AG		 6937 abi_ulong start_stack = ts->info->start_stack;
6938 int i;
6939
6940 for (i = 0; i < 44; i++) {
6941 char buf[128];
6942 int len;
6943 uint64_t val = 0;
6944
e0e65bee
FE		 6945 if (i == 0) {
6946 /* pid */
6947 val = getpid();
6948 snprintf(buf, sizeof(buf), "%"PRId64 " ", val);
6949 } else if (i == 1) {
6950 /* app name */
6951 snprintf(buf, sizeof(buf), "(%s) ", ts->bprm->argv[0]);
6952 } else if (i == 27) {
6953 /* stack bottom */
6954 val = start_stack;
6955 snprintf(buf, sizeof(buf), "%"PRId64 " ", val);
6956 } else {
6957 /* for the rest, there is MasterCard */
6958 snprintf(buf, sizeof(buf), "0%c", i == 43 ? '\n' : ' ');
480b8e7d 6959 }
e0e65bee 6960
480b8e7d
AG		 6961 len = strlen(buf);
6962 if (write(fd, buf, len) != len) {
6963 return -1;
6964 }
6965 }
6966
6967 return 0;
6968}
6969
257450ee
AG		 6970static int open_self_auxv(void *cpu_env, int fd)
6971{
0429a971
AF		 6972 CPUState *cpu = ENV_GET_CPU((CPUArchState *)cpu_env);
6973 TaskState *ts = cpu->opaque;
257450ee
AG		 6974 abi_ulong auxv = ts->info->saved_auxv;
6975 abi_ulong len = ts->info->auxv_len;
6976 char *ptr;
6977
6978 /*
6979 * Auxiliary vector is stored in target process stack.
6980 * read in whole auxv vector and copy it to file
6981 */
6982 ptr = lock_user(VERIFY_READ, auxv, len, 0);
6983 if (ptr != NULL) {
6984 while (len > 0) {
6985 ssize_t r;
6986 r = write(fd, ptr, len);
6987 if (r <= 0) {
6988 break;
6989 }
6990 len -= r;
6991 ptr += r;
6992 }
6993 lseek(fd, 0, SEEK_SET);
6994 unlock_user(ptr, auxv, len);
6995 }
6996
6997 return 0;
6998}
6999
463d8e73
AS		 7000static int is_proc_myself(const char *filename, const char *entry)
7001{
7002 if (!strncmp(filename, "/proc/", strlen("/proc/"))) {
7003 filename += strlen("/proc/");
7004 if (!strncmp(filename, "self/", strlen("self/"))) {
7005 filename += strlen("self/");
7006 } else if (*filename >= '1' && *filename <= '9') {
7007 char myself[80];
7008 snprintf(myself, sizeof(myself), "%d/", getpid());
7009 if (!strncmp(filename, myself, strlen(myself))) {
7010 filename += strlen(myself);
7011 } else {
7012 return 0;
7013 }
7014 } else {
7015 return 0;
7016 }
7017 if (!strcmp(filename, entry)) {
7018 return 1;
7019 }
7020 }
7021 return 0;
7022}
7023
de6b9933
LV		 7024#if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
7025static int is_proc(const char *filename, const char *entry)
7026{
7027 return strcmp(filename, entry) == 0;
7028}
7029
7030static int open_net_route(void *cpu_env, int fd)
7031{
7032 FILE *fp;
7033 char *line = NULL;
7034 size_t len = 0;
7035 ssize_t read;
7036
7037 fp = fopen("/proc/net/route", "r");
7038 if (fp == NULL) {
a3ca7bb2 7039 return -1;
de6b9933
LV		 7040 }
7041
7042 /* read header */
7043
7044 read = getline(&line, &len, fp);
7045 dprintf(fd, "%s", line);
7046
7047 /* read routes */
7048
7049 while ((read = getline(&line, &len, fp)) != -1) {
7050 char iface[16];
7051 uint32_t dest, gw, mask;
7052 unsigned int flags, refcnt, use, metric, mtu, window, irtt;
7053 sscanf(line, "%s\t%08x\t%08x\t%04x\t%d\t%d\t%d\t%08x\t%d\t%u\t%u\n",
7054 iface, &dest, &gw, &flags, &refcnt, &use, &metric,
7055 &mask, &mtu, &window, &irtt);
7056 dprintf(fd, "%s\t%08x\t%08x\t%04x\t%d\t%d\t%d\t%08x\t%d\t%u\t%u\n",
7057 iface, tswap32(dest), tswap32(gw), flags, refcnt, use,
7058 metric, tswap32(mask), mtu, window, irtt);
7059 }
7060
7061 free(line);
7062 fclose(fp);
7063
7064 return 0;
7065}
7066#endif
7067
0b2effd7 7068static int do_openat(void *cpu_env, int dirfd, const char *pathname, int flags, mode_t mode)
3be14d05
AG		 7069{
7070 struct fake_open {
7071 const char *filename;
7072 int (*fill)(void *cpu_env, int fd);
de6b9933 7073 int (*cmp)(const char *s1, const char *s2);
3be14d05
AG		 7074 };
7075 const struct fake_open *fake_open;
7076 static const struct fake_open fakes[] = {
de6b9933
LV		 7077 { "maps", open_self_maps, is_proc_myself },
7078 { "stat", open_self_stat, is_proc_myself },
7079 { "auxv", open_self_auxv, is_proc_myself },
76b94245 7080 { "cmdline", open_self_cmdline, is_proc_myself },
de6b9933
LV		 7081#if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
7082 { "/proc/net/route", open_net_route, is_proc },
7083#endif
7084 { NULL, NULL, NULL }
3be14d05
AG		 7085 };
7086
aa07f5ec
MO		 7087 if (is_proc_myself(pathname, "exe")) {
7088 int execfd = qemu_getauxval(AT_EXECFD);
c10a0738 7089 return execfd ? execfd : safe_openat(dirfd, exec_path, flags, mode);
aa07f5ec
MO		 7090 }
7091
3be14d05 7092 for (fake_open = fakes; fake_open->filename; fake_open++) {
de6b9933 7093 if (fake_open->cmp(pathname, fake_open->filename)) {
3be14d05
AG		 7094 break;
7095 }
7096 }
7097
7098 if (fake_open->filename) {
7099 const char *tmpdir;
7100 char filename[PATH_MAX];
7101 int fd, r;
7102
7103 /* create temporary file to map stat to */
7104 tmpdir = getenv("TMPDIR");
7105 if (!tmpdir)
7106 tmpdir = "/tmp";
7107 snprintf(filename, sizeof(filename), "%s/qemu-open.XXXXXX", tmpdir);
7108 fd = mkstemp(filename);
7109 if (fd < 0) {
7110 return fd;
7111 }
7112 unlink(filename);
7113
7114 if ((r = fake_open->fill(cpu_env, fd))) {
a3ca7bb2 7115 int e = errno;
3be14d05 7116 close(fd);
a3ca7bb2 7117 errno = e;
3be14d05
AG		 7118 return r;
7119 }
7120 lseek(fd, 0, SEEK_SET);
7121
7122 return fd;
7123 }
7124
c10a0738 7125 return safe_openat(dirfd, path(pathname), flags, mode);
3be14d05
AG		 7126}
7127
aecc8861
AG		 7128#define TIMER_MAGIC 0x0caf0000
7129#define TIMER_MAGIC_MASK 0xffff0000
7130
7131/* Convert QEMU provided timer ID back to internal 16bit index format */
7132static target_timer_t get_timer_id(abi_long arg)
7133{
7134 target_timer_t timerid = arg;
7135
7136 if ((timerid & TIMER_MAGIC_MASK) != TIMER_MAGIC) {
7137 return -TARGET_EINVAL;
7138 }
7139
7140 timerid &= 0xffff;
7141
7142 if (timerid >= ARRAY_SIZE(g_posix_timers)) {
7143 return -TARGET_EINVAL;
7144 }
7145
7146 return timerid;
7147}
7148
0da46a6e
TS		 7149/* do_syscall() should always have a single exit point at the end so
7150 that actions, such as logging of syscall results, can be performed.
7151 All errnos that do_syscall() returns must be -TARGET_<errcode>. */
992f48a0
BS		 7152abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
7153 abi_long arg2, abi_long arg3, abi_long arg4,
5945cfcb
PM		 7154 abi_long arg5, abi_long arg6, abi_long arg7,
7155 abi_long arg8)
31e31b8a 7156{
182735ef 7157 CPUState *cpu = ENV_GET_CPU(cpu_env);
992f48a0 7158 abi_long ret;
31e31b8a 7159 struct stat st;
56c8f68f 7160 struct statfs stfs;
53a5960a 7161 void *p;
3b46e624 7162
71a8f7fe
TB		 7163#if defined(DEBUG_ERESTARTSYS)
7164 /* Debug-only code for exercising the syscall-restart code paths
7165 * in the per-architecture cpu main loops: restart every syscall
7166 * the guest makes once before letting it through.
7167 */
7168 {
7169 static int flag;
7170
7171 flag = !flag;
7172 if (flag) {
7173 return -TARGET_ERESTARTSYS;
7174 }
7175 }
7176#endif
7177
72f03900 7178#ifdef DEBUG
c573ff67 7179 gemu_log("syscall %d", num);
72f03900 7180#endif
9c15e700 7181 trace_guest_user_syscall(cpu, num, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
b92c47c1
TS		 7182 if(do_strace)
7183 print_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
7184
31e31b8a
FB		 7185 switch(num) {
7186 case TARGET_NR_exit:
9b056fcc
AF		 7187 /* In old applications this may be used to implement _exit(2).
7188 However in threaded applictions it is used for thread termination,
7189 and _exit_group is used for application termination.
7190 Do thread termination if we have more then one thread. */
a0995886
TB		 7191
7192 if (block_signals()) {
7193 ret = -TARGET_ERESTARTSYS;
7194 break;
7195 }
7196
bdc44640 7197 if (CPU_NEXT(first_cpu)) {
9b056fcc 7198 TaskState *ts;
9b056fcc
AF		 7199
7200 cpu_list_lock();
9b056fcc 7201 /* Remove the CPU from the list. */
bdc44640 7202 QTAILQ_REMOVE(&cpus, cpu, node);
9b056fcc 7203 cpu_list_unlock();
0429a971 7204 ts = cpu->opaque;
9b056fcc
AF		 7205 if (ts->child_tidptr) {
7206 put_user_u32(0, ts->child_tidptr);
7207 sys_futex(g2h(ts->child_tidptr), FUTEX_WAKE, INT_MAX,
7208 NULL, NULL, 0);
7209 }
a2247f8e 7210 thread_cpu = NULL;
0429a971 7211 object_unref(OBJECT(cpu));
9b056fcc 7212 g_free(ts);
70903763 7213 rcu_unregister_thread();
9b056fcc
AF		 7214 pthread_exit(NULL);
7215 }
9788c9ca 7216#ifdef TARGET_GPROF
7d13299d
FB		 7217 _mcleanup();
7218#endif
e9009676 7219 gdb_exit(cpu_env, arg1);
c2764719 7220 _exit(arg1);
31e31b8a
FB		 7221 ret = 0; /* avoid warning */
7222 break;
7223 case TARGET_NR_read:
38d840e6
AJ		 7224 if (arg3 == 0)
7225 ret = 0;
7226 else {
7227 if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
7228 goto efault;
50afd02b 7229 ret = get_errno(safe_read(arg1, p, arg3));
e36800c9 7230 if (ret >= 0 &&
5d4d3665
LV		 7231 fd_trans_host_to_target_data(arg1)) {
7232 ret = fd_trans_host_to_target_data(arg1)(p, ret);
e36800c9 7233 }
38d840e6
AJ		 7234 unlock_user(p, arg2, ret);
7235 }
31e31b8a
FB		 7236 break;
7237 case TARGET_NR_write:
579a97f7
FB		 7238 if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
7239 goto efault;
50afd02b 7240 ret = get_errno(safe_write(arg1, p, arg3));
53a5960a 7241 unlock_user(p, arg2, 0);
31e31b8a 7242 break;
704eff6c 7243#ifdef TARGET_NR_open
31e31b8a 7244 case TARGET_NR_open:
2f619698
FB		 7245 if (!(p = lock_user_string(arg1)))
7246 goto efault;
0b2effd7
RV		 7247 ret = get_errno(do_openat(cpu_env, AT_FDCWD, p,
7248 target_to_host_bitmask(arg2, fcntl_flags_tbl),
7249 arg3));
e36800c9 7250 fd_trans_unregister(ret);
53a5960a 7251 unlock_user(p, arg1, 0);
31e31b8a 7252 break;
704eff6c 7253#endif
82424832 7254 case TARGET_NR_openat:
579a97f7
FB		 7255 if (!(p = lock_user_string(arg2)))
7256 goto efault;
0b2effd7
RV		 7257 ret = get_errno(do_openat(cpu_env, arg1, p,
7258 target_to_host_bitmask(arg3, fcntl_flags_tbl),
7259 arg4));
e36800c9 7260 fd_trans_unregister(ret);
579a97f7 7261 unlock_user(p, arg2, 0);
82424832 7262 break;
0f0426f3
LV		 7263#if defined(TARGET_NR_name_to_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
7264 case TARGET_NR_name_to_handle_at:
7265 ret = do_name_to_handle_at(arg1, arg2, arg3, arg4, arg5);
7266 break;
7267#endif
7268#if defined(TARGET_NR_open_by_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)
7269 case TARGET_NR_open_by_handle_at:
7270 ret = do_open_by_handle_at(arg1, arg2, arg3);
e36800c9 7271 fd_trans_unregister(ret);
0f0426f3
LV		 7272 break;
7273#endif
31e31b8a 7274 case TARGET_NR_close:
e36800c9 7275 fd_trans_unregister(arg1);
31e31b8a
FB		 7276 ret = get_errno(close(arg1));
7277 break;
7278 case TARGET_NR_brk:
53a5960a 7279 ret = do_brk(arg1);
31e31b8a 7280 break;
704eff6c 7281#ifdef TARGET_NR_fork
31e31b8a 7282 case TARGET_NR_fork:
d865bab5 7283 ret = get_errno(do_fork(cpu_env, SIGCHLD, 0, 0, 0, 0));
31e31b8a 7284 break;
704eff6c 7285#endif
e5febef5 7286#ifdef TARGET_NR_waitpid
31e31b8a
FB		 7287 case TARGET_NR_waitpid:
7288 {
53a5960a 7289 int status;
4af80a37 7290 ret = get_errno(safe_wait4(arg1, &status, arg3, 0));
5379557b 7291 if (!is_error(ret) && arg2 && ret
1d9d8b55 7292 && put_user_s32(host_to_target_waitstatus(status), arg2))
2f619698 7293 goto efault;
31e31b8a
FB		 7294 }
7295 break;
e5febef5 7296#endif
f0cbb613
PB		 7297#ifdef TARGET_NR_waitid
7298 case TARGET_NR_waitid:
7299 {
7300 siginfo_t info;
7301 info.si_pid = 0;
4af80a37 7302 ret = get_errno(safe_waitid(arg1, arg2, &info, arg4, NULL));
f0cbb613 7303 if (!is_error(ret) && arg3 && info.si_pid != 0) {
c227f099 7304 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_siginfo_t), 0)))
f0cbb613
PB		 7305 goto efault;
7306 host_to_target_siginfo(p, &info);
c227f099 7307 unlock_user(p, arg3, sizeof(target_siginfo_t));
f0cbb613
PB		 7308 }
7309 }
7310 break;
7311#endif
7a3148a9 7312#ifdef TARGET_NR_creat /* not on alpha */
31e31b8a 7313 case TARGET_NR_creat:
579a97f7
FB		 7314 if (!(p = lock_user_string(arg1)))
7315 goto efault;
53a5960a 7316 ret = get_errno(creat(p, arg2));
e36800c9 7317 fd_trans_unregister(ret);
53a5960a 7318 unlock_user(p, arg1, 0);
31e31b8a 7319 break;
7a3148a9 7320#endif
704eff6c 7321#ifdef TARGET_NR_link
31e31b8a 7322 case TARGET_NR_link:
53a5960a
PB		 7323 {
7324 void * p2;
7325 p = lock_user_string(arg1);
7326 p2 = lock_user_string(arg2);
579a97f7
FB		 7327 if (!p || !p2)
7328 ret = -TARGET_EFAULT;
7329 else
7330 ret = get_errno(link(p, p2));
53a5960a
PB		 7331 unlock_user(p2, arg2, 0);
7332 unlock_user(p, arg1, 0);
7333 }
31e31b8a 7334 break;
704eff6c 7335#endif
c0d472b1 7336#if defined(TARGET_NR_linkat)
64f0ce4c 7337 case TARGET_NR_linkat:
64f0ce4c
TS		 7338 {
7339 void * p2 = NULL;
579a97f7
FB		 7340 if (!arg2 || !arg4)
7341 goto efault;
64f0ce4c
TS		 7342 p = lock_user_string(arg2);
7343 p2 = lock_user_string(arg4);
579a97f7 7344 if (!p || !p2)
0da46a6e 7345 ret = -TARGET_EFAULT;
64f0ce4c 7346 else
c0d472b1 7347 ret = get_errno(linkat(arg1, p, arg3, p2, arg5));
579a97f7
FB		 7348 unlock_user(p, arg2, 0);
7349 unlock_user(p2, arg4, 0);
64f0ce4c
TS		 7350 }
7351 break;
7352#endif
704eff6c 7353#ifdef TARGET_NR_unlink
31e31b8a 7354 case TARGET_NR_unlink:
579a97f7
FB		 7355 if (!(p = lock_user_string(arg1)))
7356 goto efault;
53a5960a
PB		 7357 ret = get_errno(unlink(p));
7358 unlock_user(p, arg1, 0);
31e31b8a 7359 break;
704eff6c 7360#endif
c0d472b1 7361#if defined(TARGET_NR_unlinkat)
8170f56b 7362 case TARGET_NR_unlinkat:
579a97f7
FB		 7363 if (!(p = lock_user_string(arg2)))
7364 goto efault;
c0d472b1 7365 ret = get_errno(unlinkat(arg1, p, arg3));
579a97f7 7366 unlock_user(p, arg2, 0);
ed494d87 7367 break;
b7d35e65 7368#endif
31e31b8a 7369 case TARGET_NR_execve:
7854b056
FB		 7370 {
7371 char **argp, **envp;
f7341ff4 7372 int argc, envc;
992f48a0
BS		 7373 abi_ulong gp;
7374 abi_ulong guest_argp;
7375 abi_ulong guest_envp;
7376 abi_ulong addr;
7854b056 7377 char **q;
a6f79cc9 7378 int total_size = 0;
7854b056 7379
f7341ff4 7380 argc = 0;
53a5960a 7381 guest_argp = arg2;
da94d263 7382 for (gp = guest_argp; gp; gp += sizeof(abi_ulong)) {
03aa1976 7383 if (get_user_ual(addr, gp))
2f619698 7384 goto efault;
03aa1976 7385 if (!addr)
2f619698 7386 break;
7854b056 7387 argc++;
2f619698 7388 }
f7341ff4 7389 envc = 0;
53a5960a 7390 guest_envp = arg3;
da94d263 7391 for (gp = guest_envp; gp; gp += sizeof(abi_ulong)) {
03aa1976 7392 if (get_user_ual(addr, gp))
2f619698 7393 goto efault;
03aa1976 7394 if (!addr)
2f619698 7395 break;
7854b056 7396 envc++;
2f619698 7397 }
7854b056 7398
f7341ff4
FB		 7399 argp = alloca((argc + 1) * sizeof(void *));
7400 envp = alloca((envc + 1) * sizeof(void *));
7854b056 7401
da94d263 7402 for (gp = guest_argp, q = argp; gp;
992f48a0 7403 gp += sizeof(abi_ulong), q++) {
2f619698
FB		 7404 if (get_user_ual(addr, gp))
7405 goto execve_efault;
53a5960a
PB		 7406 if (!addr)
7407 break;
2f619698
FB		 7408 if (!(*q = lock_user_string(addr)))
7409 goto execve_efault;
a6f79cc9 7410 total_size += strlen(*q) + 1;
53a5960a 7411 }
f7341ff4
FB		 7412 *q = NULL;
7413
da94d263 7414 for (gp = guest_envp, q = envp; gp;
992f48a0 7415 gp += sizeof(abi_ulong), q++) {
2f619698
FB		 7416 if (get_user_ual(addr, gp))
7417 goto execve_efault;
53a5960a
PB		 7418 if (!addr)
7419 break;
2f619698
FB		 7420 if (!(*q = lock_user_string(addr)))
7421 goto execve_efault;
a6f79cc9 7422 total_size += strlen(*q) + 1;
53a5960a 7423 }
f7341ff4 7424 *q = NULL;
7854b056 7425
2f619698
FB		 7426 if (!(p = lock_user_string(arg1)))
7427 goto execve_efault;
ffdcbe22
TB		 7428 /* Although execve() is not an interruptible syscall it is
7429 * a special case where we must use the safe_syscall wrapper:
7430 * if we allow a signal to happen before we make the host
7431 * syscall then we will 'lose' it, because at the point of
7432 * execve the process leaves QEMU's control. So we use the
7433 * safe syscall wrapper to ensure that we either take the
7434 * signal as a guest signal, or else it does not happen
7435 * before the execve completes and makes it the other
7436 * program's problem.
7437 */
7438 ret = get_errno(safe_execve(p, argp, envp));
53a5960a
PB		 7439 unlock_user(p, arg1, 0);
7440
2f619698
FB		 7441 goto execve_end;
7442
7443 execve_efault:
7444 ret = -TARGET_EFAULT;
7445
7446 execve_end:
53a5960a 7447 for (gp = guest_argp, q = argp; *q;
992f48a0 7448 gp += sizeof(abi_ulong), q++) {
2f619698
FB		 7449 if (get_user_ual(addr, gp)
7450 || !addr)
7451 break;
53a5960a
PB		 7452 unlock_user(*q, addr, 0);
7453 }
7454 for (gp = guest_envp, q = envp; *q;
992f48a0 7455 gp += sizeof(abi_ulong), q++) {
2f619698
FB		 7456 if (get_user_ual(addr, gp)
7457 || !addr)
7458 break;
53a5960a
PB		 7459 unlock_user(*q, addr, 0);
7460 }
7854b056 7461 }
31e31b8a
FB		 7462 break;
7463 case TARGET_NR_chdir:
579a97f7
FB		 7464 if (!(p = lock_user_string(arg1)))
7465 goto efault;
53a5960a
PB		 7466 ret = get_errno(chdir(p));
7467 unlock_user(p, arg1, 0);
31e31b8a 7468 break;
a315a145 7469#ifdef TARGET_NR_time
31e31b8a
FB		 7470 case TARGET_NR_time:
7471 {
53a5960a
PB		 7472 time_t host_time;
7473 ret = get_errno(time(&host_time));
2f619698
FB		 7474 if (!is_error(ret)
7475 && arg1
7476 && put_user_sal(host_time, arg1))
7477 goto efault;
31e31b8a
FB		 7478 }
7479 break;
a315a145 7480#endif
704eff6c 7481#ifdef TARGET_NR_mknod
31e31b8a 7482 case TARGET_NR_mknod:
579a97f7
FB		 7483 if (!(p = lock_user_string(arg1)))
7484 goto efault;
53a5960a
PB		 7485 ret = get_errno(mknod(p, arg2, arg3));
7486 unlock_user(p, arg1, 0);
31e31b8a 7487 break;
704eff6c 7488#endif
c0d472b1 7489#if defined(TARGET_NR_mknodat)
75ac37a0 7490 case TARGET_NR_mknodat:
579a97f7
FB		 7491 if (!(p = lock_user_string(arg2)))
7492 goto efault;
c0d472b1 7493 ret = get_errno(mknodat(arg1, p, arg3, arg4));
579a97f7 7494 unlock_user(p, arg2, 0);
75ac37a0
TS		 7495 break;
7496#endif
704eff6c 7497#ifdef TARGET_NR_chmod
31e31b8a 7498 case TARGET_NR_chmod:
579a97f7
FB		 7499 if (!(p = lock_user_string(arg1)))
7500 goto efault;
53a5960a
PB		 7501 ret = get_errno(chmod(p, arg2));
7502 unlock_user(p, arg1, 0);
31e31b8a 7503 break;
704eff6c 7504#endif
ebc05488 7505#ifdef TARGET_NR_break
31e31b8a
FB		 7506 case TARGET_NR_break:
7507 goto unimplemented;
ebc05488
FB		 7508#endif
7509#ifdef TARGET_NR_oldstat
31e31b8a
FB		 7510 case TARGET_NR_oldstat:
7511 goto unimplemented;
ebc05488 7512#endif
31e31b8a
FB		 7513 case TARGET_NR_lseek:
7514 ret = get_errno(lseek(arg1, arg2, arg3));
7515 break;
9231733a
RH		 7516#if defined(TARGET_NR_getxpid) && defined(TARGET_ALPHA)
7517 /* Alpha specific */
7a3148a9 7518 case TARGET_NR_getxpid:
9231733a
RH		 7519 ((CPUAlphaState *)cpu_env)->ir[IR_A4] = getppid();
7520 ret = get_errno(getpid());
7521 break;
7a3148a9 7522#endif
9231733a
RH		 7523#ifdef TARGET_NR_getpid
7524 case TARGET_NR_getpid:
31e31b8a
FB		 7525 ret = get_errno(getpid());
7526 break;
9231733a 7527#endif
31e31b8a 7528 case TARGET_NR_mount:
356d771b
PB		 7529 {
7530 /* need to look at the data field */
7531 void *p2, *p3;
7532
7533 if (arg1) {
7534 p = lock_user_string(arg1);
7535 if (!p) {
7536 goto efault;
7537 }
7538 } else {
7539 p = NULL;
7540 }
7541
7542 p2 = lock_user_string(arg2);
7543 if (!p2) {
7544 if (arg1) {
7545 unlock_user(p, arg1, 0);
7546 }
7547 goto efault;
7548 }
7549
7550 if (arg3) {
7551 p3 = lock_user_string(arg3);
7552 if (!p3) {
7553 if (arg1) {
579a97f7 7554 unlock_user(p, arg1, 0);
356d771b
PB		 7555 }
7556 unlock_user(p2, arg2, 0);
7557 goto efault;
7558 }
7559 } else {
7560 p3 = NULL;
7561 }
7562
7563 /* FIXME - arg5 should be locked, but it isn't clear how to
7564 * do that since it's not guaranteed to be a NULL-terminated
7565 * string.
7566 */
7567 if (!arg5) {
7568 ret = mount(p, p2, p3, (unsigned long)arg4, NULL);
7569 } else {
7570 ret = mount(p, p2, p3, (unsigned long)arg4, g2h(arg5));
7571 }
7572 ret = get_errno(ret);
7573
7574 if (arg1) {
7575 unlock_user(p, arg1, 0);
7576 }
7577 unlock_user(p2, arg2, 0);
7578 if (arg3) {
7579 unlock_user(p3, arg3, 0);
7580 }
7581 }
7582 break;
e5febef5 7583#ifdef TARGET_NR_umount
31e31b8a 7584 case TARGET_NR_umount:
579a97f7
FB		 7585 if (!(p = lock_user_string(arg1)))
7586 goto efault;
53a5960a
PB		 7587 ret = get_errno(umount(p));
7588 unlock_user(p, arg1, 0);
31e31b8a 7589 break;
e5febef5 7590#endif
7a3148a9 7591#ifdef TARGET_NR_stime /* not on alpha */
31e31b8a
FB		 7592 case TARGET_NR_stime:
7593 {
53a5960a 7594 time_t host_time;
2f619698
FB		 7595 if (get_user_sal(host_time, arg1))
7596 goto efault;
53a5960a 7597 ret = get_errno(stime(&host_time));
31e31b8a
FB		 7598 }
7599 break;
7a3148a9 7600#endif
31e31b8a
FB		 7601 case TARGET_NR_ptrace:
7602 goto unimplemented;
7a3148a9 7603#ifdef TARGET_NR_alarm /* not on alpha */
31e31b8a
FB		 7604 case TARGET_NR_alarm:
7605 ret = alarm(arg1);
7606 break;
7a3148a9 7607#endif
ebc05488 7608#ifdef TARGET_NR_oldfstat
31e31b8a
FB		 7609 case TARGET_NR_oldfstat:
7610 goto unimplemented;
ebc05488 7611#endif
7a3148a9 7612#ifdef TARGET_NR_pause /* not on alpha */
31e31b8a 7613 case TARGET_NR_pause:
f59ec606
TB		 7614 if (!block_signals()) {
7615 sigsuspend(&((TaskState *)cpu->opaque)->signal_mask);
7616 }
7617 ret = -TARGET_EINTR;
31e31b8a 7618 break;
7a3148a9 7619#endif
e5febef5 7620#ifdef TARGET_NR_utime
31e31b8a 7621 case TARGET_NR_utime:
ebc05488 7622 {
53a5960a
PB		 7623 struct utimbuf tbuf, *host_tbuf;
7624 struct target_utimbuf *target_tbuf;
7625 if (arg2) {
579a97f7
FB		 7626 if (!lock_user_struct(VERIFY_READ, target_tbuf, arg2, 1))
7627 goto efault;
cbb21eed
MB		 7628 tbuf.actime = tswapal(target_tbuf->actime);
7629 tbuf.modtime = tswapal(target_tbuf->modtime);
53a5960a
PB		 7630 unlock_user_struct(target_tbuf, arg2, 0);
7631 host_tbuf = &tbuf;
f72e8ff4 7632 } else {
53a5960a 7633 host_tbuf = NULL;
f72e8ff4 7634 }
579a97f7
FB		 7635 if (!(p = lock_user_string(arg1)))
7636 goto efault;
53a5960a
PB		 7637 ret = get_errno(utime(p, host_tbuf));
7638 unlock_user(p, arg1, 0);
ebc05488
FB		 7639 }
7640 break;
e5febef5 7641#endif
704eff6c 7642#ifdef TARGET_NR_utimes
978a66ff
FB		 7643 case TARGET_NR_utimes:
7644 {
978a66ff 7645 struct timeval *tvp, tv[2];
53a5960a 7646 if (arg2) {
788f5ec4
TS		 7647 if (copy_from_user_timeval(&tv[0], arg2)
7648 || copy_from_user_timeval(&tv[1],
7649 arg2 + sizeof(struct target_timeval)))
7650 goto efault;
978a66ff
FB		 7651 tvp = tv;
7652 } else {
7653 tvp = NULL;
7654 }
579a97f7
FB		 7655 if (!(p = lock_user_string(arg1)))
7656 goto efault;
53a5960a
PB		 7657 ret = get_errno(utimes(p, tvp));
7658 unlock_user(p, arg1, 0);
978a66ff
FB		 7659 }
7660 break;
704eff6c 7661#endif
c0d472b1 7662#if defined(TARGET_NR_futimesat)
ac8a6556
AZ		 7663 case TARGET_NR_futimesat:
7664 {
7665 struct timeval *tvp, tv[2];
7666 if (arg3) {
7667 if (copy_from_user_timeval(&tv[0], arg3)
7668 || copy_from_user_timeval(&tv[1],
7669 arg3 + sizeof(struct target_timeval)))
7670 goto efault;
7671 tvp = tv;
7672 } else {
7673 tvp = NULL;
7674 }
7675 if (!(p = lock_user_string(arg2)))
7676 goto efault;
c0d472b1 7677 ret = get_errno(futimesat(arg1, path(p), tvp));
ac8a6556
AZ		 7678 unlock_user(p, arg2, 0);
7679 }
7680 break;
7681#endif
ebc05488 7682#ifdef TARGET_NR_stty
31e31b8a
FB		 7683 case TARGET_NR_stty:
7684 goto unimplemented;
ebc05488
FB		 7685#endif
7686#ifdef TARGET_NR_gtty
31e31b8a
FB		 7687 case TARGET_NR_gtty:
7688 goto unimplemented;
ebc05488 7689#endif
704eff6c 7690#ifdef TARGET_NR_access
31e31b8a 7691 case TARGET_NR_access:
579a97f7
FB		 7692 if (!(p = lock_user_string(arg1)))
7693 goto efault;
719f908e 7694 ret = get_errno(access(path(p), arg2));
53a5960a 7695 unlock_user(p, arg1, 0);
31e31b8a 7696 break;
704eff6c 7697#endif
92a34c10
TS		 7698#if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
7699 case TARGET_NR_faccessat:
579a97f7
FB		 7700 if (!(p = lock_user_string(arg2)))
7701 goto efault;
c0d472b1 7702 ret = get_errno(faccessat(arg1, p, arg3, 0));
579a97f7 7703 unlock_user(p, arg2, 0);
92a34c10
TS		 7704 break;
7705#endif
7a3148a9 7706#ifdef TARGET_NR_nice /* not on alpha */
31e31b8a
FB		 7707 case TARGET_NR_nice:
7708 ret = get_errno(nice(arg1));
7709 break;
7a3148a9 7710#endif
ebc05488 7711#ifdef TARGET_NR_ftime
31e31b8a
FB		 7712 case TARGET_NR_ftime:
7713 goto unimplemented;
ebc05488 7714#endif
31e31b8a 7715 case TARGET_NR_sync:
04369ff2
FB		 7716 sync();
7717 ret = 0;
31e31b8a
FB		 7718 break;
7719 case TARGET_NR_kill:
bef653d9 7720 ret = get_errno(safe_kill(arg1, target_to_host_signal(arg2)));
31e31b8a 7721 break;
704eff6c 7722#ifdef TARGET_NR_rename
31e31b8a 7723 case TARGET_NR_rename:
53a5960a
PB		 7724 {
7725 void *p2;
7726 p = lock_user_string(arg1);
7727 p2 = lock_user_string(arg2);
579a97f7
FB		 7728 if (!p || !p2)
7729 ret = -TARGET_EFAULT;
7730 else
7731 ret = get_errno(rename(p, p2));
53a5960a
PB		 7732 unlock_user(p2, arg2, 0);
7733 unlock_user(p, arg1, 0);
7734 }
31e31b8a 7735 break;
704eff6c 7736#endif
c0d472b1 7737#if defined(TARGET_NR_renameat)
722183f6 7738 case TARGET_NR_renameat:
722183f6 7739 {
579a97f7 7740 void *p2;
722183f6
TS		 7741 p = lock_user_string(arg2);
7742 p2 = lock_user_string(arg4);
579a97f7 7743 if (!p || !p2)
0da46a6e 7744 ret = -TARGET_EFAULT;
722183f6 7745 else
c0d472b1 7746 ret = get_errno(renameat(arg1, p, arg3, p2));
579a97f7
FB		 7747 unlock_user(p2, arg4, 0);
7748 unlock_user(p, arg2, 0);
722183f6
TS		 7749 }
7750 break;
7751#endif
704eff6c 7752#ifdef TARGET_NR_mkdir
31e31b8a 7753 case TARGET_NR_mkdir:
579a97f7
FB		 7754 if (!(p = lock_user_string(arg1)))
7755 goto efault;
53a5960a
PB		 7756 ret = get_errno(mkdir(p, arg2));
7757 unlock_user(p, arg1, 0);
31e31b8a 7758 break;
704eff6c 7759#endif
c0d472b1 7760#if defined(TARGET_NR_mkdirat)
4472ad0d 7761 case TARGET_NR_mkdirat:
579a97f7
FB		 7762 if (!(p = lock_user_string(arg2)))
7763 goto efault;
c0d472b1 7764 ret = get_errno(mkdirat(arg1, p, arg3));
579a97f7 7765 unlock_user(p, arg2, 0);
4472ad0d
TS		 7766 break;
7767#endif
704eff6c 7768#ifdef TARGET_NR_rmdir
31e31b8a 7769 case TARGET_NR_rmdir:
579a97f7
FB		 7770 if (!(p = lock_user_string(arg1)))
7771 goto efault;
53a5960a
PB		 7772 ret = get_errno(rmdir(p));
7773 unlock_user(p, arg1, 0);
31e31b8a 7774 break;
704eff6c 7775#endif
31e31b8a
FB		 7776 case TARGET_NR_dup:
7777 ret = get_errno(dup(arg1));
e36800c9
LV		 7778 if (ret >= 0) {
7779 fd_trans_dup(arg1, ret);
7780 }
31e31b8a 7781 break;
704eff6c 7782#ifdef TARGET_NR_pipe
31e31b8a 7783 case TARGET_NR_pipe:
fb41a66e 7784 ret = do_pipe(cpu_env, arg1, 0, 0);
099d6b0f 7785 break;
704eff6c 7786#endif
099d6b0f
RV		 7787#ifdef TARGET_NR_pipe2
7788 case TARGET_NR_pipe2:
e7ea6cbe
RH		 7789 ret = do_pipe(cpu_env, arg1,
7790 target_to_host_bitmask(arg2, fcntl_flags_tbl), 1);
31e31b8a 7791 break;
099d6b0f 7792#endif
31e31b8a 7793 case TARGET_NR_times:
32f36bce 7794 {
53a5960a 7795 struct target_tms *tmsp;
32f36bce
FB		 7796 struct tms tms;
7797 ret = get_errno(times(&tms));
53a5960a 7798 if (arg1) {
579a97f7
FB		 7799 tmsp = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_tms), 0);
7800 if (!tmsp)
7801 goto efault;
cbb21eed
MB		 7802 tmsp->tms_utime = tswapal(host_to_target_clock_t(tms.tms_utime));
7803 tmsp->tms_stime = tswapal(host_to_target_clock_t(tms.tms_stime));
7804 tmsp->tms_cutime = tswapal(host_to_target_clock_t(tms.tms_cutime));
7805 tmsp->tms_cstime = tswapal(host_to_target_clock_t(tms.tms_cstime));
32f36bce 7806 }
c596ed17
FB		 7807 if (!is_error(ret))
7808 ret = host_to_target_clock_t(ret);
32f36bce
FB		 7809 }
7810 break;
ebc05488 7811#ifdef TARGET_NR_prof
31e31b8a
FB		 7812 case TARGET_NR_prof:
7813 goto unimplemented;
ebc05488 7814#endif
e5febef5 7815#ifdef TARGET_NR_signal
31e31b8a
FB		 7816 case TARGET_NR_signal:
7817 goto unimplemented;
e5febef5 7818#endif
31e31b8a 7819 case TARGET_NR_acct:
38d840e6
AJ		 7820 if (arg1 == 0) {
7821 ret = get_errno(acct(NULL));
7822 } else {
7823 if (!(p = lock_user_string(arg1)))
7824 goto efault;
7825 ret = get_errno(acct(path(p)));
7826 unlock_user(p, arg1, 0);
7827 }
24836689 7828 break;
8070e7be 7829#ifdef TARGET_NR_umount2
31e31b8a 7830 case TARGET_NR_umount2:
579a97f7
FB		 7831 if (!(p = lock_user_string(arg1)))
7832 goto efault;
53a5960a
PB		 7833 ret = get_errno(umount2(p, arg2));
7834 unlock_user(p, arg1, 0);
31e31b8a 7835 break;
7a3148a9 7836#endif
ebc05488 7837#ifdef TARGET_NR_lock
31e31b8a
FB		 7838 case TARGET_NR_lock:
7839 goto unimplemented;
ebc05488 7840#endif
31e31b8a
FB		 7841 case TARGET_NR_ioctl:
7842 ret = do_ioctl(arg1, arg2, arg3);
7843 break;
7844 case TARGET_NR_fcntl:
9ee1fa2c 7845 ret = do_fcntl(arg1, arg2, arg3);
31e31b8a 7846 break;
ebc05488 7847#ifdef TARGET_NR_mpx
31e31b8a
FB		 7848 case TARGET_NR_mpx:
7849 goto unimplemented;
ebc05488 7850#endif
31e31b8a
FB		 7851 case TARGET_NR_setpgid:
7852 ret = get_errno(setpgid(arg1, arg2));
7853 break;
ebc05488 7854#ifdef TARGET_NR_ulimit
31e31b8a
FB		 7855 case TARGET_NR_ulimit:
7856 goto unimplemented;
ebc05488
FB		 7857#endif
7858#ifdef TARGET_NR_oldolduname
31e31b8a
FB		 7859 case TARGET_NR_oldolduname:
7860 goto unimplemented;
ebc05488 7861#endif
31e31b8a
FB		 7862 case TARGET_NR_umask:
7863 ret = get_errno(umask(arg1));
7864 break;
7865 case TARGET_NR_chroot:
579a97f7
FB		 7866 if (!(p = lock_user_string(arg1)))
7867 goto efault;
53a5960a
PB		 7868 ret = get_errno(chroot(p));
7869 unlock_user(p, arg1, 0);
31e31b8a 7870 break;
704eff6c 7871#ifdef TARGET_NR_ustat
31e31b8a
FB		 7872 case TARGET_NR_ustat:
7873 goto unimplemented;
704eff6c
CG		 7874#endif
7875#ifdef TARGET_NR_dup2
31e31b8a
FB		 7876 case TARGET_NR_dup2:
7877 ret = get_errno(dup2(arg1, arg2));
e36800c9
LV		 7878 if (ret >= 0) {
7879 fd_trans_dup(arg1, arg2);
7880 }
31e31b8a 7881 break;
704eff6c 7882#endif
d0927938
UH		 7883#if defined(CONFIG_DUP3) && defined(TARGET_NR_dup3)
7884 case TARGET_NR_dup3:
7885 ret = get_errno(dup3(arg1, arg2, arg3));
e36800c9
LV		 7886 if (ret >= 0) {
7887 fd_trans_dup(arg1, arg2);
7888 }
d0927938
UH		 7889 break;
7890#endif
7a3148a9 7891#ifdef TARGET_NR_getppid /* not on alpha */
31e31b8a
FB		 7892 case TARGET_NR_getppid:
7893 ret = get_errno(getppid());
7894 break;
7a3148a9 7895#endif
704eff6c 7896#ifdef TARGET_NR_getpgrp
31e31b8a
FB		 7897 case TARGET_NR_getpgrp:
7898 ret = get_errno(getpgrp());
7899 break;
704eff6c 7900#endif
31e31b8a
FB		 7901 case TARGET_NR_setsid:
7902 ret = get_errno(setsid());
7903 break;
e5febef5 7904#ifdef TARGET_NR_sigaction
31e31b8a 7905 case TARGET_NR_sigaction:
31e31b8a 7906 {
6049f4f8
RH		 7907#if defined(TARGET_ALPHA)
7908 struct target_sigaction act, oact, *pact = 0;
53a5960a 7909 struct target_old_sigaction *old_act;
53a5960a 7910 if (arg2) {
579a97f7
FB		 7911 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
7912 goto efault;
66fb9763
FB		 7913 act._sa_handler = old_act->_sa_handler;
7914 target_siginitset(&act.sa_mask, old_act->sa_mask);
7915 act.sa_flags = old_act->sa_flags;
6049f4f8 7916 act.sa_restorer = 0;
53a5960a 7917 unlock_user_struct(old_act, arg2, 0);
66fb9763 7918 pact = &act;
66fb9763
FB		 7919 }
7920 ret = get_errno(do_sigaction(arg1, pact, &oact));
53a5960a 7921 if (!is_error(ret) && arg3) {
579a97f7
FB		 7922 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
7923 goto efault;
53a5960a
PB		 7924 old_act->_sa_handler = oact._sa_handler;
7925 old_act->sa_mask = oact.sa_mask.sig[0];
7926 old_act->sa_flags = oact.sa_flags;
53a5960a 7927 unlock_user_struct(old_act, arg3, 1);
66fb9763 7928 }
6049f4f8 7929#elif defined(TARGET_MIPS)
106ec879
FB		 7930 struct target_sigaction act, oact, *pact, *old_act;
7931
7932 if (arg2) {
579a97f7
FB		 7933 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
7934 goto efault;
106ec879
FB		 7935 act._sa_handler = old_act->_sa_handler;
7936 target_siginitset(&act.sa_mask, old_act->sa_mask.sig[0]);
7937 act.sa_flags = old_act->sa_flags;
7938 unlock_user_struct(old_act, arg2, 0);
7939 pact = &act;
7940 } else {
7941 pact = NULL;
7942 }
7943
7944 ret = get_errno(do_sigaction(arg1, pact, &oact));
7945
7946 if (!is_error(ret) && arg3) {
579a97f7
FB		 7947 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
7948 goto efault;
106ec879
FB		 7949 old_act->_sa_handler = oact._sa_handler;
7950 old_act->sa_flags = oact.sa_flags;
7951 old_act->sa_mask.sig[0] = oact.sa_mask.sig[0];
7952 old_act->sa_mask.sig[1] = 0;
7953 old_act->sa_mask.sig[2] = 0;
7954 old_act->sa_mask.sig[3] = 0;
7955 unlock_user_struct(old_act, arg3, 1);
7956 }
6049f4f8
RH		 7957#else
7958 struct target_old_sigaction *old_act;
7959 struct target_sigaction act, oact, *pact;
7960 if (arg2) {
7961 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
7962 goto efault;
7963 act._sa_handler = old_act->_sa_handler;
7964 target_siginitset(&act.sa_mask, old_act->sa_mask);
7965 act.sa_flags = old_act->sa_flags;
7966 act.sa_restorer = old_act->sa_restorer;
7967 unlock_user_struct(old_act, arg2, 0);
7968 pact = &act;
7969 } else {
7970 pact = NULL;
7971 }
7972 ret = get_errno(do_sigaction(arg1, pact, &oact));
7973 if (!is_error(ret) && arg3) {
7974 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
7975 goto efault;
7976 old_act->_sa_handler = oact._sa_handler;
7977 old_act->sa_mask = oact.sa_mask.sig[0];
7978 old_act->sa_flags = oact.sa_flags;
7979 old_act->sa_restorer = oact.sa_restorer;
7980 unlock_user_struct(old_act, arg3, 1);
7981 }
388bb21a 7982#endif
31e31b8a
FB		 7983 }
7984 break;
e5febef5 7985#endif
66fb9763 7986 case TARGET_NR_rt_sigaction:
53a5960a 7987 {
6049f4f8
RH		 7988#if defined(TARGET_ALPHA)
7989 struct target_sigaction act, oact, *pact = 0;
7990 struct target_rt_sigaction *rt_act;
c815701e
PM		 7991
7992 if (arg4 != sizeof(target_sigset_t)) {
7993 ret = -TARGET_EINVAL;
7994 break;
7995 }
6049f4f8
RH		 7996 if (arg2) {
7997 if (!lock_user_struct(VERIFY_READ, rt_act, arg2, 1))
7998 goto efault;
7999 act._sa_handler = rt_act->_sa_handler;
8000 act.sa_mask = rt_act->sa_mask;
8001 act.sa_flags = rt_act->sa_flags;
8002 act.sa_restorer = arg5;
8003 unlock_user_struct(rt_act, arg2, 0);
8004 pact = &act;
8005 }
8006 ret = get_errno(do_sigaction(arg1, pact, &oact));
8007 if (!is_error(ret) && arg3) {
8008 if (!lock_user_struct(VERIFY_WRITE, rt_act, arg3, 0))
8009 goto efault;
8010 rt_act->_sa_handler = oact._sa_handler;
8011 rt_act->sa_mask = oact.sa_mask;
8012 rt_act->sa_flags = oact.sa_flags;
8013 unlock_user_struct(rt_act, arg3, 1);
8014 }
8015#else
53a5960a
PB		 8016 struct target_sigaction *act;
8017 struct target_sigaction *oact;
8018
c815701e
PM		 8019 if (arg4 != sizeof(target_sigset_t)) {
8020 ret = -TARGET_EINVAL;
8021 break;
8022 }
579a97f7
FB		 8023 if (arg2) {
8024 if (!lock_user_struct(VERIFY_READ, act, arg2, 1))
8025 goto efault;
8026 } else
53a5960a 8027 act = NULL;
579a97f7
FB		 8028 if (arg3) {
8029 if (!lock_user_struct(VERIFY_WRITE, oact, arg3, 0)) {
8030 ret = -TARGET_EFAULT;
8031 goto rt_sigaction_fail;
8032 }
8033 } else
53a5960a
PB		 8034 oact = NULL;
8035 ret = get_errno(do_sigaction(arg1, act, oact));
579a97f7
FB		 8036 rt_sigaction_fail:
8037 if (act)
53a5960a 8038 unlock_user_struct(act, arg2, 0);
579a97f7 8039 if (oact)
53a5960a 8040 unlock_user_struct(oact, arg3, 1);
6049f4f8 8041#endif
53a5960a 8042 }
66fb9763 8043 break;
7a3148a9 8044#ifdef TARGET_NR_sgetmask /* not on alpha */
31e31b8a 8045 case TARGET_NR_sgetmask:
66fb9763
FB		 8046 {
8047 sigset_t cur_set;
992f48a0 8048 abi_ulong target_set;
3d3efba0
PM		 8049 ret = do_sigprocmask(0, NULL, &cur_set);
8050 if (!ret) {
8051 host_to_target_old_sigset(&target_set, &cur_set);
8052 ret = target_set;
8053 }
66fb9763
FB		 8054 }
8055 break;
7a3148a9
JM		 8056#endif
8057#ifdef TARGET_NR_ssetmask /* not on alpha */
31e31b8a 8058 case TARGET_NR_ssetmask:
66fb9763
FB		 8059 {
8060 sigset_t set, oset, cur_set;
992f48a0 8061 abi_ulong target_set = arg1;
3d3efba0
PM		 8062 /* We only have one word of the new mask so we must read
8063 * the rest of it with do_sigprocmask() and OR in this word.
8064 * We are guaranteed that a do_sigprocmask() that only queries
8065 * the signal mask will not fail.
8066 */
8067 ret = do_sigprocmask(0, NULL, &cur_set);
8068 assert(!ret);
66fb9763
FB		 8069 target_to_host_old_sigset(&set, &target_set);
8070 sigorset(&set, &set, &cur_set);
3d3efba0
PM		 8071 ret = do_sigprocmask(SIG_SETMASK, &set, &oset);
8072 if (!ret) {
8073 host_to_target_old_sigset(&target_set, &oset);
8074 ret = target_set;
8075 }
66fb9763
FB		 8076 }
8077 break;
7a3148a9 8078#endif
e5febef5 8079#ifdef TARGET_NR_sigprocmask
66fb9763
FB		 8080 case TARGET_NR_sigprocmask:
8081 {
a5b3b13b
RH		 8082#if defined(TARGET_ALPHA)
8083 sigset_t set, oldset;
8084 abi_ulong mask;
8085 int how;
8086
8087 switch (arg1) {
8088 case TARGET_SIG_BLOCK:
8089 how = SIG_BLOCK;
8090 break;
8091 case TARGET_SIG_UNBLOCK:
8092 how = SIG_UNBLOCK;
8093 break;
8094 case TARGET_SIG_SETMASK:
8095 how = SIG_SETMASK;
8096 break;
8097 default:
8098 ret = -TARGET_EINVAL;
8099 goto fail;
8100 }
8101 mask = arg2;
8102 target_to_host_old_sigset(&set, &mask);
8103
3d3efba0 8104 ret = do_sigprocmask(how, &set, &oldset);
a5b3b13b
RH		 8105 if (!is_error(ret)) {
8106 host_to_target_old_sigset(&mask, &oldset);
8107 ret = mask;
0229f5a3 8108 ((CPUAlphaState *)cpu_env)->ir[IR_V0] = 0; /* force no error */
a5b3b13b
RH		 8109 }
8110#else
66fb9763 8111 sigset_t set, oldset, *set_ptr;
a5b3b13b 8112 int how;
3b46e624 8113
53a5960a 8114 if (arg2) {
a5b3b13b 8115 switch (arg1) {
66fb9763
FB		 8116 case TARGET_SIG_BLOCK:
8117 how = SIG_BLOCK;
8118 break;
8119 case TARGET_SIG_UNBLOCK:
8120 how = SIG_UNBLOCK;
8121 break;
8122 case TARGET_SIG_SETMASK:
8123 how = SIG_SETMASK;
8124 break;
8125 default:
0da46a6e 8126 ret = -TARGET_EINVAL;
66fb9763
FB		 8127 goto fail;
8128 }
c227f099 8129 if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))
579a97f7 8130 goto efault;
53a5960a
PB		 8131 target_to_host_old_sigset(&set, p);
8132 unlock_user(p, arg2, 0);
66fb9763
FB		 8133 set_ptr = &set;
8134 } else {
8135 how = 0;
8136 set_ptr = NULL;
8137 }
3d3efba0 8138 ret = do_sigprocmask(how, set_ptr, &oldset);
53a5960a 8139 if (!is_error(ret) && arg3) {
c227f099 8140 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))
579a97f7 8141 goto efault;
53a5960a 8142 host_to_target_old_sigset(p, &oldset);
c227f099 8143 unlock_user(p, arg3, sizeof(target_sigset_t));
66fb9763 8144 }
a5b3b13b 8145#endif
66fb9763
FB		 8146 }
8147 break;
e5febef5 8148#endif
66fb9763
FB		 8149 case TARGET_NR_rt_sigprocmask:
8150 {
8151 int how = arg1;
8152 sigset_t set, oldset, *set_ptr;
3b46e624 8153
c815701e
PM		 8154 if (arg4 != sizeof(target_sigset_t)) {
8155 ret = -TARGET_EINVAL;
8156 break;
8157 }
8158
53a5960a 8159 if (arg2) {
66fb9763
FB		 8160 switch(how) {
8161 case TARGET_SIG_BLOCK:
8162 how = SIG_BLOCK;
8163 break;
8164 case TARGET_SIG_UNBLOCK:
8165 how = SIG_UNBLOCK;
8166 break;
8167 case TARGET_SIG_SETMASK:
8168 how = SIG_SETMASK;
8169 break;
8170 default:
0da46a6e 8171 ret = -TARGET_EINVAL;
66fb9763
FB		 8172 goto fail;
8173 }
c227f099 8174 if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))
579a97f7 8175 goto efault;
53a5960a
PB		 8176 target_to_host_sigset(&set, p);
8177 unlock_user(p, arg2, 0);
66fb9763
FB		 8178 set_ptr = &set;
8179 } else {
8180 how = 0;
8181 set_ptr = NULL;
8182 }
3d3efba0 8183 ret = do_sigprocmask(how, set_ptr, &oldset);
53a5960a 8184 if (!is_error(ret) && arg3) {
c227f099 8185 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))
579a97f7 8186 goto efault;
53a5960a 8187 host_to_target_sigset(p, &oldset);
c227f099 8188 unlock_user(p, arg3, sizeof(target_sigset_t));
66fb9763
FB		 8189 }
8190 }
8191 break;
e5febef5 8192#ifdef TARGET_NR_sigpending
66fb9763
FB		 8193 case TARGET_NR_sigpending:
8194 {
8195 sigset_t set;
8196 ret = get_errno(sigpending(&set));
8197 if (!is_error(ret)) {
c227f099 8198 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))
579a97f7 8199 goto efault;
53a5960a 8200 host_to_target_old_sigset(p, &set);
c227f099 8201 unlock_user(p, arg1, sizeof(target_sigset_t));
66fb9763
FB		 8202 }
8203 }
8204 break;
e5febef5 8205#endif
66fb9763
FB		 8206 case TARGET_NR_rt_sigpending:
8207 {
8208 sigset_t set;
c815701e
PM		 8209
8210 /* Yes, this check is >, not != like most. We follow the kernel's
8211 * logic and it does it like this because it implements
8212 * NR_sigpending through the same code path, and in that case
8213 * the old_sigset_t is smaller in size.
8214 */
8215 if (arg2 > sizeof(target_sigset_t)) {
8216 ret = -TARGET_EINVAL;
8217 break;
8218 }
8219
66fb9763
FB		 8220 ret = get_errno(sigpending(&set));
8221 if (!is_error(ret)) {
c227f099 8222 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))
579a97f7 8223 goto efault;
53a5960a 8224 host_to_target_sigset(p, &set);
c227f099 8225 unlock_user(p, arg1, sizeof(target_sigset_t));
66fb9763
FB		 8226 }
8227 }
8228 break;
e5febef5 8229#ifdef TARGET_NR_sigsuspend
66fb9763
FB		 8230 case TARGET_NR_sigsuspend:
8231 {
3d3efba0 8232 TaskState *ts = cpu->opaque;
f43ce12b
RH		 8233#if defined(TARGET_ALPHA)
8234 abi_ulong mask = arg1;
3d3efba0 8235 target_to_host_old_sigset(&ts->sigsuspend_mask, &mask);
f43ce12b 8236#else
c227f099 8237 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
579a97f7 8238 goto efault;
3d3efba0 8239 target_to_host_old_sigset(&ts->sigsuspend_mask, p);
53a5960a 8240 unlock_user(p, arg1, 0);
f43ce12b 8241#endif
3d3efba0
PM		 8242 ret = get_errno(safe_rt_sigsuspend(&ts->sigsuspend_mask,
8243 SIGSET_T_SIZE));
8244 if (ret != -TARGET_ERESTARTSYS) {
8245 ts->in_sigsuspend = 1;
8246 }
66fb9763
FB		 8247 }
8248 break;
e5febef5 8249#endif
66fb9763
FB		 8250 case TARGET_NR_rt_sigsuspend:
8251 {
3d3efba0 8252 TaskState *ts = cpu->opaque;
c815701e
PM		 8253
8254 if (arg2 != sizeof(target_sigset_t)) {
8255 ret = -TARGET_EINVAL;
8256 break;
8257 }
c227f099 8258 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
579a97f7 8259 goto efault;
3d3efba0 8260 target_to_host_sigset(&ts->sigsuspend_mask, p);
53a5960a 8261 unlock_user(p, arg1, 0);
3d3efba0
PM		 8262 ret = get_errno(safe_rt_sigsuspend(&ts->sigsuspend_mask,
8263 SIGSET_T_SIZE));
8264 if (ret != -TARGET_ERESTARTSYS) {
8265 ts->in_sigsuspend = 1;
8266 }
66fb9763
FB		 8267 }
8268 break;
8269 case TARGET_NR_rt_sigtimedwait:
8270 {
66fb9763
FB		 8271 sigset_t set;
8272 struct timespec uts, *puts;
8273 siginfo_t uinfo;
3b46e624 8274
c815701e
PM		 8275 if (arg4 != sizeof(target_sigset_t)) {
8276 ret = -TARGET_EINVAL;
8277 break;
8278 }
8279
c227f099 8280 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
579a97f7 8281 goto efault;
53a5960a
PB		 8282 target_to_host_sigset(&set, p);
8283 unlock_user(p, arg1, 0);
8284 if (arg3) {
66fb9763 8285 puts = &uts;
53a5960a 8286 target_to_host_timespec(puts, arg3);
66fb9763
FB		 8287 } else {
8288 puts = NULL;
8289 }
b3f82330
PM		 8290 ret = get_errno(safe_rt_sigtimedwait(&set, &uinfo, puts,
8291 SIGSET_T_SIZE));
974a196d
PJ		 8292 if (!is_error(ret)) {
8293 if (arg2) {
8294 p = lock_user(VERIFY_WRITE, arg2, sizeof(target_siginfo_t),
8295 0);
8296 if (!p) {
8297 goto efault;
8298 }
8299 host_to_target_siginfo(p, &uinfo);
8300 unlock_user(p, arg2, sizeof(target_siginfo_t));
8301 }
8302 ret = host_to_target_signal(ret);
66fb9763
FB		 8303 }
8304 }
8305 break;
8306 case TARGET_NR_rt_sigqueueinfo:
8307 {
8308 siginfo_t uinfo;
4debae6f
PM		 8309
8310 p = lock_user(VERIFY_READ, arg3, sizeof(target_siginfo_t), 1);
8311 if (!p) {
579a97f7 8312 goto efault;
4debae6f 8313 }
53a5960a
PB		 8314 target_to_host_siginfo(&uinfo, p);
8315 unlock_user(p, arg1, 0);
66fb9763
FB		 8316 ret = get_errno(sys_rt_sigqueueinfo(arg1, arg2, &uinfo));
8317 }
8318 break;
e5febef5 8319#ifdef TARGET_NR_sigreturn
66fb9763 8320 case TARGET_NR_sigreturn:
3d3efba0
PM		 8321 if (block_signals()) {
8322 ret = -TARGET_ERESTARTSYS;
8323 } else {
8324 ret = do_sigreturn(cpu_env);
8325 }
66fb9763 8326 break;
e5febef5 8327#endif
66fb9763 8328 case TARGET_NR_rt_sigreturn:
3d3efba0
PM		 8329 if (block_signals()) {
8330 ret = -TARGET_ERESTARTSYS;
8331 } else {
8332 ret = do_rt_sigreturn(cpu_env);
8333 }
66fb9763 8334 break;
31e31b8a 8335 case TARGET_NR_sethostname:
579a97f7
FB		 8336 if (!(p = lock_user_string(arg1)))
8337 goto efault;
53a5960a
PB		 8338 ret = get_errno(sethostname(p, arg2));
8339 unlock_user(p, arg1, 0);
31e31b8a
FB		 8340 break;
8341 case TARGET_NR_setrlimit:
9de5e440 8342 {
e22b7015 8343 int resource = target_to_host_resource(arg1);
53a5960a 8344 struct target_rlimit *target_rlim;
9de5e440 8345 struct rlimit rlim;
579a97f7
FB		 8346 if (!lock_user_struct(VERIFY_READ, target_rlim, arg2, 1))
8347 goto efault;
81bbe906
TY		 8348 rlim.rlim_cur = target_to_host_rlim(target_rlim->rlim_cur);
8349 rlim.rlim_max = target_to_host_rlim(target_rlim->rlim_max);
53a5960a 8350 unlock_user_struct(target_rlim, arg2, 0);
9de5e440
FB		 8351 ret = get_errno(setrlimit(resource, &rlim));
8352 }
8353 break;
31e31b8a 8354 case TARGET_NR_getrlimit:
9de5e440 8355 {
e22b7015 8356 int resource = target_to_host_resource(arg1);
53a5960a 8357 struct target_rlimit *target_rlim;
9de5e440 8358 struct rlimit rlim;
3b46e624 8359
9de5e440
FB		 8360 ret = get_errno(getrlimit(resource, &rlim));
8361 if (!is_error(ret)) {
579a97f7
FB		 8362 if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))
8363 goto efault;
81bbe906
TY		 8364 target_rlim->rlim_cur = host_to_target_rlim(rlim.rlim_cur);
8365 target_rlim->rlim_max = host_to_target_rlim(rlim.rlim_max);
53a5960a 8366 unlock_user_struct(target_rlim, arg2, 1);
9de5e440
FB		 8367 }
8368 }
8369 break;
31e31b8a 8370 case TARGET_NR_getrusage:
b409186b
FB		 8371 {
8372 struct rusage rusage;
b409186b
FB		 8373 ret = get_errno(getrusage(arg1, &rusage));
8374 if (!is_error(ret)) {
a39fb273 8375 ret = host_to_target_rusage(arg2, &rusage);
b409186b
FB		 8376 }
8377 }
8378 break;
31e31b8a
FB		 8379 case TARGET_NR_gettimeofday:
8380 {
31e31b8a
FB		 8381 struct timeval tv;
8382 ret = get_errno(gettimeofday(&tv, NULL));
8383 if (!is_error(ret)) {
788f5ec4
TS		 8384 if (copy_to_user_timeval(arg1, &tv))
8385 goto efault;
31e31b8a
FB		 8386 }
8387 }
8388 break;
8389 case TARGET_NR_settimeofday:
8390 {
b67d8031 8391 struct timeval tv, *ptv = NULL;
ef4467e9
PB		 8392 struct timezone tz, *ptz = NULL;
8393
b67d8031
PB		 8394 if (arg1) {
8395 if (copy_from_user_timeval(&tv, arg1)) {
8396 goto efault;
8397 }
8398 ptv = &tv;
8399 }
ef4467e9
PB		 8400
8401 if (arg2) {
8402 if (copy_from_user_timezone(&tz, arg2)) {
8403 goto efault;
8404 }
8405 ptz = &tz;
8406 }
8407
b67d8031 8408 ret = get_errno(settimeofday(ptv, ptz));
31e31b8a
FB		 8409 }
8410 break;
9468a5d4 8411#if defined(TARGET_NR_select)
31e31b8a 8412 case TARGET_NR_select:
9468a5d4
LV		 8413#if defined(TARGET_S390X) || defined(TARGET_ALPHA)
8414 ret = do_select(arg1, arg2, arg3, arg4, arg5);
8415#else
f2674e31 8416 {
53a5960a 8417 struct target_sel_arg_struct *sel;
992f48a0 8418 abi_ulong inp, outp, exp, tvp;
53a5960a
PB		 8419 long nsel;
8420
579a97f7
FB		 8421 if (!lock_user_struct(VERIFY_READ, sel, arg1, 1))
8422 goto efault;
cbb21eed
MB		 8423 nsel = tswapal(sel->n);
8424 inp = tswapal(sel->inp);
8425 outp = tswapal(sel->outp);
8426 exp = tswapal(sel->exp);
8427 tvp = tswapal(sel->tvp);
53a5960a
PB		 8428 unlock_user_struct(sel, arg1, 0);
8429 ret = do_select(nsel, inp, outp, exp, tvp);
f2674e31 8430 }
9468a5d4 8431#endif
f2674e31 8432 break;
9e42382f
RV		 8433#endif
8434#ifdef TARGET_NR_pselect6
8435 case TARGET_NR_pselect6:
055e0906
MF		 8436 {
8437 abi_long rfd_addr, wfd_addr, efd_addr, n, ts_addr;
8438 fd_set rfds, wfds, efds;
8439 fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
8440 struct timespec ts, *ts_ptr;
8441
8442 /*
8443 * The 6th arg is actually two args smashed together,
8444 * so we cannot use the C library.
8445 */
8446 sigset_t set;
8447 struct {
8448 sigset_t *set;
8449 size_t size;
8450 } sig, *sig_ptr;
8451
8452 abi_ulong arg_sigset, arg_sigsize, *arg7;
8453 target_sigset_t *target_sigset;
8454
8455 n = arg1;
8456 rfd_addr = arg2;
8457 wfd_addr = arg3;
8458 efd_addr = arg4;
8459 ts_addr = arg5;
8460
8461 ret = copy_from_user_fdset_ptr(&rfds, &rfds_ptr, rfd_addr, n);
8462 if (ret) {
8463 goto fail;
8464 }
8465 ret = copy_from_user_fdset_ptr(&wfds, &wfds_ptr, wfd_addr, n);
8466 if (ret) {
8467 goto fail;
8468 }
8469 ret = copy_from_user_fdset_ptr(&efds, &efds_ptr, efd_addr, n);
8470 if (ret) {
8471 goto fail;
8472 }
8473
8474 /*
8475 * This takes a timespec, and not a timeval, so we cannot
8476 * use the do_select() helper ...
8477 */
8478 if (ts_addr) {
8479 if (target_to_host_timespec(&ts, ts_addr)) {
8480 goto efault;
8481 }
8482 ts_ptr = &ts;
8483 } else {
8484 ts_ptr = NULL;
8485 }
8486
8487 /* Extract the two packed args for the sigset */
8488 if (arg6) {
8489 sig_ptr = &sig;
b28a1f33 8490 sig.size = SIGSET_T_SIZE;
055e0906
MF		 8491
8492 arg7 = lock_user(VERIFY_READ, arg6, sizeof(*arg7) * 2, 1);
8493 if (!arg7) {
8494 goto efault;
8495 }
cbb21eed
MB		 8496 arg_sigset = tswapal(arg7[0]);
8497 arg_sigsize = tswapal(arg7[1]);
055e0906
MF		 8498 unlock_user(arg7, arg6, 0);
8499
8500 if (arg_sigset) {
8501 sig.set = &set;
8f04eeb3
PM		 8502 if (arg_sigsize != sizeof(*target_sigset)) {
8503 /* Like the kernel, we enforce correct size sigsets */
8504 ret = -TARGET_EINVAL;
8505 goto fail;
8506 }
055e0906
MF		 8507 target_sigset = lock_user(VERIFY_READ, arg_sigset,
8508 sizeof(*target_sigset), 1);
8509 if (!target_sigset) {
8510 goto efault;
8511 }
8512 target_to_host_sigset(&set, target_sigset);
8513 unlock_user(target_sigset, arg_sigset, 0);
8514 } else {
8515 sig.set = NULL;
8516 }
8517 } else {
8518 sig_ptr = NULL;
8519 }
8520
6df9d38d
PM		 8521 ret = get_errno(safe_pselect6(n, rfds_ptr, wfds_ptr, efds_ptr,
8522 ts_ptr, sig_ptr));
055e0906
MF		 8523
8524 if (!is_error(ret)) {
8525 if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n))
8526 goto efault;
8527 if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n))
8528 goto efault;
8529 if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n))
8530 goto efault;
8531
8532 if (ts_addr && host_to_target_timespec(ts_addr, &ts))
8533 goto efault;
8534 }
8535 }
8536 break;
048f6b4d 8537#endif
704eff6c 8538#ifdef TARGET_NR_symlink
31e31b8a 8539 case TARGET_NR_symlink:
53a5960a
PB		 8540 {
8541 void *p2;
8542 p = lock_user_string(arg1);
8543 p2 = lock_user_string(arg2);
579a97f7
FB		 8544 if (!p || !p2)
8545 ret = -TARGET_EFAULT;
8546 else
8547 ret = get_errno(symlink(p, p2));
53a5960a
PB		 8548 unlock_user(p2, arg2, 0);
8549 unlock_user(p, arg1, 0);
8550 }
31e31b8a 8551 break;
704eff6c 8552#endif
c0d472b1 8553#if defined(TARGET_NR_symlinkat)
f0b6243d 8554 case TARGET_NR_symlinkat:
f0b6243d 8555 {
579a97f7 8556 void *p2;
f0b6243d
TS		 8557 p = lock_user_string(arg1);
8558 p2 = lock_user_string(arg3);
579a97f7 8559 if (!p || !p2)
0da46a6e 8560 ret = -TARGET_EFAULT;
f0b6243d 8561 else
c0d472b1 8562 ret = get_errno(symlinkat(p, arg2, p2));
579a97f7
FB		 8563 unlock_user(p2, arg3, 0);
8564 unlock_user(p, arg1, 0);
f0b6243d
TS		 8565 }
8566 break;
8567#endif
ebc05488 8568#ifdef TARGET_NR_oldlstat
31e31b8a
FB		 8569 case TARGET_NR_oldlstat:
8570 goto unimplemented;
ebc05488 8571#endif
704eff6c 8572#ifdef TARGET_NR_readlink
31e31b8a 8573 case TARGET_NR_readlink:
53a5960a 8574 {
463d8e73 8575 void *p2;
53a5960a 8576 p = lock_user_string(arg1);
579a97f7 8577 p2 = lock_user(VERIFY_WRITE, arg2, arg3, 0);
463d8e73 8578 if (!p || !p2) {
579a97f7 8579 ret = -TARGET_EFAULT;
f17f4989
MF		 8580 } else if (!arg3) {
8581 /* Short circuit this for the magic exe check. */
8582 ret = -TARGET_EINVAL;
463d8e73
AS		 8583 } else if (is_proc_myself((const char *)p, "exe")) {
8584 char real[PATH_MAX], *temp;
8585 temp = realpath(exec_path, real);
f17f4989
MF		 8586 /* Return value is # of bytes that we wrote to the buffer. */
8587 if (temp == NULL) {
8588 ret = get_errno(-1);
8589 } else {
8590 /* Don't worry about sign mismatch as earlier mapping
8591 * logic would have thrown a bad address error. */
8592 ret = MIN(strlen(real), arg3);
8593 /* We cannot NUL terminate the string. */
8594 memcpy(p2, real, ret);
8595 }
463d8e73
AS		 8596 } else {
8597 ret = get_errno(readlink(path(p), p2, arg3));
d088d664 8598 }
53a5960a
PB		 8599 unlock_user(p2, arg2, ret);
8600 unlock_user(p, arg1, 0);
8601 }
31e31b8a 8602 break;
704eff6c 8603#endif
c0d472b1 8604#if defined(TARGET_NR_readlinkat)
5e0ccb18 8605 case TARGET_NR_readlinkat:
5e0ccb18 8606 {
579a97f7 8607 void *p2;
5e0ccb18 8608 p = lock_user_string(arg2);
579a97f7 8609 p2 = lock_user(VERIFY_WRITE, arg3, arg4, 0);
463d8e73
AS		 8610 if (!p || !p2) {
8611 ret = -TARGET_EFAULT;
8612 } else if (is_proc_myself((const char *)p, "exe")) {
8613 char real[PATH_MAX], *temp;
8614 temp = realpath(exec_path, real);
8615 ret = temp == NULL ? get_errno(-1) : strlen(real) ;
8616 snprintf((char *)p2, arg4, "%s", real);
8617 } else {
c0d472b1 8618 ret = get_errno(readlinkat(arg1, path(p), p2, arg4));
463d8e73 8619 }
579a97f7
FB		 8620 unlock_user(p2, arg3, ret);
8621 unlock_user(p, arg2, 0);
5e0ccb18
TS		 8622 }
8623 break;
8624#endif
e5febef5 8625#ifdef TARGET_NR_uselib
31e31b8a
FB		 8626 case TARGET_NR_uselib:
8627 goto unimplemented;
e5febef5
TS		 8628#endif
8629#ifdef TARGET_NR_swapon
31e31b8a 8630 case TARGET_NR_swapon:
579a97f7
FB		 8631 if (!(p = lock_user_string(arg1)))
8632 goto efault;
53a5960a
PB		 8633 ret = get_errno(swapon(p, arg2));
8634 unlock_user(p, arg1, 0);
31e31b8a 8635 break;
e5febef5 8636#endif
31e31b8a 8637 case TARGET_NR_reboot:
c07ecc68
LV		 8638 if (arg3 == LINUX_REBOOT_CMD_RESTART2) {
8639 /* arg4 must be ignored in all other cases */
8640 p = lock_user_string(arg4);
8641 if (!p) {
8642 goto efault;
8643 }
8644 ret = get_errno(reboot(arg1, arg2, arg3, p));
8645 unlock_user(p, arg4, 0);
8646 } else {
8647 ret = get_errno(reboot(arg1, arg2, arg3, NULL));
8648 }
0f6b4d21 8649 break;
e5febef5 8650#ifdef TARGET_NR_readdir
31e31b8a
FB		 8651 case TARGET_NR_readdir:
8652 goto unimplemented;
e5febef5
TS		 8653#endif
8654#ifdef TARGET_NR_mmap
31e31b8a 8655 case TARGET_NR_mmap:
09701199
AG		 8656#if (defined(TARGET_I386) && defined(TARGET_ABI32)) || \
8657 (defined(TARGET_ARM) && defined(TARGET_ABI32)) || \
a4c075f1
UH		 8658 defined(TARGET_M68K) || defined(TARGET_CRIS) || defined(TARGET_MICROBLAZE) \
8659 || defined(TARGET_S390X)
31e31b8a 8660 {
992f48a0
BS		 8661 abi_ulong *v;
8662 abi_ulong v1, v2, v3, v4, v5, v6;
579a97f7
FB		 8663 if (!(v = lock_user(VERIFY_READ, arg1, 6 * sizeof(abi_ulong), 1)))
8664 goto efault;
cbb21eed
MB		 8665 v1 = tswapal(v[0]);
8666 v2 = tswapal(v[1]);
8667 v3 = tswapal(v[2]);
8668 v4 = tswapal(v[3]);
8669 v5 = tswapal(v[4]);
8670 v6 = tswapal(v[5]);
53a5960a 8671 unlock_user(v, arg1, 0);
5fafdf24 8672 ret = get_errno(target_mmap(v1, v2, v3,
5286db75
FB		 8673 target_to_host_bitmask(v4, mmap_flags_tbl),
8674 v5, v6));
31e31b8a 8675 }
31e31b8a 8676#else
5fafdf24
TS		 8677 ret = get_errno(target_mmap(arg1, arg2, arg3,
8678 target_to_host_bitmask(arg4, mmap_flags_tbl),
6fb883e8
FB		 8679 arg5,
8680 arg6));
31e31b8a 8681#endif
6fb883e8 8682 break;
e5febef5 8683#endif
a315a145 8684#ifdef TARGET_NR_mmap2
6fb883e8 8685 case TARGET_NR_mmap2:
bb7ec043 8686#ifndef MMAP_SHIFT
c573ff67 8687#define MMAP_SHIFT 12
c573ff67 8688#endif
5fafdf24
TS		 8689 ret = get_errno(target_mmap(arg1, arg2, arg3,
8690 target_to_host_bitmask(arg4, mmap_flags_tbl),
5286db75 8691 arg5,
c573ff67 8692 arg6 << MMAP_SHIFT));
31e31b8a 8693 break;
a315a145 8694#endif
31e31b8a 8695 case TARGET_NR_munmap:
54936004 8696 ret = get_errno(target_munmap(arg1, arg2));
31e31b8a 8697 break;
9de5e440 8698 case TARGET_NR_mprotect:
97374d38 8699 {
0429a971 8700 TaskState *ts = cpu->opaque;
97374d38
PB		 8701 /* Special hack to detect libc making the stack executable. */
8702 if ((arg3 & PROT_GROWSDOWN)
8703 && arg1 >= ts->info->stack_limit
8704 && arg1 <= ts->info->start_stack) {
8705 arg3 &= ~PROT_GROWSDOWN;
8706 arg2 = arg2 + arg1 - ts->info->stack_limit;
8707 arg1 = ts->info->stack_limit;
8708 }
8709 }
54936004 8710 ret = get_errno(target_mprotect(arg1, arg2, arg3));
9de5e440 8711 break;
e5febef5 8712#ifdef TARGET_NR_mremap
9de5e440 8713 case TARGET_NR_mremap:
54936004 8714 ret = get_errno(target_mremap(arg1, arg2, arg3, arg4, arg5));
9de5e440 8715 break;
e5febef5 8716#endif
53a5960a 8717 /* ??? msync/mlock/munlock are broken for softmmu. */
e5febef5 8718#ifdef TARGET_NR_msync
9de5e440 8719 case TARGET_NR_msync:
53a5960a 8720 ret = get_errno(msync(g2h(arg1), arg2, arg3));
9de5e440 8721 break;
e5febef5
TS		 8722#endif
8723#ifdef TARGET_NR_mlock
9de5e440 8724 case TARGET_NR_mlock:
53a5960a 8725 ret = get_errno(mlock(g2h(arg1), arg2));
9de5e440 8726 break;
e5febef5
TS		 8727#endif
8728#ifdef TARGET_NR_munlock
9de5e440 8729 case TARGET_NR_munlock:
53a5960a 8730 ret = get_errno(munlock(g2h(arg1), arg2));
9de5e440 8731 break;
e5febef5
TS		 8732#endif
8733#ifdef TARGET_NR_mlockall
9de5e440 8734 case TARGET_NR_mlockall:
6f6a4032 8735 ret = get_errno(mlockall(target_to_host_mlockall_arg(arg1)));
9de5e440 8736 break;
e5febef5
TS		 8737#endif
8738#ifdef TARGET_NR_munlockall
9de5e440
FB		 8739 case TARGET_NR_munlockall:
8740 ret = get_errno(munlockall());
8741 break;
e5febef5 8742#endif
31e31b8a 8743 case TARGET_NR_truncate:
579a97f7
FB		 8744 if (!(p = lock_user_string(arg1)))
8745 goto efault;
53a5960a
PB		 8746 ret = get_errno(truncate(p, arg2));
8747 unlock_user(p, arg1, 0);
31e31b8a
FB		 8748 break;
8749 case TARGET_NR_ftruncate:
8750 ret = get_errno(ftruncate(arg1, arg2));
8751 break;
8752 case TARGET_NR_fchmod:
8753 ret = get_errno(fchmod(arg1, arg2));
8754 break;
c0d472b1 8755#if defined(TARGET_NR_fchmodat)
814d7977 8756 case TARGET_NR_fchmodat:
579a97f7
FB		 8757 if (!(p = lock_user_string(arg2)))
8758 goto efault;
c0d472b1 8759 ret = get_errno(fchmodat(arg1, p, arg3, 0));
579a97f7 8760 unlock_user(p, arg2, 0);
814d7977
TS		 8761 break;
8762#endif
31e31b8a 8763 case TARGET_NR_getpriority:
95c09828
RH		 8764 /* Note that negative values are valid for getpriority, so we must
8765 differentiate based on errno settings. */
8766 errno = 0;
8767 ret = getpriority(arg1, arg2);
8768 if (ret == -1 && errno != 0) {
8769 ret = -host_to_target_errno(errno);
8770 break;
8771 }
8772#ifdef TARGET_ALPHA
8773 /* Return value is the unbiased priority. Signal no error. */
8774 ((CPUAlphaState *)cpu_env)->ir[IR_V0] = 0;
8775#else
8776 /* Return value is a biased priority to avoid negative numbers. */
8777 ret = 20 - ret;
8778#endif
31e31b8a
FB		 8779 break;
8780 case TARGET_NR_setpriority:
8781 ret = get_errno(setpriority(arg1, arg2, arg3));
8782 break;
ebc05488 8783#ifdef TARGET_NR_profil
31e31b8a
FB		 8784 case TARGET_NR_profil:
8785 goto unimplemented;
ebc05488 8786#endif
31e31b8a 8787 case TARGET_NR_statfs:
579a97f7
FB		 8788 if (!(p = lock_user_string(arg1)))
8789 goto efault;
53a5960a
PB		 8790 ret = get_errno(statfs(path(p), &stfs));
8791 unlock_user(p, arg1, 0);
31e31b8a
FB		 8792 convert_statfs:
8793 if (!is_error(ret)) {
53a5960a 8794 struct target_statfs *target_stfs;
3b46e624 8795
579a97f7
FB		 8796 if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg2, 0))
8797 goto efault;
8798 __put_user(stfs.f_type, &target_stfs->f_type);
8799 __put_user(stfs.f_bsize, &target_stfs->f_bsize);
8800 __put_user(stfs.f_blocks, &target_stfs->f_blocks);
8801 __put_user(stfs.f_bfree, &target_stfs->f_bfree);
8802 __put_user(stfs.f_bavail, &target_stfs->f_bavail);
8803 __put_user(stfs.f_files, &target_stfs->f_files);
8804 __put_user(stfs.f_ffree, &target_stfs->f_ffree);
8805 __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
8806 __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
8807 __put_user(stfs.f_namelen, &target_stfs->f_namelen);
229d3376
AG		 8808 __put_user(stfs.f_frsize, &target_stfs->f_frsize);
8809 memset(target_stfs->f_spare, 0, sizeof(target_stfs->f_spare));
53a5960a 8810 unlock_user_struct(target_stfs, arg2, 1);
31e31b8a
FB		 8811 }
8812 break;
8813 case TARGET_NR_fstatfs:
56c8f68f 8814 ret = get_errno(fstatfs(arg1, &stfs));
31e31b8a 8815 goto convert_statfs;
56c8f68f
FB		 8816#ifdef TARGET_NR_statfs64
8817 case TARGET_NR_statfs64:
579a97f7
FB		 8818 if (!(p = lock_user_string(arg1)))
8819 goto efault;
53a5960a
PB		 8820 ret = get_errno(statfs(path(p), &stfs));
8821 unlock_user(p, arg1, 0);
56c8f68f
FB		 8822 convert_statfs64:
8823 if (!is_error(ret)) {
53a5960a 8824 struct target_statfs64 *target_stfs;
3b46e624 8825
579a97f7
FB		 8826 if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg3, 0))
8827 goto efault;
8828 __put_user(stfs.f_type, &target_stfs->f_type);
8829 __put_user(stfs.f_bsize, &target_stfs->f_bsize);
8830 __put_user(stfs.f_blocks, &target_stfs->f_blocks);
8831 __put_user(stfs.f_bfree, &target_stfs->f_bfree);
8832 __put_user(stfs.f_bavail, &target_stfs->f_bavail);
8833 __put_user(stfs.f_files, &target_stfs->f_files);
8834 __put_user(stfs.f_ffree, &target_stfs->f_ffree);
8835 __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
8836 __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
8837 __put_user(stfs.f_namelen, &target_stfs->f_namelen);
229d3376
AG		 8838 __put_user(stfs.f_frsize, &target_stfs->f_frsize);
8839 memset(target_stfs->f_spare, 0, sizeof(target_stfs->f_spare));
579a97f7 8840 unlock_user_struct(target_stfs, arg3, 1);
56c8f68f
FB		 8841 }
8842 break;
8843 case TARGET_NR_fstatfs64:
8844 ret = get_errno(fstatfs(arg1, &stfs));
8845 goto convert_statfs64;
8846#endif
ebc05488 8847#ifdef TARGET_NR_ioperm
31e31b8a
FB		 8848 case TARGET_NR_ioperm:
8849 goto unimplemented;
ebc05488 8850#endif
e5febef5 8851#ifdef TARGET_NR_socketcall
31e31b8a 8852 case TARGET_NR_socketcall:
53a5960a 8853 ret = do_socketcall(arg1, arg2);
31e31b8a 8854 break;
e5febef5 8855#endif
3532fa74
FB		 8856#ifdef TARGET_NR_accept
8857 case TARGET_NR_accept:
a94b4987
PM		 8858 ret = do_accept4(arg1, arg2, arg3, 0);
8859 break;
8860#endif
8861#ifdef TARGET_NR_accept4
8862 case TARGET_NR_accept4:
a94b4987 8863 ret = do_accept4(arg1, arg2, arg3, arg4);
3532fa74
FB		 8864 break;
8865#endif
8866#ifdef TARGET_NR_bind
8867 case TARGET_NR_bind:
8868 ret = do_bind(arg1, arg2, arg3);
8869 break;
8870#endif
8871#ifdef TARGET_NR_connect
8872 case TARGET_NR_connect:
8873 ret = do_connect(arg1, arg2, arg3);
8874 break;
8875#endif
8876#ifdef TARGET_NR_getpeername
8877 case TARGET_NR_getpeername:
1be9e1dc 8878 ret = do_getpeername(arg1, arg2, arg3);
3532fa74
FB		 8879 break;
8880#endif
8881#ifdef TARGET_NR_getsockname
8882 case TARGET_NR_getsockname:
1be9e1dc 8883 ret = do_getsockname(arg1, arg2, arg3);
3532fa74
FB		 8884 break;
8885#endif
8886#ifdef TARGET_NR_getsockopt
8887 case TARGET_NR_getsockopt:
8888 ret = do_getsockopt(arg1, arg2, arg3, arg4, arg5);
8889 break;
8890#endif
8891#ifdef TARGET_NR_listen
8892 case TARGET_NR_listen:
1be9e1dc 8893 ret = get_errno(listen(arg1, arg2));
3532fa74
FB		 8894 break;
8895#endif
8896#ifdef TARGET_NR_recv
8897 case TARGET_NR_recv:
214201bd 8898 ret = do_recvfrom(arg1, arg2, arg3, arg4, 0, 0);
3532fa74
FB		 8899 break;
8900#endif
8901#ifdef TARGET_NR_recvfrom
8902 case TARGET_NR_recvfrom:
214201bd 8903 ret = do_recvfrom(arg1, arg2, arg3, arg4, arg5, arg6);
3532fa74
FB		 8904 break;
8905#endif
8906#ifdef TARGET_NR_recvmsg
8907 case TARGET_NR_recvmsg:
8908 ret = do_sendrecvmsg(arg1, arg2, arg3, 0);
8909 break;
8910#endif
8911#ifdef TARGET_NR_send
8912 case TARGET_NR_send:
1be9e1dc 8913 ret = do_sendto(arg1, arg2, arg3, arg4, 0, 0);
3532fa74
FB		 8914 break;
8915#endif
8916#ifdef TARGET_NR_sendmsg
8917 case TARGET_NR_sendmsg:
8918 ret = do_sendrecvmsg(arg1, arg2, arg3, 1);
8919 break;
8920#endif
f19e00d7
AG		 8921#ifdef TARGET_NR_sendmmsg
8922 case TARGET_NR_sendmmsg:
8923 ret = do_sendrecvmmsg(arg1, arg2, arg3, arg4, 1);
8924 break;
8925 case TARGET_NR_recvmmsg:
8926 ret = do_sendrecvmmsg(arg1, arg2, arg3, arg4, 0);
8927 break;
8928#endif
3532fa74
FB		 8929#ifdef TARGET_NR_sendto
8930 case TARGET_NR_sendto:
1be9e1dc 8931 ret = do_sendto(arg1, arg2, arg3, arg4, arg5, arg6);
3532fa74
FB		 8932 break;
8933#endif
8934#ifdef TARGET_NR_shutdown
8935 case TARGET_NR_shutdown:
1be9e1dc 8936 ret = get_errno(shutdown(arg1, arg2));
3532fa74
FB		 8937 break;
8938#endif
f894efd1
LV		 8939#if defined(TARGET_NR_getrandom) && defined(__NR_getrandom)
8940 case TARGET_NR_getrandom:
8941 p = lock_user(VERIFY_WRITE, arg1, arg2, 0);
8942 if (!p) {
8943 goto efault;
8944 }
8945 ret = get_errno(getrandom(p, arg2, arg3));
8946 unlock_user(p, arg1, ret);
8947 break;
8948#endif
3532fa74
FB		 8949#ifdef TARGET_NR_socket
8950 case TARGET_NR_socket:
8951 ret = do_socket(arg1, arg2, arg3);
e36800c9 8952 fd_trans_unregister(ret);
3532fa74
FB		 8953 break;
8954#endif
8955#ifdef TARGET_NR_socketpair
8956 case TARGET_NR_socketpair:
1be9e1dc 8957 ret = do_socketpair(arg1, arg2, arg3, arg4);
3532fa74
FB		 8958 break;
8959#endif
8960#ifdef TARGET_NR_setsockopt
8961 case TARGET_NR_setsockopt:
8962 ret = do_setsockopt(arg1, arg2, arg3, arg4, (socklen_t) arg5);
8963 break;
8964#endif
7494b0f9 8965
31e31b8a 8966 case TARGET_NR_syslog:
579a97f7
FB		 8967 if (!(p = lock_user_string(arg2)))
8968 goto efault;
e5574487
TS		 8969 ret = get_errno(sys_syslog((int)arg1, p, (int)arg3));
8970 unlock_user(p, arg2, 0);
7494b0f9
TS		 8971 break;
8972
31e31b8a 8973 case TARGET_NR_setitimer:
66fb9763 8974 {
66fb9763
FB		 8975 struct itimerval value, ovalue, *pvalue;
8976
53a5960a 8977 if (arg2) {
66fb9763 8978 pvalue = &value;
788f5ec4
TS		 8979 if (copy_from_user_timeval(&pvalue->it_interval, arg2)
8980 || copy_from_user_timeval(&pvalue->it_value,
8981 arg2 + sizeof(struct target_timeval)))
8982 goto efault;
66fb9763
FB		 8983 } else {
8984 pvalue = NULL;
8985 }
8986 ret = get_errno(setitimer(arg1, pvalue, &ovalue));
53a5960a 8987 if (!is_error(ret) && arg3) {
788f5ec4
TS		 8988 if (copy_to_user_timeval(arg3,
8989 &ovalue.it_interval)
8990 || copy_to_user_timeval(arg3 + sizeof(struct target_timeval),
8991 &ovalue.it_value))
8992 goto efault;
66fb9763
FB		 8993 }
8994 }
8995 break;
31e31b8a 8996 case TARGET_NR_getitimer:
66fb9763 8997 {
66fb9763 8998 struct itimerval value;
3b46e624 8999
66fb9763 9000 ret = get_errno(getitimer(arg1, &value));
53a5960a 9001 if (!is_error(ret) && arg2) {
788f5ec4
TS		 9002 if (copy_to_user_timeval(arg2,
9003 &value.it_interval)
9004 || copy_to_user_timeval(arg2 + sizeof(struct target_timeval),
9005 &value.it_value))
9006 goto efault;
66fb9763
FB		 9007 }
9008 }
9009 break;
704eff6c 9010#ifdef TARGET_NR_stat
31e31b8a 9011 case TARGET_NR_stat:
579a97f7
FB		 9012 if (!(p = lock_user_string(arg1)))
9013 goto efault;
53a5960a
PB		 9014 ret = get_errno(stat(path(p), &st));
9015 unlock_user(p, arg1, 0);
31e31b8a 9016 goto do_stat;
704eff6c
CG		 9017#endif
9018#ifdef TARGET_NR_lstat
31e31b8a 9019 case TARGET_NR_lstat:
579a97f7
FB		 9020 if (!(p = lock_user_string(arg1)))
9021 goto efault;
53a5960a
PB		 9022 ret = get_errno(lstat(path(p), &st));
9023 unlock_user(p, arg1, 0);
31e31b8a 9024 goto do_stat;
704eff6c 9025#endif
31e31b8a
FB		 9026 case TARGET_NR_fstat:
9027 {
9028 ret = get_errno(fstat(arg1, &st));
704eff6c 9029#if defined(TARGET_NR_stat) || defined(TARGET_NR_lstat)
31e31b8a 9030 do_stat:
704eff6c 9031#endif
31e31b8a 9032 if (!is_error(ret)) {
53a5960a 9033 struct target_stat *target_st;
e3584658 9034
579a97f7
FB		 9035 if (!lock_user_struct(VERIFY_WRITE, target_st, arg2, 0))
9036 goto efault;
12727917 9037 memset(target_st, 0, sizeof(*target_st));
d2fd1af7
FB		 9038 __put_user(st.st_dev, &target_st->st_dev);
9039 __put_user(st.st_ino, &target_st->st_ino);
9040 __put_user(st.st_mode, &target_st->st_mode);
9041 __put_user(st.st_uid, &target_st->st_uid);
9042 __put_user(st.st_gid, &target_st->st_gid);
9043 __put_user(st.st_nlink, &target_st->st_nlink);
9044 __put_user(st.st_rdev, &target_st->st_rdev);
9045 __put_user(st.st_size, &target_st->st_size);
9046 __put_user(st.st_blksize, &target_st->st_blksize);
9047 __put_user(st.st_blocks, &target_st->st_blocks);
9048 __put_user(st.st_atime, &target_st->target_st_atime);
9049 __put_user(st.st_mtime, &target_st->target_st_mtime);
9050 __put_user(st.st_ctime, &target_st->target_st_ctime);
53a5960a 9051 unlock_user_struct(target_st, arg2, 1);
31e31b8a
FB		 9052 }
9053 }
9054 break;
ebc05488 9055#ifdef TARGET_NR_olduname
31e31b8a
FB		 9056 case TARGET_NR_olduname:
9057 goto unimplemented;
ebc05488
FB		 9058#endif
9059#ifdef TARGET_NR_iopl
31e31b8a
FB		 9060 case TARGET_NR_iopl:
9061 goto unimplemented;
ebc05488 9062#endif
31e31b8a
FB		 9063 case TARGET_NR_vhangup:
9064 ret = get_errno(vhangup());
9065 break;
ebc05488 9066#ifdef TARGET_NR_idle
31e31b8a
FB		 9067 case TARGET_NR_idle:
9068 goto unimplemented;
42ad6ae9
FB		 9069#endif
9070#ifdef TARGET_NR_syscall
9071 case TARGET_NR_syscall:
5945cfcb
PM		 9072 ret = do_syscall(cpu_env, arg1 & 0xffff, arg2, arg3, arg4, arg5,
9073 arg6, arg7, arg8, 0);
9074 break;
ebc05488 9075#endif
31e31b8a
FB		 9076 case TARGET_NR_wait4:
9077 {
9078 int status;
992f48a0 9079 abi_long status_ptr = arg2;
31e31b8a 9080 struct rusage rusage, *rusage_ptr;
992f48a0 9081 abi_ulong target_rusage = arg4;
a39fb273 9082 abi_long rusage_err;
31e31b8a
FB		 9083 if (target_rusage)
9084 rusage_ptr = &rusage;
9085 else
9086 rusage_ptr = NULL;
4af80a37 9087 ret = get_errno(safe_wait4(arg1, &status, arg3, rusage_ptr));
31e31b8a 9088 if (!is_error(ret)) {
5379557b 9089 if (status_ptr && ret) {
1d9d8b55 9090 status = host_to_target_waitstatus(status);
2f619698
FB		 9091 if (put_user_s32(status, status_ptr))
9092 goto efault;
31e31b8a 9093 }
a39fb273
PJ		 9094 if (target_rusage) {
9095 rusage_err = host_to_target_rusage(target_rusage, &rusage);
9096 if (rusage_err) {
9097 ret = rusage_err;
9098 }
9099 }
31e31b8a
FB		 9100 }
9101 }
9102 break;
e5febef5 9103#ifdef TARGET_NR_swapoff
31e31b8a 9104 case TARGET_NR_swapoff:
579a97f7
FB		 9105 if (!(p = lock_user_string(arg1)))
9106 goto efault;
53a5960a
PB		 9107 ret = get_errno(swapoff(p));
9108 unlock_user(p, arg1, 0);
31e31b8a 9109 break;
e5febef5 9110#endif
31e31b8a 9111 case TARGET_NR_sysinfo:
a5448a7d 9112 {
53a5960a 9113 struct target_sysinfo *target_value;
a5448a7d
FB		 9114 struct sysinfo value;
9115 ret = get_errno(sysinfo(&value));
53a5960a 9116 if (!is_error(ret) && arg1)
a5448a7d 9117 {
579a97f7
FB		 9118 if (!lock_user_struct(VERIFY_WRITE, target_value, arg1, 0))
9119 goto efault;
a5448a7d
FB		 9120 __put_user(value.uptime, &target_value->uptime);
9121 __put_user(value.loads[0], &target_value->loads[0]);
9122 __put_user(value.loads[1], &target_value->loads[1]);
9123 __put_user(value.loads[2], &target_value->loads[2]);
9124 __put_user(value.totalram, &target_value->totalram);
9125 __put_user(value.freeram, &target_value->freeram);
9126 __put_user(value.sharedram, &target_value->sharedram);
9127 __put_user(value.bufferram, &target_value->bufferram);
9128 __put_user(value.totalswap, &target_value->totalswap);
9129 __put_user(value.freeswap, &target_value->freeswap);
9130 __put_user(value.procs, &target_value->procs);
9131 __put_user(value.totalhigh, &target_value->totalhigh);
9132 __put_user(value.freehigh, &target_value->freehigh);
9133 __put_user(value.mem_unit, &target_value->mem_unit);
53a5960a 9134 unlock_user_struct(target_value, arg1, 1);
a5448a7d
FB		 9135 }
9136 }
9137 break;
e5febef5 9138#ifdef TARGET_NR_ipc
31e31b8a 9139 case TARGET_NR_ipc:
8853f86e
FB		 9140 ret = do_ipc(arg1, arg2, arg3, arg4, arg5, arg6);
9141 break;
e5febef5 9142#endif
e5289087
AJ		 9143#ifdef TARGET_NR_semget
9144 case TARGET_NR_semget:
9145 ret = get_errno(semget(arg1, arg2, arg3));
9146 break;
9147#endif
9148#ifdef TARGET_NR_semop
9149 case TARGET_NR_semop:
c7128c9f 9150 ret = do_semop(arg1, arg2, arg3);
e5289087
AJ		 9151 break;
9152#endif
9153#ifdef TARGET_NR_semctl
9154 case TARGET_NR_semctl:
d1c002b6 9155 ret = do_semctl(arg1, arg2, arg3, arg4);
e5289087
AJ		 9156 break;
9157#endif
eeb438c1
AJ		 9158#ifdef TARGET_NR_msgctl
9159 case TARGET_NR_msgctl:
9160 ret = do_msgctl(arg1, arg2, arg3);
9161 break;
9162#endif
9163#ifdef TARGET_NR_msgget
9164 case TARGET_NR_msgget:
9165 ret = get_errno(msgget(arg1, arg2));
9166 break;
9167#endif
9168#ifdef TARGET_NR_msgrcv
9169 case TARGET_NR_msgrcv:
9170 ret = do_msgrcv(arg1, arg2, arg3, arg4, arg5);
9171 break;
9172#endif
9173#ifdef TARGET_NR_msgsnd
9174 case TARGET_NR_msgsnd:
9175 ret = do_msgsnd(arg1, arg2, arg3, arg4);
9176 break;
88a8c984
RV		 9177#endif
9178#ifdef TARGET_NR_shmget
9179 case TARGET_NR_shmget:
9180 ret = get_errno(shmget(arg1, arg2, arg3));
9181 break;
9182#endif
9183#ifdef TARGET_NR_shmctl
9184 case TARGET_NR_shmctl:
9185 ret = do_shmctl(arg1, arg2, arg3);
9186 break;
9187#endif
9188#ifdef TARGET_NR_shmat
9189 case TARGET_NR_shmat:
9190 ret = do_shmat(arg1, arg2, arg3);
9191 break;
9192#endif
9193#ifdef TARGET_NR_shmdt
9194 case TARGET_NR_shmdt:
9195 ret = do_shmdt(arg1);
9196 break;
eeb438c1 9197#endif
31e31b8a
FB		 9198 case TARGET_NR_fsync:
9199 ret = get_errno(fsync(arg1));
9200 break;
31e31b8a 9201 case TARGET_NR_clone:
4ce6243d
PM		 9202 /* Linux manages to have three different orderings for its
9203 * arguments to clone(); the BACKWARDS and BACKWARDS2 defines
9204 * match the kernel's CONFIG_CLONE_* settings.
9205 * Microblaze is further special in that it uses a sixth
9206 * implicit argument to clone for the TLS pointer.
9207 */
9208#if defined(TARGET_MICROBLAZE)
a5b3bdcb 9209 ret = get_errno(do_fork(cpu_env, arg1, arg2, arg4, arg6, arg5));
4ce6243d
PM		 9210#elif defined(TARGET_CLONE_BACKWARDS)
9211 ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg4, arg5));
9212#elif defined(TARGET_CLONE_BACKWARDS2)
a4c075f1 9213 ret = get_errno(do_fork(cpu_env, arg2, arg1, arg3, arg5, arg4));
0b6d3ae0 9214#else
4ce6243d 9215 ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg5, arg4));
0b6d3ae0 9216#endif
1b6b029e 9217 break;
ec86b0fb
FB		 9218#ifdef __NR_exit_group
9219 /* new thread calls */
9220 case TARGET_NR_exit_group:
9788c9ca 9221#ifdef TARGET_GPROF
6d946cda
AJ		 9222 _mcleanup();
9223#endif
e9009676 9224 gdb_exit(cpu_env, arg1);
ec86b0fb
FB		 9225 ret = get_errno(exit_group(arg1));
9226 break;
9227#endif
31e31b8a 9228 case TARGET_NR_setdomainname:
579a97f7
FB		 9229 if (!(p = lock_user_string(arg1)))
9230 goto efault;
53a5960a
PB		 9231 ret = get_errno(setdomainname(p, arg2));
9232 unlock_user(p, arg1, 0);
31e31b8a
FB		 9233 break;
9234 case TARGET_NR_uname:
9235 /* no need to transcode because we use the linux syscall */
29e619b1
FB		 9236 {
9237 struct new_utsname * buf;
3b46e624 9238
579a97f7
FB		 9239 if (!lock_user_struct(VERIFY_WRITE, buf, arg1, 0))
9240 goto efault;
29e619b1
FB		 9241 ret = get_errno(sys_uname(buf));
9242 if (!is_error(ret)) {
332c9781 9243 /* Overwrite the native machine name with whatever is being
29e619b1 9244 emulated. */
da79030f 9245 strcpy (buf->machine, cpu_to_uname_machine(cpu_env));
c5937220 9246 /* Allow the user to override the reported release. */
332c9781
PM		 9247 if (qemu_uname_release && *qemu_uname_release) {
9248 g_strlcpy(buf->release, qemu_uname_release,
9249 sizeof(buf->release));
9250 }
29e619b1 9251 }
53a5960a 9252 unlock_user_struct(buf, arg1, 1);
29e619b1 9253 }
31e31b8a 9254 break;
6dbad63e 9255#ifdef TARGET_I386
31e31b8a 9256 case TARGET_NR_modify_ldt:
03acab66 9257 ret = do_modify_ldt(cpu_env, arg1, arg2, arg3);
5cd4393b 9258 break;
84409ddb 9259#if !defined(TARGET_X86_64)
5cd4393b
FB		 9260 case TARGET_NR_vm86old:
9261 goto unimplemented;
9262 case TARGET_NR_vm86:
53a5960a 9263 ret = do_vm86(cpu_env, arg1, arg2);
6dbad63e 9264 break;
84409ddb 9265#endif
6dbad63e 9266#endif
31e31b8a
FB		 9267 case TARGET_NR_adjtimex:
9268 goto unimplemented;
e5febef5 9269#ifdef TARGET_NR_create_module
31e31b8a 9270 case TARGET_NR_create_module:
e5febef5 9271#endif
31e31b8a
FB		 9272 case TARGET_NR_init_module:
9273 case TARGET_NR_delete_module:
e5febef5 9274#ifdef TARGET_NR_get_kernel_syms
31e31b8a 9275 case TARGET_NR_get_kernel_syms:
e5febef5 9276#endif
31e31b8a
FB		 9277 goto unimplemented;
9278 case TARGET_NR_quotactl:
9279 goto unimplemented;
9280 case TARGET_NR_getpgid:
9281 ret = get_errno(getpgid(arg1));
9282 break;
9283 case TARGET_NR_fchdir:
9284 ret = get_errno(fchdir(arg1));
9285 break;
84409ddb 9286#ifdef TARGET_NR_bdflush /* not on x86_64 */
31e31b8a
FB		 9287 case TARGET_NR_bdflush:
9288 goto unimplemented;
84409ddb 9289#endif
e5febef5 9290#ifdef TARGET_NR_sysfs
31e31b8a
FB		 9291 case TARGET_NR_sysfs:
9292 goto unimplemented;
e5febef5 9293#endif
31e31b8a 9294 case TARGET_NR_personality:
1b6b029e 9295 ret = get_errno(personality(arg1));
31e31b8a 9296 break;
e5febef5 9297#ifdef TARGET_NR_afs_syscall
31e31b8a
FB		 9298 case TARGET_NR_afs_syscall:
9299 goto unimplemented;
e5febef5 9300#endif
7a3148a9 9301#ifdef TARGET_NR__llseek /* Not on alpha */
31e31b8a
FB		 9302 case TARGET_NR__llseek:
9303 {
0c1592d9 9304 int64_t res;
d35b261c 9305#if !defined(__NR_llseek)
0c1592d9
PM		 9306 res = lseek(arg1, ((uint64_t)arg2 << 32) | arg3, arg5);
9307 if (res == -1) {
9308 ret = get_errno(res);
9309 } else {
9310 ret = 0;
9311 }
4f2ac237 9312#else
31e31b8a 9313 ret = get_errno(_llseek(arg1, arg2, arg3, &res, arg5));
4f2ac237 9314#endif
0c1592d9
PM		 9315 if ((ret == 0) && put_user_s64(res, arg4)) {
9316 goto efault;
9317 }
31e31b8a
FB		 9318 }
9319 break;
7a3148a9 9320#endif
704eff6c 9321#ifdef TARGET_NR_getdents
31e31b8a 9322 case TARGET_NR_getdents:
3307e236 9323#ifdef __NR_getdents
d83c8733 9324#if TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64
4add45b4 9325 {
53a5960a 9326 struct target_dirent *target_dirp;
6556a833 9327 struct linux_dirent *dirp;
992f48a0 9328 abi_long count = arg3;
4add45b4 9329
0e173b24
HK		 9330 dirp = g_try_malloc(count);
9331 if (!dirp) {
579a97f7 9332 ret = -TARGET_ENOMEM;
0da46a6e
TS		 9333 goto fail;
9334 }
3b46e624 9335
4add45b4
FB		 9336 ret = get_errno(sys_getdents(arg1, dirp, count));
9337 if (!is_error(ret)) {
6556a833 9338 struct linux_dirent *de;
4add45b4
FB		 9339 struct target_dirent *tde;
9340 int len = ret;
9341 int reclen, treclen;
9342 int count1, tnamelen;
9343
9344 count1 = 0;
9345 de = dirp;
579a97f7
FB		 9346 if (!(target_dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
9347 goto efault;
4add45b4
FB		 9348 tde = target_dirp;
9349 while (len > 0) {
9350 reclen = de->d_reclen;
333858b7
DL		 9351 tnamelen = reclen - offsetof(struct linux_dirent, d_name);
9352 assert(tnamelen >= 0);
9353 treclen = tnamelen + offsetof(struct target_dirent, d_name);
9354 assert(count1 + treclen <= count);
4add45b4 9355 tde->d_reclen = tswap16(treclen);
cbb21eed
MB		 9356 tde->d_ino = tswapal(de->d_ino);
9357 tde->d_off = tswapal(de->d_off);
333858b7 9358 memcpy(tde->d_name, de->d_name, tnamelen);
6556a833 9359 de = (struct linux_dirent *)((char *)de + reclen);
4add45b4 9360 len -= reclen;
1c5bf3bf 9361 tde = (struct target_dirent *)((char *)tde + treclen);
4add45b4
FB		 9362 count1 += treclen;
9363 }
9364 ret = count1;
579a97f7 9365 unlock_user(target_dirp, arg2, ret);
4add45b4 9366 }
0e173b24 9367 g_free(dirp);
4add45b4
FB		 9368 }
9369#else
31e31b8a 9370 {
6556a833 9371 struct linux_dirent *dirp;
992f48a0 9372 abi_long count = arg3;
dab2ed99 9373
579a97f7
FB		 9374 if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
9375 goto efault;
72f03900 9376 ret = get_errno(sys_getdents(arg1, dirp, count));
31e31b8a 9377 if (!is_error(ret)) {
6556a833 9378 struct linux_dirent *de;
31e31b8a
FB		 9379 int len = ret;
9380 int reclen;
9381 de = dirp;
9382 while (len > 0) {
8083a3e5 9383 reclen = de->d_reclen;
31e31b8a
FB		 9384 if (reclen > len)
9385 break;
8083a3e5 9386 de->d_reclen = tswap16(reclen);
31e31b8a
FB		 9387 tswapls(&de->d_ino);
9388 tswapls(&de->d_off);
6556a833 9389 de = (struct linux_dirent *)((char *)de + reclen);
31e31b8a
FB		 9390 len -= reclen;
9391 }
9392 }
53a5960a 9393 unlock_user(dirp, arg2, ret);
3307e236
PM		 9394 }
9395#endif
9396#else
9397 /* Implement getdents in terms of getdents64 */
9398 {
9399 struct linux_dirent64 *dirp;
9400 abi_long count = arg3;
9401
9402 dirp = lock_user(VERIFY_WRITE, arg2, count, 0);
9403 if (!dirp) {
9404 goto efault;
9405 }
9406 ret = get_errno(sys_getdents64(arg1, dirp, count));
9407 if (!is_error(ret)) {
9408 /* Convert the dirent64 structs to target dirent. We do this
9409 * in-place, since we can guarantee that a target_dirent is no
9410 * larger than a dirent64; however this means we have to be
9411 * careful to read everything before writing in the new format.
9412 */
9413 struct linux_dirent64 *de;
9414 struct target_dirent *tde;
9415 int len = ret;
9416 int tlen = 0;
9417
9418 de = dirp;
9419 tde = (struct target_dirent *)dirp;
9420 while (len > 0) {
9421 int namelen, treclen;
9422 int reclen = de->d_reclen;
9423 uint64_t ino = de->d_ino;
9424 int64_t off = de->d_off;
9425 uint8_t type = de->d_type;
9426
9427 namelen = strlen(de->d_name);
9428 treclen = offsetof(struct target_dirent, d_name)
9429 + namelen + 2;
9430 treclen = QEMU_ALIGN_UP(treclen, sizeof(abi_long));
9431
9432 memmove(tde->d_name, de->d_name, namelen + 1);
9433 tde->d_ino = tswapal(ino);
9434 tde->d_off = tswapal(off);
9435 tde->d_reclen = tswap16(treclen);
9436 /* The target_dirent type is in what was formerly a padding
9437 * byte at the end of the structure:
9438 */
9439 *(((char *)tde) + treclen - 1) = type;
9440
9441 de = (struct linux_dirent64 *)((char *)de + reclen);
9442 tde = (struct target_dirent *)((char *)tde + treclen);
9443 len -= reclen;
9444 tlen += treclen;
9445 }
9446 ret = tlen;
9447 }
9448 unlock_user(dirp, arg2, ret);
31e31b8a 9449 }
4add45b4 9450#endif
31e31b8a 9451 break;
704eff6c 9452#endif /* TARGET_NR_getdents */
3ae43202 9453#if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
dab2ed99
FB		 9454 case TARGET_NR_getdents64:
9455 {
6556a833 9456 struct linux_dirent64 *dirp;
992f48a0 9457 abi_long count = arg3;
579a97f7
FB		 9458 if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
9459 goto efault;
dab2ed99
FB		 9460 ret = get_errno(sys_getdents64(arg1, dirp, count));
9461 if (!is_error(ret)) {
6556a833 9462 struct linux_dirent64 *de;
dab2ed99
FB		 9463 int len = ret;
9464 int reclen;
9465 de = dirp;
9466 while (len > 0) {
8083a3e5 9467 reclen = de->d_reclen;
dab2ed99
FB		 9468 if (reclen > len)
9469 break;
8083a3e5 9470 de->d_reclen = tswap16(reclen);
8582a53a
FB		 9471 tswap64s((uint64_t *)&de->d_ino);
9472 tswap64s((uint64_t *)&de->d_off);
6556a833 9473 de = (struct linux_dirent64 *)((char *)de + reclen);
dab2ed99
FB		 9474 len -= reclen;
9475 }
9476 }
53a5960a 9477 unlock_user(dirp, arg2, ret);
dab2ed99
FB		 9478 }
9479 break;
a541f297 9480#endif /* TARGET_NR_getdents64 */
9468a5d4 9481#if defined(TARGET_NR__newselect)
31e31b8a 9482 case TARGET_NR__newselect:
53a5960a 9483 ret = do_select(arg1, arg2, arg3, arg4, arg5);
31e31b8a 9484 break;
e5febef5 9485#endif
d8035d4c
MF		 9486#if defined(TARGET_NR_poll) || defined(TARGET_NR_ppoll)
9487# ifdef TARGET_NR_poll
9de5e440 9488 case TARGET_NR_poll:
d8035d4c
MF		 9489# endif
9490# ifdef TARGET_NR_ppoll
9491 case TARGET_NR_ppoll:
9492# endif
9de5e440 9493 {
53a5960a 9494 struct target_pollfd *target_pfd;
9de5e440 9495 unsigned int nfds = arg2;
9de5e440 9496 struct pollfd *pfd;
7854b056 9497 unsigned int i;
9de5e440 9498
3e24bb3f
LV		 9499 pfd = NULL;
9500 target_pfd = NULL;
9501 if (nfds) {
9502 target_pfd = lock_user(VERIFY_WRITE, arg1,
9503 sizeof(struct target_pollfd) * nfds, 1);
9504 if (!target_pfd) {
9505 goto efault;
9506 }
d8035d4c 9507
3e24bb3f
LV		 9508 pfd = alloca(sizeof(struct pollfd) * nfds);
9509 for (i = 0; i < nfds; i++) {
9510 pfd[i].fd = tswap32(target_pfd[i].fd);
9511 pfd[i].events = tswap16(target_pfd[i].events);
9512 }
9de5e440 9513 }
d8035d4c 9514
a6130237 9515 switch (num) {
d8035d4c 9516# ifdef TARGET_NR_ppoll
a6130237
PM		 9517 case TARGET_NR_ppoll:
9518 {
d8035d4c
MF		 9519 struct timespec _timeout_ts, *timeout_ts = &_timeout_ts;
9520 target_sigset_t *target_set;
9521 sigset_t _set, *set = &_set;
9522
9523 if (arg3) {
9524 if (target_to_host_timespec(timeout_ts, arg3)) {
9525 unlock_user(target_pfd, arg1, 0);
9526 goto efault;
9527 }
9528 } else {
9529 timeout_ts = NULL;
9530 }
9531
9532 if (arg4) {
c815701e
PM		 9533 if (arg5 != sizeof(target_sigset_t)) {
9534 unlock_user(target_pfd, arg1, 0);
9535 ret = -TARGET_EINVAL;
9536 break;
9537 }
9538
d8035d4c
MF		 9539 target_set = lock_user(VERIFY_READ, arg4, sizeof(target_sigset_t), 1);
9540 if (!target_set) {
9541 unlock_user(target_pfd, arg1, 0);
9542 goto efault;
9543 }
9544 target_to_host_sigset(set, target_set);
9545 } else {
9546 set = NULL;
9547 }
9548
a6130237
PM		 9549 ret = get_errno(safe_ppoll(pfd, nfds, timeout_ts,
9550 set, SIGSET_T_SIZE));
d8035d4c
MF		 9551
9552 if (!is_error(ret) && arg3) {
9553 host_to_target_timespec(arg3, timeout_ts);
9554 }
9555 if (arg4) {
9556 unlock_user(target_set, arg4, 0);
9557 }
a6130237
PM		 9558 break;
9559 }
d8035d4c 9560# endif
a6130237
PM		 9561# ifdef TARGET_NR_poll
9562 case TARGET_NR_poll:
9563 {
9564 struct timespec ts, *pts;
9565
9566 if (arg3 >= 0) {
9567 /* Convert ms to secs, ns */
9568 ts.tv_sec = arg3 / 1000;
9569 ts.tv_nsec = (arg3 % 1000) * 1000000LL;
9570 pts = &ts;
9571 } else {
9572 /* -ve poll() timeout means "infinite" */
9573 pts = NULL;
9574 }
9575 ret = get_errno(safe_ppoll(pfd, nfds, pts, NULL, 0));
9576 break;
9577 }
d8035d4c 9578# endif
a6130237
PM		 9579 default:
9580 g_assert_not_reached();
9581 }
d8035d4c 9582
9de5e440
FB		 9583 if (!is_error(ret)) {
9584 for(i = 0; i < nfds; i++) {
5cd4393b 9585 target_pfd[i].revents = tswap16(pfd[i].revents);
9de5e440
FB		 9586 }
9587 }
30cb4cde 9588 unlock_user(target_pfd, arg1, sizeof(struct target_pollfd) * nfds);
9de5e440
FB		 9589 }
9590 break;
e5febef5 9591#endif
31e31b8a 9592 case TARGET_NR_flock:
9de5e440
FB		 9593 /* NOTE: the flock constant seems to be the same for every
9594 Linux platform */
2a845989 9595 ret = get_errno(safe_flock(arg1, arg2));
31e31b8a
FB		 9596 break;
9597 case TARGET_NR_readv:
9598 {
f287b2c2
RH		 9599 struct iovec *vec = lock_iovec(VERIFY_WRITE, arg2, arg3, 0);
9600 if (vec != NULL) {
918c03ed 9601 ret = get_errno(safe_readv(arg1, vec, arg3));
f287b2c2
RH		 9602 unlock_iovec(vec, arg2, arg3, 1);
9603 } else {
9604 ret = -host_to_target_errno(errno);
9605 }
31e31b8a
FB		 9606 }
9607 break;
9608 case TARGET_NR_writev:
9609 {
f287b2c2
RH		 9610 struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1);
9611 if (vec != NULL) {
918c03ed 9612 ret = get_errno(safe_writev(arg1, vec, arg3));
f287b2c2
RH		 9613 unlock_iovec(vec, arg2, arg3, 0);
9614 } else {
9615 ret = -host_to_target_errno(errno);
9616 }
31e31b8a
FB		 9617 }
9618 break;
9619 case TARGET_NR_getsid:
9620 ret = get_errno(getsid(arg1));
9621 break;
7a3148a9 9622#if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */
31e31b8a 9623 case TARGET_NR_fdatasync:
5cd4393b
FB		 9624 ret = get_errno(fdatasync(arg1));
9625 break;
7a3148a9 9626#endif
704eff6c 9627#ifdef TARGET_NR__sysctl
31e31b8a 9628 case TARGET_NR__sysctl:
0da46a6e 9629 /* We don't implement this, but ENOTDIR is always a safe
29e619b1 9630 return value. */
0da46a6e
TS		 9631 ret = -TARGET_ENOTDIR;
9632 break;
704eff6c 9633#endif
737de1d1
MF		 9634 case TARGET_NR_sched_getaffinity:
9635 {
9636 unsigned int mask_size;
9637 unsigned long *mask;
9638
9639 /*
9640 * sched_getaffinity needs multiples of ulong, so need to take
9641 * care of mismatches between target ulong and host ulong sizes.
9642 */
9643 if (arg2 & (sizeof(abi_ulong) - 1)) {
9644 ret = -TARGET_EINVAL;
9645 break;
9646 }
9647 mask_size = (arg2 + (sizeof(*mask) - 1)) & ~(sizeof(*mask) - 1);
9648
9649 mask = alloca(mask_size);
9650 ret = get_errno(sys_sched_getaffinity(arg1, mask_size, mask));
9651
9652 if (!is_error(ret)) {
be3bd286
PM		 9653 if (ret > arg2) {
9654 /* More data returned than the caller's buffer will fit.
9655 * This only happens if sizeof(abi_long) < sizeof(long)
9656 * and the caller passed us a buffer holding an odd number
9657 * of abi_longs. If the host kernel is actually using the
9658 * extra 4 bytes then fail EINVAL; otherwise we can just
9659 * ignore them and only copy the interesting part.
9660 */
9661 int numcpus = sysconf(_SC_NPROCESSORS_CONF);
9662 if (numcpus > arg2 * 8) {
9663 ret = -TARGET_EINVAL;
9664 break;
9665 }
9666 ret = arg2;
9667 }
9668
cd18f05e 9669 if (copy_to_user(arg3, mask, ret)) {
737de1d1
MF		 9670 goto efault;
9671 }
737de1d1
MF		 9672 }
9673 }
9674 break;
9675 case TARGET_NR_sched_setaffinity:
9676 {
9677 unsigned int mask_size;
9678 unsigned long *mask;
9679
9680 /*
9681 * sched_setaffinity needs multiples of ulong, so need to take
9682 * care of mismatches between target ulong and host ulong sizes.
9683 */
9684 if (arg2 & (sizeof(abi_ulong) - 1)) {
9685 ret = -TARGET_EINVAL;
9686 break;
9687 }
9688 mask_size = (arg2 + (sizeof(*mask) - 1)) & ~(sizeof(*mask) - 1);
9689
9690 mask = alloca(mask_size);
9691 if (!lock_user_struct(VERIFY_READ, p, arg3, 1)) {
9692 goto efault;
9693 }
9694 memcpy(mask, p, arg2);
9695 unlock_user_struct(p, arg2, 0);
9696
9697 ret = get_errno(sys_sched_setaffinity(arg1, mask_size, mask));
9698 }
9699 break;
31e31b8a 9700 case TARGET_NR_sched_setparam:
5cd4393b 9701 {
53a5960a 9702 struct sched_param *target_schp;
5cd4393b 9703 struct sched_param schp;
53a5960a 9704
a1d5c5b2
TM		 9705 if (arg2 == 0) {
9706 return -TARGET_EINVAL;
9707 }
579a97f7
FB		 9708 if (!lock_user_struct(VERIFY_READ, target_schp, arg2, 1))
9709 goto efault;
5cd4393b 9710 schp.sched_priority = tswap32(target_schp->sched_priority);
53a5960a 9711 unlock_user_struct(target_schp, arg2, 0);
5cd4393b
FB		 9712 ret = get_errno(sched_setparam(arg1, &schp));
9713 }
9714 break;
31e31b8a 9715 case TARGET_NR_sched_getparam:
5cd4393b 9716 {
53a5960a 9717 struct sched_param *target_schp;
5cd4393b 9718 struct sched_param schp;
a1d5c5b2
TM		 9719
9720 if (arg2 == 0) {
9721 return -TARGET_EINVAL;
9722 }
5cd4393b
FB		 9723 ret = get_errno(sched_getparam(arg1, &schp));
9724 if (!is_error(ret)) {
579a97f7
FB		 9725 if (!lock_user_struct(VERIFY_WRITE, target_schp, arg2, 0))
9726 goto efault;
5cd4393b 9727 target_schp->sched_priority = tswap32(schp.sched_priority);
53a5960a 9728 unlock_user_struct(target_schp, arg2, 1);
5cd4393b
FB		 9729 }
9730 }
9731 break;
31e31b8a 9732 case TARGET_NR_sched_setscheduler:
5cd4393b 9733 {
53a5960a 9734 struct sched_param *target_schp;
5cd4393b 9735 struct sched_param schp;
a1d5c5b2
TM		 9736 if (arg3 == 0) {
9737 return -TARGET_EINVAL;
9738 }
579a97f7
FB		 9739 if (!lock_user_struct(VERIFY_READ, target_schp, arg3, 1))
9740 goto efault;
5cd4393b 9741 schp.sched_priority = tswap32(target_schp->sched_priority);
53a5960a 9742 unlock_user_struct(target_schp, arg3, 0);
5cd4393b
FB		 9743 ret = get_errno(sched_setscheduler(arg1, arg2, &schp));
9744 }
9745 break;
31e31b8a 9746 case TARGET_NR_sched_getscheduler:
5cd4393b
FB		 9747 ret = get_errno(sched_getscheduler(arg1));
9748 break;
31e31b8a
FB		 9749 case TARGET_NR_sched_yield:
9750 ret = get_errno(sched_yield());
9751 break;
9752 case TARGET_NR_sched_get_priority_max:
5cd4393b
FB		 9753 ret = get_errno(sched_get_priority_max(arg1));
9754 break;
31e31b8a 9755 case TARGET_NR_sched_get_priority_min:
5cd4393b
FB		 9756 ret = get_errno(sched_get_priority_min(arg1));
9757 break;
31e31b8a 9758 case TARGET_NR_sched_rr_get_interval:
5cd4393b 9759 {
5cd4393b
FB		 9760 struct timespec ts;
9761 ret = get_errno(sched_rr_get_interval(arg1, &ts));
9762 if (!is_error(ret)) {
d4290c40 9763 ret = host_to_target_timespec(arg2, &ts);
5cd4393b
FB		 9764 }
9765 }
9766 break;
31e31b8a 9767 case TARGET_NR_nanosleep:
1b6b029e 9768 {
1b6b029e 9769 struct timespec req, rem;
53a5960a 9770 target_to_host_timespec(&req, arg1);
9e518226 9771 ret = get_errno(safe_nanosleep(&req, &rem));
53a5960a
PB		 9772 if (is_error(ret) && arg2) {
9773 host_to_target_timespec(arg2, &rem);
1b6b029e
FB		 9774 }
9775 }
9776 break;
e5febef5 9777#ifdef TARGET_NR_query_module
31e31b8a 9778 case TARGET_NR_query_module:
5cd4393b 9779 goto unimplemented;
e5febef5
TS		 9780#endif
9781#ifdef TARGET_NR_nfsservctl
31e31b8a 9782 case TARGET_NR_nfsservctl:
5cd4393b 9783 goto unimplemented;
e5febef5 9784#endif
31e31b8a 9785 case TARGET_NR_prctl:
1e6722f8
PM		 9786 switch (arg1) {
9787 case PR_GET_PDEATHSIG:
9788 {
9789 int deathsig;
9790 ret = get_errno(prctl(arg1, &deathsig, arg3, arg4, arg5));
9791 if (!is_error(ret) && arg2
9792 && put_user_ual(deathsig, arg2)) {
9793 goto efault;
e5574487 9794 }
1e6722f8
PM		 9795 break;
9796 }
db9526b1
PM		 9797#ifdef PR_GET_NAME
9798 case PR_GET_NAME:
9799 {
9800 void *name = lock_user(VERIFY_WRITE, arg2, 16, 1);
9801 if (!name) {
9802 goto efault;
9803 }
9804 ret = get_errno(prctl(arg1, (unsigned long)name,
9805 arg3, arg4, arg5));
9806 unlock_user(name, arg2, 16);
9807 break;
9808 }
9809 case PR_SET_NAME:
9810 {
9811 void *name = lock_user(VERIFY_READ, arg2, 16, 1);
9812 if (!name) {
9813 goto efault;
9814 }
9815 ret = get_errno(prctl(arg1, (unsigned long)name,
9816 arg3, arg4, arg5));
9817 unlock_user(name, arg2, 0);
9818 break;
9819 }
9820#endif
1e6722f8
PM		 9821 default:
9822 /* Most prctl options have no pointer arguments */
9823 ret = get_errno(prctl(arg1, arg2, arg3, arg4, arg5));
9824 break;
9825 }
39b9aae1 9826 break;
d2fd1af7
FB		 9827#ifdef TARGET_NR_arch_prctl
9828 case TARGET_NR_arch_prctl:
9829#if defined(TARGET_I386) && !defined(TARGET_ABI32)
9830 ret = do_arch_prctl(cpu_env, arg1, arg2);
9831 break;
9832#else
9833 goto unimplemented;
9834#endif
9835#endif
f2c7ba15
AJ		 9836#ifdef TARGET_NR_pread64
9837 case TARGET_NR_pread64:
ae017a5b
AG		 9838 if (regpairs_aligned(cpu_env)) {
9839 arg4 = arg5;
9840 arg5 = arg6;
9841 }
f2c7ba15
AJ		 9842 if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
9843 goto efault;
9844 ret = get_errno(pread64(arg1, p, arg3, target_offset64(arg4, arg5)));
9845 unlock_user(p, arg2, ret);
9846 break;
9847 case TARGET_NR_pwrite64:
ae017a5b
AG		 9848 if (regpairs_aligned(cpu_env)) {
9849 arg4 = arg5;
9850 arg5 = arg6;
9851 }
f2c7ba15
AJ		 9852 if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
9853 goto efault;
9854 ret = get_errno(pwrite64(arg1, p, arg3, target_offset64(arg4, arg5)));
9855 unlock_user(p, arg2, 0);
9856 break;
67867308 9857#endif
31e31b8a 9858 case TARGET_NR_getcwd:
579a97f7
FB		 9859 if (!(p = lock_user(VERIFY_WRITE, arg1, arg2, 0)))
9860 goto efault;
53a5960a
PB		 9861 ret = get_errno(sys_getcwd1(p, arg2));
9862 unlock_user(p, arg1, ret);
31e31b8a
FB		 9863 break;
9864 case TARGET_NR_capget:
9865 case TARGET_NR_capset:
e0eb210e
PM		 9866 {
9867 struct target_user_cap_header *target_header;
9868 struct target_user_cap_data *target_data = NULL;
9869 struct __user_cap_header_struct header;
9870 struct __user_cap_data_struct data[2];
9871 struct __user_cap_data_struct *dataptr = NULL;
9872 int i, target_datalen;
9873 int data_items = 1;
9874
9875 if (!lock_user_struct(VERIFY_WRITE, target_header, arg1, 1)) {
9876 goto efault;
9877 }
9878 header.version = tswap32(target_header->version);
9879 header.pid = tswap32(target_header->pid);
9880
ec864874 9881 if (header.version != _LINUX_CAPABILITY_VERSION) {
e0eb210e
PM		 9882 /* Version 2 and up takes pointer to two user_data structs */
9883 data_items = 2;
9884 }
9885
9886 target_datalen = sizeof(*target_data) * data_items;
9887
9888 if (arg2) {
9889 if (num == TARGET_NR_capget) {
9890 target_data = lock_user(VERIFY_WRITE, arg2, target_datalen, 0);
9891 } else {
9892 target_data = lock_user(VERIFY_READ, arg2, target_datalen, 1);
9893 }
9894 if (!target_data) {
9895 unlock_user_struct(target_header, arg1, 0);
9896 goto efault;
9897 }
9898
9899 if (num == TARGET_NR_capset) {
9900 for (i = 0; i < data_items; i++) {
9901 data[i].effective = tswap32(target_data[i].effective);
9902 data[i].permitted = tswap32(target_data[i].permitted);
9903 data[i].inheritable = tswap32(target_data[i].inheritable);
9904 }
9905 }
9906
9907 dataptr = data;
9908 }
9909
9910 if (num == TARGET_NR_capget) {
9911 ret = get_errno(capget(&header, dataptr));
9912 } else {
9913 ret = get_errno(capset(&header, dataptr));
9914 }
9915
9916 /* The kernel always updates version for both capget and capset */
9917 target_header->version = tswap32(header.version);
9918 unlock_user_struct(target_header, arg1, 1);
9919
9920 if (arg2) {
9921 if (num == TARGET_NR_capget) {
9922 for (i = 0; i < data_items; i++) {
9923 target_data[i].effective = tswap32(data[i].effective);
9924 target_data[i].permitted = tswap32(data[i].permitted);
9925 target_data[i].inheritable = tswap32(data[i].inheritable);
9926 }
9927 unlock_user(target_data, arg2, target_datalen);
9928 } else {
9929 unlock_user(target_data, arg2, 0);
9930 }
9931 }
9932 break;
9933 }
31e31b8a 9934 case TARGET_NR_sigaltstack:
9349b4f9 9935 ret = do_sigaltstack(arg1, arg2, get_sp_from_cpustate((CPUArchState *)cpu_env));
a04e134a 9936 break;
a8fd1aba
PM		 9937
9938#ifdef CONFIG_SENDFILE
9939 case TARGET_NR_sendfile:
9940 {
9941 off_t *offp = NULL;
9942 off_t off;
9943 if (arg3) {
9944 ret = get_user_sal(off, arg3);
9945 if (is_error(ret)) {
9946 break;
9947 }
9948 offp = &off;
9949 }
9950 ret = get_errno(sendfile(arg1, arg2, offp, arg4));
9951 if (!is_error(ret) && arg3) {
9952 abi_long ret2 = put_user_sal(off, arg3);
9953 if (is_error(ret2)) {
9954 ret = ret2;
9955 }
9956 }
9957 break;
9958 }
9959#ifdef TARGET_NR_sendfile64
9960 case TARGET_NR_sendfile64:
9961 {
9962 off_t *offp = NULL;
9963 off_t off;
9964 if (arg3) {
9965 ret = get_user_s64(off, arg3);
9966 if (is_error(ret)) {
9967 break;
9968 }
9969 offp = &off;
9970 }
9971 ret = get_errno(sendfile(arg1, arg2, offp, arg4));
9972 if (!is_error(ret) && arg3) {
9973 abi_long ret2 = put_user_s64(off, arg3);
9974 if (is_error(ret2)) {
9975 ret = ret2;
9976 }
9977 }
9978 break;
9979 }
9980#endif
9981#else
31e31b8a 9982 case TARGET_NR_sendfile:
7edd2cf1 9983#ifdef TARGET_NR_sendfile64
a8fd1aba
PM		 9984 case TARGET_NR_sendfile64:
9985#endif
5cd4393b 9986 goto unimplemented;
a8fd1aba
PM		 9987#endif
9988
ebc05488 9989#ifdef TARGET_NR_getpmsg
31e31b8a 9990 case TARGET_NR_getpmsg:
5cd4393b 9991 goto unimplemented;
ebc05488
FB		 9992#endif
9993#ifdef TARGET_NR_putpmsg
31e31b8a 9994 case TARGET_NR_putpmsg:
5cd4393b 9995 goto unimplemented;
ebc05488 9996#endif
048f6b4d 9997#ifdef TARGET_NR_vfork
31e31b8a 9998 case TARGET_NR_vfork:
d865bab5
PB		 9999 ret = get_errno(do_fork(cpu_env, CLONE_VFORK | CLONE_VM | SIGCHLD,
10000 0, 0, 0, 0));
31e31b8a 10001 break;
048f6b4d 10002#endif
ebc05488 10003#ifdef TARGET_NR_ugetrlimit
31e31b8a 10004 case TARGET_NR_ugetrlimit:
728584be
FB		 10005 {
10006 struct rlimit rlim;
e22b7015
WT		 10007 int resource = target_to_host_resource(arg1);
10008 ret = get_errno(getrlimit(resource, &rlim));
728584be 10009 if (!is_error(ret)) {
53a5960a 10010 struct target_rlimit *target_rlim;
579a97f7
FB		 10011 if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))
10012 goto efault;
81bbe906
TY		 10013 target_rlim->rlim_cur = host_to_target_rlim(rlim.rlim_cur);
10014 target_rlim->rlim_max = host_to_target_rlim(rlim.rlim_max);
53a5960a 10015 unlock_user_struct(target_rlim, arg2, 1);
728584be
FB		 10016 }
10017 break;
10018 }
ebc05488 10019#endif
a315a145 10020#ifdef TARGET_NR_truncate64
31e31b8a 10021 case TARGET_NR_truncate64:
579a97f7
FB		 10022 if (!(p = lock_user_string(arg1)))
10023 goto efault;
53a5960a
PB		 10024 ret = target_truncate64(cpu_env, p, arg2, arg3, arg4);
10025 unlock_user(p, arg1, 0);
667f38b1 10026 break;
a315a145
FB		 10027#endif
10028#ifdef TARGET_NR_ftruncate64
31e31b8a 10029 case TARGET_NR_ftruncate64:
ce4defa0 10030 ret = target_ftruncate64(cpu_env, arg1, arg2, arg3, arg4);
667f38b1 10031 break;
a315a145
FB		 10032#endif
10033#ifdef TARGET_NR_stat64
31e31b8a 10034 case TARGET_NR_stat64:
579a97f7
FB		 10035 if (!(p = lock_user_string(arg1)))
10036 goto efault;
53a5960a
PB		 10037 ret = get_errno(stat(path(p), &st));
10038 unlock_user(p, arg1, 0);
6a24a778
AZ		 10039 if (!is_error(ret))
10040 ret = host_to_target_stat64(cpu_env, arg2, &st);
10041 break;
a315a145
FB		 10042#endif
10043#ifdef TARGET_NR_lstat64
31e31b8a 10044 case TARGET_NR_lstat64:
579a97f7
FB		 10045 if (!(p = lock_user_string(arg1)))
10046 goto efault;
53a5960a
PB		 10047 ret = get_errno(lstat(path(p), &st));
10048 unlock_user(p, arg1, 0);
6a24a778
AZ		 10049 if (!is_error(ret))
10050 ret = host_to_target_stat64(cpu_env, arg2, &st);
10051 break;
a315a145
FB		 10052#endif
10053#ifdef TARGET_NR_fstat64
31e31b8a 10054 case TARGET_NR_fstat64:
6a24a778
AZ		 10055 ret = get_errno(fstat(arg1, &st));
10056 if (!is_error(ret))
10057 ret = host_to_target_stat64(cpu_env, arg2, &st);
10058 break;
ce4defa0 10059#endif
c0d472b1 10060#if (defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat))
9d33b76b 10061#ifdef TARGET_NR_fstatat64
6a24a778 10062 case TARGET_NR_fstatat64:
9d33b76b
AJ		 10063#endif
10064#ifdef TARGET_NR_newfstatat
10065 case TARGET_NR_newfstatat:
10066#endif
6a24a778
AZ		 10067 if (!(p = lock_user_string(arg2)))
10068 goto efault;
c0d472b1 10069 ret = get_errno(fstatat(arg1, path(p), &st, arg4));
6a24a778
AZ		 10070 if (!is_error(ret))
10071 ret = host_to_target_stat64(cpu_env, arg3, &st);
60cd49d5 10072 break;
a315a145 10073#endif
704eff6c 10074#ifdef TARGET_NR_lchown
67867308 10075 case TARGET_NR_lchown:
579a97f7
FB		 10076 if (!(p = lock_user_string(arg1)))
10077 goto efault;
53a5960a
PB		 10078 ret = get_errno(lchown(p, low2highuid(arg2), low2highgid(arg3)));
10079 unlock_user(p, arg1, 0);
67867308 10080 break;
704eff6c 10081#endif
0c866a7e 10082#ifdef TARGET_NR_getuid
67867308
FB		 10083 case TARGET_NR_getuid:
10084 ret = get_errno(high2lowuid(getuid()));
10085 break;
0c866a7e
RV		 10086#endif
10087#ifdef TARGET_NR_getgid
67867308
FB		 10088 case TARGET_NR_getgid:
10089 ret = get_errno(high2lowgid(getgid()));
10090 break;
0c866a7e
RV		 10091#endif
10092#ifdef TARGET_NR_geteuid
67867308
FB		 10093 case TARGET_NR_geteuid:
10094 ret = get_errno(high2lowuid(geteuid()));
10095 break;
0c866a7e
RV		 10096#endif
10097#ifdef TARGET_NR_getegid
67867308
FB		 10098 case TARGET_NR_getegid:
10099 ret = get_errno(high2lowgid(getegid()));
10100 break;
0c866a7e 10101#endif
67867308
FB		 10102 case TARGET_NR_setreuid:
10103 ret = get_errno(setreuid(low2highuid(arg1), low2highuid(arg2)));
10104 break;
10105 case TARGET_NR_setregid:
10106 ret = get_errno(setregid(low2highgid(arg1), low2highgid(arg2)));
10107 break;
10108 case TARGET_NR_getgroups:
10109 {
10110 int gidsetsize = arg1;
0c866a7e 10111 target_id *target_grouplist;
67867308
FB		 10112 gid_t *grouplist;
10113 int i;
10114
10115 grouplist = alloca(gidsetsize * sizeof(gid_t));
10116 ret = get_errno(getgroups(gidsetsize, grouplist));
cb3bc233
AZ		 10117 if (gidsetsize == 0)
10118 break;
67867308 10119 if (!is_error(ret)) {
03903ffc 10120 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * sizeof(target_id), 0);
579a97f7
FB		 10121 if (!target_grouplist)
10122 goto efault;
a2155fcc 10123 for(i = 0;i < ret; i++)
0c866a7e 10124 target_grouplist[i] = tswapid(high2lowgid(grouplist[i]));
03903ffc 10125 unlock_user(target_grouplist, arg2, gidsetsize * sizeof(target_id));
67867308
FB		 10126 }
10127 }
10128 break;
10129 case TARGET_NR_setgroups:
10130 {
10131 int gidsetsize = arg1;
0c866a7e 10132 target_id *target_grouplist;
f2b79ce9 10133 gid_t *grouplist = NULL;
67867308 10134 int i;
f2b79ce9
DA		 10135 if (gidsetsize) {
10136 grouplist = alloca(gidsetsize * sizeof(gid_t));
03903ffc 10137 target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * sizeof(target_id), 1);
f2b79ce9
DA		 10138 if (!target_grouplist) {
10139 ret = -TARGET_EFAULT;
10140 goto fail;
10141 }
10142 for (i = 0; i < gidsetsize; i++) {
10143 grouplist[i] = low2highgid(tswapid(target_grouplist[i]));
10144 }
10145 unlock_user(target_grouplist, arg2, 0);
579a97f7 10146 }
67867308
FB		 10147 ret = get_errno(setgroups(gidsetsize, grouplist));
10148 }
10149 break;
10150 case TARGET_NR_fchown:
10151 ret = get_errno(fchown(arg1, low2highuid(arg2), low2highgid(arg3)));
10152 break;
c0d472b1 10153#if defined(TARGET_NR_fchownat)
ccfa72b7 10154 case TARGET_NR_fchownat:
579a97f7
FB		 10155 if (!(p = lock_user_string(arg2)))
10156 goto efault;
c0d472b1
PM		 10157 ret = get_errno(fchownat(arg1, p, low2highuid(arg3),
10158 low2highgid(arg4), arg5));
579a97f7 10159 unlock_user(p, arg2, 0);
ccfa72b7
TS		 10160 break;
10161#endif
67867308
FB		 10162#ifdef TARGET_NR_setresuid
10163 case TARGET_NR_setresuid:
fd6f7798
PM		 10164 ret = get_errno(sys_setresuid(low2highuid(arg1),
10165 low2highuid(arg2),
10166 low2highuid(arg3)));
67867308
FB		 10167 break;
10168#endif
10169#ifdef TARGET_NR_getresuid
10170 case TARGET_NR_getresuid:
10171 {
53a5960a 10172 uid_t ruid, euid, suid;
67867308
FB		 10173 ret = get_errno(getresuid(&ruid, &euid, &suid));
10174 if (!is_error(ret)) {
76ca310a
PM		 10175 if (put_user_id(high2lowuid(ruid), arg1)
10176 || put_user_id(high2lowuid(euid), arg2)
10177 || put_user_id(high2lowuid(suid), arg3))
2f619698 10178 goto efault;
67867308
FB		 10179 }
10180 }
10181 break;
10182#endif
10183#ifdef TARGET_NR_getresgid
10184 case TARGET_NR_setresgid:
fd6f7798
PM		 10185 ret = get_errno(sys_setresgid(low2highgid(arg1),
10186 low2highgid(arg2),
10187 low2highgid(arg3)));
67867308
FB		 10188 break;
10189#endif
10190#ifdef TARGET_NR_getresgid
10191 case TARGET_NR_getresgid:
10192 {
53a5960a 10193 gid_t rgid, egid, sgid;
67867308
FB		 10194 ret = get_errno(getresgid(&rgid, &egid, &sgid));
10195 if (!is_error(ret)) {
76ca310a
PM		 10196 if (put_user_id(high2lowgid(rgid), arg1)
10197 || put_user_id(high2lowgid(egid), arg2)
10198 || put_user_id(high2lowgid(sgid), arg3))
2f619698 10199 goto efault;
67867308
FB		 10200 }
10201 }
10202 break;
10203#endif
704eff6c 10204#ifdef TARGET_NR_chown
67867308 10205 case TARGET_NR_chown:
579a97f7
FB		 10206 if (!(p = lock_user_string(arg1)))
10207 goto efault;
53a5960a
PB		 10208 ret = get_errno(chown(p, low2highuid(arg2), low2highgid(arg3)));
10209 unlock_user(p, arg1, 0);
67867308 10210 break;
704eff6c 10211#endif
67867308 10212 case TARGET_NR_setuid:
fd6f7798 10213 ret = get_errno(sys_setuid(low2highuid(arg1)));
67867308
FB		 10214 break;
10215 case TARGET_NR_setgid:
fd6f7798 10216 ret = get_errno(sys_setgid(low2highgid(arg1)));
67867308
FB		 10217 break;
10218 case TARGET_NR_setfsuid:
10219 ret = get_errno(setfsuid(arg1));
10220 break;
10221 case TARGET_NR_setfsgid:
10222 ret = get_errno(setfsgid(arg1));
10223 break;
67867308 10224
a315a145 10225#ifdef TARGET_NR_lchown32
31e31b8a 10226 case TARGET_NR_lchown32:
579a97f7
FB		 10227 if (!(p = lock_user_string(arg1)))
10228 goto efault;
53a5960a
PB		 10229 ret = get_errno(lchown(p, arg2, arg3));
10230 unlock_user(p, arg1, 0);
b03c60f3 10231 break;
a315a145
FB		 10232#endif
10233#ifdef TARGET_NR_getuid32
31e31b8a 10234 case TARGET_NR_getuid32:
b03c60f3
FB		 10235 ret = get_errno(getuid());
10236 break;
a315a145 10237#endif
64b4d28c
AJ		 10238
10239#if defined(TARGET_NR_getxuid) && defined(TARGET_ALPHA)
10240 /* Alpha specific */
10241 case TARGET_NR_getxuid:
ba0e276d
RH		 10242 {
10243 uid_t euid;
10244 euid=geteuid();
10245 ((CPUAlphaState *)cpu_env)->ir[IR_A4]=euid;
10246 }
64b4d28c
AJ		 10247 ret = get_errno(getuid());
10248 break;
10249#endif
10250#if defined(TARGET_NR_getxgid) && defined(TARGET_ALPHA)
10251 /* Alpha specific */
10252 case TARGET_NR_getxgid:
ba0e276d
RH		 10253 {
10254 uid_t egid;
10255 egid=getegid();
10256 ((CPUAlphaState *)cpu_env)->ir[IR_A4]=egid;
10257 }
64b4d28c
AJ		 10258 ret = get_errno(getgid());
10259 break;
10260#endif
ba0e276d
RH		 10261#if defined(TARGET_NR_osf_getsysinfo) && defined(TARGET_ALPHA)
10262 /* Alpha specific */
10263 case TARGET_NR_osf_getsysinfo:
10264 ret = -TARGET_EOPNOTSUPP;
10265 switch (arg1) {
10266 case TARGET_GSI_IEEE_FP_CONTROL:
10267 {
10268 uint64_t swcr, fpcr = cpu_alpha_load_fpcr (cpu_env);
10269
10270 /* Copied from linux ieee_fpcr_to_swcr. */
10271 swcr = (fpcr >> 35) & SWCR_STATUS_MASK;
10272 swcr |= (fpcr >> 36) & SWCR_MAP_DMZ;
10273 swcr |= (~fpcr >> 48) & (SWCR_TRAP_ENABLE_INV
10274 | SWCR_TRAP_ENABLE_DZE
10275 | SWCR_TRAP_ENABLE_OVF);
10276 swcr |= (~fpcr >> 57) & (SWCR_TRAP_ENABLE_UNF
10277 | SWCR_TRAP_ENABLE_INE);
10278 swcr |= (fpcr >> 47) & SWCR_MAP_UMZ;
10279 swcr |= (~fpcr >> 41) & SWCR_TRAP_ENABLE_DNO;
10280
10281 if (put_user_u64 (swcr, arg2))
10282 goto efault;
10283 ret = 0;
10284 }
10285 break;
10286
10287 /* case GSI_IEEE_STATE_AT_SIGNAL:
10288 -- Not implemented in linux kernel.
10289 case GSI_UACPROC:
10290 -- Retrieves current unaligned access state; not much used.
10291 case GSI_PROC_TYPE:
10292 -- Retrieves implver information; surely not used.
10293 case GSI_GET_HWRPB:
10294 -- Grabs a copy of the HWRPB; surely not used.
10295 */
10296 }
10297 break;
10298#endif
10299#if defined(TARGET_NR_osf_setsysinfo) && defined(TARGET_ALPHA)
10300 /* Alpha specific */
10301 case TARGET_NR_osf_setsysinfo:
10302 ret = -TARGET_EOPNOTSUPP;
10303 switch (arg1) {
10304 case TARGET_SSI_IEEE_FP_CONTROL:
ba0e276d
RH		 10305 {
10306 uint64_t swcr, fpcr, orig_fpcr;
10307
6e06d515 10308 if (get_user_u64 (swcr, arg2)) {
ba0e276d 10309 goto efault;
6e06d515
RH		 10310 }
10311 orig_fpcr = cpu_alpha_load_fpcr(cpu_env);
ba0e276d
RH		 10312 fpcr = orig_fpcr & FPCR_DYN_MASK;
10313
10314 /* Copied from linux ieee_swcr_to_fpcr. */
10315 fpcr |= (swcr & SWCR_STATUS_MASK) << 35;
10316 fpcr |= (swcr & SWCR_MAP_DMZ) << 36;
10317 fpcr |= (~swcr & (SWCR_TRAP_ENABLE_INV
10318 | SWCR_TRAP_ENABLE_DZE
10319 | SWCR_TRAP_ENABLE_OVF)) << 48;
10320 fpcr |= (~swcr & (SWCR_TRAP_ENABLE_UNF
10321 | SWCR_TRAP_ENABLE_INE)) << 57;
10322 fpcr |= (swcr & SWCR_MAP_UMZ ? FPCR_UNDZ | FPCR_UNFD : 0);
10323 fpcr |= (~swcr & SWCR_TRAP_ENABLE_DNO) << 41;
10324
6e06d515 10325 cpu_alpha_store_fpcr(cpu_env, fpcr);
ba0e276d 10326 ret = 0;
6e06d515
RH		 10327 }
10328 break;
10329
10330 case TARGET_SSI_IEEE_RAISE_EXCEPTION:
10331 {
10332 uint64_t exc, fpcr, orig_fpcr;
10333 int si_code;
10334
10335 if (get_user_u64(exc, arg2)) {
10336 goto efault;
10337 }
ba0e276d 10338
6e06d515 10339 orig_fpcr = cpu_alpha_load_fpcr(cpu_env);
ba0e276d 10340
6e06d515
RH		 10341 /* We only add to the exception status here. */
10342 fpcr = orig_fpcr | ((exc & SWCR_STATUS_MASK) << 35);
10343
10344 cpu_alpha_store_fpcr(cpu_env, fpcr);
10345 ret = 0;
10346
10347 /* Old exceptions are not signaled. */
10348 fpcr &= ~(orig_fpcr & FPCR_STATUS_MASK);
10349
10350 /* If any exceptions set by this call,
10351 and are unmasked, send a signal. */
10352 si_code = 0;
10353 if ((fpcr & (FPCR_INE | FPCR_INED)) == FPCR_INE) {
10354 si_code = TARGET_FPE_FLTRES;
10355 }
10356 if ((fpcr & (FPCR_UNF | FPCR_UNFD)) == FPCR_UNF) {
10357 si_code = TARGET_FPE_FLTUND;
10358 }
10359 if ((fpcr & (FPCR_OVF | FPCR_OVFD)) == FPCR_OVF) {
10360 si_code = TARGET_FPE_FLTOVF;
10361 }
10362 if ((fpcr & (FPCR_DZE | FPCR_DZED)) == FPCR_DZE) {
10363 si_code = TARGET_FPE_FLTDIV;
10364 }
10365 if ((fpcr & (FPCR_INV | FPCR_INVD)) == FPCR_INV) {
10366 si_code = TARGET_FPE_FLTINV;
10367 }
10368 if (si_code != 0) {
10369 target_siginfo_t info;
10370 info.si_signo = SIGFPE;
10371 info.si_errno = 0;
10372 info.si_code = si_code;
10373 info._sifields._sigfault._addr
10374 = ((CPUArchState *)cpu_env)->pc;
10375 queue_signal((CPUArchState *)cpu_env, info.si_signo, &info);
ba0e276d
RH		 10376 }
10377 }
10378 break;
10379
10380 /* case SSI_NVPAIRS:
10381 -- Used with SSIN_UACPROC to enable unaligned accesses.
10382 case SSI_IEEE_STATE_AT_SIGNAL:
10383 case SSI_IEEE_IGNORE_STATE_AT_SIGNAL:
10384 -- Not implemented in linux kernel
10385 */
10386 }
10387 break;
10388#endif
10389#ifdef TARGET_NR_osf_sigprocmask
10390 /* Alpha specific. */
10391 case TARGET_NR_osf_sigprocmask:
10392 {
10393 abi_ulong mask;
bc088ba1 10394 int how;
ba0e276d
RH		 10395 sigset_t set, oldset;
10396
10397 switch(arg1) {
10398 case TARGET_SIG_BLOCK:
10399 how = SIG_BLOCK;
10400 break;
10401 case TARGET_SIG_UNBLOCK:
10402 how = SIG_UNBLOCK;
10403 break;
10404 case TARGET_SIG_SETMASK:
10405 how = SIG_SETMASK;
10406 break;
10407 default:
10408 ret = -TARGET_EINVAL;
10409 goto fail;
10410 }
10411 mask = arg2;
10412 target_to_host_old_sigset(&set, &mask);
3d3efba0
PM		 10413 ret = do_sigprocmask(how, &set, &oldset);
10414 if (!ret) {
10415 host_to_target_old_sigset(&mask, &oldset);
10416 ret = mask;
10417 }
ba0e276d
RH		 10418 }
10419 break;
10420#endif
64b4d28c 10421
a315a145 10422#ifdef TARGET_NR_getgid32
31e31b8a 10423 case TARGET_NR_getgid32:
b03c60f3
FB		 10424 ret = get_errno(getgid());
10425 break;
a315a145
FB		 10426#endif
10427#ifdef TARGET_NR_geteuid32
31e31b8a 10428 case TARGET_NR_geteuid32:
b03c60f3
FB		 10429 ret = get_errno(geteuid());
10430 break;
a315a145
FB		 10431#endif
10432#ifdef TARGET_NR_getegid32
31e31b8a 10433 case TARGET_NR_getegid32:
b03c60f3
FB		 10434 ret = get_errno(getegid());
10435 break;
a315a145
FB		 10436#endif
10437#ifdef TARGET_NR_setreuid32
31e31b8a 10438 case TARGET_NR_setreuid32:
b03c60f3
FB		 10439 ret = get_errno(setreuid(arg1, arg2));
10440 break;
a315a145
FB		 10441#endif
10442#ifdef TARGET_NR_setregid32
31e31b8a 10443 case TARGET_NR_setregid32:
b03c60f3
FB		 10444 ret = get_errno(setregid(arg1, arg2));
10445 break;
a315a145
FB		 10446#endif
10447#ifdef TARGET_NR_getgroups32
31e31b8a 10448 case TARGET_NR_getgroups32:
99c475ab
FB		 10449 {
10450 int gidsetsize = arg1;
53a5960a 10451 uint32_t *target_grouplist;
99c475ab
FB		 10452 gid_t *grouplist;
10453 int i;
10454
10455 grouplist = alloca(gidsetsize * sizeof(gid_t));
10456 ret = get_errno(getgroups(gidsetsize, grouplist));
cb3bc233
AZ		 10457 if (gidsetsize == 0)
10458 break;
99c475ab 10459 if (!is_error(ret)) {
579a97f7
FB		 10460 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 4, 0);
10461 if (!target_grouplist) {
10462 ret = -TARGET_EFAULT;
10463 goto fail;
10464 }
a2155fcc 10465 for(i = 0;i < ret; i++)
53a5960a
PB		 10466 target_grouplist[i] = tswap32(grouplist[i]);
10467 unlock_user(target_grouplist, arg2, gidsetsize * 4);
99c475ab
FB		 10468 }
10469 }
10470 break;
a315a145
FB		 10471#endif
10472#ifdef TARGET_NR_setgroups32
31e31b8a 10473 case TARGET_NR_setgroups32:
99c475ab
FB		 10474 {
10475 int gidsetsize = arg1;
53a5960a 10476 uint32_t *target_grouplist;
99c475ab
FB		 10477 gid_t *grouplist;
10478 int i;
3b46e624 10479
99c475ab 10480 grouplist = alloca(gidsetsize * sizeof(gid_t));
579a97f7
FB		 10481 target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 4, 1);
10482 if (!target_grouplist) {
10483 ret = -TARGET_EFAULT;
10484 goto fail;
10485 }
99c475ab 10486 for(i = 0;i < gidsetsize; i++)
53a5960a
PB		 10487 grouplist[i] = tswap32(target_grouplist[i]);
10488 unlock_user(target_grouplist, arg2, 0);
99c475ab
FB		 10489 ret = get_errno(setgroups(gidsetsize, grouplist));
10490 }
10491 break;
a315a145
FB		 10492#endif
10493#ifdef TARGET_NR_fchown32
31e31b8a 10494 case TARGET_NR_fchown32:
b03c60f3
FB		 10495 ret = get_errno(fchown(arg1, arg2, arg3));
10496 break;
a315a145
FB		 10497#endif
10498#ifdef TARGET_NR_setresuid32
31e31b8a 10499 case TARGET_NR_setresuid32:
fd6f7798 10500 ret = get_errno(sys_setresuid(arg1, arg2, arg3));
b03c60f3 10501 break;
a315a145
FB		 10502#endif
10503#ifdef TARGET_NR_getresuid32
31e31b8a 10504 case TARGET_NR_getresuid32:
b03c60f3 10505 {
53a5960a 10506 uid_t ruid, euid, suid;
b03c60f3
FB		 10507 ret = get_errno(getresuid(&ruid, &euid, &suid));
10508 if (!is_error(ret)) {
2f619698
FB		 10509 if (put_user_u32(ruid, arg1)
10510 || put_user_u32(euid, arg2)
10511 || put_user_u32(suid, arg3))
10512 goto efault;
b03c60f3
FB		 10513 }
10514 }
10515 break;
a315a145
FB		 10516#endif
10517#ifdef TARGET_NR_setresgid32
31e31b8a 10518 case TARGET_NR_setresgid32:
fd6f7798 10519 ret = get_errno(sys_setresgid(arg1, arg2, arg3));
b03c60f3 10520 break;
a315a145
FB		 10521#endif
10522#ifdef TARGET_NR_getresgid32
31e31b8a 10523 case TARGET_NR_getresgid32:
b03c60f3 10524 {
53a5960a 10525 gid_t rgid, egid, sgid;
b03c60f3
FB		 10526 ret = get_errno(getresgid(&rgid, &egid, &sgid));
10527 if (!is_error(ret)) {
2f619698
FB		 10528 if (put_user_u32(rgid, arg1)
10529 || put_user_u32(egid, arg2)
10530 || put_user_u32(sgid, arg3))
10531 goto efault;
b03c60f3
FB		 10532 }
10533 }
10534 break;
a315a145
FB		 10535#endif
10536#ifdef TARGET_NR_chown32
31e31b8a 10537 case TARGET_NR_chown32:
579a97f7
FB		 10538 if (!(p = lock_user_string(arg1)))
10539 goto efault;
53a5960a
PB		 10540 ret = get_errno(chown(p, arg2, arg3));
10541 unlock_user(p, arg1, 0);
b03c60f3 10542 break;
a315a145
FB		 10543#endif
10544#ifdef TARGET_NR_setuid32
31e31b8a 10545 case TARGET_NR_setuid32:
fd6f7798 10546 ret = get_errno(sys_setuid(arg1));
b03c60f3 10547 break;
a315a145
FB		 10548#endif
10549#ifdef TARGET_NR_setgid32
31e31b8a 10550 case TARGET_NR_setgid32:
fd6f7798 10551 ret = get_errno(sys_setgid(arg1));
b03c60f3 10552 break;
a315a145
FB		 10553#endif
10554#ifdef TARGET_NR_setfsuid32
31e31b8a 10555 case TARGET_NR_setfsuid32:
b03c60f3
FB		 10556 ret = get_errno(setfsuid(arg1));
10557 break;
a315a145
FB		 10558#endif
10559#ifdef TARGET_NR_setfsgid32
31e31b8a 10560 case TARGET_NR_setfsgid32:
b03c60f3
FB		 10561 ret = get_errno(setfsgid(arg1));
10562 break;
a315a145 10563#endif
67867308 10564
31e31b8a 10565 case TARGET_NR_pivot_root:
b03c60f3 10566 goto unimplemented;
ffa65c3b 10567#ifdef TARGET_NR_mincore
31e31b8a 10568 case TARGET_NR_mincore:
04bb9ace
AJ		 10569 {
10570 void *a;
10571 ret = -TARGET_EFAULT;
10572 if (!(a = lock_user(VERIFY_READ, arg1,arg2, 0)))
10573 goto efault;
10574 if (!(p = lock_user_string(arg3)))
10575 goto mincore_fail;
10576 ret = get_errno(mincore(a, arg2, p));
10577 unlock_user(p, arg3, ret);
10578 mincore_fail:
10579 unlock_user(a, arg1, 0);
10580 }
10581 break;
ffa65c3b 10582#endif
408321b6
AJ		 10583#ifdef TARGET_NR_arm_fadvise64_64
10584 case TARGET_NR_arm_fadvise64_64:
e0156a9d
PM		 10585 /* arm_fadvise64_64 looks like fadvise64_64 but
10586 * with different argument order: fd, advice, offset, len
10587 * rather than the usual fd, offset, len, advice.
10588 * Note that offset and len are both 64-bit so appear as
10589 * pairs of 32-bit registers.
10590 */
10591 ret = posix_fadvise(arg1, target_offset64(arg3, arg4),
10592 target_offset64(arg5, arg6), arg2);
10593 ret = -host_to_target_errno(ret);
10594 break;
408321b6 10595#endif
badd3cd8
PM		 10596
10597#if TARGET_ABI_BITS == 32
10598
10599#ifdef TARGET_NR_fadvise64_64
10600 case TARGET_NR_fadvise64_64:
10601 /* 6 args: fd, offset (high, low), len (high, low), advice */
10602 if (regpairs_aligned(cpu_env)) {
10603 /* offset is in (3,4), len in (5,6) and advice in 7 */
10604 arg2 = arg3;
10605 arg3 = arg4;
10606 arg4 = arg5;
10607 arg5 = arg6;
10608 arg6 = arg7;
10609 }
10610 ret = -host_to_target_errno(posix_fadvise(arg1,
10611 target_offset64(arg2, arg3),
10612 target_offset64(arg4, arg5),
10613 arg6));
10614 break;
10615#endif
10616
10617#ifdef TARGET_NR_fadvise64
10618 case TARGET_NR_fadvise64:
10619 /* 5 args: fd, offset (high, low), len, advice */
10620 if (regpairs_aligned(cpu_env)) {
10621 /* offset is in (3,4), len in 5 and advice in 6 */
10622 arg2 = arg3;
10623 arg3 = arg4;
10624 arg4 = arg5;
10625 arg5 = arg6;
10626 }
10627 ret = -host_to_target_errno(posix_fadvise(arg1,
10628 target_offset64(arg2, arg3),
10629 arg4, arg5));
10630 break;
408321b6 10631#endif
badd3cd8
PM		 10632
10633#else /* not a 32-bit ABI */
e0156a9d 10634#if defined(TARGET_NR_fadvise64_64) || defined(TARGET_NR_fadvise64)
408321b6
AJ		 10635#ifdef TARGET_NR_fadvise64_64
10636 case TARGET_NR_fadvise64_64:
10637#endif
e72d2cc7
UH		 10638#ifdef TARGET_NR_fadvise64
10639 case TARGET_NR_fadvise64:
10640#endif
10641#ifdef TARGET_S390X
10642 switch (arg4) {
10643 case 4: arg4 = POSIX_FADV_NOREUSE + 1; break; /* make sure it's an invalid value */
10644 case 5: arg4 = POSIX_FADV_NOREUSE + 2; break; /* ditto */
10645 case 6: arg4 = POSIX_FADV_DONTNEED; break;
10646 case 7: arg4 = POSIX_FADV_NOREUSE; break;
10647 default: break;
10648 }
10649#endif
977d8241
PM		 10650 ret = -host_to_target_errno(posix_fadvise(arg1, arg2, arg3, arg4));
10651 break;
408321b6 10652#endif
badd3cd8
PM		 10653#endif /* end of 64-bit ABI fadvise handling */
10654
ffa65c3b 10655#ifdef TARGET_NR_madvise
31e31b8a 10656 case TARGET_NR_madvise:
24836689 10657 /* A straight passthrough may not be safe because qemu sometimes
d2d6b857 10658 turns private file-backed mappings into anonymous mappings.
24836689
PB		 10659 This will break MADV_DONTNEED.
10660 This is a hint, so ignoring and returning success is ok. */
10661 ret = get_errno(0);
10662 break;
ffa65c3b 10663#endif
992f48a0 10664#if TARGET_ABI_BITS == 32
31e31b8a 10665 case TARGET_NR_fcntl64:
77e4672d 10666 {
b1e341eb 10667 int cmd;
77e4672d 10668 struct flock64 fl;
213d3e9e
PM		 10669 from_flock64_fn *copyfrom = copy_from_user_flock64;
10670 to_flock64_fn *copyto = copy_to_user_flock64;
10671
ce4defa0 10672#ifdef TARGET_ARM
213d3e9e
PM		 10673 if (((CPUARMState *)cpu_env)->eabi) {
10674 copyfrom = copy_from_user_eabi_flock64;
10675 copyto = copy_to_user_eabi_flock64;
10676 }
ce4defa0 10677#endif
77e4672d 10678
5f106811 10679 cmd = target_to_host_fcntl_cmd(arg2);
31b63193
PM		 10680 if (cmd == -TARGET_EINVAL) {
10681 ret = cmd;
10682 break;
10683 }
b1e341eb 10684
60cd49d5 10685 switch(arg2) {
b1e341eb 10686 case TARGET_F_GETLK64:
213d3e9e
PM		 10687 ret = copyfrom(&fl, arg3);
10688 if (ret) {
10689 break;
5813427b 10690 }
b1e341eb 10691 ret = get_errno(fcntl(arg1, cmd, &fl));
213d3e9e
PM		 10692 if (ret == 0) {
10693 ret = copyto(arg3, &fl);
10694 }
77e4672d
FB		 10695 break;
10696
b1e341eb
TS		 10697 case TARGET_F_SETLK64:
10698 case TARGET_F_SETLKW64:
213d3e9e
PM		 10699 ret = copyfrom(&fl, arg3);
10700 if (ret) {
10701 break;
ce4defa0 10702 }
435da5e7 10703 ret = get_errno(safe_fcntl(arg1, cmd, &fl));
77e4672d 10704 break;
60cd49d5 10705 default:
5f106811 10706 ret = do_fcntl(arg1, arg2, arg3);
60cd49d5
FB		 10707 break;
10708 }
77e4672d
FB		 10709 break;
10710 }
60cd49d5 10711#endif
7d600c80
TS		 10712#ifdef TARGET_NR_cacheflush
10713 case TARGET_NR_cacheflush:
10714 /* self-modifying code is handled automatically, so nothing needed */
10715 ret = 0;
10716 break;
10717#endif
ebc05488 10718#ifdef TARGET_NR_security
31e31b8a
FB		 10719 case TARGET_NR_security:
10720 goto unimplemented;
c573ff67
FB		 10721#endif
10722#ifdef TARGET_NR_getpagesize
10723 case TARGET_NR_getpagesize:
10724 ret = TARGET_PAGE_SIZE;
10725 break;
ebc05488 10726#endif
31e31b8a
FB		 10727 case TARGET_NR_gettid:
10728 ret = get_errno(gettid());
10729 break;
e5febef5 10730#ifdef TARGET_NR_readahead
31e31b8a 10731 case TARGET_NR_readahead:
2054ac9b 10732#if TARGET_ABI_BITS == 32
48e515d4 10733 if (regpairs_aligned(cpu_env)) {
2054ac9b
AJ		 10734 arg2 = arg3;
10735 arg3 = arg4;
10736 arg4 = arg5;
10737 }
2054ac9b
AJ		 10738 ret = get_errno(readahead(arg1, ((off64_t)arg3 << 32) | arg2, arg4));
10739#else
10740 ret = get_errno(readahead(arg1, arg2, arg3));
10741#endif
10742 break;
e5febef5 10743#endif
a790ae38 10744#ifdef CONFIG_ATTR
ebc05488 10745#ifdef TARGET_NR_setxattr
31e31b8a
FB		 10746 case TARGET_NR_listxattr:
10747 case TARGET_NR_llistxattr:
fb5590f7
PM		 10748 {
10749 void *p, *b = 0;
10750 if (arg2) {
10751 b = lock_user(VERIFY_WRITE, arg2, arg3, 0);
10752 if (!b) {
10753 ret = -TARGET_EFAULT;
10754 break;
10755 }
10756 }
10757 p = lock_user_string(arg1);
10758 if (p) {
10759 if (num == TARGET_NR_listxattr) {
10760 ret = get_errno(listxattr(p, b, arg3));
10761 } else {
10762 ret = get_errno(llistxattr(p, b, arg3));
10763 }
10764 } else {
10765 ret = -TARGET_EFAULT;
10766 }
10767 unlock_user(p, arg1, 0);
10768 unlock_user(b, arg2, arg3);
10769 break;
10770 }
31e31b8a 10771 case TARGET_NR_flistxattr:
fb5590f7
PM		 10772 {
10773 void *b = 0;
10774 if (arg2) {
10775 b = lock_user(VERIFY_WRITE, arg2, arg3, 0);
10776 if (!b) {
10777 ret = -TARGET_EFAULT;
10778 break;
10779 }
10780 }
10781 ret = get_errno(flistxattr(arg1, b, arg3));
10782 unlock_user(b, arg2, arg3);
6f932f91 10783 break;
fb5590f7 10784 }
a790ae38 10785 case TARGET_NR_setxattr:
30297b55 10786 case TARGET_NR_lsetxattr:
a790ae38 10787 {
e3c33ec6
PM		 10788 void *p, *n, *v = 0;
10789 if (arg3) {
10790 v = lock_user(VERIFY_READ, arg3, arg4, 1);
10791 if (!v) {
10792 ret = -TARGET_EFAULT;
10793 break;
10794 }
10795 }
a790ae38
ACH		 10796 p = lock_user_string(arg1);
10797 n = lock_user_string(arg2);
e3c33ec6 10798 if (p && n) {
30297b55
PM		 10799 if (num == TARGET_NR_setxattr) {
10800 ret = get_errno(setxattr(p, n, v, arg4, arg5));
10801 } else {
10802 ret = get_errno(lsetxattr(p, n, v, arg4, arg5));
10803 }
a790ae38
ACH		 10804 } else {
10805 ret = -TARGET_EFAULT;
10806 }
10807 unlock_user(p, arg1, 0);
10808 unlock_user(n, arg2, 0);
10809 unlock_user(v, arg3, 0);
10810 }
10811 break;
30297b55
PM		 10812 case TARGET_NR_fsetxattr:
10813 {
10814 void *n, *v = 0;
10815 if (arg3) {
10816 v = lock_user(VERIFY_READ, arg3, arg4, 1);
10817 if (!v) {
10818 ret = -TARGET_EFAULT;
10819 break;
10820 }
10821 }
10822 n = lock_user_string(arg2);
10823 if (n) {
10824 ret = get_errno(fsetxattr(arg1, n, v, arg4, arg5));
10825 } else {
10826 ret = -TARGET_EFAULT;
10827 }
10828 unlock_user(n, arg2, 0);
10829 unlock_user(v, arg3, 0);
10830 }
10831 break;
a790ae38 10832 case TARGET_NR_getxattr:
30297b55 10833 case TARGET_NR_lgetxattr:
a790ae38 10834 {
e3c33ec6
PM		 10835 void *p, *n, *v = 0;
10836 if (arg3) {
10837 v = lock_user(VERIFY_WRITE, arg3, arg4, 0);
10838 if (!v) {
10839 ret = -TARGET_EFAULT;
10840 break;
10841 }
10842 }
a790ae38
ACH		 10843 p = lock_user_string(arg1);
10844 n = lock_user_string(arg2);
e3c33ec6 10845 if (p && n) {
30297b55
PM		 10846 if (num == TARGET_NR_getxattr) {
10847 ret = get_errno(getxattr(p, n, v, arg4));
10848 } else {
10849 ret = get_errno(lgetxattr(p, n, v, arg4));
10850 }
a790ae38
ACH		 10851 } else {
10852 ret = -TARGET_EFAULT;
10853 }
10854 unlock_user(p, arg1, 0);
10855 unlock_user(n, arg2, 0);
10856 unlock_user(v, arg3, arg4);
10857 }
10858 break;
30297b55
PM		 10859 case TARGET_NR_fgetxattr:
10860 {
10861 void *n, *v = 0;
10862 if (arg3) {
10863 v = lock_user(VERIFY_WRITE, arg3, arg4, 0);
10864 if (!v) {
10865 ret = -TARGET_EFAULT;
10866 break;
10867 }
10868 }
10869 n = lock_user_string(arg2);
10870 if (n) {
10871 ret = get_errno(fgetxattr(arg1, n, v, arg4));
10872 } else {
10873 ret = -TARGET_EFAULT;
10874 }
10875 unlock_user(n, arg2, 0);
10876 unlock_user(v, arg3, arg4);
10877 }
10878 break;
a790ae38 10879 case TARGET_NR_removexattr:
30297b55 10880 case TARGET_NR_lremovexattr:
a790ae38
ACH		 10881 {
10882 void *p, *n;
10883 p = lock_user_string(arg1);
10884 n = lock_user_string(arg2);
10885 if (p && n) {
30297b55
PM		 10886 if (num == TARGET_NR_removexattr) {
10887 ret = get_errno(removexattr(p, n));
10888 } else {
10889 ret = get_errno(lremovexattr(p, n));
10890 }
a790ae38
ACH		 10891 } else {
10892 ret = -TARGET_EFAULT;
10893 }
10894 unlock_user(p, arg1, 0);
10895 unlock_user(n, arg2, 0);
10896 }
10897 break;
30297b55
PM		 10898 case TARGET_NR_fremovexattr:
10899 {
10900 void *n;
10901 n = lock_user_string(arg2);
10902 if (n) {
10903 ret = get_errno(fremovexattr(arg1, n));
10904 } else {
10905 ret = -TARGET_EFAULT;
10906 }
10907 unlock_user(n, arg2, 0);
10908 }
10909 break;
ebc05488 10910#endif
a790ae38 10911#endif /* CONFIG_ATTR */
ebc05488 10912#ifdef TARGET_NR_set_thread_area
5cd4393b 10913 case TARGET_NR_set_thread_area:
8d18e893 10914#if defined(TARGET_MIPS)
d279279e 10915 ((CPUMIPSState *) cpu_env)->active_tc.CP0_UserLocal = arg1;
6f5b89a0
TS		 10916 ret = 0;
10917 break;
ef96779b
EI		 10918#elif defined(TARGET_CRIS)
10919 if (arg1 & 0xff)
10920 ret = -TARGET_EINVAL;
10921 else {
10922 ((CPUCRISState *) cpu_env)->pregs[PR_PID] = arg1;
10923 ret = 0;
10924 }
10925 break;
8d18e893
FB		 10926#elif defined(TARGET_I386) && defined(TARGET_ABI32)
10927 ret = do_set_thread_area(cpu_env, arg1);
10928 break;
1ccd9374
PM		 10929#elif defined(TARGET_M68K)
10930 {
0429a971 10931 TaskState *ts = cpu->opaque;
1ccd9374 10932 ts->tp_value = arg1;
95c1eb19 10933 ret = 0;
1ccd9374
PM		 10934 break;
10935 }
6f5b89a0
TS		 10936#else
10937 goto unimplemented_nowarn;
10938#endif
10939#endif
10940#ifdef TARGET_NR_get_thread_area
5cd4393b 10941 case TARGET_NR_get_thread_area:
8d18e893
FB		 10942#if defined(TARGET_I386) && defined(TARGET_ABI32)
10943 ret = do_get_thread_area(cpu_env, arg1);
d312bbe1 10944 break;
1ccd9374
PM		 10945#elif defined(TARGET_M68K)
10946 {
0429a971 10947 TaskState *ts = cpu->opaque;
1ccd9374
PM		 10948 ret = ts->tp_value;
10949 break;
10950 }
8d18e893 10951#else
5cd4393b 10952 goto unimplemented_nowarn;
48dc41eb 10953#endif
8d18e893 10954#endif
48dc41eb
FB		 10955#ifdef TARGET_NR_getdomainname
10956 case TARGET_NR_getdomainname:
10957 goto unimplemented_nowarn;
ebc05488 10958#endif
6f5b89a0 10959
b5906f95
TS		 10960#ifdef TARGET_NR_clock_gettime
10961 case TARGET_NR_clock_gettime:
10962 {
10963 struct timespec ts;
10964 ret = get_errno(clock_gettime(arg1, &ts));
10965 if (!is_error(ret)) {
10966 host_to_target_timespec(arg2, &ts);
10967 }
10968 break;
10969 }
10970#endif
10971#ifdef TARGET_NR_clock_getres
10972 case TARGET_NR_clock_getres:
10973 {
10974 struct timespec ts;
10975 ret = get_errno(clock_getres(arg1, &ts));
10976 if (!is_error(ret)) {
10977 host_to_target_timespec(arg2, &ts);
10978 }
10979 break;
10980 }
10981#endif
63d7651b
PB		 10982#ifdef TARGET_NR_clock_nanosleep
10983 case TARGET_NR_clock_nanosleep:
10984 {
10985 struct timespec ts;
10986 target_to_host_timespec(&ts, arg3);
9e518226
PM		 10987 ret = get_errno(safe_clock_nanosleep(arg1, arg2,
10988 &ts, arg4 ? &ts : NULL));
63d7651b
PB		 10989 if (arg4)
10990 host_to_target_timespec(arg4, &ts);
8fbe8fdf
TM		 10991
10992#if defined(TARGET_PPC)
10993 /* clock_nanosleep is odd in that it returns positive errno values.
10994 * On PPC, CR0 bit 3 should be set in such a situation. */
9e518226 10995 if (ret && ret != -TARGET_ERESTARTSYS) {
8fbe8fdf
TM		 10996 ((CPUPPCState *)cpu_env)->crf[0] |= 1;
10997 }
10998#endif
63d7651b
PB		 10999 break;
11000 }
11001#endif
b5906f95 11002
6f5b89a0
TS		 11003#if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
11004 case TARGET_NR_set_tid_address:
579a97f7
FB		 11005 ret = get_errno(set_tid_address((int *)g2h(arg1)));
11006 break;
6f5b89a0
TS		 11007#endif
11008
4cae1d16 11009 case TARGET_NR_tkill:
bef653d9 11010 ret = get_errno(safe_tkill((int)arg1, target_to_host_signal(arg2)));
4cae1d16 11011 break;
4cae1d16 11012
71455574 11013 case TARGET_NR_tgkill:
bef653d9 11014 ret = get_errno(safe_tgkill((int)arg1, (int)arg2,
4cb05961 11015 target_to_host_signal(arg3)));
bef653d9 11016 break;
71455574 11017
4f2b1fe8
TS		 11018#ifdef TARGET_NR_set_robust_list
11019 case TARGET_NR_set_robust_list:
e9a970a8
PM		 11020 case TARGET_NR_get_robust_list:
11021 /* The ABI for supporting robust futexes has userspace pass
11022 * the kernel a pointer to a linked list which is updated by
11023 * userspace after the syscall; the list is walked by the kernel
11024 * when the thread exits. Since the linked list in QEMU guest
11025 * memory isn't a valid linked list for the host and we have
11026 * no way to reliably intercept the thread-death event, we can't
11027 * support these. Silently return ENOSYS so that guest userspace
11028 * falls back to a non-robust futex implementation (which should
11029 * be OK except in the corner case of the guest crashing while
11030 * holding a mutex that is shared with another process via
11031 * shared memory).
11032 */
11033 goto unimplemented_nowarn;
4f2b1fe8
TS		 11034#endif
11035
1acae9f2 11036#if defined(TARGET_NR_utimensat)
9007f0ef
TS		 11037 case TARGET_NR_utimensat:
11038 {
ebc996f3
RV		 11039 struct timespec *tsp, ts[2];
11040 if (!arg3) {
11041 tsp = NULL;
11042 } else {
11043 target_to_host_timespec(ts, arg3);
11044 target_to_host_timespec(ts+1, arg3+sizeof(struct target_timespec));
11045 tsp = ts;
11046 }
9007f0ef 11047 if (!arg2)
ebc996f3 11048 ret = get_errno(sys_utimensat(arg1, NULL, tsp, arg4));
9007f0ef 11049 else {
579a97f7 11050 if (!(p = lock_user_string(arg2))) {
0da46a6e 11051 ret = -TARGET_EFAULT;
579a97f7
FB		 11052 goto fail;
11053 }
ebc996f3 11054 ret = get_errno(sys_utimensat(arg1, path(p), tsp, arg4));
579a97f7 11055 unlock_user(p, arg2, 0);
9007f0ef
TS		 11056 }
11057 }
11058 break;
11059#endif
bd0c5661
PB		 11060 case TARGET_NR_futex:
11061 ret = do_futex(arg1, arg2, arg3, arg4, arg5, arg6);
11062 break;
dbfe4c36 11063#if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
39b59763
AJ		 11064 case TARGET_NR_inotify_init:
11065 ret = get_errno(sys_inotify_init());
11066 break;
11067#endif
a1606b0b 11068#ifdef CONFIG_INOTIFY1
c05c7a73
RV		 11069#if defined(TARGET_NR_inotify_init1) && defined(__NR_inotify_init1)
11070 case TARGET_NR_inotify_init1:
11071 ret = get_errno(sys_inotify_init1(arg1));
11072 break;
11073#endif
a1606b0b 11074#endif
dbfe4c36 11075#if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)
39b59763
AJ		 11076 case TARGET_NR_inotify_add_watch:
11077 p = lock_user_string(arg2);
11078 ret = get_errno(sys_inotify_add_watch(arg1, path(p), arg3));
11079 unlock_user(p, arg2, 0);
11080 break;
11081#endif
dbfe4c36 11082#if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)
39b59763
AJ		 11083 case TARGET_NR_inotify_rm_watch:
11084 ret = get_errno(sys_inotify_rm_watch(arg1, arg2));
11085 break;
11086#endif
9007f0ef 11087
8ec9cf89 11088#if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
24e1003a
AJ		 11089 case TARGET_NR_mq_open:
11090 {
b6ce1f6b 11091 struct mq_attr posix_mq_attr, *attrp;
24e1003a
AJ		 11092
11093 p = lock_user_string(arg1 - 1);
b6ce1f6b 11094 if (arg4 != 0) {
24e1003a 11095 copy_from_user_mq_attr (&posix_mq_attr, arg4);
b6ce1f6b
TM		 11096 attrp = &posix_mq_attr;
11097 } else {
11098 attrp = 0;
11099 }
11100 ret = get_errno(mq_open(p, arg2, arg3, attrp));
24e1003a
AJ		 11101 unlock_user (p, arg1, 0);
11102 }
11103 break;
11104
11105 case TARGET_NR_mq_unlink:
11106 p = lock_user_string(arg1 - 1);
11107 ret = get_errno(mq_unlink(p));
11108 unlock_user (p, arg1, 0);
11109 break;
11110
11111 case TARGET_NR_mq_timedsend:
11112 {
11113 struct timespec ts;
11114
11115 p = lock_user (VERIFY_READ, arg2, arg3, 1);
11116 if (arg5 != 0) {
11117 target_to_host_timespec(&ts, arg5);
d40ecd66 11118 ret = get_errno(safe_mq_timedsend(arg1, p, arg3, arg4, &ts));
24e1003a 11119 host_to_target_timespec(arg5, &ts);
d40ecd66
PM		 11120 } else {
11121 ret = get_errno(safe_mq_timedsend(arg1, p, arg3, arg4, NULL));
24e1003a 11122 }
24e1003a
AJ		 11123 unlock_user (p, arg2, arg3);
11124 }
11125 break;
11126
11127 case TARGET_NR_mq_timedreceive:
11128 {
11129 struct timespec ts;
11130 unsigned int prio;
11131
11132 p = lock_user (VERIFY_READ, arg2, arg3, 1);
11133 if (arg5 != 0) {
11134 target_to_host_timespec(&ts, arg5);
d40ecd66
PM		 11135 ret = get_errno(safe_mq_timedreceive(arg1, p, arg3,
11136 &prio, &ts));
24e1003a 11137 host_to_target_timespec(arg5, &ts);
d40ecd66
PM		 11138 } else {
11139 ret = get_errno(safe_mq_timedreceive(arg1, p, arg3,
11140 &prio, NULL));
24e1003a 11141 }
24e1003a
AJ		 11142 unlock_user (p, arg2, arg3);
11143 if (arg4 != 0)
11144 put_user_u32(prio, arg4);
11145 }
11146 break;
11147
11148 /* Not implemented for now... */
11149/* case TARGET_NR_mq_notify: */
11150/* break; */
11151
11152 case TARGET_NR_mq_getsetattr:
11153 {
11154 struct mq_attr posix_mq_attr_in, posix_mq_attr_out;
11155 ret = 0;
11156 if (arg3 != 0) {
11157 ret = mq_getattr(arg1, &posix_mq_attr_out);
11158 copy_to_user_mq_attr(arg3, &posix_mq_attr_out);
11159 }
11160 if (arg2 != 0) {
11161 copy_from_user_mq_attr(&posix_mq_attr_in, arg2);
11162 ret |= mq_setattr(arg1, &posix_mq_attr_in, &posix_mq_attr_out);
11163 }
11164
11165 }
11166 break;
11167#endif
11168
3ce34dfb
VS		 11169#ifdef CONFIG_SPLICE
11170#ifdef TARGET_NR_tee
11171 case TARGET_NR_tee:
11172 {
11173 ret = get_errno(tee(arg1,arg2,arg3,arg4));
11174 }
11175 break;
11176#endif
11177#ifdef TARGET_NR_splice
11178 case TARGET_NR_splice:
11179 {
11180 loff_t loff_in, loff_out;
11181 loff_t *ploff_in = NULL, *ploff_out = NULL;
17644b36
AS		 11182 if (arg2) {
11183 if (get_user_u64(loff_in, arg2)) {
11184 goto efault;
11185 }
3ce34dfb
VS		 11186 ploff_in = &loff_in;
11187 }
17644b36
AS		 11188 if (arg4) {
11189 if (get_user_u64(loff_out, arg4)) {
11190 goto efault;
11191 }
3ce34dfb
VS		 11192 ploff_out = &loff_out;
11193 }
11194 ret = get_errno(splice(arg1, ploff_in, arg3, ploff_out, arg5, arg6));
17644b36
AS		 11195 if (arg2) {
11196 if (put_user_u64(loff_in, arg2)) {
11197 goto efault;
11198 }
11199 }
11200 if (arg4) {
11201 if (put_user_u64(loff_out, arg4)) {
11202 goto efault;
11203 }
11204 }
3ce34dfb
VS		 11205 }
11206 break;
11207#endif
11208#ifdef TARGET_NR_vmsplice
11209 case TARGET_NR_vmsplice:
11210 {
f287b2c2
RH		 11211 struct iovec *vec = lock_iovec(VERIFY_READ, arg2, arg3, 1);
11212 if (vec != NULL) {
11213 ret = get_errno(vmsplice(arg1, vec, arg3, arg4));
11214 unlock_iovec(vec, arg2, arg3, 0);
11215 } else {
11216 ret = -host_to_target_errno(errno);
11217 }
3ce34dfb
VS		 11218 }
11219 break;
11220#endif
11221#endif /* CONFIG_SPLICE */
c2882b96
RV		 11222#ifdef CONFIG_EVENTFD
11223#if defined(TARGET_NR_eventfd)
11224 case TARGET_NR_eventfd:
11225 ret = get_errno(eventfd(arg1, 0));
e36800c9 11226 fd_trans_unregister(ret);
c2882b96
RV		 11227 break;
11228#endif
11229#if defined(TARGET_NR_eventfd2)
11230 case TARGET_NR_eventfd2:
5947c697
PJ		 11231 {
11232 int host_flags = arg2 & (~(TARGET_O_NONBLOCK | TARGET_O_CLOEXEC));
11233 if (arg2 & TARGET_O_NONBLOCK) {
11234 host_flags |= O_NONBLOCK;
11235 }
11236 if (arg2 & TARGET_O_CLOEXEC) {
11237 host_flags |= O_CLOEXEC;
11238 }
11239 ret = get_errno(eventfd(arg1, host_flags));
e36800c9 11240 fd_trans_unregister(ret);
c2882b96 11241 break;
5947c697 11242 }
c2882b96
RV		 11243#endif
11244#endif /* CONFIG_EVENTFD */
d0927938
UH		 11245#if defined(CONFIG_FALLOCATE) && defined(TARGET_NR_fallocate)
11246 case TARGET_NR_fallocate:
20249ae1
AG		 11247#if TARGET_ABI_BITS == 32
11248 ret = get_errno(fallocate(arg1, arg2, target_offset64(arg3, arg4),
11249 target_offset64(arg5, arg6)));
11250#else
d0927938 11251 ret = get_errno(fallocate(arg1, arg2, arg3, arg4));
20249ae1 11252#endif
d0927938 11253 break;
c727f47d
PM		 11254#endif
11255#if defined(CONFIG_SYNC_FILE_RANGE)
11256#if defined(TARGET_NR_sync_file_range)
11257 case TARGET_NR_sync_file_range:
11258#if TARGET_ABI_BITS == 32
bfcedc57
RV		 11259#if defined(TARGET_MIPS)
11260 ret = get_errno(sync_file_range(arg1, target_offset64(arg3, arg4),
11261 target_offset64(arg5, arg6), arg7));
11262#else
c727f47d
PM		 11263 ret = get_errno(sync_file_range(arg1, target_offset64(arg2, arg3),
11264 target_offset64(arg4, arg5), arg6));
bfcedc57 11265#endif /* !TARGET_MIPS */
c727f47d
PM		 11266#else
11267 ret = get_errno(sync_file_range(arg1, arg2, arg3, arg4));
11268#endif
11269 break;
11270#endif
11271#if defined(TARGET_NR_sync_file_range2)
11272 case TARGET_NR_sync_file_range2:
11273 /* This is like sync_file_range but the arguments are reordered */
11274#if TARGET_ABI_BITS == 32
11275 ret = get_errno(sync_file_range(arg1, target_offset64(arg3, arg4),
11276 target_offset64(arg5, arg6), arg2));
11277#else
11278 ret = get_errno(sync_file_range(arg1, arg3, arg4, arg2));
11279#endif
11280 break;
11281#endif
3b6edd16 11282#endif
e36800c9
LV		 11283#if defined(TARGET_NR_signalfd4)
11284 case TARGET_NR_signalfd4:
11285 ret = do_signalfd4(arg1, arg2, arg4);
11286 break;
11287#endif
11288#if defined(TARGET_NR_signalfd)
11289 case TARGET_NR_signalfd:
11290 ret = do_signalfd4(arg1, arg2, 0);
11291 break;
11292#endif
3b6edd16
PM		 11293#if defined(CONFIG_EPOLL)
11294#if defined(TARGET_NR_epoll_create)
11295 case TARGET_NR_epoll_create:
11296 ret = get_errno(epoll_create(arg1));
11297 break;
11298#endif
11299#if defined(TARGET_NR_epoll_create1) && defined(CONFIG_EPOLL_CREATE1)
11300 case TARGET_NR_epoll_create1:
11301 ret = get_errno(epoll_create1(arg1));
11302 break;
11303#endif
11304#if defined(TARGET_NR_epoll_ctl)
11305 case TARGET_NR_epoll_ctl:
11306 {
11307 struct epoll_event ep;
11308 struct epoll_event *epp = 0;
11309 if (arg4) {
11310 struct target_epoll_event *target_ep;
11311 if (!lock_user_struct(VERIFY_READ, target_ep, arg4, 1)) {
11312 goto efault;
11313 }
11314 ep.events = tswap32(target_ep->events);
11315 /* The epoll_data_t union is just opaque data to the kernel,
11316 * so we transfer all 64 bits across and need not worry what
11317 * actual data type it is.
11318 */
11319 ep.data.u64 = tswap64(target_ep->data.u64);
11320 unlock_user_struct(target_ep, arg4, 0);
11321 epp = &ep;
11322 }
11323 ret = get_errno(epoll_ctl(arg1, arg2, arg3, epp));
11324 break;
11325 }
11326#endif
11327
227f0214 11328#if defined(TARGET_NR_epoll_wait) || defined(TARGET_NR_epoll_pwait)
3b6edd16
PM		 11329#if defined(TARGET_NR_epoll_wait)
11330 case TARGET_NR_epoll_wait:
11331#endif
227f0214 11332#if defined(TARGET_NR_epoll_pwait)
3b6edd16
PM		 11333 case TARGET_NR_epoll_pwait:
11334#endif
11335 {
11336 struct target_epoll_event *target_ep;
11337 struct epoll_event *ep;
11338 int epfd = arg1;
11339 int maxevents = arg3;
11340 int timeout = arg4;
11341
11342 target_ep = lock_user(VERIFY_WRITE, arg2,
11343 maxevents * sizeof(struct target_epoll_event), 1);
11344 if (!target_ep) {
11345 goto efault;
11346 }
11347
11348 ep = alloca(maxevents * sizeof(struct epoll_event));
11349
11350 switch (num) {
227f0214 11351#if defined(TARGET_NR_epoll_pwait)
3b6edd16
PM		 11352 case TARGET_NR_epoll_pwait:
11353 {
11354 target_sigset_t *target_set;
11355 sigset_t _set, *set = &_set;
11356
11357 if (arg5) {
c815701e
PM		 11358 if (arg6 != sizeof(target_sigset_t)) {
11359 ret = -TARGET_EINVAL;
11360 break;
11361 }
11362
3b6edd16
PM		 11363 target_set = lock_user(VERIFY_READ, arg5,
11364 sizeof(target_sigset_t), 1);
11365 if (!target_set) {
11366 unlock_user(target_ep, arg2, 0);
11367 goto efault;
11368 }
11369 target_to_host_sigset(set, target_set);
11370 unlock_user(target_set, arg5, 0);
11371 } else {
11372 set = NULL;
11373 }
11374
227f0214
PM		 11375 ret = get_errno(safe_epoll_pwait(epfd, ep, maxevents, timeout,
11376 set, SIGSET_T_SIZE));
3b6edd16
PM		 11377 break;
11378 }
11379#endif
11380#if defined(TARGET_NR_epoll_wait)
11381 case TARGET_NR_epoll_wait:
227f0214
PM		 11382 ret = get_errno(safe_epoll_pwait(epfd, ep, maxevents, timeout,
11383 NULL, 0));
3b6edd16
PM		 11384 break;
11385#endif
11386 default:
11387 ret = -TARGET_ENOSYS;
11388 }
11389 if (!is_error(ret)) {
11390 int i;
11391 for (i = 0; i < ret; i++) {
11392 target_ep[i].events = tswap32(ep[i].events);
11393 target_ep[i].data.u64 = tswap64(ep[i].data.u64);
11394 }
11395 }
11396 unlock_user(target_ep, arg2, ret * sizeof(struct target_epoll_event));
11397 break;
11398 }
11399#endif
163a05a8
PM		 11400#endif
11401#ifdef TARGET_NR_prlimit64
11402 case TARGET_NR_prlimit64:
11403 {
11404 /* args: pid, resource number, ptr to new rlimit, ptr to old rlimit */
11405 struct target_rlimit64 *target_rnew, *target_rold;
11406 struct host_rlimit64 rnew, rold, *rnewp = 0;
95018018 11407 int resource = target_to_host_resource(arg2);
163a05a8
PM		 11408 if (arg3) {
11409 if (!lock_user_struct(VERIFY_READ, target_rnew, arg3, 1)) {
11410 goto efault;
11411 }
11412 rnew.rlim_cur = tswap64(target_rnew->rlim_cur);
11413 rnew.rlim_max = tswap64(target_rnew->rlim_max);
11414 unlock_user_struct(target_rnew, arg3, 0);
11415 rnewp = &rnew;
11416 }
11417
95018018 11418 ret = get_errno(sys_prlimit64(arg1, resource, rnewp, arg4 ? &rold : 0));
163a05a8
PM		 11419 if (!is_error(ret) && arg4) {
11420 if (!lock_user_struct(VERIFY_WRITE, target_rold, arg4, 1)) {
11421 goto efault;
11422 }
11423 target_rold->rlim_cur = tswap64(rold.rlim_cur);
11424 target_rold->rlim_max = tswap64(rold.rlim_max);
11425 unlock_user_struct(target_rold, arg4, 1);
11426 }
11427 break;
11428 }
3d21d29c
RH		 11429#endif
11430#ifdef TARGET_NR_gethostname
11431 case TARGET_NR_gethostname:
11432 {
11433 char *name = lock_user(VERIFY_WRITE, arg1, arg2, 0);
11434 if (name) {
11435 ret = get_errno(gethostname(name, arg2));
11436 unlock_user(name, arg1, arg2);
11437 } else {
11438 ret = -TARGET_EFAULT;
11439 }
11440 break;
11441 }
89aaf1a6
RV		 11442#endif
11443#ifdef TARGET_NR_atomic_cmpxchg_32
11444 case TARGET_NR_atomic_cmpxchg_32:
11445 {
11446 /* should use start_exclusive from main.c */
11447 abi_ulong mem_value;
11448 if (get_user_u32(mem_value, arg6)) {
11449 target_siginfo_t info;
11450 info.si_signo = SIGSEGV;
11451 info.si_errno = 0;
11452 info.si_code = TARGET_SEGV_MAPERR;
11453 info._sifields._sigfault._addr = arg6;
11454 queue_signal((CPUArchState *)cpu_env, info.si_signo, &info);
11455 ret = 0xdeadbeef;
11456
11457 }
11458 if (mem_value == arg2)
11459 put_user_u32(arg1, arg6);
11460 ret = mem_value;
11461 break;
11462 }
11463#endif
11464#ifdef TARGET_NR_atomic_barrier
11465 case TARGET_NR_atomic_barrier:
11466 {
11467 /* Like the kernel implementation and the qemu arm barrier, no-op this? */
3b899ea7 11468 ret = 0;
89aaf1a6
RV		 11469 break;
11470 }
d0927938 11471#endif
f4f1e10a
ECL		 11472
11473#ifdef TARGET_NR_timer_create
11474 case TARGET_NR_timer_create:
11475 {
11476 /* args: clockid_t clockid, struct sigevent *sevp, timer_t *timerid */
11477
11478 struct sigevent host_sevp = { {0}, }, *phost_sevp = NULL;
f4f1e10a
ECL		 11479
11480 int clkid = arg1;
11481 int timer_index = next_free_host_timer();
11482
11483 if (timer_index < 0) {
11484 ret = -TARGET_EAGAIN;
11485 } else {
11486 timer_t *phtimer = g_posix_timers + timer_index;
11487
11488 if (arg2) {
f4f1e10a 11489 phost_sevp = &host_sevp;
c065976f
PM		 11490 ret = target_to_host_sigevent(phost_sevp, arg2);
11491 if (ret != 0) {
11492 break;
11493 }
f4f1e10a
ECL		 11494 }
11495
11496 ret = get_errno(timer_create(clkid, phost_sevp, phtimer));
11497 if (ret) {
11498 phtimer = NULL;
11499 } else {
aecc8861 11500 if (put_user(TIMER_MAGIC | timer_index, arg3, target_timer_t)) {
f4f1e10a
ECL		 11501 goto efault;
11502 }
f4f1e10a
ECL		 11503 }
11504 }
11505 break;
11506 }
11507#endif
11508
11509#ifdef TARGET_NR_timer_settime
11510 case TARGET_NR_timer_settime:
11511 {
11512 /* args: timer_t timerid, int flags, const struct itimerspec *new_value,
11513 * struct itimerspec * old_value */
aecc8861 11514 target_timer_t timerid = get_timer_id(arg1);
e52a99f7 11515
aecc8861
AG		 11516 if (timerid < 0) {
11517 ret = timerid;
11518 } else if (arg3 == 0) {
f4f1e10a
ECL		 11519 ret = -TARGET_EINVAL;
11520 } else {
e52a99f7 11521 timer_t htimer = g_posix_timers[timerid];
f4f1e10a
ECL		 11522 struct itimerspec hspec_new = {{0},}, hspec_old = {{0},};
11523
11524 target_to_host_itimerspec(&hspec_new, arg3);
11525 ret = get_errno(
11526 timer_settime(htimer, arg2, &hspec_new, &hspec_old));
11527 host_to_target_itimerspec(arg2, &hspec_old);
11528 }
11529 break;
11530 }
11531#endif
11532
11533#ifdef TARGET_NR_timer_gettime
11534 case TARGET_NR_timer_gettime:
11535 {
11536 /* args: timer_t timerid, struct itimerspec *curr_value */
aecc8861 11537 target_timer_t timerid = get_timer_id(arg1);
e52a99f7 11538
aecc8861
AG		 11539 if (timerid < 0) {
11540 ret = timerid;
11541 } else if (!arg2) {
11542 ret = -TARGET_EFAULT;
f4f1e10a 11543 } else {
e52a99f7 11544 timer_t htimer = g_posix_timers[timerid];
f4f1e10a
ECL		 11545 struct itimerspec hspec;
11546 ret = get_errno(timer_gettime(htimer, &hspec));
11547
11548 if (host_to_target_itimerspec(arg2, &hspec)) {
11549 ret = -TARGET_EFAULT;
11550 }
11551 }
11552 break;
11553 }
11554#endif
11555
11556#ifdef TARGET_NR_timer_getoverrun
11557 case TARGET_NR_timer_getoverrun:
11558 {
11559 /* args: timer_t timerid */
aecc8861 11560 target_timer_t timerid = get_timer_id(arg1);
e52a99f7 11561
aecc8861
AG		 11562 if (timerid < 0) {
11563 ret = timerid;
f4f1e10a 11564 } else {
e52a99f7 11565 timer_t htimer = g_posix_timers[timerid];
f4f1e10a
ECL		 11566 ret = get_errno(timer_getoverrun(htimer));
11567 }
e36800c9 11568 fd_trans_unregister(ret);
f4f1e10a
ECL		 11569 break;
11570 }
11571#endif
11572
11573#ifdef TARGET_NR_timer_delete
11574 case TARGET_NR_timer_delete:
11575 {
11576 /* args: timer_t timerid */
aecc8861 11577 target_timer_t timerid = get_timer_id(arg1);
e52a99f7 11578
aecc8861
AG		 11579 if (timerid < 0) {
11580 ret = timerid;
f4f1e10a 11581 } else {
e52a99f7 11582 timer_t htimer = g_posix_timers[timerid];
f4f1e10a 11583 ret = get_errno(timer_delete(htimer));
e52a99f7 11584 g_posix_timers[timerid] = 0;
f4f1e10a
ECL		 11585 }
11586 break;
11587 }
11588#endif
11589
51834341
RV		 11590#if defined(TARGET_NR_timerfd_create) && defined(CONFIG_TIMERFD)
11591 case TARGET_NR_timerfd_create:
11592 ret = get_errno(timerfd_create(arg1,
11593 target_to_host_bitmask(arg2, fcntl_flags_tbl)));
11594 break;
11595#endif
11596
11597#if defined(TARGET_NR_timerfd_gettime) && defined(CONFIG_TIMERFD)
11598 case TARGET_NR_timerfd_gettime:
11599 {
11600 struct itimerspec its_curr;
11601
11602 ret = get_errno(timerfd_gettime(arg1, &its_curr));
11603
11604 if (arg2 && host_to_target_itimerspec(arg2, &its_curr)) {
11605 goto efault;
11606 }
11607 }
11608 break;
11609#endif
11610
11611#if defined(TARGET_NR_timerfd_settime) && defined(CONFIG_TIMERFD)
11612 case TARGET_NR_timerfd_settime:
11613 {
11614 struct itimerspec its_new, its_old, *p_new;
11615
11616 if (arg3) {
11617 if (target_to_host_itimerspec(&its_new, arg3)) {
11618 goto efault;
11619 }
11620 p_new = &its_new;
11621 } else {
11622 p_new = NULL;
11623 }
11624
11625 ret = get_errno(timerfd_settime(arg1, arg2, p_new, &its_old));
11626
11627 if (arg4 && host_to_target_itimerspec(arg4, &its_old)) {
11628 goto efault;
11629 }
11630 }
11631 break;
11632#endif
11633
ab31cda3
PB		 11634#if defined(TARGET_NR_ioprio_get) && defined(__NR_ioprio_get)
11635 case TARGET_NR_ioprio_get:
11636 ret = get_errno(ioprio_get(arg1, arg2));
11637 break;
11638#endif
11639
11640#if defined(TARGET_NR_ioprio_set) && defined(__NR_ioprio_set)
11641 case TARGET_NR_ioprio_set:
11642 ret = get_errno(ioprio_set(arg1, arg2, arg3));
11643 break;
11644#endif
11645
9af5c906
RV		 11646#if defined(TARGET_NR_setns) && defined(CONFIG_SETNS)
11647 case TARGET_NR_setns:
11648 ret = get_errno(setns(arg1, arg2));
11649 break;
11650#endif
11651#if defined(TARGET_NR_unshare) && defined(CONFIG_SETNS)
11652 case TARGET_NR_unshare:
11653 ret = get_errno(unshare(arg1));
11654 break;
11655#endif
11656
31e31b8a
FB		 11657 default:
11658 unimplemented:
5cd4393b 11659 gemu_log("qemu: Unsupported syscall: %d\n", num);
4f2b1fe8 11660#if defined(TARGET_NR_setxattr) || defined(TARGET_NR_get_thread_area) || defined(TARGET_NR_getdomainname) || defined(TARGET_NR_set_robust_list)
5cd4393b 11661 unimplemented_nowarn:
80a9d035 11662#endif
0da46a6e 11663 ret = -TARGET_ENOSYS;
31e31b8a
FB		 11664 break;
11665 }
579a97f7 11666fail:
c573ff67 11667#ifdef DEBUG
0bf9e31a 11668 gemu_log(" = " TARGET_ABI_FMT_ld "\n", ret);
c573ff67 11669#endif
b92c47c1
TS		 11670 if(do_strace)
11671 print_syscall_ret(num, ret);
9c15e700 11672 trace_guest_user_syscall_ret(cpu, num, ret);
31e31b8a 11673 return ret;
579a97f7
FB		 11674efault:
11675 ret = -TARGET_EFAULT;
11676 goto fail;
31e31b8a 11677}
Empty description
This page took 2.789759 seconds and 4 git commands to generate.