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