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