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