]> 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
Make ioctl table static
[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
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
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>
8d5c28ec 31#include <dirent.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>
39b9aae1 39#include <sys/prctl.h>
31e31b8a
FB		 40#include <sys/resource.h>
41#include <sys/mman.h>
42#include <sys/swap.h>
43#include <signal.h>
44#include <sched.h>
45#include <sys/socket.h>
46#include <sys/uio.h>
9de5e440 47#include <sys/poll.h>
32f36bce 48#include <sys/times.h>
8853f86e 49#include <sys/shm.h>
fa294816 50#include <sys/sem.h>
56c8f68f 51#include <sys/statfs.h>
ebc05488 52#include <utime.h>
a5448a7d 53#include <sys/sysinfo.h>
72f03900 54//#include <sys/user.h>
8853f86e 55#include <netinet/ip.h>
7854b056 56#include <netinet/tcp.h>
0b6d3ae0 57#include <qemu-common.h>
31e31b8a
FB		 58
59#define termios host_termios
60#define winsize host_winsize
61#define termio host_termio
04369ff2
FB		 62#define sgttyb host_sgttyb /* same as target */
63#define tchars host_tchars /* same as target */
64#define ltchars host_ltchars /* same as target */
31e31b8a
FB		 65
66#include <linux/termios.h>
67#include <linux/unistd.h>
68#include <linux/utsname.h>
69#include <linux/cdrom.h>
70#include <linux/hdreg.h>
71#include <linux/soundcard.h>
19b84f3c 72#include <linux/kd.h>
8fbd6b52 73#include <linux/mtio.h>
d7e4036e 74#include "linux_loop.h"
31e31b8a 75
3ef693a0 76#include "qemu.h"
526ccb7a 77#include "qemu-common.h"
31e31b8a 78
30813cea
PB		 79#if defined(USE_NPTL)
80#include <linux/futex.h>
d865bab5
PB		 81#define CLONE_NPTL_FLAGS2 (CLONE_SETTLS | \
82 CLONE_PARENT_SETTID | CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID)
83#else
84/* XXX: Hardcode the above values. */
85#define CLONE_NPTL_FLAGS2 0
30813cea
PB		 86#endif
87
72f03900 88//#define DEBUG
31e31b8a 89
e6e5906b 90#if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_SPARC) \
48733d19 91 || defined(TARGET_M68K) || defined(TARGET_SH4) || defined(TARGET_CRIS)
67867308
FB		 92/* 16 bit uid wrappers emulation */
93#define USE_UID16
94#endif
95
1a9353d2
FB		 96//#include <linux/msdos_fs.h>
97#define VFAT_IOCTL_READDIR_BOTH _IOR('r', 1, struct dirent [2])
98#define VFAT_IOCTL_READDIR_SHORT _IOR('r', 2, struct dirent [2])
99
70a194b9 100
70a194b9
FB		 101#undef _syscall0
102#undef _syscall1
103#undef _syscall2
104#undef _syscall3
105#undef _syscall4
106#undef _syscall5
83fcb515 107#undef _syscall6
70a194b9 108
83fcb515 109#define _syscall0(type,name) \
8fcd3692 110static type name (void) \
83fcb515
FB		 111{ \
112 return syscall(__NR_##name); \
113}
70a194b9 114
83fcb515 115#define _syscall1(type,name,type1,arg1) \
8fcd3692 116static type name (type1 arg1) \
83fcb515
FB		 117{ \
118 return syscall(__NR_##name, arg1); \
70a194b9
FB		 119}
120
83fcb515 121#define _syscall2(type,name,type1,arg1,type2,arg2) \
8fcd3692 122static type name (type1 arg1,type2 arg2) \
83fcb515
FB		 123{ \
124 return syscall(__NR_##name, arg1, arg2); \
70a194b9
FB		 125}
126
83fcb515 127#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
8fcd3692 128static type name (type1 arg1,type2 arg2,type3 arg3) \
83fcb515
FB		 129{ \
130 return syscall(__NR_##name, arg1, arg2, arg3); \
70a194b9
FB		 131}
132
83fcb515 133#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
8fcd3692 134static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4) \
83fcb515
FB		 135{ \
136 return syscall(__NR_##name, arg1, arg2, arg3, arg4); \
70a194b9
FB		 137}
138
83fcb515
FB		 139#define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
140 type5,arg5) \
8fcd3692 141static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
83fcb515
FB		 142{ \
143 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \
70a194b9
FB		 144}
145
83fcb515
FB		 146
147#define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
148 type5,arg5,type6,arg6) \
8fcd3692
BS		 149static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5, \
150 type6 arg6) \
83fcb515
FB		 151{ \
152 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
70a194b9 153}
83fcb515 154
70a194b9 155
31e31b8a 156#define __NR_sys_uname __NR_uname
92a34c10 157#define __NR_sys_faccessat __NR_faccessat
814d7977 158#define __NR_sys_fchmodat __NR_fchmodat
ccfa72b7 159#define __NR_sys_fchownat __NR_fchownat
6a24a778 160#define __NR_sys_fstatat64 __NR_fstatat64
ac8a6556 161#define __NR_sys_futimesat __NR_futimesat
72f03900 162#define __NR_sys_getcwd1 __NR_getcwd
72f03900 163#define __NR_sys_getdents __NR_getdents
dab2ed99 164#define __NR_sys_getdents64 __NR_getdents64
c6cda17a 165#define __NR_sys_getpriority __NR_getpriority
64f0ce4c 166#define __NR_sys_linkat __NR_linkat
4472ad0d 167#define __NR_sys_mkdirat __NR_mkdirat
75ac37a0 168#define __NR_sys_mknodat __NR_mknodat
82424832 169#define __NR_sys_openat __NR_openat
5e0ccb18 170#define __NR_sys_readlinkat __NR_readlinkat
722183f6 171#define __NR_sys_renameat __NR_renameat
66fb9763 172#define __NR_sys_rt_sigqueueinfo __NR_rt_sigqueueinfo
f0b6243d 173#define __NR_sys_symlinkat __NR_symlinkat
7494b0f9 174#define __NR_sys_syslog __NR_syslog
71455574 175#define __NR_sys_tgkill __NR_tgkill
4cae1d16 176#define __NR_sys_tkill __NR_tkill
8170f56b 177#define __NR_sys_unlinkat __NR_unlinkat
9007f0ef 178#define __NR_sys_utimensat __NR_utimensat
bd0c5661 179#define __NR_sys_futex __NR_futex
39b59763
AJ		 180#define __NR_sys_inotify_init __NR_inotify_init
181#define __NR_sys_inotify_add_watch __NR_inotify_add_watch
182#define __NR_sys_inotify_rm_watch __NR_inotify_rm_watch
31e31b8a 183
bc51c5c9 184#if defined(__alpha__) || defined (__ia64__) || defined(__x86_64__)
9af9eaaa
FB		 185#define __NR__llseek __NR_lseek
186#endif
187
72f03900 188#ifdef __NR_gettid
31e31b8a 189_syscall0(int, gettid)
72f03900 190#else
0da46a6e
TS		 191/* This is a replacement for the host gettid() and must return a host
192 errno. */
72f03900
FB		 193static int gettid(void) {
194 return -ENOSYS;
195}
196#endif
31e31b8a 197_syscall1(int,sys_uname,struct new_utsname *,buf)
92a34c10
TS		 198#if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
199_syscall4(int,sys_faccessat,int,dirfd,const char *,pathname,int,mode,int,flags)
200#endif
814d7977
TS		 201#if defined(TARGET_NR_fchmodat) && defined(__NR_fchmodat)
202_syscall4(int,sys_fchmodat,int,dirfd,const char *,pathname,
203 mode_t,mode,int,flags)
204#endif
4583f589 205#if defined(TARGET_NR_fchownat) && defined(__NR_fchownat) && defined(USE_UID16)
ccfa72b7
TS		 206_syscall5(int,sys_fchownat,int,dirfd,const char *,pathname,
207 uid_t,owner,gid_t,group,int,flags)
208#endif
6a24a778
AZ		 209#if defined(TARGET_NR_fstatat64) && defined(__NR_fstatat64)
210_syscall4(int,sys_fstatat64,int,dirfd,const char *,pathname,
211 struct stat *,buf,int,flags)
212#endif
ac8a6556
AZ		 213#if defined(TARGET_NR_futimesat) && defined(__NR_futimesat)
214_syscall3(int,sys_futimesat,int,dirfd,const char *,pathname,
215 const struct timeval *,times)
216#endif
72f03900 217_syscall2(int,sys_getcwd1,char *,buf,size_t,size)
4583f589 218#if TARGET_ABI_BITS == 32
72f03900 219_syscall3(int, sys_getdents, uint, fd, struct dirent *, dirp, uint, count);
4583f589 220#endif
3ae43202 221#if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
dab2ed99 222_syscall3(int, sys_getdents64, uint, fd, struct dirent64 *, dirp, uint, count);
3ae43202 223#endif
c6cda17a 224_syscall2(int, sys_getpriority, int, which, int, who);
8fcd3692 225#if !defined (__x86_64__)
31e31b8a
FB		 226_syscall5(int, _llseek, uint, fd, ulong, hi, ulong, lo,
227 loff_t *, res, uint, wh);
8fcd3692 228#endif
64f0ce4c
TS		 229#if defined(TARGET_NR_linkat) && defined(__NR_linkat)
230_syscall5(int,sys_linkat,int,olddirfd,const char *,oldpath,
231 int,newdirfd,const char *,newpath,int,flags)
232#endif
4472ad0d
TS		 233#if defined(TARGET_NR_mkdirat) && defined(__NR_mkdirat)
234_syscall3(int,sys_mkdirat,int,dirfd,const char *,pathname,mode_t,mode)
235#endif
75ac37a0
TS		 236#if defined(TARGET_NR_mknodat) && defined(__NR_mknodat)
237_syscall4(int,sys_mknodat,int,dirfd,const char *,pathname,
238 mode_t,mode,dev_t,dev)
239#endif
82424832
TS		 240#if defined(TARGET_NR_openat) && defined(__NR_openat)
241_syscall4(int,sys_openat,int,dirfd,const char *,pathname,int,flags,mode_t,mode)
242#endif
5e0ccb18
TS		 243#if defined(TARGET_NR_readlinkat) && defined(__NR_readlinkat)
244_syscall4(int,sys_readlinkat,int,dirfd,const char *,pathname,
245 char *,buf,size_t,bufsize)
246#endif
722183f6
TS		 247#if defined(TARGET_NR_renameat) && defined(__NR_renameat)
248_syscall4(int,sys_renameat,int,olddirfd,const char *,oldpath,
249 int,newdirfd,const char *,newpath)
250#endif
66fb9763 251_syscall3(int,sys_rt_sigqueueinfo,int,pid,int,sig,siginfo_t *,uinfo)
b51eaa82 252#if defined(TARGET_NR_symlinkat) && defined(__NR_symlinkat)
f0b6243d
TS		 253_syscall3(int,sys_symlinkat,const char *,oldpath,
254 int,newdirfd,const char *,newpath)
255#endif
7494b0f9 256_syscall3(int,sys_syslog,int,type,char*,bufp,int,len)
3ae43202 257#if defined(TARGET_NR_tgkill) && defined(__NR_tgkill)
71455574 258_syscall3(int,sys_tgkill,int,tgid,int,pid,int,sig)
4cae1d16 259#endif
3ae43202 260#if defined(TARGET_NR_tkill) && defined(__NR_tkill)
4cae1d16
TS		 261_syscall2(int,sys_tkill,int,tid,int,sig)
262#endif
ec86b0fb
FB		 263#ifdef __NR_exit_group
264_syscall1(int,exit_group,int,error_code)
265#endif
6f5b89a0
TS		 266#if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
267_syscall1(int,set_tid_address,int *,tidptr)
268#endif
8170f56b
TS		 269#if defined(TARGET_NR_unlinkat) && defined(__NR_unlinkat)
270_syscall3(int,sys_unlinkat,int,dirfd,const char *,pathname,int,flags)
271#endif
9007f0ef
TS		 272#if defined(TARGET_NR_utimensat) && defined(__NR_utimensat)
273_syscall4(int,sys_utimensat,int,dirfd,const char *,pathname,
274 const struct timespec *,tsp,int,flags)
275#endif
39b59763
AJ		 276#if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
277_syscall0(int,sys_inotify_init)
278#endif
279#if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)
280_syscall3(int,sys_inotify_add_watch,int,fd,const char *,pathname,uint32_t,mask)
281#endif
282#if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)
283_syscall2(int,sys_inotify_rm_watch,int,fd,uint32_t,wd)
284#endif
8fcd3692 285#if defined(USE_NPTL)
bd0c5661
PB		 286#if defined(TARGET_NR_futex) && defined(__NR_futex)
287_syscall6(int,sys_futex,int *,uaddr,int,op,int,val,
288 const struct timespec *,timeout,int *,uaddr2,int,val3)
8fcd3692 289#endif
bd0c5661 290#endif
66fb9763
FB		 291
292extern int personality(int);
9de5e440
FB		 293extern int flock(int, int);
294extern int setfsuid(int);
295extern int setfsgid(int);
19b84f3c 296extern int setgroups(int, gid_t *);
31e31b8a 297
b92c47c1
TS		 298#define ERRNO_TABLE_SIZE 1200
299
300/* target_to_host_errno_table[] is initialized from
301 * host_to_target_errno_table[] in syscall_init(). */
302static uint16_t target_to_host_errno_table[ERRNO_TABLE_SIZE] = {
303};
304
637947f1 305/*
fe8f096b 306 * This list is the union of errno values overridden in asm-<arch>/errno.h
637947f1
TS		 307 * minus the errnos that are not actually generic to all archs.
308 */
b92c47c1 309static uint16_t host_to_target_errno_table[ERRNO_TABLE_SIZE] = {
637947f1
TS		 310 [EIDRM] = TARGET_EIDRM,
311 [ECHRNG] = TARGET_ECHRNG,
312 [EL2NSYNC] = TARGET_EL2NSYNC,
313 [EL3HLT] = TARGET_EL3HLT,
314 [EL3RST] = TARGET_EL3RST,
315 [ELNRNG] = TARGET_ELNRNG,
316 [EUNATCH] = TARGET_EUNATCH,
317 [ENOCSI] = TARGET_ENOCSI,
318 [EL2HLT] = TARGET_EL2HLT,
319 [EDEADLK] = TARGET_EDEADLK,
320 [ENOLCK] = TARGET_ENOLCK,
321 [EBADE] = TARGET_EBADE,
322 [EBADR] = TARGET_EBADR,
323 [EXFULL] = TARGET_EXFULL,
324 [ENOANO] = TARGET_ENOANO,
325 [EBADRQC] = TARGET_EBADRQC,
326 [EBADSLT] = TARGET_EBADSLT,
327 [EBFONT] = TARGET_EBFONT,
328 [ENOSTR] = TARGET_ENOSTR,
329 [ENODATA] = TARGET_ENODATA,
330 [ETIME] = TARGET_ETIME,
331 [ENOSR] = TARGET_ENOSR,
332 [ENONET] = TARGET_ENONET,
333 [ENOPKG] = TARGET_ENOPKG,
334 [EREMOTE] = TARGET_EREMOTE,
335 [ENOLINK] = TARGET_ENOLINK,
336 [EADV] = TARGET_EADV,
337 [ESRMNT] = TARGET_ESRMNT,
338 [ECOMM] = TARGET_ECOMM,
339 [EPROTO] = TARGET_EPROTO,
340 [EDOTDOT] = TARGET_EDOTDOT,
341 [EMULTIHOP] = TARGET_EMULTIHOP,
342 [EBADMSG] = TARGET_EBADMSG,
343 [ENAMETOOLONG] = TARGET_ENAMETOOLONG,
344 [EOVERFLOW] = TARGET_EOVERFLOW,
345 [ENOTUNIQ] = TARGET_ENOTUNIQ,
346 [EBADFD] = TARGET_EBADFD,
347 [EREMCHG] = TARGET_EREMCHG,
348 [ELIBACC] = TARGET_ELIBACC,
349 [ELIBBAD] = TARGET_ELIBBAD,
350 [ELIBSCN] = TARGET_ELIBSCN,
351 [ELIBMAX] = TARGET_ELIBMAX,
352 [ELIBEXEC] = TARGET_ELIBEXEC,
353 [EILSEQ] = TARGET_EILSEQ,
354 [ENOSYS] = TARGET_ENOSYS,
355 [ELOOP] = TARGET_ELOOP,
356 [ERESTART] = TARGET_ERESTART,
357 [ESTRPIPE] = TARGET_ESTRPIPE,
358 [ENOTEMPTY] = TARGET_ENOTEMPTY,
359 [EUSERS] = TARGET_EUSERS,
360 [ENOTSOCK] = TARGET_ENOTSOCK,
361 [EDESTADDRREQ] = TARGET_EDESTADDRREQ,
362 [EMSGSIZE] = TARGET_EMSGSIZE,
363 [EPROTOTYPE] = TARGET_EPROTOTYPE,
364 [ENOPROTOOPT] = TARGET_ENOPROTOOPT,
365 [EPROTONOSUPPORT] = TARGET_EPROTONOSUPPORT,
366 [ESOCKTNOSUPPORT] = TARGET_ESOCKTNOSUPPORT,
367 [EOPNOTSUPP] = TARGET_EOPNOTSUPP,
368 [EPFNOSUPPORT] = TARGET_EPFNOSUPPORT,
369 [EAFNOSUPPORT] = TARGET_EAFNOSUPPORT,
370 [EADDRINUSE] = TARGET_EADDRINUSE,
371 [EADDRNOTAVAIL] = TARGET_EADDRNOTAVAIL,
372 [ENETDOWN] = TARGET_ENETDOWN,
373 [ENETUNREACH] = TARGET_ENETUNREACH,
374 [ENETRESET] = TARGET_ENETRESET,
375 [ECONNABORTED] = TARGET_ECONNABORTED,
376 [ECONNRESET] = TARGET_ECONNRESET,
377 [ENOBUFS] = TARGET_ENOBUFS,
378 [EISCONN] = TARGET_EISCONN,
379 [ENOTCONN] = TARGET_ENOTCONN,
380 [EUCLEAN] = TARGET_EUCLEAN,
381 [ENOTNAM] = TARGET_ENOTNAM,
382 [ENAVAIL] = TARGET_ENAVAIL,
383 [EISNAM] = TARGET_EISNAM,
384 [EREMOTEIO] = TARGET_EREMOTEIO,
385 [ESHUTDOWN] = TARGET_ESHUTDOWN,
386 [ETOOMANYREFS] = TARGET_ETOOMANYREFS,
387 [ETIMEDOUT] = TARGET_ETIMEDOUT,
388 [ECONNREFUSED] = TARGET_ECONNREFUSED,
389 [EHOSTDOWN] = TARGET_EHOSTDOWN,
390 [EHOSTUNREACH] = TARGET_EHOSTUNREACH,
391 [EALREADY] = TARGET_EALREADY,
392 [EINPROGRESS] = TARGET_EINPROGRESS,
393 [ESTALE] = TARGET_ESTALE,
394 [ECANCELED] = TARGET_ECANCELED,
395 [ENOMEDIUM] = TARGET_ENOMEDIUM,
396 [EMEDIUMTYPE] = TARGET_EMEDIUMTYPE,
b7fe5db7 397#ifdef ENOKEY
637947f1 398 [ENOKEY] = TARGET_ENOKEY,
b7fe5db7
TS		 399#endif
400#ifdef EKEYEXPIRED
637947f1 401 [EKEYEXPIRED] = TARGET_EKEYEXPIRED,
b7fe5db7
TS		 402#endif
403#ifdef EKEYREVOKED
637947f1 404 [EKEYREVOKED] = TARGET_EKEYREVOKED,
b7fe5db7
TS		 405#endif
406#ifdef EKEYREJECTED
637947f1 407 [EKEYREJECTED] = TARGET_EKEYREJECTED,
b7fe5db7
TS		 408#endif
409#ifdef EOWNERDEAD
637947f1 410 [EOWNERDEAD] = TARGET_EOWNERDEAD,
b7fe5db7
TS		 411#endif
412#ifdef ENOTRECOVERABLE
637947f1 413 [ENOTRECOVERABLE] = TARGET_ENOTRECOVERABLE,
b7fe5db7 414#endif
b92c47c1 415};
637947f1
TS		 416
417static inline int host_to_target_errno(int err)
418{
419 if(host_to_target_errno_table[err])
420 return host_to_target_errno_table[err];
421 return err;
422}
423
b92c47c1
TS		 424static inline int target_to_host_errno(int err)
425{
426 if (target_to_host_errno_table[err])
427 return target_to_host_errno_table[err];
428 return err;
429}
430
992f48a0 431static inline abi_long get_errno(abi_long ret)
31e31b8a
FB		 432{
433 if (ret == -1)
637947f1 434 return -host_to_target_errno(errno);
31e31b8a
FB		 435 else
436 return ret;
437}
438
992f48a0 439static inline int is_error(abi_long ret)
31e31b8a 440{
992f48a0 441 return (abi_ulong)ret >= (abi_ulong)(-4096);
31e31b8a
FB		 442}
443
b92c47c1
TS		 444char *target_strerror(int err)
445{
446 return strerror(target_to_host_errno(err));
447}
448
992f48a0
BS		 449static abi_ulong target_brk;
450static abi_ulong target_original_brk;
31e31b8a 451
992f48a0 452void target_set_brk(abi_ulong new_brk)
31e31b8a 453{
4c1de73d 454 target_original_brk = target_brk = HOST_PAGE_ALIGN(new_brk);
31e31b8a
FB		 455}
456
0da46a6e 457/* do_brk() must return target values and target errnos. */
992f48a0 458abi_long do_brk(abi_ulong new_brk)
31e31b8a 459{
992f48a0
BS		 460 abi_ulong brk_page;
461 abi_long mapped_addr;
31e31b8a
FB		 462 int new_alloc_size;
463
464 if (!new_brk)
53a5960a 465 return target_brk;
31e31b8a 466 if (new_brk < target_original_brk)
7ab240ad 467 return target_brk;
3b46e624 468
53a5960a 469 brk_page = HOST_PAGE_ALIGN(target_brk);
31e31b8a
FB		 470
471 /* If the new brk is less than this, set it and we're done... */
472 if (new_brk < brk_page) {
473 target_brk = new_brk;
53a5960a 474 return target_brk;
31e31b8a
FB		 475 }
476
477 /* We need to allocate more memory after the brk... */
54936004 478 new_alloc_size = HOST_PAGE_ALIGN(new_brk - brk_page + 1);
5fafdf24 479 mapped_addr = get_errno(target_mmap(brk_page, new_alloc_size,
54936004
FB		 480 PROT_READ|PROT_WRITE,
481 MAP_ANON|MAP_FIXED|MAP_PRIVATE, 0, 0));
7ab240ad
AZ		 482
483 if (!is_error(mapped_addr))
31e31b8a 484 target_brk = new_brk;
7ab240ad
AZ		 485
486 return target_brk;
31e31b8a
FB		 487}
488
26edcf41
TS		 489static inline abi_long copy_from_user_fdset(fd_set *fds,
490 abi_ulong target_fds_addr,
491 int n)
31e31b8a 492{
26edcf41
TS		 493 int i, nw, j, k;
494 abi_ulong b, *target_fds;
495
496 nw = (n + TARGET_ABI_BITS - 1) / TARGET_ABI_BITS;
497 if (!(target_fds = lock_user(VERIFY_READ,
498 target_fds_addr,
499 sizeof(abi_ulong) * nw,
500 1)))
501 return -TARGET_EFAULT;
502
503 FD_ZERO(fds);
504 k = 0;
505 for (i = 0; i < nw; i++) {
506 /* grab the abi_ulong */
507 __get_user(b, &target_fds[i]);
508 for (j = 0; j < TARGET_ABI_BITS; j++) {
509 /* check the bit inside the abi_ulong */
510 if ((b >> j) & 1)
511 FD_SET(k, fds);
512 k++;
31e31b8a 513 }
31e31b8a 514 }
26edcf41
TS		 515
516 unlock_user(target_fds, target_fds_addr, 0);
517
518 return 0;
31e31b8a
FB		 519}
520
26edcf41
TS		 521static inline abi_long copy_to_user_fdset(abi_ulong target_fds_addr,
522 const fd_set *fds,
523 int n)
31e31b8a 524{
31e31b8a 525 int i, nw, j, k;
992f48a0 526 abi_long v;
26edcf41 527 abi_ulong *target_fds;
31e31b8a 528
26edcf41
TS		 529 nw = (n + TARGET_ABI_BITS - 1) / TARGET_ABI_BITS;
530 if (!(target_fds = lock_user(VERIFY_WRITE,
531 target_fds_addr,
532 sizeof(abi_ulong) * nw,
533 0)))
534 return -TARGET_EFAULT;
535
536 k = 0;
537 for (i = 0; i < nw; i++) {
538 v = 0;
539 for (j = 0; j < TARGET_ABI_BITS; j++) {
540 v |= ((FD_ISSET(k, fds) != 0) << j);
541 k++;
31e31b8a 542 }
26edcf41 543 __put_user(v, &target_fds[i]);
31e31b8a 544 }
26edcf41
TS		 545
546 unlock_user(target_fds, target_fds_addr, sizeof(abi_ulong) * nw);
547
548 return 0;
31e31b8a
FB		 549}
550
c596ed17
FB		 551#if defined(__alpha__)
552#define HOST_HZ 1024
553#else
554#define HOST_HZ 100
555#endif
556
992f48a0 557static inline abi_long host_to_target_clock_t(long ticks)
c596ed17
FB		 558{
559#if HOST_HZ == TARGET_HZ
560 return ticks;
561#else
562 return ((int64_t)ticks * TARGET_HZ) / HOST_HZ;
563#endif
564}
565
579a97f7
FB		 566static inline abi_long host_to_target_rusage(abi_ulong target_addr,
567 const struct rusage *rusage)
b409186b 568{
53a5960a
PB		 569 struct target_rusage *target_rusage;
570
579a97f7
FB		 571 if (!lock_user_struct(VERIFY_WRITE, target_rusage, target_addr, 0))
572 return -TARGET_EFAULT;
b409186b
FB		 573 target_rusage->ru_utime.tv_sec = tswapl(rusage->ru_utime.tv_sec);
574 target_rusage->ru_utime.tv_usec = tswapl(rusage->ru_utime.tv_usec);
575 target_rusage->ru_stime.tv_sec = tswapl(rusage->ru_stime.tv_sec);
576 target_rusage->ru_stime.tv_usec = tswapl(rusage->ru_stime.tv_usec);
577 target_rusage->ru_maxrss = tswapl(rusage->ru_maxrss);
578 target_rusage->ru_ixrss = tswapl(rusage->ru_ixrss);
579 target_rusage->ru_idrss = tswapl(rusage->ru_idrss);
580 target_rusage->ru_isrss = tswapl(rusage->ru_isrss);
581 target_rusage->ru_minflt = tswapl(rusage->ru_minflt);
582 target_rusage->ru_majflt = tswapl(rusage->ru_majflt);
583 target_rusage->ru_nswap = tswapl(rusage->ru_nswap);
584 target_rusage->ru_inblock = tswapl(rusage->ru_inblock);
585 target_rusage->ru_oublock = tswapl(rusage->ru_oublock);
586 target_rusage->ru_msgsnd = tswapl(rusage->ru_msgsnd);
587 target_rusage->ru_msgrcv = tswapl(rusage->ru_msgrcv);
588 target_rusage->ru_nsignals = tswapl(rusage->ru_nsignals);
589 target_rusage->ru_nvcsw = tswapl(rusage->ru_nvcsw);
590 target_rusage->ru_nivcsw = tswapl(rusage->ru_nivcsw);
53a5960a 591 unlock_user_struct(target_rusage, target_addr, 1);
579a97f7
FB		 592
593 return 0;
b409186b
FB		 594}
595
788f5ec4
TS		 596static inline abi_long copy_from_user_timeval(struct timeval *tv,
597 abi_ulong target_tv_addr)
31e31b8a 598{
53a5960a
PB		 599 struct target_timeval *target_tv;
600
788f5ec4 601 if (!lock_user_struct(VERIFY_READ, target_tv, target_tv_addr, 1))
579a97f7 602 return -TARGET_EFAULT;
788f5ec4
TS		 603
604 __get_user(tv->tv_sec, &target_tv->tv_sec);
605 __get_user(tv->tv_usec, &target_tv->tv_usec);
606
607 unlock_user_struct(target_tv, target_tv_addr, 0);
579a97f7
FB		 608
609 return 0;
31e31b8a
FB		 610}
611
788f5ec4
TS		 612static inline abi_long copy_to_user_timeval(abi_ulong target_tv_addr,
613 const struct timeval *tv)
31e31b8a 614{
53a5960a
PB		 615 struct target_timeval *target_tv;
616
788f5ec4 617 if (!lock_user_struct(VERIFY_WRITE, target_tv, target_tv_addr, 0))
579a97f7 618 return -TARGET_EFAULT;
788f5ec4
TS		 619
620 __put_user(tv->tv_sec, &target_tv->tv_sec);
621 __put_user(tv->tv_usec, &target_tv->tv_usec);
622
623 unlock_user_struct(target_tv, target_tv_addr, 1);
579a97f7
FB		 624
625 return 0;
31e31b8a
FB		 626}
627
628
0da46a6e 629/* do_select() must return target values and target errnos. */
992f48a0 630static abi_long do_select(int n,
26edcf41
TS		 631 abi_ulong rfd_addr, abi_ulong wfd_addr,
632 abi_ulong efd_addr, abi_ulong target_tv_addr)
31e31b8a
FB		 633{
634 fd_set rfds, wfds, efds;
635 fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
636 struct timeval tv, *tv_ptr;
992f48a0 637 abi_long ret;
31e31b8a 638
26edcf41
TS		 639 if (rfd_addr) {
640 if (copy_from_user_fdset(&rfds, rfd_addr, n))
641 return -TARGET_EFAULT;
642 rfds_ptr = &rfds;
53a5960a 643 } else {
53a5960a
PB		 644 rfds_ptr = NULL;
645 }
26edcf41
TS		 646 if (wfd_addr) {
647 if (copy_from_user_fdset(&wfds, wfd_addr, n))
648 return -TARGET_EFAULT;
649 wfds_ptr = &wfds;
53a5960a 650 } else {
53a5960a
PB		 651 wfds_ptr = NULL;
652 }
26edcf41
TS		 653 if (efd_addr) {
654 if (copy_from_user_fdset(&efds, efd_addr, n))
655 return -TARGET_EFAULT;
656 efds_ptr = &efds;
53a5960a 657 } else {
53a5960a
PB		 658 efds_ptr = NULL;
659 }
3b46e624 660
26edcf41 661 if (target_tv_addr) {
788f5ec4
TS		 662 if (copy_from_user_timeval(&tv, target_tv_addr))
663 return -TARGET_EFAULT;
31e31b8a
FB		 664 tv_ptr = &tv;
665 } else {
666 tv_ptr = NULL;
667 }
26edcf41 668
31e31b8a 669 ret = get_errno(select(n, rfds_ptr, wfds_ptr, efds_ptr, tv_ptr));
53a5960a 670
26edcf41
TS		 671 if (!is_error(ret)) {
672 if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n))
673 return -TARGET_EFAULT;
674 if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n))
675 return -TARGET_EFAULT;
676 if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n))
677 return -TARGET_EFAULT;
31e31b8a 678
788f5ec4
TS		 679 if (target_tv_addr && copy_to_user_timeval(target_tv_addr, &tv))
680 return -TARGET_EFAULT;
31e31b8a 681 }
579a97f7 682
31e31b8a
FB		 683 return ret;
684}
685
579a97f7
FB		 686static inline abi_long target_to_host_sockaddr(struct sockaddr *addr,
687 abi_ulong target_addr,
688 socklen_t len)
7854b056 689{
53a5960a
PB		 690 struct target_sockaddr *target_saddr;
691
579a97f7
FB		 692 target_saddr = lock_user(VERIFY_READ, target_addr, len, 1);
693 if (!target_saddr)
694 return -TARGET_EFAULT;
53a5960a
PB		 695 memcpy(addr, target_saddr, len);
696 addr->sa_family = tswap16(target_saddr->sa_family);
697 unlock_user(target_saddr, target_addr, 0);
579a97f7
FB		 698
699 return 0;
7854b056
FB		 700}
701
579a97f7
FB		 702static inline abi_long host_to_target_sockaddr(abi_ulong target_addr,
703 struct sockaddr *addr,
704 socklen_t len)
7854b056 705{
53a5960a
PB		 706 struct target_sockaddr *target_saddr;
707
579a97f7
FB		 708 target_saddr = lock_user(VERIFY_WRITE, target_addr, len, 0);
709 if (!target_saddr)
710 return -TARGET_EFAULT;
53a5960a
PB		 711 memcpy(target_saddr, addr, len);
712 target_saddr->sa_family = tswap16(addr->sa_family);
713 unlock_user(target_saddr, target_addr, len);
579a97f7
FB		 714
715 return 0;
7854b056
FB		 716}
717
53a5960a 718/* ??? Should this also swap msgh->name? */
5a4a898d
FB		 719static inline abi_long target_to_host_cmsg(struct msghdr *msgh,
720 struct target_msghdr *target_msgh)
7854b056
FB		 721{
722 struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh);
5a4a898d
FB		 723 abi_long msg_controllen;
724 abi_ulong target_cmsg_addr;
725 struct target_cmsghdr *target_cmsg;
7854b056 726 socklen_t space = 0;
5a4a898d
FB		 727
728 msg_controllen = tswapl(target_msgh->msg_controllen);
729 if (msg_controllen < sizeof (struct target_cmsghdr))
730 goto the_end;
731 target_cmsg_addr = tswapl(target_msgh->msg_control);
732 target_cmsg = lock_user(VERIFY_READ, target_cmsg_addr, msg_controllen, 1);
733 if (!target_cmsg)
734 return -TARGET_EFAULT;
7854b056
FB		 735
736 while (cmsg && target_cmsg) {
737 void *data = CMSG_DATA(cmsg);
738 void *target_data = TARGET_CMSG_DATA(target_cmsg);
739
5fafdf24 740 int len = tswapl(target_cmsg->cmsg_len)
7854b056
FB		 741 - TARGET_CMSG_ALIGN(sizeof (struct target_cmsghdr));
742
743 space += CMSG_SPACE(len);
744 if (space > msgh->msg_controllen) {
745 space -= CMSG_SPACE(len);
31febb71 746 gemu_log("Host cmsg overflow\n");
7854b056
FB		 747 break;
748 }
749
750 cmsg->cmsg_level = tswap32(target_cmsg->cmsg_level);
751 cmsg->cmsg_type = tswap32(target_cmsg->cmsg_type);
752 cmsg->cmsg_len = CMSG_LEN(len);
753
3532fa74 754 if (cmsg->cmsg_level != TARGET_SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) {
7854b056
FB		 755 gemu_log("Unsupported ancillary data: %d/%d\n", cmsg->cmsg_level, cmsg->cmsg_type);
756 memcpy(data, target_data, len);
757 } else {
758 int *fd = (int *)data;
759 int *target_fd = (int *)target_data;
760 int i, numfds = len / sizeof(int);
761
762 for (i = 0; i < numfds; i++)
763 fd[i] = tswap32(target_fd[i]);
764 }
765
766 cmsg = CMSG_NXTHDR(msgh, cmsg);
767 target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg);
768 }
5a4a898d
FB		 769 unlock_user(target_cmsg, target_cmsg_addr, 0);
770 the_end:
7854b056 771 msgh->msg_controllen = space;
5a4a898d 772 return 0;
7854b056
FB		 773}
774
53a5960a 775/* ??? Should this also swap msgh->name? */
5a4a898d
FB		 776static inline abi_long host_to_target_cmsg(struct target_msghdr *target_msgh,
777 struct msghdr *msgh)
7854b056
FB		 778{
779 struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh);
5a4a898d
FB		 780 abi_long msg_controllen;
781 abi_ulong target_cmsg_addr;
782 struct target_cmsghdr *target_cmsg;
7854b056
FB		 783 socklen_t space = 0;
784
5a4a898d
FB		 785 msg_controllen = tswapl(target_msgh->msg_controllen);
786 if (msg_controllen < sizeof (struct target_cmsghdr))
787 goto the_end;
788 target_cmsg_addr = tswapl(target_msgh->msg_control);
789 target_cmsg = lock_user(VERIFY_WRITE, target_cmsg_addr, msg_controllen, 0);
790 if (!target_cmsg)
791 return -TARGET_EFAULT;
792
7854b056
FB		 793 while (cmsg && target_cmsg) {
794 void *data = CMSG_DATA(cmsg);
795 void *target_data = TARGET_CMSG_DATA(target_cmsg);
796
797 int len = cmsg->cmsg_len - CMSG_ALIGN(sizeof (struct cmsghdr));
798
799 space += TARGET_CMSG_SPACE(len);
5a4a898d 800 if (space > msg_controllen) {
7854b056 801 space -= TARGET_CMSG_SPACE(len);
31febb71 802 gemu_log("Target cmsg overflow\n");
7854b056
FB		 803 break;
804 }
805
806 target_cmsg->cmsg_level = tswap32(cmsg->cmsg_level);
807 target_cmsg->cmsg_type = tswap32(cmsg->cmsg_type);
808 target_cmsg->cmsg_len = tswapl(TARGET_CMSG_LEN(len));
809
3532fa74 810 if (cmsg->cmsg_level != TARGET_SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) {
7854b056
FB		 811 gemu_log("Unsupported ancillary data: %d/%d\n", cmsg->cmsg_level, cmsg->cmsg_type);
812 memcpy(target_data, data, len);
813 } else {
814 int *fd = (int *)data;
815 int *target_fd = (int *)target_data;
816 int i, numfds = len / sizeof(int);
817
818 for (i = 0; i < numfds; i++)
819 target_fd[i] = tswap32(fd[i]);
820 }
821
822 cmsg = CMSG_NXTHDR(msgh, cmsg);
823 target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg);
824 }
5a4a898d
FB		 825 unlock_user(target_cmsg, target_cmsg_addr, space);
826 the_end:
827 target_msgh->msg_controllen = tswapl(space);
828 return 0;
7854b056
FB		 829}
830
0da46a6e 831/* do_setsockopt() Must return target values and target errnos. */
992f48a0 832static abi_long do_setsockopt(int sockfd, int level, int optname,
2f619698 833 abi_ulong optval_addr, socklen_t optlen)
7854b056 834{
992f48a0 835 abi_long ret;
32407103 836 int val;
3b46e624 837
8853f86e
FB		 838 switch(level) {
839 case SOL_TCP:
7854b056 840 /* TCP options all take an 'int' value. */
7854b056 841 if (optlen < sizeof(uint32_t))
0da46a6e 842 return -TARGET_EINVAL;
3b46e624 843
2f619698
FB		 844 if (get_user_u32(val, optval_addr))
845 return -TARGET_EFAULT;
8853f86e
FB		 846 ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val)));
847 break;
848 case SOL_IP:
849 switch(optname) {
2efbe911
FB		 850 case IP_TOS:
851 case IP_TTL:
8853f86e 852 case IP_HDRINCL:
2efbe911
FB		 853 case IP_ROUTER_ALERT:
854 case IP_RECVOPTS:
855 case IP_RETOPTS:
856 case IP_PKTINFO:
857 case IP_MTU_DISCOVER:
858 case IP_RECVERR:
859 case IP_RECVTOS:
860#ifdef IP_FREEBIND
861 case IP_FREEBIND:
862#endif
863 case IP_MULTICAST_TTL:
864 case IP_MULTICAST_LOOP:
8853f86e
FB		 865 val = 0;
866 if (optlen >= sizeof(uint32_t)) {
2f619698
FB		 867 if (get_user_u32(val, optval_addr))
868 return -TARGET_EFAULT;
8853f86e 869 } else if (optlen >= 1) {
2f619698
FB		 870 if (get_user_u8(val, optval_addr))
871 return -TARGET_EFAULT;
8853f86e
FB		 872 }
873 ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val)));
874 break;
875 default:
876 goto unimplemented;
877 }
878 break;
3532fa74 879 case TARGET_SOL_SOCKET:
8853f86e
FB		 880 switch (optname) {
881 /* Options with 'int' argument. */
3532fa74
FB		 882 case TARGET_SO_DEBUG:
883 optname = SO_DEBUG;
884 break;
885 case TARGET_SO_REUSEADDR:
886 optname = SO_REUSEADDR;
887 break;
888 case TARGET_SO_TYPE:
889 optname = SO_TYPE;
890 break;
891 case TARGET_SO_ERROR:
892 optname = SO_ERROR;
893 break;
894 case TARGET_SO_DONTROUTE:
895 optname = SO_DONTROUTE;
896 break;
897 case TARGET_SO_BROADCAST:
898 optname = SO_BROADCAST;
899 break;
900 case TARGET_SO_SNDBUF:
901 optname = SO_SNDBUF;
902 break;
903 case TARGET_SO_RCVBUF:
904 optname = SO_RCVBUF;
905 break;
906 case TARGET_SO_KEEPALIVE:
907 optname = SO_KEEPALIVE;
908 break;
909 case TARGET_SO_OOBINLINE:
910 optname = SO_OOBINLINE;
911 break;
912 case TARGET_SO_NO_CHECK:
913 optname = SO_NO_CHECK;
914 break;
915 case TARGET_SO_PRIORITY:
916 optname = SO_PRIORITY;
917 break;
5e83e8e3 918#ifdef SO_BSDCOMPAT
3532fa74
FB		 919 case TARGET_SO_BSDCOMPAT:
920 optname = SO_BSDCOMPAT;
921 break;
5e83e8e3 922#endif
3532fa74
FB		 923 case TARGET_SO_PASSCRED:
924 optname = SO_PASSCRED;
925 break;
926 case TARGET_SO_TIMESTAMP:
927 optname = SO_TIMESTAMP;
928 break;
929 case TARGET_SO_RCVLOWAT:
930 optname = SO_RCVLOWAT;
931 break;
932 case TARGET_SO_RCVTIMEO:
933 optname = SO_RCVTIMEO;
934 break;
935 case TARGET_SO_SNDTIMEO:
936 optname = SO_SNDTIMEO;
937 break;
8853f86e
FB		 938 break;
939 default:
940 goto unimplemented;
941 }
3532fa74 942 if (optlen < sizeof(uint32_t))
2f619698 943 return -TARGET_EINVAL;
3532fa74 944
2f619698
FB		 945 if (get_user_u32(val, optval_addr))
946 return -TARGET_EFAULT;
3532fa74 947 ret = get_errno(setsockopt(sockfd, SOL_SOCKET, optname, &val, sizeof(val)));
8853f86e 948 break;
7854b056 949 default:
8853f86e
FB		 950 unimplemented:
951 gemu_log("Unsupported setsockopt level=%d optname=%d \n", level, optname);
6fa13c17 952 ret = -TARGET_ENOPROTOOPT;
7854b056 953 }
8853f86e 954 return ret;
7854b056
FB		 955}
956
0da46a6e 957/* do_getsockopt() Must return target values and target errnos. */
992f48a0 958static abi_long do_getsockopt(int sockfd, int level, int optname,
2f619698 959 abi_ulong optval_addr, abi_ulong optlen)
7854b056 960{
992f48a0 961 abi_long ret;
b55266b5
BS		 962 int len, val;
963 socklen_t lv;
8853f86e
FB		 964
965 switch(level) {
3532fa74
FB		 966 case TARGET_SOL_SOCKET:
967 level = SOL_SOCKET;
8853f86e 968 switch (optname) {
3532fa74
FB		 969 case TARGET_SO_LINGER:
970 case TARGET_SO_RCVTIMEO:
971 case TARGET_SO_SNDTIMEO:
972 case TARGET_SO_PEERCRED:
973 case TARGET_SO_PEERNAME:
8853f86e
FB		 974 /* These don't just return a single integer */
975 goto unimplemented;
976 default:
2efbe911
FB		 977 goto int_case;
978 }
979 break;
980 case SOL_TCP:
981 /* TCP options all take an 'int' value. */
982 int_case:
2f619698
FB		 983 if (get_user_u32(len, optlen))
984 return -TARGET_EFAULT;
2efbe911 985 if (len < 0)
0da46a6e 986 return -TARGET_EINVAL;
2efbe911
FB		 987 lv = sizeof(int);
988 ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
989 if (ret < 0)
990 return ret;
991 val = tswap32(val);
992 if (len > lv)
993 len = lv;
2f619698
FB		 994 if (len == 4) {
995 if (put_user_u32(val, optval_addr))
996 return -TARGET_EFAULT;
997 } else {
998 if (put_user_u8(val, optval_addr))
999 return -TARGET_EFAULT;
1000 }
1001 if (put_user_u32(len, optlen))
1002 return -TARGET_EFAULT;
2efbe911
FB		 1003 break;
1004 case SOL_IP:
1005 switch(optname) {
1006 case IP_TOS:
1007 case IP_TTL:
1008 case IP_HDRINCL:
1009 case IP_ROUTER_ALERT:
1010 case IP_RECVOPTS:
1011 case IP_RETOPTS:
1012 case IP_PKTINFO:
1013 case IP_MTU_DISCOVER:
1014 case IP_RECVERR:
1015 case IP_RECVTOS:
1016#ifdef IP_FREEBIND
1017 case IP_FREEBIND:
1018#endif
1019 case IP_MULTICAST_TTL:
1020 case IP_MULTICAST_LOOP:
2f619698
FB		 1021 if (get_user_u32(len, optlen))
1022 return -TARGET_EFAULT;
8853f86e 1023 if (len < 0)
0da46a6e 1024 return -TARGET_EINVAL;
8853f86e
FB		 1025 lv = sizeof(int);
1026 ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
1027 if (ret < 0)
1028 return ret;
2efbe911 1029 if (len < sizeof(int) && len > 0 && val >= 0 && val < 255) {
2efbe911 1030 len = 1;
2f619698
FB		 1031 if (put_user_u32(len, optlen)
1032 || put_user_u8(val, optval_addr))
1033 return -TARGET_EFAULT;
2efbe911 1034 } else {
2efbe911
FB		 1035 if (len > sizeof(int))
1036 len = sizeof(int);
2f619698
FB		 1037 if (put_user_u32(len, optlen)
1038 || put_user_u32(val, optval_addr))
1039 return -TARGET_EFAULT;
2efbe911 1040 }
8853f86e 1041 break;
2efbe911 1042 default:
c02f499e
TS		 1043 ret = -TARGET_ENOPROTOOPT;
1044 break;
8853f86e
FB		 1045 }
1046 break;
1047 default:
1048 unimplemented:
1049 gemu_log("getsockopt level=%d optname=%d not yet supported\n",
1050 level, optname);
c02f499e 1051 ret = -TARGET_EOPNOTSUPP;
8853f86e
FB		 1052 break;
1053 }
1054 return ret;
7854b056
FB		 1055}
1056
579a97f7
FB		 1057/* FIXME
1058 * lock_iovec()/unlock_iovec() have a return code of 0 for success where
1059 * other lock functions have a return code of 0 for failure.
1060 */
1061static abi_long lock_iovec(int type, struct iovec *vec, abi_ulong target_addr,
1062 int count, int copy)
53a5960a
PB		 1063{
1064 struct target_iovec *target_vec;
992f48a0 1065 abi_ulong base;
579a97f7 1066 int i, j;
53a5960a 1067
579a97f7
FB		 1068 target_vec = lock_user(VERIFY_READ, target_addr, count * sizeof(struct target_iovec), 1);
1069 if (!target_vec)
1070 return -TARGET_EFAULT;
53a5960a
PB		 1071 for(i = 0;i < count; i++) {
1072 base = tswapl(target_vec[i].iov_base);
1073 vec[i].iov_len = tswapl(target_vec[i].iov_len);
41df8411
FB		 1074 if (vec[i].iov_len != 0) {
1075 vec[i].iov_base = lock_user(type, base, vec[i].iov_len, copy);
7bedce8d 1076 if (!vec[i].iov_base && vec[i].iov_len)
41df8411
FB		 1077 goto fail;
1078 } else {
1079 /* zero length pointer is ignored */
1080 vec[i].iov_base = NULL;
1081 }
579a97f7
FB		 1082 }
1083 unlock_user (target_vec, target_addr, 0);
1084 return 0;
1085 fail:
1086 /* failure - unwind locks */
1087 for (j = 0; j < i; j++) {
1088 base = tswapl(target_vec[j].iov_base);
1089 unlock_user(vec[j].iov_base, base, 0);
53a5960a
PB		 1090 }
1091 unlock_user (target_vec, target_addr, 0);
579a97f7 1092 return -TARGET_EFAULT;
53a5960a
PB		 1093}
1094
579a97f7
FB		 1095static abi_long unlock_iovec(struct iovec *vec, abi_ulong target_addr,
1096 int count, int copy)
53a5960a
PB		 1097{
1098 struct target_iovec *target_vec;
992f48a0 1099 abi_ulong base;
53a5960a
PB		 1100 int i;
1101
579a97f7
FB		 1102 target_vec = lock_user(VERIFY_READ, target_addr, count * sizeof(struct target_iovec), 1);
1103 if (!target_vec)
1104 return -TARGET_EFAULT;
53a5960a
PB		 1105 for(i = 0;i < count; i++) {
1106 base = tswapl(target_vec[i].iov_base);
1107 unlock_user(vec[i].iov_base, base, copy ? vec[i].iov_len : 0);
1108 }
1109 unlock_user (target_vec, target_addr, 0);
579a97f7
FB		 1110
1111 return 0;
53a5960a
PB		 1112}
1113
0da46a6e 1114/* do_socket() Must return target values and target errnos. */
992f48a0 1115static abi_long do_socket(int domain, int type, int protocol)
3532fa74
FB		 1116{
1117#if defined(TARGET_MIPS)
1118 switch(type) {
1119 case TARGET_SOCK_DGRAM:
1120 type = SOCK_DGRAM;
1121 break;
1122 case TARGET_SOCK_STREAM:
1123 type = SOCK_STREAM;
1124 break;
1125 case TARGET_SOCK_RAW:
1126 type = SOCK_RAW;
1127 break;
1128 case TARGET_SOCK_RDM:
1129 type = SOCK_RDM;
1130 break;
1131 case TARGET_SOCK_SEQPACKET:
1132 type = SOCK_SEQPACKET;
1133 break;
1134 case TARGET_SOCK_PACKET:
1135 type = SOCK_PACKET;
1136 break;
1137 }
1138#endif
12bc92ab
AZ		 1139 if (domain == PF_NETLINK)
1140 return -EAFNOSUPPORT; /* do not NETLINK socket connections possible */
3532fa74
FB		 1141 return get_errno(socket(domain, type, protocol));
1142}
1143
0da46a6e 1144/* do_bind() Must return target values and target errnos. */
992f48a0
BS		 1145static abi_long do_bind(int sockfd, abi_ulong target_addr,
1146 socklen_t addrlen)
3532fa74
FB		 1147{
1148 void *addr = alloca(addrlen);
3b46e624 1149
3532fa74
FB		 1150 target_to_host_sockaddr(addr, target_addr, addrlen);
1151 return get_errno(bind(sockfd, addr, addrlen));
1152}
1153
0da46a6e 1154/* do_connect() Must return target values and target errnos. */
992f48a0
BS		 1155static abi_long do_connect(int sockfd, abi_ulong target_addr,
1156 socklen_t addrlen)
3532fa74
FB		 1157{
1158 void *addr = alloca(addrlen);
3b46e624 1159
3532fa74
FB		 1160 target_to_host_sockaddr(addr, target_addr, addrlen);
1161 return get_errno(connect(sockfd, addr, addrlen));
1162}
1163
0da46a6e 1164/* do_sendrecvmsg() Must return target values and target errnos. */
992f48a0
BS		 1165static abi_long do_sendrecvmsg(int fd, abi_ulong target_msg,
1166 int flags, int send)
3532fa74 1167{
992f48a0 1168 abi_long ret;
3532fa74
FB		 1169 struct target_msghdr *msgp;
1170 struct msghdr msg;
1171 int count;
1172 struct iovec *vec;
992f48a0 1173 abi_ulong target_vec;
3532fa74 1174
579a97f7
FB		 1175 /* FIXME */
1176 if (!lock_user_struct(send ? VERIFY_READ : VERIFY_WRITE,
1177 msgp,
1178 target_msg,
1179 send ? 1 : 0))
1180 return -TARGET_EFAULT;
3532fa74
FB		 1181 if (msgp->msg_name) {
1182 msg.msg_namelen = tswap32(msgp->msg_namelen);
1183 msg.msg_name = alloca(msg.msg_namelen);
1184 target_to_host_sockaddr(msg.msg_name, tswapl(msgp->msg_name),
1185 msg.msg_namelen);
1186 } else {
1187 msg.msg_name = NULL;
1188 msg.msg_namelen = 0;
1189 }
1190 msg.msg_controllen = 2 * tswapl(msgp->msg_controllen);
1191 msg.msg_control = alloca(msg.msg_controllen);
1192 msg.msg_flags = tswap32(msgp->msg_flags);
3b46e624 1193
3532fa74
FB		 1194 count = tswapl(msgp->msg_iovlen);
1195 vec = alloca(count * sizeof(struct iovec));
1196 target_vec = tswapl(msgp->msg_iov);
579a97f7 1197 lock_iovec(send ? VERIFY_READ : VERIFY_WRITE, vec, target_vec, count, send);
3532fa74
FB		 1198 msg.msg_iovlen = count;
1199 msg.msg_iov = vec;
3b46e624 1200
3532fa74 1201 if (send) {
5a4a898d
FB		 1202 ret = target_to_host_cmsg(&msg, msgp);
1203 if (ret == 0)
1204 ret = get_errno(sendmsg(fd, &msg, flags));
3532fa74
FB		 1205 } else {
1206 ret = get_errno(recvmsg(fd, &msg, flags));
1207 if (!is_error(ret))
5a4a898d 1208 ret = host_to_target_cmsg(msgp, &msg);
3532fa74
FB		 1209 }
1210 unlock_iovec(vec, target_vec, count, !send);
579a97f7 1211 unlock_user_struct(msgp, target_msg, send ? 0 : 1);
3532fa74
FB		 1212 return ret;
1213}
1214
0da46a6e 1215/* do_accept() Must return target values and target errnos. */
992f48a0 1216static abi_long do_accept(int fd, abi_ulong target_addr,
2f619698 1217 abi_ulong target_addrlen_addr)
1be9e1dc 1218{
2f619698
FB		 1219 socklen_t addrlen;
1220 void *addr;
992f48a0 1221 abi_long ret;
1be9e1dc 1222
2f619698
FB		 1223 if (get_user_u32(addrlen, target_addrlen_addr))
1224 return -TARGET_EFAULT;
1225
1226 addr = alloca(addrlen);
1227
1be9e1dc
PB		 1228 ret = get_errno(accept(fd, addr, &addrlen));
1229 if (!is_error(ret)) {
1230 host_to_target_sockaddr(target_addr, addr, addrlen);
2f619698
FB		 1231 if (put_user_u32(addrlen, target_addrlen_addr))
1232 ret = -TARGET_EFAULT;
1be9e1dc
PB		 1233 }
1234 return ret;
1235}
1236
0da46a6e 1237/* do_getpeername() Must return target values and target errnos. */
992f48a0 1238static abi_long do_getpeername(int fd, abi_ulong target_addr,
2f619698 1239 abi_ulong target_addrlen_addr)
1be9e1dc 1240{
2f619698
FB		 1241 socklen_t addrlen;
1242 void *addr;
992f48a0 1243 abi_long ret;
1be9e1dc 1244
2f619698
FB		 1245 if (get_user_u32(addrlen, target_addrlen_addr))
1246 return -TARGET_EFAULT;
1247
1248 addr = alloca(addrlen);
1249
1be9e1dc
PB		 1250 ret = get_errno(getpeername(fd, addr, &addrlen));
1251 if (!is_error(ret)) {
1252 host_to_target_sockaddr(target_addr, addr, addrlen);
2f619698
FB		 1253 if (put_user_u32(addrlen, target_addrlen_addr))
1254 ret = -TARGET_EFAULT;
1be9e1dc
PB		 1255 }
1256 return ret;
1257}
1258
0da46a6e 1259/* do_getsockname() Must return target values and target errnos. */
992f48a0 1260static abi_long do_getsockname(int fd, abi_ulong target_addr,
2f619698 1261 abi_ulong target_addrlen_addr)
1be9e1dc 1262{
2f619698
FB		 1263 socklen_t addrlen;
1264 void *addr;
992f48a0 1265 abi_long ret;
1be9e1dc 1266
2f619698
FB		 1267 if (get_user_u32(addrlen, target_addrlen_addr))
1268 return -TARGET_EFAULT;
1269
1270 addr = alloca(addrlen);
1271
1be9e1dc
PB		 1272 ret = get_errno(getsockname(fd, addr, &addrlen));
1273 if (!is_error(ret)) {
1274 host_to_target_sockaddr(target_addr, addr, addrlen);
2f619698
FB		 1275 if (put_user_u32(addrlen, target_addrlen_addr))
1276 ret = -TARGET_EFAULT;
1be9e1dc
PB		 1277 }
1278 return ret;
1279}
1280
0da46a6e 1281/* do_socketpair() Must return target values and target errnos. */
992f48a0 1282static abi_long do_socketpair(int domain, int type, int protocol,
2f619698 1283 abi_ulong target_tab_addr)
1be9e1dc
PB		 1284{
1285 int tab[2];
992f48a0 1286 abi_long ret;
1be9e1dc
PB		 1287
1288 ret = get_errno(socketpair(domain, type, protocol, tab));
1289 if (!is_error(ret)) {
2f619698
FB		 1290 if (put_user_s32(tab[0], target_tab_addr)
1291 || put_user_s32(tab[1], target_tab_addr + sizeof(tab[0])))
1292 ret = -TARGET_EFAULT;
1be9e1dc
PB		 1293 }
1294 return ret;
1295}
1296
0da46a6e 1297/* do_sendto() Must return target values and target errnos. */
992f48a0
BS		 1298static abi_long do_sendto(int fd, abi_ulong msg, size_t len, int flags,
1299 abi_ulong target_addr, socklen_t addrlen)
1be9e1dc
PB		 1300{
1301 void *addr;
1302 void *host_msg;
992f48a0 1303 abi_long ret;
1be9e1dc 1304
579a97f7
FB		 1305 host_msg = lock_user(VERIFY_READ, msg, len, 1);
1306 if (!host_msg)
1307 return -TARGET_EFAULT;
1be9e1dc
PB		 1308 if (target_addr) {
1309 addr = alloca(addrlen);
1310 target_to_host_sockaddr(addr, target_addr, addrlen);
1311 ret = get_errno(sendto(fd, host_msg, len, flags, addr, addrlen));
1312 } else {
1313 ret = get_errno(send(fd, host_msg, len, flags));
1314 }
1315 unlock_user(host_msg, msg, 0);
1316 return ret;
1317}
1318
0da46a6e 1319/* do_recvfrom() Must return target values and target errnos. */
992f48a0
BS		 1320static abi_long do_recvfrom(int fd, abi_ulong msg, size_t len, int flags,
1321 abi_ulong target_addr,
1322 abi_ulong target_addrlen)
1be9e1dc
PB		 1323{
1324 socklen_t addrlen;
1325 void *addr;
1326 void *host_msg;
992f48a0 1327 abi_long ret;
1be9e1dc 1328
579a97f7
FB		 1329 host_msg = lock_user(VERIFY_WRITE, msg, len, 0);
1330 if (!host_msg)
1331 return -TARGET_EFAULT;
1be9e1dc 1332 if (target_addr) {
2f619698
FB		 1333 if (get_user_u32(addrlen, target_addrlen)) {
1334 ret = -TARGET_EFAULT;
1335 goto fail;
1336 }
1be9e1dc
PB		 1337 addr = alloca(addrlen);
1338 ret = get_errno(recvfrom(fd, host_msg, len, flags, addr, &addrlen));
1339 } else {
1340 addr = NULL; /* To keep compiler quiet. */
1341 ret = get_errno(recv(fd, host_msg, len, flags));
1342 }
1343 if (!is_error(ret)) {
1344 if (target_addr) {
1345 host_to_target_sockaddr(target_addr, addr, addrlen);
2f619698
FB		 1346 if (put_user_u32(addrlen, target_addrlen)) {
1347 ret = -TARGET_EFAULT;
1348 goto fail;
1349 }
1be9e1dc
PB		 1350 }
1351 unlock_user(host_msg, msg, len);
1352 } else {
2f619698 1353fail:
1be9e1dc
PB		 1354 unlock_user(host_msg, msg, 0);
1355 }
1356 return ret;
1357}
1358
32407103 1359#ifdef TARGET_NR_socketcall
0da46a6e 1360/* do_socketcall() Must return target values and target errnos. */
992f48a0 1361static abi_long do_socketcall(int num, abi_ulong vptr)
31e31b8a 1362{
992f48a0
BS		 1363 abi_long ret;
1364 const int n = sizeof(abi_ulong);
31e31b8a
FB		 1365
1366 switch(num) {
1367 case SOCKOP_socket:
7854b056 1368 {
2f619698
FB		 1369 int domain, type, protocol;
1370
1371 if (get_user_s32(domain, vptr)
1372 || get_user_s32(type, vptr + n)
1373 || get_user_s32(protocol, vptr + 2 * n))
1374 return -TARGET_EFAULT;
1375
3532fa74 1376 ret = do_socket(domain, type, protocol);
7854b056 1377 }
31e31b8a
FB		 1378 break;
1379 case SOCKOP_bind:
7854b056 1380 {
2f619698
FB		 1381 int sockfd;
1382 abi_ulong target_addr;
1383 socklen_t addrlen;
1384
1385 if (get_user_s32(sockfd, vptr)
1386 || get_user_ual(target_addr, vptr + n)
1387 || get_user_u32(addrlen, vptr + 2 * n))
1388 return -TARGET_EFAULT;
1389
3532fa74 1390 ret = do_bind(sockfd, target_addr, addrlen);
7854b056 1391 }
31e31b8a
FB		 1392 break;
1393 case SOCKOP_connect:
7854b056 1394 {
2f619698
FB		 1395 int sockfd;
1396 abi_ulong target_addr;
1397 socklen_t addrlen;
1398
1399 if (get_user_s32(sockfd, vptr)
1400 || get_user_ual(target_addr, vptr + n)
1401 || get_user_u32(addrlen, vptr + 2 * n))
1402 return -TARGET_EFAULT;
1403
3532fa74 1404 ret = do_connect(sockfd, target_addr, addrlen);
7854b056 1405 }
31e31b8a
FB		 1406 break;
1407 case SOCKOP_listen:
7854b056 1408 {
2f619698
FB		 1409 int sockfd, backlog;
1410
1411 if (get_user_s32(sockfd, vptr)
1412 || get_user_s32(backlog, vptr + n))
1413 return -TARGET_EFAULT;
1414
7854b056
FB		 1415 ret = get_errno(listen(sockfd, backlog));
1416 }
31e31b8a
FB		 1417 break;
1418 case SOCKOP_accept:
1419 {
2f619698
FB		 1420 int sockfd;
1421 abi_ulong target_addr, target_addrlen;
1422
1423 if (get_user_s32(sockfd, vptr)
1424 || get_user_ual(target_addr, vptr + n)
1425 || get_user_u32(target_addrlen, vptr + 2 * n))
1426 return -TARGET_EFAULT;
1427
1be9e1dc 1428 ret = do_accept(sockfd, target_addr, target_addrlen);
31e31b8a
FB		 1429 }
1430 break;
1431 case SOCKOP_getsockname:
1432 {
2f619698
FB		 1433 int sockfd;
1434 abi_ulong target_addr, target_addrlen;
1435
1436 if (get_user_s32(sockfd, vptr)
1437 || get_user_ual(target_addr, vptr + n)
1438 || get_user_u32(target_addrlen, vptr + 2 * n))
1439 return -TARGET_EFAULT;
1440
1be9e1dc 1441 ret = do_getsockname(sockfd, target_addr, target_addrlen);
31e31b8a
FB		 1442 }
1443 break;
1444 case SOCKOP_getpeername:
1445 {
2f619698
FB		 1446 int sockfd;
1447 abi_ulong target_addr, target_addrlen;
1448
1449 if (get_user_s32(sockfd, vptr)
1450 || get_user_ual(target_addr, vptr + n)
1451 || get_user_u32(target_addrlen, vptr + 2 * n))
1452 return -TARGET_EFAULT;
1453
1be9e1dc 1454 ret = do_getpeername(sockfd, target_addr, target_addrlen);
31e31b8a
FB		 1455 }
1456 break;
1457 case SOCKOP_socketpair:
1458 {
2f619698
FB		 1459 int domain, type, protocol;
1460 abi_ulong tab;
1461
1462 if (get_user_s32(domain, vptr)
1463 || get_user_s32(type, vptr + n)
1464 || get_user_s32(protocol, vptr + 2 * n)
1465 || get_user_ual(tab, vptr + 3 * n))
1466 return -TARGET_EFAULT;
1467
1be9e1dc 1468 ret = do_socketpair(domain, type, protocol, tab);
31e31b8a
FB		 1469 }
1470 break;
1471 case SOCKOP_send:
7854b056 1472 {
2f619698
FB		 1473 int sockfd;
1474 abi_ulong msg;
1475 size_t len;
1476 int flags;
1477
1478 if (get_user_s32(sockfd, vptr)
1479 || get_user_ual(msg, vptr + n)
1480 || get_user_ual(len, vptr + 2 * n)
1481 || get_user_s32(flags, vptr + 3 * n))
1482 return -TARGET_EFAULT;
1483
1be9e1dc 1484 ret = do_sendto(sockfd, msg, len, flags, 0, 0);
7854b056 1485 }
31e31b8a
FB		 1486 break;
1487 case SOCKOP_recv:
7854b056 1488 {
2f619698
FB		 1489 int sockfd;
1490 abi_ulong msg;
1491 size_t len;
1492 int flags;
1493
1494 if (get_user_s32(sockfd, vptr)
1495 || get_user_ual(msg, vptr + n)
1496 || get_user_ual(len, vptr + 2 * n)
1497 || get_user_s32(flags, vptr + 3 * n))
1498 return -TARGET_EFAULT;
1499
1be9e1dc 1500 ret = do_recvfrom(sockfd, msg, len, flags, 0, 0);
7854b056 1501 }
31e31b8a
FB		 1502 break;
1503 case SOCKOP_sendto:
7854b056 1504 {
2f619698
FB		 1505 int sockfd;
1506 abi_ulong msg;
1507 size_t len;
1508 int flags;
1509 abi_ulong addr;
1510 socklen_t addrlen;
1511
1512 if (get_user_s32(sockfd, vptr)
1513 || get_user_ual(msg, vptr + n)
1514 || get_user_ual(len, vptr + 2 * n)
1515 || get_user_s32(flags, vptr + 3 * n)
1516 || get_user_ual(addr, vptr + 4 * n)
1517 || get_user_u32(addrlen, vptr + 5 * n))
1518 return -TARGET_EFAULT;
1519
1be9e1dc 1520 ret = do_sendto(sockfd, msg, len, flags, addr, addrlen);
7854b056 1521 }
31e31b8a
FB		 1522 break;
1523 case SOCKOP_recvfrom:
1524 {
2f619698
FB		 1525 int sockfd;
1526 abi_ulong msg;
1527 size_t len;
1528 int flags;
1529 abi_ulong addr;
1530 socklen_t addrlen;
1531
1532 if (get_user_s32(sockfd, vptr)
1533 || get_user_ual(msg, vptr + n)
1534 || get_user_ual(len, vptr + 2 * n)
1535 || get_user_s32(flags, vptr + 3 * n)
1536 || get_user_ual(addr, vptr + 4 * n)
1537 || get_user_u32(addrlen, vptr + 5 * n))
1538 return -TARGET_EFAULT;
1539
1be9e1dc 1540 ret = do_recvfrom(sockfd, msg, len, flags, addr, addrlen);
31e31b8a
FB		 1541 }
1542 break;
1543 case SOCKOP_shutdown:
7854b056 1544 {
2f619698
FB		 1545 int sockfd, how;
1546
1547 if (get_user_s32(sockfd, vptr)
1548 || get_user_s32(how, vptr + n))
1549 return -TARGET_EFAULT;
7854b056
FB		 1550
1551 ret = get_errno(shutdown(sockfd, how));
1552 }
31e31b8a
FB		 1553 break;
1554 case SOCKOP_sendmsg:
1555 case SOCKOP_recvmsg:
1a9353d2
FB		 1556 {
1557 int fd;
992f48a0 1558 abi_ulong target_msg;
3532fa74 1559 int flags;
1a9353d2 1560
2f619698
FB		 1561 if (get_user_s32(fd, vptr)
1562 || get_user_ual(target_msg, vptr + n)
1563 || get_user_s32(flags, vptr + 2 * n))
1564 return -TARGET_EFAULT;
3532fa74 1565
5fafdf24 1566 ret = do_sendrecvmsg(fd, target_msg, flags,
3532fa74 1567 (num == SOCKOP_sendmsg));
1a9353d2
FB		 1568 }
1569 break;
31e31b8a 1570 case SOCKOP_setsockopt:
7854b056 1571 {
2f619698
FB		 1572 int sockfd;
1573 int level;
1574 int optname;
1575 abi_ulong optval;
1576 socklen_t optlen;
1577
1578 if (get_user_s32(sockfd, vptr)
1579 || get_user_s32(level, vptr + n)
1580 || get_user_s32(optname, vptr + 2 * n)
1581 || get_user_ual(optval, vptr + 3 * n)
1582 || get_user_u32(optlen, vptr + 4 * n))
1583 return -TARGET_EFAULT;
7854b056
FB		 1584
1585 ret = do_setsockopt(sockfd, level, optname, optval, optlen);
1586 }
1587 break;
31e31b8a 1588 case SOCKOP_getsockopt:
7854b056 1589 {
2f619698
FB		 1590 int sockfd;
1591 int level;
1592 int optname;
1593 abi_ulong optval;
1594 socklen_t optlen;
1595
1596 if (get_user_s32(sockfd, vptr)
1597 || get_user_s32(level, vptr + n)
1598 || get_user_s32(optname, vptr + 2 * n)
1599 || get_user_ual(optval, vptr + 3 * n)
1600 || get_user_u32(optlen, vptr + 4 * n))
1601 return -TARGET_EFAULT;
7854b056 1602
2f619698 1603 ret = do_getsockopt(sockfd, level, optname, optval, optlen);
7854b056
FB		 1604 }
1605 break;
31e31b8a
FB		 1606 default:
1607 gemu_log("Unsupported socketcall: %d\n", num);
0da46a6e 1608 ret = -TARGET_ENOSYS;
31e31b8a
FB		 1609 break;
1610 }
1611 return ret;
1612}
32407103 1613#endif
31e31b8a 1614
32407103 1615#ifdef TARGET_NR_ipc
8853f86e
FB		 1616#define N_SHM_REGIONS 32
1617
1618static struct shm_region {
5a4a898d
FB		 1619 abi_ulong start;
1620 abi_ulong size;
8853f86e
FB		 1621} shm_regions[N_SHM_REGIONS];
1622
3eb6b044
TS		 1623struct target_ipc_perm
1624{
992f48a0
BS		 1625 abi_long __key;
1626 abi_ulong uid;
1627 abi_ulong gid;
1628 abi_ulong cuid;
1629 abi_ulong cgid;
3eb6b044
TS		 1630 unsigned short int mode;
1631 unsigned short int __pad1;
1632 unsigned short int __seq;
1633 unsigned short int __pad2;
992f48a0
BS		 1634 abi_ulong __unused1;
1635 abi_ulong __unused2;
3eb6b044
TS		 1636};
1637
1638struct target_semid_ds
1639{
1640 struct target_ipc_perm sem_perm;
992f48a0
BS		 1641 abi_ulong sem_otime;
1642 abi_ulong __unused1;
1643 abi_ulong sem_ctime;
1644 abi_ulong __unused2;
1645 abi_ulong sem_nsems;
1646 abi_ulong __unused3;
1647 abi_ulong __unused4;
3eb6b044
TS		 1648};
1649
579a97f7
FB		 1650static inline abi_long target_to_host_ipc_perm(struct ipc_perm *host_ip,
1651 abi_ulong target_addr)
3eb6b044
TS		 1652{
1653 struct target_ipc_perm *target_ip;
1654 struct target_semid_ds *target_sd;
1655
579a97f7
FB		 1656 if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1))
1657 return -TARGET_EFAULT;
3eb6b044
TS		 1658 target_ip=&(target_sd->sem_perm);
1659 host_ip->__key = tswapl(target_ip->__key);
1660 host_ip->uid = tswapl(target_ip->uid);
1661 host_ip->gid = tswapl(target_ip->gid);
1662 host_ip->cuid = tswapl(target_ip->cuid);
1663 host_ip->cgid = tswapl(target_ip->cgid);
1664 host_ip->mode = tswapl(target_ip->mode);
1665 unlock_user_struct(target_sd, target_addr, 0);
579a97f7 1666 return 0;
3eb6b044
TS		 1667}
1668
579a97f7
FB		 1669static inline abi_long host_to_target_ipc_perm(abi_ulong target_addr,
1670 struct ipc_perm *host_ip)
3eb6b044
TS		 1671{
1672 struct target_ipc_perm *target_ip;
1673 struct target_semid_ds *target_sd;
1674
579a97f7
FB		 1675 if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0))
1676 return -TARGET_EFAULT;
3eb6b044
TS		 1677 target_ip = &(target_sd->sem_perm);
1678 target_ip->__key = tswapl(host_ip->__key);
1679 target_ip->uid = tswapl(host_ip->uid);
1680 target_ip->gid = tswapl(host_ip->gid);
1681 target_ip->cuid = tswapl(host_ip->cuid);
1682 target_ip->cgid = tswapl(host_ip->cgid);
1683 target_ip->mode = tswapl(host_ip->mode);
1684 unlock_user_struct(target_sd, target_addr, 1);
579a97f7 1685 return 0;
3eb6b044
TS		 1686}
1687
579a97f7
FB		 1688static inline abi_long target_to_host_semid_ds(struct semid_ds *host_sd,
1689 abi_ulong target_addr)
3eb6b044
TS		 1690{
1691 struct target_semid_ds *target_sd;
1692
579a97f7
FB		 1693 if (!lock_user_struct(VERIFY_READ, target_sd, target_addr, 1))
1694 return -TARGET_EFAULT;
3eb6b044
TS		 1695 target_to_host_ipc_perm(&(host_sd->sem_perm),target_addr);
1696 host_sd->sem_nsems = tswapl(target_sd->sem_nsems);
1697 host_sd->sem_otime = tswapl(target_sd->sem_otime);
1698 host_sd->sem_ctime = tswapl(target_sd->sem_ctime);
1699 unlock_user_struct(target_sd, target_addr, 0);
579a97f7 1700 return 0;
3eb6b044
TS		 1701}
1702
579a97f7
FB		 1703static inline abi_long host_to_target_semid_ds(abi_ulong target_addr,
1704 struct semid_ds *host_sd)
3eb6b044
TS		 1705{
1706 struct target_semid_ds *target_sd;
1707
579a97f7
FB		 1708 if (!lock_user_struct(VERIFY_WRITE, target_sd, target_addr, 0))
1709 return -TARGET_EFAULT;
3eb6b044
TS		 1710 host_to_target_ipc_perm(target_addr,&(host_sd->sem_perm));
1711 target_sd->sem_nsems = tswapl(host_sd->sem_nsems);
1712 target_sd->sem_otime = tswapl(host_sd->sem_otime);
1713 target_sd->sem_ctime = tswapl(host_sd->sem_ctime);
1714 unlock_user_struct(target_sd, target_addr, 1);
579a97f7 1715 return 0;
3eb6b044
TS		 1716}
1717
fa294816
TS		 1718union semun {
1719 int val;
3eb6b044 1720 struct semid_ds *buf;
fa294816
TS		 1721 unsigned short *array;
1722};
1723
3eb6b044
TS		 1724union target_semun {
1725 int val;
992f48a0 1726 abi_long buf;
3eb6b044
TS		 1727 unsigned short int *array;
1728};
1729
579a97f7
FB		 1730static inline abi_long target_to_host_semun(int cmd,
1731 union semun *host_su,
1732 abi_ulong target_addr,
1733 struct semid_ds *ds)
3eb6b044
TS		 1734{
1735 union target_semun *target_su;
1736
1737 switch( cmd ) {
1738 case IPC_STAT:
1739 case IPC_SET:
579a97f7
FB		 1740 if (!lock_user_struct(VERIFY_READ, target_su, target_addr, 1))
1741 return -TARGET_EFAULT;
3eb6b044
TS		 1742 target_to_host_semid_ds(ds,target_su->buf);
1743 host_su->buf = ds;
1744 unlock_user_struct(target_su, target_addr, 0);
1745 break;
1746 case GETVAL:
1747 case SETVAL:
579a97f7
FB		 1748 if (!lock_user_struct(VERIFY_READ, target_su, target_addr, 1))
1749 return -TARGET_EFAULT;
3eb6b044
TS		 1750 host_su->val = tswapl(target_su->val);
1751 unlock_user_struct(target_su, target_addr, 0);
1752 break;
1753 case GETALL:
1754 case SETALL:
579a97f7
FB		 1755 if (!lock_user_struct(VERIFY_READ, target_su, target_addr, 1))
1756 return -TARGET_EFAULT;
3eb6b044
TS		 1757 *host_su->array = tswap16(*target_su->array);
1758 unlock_user_struct(target_su, target_addr, 0);
1759 break;
1760 default:
1761 gemu_log("semun operation not fully supported: %d\n", (int)cmd);
1762 }
579a97f7 1763 return 0;
3eb6b044
TS		 1764}
1765
579a97f7
FB		 1766static inline abi_long host_to_target_semun(int cmd,
1767 abi_ulong target_addr,
1768 union semun *host_su,
1769 struct semid_ds *ds)
3eb6b044
TS		 1770{
1771 union target_semun *target_su;
1772
1773 switch( cmd ) {
1774 case IPC_STAT:
1775 case IPC_SET:
579a97f7
FB		 1776 if (lock_user_struct(VERIFY_WRITE, target_su, target_addr, 0))
1777 return -TARGET_EFAULT;
3eb6b044
TS		 1778 host_to_target_semid_ds(target_su->buf,ds);
1779 unlock_user_struct(target_su, target_addr, 1);
1780 break;
1781 case GETVAL:
1782 case SETVAL:
579a97f7
FB		 1783 if (lock_user_struct(VERIFY_WRITE, target_su, target_addr, 0))
1784 return -TARGET_EFAULT;
3eb6b044
TS		 1785 target_su->val = tswapl(host_su->val);
1786 unlock_user_struct(target_su, target_addr, 1);
1787 break;
1788 case GETALL:
1789 case SETALL:
579a97f7
FB		 1790 if (lock_user_struct(VERIFY_WRITE, target_su, target_addr, 0))
1791 return -TARGET_EFAULT;
3eb6b044
TS		 1792 *target_su->array = tswap16(*host_su->array);
1793 unlock_user_struct(target_su, target_addr, 1);
1794 break;
1795 default:
1796 gemu_log("semun operation not fully supported: %d\n", (int)cmd);
1797 }
579a97f7 1798 return 0;
3eb6b044
TS		 1799}
1800
992f48a0
BS		 1801static inline abi_long do_semctl(int first, int second, int third,
1802 abi_long ptr)
3eb6b044
TS		 1803{
1804 union semun arg;
1805 struct semid_ds dsarg;
1806 int cmd = third&0xff;
992f48a0 1807 abi_long ret = 0;
3eb6b044
TS		 1808
1809 switch( cmd ) {
1810 case GETVAL:
1811 target_to_host_semun(cmd,&arg,ptr,&dsarg);
1812 ret = get_errno(semctl(first, second, cmd, arg));
1813 host_to_target_semun(cmd,ptr,&arg,&dsarg);
1814 break;
1815 case SETVAL:
1816 target_to_host_semun(cmd,&arg,ptr,&dsarg);
1817 ret = get_errno(semctl(first, second, cmd, arg));
1818 host_to_target_semun(cmd,ptr,&arg,&dsarg);
1819 break;
1820 case GETALL:
1821 target_to_host_semun(cmd,&arg,ptr,&dsarg);
1822 ret = get_errno(semctl(first, second, cmd, arg));
1823 host_to_target_semun(cmd,ptr,&arg,&dsarg);
1824 break;
1825 case SETALL:
1826 target_to_host_semun(cmd,&arg,ptr,&dsarg);
1827 ret = get_errno(semctl(first, second, cmd, arg));
1828 host_to_target_semun(cmd,ptr,&arg,&dsarg);
1829 break;
1830 case IPC_STAT:
1831 target_to_host_semun(cmd,&arg,ptr,&dsarg);
1832 ret = get_errno(semctl(first, second, cmd, arg));
1833 host_to_target_semun(cmd,ptr,&arg,&dsarg);
1834 break;
1835 case IPC_SET:
1836 target_to_host_semun(cmd,&arg,ptr,&dsarg);
1837 ret = get_errno(semctl(first, second, cmd, arg));
1838 host_to_target_semun(cmd,ptr,&arg,&dsarg);
1839 break;
1840 default:
1841 ret = get_errno(semctl(first, second, cmd, arg));
1842 }
1843
1844 return ret;
1845}
1846
1bc012f6
TS		 1847struct target_msqid_ds
1848{
1849 struct target_ipc_perm msg_perm;
992f48a0
BS		 1850 abi_ulong msg_stime;
1851 abi_ulong __unused1;
1852 abi_ulong msg_rtime;
1853 abi_ulong __unused2;
1854 abi_ulong msg_ctime;
1855 abi_ulong __unused3;
1856 abi_ulong __msg_cbytes;
1857 abi_ulong msg_qnum;
1858 abi_ulong msg_qbytes;
1859 abi_ulong msg_lspid;
1860 abi_ulong msg_lrpid;
1861 abi_ulong __unused4;
1862 abi_ulong __unused5;
1bc012f6
TS		 1863};
1864
579a97f7
FB		 1865static inline abi_long target_to_host_msqid_ds(struct msqid_ds *host_md,
1866 abi_ulong target_addr)
1bc012f6
TS		 1867{
1868 struct target_msqid_ds *target_md;
1869
579a97f7
FB		 1870 if (!lock_user_struct(VERIFY_READ, target_md, target_addr, 1))
1871 return -TARGET_EFAULT;
1bc012f6
TS		 1872 target_to_host_ipc_perm(&(host_md->msg_perm),target_addr);
1873 host_md->msg_stime = tswapl(target_md->msg_stime);
1874 host_md->msg_rtime = tswapl(target_md->msg_rtime);
1875 host_md->msg_ctime = tswapl(target_md->msg_ctime);
1876 host_md->__msg_cbytes = tswapl(target_md->__msg_cbytes);
1877 host_md->msg_qnum = tswapl(target_md->msg_qnum);
1878 host_md->msg_qbytes = tswapl(target_md->msg_qbytes);
1879 host_md->msg_lspid = tswapl(target_md->msg_lspid);
1880 host_md->msg_lrpid = tswapl(target_md->msg_lrpid);
1881 unlock_user_struct(target_md, target_addr, 0);
579a97f7 1882 return 0;
1bc012f6
TS		 1883}
1884
579a97f7
FB		 1885static inline abi_long host_to_target_msqid_ds(abi_ulong target_addr,
1886 struct msqid_ds *host_md)
1bc012f6
TS		 1887{
1888 struct target_msqid_ds *target_md;
1889
579a97f7
FB		 1890 if (!lock_user_struct(VERIFY_WRITE, target_md, target_addr, 0))
1891 return -TARGET_EFAULT;
1bc012f6
TS		 1892 host_to_target_ipc_perm(target_addr,&(host_md->msg_perm));
1893 target_md->msg_stime = tswapl(host_md->msg_stime);
1894 target_md->msg_rtime = tswapl(host_md->msg_rtime);
1895 target_md->msg_ctime = tswapl(host_md->msg_ctime);
1896 target_md->__msg_cbytes = tswapl(host_md->__msg_cbytes);
1897 target_md->msg_qnum = tswapl(host_md->msg_qnum);
1898 target_md->msg_qbytes = tswapl(host_md->msg_qbytes);
1899 target_md->msg_lspid = tswapl(host_md->msg_lspid);
1900 target_md->msg_lrpid = tswapl(host_md->msg_lrpid);
1901 unlock_user_struct(target_md, target_addr, 1);
579a97f7 1902 return 0;
1bc012f6
TS		 1903}
1904
992f48a0 1905static inline abi_long do_msgctl(int first, int second, abi_long ptr)
1bc012f6
TS		 1906{
1907 struct msqid_ds dsarg;
1908 int cmd = second&0xff;
992f48a0 1909 abi_long ret = 0;
1bc012f6
TS		 1910 switch( cmd ) {
1911 case IPC_STAT:
1912 case IPC_SET:
1913 target_to_host_msqid_ds(&dsarg,ptr);
1914 ret = get_errno(msgctl(first, cmd, &dsarg));
1915 host_to_target_msqid_ds(ptr,&dsarg);
1916 default:
1917 ret = get_errno(msgctl(first, cmd, &dsarg));
1918 }
1919 return ret;
1920}
1921
1922struct target_msgbuf {
992f48a0 1923 abi_ulong mtype;
1bc012f6
TS		 1924 char mtext[1];
1925};
1926
992f48a0
BS		 1927static inline abi_long do_msgsnd(int msqid, abi_long msgp,
1928 unsigned int msgsz, int msgflg)
1bc012f6
TS		 1929{
1930 struct target_msgbuf *target_mb;
1931 struct msgbuf *host_mb;
992f48a0 1932 abi_long ret = 0;
1bc012f6 1933
579a97f7
FB		 1934 if (!lock_user_struct(VERIFY_READ, target_mb, msgp, 0))
1935 return -TARGET_EFAULT;
1bc012f6
TS		 1936 host_mb = malloc(msgsz+sizeof(long));
1937 host_mb->mtype = tswapl(target_mb->mtype);
1938 memcpy(host_mb->mtext,target_mb->mtext,msgsz);
1939 ret = get_errno(msgsnd(msqid, host_mb, msgsz, msgflg));
1940 free(host_mb);
1941 unlock_user_struct(target_mb, msgp, 0);
1942
1943 return ret;
1944}
1945
992f48a0
BS		 1946static inline abi_long do_msgrcv(int msqid, abi_long msgp,
1947 unsigned int msgsz, int msgtype,
1948 int msgflg)
1bc012f6
TS		 1949{
1950 struct target_msgbuf *target_mb;
579a97f7 1951 char *target_mtext;
1bc012f6 1952 struct msgbuf *host_mb;
992f48a0 1953 abi_long ret = 0;
1bc012f6 1954
579a97f7
FB		 1955 if (!lock_user_struct(VERIFY_WRITE, target_mb, msgp, 0))
1956 return -TARGET_EFAULT;
1bc012f6
TS		 1957 host_mb = malloc(msgsz+sizeof(long));
1958 ret = get_errno(msgrcv(msqid, host_mb, msgsz, 1, msgflg));
579a97f7
FB		 1959 if (ret > 0) {
1960 abi_ulong target_mtext_addr = msgp + sizeof(abi_ulong);
1961 target_mtext = lock_user(VERIFY_WRITE, target_mtext_addr, ret, 0);
1962 if (!target_mtext) {
1963 ret = -TARGET_EFAULT;
1964 goto end;
1965 }
1bc012f6 1966 memcpy(target_mb->mtext, host_mb->mtext, ret);
579a97f7
FB		 1967 unlock_user(target_mtext, target_mtext_addr, ret);
1968 }
1bc012f6
TS		 1969 target_mb->mtype = tswapl(host_mb->mtype);
1970 free(host_mb);
1bc012f6 1971
579a97f7
FB		 1972end:
1973 if (target_mb)
1974 unlock_user_struct(target_mb, msgp, 1);
1bc012f6
TS		 1975 return ret;
1976}
1977
53a5960a 1978/* ??? This only works with linear mappings. */
0da46a6e 1979/* do_ipc() must return target values and target errnos. */
992f48a0
BS		 1980static abi_long do_ipc(unsigned int call, int first,
1981 int second, int third,
1982 abi_long ptr, abi_long fifth)
8853f86e
FB		 1983{
1984 int version;
992f48a0 1985 abi_long ret = 0;
8853f86e
FB		 1986 struct shmid_ds shm_info;
1987 int i;
1988
1989 version = call >> 16;
1990 call &= 0xffff;
1991
1992 switch (call) {
fa294816 1993 case IPCOP_semop:
579a97f7 1994 ret = get_errno(semop(first,(struct sembuf *)g2h(ptr), second));
fa294816
TS		 1995 break;
1996
1997 case IPCOP_semget:
1998 ret = get_errno(semget(first, second, third));
1999 break;
2000
2001 case IPCOP_semctl:
3eb6b044 2002 ret = do_semctl(first, second, third, ptr);
fa294816
TS		 2003 break;
2004
2005 case IPCOP_semtimedop:
32407103 2006 gemu_log("Unsupported ipc call: %d (version %d)\n", call, version);
0da46a6e 2007 ret = -TARGET_ENOSYS;
fa294816 2008 break;
d96372ef
TS		 2009
2010 case IPCOP_msgget:
2011 ret = get_errno(msgget(first, second));
2012 break;
2013
2014 case IPCOP_msgsnd:
1bc012f6 2015 ret = do_msgsnd(first, ptr, second, third);
d96372ef
TS		 2016 break;
2017
2018 case IPCOP_msgctl:
1bc012f6 2019 ret = do_msgctl(first, second, ptr);
d96372ef
TS		 2020 break;
2021
2022 case IPCOP_msgrcv:
1bc012f6 2023 {
579a97f7 2024 /* XXX: this code is not correct */
1bc012f6
TS		 2025 struct ipc_kludge
2026 {
2027 void *__unbounded msgp;
2028 long int msgtyp;
2029 };
d96372ef 2030
579a97f7 2031 struct ipc_kludge *foo = (struct ipc_kludge *)g2h(ptr);
1bc012f6 2032 struct msgbuf *msgp = (struct msgbuf *) foo->msgp;
d96372ef 2033
1bc012f6 2034 ret = do_msgrcv(first, (long)msgp, second, 0, third);
d96372ef 2035
1bc012f6 2036 }
d96372ef
TS		 2037 break;
2038
8853f86e 2039 case IPCOP_shmat:
5a4a898d
FB		 2040 {
2041 abi_ulong raddr;
2042 void *host_addr;
2043 /* SHM_* flags are the same on all linux platforms */
2044 host_addr = shmat(first, (void *)g2h(ptr), second);
2045 if (host_addr == (void *)-1) {
2046 ret = get_errno((long)host_addr);
8853f86e 2047 break;
5a4a898d
FB		 2048 }
2049 raddr = h2g((unsigned long)host_addr);
2050 /* find out the length of the shared memory segment */
2051
2052 ret = get_errno(shmctl(first, IPC_STAT, &shm_info));
2053 if (is_error(ret)) {
2054 /* can't get length, bail out */
2055 shmdt(host_addr);
2056 break;
2057 }
2058 page_set_flags(raddr, raddr + shm_info.shm_segsz,
2059 PAGE_VALID | PAGE_READ |
2060 ((second & SHM_RDONLY)? 0: PAGE_WRITE));
2061 for (i = 0; i < N_SHM_REGIONS; ++i) {
2062 if (shm_regions[i].start == 0) {
2063 shm_regions[i].start = raddr;
2064 shm_regions[i].size = shm_info.shm_segsz;
2065 break;
2066 }
2067 }
2f619698 2068 if (put_user_ual(raddr, third))
5a4a898d
FB		 2069 return -TARGET_EFAULT;
2070 ret = 0;
2071 }
8853f86e
FB		 2072 break;
2073 case IPCOP_shmdt:
2074 for (i = 0; i < N_SHM_REGIONS; ++i) {
2075 if (shm_regions[i].start == ptr) {
2076 shm_regions[i].start = 0;
2077 page_set_flags(ptr, shm_regions[i].size, 0);
2078 break;
2079 }
2080 }
5a4a898d 2081 ret = get_errno(shmdt((void *)g2h(ptr)));
8853f86e
FB		 2082 break;
2083
2084 case IPCOP_shmget:
2085 /* IPC_* flag values are the same on all linux platforms */
2086 ret = get_errno(shmget(first, second, third));
2087 break;
2088
2089 /* IPC_* and SHM_* command values are the same on all linux platforms */
2090 case IPCOP_shmctl:
2091 switch(second) {
2092 case IPC_RMID:
2093 case SHM_LOCK:
2094 case SHM_UNLOCK:
2095 ret = get_errno(shmctl(first, second, NULL));
2096 break;
2097 default:
2098 goto unimplemented;
2099 }
2100 break;
2101 default:
2102 unimplemented:
32407103 2103 gemu_log("Unsupported ipc call: %d (version %d)\n", call, version);
0da46a6e 2104 ret = -TARGET_ENOSYS;
8853f86e
FB		 2105 break;
2106 }
2107 return ret;
2108}
32407103 2109#endif
8853f86e 2110
31e31b8a
FB		 2111/* kernel structure types definitions */
2112#define IFNAMSIZ 16
2113
2114#define STRUCT(name, list...) STRUCT_ ## name,
2115#define STRUCT_SPECIAL(name) STRUCT_ ## name,
2116enum {
2117#include "syscall_types.h"
2118};
2119#undef STRUCT
2120#undef STRUCT_SPECIAL
2121
2122#define STRUCT(name, list...) const argtype struct_ ## name ## _def[] = { list, TYPE_NULL };
2123#define STRUCT_SPECIAL(name)
2124#include "syscall_types.h"
2125#undef STRUCT
2126#undef STRUCT_SPECIAL
2127
2128typedef struct IOCTLEntry {
2ab83ea7
FB		 2129 unsigned int target_cmd;
2130 unsigned int host_cmd;
31e31b8a
FB		 2131 const char *name;
2132 int access;
1a9353d2 2133 const argtype arg_type[5];
31e31b8a
FB		 2134} IOCTLEntry;
2135
2136#define IOC_R 0x0001
2137#define IOC_W 0x0002
2138#define IOC_RW (IOC_R | IOC_W)
2139
2140#define MAX_STRUCT_SIZE 4096
2141
9f106a75 2142static IOCTLEntry ioctl_entries[] = {
31e31b8a
FB		 2143#define IOCTL(cmd, access, types...) \
2144 { TARGET_ ## cmd, cmd, #cmd, access, { types } },
2145#include "ioctls.h"
2146 { 0, 0, },
2147};
2148
53a5960a 2149/* ??? Implement proper locking for ioctls. */
0da46a6e 2150/* do_ioctl() Must return target values and target errnos. */
992f48a0 2151static abi_long do_ioctl(int fd, abi_long cmd, abi_long arg)
31e31b8a
FB		 2152{
2153 const IOCTLEntry *ie;
2154 const argtype *arg_type;
992f48a0 2155 abi_long ret;
31e31b8a 2156 uint8_t buf_temp[MAX_STRUCT_SIZE];
53a5960a
PB		 2157 int target_size;
2158 void *argptr;
31e31b8a
FB		 2159
2160 ie = ioctl_entries;
2161 for(;;) {
2162 if (ie->target_cmd == 0) {
32407103 2163 gemu_log("Unsupported ioctl: cmd=0x%04lx\n", (long)cmd);
0da46a6e 2164 return -TARGET_ENOSYS;
31e31b8a
FB		 2165 }
2166 if (ie->target_cmd == cmd)
2167 break;
2168 ie++;
2169 }
2170 arg_type = ie->arg_type;
9de5e440 2171#if defined(DEBUG)
32407103 2172 gemu_log("ioctl: cmd=0x%04lx (%s)\n", (long)cmd, ie->name);
72f03900 2173#endif
31e31b8a
FB		 2174 switch(arg_type[0]) {
2175 case TYPE_NULL:
2176 /* no argument */
2177 ret = get_errno(ioctl(fd, ie->host_cmd));
2178 break;
2179 case TYPE_PTRVOID:
2180 case TYPE_INT:
2181 /* int argment */
2182 ret = get_errno(ioctl(fd, ie->host_cmd, arg));
2183 break;
2184 case TYPE_PTR:
2185 arg_type++;
53a5960a 2186 target_size = thunk_type_size(arg_type, 0);
31e31b8a
FB		 2187 switch(ie->access) {
2188 case IOC_R:
2189 ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp));
2190 if (!is_error(ret)) {
579a97f7
FB		 2191 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
2192 if (!argptr)
2193 return -TARGET_EFAULT;
53a5960a
PB		 2194 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
2195 unlock_user(argptr, arg, target_size);
31e31b8a
FB		 2196 }
2197 break;
2198 case IOC_W:
579a97f7
FB		 2199 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
2200 if (!argptr)
2201 return -TARGET_EFAULT;
53a5960a
PB		 2202 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
2203 unlock_user(argptr, arg, 0);
31e31b8a
FB		 2204 ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp));
2205 break;
2206 default:
2207 case IOC_RW:
579a97f7
FB		 2208 argptr = lock_user(VERIFY_READ, arg, target_size, 1);
2209 if (!argptr)
2210 return -TARGET_EFAULT;
53a5960a
PB		 2211 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
2212 unlock_user(argptr, arg, 0);
31e31b8a
FB		 2213 ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp));
2214 if (!is_error(ret)) {
579a97f7
FB		 2215 argptr = lock_user(VERIFY_WRITE, arg, target_size, 0);
2216 if (!argptr)
2217 return -TARGET_EFAULT;
53a5960a
PB		 2218 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
2219 unlock_user(argptr, arg, target_size);
31e31b8a
FB		 2220 }
2221 break;
2222 }
2223 break;
2224 default:
32407103
JM		 2225 gemu_log("Unsupported ioctl type: cmd=0x%04lx type=%d\n",
2226 (long)cmd, arg_type[0]);
0da46a6e 2227 ret = -TARGET_ENOSYS;
31e31b8a
FB		 2228 break;
2229 }
2230 return ret;
2231}
2232
b39bc503 2233static const bitmask_transtbl iflag_tbl[] = {
31e31b8a
FB		 2234 { TARGET_IGNBRK, TARGET_IGNBRK, IGNBRK, IGNBRK },
2235 { TARGET_BRKINT, TARGET_BRKINT, BRKINT, BRKINT },
2236 { TARGET_IGNPAR, TARGET_IGNPAR, IGNPAR, IGNPAR },
2237 { TARGET_PARMRK, TARGET_PARMRK, PARMRK, PARMRK },
2238 { TARGET_INPCK, TARGET_INPCK, INPCK, INPCK },
2239 { TARGET_ISTRIP, TARGET_ISTRIP, ISTRIP, ISTRIP },
2240 { TARGET_INLCR, TARGET_INLCR, INLCR, INLCR },
2241 { TARGET_IGNCR, TARGET_IGNCR, IGNCR, IGNCR },
2242 { TARGET_ICRNL, TARGET_ICRNL, ICRNL, ICRNL },
2243 { TARGET_IUCLC, TARGET_IUCLC, IUCLC, IUCLC },
2244 { TARGET_IXON, TARGET_IXON, IXON, IXON },
2245 { TARGET_IXANY, TARGET_IXANY, IXANY, IXANY },
2246 { TARGET_IXOFF, TARGET_IXOFF, IXOFF, IXOFF },
2247 { TARGET_IMAXBEL, TARGET_IMAXBEL, IMAXBEL, IMAXBEL },
2248 { 0, 0, 0, 0 }
2249};
2250
b39bc503 2251static const bitmask_transtbl oflag_tbl[] = {
31e31b8a
FB		 2252 { TARGET_OPOST, TARGET_OPOST, OPOST, OPOST },
2253 { TARGET_OLCUC, TARGET_OLCUC, OLCUC, OLCUC },
2254 { TARGET_ONLCR, TARGET_ONLCR, ONLCR, ONLCR },
2255 { TARGET_OCRNL, TARGET_OCRNL, OCRNL, OCRNL },
2256 { TARGET_ONOCR, TARGET_ONOCR, ONOCR, ONOCR },
2257 { TARGET_ONLRET, TARGET_ONLRET, ONLRET, ONLRET },
2258 { TARGET_OFILL, TARGET_OFILL, OFILL, OFILL },
2259 { TARGET_OFDEL, TARGET_OFDEL, OFDEL, OFDEL },
2260 { TARGET_NLDLY, TARGET_NL0, NLDLY, NL0 },
2261 { TARGET_NLDLY, TARGET_NL1, NLDLY, NL1 },
2262 { TARGET_CRDLY, TARGET_CR0, CRDLY, CR0 },
2263 { TARGET_CRDLY, TARGET_CR1, CRDLY, CR1 },
2264 { TARGET_CRDLY, TARGET_CR2, CRDLY, CR2 },
2265 { TARGET_CRDLY, TARGET_CR3, CRDLY, CR3 },
2266 { TARGET_TABDLY, TARGET_TAB0, TABDLY, TAB0 },
2267 { TARGET_TABDLY, TARGET_TAB1, TABDLY, TAB1 },
2268 { TARGET_TABDLY, TARGET_TAB2, TABDLY, TAB2 },
2269 { TARGET_TABDLY, TARGET_TAB3, TABDLY, TAB3 },
2270 { TARGET_BSDLY, TARGET_BS0, BSDLY, BS0 },
2271 { TARGET_BSDLY, TARGET_BS1, BSDLY, BS1 },
2272 { TARGET_VTDLY, TARGET_VT0, VTDLY, VT0 },
2273 { TARGET_VTDLY, TARGET_VT1, VTDLY, VT1 },
2274 { TARGET_FFDLY, TARGET_FF0, FFDLY, FF0 },
2275 { TARGET_FFDLY, TARGET_FF1, FFDLY, FF1 },
2276 { 0, 0, 0, 0 }
2277};
2278
b39bc503 2279static const bitmask_transtbl cflag_tbl[] = {
31e31b8a
FB		 2280 { TARGET_CBAUD, TARGET_B0, CBAUD, B0 },
2281 { TARGET_CBAUD, TARGET_B50, CBAUD, B50 },
2282 { TARGET_CBAUD, TARGET_B75, CBAUD, B75 },
2283 { TARGET_CBAUD, TARGET_B110, CBAUD, B110 },
2284 { TARGET_CBAUD, TARGET_B134, CBAUD, B134 },
2285 { TARGET_CBAUD, TARGET_B150, CBAUD, B150 },
2286 { TARGET_CBAUD, TARGET_B200, CBAUD, B200 },
2287 { TARGET_CBAUD, TARGET_B300, CBAUD, B300 },
2288 { TARGET_CBAUD, TARGET_B600, CBAUD, B600 },
2289 { TARGET_CBAUD, TARGET_B1200, CBAUD, B1200 },
2290 { TARGET_CBAUD, TARGET_B1800, CBAUD, B1800 },
2291 { TARGET_CBAUD, TARGET_B2400, CBAUD, B2400 },
2292 { TARGET_CBAUD, TARGET_B4800, CBAUD, B4800 },
2293 { TARGET_CBAUD, TARGET_B9600, CBAUD, B9600 },
2294 { TARGET_CBAUD, TARGET_B19200, CBAUD, B19200 },
2295 { TARGET_CBAUD, TARGET_B38400, CBAUD, B38400 },
2296 { TARGET_CBAUD, TARGET_B57600, CBAUD, B57600 },
2297 { TARGET_CBAUD, TARGET_B115200, CBAUD, B115200 },
2298 { TARGET_CBAUD, TARGET_B230400, CBAUD, B230400 },
2299 { TARGET_CBAUD, TARGET_B460800, CBAUD, B460800 },
2300 { TARGET_CSIZE, TARGET_CS5, CSIZE, CS5 },
2301 { TARGET_CSIZE, TARGET_CS6, CSIZE, CS6 },
2302 { TARGET_CSIZE, TARGET_CS7, CSIZE, CS7 },
2303 { TARGET_CSIZE, TARGET_CS8, CSIZE, CS8 },
2304 { TARGET_CSTOPB, TARGET_CSTOPB, CSTOPB, CSTOPB },
2305 { TARGET_CREAD, TARGET_CREAD, CREAD, CREAD },
2306 { TARGET_PARENB, TARGET_PARENB, PARENB, PARENB },
2307 { TARGET_PARODD, TARGET_PARODD, PARODD, PARODD },
2308 { TARGET_HUPCL, TARGET_HUPCL, HUPCL, HUPCL },
2309 { TARGET_CLOCAL, TARGET_CLOCAL, CLOCAL, CLOCAL },
2310 { TARGET_CRTSCTS, TARGET_CRTSCTS, CRTSCTS, CRTSCTS },
2311 { 0, 0, 0, 0 }
2312};
2313
b39bc503 2314static const bitmask_transtbl lflag_tbl[] = {
31e31b8a
FB		 2315 { TARGET_ISIG, TARGET_ISIG, ISIG, ISIG },
2316 { TARGET_ICANON, TARGET_ICANON, ICANON, ICANON },
2317 { TARGET_XCASE, TARGET_XCASE, XCASE, XCASE },
2318 { TARGET_ECHO, TARGET_ECHO, ECHO, ECHO },
2319 { TARGET_ECHOE, TARGET_ECHOE, ECHOE, ECHOE },
2320 { TARGET_ECHOK, TARGET_ECHOK, ECHOK, ECHOK },
2321 { TARGET_ECHONL, TARGET_ECHONL, ECHONL, ECHONL },
2322 { TARGET_NOFLSH, TARGET_NOFLSH, NOFLSH, NOFLSH },
2323 { TARGET_TOSTOP, TARGET_TOSTOP, TOSTOP, TOSTOP },
2324 { TARGET_ECHOCTL, TARGET_ECHOCTL, ECHOCTL, ECHOCTL },
2325 { TARGET_ECHOPRT, TARGET_ECHOPRT, ECHOPRT, ECHOPRT },
2326 { TARGET_ECHOKE, TARGET_ECHOKE, ECHOKE, ECHOKE },
2327 { TARGET_FLUSHO, TARGET_FLUSHO, FLUSHO, FLUSHO },
2328 { TARGET_PENDIN, TARGET_PENDIN, PENDIN, PENDIN },
2329 { TARGET_IEXTEN, TARGET_IEXTEN, IEXTEN, IEXTEN },
2330 { 0, 0, 0, 0 }
2331};
2332
2333static void target_to_host_termios (void *dst, const void *src)
2334{
2335 struct host_termios *host = dst;
2336 const struct target_termios *target = src;
3b46e624 2337
5fafdf24 2338 host->c_iflag =
31e31b8a 2339 target_to_host_bitmask(tswap32(target->c_iflag), iflag_tbl);
5fafdf24 2340 host->c_oflag =
31e31b8a 2341 target_to_host_bitmask(tswap32(target->c_oflag), oflag_tbl);
5fafdf24 2342 host->c_cflag =
31e31b8a 2343 target_to_host_bitmask(tswap32(target->c_cflag), cflag_tbl);
5fafdf24 2344 host->c_lflag =
31e31b8a
FB		 2345 target_to_host_bitmask(tswap32(target->c_lflag), lflag_tbl);
2346 host->c_line = target->c_line;
3b46e624 2347
5fafdf24
TS		 2348 host->c_cc[VINTR] = target->c_cc[TARGET_VINTR];
2349 host->c_cc[VQUIT] = target->c_cc[TARGET_VQUIT];
3b46e624 2350 host->c_cc[VERASE] = target->c_cc[TARGET_VERASE];
5fafdf24 2351 host->c_cc[VKILL] = target->c_cc[TARGET_VKILL];
3b46e624 2352 host->c_cc[VEOF] = target->c_cc[TARGET_VEOF];
5fafdf24 2353 host->c_cc[VTIME] = target->c_cc[TARGET_VTIME];
3b46e624 2354 host->c_cc[VMIN] = target->c_cc[TARGET_VMIN];
5fafdf24 2355 host->c_cc[VSWTC] = target->c_cc[TARGET_VSWTC];
3b46e624 2356 host->c_cc[VSTART] = target->c_cc[TARGET_VSTART];
5fafdf24
TS		 2357 host->c_cc[VSTOP] = target->c_cc[TARGET_VSTOP];
2358 host->c_cc[VSUSP] = target->c_cc[TARGET_VSUSP];
3b46e624
TS		 2359 host->c_cc[VEOL] = target->c_cc[TARGET_VEOL];
2360 host->c_cc[VREPRINT] = target->c_cc[TARGET_VREPRINT];
2361 host->c_cc[VDISCARD] = target->c_cc[TARGET_VDISCARD];
2362 host->c_cc[VWERASE] = target->c_cc[TARGET_VWERASE];
2363 host->c_cc[VLNEXT] = target->c_cc[TARGET_VLNEXT];
5fafdf24 2364 host->c_cc[VEOL2] = target->c_cc[TARGET_VEOL2];
31e31b8a 2365}
3b46e624 2366
31e31b8a
FB		 2367static void host_to_target_termios (void *dst, const void *src)
2368{
2369 struct target_termios *target = dst;
2370 const struct host_termios *host = src;
2371
5fafdf24 2372 target->c_iflag =
31e31b8a 2373 tswap32(host_to_target_bitmask(host->c_iflag, iflag_tbl));
5fafdf24 2374 target->c_oflag =
31e31b8a 2375 tswap32(host_to_target_bitmask(host->c_oflag, oflag_tbl));
5fafdf24 2376 target->c_cflag =
31e31b8a 2377 tswap32(host_to_target_bitmask(host->c_cflag, cflag_tbl));
5fafdf24 2378 target->c_lflag =
31e31b8a
FB		 2379 tswap32(host_to_target_bitmask(host->c_lflag, lflag_tbl));
2380 target->c_line = host->c_line;
3b46e624 2381
31e31b8a
FB		 2382 target->c_cc[TARGET_VINTR] = host->c_cc[VINTR];
2383 target->c_cc[TARGET_VQUIT] = host->c_cc[VQUIT];
2384 target->c_cc[TARGET_VERASE] = host->c_cc[VERASE];
2385 target->c_cc[TARGET_VKILL] = host->c_cc[VKILL];
2386 target->c_cc[TARGET_VEOF] = host->c_cc[VEOF];
2387 target->c_cc[TARGET_VTIME] = host->c_cc[VTIME];
2388 target->c_cc[TARGET_VMIN] = host->c_cc[VMIN];
2389 target->c_cc[TARGET_VSWTC] = host->c_cc[VSWTC];
2390 target->c_cc[TARGET_VSTART] = host->c_cc[VSTART];
2391 target->c_cc[TARGET_VSTOP] = host->c_cc[VSTOP];
2392 target->c_cc[TARGET_VSUSP] = host->c_cc[VSUSP];
2393 target->c_cc[TARGET_VEOL] = host->c_cc[VEOL];
2394 target->c_cc[TARGET_VREPRINT] = host->c_cc[VREPRINT];
2395 target->c_cc[TARGET_VDISCARD] = host->c_cc[VDISCARD];
2396 target->c_cc[TARGET_VWERASE] = host->c_cc[VWERASE];
2397 target->c_cc[TARGET_VLNEXT] = host->c_cc[VLNEXT];
2398 target->c_cc[TARGET_VEOL2] = host->c_cc[VEOL2];
2399}
2400
8e853dc7 2401static const StructEntry struct_termios_def = {
31e31b8a
FB		 2402 .convert = { host_to_target_termios, target_to_host_termios },
2403 .size = { sizeof(struct target_termios), sizeof(struct host_termios) },
2404 .align = { __alignof__(struct target_termios), __alignof__(struct host_termios) },
2405};
2406
5286db75
FB		 2407static bitmask_transtbl mmap_flags_tbl[] = {
2408 { TARGET_MAP_SHARED, TARGET_MAP_SHARED, MAP_SHARED, MAP_SHARED },
2409 { TARGET_MAP_PRIVATE, TARGET_MAP_PRIVATE, MAP_PRIVATE, MAP_PRIVATE },
2410 { TARGET_MAP_FIXED, TARGET_MAP_FIXED, MAP_FIXED, MAP_FIXED },
2411 { TARGET_MAP_ANONYMOUS, TARGET_MAP_ANONYMOUS, MAP_ANONYMOUS, MAP_ANONYMOUS },
2412 { TARGET_MAP_GROWSDOWN, TARGET_MAP_GROWSDOWN, MAP_GROWSDOWN, MAP_GROWSDOWN },
2413 { TARGET_MAP_DENYWRITE, TARGET_MAP_DENYWRITE, MAP_DENYWRITE, MAP_DENYWRITE },
2414 { TARGET_MAP_EXECUTABLE, TARGET_MAP_EXECUTABLE, MAP_EXECUTABLE, MAP_EXECUTABLE },
2415 { TARGET_MAP_LOCKED, TARGET_MAP_LOCKED, MAP_LOCKED, MAP_LOCKED },
2416 { 0, 0, 0, 0 }
2417};
2418
ffa65c3b
FB		 2419static bitmask_transtbl fcntl_flags_tbl[] = {
2420 { TARGET_O_ACCMODE, TARGET_O_WRONLY, O_ACCMODE, O_WRONLY, },
2421 { TARGET_O_ACCMODE, TARGET_O_RDWR, O_ACCMODE, O_RDWR, },
2422 { TARGET_O_CREAT, TARGET_O_CREAT, O_CREAT, O_CREAT, },
2423 { TARGET_O_EXCL, TARGET_O_EXCL, O_EXCL, O_EXCL, },
2424 { TARGET_O_NOCTTY, TARGET_O_NOCTTY, O_NOCTTY, O_NOCTTY, },
2425 { TARGET_O_TRUNC, TARGET_O_TRUNC, O_TRUNC, O_TRUNC, },
2426 { TARGET_O_APPEND, TARGET_O_APPEND, O_APPEND, O_APPEND, },
2427 { TARGET_O_NONBLOCK, TARGET_O_NONBLOCK, O_NONBLOCK, O_NONBLOCK, },
2428 { TARGET_O_SYNC, TARGET_O_SYNC, O_SYNC, O_SYNC, },
2429 { TARGET_FASYNC, TARGET_FASYNC, FASYNC, FASYNC, },
2430 { TARGET_O_DIRECTORY, TARGET_O_DIRECTORY, O_DIRECTORY, O_DIRECTORY, },
2431 { TARGET_O_NOFOLLOW, TARGET_O_NOFOLLOW, O_NOFOLLOW, O_NOFOLLOW, },
2432 { TARGET_O_LARGEFILE, TARGET_O_LARGEFILE, O_LARGEFILE, O_LARGEFILE, },
121061dc 2433#if defined(O_DIRECT)
ffa65c3b 2434 { TARGET_O_DIRECT, TARGET_O_DIRECT, O_DIRECT, O_DIRECT, },
121061dc 2435#endif
ffa65c3b
FB		 2436 { 0, 0, 0, 0 }
2437};
2438
2ab83ea7 2439#if defined(TARGET_I386)
6dbad63e
FB		 2440
2441/* NOTE: there is really one LDT for all the threads */
2442uint8_t *ldt_table;
2443
03acab66 2444static abi_long read_ldt(abi_ulong ptr, unsigned long bytecount)
6dbad63e
FB		 2445{
2446 int size;
53a5960a 2447 void *p;
6dbad63e
FB		 2448
2449 if (!ldt_table)
2450 return 0;
2451 size = TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE;
2452 if (size > bytecount)
2453 size = bytecount;
579a97f7
FB		 2454 p = lock_user(VERIFY_WRITE, ptr, size, 0);
2455 if (!p)
03acab66 2456 return -TARGET_EFAULT;
579a97f7 2457 /* ??? Should this by byteswapped? */
53a5960a
PB		 2458 memcpy(p, ldt_table, size);
2459 unlock_user(p, ptr, size);
6dbad63e
FB		 2460 return size;
2461}
2462
2463/* XXX: add locking support */
03acab66
FB		 2464static abi_long write_ldt(CPUX86State *env,
2465 abi_ulong ptr, unsigned long bytecount, int oldmode)
6dbad63e
FB		 2466{
2467 struct target_modify_ldt_ldt_s ldt_info;
53a5960a 2468 struct target_modify_ldt_ldt_s *target_ldt_info;
6dbad63e 2469 int seg_32bit, contents, read_exec_only, limit_in_pages;
8d18e893 2470 int seg_not_present, useable, lm;
6dbad63e
FB		 2471 uint32_t *lp, entry_1, entry_2;
2472
2473 if (bytecount != sizeof(ldt_info))
03acab66 2474 return -TARGET_EINVAL;
579a97f7 2475 if (!lock_user_struct(VERIFY_READ, target_ldt_info, ptr, 1))
03acab66 2476 return -TARGET_EFAULT;
53a5960a
PB		 2477 ldt_info.entry_number = tswap32(target_ldt_info->entry_number);
2478 ldt_info.base_addr = tswapl(target_ldt_info->base_addr);
2479 ldt_info.limit = tswap32(target_ldt_info->limit);
2480 ldt_info.flags = tswap32(target_ldt_info->flags);
2481 unlock_user_struct(target_ldt_info, ptr, 0);
3b46e624 2482
6dbad63e 2483 if (ldt_info.entry_number >= TARGET_LDT_ENTRIES)
03acab66 2484 return -TARGET_EINVAL;
6dbad63e
FB		 2485 seg_32bit = ldt_info.flags & 1;
2486 contents = (ldt_info.flags >> 1) & 3;
2487 read_exec_only = (ldt_info.flags >> 3) & 1;
2488 limit_in_pages = (ldt_info.flags >> 4) & 1;
2489 seg_not_present = (ldt_info.flags >> 5) & 1;
2490 useable = (ldt_info.flags >> 6) & 1;
8d18e893
FB		 2491#ifdef TARGET_ABI32
2492 lm = 0;
2493#else
2494 lm = (ldt_info.flags >> 7) & 1;
2495#endif
6dbad63e
FB		 2496 if (contents == 3) {
2497 if (oldmode)
03acab66 2498 return -TARGET_EINVAL;
6dbad63e 2499 if (seg_not_present == 0)
03acab66 2500 return -TARGET_EINVAL;
6dbad63e
FB		 2501 }
2502 /* allocate the LDT */
2503 if (!ldt_table) {
2504 ldt_table = malloc(TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE);
2505 if (!ldt_table)
03acab66 2506 return -TARGET_ENOMEM;
6dbad63e 2507 memset(ldt_table, 0, TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE);
eeeac3f3 2508 env->ldt.base = h2g((unsigned long)ldt_table);
6dbad63e
FB		 2509 env->ldt.limit = 0xffff;
2510 }
2511
2512 /* NOTE: same code as Linux kernel */
2513 /* Allow LDTs to be cleared by the user. */
2514 if (ldt_info.base_addr == 0 && ldt_info.limit == 0) {
2515 if (oldmode ||
2516 (contents == 0 &&
2517 read_exec_only == 1 &&
2518 seg_32bit == 0 &&
2519 limit_in_pages == 0 &&
2520 seg_not_present == 1 &&
2521 useable == 0 )) {
2522 entry_1 = 0;
2523 entry_2 = 0;
2524 goto install;
2525 }
2526 }
3b46e624 2527
6dbad63e
FB		 2528 entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) |
2529 (ldt_info.limit & 0x0ffff);
2530 entry_2 = (ldt_info.base_addr & 0xff000000) |
2531 ((ldt_info.base_addr & 0x00ff0000) >> 16) |
2532 (ldt_info.limit & 0xf0000) |
2533 ((read_exec_only ^ 1) << 9) |
2534 (contents << 10) |
2535 ((seg_not_present ^ 1) << 15) |
2536 (seg_32bit << 22) |
2537 (limit_in_pages << 23) |
8d18e893 2538 (lm << 21) |
6dbad63e
FB		 2539 0x7000;
2540 if (!oldmode)
2541 entry_2 |= (useable << 20);
14ae3ba7 2542
6dbad63e
FB		 2543 /* Install the new entry ... */
2544install:
2545 lp = (uint32_t *)(ldt_table + (ldt_info.entry_number << 3));
2546 lp[0] = tswap32(entry_1);
2547 lp[1] = tswap32(entry_2);
2548 return 0;
2549}
2550
2551/* specific and weird i386 syscalls */
8fcd3692
BS		 2552static abi_long do_modify_ldt(CPUX86State *env, int func, abi_ulong ptr,
2553 unsigned long bytecount)
6dbad63e 2554{
03acab66 2555 abi_long ret;
3b46e624 2556
6dbad63e
FB		 2557 switch (func) {
2558 case 0:
2559 ret = read_ldt(ptr, bytecount);
2560 break;
2561 case 1:
2562 ret = write_ldt(env, ptr, bytecount, 1);
2563 break;
2564 case 0x11:
2565 ret = write_ldt(env, ptr, bytecount, 0);
2566 break;
03acab66
FB		 2567 default:
2568 ret = -TARGET_ENOSYS;
2569 break;
6dbad63e
FB		 2570 }
2571 return ret;
2572}
1b6b029e 2573
4583f589 2574#if defined(TARGET_I386) && defined(TARGET_ABI32)
8fcd3692 2575static abi_long do_set_thread_area(CPUX86State *env, abi_ulong ptr)
8d18e893
FB		 2576{
2577 uint64_t *gdt_table = g2h(env->gdt.base);
2578 struct target_modify_ldt_ldt_s ldt_info;
2579 struct target_modify_ldt_ldt_s *target_ldt_info;
2580 int seg_32bit, contents, read_exec_only, limit_in_pages;
2581 int seg_not_present, useable, lm;
2582 uint32_t *lp, entry_1, entry_2;
2583 int i;
2584
2585 lock_user_struct(VERIFY_WRITE, target_ldt_info, ptr, 1);
2586 if (!target_ldt_info)
2587 return -TARGET_EFAULT;
2588 ldt_info.entry_number = tswap32(target_ldt_info->entry_number);
2589 ldt_info.base_addr = tswapl(target_ldt_info->base_addr);
2590 ldt_info.limit = tswap32(target_ldt_info->limit);
2591 ldt_info.flags = tswap32(target_ldt_info->flags);
2592 if (ldt_info.entry_number == -1) {
2593 for (i=TARGET_GDT_ENTRY_TLS_MIN; i<=TARGET_GDT_ENTRY_TLS_MAX; i++) {
2594 if (gdt_table[i] == 0) {
2595 ldt_info.entry_number = i;
2596 target_ldt_info->entry_number = tswap32(i);
2597 break;
2598 }
2599 }
2600 }
2601 unlock_user_struct(target_ldt_info, ptr, 1);
2602
2603 if (ldt_info.entry_number < TARGET_GDT_ENTRY_TLS_MIN ||
2604 ldt_info.entry_number > TARGET_GDT_ENTRY_TLS_MAX)
2605 return -TARGET_EINVAL;
2606 seg_32bit = ldt_info.flags & 1;
2607 contents = (ldt_info.flags >> 1) & 3;
2608 read_exec_only = (ldt_info.flags >> 3) & 1;
2609 limit_in_pages = (ldt_info.flags >> 4) & 1;
2610 seg_not_present = (ldt_info.flags >> 5) & 1;
2611 useable = (ldt_info.flags >> 6) & 1;
2612#ifdef TARGET_ABI32
2613 lm = 0;
2614#else
2615 lm = (ldt_info.flags >> 7) & 1;
2616#endif
2617
2618 if (contents == 3) {
2619 if (seg_not_present == 0)
2620 return -TARGET_EINVAL;
2621 }
2622
2623 /* NOTE: same code as Linux kernel */
2624 /* Allow LDTs to be cleared by the user. */
2625 if (ldt_info.base_addr == 0 && ldt_info.limit == 0) {
2626 if ((contents == 0 &&
2627 read_exec_only == 1 &&
2628 seg_32bit == 0 &&
2629 limit_in_pages == 0 &&
2630 seg_not_present == 1 &&
2631 useable == 0 )) {
2632 entry_1 = 0;
2633 entry_2 = 0;
2634 goto install;
2635 }
2636 }
2637
2638 entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) |
2639 (ldt_info.limit & 0x0ffff);
2640 entry_2 = (ldt_info.base_addr & 0xff000000) |
2641 ((ldt_info.base_addr & 0x00ff0000) >> 16) |
2642 (ldt_info.limit & 0xf0000) |
2643 ((read_exec_only ^ 1) << 9) |
2644 (contents << 10) |
2645 ((seg_not_present ^ 1) << 15) |
2646 (seg_32bit << 22) |
2647 (limit_in_pages << 23) |
2648 (useable << 20) |
2649 (lm << 21) |
2650 0x7000;
2651
2652 /* Install the new entry ... */
2653install:
2654 lp = (uint32_t *)(gdt_table + ldt_info.entry_number);
2655 lp[0] = tswap32(entry_1);
2656 lp[1] = tswap32(entry_2);
2657 return 0;
2658}
2659
8fcd3692 2660static abi_long do_get_thread_area(CPUX86State *env, abi_ulong ptr)
8d18e893
FB		 2661{
2662 struct target_modify_ldt_ldt_s *target_ldt_info;
2663 uint64_t *gdt_table = g2h(env->gdt.base);
2664 uint32_t base_addr, limit, flags;
2665 int seg_32bit, contents, read_exec_only, limit_in_pages, idx;
2666 int seg_not_present, useable, lm;
2667 uint32_t *lp, entry_1, entry_2;
2668
2669 lock_user_struct(VERIFY_WRITE, target_ldt_info, ptr, 1);
2670 if (!target_ldt_info)
2671 return -TARGET_EFAULT;
2672 idx = tswap32(target_ldt_info->entry_number);
2673 if (idx < TARGET_GDT_ENTRY_TLS_MIN ||
2674 idx > TARGET_GDT_ENTRY_TLS_MAX) {
2675 unlock_user_struct(target_ldt_info, ptr, 1);
2676 return -TARGET_EINVAL;
2677 }
2678 lp = (uint32_t *)(gdt_table + idx);
2679 entry_1 = tswap32(lp[0]);
2680 entry_2 = tswap32(lp[1]);
2681
2682 read_exec_only = ((entry_2 >> 9) & 1) ^ 1;
2683 contents = (entry_2 >> 10) & 3;
2684 seg_not_present = ((entry_2 >> 15) & 1) ^ 1;
2685 seg_32bit = (entry_2 >> 22) & 1;
2686 limit_in_pages = (entry_2 >> 23) & 1;
2687 useable = (entry_2 >> 20) & 1;
2688#ifdef TARGET_ABI32
2689 lm = 0;
2690#else
2691 lm = (entry_2 >> 21) & 1;
2692#endif
2693 flags = (seg_32bit << 0) | (contents << 1) |
2694 (read_exec_only << 3) | (limit_in_pages << 4) |
2695 (seg_not_present << 5) | (useable << 6) | (lm << 7);
2696 limit = (entry_1 & 0xffff) | (entry_2 & 0xf0000);
2697 base_addr = (entry_1 >> 16) |
2698 (entry_2 & 0xff000000) |
2699 ((entry_2 & 0xff) << 16);
2700 target_ldt_info->base_addr = tswapl(base_addr);
2701 target_ldt_info->limit = tswap32(limit);
2702 target_ldt_info->flags = tswap32(flags);
2703 unlock_user_struct(target_ldt_info, ptr, 1);
2704 return 0;
2705}
4583f589 2706#endif /* TARGET_I386 && TARGET_ABI32 */
8d18e893 2707
d2fd1af7 2708#ifndef TARGET_ABI32
8fcd3692 2709static abi_long do_arch_prctl(CPUX86State *env, int code, abi_ulong addr)
d2fd1af7
FB		 2710{
2711 abi_long ret;
2712 abi_ulong val;
2713 int idx;
2714
2715 switch(code) {
2716 case TARGET_ARCH_SET_GS:
2717 case TARGET_ARCH_SET_FS:
2718 if (code == TARGET_ARCH_SET_GS)
2719 idx = R_GS;
2720 else
2721 idx = R_FS;
2722 cpu_x86_load_seg(env, idx, 0);
2723 env->segs[idx].base = addr;
2724 break;
2725 case TARGET_ARCH_GET_GS:
2726 case TARGET_ARCH_GET_FS:
2727 if (code == TARGET_ARCH_GET_GS)
2728 idx = R_GS;
2729 else
2730 idx = R_FS;
2731 val = env->segs[idx].base;
2732 if (put_user(val, addr, abi_ulong))
2733 return -TARGET_EFAULT;
2734 break;
2735 default:
2736 ret = -TARGET_EINVAL;
2737 break;
2738 }
2739 return 0;
2740}
2741#endif
2742
2ab83ea7
FB		 2743#endif /* defined(TARGET_I386) */
2744
d865bab5
PB		 2745#if defined(USE_NPTL)
2746
2747#define NEW_STACK_SIZE PTHREAD_STACK_MIN
2748
2749static pthread_mutex_t clone_lock = PTHREAD_MUTEX_INITIALIZER;
2750typedef struct {
2751 CPUState *env;
2752 pthread_mutex_t mutex;
2753 pthread_cond_t cond;
2754 pthread_t thread;
2755 uint32_t tid;
2756 abi_ulong child_tidptr;
2757 abi_ulong parent_tidptr;
2758 sigset_t sigmask;
2759} new_thread_info;
2760
2761static void *clone_func(void *arg)
2762{
2763 new_thread_info *info = arg;
2764 CPUState *env;
2765
2766 env = info->env;
2767 thread_env = env;
2768 info->tid = gettid();
2769 if (info->child_tidptr)
2770 put_user_u32(info->tid, info->child_tidptr);
2771 if (info->parent_tidptr)
2772 put_user_u32(info->tid, info->parent_tidptr);
2773 /* Enable signals. */
2774 sigprocmask(SIG_SETMASK, &info->sigmask, NULL);
2775 /* Signal to the parent that we're ready. */
2776 pthread_mutex_lock(&info->mutex);
2777 pthread_cond_broadcast(&info->cond);
2778 pthread_mutex_unlock(&info->mutex);
2779 /* Wait until the parent has finshed initializing the tls state. */
2780 pthread_mutex_lock(&clone_lock);
2781 pthread_mutex_unlock(&clone_lock);
2782 cpu_loop(env);
2783 /* never exits */
2784 return NULL;
2785}
2786#else
1b6b029e
FB		 2787/* this stack is the equivalent of the kernel stack associated with a
2788 thread/process */
2789#define NEW_STACK_SIZE 8192
2790
2791static int clone_func(void *arg)
2792{
2ab83ea7 2793 CPUState *env = arg;
1b6b029e
FB		 2794 cpu_loop(env);
2795 /* never exits */
2796 return 0;
2797}
d865bab5 2798#endif
1b6b029e 2799
0da46a6e
TS		 2800/* do_fork() Must return host values and target errnos (unlike most
2801 do_*() functions). */
d865bab5
PB		 2802static int do_fork(CPUState *env, unsigned int flags, abi_ulong newsp,
2803 abi_ulong parent_tidptr, target_ulong newtls,
2804 abi_ulong child_tidptr)
1b6b029e
FB		 2805{
2806 int ret;
5cd4393b 2807 TaskState *ts;
1b6b029e 2808 uint8_t *new_stack;
2ab83ea7 2809 CPUState *new_env;
d865bab5
PB		 2810#if defined(USE_NPTL)
2811 unsigned int nptl_flags;
2812 sigset_t sigmask;
2813#endif
3b46e624 2814
436d124b
AZ		 2815 /* Emulate vfork() with fork() */
2816 if (flags & CLONE_VFORK)
2817 flags &= ~(CLONE_VFORK | CLONE_VM);
2818
1b6b029e 2819 if (flags & CLONE_VM) {
bd0c5661 2820#if defined(USE_NPTL)
d865bab5
PB		 2821 new_thread_info info;
2822 pthread_attr_t attr;
bd0c5661 2823#endif
c3a92833 2824 ts = qemu_mallocz(sizeof(TaskState) + NEW_STACK_SIZE);
624f7979 2825 init_task_state(ts);
5cd4393b 2826 new_stack = ts->stack;
1b6b029e 2827 /* we create a new CPU instance. */
c5be9f08 2828 new_env = cpu_copy(env);
6e68e076
PB		 2829 /* Init regs that differ from the parent. */
2830 cpu_clone_regs(new_env, newsp);
5cd4393b 2831 new_env->opaque = ts;
d865bab5
PB		 2832#if defined(USE_NPTL)
2833 nptl_flags = flags;
2834 flags &= ~CLONE_NPTL_FLAGS2;
2835
2836 /* TODO: Implement CLONE_CHILD_CLEARTID. */
2837 if (nptl_flags & CLONE_SETTLS)
2838 cpu_set_tls (new_env, newtls);
2839
2840 /* Grab a mutex so that thread setup appears atomic. */
2841 pthread_mutex_lock(&clone_lock);
2842
2843 memset(&info, 0, sizeof(info));
2844 pthread_mutex_init(&info.mutex, NULL);
2845 pthread_mutex_lock(&info.mutex);
2846 pthread_cond_init(&info.cond, NULL);
2847 info.env = new_env;
2848 if (nptl_flags & CLONE_CHILD_SETTID)
2849 info.child_tidptr = child_tidptr;
2850 if (nptl_flags & CLONE_PARENT_SETTID)
2851 info.parent_tidptr = parent_tidptr;
2852
2853 ret = pthread_attr_init(&attr);
2854 ret = pthread_attr_setstack(&attr, new_stack, NEW_STACK_SIZE);
2855 /* It is not safe to deliver signals until the child has finished
2856 initializing, so temporarily block all signals. */
2857 sigfillset(&sigmask);
2858 sigprocmask(SIG_BLOCK, &sigmask, &info.sigmask);
2859
2860 ret = pthread_create(&info.thread, &attr, clone_func, &info);
2861
2862 sigprocmask(SIG_SETMASK, &info.sigmask, NULL);
2863 pthread_attr_destroy(&attr);
2864 if (ret == 0) {
2865 /* Wait for the child to initialize. */
2866 pthread_cond_wait(&info.cond, &info.mutex);
2867 ret = info.tid;
2868 if (flags & CLONE_PARENT_SETTID)
2869 put_user_u32(ret, parent_tidptr);
2870 } else {
2871 ret = -1;
2872 }
2873 pthread_mutex_unlock(&info.mutex);
2874 pthread_cond_destroy(&info.cond);
2875 pthread_mutex_destroy(&info.mutex);
2876 pthread_mutex_unlock(&clone_lock);
2877#else
2878 if (flags & CLONE_NPTL_FLAGS2)
2879 return -EINVAL;
2880 /* This is probably going to die very quickly, but do it anyway. */
27725c1d 2881#ifdef __ia64__
fd4a43e4 2882 ret = __clone2(clone_func, new_stack + NEW_STACK_SIZE, flags, new_env);
27725c1d
FB		 2883#else
2884 ret = clone(clone_func, new_stack + NEW_STACK_SIZE, flags, new_env);
d865bab5 2885#endif
27725c1d 2886#endif
1b6b029e
FB		 2887 } else {
2888 /* if no CLONE_VM, we consider it is a fork */
d865bab5 2889 if ((flags & ~(CSIGNAL | CLONE_NPTL_FLAGS2)) != 0)
1b6b029e 2890 return -EINVAL;
d865bab5 2891 fork_start();
1b6b029e 2892 ret = fork();
d865bab5
PB		 2893#if defined(USE_NPTL)
2894 /* There is a race condition here. The parent process could
2895 theoretically read the TID in the child process before the child
2896 tid is set. This would require using either ptrace
2897 (not implemented) or having *_tidptr to point at a shared memory
2898 mapping. We can't repeat the spinlock hack used above because
2899 the child process gets its own copy of the lock. */
2900 if (ret == 0) {
2901 cpu_clone_regs(env, newsp);
2902 fork_end(1);
2903 /* Child Process. */
2904 if (flags & CLONE_CHILD_SETTID)
2905 put_user_u32(gettid(), child_tidptr);
2906 if (flags & CLONE_PARENT_SETTID)
2907 put_user_u32(gettid(), parent_tidptr);
2908 ts = (TaskState *)env->opaque;
2909 if (flags & CLONE_SETTLS)
2910 cpu_set_tls (env, newtls);
2911 /* TODO: Implement CLONE_CHILD_CLEARTID. */
2912 } else {
2913 fork_end(0);
2914 }
2915#else
6e68e076
PB		 2916 if (ret == 0) {
2917 cpu_clone_regs(env, newsp);
2918 }
d865bab5 2919#endif
1b6b029e
FB		 2920 }
2921 return ret;
2922}
2923
992f48a0 2924static abi_long do_fcntl(int fd, int cmd, abi_ulong arg)
7775e9ec
FB		 2925{
2926 struct flock fl;
53a5960a 2927 struct target_flock *target_fl;
43f238d7
TS		 2928 struct flock64 fl64;
2929 struct target_flock64 *target_fl64;
992f48a0 2930 abi_long ret;
53a5960a 2931
7775e9ec
FB		 2932 switch(cmd) {
2933 case TARGET_F_GETLK:
579a97f7
FB		 2934 if (!lock_user_struct(VERIFY_READ, target_fl, arg, 1))
2935 return -TARGET_EFAULT;
5813427b
TS		 2936 fl.l_type = tswap16(target_fl->l_type);
2937 fl.l_whence = tswap16(target_fl->l_whence);
2938 fl.l_start = tswapl(target_fl->l_start);
2939 fl.l_len = tswapl(target_fl->l_len);
2940 fl.l_pid = tswapl(target_fl->l_pid);
2941 unlock_user_struct(target_fl, arg, 0);
9ee1fa2c 2942 ret = get_errno(fcntl(fd, cmd, &fl));
7775e9ec 2943 if (ret == 0) {
579a97f7
FB		 2944 if (!lock_user_struct(VERIFY_WRITE, target_fl, arg, 0))
2945 return -TARGET_EFAULT;
7775e9ec
FB		 2946 target_fl->l_type = tswap16(fl.l_type);
2947 target_fl->l_whence = tswap16(fl.l_whence);
2948 target_fl->l_start = tswapl(fl.l_start);
2949 target_fl->l_len = tswapl(fl.l_len);
2950 target_fl->l_pid = tswapl(fl.l_pid);
53a5960a 2951 unlock_user_struct(target_fl, arg, 1);
7775e9ec
FB		 2952 }
2953 break;
3b46e624 2954
7775e9ec
FB		 2955 case TARGET_F_SETLK:
2956 case TARGET_F_SETLKW:
579a97f7
FB		 2957 if (!lock_user_struct(VERIFY_READ, target_fl, arg, 1))
2958 return -TARGET_EFAULT;
7775e9ec
FB		 2959 fl.l_type = tswap16(target_fl->l_type);
2960 fl.l_whence = tswap16(target_fl->l_whence);
2961 fl.l_start = tswapl(target_fl->l_start);
2962 fl.l_len = tswapl(target_fl->l_len);
2963 fl.l_pid = tswapl(target_fl->l_pid);
53a5960a 2964 unlock_user_struct(target_fl, arg, 0);
9ee1fa2c 2965 ret = get_errno(fcntl(fd, cmd, &fl));
7775e9ec 2966 break;
3b46e624 2967
7775e9ec 2968 case TARGET_F_GETLK64:
579a97f7
FB		 2969 if (!lock_user_struct(VERIFY_READ, target_fl64, arg, 1))
2970 return -TARGET_EFAULT;
5813427b
TS		 2971 fl64.l_type = tswap16(target_fl64->l_type) >> 1;
2972 fl64.l_whence = tswap16(target_fl64->l_whence);
2973 fl64.l_start = tswapl(target_fl64->l_start);
2974 fl64.l_len = tswapl(target_fl64->l_len);
2975 fl64.l_pid = tswap16(target_fl64->l_pid);
2976 unlock_user_struct(target_fl64, arg, 0);
9ee1fa2c 2977 ret = get_errno(fcntl(fd, cmd >> 1, &fl64));
43f238d7 2978 if (ret == 0) {
579a97f7
FB		 2979 if (!lock_user_struct(VERIFY_WRITE, target_fl64, arg, 0))
2980 return -TARGET_EFAULT;
43f238d7
TS		 2981 target_fl64->l_type = tswap16(fl64.l_type) >> 1;
2982 target_fl64->l_whence = tswap16(fl64.l_whence);
2983 target_fl64->l_start = tswapl(fl64.l_start);
2984 target_fl64->l_len = tswapl(fl64.l_len);
2985 target_fl64->l_pid = tswapl(fl64.l_pid);
2986 unlock_user_struct(target_fl64, arg, 1);
2987 }
9ee1fa2c 2988 break;
7775e9ec
FB		 2989 case TARGET_F_SETLK64:
2990 case TARGET_F_SETLKW64:
579a97f7
FB		 2991 if (!lock_user_struct(VERIFY_READ, target_fl64, arg, 1))
2992 return -TARGET_EFAULT;
43f238d7
TS		 2993 fl64.l_type = tswap16(target_fl64->l_type) >> 1;
2994 fl64.l_whence = tswap16(target_fl64->l_whence);
2995 fl64.l_start = tswapl(target_fl64->l_start);
2996 fl64.l_len = tswapl(target_fl64->l_len);
2997 fl64.l_pid = tswap16(target_fl64->l_pid);
2998 unlock_user_struct(target_fl64, arg, 0);
9ee1fa2c 2999 ret = get_errno(fcntl(fd, cmd >> 1, &fl64));
7775e9ec
FB		 3000 break;
3001
ffa65c3b 3002 case F_GETFL:
9ee1fa2c
FB		 3003 ret = get_errno(fcntl(fd, cmd, arg));
3004 if (ret >= 0) {
3005 ret = host_to_target_bitmask(ret, fcntl_flags_tbl);
3006 }
ffa65c3b
FB		 3007 break;
3008
3009 case F_SETFL:
9ee1fa2c 3010 ret = get_errno(fcntl(fd, cmd, target_to_host_bitmask(arg, fcntl_flags_tbl)));
ffa65c3b
FB		 3011 break;
3012
7775e9ec 3013 default:
9ee1fa2c 3014 ret = get_errno(fcntl(fd, cmd, arg));
7775e9ec
FB		 3015 break;
3016 }
3017 return ret;
3018}
3019
67867308 3020#ifdef USE_UID16
7775e9ec 3021
67867308
FB		 3022static inline int high2lowuid(int uid)
3023{
3024 if (uid > 65535)
3025 return 65534;
3026 else
3027 return uid;
3028}
3029
3030static inline int high2lowgid(int gid)
3031{
3032 if (gid > 65535)
3033 return 65534;
3034 else
3035 return gid;
3036}
3037
3038static inline int low2highuid(int uid)
3039{
3040 if ((int16_t)uid == -1)
3041 return -1;
3042 else
3043 return uid;
3044}
3045
3046static inline int low2highgid(int gid)
3047{
3048 if ((int16_t)gid == -1)
3049 return -1;
3050 else
3051 return gid;
3052}
3053
3054#endif /* USE_UID16 */
1b6b029e 3055
31e31b8a
FB		 3056void syscall_init(void)
3057{
2ab83ea7
FB		 3058 IOCTLEntry *ie;
3059 const argtype *arg_type;
3060 int size;
b92c47c1 3061 int i;
2ab83ea7 3062
5fafdf24
TS		 3063#define STRUCT(name, list...) thunk_register_struct(STRUCT_ ## name, #name, struct_ ## name ## _def);
3064#define STRUCT_SPECIAL(name) thunk_register_struct_direct(STRUCT_ ## name, #name, &struct_ ## name ## _def);
31e31b8a
FB		 3065#include "syscall_types.h"
3066#undef STRUCT
3067#undef STRUCT_SPECIAL
2ab83ea7
FB		 3068
3069 /* we patch the ioctl size if necessary. We rely on the fact that
3070 no ioctl has all the bits at '1' in the size field */
3071 ie = ioctl_entries;
3072 while (ie->target_cmd != 0) {
3073 if (((ie->target_cmd >> TARGET_IOC_SIZESHIFT) & TARGET_IOC_SIZEMASK) ==
3074 TARGET_IOC_SIZEMASK) {
3075 arg_type = ie->arg_type;
3076 if (arg_type[0] != TYPE_PTR) {
5fafdf24 3077 fprintf(stderr, "cannot patch size for ioctl 0x%x\n",
2ab83ea7
FB		 3078 ie->target_cmd);
3079 exit(1);
3080 }
3081 arg_type++;
3082 size = thunk_type_size(arg_type, 0);
5fafdf24 3083 ie->target_cmd = (ie->target_cmd &
2ab83ea7
FB		 3084 ~(TARGET_IOC_SIZEMASK << TARGET_IOC_SIZESHIFT)) |
3085 (size << TARGET_IOC_SIZESHIFT);
3086 }
b92c47c1
TS		 3087
3088 /* Build target_to_host_errno_table[] table from
3089 * host_to_target_errno_table[]. */
3090 for (i=0; i < ERRNO_TABLE_SIZE; i++)
3091 target_to_host_errno_table[host_to_target_errno_table[i]] = i;
3092
2ab83ea7 3093 /* automatic consistency check if same arch */
872ea0c0
AZ		 3094#if (defined(__i386__) && defined(TARGET_I386) && defined(TARGET_ABI32)) || \
3095 (defined(__x86_64__) && defined(TARGET_X86_64))
3096 if (unlikely(ie->target_cmd != ie->host_cmd)) {
3097 fprintf(stderr, "ERROR: ioctl(%s): target=0x%x host=0x%x\n",
3098 ie->name, ie->target_cmd, ie->host_cmd);
2ab83ea7
FB		 3099 }
3100#endif
3101 ie++;
3102 }
31e31b8a 3103}
c573ff67 3104
992f48a0 3105#if TARGET_ABI_BITS == 32
ce4defa0
PB		 3106static inline uint64_t target_offset64(uint32_t word0, uint32_t word1)
3107{
af325d36 3108#ifdef TARGET_WORDS_BIGENDIAN
ce4defa0
PB		 3109 return ((uint64_t)word0 << 32) | word1;
3110#else
3111 return ((uint64_t)word1 << 32) | word0;
3112#endif
3113}
992f48a0 3114#else /* TARGET_ABI_BITS == 32 */
32407103
JM		 3115static inline uint64_t target_offset64(uint64_t word0, uint64_t word1)
3116{
3117 return word0;
3118}
992f48a0 3119#endif /* TARGET_ABI_BITS != 32 */
ce4defa0
PB		 3120
3121#ifdef TARGET_NR_truncate64
992f48a0
BS		 3122static inline abi_long target_truncate64(void *cpu_env, const char *arg1,
3123 abi_long arg2,
3124 abi_long arg3,
3125 abi_long arg4)
ce4defa0
PB		 3126{
3127#ifdef TARGET_ARM
3128 if (((CPUARMState *)cpu_env)->eabi)
3129 {
3130 arg2 = arg3;
3131 arg3 = arg4;
3132 }
3133#endif
3134 return get_errno(truncate64(arg1, target_offset64(arg2, arg3)));
3135}
3136#endif
3137
3138#ifdef TARGET_NR_ftruncate64
992f48a0
BS		 3139static inline abi_long target_ftruncate64(void *cpu_env, abi_long arg1,
3140 abi_long arg2,
3141 abi_long arg3,
3142 abi_long arg4)
ce4defa0
PB		 3143{
3144#ifdef TARGET_ARM
3145 if (((CPUARMState *)cpu_env)->eabi)
3146 {
3147 arg2 = arg3;
3148 arg3 = arg4;
3149 }
3150#endif
3151 return get_errno(ftruncate64(arg1, target_offset64(arg2, arg3)));
3152}
3153#endif
3154
579a97f7
FB		 3155static inline abi_long target_to_host_timespec(struct timespec *host_ts,
3156 abi_ulong target_addr)
53a5960a
PB		 3157{
3158 struct target_timespec *target_ts;
3159
579a97f7
FB		 3160 if (!lock_user_struct(VERIFY_READ, target_ts, target_addr, 1))
3161 return -TARGET_EFAULT;
53a5960a
PB		 3162 host_ts->tv_sec = tswapl(target_ts->tv_sec);
3163 host_ts->tv_nsec = tswapl(target_ts->tv_nsec);
3164 unlock_user_struct(target_ts, target_addr, 0);
b255bfa8 3165 return 0;
53a5960a
PB		 3166}
3167
579a97f7
FB		 3168static inline abi_long host_to_target_timespec(abi_ulong target_addr,
3169 struct timespec *host_ts)
53a5960a
PB		 3170{
3171 struct target_timespec *target_ts;
3172
579a97f7
FB		 3173 if (!lock_user_struct(VERIFY_WRITE, target_ts, target_addr, 0))
3174 return -TARGET_EFAULT;
53a5960a
PB		 3175 target_ts->tv_sec = tswapl(host_ts->tv_sec);
3176 target_ts->tv_nsec = tswapl(host_ts->tv_nsec);
3177 unlock_user_struct(target_ts, target_addr, 1);
b255bfa8 3178 return 0;
53a5960a
PB		 3179}
3180
6a24a778
AZ		 3181#ifdef TARGET_NR_stat64
3182static inline abi_long host_to_target_stat64(void *cpu_env,
3183 abi_ulong target_addr,
3184 struct stat *host_st)
3185{
3186#ifdef TARGET_ARM
3187 if (((CPUARMState *)cpu_env)->eabi) {
3188 struct target_eabi_stat64 *target_st;
3189
3190 if (!lock_user_struct(VERIFY_WRITE, target_st, target_addr, 0))
3191 return -TARGET_EFAULT;
3192 memset(target_st, 0, sizeof(struct target_eabi_stat64));
3193 __put_user(host_st->st_dev, &target_st->st_dev);
3194 __put_user(host_st->st_ino, &target_st->st_ino);
3195#ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
3196 __put_user(host_st->st_ino, &target_st->__st_ino);
3197#endif
3198 __put_user(host_st->st_mode, &target_st->st_mode);
3199 __put_user(host_st->st_nlink, &target_st->st_nlink);
3200 __put_user(host_st->st_uid, &target_st->st_uid);
3201 __put_user(host_st->st_gid, &target_st->st_gid);
3202 __put_user(host_st->st_rdev, &target_st->st_rdev);
3203 __put_user(host_st->st_size, &target_st->st_size);
3204 __put_user(host_st->st_blksize, &target_st->st_blksize);
3205 __put_user(host_st->st_blocks, &target_st->st_blocks);
3206 __put_user(host_st->st_atime, &target_st->target_st_atime);
3207 __put_user(host_st->st_mtime, &target_st->target_st_mtime);
3208 __put_user(host_st->st_ctime, &target_st->target_st_ctime);
3209 unlock_user_struct(target_st, target_addr, 1);
3210 } else
3211#endif
3212 {
3213 struct target_stat64 *target_st;
3214
3215 if (!lock_user_struct(VERIFY_WRITE, target_st, target_addr, 0))
3216 return -TARGET_EFAULT;
3217 memset(target_st, 0, sizeof(struct target_stat64));
3218 __put_user(host_st->st_dev, &target_st->st_dev);
3219 __put_user(host_st->st_ino, &target_st->st_ino);
3220#ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
3221 __put_user(host_st->st_ino, &target_st->__st_ino);
3222#endif
3223 __put_user(host_st->st_mode, &target_st->st_mode);
3224 __put_user(host_st->st_nlink, &target_st->st_nlink);
3225 __put_user(host_st->st_uid, &target_st->st_uid);
3226 __put_user(host_st->st_gid, &target_st->st_gid);
3227 __put_user(host_st->st_rdev, &target_st->st_rdev);
3228 /* XXX: better use of kernel struct */
3229 __put_user(host_st->st_size, &target_st->st_size);
3230 __put_user(host_st->st_blksize, &target_st->st_blksize);
3231 __put_user(host_st->st_blocks, &target_st->st_blocks);
3232 __put_user(host_st->st_atime, &target_st->target_st_atime);
3233 __put_user(host_st->st_mtime, &target_st->target_st_mtime);
3234 __put_user(host_st->st_ctime, &target_st->target_st_ctime);
3235 unlock_user_struct(target_st, target_addr, 1);
3236 }
3237
3238 return 0;
3239}
3240#endif
3241
bd0c5661
PB		 3242#if defined(USE_NPTL)
3243/* ??? Using host futex calls even when target atomic operations
3244 are not really atomic probably breaks things. However implementing
3245 futexes locally would make futexes shared between multiple processes
3246 tricky. However they're probably useless because guest atomic
3247 operations won't work either. */
8fcd3692
BS		 3248static int do_futex(target_ulong uaddr, int op, int val, target_ulong timeout,
3249 target_ulong uaddr2, int val3)
bd0c5661
PB		 3250{
3251 struct timespec ts, *pts;
3252
3253 /* ??? We assume FUTEX_* constants are the same on both host
3254 and target. */
3255 switch (op) {
3256 case FUTEX_WAIT:
3257 if (timeout) {
3258 pts = &ts;
3259 target_to_host_timespec(pts, timeout);
3260 } else {
3261 pts = NULL;
3262 }
3263 return get_errno(sys_futex(g2h(uaddr), FUTEX_WAIT, tswap32(val),
3264 pts, NULL, 0));
3265 case FUTEX_WAKE:
3266 return get_errno(sys_futex(g2h(uaddr), FUTEX_WAKE, val, NULL, NULL, 0));
3267 case FUTEX_FD:
3268 return get_errno(sys_futex(g2h(uaddr), FUTEX_FD, val, NULL, NULL, 0));
3269 case FUTEX_REQUEUE:
3270 return get_errno(sys_futex(g2h(uaddr), FUTEX_REQUEUE, val,
3271 NULL, g2h(uaddr2), 0));
3272 case FUTEX_CMP_REQUEUE:
3273 return get_errno(sys_futex(g2h(uaddr), FUTEX_CMP_REQUEUE, val,
3274 NULL, g2h(uaddr2), tswap32(val3)));
3275 default:
3276 return -TARGET_ENOSYS;
3277 }
3278}
3279#endif
3280
a745ec6d
PB		 3281int get_osversion(void)
3282{
3283 static int osversion;
3284 struct new_utsname buf;
3285 const char *s;
3286 int i, n, tmp;
3287 if (osversion)
3288 return osversion;
3289 if (qemu_uname_release && *qemu_uname_release) {
3290 s = qemu_uname_release;
3291 } else {
3292 if (sys_uname(&buf))
3293 return 0;
3294 s = buf.release;
3295 }
3296 tmp = 0;
3297 for (i = 0; i < 3; i++) {
3298 n = 0;
3299 while (*s >= '0' && *s <= '9') {
3300 n *= 10;
3301 n += *s - '0';
3302 s++;
3303 }
3304 tmp = (tmp << 8) + n;
3305 if (*s == '.')
3306 s++;
3307 }
3308 osversion = tmp;
3309 return osversion;
3310}
3311
0da46a6e
TS		 3312/* do_syscall() should always have a single exit point at the end so
3313 that actions, such as logging of syscall results, can be performed.
3314 All errnos that do_syscall() returns must be -TARGET_<errcode>. */
992f48a0
BS		 3315abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
3316 abi_long arg2, abi_long arg3, abi_long arg4,
3317 abi_long arg5, abi_long arg6)
31e31b8a 3318{
992f48a0 3319 abi_long ret;
31e31b8a 3320 struct stat st;
56c8f68f 3321 struct statfs stfs;
53a5960a 3322 void *p;
3b46e624 3323
72f03900 3324#ifdef DEBUG
c573ff67 3325 gemu_log("syscall %d", num);
72f03900 3326#endif
b92c47c1
TS		 3327 if(do_strace)
3328 print_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
3329
31e31b8a
FB		 3330 switch(num) {
3331 case TARGET_NR_exit:
7d13299d
FB		 3332#ifdef HAVE_GPROF
3333 _mcleanup();
3334#endif
e9009676 3335 gdb_exit(cpu_env, arg1);
1b6b029e 3336 /* XXX: should free thread stack and CPU env */
31e31b8a
FB		 3337 _exit(arg1);
3338 ret = 0; /* avoid warning */
3339 break;
3340 case TARGET_NR_read:
579a97f7
FB		 3341 if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
3342 goto efault;
53a5960a
PB		 3343 ret = get_errno(read(arg1, p, arg3));
3344 unlock_user(p, arg2, ret);
31e31b8a
FB		 3345 break;
3346 case TARGET_NR_write:
579a97f7
FB		 3347 if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
3348 goto efault;
53a5960a
PB		 3349 ret = get_errno(write(arg1, p, arg3));
3350 unlock_user(p, arg2, 0);
31e31b8a
FB		 3351 break;
3352 case TARGET_NR_open:
2f619698
FB		 3353 if (!(p = lock_user_string(arg1)))
3354 goto efault;
53a5960a 3355 ret = get_errno(open(path(p),
ffa65c3b
FB		 3356 target_to_host_bitmask(arg2, fcntl_flags_tbl),
3357 arg3));
53a5960a 3358 unlock_user(p, arg1, 0);
31e31b8a 3359 break;
82424832
TS		 3360#if defined(TARGET_NR_openat) && defined(__NR_openat)
3361 case TARGET_NR_openat:
579a97f7
FB		 3362 if (!(p = lock_user_string(arg2)))
3363 goto efault;
3364 ret = get_errno(sys_openat(arg1,
3365 path(p),
3366 target_to_host_bitmask(arg3, fcntl_flags_tbl),
3367 arg4));
3368 unlock_user(p, arg2, 0);
82424832
TS		 3369 break;
3370#endif
31e31b8a
FB		 3371 case TARGET_NR_close:
3372 ret = get_errno(close(arg1));
3373 break;
3374 case TARGET_NR_brk:
53a5960a 3375 ret = do_brk(arg1);
31e31b8a
FB		 3376 break;
3377 case TARGET_NR_fork:
d865bab5 3378 ret = get_errno(do_fork(cpu_env, SIGCHLD, 0, 0, 0, 0));
31e31b8a 3379 break;
e5febef5 3380#ifdef TARGET_NR_waitpid
31e31b8a
FB		 3381 case TARGET_NR_waitpid:
3382 {
53a5960a
PB		 3383 int status;
3384 ret = get_errno(waitpid(arg1, &status, arg3));
2f619698
FB		 3385 if (!is_error(ret) && arg2
3386 && put_user_s32(status, arg2))
3387 goto efault;
31e31b8a
FB		 3388 }
3389 break;
e5febef5 3390#endif
f0cbb613
PB		 3391#ifdef TARGET_NR_waitid
3392 case TARGET_NR_waitid:
3393 {
3394 siginfo_t info;
3395 info.si_pid = 0;
3396 ret = get_errno(waitid(arg1, arg2, &info, arg4));
3397 if (!is_error(ret) && arg3 && info.si_pid != 0) {
3398 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_siginfo_t), 0)))
3399 goto efault;
3400 host_to_target_siginfo(p, &info);
3401 unlock_user(p, arg3, sizeof(target_siginfo_t));
3402 }
3403 }
3404 break;
3405#endif
7a3148a9 3406#ifdef TARGET_NR_creat /* not on alpha */
31e31b8a 3407 case TARGET_NR_creat:
579a97f7
FB		 3408 if (!(p = lock_user_string(arg1)))
3409 goto efault;
53a5960a
PB		 3410 ret = get_errno(creat(p, arg2));
3411 unlock_user(p, arg1, 0);
31e31b8a 3412 break;
7a3148a9 3413#endif
31e31b8a 3414 case TARGET_NR_link:
53a5960a
PB		 3415 {
3416 void * p2;
3417 p = lock_user_string(arg1);
3418 p2 = lock_user_string(arg2);
579a97f7
FB		 3419 if (!p || !p2)
3420 ret = -TARGET_EFAULT;
3421 else
3422 ret = get_errno(link(p, p2));
53a5960a
PB		 3423 unlock_user(p2, arg2, 0);
3424 unlock_user(p, arg1, 0);
3425 }
31e31b8a 3426 break;
64f0ce4c
TS		 3427#if defined(TARGET_NR_linkat) && defined(__NR_linkat)
3428 case TARGET_NR_linkat:
64f0ce4c
TS		 3429 {
3430 void * p2 = NULL;
579a97f7
FB		 3431 if (!arg2 || !arg4)
3432 goto efault;
64f0ce4c
TS		 3433 p = lock_user_string(arg2);
3434 p2 = lock_user_string(arg4);
579a97f7 3435 if (!p || !p2)
0da46a6e 3436 ret = -TARGET_EFAULT;
64f0ce4c
TS		 3437 else
3438 ret = get_errno(sys_linkat(arg1, p, arg3, p2, arg5));
579a97f7
FB		 3439 unlock_user(p, arg2, 0);
3440 unlock_user(p2, arg4, 0);
64f0ce4c
TS		 3441 }
3442 break;
3443#endif
31e31b8a 3444 case TARGET_NR_unlink:
579a97f7
FB		 3445 if (!(p = lock_user_string(arg1)))
3446 goto efault;
53a5960a
PB		 3447 ret = get_errno(unlink(p));
3448 unlock_user(p, arg1, 0);
31e31b8a 3449 break;
8170f56b
TS		 3450#if defined(TARGET_NR_unlinkat) && defined(__NR_unlinkat)
3451 case TARGET_NR_unlinkat:
579a97f7
FB		 3452 if (!(p = lock_user_string(arg2)))
3453 goto efault;
3454 ret = get_errno(sys_unlinkat(arg1, p, arg3));
3455 unlock_user(p, arg2, 0);
ed494d87 3456 break;
b7d35e65 3457#endif
31e31b8a 3458 case TARGET_NR_execve:
7854b056
FB		 3459 {
3460 char **argp, **envp;
f7341ff4 3461 int argc, envc;
992f48a0
BS		 3462 abi_ulong gp;
3463 abi_ulong guest_argp;
3464 abi_ulong guest_envp;
3465 abi_ulong addr;
7854b056
FB		 3466 char **q;
3467
f7341ff4 3468 argc = 0;
53a5960a 3469 guest_argp = arg2;
da94d263 3470 for (gp = guest_argp; gp; gp += sizeof(abi_ulong)) {
03aa1976 3471 if (get_user_ual(addr, gp))
2f619698 3472 goto efault;
03aa1976 3473 if (!addr)
2f619698 3474 break;
7854b056 3475 argc++;
2f619698 3476 }
f7341ff4 3477 envc = 0;
53a5960a 3478 guest_envp = arg3;
da94d263 3479 for (gp = guest_envp; gp; gp += sizeof(abi_ulong)) {
03aa1976 3480 if (get_user_ual(addr, gp))
2f619698 3481 goto efault;
03aa1976 3482 if (!addr)
2f619698 3483 break;
7854b056 3484 envc++;
2f619698 3485 }
7854b056 3486
f7341ff4
FB		 3487 argp = alloca((argc + 1) * sizeof(void *));
3488 envp = alloca((envc + 1) * sizeof(void *));
7854b056 3489
da94d263 3490 for (gp = guest_argp, q = argp; gp;
992f48a0 3491 gp += sizeof(abi_ulong), q++) {
2f619698
FB		 3492 if (get_user_ual(addr, gp))
3493 goto execve_efault;
53a5960a
PB		 3494 if (!addr)
3495 break;
2f619698
FB		 3496 if (!(*q = lock_user_string(addr)))
3497 goto execve_efault;
53a5960a 3498 }
f7341ff4
FB		 3499 *q = NULL;
3500
da94d263 3501 for (gp = guest_envp, q = envp; gp;
992f48a0 3502 gp += sizeof(abi_ulong), q++) {
2f619698
FB		 3503 if (get_user_ual(addr, gp))
3504 goto execve_efault;
53a5960a
PB		 3505 if (!addr)
3506 break;
2f619698
FB		 3507 if (!(*q = lock_user_string(addr)))
3508 goto execve_efault;
53a5960a 3509 }
f7341ff4 3510 *q = NULL;
7854b056 3511
2f619698
FB		 3512 if (!(p = lock_user_string(arg1)))
3513 goto execve_efault;
53a5960a
PB		 3514 ret = get_errno(execve(p, argp, envp));
3515 unlock_user(p, arg1, 0);
3516
2f619698
FB		 3517 goto execve_end;
3518
3519 execve_efault:
3520 ret = -TARGET_EFAULT;
3521
3522 execve_end:
53a5960a 3523 for (gp = guest_argp, q = argp; *q;
992f48a0 3524 gp += sizeof(abi_ulong), q++) {
2f619698
FB		 3525 if (get_user_ual(addr, gp)
3526 || !addr)
3527 break;
53a5960a
PB		 3528 unlock_user(*q, addr, 0);
3529 }
3530 for (gp = guest_envp, q = envp; *q;
992f48a0 3531 gp += sizeof(abi_ulong), q++) {
2f619698
FB		 3532 if (get_user_ual(addr, gp)
3533 || !addr)
3534 break;
53a5960a
PB		 3535 unlock_user(*q, addr, 0);
3536 }
7854b056 3537 }
31e31b8a
FB		 3538 break;
3539 case TARGET_NR_chdir:
579a97f7
FB		 3540 if (!(p = lock_user_string(arg1)))
3541 goto efault;
53a5960a
PB		 3542 ret = get_errno(chdir(p));
3543 unlock_user(p, arg1, 0);
31e31b8a 3544 break;
a315a145 3545#ifdef TARGET_NR_time
31e31b8a
FB		 3546 case TARGET_NR_time:
3547 {
53a5960a
PB		 3548 time_t host_time;
3549 ret = get_errno(time(&host_time));
2f619698
FB		 3550 if (!is_error(ret)
3551 && arg1
3552 && put_user_sal(host_time, arg1))
3553 goto efault;
31e31b8a
FB		 3554 }
3555 break;
a315a145 3556#endif
31e31b8a 3557 case TARGET_NR_mknod:
579a97f7
FB		 3558 if (!(p = lock_user_string(arg1)))
3559 goto efault;
53a5960a
PB		 3560 ret = get_errno(mknod(p, arg2, arg3));
3561 unlock_user(p, arg1, 0);
31e31b8a 3562 break;
75ac37a0
TS		 3563#if defined(TARGET_NR_mknodat) && defined(__NR_mknodat)
3564 case TARGET_NR_mknodat:
579a97f7
FB		 3565 if (!(p = lock_user_string(arg2)))
3566 goto efault;
3567 ret = get_errno(sys_mknodat(arg1, p, arg3, arg4));
3568 unlock_user(p, arg2, 0);
75ac37a0
TS		 3569 break;
3570#endif
31e31b8a 3571 case TARGET_NR_chmod:
579a97f7
FB		 3572 if (!(p = lock_user_string(arg1)))
3573 goto efault;
53a5960a
PB		 3574 ret = get_errno(chmod(p, arg2));
3575 unlock_user(p, arg1, 0);
31e31b8a 3576 break;
ebc05488 3577#ifdef TARGET_NR_break
31e31b8a
FB		 3578 case TARGET_NR_break:
3579 goto unimplemented;
ebc05488
FB		 3580#endif
3581#ifdef TARGET_NR_oldstat
31e31b8a
FB		 3582 case TARGET_NR_oldstat:
3583 goto unimplemented;
ebc05488 3584#endif
31e31b8a
FB		 3585 case TARGET_NR_lseek:
3586 ret = get_errno(lseek(arg1, arg2, arg3));
3587 break;
7a3148a9
JM		 3588#ifdef TARGET_NR_getxpid
3589 case TARGET_NR_getxpid:
3590#else
31e31b8a 3591 case TARGET_NR_getpid:
7a3148a9 3592#endif
31e31b8a
FB		 3593 ret = get_errno(getpid());
3594 break;
3595 case TARGET_NR_mount:
80265918
TS		 3596 {
3597 /* need to look at the data field */
3598 void *p2, *p3;
3599 p = lock_user_string(arg1);
3600 p2 = lock_user_string(arg2);
3601 p3 = lock_user_string(arg3);
579a97f7
FB		 3602 if (!p || !p2 || !p3)
3603 ret = -TARGET_EFAULT;
3604 else
3605 /* FIXME - arg5 should be locked, but it isn't clear how to
3606 * do that since it's not guaranteed to be a NULL-terminated
3607 * string.
3608 */
3609 ret = get_errno(mount(p, p2, p3, (unsigned long)arg4, g2h(arg5)));
3610 unlock_user(p, arg1, 0);
3611 unlock_user(p2, arg2, 0);
3612 unlock_user(p3, arg3, 0);
80265918
TS		 3613 break;
3614 }
e5febef5 3615#ifdef TARGET_NR_umount
31e31b8a 3616 case TARGET_NR_umount:
579a97f7
FB		 3617 if (!(p = lock_user_string(arg1)))
3618 goto efault;
53a5960a
PB		 3619 ret = get_errno(umount(p));
3620 unlock_user(p, arg1, 0);
31e31b8a 3621 break;
e5febef5 3622#endif
7a3148a9 3623#ifdef TARGET_NR_stime /* not on alpha */
31e31b8a
FB		 3624 case TARGET_NR_stime:
3625 {
53a5960a 3626 time_t host_time;
2f619698
FB		 3627 if (get_user_sal(host_time, arg1))
3628 goto efault;
53a5960a 3629 ret = get_errno(stime(&host_time));
31e31b8a
FB		 3630 }
3631 break;
7a3148a9 3632#endif
31e31b8a
FB		 3633 case TARGET_NR_ptrace:
3634 goto unimplemented;
7a3148a9 3635#ifdef TARGET_NR_alarm /* not on alpha */
31e31b8a
FB		 3636 case TARGET_NR_alarm:
3637 ret = alarm(arg1);
3638 break;
7a3148a9 3639#endif
ebc05488 3640#ifdef TARGET_NR_oldfstat
31e31b8a
FB		 3641 case TARGET_NR_oldfstat:
3642 goto unimplemented;
ebc05488 3643#endif
7a3148a9 3644#ifdef TARGET_NR_pause /* not on alpha */
31e31b8a
FB		 3645 case TARGET_NR_pause:
3646 ret = get_errno(pause());
3647 break;
7a3148a9 3648#endif
e5febef5 3649#ifdef TARGET_NR_utime
31e31b8a 3650 case TARGET_NR_utime:
ebc05488 3651 {
53a5960a
PB		 3652 struct utimbuf tbuf, *host_tbuf;
3653 struct target_utimbuf *target_tbuf;
3654 if (arg2) {
579a97f7
FB		 3655 if (!lock_user_struct(VERIFY_READ, target_tbuf, arg2, 1))
3656 goto efault;
53a5960a
PB		 3657 tbuf.actime = tswapl(target_tbuf->actime);
3658 tbuf.modtime = tswapl(target_tbuf->modtime);
3659 unlock_user_struct(target_tbuf, arg2, 0);
3660 host_tbuf = &tbuf;
f72e8ff4 3661 } else {
53a5960a 3662 host_tbuf = NULL;
f72e8ff4 3663 }
579a97f7
FB		 3664 if (!(p = lock_user_string(arg1)))
3665 goto efault;
53a5960a
PB		 3666 ret = get_errno(utime(p, host_tbuf));
3667 unlock_user(p, arg1, 0);
ebc05488
FB		 3668 }
3669 break;
e5febef5 3670#endif
978a66ff
FB		 3671 case TARGET_NR_utimes:
3672 {
978a66ff 3673 struct timeval *tvp, tv[2];
53a5960a 3674 if (arg2) {
788f5ec4
TS		 3675 if (copy_from_user_timeval(&tv[0], arg2)
3676 || copy_from_user_timeval(&tv[1],
3677 arg2 + sizeof(struct target_timeval)))
3678 goto efault;
978a66ff
FB		 3679 tvp = tv;
3680 } else {
3681 tvp = NULL;
3682 }
579a97f7
FB		 3683 if (!(p = lock_user_string(arg1)))
3684 goto efault;
53a5960a
PB		 3685 ret = get_errno(utimes(p, tvp));
3686 unlock_user(p, arg1, 0);
978a66ff
FB		 3687 }
3688 break;
ac8a6556
AZ		 3689#if defined(TARGET_NR_futimesat) && defined(__NR_futimesat)
3690 case TARGET_NR_futimesat:
3691 {
3692 struct timeval *tvp, tv[2];
3693 if (arg3) {
3694 if (copy_from_user_timeval(&tv[0], arg3)
3695 || copy_from_user_timeval(&tv[1],
3696 arg3 + sizeof(struct target_timeval)))
3697 goto efault;
3698 tvp = tv;
3699 } else {
3700 tvp = NULL;
3701 }
3702 if (!(p = lock_user_string(arg2)))
3703 goto efault;
3704 ret = get_errno(sys_futimesat(arg1, path(p), tvp));
3705 unlock_user(p, arg2, 0);
3706 }
3707 break;
3708#endif
ebc05488 3709#ifdef TARGET_NR_stty
31e31b8a
FB		 3710 case TARGET_NR_stty:
3711 goto unimplemented;
ebc05488
FB		 3712#endif
3713#ifdef TARGET_NR_gtty
31e31b8a
FB		 3714 case TARGET_NR_gtty:
3715 goto unimplemented;
ebc05488 3716#endif
31e31b8a 3717 case TARGET_NR_access:
579a97f7
FB		 3718 if (!(p = lock_user_string(arg1)))
3719 goto efault;
53a5960a
PB		 3720 ret = get_errno(access(p, arg2));
3721 unlock_user(p, arg1, 0);
31e31b8a 3722 break;
92a34c10
TS		 3723#if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
3724 case TARGET_NR_faccessat:
579a97f7
FB		 3725 if (!(p = lock_user_string(arg2)))
3726 goto efault;
3727 ret = get_errno(sys_faccessat(arg1, p, arg3, arg4));
3728 unlock_user(p, arg2, 0);
92a34c10
TS		 3729 break;
3730#endif
7a3148a9 3731#ifdef TARGET_NR_nice /* not on alpha */
31e31b8a
FB		 3732 case TARGET_NR_nice:
3733 ret = get_errno(nice(arg1));
3734 break;
7a3148a9 3735#endif
ebc05488 3736#ifdef TARGET_NR_ftime
31e31b8a
FB		 3737 case TARGET_NR_ftime:
3738 goto unimplemented;
ebc05488 3739#endif
31e31b8a 3740 case TARGET_NR_sync:
04369ff2
FB		 3741 sync();
3742 ret = 0;
31e31b8a
FB		 3743 break;
3744 case TARGET_NR_kill:
4cb05961 3745 ret = get_errno(kill(arg1, target_to_host_signal(arg2)));
31e31b8a
FB		 3746 break;
3747 case TARGET_NR_rename:
53a5960a
PB		 3748 {
3749 void *p2;
3750 p = lock_user_string(arg1);
3751 p2 = lock_user_string(arg2);
579a97f7
FB		 3752 if (!p || !p2)
3753 ret = -TARGET_EFAULT;
3754 else
3755 ret = get_errno(rename(p, p2));
53a5960a
PB		 3756 unlock_user(p2, arg2, 0);
3757 unlock_user(p, arg1, 0);
3758 }
31e31b8a 3759 break;
722183f6
TS		 3760#if defined(TARGET_NR_renameat) && defined(__NR_renameat)
3761 case TARGET_NR_renameat:
722183f6 3762 {
579a97f7 3763 void *p2;
722183f6
TS		 3764 p = lock_user_string(arg2);
3765 p2 = lock_user_string(arg4);
579a97f7 3766 if (!p || !p2)
0da46a6e 3767 ret = -TARGET_EFAULT;
722183f6
TS		 3768 else
3769 ret = get_errno(sys_renameat(arg1, p, arg3, p2));
579a97f7
FB		 3770 unlock_user(p2, arg4, 0);
3771 unlock_user(p, arg2, 0);
722183f6
TS		 3772 }
3773 break;
3774#endif
31e31b8a 3775 case TARGET_NR_mkdir:
579a97f7
FB		 3776 if (!(p = lock_user_string(arg1)))
3777 goto efault;
53a5960a
PB		 3778 ret = get_errno(mkdir(p, arg2));
3779 unlock_user(p, arg1, 0);
31e31b8a 3780 break;
4472ad0d
TS		 3781#if defined(TARGET_NR_mkdirat) && defined(__NR_mkdirat)
3782 case TARGET_NR_mkdirat:
579a97f7
FB		 3783 if (!(p = lock_user_string(arg2)))
3784 goto efault;
3785 ret = get_errno(sys_mkdirat(arg1, p, arg3));
3786 unlock_user(p, arg2, 0);
4472ad0d
TS		 3787 break;
3788#endif
31e31b8a 3789 case TARGET_NR_rmdir:
579a97f7
FB		 3790 if (!(p = lock_user_string(arg1)))
3791 goto efault;
53a5960a
PB		 3792 ret = get_errno(rmdir(p));
3793 unlock_user(p, arg1, 0);
31e31b8a
FB		 3794 break;
3795 case TARGET_NR_dup:
3796 ret = get_errno(dup(arg1));
3797 break;
3798 case TARGET_NR_pipe:
3799 {
53a5960a
PB		 3800 int host_pipe[2];
3801 ret = get_errno(pipe(host_pipe));
31e31b8a 3802 if (!is_error(ret)) {
c12ab05c 3803#if defined(TARGET_MIPS)
ead9360e 3804 CPUMIPSState *env = (CPUMIPSState*)cpu_env;
b5dc7732 3805 env->active_tc.gpr[3] = host_pipe[1];
c12ab05c 3806 ret = host_pipe[0];
b5eff355
AJ		 3807#elif defined(TARGET_SH4)
3808 ((CPUSH4State*)cpu_env)->gregs[1] = host_pipe[1];
3809 ret = host_pipe[0];
c12ab05c 3810#else
2f619698
FB		 3811 if (put_user_s32(host_pipe[0], arg1)
3812 || put_user_s32(host_pipe[1], arg1 + sizeof(host_pipe[0])))
3813 goto efault;
c12ab05c 3814#endif
31e31b8a
FB		 3815 }
3816 }
3817 break;
3818 case TARGET_NR_times:
32f36bce 3819 {
53a5960a 3820 struct target_tms *tmsp;
32f36bce
FB		 3821 struct tms tms;
3822 ret = get_errno(times(&tms));
53a5960a 3823 if (arg1) {
579a97f7
FB		 3824 tmsp = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_tms), 0);
3825 if (!tmsp)
3826 goto efault;
c596ed17
FB		 3827 tmsp->tms_utime = tswapl(host_to_target_clock_t(tms.tms_utime));
3828 tmsp->tms_stime = tswapl(host_to_target_clock_t(tms.tms_stime));
3829 tmsp->tms_cutime = tswapl(host_to_target_clock_t(tms.tms_cutime));
3830 tmsp->tms_cstime = tswapl(host_to_target_clock_t(tms.tms_cstime));
32f36bce 3831 }
c596ed17
FB		 3832 if (!is_error(ret))
3833 ret = host_to_target_clock_t(ret);
32f36bce
FB		 3834 }
3835 break;
ebc05488 3836#ifdef TARGET_NR_prof
31e31b8a
FB		 3837 case TARGET_NR_prof:
3838 goto unimplemented;
ebc05488 3839#endif
e5febef5 3840#ifdef TARGET_NR_signal
31e31b8a
FB		 3841 case TARGET_NR_signal:
3842 goto unimplemented;
e5febef5 3843#endif
31e31b8a 3844 case TARGET_NR_acct:
579a97f7
FB		 3845 if (!(p = lock_user_string(arg1)))
3846 goto efault;
24836689
PB		 3847 ret = get_errno(acct(path(p)));
3848 unlock_user(p, arg1, 0);
3849 break;
7a3148a9 3850#ifdef TARGET_NR_umount2 /* not on alpha */
31e31b8a 3851 case TARGET_NR_umount2:
579a97f7
FB		 3852 if (!(p = lock_user_string(arg1)))
3853 goto efault;
53a5960a
PB		 3854 ret = get_errno(umount2(p, arg2));
3855 unlock_user(p, arg1, 0);
31e31b8a 3856 break;
7a3148a9 3857#endif
ebc05488 3858#ifdef TARGET_NR_lock
31e31b8a
FB		 3859 case TARGET_NR_lock:
3860 goto unimplemented;
ebc05488 3861#endif
31e31b8a
FB		 3862 case TARGET_NR_ioctl:
3863 ret = do_ioctl(arg1, arg2, arg3);
3864 break;
3865 case TARGET_NR_fcntl:
9ee1fa2c 3866 ret = do_fcntl(arg1, arg2, arg3);
31e31b8a 3867 break;
ebc05488 3868#ifdef TARGET_NR_mpx
31e31b8a
FB		 3869 case TARGET_NR_mpx:
3870 goto unimplemented;
ebc05488 3871#endif
31e31b8a
FB		 3872 case TARGET_NR_setpgid:
3873 ret = get_errno(setpgid(arg1, arg2));
3874 break;
ebc05488 3875#ifdef TARGET_NR_ulimit
31e31b8a
FB		 3876 case TARGET_NR_ulimit:
3877 goto unimplemented;
ebc05488
FB		 3878#endif
3879#ifdef TARGET_NR_oldolduname
31e31b8a
FB		 3880 case TARGET_NR_oldolduname:
3881 goto unimplemented;
ebc05488 3882#endif
31e31b8a
FB		 3883 case TARGET_NR_umask:
3884 ret = get_errno(umask(arg1));
3885 break;
3886 case TARGET_NR_chroot:
579a97f7
FB		 3887 if (!(p = lock_user_string(arg1)))
3888 goto efault;
53a5960a
PB		 3889 ret = get_errno(chroot(p));
3890 unlock_user(p, arg1, 0);
31e31b8a
FB		 3891 break;
3892 case TARGET_NR_ustat:
3893 goto unimplemented;
3894 case TARGET_NR_dup2:
3895 ret = get_errno(dup2(arg1, arg2));
3896 break;
7a3148a9 3897#ifdef TARGET_NR_getppid /* not on alpha */
31e31b8a
FB		 3898 case TARGET_NR_getppid:
3899 ret = get_errno(getppid());
3900 break;
7a3148a9 3901#endif
31e31b8a
FB		 3902 case TARGET_NR_getpgrp:
3903 ret = get_errno(getpgrp());
3904 break;
3905 case TARGET_NR_setsid:
3906 ret = get_errno(setsid());
3907 break;
e5febef5 3908#ifdef TARGET_NR_sigaction
31e31b8a 3909 case TARGET_NR_sigaction:
31e31b8a 3910 {
388bb21a 3911#if !defined(TARGET_MIPS)
53a5960a 3912 struct target_old_sigaction *old_act;
66fb9763 3913 struct target_sigaction act, oact, *pact;
53a5960a 3914 if (arg2) {
579a97f7
FB		 3915 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
3916 goto efault;
66fb9763
FB		 3917 act._sa_handler = old_act->_sa_handler;
3918 target_siginitset(&act.sa_mask, old_act->sa_mask);
3919 act.sa_flags = old_act->sa_flags;
3920 act.sa_restorer = old_act->sa_restorer;
53a5960a 3921 unlock_user_struct(old_act, arg2, 0);
66fb9763
FB		 3922 pact = &act;
3923 } else {
3924 pact = NULL;
3925 }
3926 ret = get_errno(do_sigaction(arg1, pact, &oact));
53a5960a 3927 if (!is_error(ret) && arg3) {
579a97f7
FB		 3928 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
3929 goto efault;
53a5960a
PB		 3930 old_act->_sa_handler = oact._sa_handler;
3931 old_act->sa_mask = oact.sa_mask.sig[0];
3932 old_act->sa_flags = oact.sa_flags;
3933 old_act->sa_restorer = oact.sa_restorer;
3934 unlock_user_struct(old_act, arg3, 1);
66fb9763 3935 }
388bb21a 3936#else
106ec879
FB		 3937 struct target_sigaction act, oact, *pact, *old_act;
3938
3939 if (arg2) {
579a97f7
FB		 3940 if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
3941 goto efault;
106ec879
FB		 3942 act._sa_handler = old_act->_sa_handler;
3943 target_siginitset(&act.sa_mask, old_act->sa_mask.sig[0]);
3944 act.sa_flags = old_act->sa_flags;
3945 unlock_user_struct(old_act, arg2, 0);
3946 pact = &act;
3947 } else {
3948 pact = NULL;
3949 }
3950
3951 ret = get_errno(do_sigaction(arg1, pact, &oact));
3952
3953 if (!is_error(ret) && arg3) {
579a97f7
FB		 3954 if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
3955 goto efault;
106ec879
FB		 3956 old_act->_sa_handler = oact._sa_handler;
3957 old_act->sa_flags = oact.sa_flags;
3958 old_act->sa_mask.sig[0] = oact.sa_mask.sig[0];
3959 old_act->sa_mask.sig[1] = 0;
3960 old_act->sa_mask.sig[2] = 0;
3961 old_act->sa_mask.sig[3] = 0;
3962 unlock_user_struct(old_act, arg3, 1);
3963 }
388bb21a 3964#endif
31e31b8a
FB		 3965 }
3966 break;
e5febef5 3967#endif
66fb9763 3968 case TARGET_NR_rt_sigaction:
53a5960a
PB		 3969 {
3970 struct target_sigaction *act;
3971 struct target_sigaction *oact;
3972
579a97f7
FB		 3973 if (arg2) {
3974 if (!lock_user_struct(VERIFY_READ, act, arg2, 1))
3975 goto efault;
3976 } else
53a5960a 3977 act = NULL;
579a97f7
FB		 3978 if (arg3) {
3979 if (!lock_user_struct(VERIFY_WRITE, oact, arg3, 0)) {
3980 ret = -TARGET_EFAULT;
3981 goto rt_sigaction_fail;
3982 }
3983 } else
53a5960a
PB		 3984 oact = NULL;
3985 ret = get_errno(do_sigaction(arg1, act, oact));
579a97f7
FB		 3986 rt_sigaction_fail:
3987 if (act)
53a5960a 3988 unlock_user_struct(act, arg2, 0);
579a97f7 3989 if (oact)
53a5960a
PB		 3990 unlock_user_struct(oact, arg3, 1);
3991 }
66fb9763 3992 break;
7a3148a9 3993#ifdef TARGET_NR_sgetmask /* not on alpha */
31e31b8a 3994 case TARGET_NR_sgetmask:
66fb9763
FB		 3995 {
3996 sigset_t cur_set;
992f48a0 3997 abi_ulong target_set;
66fb9763
FB		 3998 sigprocmask(0, NULL, &cur_set);
3999 host_to_target_old_sigset(&target_set, &cur_set);
4000 ret = target_set;
4001 }
4002 break;
7a3148a9
JM		 4003#endif
4004#ifdef TARGET_NR_ssetmask /* not on alpha */
31e31b8a 4005 case TARGET_NR_ssetmask:
66fb9763
FB		 4006 {
4007 sigset_t set, oset, cur_set;
992f48a0 4008 abi_ulong target_set = arg1;
66fb9763
FB		 4009 sigprocmask(0, NULL, &cur_set);
4010 target_to_host_old_sigset(&set, &target_set);
4011 sigorset(&set, &set, &cur_set);
4012 sigprocmask(SIG_SETMASK, &set, &oset);
4013 host_to_target_old_sigset(&target_set, &oset);
4014 ret = target_set;
4015 }
4016 break;
7a3148a9 4017#endif
e5febef5 4018#ifdef TARGET_NR_sigprocmask
66fb9763
FB		 4019 case TARGET_NR_sigprocmask:
4020 {
4021 int how = arg1;
4022 sigset_t set, oldset, *set_ptr;
3b46e624 4023
53a5960a 4024 if (arg2) {
66fb9763
FB		 4025 switch(how) {
4026 case TARGET_SIG_BLOCK:
4027 how = SIG_BLOCK;
4028 break;
4029 case TARGET_SIG_UNBLOCK:
4030 how = SIG_UNBLOCK;
4031 break;
4032 case TARGET_SIG_SETMASK:
4033 how = SIG_SETMASK;
4034 break;
4035 default:
0da46a6e 4036 ret = -TARGET_EINVAL;
66fb9763
FB		 4037 goto fail;
4038 }
579a97f7
FB		 4039 if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))
4040 goto efault;
53a5960a
PB		 4041 target_to_host_old_sigset(&set, p);
4042 unlock_user(p, arg2, 0);
66fb9763
FB		 4043 set_ptr = &set;
4044 } else {
4045 how = 0;
4046 set_ptr = NULL;
4047 }
4048 ret = get_errno(sigprocmask(arg1, set_ptr, &oldset));
53a5960a 4049 if (!is_error(ret) && arg3) {
579a97f7
FB		 4050 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))
4051 goto efault;
53a5960a
PB		 4052 host_to_target_old_sigset(p, &oldset);
4053 unlock_user(p, arg3, sizeof(target_sigset_t));
66fb9763
FB		 4054 }
4055 }
4056 break;
e5febef5 4057#endif
66fb9763
FB		 4058 case TARGET_NR_rt_sigprocmask:
4059 {
4060 int how = arg1;
4061 sigset_t set, oldset, *set_ptr;
3b46e624 4062
53a5960a 4063 if (arg2) {
66fb9763
FB		 4064 switch(how) {
4065 case TARGET_SIG_BLOCK:
4066 how = SIG_BLOCK;
4067 break;
4068 case TARGET_SIG_UNBLOCK:
4069 how = SIG_UNBLOCK;
4070 break;
4071 case TARGET_SIG_SETMASK:
4072 how = SIG_SETMASK;
4073 break;
4074 default:
0da46a6e 4075 ret = -TARGET_EINVAL;
66fb9763
FB		 4076 goto fail;
4077 }
579a97f7
FB		 4078 if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))
4079 goto efault;
53a5960a
PB		 4080 target_to_host_sigset(&set, p);
4081 unlock_user(p, arg2, 0);
66fb9763
FB		 4082 set_ptr = &set;
4083 } else {
4084 how = 0;
4085 set_ptr = NULL;
4086 }
4087 ret = get_errno(sigprocmask(how, set_ptr, &oldset));
53a5960a 4088 if (!is_error(ret) && arg3) {
579a97f7
FB		 4089 if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))
4090 goto efault;
53a5960a
PB		 4091 host_to_target_sigset(p, &oldset);
4092 unlock_user(p, arg3, sizeof(target_sigset_t));
66fb9763
FB		 4093 }
4094 }
4095 break;
e5febef5 4096#ifdef TARGET_NR_sigpending
66fb9763
FB		 4097 case TARGET_NR_sigpending:
4098 {
4099 sigset_t set;
4100 ret = get_errno(sigpending(&set));
4101 if (!is_error(ret)) {
579a97f7
FB		 4102 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))
4103 goto efault;
53a5960a
PB		 4104 host_to_target_old_sigset(p, &set);
4105 unlock_user(p, arg1, sizeof(target_sigset_t));
66fb9763
FB		 4106 }
4107 }
4108 break;
e5febef5 4109#endif
66fb9763
FB		 4110 case TARGET_NR_rt_sigpending:
4111 {
4112 sigset_t set;
4113 ret = get_errno(sigpending(&set));
4114 if (!is_error(ret)) {
579a97f7
FB		 4115 if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))
4116 goto efault;
53a5960a
PB		 4117 host_to_target_sigset(p, &set);
4118 unlock_user(p, arg1, sizeof(target_sigset_t));
66fb9763
FB		 4119 }
4120 }
4121 break;
e5febef5 4122#ifdef TARGET_NR_sigsuspend
66fb9763
FB		 4123 case TARGET_NR_sigsuspend:
4124 {
4125 sigset_t set;
579a97f7
FB		 4126 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
4127 goto efault;
53a5960a
PB		 4128 target_to_host_old_sigset(&set, p);
4129 unlock_user(p, arg1, 0);
66fb9763
FB		 4130 ret = get_errno(sigsuspend(&set));
4131 }
4132 break;
e5febef5 4133#endif
66fb9763
FB		 4134 case TARGET_NR_rt_sigsuspend:
4135 {
4136 sigset_t set;
579a97f7
FB		 4137 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
4138 goto efault;
53a5960a
PB		 4139 target_to_host_sigset(&set, p);
4140 unlock_user(p, arg1, 0);
66fb9763
FB		 4141 ret = get_errno(sigsuspend(&set));
4142 }
4143 break;
4144 case TARGET_NR_rt_sigtimedwait:
4145 {
66fb9763
FB		 4146 sigset_t set;
4147 struct timespec uts, *puts;
4148 siginfo_t uinfo;
3b46e624 4149
579a97f7
FB		 4150 if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
4151 goto efault;
53a5960a
PB		 4152 target_to_host_sigset(&set, p);
4153 unlock_user(p, arg1, 0);
4154 if (arg3) {
66fb9763 4155 puts = &uts;
53a5960a 4156 target_to_host_timespec(puts, arg3);
66fb9763
FB		 4157 } else {
4158 puts = NULL;
4159 }
4160 ret = get_errno(sigtimedwait(&set, &uinfo, puts));
53a5960a 4161 if (!is_error(ret) && arg2) {
e1e3f30b 4162 if (!(p = lock_user(VERIFY_WRITE, arg2, sizeof(target_siginfo_t), 0)))
579a97f7 4163 goto efault;
53a5960a 4164 host_to_target_siginfo(p, &uinfo);
e1e3f30b 4165 unlock_user(p, arg2, sizeof(target_siginfo_t));
66fb9763
FB		 4166 }
4167 }
4168 break;
4169 case TARGET_NR_rt_sigqueueinfo:
4170 {
4171 siginfo_t uinfo;
579a97f7
FB		 4172 if (!(p = lock_user(VERIFY_READ, arg3, sizeof(target_sigset_t), 1)))
4173 goto efault;
53a5960a
PB		 4174 target_to_host_siginfo(&uinfo, p);
4175 unlock_user(p, arg1, 0);
66fb9763
FB		 4176 ret = get_errno(sys_rt_sigqueueinfo(arg1, arg2, &uinfo));
4177 }
4178 break;
e5febef5 4179#ifdef TARGET_NR_sigreturn
66fb9763
FB		 4180 case TARGET_NR_sigreturn:
4181 /* NOTE: ret is eax, so not transcoding must be done */
4182 ret = do_sigreturn(cpu_env);
4183 break;
e5febef5 4184#endif
66fb9763
FB		 4185 case TARGET_NR_rt_sigreturn:
4186 /* NOTE: ret is eax, so not transcoding must be done */
4187 ret = do_rt_sigreturn(cpu_env);
4188 break;
31e31b8a 4189 case TARGET_NR_sethostname:
579a97f7
FB		 4190 if (!(p = lock_user_string(arg1)))
4191 goto efault;
53a5960a
PB		 4192 ret = get_errno(sethostname(p, arg2));
4193 unlock_user(p, arg1, 0);
31e31b8a
FB		 4194 break;
4195 case TARGET_NR_setrlimit:
9de5e440
FB		 4196 {
4197 /* XXX: convert resource ? */
4198 int resource = arg1;
53a5960a 4199 struct target_rlimit *target_rlim;
9de5e440 4200 struct rlimit rlim;
579a97f7
FB		 4201 if (!lock_user_struct(VERIFY_READ, target_rlim, arg2, 1))
4202 goto efault;
9de5e440
FB		 4203 rlim.rlim_cur = tswapl(target_rlim->rlim_cur);
4204 rlim.rlim_max = tswapl(target_rlim->rlim_max);
53a5960a 4205 unlock_user_struct(target_rlim, arg2, 0);
9de5e440
FB		 4206 ret = get_errno(setrlimit(resource, &rlim));
4207 }
4208 break;
31e31b8a 4209 case TARGET_NR_getrlimit:
9de5e440
FB		 4210 {
4211 /* XXX: convert resource ? */
4212 int resource = arg1;
53a5960a 4213 struct target_rlimit *target_rlim;
9de5e440 4214 struct rlimit rlim;
3b46e624 4215
9de5e440
FB		 4216 ret = get_errno(getrlimit(resource, &rlim));
4217 if (!is_error(ret)) {
579a97f7
FB		 4218 if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))
4219 goto efault;
53a5960a
PB		 4220 rlim.rlim_cur = tswapl(target_rlim->rlim_cur);
4221 rlim.rlim_max = tswapl(target_rlim->rlim_max);
4222 unlock_user_struct(target_rlim, arg2, 1);
9de5e440
FB		 4223 }
4224 }
4225 break;
31e31b8a 4226 case TARGET_NR_getrusage:
b409186b
FB		 4227 {
4228 struct rusage rusage;
b409186b
FB		 4229 ret = get_errno(getrusage(arg1, &rusage));
4230 if (!is_error(ret)) {
53a5960a 4231 host_to_target_rusage(arg2, &rusage);
b409186b
FB		 4232 }
4233 }
4234 break;
31e31b8a
FB		 4235 case TARGET_NR_gettimeofday:
4236 {
31e31b8a
FB		 4237 struct timeval tv;
4238 ret = get_errno(gettimeofday(&tv, NULL));
4239 if (!is_error(ret)) {
788f5ec4
TS		 4240 if (copy_to_user_timeval(arg1, &tv))
4241 goto efault;
31e31b8a
FB		 4242 }
4243 }
4244 break;
4245 case TARGET_NR_settimeofday:
4246 {
31e31b8a 4247 struct timeval tv;
788f5ec4
TS		 4248 if (copy_from_user_timeval(&tv, arg1))
4249 goto efault;
31e31b8a
FB		 4250 ret = get_errno(settimeofday(&tv, NULL));
4251 }
4252 break;
048f6b4d 4253#ifdef TARGET_NR_select
31e31b8a 4254 case TARGET_NR_select:
f2674e31 4255 {
53a5960a 4256 struct target_sel_arg_struct *sel;
992f48a0 4257 abi_ulong inp, outp, exp, tvp;
53a5960a
PB		 4258 long nsel;
4259
579a97f7
FB		 4260 if (!lock_user_struct(VERIFY_READ, sel, arg1, 1))
4261 goto efault;
53a5960a
PB		 4262 nsel = tswapl(sel->n);
4263 inp = tswapl(sel->inp);
4264 outp = tswapl(sel->outp);
4265 exp = tswapl(sel->exp);
4266 tvp = tswapl(sel->tvp);
4267 unlock_user_struct(sel, arg1, 0);
4268 ret = do_select(nsel, inp, outp, exp, tvp);
f2674e31
FB		 4269 }
4270 break;
048f6b4d 4271#endif
31e31b8a 4272 case TARGET_NR_symlink:
53a5960a
PB		 4273 {
4274 void *p2;
4275 p = lock_user_string(arg1);
4276 p2 = lock_user_string(arg2);
579a97f7
FB		 4277 if (!p || !p2)
4278 ret = -TARGET_EFAULT;
4279 else
4280 ret = get_errno(symlink(p, p2));
53a5960a
PB		 4281 unlock_user(p2, arg2, 0);
4282 unlock_user(p, arg1, 0);
4283 }
31e31b8a 4284 break;
f0b6243d
TS		 4285#if defined(TARGET_NR_symlinkat) && defined(__NR_symlinkat)
4286 case TARGET_NR_symlinkat:
f0b6243d 4287 {
579a97f7 4288 void *p2;
f0b6243d
TS		 4289 p = lock_user_string(arg1);
4290 p2 = lock_user_string(arg3);
579a97f7 4291 if (!p || !p2)
0da46a6e 4292 ret = -TARGET_EFAULT;
f0b6243d
TS		 4293 else
4294 ret = get_errno(sys_symlinkat(p, arg2, p2));
579a97f7
FB		 4295 unlock_user(p2, arg3, 0);
4296 unlock_user(p, arg1, 0);
f0b6243d
TS		 4297 }
4298 break;
4299#endif
ebc05488 4300#ifdef TARGET_NR_oldlstat
31e31b8a
FB		 4301 case TARGET_NR_oldlstat:
4302 goto unimplemented;
ebc05488 4303#endif
31e31b8a 4304 case TARGET_NR_readlink:
53a5960a
PB		 4305 {
4306 void *p2;
4307 p = lock_user_string(arg1);
579a97f7
FB		 4308 p2 = lock_user(VERIFY_WRITE, arg2, arg3, 0);
4309 if (!p || !p2)
4310 ret = -TARGET_EFAULT;
4311 else
4312 ret = get_errno(readlink(path(p), p2, arg3));
53a5960a
PB		 4313 unlock_user(p2, arg2, ret);
4314 unlock_user(p, arg1, 0);
4315 }
31e31b8a 4316 break;
5e0ccb18
TS		 4317#if defined(TARGET_NR_readlinkat) && defined(__NR_readlinkat)
4318 case TARGET_NR_readlinkat:
5e0ccb18 4319 {
579a97f7 4320 void *p2;
5e0ccb18 4321 p = lock_user_string(arg2);
579a97f7
FB		 4322 p2 = lock_user(VERIFY_WRITE, arg3, arg4, 0);
4323 if (!p || !p2)
0da46a6e 4324 ret = -TARGET_EFAULT;
5e0ccb18
TS		 4325 else
4326 ret = get_errno(sys_readlinkat(arg1, path(p), p2, arg4));
579a97f7
FB		 4327 unlock_user(p2, arg3, ret);
4328 unlock_user(p, arg2, 0);
5e0ccb18
TS		 4329 }
4330 break;
4331#endif
e5febef5 4332#ifdef TARGET_NR_uselib
31e31b8a
FB		 4333 case TARGET_NR_uselib:
4334 goto unimplemented;
e5febef5
TS		 4335#endif
4336#ifdef TARGET_NR_swapon
31e31b8a 4337 case TARGET_NR_swapon:
579a97f7
FB		 4338 if (!(p = lock_user_string(arg1)))
4339 goto efault;
53a5960a
PB		 4340 ret = get_errno(swapon(p, arg2));
4341 unlock_user(p, arg1, 0);
31e31b8a 4342 break;
e5febef5 4343#endif
31e31b8a
FB		 4344 case TARGET_NR_reboot:
4345 goto unimplemented;
e5febef5 4346#ifdef TARGET_NR_readdir
31e31b8a
FB		 4347 case TARGET_NR_readdir:
4348 goto unimplemented;
e5febef5
TS		 4349#endif
4350#ifdef TARGET_NR_mmap
31e31b8a 4351 case TARGET_NR_mmap:
d2fd1af7 4352#if (defined(TARGET_I386) && defined(TARGET_ABI32)) || defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_CRIS)
31e31b8a 4353 {
992f48a0
BS		 4354 abi_ulong *v;
4355 abi_ulong v1, v2, v3, v4, v5, v6;
579a97f7
FB		 4356 if (!(v = lock_user(VERIFY_READ, arg1, 6 * sizeof(abi_ulong), 1)))
4357 goto efault;
53a5960a
PB		 4358 v1 = tswapl(v[0]);
4359 v2 = tswapl(v[1]);
4360 v3 = tswapl(v[2]);
4361 v4 = tswapl(v[3]);
4362 v5 = tswapl(v[4]);
4363 v6 = tswapl(v[5]);
4364 unlock_user(v, arg1, 0);
5fafdf24 4365 ret = get_errno(target_mmap(v1, v2, v3,
5286db75
FB		 4366 target_to_host_bitmask(v4, mmap_flags_tbl),
4367 v5, v6));
31e31b8a 4368 }
31e31b8a 4369#else
5fafdf24
TS		 4370 ret = get_errno(target_mmap(arg1, arg2, arg3,
4371 target_to_host_bitmask(arg4, mmap_flags_tbl),
6fb883e8
FB		 4372 arg5,
4373 arg6));
31e31b8a 4374#endif
6fb883e8 4375 break;
e5febef5 4376#endif
a315a145 4377#ifdef TARGET_NR_mmap2
6fb883e8 4378 case TARGET_NR_mmap2:
bb7ec043 4379#ifndef MMAP_SHIFT
c573ff67 4380#define MMAP_SHIFT 12
c573ff67 4381#endif
5fafdf24
TS		 4382 ret = get_errno(target_mmap(arg1, arg2, arg3,
4383 target_to_host_bitmask(arg4, mmap_flags_tbl),
5286db75 4384 arg5,
c573ff67 4385 arg6 << MMAP_SHIFT));
31e31b8a 4386 break;
a315a145 4387#endif
31e31b8a 4388 case TARGET_NR_munmap:
54936004 4389 ret = get_errno(target_munmap(arg1, arg2));
31e31b8a 4390 break;
9de5e440 4391 case TARGET_NR_mprotect:
54936004 4392 ret = get_errno(target_mprotect(arg1, arg2, arg3));
9de5e440 4393 break;
e5febef5 4394#ifdef TARGET_NR_mremap
9de5e440 4395 case TARGET_NR_mremap:
54936004 4396 ret = get_errno(target_mremap(arg1, arg2, arg3, arg4, arg5));
9de5e440 4397 break;
e5febef5 4398#endif
53a5960a 4399 /* ??? msync/mlock/munlock are broken for softmmu. */
e5febef5 4400#ifdef TARGET_NR_msync
9de5e440 4401 case TARGET_NR_msync:
53a5960a 4402 ret = get_errno(msync(g2h(arg1), arg2, arg3));
9de5e440 4403 break;
e5febef5
TS		 4404#endif
4405#ifdef TARGET_NR_mlock
9de5e440 4406 case TARGET_NR_mlock:
53a5960a 4407 ret = get_errno(mlock(g2h(arg1), arg2));
9de5e440 4408 break;
e5febef5
TS		 4409#endif
4410#ifdef TARGET_NR_munlock
9de5e440 4411 case TARGET_NR_munlock:
53a5960a 4412 ret = get_errno(munlock(g2h(arg1), arg2));
9de5e440 4413 break;
e5febef5
TS		 4414#endif
4415#ifdef TARGET_NR_mlockall
9de5e440
FB		 4416 case TARGET_NR_mlockall:
4417 ret = get_errno(mlockall(arg1));
4418 break;
e5febef5
TS		 4419#endif
4420#ifdef TARGET_NR_munlockall
9de5e440
FB		 4421 case TARGET_NR_munlockall:
4422 ret = get_errno(munlockall());
4423 break;
e5febef5 4424#endif
31e31b8a 4425 case TARGET_NR_truncate:
579a97f7
FB		 4426 if (!(p = lock_user_string(arg1)))
4427 goto efault;
53a5960a
PB		 4428 ret = get_errno(truncate(p, arg2));
4429 unlock_user(p, arg1, 0);
31e31b8a
FB		 4430 break;
4431 case TARGET_NR_ftruncate:
4432 ret = get_errno(ftruncate(arg1, arg2));
4433 break;
4434 case TARGET_NR_fchmod:
4435 ret = get_errno(fchmod(arg1, arg2));
4436 break;
814d7977
TS		 4437#if defined(TARGET_NR_fchmodat) && defined(__NR_fchmodat)
4438 case TARGET_NR_fchmodat:
579a97f7
FB		 4439 if (!(p = lock_user_string(arg2)))
4440 goto efault;
4441 ret = get_errno(sys_fchmodat(arg1, p, arg3, arg4));
4442 unlock_user(p, arg2, 0);
814d7977
TS		 4443 break;
4444#endif
31e31b8a 4445 case TARGET_NR_getpriority:
c6cda17a
TS		 4446 /* libc does special remapping of the return value of
4447 * sys_getpriority() so it's just easiest to call
4448 * sys_getpriority() directly rather than through libc. */
4449 ret = sys_getpriority(arg1, arg2);
31e31b8a
FB		 4450 break;
4451 case TARGET_NR_setpriority:
4452 ret = get_errno(setpriority(arg1, arg2, arg3));
4453 break;
ebc05488 4454#ifdef TARGET_NR_profil
31e31b8a
FB		 4455 case TARGET_NR_profil:
4456 goto unimplemented;
ebc05488 4457#endif
31e31b8a 4458 case TARGET_NR_statfs:
579a97f7
FB		 4459 if (!(p = lock_user_string(arg1)))
4460 goto efault;
53a5960a
PB		 4461 ret = get_errno(statfs(path(p), &stfs));
4462 unlock_user(p, arg1, 0);
31e31b8a
FB		 4463 convert_statfs:
4464 if (!is_error(ret)) {
53a5960a 4465 struct target_statfs *target_stfs;
3b46e624 4466
579a97f7
FB		 4467 if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg2, 0))
4468 goto efault;
4469 __put_user(stfs.f_type, &target_stfs->f_type);
4470 __put_user(stfs.f_bsize, &target_stfs->f_bsize);
4471 __put_user(stfs.f_blocks, &target_stfs->f_blocks);
4472 __put_user(stfs.f_bfree, &target_stfs->f_bfree);
4473 __put_user(stfs.f_bavail, &target_stfs->f_bavail);
4474 __put_user(stfs.f_files, &target_stfs->f_files);
4475 __put_user(stfs.f_ffree, &target_stfs->f_ffree);
4476 __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
4477 __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
4478 __put_user(stfs.f_namelen, &target_stfs->f_namelen);
53a5960a 4479 unlock_user_struct(target_stfs, arg2, 1);
31e31b8a
FB		 4480 }
4481 break;
4482 case TARGET_NR_fstatfs:
56c8f68f 4483 ret = get_errno(fstatfs(arg1, &stfs));
31e31b8a 4484 goto convert_statfs;
56c8f68f
FB		 4485#ifdef TARGET_NR_statfs64
4486 case TARGET_NR_statfs64:
579a97f7
FB		 4487 if (!(p = lock_user_string(arg1)))
4488 goto efault;
53a5960a
PB		 4489 ret = get_errno(statfs(path(p), &stfs));
4490 unlock_user(p, arg1, 0);
56c8f68f
FB		 4491 convert_statfs64:
4492 if (!is_error(ret)) {
53a5960a 4493 struct target_statfs64 *target_stfs;
3b46e624 4494
579a97f7
FB		 4495 if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg3, 0))
4496 goto efault;
4497 __put_user(stfs.f_type, &target_stfs->f_type);
4498 __put_user(stfs.f_bsize, &target_stfs->f_bsize);
4499 __put_user(stfs.f_blocks, &target_stfs->f_blocks);
4500 __put_user(stfs.f_bfree, &target_stfs->f_bfree);
4501 __put_user(stfs.f_bavail, &target_stfs->f_bavail);
4502 __put_user(stfs.f_files, &target_stfs->f_files);
4503 __put_user(stfs.f_ffree, &target_stfs->f_ffree);
4504 __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
4505 __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
4506 __put_user(stfs.f_namelen, &target_stfs->f_namelen);
4507 unlock_user_struct(target_stfs, arg3, 1);
56c8f68f
FB		 4508 }
4509 break;
4510 case TARGET_NR_fstatfs64:
4511 ret = get_errno(fstatfs(arg1, &stfs));
4512 goto convert_statfs64;
4513#endif
ebc05488 4514#ifdef TARGET_NR_ioperm
31e31b8a
FB		 4515 case TARGET_NR_ioperm:
4516 goto unimplemented;
ebc05488 4517#endif
e5febef5 4518#ifdef TARGET_NR_socketcall
31e31b8a 4519 case TARGET_NR_socketcall:
53a5960a 4520 ret = do_socketcall(arg1, arg2);
31e31b8a 4521 break;
e5febef5 4522#endif
3532fa74
FB		 4523#ifdef TARGET_NR_accept
4524 case TARGET_NR_accept:
1be9e1dc 4525 ret = do_accept(arg1, arg2, arg3);
3532fa74
FB		 4526 break;
4527#endif
4528#ifdef TARGET_NR_bind
4529 case TARGET_NR_bind:
4530 ret = do_bind(arg1, arg2, arg3);
4531 break;
4532#endif
4533#ifdef TARGET_NR_connect
4534 case TARGET_NR_connect:
4535 ret = do_connect(arg1, arg2, arg3);
4536 break;
4537#endif
4538#ifdef TARGET_NR_getpeername
4539 case TARGET_NR_getpeername:
1be9e1dc 4540 ret = do_getpeername(arg1, arg2, arg3);
3532fa74
FB		 4541 break;
4542#endif
4543#ifdef TARGET_NR_getsockname
4544 case TARGET_NR_getsockname:
1be9e1dc 4545 ret = do_getsockname(arg1, arg2, arg3);
3532fa74
FB		 4546 break;
4547#endif
4548#ifdef TARGET_NR_getsockopt
4549 case TARGET_NR_getsockopt:
4550 ret = do_getsockopt(arg1, arg2, arg3, arg4, arg5);
4551 break;
4552#endif
4553#ifdef TARGET_NR_listen
4554 case TARGET_NR_listen:
1be9e1dc 4555 ret = get_errno(listen(arg1, arg2));
3532fa74
FB		 4556 break;
4557#endif
4558#ifdef TARGET_NR_recv
4559 case TARGET_NR_recv:
214201bd 4560 ret = do_recvfrom(arg1, arg2, arg3, arg4, 0, 0);
3532fa74
FB		 4561 break;
4562#endif
4563#ifdef TARGET_NR_recvfrom
4564 case TARGET_NR_recvfrom:
214201bd 4565 ret = do_recvfrom(arg1, arg2, arg3, arg4, arg5, arg6);
3532fa74
FB		 4566 break;
4567#endif
4568#ifdef TARGET_NR_recvmsg
4569 case TARGET_NR_recvmsg:
4570 ret = do_sendrecvmsg(arg1, arg2, arg3, 0);
4571 break;
4572#endif
4573#ifdef TARGET_NR_send
4574 case TARGET_NR_send:
1be9e1dc 4575 ret = do_sendto(arg1, arg2, arg3, arg4, 0, 0);
3532fa74
FB		 4576 break;
4577#endif
4578#ifdef TARGET_NR_sendmsg
4579 case TARGET_NR_sendmsg:
4580 ret = do_sendrecvmsg(arg1, arg2, arg3, 1);
4581 break;
4582#endif
4583#ifdef TARGET_NR_sendto
4584 case TARGET_NR_sendto:
1be9e1dc 4585 ret = do_sendto(arg1, arg2, arg3, arg4, arg5, arg6);
3532fa74
FB		 4586 break;
4587#endif
4588#ifdef TARGET_NR_shutdown
4589 case TARGET_NR_shutdown:
1be9e1dc 4590 ret = get_errno(shutdown(arg1, arg2));
3532fa74
FB		 4591 break;
4592#endif
4593#ifdef TARGET_NR_socket
4594 case TARGET_NR_socket:
4595 ret = do_socket(arg1, arg2, arg3);
4596 break;
4597#endif
4598#ifdef TARGET_NR_socketpair
4599 case TARGET_NR_socketpair:
1be9e1dc 4600 ret = do_socketpair(arg1, arg2, arg3, arg4);
3532fa74
FB		 4601 break;
4602#endif
4603#ifdef TARGET_NR_setsockopt
4604 case TARGET_NR_setsockopt:
4605 ret = do_setsockopt(arg1, arg2, arg3, arg4, (socklen_t) arg5);
4606 break;
4607#endif
7494b0f9 4608
31e31b8a 4609 case TARGET_NR_syslog:
579a97f7
FB		 4610 if (!(p = lock_user_string(arg2)))
4611 goto efault;
e5574487
TS		 4612 ret = get_errno(sys_syslog((int)arg1, p, (int)arg3));
4613 unlock_user(p, arg2, 0);
7494b0f9
TS		 4614 break;
4615
31e31b8a 4616 case TARGET_NR_setitimer:
66fb9763 4617 {
66fb9763
FB		 4618 struct itimerval value, ovalue, *pvalue;
4619
53a5960a 4620 if (arg2) {
66fb9763 4621 pvalue = &value;
788f5ec4
TS		 4622 if (copy_from_user_timeval(&pvalue->it_interval, arg2)
4623 || copy_from_user_timeval(&pvalue->it_value,
4624 arg2 + sizeof(struct target_timeval)))
4625 goto efault;
66fb9763
FB		 4626 } else {
4627 pvalue = NULL;
4628 }
4629 ret = get_errno(setitimer(arg1, pvalue, &ovalue));
53a5960a 4630 if (!is_error(ret) && arg3) {
788f5ec4
TS		 4631 if (copy_to_user_timeval(arg3,
4632 &ovalue.it_interval)
4633 || copy_to_user_timeval(arg3 + sizeof(struct target_timeval),
4634 &ovalue.it_value))
4635 goto efault;
66fb9763
FB		 4636 }
4637 }
4638 break;
31e31b8a 4639 case TARGET_NR_getitimer:
66fb9763 4640 {
66fb9763 4641 struct itimerval value;
3b46e624 4642
66fb9763 4643 ret = get_errno(getitimer(arg1, &value));
53a5960a 4644 if (!is_error(ret) && arg2) {
788f5ec4
TS		 4645 if (copy_to_user_timeval(arg2,
4646 &value.it_interval)
4647 || copy_to_user_timeval(arg2 + sizeof(struct target_timeval),
4648 &value.it_value))
4649 goto efault;
66fb9763
FB		 4650 }
4651 }
4652 break;
31e31b8a 4653 case TARGET_NR_stat:
579a97f7
FB		 4654 if (!(p = lock_user_string(arg1)))
4655 goto efault;
53a5960a
PB		 4656 ret = get_errno(stat(path(p), &st));
4657 unlock_user(p, arg1, 0);
31e31b8a
FB		 4658 goto do_stat;
4659 case TARGET_NR_lstat:
579a97f7
FB		 4660 if (!(p = lock_user_string(arg1)))
4661 goto efault;
53a5960a
PB		 4662 ret = get_errno(lstat(path(p), &st));
4663 unlock_user(p, arg1, 0);
31e31b8a
FB		 4664 goto do_stat;
4665 case TARGET_NR_fstat:
4666 {
4667 ret = get_errno(fstat(arg1, &st));
4668 do_stat:
4669 if (!is_error(ret)) {
53a5960a 4670 struct target_stat *target_st;
e3584658 4671
579a97f7
FB		 4672 if (!lock_user_struct(VERIFY_WRITE, target_st, arg2, 0))
4673 goto efault;
d2fd1af7
FB		 4674 __put_user(st.st_dev, &target_st->st_dev);
4675 __put_user(st.st_ino, &target_st->st_ino);
4676 __put_user(st.st_mode, &target_st->st_mode);
4677 __put_user(st.st_uid, &target_st->st_uid);
4678 __put_user(st.st_gid, &target_st->st_gid);
4679 __put_user(st.st_nlink, &target_st->st_nlink);
4680 __put_user(st.st_rdev, &target_st->st_rdev);
4681 __put_user(st.st_size, &target_st->st_size);
4682 __put_user(st.st_blksize, &target_st->st_blksize);
4683 __put_user(st.st_blocks, &target_st->st_blocks);
4684 __put_user(st.st_atime, &target_st->target_st_atime);
4685 __put_user(st.st_mtime, &target_st->target_st_mtime);
4686 __put_user(st.st_ctime, &target_st->target_st_ctime);
53a5960a 4687 unlock_user_struct(target_st, arg2, 1);
31e31b8a
FB		 4688 }
4689 }
4690 break;
ebc05488 4691#ifdef TARGET_NR_olduname
31e31b8a
FB		 4692 case TARGET_NR_olduname:
4693 goto unimplemented;
ebc05488
FB		 4694#endif
4695#ifdef TARGET_NR_iopl
31e31b8a
FB		 4696 case TARGET_NR_iopl:
4697 goto unimplemented;
ebc05488 4698#endif
31e31b8a
FB		 4699 case TARGET_NR_vhangup:
4700 ret = get_errno(vhangup());
4701 break;
ebc05488 4702#ifdef TARGET_NR_idle
31e31b8a
FB		 4703 case TARGET_NR_idle:
4704 goto unimplemented;
42ad6ae9
FB		 4705#endif
4706#ifdef TARGET_NR_syscall
4707 case TARGET_NR_syscall:
4708 ret = do_syscall(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,0);
4709 break;
ebc05488 4710#endif
31e31b8a
FB		 4711 case TARGET_NR_wait4:
4712 {
4713 int status;
992f48a0 4714 abi_long status_ptr = arg2;
31e31b8a 4715 struct rusage rusage, *rusage_ptr;
992f48a0 4716 abi_ulong target_rusage = arg4;
31e31b8a
FB		 4717 if (target_rusage)
4718 rusage_ptr = &rusage;
4719 else
4720 rusage_ptr = NULL;
4721 ret = get_errno(wait4(arg1, &status, arg3, rusage_ptr));
4722 if (!is_error(ret)) {
2f619698
FB		 4723 if (status_ptr) {
4724 if (put_user_s32(status, status_ptr))
4725 goto efault;
31e31b8a 4726 }
2f619698
FB		 4727 if (target_rusage)
4728 host_to_target_rusage(target_rusage, &rusage);
31e31b8a
FB		 4729 }
4730 }
4731 break;
e5febef5 4732#ifdef TARGET_NR_swapoff
31e31b8a 4733 case TARGET_NR_swapoff:
579a97f7
FB		 4734 if (!(p = lock_user_string(arg1)))
4735 goto efault;
53a5960a
PB		 4736 ret = get_errno(swapoff(p));
4737 unlock_user(p, arg1, 0);
31e31b8a 4738 break;
e5febef5 4739#endif
31e31b8a 4740 case TARGET_NR_sysinfo:
a5448a7d 4741 {
53a5960a 4742 struct target_sysinfo *target_value;
a5448a7d
FB		 4743 struct sysinfo value;
4744 ret = get_errno(sysinfo(&value));
53a5960a 4745 if (!is_error(ret) && arg1)
a5448a7d 4746 {
579a97f7
FB		 4747 if (!lock_user_struct(VERIFY_WRITE, target_value, arg1, 0))
4748 goto efault;
a5448a7d
FB		 4749 __put_user(value.uptime, &target_value->uptime);
4750 __put_user(value.loads[0], &target_value->loads[0]);
4751 __put_user(value.loads[1], &target_value->loads[1]);
4752 __put_user(value.loads[2], &target_value->loads[2]);
4753 __put_user(value.totalram, &target_value->totalram);
4754 __put_user(value.freeram, &target_value->freeram);
4755 __put_user(value.sharedram, &target_value->sharedram);
4756 __put_user(value.bufferram, &target_value->bufferram);
4757 __put_user(value.totalswap, &target_value->totalswap);
4758 __put_user(value.freeswap, &target_value->freeswap);
4759 __put_user(value.procs, &target_value->procs);
4760 __put_user(value.totalhigh, &target_value->totalhigh);
4761 __put_user(value.freehigh, &target_value->freehigh);
4762 __put_user(value.mem_unit, &target_value->mem_unit);
53a5960a 4763 unlock_user_struct(target_value, arg1, 1);
a5448a7d
FB		 4764 }
4765 }
4766 break;
e5febef5 4767#ifdef TARGET_NR_ipc
31e31b8a 4768 case TARGET_NR_ipc:
8853f86e
FB		 4769 ret = do_ipc(arg1, arg2, arg3, arg4, arg5, arg6);
4770 break;
e5febef5 4771#endif
31e31b8a
FB		 4772 case TARGET_NR_fsync:
4773 ret = get_errno(fsync(arg1));
4774 break;
31e31b8a 4775 case TARGET_NR_clone:
0b6d3ae0
AJ		 4776#if defined(TARGET_SH4)
4777 ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg5, arg4));
4778#else
d865bab5 4779 ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg4, arg5));
0b6d3ae0 4780#endif
1b6b029e 4781 break;
ec86b0fb
FB		 4782#ifdef __NR_exit_group
4783 /* new thread calls */
4784 case TARGET_NR_exit_group:
e9009676 4785 gdb_exit(cpu_env, arg1);
ec86b0fb
FB		 4786 ret = get_errno(exit_group(arg1));
4787 break;
4788#endif
31e31b8a 4789 case TARGET_NR_setdomainname:
579a97f7
FB		 4790 if (!(p = lock_user_string(arg1)))
4791 goto efault;
53a5960a
PB		 4792 ret = get_errno(setdomainname(p, arg2));
4793 unlock_user(p, arg1, 0);
31e31b8a
FB		 4794 break;
4795 case TARGET_NR_uname:
4796 /* no need to transcode because we use the linux syscall */
29e619b1
FB		 4797 {
4798 struct new_utsname * buf;
3b46e624 4799
579a97f7
FB		 4800 if (!lock_user_struct(VERIFY_WRITE, buf, arg1, 0))
4801 goto efault;
29e619b1
FB		 4802 ret = get_errno(sys_uname(buf));
4803 if (!is_error(ret)) {
4804 /* Overrite the native machine name with whatever is being
4805 emulated. */
4806 strcpy (buf->machine, UNAME_MACHINE);
c5937220
PB		 4807 /* Allow the user to override the reported release. */
4808 if (qemu_uname_release && *qemu_uname_release)
4809 strcpy (buf->release, qemu_uname_release);
29e619b1 4810 }
53a5960a 4811 unlock_user_struct(buf, arg1, 1);
29e619b1 4812 }
31e31b8a 4813 break;
6dbad63e 4814#ifdef TARGET_I386
31e31b8a 4815 case TARGET_NR_modify_ldt:
03acab66 4816 ret = do_modify_ldt(cpu_env, arg1, arg2, arg3);
5cd4393b 4817 break;
84409ddb 4818#if !defined(TARGET_X86_64)
5cd4393b
FB		 4819 case TARGET_NR_vm86old:
4820 goto unimplemented;
4821 case TARGET_NR_vm86:
53a5960a 4822 ret = do_vm86(cpu_env, arg1, arg2);
6dbad63e 4823 break;
84409ddb 4824#endif
6dbad63e 4825#endif
31e31b8a
FB		 4826 case TARGET_NR_adjtimex:
4827 goto unimplemented;
e5febef5 4828#ifdef TARGET_NR_create_module
31e31b8a 4829 case TARGET_NR_create_module:
e5febef5 4830#endif
31e31b8a
FB		 4831 case TARGET_NR_init_module:
4832 case TARGET_NR_delete_module:
e5febef5 4833#ifdef TARGET_NR_get_kernel_syms
31e31b8a 4834 case TARGET_NR_get_kernel_syms:
e5febef5 4835#endif
31e31b8a
FB		 4836 goto unimplemented;
4837 case TARGET_NR_quotactl:
4838 goto unimplemented;
4839 case TARGET_NR_getpgid:
4840 ret = get_errno(getpgid(arg1));
4841 break;
4842 case TARGET_NR_fchdir:
4843 ret = get_errno(fchdir(arg1));
4844 break;
84409ddb 4845#ifdef TARGET_NR_bdflush /* not on x86_64 */
31e31b8a
FB		 4846 case TARGET_NR_bdflush:
4847 goto unimplemented;
84409ddb 4848#endif
e5febef5 4849#ifdef TARGET_NR_sysfs
31e31b8a
FB		 4850 case TARGET_NR_sysfs:
4851 goto unimplemented;
e5febef5 4852#endif
31e31b8a 4853 case TARGET_NR_personality:
1b6b029e 4854 ret = get_errno(personality(arg1));
31e31b8a 4855 break;
e5febef5 4856#ifdef TARGET_NR_afs_syscall
31e31b8a
FB		 4857 case TARGET_NR_afs_syscall:
4858 goto unimplemented;
e5febef5 4859#endif
7a3148a9 4860#ifdef TARGET_NR__llseek /* Not on alpha */
31e31b8a
FB		 4861 case TARGET_NR__llseek:
4862 {
4f2ac237
FB		 4863#if defined (__x86_64__)
4864 ret = get_errno(lseek(arg1, ((uint64_t )arg2 << 32) | arg3, arg5));
2f619698
FB		 4865 if (put_user_s64(ret, arg4))
4866 goto efault;
4f2ac237 4867#else
31e31b8a
FB		 4868 int64_t res;
4869 ret = get_errno(_llseek(arg1, arg2, arg3, &res, arg5));
2f619698
FB		 4870 if (put_user_s64(res, arg4))
4871 goto efault;
4f2ac237 4872#endif
31e31b8a
FB		 4873 }
4874 break;
7a3148a9 4875#endif
31e31b8a 4876 case TARGET_NR_getdents:
992f48a0 4877#if TARGET_ABI_BITS != 32
53a5960a 4878 goto unimplemented;
992f48a0 4879#elif TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64
4add45b4 4880 {
53a5960a 4881 struct target_dirent *target_dirp;
4add45b4 4882 struct dirent *dirp;
992f48a0 4883 abi_long count = arg3;
4add45b4
FB		 4884
4885 dirp = malloc(count);
0da46a6e 4886 if (!dirp) {
579a97f7 4887 ret = -TARGET_ENOMEM;
0da46a6e
TS		 4888 goto fail;
4889 }
3b46e624 4890
4add45b4
FB		 4891 ret = get_errno(sys_getdents(arg1, dirp, count));
4892 if (!is_error(ret)) {
4893 struct dirent *de;
4894 struct target_dirent *tde;
4895 int len = ret;
4896 int reclen, treclen;
4897 int count1, tnamelen;
4898
4899 count1 = 0;
4900 de = dirp;
579a97f7
FB		 4901 if (!(target_dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
4902 goto efault;
4add45b4
FB		 4903 tde = target_dirp;
4904 while (len > 0) {
4905 reclen = de->d_reclen;
992f48a0 4906 treclen = reclen - (2 * (sizeof(long) - sizeof(abi_long)));
4add45b4
FB		 4907 tde->d_reclen = tswap16(treclen);
4908 tde->d_ino = tswapl(de->d_ino);
4909 tde->d_off = tswapl(de->d_off);
992f48a0 4910 tnamelen = treclen - (2 * sizeof(abi_long) + 2);
4add45b4
FB		 4911 if (tnamelen > 256)
4912 tnamelen = 256;
80a9d035 4913 /* XXX: may not be correct */
4add45b4
FB		 4914 strncpy(tde->d_name, de->d_name, tnamelen);
4915 de = (struct dirent *)((char *)de + reclen);
4916 len -= reclen;
1c5bf3bf 4917 tde = (struct target_dirent *)((char *)tde + treclen);
4add45b4
FB		 4918 count1 += treclen;
4919 }
4920 ret = count1;
579a97f7 4921 unlock_user(target_dirp, arg2, ret);
4add45b4
FB		 4922 }
4923 free(dirp);
4924 }
4925#else
31e31b8a 4926 {
53a5960a 4927 struct dirent *dirp;
992f48a0 4928 abi_long count = arg3;
dab2ed99 4929
579a97f7
FB		 4930 if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
4931 goto efault;
72f03900 4932 ret = get_errno(sys_getdents(arg1, dirp, count));
31e31b8a
FB		 4933 if (!is_error(ret)) {
4934 struct dirent *de;
4935 int len = ret;
4936 int reclen;
4937 de = dirp;
4938 while (len > 0) {
8083a3e5 4939 reclen = de->d_reclen;
31e31b8a
FB		 4940 if (reclen > len)
4941 break;
8083a3e5 4942 de->d_reclen = tswap16(reclen);
31e31b8a
FB		 4943 tswapls(&de->d_ino);
4944 tswapls(&de->d_off);
4945 de = (struct dirent *)((char *)de + reclen);
4946 len -= reclen;
4947 }
4948 }
53a5960a 4949 unlock_user(dirp, arg2, ret);
31e31b8a 4950 }
4add45b4 4951#endif
31e31b8a 4952 break;
3ae43202 4953#if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
dab2ed99
FB		 4954 case TARGET_NR_getdents64:
4955 {
53a5960a 4956 struct dirent64 *dirp;
992f48a0 4957 abi_long count = arg3;
579a97f7
FB		 4958 if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))
4959 goto efault;
dab2ed99
FB		 4960 ret = get_errno(sys_getdents64(arg1, dirp, count));
4961 if (!is_error(ret)) {
4962 struct dirent64 *de;
4963 int len = ret;
4964 int reclen;
4965 de = dirp;
4966 while (len > 0) {
8083a3e5 4967 reclen = de->d_reclen;
dab2ed99
FB		 4968 if (reclen > len)
4969 break;
8083a3e5 4970 de->d_reclen = tswap16(reclen);
8582a53a
FB		 4971 tswap64s((uint64_t *)&de->d_ino);
4972 tswap64s((uint64_t *)&de->d_off);
dab2ed99
FB		 4973 de = (struct dirent64 *)((char *)de + reclen);
4974 len -= reclen;
4975 }
4976 }
53a5960a 4977 unlock_user(dirp, arg2, ret);
dab2ed99
FB		 4978 }
4979 break;
a541f297 4980#endif /* TARGET_NR_getdents64 */
e5febef5 4981#ifdef TARGET_NR__newselect
31e31b8a 4982 case TARGET_NR__newselect:
53a5960a 4983 ret = do_select(arg1, arg2, arg3, arg4, arg5);
31e31b8a 4984 break;
e5febef5
TS		 4985#endif
4986#ifdef TARGET_NR_poll
9de5e440
FB		 4987 case TARGET_NR_poll:
4988 {
53a5960a 4989 struct target_pollfd *target_pfd;
9de5e440
FB		 4990 unsigned int nfds = arg2;
4991 int timeout = arg3;
4992 struct pollfd *pfd;
7854b056 4993 unsigned int i;
9de5e440 4994
579a97f7
FB		 4995 target_pfd = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_pollfd) * nfds, 1);
4996 if (!target_pfd)
4997 goto efault;
9de5e440
FB		 4998 pfd = alloca(sizeof(struct pollfd) * nfds);
4999 for(i = 0; i < nfds; i++) {
5cd4393b
FB		 5000 pfd[i].fd = tswap32(target_pfd[i].fd);
5001 pfd[i].events = tswap16(target_pfd[i].events);
9de5e440
FB		 5002 }
5003 ret = get_errno(poll(pfd, nfds, timeout));
5004 if (!is_error(ret)) {
5005 for(i = 0; i < nfds; i++) {
5cd4393b 5006 target_pfd[i].revents = tswap16(pfd[i].revents);
9de5e440 5007 }
53a5960a
PB		 5008 ret += nfds * (sizeof(struct target_pollfd)
5009 - sizeof(struct pollfd));
9de5e440 5010 }
53a5960a 5011 unlock_user(target_pfd, arg1, ret);
9de5e440
FB		 5012 }
5013 break;
e5febef5 5014#endif
31e31b8a 5015 case TARGET_NR_flock:
9de5e440
FB		 5016 /* NOTE: the flock constant seems to be the same for every
5017 Linux platform */
5018 ret = get_errno(flock(arg1, arg2));
31e31b8a
FB		 5019 break;
5020 case TARGET_NR_readv:
5021 {
5022 int count = arg3;
31e31b8a 5023 struct iovec *vec;
31e31b8a
FB		 5024
5025 vec = alloca(count * sizeof(struct iovec));
41df8411
FB		 5026 if (lock_iovec(VERIFY_WRITE, vec, arg2, count, 0) < 0)
5027 goto efault;
31e31b8a 5028 ret = get_errno(readv(arg1, vec, count));
53a5960a 5029 unlock_iovec(vec, arg2, count, 1);
31e31b8a
FB		 5030 }
5031 break;
5032 case TARGET_NR_writev:
5033 {
5034 int count = arg3;
31e31b8a 5035 struct iovec *vec;
31e31b8a
FB		 5036
5037 vec = alloca(count * sizeof(struct iovec));
41df8411
FB		 5038 if (lock_iovec(VERIFY_READ, vec, arg2, count, 1) < 0)
5039 goto efault;
31e31b8a 5040 ret = get_errno(writev(arg1, vec, count));
53a5960a 5041 unlock_iovec(vec, arg2, count, 0);
31e31b8a
FB		 5042 }
5043 break;
5044 case TARGET_NR_getsid:
5045 ret = get_errno(getsid(arg1));
5046 break;
7a3148a9 5047#if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */
31e31b8a 5048 case TARGET_NR_fdatasync:
5cd4393b
FB		 5049 ret = get_errno(fdatasync(arg1));
5050 break;
7a3148a9 5051#endif
31e31b8a 5052 case TARGET_NR__sysctl:
0da46a6e 5053 /* We don't implement this, but ENOTDIR is always a safe
29e619b1 5054 return value. */
0da46a6e
TS		 5055 ret = -TARGET_ENOTDIR;
5056 break;
31e31b8a 5057 case TARGET_NR_sched_setparam:
5cd4393b 5058 {
53a5960a 5059 struct sched_param *target_schp;
5cd4393b 5060 struct sched_param schp;
53a5960a 5061
579a97f7
FB		 5062 if (!lock_user_struct(VERIFY_READ, target_schp, arg2, 1))
5063 goto efault;
5cd4393b 5064 schp.sched_priority = tswap32(target_schp->sched_priority);
53a5960a 5065 unlock_user_struct(target_schp, arg2, 0);
5cd4393b
FB		 5066 ret = get_errno(sched_setparam(arg1, &schp));
5067 }
5068 break;
31e31b8a 5069 case TARGET_NR_sched_getparam:
5cd4393b 5070 {
53a5960a 5071 struct sched_param *target_schp;
5cd4393b
FB		 5072 struct sched_param schp;
5073 ret = get_errno(sched_getparam(arg1, &schp));
5074 if (!is_error(ret)) {
579a97f7
FB		 5075 if (!lock_user_struct(VERIFY_WRITE, target_schp, arg2, 0))
5076 goto efault;
5cd4393b 5077 target_schp->sched_priority = tswap32(schp.sched_priority);
53a5960a 5078 unlock_user_struct(target_schp, arg2, 1);
5cd4393b
FB		 5079 }
5080 }
5081 break;
31e31b8a 5082 case TARGET_NR_sched_setscheduler:
5cd4393b 5083 {
53a5960a 5084 struct sched_param *target_schp;
5cd4393b 5085 struct sched_param schp;
579a97f7
FB		 5086 if (!lock_user_struct(VERIFY_READ, target_schp, arg3, 1))
5087 goto efault;
5cd4393b 5088 schp.sched_priority = tswap32(target_schp->sched_priority);
53a5960a 5089 unlock_user_struct(target_schp, arg3, 0);
5cd4393b
FB		 5090 ret = get_errno(sched_setscheduler(arg1, arg2, &schp));
5091 }
5092 break;
31e31b8a 5093 case TARGET_NR_sched_getscheduler:
5cd4393b
FB		 5094 ret = get_errno(sched_getscheduler(arg1));
5095 break;
31e31b8a
FB		 5096 case TARGET_NR_sched_yield:
5097 ret = get_errno(sched_yield());
5098 break;
5099 case TARGET_NR_sched_get_priority_max:
5cd4393b
FB		 5100 ret = get_errno(sched_get_priority_max(arg1));
5101 break;
31e31b8a 5102 case TARGET_NR_sched_get_priority_min:
5cd4393b
FB		 5103 ret = get_errno(sched_get_priority_min(arg1));
5104 break;
31e31b8a 5105 case TARGET_NR_sched_rr_get_interval:
5cd4393b 5106 {
5cd4393b
FB		 5107 struct timespec ts;
5108 ret = get_errno(sched_rr_get_interval(arg1, &ts));
5109 if (!is_error(ret)) {
53a5960a 5110 host_to_target_timespec(arg2, &ts);
5cd4393b
FB		 5111 }
5112 }
5113 break;
31e31b8a 5114 case TARGET_NR_nanosleep:
1b6b029e 5115 {
1b6b029e 5116 struct timespec req, rem;
53a5960a 5117 target_to_host_timespec(&req, arg1);
1b6b029e 5118 ret = get_errno(nanosleep(&req, &rem));
53a5960a
PB		 5119 if (is_error(ret) && arg2) {
5120 host_to_target_timespec(arg2, &rem);
1b6b029e
FB		 5121 }
5122 }
5123 break;
e5febef5 5124#ifdef TARGET_NR_query_module
31e31b8a 5125 case TARGET_NR_query_module:
5cd4393b 5126 goto unimplemented;
e5febef5
TS		 5127#endif
5128#ifdef TARGET_NR_nfsservctl
31e31b8a 5129 case TARGET_NR_nfsservctl:
5cd4393b 5130 goto unimplemented;
e5febef5 5131#endif
31e31b8a 5132 case TARGET_NR_prctl:
e5574487
TS		 5133 switch (arg1)
5134 {
5135 case PR_GET_PDEATHSIG:
5136 {
5137 int deathsig;
5138 ret = get_errno(prctl(arg1, &deathsig, arg3, arg4, arg5));
2f619698
FB		 5139 if (!is_error(ret) && arg2
5140 && put_user_ual(deathsig, arg2))
5141 goto efault;
e5574487
TS		 5142 }
5143 break;
5144 default:
5145 ret = get_errno(prctl(arg1, arg2, arg3, arg4, arg5));
5146 break;
5147 }
39b9aae1 5148 break;
d2fd1af7
FB		 5149#ifdef TARGET_NR_arch_prctl
5150 case TARGET_NR_arch_prctl:
5151#if defined(TARGET_I386) && !defined(TARGET_ABI32)
5152 ret = do_arch_prctl(cpu_env, arg1, arg2);
5153 break;
5154#else
5155 goto unimplemented;
5156#endif
5157#endif
67867308 5158#ifdef TARGET_NR_pread
31e31b8a 5159 case TARGET_NR_pread:
a4ae00bc
AZ		 5160#ifdef TARGET_ARM
5161 if (((CPUARMState *)cpu_env)->eabi)
5162 arg4 = arg5;
5163#endif
579a97f7
FB		 5164 if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
5165 goto efault;
53a5960a
PB		 5166 ret = get_errno(pread(arg1, p, arg3, arg4));
5167 unlock_user(p, arg2, ret);
206f0fa7 5168 break;
31e31b8a 5169 case TARGET_NR_pwrite:
a4ae00bc
AZ		 5170#ifdef TARGET_ARM
5171 if (((CPUARMState *)cpu_env)->eabi)
5172 arg4 = arg5;
5173#endif
579a97f7
FB		 5174 if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
5175 goto efault;
53a5960a
PB		 5176 ret = get_errno(pwrite(arg1, p, arg3, arg4));
5177 unlock_user(p, arg2, 0);
206f0fa7 5178 break;
f2c7ba15
AJ		 5179#endif
5180#ifdef TARGET_NR_pread64
5181 case TARGET_NR_pread64:
5182 if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
5183 goto efault;
5184 ret = get_errno(pread64(arg1, p, arg3, target_offset64(arg4, arg5)));
5185 unlock_user(p, arg2, ret);
5186 break;
5187 case TARGET_NR_pwrite64:
5188 if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
5189 goto efault;
5190 ret = get_errno(pwrite64(arg1, p, arg3, target_offset64(arg4, arg5)));
5191 unlock_user(p, arg2, 0);
5192 break;
67867308 5193#endif
31e31b8a 5194 case TARGET_NR_getcwd:
579a97f7
FB		 5195 if (!(p = lock_user(VERIFY_WRITE, arg1, arg2, 0)))
5196 goto efault;
53a5960a
PB		 5197 ret = get_errno(sys_getcwd1(p, arg2));
5198 unlock_user(p, arg1, ret);
31e31b8a
FB		 5199 break;
5200 case TARGET_NR_capget:
5cd4393b 5201 goto unimplemented;
31e31b8a 5202 case TARGET_NR_capset:
5cd4393b 5203 goto unimplemented;
31e31b8a 5204 case TARGET_NR_sigaltstack:
198a74de
TS		 5205#if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_MIPS) || \
5206 defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_ALPHA)
579a97f7 5207 ret = do_sigaltstack(arg1, arg2, get_sp_from_cpustate((CPUState *)cpu_env));
a04e134a
TS		 5208 break;
5209#else
5cd4393b 5210 goto unimplemented;
a04e134a 5211#endif
31e31b8a 5212 case TARGET_NR_sendfile:
5cd4393b 5213 goto unimplemented;
ebc05488 5214#ifdef TARGET_NR_getpmsg
31e31b8a 5215 case TARGET_NR_getpmsg:
5cd4393b 5216 goto unimplemented;
ebc05488
FB		 5217#endif
5218#ifdef TARGET_NR_putpmsg
31e31b8a 5219 case TARGET_NR_putpmsg:
5cd4393b 5220 goto unimplemented;
ebc05488 5221#endif
048f6b4d 5222#ifdef TARGET_NR_vfork
31e31b8a 5223 case TARGET_NR_vfork:
d865bab5
PB		 5224 ret = get_errno(do_fork(cpu_env, CLONE_VFORK | CLONE_VM | SIGCHLD,
5225 0, 0, 0, 0));
31e31b8a 5226 break;
048f6b4d 5227#endif
ebc05488 5228#ifdef TARGET_NR_ugetrlimit
31e31b8a 5229 case TARGET_NR_ugetrlimit:
728584be
FB		 5230 {
5231 struct rlimit rlim;
5232 ret = get_errno(getrlimit(arg1, &rlim));
5233 if (!is_error(ret)) {
53a5960a 5234 struct target_rlimit *target_rlim;
579a97f7
FB		 5235 if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))
5236 goto efault;
728584be
FB		 5237 target_rlim->rlim_cur = tswapl(rlim.rlim_cur);
5238 target_rlim->rlim_max = tswapl(rlim.rlim_max);
53a5960a 5239 unlock_user_struct(target_rlim, arg2, 1);
728584be
FB		 5240 }
5241 break;
5242 }
ebc05488 5243#endif
a315a145 5244#ifdef TARGET_NR_truncate64
31e31b8a 5245 case TARGET_NR_truncate64:
579a97f7
FB		 5246 if (!(p = lock_user_string(arg1)))
5247 goto efault;
53a5960a
PB		 5248 ret = target_truncate64(cpu_env, p, arg2, arg3, arg4);
5249 unlock_user(p, arg1, 0);
667f38b1 5250 break;
a315a145
FB		 5251#endif
5252#ifdef TARGET_NR_ftruncate64
31e31b8a 5253 case TARGET_NR_ftruncate64:
ce4defa0 5254 ret = target_ftruncate64(cpu_env, arg1, arg2, arg3, arg4);
667f38b1 5255 break;
a315a145
FB		 5256#endif
5257#ifdef TARGET_NR_stat64
31e31b8a 5258 case TARGET_NR_stat64:
579a97f7
FB		 5259 if (!(p = lock_user_string(arg1)))
5260 goto efault;
53a5960a
PB		 5261 ret = get_errno(stat(path(p), &st));
5262 unlock_user(p, arg1, 0);
6a24a778
AZ		 5263 if (!is_error(ret))
5264 ret = host_to_target_stat64(cpu_env, arg2, &st);
5265 break;
a315a145
FB		 5266#endif
5267#ifdef TARGET_NR_lstat64
31e31b8a 5268 case TARGET_NR_lstat64:
579a97f7
FB		 5269 if (!(p = lock_user_string(arg1)))
5270 goto efault;
53a5960a
PB		 5271 ret = get_errno(lstat(path(p), &st));
5272 unlock_user(p, arg1, 0);
6a24a778
AZ		 5273 if (!is_error(ret))
5274 ret = host_to_target_stat64(cpu_env, arg2, &st);
5275 break;
a315a145
FB		 5276#endif
5277#ifdef TARGET_NR_fstat64
31e31b8a 5278 case TARGET_NR_fstat64:
6a24a778
AZ		 5279 ret = get_errno(fstat(arg1, &st));
5280 if (!is_error(ret))
5281 ret = host_to_target_stat64(cpu_env, arg2, &st);
5282 break;
ce4defa0 5283#endif
6a24a778
AZ		 5284#if defined(TARGET_NR_fstatat64) && defined(__NR_fstatat64)
5285 case TARGET_NR_fstatat64:
5286 if (!(p = lock_user_string(arg2)))
5287 goto efault;
5288 ret = get_errno(sys_fstatat64(arg1, path(p), &st, arg4));
5289 if (!is_error(ret))
5290 ret = host_to_target_stat64(cpu_env, arg3, &st);
60cd49d5 5291 break;
a315a145 5292#endif
67867308
FB		 5293#ifdef USE_UID16
5294 case TARGET_NR_lchown:
579a97f7
FB		 5295 if (!(p = lock_user_string(arg1)))
5296 goto efault;
53a5960a
PB		 5297 ret = get_errno(lchown(p, low2highuid(arg2), low2highgid(arg3)));
5298 unlock_user(p, arg1, 0);
67867308
FB		 5299 break;
5300 case TARGET_NR_getuid:
5301 ret = get_errno(high2lowuid(getuid()));
5302 break;
5303 case TARGET_NR_getgid:
5304 ret = get_errno(high2lowgid(getgid()));
5305 break;
5306 case TARGET_NR_geteuid:
5307 ret = get_errno(high2lowuid(geteuid()));
5308 break;
5309 case TARGET_NR_getegid:
5310 ret = get_errno(high2lowgid(getegid()));
5311 break;
5312 case TARGET_NR_setreuid:
5313 ret = get_errno(setreuid(low2highuid(arg1), low2highuid(arg2)));
5314 break;
5315 case TARGET_NR_setregid:
5316 ret = get_errno(setregid(low2highgid(arg1), low2highgid(arg2)));
5317 break;
5318 case TARGET_NR_getgroups:
5319 {
5320 int gidsetsize = arg1;
53a5960a 5321 uint16_t *target_grouplist;
67867308
FB		 5322 gid_t *grouplist;
5323 int i;
5324
5325 grouplist = alloca(gidsetsize * sizeof(gid_t));
5326 ret = get_errno(getgroups(gidsetsize, grouplist));
cb3bc233
AZ		 5327 if (gidsetsize == 0)
5328 break;
67867308 5329 if (!is_error(ret)) {
579a97f7
FB		 5330 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 2, 0);
5331 if (!target_grouplist)
5332 goto efault;
a2155fcc 5333 for(i = 0;i < ret; i++)
67867308 5334 target_grouplist[i] = tswap16(grouplist[i]);
53a5960a 5335 unlock_user(target_grouplist, arg2, gidsetsize * 2);
67867308
FB		 5336 }
5337 }
5338 break;
5339 case TARGET_NR_setgroups:
5340 {
5341 int gidsetsize = arg1;
53a5960a 5342 uint16_t *target_grouplist;
67867308
FB		 5343 gid_t *grouplist;
5344 int i;
5345
5346 grouplist = alloca(gidsetsize * sizeof(gid_t));
579a97f7
FB		 5347 target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 2, 1);
5348 if (!target_grouplist) {
5349 ret = -TARGET_EFAULT;
5350 goto fail;
5351 }
67867308
FB		 5352 for(i = 0;i < gidsetsize; i++)
5353 grouplist[i] = tswap16(target_grouplist[i]);
53a5960a 5354 unlock_user(target_grouplist, arg2, 0);
67867308
FB		 5355 ret = get_errno(setgroups(gidsetsize, grouplist));
5356 }
5357 break;
5358 case TARGET_NR_fchown:
5359 ret = get_errno(fchown(arg1, low2highuid(arg2), low2highgid(arg3)));
5360 break;
ccfa72b7
TS		 5361#if defined(TARGET_NR_fchownat) && defined(__NR_fchownat)
5362 case TARGET_NR_fchownat:
579a97f7
FB		 5363 if (!(p = lock_user_string(arg2)))
5364 goto efault;
5365 ret = get_errno(sys_fchownat(arg1, p, low2highuid(arg3), low2highgid(arg4), arg5));
5366 unlock_user(p, arg2, 0);
ccfa72b7
TS		 5367 break;
5368#endif
67867308
FB		 5369#ifdef TARGET_NR_setresuid
5370 case TARGET_NR_setresuid:
5fafdf24
TS		 5371 ret = get_errno(setresuid(low2highuid(arg1),
5372 low2highuid(arg2),
67867308
FB		 5373 low2highuid(arg3)));
5374 break;
5375#endif
5376#ifdef TARGET_NR_getresuid
5377 case TARGET_NR_getresuid:
5378 {
53a5960a 5379 uid_t ruid, euid, suid;
67867308
FB		 5380 ret = get_errno(getresuid(&ruid, &euid, &suid));
5381 if (!is_error(ret)) {
2f619698
FB		 5382 if (put_user_u16(high2lowuid(ruid), arg1)
5383 || put_user_u16(high2lowuid(euid), arg2)
5384 || put_user_u16(high2lowuid(suid), arg3))
5385 goto efault;
67867308
FB		 5386 }
5387 }
5388 break;
5389#endif
5390#ifdef TARGET_NR_getresgid
5391 case TARGET_NR_setresgid:
5fafdf24
TS		 5392 ret = get_errno(setresgid(low2highgid(arg1),
5393 low2highgid(arg2),
67867308
FB		 5394 low2highgid(arg3)));
5395 break;
5396#endif
5397#ifdef TARGET_NR_getresgid
5398 case TARGET_NR_getresgid:
5399 {
53a5960a 5400 gid_t rgid, egid, sgid;
67867308
FB		 5401 ret = get_errno(getresgid(&rgid, &egid, &sgid));
5402 if (!is_error(ret)) {
2f619698
FB		 5403 if (put_user_u16(high2lowgid(rgid), arg1)
5404 || put_user_u16(high2lowgid(egid), arg2)
5405 || put_user_u16(high2lowgid(sgid), arg3))
5406 goto efault;
67867308
FB		 5407 }
5408 }
5409 break;
5410#endif
5411 case TARGET_NR_chown:
579a97f7
FB		 5412 if (!(p = lock_user_string(arg1)))
5413 goto efault;
53a5960a
PB		 5414 ret = get_errno(chown(p, low2highuid(arg2), low2highgid(arg3)));
5415 unlock_user(p, arg1, 0);
67867308
FB		 5416 break;
5417 case TARGET_NR_setuid:
5418 ret = get_errno(setuid(low2highuid(arg1)));
5419 break;
5420 case TARGET_NR_setgid:
5421 ret = get_errno(setgid(low2highgid(arg1)));
5422 break;
5423 case TARGET_NR_setfsuid:
5424 ret = get_errno(setfsuid(arg1));
5425 break;
5426 case TARGET_NR_setfsgid:
5427 ret = get_errno(setfsgid(arg1));
5428 break;
5429#endif /* USE_UID16 */
5430
a315a145 5431#ifdef TARGET_NR_lchown32
31e31b8a 5432 case TARGET_NR_lchown32:
579a97f7
FB		 5433 if (!(p = lock_user_string(arg1)))
5434 goto efault;
53a5960a
PB		 5435 ret = get_errno(lchown(p, arg2, arg3));
5436 unlock_user(p, arg1, 0);
b03c60f3 5437 break;
a315a145
FB		 5438#endif
5439#ifdef TARGET_NR_getuid32
31e31b8a 5440 case TARGET_NR_getuid32:
b03c60f3
FB		 5441 ret = get_errno(getuid());
5442 break;
a315a145
FB		 5443#endif
5444#ifdef TARGET_NR_getgid32
31e31b8a 5445 case TARGET_NR_getgid32:
b03c60f3
FB		 5446 ret = get_errno(getgid());
5447 break;
a315a145
FB		 5448#endif
5449#ifdef TARGET_NR_geteuid32
31e31b8a 5450 case TARGET_NR_geteuid32:
b03c60f3
FB		 5451 ret = get_errno(geteuid());
5452 break;
a315a145
FB		 5453#endif
5454#ifdef TARGET_NR_getegid32
31e31b8a 5455 case TARGET_NR_getegid32:
b03c60f3
FB		 5456 ret = get_errno(getegid());
5457 break;
a315a145
FB		 5458#endif
5459#ifdef TARGET_NR_setreuid32
31e31b8a 5460 case TARGET_NR_setreuid32:
b03c60f3
FB		 5461 ret = get_errno(setreuid(arg1, arg2));
5462 break;
a315a145
FB		 5463#endif
5464#ifdef TARGET_NR_setregid32
31e31b8a 5465 case TARGET_NR_setregid32:
b03c60f3
FB		 5466 ret = get_errno(setregid(arg1, arg2));
5467 break;
a315a145
FB		 5468#endif
5469#ifdef TARGET_NR_getgroups32
31e31b8a 5470 case TARGET_NR_getgroups32:
99c475ab
FB		 5471 {
5472 int gidsetsize = arg1;
53a5960a 5473 uint32_t *target_grouplist;
99c475ab
FB		 5474 gid_t *grouplist;
5475 int i;
5476
5477 grouplist = alloca(gidsetsize * sizeof(gid_t));
5478 ret = get_errno(getgroups(gidsetsize, grouplist));
cb3bc233
AZ		 5479 if (gidsetsize == 0)
5480 break;
99c475ab 5481 if (!is_error(ret)) {
579a97f7
FB		 5482 target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 4, 0);
5483 if (!target_grouplist) {
5484 ret = -TARGET_EFAULT;
5485 goto fail;
5486 }
a2155fcc 5487 for(i = 0;i < ret; i++)
53a5960a
PB		 5488 target_grouplist[i] = tswap32(grouplist[i]);
5489 unlock_user(target_grouplist, arg2, gidsetsize * 4);
99c475ab
FB		 5490 }
5491 }
5492 break;
a315a145
FB		 5493#endif
5494#ifdef TARGET_NR_setgroups32
31e31b8a 5495 case TARGET_NR_setgroups32:
99c475ab
FB		 5496 {
5497 int gidsetsize = arg1;
53a5960a 5498 uint32_t *target_grouplist;
99c475ab
FB		 5499 gid_t *grouplist;
5500 int i;
3b46e624 5501
99c475ab 5502 grouplist = alloca(gidsetsize * sizeof(gid_t));
579a97f7
FB		 5503 target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 4, 1);
5504 if (!target_grouplist) {
5505 ret = -TARGET_EFAULT;
5506 goto fail;
5507 }
99c475ab 5508 for(i = 0;i < gidsetsize; i++)
53a5960a
PB		 5509 grouplist[i] = tswap32(target_grouplist[i]);
5510 unlock_user(target_grouplist, arg2, 0);
99c475ab
FB		 5511 ret = get_errno(setgroups(gidsetsize, grouplist));
5512 }
5513 break;
a315a145
FB		 5514#endif
5515#ifdef TARGET_NR_fchown32
31e31b8a 5516 case TARGET_NR_fchown32:
b03c60f3
FB		 5517 ret = get_errno(fchown(arg1, arg2, arg3));
5518 break;
a315a145
FB		 5519#endif
5520#ifdef TARGET_NR_setresuid32
31e31b8a 5521 case TARGET_NR_setresuid32:
b03c60f3
FB		 5522 ret = get_errno(setresuid(arg1, arg2, arg3));
5523 break;
a315a145
FB		 5524#endif
5525#ifdef TARGET_NR_getresuid32
31e31b8a 5526 case TARGET_NR_getresuid32:
b03c60f3 5527 {
53a5960a 5528 uid_t ruid, euid, suid;
b03c60f3
FB		 5529 ret = get_errno(getresuid(&ruid, &euid, &suid));
5530 if (!is_error(ret)) {
2f619698
FB		 5531 if (put_user_u32(ruid, arg1)
5532 || put_user_u32(euid, arg2)
5533 || put_user_u32(suid, arg3))
5534 goto efault;
b03c60f3
FB		 5535 }
5536 }
5537 break;
a315a145
FB		 5538#endif
5539#ifdef TARGET_NR_setresgid32
31e31b8a 5540 case TARGET_NR_setresgid32:
b03c60f3
FB		 5541 ret = get_errno(setresgid(arg1, arg2, arg3));
5542 break;
a315a145
FB		 5543#endif
5544#ifdef TARGET_NR_getresgid32
31e31b8a 5545 case TARGET_NR_getresgid32:
b03c60f3 5546 {
53a5960a 5547 gid_t rgid, egid, sgid;
b03c60f3
FB		 5548 ret = get_errno(getresgid(&rgid, &egid, &sgid));
5549 if (!is_error(ret)) {
2f619698
FB		 5550 if (put_user_u32(rgid, arg1)
5551 || put_user_u32(egid, arg2)
5552 || put_user_u32(sgid, arg3))
5553 goto efault;
b03c60f3
FB		 5554 }
5555 }
5556 break;
a315a145
FB		 5557#endif
5558#ifdef TARGET_NR_chown32
31e31b8a 5559 case TARGET_NR_chown32:
579a97f7
FB		 5560 if (!(p = lock_user_string(arg1)))
5561 goto efault;
53a5960a
PB		 5562 ret = get_errno(chown(p, arg2, arg3));
5563 unlock_user(p, arg1, 0);
b03c60f3 5564 break;
a315a145
FB		 5565#endif
5566#ifdef TARGET_NR_setuid32
31e31b8a 5567 case TARGET_NR_setuid32:
b03c60f3
FB		 5568 ret = get_errno(setuid(arg1));
5569 break;
a315a145
FB		 5570#endif
5571#ifdef TARGET_NR_setgid32
31e31b8a 5572 case TARGET_NR_setgid32:
b03c60f3
FB		 5573 ret = get_errno(setgid(arg1));
5574 break;
a315a145
FB		 5575#endif
5576#ifdef TARGET_NR_setfsuid32
31e31b8a 5577 case TARGET_NR_setfsuid32:
b03c60f3
FB		 5578 ret = get_errno(setfsuid(arg1));
5579 break;
a315a145
FB		 5580#endif
5581#ifdef TARGET_NR_setfsgid32
31e31b8a 5582 case TARGET_NR_setfsgid32:
b03c60f3
FB		 5583 ret = get_errno(setfsgid(arg1));
5584 break;
a315a145 5585#endif
67867308 5586
31e31b8a 5587 case TARGET_NR_pivot_root:
b03c60f3 5588 goto unimplemented;
ffa65c3b 5589#ifdef TARGET_NR_mincore
31e31b8a 5590 case TARGET_NR_mincore:
04bb9ace
AJ		 5591 {
5592 void *a;
5593 ret = -TARGET_EFAULT;
5594 if (!(a = lock_user(VERIFY_READ, arg1,arg2, 0)))
5595 goto efault;
5596 if (!(p = lock_user_string(arg3)))
5597 goto mincore_fail;
5598 ret = get_errno(mincore(a, arg2, p));
5599 unlock_user(p, arg3, ret);
5600 mincore_fail:
5601 unlock_user(a, arg1, 0);
5602 }
5603 break;
ffa65c3b 5604#endif
408321b6
AJ		 5605#ifdef TARGET_NR_arm_fadvise64_64
5606 case TARGET_NR_arm_fadvise64_64:
5607 {
5608 /*
5609 * arm_fadvise64_64 looks like fadvise64_64 but
5610 * with different argument order
5611 */
5612 abi_long temp;
5613 temp = arg3;
5614 arg3 = arg4;
5615 arg4 = temp;
5616 }
5617#endif
5618#if defined(TARGET_NR_fadvise64_64) || defined(TARGET_NR_arm_fadvise64_64)
5619#ifdef TARGET_NR_fadvise64_64
5620 case TARGET_NR_fadvise64_64:
5621#endif
5622 /* This is a hint, so ignoring and returning success is ok. */
5623 ret = get_errno(0);
5624 break;
5625#endif
ffa65c3b 5626#ifdef TARGET_NR_madvise
31e31b8a 5627 case TARGET_NR_madvise:
24836689
PB		 5628 /* A straight passthrough may not be safe because qemu sometimes
5629 turns private flie-backed mappings into anonymous mappings.
5630 This will break MADV_DONTNEED.
5631 This is a hint, so ignoring and returning success is ok. */
5632 ret = get_errno(0);
5633 break;
ffa65c3b 5634#endif
992f48a0 5635#if TARGET_ABI_BITS == 32
31e31b8a 5636 case TARGET_NR_fcntl64:
77e4672d 5637 {
b1e341eb 5638 int cmd;
77e4672d 5639 struct flock64 fl;
53a5960a 5640 struct target_flock64 *target_fl;
ce4defa0 5641#ifdef TARGET_ARM
53a5960a 5642 struct target_eabi_flock64 *target_efl;
ce4defa0 5643#endif
77e4672d 5644
b1e341eb
TS		 5645 switch(arg2){
5646 case TARGET_F_GETLK64:
5647 cmd = F_GETLK64;
a7222580 5648 break;
b1e341eb
TS		 5649 case TARGET_F_SETLK64:
5650 cmd = F_SETLK64;
a7222580 5651 break;
b1e341eb
TS		 5652 case TARGET_F_SETLKW64:
5653 cmd = F_SETLK64;
a7222580 5654 break;
b1e341eb
TS		 5655 default:
5656 cmd = arg2;
a7222580 5657 break;
b1e341eb
TS		 5658 }
5659
60cd49d5 5660 switch(arg2) {
b1e341eb 5661 case TARGET_F_GETLK64:
5813427b
TS		 5662#ifdef TARGET_ARM
5663 if (((CPUARMState *)cpu_env)->eabi) {
9ee1fa2c
FB		 5664 if (!lock_user_struct(VERIFY_READ, target_efl, arg3, 1))
5665 goto efault;
5813427b
TS		 5666 fl.l_type = tswap16(target_efl->l_type);
5667 fl.l_whence = tswap16(target_efl->l_whence);
5668 fl.l_start = tswap64(target_efl->l_start);
5669 fl.l_len = tswap64(target_efl->l_len);
5670 fl.l_pid = tswapl(target_efl->l_pid);
5671 unlock_user_struct(target_efl, arg3, 0);
5672 } else
5673#endif
5674 {
9ee1fa2c
FB		 5675 if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1))
5676 goto efault;
5813427b
TS		 5677 fl.l_type = tswap16(target_fl->l_type);
5678 fl.l_whence = tswap16(target_fl->l_whence);
5679 fl.l_start = tswap64(target_fl->l_start);
5680 fl.l_len = tswap64(target_fl->l_len);
5681 fl.l_pid = tswapl(target_fl->l_pid);
5682 unlock_user_struct(target_fl, arg3, 0);
5683 }
b1e341eb 5684 ret = get_errno(fcntl(arg1, cmd, &fl));
77e4672d 5685 if (ret == 0) {
ce4defa0
PB		 5686#ifdef TARGET_ARM
5687 if (((CPUARMState *)cpu_env)->eabi) {
9ee1fa2c
FB		 5688 if (!lock_user_struct(VERIFY_WRITE, target_efl, arg3, 0))
5689 goto efault;
ce4defa0
PB		 5690 target_efl->l_type = tswap16(fl.l_type);
5691 target_efl->l_whence = tswap16(fl.l_whence);
5692 target_efl->l_start = tswap64(fl.l_start);
5693 target_efl->l_len = tswap64(fl.l_len);
5694 target_efl->l_pid = tswapl(fl.l_pid);
53a5960a 5695 unlock_user_struct(target_efl, arg3, 1);
ce4defa0
PB		 5696 } else
5697#endif
5698 {
9ee1fa2c
FB		 5699 if (!lock_user_struct(VERIFY_WRITE, target_fl, arg3, 0))
5700 goto efault;
ce4defa0
PB		 5701 target_fl->l_type = tswap16(fl.l_type);
5702 target_fl->l_whence = tswap16(fl.l_whence);
5703 target_fl->l_start = tswap64(fl.l_start);
5704 target_fl->l_len = tswap64(fl.l_len);
5705 target_fl->l_pid = tswapl(fl.l_pid);
53a5960a 5706 unlock_user_struct(target_fl, arg3, 1);
ce4defa0 5707 }
77e4672d
FB		 5708 }
5709 break;
5710
b1e341eb
TS		 5711 case TARGET_F_SETLK64:
5712 case TARGET_F_SETLKW64:
ce4defa0
PB		 5713#ifdef TARGET_ARM
5714 if (((CPUARMState *)cpu_env)->eabi) {
9ee1fa2c
FB		 5715 if (!lock_user_struct(VERIFY_READ, target_efl, arg3, 1))
5716 goto efault;
ce4defa0
PB		 5717 fl.l_type = tswap16(target_efl->l_type);
5718 fl.l_whence = tswap16(target_efl->l_whence);
5719 fl.l_start = tswap64(target_efl->l_start);
5720 fl.l_len = tswap64(target_efl->l_len);
5721 fl.l_pid = tswapl(target_efl->l_pid);
53a5960a 5722 unlock_user_struct(target_efl, arg3, 0);
ce4defa0
PB		 5723 } else
5724#endif
5725 {
9ee1fa2c
FB		 5726 if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1))
5727 goto efault;
ce4defa0
PB		 5728 fl.l_type = tswap16(target_fl->l_type);
5729 fl.l_whence = tswap16(target_fl->l_whence);
5730 fl.l_start = tswap64(target_fl->l_start);
5731 fl.l_len = tswap64(target_fl->l_len);
5732 fl.l_pid = tswapl(target_fl->l_pid);
53a5960a 5733 unlock_user_struct(target_fl, arg3, 0);
ce4defa0 5734 }
b1e341eb 5735 ret = get_errno(fcntl(arg1, cmd, &fl));
77e4672d 5736 break;
60cd49d5 5737 default:
9ee1fa2c 5738 ret = do_fcntl(arg1, cmd, arg3);
60cd49d5
FB		 5739 break;
5740 }
77e4672d
FB		 5741 break;
5742 }
60cd49d5 5743#endif
7d600c80
TS		 5744#ifdef TARGET_NR_cacheflush
5745 case TARGET_NR_cacheflush:
5746 /* self-modifying code is handled automatically, so nothing needed */
5747 ret = 0;
5748 break;
5749#endif
ebc05488 5750#ifdef TARGET_NR_security
31e31b8a
FB		 5751 case TARGET_NR_security:
5752 goto unimplemented;
c573ff67
FB		 5753#endif
5754#ifdef TARGET_NR_getpagesize
5755 case TARGET_NR_getpagesize:
5756 ret = TARGET_PAGE_SIZE;
5757 break;
ebc05488 5758#endif
31e31b8a
FB		 5759 case TARGET_NR_gettid:
5760 ret = get_errno(gettid());
5761 break;
e5febef5 5762#ifdef TARGET_NR_readahead
31e31b8a 5763 case TARGET_NR_readahead:
5cd4393b 5764 goto unimplemented;
e5febef5 5765#endif
ebc05488 5766#ifdef TARGET_NR_setxattr
31e31b8a
FB		 5767 case TARGET_NR_setxattr:
5768 case TARGET_NR_lsetxattr:
5769 case TARGET_NR_fsetxattr:
5770 case TARGET_NR_getxattr:
5771 case TARGET_NR_lgetxattr:
5772 case TARGET_NR_fgetxattr:
5773 case TARGET_NR_listxattr:
5774 case TARGET_NR_llistxattr:
5775 case TARGET_NR_flistxattr:
5776 case TARGET_NR_removexattr:
5777 case TARGET_NR_lremovexattr:
5778 case TARGET_NR_fremovexattr:
5cd4393b 5779 goto unimplemented_nowarn;
ebc05488
FB		 5780#endif
5781#ifdef TARGET_NR_set_thread_area
5cd4393b 5782 case TARGET_NR_set_thread_area:
8d18e893 5783#if defined(TARGET_MIPS)
6f5b89a0
TS		 5784 ((CPUMIPSState *) cpu_env)->tls_value = arg1;
5785 ret = 0;
5786 break;
8d18e893
FB		 5787#elif defined(TARGET_I386) && defined(TARGET_ABI32)
5788 ret = do_set_thread_area(cpu_env, arg1);
5789 break;
6f5b89a0
TS		 5790#else
5791 goto unimplemented_nowarn;
5792#endif
5793#endif
5794#ifdef TARGET_NR_get_thread_area
5cd4393b 5795 case TARGET_NR_get_thread_area:
8d18e893
FB		 5796#if defined(TARGET_I386) && defined(TARGET_ABI32)
5797 ret = do_get_thread_area(cpu_env, arg1);
5798#else
5cd4393b 5799 goto unimplemented_nowarn;
48dc41eb 5800#endif
8d18e893 5801#endif
48dc41eb
FB		 5802#ifdef TARGET_NR_getdomainname
5803 case TARGET_NR_getdomainname:
5804 goto unimplemented_nowarn;
ebc05488 5805#endif
6f5b89a0 5806
b5906f95
TS		 5807#ifdef TARGET_NR_clock_gettime
5808 case TARGET_NR_clock_gettime:
5809 {
5810 struct timespec ts;
5811 ret = get_errno(clock_gettime(arg1, &ts));
5812 if (!is_error(ret)) {
5813 host_to_target_timespec(arg2, &ts);
5814 }
5815 break;
5816 }
5817#endif
5818#ifdef TARGET_NR_clock_getres
5819 case TARGET_NR_clock_getres:
5820 {
5821 struct timespec ts;
5822 ret = get_errno(clock_getres(arg1, &ts));
5823 if (!is_error(ret)) {
5824 host_to_target_timespec(arg2, &ts);
5825 }
5826 break;
5827 }
5828#endif
63d7651b
PB		 5829#ifdef TARGET_NR_clock_nanosleep
5830 case TARGET_NR_clock_nanosleep:
5831 {
5832 struct timespec ts;
5833 target_to_host_timespec(&ts, arg3);
5834 ret = get_errno(clock_nanosleep(arg1, arg2, &ts, arg4 ? &ts : NULL));
5835 if (arg4)
5836 host_to_target_timespec(arg4, &ts);
5837 break;
5838 }
5839#endif
b5906f95 5840
6f5b89a0
TS		 5841#if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
5842 case TARGET_NR_set_tid_address:
579a97f7
FB		 5843 ret = get_errno(set_tid_address((int *)g2h(arg1)));
5844 break;
6f5b89a0
TS		 5845#endif
5846
3ae43202 5847#if defined(TARGET_NR_tkill) && defined(__NR_tkill)
4cae1d16 5848 case TARGET_NR_tkill:
4cb05961 5849 ret = get_errno(sys_tkill((int)arg1, target_to_host_signal(arg2)));
4cae1d16
TS		 5850 break;
5851#endif
5852
3ae43202 5853#if defined(TARGET_NR_tgkill) && defined(__NR_tgkill)
71455574 5854 case TARGET_NR_tgkill:
4cb05961
PB		 5855 ret = get_errno(sys_tgkill((int)arg1, (int)arg2,
5856 target_to_host_signal(arg3)));
71455574
TS		 5857 break;
5858#endif
5859
4f2b1fe8
TS		 5860#ifdef TARGET_NR_set_robust_list
5861 case TARGET_NR_set_robust_list:
5862 goto unimplemented_nowarn;
5863#endif
5864
9007f0ef
TS		 5865#if defined(TARGET_NR_utimensat) && defined(__NR_utimensat)
5866 case TARGET_NR_utimensat:
5867 {
5868 struct timespec ts[2];
5869 target_to_host_timespec(ts, arg3);
5870 target_to_host_timespec(ts+1, arg3+sizeof(struct target_timespec));
5871 if (!arg2)
5872 ret = get_errno(sys_utimensat(arg1, NULL, ts, arg4));
5873 else {
579a97f7 5874 if (!(p = lock_user_string(arg2))) {
0da46a6e 5875 ret = -TARGET_EFAULT;
579a97f7
FB		 5876 goto fail;
5877 }
5878 ret = get_errno(sys_utimensat(arg1, path(p), ts, arg4));
5879 unlock_user(p, arg2, 0);
9007f0ef
TS		 5880 }
5881 }
5882 break;
5883#endif
bd0c5661
PB		 5884#if defined(USE_NPTL)
5885 case TARGET_NR_futex:
5886 ret = do_futex(arg1, arg2, arg3, arg4, arg5, arg6);
5887 break;
5888#endif
39b59763
AJ		 5889#ifdef TARGET_NR_inotify_init
5890 case TARGET_NR_inotify_init:
5891 ret = get_errno(sys_inotify_init());
5892 break;
5893#endif
5894#ifdef TARGET_NR_inotify_add_watch
5895 case TARGET_NR_inotify_add_watch:
5896 p = lock_user_string(arg2);
5897 ret = get_errno(sys_inotify_add_watch(arg1, path(p), arg3));
5898 unlock_user(p, arg2, 0);
5899 break;
5900#endif
5901#ifdef TARGET_NR_inotify_rm_watch
5902 case TARGET_NR_inotify_rm_watch:
5903 ret = get_errno(sys_inotify_rm_watch(arg1, arg2));
5904 break;
5905#endif
9007f0ef 5906
31e31b8a
FB		 5907 default:
5908 unimplemented:
5cd4393b 5909 gemu_log("qemu: Unsupported syscall: %d\n", num);
4f2b1fe8 5910#if defined(TARGET_NR_setxattr) || defined(TARGET_NR_get_thread_area) || defined(TARGET_NR_getdomainname) || defined(TARGET_NR_set_robust_list)
5cd4393b 5911 unimplemented_nowarn:
80a9d035 5912#endif
0da46a6e 5913 ret = -TARGET_ENOSYS;
31e31b8a
FB		 5914 break;
5915 }
579a97f7 5916fail:
c573ff67
FB		 5917#ifdef DEBUG
5918 gemu_log(" = %ld\n", ret);
5919#endif
b92c47c1
TS		 5920 if(do_strace)
5921 print_syscall_ret(num, ret);
31e31b8a 5922 return ret;
579a97f7
FB		 5923efault:
5924 ret = -TARGET_EFAULT;
5925 goto fail;
31e31b8a 5926}
Qemu copy for testing