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